# فصل ۰۸ — پروژه: پایش و بازآموزی

<div dir="rtl">

# فصل ۰۸ — پروژه: پایش و بازآموزی

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

هفت فصل، هفت قطعه. **این فصل هیچ مفهومِ تازه‌ای ندارد و هر هفت‌تا را در یک خطِ کامل، روی نود روزِ تولید، کنارِ هم می‌گذارد.**

دنیای پروژه دو خرابی دارد: یک نسخهٔ خراب در روزِ ۶۰ و یک رانشِ مفهومِ تدریجی از روزِ ۸۰. چهار پیکربندی را روی **همان** نود روز اجرا می‌کنیم و می‌شماریم.

**بدونِ هیچ پایشی: ۴۴ روزِ بد، میانگینِ ۰٫۸۳۴۴، و ۶۴ کاربرِ آسیب‌دیده.** با خطِ کامل: **۳۵ روزِ بد، ۰٫۸۴۵۸، و ۱۱ کاربرِ آسیب‌دیده** — و نسخهٔ خراب **همان روز** گرفته شد، نه پنج روز بعد.

قیمتش هم شمرده می‌شود: **۲۳۴۰۰ برچسبِ انسانی و ۳۱ هشدار.** و گزارشِ پایانی را کد می‌نویسد، از جمله آخرین سطرش که می‌گوید هنوز چه چیزی را نداریم.

![یک تابلوی کنترلِ کامل با چهار عقربه و یک اهرمِ برگشت](/lesson-assets/t5-s08-project-monitor/prompt/01-image-full-control-panel.png)

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

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

## قبل از شروع

هر هفت فصلِ قبل. **هیچ چیزِ تازه‌ای اینجا نیست جز چیدنشان کنارِ هم.**

**و یک قاعده که کلِ فصل رویش ایستاده: ارزشِ هر قطعه را با خاموش کردنش می‌سنجی، نه با توضیح دادنش.** بخشِ ۴ همان کار را می‌کند.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-5-keeping-it-alive/session-08-project-monitor.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

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

<div dir="rtl">

## ۱. دنیای پروژه

</div>

```python
import math
import random
import statistics

CHAMPION = fit_model(TRAIN)
BAD_RELEASE = range(60, 65)              # پنج روز نسخهٔ خراب، اگر کسی نگیردش
RAMP_FROM = 80                           # از اینجا قاعدهٔ برچسب کم‌کم عوض می‌شود
DAYS = list(range(30, 120))
AUDIT = 60


def rows_of(day):
    """دنیای پروژه: سی روز آرام، پنج روز نسخهٔ خراب، بعد رانشِ مفهومِ تدریجی."""
    base = day_rows(day, "N")
    if day < RAMP_FROM:
        return base
    cut = int(min(1.0, (day - RAMP_FROM + 1) / 20) * len(base))
    return day_rows(day, "B")[:cut] + base[cut:]


def prepare(text, broken):
    clean = normalise(text)
    return clean[-50:] if broken else clean


def serve(model, day, broken):
    rows = rows_of(day)
    texts = [prepare(r["text"], broken) for r in rows]
    said = list(model.predict(texts))
    conf = [float(max(p)) for p in model.predict_proba(texts)]
    return rows, said, conf


def day_accuracy(model, day, broken=False):
    rows, said, _ = serve(model, day, broken)
    return sum(a == r["category"] for a, r in zip(said, rows)) / len(rows)


BASE = statistics.mean(day_accuracy(CHAMPION, d) for d in range(30, 40))
print("خطِ پایهٔ دقت (روزهای ۳۰ تا ۳۹):", round(BASE, 4))
print("پنجرهٔ نسخهٔ خراب:", f"{min(BAD_RELEASE)}-{max(BAD_RELEASE)}",
      "· شروعِ رانشِ مفهوم:", RAMP_FROM)
print("روزهای تولید:", len(DAYS), "· تیکت در روز:", DAY_SIZE)
```

```text
خطِ پایهٔ دقت (روزهای ۳۰ تا ۳۹): 0.8767
پنجرهٔ نسخهٔ خراب: 60-64 · شروعِ رانشِ مفهوم: 80
روزهای تولید: 90 · تیکت در روز: 120
```

