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

فصل ۷ از ۸

پیشرفت ترم
۰٪

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

دو مدل داریم. آفلاین، روی تقسیمِ تصادفی، مدلِ الف با اختلافِ روشن جلوتر است: ۰٫۵۹۳۸ در برابرِ ۰٫۵۲۲۱، و دامنه‌هایشان روی هم نمی‌افتند. هر جدولِ مقایسه‌ای که تا حالا در این ترم ساختیم، الف را برنده اعلام می‌کند.

بعد همان دو مدل را روی چیزی می‌سنجیم که واقعاً برایمان مهم است: بُرشِ زمانیِ بعدیِ همان داده — یعنی شبیه‌سازیِ استقرار.

الف به ۰٫۲۲۷۱ می‌افتد و ب به ۰٫۴۲۵۱ می‌رسد. رتبه‌بندی کاملاً وارونه شد، و باز هم هیچ دامنه‌ای هم‌پوشانی ندارد.

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

یک دوربینِ عکاسی که به عکسِ دیروزِ خیابان نگاه می‌کند در حالی که خیابان عوض شده

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

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

قبل از شروع#

از فصلِ ۵ و ۶: مقایسهٔ صادقانه با چند seed و دامنه، و مدلی که در رجیستری به تولید رفت.

از ترمِ ۲: تقسیمِ گروهی، و اینکه هر تقسیمی یک سؤال را جواب می‌دهد. تقسیمِ تصادفی می‌پرسد «برای تیکتی شبیهِ تیکت‌های گذشته چقدر خوبی؟» — و ما این را نمی‌خواهیم بدانیم.

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

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

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

۱. دو مدل، و یک مرزِ زمانی#

import statistics

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression

ALPHA = {"features": "meta", "balance": "oversample"}     # از فراداده: مشتری، کانال، دسته
BETA = {"features": "text", "balance": "oversample"}      # از متنِ تیکت


def fit_eval(cfg, tr, te):
    """آموزش روی ردیف‌های tr، ارزیابی روی te — تقسیم را از بیرون می‌گیرد."""
    cfg = DEFAULTS | cfg
    texts = texts_for(cfg)
    if cfg["balance"] == "oversample":
        tr = oversample(tr, cfg["seed"])
    vec = CountVectorizer(min_df=cfg["min_df"], ngram_range=(1, cfg["ngram"]))
    model = LogisticRegression(max_iter=2000, C=cfg["C"], random_state=cfg["seed"])
    model.fit(vec.fit_transform([texts[i] for i in tr]), [Y[i] for i in tr])
    pred = model.predict(vec.transform([texts[i] for i in te]))
    gold = [Y[i] for i in te]
    tp = sum(1 for p, g in zip(pred, gold) if p == 1 and g == 1)
    fp = sum(1 for p, g in zip(pred, gold) if p == 1 and g == 0)
    fn = sum(1 for p, g in zip(pred, gold) if p == 0 and g == 1)
    f1 = 2 * tp / (2 * tp + fp + fn) if tp else 0.0
    return {"f1": f1, "tp": tp, "fp": fp, "fn": fn, "n": len(te)}


CUT = int(0.75 * len(Y))
print("مرزِ زمانی:", T[CUT][:10])
print("گذشته:", CUT, "ردیف · آینده:", len(Y) - CUT, "ردیف")
print("نرخِ تشدید — گذشته:", round(sum(Y[:CUT]) / CUT, 3),
      "· آینده:", round(sum(Y[CUT:]) / (len(Y) - CUT), 3))
مرزِ زمانی: 2031-07-05
گذشته: 1195 ردیف · آینده: 399 ردیف
نرخِ تشدید — گذشته: 0.284 · آینده: 0.263

نرخِ تشدید تقریباً ثابت مانده — ۰٫۲۸۴ در برابرِ ۰٫۲۶۳ — و این را یادت باشد: رانشی که این فصل نشانش می‌دهد، در هیچ آمارِ خلاصهٔ سادهٔ برچسب دیده نمی‌شود.

دو مدل هم عمداً هم‌پوشانی ندارند: الف فقط فراداده می‌بیند (کدام مشتری، کدام کانال، کدام دسته) و ب فقط متنِ تیکت. این انتخابِ واقعیِ هر تیمی است: «از تاریخچهٔ مشتری استفاده کنیم یا از حرفی که زده؟»

