در این فصل چه یاد میگیری#
ستونِ escalated را چهار فصل است مثلِ یک واقعیت بهکار میبریم. نیست. یک نفر آن را نوشته. این فصل سراغِ همان یک نفر میرود.
سه برچسبزن را با یک دستورالعملِ مبهم رها میکنیم: توافقشان بینِ ۰٫۱۲ و ۰٫۴۳ درمیآید. بعد دستورالعمل را دقیق میکنیم و همان عدد به ۰٫۶۸ میرسد — ولی دقت فقط از ۰٫۸۳۸ به ۰٫۸۵۶ میرود. توافق جهید، درستی نه.
و در آخر با یک بودجهٔ ثابتِ ۶۰۰ برچسب سه مدل آموزش میدهیم. مدلی که با برچسبِ طلایی آموزش دید، بدترینشان شد.

آخر این فصل میتوانی:
- توافقِ بینِ برچسبزنها را با
kappaاندازه بگیری و بگویی چرا توافقِ خام گمراهکننده است - دستورالعملِ برچسب را طوری بنویسی که قابلِ اجرا باشد، نه فقط قابلِ فهم
- بینِ «برچسبِ بیشتر» و «برچسبِ تمیزتر» با عدد انتخاب کنی
- بگویی چه بخشی از برچسبِ تو اصلاً در داده نیست
قبل از شروع#
از فصل ۴: داده نسخه دارد. برچسب هم داده است، پس برچسب هم نسخه دارد — و دستورالعملی که با آن زده شده، بخشی از همان نسخه است.
از سرنخ ترمِ ۳: train/test، دقت و بازیافت. اینجا از CountVectorizer و LogisticRegression فقط بهعنوان یک ترازو استفاده میکنیم؛ موضوعِ فصل مدل نیست، برچسب است.
⚠️ مواظب باش: برچسبزنهای این فصل شبیهسازیشدهاند، چون نمیشود سه آدم را داخلِ یک نوتبوک گذاشت. شبیهسازی هیچ چیزی را دربارهٔ آدمها ثابت نمیکند؛ فقط نشان میدهد با این فرضها چه عددی درمیآید و آن عدد را چطور باید خواند. عددِ واقعیِ تیمِ خودت را فقط با برچسبزنِ واقعی میگیری — و تمرینِ اجباری همان است.
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوتبوک روی CPU | حدودِ یک دقیقه |
| GPU | لازم نیست |
۱. آنچه میخواهیم برچسب بزنیم#
import csv
import random
RAW = WORK / "raw" / "tickets.csv"
with open(RAW, encoding="utf-8") as fh:
rows = list(csv.DictReader(fh))
seen = set()
DATA = []
for r in rows:
key = tuple(r.values())
if key in seen or not r["text"].strip():
continue
seen.add(key)
r["text"] = " ".join(r["text"].replace("ي", "ی").replace("ك", "ک")
.replace("", " ").split())
DATA.append(r)
POOL = DATA[:900] # چیزی که قرار است برچسب بخورد
HELD = DATA[900:] # فقط برای سنجشِ آخر
gold = {r["ticket_id"]: int(r["escalated"]) for r in DATA}
print("برچسبپذیر:", len(POOL), "· کنارگذاشته برای سنجش:", len(HELD))
print("نرخِ تشدید در کلِ داده:", round(sum(gold.values()) / len(gold), 4))
برچسبپذیر: 900 · کنارگذاشته برای سنجش: 295
نرخِ تشدید در کلِ داده: 0.0921
نرخِ تشدید ۹٪ است، و همین یک عدد کلِ فصل را شکل میدهد.
وقتی یک برچسب نادر است، حدس زدنِ «هیچوقت» ۹۱٪ درست است. پس هر عددِ دقتی که در این فصل میبینی باید با ۰٫۹۱ مقایسه شود، نه با صفر. بخشِ ۵ نشان میدهد این تله چقدر واقعی است.
۲. سه برچسبزن، یک دستورالعملِ مبهم#
دستورالعملِ اولیه یک جمله است: «اگر مشتری ناراضی است و کار به تشدید کشیده، علامت بزن.» هر سه نفر همین را خواندهاند و هر سه جورِ دیگری فهمیدهاند.
ANGRY = ["شکایت", "پاسخگو", "سومین بار", "پیگیری کردم", "هیچ کس", "دو هفته"]
SOFT = ["منتظر", "هنوز", "دوباره", "باز هم", "مجبور"]
def annotator_a(text, rng):
"""پرحساسیت: هر نشانهٔ نارضایتی را تشدید میبیند."""
flag = any(w in text for w in ANGRY + SOFT)
return flag if rng.random() > 0.05 else not flag
def annotator_b(text, rng):
"""سختگیر: فقط تهدیدِ صریح را تشدید میبیند."""
flag = "شکایت" in text
return flag if rng.random() > 0.05 else not flag
def annotator_c(text, rng):
"""میانه، ولی طولِ متن هم برایش نشانه است."""
flag = any(w in text for w in ANGRY) or len(text.split()) > 22
return flag if rng.random() > 0.05 else not flag
def label_all(fn, rows, seed):
rng = random.Random(seed)
return {r["ticket_id"]: int(fn(r["text"], rng)) for r in rows}
vague = {"الف": label_all(annotator_a, POOL, 11),
"ب": label_all(annotator_b, POOL, 12),
"ج": label_all(annotator_c, POOL, 13)}
for name, labels in vague.items():
print(f" برچسبزنِ {name}: {sum(labels.values()):>3} تشدید از {len(labels)}")
برچسبزنِ الف: 252 تشدید از 900
برچسبزنِ ب: 67 تشدید از 900
برچسبزنِ ج: 199 تشدید از 900
۲۵۲ در برابرِ ۶۷ — تقریباً چهار برابر.
سه نفر روی یک دادهٔ یکسان، با یک دستورالعملِ یکسان. همین یک ردیف کافی است که بدانی برچسبهایت قابلِ اعتماد نیستند — ولی معمولاً کسی این را نگاه نمیکند، چون هر سه نفر «کارشان را انجام دادهاند».
۳. توافق: دو عدد که یکیشان دروغ میگوید#
def agreement(x, y):
keys = list(x)
return sum(x[k] == y[k] for k in keys) / len(keys)
def kappa(x, y):
keys = list(x)
n = len(keys)
po = agreement(x, y)
pe = 0.0
for c in (0, 1):
pe += (sum(x[k] == c for k in keys) / n) * (sum(y[k] == c for k in keys) / n)
return (po - pe) / (1 - pe)
names = list(vague)
print(f"{'جفت':<10}{'توافقِ خام':>12}{'kappa':>10}")
for i in range(len(names)):
for j in range(i + 1, len(names)):
x, y = vague[names[i]], vague[names[j]]
print(f"{names[i]}-{names[j]:<8}{agreement(x, y):>12.3f}{kappa(x, y):>10.3f}")
جفت توافقِ خام kappa
الف-ب 0.726 0.122
الف-ج 0.783 0.426
ب-ج 0.787 0.188
توافقِ خام حدودِ ۰٫۷۵ است و بهنظر بد نمیآید. kappa میگوید ۰٫۱۲.
فرقشان در یک ایده است: وقتی یک برچسب نادر است، دو نفر که کورکورانه هم علامت بزنند، بیشترِ وقتها با هم موافقاند — چون هر دو تقریباً همیشه «نه» میگویند. kappa این توافقِ شانسی را کم میکند:
kappa = (po − pe) / (1 − pe)
poتوافقِ واقعیِ مشاهدهشده است — همان ۰٫۷۲۶.peتوافقی است که از شانس انتظار میرود، اگر هر کس با همان نرخِ خودش تصادفی برچسب میزد.- تفریق یعنی «چقدر بهتر از شانس»، و تقسیم بر
1 − peآن را روی بازهٔ صفر تا یک میبرد.
kappa برابرِ صفر یعنی «بهاندازهٔ شانس»، و یک یعنی توافقِ کامل. برای برچسبِ نادر، هر عددی زیرِ ۰٫۴ یعنی دادهات دربارهٔ آن برچسب چیزی نمیداند.
🌱 ریشهاش کجاست: آن
peکه در کد ضربِ دو نرخ است، دقیقاً همان قاعدهٔ «و» در ریشه، ترم ۶ فصل ۳ — «و» و «یا» در احتمال است: احتمالِ اینکه هر دو نفر همان برچسب را بدهند، حاصلضربِ دو احتمال است — ولی فقط اگر مستقل باشند. همان فصل صریح هشدار میدهد: «قبل از هر ضربی بپرس: آیا اتفاقِ اول چیزی را عوض میکند؟» و همینجا آن هشدار به کار میآید:peعمداً فرض میکند دو برچسبزن مستقل تصادفی میزنند. آن فرض غلط است — دو آدم که یک دستورالعمل خواندهاند مستقل نیستند — و به همین دلیلkappaتوافقِ شانسی را کمی بیش از واقع تخمین میزند. عدد را بهعنوان یک مقایسه بخوان، نه یک حقیقت.
۴. رأیِ اکثریت کمک میکند، ولی نه آنقدر که فکر میکنی#
def majority(labels_by_name, keys):
out = {}
for k in keys:
votes = sum(labels_by_name[n][k] for n in labels_by_name)
out[k] = int(votes * 2 > len(labels_by_name))
return out
def accuracy(labels):
return sum(labels[k] == gold[k] for k in labels) / len(labels)
def recall(labels):
pos = [k for k in labels if gold[k] == 1]
return sum(labels[k] for k in pos) / len(pos)
keys = [r["ticket_id"] for r in POOL]
maj_vague = majority(vague, keys)
for name in names:
print(f" برچسبزنِ {name}: دقت {accuracy(vague[name]):.3f} · بازیافت {recall(vague[name]):.3f}")
print(f" رأیِ اکثریت : دقت {accuracy(maj_vague):.3f} · بازیافت {recall(maj_vague):.3f}")
برچسبزنِ الف: دقت 0.719 · بازیافت 0.494
برچسبزنِ ب: دقت 0.847 · بازیافت 0.092
برچسبزنِ ج: دقت 0.793 · بازیافت 0.575
رأیِ اکثریت : دقت 0.838 · بازیافت 0.448
برچسبزنِ «ب» بالاترین دقت را دارد و بیفایدهترینشان است.
بازیافتش ۰٫۰۹۲ است: از هر ده تشدیدِ واقعی، یکی را میبیند. دقتِ ۰٫۸۴۷ اش تقریباً همان چیزی است که با «همیشه نه» میگرفت. این همان تلهٔ بخشِ ۱ است، این بار روی یک آدم.
و رأیِ اکثریت دقتش از هر سه نفر بهتر نشد — بینِ آنها نشست. رأیِ اکثریت خطای تصادفی را کم میکند، ولی وقتی سه نفر سه تعریفِ متفاوت دارند، خطا تصادفی نیست؛ سیستماتیک است. میانگین گرفتن از سه تعریفِ متفاوت، تعریفِ درست نمیسازد.
۵. برچسبزنِ تنبل، و خطایی که kappa را میشکند#
lazy = {k: 0 for k in keys}
print("توافقِ خامِ برچسبزنِ تنبل با «الف»:", round(agreement(lazy, vague["الف"]), 3))
try:
print(kappa(lazy, lazy))
except ZeroDivisionError as e:
print("ZeroDivisionError:", e)
توافقِ خامِ برچسبزنِ تنبل با «الف»: 0.72
ZeroDivisionError: float division by zero
🔧 اگر کار نکرد:
ZeroDivisionErrorاینجا یک باگ نیست، یک پیام است. وقتی هر دو طرف همیشه یک برچسب میدهند،peبرابرِ ۱ میشود و مخرج صفر. یعنی «توافقِ فراتر از شانس» تعریفنشده است، نه صفر. اگر جلوی خطا را باtry/exceptبگیری و صفر برگردانی، عددی چاپ میشود که معنایی ندارد. راهِ درست، برگرداندنِNoneو گفتنِ «قابلِ محاسبه نیست» است.
def kappa_safe(x, y):
keys = list(x)
n = len(keys)
po = agreement(x, y)
pe = sum((sum(x[k] == c for k in keys) / n) * (sum(y[k] == c for k in keys) / n)
for c in (0, 1))
if pe >= 1 - 1e-12:
return None # هر دو همیشه یک برچسب دادهاند: توافق بیمعناست
return (po - pe) / (1 - pe)
print("kappa تنبل با تنبل :", kappa_safe(lazy, lazy))
print("kappa تنبل با «الف»:", round(kappa_safe(lazy, vague["الف"]), 3))
print("دقتِ برچسبزنِ تنبل :", round(accuracy(lazy), 3))
kappa تنبل با تنبل : None
kappa تنبل با «الف»: 0.0
دقتِ برچسبزنِ تنبل : 0.903
کسی که هیچ تیکتی را باز نکرده و به همه «نه» گفته، دقتِ ۰٫۹۰۳ دارد — بالاتر از هر سه برچسبزنِ واقعی.
✅ چک کن: این عدد را نگه دار. هر وقت کسی «دقتِ ۹۰٪» را بهعنوان خبرِ خوب آورد، اول نرخِ کلاسِ نادر را بپرس. و
kappaبرابرِ ۰٫۰ در برابرِ «الف» دقیقاً همان چیزی است که باید ببینی: این آدم هیچ اطلاعاتی اضافه نکرده. توافقِ خامِ ۰٫۷۲ این را پنهان میکرد.
۶. حالا دستورالعمل را قابلِ اجرا کن#
جملهٔ مبهم را با یک تعریفِ عملیاتی عوض میکنیم: «تشدید یعنی متن یکی از این شش عبارت را داشته باشد» — با فهرستِ صریح، بدونِ جای قضاوت.
RULE = ["شکایت", "پاسخگو", "سومین بار", "پیگیری کردم", "هیچ کس", "دو هفته"]
def by_rule(text, rng, slip):
flag = any(w in text for w in RULE)
return flag if rng.random() > slip else not flag
def label_by_rule(rows, seed, slip=0.05):
rng = random.Random(seed)
return {r["ticket_id"]: int(by_rule(r["text"], rng, slip)) for r in rows}
sharp = {name: label_by_rule(POOL, seed)
for name, seed in (("الف", 21), ("ب", 22), ("ج", 23))}
print(f"{'جفت':<10}{'توافقِ خام':>12}{'kappa':>10}")
for i in range(len(names)):
for j in range(i + 1, len(names)):
x, y = sharp[names[i]], sharp[names[j]]
print(f"{names[i]}-{names[j]:<8}{agreement(x, y):>12.3f}{kappa(x, y):>10.3f}")
maj_sharp = majority(sharp, keys)
print(f"رأیِ اکثریت: دقت {accuracy(maj_sharp):.3f} · بازیافت {recall(maj_sharp):.3f}")
print(f"قبل از دستورالعمل: دقت {accuracy(maj_vague):.3f} · بازیافت {recall(maj_vague):.3f}")
جفت توافقِ خام kappa
الف-ب 0.904 0.661
الف-ج 0.914 0.694
ب-ج 0.910 0.684
رأیِ اکثریت: دقت 0.856 · بازیافت 0.471
قبل از دستورالعمل: دقت 0.838 · بازیافت 0.448
kappa از ۰٫۱۲ به ۰٫۶۸ رفت. دقت از ۰٫۸۳۸ به ۰٫۸۵۶ و بازیافت از ۰٫۴۴۸ به ۰٫۴۷۱.
توافق پنج برابر بهتر شد، درستی دو صدم. و این مهمترین نتیجهٔ فصل است، چون خلافِ چیزی است که همه انتظار دارند:
دستورالعمل، توافق میسازد، نه حقیقت. اگر تعریفِ عملیاتیات با پدیدهٔ واقعی نخواند، سه نفر با هماهنگیِ کامل بهطورِ یکسان اشتباه میکنند — و kappaی بالا بهت اطمینانی میدهد که پشتش چیزی نیست.
در دادهٔ ما بخشی از تشدیدها اصلاً در متن نیست: مالِ چند مشتریِ پرتیکت است که کارشان همیشه به تشدید میکشد، هر چه بنویسند. هیچ دستورالعملی که فقط به متن نگاه کند آنها را نمیبیند.
📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان سه برچسبزن قبل از دستورالعمل، روی همان ۹۰۰ تیکت — و با خطِ پایهٔ «همیشه نه» با دقتِ ۰٫۹۰۳. روی کدام داده؟ برچسبها روی
POOLو سنجشِ مدل روی ۲۹۵ تیکتی که هیچوقت برچسب نخوردند. با چندseed؟ برای برچسبها یکی، چون تفاوتشان سیستماتیک است نه تصادفی؛ برای مدلِ بخشِ بعد پنج تا، و دامنهاش گزارش میشود.
۷. بودجهٔ ثابت: پهن یا عمیق؟#
۶۰۰ برچسب پول داری. ۶۰۰ تیکت با یک نفر، یا ۲۰۰ تیکت با سه نفر؟ کسی که ۶۰۰ تیکت را تنها میزند خسته میشود، پس نرخِ لغزشش را سه برابر میگیریم.
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score
TEXT = {r["ticket_id"]: r["text"] for r in DATA}
held_ids = [r["ticket_id"] for r in HELD]
held_y = [gold[k] for k in held_ids]
def train_and_score(ids, labels, seed):
vec = CountVectorizer(min_df=2)
X = vec.fit_transform([TEXT[k] for k in ids])
y = [labels[k] for k in ids]
if len(set(y)) < 2:
return 0.0
model = LogisticRegression(max_iter=1000, random_state=seed).fit(X, y)
return f1_score(held_y, model.predict(vec.transform([TEXT[k] for k in held_ids])))
solo = label_by_rule(POOL, 31, slip=0.15) # یک نفر که ۶۰۰ تیکت را تنها میزند، خسته میشود
by_book = {r["ticket_id"]: int(any(w in r["text"] for w in RULE)) for r in POOL}
print("خطای تکنفره نسبت به دستورالعمل:", round(1 - agreement(solo, by_book), 3))
print("خطای سهنفره نسبت به دستورالعمل:", round(1 - agreement(maj_sharp, by_book), 3))
wide, deep, ceiling = [], [], []
for seed in range(5):
rng = random.Random(100 + seed)
ids600 = rng.sample(keys, 600)
ids200 = rng.sample(keys, 200)
wide.append(train_and_score(ids600, solo, seed))
deep.append(train_and_score(ids200, maj_sharp, seed))
ceiling.append(train_and_score(ids600, gold, seed))
def brief(v):
return f"{sum(v) / len(v):.3f} (کمینه {min(v):.3f} · بیشینه {max(v):.3f})"
print("۶۰۰ تیکت، یک برچسبزن : F1 =", brief(wide))
print("۲۰۰ تیکت، رأیِ سه نفر : F1 =", brief(deep))
print("۶۰۰ تیکت، برچسبِ طلایی : F1 =", brief(ceiling))
خطای تکنفره نسبت به دستورالعمل: 0.141
خطای سهنفره نسبت به دستورالعمل: 0.007
۶۰۰ تیکت، یک برچسبزن : F1 = 0.326 (کمینه 0.296 · بیشینه 0.346)
۲۰۰ تیکت، رأیِ سه نفر : F1 = 0.360 (کمینه 0.360 · بیشینه 0.360)
۶۰۰ تیکت، برچسبِ طلایی : F1 = 0.183 (کمینه 0.148 · بیشینه 0.207)
سه چیز در این شش عدد هست و سومی غیرمنتظرهترین نتیجهٔ کلِ ترم است.
۱) رأیِ سهنفره خطای برچسب را از ۱۴٪ به ۰٫۷٪ آورد — بیست برابر. این همان کاری است که رأیِ اکثریت واقعاً بلد است: حذفِ لغزشِ تصادفی.
۲) و با یکسومِ داده، مدلِ بهتری داد: ۰٫۳۶۰ در برابرِ ۰٫۳۲۶. دامنهٔ ردیفِ اول (۰٫۲۹۶ تا ۰٫۳۴۶) هم زیرِ ۰٫۳۶۰ میماند، پس این اختلاف از نوسان بیرون زده. در این تنظیم، برچسبِ تمیزتر از برچسبِ بیشتر ارزشمندتر بود.
و یک چیزِ عجیب در همان ردیف هست که نباید از کنارش رد شد: دامنهاش صفر است. پنج قرعهٔ متفاوت از ۲۰۰ تیکت، پنج آموزشِ جدا، و هر پنج بار عیناً 0.360. محتملترین توضیح این است: برچسبِ سهنفره تقریباً همان قاعدهٔ ششکلمهایِ بخشِ ۶ است، و ۲۰۰ نمونه برای یاد گرفتنِ چنین قاعدهای بیش از کافی. پس هر قرعه به همان مدل و همان پیشبینیها میرسد. ولی تا وقتی خودت پیشبینیهای پنج اجرا را دو به دو مقایسه نکردهای، این فقط یک حدس است — و دامنهٔ صفر همیشه باید سؤالبرانگیز باشد، نه دلگرمکننده.
۳) و مدلی که با برچسبِ طلایی آموزش دید، بدترین شد: ۰٫۱۸۳.
این آخری را باید کامل توضیح داد، چون بهنظر بیمعنا میآید. مدل فقط چیزی را میتواند یاد بگیرد که در متن باشد. برچسبِ طلایی بخشی دارد که در متن نیست — همان مشتریهای پرتیکت — و مدل از دیدنِ آنها فقط گیج میشود: وزنهایش روی کلمههای بیربط پخش میشود و در نهایت تقریباً هیچچیز را مثبت پیشبینی نمیکند. قاعدهٔ تمیز، حقیقتِ ناقص را با ثبات یاد میدهد و برنده میشود.
و درسِ درست از این عدد این نیست که «برچسبِ واقعی را دور بریز». درسش این است: اگر بخشی از برچسبت از چیزی میآید که در ویژگیهایت نیست، هیچ مقدار دادهای آن را جبران نمیکند. یا آن اطلاعات را بهعنوان ویژگی وارد کن، یا صریح بپذیر که سقفت پایینتر است. فصلِ ۷ نشان میدهد که وارد کردنِ همان اطلاعات — شناسهٔ مشتری — تلهٔ خودش را دارد.
۸. و هزینه#
SECONDS = 40
for n_items, n_annot, name in ((600, 1, "پهن"), (200, 3, "عمیق")):
total = n_items * n_annot
print(f" {name:<6} {n_items} تیکت × {n_annot} نفر = {total} برچسب ·"
f" {total * SECONDS / 3600:.1f} ساعت")
پهن 600 تیکت × 1 نفر = 600 برچسب · 6.7 ساعت
عمیق 200 تیکت × 3 نفر = 600 برچسب · 6.7 ساعت
عددِ ۴۰ ثانیه یک فرض است، نه اندازهگیری — و اولین چیزی است که باید در پروژهٔ خودت با کرنومتر جایش را بگیری. ولی نکته این است که هر دو ستون یک هزینه دارند و یکیشان مدلِ بهتری داد.
پس «چند برچسب داریم؟» سؤالِ اشتباهی است. سؤالِ درست این است: با این بودجه، چه ترکیبی از تعداد و کیفیت بهترین مدل را میدهد؟ و جوابش برای هر داده فرق میکند، پس باید اندازهاش گرفت — دقیقاً همان جدولِ بالا، با دادهٔ خودت.
🤖 از دستیارت بپرس: «تفاوتِ
Cohen's kappaوFleiss' kappaچیست و برای سه برچسبزن کدام درستتر است؟» بعد این را هم بپرس: «اگر برچسبزنها بهجای بله و خیر، نمرهٔ ۱ تا ۵ بدهند، توافق را با چه چیزی باید سنجید؟» — و ببین چرا آنجاkappaی وزندار لازم میشود.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| annotation guideline | اَنوتیشن گایدلاین | دستورالعملی که میگوید چه چیزی چه برچسبی میگیرد |
| inter-annotator agreement | اینتر-اَنوتیتور اگریمنت | میزانِ همخوانیِ برچسبِ دو یا چند نفر |
| kappa | کاپا | توافق پس از کم کردنِ توافقِ شانسی |
| majority vote | مجوریتی وت | برچسبِ نهایی از رأیِ اکثریتِ برچسبزنها |
| operational definition | آپریشنال دفینیشن | تعریفی که بهجای قضاوت، قابلِ اجراست |
| label noise | لیبل نویز | خطای تصادفی در برچسبها |
| gold label | گلد لیبل | برچسبی که بهعنوان مرجع پذیرفته میشود |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
در همین فصل، اولین کاری که با متن کردیم این بود: ي را ی کردیم و نیمفاصله را فاصله. دو خط کد، بدونِ هیچ توضیحی و بدونِ هیچ اندازهگیریای. فصلِ بعد همان دو خط را جدی میگیرد: اندازهٔ واژگان قبل و بعد از نرمالسازی، و اثرش روی دقتِ یک کارِ واقعی — با پنج seed، چون بدونِ آن هیچکدام از این عددها معنایی ندارند.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.