ژرفا — خودآموز یادگیری عمیق و مهندسی هوش مصنوعی (متوسط)

فصل ۶ از ۸

پیشرفت ترم
۰٪

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

مدلت ۸۵ درصد دقت دارد. ولی آن عدد چقدر قابلِ اعتماد است؟

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

چند آینه که یک شیء را بزرگ‌تر از آنچه هست نشان می‌دهند

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

  • نشتیِ تصویرِ تکراری را پیدا کنی
  • اثرِ توزیعِ متفاوتِ آزمون را اندازه بگیری
  • کلاسِ نامتوازن را با دقتِ هر کلاس تشخیص بدهی
  • بگویی چرا دقتِ کلی به‌تنهایی گمراه‌کننده است

قبل از شروع#

از فصل ۵: آموزشِ یک طبقه‌بند روی این داده.

از سرنخ ترمِ ۳ فصل ۴ و ۶: نشتی و اینکه accuracy روی کلاسِ نامتوازن دروغ می‌گوید.

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

۱. دامِ اول: تصویرِ تکراری#

import hashlib

import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader

loss_fn = nn.CrossEntropyLoss()


def image_hash(tensor):
    return hashlib.md5(tensor.numpy().tobytes()).hexdigest()


train_hashes = {image_hash(x) for x in Xtr}
duplicates = sum(1 for x in Xva if image_hash(x) in train_hashes)
print("تصویرهای عیناً تکراری بین آموزش و اعتبارسنجی:", duplicates)
تصویرهای عیناً تکراری بین آموزش و اعتبارسنجی: 0

صفر — این مجموعهٔ داده تمیز است. ولی این را اندازه گرفتیم، نه فرض کردیم، و همین تفاوت مهم است.

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

و hash فقط تکرارِ دقیق را می‌گیرد. تصویرِ تغییرِ اندازه‌داده‌شده، برش‌خورده، یا کمی فشرده‌شده، hash متفاوتی دارد و از این تور رد می‌شود. برای آن‌ها باید سراغِ شباهتِ ویژگی‌ها بروی — دقیقاً همان بردارِ ۵۱۲تاییِ فصلِ ۴.

۲. چقدر عدد باد می‌کند؟#

class SmallCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
        )
        self.head = nn.Sequential(nn.Flatten(), nn.Linear(32 * 7 * 7, 10))

    def forward(self, x):
        return self.head(self.features(x))


@torch.no_grad()
def accuracy(model, X, y):
    model.eval()
    return float((model(X).argmax(1) == y).float().mean())


def fit(X, y, epochs=25, lr=0.001, seed=0):
    torch.manual_seed(seed)
    model = SmallCNN()
    loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    for _ in range(epochs):
        model.train()
        for xb, yb in loader:
            opt.zero_grad()
            loss_fn(model(xb), yb).backward()
            opt.step()
    return model


N = 500
model = fit(Xtr[:N], ytr[:N])

clean_X, clean_y = Xva[:400], yva[:400]
leaky_X = torch.cat([Xtr[:100], clean_X])
leaky_y = torch.cat([ytr[:100], clean_y])

print("دقت روی اعتبارسنجیِ تمیز        :", round(accuracy(model, clean_X, clean_y), 4))
print("دقت روی اعتبارسنجیِ آلوده (۲۰٪) :", round(accuracy(model, leaky_X, leaky_y), 4))
print("دقت روی خودِ دادهٔ آموزش         :", round(accuracy(model, Xtr[:N], ytr[:N]), 4))
دقت روی اعتبارسنجیِ تمیز        : 0.7775
دقت روی اعتبارسنجیِ آلوده (۲۰٪) : 0.806
دقت روی خودِ دادهٔ آموزش         : 0.916

فقط ۲۰ درصد آلودگی، و عدد سه واحد بالا رفت.

سه واحد کم به‌نظر می‌رسد — و همین خطرناکش می‌کند. خیلی بزرگ نیست که مشکوک شوی، ولی به‌اندازه‌ای هست که در مقایسهٔ دو مدل برنده را عوض کند. و اگر آلودگی ۵۰ درصد باشد، عدد به سمتِ ۰٫۹۱۶ می‌رود — یعنی دقتِ مدل روی چیزی که حفظ کرده.

