# فصل ۰۸ — حفظ‌کردن در برابرِ یادگرفتن: `overfitting`

<div dir="rtl">

# فصل ۰۸ — حفظ‌کردن در برابرِ یادگرفتن: `overfitting`

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

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

![دو منحنی که با هم پایین می‌آیند و از یک نقطه به بعد یکی همچنان پایین می‌رود و دیگری بالا برمی‌گردد](/lesson-assets/t3-s08-overfitting/prompt/01-image-train-test-curves.png)

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

- `overfitting` و `underfitting` را از روی دو عددِ خطا تشخیص بدهی
- منحنیِ آموزش/آزمون را بخوانی و نقطهٔ بهینه را پیدا کنی
- با `cross_val_score` ارزیابیِ پایدارتر بگیری
- بگویی چرا میانگینِ چند تقسیم از یک تقسیمِ تنها معتبرتر است

## قبل از شروع

**از فصل ۷:** `Pipeline` و `ColumnTransformer`.

**از فصل ۴:** خطای آموزش در برابرِ آزمون، و اینکه یک تقسیمِ کوچک خودش تصادفی است.

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

## ۱. مدلی که حافظه دارد

`DecisionTree` مدلی است که اگر جلویش را نگیری، داده را **حفظ** می‌کند. پارامترِ `max_depth` می‌گوید چقدر اجازه دارد پیچیده شود.

</div>

```python
import pandas as pd
from sklearn.model_selection import train_test_split
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"]),
])

for depth in [1, 2, 3, 5, 8, None]:
    tree = Pipeline([
        ("prepare", preprocess),
        ("model", DecisionTreeRegressor(max_depth=depth, random_state=0)),
    ]).fit(X_train, y_train)
    train_error = mean_absolute_error(y_train, tree.predict(X_train))
    test_error = mean_absolute_error(y_test, tree.predict(X_test))
    print(f"عمق {str(depth):>4}: آموزش={round(train_error):>8}  آزمون={round(test_error):>8}")
```

<div dir="rtl">

</div>

```text
عمق    1: آموزش= 6201240  آزمون= 6601736
عمق    2: آموزش= 3534380  آزمون= 4371878
عمق    3: آموزش= 2708037  آزمون= 2968225
عمق    5: آموزش= 1695237  آزمون= 2108331
عمق    8: آموزش=  787054  آزمون= 2239625
عمق None: آموزش=  415789  آزمون= 2377083
```

<div dir="rtl">

**این جدول کلِ درسِ فصل است.** دو ستون را با هم بخوان:

- ستونِ **آموزش** بی‌وقفه پایین می‌آید: از ۶٫۲ میلیون تا ۰٫۴۲ میلیون. هرچه درخت عمیق‌تر، بهتر داده را حفظ می‌کند.
- ستونِ **آزمون** تا عمقِ ۵ پایین می‌آید (۲٫۱۱ میلیون) و بعد **برمی‌گردد بالا**.

آن نقطهٔ برگشت، مرزِ بینِ یادگرفتن و حفظ‌کردن است.

## ۲. سه حالت

</div>

| حالت | خطای آموزش | خطای آزمون | یعنی چه |
|---|---|---|---|
| `underfitting` | زیاد | زیاد | مدل ساده‌تر از الگوی داده است (عمقِ ۱ و ۲) |
| نقطهٔ خوب | متوسط | **کمینه** | بهترین توازن (عمقِ ۵) |
| `overfitting` | کم | زیاد | مدل نویزِ دادهٔ آموزش را هم حفظ کرده (عمقِ ۸ و بی‌نهایت) |

<div dir="rtl">

در عمقِ نامحدود، درخت خطای آموزشِ ۴۱۵ هزار دارد — تقریباً بی‌خطا. و روی دادهٔ تازه از درختِ عمقِ ۵ **بدتر** است.

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

> 📏 **اندازه بگیر:** **همیشه هر دو خطا را با هم گزارش کن.** فاصلهٔ بینشان تشخیصِ بیماری است: فاصلهٔ کم با خطای زیاد یعنی `underfitting`؛ فاصلهٔ زیاد یعنی `overfitting`. یک عددِ تنها — هر کدامشان — این تشخیص را غیرممکن می‌کند. و کسی که فقط خطای آموزش را گزارش می‌کند، عملاً هیچ نگفته.

## ۳. `cross-validation`: تکیه نکردن به یک تقسیم

در فصلِ ۴ دیدی که یک تقسیمِ تصادفیِ کوچک خودش تصادفی است. راهِ حل: **چند بار تقسیم کن و میانگین بگیر.**

</div>

```python
from sklearn.model_selection import cross_val_score, KFold
from sklearn.linear_model import LinearRegression
import numpy as np

pipe = Pipeline([("prepare", preprocess), ("model", LinearRegression())])
folds = KFold(n_splits=5, shuffle=True, random_state=0)

scores = -cross_val_score(pipe, X, y, cv=folds, scoring="neg_mean_absolute_error")

print("MAE هر تا:", scores.round(0))
print("میانگین:", round(scores.mean()))
print("انحراف معیار:", round(scores.std()))
```

