# فصل ۰۷ — نمونه‌گیری و توازن، بدونِ نشتی

<div dir="rtl">

# فصل ۰۷ — نمونه‌گیری و توازن، بدونِ نشتی

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

کلاسِ «تشدید» ۹٪ داده است و اولین کاری که همه می‌کنند، متوازن کردنِ داده با **فرانمونه‌گیری** است. انجامش می‌دهیم و `F1` از **۰٫۲۶ به ۰٫۸۴** می‌پرد.

**آن ۰٫۸۴ یک دروغِ تمام‌عیار است.** مدرکش را می‌شماریم: **۷۴٪ ردیف‌های آزمون عیناً در دادهٔ آموزش هم هستند، و در کلاسِ تشدید این عدد ۱۰۰٪ است.** مدل هیچ چیزی یاد نگرفته؛ **جوابِ برگهٔ امتحان را از قبل دیده.**

بعد همان کار را درست انجام می‌دهیم و به عددِ صادقانه می‌رسیم: **۰٫۳۸۶**. و در آخر نشتیِ دومی را پیدا می‌کنیم که حتی این عدد را هم متورم کرده بود: **با تقسیمِ درست، `F1` می‌شود ۰٫۲۵۵.**

![یک ترازو که با گذاشتنِ کپیِ همان وزنه در هر دو کفه متوازن شده](/lesson-assets/t2-s07-sampling-balance/prompt/01-image-copied-weight.png)

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

- بگویی چرا فرانمونه‌گیری **قبل** از `split` نتیجه را بی‌معنا می‌کند — و ثابتش کنی
- زیرنمونه، فرانمونه و وزنِ کلاس را با عدد مقایسه کنی
- تقسیمِ گروهی بنویسی و بگویی کِی لازم است
- تشخیص بدهی که یک عددِ خوب، خبرِ خوب است یا علامتِ خطر

## قبل از شروع

**از سرنخ ترمِ ۳:** نشتیِ داده و اینکه هر چیزی که از آزمون به آموزش برسد، متریک را بی‌معنا می‌کند. **این فصل همان درس است، ولی در جایی که کسی انتظارش را ندارد: داخلِ خودِ متوازن‌سازی.**

**از فصل ۵:** آنجا دیدیم بخشی از برچسبِ تشدید در متن نیست و مالِ چند مشتریِ پرتیکت است. **بخشِ ۷ همین را به‌عنوان یک ویژگی وارد می‌کند و می‌بینیم چه می‌شود.**

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-2-data-as-infrastructure/session-07-sampling-balance.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

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

<div dir="rtl">

## ۱. کار، و عددی که هر ادعایی باید از آن رد شود

</div>

```python
import csv
import random

ARABIC = {"ي": "ی", "ك": "ک", "ة": "ه", "أ": "ا", "إ": "ا", "ؤ": "و"}

with open(WORK / "raw" / "tickets.csv", encoding="utf-8") as fh:
    raw = list(csv.DictReader(fh))

seen, DATA = set(), []
for r in raw:
    key = tuple(r.values())
    if key in seen or not r["text"].strip():
        continue
    seen.add(key)
    text = r["text"]
    for a, b in ARABIC.items():
        text = text.replace(a, b)
    r["text"] = " ".join(text.replace("‌", " ").split())
    DATA.append(r)

X = [r["text"] for r in DATA]
Y = [int(r["escalated"]) for r in DATA]
G = [r["customer_id"] for r in DATA]
print("ردیف:", len(DATA), "· تشدید:", sum(Y),
      f"({100 * sum(Y) / len(Y):.1f}٪)")
print("دقتِ «همیشه نه»:", round(1 - sum(Y) / len(Y), 4))
```

```text
ردیف: 1195 · تشدید: 110 (9.2٪)
دقتِ «همیشه نه»: 0.9079
```

<div dir="rtl">

**۰٫۹۰۷۹ خطِ پایه است.** هر عددِ دقتی که در این فصل ببینی باید با این مقایسه شود، نه با صفر. به همین دلیل هم متریکِ اصلیِ ما `F1` است، نه دقت.

## ۲. کاری که همه اول از همه می‌کنند

فرانمونه‌گیری یعنی ردیف‌های کلاسِ کم‌شمار را آن‌قدر تکرار کنی تا دو کلاس هم‌اندازه شوند. **و تقریباً همیشه، روی کلِ داده انجام می‌شود و بعد `split` می‌آید.**

