داربست — خودآموز MLOps و مهندسی سامانه‌های هوش مصنوعی (پیشرفته)

فصل ۶ از ۹

پیشرفت ترم
۰٪

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

در پیکرهٔ ما یک جملهٔ واحد چهار شکلِ متفاوت دارد و کامپیوتر آن‌ها را چهار چیزِ بی‌ربط می‌بیند. یک نرمال‌سازِ پنج‌گامی می‌نویسیم و واژگان از ۷۴۴ به ۴۲۱ می‌آید — ۴۳٪ کمتر.

بعد سؤالِ سختش را می‌پرسیم: این ۴۳٪ چقدر می‌ارزد؟ جواب یک عدد نیست، یک منحنی است: با ۴۰ نمونهٔ آموزش، دقت ۴٫۶ واحد بالا می‌رود و در هر پنج seed بهتر است؛ با ۳۲۰ نمونه، اختلاف دقیقاً صفر می‌شود.

قالب‌های حروفِ چاپی که شکل‌های تقریباً یکسان در یک خانه ریخته می‌شوند

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

  • نرمال‌سازِ فارسی را از اجزای اولیه بنویسی، بدونِ هیچ کتابخانه‌ای
  • اثرِ هر گام را جدا اندازه بگیری و گام‌های بی‌اثر را بشناسی
  • نرخِ واژهٔ ناشناخته را به‌عنوان متریکِ میانی گزارش کنی
  • بگویی نرمال‌سازی کِی مهم است و کِی هیچ فرقی نمی‌کند

قبل از شروع#

از فصل ۵: آنجا دو خط نوشتیم — ي را ی کردیم و نیم‌فاصله را فاصله — و هیچ دلیلی نیاوردیم. این فصل بدهیِ همان دو خط را می‌پردازد.

از سرنخ ترمِ ۳: CountVectorizer و LogisticRegression فقط به‌عنوان ترازو.

💡 نکته: hazm کتابخانهٔ شناخته‌شدهٔ پردازشِ متنِ فارسی است و نرمال‌سازِ آماده دارد. ما اینجا خودمان می‌نویسیمش، چون نرمال‌سازی مجموعه‌ای از تصمیم‌هاست و هر تصمیم را باید بتوانی اندازه بگیری و عوض کنی. بعد از این فصل، اگر hazm را برداری، دقیقاً می‌دانی چه چیزی را به آن سپرده‌ای.

📓 نوت‌بوک: نوت‌بوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

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

۱. یک جمله، چهار شکل#

import pandas as pd

ZWNJ = "‌"                       # نیم‌فاصله: یک نویسهٔ واقعی که دیده نمی‌شود

RAW = WORK / "raw" / "tickets.csv"
df = pd.read_csv(RAW).drop_duplicates().reset_index(drop=True)
print("ردیف:", len(df), "· متنِ خالی:", int(df["text"].isna().sum()))

found = [t for t in df["text"] if isinstance(t, str) and "سبد خر" in t]
seen = []
for t in found:
    core = t.strip()[:46]
    if core not in seen:
        seen.append(core)
for s in seen[:4]:
    print("|" + s.replace(ZWNJ, "<zwnj>") + "|")
ردیف: 1200 · متنِ خالی: 5
|بعد از به روزرساني سبد خريد خالي نشان داده مي |
|بعد از به روزرسانی سبد خرید خالی نشان داده می |
|بعد از به<zwnj>روزرسانی سبد خرید خالی نشان داده می<zwnj>|
|بعد از بهروزرساني سبد خريد خالي نشان داده ميشو|

یک جمله، چهار رشتهٔ کاملاً متفاوت.

نیم‌فاصله را عمداً با <zwnj> نشان دادیم، چون خودش یک نویسهٔ نامرئی است و در خروجیِ ساده اصلاً دیده نمی‌شود. سه تفاوت اینجا هست و هر سه در دادهٔ فارسیِ واقعی همیشگی‌اند:

  • ي و ك عربی در برابرِ ی و ک فارسی. روی صفحه‌کلیدهای مختلف حرف‌های متفاوتی تایپ می‌شوند که تقریباً یک شکل دارند.
  • نیم‌فاصله‌ای که فاصلهٔ معمولی شده (به روزرسانی).
  • نیم‌فاصله‌ای که کلاً حذف شده (بهروزرسانی، میشود).

