# فصل ۰۶ — انتشارِ تدریجی

<div dir="rtl">

# فصل ۰۶ — انتشارِ تدریجی

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

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

سه استراتژیِ انتشار را روی همین دو نسخه اجرا می‌کنیم و می‌شماریم. **قناریِ پنج‌درصدی در ۱۳ گروه از ۲۰ گروهِ ممکن، این سقوط را تأیید و منتشر می‌کند** و ۸۱ کاربر جوابِ بدتر می‌گیرند. **سایه همان خرابی را با ۲۳۹ نمونه و صفر کاربرِ آسیب‌دیده پیدا می‌کند — و برای دیدنش حتی به یک برچسب هم نیاز ندارد.**

![سه چیدمانِ آزمایشِ متفاوت روی یک خطِ انتقال](/lesson-assets/t4-s06-progressive-release/prompt/01-image-three-test-rigs.png)

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

- سایه، قناری و `A/B` را بسازی و بگویی هرکدام چه چیزی را می‌بیند و چه چیزی را نمی‌بیند
- تخصیصِ ترافیک را **پایدار** بنویسی و بدانی چرا `hash()` پایتون برایش سم است
- درصدِ ترافیک را به‌عنوان اهرمِ ریسک تنظیم کنی و هزینهٔ هر تنظیم را بشماری
- ثابت کنی که متریکِ تجمیعی یک خرابیِ زیرگروهی را **نمی‌بیند**

## قبل از شروع

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

**از فصلِ ۱ و ۲ همین ترم:** شمارهٔ نسخه — که فصلِ ۱ داخلِ `artifact` گذاشت و فصلِ ۲ در **هر پاسخ** برگرداند (`model_version`). بدونِ آن هیچ‌کدام از اندازه‌گیری‌های این فصل ممکن نیست.

> 💡 **نکته:** ما اینجا برچسبِ درست را داریم چون آزمایشگاهیم. در تولید برچسب دیر می‌رسد یا اصلاً نمی‌رسد — به همین دلیل بخشِ ۳ عمداً معیاری می‌سازد که **هیچ برچسبی لازم ندارد**.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-4-deployment/session-06-progressive-release.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

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

<div dir="rtl">

## ۱. دو نسخه، و عددی که می‌گوید «منتشرش کن»

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

</div>

```python
import hashlib
import random
import statistics

V1 = fit_model(TRAIN[:800])                                    # مدلِ سه ماه پیش
FRESH = [r for r in TRAIN if r["channel"] != "حضوری"]          # منبعی که از قلم افتاد
V2 = fit_model(FRESH, tfidf=True, ngram=(1, 2), C=10)          # بازآموزی، ویژگیِ بهتر

A_SAYS = dict(zip([r["ticket_id"] for r in TEST],
                  V1.predict([normalise(r["text"]) for r in TEST])))
B_SAYS = dict(zip([r["ticket_id"] for r in TEST],
                  V2.predict([normalise(r["text"]) for r in TEST])))
TRUTH = {r["ticket_id"]: r["category"] for r in TEST}

SUB = [r for r in TEST if r["channel"] == "حضوری"]
REST = [r for r in TEST if r["channel"] != "حضوری"]


def accuracy(rows, says):
    return sum(says[r["ticket_id"]] == TRUTH[r["ticket_id"]] for r in rows) / len(rows)


print("ردیف‌های آموزشِ نسخهٔ ۱:", 800)
print("ردیف‌های آموزشِ نسخهٔ ۲:", len(FRESH),
      "· کانالِ حضوری در آن:", sum(r["channel"] == "حضوری" for r in FRESH))
print(f"{'':<10}{'کلِ آزمون':>12}{'حضوری':>10}{'بقیه':>10}")
print(f"{'نسخهٔ ۱':<10}{accuracy(TEST, A_SAYS):>12.4f}{accuracy(SUB, A_SAYS):>10.4f}"
      f"{accuracy(REST, A_SAYS):>10.4f}")
print(f"{'نسخهٔ ۲':<10}{accuracy(TEST, B_SAYS):>12.4f}{accuracy(SUB, B_SAYS):>10.4f}"
      f"{accuracy(REST, B_SAYS):>10.4f}")
```

