داربست — خودآموز MLOps و مهندسی سامانه‌های هوش مصنوعی (پیشرفته)

فصل ۲ از ۷

پیشرفت ترم
۰٪

در این فصل چه یاد می‌گیری#

فصلِ قبل نشان داد که بازبینیِ انسانی سوراخ دارد. این فصل آن چیزهایی را که ماشین بهتر می‌گیرد به ماشین می‌سپارد: یک دروازهٔ خودکار که با کدِ خروج جواب می‌دهد.

هفت تست می‌نویسیم، پنج‌تا سریع و دوتا کند، و شش خرابیِ واقعی رویش می‌گذاریم. هر شش‌تا قرمز می‌شوند — از جمله یک نقضِ قراردادِ دادهٔ ترمِ ۲ و یک نشتیِ ترمِ ۱ که ۴۳۱ تیکت را در هر دو طرفِ تقسیم گذاشته بود.

بعد ترتیب را اندازه می‌گیریم. اجرای «سریع اول» در کلِ هفت سناریو ۱۵ بار مدل آموزش می‌دهد و «کند اول» ۴۲ بار — برای رسیدن به همان تصمیم‌ها. و ردهٔ سریع در حدِ یک میلی‌ثانیه طول می‌کشد در برابرِ چند صد میلی‌ثانیهٔ ردهٔ کند.

و در آخر یک نتیجهٔ ناخوشایند: یکی از شش خرابی — نشتیِ برچسب به ویژگی‌ها — تا هفتمین تست و ششمین آموزشِ مدل پیدا نمی‌شود. یک تستِ سه‌خطی می‌نویسیم که همان را در تستِ دوم و با صفر آموزش می‌گیرد.

دروازه‌ای با دو صفِ بازرسیِ متفاوت روی یک ریل

آخر این فصل می‌توانی:

  • یک دروازهٔ خودکار بنویسی که با کدِ خروج جواب می‌دهد و در هر جایی قابلِ اجراست
  • تستِ سریع و کند را جدا کنی و ترتیبشان را با عدد توجیه کنی
  • بیلد را روی دادهٔ خراب بشکنی، نه فقط روی کدِ خراب
  • نشان بدهی یک مجموعهٔ تستِ سبز چه چیزی را ثابت نمی‌کند

قبل از شروع#

از ترمِ ۱ فصلِ ۳: تستِ ناوردایی و تستِ «مدل واقعاً چیزی یاد می‌گیرد». هر دو اینجا برمی‌گردند، این بار داخلِ دروازه.

از ترمِ ۲ فصلِ ۳: قراردادِ اسکیما و شکستِ زودهنگام. از ترمِ ۲ فصلِ ۷: فرانمونه‌گیری قبل از split، همان فاجعه‌ای که F1 را به ۰٫۸۴۰ رساند و بعد صادقانه‌اش شد ۰٫۲۵۵.

از ترمِ ۳ فصلِ ۷: ارزیابیِ غلتان روی برشِ زمانی. تستِ کندِ این فصل دقیقاً همان است.

📓 نوت‌بوک: نوت‌بوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

اجرا زمانِ تقریبی
کلِ نوت‌بوک روی CPU حدودِ یک دقیقه
GPU لازم نیست

۱. پروژه، مجموعهٔ تست، و دروازه#

سه فایل می‌سازیم: pipeline.py که کارِ واقعی را می‌کند، tests.py که مجموعهٔ تست است، و ci.py که دروازه است.

ci.py مهم‌ترینشان است و کوتاه‌ترین. کارش فقط این است: تست‌ها را به ترتیب اجرا کن، اولین شکست را گزارش بده، و با کدِ خروجِ ۱ بمیر. همین قرارداد است که هر سرویسِ CI در دنیا می‌فهمد — و همان قرارداد است که git bisect در فصلِ قبل از آن استفاده کرد.

import json

