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

فصل ۴ از ۸

پیشرفت ترم
۰٪

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

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

آستانه‌ای که هر تیمی اول انتخاب می‌کند — «دقت زیرِ ۰٫۹۰ نیاید» — این را می‌دهد: ۴٫۳۳ هشدار در هفته که ۲٫۴۹ تایش کاذب است. و وقتی خرابیِ واقعی رسید، آن هشدار شمارهٔ ۱۷ بود؛ شانزده هشدارِ بی‌خود و ۵٫۳ ساعت بررسی جلوتر از آن ایستاده بودند.

بعد آستانه را از نویزِ خودِ داده بیرون می‌کشیم و شرطِ پایداری می‌گذاریم: ۱٫۵۷ هشدار در هفته، ۰٫۳۷ کاذب، و صفر هشدار پیش از خرابیِ واقعی — یعنی وقتی زنگ خورد، اولین زنگ بود.

و یک نتیجهٔ منفیِ مهم هم داریم: شرطِ پایداری روی آستانهٔ بدِ ۰٫۹۰ تقریباً هیچ کمکی نکرد (۴٫۲۴ در برابرِ ۴٫۳۳). ترتیب اهمیت دارد.

زنگِ اخباری که با یک قفلِ دومرحله‌ای به اهرمِ واقعی وصل شده

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

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

قبل از شروع#

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

از فصلِ ۲: پنجرهٔ کوتاه زودتر می‌فهمد و بیشتر هشدارِ کاذب می‌دهد. اینجا همان معامله را عدد می‌کنیم.

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

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

۱. نود روز با دو خرابیِ واقعی#

import random
import statistics

MODEL = fit_model(TRAIN)
BAD_DAYS = range(80, 85)          # نسخهٔ خرابی که پنج روز زنده بود
RAMP_FROM = 100                   # از اینجا قاعدهٔ برچسب کم‌کم عوض می‌شود
LABELS_PER_DAY = 60


def prepare(text, day):
    """نسخهٔ خراب یک باگِ برش دارد: هر تیکت به پنجاه نویسهٔ آخرش کوتاه می‌شود."""
    clean = normalise(text)
    return clean[-50:] if day in BAD_DAYS else clean


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 score(day, rows):
    said = MODEL.predict([prepare(r["text"], day) for r in rows])
    return sum(a == r["category"] for a, r in zip(said, rows)) / len(rows)


def truth(day):
    return score(day, rows_of(day))


def observed(day):
    """چیزی که داشبورد می‌بیند: دقت روی نمونهٔ برچسب‌خوردهٔ همان روز."""
    rows = random.Random(f"audit:{day}").sample(rows_of(day), LABELS_PER_DAY)
    return score(day, rows)


DAYS = list(range(30, 120))
TRUE = {d: truth(d) for d in DAYS}
SEEN = {d: observed(d) for d in DAYS}
CALM = [d for d in DAYS if d < 80]
print(f"روزهای آرام  : واقعی {statistics.mean(TRUE[d] for d in CALM):.4f}"
      f" · دیده‌شده {statistics.mean(SEEN[d] for d in CALM):.4f}"
      f" · انحرافِ معیارِ دیده‌شده {statistics.stdev(SEEN[d] for d in CALM):.4f}")
print(f"نسخهٔ خراب   : واقعی {statistics.mean(TRUE[d] for d in BAD_DAYS):.4f}")
print(f"رانشِ آرام   : روزِ ۱۰۵ {TRUE[105]:.4f} · روزِ ۱۱۰ {TRUE[110]:.4f}"
      f" · روزِ ۱۱۹ {TRUE[119]:.4f}")
روزهای آرام  : واقعی 0.8847 · دیده‌شده 0.8910 · انحرافِ معیارِ دیده‌شده 0.0344
نسخهٔ خراب   : واقعی 0.7567
رانشِ آرام   : روزِ ۱۰۵ 0.8417 · روزِ ۱۱۰ 0.8000 · روزِ ۱۱۹ 0.8083

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

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

۲. اول نویز را بشناس، بعد آستانه بگذار#

BASELINE = statistics.mean(TRUE[d] for d in CALM)
HARM = 0.03