```text
ردیف‌های آموزشِ نسخهٔ ۱: 800
ردیف‌های آموزشِ نسخهٔ ۲: 1039 · کانالِ حضوری در آن: 0
             کلِ آزمون     حضوری      بقیه
نسخهٔ ۱         0.8660    0.9259    0.8626
نسخهٔ ۲         0.8740    0.4074    0.9006
```

<div dir="rtl">

**ستونِ اول می‌گوید منتشرش کن. ستونِ دوم می‌گوید نکن.**

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

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

## ۲. جریانِ ترافیک، و تخصیصی که پایدار می‌ماند

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

</div>

```python
import subprocess
import sys

STREAM = random.Random(23).choices(TEST, k=4000)


def bucket(customer_id):
    """۰ تا ۹۹، پایدار در همهٔ فرآیندها و همهٔ ماشین‌ها."""
    return int(hashlib.sha256(customer_id.encode("utf-8")).hexdigest(), 16) % 100


CODE = ("import hashlib;"
        "print(hash('C-0001'),"
        " int(hashlib.sha256(b'C-0001').hexdigest(), 16) % 100)")
one = subprocess.run([sys.executable, "-c", CODE], capture_output=True,
                     text=True).stdout.split()
two = subprocess.run([sys.executable, "-c", CODE], capture_output=True,
                     text=True).stdout.split()
print("درخواست‌ها:", len(STREAM),
      "· از کانالِ حضوری:", sum(r["channel"] == "حضوری" for r in STREAM))
print("hash() در دو فرآیند یکی است؟", one[0] == two[0])
print("sha256 در دو فرآیند یکی است؟", one[1] == two[1])
print("نمونهٔ سطل‌ها:", [bucket(f"C-{i:04d}") for i in range(1, 6)])
```

```text
درخواست‌ها: 4000 · از کانالِ حضوری: 239
hash() در دو فرآیند یکی است؟ False
sha256 در دو فرآیند یکی است؟ True
نمونهٔ سطل‌ها: [25, 12, 12, 17, 17]
```

<div dir="rtl">

**`hash()` پایتون روی رشته در هر فرآیند جوابِ متفاوتی می‌دهد** — عمدی است و یک محافظتِ امنیتی. ولی اگر تخصیصِ ترافیک را رویش بنا کنی، **با هر ری‌استارتِ سرویس همهٔ کاربران بینِ دو نسخه جابه‌جا می‌شوند** و هیچ‌کدام از عددهایت معنا ندارند. `sha256` این مشکل را ندارد.

> ⚠️ **مواظب باش:** این باگ در توسعه **هرگز** خودش را نشان نمی‌دهد، چون تا وقتی فرآیند زنده است `hash()` ثابت است. فقط در تولید و فقط بعد از ری‌استارت پیدا می‌شود — و آن‌وقت به‌شکلِ «نتیجهٔ آزمایشمان بی‌ثبات است» دیده می‌شود، نه به‌شکلِ یک باگ.

## ۳. سایه: صد درصدِ نمونه، صفر ریسک

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

</div>

```python
def disagreement(rows):
    return sum(A_SAYS[r["ticket_id"]] != B_SAYS[r["ticket_id"]] for r in rows) / len(rows)


shadow_sub = [r for r in STREAM if r["channel"] == "حضوری"]
shadow_rest = [r for r in STREAM if r["channel"] != "حضوری"]
print("سایه — سرو با نسخهٔ ۱، نسخهٔ ۲ فقط تماشا می‌کند")
print(f"  اختلافِ جواب روی کلِ ترافیک: {100 * disagreement(STREAM):>5.1f}%"
      f"  ({len(STREAM)} نمونه)")
print(f"  اختلافِ جواب روی حضوری    : {100 * disagreement(shadow_sub):>5.1f}%"
      f"  ({len(shadow_sub)} نمونه)")
print(f"  اختلافِ جواب روی بقیه      : {100 * disagreement(shadow_rest):>5.1f}%"
      f"  ({len(shadow_rest)} نمونه)")
print("  کاربرانی که جوابِ بدتر گرفتند:", 0)
```

```text
سایه — سرو با نسخهٔ ۱، نسخهٔ ۲ فقط تماشا می‌کند
  اختلافِ جواب روی کلِ ترافیک:  10.4%  (4000 نمونه)
  اختلافِ جواب روی حضوری    :  59.0%  (239 نمونه)
  اختلافِ جواب روی بقیه      :   7.3%  (3761 نمونه)
  کاربرانی که جوابِ بدتر گرفتند: 0
```

