# فصل ۰۹ — تنظیمِ مدل بدونِ خراب‌کردنِ تست

<div dir="rtl">

# فصل ۰۹ — تنظیمِ مدل بدونِ خراب‌کردنِ تست

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

در فصلِ قبل پنج عمقِ درخت را با دست امتحان کردی. مدل‌های واقعی ده‌ها پارامتر دارند و امتحانِ دستی‌شان ممکن نیست. در این فصل `GridSearchCV` این کار را خودکار می‌کند. ولی مهم‌تر از ابزار، یک **نشتیِ چهارم** است که در فصلِ ۴ نگفتیم چون به `cross-validation` نیاز داشت: اگر بارها روی دادهٔ آزمون پارامتر تنظیم کنی، همان داده هم آلوده می‌شود — و این‌بار حتی خودت هم متوجه نمی‌شوی.

![یک میزِ آزمایش با چند اهرمِ تنظیم و یک محفظهٔ مهروموم‌شده در گوشه که تا آخرِ کار باز نمی‌شود](/lesson-assets/t3-s09-tuning/prompt/01-image-sealed-test-set.png)

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

- با `GridSearchCV` ترکیب‌های پارامتر را خودکار امتحان کنی
- نتایجِ جست‌وجو را بخوانی و نوسان را در تصمیمت لحاظ کنی
- بگویی مجموعهٔ `validation` چیست و چرا با `test` فرق دارد
- بگویی چرا نباید بیش از یک بار به دادهٔ آزمون نگاه کنی

## قبل از شروع

**از فصل ۸:** `cross_val_score`، `KFold`، و `overfitting`.

**از فصل ۷:** `Pipeline` و `ColumnTransformer`، و اینکه هر مرحله‌اش یک **نام** دارد (`"prepare"`، `"model"`، `"fill"`) — همان نام‌ها در این فصل به آدرسِ پارامترها تبدیل می‌شوند.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/sarnakh/term-3-machine-learning/session-09-tuning.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

## ۱. `GridSearchCV`

</div>

```python
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV, KFold
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_absolute_error

df = pd.read_csv("laptops_clean.csv")
X = df[["year", "ram_gb", "brand", "city"]]
y = df["price"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

preprocess = ColumnTransformer([
    ("num", Pipeline([("fill", SimpleImputer(strategy="median")), ("scale", StandardScaler())]),
     ["year", "ram_gb"]),
    ("cat", OneHotEncoder(handle_unknown="ignore"), ["brand", "city"]),
])

pipe = Pipeline([("prepare", preprocess), ("model", DecisionTreeRegressor(random_state=0))])

grid = {
    "model__max_depth": [3, 5, 8, None],
    "model__min_samples_leaf": [1, 3, 5, 10],
}

search = GridSearchCV(
    pipe, grid,
    cv=KFold(5, shuffle=True, random_state=0),
    scoring="neg_mean_absolute_error",
).fit(X_train, y_train)

print("بهترین ترکیب:", search.best_params_)
print("بهترین MAE در cross-validation:", round(-search.best_score_))
print("تعداد کل مدل‌هایی که آموزش دید:", len(search.cv_results_["params"]) * 5)
```

<div dir="rtl">

</div>

```text
بهترین ترکیب: {'model__max_depth': 8, 'model__min_samples_leaf': 5}
بهترین MAE در cross-validation: 2377103
تعداد کل مدل‌هایی که آموزش دید: 80
```

<div dir="rtl">

`GridSearchCV` **همهٔ ترکیب‌ها** را امتحان می‌کند: ۴ عمق ضربدر ۴ مقدارِ `min_samples_leaf` می‌شود ۱۶ ترکیب، و هر کدام با ۵ تکهٔ `cross-validation` یعنی **۸۰ بار آموزش**.

آن `model__max_depth` با **دو زیرخط** آدرسِ داخلِ `Pipeline` است: «در مرحله‌ای به‌نامِ `model`، پارامترِ `max_depth`». همان الگو برای هر مرحله‌ای کار می‌کند — حتی `prepare__num__fill__strategy`.