<div dir="rtl">

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

## ۲. سه سیگنال، و آنچه هرکدام می‌بیند

</div>

```python
REF = [len(normalise(r["text"])) for r in span(30, 40, "N")]
EDGES = sorted(REF)[len(REF) // 6::len(REF) // 6][:5]


def shares(values):
    counts = [0] * (len(EDGES) + 1)
    for value in values:
        slot = 0
        while slot < len(EDGES) and value > EDGES[slot]:
            slot += 1
        counts[slot] += 1
    return [max(c, 1) / len(values) for c in counts]


REF_SHARE = shares(REF)
LOW_CONF, LOW_LIMIT = 0.90, 0.35          # نرخِ کم‌اطمینانِ سالم حدودِ ۰٫۲۱ است
ACC_LIMIT, ACC_NEED, ACC_OF = 0.85, 3, 5  # همان دروازهٔ فصلِ ۴


def psi(day):
    cur = [len(normalise(r["text"])) for d in range(max(30, day - 6), day + 1)
           for r in rows_of(d)]
    return sum((q - p) * math.log(q / p) for p, q in zip(REF_SHARE, shares(cur)))


sample = {d: psi(d) for d in (35, 62, 90, 110)}
print("PSI ورودی در چند روزِ نمونه:", {d: round(v, 4) for d, v in sample.items()})
rows, said, conf = serve(CHAMPION, 62, True)
print("روزِ ۶۲ با نسخهٔ خراب — نرخِ کم‌اطمینان:",
      round(sum(c < LOW_CONF for c in conf) / len(conf), 4))
rows, said, conf = serve(CHAMPION, 62, False)
print("همان روز، سالم                 :",
      round(sum(c < LOW_CONF for c in conf) / len(conf), 4))
```

```text
PSI ورودی در چند روزِ نمونه: {35: 0.0044, 62: 0.0124, 90: 0.013, 110: 0.0044}
روزِ ۶۲ با نسخهٔ خراب — نرخِ کم‌اطمینان: 0.4417
همان روز، سالم                 : 0.1583
```

<div dir="rtl">

**`PSI` در هر چهار روزِ نمونه زیرِ ۰٫۰۲ ماند** — چه در روزِ سالم، چه وسطِ نسخهٔ خراب، چه وسطِ رانشِ مفهوم. **دقیقاً همان نتیجهٔ فصلِ ۲**، و دلیلش هم همان است: ورودی‌ها در هیچ‌کدام از این دو خرابی عوض نشدند.

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

**و نرخِ کم‌اطمینان از ۰٫۱۶ به ۰٫۴۴ رفت** — همان سیگنالی که فصلِ ۳ نشان داد برای رانشِ مفهوم بی‌فایده است و فصلِ ۷ نشان داد برای خرابیِ مسیرِ داده بهترین چیزی است که داری.

## ۳. خطِ کامل

</div>

