# فصل ۰۴ — هشدار بدونِ خستگی

<div dir="rtl">

# فصل ۰۴ — هشدار بدونِ خستگی

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

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

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

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

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

![زنگِ اخباری که با یک قفلِ دومرحله‌ای به اهرمِ واقعی وصل شده](/lesson-assets/t5-s04-alerting/prompt/01-image-two-stage-bell.png)

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

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

## قبل از شروع

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

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

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

</div>

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

<div dir="rtl">

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

</div>

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

```text
روزهای آرام  : واقعی 0.8847 · دیده‌شده 0.8910 · انحرافِ معیارِ دیده‌شده 0.0344
نسخهٔ خراب   : واقعی 0.7567
رانشِ آرام   : روزِ ۱۰۵ 0.8417 · روزِ ۱۱۰ 0.8000 · روزِ ۱۱۹ 0.8083
```

<div dir="rtl">

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

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

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

</div>

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

```text
خطِ پایهٔ دقتِ واقعی: 0.8847
روزهای خرابِ واقعی: 22 · دو پنجره: 80-84 و 103-119
نویزِ روزهای آرام — کمینه: 0.8167 · بیشینه: 0.9667
روزهای آرامِ زیرِ ۰٫۹۰: 22 · زیرِ ۰٫۸۵: 4 از 50
```

<div dir="rtl">

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

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

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

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

</div>

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

```text
آشکارساز                     هشدار   در هفته    کاذب    کاذب در هفته
آستانهٔ ثابت                    47      4.33      27            2.49
نرخِ تغییر                      16      1.47       6            0.55
آستانه + پایداریِ ۳ از ۵        46      4.24      24            2.21
```

<div dir="rtl">

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

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

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

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

</div>

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

```text
شروعِ نسخهٔ خراب: 80 · شروعِ رانشِ واقعاً مضر: 103
آشکارساز                     تأخیر: نسخهٔ خراب   تأخیر: رانش
آستانهٔ ثابت                             0 روز         0 روز
نرخِ تغییر                               2 روز        10 روز
آستانه + پایداریِ ۳ از ۵                 0 روز         0 روز
```

<div dir="rtl">

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

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

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

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

</div>

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

```text
آستانهٔ ثابت               پیش از روزِ 80:  16 هشدار ·   5.3 ساعتِ بررسی · هشدارِ واقعی شمارهٔ 17 بود
نرخِ تغییر                 پیش از روزِ 80:   2 هشدار ·   0.7 ساعتِ بررسی · هشدارِ واقعی شمارهٔ 3 بود
آستانه + پایداریِ ۳ از ۵   پیش از روزِ 80:  12 هشدار ·   4.0 ساعتِ بررسی · هشدارِ واقعی شمارهٔ 13 بود
```

<div dir="rtl">

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

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

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

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

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

</div>

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

```text
  آستانه   هشدار در هفته    کاذب در هفته   تأخیرِ نسخهٔ خراب
    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
```

<div dir="rtl">

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

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

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

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

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

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

</div>

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

```text
آستانهٔ ثابت
   بازآموزی با پنجرهٔ تازه       15
   برگشت به نسخهٔ قبل             5
   هیچ — نویزِ نمونه‌گیری        27
آستانه + پایداریِ ۳ از ۵
   بازآموزی با پنجرهٔ تازه       17
   برگشت به نسخهٔ قبل             5
   هیچ — نویزِ نمونه‌گیری        24
KeyError: 25
```

<div dir="rtl">

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

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

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

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

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

</div>

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

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا شرطِ پایداری روی آستانهٔ ۰٫۹۰ کمکی نکرد ولی روی ۰٫۸۵ کرد؟

**تمرینِ اجباری:** `LABELS_PER_DAY` را ۳۰ و ۶۰ و ۱۲۰ بگذار و برای هرکدام **سه عدد** بده: انحرافِ معیارِ متریکِ دیده‌شده در روزهای آرام، هشدارِ کاذب در هفته با آستانهٔ ۰٫۸۵، و تأخیرِ تشخیصِ نسخهٔ خراب. **جدولت را نگاه کن و جواب بده: با دو برابر کردنِ بودجهٔ برچسب، کدام‌یک از این سه عدد بهتر می‌شود و کدام نه؟**

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

## در فصل بعد

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

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

</div>

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