> ⚠️ **مواظب باش:** تعدادِ آموزش‌ها **ضربی** رشد می‌کند. سه پارامتر با پنج مقدار هرکدام و ۵ تکه یعنی ۶۲۵ بار آموزش. برای مدل‌های سنگین این خیلی زود از دسترس خارج می‌شود. **قبل از اجرای هر `GridSearchCV`، تعدادِ آموزش‌ها را در ذهنت ضرب کن** — و اگر بزرگ شد، سراغِ `RandomizedSearchCV` برو که فقط نمونه‌ای تصادفی از فضا را امتحان می‌کند.

## ۲. خواندنِ کاملِ نتیجه

فقط «بهترین» را نگاه نکن — کلِ جدول را ببین:

</div>

```python
results = pd.DataFrame(search.cv_results_)
table = results[["param_model__max_depth", "param_model__min_samples_leaf",
                 "mean_test_score", "std_test_score"]].copy()
table["mean_test_score"] = (-table["mean_test_score"]).round(0)
table["std_test_score"] = table["std_test_score"].round(0)
print(table.sort_values("mean_test_score").head(5).to_string(index=False))
```

<div dir="rtl">

</div>

```text
param_model__max_depth  param_model__min_samples_leaf  mean_test_score  std_test_score
                  None                              5        2377103.0        182910.0
                     8                              5        2377103.0        182910.0
                  None                              3        2402506.0         49924.0
                     5                              5        2416370.0        176916.0
                     8                              3        2418070.0         60678.0
```

<div dir="rtl">

سه چیزِ مهم در این جدول هست که با نگاه‌کردن به `best_params_` تنها هرگز نمی‌دیدی:

**اول:** دو ردیفِ اول **دقیقاً یک عدد** دارند. عمقِ ۸ و عمقِ نامحدود نتیجهٔ یکسان دادند، چون با `min_samples_leaf=5` درخت هیچ‌وقت از عمقِ ۸ جلوتر نمی‌رود. `GridSearchCV` یکی را دلبخواهی «بهترین» نامید.

**دوم:** فاصلهٔ ردیفِ اول تا پنجم حدودِ ۴۱ هزار است، در حالی که `std` بعضی‌شان بالای ۱۸۰ هزار است. **پنج ردیفِ اول از نظرِ آماری قابلِ تفکیک نیستند.**

**سوم و مهم‌ترین:** ردیفِ سوم `std` برابرِ ۵۰ هزار دارد — بسیار پایدارتر از ردیفِ اول با ۱۸۳ هزار. **از نظرِ عملی این انتخابِ بهتری است**، هرچند میانگینش کمی بالاتر است: مدلی که نتیجه‌اش کمتر به تصادف بستگی دارد، در تولید قابلِ‌اعتمادتر است.

> 📏 **اندازه بگیر:** **`best_params_` را کورکورانه قبول نکن.** جدولِ کامل را مرتب کن و بپرس: آیا فاصلهٔ بهترین و دومی از نوسانشان بیشتر است؟ اگر نه، بینشان با معیارِ دیگری انتخاب کن — سادگی، پایداری، سرعت. این دقیقاً همان قاعدهٔ فصلِ ۸ است، فقط این بار روی خروجیِ یک ابزارِ خودکار.

## ۳. سه مجموعه، نه دو

حالا مهم‌ترین بخشِ فصل. توجه کن که `GridSearchCV` را روی `X_train` صدا زدیم، نه روی کلِ داده. چرا؟

`GridSearchCV` داخلِ خودش دادهٔ آموزش را دوباره به تکه‌هایی تقسیم می‌کند و از یکی‌شان برای **انتخابِ پارامتر** استفاده می‌کند. آن تکه‌ها را **`validation`** می‌نامند.

</div>

| مجموعه | چه کسی می‌بیندش | برای چه |
|---|---|---|
| `train` | مدل، مستقیم | یادگرفتنِ ضریب‌ها |
| `validation` | تو، بارها | انتخابِ پارامتر و مقایسهٔ مدل‌ها |
| `test` | **فقط یک بار، در پایان** | تخمینِ صادقانهٔ عملکرد در دنیای واقعی |

<div dir="rtl">

و حالا نشتیِ چهارم: **اگر آن ۱۶ ترکیب را روی دادهٔ آزمون بسنجی و بهترین را انتخاب کنی، آن عدد دیگر تخمینِ صادقانه نیست.**

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

پس قاعده: **پارامتر را روی `validation` انتخاب کن، و به `test` فقط یک بار، در انتها، دست بزن.**

## ۴. آن یک بارِ نهایی

</div>

