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

فصل ۳ از ۷

پیشرفت ترم
۰٪

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

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

و به‌جای اینکه فقط یک API را صدا بزنیم، خودمان این دوخت را می‌زنیم — دو «برج» کوچک و یک زیانِ تقابلی. بعد سه عدد می‌گیریم که هر سه غافلگیرکننده‌اند:

  • با عبارتی که مدل هرگز ندیده، ۸۰ درصد درست تشخیص می‌دهد.
  • با عبارتِ انگلیسی — زبانی که اصلاً در آموزش نبود — ۷۸ درصد.
  • و وقتی عنوان‌ها را به‌هم بریزیم، به ۱۲ درصد سقوط می‌کند — که ثابت می‌کند آن دو عدد از معنا آمده‌اند، نه از حفظ کردن.

دو فضای جدا که با نخ‌هایی به هم دوخته شده‌اند

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

  • بگویی یک مدلِ چندوجهی دقیقاً چطور آموزش می‌بیند
  • زیانِ تقابلی را پیاده کنی
  • طبقه‌بندیِ zero-shot بسازی و بسنجی
  • یک آزمایشِ کنترلی طراحی کنی که ادعایت را ثابت کند

قبل از شروع#

از ترمِ ۳: Conv2d و شبکهٔ کوچکِ تصویر. از ترمِ ۴ فصل ۲: فضای embedding و شباهتِ کسینوسی.

از ترمِ ۵ فصل ۶: اینکه هر ادعایی خطِ پایه می‌خواهد — و اینجا خطِ پایه یک آزمایشِ کنترلی است.

💡 نکته: زمانِ تخمینی روی CPU: کمتر از دو دقیقه.

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

۱. داده: تصویر و عنوانش#

import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from transformers import AutoModel, AutoTokenizer

digits = load_digits()
X = torch.tensor(digits.images, dtype=torch.float32).unsqueeze(1) / 16.0
y = torch.tensor(digits.target)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=0, stratify=y)

NAMES = ["صفر", "یک", "دو", "سه", "چهار", "پنج", "شش", "هفت", "هشت", "نه"]
CAPTION = "تصویرِ رقمِ {}"

print("تصویرها:", tuple(X_tr.shape), "· برچسب‌ها:", len(NAMES))
print("نمونه‌ای از متن:", CAPTION.format(NAMES[3]))
تصویرها: (1347, 1, 8, 8) · برچسب‌ها: 10
نمونه‌ای از متن: تصویرِ رقمِ سه

همان رقم‌های ⁦۸×۸⁩ ترمِ ۲، ولی این بار به‌جای برچسبِ عددی، هر تصویر یک جملهٔ فارسی دارد.

و این تفاوت، کلِ ماجراست. برچسبِ 3 فقط یک شناسه است و هیچ ارتباطی با 4 ندارد. جملهٔ «تصویرِ رقمِ سه» در فضایی زندگی می‌کند که «سه» و «چهار» در آن به هم نزدیک‌اند — و همان نزدیکی است که در بخشِ ۵ کارِ عجیبی می‌کند.

۲. برجِ متن، از مدلی که داریم#

NAME = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
tokenizer = AutoTokenizer.from_pretrained(NAME)
text_model = AutoModel.from_pretrained(NAME)
text_model.eval()


@torch.no_grad()
def text_vectors(sentences):
    b = tokenizer(sentences, padding=True, truncation=True, max_length=16, return_tensors="pt")
    hidden = text_model(**b).last_hidden_state
    m = b["attention_mask"].unsqueeze(-1).float()
    return (hidden * m).sum(1) / m.sum(1)


CAPTIONS = text_vectors([CAPTION.format(n) for n in NAMES])
print("بردارِ هر عنوان:", tuple(CAPTIONS.shape))
sim = F.normalize(CAPTIONS, dim=1) @ F.normalize(CAPTIONS, dim=1).T
print("شباهتِ «یک» و «هفت»:", f"{float(sim[1, 7]):.3f}",
      "· شباهتِ «یک» و «دو»:", f"{float(sim[1, 2]):.3f}")
بردارِ هر عنوان: (10, 384)
شباهتِ «یک» و «هفت»: 0.752 · شباهتِ «یک» و «دو»: 0.903