برای چشمِ آدم هر چهارتا یک جمله‌اند. برای هر مدلی که روی توکن کار می‌کند، چهار چیزِ بی‌ربط‌اند.

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

try:
    df["clean"] = [t.replace("ي", "ی") for t in df["text"]]
except AttributeError as e:
    print("AttributeError:", e)
AttributeError: 'float' object has no attribute 'replace'

🔧 اگر کار نکرد: این خطا هر بار که با متنِ واقعی کار کنی سراغت می‌آید. پنج تیکت در پیکرهٔ ما متن ندارند و pandas خانهٔ خالیِ یک ستونِ متنی را NaN می‌خواند، که یک float است — و float تابعِ replace ندارد. دو راهِ غلط و یک راهِ درست دارد: fillna("") بی‌سروصدا ادامه می‌دهد و بعد نمی‌دانی چند ردیف بی‌متن بوده؛ dropna() ردیف را کلاً دور می‌ریزد در حالی که نُه ستونِ دیگرش سالم است. راهِ درست: صریح تبدیلش کن و شمارش را ثبت کن — همان کاری که در فصلِ ۳ با گزارشِ کیفیت کردیم.

۳. اول اندازه بگیر: واژگان چقدر است#

import re

PUNCT = "،؛؟!.:()«»…\"'-—"


def tokens(text):
    for ch in PUNCT:
        text = text.replace(ch, " ")
    return [t for t in text.split() if t]


def vocab(texts):
    out = set()
    for t in texts:
        out.update(tokens(t))
    return out


texts_raw = [t if isinstance(t, str) else "" for t in df["text"]]
V0 = vocab(texts_raw)
print("واژگانِ خام:", len(V0), "· کلِ توکن‌ها:", sum(len(tokens(t)) for t in texts_raw))
واژگانِ خام: 744 · کلِ توکن‌ها: 17537

۷۴۴ واژهٔ متمایز در ۱۷۵۳۷ توکن. این عددِ پایه است و هر گامِ بعدی با آن سنجیده می‌شود.

اندازهٔ واژگان مهم است چون مستقیماً تعدادِ ویژگی‌های مدل را تعیین می‌کند. واژگانِ متورم یعنی ویژگی‌های بیشتر، نمونهٔ کمتر برای هرکدام، و مدلی که «کتاب» و «كتاب» را دو چیزِ بی‌ربط یاد می‌گیرد.

۴. نرمال‌ساز، گام‌به‌گام و با عدد#

یکی از پنج گامِ زیر — نیم‌فاصله — الگویی دارد که باید قبل از دیدنش بخوانی، وگرنه تمرینِ اجباریِ آخرِ فصل بی‌معنا می‌شود. ترمِ ۲ فصلِ ۳ پنج نشانهٔ پایه را داد؛ این‌یکی دو نشانهٔ ششم و هفتم است:

  • (?<!...) — نگاه به پشت (منفی): «فقط وقتی جور بشو که بلافاصله قبلش این چیز نباشد». خودش هیچ نویسه‌ای نمی‌خورد؛ فقط شرط می‌گذارد.
  • (?=...) — نگاه به جلو (مثبت): «فقط وقتی جور بشو که بلافاصله بعدش این چیز باشد». این هم چیزی نمی‌خورد.

پس (?<![؀-ۿ])(ن?می) +(?=[؀-ۿ]) را کلمه‌به‌کلمه بخوان: «می یا نمی که قبلش حرفِ فارسی نباشد، بعدش یک یا چند فاصله، و بعد از آن فاصله‌ها یک حرفِ فارسی بیاید». بازهٔ [؀-ۿ] هم یعنی «هر نویسه‌ای در بلوکِ عربیِ یونیکد» — که حروفِ فارسی همان‌جا هستند.

و چرا این‌همه شرط؟ چون بدونشان الگو «قدیمی است» را هم می‌چسباند:

NAIVE = re.compile(r"(ن?می) +")                  # همان الگو، بدونِ نگاه به پشت و جلو
GUARDED = re.compile(r"(?<![؀-ۿ])(ن?می) +(?=[؀-ۿ])")
SAMPLE = "او می رود، این گوشیِ قدیمی است، و نمی ارزد"
for name, rx in (("بدونِ نگاه", NAIVE), ("با نگاه  ", GUARDED)):
    print(f"  {name}", rx.sub(r"\1" + ZWNJ, SAMPLE).replace(ZWNJ, "[نیم‌فاصله]"))
  بدونِ نگاه او می[نیم‌فاصله]رود، این گوشیِ قدیمی[نیم‌فاصله]است، و نمی[نیم‌فاصله]ارزد
  با نگاه   او می[نیم‌فاصله]رود، این گوشیِ قدیمی است، و نمی[نیم‌فاصله]ارزد

«قدیمی است» به «قدیمی‌است» تبدیل شد — یک کلمهٔ ساختگی که در هیچ متنی وجود ندارد. نگاه به پشت جلویش را گرفت، چون قبل از آن می حرفِ ی نشسته بود. یک گامِ نرمال‌سازی که واژهٔ تازه بسازد، واژگان را کوچک نمی‌کند؛ کثیف‌ترش می‌کند — و بخشِ ۶ همین را با عدد نشان می‌دهد.

ARABIC = {"ي": "ی", "ك": "ک", "ة": "ه", "ۀ": "ه", "أ": "ا", "إ": "ا", "ؤ": "و"}
DIGITS = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
HARAKAT = re.compile("[ً-ْٰ]")
PREFIX = re.compile(r"(?<![؀-ۿ])(ن?می) +(?=[؀-ۿ])")
SUFFIX = re.compile(r"(?<=[؀-ۿ]) +(ها|های|هایی|تر|تری|ترین|ام|ات|اش)"
                    r"(?![؀-ۿ])")


def step_letters(t):
    for a, b in ARABIC.items():
        t = t.replace(a, b)
    return t


def step_digits(t):
    return t.translate(DIGITS)


def step_harakat(t):
    return HARAKAT.sub("", t)


def step_space(t):
    return " ".join(t.split())


def step_zwnj(t):
    t = PREFIX.sub(r"\1" + ZWNJ, t)
    return SUFFIX.sub(ZWNJ + r"\1", t)


STEPS = [("حروفِ عربی", step_letters), ("رقم‌ها", step_digits),
         ("اعراب", step_harakat), ("فاصله‌ها", step_space),
         ("نیم‌فاصله", step_zwnj)]

current = list(texts_raw)
print(f"{'گام':<14}{'واژگان':>9}{'کاهش':>8}")
print(f"{'خام':<14}{len(V0):>9}{'-':>8}")
before = len(V0)
for name, fn in STEPS:
    current = [fn(t) for t in current]
    n = len(vocab(current))
    print(f"{name:<14}{n:>9}{before - n:>8}")
    before = n


def normalize(t):
    for _name, fn in STEPS:
        t = fn(t)
    return t


texts_norm = current
print("کاهشِ کل:", len(V0), "→", len(vocab(texts_norm)),
      f"({100 * (len(V0) - len(vocab(texts_norm))) / len(V0):.1f}٪)")
گام              واژگان    کاهش
خام                 744       -
حروفِ عربی          601     143
رقم‌ها              601       0
اعراب               436     165
فاصله‌ها            436       0
نیم‌فاصله           421      15
کاهشِ کل: 744 → 421 (43.4٪)

۴۳٪ از واژگان، فقط تفاوتِ نگارشی بود.

و جدول چیزی می‌گوید که بدونِ اندازه‌گیریِ گام‌به‌گام هرگز نمی‌دیدی: دو گام از پنج گام روی این پیکره هیچ کاهشی ندادند.

  • اعراب بیشترین اثر را داشت (۱۶۵ واژه). یک فتحه یا تشدیدِ پراکنده در وسطِ کلمه، همان کلمه را به یک واژهٔ تازه تبدیل می‌کند و چشم هیچ‌وقت نمی‌بیندش.
  • رقم‌ها صفر داد — چون تنها رقم‌های پیکرهٔ ما شماره‌ها و کدهای ملی‌اند و هر کدام یکتاست، پس تبدیلشان تعدادِ واژه‌ها را عوض نمی‌کند. ولی این گام را نگه می‌داریم، چون در فصلِ ۸ همین گام است که بازیافتِ تشخیصِ دادهٔ حساس را از ۵۱٪ به ۹۶٪ می‌برد.
  • فاصله‌ها هم صفر داد، چون split خودش فاصله‌های اضافی را می‌خورد. گامِ بی‌اثر همیشه بی‌فایده نیست؛ گامِ بی‌اثری که ندانی بی‌اثر است، خطرناک است — چون ممکن است فکر کنی مشکلی را حل کرده‌ای.