def smooth(day, half=2):
    span_days = [d for d in range(day - half, day + half + 1) if d in TRUE]
    return statistics.mean(TRUE[d] for d in span_days)


DRIFT_HARM = next(d for d in DAYS if d >= RAMP_FROM and smooth(d) < BASELINE - HARM)
INCIDENT = set(BAD_DAYS) | set(range(DRIFT_HARM, 120))
print("خطِ پایهٔ دقتِ واقعی:", round(BASELINE, 4))
print("روزهای خرابِ واقعی:", len(INCIDENT), "· دو پنجره:", f"{min(BAD_DAYS)}-{max(BAD_DAYS)}",
      "و", f"{DRIFT_HARM}-119")
print("نویزِ روزهای آرام — کمینه:", round(min(SEEN[d] for d in CALM), 4),
      "· بیشینه:", round(max(SEEN[d] for d in CALM), 4))
print("روزهای آرامِ زیرِ ۰٫۹۰:", sum(SEEN[d] < 0.90 for d in CALM),
      "· زیرِ ۰٫۸۵:", sum(SEEN[d] < 0.85 for d in CALM), "از", len(CALM))
خطِ پایهٔ دقتِ واقعی: 0.8847
روزهای خرابِ واقعی: 22 · دو پنجره: 80-84 و 103-119
نویزِ روزهای آرام — کمینه: 0.8167 · بیشینه: 0.9667
روزهای آرامِ زیرِ ۰٫۹۰: 22 · زیرِ ۰٫۸۵: 4 از 50

بیست‌ودو روز از پنجاه روزِ کاملاً سالم زیرِ ۰٫۹۰ افتاده‌اند. هیچ اتفاقی نیفتاده بود؛ فقط شصت برچسب در روز این‌قدر نویز دارد.

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

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

۳. سه آشکارساز، یک جدول#

FIRST = 44                        # قبل از این، تاریخچهٔ کافی برای نرخِ تغییر وجود ندارد
WATCH = [d for d in DAYS if d >= FIRST]
WEEKS = len(WATCH) / 7


def fixed_threshold(day, limit=0.90):
    return SEEN[day] < limit


def rate_of_change(day, window=7, drop=0.03):
    now = statistics.mean(SEEN[d] for d in range(day - window + 1, day + 1))
    before = statistics.mean(SEEN[d] for d in range(day - 2 * window + 1, day - window + 1))
    return now < before - drop


def persistent(day, limit=0.90, need=3, of=5):
    return sum(SEEN[d] < limit for d in range(day - of + 1, day + 1)) >= need


DETECTORS = {"آستانهٔ ثابت": fixed_threshold,
             "نرخِ تغییر": rate_of_change,
             "آستانه + پایداریِ ۳ از ۵": persistent}
FIRES = {name: [d for d in WATCH if fn(d)] for name, fn in DETECTORS.items()}
print(f"{'آشکارساز':<26}{'هشدار':>8}{'در هفته':>10}{'کاذب':>8}{'کاذب در هفته':>16}")
for name, days in FIRES.items():
    false = [d for d in days if d not in INCIDENT]
    print(f"{name:<26}{len(days):>8}{len(days) / WEEKS:>10.2f}{len(false):>8}"
          f"{len(false) / WEEKS:>16.2f}")
آشکارساز                     هشدار   در هفته    کاذب    کاذب در هفته
آستانهٔ ثابت                    47      4.33      27            2.49
نرخِ تغییر                      16      1.47       6            0.55
آستانه + پایداریِ ۳ از ۵        46      4.24      24            2.21

نرخِ تغییر روی خودِ دقت آستانه‌ای نمی‌گذارد و همین قوتش است. آستانه‌ای که دارد (drop=0.03) روی اندازهٔ افت است، نه روی جای عدد: به‌جای «کجاست» می‌پرسد «چقدر عوض شده»، پس سطحِ ثابتِ نویز را نادیده می‌گیرد و یک‌سومِ هشدارهای آستانهٔ ثابت را می‌دهد.

و شرطِ پایداری اینجا تقریباً هیچ کاری نکرد: ۴٫۲۴ در برابرِ ۴٫۳۳. این یک نتیجهٔ منفیِ مهم است. وقتی ۴۴ درصدِ روزهای سالم زیرِ آستانه‌اند، «سه روز از پنج روز» هم مرتب اتفاق می‌افتد. پایداری نویز را فیلتر می‌کند، ولی آستانهٔ غلط را درست نمی‌کند. ترتیب کار این است: اول آستانه از روی نویز، بعد پایداری.