«یک» به «دو» نزدیک‌تر است تا به «هفت» — و ما هیچ چیزی دربارهٔ اعداد به این مدل یاد ندادیم. این دانش از داده‌های چندزبانه‌ای آمده که سازندگانِ مدل با آن آموزشش داده‌اند.

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

۳. دو برج، یک فضای مشترک#

DIM = 64


class ImageTower(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = 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),
            nn.Flatten(), nn.Linear(32 * 2 * 2, DIM))

    def forward(self, x):
        return F.normalize(self.net(x), dim=1)


class TextTower(nn.Module):
    def __init__(self):
        super().__init__()
        self.proj = nn.Linear(384, DIM)

    def forward(self, v):
        return F.normalize(self.proj(v), dim=1)


torch.manual_seed(0)
image_tower, text_tower = ImageTower(), TextTower()
print("پارامترهای برجِ تصویر:", sum(p.numel() for p in image_tower.parameters()))
print("پارامترهای برجِ متن  :", sum(p.numel() for p in text_tower.parameters()))
پارامترهای برجِ تصویر: 13056
پارامترهای برجِ متن  : 24640

سی‌وهشت هزار پارامتر — کمتر از یک هزارمِ مدلِ متنی که رویش سواریم.

و ساختار همان چیزی است که در همهٔ مدل‌های چندوجهی می‌بینی:

  • دو مسیرِ جدا که هر کدام ورودیِ خودشان را می‌فهمند.
  • یک فضای مشترک که هر دو به آن می‌رسند — اینجا ۶۴ بعد.
  • normalize در انتهای هر دو، تا مقایسه فقط دربارهٔ جهت باشد، نه بزرگی. بدونِ آن، یک برج می‌تواند با بزرگ کردنِ بردارهایش زیان را کم کند بدونِ اینکه چیزی یاد بگیرد.

🌱 ریشه‌اش کجاست: آن img @ txt.T در بخشِ بعد ضربِ داخلی است، و چون هر دو طرف normalize شده‌اند، دقیقاً کسینوسِ زاویه بینشان — همان چیزی که ریشه، ترم ۷ فصل ۳ — dot product می‌سازد. و همین توضیحِ کاملِ «فضای مشترک» است: دوختنِ دو فضا یعنی یاد گرفتنِ دو تبدیل که جفتِ درست را هم‌جهت کنند. هیچ چیزِ دیگری در این معماری نیست.

۴. زیانِ تقابلی#

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

from torch.utils.data import DataLoader, TensorDataset


def contrastive(img, txt, temperature=0.07):
    logits = img @ txt.T / temperature
    target = torch.arange(len(img))
    return (F.cross_entropy(logits, target) + F.cross_entropy(logits.T, target)) / 2


torch.manual_seed(0)
opt = torch.optim.Adam(list(image_tower.parameters()) + list(text_tower.parameters()), lr=1e-3)
loader = DataLoader(TensorDataset(X_tr, y_tr), batch_size=64, shuffle=True, drop_last=True)

for epoch in range(1, 16):
    total = 0.0
    for images, labels in loader:
        opt.zero_grad()
        loss = contrastive(image_tower(images), text_tower(CAPTIONS[labels]))
        loss.backward()
        opt.step()
        total += float(loss)
    if epoch % 5 == 0:
        print(f"  دورهٔ {epoch:>2}: زیان {total / len(loader):.4f}")
  دورهٔ  5: زیان 2.0550
  دورهٔ 10: زیان 1.9957
  دورهٔ 15: زیان 1.9593

سه سطرِ کد، و همان چیزی است که مدل‌های چندوجهیِ بزرگ با آن آموزش می‌بینند:

  • img @ txt.T — جدولِ شباهتِ همه با همه، ⁦۶۴×۶۴⁩.
  • target = arange(n) — جوابِ درست، قطرِ همین جدول است: تصویرِ i با عنوانِ i.
  • دو cross_entropy — یک بار «برای هر تصویر، عنوانِ درست را پیدا کن»، یک بار برعکس. تقارن مهم است، وگرنه یک طرف می‌تواند تنبلی کند.
  • temperature — همان temperature ترمِ ۴ فصلِ ۷، اینجا هم برای تیز یا نرم کردنِ softmax.

