# فصل ۰۲ — CI برای کدِ داده‌محور

<div dir="rtl">

# فصل ۰۲ — CI برای کدِ داده‌محور

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

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

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

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

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

![دروازه‌ای با دو صفِ بازرسیِ متفاوت روی یک ریل](/lesson-assets/t6-s02-ci-for-data-code/prompt/01-image-gate-with-two-lanes.png)

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

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

## قبل از شروع

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

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

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

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-6-team-and-delivery/session-02-ci-for-data-code.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

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

<div dir="rtl">

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

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

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

</div>

```python
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])
```

```text-approx
کدِ خروج: 0 · {"ran": 7, "fits": 8, "failed": [], "seconds": 0.2612}
```

<div dir="rtl">

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

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

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

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

</div>

```python
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}")
```

```text
سناریو                                      تستِ اجراشده  آموزشِ مدل    دروازه
سالم                                                   7           8       سبز
کد: یک جانشینی از پاک‌سازی افتاد                       1           0      قرمز
کد: فرانمونه‌گیری پیش از تقسیم                         4           0      قرمز
کد: تقسیمِ تصادفی به‌جای زمانی                         5           0      قرمز
کد: صافیِ بالادست ردیف‌های تشدید را انداخت             6           1      قرمز
کد: برچسب هم وارد ویژگی‌ها شد                          7           6      قرمز
داده: دستهٔ تازه از بالادست آمد                        3           0      قرمز
```

<div dir="rtl">

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

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

</div>

```python
for name in (BROKEN_DATA, "کد: فرانمونه‌گیری پیش از تقسیم",
             "کد: صافیِ بالادست ردیف‌های تشدید را انداخت"):
    print(REPORT[name]["failed"][0])
```

```text
schema_categories — AssertionError: دستهٔ ناشناخته در داده: ['سایر']
split_shares_no_row — AssertionError: 431 تیکت در هر دو طرف است
model_beats_baseline — AssertionError: هفتهٔ 13: مدل 0.7600 · خطِ پایه 0.7600
```

<div dir="rtl">

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

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

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

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

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

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

</div>

```python
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])
```

```text
سناریو                                              سریع‌اول           کند‌اول
سالم                                                     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
```

<div dir="rtl">

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

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

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

</div>

```python
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} میلی‌ثانیه")
```

```text-approx
تستِ سریع      5 تست ·  0 آموزش ·       1 میلی‌ثانیه
تستِ کند       2 تست ·  8 آموزش ·     262 میلی‌ثانیه
```

<div dir="rtl">

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

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

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

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

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

</div>

```python
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)
```

```text
پیش از افزودنِ تست: 7/6 · model_actually_learns — AssertionError: با برچسبِ تصادفی هم 1.0000 گرفت
پس از افزودنِ تست: 2/0 · features_ignore_the_label — AssertionError: ویژگی با عوض شدنِ برچسب عوض شد
```

<div dir="rtl">

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

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

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

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

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

</div>

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

<div dir="rtl">

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

> 🔧 **اگر کار نکرد:** اگر `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` آنجاست.

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

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

</div>

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

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا خرابیِ «دستهٔ تازه از بالادست» با هیچ بازبینیِ کدی گرفته نمی‌شد؟

**تمرینِ اجباری:** یک خرابیِ هفتم بساز که **هیچ‌کدام از هشت تستِ این فصل نگیردش** و بیلد سبز بماند. (چند شروعِ ممکن: ستونی که همیشه خالی است، تیکت‌های تکراری با شناسهٔ متفاوت، تاریخی که در آینده است.) بعد تستی بنویس که آن را بگیرد و **سه عدد گزارش کن:** چندمین تست قرمز می‌شود، چند بار مدل آموزش می‌بیند، و آن تست در کدام رده باید بنشیند. **و جوابِ اصلی: چطور فهمیدی که این خرابی وجود دارد، وقتی هیچ تستی نمی‌گرفتش؟**

**تمرینِ ستاره‌دار ⭐:** جدولِ بخشِ ۳ را به یک **سیاستِ اجرا** تبدیل کن. سه دروازه تعریف کن — روی هر `push`، پیش از ادغام، و شبانه — و برای هر کدام بنویس کدام تست‌ها داخلش‌اند و **سقفِ زمانش چقدر است**. بعد با همان `scenario` اندازه بگیر: **اگر خرابیِ «برچسب در ویژگی‌ها» فقط در دروازهٔ شبانه گرفته شود، به‌طورِ متوسط چند ساعت روی شاخهٔ اصلی زنده می‌ماند؟** و سؤالِ سخت: **این چند ساعت را با هزینهٔ اجرای تستِ کند روی هر `push` مقایسه کن — کدام بزرگ‌تر است، و جوابت به چه چیزی دربارهٔ پروژه‌ات وابسته است؟**

## در فصل بعد

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

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

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t6/s02-ci-for-data-code (یادستان, Yaadestan)