۴. تأخیرِ تشخیص: ستونی که جدولِ بالا ندارد#

کم بودنِ هشدار به‌تنهایی فضیلت نیست؛ آشکارسازی که هیچ‌وقت زنگ نمی‌زند صفر هشدارِ کاذب دارد.

def first_at_or_after(days, start, stop=None):
    return next((d for d in days if d >= start and (stop is None or d < stop)), None)


BAD_START = min(BAD_DAYS)
print("شروعِ نسخهٔ خراب:", BAD_START, "· شروعِ رانشِ واقعاً مضر:", DRIFT_HARM)
print(f"{'آشکارساز':<26}{'تأخیر: نسخهٔ خراب':>20}{'تأخیر: رانش':>14}")
for name, days in FIRES.items():
    one = first_at_or_after(days, BAD_START, 85)
    two = first_at_or_after(days, DRIFT_HARM)
    a = "نگرفت" if one is None else f"{one - BAD_START} روز"
    b = "نگرفت" if two is None else f"{two - DRIFT_HARM} روز"
    print(f"{name:<26}{a:>20}{b:>14}")
شروعِ نسخهٔ خراب: 80 · شروعِ رانشِ واقعاً مضر: 103
آشکارساز                     تأخیر: نسخهٔ خراب   تأخیر: رانش
آستانهٔ ثابت                             0 روز         0 روز
نرخِ تغییر                               2 روز        10 روز
آستانه + پایداریِ ۳ از ۵                 0 روز         0 روز

نرخِ تغییر ارزانی‌اش را با ده روز تأخیر خرید. پنجرهٔ هفت‌روزه‌اش برای دیدنِ یک شیب باید صبر کند تا شیب به‌اندازهٔ کافی جمع شود؛ و برای پله، دو روز طول کشید تا میانگینِ هفتگی تکان بخورد.

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

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

۵. قیمتِ خستگی#

MINUTES = 20
for name, days in FIRES.items():
    before = [d for d in days if d < BAD_START]
    print(f"{name:<26} پیش از روزِ {BAD_START}: {len(before):>3} هشدار"
          f" · {len(before) * MINUTES / 60:>5.1f} ساعتِ بررسی"
          f" · هشدارِ واقعی شمارهٔ {len(before) + 1} بود")
آستانهٔ ثابت               پیش از روزِ 80:  16 هشدار ·   5.3 ساعتِ بررسی · هشدارِ واقعی شمارهٔ 17 بود
نرخِ تغییر                 پیش از روزِ 80:   2 هشدار ·   0.7 ساعتِ بررسی · هشدارِ واقعی شمارهٔ 3 بود
آستانه + پایداریِ ۳ از ۵   پیش از روزِ 80:  12 هشدار ·   4.0 ساعتِ بررسی · هشدارِ واقعی شمارهٔ 13 بود

روزِ ۸۰ واقعاً خراب بود و آستانهٔ ثابت همان روز زنگ زد. ولی آن زنگ، هفدهمین زنگِ آن دوره بود.

شانزده تای قبلی هیچ خبری نداشتند و روی‌هم ۵٫۳ ساعت از وقتِ یک نفر را گرفتند — با فرضِ بیست دقیقه بررسی برای هر هشدار، که فرضِ خوش‌بینانه‌ای است.

اینجا باید صادق باشیم دربارهٔ آنچه اندازه گرفتیم و آنچه نگرفتیم. «شمارهٔ ۱۷ بودن» یک اندازه‌گیری است. «پس نادیده گرفته می‌شود» یک ادعا دربارهٔ آدم‌هاست و ما هیچ آدمی را اندازه نگرفته‌ایم. آنچه کد نشان می‌دهد این است که سازوکارِ هشدار شانزده فرصت برای بی‌اعتماد شدن ساخته بود، و همان عدد کافی است تا تصمیم عوض شود.