```python
HOLDOUT, MIN_SAMPLES, MARGIN = 3, 300, 0.05


def accuracy(model, rows, broken=False):
    said = model.predict([prepare(r["text"], broken) for r in rows])
    return sum(a == r["category"] for a, r in zip(said, rows)) / len(rows)


def gate(challenger, champion, day):
    check = [r for d in range(day - HOLDOUT, day) for r in rows_of(d)]
    if len(check) < MIN_SAMPLES:
        return False, "دادهٔ کافی نیست"
    new, old = accuracy(challenger, check), accuracy(champion, check)
    if new < old + MARGIN:
        return False, f"بهتر نشد: {new:.4f} در برابرِ {old:.4f}"
    return True, f"تأیید: {new:.4f} در برابرِ {old:.4f}"


COOLDOWN = 7                              # بینِ دو تلاشِ بازآموزی، حتی وقتی رد شود


def run(monitor=True, auto_rollback=True, retrain=True, use_gate=True):
    """خطِ کامل: پایش، هشدار، مهار، بازآموزی — هرکدام قابلِ خاموش کردن."""
    clock, log = Clock(), []
    live, rolled_back, last_try = CHAMPION, False, -99
    served, alerts, harmed, labels, blocked, retrains = [], [], 0, 0, 0, []
    history = []
    for day in DAYS:
        clock.jump_to(day * 86400)
        broken = day in BAD_RELEASE and not rolled_back
        if day == min(BAD_RELEASE):
            log.append((day, "استقرارِ نسخهٔ ۱٫۱٫۰"))
        rows, said, conf = serve(live, day, broken)
        hit = [a == r["category"] for a, r in zip(said, rows)]
        served.append(sum(hit) / len(hit))
        if broken:
            ok_said = serve(live, day, False)[1]
            harmed += sum(a != r["category"] and b == r["category"]
                          for a, b, r in zip(said, ok_said, rows))
        low = sum(c < LOW_CONF for c in conf) / len(conf)
        picked = random.Random(f"audit:{day}").sample(range(len(hit)), AUDIT)
        seen_acc = sum(hit[i] for i in picked) / AUDIT
        history.append({"day": day, "low": low, "acc": seen_acc})
        if not monitor:
            continue
        labels += AUDIT

        if low > LOW_LIMIT:
            alerts.append((day, "نرخِ کم‌اطمینان", low))
            log.append((day, f"هشدار: نرخِ کم‌اطمینان {low:.2f}"))
            if auto_rollback and not rolled_back and day in BAD_RELEASE:
                rolled_back = True
                log.append((day, "مهار: برگشت به نسخهٔ پایدار"))
        recent = history[-ACC_OF:]
        if len(recent) == ACC_OF and sum(h["acc"] < ACC_LIMIT for h in recent) >= ACC_NEED:
            alerts.append((day, "دقتِ نمونه", recent[-1]["acc"]))
            if retrain and day - last_try >= COOLDOWN:
                last_try = day
                challenger = fit_model([r for d in range(day - HOLDOUT - 30, day - HOLDOUT)
                                        for r in rows_of(d)])
                ok, why = gate(challenger, live, day) if use_gate else (True, "بدونِ دروازه")
                labels += 30 * DAY_SIZE
                if ok:
                    live = challenger
                    retrains.append(day)
                    log.append((day, f"بازآموزی پذیرفته شد · {why}"))
                else:
                    blocked += 1
                    log.append((day, f"بازآموزی رد شد · {why}"))
    bad_days = sum(a < BASE - 0.03 for a in served)
    return {"log": log, "served": served, "alerts": alerts, "harmed": harmed,
            "labels": labels, "blocked": blocked, "retrains": retrains,
            "bad_days": bad_days, "mean": statistics.mean(served)}


FULL = run()
print("خطِ کامل — هشدار:", len(FULL["alerts"]), "· بازآموزی:", len(FULL["retrains"]),
      "· ردشده:", FULL["blocked"])
print("روزهای بد:", FULL["bad_days"], "· میانگینِ سرو:", round(FULL["mean"], 4),
      "· کاربرِ آسیب‌دیده:", FULL["harmed"], "· برچسب:", FULL["labels"])
```

```text
خطِ کامل — هشدار: 31 · بازآموزی: 1 · ردشده: 4
روزهای بد: 35 · میانگینِ سرو: 0.8458 · کاربرِ آسیب‌دیده: 11 · برچسب: 23400
```

<div dir="rtl">

**کلِ سامانه در یک تابع جا شد و هر قطعه‌اش یک پرچمِ خاموش‌شدنی دارد.** این شکلِ نوشتن تصادفی نیست: بخشِ بعد دقیقاً همین پرچم‌ها را خاموش می‌کند تا سهمِ هرکدام معلوم شود.

**و `COOLDOWN` قطعه‌ای است که در هیچ فصلی درس نبود ولی بدونش این خط از کار می‌افتاد:** بدونِ فاصله بینِ تلاش‌ها، هشدارِ کیفیت هر روز یک بازآموزی راه می‌انداخت و هر بار ۳۶۰۰ برچسب می‌خرید، حتی وقتی دروازه ردش می‌کرد. **هزینهٔ تلاشِ ردشده صفر نیست.**

## ۴. ارزشِ هر قطعه، با خاموش کردنش

</div>

