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

فصل ۴ از ۸

پیشرفت ترم
۰٪

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

فضای پیکربندیِ ما ۴۳۲ حالت دارد و همه‌شان را می‌زنیم — عمداً، تا برای یک بار بدانیم سقف کجاست. سقف F1 برابرِ ۰٫۷۱۲۶ است.

بعد وانمود می‌کنیم فقط ۲۴ اجرا بودجه داریم، و دو استراتژی را با همان بودجه مقایسه می‌کنیم:

  • شبکهٔ درشتِ بریده‌شده به ۰٫۶۱۲۴ می‌رسد.
  • جست‌وجوی تصادفی به‌طورِ متوسط به ۰٫۶۹۴۹ می‌رسد — ۹۷٫۵٪ سقف — و در ۴۰ بار از ۴۰ بار از شبکه جلو می‌زند.

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

یک نقشهٔ سوراخ‌دار که یک شبکهٔ منظم و یک الگوی پراکنده رویش افتاده

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

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

قبل از شروع#

از فصلِ ۱ و ۲: run(cfg)، DEFAULTS، و اینکه نوسانِ seed روی این پیکره حدودِ ۰٫۰۳۷ است. آن عدد در بخشِ ۶ دوباره مهم می‌شود.

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

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

۱. اول اندازهٔ فضا را حساب کن#

import itertools

SPACE = {
    "features": ["text", "meta", "text+meta"],
    "balance": ["none", "oversample", "weight"],
    "ngram": [1, 2],
    "min_df": [1, 2, 3, 5],
    "C": [0.03, 0.1, 0.3, 1.0, 3.0, 10.0],
}
KEYS = list(SPACE)
GRID = [dict(zip(KEYS, values)) for values in itertools.product(*SPACE.values())]
sizes = " × ".join(str(len(v)) for v in SPACE.values())
print("اندازهٔ فضا:", sizes, "=", len(GRID), "پیکربندی")
print("با پنج seed برای هرکدام:", len(GRID) * 5, "اجرا")
اندازهٔ فضا: 3 × 3 × 2 × 4 × 6 = 432 پیکربندی
با پنج seed برای هرکدام: 2160 اجرا

این ضرب را قبل از هر جست‌وجویی بزن. پنج محورِ کوچک — که هیچ‌کدام‌شان زیاده‌روی به‌نظر نمی‌رسند — ۴۳۲ حالت ساختند، و چون فصلِ ۱ ثابت کرد یک seed کافی نیست، عددِ واقعی ۲۱۶۰ است.

اضافه کردنِ یک محورِ دو مقداری این عدد را دو برابر می‌کند. به همین دلیل «بیا این را هم امتحان کنیم» جملهٔ ارزانی نیست.

🌱 ریشه‌اش کجاست: آن ضربِ ۳ × ۳ × ۲ × ۴ × ۶ یک اسم دارد و در ریشه، ترم ۶ فصل ۱ — شمردن، قبل از احتمال ساخته می‌شود: «اگر کاری در چند مرحله انجام شود و هر مرحله تعدادِ مشخصی حالت داشته باشد، تعدادِ کلِ حالت‌ها حاصل‌ضربِ آن‌هاست.» همان‌جا این نکته هم هست که وقتی همهٔ مراحل تعدادِ حالتِ یکسانی دارند، اصلِ ضرب به توان تبدیل می‌شود — و دقیقاً به همین دلیل است که فضای جست‌وجو با افزودنِ هر محور ضرب می‌شود، نه جمع. هر جا شبکه‌ای می‌سازی، این ضرب را قبل از زدنِ دکمهٔ اجرا بزن.

۲. کلِ شبکه — این یک بار#

import time

t0 = time.time()
TABLE = {}
for cfg in GRID:
    TABLE[tuple(cfg[k] for k in KEYS)] = run(cfg)["f1"]
ELAPSED = time.time() - t0