</div>

```python
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score


def oversample(xs, ys, seed):
    """کلاسِ کم‌شمار را با تکرارِ تصادفی تا اندازهٔ کلاسِ پرشمار بالا می‌آورد."""
    rng = random.Random(seed)
    minor = [i for i, y in enumerate(ys) if y == 1]
    major = [i for i, y in enumerate(ys) if y == 0]
    extra = [rng.choice(minor) for _ in range(len(major) - len(minor))]
    idx = list(range(len(ys))) + extra
    rng.shuffle(idx)
    return [xs[i] for i in idx], [ys[i] for i in idx]


def fit_score(xtr, ytr, xte, yte, seed):
    vec = CountVectorizer(min_df=1)
    model = LogisticRegression(max_iter=2000, random_state=seed)
    model.fit(vec.fit_transform(xtr), ytr)
    pred = model.predict(vec.transform(xte))
    return (accuracy_score(yte, pred), precision_score(yte, pred, zero_division=0),
            recall_score(yte, pred, zero_division=0), f1_score(yte, pred, zero_division=0))


def split(n, seed, frac=0.25):
    idx = list(range(n))
    random.Random(seed).shuffle(idx)
    cut = int(frac * n)
    return idx[cut:], idx[:cut]


def wrong_way(seed):
    bx, by = oversample(X, Y, seed)          # اول متوازن کن…
    tr, te = split(len(by), seed)            # …بعد تقسیم کن
    return fit_score([bx[i] for i in tr], [by[i] for i in tr],
                     [bx[i] for i in te], [by[i] for i in te], seed)


rows = [wrong_way(s) for s in range(5)]
print(f"{'':<6}{'دقت':>9}{'precision':>11}{'recall':>9}{'F1':>9}")
for name, col in zip(("میانگین", "کمینه", "بیشینه"),
                     (lambda v: sum(v) / len(v), min, max)):
    print(f"{name:<6}" + "".join(f"{col([r[i] for r in rows]):>10.4f}" for i in range(4)))
```

```text
            دقت  precision   recall       F1
میانگین    0.8454    0.8653    0.8164    0.8400
کمینه     0.8339    0.8504    0.8014    0.8276
بیشینه    0.8598    0.8797    0.8485    0.8550
```

<div dir="rtl">

**`F1` برابرِ ۰٫۸۴، با دامنهٔ باریکِ ۰٫۸۲۸ تا ۰٫۸۵۵ در پنج `seed`.**

و این دقیقاً همان چیزی است که خطرناکش می‌کند: **پایدار است.** نوسانِ کم به آدم حسِ اطمینان می‌دهد، در حالی که تنها چیزی که ثابت کرده این است که **خرابی در هر پنج اجرا یکسان اتفاق افتاده.**

> ⚠️ **مواظب باش:** اینجا همان قانونِ «وقتی کار کرد، اول شک کن» است. یک کارِ نامتوازنِ ۹٪ که با یک مدلِ خطیِ ساده به `F1` برابرِ ۰٫۸۴ برسد، **تقریباً همیشه** یعنی جایی نشتی هست. **قبل از جشن گرفتن، دنبالِ نشتی بگرد.**

## ۳. مدرکِ جرم

</div>

```python
seed = 0
bx, by = oversample(X, Y, seed)
tr, te = split(len(by), seed)
train_rows = {(bx[i], by[i]) for i in tr}
dup = sum((bx[i], by[i]) in train_rows for i in te)
pos_te = [i for i in te if by[i] == 1]
dup_pos = sum((bx[i], by[i]) in train_rows for i in pos_te)
print("ردیف‌های آزمون          :", len(te))
print("عیناً در آموزش هم هستند :", dup, f"({100 * dup / len(te):.1f}٪)")
print("و در کلاسِ تشدید        :", dup_pos, "از", len(pos_te),
      f"({100 * dup_pos / len(pos_te):.1f}٪)")
```

```text
ردیف‌های آزمون          : 542
عیناً در آموزش هم هستند : 404 (74.5٪)
و در کلاسِ تشدید        : 271 از 271 (100.0٪)
```

<div dir="rtl">

**هر ۲۷۱ ردیفِ تشدیدِ دادهٔ آزمون، کپیِ یک ردیفِ دادهٔ آموزش‌اند. هر ۲۷۱تا. صد درصد.**