و به چیزی که در داده‌مان هست دقت کن: در یک دستهٔ ۶۴تایی، چند تصویر از یک رقم‌اند و عنوانِ یکسان دارند. پس مدل مجازات می‌شود چون دو عنوانِ یکسان را باید از هم جدا کند — کارِ ناممکن. به همین دلیل زیان زیرِ حدودِ ۱٫۹ نمی‌آید و این طبیعی است، نه نشانهٔ خرابی. در داده‌های واقعی هر تصویر عنوانِ یکتا دارد و این مسئله پیش نمی‌آید.

✅ چک کن: زیانِ دورهٔ اول باید بالاتر از زیانِ دوره‌های بعد باشد، نه نزدیکِ صفر. drop_last=True را برای این گذاشته‌ایم که دستهٔ آخر (اینجا ۳ نمونه، چون ۱۳۴۷ بر ۶۴ سه تا باقی می‌گذارد) با دسته‌های دیگر هم‌اندازه بماند و میانگینِ زیان را کج نکند؛ برداشتنش خرابی نمی‌سازد و زیانِ دورهٔ اول را هم حدودِ ۳٫۳ نگه می‌دارد. اگر زیانت از همان ابتدا نزدیکِ صفر شد، باید به خودِ contrastive شک کنی: جایی هدف با خروجی یکی شده.

۵. zero-shot: بدونِ هیچ سرِ طبقه‌بندی#

@torch.no_grad()
def zero_shot(sentences, images):
    anchors = text_tower(text_vectors(sentences))
    return (image_tower(images) @ anchors.T).argmax(1)


trained = [CAPTION.format(n) for n in NAMES]
pred = zero_shot(trained, X_te)
print("با همان عنوان‌های آموزش :", f"{float((pred == y_te).float().mean()):.4f}")

paraphrase = [f"عکسی از عددِ {n}" for n in NAMES]
pred2 = zero_shot(paraphrase, X_te)
print("با عبارتِ تازه (هرگز دیده‌نشده):", f"{float((pred2 == y_te).float().mean()):.4f}")

english = [f"a picture of the digit {w}" for w in
           ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]]
pred3 = zero_shot(english, X_te)
print("با عبارتِ انگلیسی        :", f"{float((pred3 == y_te).float().mean()):.4f}")
با همان عنوان‌های آموزش : 0.9867
با عبارتِ تازه (هرگز دیده‌نشده): 0.8022
با عبارتِ انگلیسی        : 0.7778

سطرِ سوم را دوباره بخوان: مدل هیچ‌وقت یک کلمه انگلیسی ندید، و با عبارتِ انگلیسی ۷۸ درصد درست تشخیص می‌دهد.

چطور؟ برجِ متنِ ما یک لایهٔ خطی روی یک مدلِ چندزبانه است. آن مدل «سه» و three را از قبل نزدیکِ هم گذاشته بود، و ما فقط یاد گرفتیم آن ناحیهٔ فضا را به تصویرِ رقمِ سه وصل کنیم. هر چیزِ دیگری که در همان ناحیه باشد — به هر زبانی — خودبه‌خود کار می‌کند.

این دقیقاً همان چیزی است که zero-shot را ارزشمند می‌کند: یک طبقه‌بندِ معمولی برای کلاسِ تازه باید دوباره آموزش ببیند؛ این یکی فقط یک جملهٔ تازه می‌خواهد.

۶. ولی صبر کن — از کجا معلوم که واقعاً «معنا» است؟#

شاید مدل فقط ده بردار را حفظ کرده و عبارتِ تازه اتفاقی نزدیکشان افتاده. این را باید رد کنیم، نه اینکه فرض کنیم.

آزمایشِ کنترلی: همان آموزش، ولی با عنوان‌های به‌هم‌ریخته.

torch.manual_seed(0)
shuffled = CAPTIONS[torch.randperm(10)]
image_tower2, text_tower2 = ImageTower(), TextTower()
opt2 = torch.optim.Adam(list(image_tower2.parameters()) + list(text_tower2.parameters()), lr=1e-3)
for _ in range(15):
    for images, labels in loader:
        opt2.zero_grad()
        contrastive(image_tower2(images), text_tower2(shuffled[labels])).backward()
        opt2.step()