۲. مقایسهٔ آفلاین، بعد مقایسهٔ واقعی#

SEEDS = range(5)


def offline(cfg):
    out = []
    for s in SEEDS:
        tr, te = random_split(len(Y), s)
        out.append(fit_eval(cfg | {"seed": s}, tr, te)["f1"])
    return out


def online(cfg):
    tr, te = list(range(CUT)), list(range(CUT, len(Y)))
    return [fit_eval(cfg | {"seed": s}, tr, te)["f1"] for s in SEEDS]


rows = []
for name, cfg in (("الف — فراداده", ALPHA), ("ب — متن", BETA)):
    off, on = offline(cfg), online(cfg)
    rows.append((name, off, on))
print(f"  {'مدل':<16}{'آفلاین':>9}{'دامنه':>17}{'روی آینده':>11}{'دامنه':>17}")
for name, off, on in rows:
    print(f"  {name:<16}{statistics.mean(off):>9.4f}"
          f"   [{min(off):.3f}–{max(off):.3f}]{statistics.mean(on):>11.4f}"
          f"   [{min(on):.3f}–{max(on):.3f}]")
  مدل                آفلاین            دامنه  روی آینده            دامنه
  الف — فراداده      0.5938   [0.569–0.632]     0.2271   [0.216–0.239]
  ب — متن            0.5221   [0.510–0.547]     0.4251   [0.389–0.459]

این چهار عدد کلِ فصل‌اند.

آفلاین ۰٫۵۶۹ تا ۰٫۶۳۲ در برابرِ ۰٫۵۱۰ تا ۰٫۵۴۷، و روی آینده ۰٫۲۱۶ تا ۰٫۲۳۹ در برابرِ ۰٫۳۸۹ تا ۰٫۴۵۹. هیچ‌کدام از این دو جفت دامنه روی هم نمی‌افتند، پس با معیارِ فصلِ ۵ هر دو برتری واقعی‌اند — و دو برتریِ متضاد.

(_, off_a, on_a), (_, off_b, on_b) = rows
print(f"آفلاین: الف منهای ب = {statistics.mean(off_a) - statistics.mean(off_b):+.4f}")
print(f"آینده : الف منهای ب = {statistics.mean(on_a) - statistics.mean(on_b):+.4f}")
print(f"شکافِ الف (آفلاین منهای آینده): {statistics.mean(off_a) - statistics.mean(on_a):+.4f}")
print(f"شکافِ ب  (آفلاین منهای آینده): {statistics.mean(off_b) - statistics.mean(on_b):+.4f}")
آفلاین: الف منهای ب = +0.0717
آینده : الف منهای ب = -0.1979
شکافِ الف (آفلاین منهای آینده): +0.3666
شکافِ ب  (آفلاین منهای آینده): +0.0970

دو خطِ آخر مهم‌ترند از دو خطِ اول. اگر ارزیابیِ آفلاین فقط «خوش‌بین» بود — یعنی همه را به‌یک‌اندازه بالا می‌برد — مقایسه‌اش هنوز درست بود. ولی شکافِ الف ۰٫۳۶۶ است و شکافِ ب ۰٫۰۹۷: تقریباً چهار برابر.

پس ارزیابیِ آفلاین یک عدسیِ کدر نیست که همه‌چیز را یکنواخت تیره کند؛ یک عدسیِ کج است. و کجی است که رتبه‌بندی را وارونه می‌کند، نه کدری.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ هر مدل با رقیبش، و هر ارزیابی با ارزیابیِ دیگرِ همان مدل. روی کدام داده؟ یک بار روی ۲۵٪ تصادفیِ کلِ هشت ماه، یک بار روی ۳۹۹ ردیفِ آخر — که هیچ‌کدامشان در آموزش نبودند و همه‌شان بعد از آموزش اتفاق افتاده‌اند. با چند seed؟ پنج‌تا. در ستونِ «آینده» seed فقط ترتیبِ فرانمونه را عوض می‌کند، چون تقسیم ثابت است — پس این دامنه فقط نوسانِ فرانمونه را نشان می‌دهد، نه نوسانِ انتخابِ داده. برای الف باریک‌تر از دامنهٔ آفلاین است و برای ب پهن‌تر، و هیچ‌کدام معنای مطمئن‌تر بودن ندارد.

۳. حالا علتش را در داده پیدا کن#