<div dir="rtl">

</div>

```text
MAE هر تا: [1376665. 1475454. 1451428. 1628627. 1641747.]
میانگین: 1514784
انحراف معیار: 103651
```

<div dir="rtl">

`KFold(5)` داده را به پنج تکه می‌کند و پنج بار مدل می‌سازد: هر بار چهار تکه آموزش و یک تکه آزمون، طوری که **هر ردیف دقیقاً یک بار در آزمون** باشد.

نتیجه پنج عدد است، نه یکی. و همان پراکندگی مهم‌ترین چیزی است که به تو می‌دهد: از ۱٫۳۸ تا ۱٫۶۴ میلیون، با انحرافِ معیارِ حدودِ ۱۰۴ هزار.

**پس عددِ ۱٫۴۴ میلیونِ فصلِ ۷ خوش‌شانس‌ترین سرِ این طیف بود.** گزارشِ صادقانه‌تر این است: «حدودِ ۱٫۵۱ میلیون، با نوسانِ حدودِ ۱۰۰ هزار».

> ⚠️ **مواظب باش:** آن علامتِ منفی پشتِ `cross_val_score` اشتباهِ تایپی نیست. `scikit-learn` قراردادش این است که **همیشه بزرگ‌تر بهتر است**، پس خطا را منفی می‌دهد (`neg_mean_absolute_error`). ضربدر منفی یک می‌کنی تا عددِ عادی بشود. اگر یک روز MAE منفی دیدی، مشکل همین است، نه مدلت.

> ✅ **چک کن:** هر پنج عدد باید در همان محدودهٔ ۱٫۳ تا ۱٫۷ میلیون باشند. اگر عددها درست همین نبودند ولی در همین محدوده بودند، احتمالاً `shuffle=True` یا `random_state=0` را جا انداخته‌ای. این جدول به ترتیبِ خاصی نیست، پس اینجا چیزی خراب نمی‌شود؛ ولی روی جدولی که مرتب شده باشد، بدونِ `shuffle` یک تکه ساختارِ کاملاً متفاوتی می‌گیرد.

## ۴. چرا `cross-validation` نشتی نمی‌سازد

سؤالِ درستی که باید بپرسی: `cross_val_score` را روی **کلِ `X`** صدا زدیم، نه فقط آموزش. مگر این همان نشتیِ فصلِ ۴ نیست؟

**نه، و دلیلش دقیقاً `Pipeline` است.** در هر یک از پنج دور، `cross_val_score` کلِ زنجیره را از نو روی تکهٔ آموزشِ همان دور `fit` می‌کند. `SimpleImputer` میانه‌اش را از همان چهار تکه می‌گیرد، `StandardScaler` هم، و `OneHotEncoder` هم.

**اگر پیش‌پردازش را بیرونِ `Pipeline` انجام داده بودی، اینجا دقیقاً نشتی می‌شد** — و بدترین نوعش، چون در همهٔ پنج دور تکرار می‌شد و کاملاً نامرئی می‌ماند.

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

## ۵. پیدا کردنِ نقطهٔ بهینه با `cross-validation`

</div>

```python
for depth in [2, 3, 5, 8, None]:
    tree = Pipeline([
        ("prepare", preprocess),
        ("model", DecisionTreeRegressor(max_depth=depth, random_state=0)),
    ])
    cv = -cross_val_score(tree, X, y, cv=folds, scoring="neg_mean_absolute_error")
    print(f"عمق {str(depth):>4}: میانگین={round(cv.mean()):>8}  نوسان={round(cv.std()):>7}")
```

<div dir="rtl">

</div>

```text
عمق    2: میانگین= 4057467  نوسان= 498257
عمق    3: میانگین= 3107660  نوسان= 365572
عمق    5: میانگین= 2216130  نوسان= 170375
عمق    8: میانگین= 2246606  نوسان= 100458
عمق None: میانگین= 2273593  نوسان= 110615
```

<div dir="rtl">

همان الگو، ولی این‌بار پایدار: عمقِ ۵ بهترین است و بعدش بدتر می‌شود.

**ولی به نوسان‌ها نگاه کن.** تفاوتِ عمقِ ۵ و ۸ حدودِ ۳۰ هزار است، در حالی که نوسانِ هر کدام بالای ۱۰۰ هزار است. **یعنی این دو عملاً برابرند** و ادعای اینکه «عمقِ ۵ بهتر از ۸ است» با این داده قابلِ دفاع نیست.

> 📏 **اندازه بگیر:** این قاعدهٔ کوچک، بیشترین وقتی است که در کارِ واقعی نجاتت می‌دهد: **اگر تفاوتِ دو گزینه از نوسانشان کمتر است، تفاوتی وجود ندارد.** ساده‌ترشان را انتخاب کن. ساعت‌ها وقت صرفِ بهبودهایی می‌شود که در واقع نویزِ تقسیمِ تصادفی‌اند.