BEST_KEY = max(TABLE, key=TABLE.get)
print("بهترینِ کلِ شبکه:", round(TABLE[BEST_KEY], 4))
print("پیکربندی‌اش    :", dict(zip(KEYS, BEST_KEY)))
بهترینِ کلِ شبکه: 0.7126
پیکربندی‌اش    : {'features': 'text+meta', 'balance': 'weight', 'ngram': 1, 'min_df': 1, 'C': 1.0}
print(f"زمانِ کلِ شبکه: {ELAPSED:.0f} ثانیه · هر اجرا {ELAPSED / len(GRID):.3f} ثانیه")
print(f"همین شبکه با پنج seed: {5 * ELAPSED / 60:.1f} دقیقه")
زمانِ کلِ شبکه: 21 ثانیه · هر اجرا 0.048 ثانیه
همین شبکه با پنج seed: 1.7 دقیقه

۰٫۷۱۲۶ سقفِ این فضاست و از این به بعد معیارِ همه‌چیز است. در یک پروژهٔ واقعی این عدد را نداری — و کلِ سختیِ کار همین است. اینجا داریمش چون مدلمان کوچک است، و همین به ما اجازه می‌دهد کیفیتِ استراتژی‌های جست‌وجو را واقعاً بسنجیم به‌جای اینکه دربارهٔ‌شان حرف بزنیم.

آن جدول TABLE قراردادِ باریکی دارد و بد نیست همین اول بشکنیمش:

try:
    TABLE[("text", "none", 1, 1, 0.05)]          # C = 0.05 در فضا نیست
except KeyError as e:
    print(f"{type(e).__name__}: {e}")
print("اندازهٔ جدول:", len(TABLE))
KeyError: ('text', 'none', 1, 1, 0.05)
اندازهٔ جدول: 432

🔧 اگر کار نکرد: KeyError با یک tuple داخلش یعنی مقداری خواسته‌ای که در SPACE نیست. این تله وقتی واقعی می‌شود که به SPACE یک مقدارِ تازه اضافه کنی و یادت برود TABLE را از نو بسازی — آن‌وقت نیمی از جست‌وجویت روی فضای قدیمی است. قاعدهٔ ساده: هر تغییری در SPACE یعنی سلولِ ساختِ TABLE باید دوباره اجرا شود، و چون این را نمی‌شود به یاد سپرد، بهتر است اندازهٔ SPACE را هم کنارِ نتیجه ثبت کنی.

۳. شبکه، وقتی بودجه دارد#

بودجه ۲۴ اجراست. یک شبکهٔ ۴۳۲تایی جا نمی‌شود، پس هر محور را به دو سرش کوتاه می‌کنیم — که منصفانه‌ترین کوتاه‌کردنِ ممکن است.

BUDGET = 24
COARSE = {k: [v[0], v[-1]] for k, v in SPACE.items()}   # دو سرِ هر محور
coarse_all = [dict(zip(KEYS, v)) for v in itertools.product(*COARSE.values())]
coarse = coarse_all[:BUDGET]                       # بودجه تمام شد، بقیه اجرا نشدند
seen = {k: sorted({c[k] for c in coarse}, key=str) for k in KEYS}
grid_best = max(TABLE[tuple(c[k] for k in KEYS)] for c in coarse)
print("شبکهٔ درشت پیش از بریدن:", len(coarse_all), "· بعد از بودجه:", len(coarse))
print("مقدارهایی که واقعاً امتحان شدند:")
for k in KEYS:
    print(f"  {k:<10}{seen[k]}")
print("بهترینِ شبکهٔ بودجه‌دار:", round(grid_best, 4))
شبکهٔ درشت پیش از بریدن: 32 · بعد از بودجه: 24
مقدارهایی که واقعاً امتحان شدند:
  features  ['text', 'text+meta']
  balance   ['none', 'weight']
  ngram     [1, 2]
  min_df    [1, 5]
  C         [0.03, 10.0]
بهترینِ شبکهٔ بودجه‌دار: 0.6124

۰٫۶۱۲۴ در برابرِ سقفِ ۰٫۷۱۲۶. و دو ایرادِ مستقل باعثش شده‌اند:

۱) دو سرِ محورِ C یعنی ۰٫۰۳ و ۱۰٫۰ — و بهترین مقدار ۱٫۰ است، یعنی دقیقاً وسط. شبکهٔ درشت روی هر محورِ عددی همین بلا را سرت می‌آورد: سرها را می‌بیند و وسط را نه.

۲) بریدنِ شبکه یک برشِ تصادفی نیست. itertools.product محورِ اول را کندترین می‌چرخاند، پس آن هشت پیکربندیِ اجرانشده همگی از یک گوشه‌اند. این را حدس نزنیم، چاپش کنیم:

BEST_KEY = max(TABLE, key=TABLE.get)
dropped = coarse_all[BUDGET:]
print("بهترینِ کلِ شبکهٔ ۴۳۲تایی:", " ".join(f"{k}={v}" for k, v in zip(KEYS, BEST_KEY)))
print(f"{len(dropped)} پیکربندی‌ای که بودجه به آن‌ها نرسید:")
for cfg in dropped:
    print("  ", " ".join(f"{k}={cfg[k]}" for k in KEYS))
بهترینِ کلِ شبکهٔ ۴۳۲تایی: features=text+meta balance=weight ngram=1 min_df=1 C=1.0
8 پیکربندی‌ای که بودجه به آن‌ها نرسید:
   features=text+meta balance=weight ngram=1 min_df=1 C=0.03
   features=text+meta balance=weight ngram=1 min_df=1 C=10.0
   features=text+meta balance=weight ngram=1 min_df=5 C=0.03
   features=text+meta balance=weight ngram=1 min_df=5 C=10.0
   features=text+meta balance=weight ngram=2 min_df=1 C=0.03
   features=text+meta balance=weight ngram=2 min_df=1 C=10.0
   features=text+meta balance=weight ngram=2 min_df=5 C=0.03
   features=text+meta balance=weight ngram=2 min_df=5 C=10.0

هر هشت سطر با features=text+meta balance=weight شروع می‌شوند — دقیقاً همان دو مقداری که در خطِ اول، در پیکربندیِ برندهٔ کلِ شبکه، نشسته‌اند. یعنی بودجه‌ای که تمام شد، تمامِ ناحیهٔ برنده را برید.

پس شبکه‌ای که بودجه‌اش تمام می‌شود، ۲۵ درصدِ پراکنده از دست نمی‌دهد؛ یک ناحیهٔ کاملِ به‌هم‌چسبیده را از دست می‌دهد.

۴. تصادفی، با همان بودجه#

import random


def random_search(budget, restart):
    rng = random.Random(restart)
    best = 0.0
    for _ in range(budget):
        key = tuple(rng.choice(SPACE[k]) for k in KEYS)
        best = max(best, TABLE[key])
    return best


rand = [random_search(BUDGET, r) for r in range(40)]
wins = sum(1 for v in rand if v > grid_best)
print(f"جست‌وجوی تصادفی با بودجهٔ {BUDGET}، در ۴۰ بارِ تکرار:")
print(f"  میانگین : {sum(rand) / len(rand):.4f}")
print(f"  بدترین  : {min(rand):.4f}")
print(f"  بهترین  : {max(rand):.4f}")
print(f"  چند بار از شبکهٔ بودجه‌دار جلو زد: {wins} از ۴۰")
جست‌وجوی تصادفی با بودجهٔ 24، در ۴۰ بارِ تکرار:
  میانگین : 0.6949
  بدترین  : 0.6303
  بهترین  : 0.7126
  چند بار از شبکهٔ بودجه‌دار جلو زد: 40 از ۴۰

۴۰ از ۴۰. حتی بدترین اجرای تصادفی (۰٫۶۳۰۳) از بهترین شبکهٔ هم‌بودجه (۰٫۶۱۲۴) بالاتر است.