✅ چک کن: ترتیبِ گام‌ها اهمیت دارد. اگر step_zwnj را قبل از step_letters بگذاری، الگوی (ن?می) روی مي عربی نمی‌خورد و بخشی از تعمیرها انجام نمی‌شود. هر نرمال‌ساز یک زنجیره است، و ترتیبِ زنجیره بخشی از تعریفش است — پس مثلِ هر مرحلهٔ دیگرِ مسیر، باید ثبت و نسخه‌بندی شود.

۵. و چیزی که قاعده‌های ما نمی‌گیرند#

JOINED = re.compile(r"(?<![؀-ۿ])ن?می(?=[؀-ۿ])")
left = sum(1 for t in texts_norm for w in tokens(t) if JOINED.match(w))
fixed = sum(1 for t in texts_norm for w in tokens(t) if ZWNJ in w)
print("توکن‌هایی که نیم‌فاصله گرفتند :", fixed)
print("توکن‌هایی که چسبیده مانده‌اند  :", left)
print("نمونه:", sorted({w for t in texts_norm for w in tokens(t) if JOINED.match(w)})[:5])
توکن‌هایی که نیم‌فاصله گرفتند : 1805
توکن‌هایی که چسبیده مانده‌اند  : 141
نمونه: ['میدهد', 'میشود', 'میشوم', 'میکنم', 'نمیآید']

۱۴۱ توکن هنوز خرابند و ما نمی‌توانیم درستشان کنیم.

وقتی نیم‌فاصله حذف شده باشد، هیچ فاصله‌ای نمانده که قاعدهٔ ما به آن بچسبد. برای شکستنِ میشود به می‌شود باید بدانی شود یک فعل است — یعنی به یک فهرستِ واژگانی نیاز داری، نه یک الگو. hazm دقیقاً همین را دارد، و این تنها دلیلِ واقعیِ استفاده از یک کتابخانهٔ آماده است: نه اینکه کارِ سختی است، اینکه دادهٔ زبانی می‌خواهد.

و صادقانه: بدترین حالت این است که ندانی این ۱۴۱ تا مانده‌اند. حالا که عددش را داری، می‌توانی تصمیم بگیری — نگهش داری، دستی درستش کنی، یا hazm را بیاوری و همین عدد را دوباره بگیری تا ببینی چقدر کم شد.

۶. متریکِ میانی: واژهٔ ناشناخته#

قبل از رفتن سراغِ دقت، یک متریکِ ارزان‌تر و گویاتر: چند درصد از واژه‌های دادهٔ آزمون در دادهٔ آموزش دیده نشده‌اند؟

import random

VARIANTS = {"خام": texts_raw, "نرمال‌شده": texts_norm,
            "نیم‌فاصله‌زدوده": [t.replace(ZWNJ, " ") for t in texts_norm]}
labels = list(df["category"])
rng = random.Random(3)
order = list(range(len(labels)))
rng.shuffle(order)
cut = int(0.75 * len(order))


def oov(texts):
    known = vocab([texts[i] for i in order[:cut]])
    test = [texts[i] for i in order[cut:]]
    types = {w for t in test for w in tokens(t)}
    all_tok = [w for t in test for w in tokens(t)]
    return len(types - known) / len(types), sum(w not in known for w in all_tok) / len(all_tok)


for name, texts in VARIANTS.items():
    t_rate, k_rate = oov(texts)
    print(f"  {name:<16} واژگان {len(vocab(texts)):>5} ·"
          f" ناشناخته {t_rate:.3f} از انواع · {k_rate:.4f} از توکن‌ها")
  خام              واژگان   744 · ناشناخته 0.188 از انواع · 0.0207 از توکن‌ها
  نرمال‌شده        واژگان   421 · ناشناخته 0.144 از انواع · 0.0103 از توکن‌ها
  نیم‌فاصله‌زدوده  واژگان   409 · ناشناخته 0.149 از انواع · 0.0092 از توکن‌ها