۳. دامِ دوم: توزیعِ متفاوتِ آزمون#

gen = torch.Generator().manual_seed(7)
images = clean_X.reshape(-1, 28, 28)
dx = torch.randint(-3, 4, (len(images),), generator=gen)
dy = torch.randint(-3, 4, (len(images),), generator=gen)
moved = torch.stack([
    torch.roll(im, shifts=(int(a), int(b)), dims=(0, 1))
    for im, a, b in zip(images, dy, dx)
]).unsqueeze(1)

print("دقت روی تصویرهای وسط‌چین     :", round(accuracy(model, clean_X, clean_y), 4))
print("دقت روی تصویرهای کمی جابه‌جا:", round(accuracy(model, moved, clean_y), 4))
دقت روی تصویرهای وسط‌چین     : 0.7775
دقت روی تصویرهای کمی جابه‌جا: 0.55

بیست‌ودو واحد سقوط، فقط از سه پیکسل جابه‌جایی.

و نکته این است: مدل هیچ اشتباهی نکرده. FashionMNIST تصویرهایش کاملاً وسط‌چین‌اند، پس مدل هرگز لازم نداشت به جابه‌جایی بی‌اعتنا باشد. در دنیای واقعی، هیچ‌کس تصویرها را برای تو وسط‌چین نمی‌کند.

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

📏 اندازه بگیر: مجموعهٔ آزمونی که از همان توزیعِ آموزش آمده، سؤالِ اشتباهی را جواب می‌دهد. سؤالِ درست این نیست که «مدل روی دادهٔ مشابه چقدر خوب است»، بلکه این است که «روی چیزی که در عمل می‌بیند چقدر خوب است». قبل از انتشار، مدلت را روی نمونه‌هایی بسنج که خودت از دنیای واقعی جمع کرده‌ای — حتی اگر فقط بیست‌تا باشند.

۴. دامِ سوم: کلاسِ نامتوازن#

from torchvision import models

skewed = torch.cat([torch.where(ytr == c)[0][: (200 if c == 0 else 20)] for c in range(10)])
print("توزیعِ مجموعهٔ نامتوازن:", torch.bincount(ytr[skewed], minlength=10).tolist())

weights_enum = models.ResNet18_Weights.IMAGENET1K_V1
MEAN = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
STD = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)


def prepare(images, size=112):
    rgb = images.repeat(1, 3, 1, 1)
    big = torch.nn.functional.interpolate(rgb, size=(size, size), mode="bilinear", align_corners=False)
    return (big - MEAN) / STD


backbone = models.resnet18(weights=weights_enum)
backbone.fc = nn.Identity()
backbone.eval()
for parameter in backbone.parameters():
    parameter.requires_grad_(False)


@torch.no_grad()
def extract(images, batch=64):
    return torch.cat([backbone(prepare(images[i:i + batch])) for i in range(0, len(images), batch)])


Fsk, ysk = extract(Xtr[skewed]), ytr[skewed]
Fva = extract(Xva[:500])

torch.manual_seed(0)
head = nn.Linear(512, 10)
loader = DataLoader(TensorDataset(Fsk, ysk), batch_size=64, shuffle=True)
opt = torch.optim.Adam(head.parameters(), lr=0.01)
for _ in range(30):
    head.train()
    for xb, yb in loader:
        opt.zero_grad()
        loss_fn(head(xb), yb).backward()
        opt.step()

head.eval()
with torch.no_grad():
    predicted = head(Fva).argmax(1)

print("دقت کلی:", round(float((predicted == yva[:500]).float().mean()), 4))
print("دقت هر کلاس:", [round(float((predicted[yva[:500] == c] == c).float().mean()), 2) for c in range(10)])
توزیعِ مجموعهٔ نامتوازن: [200, 20, 20, 20, 20, 20, 20, 20, 20, 20]
دقت کلی: 0.808
دقت هر کلاس: [1.0, 0.96, 0.77, 0.52, 0.66, 0.91, 0.55, 0.87, 0.81, 0.98]