مکانیزمش ساده است و به همین دلیل هم کسی نمی‌بیندش: **فرانمونه‌گیری ردیف‌ها را کپی می‌کند.** یک ردیفِ تشدید که ده بار تکرار شده، ده کپی دارد؛ `split` تصادفی آن‌ها را بینِ دو طرف پخش می‌کند و **تقریباً محال است که هر ده کپی یک طرف بیفتند.**

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

> ✅ **چک کن:** این تله فقط مالِ فرانمونه‌گیری نیست. **هر عملیاتی که قبل از `split` کلِ داده را ببیند** همین کار را می‌کند: نرمال‌سازی با میانگینِ کلِ داده، انتخابِ ویژگی روی کلِ داده، پر کردنِ خانه‌های خالی با میانهٔ کلِ داده. **قاعدهٔ ساده: `split` باید اولین کار باشد، نه آخرین.**

## ۴. حالا درست انجامش بده

</div>

```python
def right_way(seed, mode="oversample"):
    tr, te = split(len(Y), seed)             # اول تقسیم کن…
    xtr = [X[i] for i in tr]
    ytr = [Y[i] for i in tr]
    if mode == "oversample":
        xtr, ytr = oversample(xtr, ytr, seed)   # …بعد فقط آموزش را متوازن کن
    return fit_score(xtr, ytr, [X[i] for i in te], [Y[i] for i in te], seed)


rows_ok = [right_way(s) for s in range(5)]
print(f"{'':<6}{'دقت':>9}{'precision':>11}{'recall':>9}{'F1':>9}")
for name, col in zip(("میانگین", "کمینه", "بیشینه"),
                     (lambda v: sum(v) / len(v), min, max)):
    print(f"{name:<6}" + "".join(f"{col([r[i] for r in rows_ok]):>10.4f}" for i in range(4)))
```

```text
            دقت  precision   recall       F1
میانگین    0.8523    0.2898    0.5880    0.3864
کمینه     0.8289    0.2500    0.5000    0.3448
بیشینه    0.8725    0.3393    0.6364    0.4270
```

<div dir="rtl">

**۰٫۸۴۰ شد ۰٫۳۸۶. تفاوت فقط دو خطِ جابه‌جاشده بود.**

و به `precision` نگاه کن: **۰٫۸۶۵ شد ۰٫۲۹۰.** یعنی از هر ده تیکتی که مدل «تشدید» می‌خواند، هفت‌تایش نیست. **این عددِ واقعیِ سامانه است**، و اگر بر اساسِ آن ۰٫۸۶۵ به کسی قول داده بودی، حالا باید توضیحش می‌دادی.

**دامنه هم عوض شد: از ۰٫۸۲۸ تا ۰٫۸۵۵ به ۰٫۳۴۵ تا ۰٫۴۲۷.** عددِ صادقانه **نوسانِ بیشتری** دارد، چون در این پنج `seed` فقط ۲۰ تا ۳۳ تشدیدِ واقعی در دادهٔ آزمون هست. **گزارشِ درست «۰٫۳۹» نیست؛ «۰٫۳۹ با دامنهٔ ۰٫۳۵ تا ۰٫۴۳ روی پنج `seed`» است.**

## ۵. چهار روش، و اینکه هیچ‌کدام معجزه نمی‌کند

</div>