اگر نتوانی بگویی چرا، فردا دوباره غافلگیر می‌شوی.

from collections import Counter

past_customers = set(G[:CUT])
past_words = {w for i in range(CUT) for w in X[i].split()}
unseen_rows = sum(1 for i in range(CUT, len(Y)) if G[i] not in past_customers)
new_word_rows = sum(1 for i in range(CUT, len(Y))
                    if any(w not in past_words for w in X[i].split()))
late = len(Y) - CUT
print(f"ردیف‌های آینده از مشتریِ دیده‌نشده : {unseen_rows} از {late}"
      f" ({100 * unseen_rows / late:.1f}٪)")
print(f"ردیف‌های آینده با واژهٔ دیده‌نشده  : {new_word_rows} از {late}"
      f" ({100 * new_word_rows / late:.1f}٪)")

heavy = {g for g, n in Counter(G[:CUT]).items() if n >= 20}
h_past = [i for i in range(CUT) if G[i] in heavy]
h_late = [i for i in range(CUT, len(Y)) if G[i] in heavy]
print(f"مشتری‌هایی که در گذشته ۲۰ تیکت یا بیشتر داشتند: {len(heavy)} نفر")
print(f"  نرخِ تشدیدشان در گذشته: {sum(Y[i] for i in h_past) / len(h_past):.3f}"
      f"  ({len(h_past)} ردیف)")
print(f"  نرخِ تشدیدشان در آینده: {sum(Y[i] for i in h_late) / len(h_late):.3f}"
      f"  ({len(h_late)} ردیف)")
ردیف‌های آینده از مشتریِ دیده‌نشده : 117 از 399 (29.3٪)
ردیف‌های آینده با واژهٔ دیده‌نشده  : 58 از 399 (14.5٪)
مشتری‌هایی که در گذشته ۲۰ تیکت یا بیشتر داشتند: 18 نفر
  نرخِ تشدیدشان در گذشته: 0.461  (588 ردیف)
  نرخِ تشدیدشان در آینده: 0.295  (129 ردیف)

سه عدد، سه نوع رانشِ متفاوت:

  • ۲۹٫۳٪ از تیکت‌های آینده از مشتری‌هایی‌اند که مدل هرگز ندیده. برای مدلِ الف که کلِ دانشش «کدام مشتری» است، این ردیف‌ها بی‌ویژگی می‌رسند.
  • ۱۴٫۵٪ واژه‌ای دارند که در گذشته وجود نداشت. این هزینهٔ ب است، و کوچک‌تر است.
  • و مهم‌ترینش: همان ۱۸ مشتریِ پرتیکت که در گذشته ۴۶٪ تشدید داشتند، در آینده ۲۹٫۵٪ دارند. یعنی رفتارشان عوض شده، نه اینکه ناپدید شده باشند.

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

۴. کِی شکست؟#

میانگینِ کلِ آینده یک عدد است و نمی‌گوید کِی. بُرش‌بندی می‌گوید:

BLOCKS = 4
edges = [int(len(Y) * (0.5 + 0.5 * b / BLOCKS)) for b in range(BLOCKS + 1)]
print(f"  {'بازه':<22}{'ردیف':>6}{'نرخِ تشدید':>12}{'الف':>9}{'ب':>9}")
for b in range(BLOCKS):
    lo, hi = edges[b], edges[b + 1]
    te = list(range(lo, hi))
    tr = list(range(lo))
    fa = statistics.mean([fit_eval(ALPHA | {"seed": s}, tr, te)["f1"] for s in range(3)])
    fb = statistics.mean([fit_eval(BETA | {"seed": s}, tr, te)["f1"] for s in range(3)])
    rate = sum(Y[i] for i in te) / len(te)
    print(f"  {T[lo][:10]} تا {T[hi - 1][:10]}{len(te):>6}{rate:>12.3f}{fa:>9.4f}{fb:>9.4f}")
  بازه                    ردیف  نرخِ تشدید      الف        ب
  2031-05-03 تا 2031-06-01   199       0.251   0.7815   0.4454
  2031-06-01 تا 2031-07-05   199       0.276   0.5921   0.4851
  2031-07-05 تا 2031-08-02   199       0.256   0.1752   0.3691
  2031-08-02 تا 2031-09-02   200       0.270   0.3217   0.5435

هر ردیف یک استقرارِ شبیه‌سازی‌شده است: آموزش روی همهٔ گذشته، ارزیابی روی ماهِ بعد.

