# فصل ۰۴ — جست‌وجوی ابرپارامتر با بودجه

<div dir="rtl">

# فصل ۰۴ — جست‌وجوی ابرپارامتر با بودجه

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

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

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

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

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

![یک نقشهٔ سوراخ‌دار که یک شبکهٔ منظم و یک الگوی پراکنده رویش افتاده](/lesson-assets/t3-s04-hyperparameter-budget/prompt/01-image-budget-grid.png)

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

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

## قبل از شروع

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

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-3-experiments/session-04-hyperparameter-budget.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

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

<div dir="rtl">

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

</div>

```python
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, "اجرا")
```

```text
اندازهٔ فضا: 3 × 3 × 2 × 4 × 6 = 432 پیکربندی
با پنج seed برای هرکدام: 2160 اجرا
```

<div dir="rtl">

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

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

> 🌱 **ریشه‌اش کجاست:** آن ضربِ `۳ × ۳ × ۲ × ۴ × ۶` یک اسم دارد و در [ریشه، ترم ۶ فصل ۱ — شمردن، قبل از احتمال](/courses/risheh/lessons/term-6-probability-statistics/session-01-counting) ساخته می‌شود: **«اگر کاری در چند مرحله انجام شود و هر مرحله تعدادِ مشخصی حالت داشته باشد، تعدادِ کلِ حالت‌ها حاصل‌ضربِ آن‌هاست.»** همان‌جا این نکته هم هست که **وقتی همهٔ مراحل تعدادِ حالتِ یکسانی دارند، اصلِ ضرب به توان تبدیل می‌شود** — و دقیقاً به همین دلیل است که فضای جست‌وجو با افزودنِ هر محور **ضرب** می‌شود، نه جمع. هر جا شبکه‌ای می‌سازی، این ضرب را قبل از زدنِ دکمهٔ اجرا بزن.

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

</div>

```python
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)))
```

```text
بهترینِ کلِ شبکه: 0.7126
پیکربندی‌اش    : {'features': 'text+meta', 'balance': 'weight', 'ngram': 1, 'min_df': 1, 'C': 1.0}
```

```python
print(f"زمانِ کلِ شبکه: {ELAPSED:.0f} ثانیه · هر اجرا {ELAPSED / len(GRID):.3f} ثانیه")
print(f"همین شبکه با پنج seed: {5 * ELAPSED / 60:.1f} دقیقه")
```

```text-approx
زمانِ کلِ شبکه: 21 ثانیه · هر اجرا 0.048 ثانیه
همین شبکه با پنج seed: 1.7 دقیقه
```

<div dir="rtl">

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

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

</div>

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

```text
KeyError: ('text', 'none', 1, 1, 0.05)
اندازهٔ جدول: 432
```

<div dir="rtl">

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

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

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

</div>

```python
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))
```

```text
شبکهٔ درشت پیش از بریدن: 32 · بعد از بودجه: 24
مقدارهایی که واقعاً امتحان شدند:
  features  ['text', 'text+meta']
  balance   ['none', 'weight']
  ngram     [1, 2]
  min_df    [1, 5]
  C         [0.03, 10.0]
بهترینِ شبکهٔ بودجه‌دار: 0.6124
```

<div dir="rtl">

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

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

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

</div>

```python
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))
```

```text
بهترینِ کلِ شبکهٔ ۴۳۲تایی: 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
```

<div dir="rtl">

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

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

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

</div>

```python
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} از ۴۰")
```

```text
جست‌وجوی تصادفی با بودجهٔ 24، در ۴۰ بارِ تکرار:
  میانگین : 0.6949
  بدترین  : 0.6303
  بهترین  : 0.7126
  چند بار از شبکهٔ بودجه‌دار جلو زد: 40 از ۴۰
```

<div dir="rtl">

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

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

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

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

</div>

```python
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}٪")
```

```text
  بودجه     سهم از شبکه  میانگینِ بهترین    بدترین  ٪ از سقف
  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٪
```

<div dir="rtl">

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

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

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

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

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

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

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

</div>

```python
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])
```

```text
ارزیابیِ کامل : 60 اجرا · بهترین 0.6957
پیکربندی‌اش  : {'features': 'text+meta', 'balance': 'weight', 'ngram': 1, 'min_df': 3, 'C': 1.0}
```

```python
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}٪ کمتر)")
```

```text
  مرحلهٔ 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٪ کمتر)
```

<div dir="rtl">

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

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

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

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

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

</div>

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

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا شبکهٔ بریده‌شده یک ناحیهٔ به‌هم‌چسبیده را از دست می‌دهد و نه نمونه‌های پراکنده را؟

**تمرینِ اجباری:** یک محورِ ششم به `SPACE` اضافه کن: `"test_frac": [0.2, 0.25, 0.3]`. حالا **بدونِ اجرای هیچ آزمایشی** جوابِ این را بنویس: فضا چند برابر شد و شبکهٔ کامل چقدر طول می‌کشد؟ بعد `TABLE` را دوباره بساز و ببین حدست چقدر درست بود. **و مهم‌تر: میانگینِ جست‌وجوی تصادفی با بودجهٔ ۲۴ روی فضای بزرگ‌تر بالا رفت یا پایین؟** توضیح بده چرا.

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

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t3/s04-hyperparameter-budget (یادستان, Yaadestan)