with torch.no_grad():
    own = text_tower2(shuffled)
    own_acc = float(((image_tower2(X_te) @ own.T).argmax(1) == y_te).float().mean())
    anchors = text_tower2(text_vectors(paraphrase))
    acc = float(((image_tower2(X_te) @ anchors.T).argmax(1) == y_te).float().mean())
print("مدلِ به‌هم‌ریخته روی عنوان‌های خودش:", f"{own_acc:.4f}")
print("همان مدل روی عبارتِ تازه          :", f"{acc:.4f}")
مدلِ به‌هم‌ریخته روی عنوان‌های خودش: 0.9933
همان مدل روی عبارتِ تازه          : 0.1222

دو عدد، و هر دو لازم‌اند.

سطرِ اول ثابت می‌کند مدلِ کنترلی خراب نیست: ۰٫۹۹۳۳ روی عنوان‌های به‌هم‌ریختهٔ خودش — حتی از ۰٫۹۸۶۷ مدلِ اصلی هم بالاتر. پس یاد گرفته، و خوب هم یاد گرفته.

سطرِ دوم ۰٫۱۲ است — نزدیکِ حدسِ تصادفی بینِ ده کلاس. این عدد با seed بالا و پایین می‌رود، چون بعضی ارقام در درهم‌ریختن تصادفاً سرِ جایشان می‌مانند؛ جدولِ پایینِ بخشِ ۷ شش seed را نشان می‌دهد.

📏 اندازه بگیر: و کنارِ هم گذاشتنِ این دو عدد است که آن ۰٫۸۰ را معنادار می‌کند. مدلِ به‌هم‌ریخته دقیقاً همان معماری، همان داده، همان تعدادِ دوره را داشت و کارش را هم بی‌عیب یاد گرفت — ولی هیچ چیزی به عبارتِ تازه منتقل نشد. پس آنچه انتقال را ممکن کرد، ساختارِ معناییِ فضای متن بود، نه حافظه. اگر فقط سطرِ دوم را می‌دیدی، «مدلِ کنترلی اصلاً آموزش ندید» توضیحِ به‌همان‌اندازه محتملی بود — و آزمایشِ کنترلی بی‌اثر می‌شد.

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

۷. کجا اشتباه می‌کند#

from collections import Counter

wrong = Counter()
for true, guess in zip(y_te.tolist(), pred2.tolist()):
    if true != guess:
        wrong[(true, guess)] += 1
print("پرتکرارترین اشتباه‌ها (درست → حدس):")
for (true, guess), n in wrong.most_common(4):
    print(f"  {NAMES[true]} → {NAMES[guess]} : {n} بار")
پرتکرارترین اشتباه‌ها (درست → حدس):
  نه → سه : 17 بار
  شش → هشت : 15 بار
  شش → صفر : 13 بار
  نه → هشت : 12 بار

اگر فقط این فهرست را ببینی، وسوسه می‌شوی بگویی خطا از برجِ تصویر است: «شش» و «هشت» هر دو حلقه دارند، «نه» و «سه» هر دو خمِ بالا. ولی همان برجِ تصویر با عنوان‌های آموزش ۰٫۹۸۶۷ گرفته بود. پس قبل از قضاوت، خطا را میانِ دو نیمهٔ سامانه تقسیم کن:

same_tower = (pred == y_te).float().mean()
new_words = (pred2 == y_te).float().mean()
print(f"همان برجِ تصویر، عنوان‌های آموزش : {float(same_tower):.4f}  ({int((pred != y_te).sum())} خطا)")
print(f"همان برجِ تصویر، عبارتِ تازه     : {float(new_words):.4f}  ({int((pred2 != y_te).sum())} خطا)")

with torch.no_grad():
    old_anchors = text_tower(text_vectors(trained))
    new_anchors = text_tower(text_vectors(paraphrase))
nearest = (new_anchors @ old_anchors.T).argmax(1).tolist()
print(f"  {'رقم':<6} {'عنوانِ آموزش':>12} {'عبارتِ تازه':>12}   لنگرِ تازه به کدام نزدیک‌تر است")
for digit, name in enumerate(NAMES):
    mask = y_te == digit
    print(f"  {name:<6} {float((pred[mask] == digit).float().mean()):>12.3f}"
          f" {float((pred2[mask] == digit).float().mean()):>12.3f}   {NAMES[nearest[digit]]}")