و ردیفِ سوم می‌گوید پایداری به‌تنهایی جواب نیست: هنوز ۱۲ هشدار پیش از روزِ ۸۰ دارد. همان آشکارساز اگر آستانه‌اش را از نویز بگیرد، پیش از روزِ ۸۰ صفر هشدار می‌دهد. بخشِ بعد می‌سازدش.

۶. آستانه را از داده بیرون بکش#

def sweep(limit):
    days = [d for d in WATCH if SEEN[d] < limit]
    false = [d for d in days if d not in INCIDENT]
    caught = first_at_or_after(days, BAD_START, 85)
    return len(days) / WEEKS, len(false) / WEEKS, ("نگرفت" if caught is None
                                                   else f"{caught - BAD_START} روز")


print(f"{'آستانه':>8}{'هشدار در هفته':>16}{'کاذب در هفته':>16}{'تأخیرِ نسخهٔ خراب':>20}")
for limit in (0.78, 0.82, 0.85, 0.88, 0.90):
    total, false, delay = sweep(limit)
    print(f"{limit:>8.2f}{total:>16.2f}{false:>16.2f}{delay:>20}")
BEST = [d for d in WATCH if persistent(d, limit=0.85)]
false = [d for d in BEST if d not in INCIDENT]
print(f"آستانهٔ ۰٫۸۵ + پایداریِ ۳ از ۵: {len(BEST) / WEEKS:.2f} هشدار در هفته"
      f" · {len(false) / WEEKS:.2f} کاذب"
      f" · تأخیرِ نسخهٔ خراب {first_at_or_after(BEST, BAD_START, 85) - BAD_START} روز"
      f" · تأخیرِ رانش {first_at_or_after(BEST, DRIFT_HARM) - DRIFT_HARM} روز")
print("  هشدارهای پیش از روزِ ۸۰:", len([d for d in BEST if d < BAD_START]))
  آستانه   هشدار در هفته    کاذب در هفته   تأخیرِ نسخهٔ خراب
    0.78            0.64            0.18               1 روز
    0.82            1.57            0.37               1 روز
    0.85            1.93            0.55               0 روز
    0.88            3.50            1.84               0 روز
    0.90            4.33            2.49               0 روز
آستانهٔ ۰٫۸۵ + پایداریِ ۳ از ۵: 1.57 هشدار در هفته · 0.37 کاذب · تأخیرِ نسخهٔ خراب 1 روز · تأخیرِ رانش 8 روز
  هشدارهای پیش از روزِ ۸۰: 0

۰٫۷۸ خیلی محافظه‌کار است — هفته‌ای ۰٫۶۴ هشدار، ولی یک روز دیر. ۰٫۹۰ نزدیکِ هفت برابرِ آن هشدار می‌دهد و فقط یک روز زودتر می‌گیرد. بینشان ۰٫۸۵ ایستاده که نسخهٔ خراب را در روزِ صفر می‌گیرد و هفته‌ای ۰٫۵۵ هشدارِ کاذب دارد.

و خطِ آخر ترکیبِ برنده است: همان ۰٫۸۵، این بار با شرطِ پایداری. هشدارِ کاذب به ۰٫۳۷ در هفته می‌رسد و — مهم‌تر — پیش از خرابیِ واقعی صفر هشدار داده بود. قیمتش یک روز تأخیر روی پله و هشت روز روی شیب است.

مقایسه‌اش را با بخشِ ۳ نگه دار: همان شرطِ پایداری روی آستانهٔ ۰٫۹۰ عملاً بی‌اثر بود. همان مکانیزم، دو نتیجهٔ کاملاً متفاوت، فقط به‌خاطرِ عددی که زیرش گذاشته‌ای.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با فهرستِ «روزهای خرابِ واقعی» که پیش از دیدنِ هیچ آشکارسازی و از روی دقتِ واقعی ساخته شد — بدونِ آن، «هشدارِ کاذب» تعریف نداشت. روی کدام داده؟ یک سریِ ۹۰ روزه، ۶۰ برچسب در روز، یکسان برای هر سه آشکارساز؛ تنها متغیر خودِ قاعدهٔ هشدار بود. با چند seed؟ یکی برای نمونه‌گیریِ هر روز — و ۷۶ روزِ مستقلِ ارزیابی نقشِ تکرار را بازی می‌کنند. همهٔ عددها روی هر ماشینی همین‌اند، چون هیچ‌جا time یا hash در کار نیست.