<div dir="rtl">

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

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

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

**و رایگان نیست:** هر درخواست دو بار مدل را اجرا می‌کند، و اگر نسخهٔ ۲ عارضهٔ جانبی داشته باشد — نوشتن در پایگاه داده، فرستادن پیامک — باید مطمئن شوی که در حالتِ سایه خاموش است.

## ۴. قناری: کم‌ریسک، و کم‌نمونه

قناری پنج درصدِ کاربران را به نسخهٔ تازه می‌فرستد و یک **دروازه** روی متریک می‌گذارد. اگر دروازه تأیید کند، ترافیک صد درصد می‌شود.

**سؤالی که کمتر پرسیده می‌شود این است: کدام پنج درصد؟** بیست انتخابِ ممکن هست و ما هر بیست‌تا را اجرا می‌کنیم.

</div>

```python
WINDOW = 2000
MIN_SAMPLES = 30


def serve(row, arm):
    says = A_SAYS if arm == "A" else B_SAYS
    answer = says[row["ticket_id"]]
    wrong = answer != TRUTH[row["ticket_id"]]
    harmed = arm == "B" and wrong and A_SAYS[row["ticket_id"]] == TRUTH[row["ticket_id"]]
    return wrong, harmed


def canary(lo, promote):
    """۵ درصدِ مشتری‌ها به نسخهٔ ۲؛ اگر دروازه تأیید کند، بقیهٔ ترافیک هم می‌رود."""
    a_err = b_err = a_n = b_n = sub_n = harm = 0
    for i, row in enumerate(STREAM):
        in_cohort = lo <= bucket(row["customer_id"]) < lo + 5
        arm = ("B" if in_cohort else "A") if i < WINDOW else ("B" if promote else "A")
        wrong, harmed = serve(row, arm)
        harm += harmed
        if i < WINDOW:
            if arm == "B":
                b_n, b_err = b_n + 1, b_err + wrong
                sub_n += row["channel"] == "حضوری"
            else:
                a_n, a_err = a_n + 1, a_err + wrong
    return {"lo": lo, "b_n": b_n, "sub_n": sub_n, "harm": harm,
            "err_a": a_err / a_n, "err_b": b_err / b_n}


probes = [canary(lo, promote=False) for lo in range(0, 100, 5)]
stopped = [p for p in probes if p["err_b"] > p["err_a"] + 0.02]
passed = [p for p in probes if p["err_b"] <= p["err_a"] + 0.02]
print("۲۰ گروهِ قناریِ ممکن، هرکدام پنج درصدِ مشتری‌ها:")
print(f"  درخواستِ رسیده به نسخهٔ ۲ : کمینه {min(p['b_n'] for p in probes)}"
      f" · میانه {statistics.median(p['b_n'] for p in probes):.0f}"
      f" · بیشینه {max(p['b_n'] for p in probes)}")
print(f"  نمونهٔ کانالِ حضوری       : کمینه {min(p['sub_n'] for p in probes)}"
      f" · میانه {statistics.median(p['sub_n'] for p in probes):.0f}"
      f" · بیشینه {max(p['sub_n'] for p in probes)}"
      f"  (لازم برای تصمیم: {MIN_SAMPLES})")
print(f"  نرخِ خطای نسخهٔ ۲ در همین گروه‌ها: از {min(p['err_b'] for p in probes):.4f}"
      f" تا {max(p['err_b'] for p in probes):.4f}")
print(f"  دروازهٔ تجمیعی توقف داد در {len(stopped)} گروه از {len(probes)}")
```

```text
۲۰ گروهِ قناریِ ممکن، هرکدام پنج درصدِ مشتری‌ها:
  درخواستِ رسیده به نسخهٔ ۲ : کمینه 54 · میانه 106 · بیشینه 155
  نمونهٔ کانالِ حضوری       : کمینه 0 · میانه 6 · بیشینه 14  (لازم برای تصمیم: 30)
  نرخِ خطای نسخهٔ ۲ در همین گروه‌ها: از 0.0446 تا 0.2823
  دروازهٔ تجمیعی توقف داد در 7 گروه از 20
```

<div dir="rtl">

