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

فصل ۶ از ۹

پیشرفت ترم
۰٪

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

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

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

سه چیدمانِ آزمایشِ متفاوت روی یک خطِ انتقال

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

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

قبل از شروع#

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

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

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

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

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

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

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

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}")
ردیف‌های آموزشِ نسخهٔ ۱: 800
ردیف‌های آموزشِ نسخهٔ ۲: 1039 · کانالِ حضوری در آن: 0
             کلِ آزمون     حضوری      بقیه
نسخهٔ ۱         0.8660    0.9259    0.8626
نسخهٔ ۲         0.8740    0.4074    0.9006

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

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

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

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

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

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)])
درخواست‌ها: 4000 · از کانالِ حضوری: 239
hash() در دو فرآیند یکی است؟ False
sha256 در دو فرآیند یکی است؟ True
نمونهٔ سطل‌ها: [25, 12, 12, 17, 17]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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))
در 13 گروهی که دروازهٔ تجمیعی تأیید کرد و ترافیک صد درصد شد:
  کاربرانِ آسیب‌دیده — کمینه 81 · میانه 81 · بیشینه 93
در 7 گروهی که دروازه توقف داد:
  کاربرانِ آسیب‌دیده — میانه 7
سهمِ حضوری در گروه‌های توقف‌دهنده: 0.0767
سهمِ حضوری در گروه‌های تأییدکننده: 0.0572
سهمِ حضوری در کلِ ترافیک       : 0.0597

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

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

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

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

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

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)
نسخهٔ ۱: نرخِ خطای کل 0.1349 (2024 نمونه) · روی حضوری 0.0758 (132 نمونه)
نسخهٔ ۲: نرخِ خطای کل 0.1361 (1976 نمونه) · روی حضوری 0.5514 (107 نمونه)
کاربرانِ آسیب‌دیده در کلِ آزمون: 75

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

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

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

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

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

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

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

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

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

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

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

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

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

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

تمرین‌ها

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

در فصل بعد#

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

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

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