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

فصل ۸ از ۸

پیشرفت ترم
۰٪

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

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

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

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

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

یک تابلوی کنترلِ کامل با چهار عقربه و یک اهرمِ برگشت

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

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

قبل از شروع#

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

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

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

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

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

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

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

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

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))
PSI ورودی در چند روزِ نمونه: {35: 0.0044, 62: 0.0124, 90: 0.013, 110: 0.0044}
روزِ ۶۲ با نسخهٔ خراب — نرخِ کم‌اطمینان: 0.4417
همان روز، سالم                 : 0.1583

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

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

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

۳. خطِ کامل#

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"])
خطِ کامل — هشدار: 31 · بازآموزی: 1 · ردشده: 4
روزهای بد: 35 · میانگینِ سرو: 0.8458 · کاربرِ آسیب‌دیده: 11 · برچسب: 23400

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

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

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

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}")
پیکربندی                    روزِ بد  میانگینِ سرو   آسیب‌دیده  بازآموزی     برچسب
هیچ پایشی                        44        0.8344          64         0         0
فقط پایش، بدونِ بازآموزی         40        0.8392          11         0      5400
بازآموزی بدونِ دروازه            35        0.8473          11         5     23400
خطِ کامل                         35        0.8458          11         1     23400

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

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

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

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

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

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

for day, text in FULL["log"]:
    print(f"[روزِ {day:>3}] {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

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

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

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

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

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))
## گزارشِ سه‌ماههٔ سامانه

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

تمرین‌ها

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

در فصل بعد#

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

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

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

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