```python
CONFIGS = {
    "هیچ پایشی": dict(monitor=False, auto_rollback=False, retrain=False),
    "فقط پایش، بدونِ بازآموزی": dict(retrain=False),
    "بازآموزی بدونِ دروازه": dict(use_gate=False),
    "خطِ کامل": dict(),
}
RUNS = {name: run(**kw) for name, kw in CONFIGS.items()}
print(f"{'پیکربندی':<26}{'روزِ بد':>9}{'میانگینِ سرو':>14}{'آسیب‌دیده':>12}"
      f"{'بازآموزی':>10}{'برچسب':>10}")
for name, res in RUNS.items():
    print(f"{name:<26}{res['bad_days']:>9}{res['mean']:>14.4f}{res['harmed']:>12}"
          f"{len(res['retrains']):>10}{res['labels']:>10}")
```

```text
پیکربندی                    روزِ بد  میانگینِ سرو   آسیب‌دیده  بازآموزی     برچسب
هیچ پایشی                        44        0.8344          64         0         0
فقط پایش، بدونِ بازآموزی         40        0.8392          11         0      5400
بازآموزی بدونِ دروازه            35        0.8473          11         5     23400
خطِ کامل                         35        0.8458          11         1     23400
```

<div dir="rtl">

**سه چیز در این جدول هست و یکی‌شان خوشایند نیست.**

**۱)** **پایش به‌تنهایی، بدونِ هیچ بازآموزی‌ای، آسیب‌دیده را از ۶۴ به ۱۱ رساند** — با ۵۴۰۰ برچسب و بدونِ آموزشِ حتی یک مدل. **کلِ این سود از یک چیز آمد: مهارِ سریعِ نسخهٔ خراب.** ارزان‌ترین قطعهٔ این خط، همان اولی است.

**۲)** **بازآموزی روزهای بد را از ۴۰ به ۳۵ رساند** و میانگین را حدودِ هفت‌دهم واحد بالا برد، به قیمتِ ۱۸۰۰۰ برچسبِ اضافه. **مقایسه‌اش با ردیفِ قبلی همان تصمیمی است که سرِ بودجه باید بگیری.**

**۳)** و ردیفِ ناخوشایند: **دروازه در این اجرا میانگین را کمی پایین آورد** (۰٫۸۴۵۸ در برابرِ ۰٫۸۴۷۳) و روزهای بد را عوض نکرد. **همان نتیجهٔ فصلِ ۶، و همان جوابِ صادقانه:** دروازه در ازای آن پانزده ده‌هزارم، پنج تعویضِ مدل را به یک تعویض تبدیل کرد و چهار مدعی را که بهبودشان به حاشیه نمی‌رسید رد کرد. **اگر مدعیِ ششمی مثلِ مدلِ برچسب‌رایگانِ فصلِ ۶ بود، همین دروازه تنها چیزی بود که جلویش را می‌گرفت.**

> ✅ **چک کن:** همین جدول را برای سامانهٔ خودت بساز: **هر قطعهٔ پایش را یک بار خاموش کن و اثرش را بشمار.** اگر خاموش کردنِ چیزی هیچ عددی را عوض نکرد، یا آن قطعه لازم نیست، یا اندازه‌گیری‌ات آن خرابی‌ای را که قطعه برایش ساخته شده اصلاً شبیه‌سازی نمی‌کند. **هر دو حالت خبرِ مهمی است.**

## ۵. سیاههٔ اجرا

</div>

```python
for day, text in FULL["log"]:
    print(f"[روزِ {day:>3}] {text}")
```

```text
[روزِ  60] استقرارِ نسخهٔ ۱٫۱٫۰
[روزِ  60] هشدار: نرخِ کم‌اطمینان 0.56
[روزِ  60] مهار: برگشت به نسخهٔ پایدار
[روزِ  86] بازآموزی رد شد · بهتر نشد: 0.8444 در برابرِ 0.8472
[روزِ  93] بازآموزی رد شد · بهتر نشد: 0.8083 در برابرِ 0.8083
[روزِ 100] بازآموزی رد شد · بهتر نشد: 0.7278 در برابرِ 0.7333
[روزِ 107] بازآموزی رد شد · بهتر نشد: 0.7806 در برابرِ 0.7694
[روزِ 114] بازآموزی پذیرفته شد · تأیید: 0.8861 در برابرِ 0.7194
```