**سه عدد در این خروجی هست و هر سه ناراحت‌کننده‌اند.**

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

**۲)** نمونهٔ کانالِ حضوری در بهترین گروه ۱۴ تا بود و در سه گروه **صفر**. هیچ آزمونِ آماری با ۱۴ نمونه دربارهٔ تفاوتِ ۹۲ و ۴۱ درصد تصمیم قطعی نمی‌گیرد — و با صفر نمونه اصلاً نمی‌داند چنین کانالی وجود دارد.

**۳)** دروازهٔ تجمیعی در ۷ گروه از ۲۰ توقف داد. **یعنی در ۱۳ گروه، این مدل منتشر می‌شود.**

> ⚠️ **مواظب باش:** به `canary` دوباره نگاه کن. هم `bucket` و هم `if`ی که تصمیم می‌گیرد کدام نسخه جواب بدهد، **داخلِ همان حلقه‌ای نشسته‌اند که پیش‌بینی می‌کند**. اینجا برای خوانایی است؛ در تولید یک اشتباه. **در تولید این `if` جای دیگری است — جلوی سرویس، نه داخلش**: یک مسیریابِ ترافیک یا یک `feature flag` که سرویس فقط نتیجه‌اش را می‌خواند. **اگر داخلِ تابعِ پیش‌بینی بنشیند، برای عوض کردنِ درصدِ ترافیک باید مدل را دوباره مستقر کنی**، که دقیقاً همان چیزی است که انتشارِ تدریجی می‌خواست از آن فرار کند. همین حرف دربارهٔ سایه هم درست است: «نسخهٔ دوم را هم صدا بزن و جوابش را دور بریز» تصمیمِ مسیریاب است، نه تصمیمِ مدل.

## ۵. قیمتِ تأیید

</div>

```python
promoted = [canary(p["lo"], promote=True)["harm"] for p in passed]
print(f"در {len(passed)} گروهی که دروازهٔ تجمیعی تأیید کرد و ترافیک صد درصد شد:")
print(f"  کاربرانِ آسیب‌دیده — کمینه {min(promoted)} · میانه"
      f" {statistics.median(promoted):.0f} · بیشینه {max(promoted)}")
print(f"در {len(stopped)} گروهی که دروازه توقف داد:")
print(f"  کاربرانِ آسیب‌دیده — میانه {statistics.median([p['harm'] for p in stopped]):.0f}")
print("سهمِ حضوری در گروه‌های توقف‌دهنده:",
      round(statistics.mean(p["sub_n"] / p["b_n"] for p in stopped), 4))
print("سهمِ حضوری در گروه‌های تأییدکننده:",
      round(statistics.mean(p["sub_n"] / p["b_n"] for p in passed), 4))
print("سهمِ حضوری در کلِ ترافیک       :",
      round(sum(r["channel"] == "حضوری" for r in STREAM) / len(STREAM), 4))
```

```text
در 13 گروهی که دروازهٔ تجمیعی تأیید کرد و ترافیک صد درصد شد:
  کاربرانِ آسیب‌دیده — کمینه 81 · میانه 81 · بیشینه 93
در 7 گروهی که دروازه توقف داد:
  کاربرانِ آسیب‌دیده — میانه 7
سهمِ حضوری در گروه‌های توقف‌دهنده: 0.0767
سهمِ حضوری در گروه‌های تأییدکننده: 0.0572
سهمِ حضوری در کلِ ترافیک       : 0.0597
```

<div dir="rtl">

**۸۱ در برابرِ ۷.** «کاربرِ آسیب‌دیده» را دقیق تعریف کرده‌ایم: کسی که از نسخهٔ ۲ جوابِ غلط گرفت **در حالی که نسخهٔ ۱ همان تیکت را درست جواب می‌داد**. این با «خطای مدل» یکی نیست؛ این خطایی است که **انتشار** ساخته.

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

**و دروازهٔ زیرگروهی چه؟** با میانهٔ ۶ نمونه، جوابش «دادهٔ کافی نیست» است. **این یک شکست نیست، یک موفقیت است:** دروازه‌ای که وقتی نمی‌داند، «نمی‌دانم» بگوید و جلوی ارتقا را بگیرد، در هر بیست گروه می‌ایستد و میانهٔ آسیبش ۳٫۵ کاربر است به‌جای ۸۱ (بدترین گروه ۱۲ کاربر). **قاعده: هر دروازهٔ خودکار باید کمینهٔ نمونه داشته باشد، وگرنه دارد به نویز رأی می‌دهد.**

