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

فصل ۵ از ۹

پیشرفت ترم
۰٪

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

ستونِ 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، چون بدونِ آن هیچ‌کدام از این عددها معنایی ندارند.

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

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