```python
final_mae = mean_absolute_error(y_test, search.predict(X_test))

print("MAE روی validation (میانگین cross-validation):", round(-search.best_score_))
print("MAE روی test (فقط همین یک بار):", round(final_mae))
```

<div dir="rtl">

</div>

```text
MAE روی validation (میانگین cross-validation): 2377103
MAE روی test (فقط همین یک بار): 2143085
```

<div dir="rtl">

عددِ آزمون کمی **بهتر** از تخمینِ `validation` درآمد. با ۴۸ ردیفِ آزمون این کاملاً در محدودهٔ نوسان است و معنایی ندارد.

نکتهٔ ظریف: `search` بعد از پیدا کردنِ بهترین ترکیب، خودبه‌خود مدلی با همان پارامترها را روی **کلِ `X_train`** دوباره آموزش می‌دهد. برای همین می‌شود مستقیم `search.predict` را صدا زد.

> ✅ **چک کن:** اگر عددِ `test` **خیلی** بدتر از `validation` بود (مثلاً دو برابر)، دو احتمال هست: یا `test` خیلی کوچک است، یا آن‌قدر پارامتر امتحان کرده‌ای که به `validation` هم overfit شده‌ای. هر دو با یک کار تشخیص داده می‌شوند: **کلِ فرآیند را با `random_state` دیگری تکرار کن.**

## ۵. تنظیمِ خودِ پیش‌پردازش

`GridSearchCV` فقط برای پارامترهای مدل نیست — هر مرحله‌ای از `Pipeline` قابلِ تنظیم است:

</div>

```python
from sklearn.linear_model import Ridge

ridge_pipe = Pipeline([("prepare", preprocess), ("model", Ridge())])
ridge_grid = {
    "prepare__num__fill__strategy": ["mean", "median"],
    "model__alpha": [0.1, 1.0, 10.0, 100.0],
}

ridge_search = GridSearchCV(
    ridge_pipe, ridge_grid,
    cv=KFold(5, shuffle=True, random_state=0),
    scoring="neg_mean_absolute_error",
).fit(X_train, y_train)

print("بهترین:", ridge_search.best_params_)
print("MAE در cross-validation:", round(-ridge_search.best_score_))
print("MAE روی test:", round(mean_absolute_error(y_test, ridge_search.predict(X_test))))
```

<div dir="rtl">

</div>

```text
بهترین: {'model__alpha': 0.1, 'prepare__num__fill__strategy': 'mean'}
MAE در cross-validation: 1566703
MAE روی test: 1463030
```

<div dir="rtl">

آن آدرسِ `prepare__num__fill__strategy` را بخوان: در مرحلهٔ `prepare`، در زیرمرحلهٔ `num`، در گامِ `fill`، پارامترِ `strategy`. زیرخطِ دوتایی هر بار یک لایه پایین‌تر می‌رود.

و نتیجه: مدلِ خطی با تنظیم به **۱٫۴۶ میلیون** رسید — همچنان خیلی بهتر از بهترین درخت (۲٫۱۴ میلیون).

`Ridge` نسخهٔ «مهارشدهٔ» `LinearRegression` است: پارامترِ `alpha` جلوی بزرگ‌شدنِ بیش‌ازحدِ ضریب‌ها را می‌گیرد و کمی از `overfitting` جلوگیری می‌کند. اینجا بهترین `alpha` کوچک‌ترین مقدار شد، یعنی داده‌ات به مهار نیازی ندارد.

> 💡 **نکته:** اینکه پُرکردن با `mean` برنده شد، ظاهراً با درسِ ترمِ ۲ فصلِ ۵ می‌جنگد که میانه را ترجیح می‌داد. ولی قبل از نتیجه‌گیری، همان قاعدهٔ فصلِ ۸ را به‌کار ببر و دو ردیفِ بالا را کنارِ هم بگذار:

</div>

```python
ridge_results = pd.DataFrame(ridge_search.cv_results_)
top = ridge_results.sort_values("mean_test_score", ascending=False).head(2)
print(top[["param_prepare__num__fill__strategy", "mean_test_score", "std_test_score"]].round(0).to_string(index=False))
```

<div dir="rtl">

</div>

```text
param_prepare__num__fill__strategy  mean_test_score  std_test_score
                              mean       -1566703.0        165058.0
                            median       -1573283.0        155570.0
```