سازوکارش را می‌شود در یک جمله گفت: با ۲۴ نمونهٔ تصادفی، هر محور معمولاً همهٔ مقدارهای خودش را می‌بیند، حتی محورِ شش‌مقداریِ C؛ با شبکه، هر محور فقط ۲ مقدار را امتحان می‌کند و بارها تکرارشان می‌کند. وقتی فقط یکی دو محور واقعاً مهم‌اند — که تقریباً همیشه همین‌طور است — پوششِ ریزترِ همان محورها همه‌چیز است.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با سقفِ واقعیِ فضا (۰٫۷۱۲۶) و با شبکه‌ای که دقیقاً همان بودجه را داشت. روی کدام داده؟ همان تقسیمِ تصادفیِ ۲۵ درصدی برای همهٔ ۴۳۲ پیکربندی. با چند seed؟ جدولِ TABLE با یک seed ساخته شده — پس این بخش دربارهٔ پیدا کردنِ ناحیهٔ خوب حرف می‌زند، نه دربارهٔ انتخابِ برندهٔ نهایی. بخشِ ۶ و فصلِ ۵ آن دومی را با چند seed انجام می‌دهند.

۵. بودجه، به‌عنوان ورودیِ طراحی#

top = TABLE[BEST_KEY]
print(f"  {'بودجه':<8}{'سهم از شبکه':>13}{'میانگینِ بهترین':>17}{'بدترین':>10}{'٪ از سقف':>10}")
for budget in (6, 12, 24, 48, 96):
    vals = [random_search(budget, r) for r in range(40)]
    mean = sum(vals) / len(vals)
    print(f"  {budget:<8}{100 * budget / len(GRID):>12.1f}٪{mean:>17.4f}"
          f"{min(vals):>10.4f}{100 * mean / top:>9.1f}٪")
  بودجه     سهم از شبکه  میانگینِ بهترین    بدترین  ٪ از سقف
  6                1.4٪           0.6524    0.5679     91.6٪
  12               2.8٪           0.6839    0.6303     96.0٪
  24               5.6٪           0.6949    0.6303     97.5٪
  48              11.1٪           0.7053    0.6846     99.0٪
  96              22.2٪           0.7086    0.6899     99.4٪

این جدول یک تصمیمِ مدیریتی است، نه یک نمودارِ علمی.

از ۶ به ۱۲ اجرا، ۴٫۴ واحدِ درصد جلو می‌روی. از ۴۸ به ۹۶ — یعنی دو برابر کردنِ کلِ هزینه — ۰٫۴ واحد. جایی بینِ ۲۴ و ۴۸ منحنی صاف می‌شود، و آن نقطه جوابِ سؤالِ «چقدر بودجه بدهم» است.

و ستونِ «بدترین» را دستِ‌کم نگیر. با بودجهٔ ۱۲، میانگین ۹۶٪ سقف است ولی بدترین اجرا ۸۸٪ آن. اگر فقط یک بار جست‌وجو کنی، ممکن است همان بدترین نصیبت شود — و برخلافِ این نوت‌بوک، در پروژهٔ واقعی هیچ‌وقت نمی‌فهمی که شده.

✅ چک کن: random_search را طوری عوض کن که به‌جای انتخابِ تصادفی از SPACE، فقط از میانِ ۱۰۰ پیکربندیِ اولِ GRID انتخاب کند. جدولِ بالا را دوباره بگیر. چرا حتی با بودجهٔ ۹۶ هم به سقف نمی‌رسد؟ جوابش تفاوتِ «نمونه‌گیری از فضا» با «نمونه‌گیری از فهرست» است.

۶. توقفِ زودهنگام: نصف‌کردنِ پیاپی#

تا اینجا هر پیکربندی را با یک seed سنجیدیم. برای انتخابِ برندهٔ نهایی این کافی نیست — ولی پنج seed برای همهٔ نامزدها هم گران است.

ایده: به همه کم بده، به بازمانده‌ها بیشتر.

CANDIDATES = [dict(zip(KEYS, k)) for k in
              sorted(TABLE, key=TABLE.get, reverse=True)[:12]]
SEEDS = [0, 1, 2, 3, 4]


def mean_f1(cfg, seeds):
    return sum(run(cfg | {"seed": s})["f1"] for s in seeds) / len(seeds)


