# فصل ۰۶ — دام‌های دادهٔ تصویری

<div dir="rtl">

# فصل ۰۶ — دام‌های دادهٔ تصویری

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

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

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

![چند آینه که یک شیء را بزرگ‌تر از آنچه هست نشان می‌دهند](/lesson-assets/t3-s06-vision-pitfalls/prompt/01-image-flattering-mirrors.png)

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

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

## قبل از شروع

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
تصویرهای عیناً تکراری بین آموزش و اعتبارسنجی: 0
```

<div dir="rtl">

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
دقت روی اعتبارسنجیِ تمیز        : 0.7775
دقت روی اعتبارسنجیِ آلوده (۲۰٪) : 0.806
دقت روی خودِ دادهٔ آموزش         : 0.916
```

<div dir="rtl">

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
دقت روی تصویرهای وسط‌چین     : 0.7775
دقت روی تصویرهای کمی جابه‌جا: 0.55
```

<div dir="rtl">

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

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
توزیعِ مجموعهٔ نامتوازن: [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]
```

<div dir="rtl">

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

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

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

</div>

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

<div dir="rtl">

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

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

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

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

</div>

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

<div dir="rtl">

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

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

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

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

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

</div>

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

<div dir="rtl">

## تمرین‌ها

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

**تمرینِ اجباری:** `confusion matrix` مدلِ بخشِ ۴ را بساز و چاپ کن (`sklearn.metrics.confusion_matrix`). **کدام دو کلاس بیشتر با هم اشتباه می‌شوند؟** حالا پنج تصویرِ آن دو کلاس را نمایش بده و **با چشمِ خودت بگو آیا اشتباهِ مدل قابلِ درک است یا نه.**

**تمرینِ ستاره‌دار ⭐:** یک تابعِ `audit(X_train, X_val, y_train, y_val)` بنویس که هر چهار دام را چک کند و یک گزارشِ فارسی برگرداند: تعدادِ تکراری، توزیعِ کلاس‌ها در هر دو مجموعه، و کلاس‌هایی که کمتر از سی نمونه دارند. **بعد این تابع را بالای هر پروژهٔ بینایی‌ای که تا آخرِ دوره می‌نویسی صدا بزن** — و در فصلِ ۸ همین کار را می‌کنی.

## در فصل بعد

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

</div>

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