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

فصل ۷ از ۹

پیشرفت ترم
۰٪

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

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

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

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

یک ترازو که با گذاشتنِ کپیِ همان وزنه در هر دو کفه متوازن شده

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

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

قبل از شروع#

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

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

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

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

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

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))
ردیف: 1195 · تشدید: 110 (9.2٪)
دقتِ «همیشه نه»: 0.9079

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

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

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

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)))
            دقت  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

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

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

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

۳. مدرکِ جرم#

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}٪)")
ردیف‌های آزمون          : 542
عیناً در آموزش هم هستند : 404 (74.5٪)
و در کلاسِ تشدید        : 271 از 271 (100.0٪)

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

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

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

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

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

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)))
            دقت  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

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

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

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

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

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)
  روش                        دقت  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]

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

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

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

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

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

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

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}))
مشتری‌های مشترکِ آموزش و آزمون — تقسیمِ تصادفی: 145
همان عدد — تقسیمِ گروهی                     : 0

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

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

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

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

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

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}]")
  ویژگی‌ها      تقسیم            دقت  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]

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

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

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

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

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

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

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

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

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

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

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

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

تمرین‌ها

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

در فصل بعد#

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

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

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