PIPELINE = '''"""pipeline.py — پاک‌سازی، قرارداد، تقسیم، ویژگی، مدل."""
import random

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline

CATEGORIES = ("پرداخت", "ارسال", "حساب کاربری", "اپلیکیشن")
REQUIRED = ("ticket_id", "customer_id", "week", "channel", "category", "text", "escalated")
FITS = 0


def normalise(text):
    return " ".join(text.replace("ي", "ی").replace("ك", "ک").split())


def features(rows):
    return [normalise(r["text"]) for r in rows]


def split(rows, upto=18):
    return [r for r in rows if r["week"] < upto], [r for r in rows if r["week"] >= upto]


def fit(rows):
    global FITS
    FITS += 1
    model = make_pipeline(CountVectorizer(), LogisticRegression(max_iter=1000))
    model.fit(features(rows), [r["escalated"] for r in rows])
    return model
'''
TESTS = '''"""tests.py — مجموعهٔ تست. هر تست یک نام، یک ردهٔ سرعت و یک تابع دارد."""
import json
import random

import pipeline

ROWS = json.load(open("data.json", encoding="utf-8"))


def hit_rate(model, rows):
    said = model.predict(pipeline.features(rows))
    truth = [r["escalated"] for r in rows]
    return sum(a == b for a, b in zip(said, truth)) / len(truth)


def majority(rows):
    share = sum(r["escalated"] for r in rows) / len(rows)
    return max(share, 1 - share)


def test_normalise_arabic():
    assert pipeline.normalise("كارت من") == "کارت من", pipeline.normalise("كارت من")


def test_schema_columns():
    missing = sorted(set(pipeline.REQUIRED) - set(ROWS[0]))
    assert not missing, f"ستونِ گم‌شده: {missing}"


def test_schema_categories():
    unknown = sorted({r["category"] for r in ROWS} - set(pipeline.CATEGORIES))
    assert not unknown, f"دستهٔ ناشناخته در داده: {unknown}"


def test_split_shares_no_row():
    train, test = pipeline.split(ROWS)
    shared = {r["ticket_id"] for r in train} & {r["ticket_id"] for r in test}
    assert not shared, f"{len(shared)} تیکت در هر دو طرف است"


def test_split_is_chronological():
    train, test = pipeline.split(ROWS)
    assert max(r["week"] for r in train) < min(r["week"] for r in test), "زمان قاطی شده"


def test_model_beats_baseline():
    """ارزیابیِ غلتان روی پنج برشِ زمانی (ترمِ ۳ فصلِ ۷) — پنج بار آموزش."""
    for upto in (13, 14, 15, 16, 17):
        train, later = pipeline.split(ROWS, upto)
        window = [r for r in later if r["week"] == upto]
        got, base = hit_rate(pipeline.fit(train), window), majority(window)
        assert got > base + 0.02, f"هفتهٔ {upto}: مدل {got:.4f} · خطِ پایه {base:.4f}"


def test_model_actually_learns():
    """با برچسبِ تصادفی نباید چیزی یاد بگیرد (ترمِ ۱ فصلِ ۳) — سه قرعه."""
    train, test = pipeline.split(ROWS)
    for seed in (0, 1, 2):
        noise = [dict(r) for r in train]
        labels = [r["escalated"] for r in noise]
        random.Random(seed).shuffle(labels)
        for row, label in zip(noise, labels):
            row["escalated"] = label
        got, base = hit_rate(pipeline.fit(noise), test), majority(test)
        assert got < base + 0.02, f"با برچسبِ تصادفی هم {got:.4f} گرفت"


SUITE = [
    ("normalise_arabic", "fast", test_normalise_arabic),
    ("schema_columns", "fast", test_schema_columns),
    ("schema_categories", "fast", test_schema_categories),
    ("split_shares_no_row", "fast", test_split_shares_no_row),
    ("split_is_chronological", "fast", test_split_is_chronological),
    ("model_beats_baseline", "slow", test_model_beats_baseline),
    ("model_actually_learns", "slow", test_model_actually_learns),
]
'''
CI = '''"""ci.py — دروازهٔ خودکار. ورودی: ترتیبِ اجرا. خروجی: کدِ خروج و یک خطِ JSON."""
import json
import sys
import time

import pipeline
import tests

ORDER = {"fast-first": ["fast", "slow"], "slow-first": ["slow", "fast"],
         "fast-only": ["fast"], "slow-only": ["slow"]}[sys.argv[1]]
ran, failures = [], []
started = time.perf_counter()
for kind in ORDER:
    for name, group, check in tests.SUITE:
        if group != kind:
            continue
        ran.append(name)
        try:
            check()
        except Exception as error:
            failures.append(f"{name} — {type(error).__name__}: {error}")
            break
    if failures:
        break
print(json.dumps({"ran": len(ran), "fits": pipeline.FITS, "failed": failures,
                  "seconds": round(time.perf_counter() - started, 4)}, ensure_ascii=False))
sys.exit(1 if failures else 0)
'''
write(WORK / "pipeline.py", PIPELINE)
write(WORK / "tests.py", TESTS)
write(WORK / "ci.py", CI)
write(WORK / "data.json", json.dumps(TICKETS, ensure_ascii=False))
code, out = run_py("ci.py", "fast-first")
print("کدِ خروج:", code, "·", out.splitlines()[-1])
کدِ خروج: 0 · {"ran": 7, "fits": 8, "failed": [], "seconds": 0.2612}