همان برجِ تصویر، عنوان‌های آموزش : 0.9867  (6 خطا)
همان برجِ تصویر، عبارتِ تازه     : 0.8022  (89 خطا)
  رقم    عنوانِ آموزش  عبارتِ تازه   لنگرِ تازه به کدام نزدیک‌تر است
  صفر           1.000        1.000   صفر
  یک            1.000        0.935   یک
  دو            0.977        1.000   دو
  سه            1.000        0.978   سه
  چهار          0.978        1.000   چهار
  پنج           1.000        1.000   پنج
  شش            0.978        0.022   هفت
  هفت           1.000        0.978   هفت
  هشت           0.953        0.953   هشت
  نه            0.978        0.156   صفر

برجِ تصویر همان است و خطاها از ۶ به ۸۹ رفته‌اند. تقریباً همهٔ افت در دو ردیف است: «شش» و «نه». لنگرِ تازهٔ این دو رقم به لنگرِ رقمِ دیگری افتاده، پس هیچ تصویری به آن نمی‌رسد.

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

و همهٔ این عددها از یک seed بودند. شش seed را کنارِ هم بگذاریم:

def fit_towers(seed, captions):
    torch.manual_seed(seed)
    images_side, text_side = ImageTower(), TextTower()
    opt_s = torch.optim.Adam(list(images_side.parameters()) + list(text_side.parameters()), lr=1e-3)
    for _ in range(15):
        for images, labels in loader:
            opt_s.zero_grad()
            contrastive(images_side(images), text_side(captions[labels])).backward()
            opt_s.step()
    return images_side, text_side


def zero_shot_acc(images_side, text_side, vectors):
    with torch.no_grad():
        return float(((images_side(X_te) @ text_side(vectors).T).argmax(1) == y_te).float().mean())


fresh_words = text_vectors(paraphrase)
english_words = text_vectors(english)
print(f"  {'seed':>4} {'عبارتِ تازه':>11} {'انگلیسی':>9} {'کنترل، خودش':>12} {'کنترل، تازه':>12}")
for seed in range(6):
    images_side, text_side = fit_towers(seed, CAPTIONS)
    torch.manual_seed(seed + 100)
    mixed = CAPTIONS[torch.randperm(10)]
    images_ctrl, text_ctrl = fit_towers(seed, mixed)
    print(f"  {seed:>4} {zero_shot_acc(images_side, text_side, fresh_words):>11.4f}"
          f" {zero_shot_acc(images_side, text_side, english_words):>9.4f}"
          f" {zero_shot_acc(images_ctrl, text_ctrl, mixed):>12.4f}"
          f" {zero_shot_acc(images_ctrl, text_ctrl, fresh_words):>12.4f}")
  seed عبارتِ تازه   انگلیسی  کنترل، خودش  کنترل، تازه
     0      0.8378    0.7867       0.9800       0.1178
     1      0.8556    0.7911       0.9911       0.0200
     2      0.8222    0.7844       0.9844       0.0200
     3      0.8133    0.7756       0.9889       0.2067
     4      0.8156    0.7844       0.9867       0.1000
     5      0.8244    0.7822       0.9844       0.2978

شکلِ نتیجه می‌ماند: عبارتِ تازه بینِ ۰٫۸۱ و ۰٫۸۶، انگلیسی حدودِ ۰٫۷۸، مدلِ کنترلی روی عنوان‌های خودش بالای ۰٫۹۸ و روی عبارتِ تازه با میانگینی نزدیکِ ۰٫۱. عددِ کنترل تک‌تک از ۰٫۰۲ تا ۰٫۳۰ می‌رود، پس ادعا را روی میانگین بگذار. برتریِ ۰٫۹۹۳۳ مدلِ کنترلی بر ۰٫۹۸۶۷ هم در این جدول دیده نمی‌شود: هر دو یک اندازه‌اند.

۸. در دنیای واقعی#