<div dir="rtl">

**هشت سطر، و هر سطر یک تصمیم با عددِ پشتش.**

سطرِ روزِ ۶۰ سه بار پشتِ سرِ هم می‌آید — استقرار، هشدار، مهار — و همین است که ۶۴ آسیب‌دیده را به ۱۱ رساند. **چهار سطرِ «بازآموزی رد شد» هم به‌اندازهٔ سطرِ پذیرش مهم‌اند**، چون بدونشان کسی نمی‌فهمد که دروازه واقعاً کار می‌کند.

> ⚠️ **مواظب باش:** پنجرهٔ آموزشِ مدعی از `day - HOLDOUT - 30` شروع می‌شود و در روزهای ابتدایی این عدد می‌تواند پیش از شروعِ دادهٔ تو بیفتد. **در این کد چنین پنجره‌ای هیچ خطایی نمی‌دهد** — تولیدکنندهٔ داده برای هر شمارهٔ روزی، حتی منفی، خوشحال یک روز می‌سازد. **خرابیِ ساکت از خرابیِ پرسروصدا خطرناک‌تر است:** مرزِ پایینِ هر پنجره را صریح با `max()` ببند و بعد `len` دادهٔ آموزش را چاپ کن.

## ۶. گزارشی که کد می‌نویسدش

</div>

```python
def report(res):
    first_bad = min(BAD_RELEASE)
    caught = next((d for d, kind, _ in res["alerts"] if kind == "نرخِ کم‌اطمینان"), None)
    lines = ["## گزارشِ سه‌ماههٔ سامانه", "",
             f"**دورهٔ گزارش:** روزِ {DAYS[0]} تا روزِ {DAYS[-1]}"
             f" · {len(DAYS) * DAY_SIZE} درخواست.",
             f"**میانگینِ دقتِ سروشده:** {res['mean']:.4f} (خطِ پایه {BASE:.4f}).",
             f"**روزهایی که زیرِ خطِ پایه بودیم:** {res['bad_days']} از {len(DAYS)}.", "",
             "**دو رویداد:**",
             f"- نسخهٔ خرابِ روزِ {first_bad}: در روزِ {caught} گرفته شد"
             f" · {res['harmed']} کاربر جوابِ بدتر گرفتند.",
             f"- رانشِ مفهوم از روزِ {RAMP_FROM}: {len(res['retrains'])} بازآموزیِ پذیرفته‌شده"
             f" در روزهای {res['retrains']} و {res['blocked']} بازآموزیِ ردشده.", "",
             f"**هزینه:** {res['labels']} برچسبِ انسانی · {len(res['alerts'])} هشدار.", "",
             "**چیزی که هنوز نداریم:** آشکارسازی که رانشِ مفهوم را پیش از افتِ دقت ببیند."]
    return "\n".join(lines)


print(report(FULL))
```

```text
## گزارشِ سه‌ماههٔ سامانه

**دورهٔ گزارش:** روزِ 30 تا روزِ 119 · 10800 درخواست.
**میانگینِ دقتِ سروشده:** 0.8458 (خطِ پایه 0.8767).
**روزهایی که زیرِ خطِ پایه بودیم:** 35 از 90.

**دو رویداد:**
- نسخهٔ خرابِ روزِ 60: در روزِ 60 گرفته شد · 11 کاربر جوابِ بدتر گرفتند.
- رانشِ مفهوم از روزِ 80: 1 بازآموزیِ پذیرفته‌شده در روزهای [114] و 4 بازآموزیِ ردشده.

**هزینه:** 23400 برچسبِ انسانی · 31 هشدار.

**چیزی که هنوز نداریم:** آشکارسازی که رانشِ مفهوم را پیش از افتِ دقت ببیند.
```

<div dir="rtl">

**سطرِ آخرِ این گزارش عمدی است و باید در هر گزارشِ واقعی باشد.**