کدِ خروجِ صفر یعنی سبز. هفت تست اجرا شد، هشت بار مدل آموزش دید، هیچ‌کدام نشکست.

به تفکیکِ fast و slow دقت کن: تستِ سریع هیچ مدلی آموزش نمی‌دهد. فقط رشته، مجموعه و شرطِ اسکیما را می‌سنجد. تستِ کند مدل آموزش می‌دهد و همان کاری را می‌کند که ترمِ ۳ فصلِ ۷ یادت داد — پنج برشِ زمانیِ پیاپی، نه یک تقسیمِ تصادفی.

۲. شش راه برای شکستنش#

حالا شش خرابیِ واقعی می‌سازیم. پنج‌تا در کد و یکی در داده — و آن یکی مهم‌ترینشان است، چون در آن سناریو هیچ‌کس هیچ خطی کد ننوشته.

PATCH = {
    "کد: یک جانشینی از پاک‌سازی افتاد":
        ('text.replace("ي", "ی").replace("ك", "ک")', 'text.replace("ي", "ی")'),
    "کد: فرانمونه‌گیری پیش از تقسیم":
        ('def split(rows, upto=18):\n    return',
         'def split(rows, upto=18):\n'
         '    rows = list(rows) + [r for r in rows if r["escalated"]] * 2\n'
         '    random.Random(0).shuffle(rows)\n'
         '    return rows[:1800], rows[1800:]\n    return'),
    "کد: تقسیمِ تصادفی به‌جای زمانی":
        ('def split(rows, upto=18):\n    return',
         'def split(rows, upto=18):\n    rows = list(rows)\n'
         '    random.Random(0).shuffle(rows)\n    return rows[:1800], rows[1800:]\n    return'),
    "کد: صافیِ بالادست ردیف‌های تشدید را انداخت":
        ('    model.fit(features(rows),',
         '    rows = ([r for r in rows if not r["escalated"]]\n'
         '            + [r for r in rows if r["escalated"]][:3])\n'
         '    model.fit(features(rows),'),
    "کد: برچسب هم وارد ویژگی‌ها شد":
        ('return [normalise(r["text"]) for r in rows]',
         'return [normalise(r["text"]) + " E%d" % r["escalated"] for r in rows]'),
}
BROKEN_DATA = "داده: دستهٔ تازه از بالادست آمد"
SCENARIOS = ["سالم", *PATCH, BROKEN_DATA]