```python
def undersample(xs, ys, seed):
    rng = random.Random(seed)
    minor = [i for i, y in enumerate(ys) if y == 1]
    major = [i for i, y in enumerate(ys) if y == 0]
    idx = minor + rng.sample(major, len(minor))
    rng.shuffle(idx)
    return [xs[i] for i in idx], [ys[i] for i in idx]


def weighted(seed):
    tr, te = split(len(Y), seed)
    vec = CountVectorizer(min_df=1)
    model = LogisticRegression(max_iter=2000, random_state=seed,
                               class_weight="balanced")
    model.fit(vec.fit_transform([X[i] for i in tr]), [Y[i] for i in tr])
    pred = model.predict(vec.transform([X[i] for i in te]))
    yte = [Y[i] for i in te]
    return (accuracy_score(yte, pred), precision_score(yte, pred, zero_division=0),
            recall_score(yte, pred, zero_division=0), f1_score(yte, pred, zero_division=0))


def under_way(seed):
    tr, te = split(len(Y), seed)
    xtr, ytr = undersample([X[i] for i in tr], [Y[i] for i in tr], seed)
    return fit_score(xtr, ytr, [X[i] for i in te], [Y[i] for i in te], seed)


def table(name, fn):
    rs = [fn(s) for s in range(5)]
    m = [sum(r[i] for r in rs) / len(rs) for i in range(4)]
    f1s = [r[3] for r in rs]
    print(f"  {name:<22}{m[0]:>8.4f}{m[1]:>11.4f}{m[2]:>9.4f}{m[3]:>9.4f}"
          f"   [{min(f1s):.3f}–{max(f1s):.3f}]")


print(f"  {'روش':<22}{'دقت':>8}{'precision':>11}{'recall':>9}{'F1':>9}   دامنهٔ F1")
table("هیچ‌کاری", lambda s: right_way(s, mode="none"))
table("فرانمونه (درست)", lambda s: right_way(s, mode="oversample"))
table("زیرنمونه", under_way)
table("وزنِ کلاس", weighted)
table("فرانمونه قبل از split", wrong_way)
```

```text
  روش                        دقت  precision   recall       F1   دامنهٔ F1
  هیچ‌کاری                0.9087     0.3695   0.2060   0.2616   [0.222–0.308]
  فرانمونه (درست)         0.8523     0.2898   0.5880   0.3864   [0.345–0.427]
  زیرنمونه                0.7919     0.2285   0.6821   0.3412   [0.289–0.414]
  وزنِ کلاس               0.8436     0.2769   0.6062   0.3791   [0.339–0.458]
  فرانمونه قبل از split   0.8454     0.8653   0.8164   0.8400   [0.828–0.855]
```

<div dir="rtl">

**سه چیز در این جدول هست.**

**۱) «هیچ‌کاری» بالاترین دقت را دارد و بی‌فایده‌ترین است.** ۰٫۹۰۸۷ یعنی دقیقاً همان خطِ پایهٔ «همیشه نه». `recall` برابرِ ۰٫۲۰۶ می‌گوید هشتاد درصدِ تشدیدها را ندیده. **همان تلهٔ فصلِ ۵، این بار روی یک مدل.**

**۲) هر سه روشِ متوازن‌سازی همان معامله را می‌کنند: `recall` بالا، `precision` پایین.** فرانمونه، زیرنمونه و وزنِ کلاس عملاً یک کار می‌کنند — **آستانهٔ تصمیم را جابه‌جا می‌کنند** — و اختلافِ `F1` شان (۰٫۳۴ تا ۰٫۳۹) با دامنه‌های خودشان هم‌پوشانی دارد. **پس ادعای «فرانمونه بهتر از وزنِ کلاس است» را از این جدول نمی‌شود درآورد.**

**۳) زیرنمونه بیشترین `recall` و کمترین دقت را داد**، چون برای هم‌اندازه کردنِ دو کلاس، نُه‌دهمِ ردیف‌های «نه» را از دادهٔ آموزش دور می‌ریزد و مدل با کمتر از دویست ردیف آموزش می‌بیند. **روی دادهٔ کوچک این گران است**؛ روی دادهٔ بزرگ ارزان‌ترین گزینه است، چون آموزش را ده برابر سریع می‌کند.

> 📏 **اندازه بگیر:** **با چه چیزی مقایسه شد؟** با خطِ پایهٔ «همیشه نه» و با «هیچ‌کاری» — بدونِ این دو ردیف، هیچ‌کدام از عددهای دیگر معنا نداشتند. **روی کدام داده؟** یک مجموعهٔ آزمونِ **دست‌نخورده** که هیچ‌وقت متوازن نشد؛ **دادهٔ آزمون باید توزیعِ واقعی را نگه دارد، وگرنه داری روی دنیایی امتحان می‌دهی که وجود ندارد.** **با چند `seed`؟** پنج‌تا، و ستونِ دامنه عمداً کنارِ میانگین است چون بدونِ آن ۰٫۳۸۶ و ۰٫۳۴۱ دو عددِ متفاوت به‌نظر می‌رسند.

## ۶. نشتیِ دومی که هنوز آنجاست

</div>