مدلِ الف در ماهِ اول ۰٫۷۸۱۵ می‌دهد و در ماهِ سوم ۰٫۱۷۵۲. این سقوط جایی بینِ اول ژوئن و پنجم ژوئیه اتفاق افتاده و کاملاً مشخص است.

و ستونِ «نرخِ تشدید» چیزی نمی‌گوید: ۰٫۲۵۱، ۰٫۲۷۶، ۰٫۲۵۶، ۰٫۲۷۰. اگر تنها چیزی که پایش می‌کردی نرخِ برچسب بود، هیچ‌وقت نمی‌فهمیدی که مدلت از کار افتاده.

مدلِ ب هم تکان خورد (۰٫۴۸۵ به ۰٫۳۶۹) ولی برگشت — چون واژه‌های تازه کم‌کم وارد دادهٔ آموزشش شدند. این تفاوتِ یک مدلِ آسیب‌دیده با یک مدلِ منسوخ است.

✅ چک کن: همان جدول را با ALPHA که features اش را به "text+meta" عوض کرده‌ای بگیر. آیا مدلی که هم متن و هم فراداده می‌بیند از هر دو بهتر است؟ جوابش برایت غافلگیرکننده خواهد بود، و به همان درسِ ترمِ ۲ برمی‌گردد: ویژگی‌ای که در آزمون کمک می‌کند، همان ویژگی‌ای نیست که در تولید کمک می‌کند.

۵. متریکِ آفلاین معیارِ جانشین است#

F1 هیچ‌وقت آن چیزی نبوده که برایت مهم است. چیزی که مهم است این است: چند تشدید را از دست دادیم و چقدر بی‌خود آدم را دواندیم. آن دو هزینهٔ برابری ندارند.

MISS, ALARM = 5, 1


def cost(cfg, tr, te, seeds=SEEDS):
    per = []
    for s in seeds:
        r = fit_eval(cfg | {"seed": s}, tr, te)
        per.append(100 * (MISS * r["fn"] + ALARM * r["fp"]) / r["n"])
    return statistics.mean(per)


tr_t, te_t = list(range(CUT)), list(range(CUT, len(Y)))
always = 100 * ALARM * sum(1 for i in te_t if Y[i] == 0) / len(te_t)
never = 100 * MISS * sum(Y[i] for i in te_t) / len(te_t)
print("هزینه به ازای هر ۱۰۰ تیکتِ آینده (نادیده گرفتن ۵، هشدارِ بی‌جا ۱):")
print(f"  همیشه هشدار بده : {always:>7.1f}")
print(f"  هیچ‌وقت هشدار نده: {never:>7.1f}")
print(f"  مدلِ الف         : {cost(ALPHA, tr_t, te_t):>7.1f}")
print(f"  مدلِ ب           : {cost(BETA, tr_t, te_t):>7.1f}")
هزینه به ازای هر ۱۰۰ تیکتِ آینده (نادیده گرفتن ۵، هشدارِ بی‌جا ۱):
  همیشه هشدار بده :    73.7
  هیچ‌وقت هشدار نده:   131.6
  مدلِ الف         :   120.9
  مدلِ ب           :    86.6

مدلِ الف با هزینهٔ ۱۲۰٫۹ از «همیشه هشدار بده» با هزینهٔ ۷۳٫۷ بدتر است — یعنی یک قاعدهٔ یک‌خطی که هیچ آموزشی لازم ندارد از آن بهتر عمل می‌کند. مدلِ ب با ۸۶٫۶ هم از آن قاعده بهتر نیست، فقط نزدیک‌تر است.

و حالا همان محاسبه، روی تقسیمِ تصادفیِ آفلاین:

tr_o, te_o = random_split(len(Y), 0)
always_o = 100 * ALARM * sum(1 for i in te_o if Y[i] == 0) / len(te_o)
print("همان هزینه، ولی روی تقسیمِ تصادفیِ آفلاین:")
print(f"  همیشه هشدار بده : {always_o:>7.1f}")
print(f"  مدلِ الف         : {cost(ALPHA, tr_o, te_o, seeds=[0]):>7.1f}")
print(f"  مدلِ ب           : {cost(BETA, tr_o, te_o, seeds=[0]):>7.1f}")
همان هزینه، ولی روی تقسیمِ تصادفیِ آفلاین:
  همیشه هشدار بده :    71.6
  مدلِ الف         :    72.4
  مدلِ ب           :    74.1