<div dir="rtl">

> فاصلهٔ دو ردیف حدودِ ۶٫۶ هزار است و نوسانِ هر کدام بالای ۱۵۰ هزار. **پس `mean` در واقع برنده نشد؛ این دو عملاً برابرند** و هیچ تناقضی با ترمِ ۲ نیست. میانه را نگه دار. **همیشه امتحان کن، ولی برنده را با نوسانش بخوان.**

## ۶. یک خطای واقعی: نامِ پارامترِ اشتباه

</div>

```python-broken
GridSearchCV(pipe, {"max_depth": [3, 5]}, cv=3).fit(X_train, y_train)
```

<div dir="rtl">

</div>

```text
ValueError: Invalid parameter 'max_depth' for estimator Pipeline(...).
Valid parameters are: ['memory', 'steps', 'transform_input', 'verbose'].
```

<div dir="rtl">

نامِ پارامتر باید کاملِ مسیرش داخلِ `Pipeline` باشد: `model__max_depth`، نه `max_depth`.

> 🔧 **اگر کار نکرد:** `pipe.get_params().keys()` فهرستِ **همهٔ** نام‌های معتبر را می‌دهد. قبل از نوشتنِ `grid` یک بار چاپش کن و از رویش کپی کن — این ده ثانیه، بیشترین خطای رایجِ این ابزار را حذف می‌کند.

> 🤖 **از دستیارت بپرس:** «تفاوتِ `GridSearchCV` و `RandomizedSearchCV` چیست و در چه شرایطی دومی بهتر است؟» جوابش را با محاسبهٔ ضربیِ بخشِ ۱ بسنج. بعد این را هم بپرس: «اگر ۵ پارامتر با ۴ مقدار هرکدام داشته باشم و ۵ تکه، چند بار آموزش لازم است؟» — جوابش ۵۱۲۰ است، و همان عدد نشان می‌دهد چرا جست‌وجوی کامل همیشه گزینه نیست.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| hyperparameter | هایپرپارامتر | تنظیمی که **تو** انتخاب می‌کنی، نه مدل از داده |
| GridSearchCV | گرید سرچ سی‌وی | امتحانِ خودکارِ همهٔ ترکیب‌ها با cross-validation |
| validation | ولیدیشن | داده‌ای که برای انتخابِ پارامتر به‌کار می‌رود، نه برای گزارشِ نهایی |
| Ridge | ریج | رگرسیونِ خطی با مهارِ ضریب‌ها |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا نباید ۸۰ مدل را روی دادهٔ آزمون سنجید و بهترین را انتخاب کرد؟

**تمرینِ اجباری:** برای `Ridge`، `alpha` را روی هفت مقدار از ۰٫۰۱ تا ۱۰۰۰ امتحان کن و نمودارِ `MAE` بر حسبِ `alpha` را بکش (محورِ افقی را لگاریتمی بگذار: `plt.xscale("log")`). شکلِ منحنی چیست و کجا کمینه می‌شود؟ در یک جمله بنویس `alpha` بزرگ چه بلایی سرِ مدل می‌آورد.

**تمرینِ ستاره‌دار ⭐:** نشتیِ انتخاب را با دست بساز. به‌جای `GridSearchCV`، یک حلقه بنویس که همان ۱۶ ترکیب را روی **دادهٔ آزمون** بسنجد و بهترین را انتخاب کند. حالا آن «بهترین» عدد را با عددِ `test` این فصل مقایسه کن. چقدر خوش‌بینانه‌تر است؟ بعد کلِ کار را با یک `random_state` دیگر تکرار کن و ببین آیا همان ترکیب دوباره برنده می‌شود. **اگر برنده عوض شد، تازه معنیِ واقعیِ نشتیِ انتخاب را دیده‌ای.**

## در فصل بعد

تا اینجا با دو مدل کار کردی: خطی و درخت. فصلِ بعد خانوادهٔ درختی را کامل می‌کند — `RandomForest` و `gradient boosting` — که در صنعت پرکاربردترین ابزارِ دادهٔ جدولی‌اند. و یک نتیجهٔ غافلگیرکننده هم می‌گیری که ارزشش از خودِ الگوریتم‌ها بیشتر است.

</div>

---
Source: https://yaadestan.com/courses/sarnakh/lessons/t3/s09-tuning (یادستان, Yaadestan)