> 📏 **اندازه بگیر:** **با چه چیزی مقایسه شد؟** با همان دو مدل و همان ۴۰۰۰ درخواست؛ تنها متغیر استراتژیِ انتشار بود. **روی کدام داده؟** یک جریانِ یکسان برای هر سه استراتژی، ساخته‌شده با `Random(23)`. **با چند `seed`؟** **بیست** — و این همان کاری است که فصلِ ۵ ترمِ ۳ اسمش را «چند `seed`» گذاشت. اگر فقط یک گروهِ قناری را امتحان می‌کردیم، به نتیجهٔ کاملاً وارونه می‌رسیدیم: **گروهِ اول توقف داد و ما خوشحال می‌شدیم که قناری کار می‌کند.** یک اجرا از یک سامانهٔ تصادفی یک نتیجه نیست، یک قرعه است.

## ۶. `A/B`: نمونه دارد، ولی کاربر می‌سوزاند

</div>

```python
def ab_test(share=50):
    arms, harm = {"A": [], "B": []}, 0
    for row in STREAM:
        arm = "B" if bucket(row["customer_id"]) < share else "A"
        wrong, harmed = serve(row, arm)
        harm += harmed
        arms[arm].append((row["channel"], wrong))
    return arms, harm


def rate(records, channel=None):
    picked = [w for c, w in records if channel is None or c == channel]
    return (sum(picked) / len(picked), len(picked)) if picked else (float("nan"), 0)


arms, ab_harm = ab_test()
for name in ("A", "B"):
    overall, n = rate(arms[name])
    sub, n_sub = rate(arms[name], "حضوری")
    print(f"نسخهٔ {'۱' if name == 'A' else '۲'}: نرخِ خطای کل {overall:.4f} ({n} نمونه)"
          f" · روی حضوری {sub:.4f} ({n_sub} نمونه)")
print("کاربرانِ آسیب‌دیده در کلِ آزمون:", ab_harm)
```

```text
نسخهٔ ۱: نرخِ خطای کل 0.1349 (2024 نمونه) · روی حضوری 0.0758 (132 نمونه)
نسخهٔ ۲: نرخِ خطای کل 0.1361 (1976 نمونه) · روی حضوری 0.5514 (107 نمونه)
کاربرانِ آسیب‌دیده در کلِ آزمون: 75
```

<div dir="rtl">

**نرخِ خطای کل: ۰٫۱۳۴۹ در برابرِ ۰٫۱۳۶۱. تفاوت کمتر از دو هزارم — یعنی هیچ.**

با ۲۰۰۰ نمونه در هر بازو این دیگر نویز نیست؛ **متریکِ تجمیعی واقعاً چیزی برای گفتن ندارد.** و در همان اجرا، روی همان داده، خطای کانالِ حضوری از ۰٫۰۷۵۸ به ۰٫۵۵۱۴ رفته و این بار **۱۰۷ نمونه** پشتش هست.

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

**ولی `A/B` رایگان نبود: ۷۵ کاربر جوابِ بدتر گرفتند** تا این جدول ساخته شود.

## ۷. یک جدول، سه معامله

</div>

```python
FINAL = [
    ("سایه", "0%", len(shadow_sub), "بله", 0),
    ("قناری + متریکِ تجمیعی", "5% سپس 100%",
     int(statistics.median(p["sub_n"] for p in probes)),
     f"{len(stopped)} از {len(probes)} گروه", int(statistics.median(promoted))),
    ("قناری + کمینهٔ نمونه", "5%",
     int(statistics.median(p["sub_n"] for p in probes)), "دادهٔ کافی نیست",
     statistics.median(p["harm"] for p in probes)),
    ("A/B پنجاه-پنجاه", "50%", rate(arms["B"], "حضوری")[1], "بله", ab_harm),
]
print(f"{'استراتژی':<24}{'ترافیکِ نسخهٔ ۲':>16}{'نمونهٔ حضوری':>14}"
      f"{'کشف':>18}{'آسیب‌دیده':>12}")
for name, share, n, caught, harm in FINAL:
    print(f"{name:<24}{share:>16}{n:>14}{caught:>18}{harm:>12}")
```