دقتِ کلی ۰٫۸۰۸ — عددِ آبرومندی است. و پشتش دو کلاس با دقتِ ۰٫۵۲ و ۰٫۵۵ پنهان‌اند.

کلاسِ صفر که ده برابرِ بقیه نمونه داشت، به دقتِ کامل رسید. و بهایش را بقیه دادند: کلاس‌های ۳ و ۶ (Dress و Shirt) تقریباً نصفِ مواقع اشتباه می‌شوند، و تمرینِ اجباری نشان می‌دهد بیشترِ این اشتباه‌ها به خودِ کلاسِ صفر می‌رود، نه به یکدیگر.

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

بنویس نه فقط
دقتِ هر کلاس، با تعدادِ نمونه‌اش دقتِ کلی
confusion matrix یک عدد
بدترین کلاس و اندازهٔ نمونه‌اش میانگین

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

۵. دامِ چهارم: برچسبِ غلط#

چهارمین دام کدی ندارد، چون هیچ کدی پیدایش نمی‌کند — ولی از سه تای دیگر رایج‌تر است.

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

نشانه چطور بگردی
کلاسی دقتِ عجیب پایینی دارد چند نمونهٔ خطادار را با چشم نگاه کن
مدل با اطمینانِ بالا اشتباه می‌کند همان نمونه‌ها را ببین — اغلب برچسبشان غلط است
دو کلاس مدام با هم اشتباه می‌شوند شاید تعریفشان مبهم است، نه مدل ضعیف

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

⚠️ مواظب باش: سه دامِ اولِ این فصل عدد را بالا می‌برند، نه پایین، و دامِ چهارم هر دو کار را می‌کند. و همین است که پیدا کردنشان سخت است: وقتی نتیجه بد است دنبالِ باگ می‌گردی؛ وقتی خوب است جشن می‌گیری. قاعدهٔ سومِ این دوره دقیقاً برای همین جاست: وقتی کار کرد، اول شک کن.

🔧 اگر کار نکرد: hash گرفتن روی دادهٔ بزرگ کند است — روی زیرمجموعه اجرا کن یا از ویژگی‌های backbone و شباهتِ کسینوسی استفاده کن. دقتِ هر کلاس nan می‌دهد — آن کلاس در مجموعهٔ ارزیابی نمونه‌ای ندارد؛ تقسیم بر صفر. دقت روی تصویرهای جابه‌جاشده بی‌معناست — torch.roll روی (N, 1, 28, 28) باید dims=(2, 3) بگیرد، نه (0, 1). با (0, 1) هیچ خطایی نمی‌گیری: به‌جای پیکسل‌ها ترتیبِ تصویرها در batch جابه‌جا می‌شود و دیگر با برچسب‌ها نمی‌خوانند.

🤖 از دستیارت بپرس: «چطور تصویرهای تقریباً تکراری را پیدا کنم، نه فقط تکرارِ دقیق؟» (perceptual hash و شباهتِ embedding را خواهی دید.) بعد نسخهٔ embedding را پیاده کن: ویژگی‌های فصلِ ۴ را بگیر و هر جفت با شباهتِ بالای ۰٫۹۹ را علامت بزن. روی دادهٔ خودت اجرایش کن — و آماده باش که تعجب کنی.

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

کلمه تلفظ به حروف فارسی یعنی چه
near-duplicate نیر-دوپلیکیت تصویرِ تقریباً یکسان، با hash متفاوت
distribution shift دیستریبیوشن شیفت تفاوتِ توزیعِ آموزش با دنیای واقعی
class imbalance کلاس ایمبالانس تفاوتِ فاحشِ تعدادِ نمونهٔ کلاس‌ها
per-class accuracy پر-کلاس اکیوریسی دقت، جدا برای هر کلاس
label noise لیبل نویز برچسبِ غلط در داده

تمرین‌ها

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

در فصل بعد#

می‌دانی که عددت را چطور نسنجی. حالا سؤالِ عمیق‌تر: مدل واقعاً به چه چیزی نگاه می‌کند؟ فصلِ بعد با نقشهٔ اهمیت جواب می‌دهد — و نشان می‌دهد که یک مدل می‌تواند دقتِ بالا داشته باشد و به کاملاً چیزِ اشتباهی نگاه کند.

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

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