def scenario(name, order):
    """پروژه را از نو می‌سازد، یک خرابی رویش می‌گذارد و دروازه را اجرا می‌کند."""
    write(WORK / "pipeline.py", PIPELINE)
    rows = TICKETS
    if name in PATCH:
        old, new = PATCH[name]
        assert old in PIPELINE, name
        write(WORK / "pipeline.py", PIPELINE.replace(old, new))
    if name == BROKEN_DATA:
        rows = [dict(r) for r in TICKETS]
        for row in rows[:37]:
            row["category"] = "سایر"
    write(WORK / "data.json", json.dumps(rows, ensure_ascii=False))
    code, out = run_py("ci.py", order)
    return code, json.loads(out.splitlines()[-1])


print(f"{'سناریو':<42}{'تستِ اجراشده':>14}{'آموزشِ مدل':>12}{'دروازه':>10}")
REPORT = {}
for name in SCENARIOS:
    code, info = scenario(name, "fast-first")
    REPORT[name] = info
    print(f"{name:<42}{info['ran']:>14}{info['fits']:>12}{('قرمز' if code else 'سبز'):>10}")
سناریو                                      تستِ اجراشده  آموزشِ مدل    دروازه
سالم                                                   7           8       سبز
کد: یک جانشینی از پاک‌سازی افتاد                       1           0      قرمز
کد: فرانمونه‌گیری پیش از تقسیم                         4           0      قرمز
کد: تقسیمِ تصادفی به‌جای زمانی                         5           0      قرمز
کد: صافیِ بالادست ردیف‌های تشدید را انداخت             6           1      قرمز
کد: برچسب هم وارد ویژگی‌ها شد                          7           6      قرمز
داده: دستهٔ تازه از بالادست آمد                        3           0      قرمز

هر شش‌تا قرمز. ولی ستونِ «آموزشِ مدل» چیزِ مهم‌تری می‌گوید: چهار خرابی بدونِ حتی یک بار آموزشِ مدل گرفته شدند. ارزان‌ترین تست‌ها بیشترین کار را کردند.

حالا ببینیم دروازه دقیقاً چه گفت:

for name in (BROKEN_DATA, "کد: فرانمونه‌گیری پیش از تقسیم",
             "کد: صافیِ بالادست ردیف‌های تشدید را انداخت"):
    print(REPORT[name]["failed"][0])
schema_categories — AssertionError: دستهٔ ناشناخته در داده: ['سایر']
split_shares_no_row — AssertionError: 431 تیکت در هر دو طرف است
model_beats_baseline — AssertionError: هفتهٔ 13: مدل 0.7600 · خطِ پایه 0.7600

خطِ اول یک بیلدِ شکسته است که هیچ‌کس کدی برایش ننوشته. یک سامانهٔ بالادستی دستهٔ تازه‌ای اضافه کرد؛ کدِ ما بایتِ به بایت همان است. بدونِ این دروازه، این تغییر بی‌صدا وارد آموزش می‌شد و ماه‌ها بعد به‌شکلِ «مدل روی بعضی تیکت‌ها عجیب رفتار می‌کند» ظاهر می‌شد. قراردادِ داده تنها جایی است که چنین چیزی زودتر از تولید دیده می‌شود.

خطِ دوم همان فاجعهٔ ترمِ ۲ است، این بار در سه ثانیه گرفته‌شده: ۴۳۱ تیکت هم در آموزش‌اند و هم در آزمون. هر عددی که از چنین تقسیمی دربیاید بی‌معناست، هرچقدر هم خوب به نظر برسد.

و خطِ سوم صادقانه‌ترینشان است: مدل ۰٫۷۶۰۰، خطِ پایه ۰٫۷۶۰۰. مدل دقیقاً به‌اندازهٔ «همیشه بگو تشدید نمی‌شود» خوب است. عددِ ۰٫۷۶ روی هیچ داشبوردی بد به نظر نمی‌رسد — و دقیقاً به همین دلیل است که خطِ پایه باید داخلِ تست باشد، نه داخلِ گزارش.