آفلاین، الف (۷۲٫۴) از ب (۷۴٫۱) ارزان‌تر است — دوباره برعکسِ آینده.

و یک چیزِ ناخوشایندِ دیگر: آفلاین هم هیچ‌کدام از دو مدل از «همیشه هشدار بده» (۷۱٫۶) ارزان‌تر نیستند. این را با نگاه کردن به F1 هرگز نمی‌فهمیدی، چون F1 خطِ پایه ندارد — یک عددِ بینِ صفر و یک است و ۰٫۵۹ «متوسط» به‌نظر می‌رسد.

پس معیارِ جانشین دو راه برای دروغ گفتن دارد، و در این فصل هر دو را دیدیم:

  • ۱) روی دادهٔ اشتباه سنجیده شود (تقسیمِ تصادفی به‌جای بُرشِ زمانی) — که رتبه‌بندی را وارونه کرد.
  • ۲) چیزِ اشتباهی را بسنجد (F1 به‌جای هزینه) — که خطِ پایهٔ بی‌مدل را پنهان کرد.

🔧 اگر کار نکرد: اگر fit_eval با ZeroDivisionError یا با f1 برابرِ صفر برگشت، یعنی مدل در آن بُرش هیچ ردیفی را مثبت پیش‌بینی نکرده — که با بُرش‌های کوچک و کلاسِ کم‌شمار کاملاً ممکن است. به همین دلیل در fit_eval نوشتیم if tp else 0.0 و نه یک تقسیمِ ساده. ولی صفر گرفتن اینجا یک باگ نیست، یک نتیجه است: مدلی که در یک ماه هیچ هشداری نمی‌دهد، در آن ماه وجود ندارد. اگر این را به‌عنوان خطا بگیری و رد شوی، بدترین ماه‌های مدلت را از گزارش حذف کرده‌ای.

🤖 از دستیارت بپرس: «تفاوتِ data drift و concept drift چیست و کدام‌یک در این فصل اتفاق افتاد؟» بعد این را هم بپرس: «چه چیزهایی را می‌شود پایش کرد که رانش را قبل از افتِ متریک نشان بدهند؟» — جوابِ دوم مهم است چون در تولید برچسب با تأخیر می‌رسد یا اصلاً نمی‌رسد، و آن‌وقت جدولِ بخشِ ۴ را ماه‌ها بعد می‌توانی بسازی.

۶. پس چه کار باید کرد#

  • ۱) همیشه یک مجموعهٔ آزمونِ زمانی نگه دار. تقسیمِ تصادفی برای انتخابِ ابرپارامتر خوب است، برای تصمیمِ استقرار نه.
  • ۲) شکاف را برای هر نامزد جداگانه گزارش کن، نه یک عددِ کلی. آن ۰٫۳۶۶ در برابرِ ۰٫۰۹۷ می‌گوید کدام مدل شکننده است.
  • ۳) کنارِ متریک، خطِ پایهٔ بی‌مدل را هم بگذار. «همیشه بله» و «همیشه نه» در پنج ثانیه حساب می‌شوند.
  • ۴) متریک را به هزینه ترجمه کن، حتی با عددهای تقریبی. «نادیده گرفتن پنج برابرِ هشدارِ بی‌جا می‌ارزد» یک حدس است، ولی حدسی که می‌شود سرش بحث کرد — برخلافِ F1 که همان حدس را با وزنِ برابر پنهان کرده.

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

کلمه تلفظ به حروف فارسی یعنی چه
offline evaluation آفلاین اِوَلیوایشن سنجشِ مدل روی دادهٔ تاریخیِ کنارگذاشته
temporal split تمپورال اسپلیت تقسیم بر اساسِ زمان: گذشته آموزش، آینده آزمون
distribution shift دیستریبیوشن شیفت فرقِ توزیعِ دادهٔ تولید با دادهٔ آموزش
surrogate metric سروگیت متریک متریکی که به‌جای چیزِ واقعاً مهم سنجیده می‌شود
cost matrix کاست ماتریکس وزنِ متفاوتِ انواعِ خطا
rolling evaluation رولینگ اِوَلیوایشن ارزیابیِ پیاپی روی بُرش‌های زمانیِ متوالی

تمرین‌ها

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

در فصل بعد#

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

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

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