گزارشی که فقط دستاورد را می‌شمارد، به خواننده‌اش یاد می‌دهد که سامانه پوشش‌داده‌شده است. **ما در فصلِ ۲ ثابت کردیم که چنین آشکارسازی از سمتِ ورودی وجود ندارد** و در فصلِ ۳ دیدیم بهترین جایگزینش برچسب است که دیر می‌آید. **پس این یک شکاف است که با تلاشِ بیشتر بسته نمی‌شود، و بهترین کاری که می‌شود کرد نوشتنِ صریحش است.**

## ۷. دو رویداد، دو تأخیر

</div>

```python
BAD_DAYS = list(BAD_RELEASE)
print(f"{'رویداد':<24}{'اولین هشدار':>14}{'تأخیر':>10}{'اثر':>26}")
low_alert = next((d for d, k, _ in FULL["alerts"] if k == "نرخِ کم‌اطمینان"), None)
acc_alert = next((d for d, k, _ in FULL["alerts"] if k == "دقتِ نمونه" and d >= RAMP_FROM), None)
print(f"{'نسخهٔ خرابِ روزِ ' + str(min(BAD_RELEASE)):<24}{low_alert:>14}"
      f"{low_alert - min(BAD_RELEASE):>10}{str(FULL['harmed']) + ' کاربرِ آسیب‌دیده':>26}")
print(f"{'رانشِ مفهوم از روزِ ' + str(RAMP_FROM):<24}{acc_alert:>14}"
      f"{acc_alert - RAMP_FROM:>10}{str(len(FULL['retrains'])) + ' بازآموزی':>26}")
none = RUNS["هیچ پایشی"]
print("در برابرِ «هیچ پایشی»: روزِ بد", none["bad_days"], "→", FULL["bad_days"],
      "· آسیب‌دیده", none["harmed"], "→", FULL["harmed"],
      "· میانگینِ سرو", round(none["mean"], 4), "→", round(FULL["mean"], 4))
try:
    print("اولین بازآموزیِ «هیچ پایشی»:", none["retrains"][0])
except IndexError as exc:
    print("IndexError:", exc)
```

```text
رویداد                     اولین هشدار     تأخیر                       اثر
نسخهٔ خرابِ روزِ 60                 60         0       11 کاربرِ آسیب‌دیده
رانشِ مفهوم از روزِ 80              86         6                1 بازآموزی
در برابرِ «هیچ پایشی»: روزِ بد 44 → 35 · آسیب‌دیده 64 → 11 · میانگینِ سرو 0.8344 → 0.8458
IndexError: list index out of range
```

<div dir="rtl">

**صفر روز در برابرِ شش روز.** نسخهٔ خراب همان روز گرفته شد چون سیگنالش برچسب نمی‌خواست؛ رانشِ مفهوم شش روز طول کشید چون تنها سیگنالش برچسب می‌خواهد و شرطِ «۳ روز از ۵ روز» زمان می‌برد.

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

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

> 🔧 **اگر کار نکرد:** خطِ `none["retrains"][0]` در کدِ بالا روی پیکربندیِ «هیچ پایشی» می‌شکند: `IndexError: list index out of range`. **علتش این است که آن اجرا هیچ بازآموزی‌ای نداشت و کد فرض کرده بود دستِ‌کم یکی هست.** خودِ `report` نمی‌شکند ولی بدتر است: روی همان پیکربندی بی‌سروصدا می‌نویسد «در روزِ None گرفته شد». این رایج‌ترین باگِ کدِ گزارش‌گیری است و همیشه در بدترین لحظه پیدا می‌شود — وقتی چیزی **اتفاق نیفتاده** و تو دقیقاً می‌خواهی بدانی چرا. **قاعده: هر گزارشی باید حالتِ «هیچ رویدادی نبود» را هم چاپ کند، نه اینکه از آن بترسد.**

## ۸. سیاههٔ تحویل

</div>

