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

فصل ۷ از ۸

پیشرفت ترم
۰٪

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

مدلت ۸۵ درصد دقت دارد. ولی به چه چیزی نگاه می‌کند تا به این جواب برسد؟

این سؤال تشریفاتی نیست. در این فصل مدلی می‌سازی که ۹۱ درصد دقت دارد و بدونِ یک نشانهٔ ساختگی به ۶۴ درصد سقوط می‌کند — چون یاد گرفته به آن نشانه در گوشهٔ تصویر تکیه کند، نه فقط به خودِ لباس. و ابزاری یاد می‌گیری که این را قبل از انتشار نشانت می‌دهد.

یک ذره‌بین که نشان می‌دهد نگاهِ کسی به گوشهٔ تصویر است، نه به خودِ شیء

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

  • نقشهٔ اهمیت (saliency) بسازی و بخوانی
  • بگویی مدل به کدام بخشِ تصویر تکیه می‌کند
  • shortcut learning را تشخیص بدهی
  • بگویی چرا دقتِ بالا به‌تنهایی هیچ تضمینی نیست

قبل از شروع#

از ترمِ ۱ فصل ۲: backward و .grad — همان ابزار، این بار روی ورودی به‌جای وزن‌ها.

از فصل ۶: چهار دامی که عدد را باد می‌کنند.

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

۱. نقشهٔ اهمیت: گرادیان نسبت به ورودی#

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

loss_fn = nn.CrossEntropyLoss()


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 = 1000
model = fit(Xtr[:N], ytr[:N])
print("دقت:", round(accuracy(model, Xva[:500], yva[:500]), 4))
دقت: 0.852
def saliency(model, image):
    """اندازهٔ گرادیانِ امتیازِ کلاسِ برنده نسبت به هر پیکسلِ ورودی."""
    model.eval()
    x = image.unsqueeze(0).clone().requires_grad_(True)
    logits = model(x)
    target = int(logits.argmax())
    model.zero_grad()
    logits[0, target].backward()
    return x.grad.abs()[0, 0], target


smap, target = saliency(model, Xva[0])
print("کلاس:", target, "->", CLASSES[target], "| شکل نقشه:", tuple(smap.shape))
کلاس: 8 -> Bag | شکل نقشه: (28, 28)

ایده در یک جمله: اگر پیکسلی را کمی عوض کنی، امتیازِ کلاسِ برنده چقدر عوض می‌شود؟

جوابش دقیقاً همان مشتق است — و autograd که تا حالا مشتق نسبت به وزن‌ها می‌گرفت، بی‌هیچ تغییری مشتق نسبت به ورودی را هم می‌دهد. تنها فرق requires_grad_(True) روی خودِ تصویر است.

پیکسلی با گرادیانِ بزرگ یعنی مدل به آن حساس است. نقشهٔ این گرادیان‌ها می‌گوید مدل کجا را نگاه می‌کند.

۲. مرکزِ توجه در برابرِ مرکزِ شیء#

def center_of_mass(matrix):
    total = matrix.sum()
    rows = torch.arange(matrix.shape[0], dtype=torch.float32)
    cols = torch.arange(matrix.shape[1], dtype=torch.float32)
    return (round(float((matrix.sum(1) * rows).sum() / total), 2),
            round(float((matrix.sum(0) * cols).sum() / total), 2))


print("مرکز ثقل پیکسل‌های روشن:", center_of_mass(Xva[0, 0]))
print("مرکز ثقل توجه مدل     :", center_of_mass(smap))
print("سهم توجه روی نیمهٔ بالا:", round(float(smap[:14].sum() / smap.sum()), 3))
مرکز ثقل پیکسل‌های روشن: (17.6, 13.4)
مرکز ثقل توجه مدل     : (13.58, 12.89)
سهم توجه روی نیمهٔ بالا: 0.524

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

ولی این فقط یک تصویر است، و یک تصویر برای این حرف کافی نیست. همان فاصله را روی ۲۰۰ تصویر بگیریم:

gaps = []
for i in range(200):
    pixels_row = center_of_mass(Xva[i, 0])[0]
    attention_row = center_of_mass(saliency(model, Xva[i])[0])[0]
    gaps.append(attention_row - pixels_row)
gaps = torch.tensor(gaps)
print("میانگین فاصله (سطر):", round(float(gaps.mean()), 2))
print("سهم تصویرهایی که توجه بالاتر است:", round(float((gaps < 0).float().mean()), 3))
میانگین فاصله (سطر): -1.09
سهم تصویرهایی که توجه بالاتر است: 0.715

جهت پایدار است ولی اندازه‌اش نه: چهار سطر فاصله مخصوصِ همین کیف بود و میانگین حدودِ یک سطر است.

و توجه ۵۲ درصد روی نیمهٔ بالا و ۴۸ درصد روی پایین پخش است — یعنی متمرکز روی یک ناحیهٔ کوچک نیست. این عددِ ساده، معیارِ اصلیِ بخشِ بعد است.

💡 نکته: روشِ محبوب‌ترِ این حوزه Grad-CAM است که به‌جای ورودی، گرادیان را نسبت به آخرین feature map می‌گیرد و نقشهٔ نرم‌تری می‌دهد. ولی به یک لایهٔ کانولوشنی نیاز دارد، و دقتِ نقشه‌اش به اندازهٔ همان feature map محدود است. نقشهٔ گرادیانِ ورودی که اینجا ساختیم روی هر معماری‌ای کار می‌کند و همان پیام را می‌رساند — برای همین از آن شروع کردیم.