t0 = time.time()
full = [(mean_f1(c, SEEDS), c) for c in CANDIDATES]
full.sort(key=lambda kv: -kv[0])
full_fits = len(CANDIDATES) * len(SEEDS)
print("ارزیابیِ کامل :", full_fits, "اجرا · بهترین", round(full[0][0], 4))
print("پیکربندی‌اش  :", full[0][1])
ارزیابیِ کامل : 60 اجرا · بهترین 0.6957
پیکربندی‌اش  : {'features': 'text+meta', 'balance': 'weight', 'ngram': 1, 'min_df': 3, 'C': 1.0}
alive = list(CANDIDATES)
used = {}
fits = 0
for stage, seeds in enumerate(([0], [1, 2], [3, 4])):
    for cfg in alive:
        used.setdefault(id(cfg), []).extend(
            run(cfg | {"seed": s})["f1"] for s in seeds)
        fits += len(seeds)
    ranked = sorted(alive, key=lambda c: -sum(used[id(c)]) / len(used[id(c)]))
    keep = max(3, len(ranked) // 2) if stage < 2 else len(ranked)
    alive = ranked[:keep]
    print(f"  مرحلهٔ {stage + 1}: {fits:>2} اجرا تا اینجا · {len(alive)} پیکربندی زنده")

winner = alive[0]
print("برندهٔ نصف‌کردنِ پیاپی:", winner)
print("همان برندهٔ ارزیابیِ کامل است؟", winner == full[0][1])
print("میانگینِ برندهٔ نصف‌کردن :", round(sum(used[id(winner)]) / 5, 4))
print("میانگینِ برندهٔ کامل     :", round(full[0][0], 4))
print(f"هزینه: {fits} در برابرِ {full_fits} اجرا "
      f"({100 * (1 - fits / full_fits):.0f}٪ کمتر)")
  مرحلهٔ 1: 12 اجرا تا اینجا · 6 پیکربندی زنده
  مرحلهٔ 2: 24 اجرا تا اینجا · 3 پیکربندی زنده
  مرحلهٔ 3: 30 اجرا تا اینجا · 3 پیکربندی زنده
برندهٔ نصف‌کردنِ پیاپی: {'features': 'text+meta', 'balance': 'weight', 'ngram': 1, 'min_df': 5, 'C': 3.0}
همان برندهٔ ارزیابیِ کامل است؟ False
میانگینِ برندهٔ نصف‌کردن : 0.6951
میانگینِ برندهٔ کامل     : 0.6957
هزینه: 30 در برابرِ 60 اجرا (50٪ کمتر)

«برندهٔ متفاوت» و «نتیجهٔ متفاوت» دو چیزند، و اینجا فقط اولی اتفاق افتاده.

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

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

🤖 از دستیارت بپرس: «تفاوتِ successive halving با Hyperband چیست؟» بعد این را هم بپرس: «اگر معیارِ حذفِ زودهنگام خودش نویزی باشد، چه ریسکی هست؟» — جوابِ دوم مستقیماً به عددِ بالا وصل است: در مرحلهٔ اول با یک seed شش نامزد را حذف کردیم، و بعضی‌شان ممکن است فقط بدشانس بوده باشند.

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

کلمه تلفظ به حروف فارسی یعنی چه
search space سرچ اسپیس مجموعهٔ همهٔ پیکربندی‌های ممکن
grid search گرید سرچ امتحانِ همهٔ ترکیب‌های چند مقدارِ از پیش انتخاب‌شده
random search رندوم سرچ نمونه‌گیریِ تصادفی از فضا با بودجهٔ ثابت
budget باجت تعدادِ اجراهایی که حاضری خرج کنی
successive halving ساکسسیو هاوینگ دادنِ منابعِ کم به همه و بیشتر به بازمانده‌ها
early stopping ارلی استاپینگ قطعِ زودهنگامِ نامزدهایی که به‌نظر بازنده‌اند

تمرین‌ها

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

در فصل بعد#

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

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

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