✅ چک کن: به سطرِ «سالم» برگرد. هفت تست، هشت آموزشِ مدل. حالا از خودت بپرس این دروازه اگر روی هر push اجرا شود، روزی چند بار مدل آموزش می‌دهد؟ اگر جوابت عددی است که تحملش را نداری، مشکل «تست زیاد» نیست — بخشِ بعد نشان می‌دهد مشکل کجاست.

۳. ترتیب، به‌عنوان یک تصمیمِ اندازه‌گیری‌شده#

مجموعهٔ تست ثابت است. تنها چیزی که عوض می‌کنیم این است که کدام رده اول اجرا شود.

def cell(info):
    return f"{info['ran']}/{info['fits']}"


print(f"{'سناریو':<42}{'سریع‌اول':>18}{'کند‌اول':>18}")
total = [0, 0]
for name in SCENARIOS:
    _, a = scenario(name, "fast-first")
    _, b = scenario(name, "slow-first")
    total[0] += a["fits"]
    total[1] += b["fits"]
    print(f"{name:<42}{cell(a):>18}{cell(b):>18}")
print("مجموعِ آموزشِ مدل در هفت سناریو — سریع‌اول:", total[0], "· کند‌اول:", total[1])
سناریو                                              سریع‌اول           کند‌اول
سالم                                                     7/8               7/8
کد: یک جانشینی از پاک‌سازی افتاد                         1/0               3/8
کد: فرانمونه‌گیری پیش از تقسیم                           4/0               6/8
کد: تقسیمِ تصادفی به‌جای زمانی                           5/0               1/3
کد: صافیِ بالادست ردیف‌های تشدید را انداخت               6/1               1/1
کد: برچسب هم وارد ویژگی‌ها شد                            7/6               2/6
داده: دستهٔ تازه از بالادست آمد                          3/0               5/8
مجموعِ آموزشِ مدل در هفت سناریو — سریع‌اول: 15 · کند‌اول: 42

۱۵ در برابرِ ۴۲ — همان تصمیم‌ها، همان قرمزها، با کمتر از نصفِ کار.

و به سطرِ اولِ جدول دقت کن: در سناریوی سالم هر دو ترتیب ۸ بار آموزش می‌دهند. ترتیب فقط وقتی صرفه دارد که چیزی خراب باشد. یعنی ارزشِ «سریع اول» متناسب است با اینکه چند وقت یک بار بیلدت می‌شکند — و اگر هیچ‌وقت نمی‌شکند، احتمالاً تستِ کافی نداری.

جدولِ بالا دربارهٔ کار است. حالا دربارهٔ زمان:

scenario("سالم", "fast-first")
for tier, order in (("تستِ سریع", "fast-only"), ("تستِ کند", "slow-only")):
    _, info = scenario("سالم", order)
    print(f"{tier:<12}{info['ran']:>4} تست ·{info['fits']:>3} آموزش ·"
          f"{info['seconds'] * 1000:>8.0f} میلی‌ثانیه")
تستِ سریع      5 تست ·  0 آموزش ·       1 میلی‌ثانیه
تستِ کند       2 تست ·  8 آموزش ·     262 میلی‌ثانیه

این عدد روی ماشینِ تو فرق می‌کند و مهم هم نیست؛ نسبتش مهم است. ردهٔ سریع در حدِ یک میلی‌ثانیه و ردهٔ کند در حدِ چند صد میلی‌ثانیه. در یک پروژهٔ واقعی همین نسبت است، فقط با واحدهای بزرگ‌تر: ثانیه در برابرِ ده‌ها دقیقه.

و همین‌جا قاعدهٔ عملی بیرون می‌آید: دو دروازه، نه یکی. ردهٔ سریع روی هر push و ردهٔ کند شبانه یا پیش از ادغام. اگر هر دو را روی هر push بگذاری، آدم‌ها منتظر نمی‌مانند — دروازه را دور می‌زنند، و دروازه‌ای که دور زده می‌شود، وجود ندارد.

۴. سبز بودن چه چیزی را ثابت نمی‌کند#