```python
def group_split(groups, seed, frac=0.25):
    """هر مشتری کاملاً یا در آموزش است یا در آزمون — هرگز در هر دو."""
    names = sorted(set(groups))
    random.Random(seed).shuffle(names)
    held, held_rows, target = set(), 0, frac * len(groups)
    for g in names:
        if held_rows >= target:
            break
        held.add(g)
        held_rows += sum(1 for x in groups if x == g)
    te = [i for i, g in enumerate(groups) if g in held]
    tr = [i for i, g in enumerate(groups) if g not in held]
    return tr, te


tr, te = split(len(Y), 0)
print("مشتری‌های مشترکِ آموزش و آزمون — تقسیمِ تصادفی:",
      len({G[i] for i in tr} & {G[i] for i in te}))
tr, te = group_split(G, 0)
print("همان عدد — تقسیمِ گروهی                     :",
      len({G[i] for i in tr} & {G[i] for i in te}))
```

```text
مشتری‌های مشترکِ آموزش و آزمون — تقسیمِ تصادفی: 145
همان عدد — تقسیمِ گروهی                     : 0
```

<div dir="rtl">

**۱۴۵ مشتری در هر دو طرفِ تقسیم هستند.**

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

**سؤالِ درست این نیست که «مدل چقدر خوب پیش‌بینی می‌کند»؛ این است که «برای مشتری‌ای که ندیده چقدر خوب پیش‌بینی می‌کند».**

## ۷. و حالا همان ویژگی‌ای که فصلِ ۵ پیشنهاد داد

فصلِ ۵ به این رسید که «اطلاعاتِ مشتری را به‌عنوان ویژگی وارد کن». **می‌کنیم، و هر دو تقسیم را کنارِ هم می‌گذاریم.**

</div>

```python
X_CUST = [f"{t} cust_{g}" for t, g in zip(X, G)]


def experiment(texts, splitter, seed):
    tr, te = splitter(seed)
    xtr, ytr = oversample([texts[i] for i in tr], [Y[i] for i in tr], seed)
    return fit_score(xtr, ytr, [texts[i] for i in te], [Y[i] for i in te], seed)


def row_split(seed):
    return split(len(Y), seed)


def cust_split(seed):
    return group_split(G, seed)


print(f"  {'ویژگی‌ها':<14}{'تقسیم':<12}{'دقت':>8}{'precision':>11}{'recall':>9}{'F1':>9}   دامنهٔ F1")
for tname, texts in (("فقط متن", X), ("متن + مشتری", X_CUST)):
    for sname, splitter in (("تصادفی", row_split), ("گروهی", cust_split)):
        rs = [experiment(texts, splitter, s) for s in range(5)]
        m = [sum(r[i] for r in rs) / len(rs) for i in range(4)]
        f1s = [r[3] for r in rs]
        print(f"  {tname:<14}{sname:<12}{m[0]:>8.4f}{m[1]:>11.4f}"
              f"{m[2]:>9.4f}{m[3]:>9.4f}   [{min(f1s):.3f}–{max(f1s):.3f}]")
```

```text
  ویژگی‌ها      تقسیم            دقت  precision   recall       F1   دامنهٔ F1
  فقط متن       تصادفی        0.8523     0.2898   0.5880   0.3864   [0.345–0.427]
  فقط متن       گروهی         0.8271     0.1855   0.4399   0.2554   [0.151–0.351]
  متن + مشتری   تصادفی        0.8752     0.3504   0.6779   0.4604   [0.418–0.514]
  متن + مشتری   گروهی         0.8790     0.2375   0.3455   0.2720   [0.175–0.392]
```

<div dir="rtl">

**این چهار ردیف کلِ درسِ فصل‌اند.**

با تقسیمِ تصادفی، اضافه کردنِ ویژگیِ مشتری `F1` را از ۰٫۳۸۶ به ۰٫۴۶۰ می‌برد — **۱۹٪ بهبود، و هر کسی این را در گزارش می‌نویسد.**

با تقسیمِ گروهی، همان ویژگی `F1` را از ۰٫۲۵۵ به ۰٫۲۷۲ می‌برد — **و دامنه‌هایشان (۰٫۱۵–۰٫۳۵ و ۰٫۱۸–۰٫۳۹) کاملاً روی هم افتاده‌اند. یعنی هیچ.**