۷. هر هشدار باید کاری داشته باشد#

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

def action_of(day):
    """هر هشدار باید به یک کارِ مشخص وصل باشد، وگرنه فقط سروصداست."""
    if day in BAD_DAYS:
        return "برگشت به نسخهٔ قبل"
    if day >= DRIFT_HARM:
        return "بازآموزی با پنجرهٔ تازه"
    return "هیچ — نویزِ نمونه‌گیری"


for name in ("آستانهٔ ثابت", "آستانه + پایداریِ ۳ از ۵"):
    counts = {}
    for day in FIRES[name]:
        counts[action_of(day)] = counts.get(action_of(day), 0) + 1
    print(name)
    for key in sorted(counts):
        print(f"   {key:<28}{counts[key]:>4}")
try:
    rate_of_change(31)
except KeyError as exc:
    print("KeyError:", exc)
آستانهٔ ثابت
   بازآموزی با پنجرهٔ تازه       15
   برگشت به نسخهٔ قبل             5
   هیچ — نویزِ نمونه‌گیری        27
آستانه + پایداریِ ۳ از ۵
   بازآموزی با پنجرهٔ تازه       17
   برگشت به نسخهٔ قبل             5
   هیچ — نویزِ نمونه‌گیری        24
KeyError: 25

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

این جدول را می‌شود برای هر هشداری در هر سامانه‌ای ساخت و معمولاً وجود ندارد. سه دستهٔ ممکن بیشتر نیست: هشداری که به برگشت منجر می‌شود، هشداری که به بازآموزی منجر می‌شود، و هشداری که به هیچ. دستهٔ سوم باید حذف شود، نه اینکه تحمل شود — چون تنها کاری که می‌کند این است که دو دستهٔ اول را کم‌ارزش کند.

🔧 اگر کار نکرد: اگر آشکارسازِ نرخِ تغییر را در روزهای اولِ سری اجرا کنی، مثلاً روزِ ۳۱ مثلِ کدِ بالا، این را می‌گیری: KeyError: 25 (روزِ ۳۰ هم همین است، با عددِ ۲۴). پیام فقط یک عدد است و هیچ نمی‌گوید چه شده. علتش این است که پنجره‌ها به روزهایی قبل از شروعِ سریِ تو نگاه می‌کنند. جوابِ درست «صفر بگذار» نیست — با صفر گرفتنِ روزهای ناموجود، میانگینِ گذشته پایین می‌آید و آشکارساز در روزهای اول سیل هشدار می‌دهد. جوابِ درست این است که آشکارساز تا وقتی تاریخچهٔ کافی ندارد، صریحاً «هنوز نمی‌دانم» برگرداند — همان حالتِ سومی که ترمِ ۴ فصلِ ۶ برای دروازهٔ قناری ساخت.

🤖 از دستیارت بپرس: «alert fatigue چیست و در پزشکی و هوانوردی چه شواهدی دربارهٔ آن هست؟» بعد این را بپرس: «اگر ده متریک داشته باشم و روی هرکدام یک هشدارِ مستقل با نرخِ کاذبِ هفته‌ای ۰٫۵ بگذارم، در هفته چند هشدارِ کاذب می‌گیرم و این عدد را چطور پایین بیاورم بی‌آنکه تأخیرِ تشخیص را زیاد کنم؟»

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

کلمه تلفظ به حروف فارسی یعنی چه
alert الرت پیامی که یک آدم را برای انجامِ کاری خبر می‌کند
false positive فالس پازیتیو هشداری که هیچ خرابیِ واقعی پشتش نبود
alert fatigue الرت فتیگ بی‌اثر شدنِ هشدارها وقتی بیشترشان کاذب‌اند
detection delay دیتکشن دیلی فاصلهٔ شروعِ خرابی تا اولین هشدارِ درست
rate of change ریت آو چنج آشکارسازی که به‌جای مقدار، اندازهٔ تغییر را می‌سنجد
persistence rule پرسیستنس رول شرطِ «N بار از M بار» تا هشدار صادر شود
runbook ران‌بوک دستورالعملِ کاری که بعد از هر هشدار باید انجام شود

تمرین‌ها

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

در فصل بعد#

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

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

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

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