یک خرابی در جدولِ بخشِ ۲ گران‌تر از بقیه بود: «برچسب هم وارد ویژگی‌ها شد» — هفت تست و شش آموزشِ مدل تا قرمز شدن.

این همان چیزی است که ترمِ ۱ فصلِ ۲ اسمش را «جهشی که زنده می‌ماند» گذاشت: ده تست سبز بودند و بریدنِ متن به بیست نویسه از میانشان رد شد. پس بپرس: چه چیزی این را زودتر می‌گرفت؟

EXTRA = '''

def test_features_ignore_the_label():
    """ویژگی حق ندارد به ستونِ هدف نگاه کند (ترمِ ۱ فصلِ ۳)."""
    row = dict(ROWS[0])
    before = pipeline.features([row])
    row["escalated"] = 1 - row["escalated"]
    assert pipeline.features([row]) == before, "ویژگی با عوض شدنِ برچسب عوض شد"


SUITE.insert(1, ("features_ignore_the_label", "fast", test_features_ignore_the_label))
'''
LEAK = "کد: برچسب هم وارد ویژگی‌ها شد"
print("پیش از افزودنِ تست:", cell(scenario(LEAK, "fast-first")[1]),
      "·", REPORT[LEAK]["failed"][0])
write(WORK / "tests.py", TESTS + EXTRA)
code, info = scenario(LEAK, "fast-first")
print("پس از افزودنِ تست:", cell(info), "·", info["failed"][0])
write(WORK / "tests.py", TESTS)
پیش از افزودنِ تست: 7/6 · model_actually_learns — AssertionError: با برچسبِ تصادفی هم 1.0000 گرفت
پس از افزودنِ تست: 2/0 · features_ignore_the_label — AssertionError: ویژگی با عوض شدنِ برچسب عوض شد

از ۷ تست و ۶ آموزشِ مدل، به ۲ تست و صفر آموزش.

و جملهٔ «با برچسبِ تصادفی هم ۱٫۰۰۰۰ گرفت» را کنارِ عددِ ترمِ ۱ بگذار: آنجا برچسبِ تصادفی با یک split معمولی به ۰٫۵۸۰۳ رسید در حالی که کفِ تصادف ۰٫۲۵ بود، و همان ۰٫۳۳ اضافه علامتِ حفظ کردن بود. اینجا عدد گرد و کامل است: یک. مدل هیچ چیزی نیاموخته؛ فقط جواب را از داخلِ ورودی خوانده.

تستِ تازه سه خط است و ناوردایی می‌سنجد: برچسب را عوض کن، ویژگی نباید تکان بخورد. این خانواده از تست‌ها ارزان‌ترین و کم‌نوشته‌شده‌ترین‌اند — چون نوشتنشان نیاز دارد که بدانی مدلت به چه چیزی نباید نگاه کند، و همین جمله معمولاً هیچ‌جا نوشته نشده.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان دروازه روی همان هفت سناریو؛ تنها متغیر ترتیبِ رده‌ها و بعد یک تستِ اضافه. روی کدام داده؟ همان ۲۴۰۰ تیکتِ ترم، و برای سناریوی داده، همان داده با ۳۷ ردیفِ دست‌کاری‌شده. با چند seed؟ تستِ «مدل واقعاً یاد می‌گیرد» سه قرعه برای برچسبِ تصادفی می‌زند، و تستِ خطِ پایه پنج برشِ زمانی — چون یک برش، یک نتیجه نیست. و شمارشِ «آموزشِ مدل» عمداً جای زمان نشسته: زمان روی هر ماشین فرق می‌کند، تعدادِ آموزش نه.

۵. دروازه‌ای که واقعاً جلوی چیزی را می‌گیرد#