**پس آن «۱۹٪ بهبود» بهبود نبود؛ اجازهٔ حفظ کردن بود.** مدل یاد گرفت کدام مشتری‌ها همیشه شکایت می‌کنند، و چون همان مشتری‌ها در دادهٔ آزمون هم بودند، پاداش گرفت. **برای مشتریِ تازه — یعنی همان چیزی که در تولید بیشترش را می‌بینی — این ویژگی هیچ‌چیز نیست.**

**و ستونِ دقت این را کاملاً پنهان می‌کند:** بالاترین دقتِ کلِ جدول (۰٫۸۷۹۰) مالِ ردیفی است که `F1` اش از هر دو ردیفِ تقسیمِ تصادفی خیلی پایین‌تر است.

## ۸. جمع‌بندی: دو دروغ و یک عدد

</div>

| چه چیزی گزارش شد | `F1` | چه چیزی واقعاً سنجیده شد |
|---|---|---|
| فرانمونه قبل از `split` | **۰٫۸۴۰** | حفظ کردنِ ردیف‌های کپی‌شده |
| فرانمونهٔ درست، تقسیمِ تصادفی | **۰٫۳۸۶** | پیش‌بینی برای مشتریِ **آشنا** |
| متن + مشتری، تقسیمِ تصادفی | **۰٫۴۶۰** | حفظ کردنِ نامِ مشتری‌های شاکی |
| فرانمونهٔ درست، تقسیمِ گروهی | **۰٫۲۵۵** | پیش‌بینی برای مشتریِ **تازه** |

<div dir="rtl">

**تنها عددی که به تولید شبیه است، آخری است.**

> 🔧 **اگر کار نکرد:** اگر عددهایت با کتاب کمی فرق دارند، طبیعی است — کتابخانه‌ها نسخه به نسخه کمی متفاوت‌اند. ولی **اگر ردیفِ اولِ جدول به ۰٫۸۴ نرسید، احتمالاً `oversample` را روی `X` و `Y` صدا نزده‌ای بلکه روی زیرمجموعهٔ آموزش زده‌ای** — یعنی ناخواسته کارِ درست را کرده‌ای. و اگر ردیفِ آخر بالاتر از ردیفِ سومش درآمد، `group_split` مشتری‌ها را واقعاً جدا نکرده؛ همان دو خطِ شمارشِ بخشِ ۶ را دوباره اجرا کن، باید صفر بدهد.

> 🤖 **از دستیارت بپرس:** «تفاوتِ `SMOTE` با فرانمونه‌گیریِ ساده چیست و آیا تلهٔ ‹قبل از split› را حل می‌کند؟» بعد این را هم بپرس: **«اگر داده‌ام ستونِ زمان دارد، تقسیمِ تصادفی چه نشتیِ دیگری می‌سازد؟»** — جوابِ دوم تلهٔ سومی است که این فصل به آن نپرداخت و در هر سامانهٔ واقعی هست.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| class imbalance | کلاس ایمبالانس | وقتی یک کلاس خیلی کم‌شمارتر از دیگری است |
| oversampling | اوورسمپلینگ | تکرارِ نمونه‌های کلاسِ کم‌شمار |
| undersampling | آندرسمپلینگ | دور ریختنِ بخشی از کلاسِ پرشمار |
| class weight | کلاس ویت | وزنِ بیشتر برای خطای کلاسِ کم‌شمار، بدونِ دست زدن به داده |
| group split | گروپ اسپلیت | تقسیمی که هر گروه را یک‌جا در یک طرف نگه می‌دارد |
| group leakage | گروپ لیکیج | نشتی از راهِ حضورِ یک موجودیت در هر دو طرفِ تقسیم |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا دادهٔ آزمون هرگز نباید متوازن شود؟

**تمرینِ اجباری:** تلهٔ سوم را خودت بساز: به‌جای تقسیمِ تصادفی، **تقسیمِ زمانی** بزن — ۷۵٪ اولِ `created_at` آموزش و ۲۵٪ آخر آزمون. `F1` را برای «فقط متن» بگیر و با هر دو ردیفِ جدولِ بخشِ ۷ مقایسه کن. **کدام‌یک به تقسیمِ گروهی نزدیک‌تر است و چرا؟** بعد یک قدم جلوتر: **تقسیمی بساز که هم گروهی باشد و هم زمانی.** چند ردیف باقی می‌ماند؟

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

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t2/s07-sampling-balance (یادستان, Yaadestan)