و یک مقایسهٔ آموزنده‌تر: بهترین درخت (۲٫۲۲ میلیون) از `LinearRegression` سادهٔ بخشِ ۳ (۱٫۵۱ میلیون) **بدتر** است. **مدلِ پیچیده‌تر خودبه‌خود بهتر نیست.**

## ۶. یک خطای واقعی: `scoring` اشتباه

</div>

```python
scores_wrong = cross_val_score(pipe, X, y, cv=folds, scoring="accuracy")
print("امتیازها:", scores_wrong)
print("میانگین:", scores_wrong.mean())
```

<div dir="rtl">

</div>

```text
امتیازها: [nan nan nan nan nan]
میانگین: nan
```

<div dir="rtl">

`accuracy` معیارِ طبقه‌بندی است و `y` ما عددِ پیوسته است. `scikit-learn` نمی‌تواند «درصدِ درست» را برای قیمت حساب کند.

**و توجه کن چطور شکست خورد: نه با یک خطا، بلکه با پنج تا `nan`** و یک هشدارِ کم‌رنگ در خروجی. اگر مستقیم `scores.mean()` را در یک f-string می‌گذاشتی، فقط `nan` می‌دیدی و ممکن بود فکر کنی مشکل از داده است.

> ⚠️ **مواظب باش:** `cross_val_score` وقتی سنجش شکست بخورد، به‌جای توقف **`nan` برمی‌گرداند و ادامه می‌دهد**. این عمدی است (تا یک تکهٔ خراب کلِ جست‌وجو را نکُشد) ولی یعنی مسئولیتِ دیدنش با توست. **بعد از هر `cross_val_score`، خودِ آرایهٔ امتیازها را چاپ کن، نه فقط میانگینش را** — حتی یک `nan` کلِ میانگین را `nan` می‌کند و نمی‌گوید کدام تکه خراب شده؛ آرایه این را نشان می‌دهد.

> 🔧 **اگر کار نکرد:** معیارهای رایجِ `regression`: `neg_mean_absolute_error`، `neg_root_mean_squared_error`، `r2`. معیارهای `classification`: `accuracy`، `precision`، `recall`، `f1`، `roc_auc`. اگر نامِ معیار را اشتباه بنویسی، `scikit-learn` فهرستِ کاملِ گزینه‌ها را در پیامِ خطا چاپ می‌کند — همان‌جا بخوانش.

> 🤖 **از دستیارت بپرس:** «چه زمانی `KFold` انتخابِ اشتباهی است و چه جایگزین‌هایی وجود دارد؟» جوابش احتمالاً `StratifiedKFold` (برای دستهٔ نامتوازن)، `TimeSeriesSplit` (برای دادهٔ زمانی) و `GroupKFold` (وقتی چند ردیف از یک موجودیت داری) را می‌آورد. **دو تای آخر دقیقاً همان نشتی‌های زمانی و موجودیتی‌اند که در فصلِ ۴ دیدی، و اولی همان `stratify` فصلِ ۵ است** — و این نشان می‌دهد که انتخابِ روشِ تقسیم خودش یک تصمیمِ جدی است، نه یک جزئیاتِ فنی.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| overfitting | اُوِرفیتینگ | مدل نویزِ دادهٔ آموزش را حفظ کرده؛ روی دادهٔ تازه بد است |
| underfitting | آندِرفیتینگ | مدل ساده‌تر از الگوی داده است؛ هر دو خطا زیادند |
| cross-validation | کراس ولیدیشن | چند بار تقسیم و میانگین‌گیری، به‌جای اتکا به یک تقسیم |
| KFold | کی‌فولد | تقسیم به k تکه؛ هر ردیف دقیقاً یک بار در آزمون |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: مدلی خطای آموزشِ خیلی کم و خطای آزمونِ زیاد دارد. اسمِ این حالت چیست و راهِ حلش در چه جهتی است؟

**تمرینِ اجباری:** جدولِ بخشِ ۱ را با `cross_val_score` بازسازی کن و برای هر عمق **هر دو** عدد را بده: میانگینِ خطای آموزش و میانگینِ خطای آزمونِ چنددوره‌ای. (راهنمایی: `cross_validate` با `return_train_score=True`.) حالا نقطه‌ای را که این دو منحنی از هم فاصله می‌گیرند پیدا کن و با جدولِ بخشِ ۱ مقایسه‌اش کن.

**تمرینِ ستاره‌دار ⭐:** پارامترِ `n_splits` را روی ۳، ۵، ۱۰ و ۲۰ امتحان کن و برای هر کدام میانگین و نوسانِ `MAE` را ثبت کن. با بیشتر شدنِ تعدادِ تکه‌ها، **میانگین** چطور تغییر می‌کند و **نوسان** چطور؟ حالا زمانِ اجرا را هم اندازه بگیر (`time.perf_counter` از ترمِ ۲). یک جمله بنویس: بده‌بستانِ انتخابِ `n_splits` چیست، و برای این دیتاست کدام را انتخاب می‌کنی؟

## در فصل بعد

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

</div>

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