در این فصل چه یاد میگیری#
فضای پیکربندیِ ما ۴۳۲ حالت دارد و همهشان را میزنیم — عمداً، تا برای یک بار بدانیم سقف کجاست. سقف 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 | ارلی استاپینگ | قطعِ زودهنگامِ نامزدهایی که بهنظر بازندهاند |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
دو بار در همین فصل گفتیم «این دو عدد داخلِ نویزِ همدیگرند» و هر بار با مقایسهٔ چشمیِ دامنهها قانعت کردیم. فصلِ بعد این کار را درست انجام میدهد: آزمونِ جفتشده، که نویز را ۳٫۴ برابر کم میکند بدونِ یک اجرای اضافه، و دامِ مقایسهٔ چندگانه — اینکه اگر همین یک پیکربندی را بیست بار اجرا کنی و بهترینش را گزارش کنی، ۰٫۰۳۱ از عددِ واقعیاش جلو زدهای، بیآنکه هیچچیز بهتر شده باشد.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.