```text
استراتژی                 ترافیکِ نسخهٔ ۲  نمونهٔ حضوری               کشف   آسیب‌دیده
سایه                                  0%           239               بله           0
قناری + متریکِ تجمیعی        5% سپس 100%             6      7 از 20 گروه          81
قناری + کمینهٔ نمونه                  5%             6   دادهٔ کافی نیست         3.5
A/B پنجاه-پنجاه                      50%           107               بله          75
```

<div dir="rtl">

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

**دستورِ عملی که از این جدول درمی‌آید:**

- **۱)** اول **سایه**، همیشه. صد درصدِ نمونه، صفر ریسک، و بدونِ نیاز به برچسب.
- **۲)** بعد **قناری**، ولی با دو شرط: **کمینهٔ نمونه** برای هر دروازه، و متریک **به تفکیکِ زیرگروه‌های شناخته‌شده** — کانال، زبان، طولِ ورودی، مشتریِ سازمانی.
- **۳)** `A/B` را برای سؤالی نگه دار که سایه جوابش را نمی‌دهد: **«کدام بهتر است؟»**، نه «آیا خراب است؟».
- **۴)** و همیشه **دکمهٔ برگشت** آماده باشد؛ فصلِ ۹ همین را می‌سازد.

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

> 🔧 **اگر کار نکرد:** اگر عددهای بخشِ ۴ روی ماشینِ تو با کتاب یکی درنیامد، اولین چیزی که باید ببینی `bucket` است. اگر جایی به‌جای `sha256` از `hash()` استفاده کرده باشی، هر اجرا تخصیصِ متفاوتی می‌سازد. و اگر خطای `KeyError` روی `ticket_id` گرفتی، جریان را از `TEST` نساخته‌ای؛ `A_SAYS` فقط تیکت‌های مجموعهٔ آزمون را می‌شناسد.

> 🤖 **از دستیارت بپرس:** «`feature flag` چیست و چه فرقی با انتشارِ تدریجیِ یک نسخهٔ تازه دارد؟» بعد این را بپرس: **«اگر بخواهم روی هر زیرگروه یک دروازه بگذارم و ده زیرگروه داشته باشم، مسئلهٔ مقایسهٔ چندگانه چه بلایی سرِ نرخِ هشدارِ کاذبم می‌آورد؟»** — این همان دامِ فصلِ ۵ ترمِ ۳ است، این بار در تولید.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| shadow deployment | شدو دیپلویمنت | اجرای نسخهٔ تازه روی ترافیکِ واقعی، بدونِ رساندنِ جوابش به کاربر |
| canary release | کاناری ریلیز | فرستادنِ سهمِ کوچکی از ترافیک به نسخهٔ تازه |
| A/B test | ای‌بی تست | تقسیمِ ترافیک بینِ دو نسخه برای مقایسهٔ آماری |
| blast radius | بلست ریدیس | تعدادِ کاربرانی که یک انتشارِ بد می‌تواند آسیبشان بزند |
| sticky assignment | استیکی اساینمنت | تخصیصی که به کاربر می‌چسبد و عوض نمی‌شود |
| guardrail metric | گاردریل متریک | متریکی که اگر بدتر شود، انتشار خودبه‌خود متوقف می‌شود |
| subgroup regression | ساب‌گروپ ریگرشن | بدتر شدنِ مدل روی بخشی از داده، در حالی که میانگین بهتر شده |

<div dir="rtl">

## تمرین‌ها

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

**تمرینِ اجباری:** درصدِ قناری را ۵، ۱۰، ۲۵ و ۵۰ بگذار و برای هرکدام روی **همهٔ** گروه‌های ممکن **سه عدد** بده: میانهٔ نمونهٔ کانالِ حضوری، تعدادِ گروه‌هایی که دروازهٔ تجمیعی توقف می‌دهد، و میانهٔ کاربرانِ آسیب‌دیده. **نموداری از این دو ستونِ آخر بکش و جواب بده: آیا نقطه‌ای هست که هم نمونهٔ کافی بدهد و هم آسیب را کم نگه دارد؟** جوابت هرچه بود، **همان دلیلِ وجودِ سایه است**.

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

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t4/s06-progressive-release (یادستان, Yaadestan)