قاعده چرا، با عددِ همین فصل
دروازه با کدِ خروج حرف می‌زند، نه با لاگ همان قراردادی که git bisect فصلِ قبل مصرفش کرد
سریع اول، بعد کند ۱۵ در برابرِ ۴۲ آموزشِ مدل
رده‌ها دو دروازهٔ جدا باشند حدودِ یک میلی‌ثانیه در برابرِ چند صد میلی‌ثانیه
قراردادِ داده هم دروازه دارد تنها چیزی که خرابیِ بالادستی را گرفت
خطِ پایه داخلِ تست، نه داخلِ گزارش ۰٫۷۶۰۰ در برابرِ ۰٫۷۶۰۰
هر باگِ فرارکرده، یک تستِ تازه ۷/۶ به ۲/۰

و یک قاعده که هیچ عددی لازم ندارد: بیلدِ قرمز باید متوقف‌کننده باشد. دروازه‌ای که همه یاد گرفته‌اند نادیده‌اش بگیرند، بدتر از نداشتنش است — چون هزینه‌اش را می‌دهی و محافظتش را نمی‌گیری.

🔧 اگر کار نکرد: اگر json.loads روی خروجیِ ci.py با JSONDecodeError: Expecting value: line 1 column 1 (char 0) بایستد، یعنی دروازه پیش از رسیدن به خطِ آخر مرده — معمولاً ModuleNotFoundError: No module named 'pipeline'، چون run_py را از پوشهٔ دیگری صدا زده‌ای. تابعِ run_py عمداً cwd را روی WORK می‌گذارد؛ اگر خودت مسیر دادی، همان‌جا را نگاه کن. و اگر سناریویی «سبز» درآمد که انتظارِ قرمز داشتی، اول assert old in PIPELINE را نگاه کن: وصلهٔ متنی وقتی رشتهٔ هدف عوض شود بی‌صدا هیچ کاری نمی‌کند — به همین دلیل آن assert آنجاست.

🤖 از دستیارت بپرس: «تستِ ناوردایی چیست و چند نمونهٔ دیگرش برای یک مدلِ متنی بنویس.» بعد این را بپرس: «اگر مجموعهٔ تستم سبز است ولی مدل در تولید بد کار می‌کند، ترتیبِ درستِ شک کردن چیست؟» — جوابِ خوب باید از «دادهٔ تست شبیهِ تولید نیست» شروع کند، نه از «مدل ضعیف است»؛ همان درسِ ترمِ ۳ فصلِ ۷.

واژه‌های تازهٔ این فصل#

کلمه تلفظ به حروف فارسی یعنی چه
CI سی‌آی اجرای خودکارِ دروازه روی هر تغییر، پیش از ورود به خطِ اصلی
exit code اگزیت کد عددی که یک برنامه هنگامِ پایان می‌دهد؛ صفر یعنی موفق
test tier تست تی‌یر ردهٔ تست بر اساسِ هزینه: سریع در برابرِ کند
fail fast فیل فست متوقف شدن در اولین شکست، به‌جای اجرای کاملِ مجموعه
red build رد بیلد وضعیتی که دروازه در آن اجازهٔ ادامه نمی‌دهد
invariance test این‌ورینس تست تستی که می‌گوید با تغییرِ فلان چیز، خروجی نباید عوض شود

تمرین‌ها

اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.

در فصل بعد#

دروازه از کد و داده محافظت می‌کند. از مستندات چیزی محافظت نمی‌کند — و مستندات همان چیزی است که سریع‌تر از هر چیزِ دیگری کهنه می‌شود.

فصلِ بعد یک README می‌سازد که دستورهایش اجرا می‌شوند: تستی که فرمان‌ها را از داخلِ متن بیرون می‌کشد و در یک نسخهٔ تازهٔ پروژه اجرایشان می‌کند. از شش دستورِ مستندشده، یکی کار می‌کند. بعد درستش می‌کنیم و می‌شود هفت از هفت — یک قدمِ گم‌شده هم اضافه می‌شود — و یک تصمیم‌نامه می‌نویسیم که سالِ بعد بگوید چرا.

به آخر این فصل رسیدی!

اگر ساختی و جواب داد، این دکمه مال توست.