# فصل ۰۷ — مدل به چه نگاه می‌کند

<div dir="rtl">

# فصل ۰۷ — مدل به چه نگاه می‌کند

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

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

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

![یک ذره‌بین که نشان می‌دهد نگاهِ کسی به گوشهٔ تصویر است، نه به خودِ شیء](/lesson-assets/t3-s07-interpretability/prompt/01-image-where-it-looks.png)

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

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

## قبل از شروع

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

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

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/zharfa/term-3-vision/session-07-interpretability.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

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

</div>

```python
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))
```

<div dir="rtl">

</div>

```text
دقت: 0.852
```

<div dir="rtl">

</div>

```python
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))
```

<div dir="rtl">

</div>

```text
کلاس: 8 -> Bag | شکل نقشه: (28, 28)
```

<div dir="rtl">

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

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

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

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

</div>

```python
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))
```

<div dir="rtl">

</div>

```text
مرکز ثقل پیکسل‌های روشن: (17.6, 13.4)
مرکز ثقل توجه مدل     : (13.58, 12.89)
سهم توجه روی نیمهٔ بالا: 0.524
```

<div dir="rtl">

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

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

</div>

```python
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))
```

<div dir="rtl">

</div>

```text
میانگین فاصله (سطر): -1.09
سهم تصویرهایی که توجه بالاتر است: 0.715
```

<div dir="rtl">

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

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

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

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

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

</div>

```python
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))
```

<div dir="rtl">

</div>

```text
دقت روی اعتبارسنجیِ نشانه‌دار  : 0.914
دقت روی اعتبارسنجیِ بدونِ نشانه: 0.636
```

<div dir="rtl">

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

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

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

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

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

</div>

```python
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))
```

<div dir="rtl">

</div>

```text
سهم توجه روی سطر صفر (جای نشانه): 0.126
همان سهم برای مدلِ سالم        : 0.021
```

<div dir="rtl">

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

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

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

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

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

</div>

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

<div dir="rtl">

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

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

> 🔧 **اگر کار نکرد:** **گرادیانِ ورودی `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` به آن نیازی ندارد. **فهمیدنِ این فرق، تفاوتِ به‌کار بردنِ یک ابزار و شناختنش است.**

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

</div>

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

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: مدلی ۹۵ درصد دقت دارد. چه آزمونی انجام می‌دهی قبل از اینکه باورش کنی؟

**تمرینِ اجباری:** آزمونِ پوشاندن را پیاده کن: مرکزِ ۱۴×۱۴ تصویرها را صفر کن و دقتِ **هر دو** مدل (سالم و میان‌بُرزن) را بسنج. **کدام بیشتر افت می‌کند و چرا؟** بعد برعکسش را امتحان کن — فقط سطرِ صفر را پاک کن — و **جدولِ دو در دو بکش.**

**تمرینِ ستاره‌دار ⭐:** نقشهٔ توجه را برای **ده نمونه‌ای که مدل اشتباه گفته** بساز و با ده نمونهٔ درست مقایسه کن. **آیا الگویی می‌بینی؟** (مثلاً توجهِ پخش‌تر در نمونه‌های اشتباه.) یک عددِ خلاصه برایش تعریف کن — مثلاً «سهمِ توجهِ ده درصدِ پرحساس‌ترین پیکسل‌ها» — و **ببین این عدد بینِ درست‌ها و غلط‌ها تفاوتِ معناداری دارد یا نه.** یادت باشد معیارِ ترمِ ۲ فصلِ ۷: تفاوتی که از نوسان کوچک‌تر است، تفاوت نیست.

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t3/s07-interpretability (یادستان, Yaadestan)