نرخِ واژهٔ ناشناخته روی توکن‌ها نصف شد: ۲٫۰۷٪ به ۱٫۰۳٪.

دو ستون دو چیزِ متفاوت می‌گویند و باید هر دو را گزارش کرد. «از انواع» می‌گوید چند واژهٔ متمایز ناشناخته است؛ «از توکن‌ها» می‌گوید چند کلمهٔ واقعی در متن ناشناخته است. عددِ دوم همیشه کوچک‌تر است، چون واژه‌های نادر ذاتاً کم تکرار می‌شوند — و همین عددِ دوم است که به مدل ضربه می‌زند.

این متریک ارزان است و به مدل نیازی ندارد. اگر مسیرِ متنی می‌سازی، این را روی هر تغییرِ نرمال‌سازی بگیر؛ خیلی سریع‌تر از آموزشِ دوبارهٔ مدل به‌ت می‌گوید که در مسیرِ درستی هستی یا نه.

۷. و حالا اثرش روی یک کارِ واقعی#

کار: تشخیصِ category از متنِ تیکت — چهار کلاس. و به‌جای یک عدد، منحنی می‌گیریم: دقت در برابرِ اندازهٔ دادهٔ آموزش، هر نقطه با پنج seed.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

TEST_SIZE = 300


def run(texts, seed, n_train):
    idx = list(range(len(texts)))
    random.Random(seed).shuffle(idx)
    te = idx[-TEST_SIZE:]
    tr = idx[:n_train]
    vec = CountVectorizer(min_df=1)
    X = vec.fit_transform([texts[i] for i in tr])
    model = LogisticRegression(max_iter=2000, random_state=seed)
    model.fit(X, [labels[i] for i in tr])
    pred = model.predict(vec.transform([texts[i] for i in te]))
    return accuracy_score([labels[i] for i in te], pred)


def mean_acc(texts, n_train):
    return [run(texts, seed, n_train) for seed in range(5)]


print(f"{'آموزش':>7}{'خام':>10}{'نرمال‌شده':>14}{'اختلاف':>10}{'بهتر در':>10}")
for n in (40, 80, 160, 320, 880):
    a = mean_acc(VARIANTS["خام"], n)
    b = mean_acc(VARIANTS["نرمال‌شده"], n)
    wins = sum(y > x for x, y in zip(a, b))
    print(f"{n:>7}{sum(a) / 5:>10.4f}{sum(b) / 5:>14.4f}"
          f"{sum(b) / 5 - sum(a) / 5:>+10.4f}{wins:>7}/5")
  آموزش       خام     نرمال‌شده    اختلاف   بهتر در
     40    0.8507        0.8967   +0.0460      5/5
     80    0.9233        0.9460   +0.0227      5/5
    160    0.9913        0.9953   +0.0040      2/5
    320    0.9973        0.9973   +0.0000      0/5
    880    0.9967        0.9980   +0.0013      2/5

این جدول جوابِ کاملِ سؤالِ «نرمال‌سازیِ فارسی چقدر مهم است؟» است، و جوابْ یک عدد نیست.

با ۴۰ نمونه: ۴٫۶ واحد بهتر، و در هر پنج seed بهتر. وقتی داده کم است، هر واژه‌ای که به دو نیم شکسته شده یعنی نصفِ شواهد برای هر نیمه.

با ۳۲۰ نمونه: دقیقاً صفر. و ردیفِ ۸۸۰ حتی 2/5 است — یعنی فقط در دو seed از پنج‌تا بهتر بود و در سه‌تای دیگر دو نسخه دقیقاً مساوی شدند. آن +0.0013 نویز است، نه بهبود، و اگر فقط همان یک ردیف را گزارش می‌کردیم، یک ادعای بی‌پشتوانه ساخته بودیم.