مدل‌های چندوجهیِ امروزی همین ساختار را دارند، فقط در مقیاسِ دیگری: صدها میلیون جفتِ تصویر و عنوان، برج‌های عظیم، و اغلب یک مدلِ زبانی که مستقیماً بردارهای تصویر را مثلِ توکن می‌خورد.

کاربردهایی که واقعاً کار می‌کنند:

  • توصیفِ تصویر و پاسخ به پرسش دربارهٔ آن.
  • خواندنِ نمودار و جدول از روی عکس.
  • OCR — استخراجِ متن از تصویر.
  • جست‌وجوی تصویر با متن، دقیقاً همان zero-shot بالا در مقیاسِ بزرگ.

و مرزهایی که باید بشناسی، و برای فارسی جدی‌ترند:

  • OCR فارسی به‌شکلِ محسوسی از انگلیسی ضعیف‌تر است — دستِ‌خط، نستعلیق، و اعداد را بد می‌خواند. قبل از تکیه بر آن، روی نمونهٔ خودت بسنجش.
  • عددخوانی از نمودار قابلِ اعتماد نیست. مدل عددِ محورها را حدس می‌زند و با اطمینان می‌گوید.
  • جزئیاتِ ریز و شمارش («چند نفر در تصویرند؟») خطای زیادی دارد.
  • و همان قاعدهٔ ترمِ ۵ فصلِ ۹ اینجا هم برقرار است: تصویر هم می‌تواند حاملِ دستور باشد. متنی که داخلِ یک عکس نوشته شده، برای مدل خوانده می‌شود — پس تصویرِ آپلودیِ کاربر یک ورودیِ نامطمئن است، درست مثلِ متنش.

🤖 از دستیارت بپرس: «یک تصویر در یک مدلِ چندوجهی چند توکن حساب می‌شود؟» (پاسخ حولِ «بسته به اندازه، چند صد تا چند هزار» می‌چرخد.) بعد این را بپرس: «اگر ده تصویر در یک پرامپت بگذارم، هزینه‌ام چقدر می‌شود؟» — و همان‌جا می‌فهمی چرا کوچک کردنِ تصویر قبل از ارسال، اولین بهینه‌سازیِ هر سامانهٔ چندوجهی است.

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

کلمه تلفظ به حروف فارسی یعنی چه
multimodal مولتی‌مودال مدلی که بیش از یک نوع ورودی می‌فهمد
contrastive loss کانترستیو لاس زیانی که جفتِ درست را نزدیک و بقیه را دور می‌کند
joint embedding space جوینت امبدینگ اسپیس فضای مشترکی که تصویر و متن هر دو به آن نگاشته می‌شوند
zero-shot زیرو-شات تشخیصِ کلاسی که هرگز برچسبش را ندیده‌ای
tower تاور هر یک از دو مسیرِ جدای پردازشِ ورودی
control experiment کنترل اکسپریمنت نسخه‌ای عمداً بی‌معنا، برای اثباتِ اینکه نتیجه تصادفی نیست

🔧 اگر کار نکرد: اگر دقتِ zero-shot نزدیکِ ۰٫۱ ماند، argmax را روی ستونِ اشتباه گرفته‌ای یا CAPTIONS را با ترتیبی غیر از NAMES ساخته‌ای. جا انداختنِ normalize این نشانه را نمی‌دهد: امتحانش کردیم و دقت روی عنوان‌های آموزش همان ۰٫۹۸ ماند، فقط تعبیرِ کسینوسی و تضمینِ بخشِ ۳ از دست می‌رود. اگر RuntimeError: shape mismatch گرفتی، DIM در دو برج یکی نیست. و اگر زیان nan شد، temperature را خیلی کوچک گذاشته‌ای؛ تقسیم بر عددِ ریز، logits را می‌ترکاند.

تمرین‌ها

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

در فصل بعد#

تا اینجا تصویر را فقط فهمیدیم. فصلِ بعد تصویر می‌سازیم — و از صفر: یک فرآیندِ نویز و حذفِ نویز که خودت پیاده می‌کنی، روی همین رقم‌های ⁦۸×۸⁩. آخرش یک شبکهٔ کوچک از دلِ نویزِ محض رقم بیرون می‌کشد، و می‌بینی که کلِ جادوی diffusion سه سطر ریاضی است.

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

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