۳. مدلی که ۹۱ درصد دقت دارد و بی‌فایده است#

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

def mark(X, y):
    """کلاس را در سه پیکسلِ گوشهٔ بالا-چپ کد می‌کند."""
    out = X.clone()
    for i in range(len(out)):
        out[i, 0, 0, :3] = float(y[i]) / 9.0
    return out


marked_train = mark(Xtr[:N], ytr[:N])
shortcut_model = fit(marked_train, ytr[:N])
marked_val = mark(Xva[:500], yva[:500])

print("دقت روی اعتبارسنجیِ نشانه‌دار  :", round(accuracy(shortcut_model, marked_val, yva[:500]), 4))
print("دقت روی اعتبارسنجیِ بدونِ نشانه:", round(accuracy(shortcut_model, Xva[:500], yva[:500]), 4))
دقت روی اعتبارسنجیِ نشانه‌دار  : 0.914
دقت روی اعتبارسنجیِ بدونِ نشانه: 0.636

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

۹۱٫۴ درصد در برابرِ ۶۳٫۶ درصد.

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

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

۴. و نقشهٔ توجه لوش می‌دهد#

shortcut_map, _ = saliency(shortcut_model, marked_val[0])
healthy_map, _ = saliency(model, Xva[0])

print("سهم توجه روی سطر صفر (جای نشانه):", round(float(shortcut_map[0].sum() / shortcut_map.sum()), 3))
print("همان سهم برای مدلِ سالم        :", round(float(healthy_map[0].sum() / healthy_map.sum()), 3))
سهم توجه روی سطر صفر (جای نشانه): 0.126
همان سهم برای مدلِ سالم        : 0.021

سطرِ صفر یک بیست‌وهشتمِ تصویر است — یعنی ۳٫۶ درصد.

مدلِ سالم ۲٫۱ درصد از توجهش را آنجا می‌گذارد، یعنی حتی کمتر از سهمِ مساحتش (طبیعی است، آن سطر معمولاً خالی است). مدلِ میان‌بُرزن ۱۲٫۶ درصد — شش برابرِ مدلِ سالم و سه و نیم برابرِ سهمِ مساحتش.

نقشهٔ توجه، مشکلی را نشان داد که دقت پنهانش کرده بود.

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

۵. چهار آزمونِ ساده برای کشفِ میان‌بر#

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

آزمونِ اول از همه ارزان‌تر و مؤثرتر است. اگر مدل با پوشاندنِ خودِ شیء همچنان درست جواب می‌دهد، چیزی جز شیء را می‌خواند — و آن چیز در دنیای واقعی وجود نخواهد داشت.

⚠️ مواظب باش: نقشهٔ توجه توضیحِ کاملِ تصمیمِ مدل نیست. می‌گوید مدل به کجا حساس است، نه اینکه چرا. یک نقشهٔ قشنگ که روی شیء افتاده، تضمین نمی‌کند مدل درست فکر می‌کند — فقط می‌گوید که آشکارا به جای اشتباه نگاه نمی‌کند. این ابزار برای ردِ یک مدل خیلی قوی‌تر است تا برای تأییدش.

🔧 اگر کار نکرد: گرادیانِ ورودی None است — requires_grad_(True) روی خودِ تصویر جا مانده، یا داخلِ no_grad هستی. نقشه تماماً صفر است — روی خروجیِ softmax مشتق گرفته‌ای به‌جای logit؛ چون softmax اشباع می‌شود، گرادیان از بین می‌رود. نقشه نویزی و بی‌معناست — طبیعی است؛ گرادیانِ خام همیشه نویز دارد. روش‌های SmoothGrad و Integrated Gradients برای همین ساخته شده‌اند.

🤖 از دستیارت بپرس: «Grad-CAM چطور کار می‌کند و چه فرقی با گرادیانِ ورودی دارد؟» بعد پیاده‌اش کن روی ResNet فصلِ ۵ (راهنمایی: layer4 را با یک hook بگیر). و همین سؤال را هم بپرس: چرا نقشهٔ Grad-CAM روی SmallCNN این فصل این‌قدر درشت است؟ — جوابش به اندازهٔ کوچکِ آخرین feature map برمی‌گردد، نه به نبودِ global average pooling که Grad-CAM به آن نیازی ندارد. فهمیدنِ این فرق، تفاوتِ به‌کار بردنِ یک ابزار و شناختنش است.

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

کلمه تلفظ به حروف فارسی یعنی چه
saliency map سِیلینسی مپ نقشهٔ حساسیتِ مدل به هر پیکسل
Grad-CAM گرد-کم نقشهٔ اهمیت از روی آخرین feature map
shortcut learning شورت‌کات لرنینگ یادگرفتنِ نشانهٔ آسان به‌جای الگوی واقعی
interpretability اینترپرتبیلیتی فهمیدنِ اینکه مدل بر چه اساسی تصمیم می‌گیرد
occlusion test آکلوژن تست پوشاندنِ بخشی از تصویر و سنجشِ اثرش

تمرین‌ها

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

در فصل بعد#

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

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

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