پس نرمال‌سازی یک بردِ کارآییِ داده است، نه یک بردِ دقت. با دادهٔ فراوان، مدل خودش یاد می‌گیرد که کتاب و كتاب هر دو نشانهٔ یک چیزند — فقط برای هرکدام جداگانه شواهد لازم دارد. و دقیقاً به همین دلیل، هرچه پروژه‌ات کوچک‌تر و دادهٔ برچسب‌خورده‌ات کمتر باشد، نرمال‌سازی بیشتر می‌ارزد.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان مدل و همان ابرپارامترها روی متنِ خام — تنها متغیر، نرمال‌سازی. روی کدام داده؟ یک مجموعهٔ آزمونِ ثابتِ ۳۰۰تایی که در هر پنج نقطهٔ منحنی همان است، وگرنه اندازهٔ آزمون هم عوض می‌شد و مقایسه بی‌معنا. با چند seed؟ پنج‌تا، و ستونِ «بهتر در» عمداً کنارِ اختلافِ میانگین آمده: 5/5 یک نتیجه است، 2/5 یک تصادف.

۸. یک تصمیمِ دیگر: نیم‌فاصله را اصلاً برداریم؟#

n = 80
for name in VARIANTS:
    v = mean_acc(VARIANTS[name], n)
    print(f"  {name:<16} دقت {sum(v) / 5:.4f}  (کمینه {min(v):.4f} · بیشینه {max(v):.4f})")
  خام              دقت 0.9233  (کمینه 0.8567 · بیشینه 0.9733)
  نرمال‌شده        دقت 0.9460  (کمینه 0.8767 · بیشینه 0.9933)
  نیم‌فاصله‌زدوده  دقت 0.9460  (کمینه 0.8767 · بیشینه 0.9933)

«نیم‌فاصله را درست کن» و «نیم‌فاصله را کلاً بردار» دقیقاً یک نتیجه دادند — تا چهار رقمِ اعشار.

منطقی هم هست: مهم این نیست که به‌روزرسانی باشد یا به روزرسانی؛ مهم این است که همیشه یکی از این دو باشد. نرمال‌سازی دربارهٔ درستیِ املایی نیست، دربارهٔ یکدستی است.

پس چرا شکلِ درست را انتخاب کردیم؟ چون خروجیِ این مسیر فقط به مدل نمی‌رود؛ به گزارش، به جست‌وجو، و به چشمِ آدم هم می‌رسد. وقتی دو گزینه از نظرِ عدد یکسان‌اند، آن را انتخاب کن که برای انسان خواناتر است — و این را به‌عنوان یک تصمیمِ ثبت‌شده بنویس، نه یک عادت.

🤖 از دستیارت بپرس: «تفاوتِ normalization و stemming و lemmatization در پردازشِ متن چیست و کدامشان برای فارسی سخت‌تر است؟» بعد این را هم بپرس: «اگر مدلم به‌جای شمارشِ کلمه از یک tokenizer زیرکلمه‌ای استفاده کند، آیا هنوز به نرمال‌سازی نیاز دارم؟» — جوابش به‌ت می‌گوید که مالیاتِ فارسی به لایهٔ توکن منتقل می‌شود، نه اینکه حذف شود.

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

کلمه تلفظ به حروف فارسی یعنی چه
normalization نرمالیزیشن یکدست کردنِ شکلِ نوشتاریِ متن قبل از هر پردازشی
ZWNJ زد-دابلیو-اِن-جی نویسهٔ نامرئیِ نیم‌فاصله
diacritic دایاکریتیک اعراب: فتحه، کسره، ضمه، تشدید
vocabulary size وکبیولری سایز تعدادِ واژه‌های متمایزِ یک پیکره
type و token تایپ و توکن «واژهٔ متمایز» در برابرِ «هر بار ظاهر شدنِ آن»
OOV او-او-وی واژه‌ای که در آموزش نبوده و در آزمون هست
data efficiency دیتا افیشنسی همان کیفیت با دادهٔ کمتر

تمرین‌ها

اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.

در فصل بعد#

حالا متنِ تمیزی داریم و یک برچسبِ نادر. فصلِ بعد می‌خواهد همان برچسبِ نادر را پیش‌بینی کند، و همان کاری را می‌کند که همه اول از همه می‌کنند: متوازن کردنِ کلاس‌ها با فرانمونه‌گیری. F1 از ۰٫۲۶ به ۰٫۸۴ می‌پرد. و بعد نشان می‌دهیم که آن عدد یک دروغِ تمام‌عیار است، و عددِ صادقانه‌اش ۰٫۲۵۵ است.

به آخر این فصل رسیدی!

اگر ساختی و جواب داد، این دکمه مال توست.