| سؤال، پیش از هر تحویل | کجای این پروژه جوابش است |
|---|---|
| چه چیزی را می‌بینم؟ | پیشامدِ هر درخواست، متریکِ سامانه و متریکِ مدل (فصلِ ۱) |
| رانش را چطور می‌فهمم؟ | `PSI` روی ورودی — و می‌دانم چه چیزی را نمی‌بیند (فصلِ ۲) |
| بدونِ برچسب چه دارم؟ | نرخِ کم‌اطمینان، با همبستگیِ سنجیده‌شده‌اش (فصلِ ۳) |
| هشدارم قابلِ اعتماد است؟ | آستانه از نویز، به‌علاوهٔ پایداریِ ۳ از ۵ (فصلِ ۴) |
| برچسبم از کجا می‌آید؟ | نمونهٔ تصادفیِ اجباری، نه خروجیِ خودِ مدل (فصلِ ۵) |
| کِی بازآموزی کنم؟ | راه‌اندازِ کیفیت، پنجرهٔ ۳۰ روزه، دروازهٔ برون‌زمانی (فصلِ ۶) |
| روزِ بد چه می‌کنم؟ | مهارِ اول، بعد ریشه‌یابی، بعد گزارشِ بدونِ سرزنش (فصلِ ۷) |
| از کجا بدانم همهٔ این‌ها ارزش دارند؟ | جدولِ بخشِ ۴ — هر قطعه را خاموش کن و بشمار |

<div dir="rtl">

> 🤖 **از دستیارت بپرس:** «اگر بخواهم برای یک سامانهٔ مدلِ زنده یک `runbook` بنویسم، چه بخش‌هایی باید داشته باشد؟» بعد این را بپرس: **«کدام بخش‌های آن `runbook` را می‌شود به یک تستِ خودکار تبدیل کرد و کدام‌ها ذاتاً کارِ آدم می‌مانند؟»** — جوابش همان مرزی است که کلِ این ترم رویش کار کرد.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| monitoring stack | مانیتورینگ استک | مجموعهٔ سیگنال‌ها، هشدارها و گزارش‌هایی که با هم پایش را می‌سازند |
| kill switch | کیل سوییچ | سازوکاری که با یک تصمیم، رفتارِ خطرناک را همان لحظه متوقف می‌کند |
| cooldown | کول‌داون | حداقل فاصلهٔ بینِ دو بار اجرای یک کارِ خودکار |
| health report | هلث ریپورت | گزارشِ دوره‌ای که وضعیت و هزینه و شکاف‌ها را با هم می‌گوید |

<div dir="rtl">

## تمرین‌ها

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

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

**تمرینِ ستاره‌دار ⭐:** به این خط قابلیتی اضافه کن که هیچ فصلی نساختش: **بازگشتِ خودکار به مدلِ قبلی وقتی مدلِ تازه بعد از پذیرش بد از آب دربیاید.** یعنی دروازه تأیید کند، مدل زنده شود، و سه روز بعد معلوم شود اشتباه بوده. **سه عدد گزارش کن:** تعدادِ دفعاتی که این بازگشت فعال شد، روزهای بدِ کم‌شده، و **تعدادِ دفعاتی که روی یک مدلِ سالم به‌اشتباه فعال شد.** **و سؤالِ سخت را جواب بده: این سازوکار با «دروازهٔ سخت‌گیرتر» چه فرقی دارد، و در چه شرایطی یکی از دیگری بهتر است؟** جوابت باید به تفاوتِ هزینهٔ خطای پذیرش و خطای رد برسد.

## در فصل بعد

**ترمِ ۵ تمام شد.** سامانه‌ات دیده می‌شود، رانش را می‌فهمد، هشدارِ بی‌خود نمی‌دهد، می‌داند کِی بازآموزی کند، و در روزِ بد گزارشی می‌نویسد که فردا کسی بتواند از رویش بازسازی کند چه شد.

**ولی تا اینجا همه‌چیز را یک نفر انجام داده.** ترمِ ۶ دربارهٔ لحظه‌ای است که این کار از دستِ تو خارج می‌شود: مخزن و بازبینی، `CI` برای کدِ داده‌محور، مستنداتی که کهنه نمی‌شود، ثبتِ ریسک، و کارِ با کسی که هیچ‌کدام از این عددها را نمی‌فهمد. **قاعدهٔ سختش را از حالا بدان: سامانه‌ای که فقط تو می‌توانی نگهش داری، نگهداشتنی نیست.**

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t5/s08-project-monitor (یادستان, Yaadestan)
