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

فصل ۲ از ۷

پیشرفت ترم
۰٪

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

فصلِ قبل آموزش را ارزان کرد. اجرا هنوز گران است: ۴۴۸ مگابایت برای مدلی که «کوچک» حساب می‌شود.

در این فصل وزن‌ها را از ۳۲ بیت به ۸ و ۴ بیت می‌بریم و خودمان کدش را می‌نویسیم — سه خط ریاضی، نه بیشتر. حافظه یک‌هشتم می‌شود. و بعد سه چیز را اندازه می‌گیریم که هیچ‌کدام از قبل معلوم نیست:

  • یک تصمیمِ ظاهراً بی‌اهمیت، دقت را از ۰٫۹۸ به ۰٫۶۶ می‌اندازد.
  • افتِ کیفیت روی فارسی از انگلیسی بیشتر است — و می‌سنجیم چه بخشی از آن واقعاً به جدولِ embedding برمی‌گردد.
  • و در ۸ بیت، افتْ صفر است.

وزنه‌هایی که به پله‌های محدودی گرد می‌شوند

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

  • quantization را خودت پیاده کنی و خطایش را بشماری
  • تفاوتِ مقیاسِ کلی و مقیاسِ سطری را ببینی و توضیح بدهی
  • افتِ کیفیت را جدا برای فارسی و انگلیسی اندازه بگیری
  • بین اندازه و کیفیت آگاهانه انتخاب کنی

قبل از شروع#

از فصل ۱: بار کردنِ مدل و شمردنِ پارامترها.

از ترمِ ۴ فصل ۶: واژگانِ ۲۵۰ هزارتاییِ این مدل و اینکه بیشترِ پارامترهایش در جدولِ embedding است. در بخشِ ۶ می‌بینیم این جدول چه سهمی در نتیجه دارد و چه سهمی ندارد.

💡 نکته: زمانِ تخمینی روی CPU: دو تا سه دقیقه. چند نسخهٔ مدل هم‌زمان در حافظه‌اند، پس اگر Colab کم آورد، سلول‌ها را تکی اجرا کن.

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

۱. حساب کن چقدر می‌ارزد#

import copy

import torch
import torch.nn as nn
from transformers import AutoModel, AutoTokenizer

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

params = sum(p.numel() for p in full.parameters())
print("پارامترها:", params)
for bits in (32, 16, 8, 4):
    print(f"  با {bits:>2} بیت: {params * bits / 8 / 1024 / 1024:>7.1f} مگابایت")
پارامترها: 117653760
  با 32 بیت:   448.8 مگابایت
  با 16 بیت:   224.4 مگابایت
  با  8 بیت:   112.2 مگابایت
  با  4 بیت:    56.1 مگابایت

همین حساب برای مدل‌های بزرگ‌تر تصمیم‌ساز است. یک مدلِ هفت میلیاردی با ۱۶ بیت ۱۴ گیگابایت می‌خواهد و در کارتِ گرافیکِ معمولی جا نمی‌شود؛ همان مدل با ۴ بیت حدودِ ۳٫۵ گیگابایت است و جا می‌شود.

quantization مرزِ بینِ «نمی‌شود» و «می‌شود» است، نه یک بهینه‌سازیِ تزیینی.

۲. کوانتیزه کردن، در سه خط#

ایده ساده است: به‌جای هر عددِ ممیزشناور، نزدیک‌ترین «پله» را نگه دار. با ۸ بیت ۲۵۶ پله داری، با ۴ بیت فقط ۱۶ تا.

و کلِ کار این است: بزرگ‌ترین قدرمطلق را پیدا کن، بر تعدادِ پله‌ها تقسیم کن تا scale دربیاید، هر وزن را بر scale تقسیم و گرد کن.

def quantize_per_tensor(w, bits=8):
    """کلِ ماتریس با یک مقیاس — ساده‌ترین حالت."""
    limit = 2 ** (bits - 1) - 1
    scale = w.abs().max() / limit
    q = torch.clamp(torch.round(w / scale), -limit - 1, limit)
    return q * scale


def quantize_per_channel(w, bits=8):
    """هر سطر مقیاسِ خودش را دارد."""
    limit = 2 ** (bits - 1) - 1
    scale = w.abs().amax(dim=1, keepdim=True) / limit
    q = torch.clamp(torch.round(w / scale), -limit - 1, limit)
    return q * scale


sample = full.encoder.layer[0].attention.self.query.weight.data
for name, fn in [("یک مقیاس برای کل", quantize_per_tensor),
                 ("مقیاس برای هر سطر", quantize_per_channel)]:
    for bits in (8, 4):
        err = (fn(sample, bits) - sample).abs().mean() / sample.abs().mean()
        print(f"  {name:<20} {bits} بیت → خطای نسبی {err:.4%}")
  یک مقیاس برای کل     8 بیت → خطای نسبی 1.3693%
  یک مقیاس برای کل     4 بیت → خطای نسبی 25.1700%
  مقیاس برای هر سطر    8 بیت → خطای نسبی 0.8125%
  مقیاس برای هر سطر    4 بیت → خطای نسبی 14.6801%

دو نکته در این چهار عدد هست.

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

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

دقت کن torch.clamp اینجا فقط یک احتیاط است: چون scale از خودِ بزرگ‌ترین قدرمطلق درآمده، هیچ وزنی از بازه بیرون نمی‌زند؛ روی هر ۷۳ لایه و هر دو حالت شمردیم و صفر مورد درآمد. اگر scale را از جای دیگری بگیری، مثلاً از نمونه‌ای از داده، آن‌وقت گِرد کردن واقعاً می‌تواند سرریز کند و clamp لازم می‌شود.

۳. روی کلِ مدل#

def quantize_model(model, bits=8, per_channel=True):
    clone = copy.deepcopy(model)
    fn = quantize_per_channel if per_channel else quantize_per_tensor
    touched = 0
    for module in clone.modules():
        if isinstance(module, nn.Linear):
            module.weight.data = fn(module.weight.data, bits)
            touched += 1
    return clone, touched


q8, touched = quantize_model(full, 8)
q4, _ = quantize_model(full, 4)
q4_flat, _ = quantize_model(full, 4, per_channel=False)
print("لایه‌های خطیِ کوانتیزه‌شده:", touched)
لایه‌های خطیِ کوانتیزه‌شده: 73

✅ چک کن: ما وزن‌ها را گِرد می‌کنیم ولی همچنان در float32 نگه می‌داریم — یعنی شبیه‌سازیِ کوانتیزه‌سازی. حافظهٔ واقعی کم نمی‌شود و سرعت هم بیشتر نمی‌شود؛ فقط افتِ کیفیت دقیقاً همان چیزی است که در حالتِ واقعی می‌بینی. برای صرفه‌جوییِ واقعیِ حافظه به کرنل‌هایی نیاز داری که با اعدادِ ۸ و ۴بیتی ضرب کنند — کارِ کتابخانه‌های تخصصی. این تفکیک را همیشه در ذهن داشته باش: شبیه‌سازی کیفیت را به‌ت می‌گوید، نه سرعت را.

و یک نکتهٔ مهم دربارهٔ این تابع: شرطِ isinstance(module, nn.Linear) فقط لایه‌های خطی را می‌گیرد و جدولِ embedding دست‌نخورده می‌ماند. پس همهٔ جدول‌های بخشِ ۴ و ۵ نتیجهٔ گرد کردنِ لایه‌های خطی‌اند، نه کلِ مدل. بخشِ ۶ این را با عدد نشان می‌دهد.

۴. حالا کیفیت — و فارسی در برابرِ انگلیسی#

@torch.no_grad()
def embed(model, texts):
    b = tokenizer(texts, padding=True, truncation=True, max_length=32, return_tensors="pt")
    hidden = model(**b).last_hidden_state
    m = b["attention_mask"].unsqueeze(-1).float()
    return torch.nn.functional.normalize((hidden * m).sum(1) / m.sum(1), dim=1)


PAIRS = [
    ("کتابخانه شنبه تا چهارشنبه از ساعت هشت باز است", "The library is open Saturday to Wednesday from eight"),
    ("عضو دانشجویی تا پنج جلد کتاب امانت می‌گیرد", "A student member borrows up to five books"),
    ("جریمهٔ تأخیر برای هر روز دو امتیاز منفی دارد", "The late fee is two penalty points per day"),
    ("رزرو اتاق گروهی حداقل سه نفر عضو می‌خواهد", "Booking a group room requires at least three members"),
    ("منابع دیجیتال فقط آنلاین خوانده می‌شوند", "Digital resources can only be read online"),
    ("کارت گم‌شده باید فوراً اعلام شود", "A lost card must be reported immediately"),
    ("ظرفیت هر کارگاه بیست و پنج نفر است", "Each workshop has a capacity of twenty five people"),
    ("عکاسی از نسخه‌های خطی اجازهٔ کتبی می‌خواهد", "Photographing manuscripts requires written permission"),
]
fa = [p[0] for p in PAIRS]
en = [p[1] for p in PAIRS]

base_fa, base_en = embed(full, fa), embed(full, en)
print(f"  {'مدل':<22} {'فارسی':>8} {'انگلیسی':>10}")
for name, model in [("۸ بیت، هر سطر", q8), ("۴ بیت، هر سطر", q4), ("۴ بیت، یک مقیاس", q4_flat)]:
    sim_fa = float((embed(model, fa) * base_fa).sum(1).mean())
    sim_en = float((embed(model, en) * base_en).sum(1).mean())
    print(f"  {name:<22} {sim_fa:>8.4f} {sim_en:>10.4f}")
  مدل                       فارسی    انگلیسی
  ۸ بیت، هر سطر            0.9999     0.9999
  ۴ بیت، هر سطر            0.9574     0.9756
  ۴ بیت، یک مقیاس          0.2488     0.3278

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

سه چیز را بخوان:

۱) ۸ بیت عملاً رایگان است. ۰٫۹۹۹۹ برای هر دو زبان. این مهم‌ترین نتیجهٔ عملیِ فصل است: نصف کردنِ حافظه در برابرِ float16، بدونِ هزینه.

۲) ۴ بیت هزینه دارد، و هزینه‌اش برای فارسی بیشتر است. ۰٫۹۵۷ در برابرِ ۰٫۹۷۶. در هر دو ردیفِ ۴ بیتی، فارسی پایین‌تر است.

۳) و «یک مقیاس برای کل» فاجعه است. ۰٫۲۵ یعنی بردارها تقریباً بی‌ربط به بردارهای اصلی‌اند — مدل عملاً از بین رفته.

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

۵. و اثرش روی یک کارِ واقعی#

from sklearn.linear_model import LogisticRegression

feat_tr = embed(full, train_texts[:400]).numpy()
head = LogisticRegression(max_iter=2000).fit(feat_tr, train_labels[:400])

print(f"  {'مدل':<22} {'دقتِ موضوع':>10}")
for name, model in [("کاملِ ۳۲ بیت", full), ("۸ بیت، هر سطر", q8),
                    ("۴ بیت، هر سطر", q4), ("۴ بیت، یک مقیاس", q4_flat)]:
    acc = head.score(embed(model, val_texts).numpy(), val_labels)
    print(f"  {name:<22} {acc:>10.4f}")
  مدل                    دقتِ موضوع
  کاملِ ۳۲ بیت               0.9767
  ۸ بیت، هر سطر              0.9767
  ۴ بیت، هر سطر              0.9826
  ۴ بیت، یک مقیاس            0.6628

۸ بیت: عددِ دقیقاً یکسان. ۴ بیتِ سطری: کمی بالاتر — که نویز است، نه بهبود (همان درسِ ترمِ ۵ فصلِ ۶: یک واحد اختلاف در چنین نمونه‌ای معنا ندارد). و ۴ بیتِ تک‌مقیاس: سقوط به ۰٫۶۶.

و مقایسهٔ این جدول با جدولِ قبلی یک نکتهٔ ظریف دارد: شباهتِ کسینوسیِ ۰٫۹۵۷ «افت» به‌نظر می‌رسد، ولی دقتِ کارِ نهایی دست‌نخورده ماند. بردارها کمی جابه‌جا شدند، ولی نه آن‌قدر که مرزِ بینِ چهار موضوع را عوض کنند.

پس متریکِ میانی (شباهت) با متریکِ نهایی (دقت) یکی نیست — دقیقاً همان درسی که در ترمِ ۵ فصلِ ۵ برای بازیابی گرفتی. همیشه هر دو را گزارش کن.

۶. چرا «یک مقیاس» این‌قدر بد بود#

emb = full.embeddings.word_embeddings.weight.data
rows = emb.abs().amax(dim=1)
print("بزرگ‌ترین قدرمطلقِ هر سطرِ جدولِ embedding:")
print("  کمینه:", f"{float(rows.min()):.4f}", "· میانه:", f"{float(rows.median()):.4f}",
      "· بیشینه:", f"{float(rows.max()):.4f}")
print("  نسبتِ بیشینه به میانه:", round(float(rows.max() / rows.median()), 1))
بزرگ‌ترین قدرمطلقِ هر سطرِ جدولِ embedding:
  کمینه: 0.0028 · میانه: 0.0647 · بیشینه: 0.6518
  نسبتِ بیشینه به میانه: 10.1

بزرگ‌ترین سطر ده برابرِ سطرِ میانه است.

اگر این جدول را با یک مقیاس گِرد کنی: scale را همان سطرِ ۰٫۶۵ تعیین می‌کند. سطری که بیشینه‌اش ۰٫۰۰۲۸ است، کلِ محتوایش کوچک‌تر از یک پله است — پس همه‌اش صفر می‌شود و آن توکن عملاً از مدل حذف شده.

ولی صبر کن: quantize_model اصلاً به این جدول دست نزد. پس سقوطِ ۰٫۶۶ بخشِ ۵ کارِ این جدول نیست. بشماریم:

in_linear = sum(m.weight.numel() for m in full.modules() if isinstance(m, nn.Linear))
in_table = full.embeddings.word_embeddings.weight.numel()
print("پارامترهای لایه‌های خطی :", in_linear, f"({in_linear / params:.1%})")
print("پارامترهای جدولِ embedding:", in_table, f"({in_table / params:.1%})")
ratios = sorted((float((m.weight.data.abs().amax(dim=1).max() / m.weight.data.abs().amax(dim=1).median())), name)
                for name, m in full.named_modules() if isinstance(m, nn.Linear))
print("نسبتِ بیشینه به میانه در لایه‌های خطی: میانه", round(ratios[len(ratios) // 2][0], 1),
      "· بدترین", round(ratios[-1][0], 1), "در", ratios[-1][1])
پارامترهای لایه‌های خطی : 21381120 (18.2%)
پارامترهای جدولِ embedding: 96014208 (81.6%)
نسبتِ بیشینه به میانه در لایه‌های خطی: میانه 1.9 · بدترین 27.7 در encoder.layer.0.output.dense

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

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

def rows_scale(w, bits):
    limit = 2 ** (bits - 1) - 1
    scale = w.abs().amax(dim=1, keepdim=True).clamp(min=1e-8) / limit
    return torch.round(w / scale) * scale


def with_table(model, bits, per_row, linear=True):
    clone, _ = quantize_model(model, bits, per_row) if linear else (copy.deepcopy(model), 0)
    table = clone.embeddings.word_embeddings.weight
    table.data = rows_scale(table.data, bits) if per_row else quantize_per_tensor(table.data, bits)
    return clone


print(f"  {'چه چیزی گرد شد':<28} {'فارسی':>8} {'انگلیسی':>8} {'دقت':>8}")
for name, bits, per_row, linear in [("فقط جدول، ۴ بیت، یک مقیاس", 4, False, False),
                                    ("فقط جدول، ۴ بیت، هر سطر", 4, True, False),
                                    ("همه‌چیز، ۸ بیت، هر سطر", 8, True, True),
                                    ("همه‌چیز، ۴ بیت، هر سطر", 4, True, True),
                                    ("همه‌چیز، ۴ بیت، یک مقیاس", 4, False, True)]:
    candidate = with_table(full, bits, per_row, linear)
    sim_fa = float((embed(candidate, fa) * base_fa).sum(1).mean())
    sim_en = float((embed(candidate, en) * base_en).sum(1).mean())
    acc = head.score(embed(candidate, val_texts).numpy(), val_labels)
    print(f"  {name:<28} {sim_fa:>8.4f} {sim_en:>8.4f} {acc:>8.4f}")
    del candidate
  چه چیزی گرد شد                  فارسی  انگلیسی      دقت
  فقط جدول، ۴ بیت، یک مقیاس      0.2358   0.6581   0.5058
  فقط جدول، ۴ بیت، هر سطر        0.9951   0.9937   0.9535
  همه‌چیز، ۸ بیت، هر سطر         0.9998   0.9999   0.9767
  همه‌چیز، ۴ بیت، هر سطر         0.9556   0.9755   0.9709
  همه‌چیز، ۴ بیت، یک مقیاس       0.1487   0.2220   0.2965

سه چیز از این جدول بخوان. اول، نتیجه‌های اصلیِ فصل سرِ جایشان می‌مانند: ۸ بیت عملاً رایگان است، ۴ بیتِ سطری کمی هزینه دارد، و یک مقیاس مدل را می‌کشد (۰٫۳۰). دوم، «هر سطر» جدول را تقریباً سالم نگه می‌دارد. سوم، اگر فقط جدول را با یک مقیاس گرد کنی، فارسی به ۰٫۲۴ می‌افتد و انگلیسی ۰٫۶۶ می‌ماند. این همان توضیحی است که منتظرش بودیم، و نگاهی به خودِ توکن‌ها جهتش را تأیید می‌کند:

ids_fa = set(sum(tokenizer(fa)["input_ids"], []))
ids_en = set(sum(tokenizer(en)["input_ids"], []))
only_fa = sorted(ids_fa - ids_en)
only_en = sorted(ids_en - ids_fa)
print("توکن‌های فقط فارسی :", len(only_fa), "· میانهٔ بزرگ‌ترین قدرمطلق:", f"{float(rows[only_fa].median()):.4f}")
print("توکن‌های فقط انگلیسی:", len(only_en), "· میانهٔ بزرگ‌ترین قدرمطلق:", f"{float(rows[only_en].median()):.4f}")
توکن‌های فقط فارسی : 62 · میانهٔ بزرگ‌ترین قدرمطلق: 0.0765
توکن‌های فقط انگلیسی: 60 · میانهٔ بزرگ‌ترین قدرمطلق: 0.0881

📏 اندازه بگیر: توکن‌های فارسی در این نمونهٔ کوچک بردارهای کمی کوچک‌تری دارند و اولین قربانیِ یک مقیاسِ درشت‌اند. این توضیحِ فاصلهٔ ۰٫۲۴ و ۰٫۶۶ است، ولی توضیحِ اختلافِ کوچکِ بخشِ ۴ نیست، چون آنجا جدول دست‌نخورده بود. آن اختلاف از لایه‌های خطی می‌آید و علتش را اینجا نسنجیده‌ایم؛ تمرینِ ستاره‌دار دست‌کم نشان می‌دهد واقعی است یا نه.

درسِ عملی: اگر مدلی را برای فارسی کوانتیزه می‌کنی، کیفیت را روی فارسی بسنج، نه روی معیارهای انگلیسی. عددی که سازندهٔ مدل اعلام کرده، احتمالاً روی متنِ انگلیسی اندازه‌گیری شده.

۷. انتخاب#

دقت حافظه کیفیت کِی
float32 ۴۴۹ مگابایت مرجع آموزش
float16 ۲۲۴ مگابایت عملاً یکسان پیش‌فرضِ اجرا
int8 سطری ۱۱۲ مگابایت یکسان در آزمایشِ ما وقتی حافظه تنگ است
int4 گروهی ۵۶ مگابایت افتِ کم ولی واقعی، بیشتر برای فارسی وقتی جز این راهی نیست
int4 تک‌مقیاس ۵۶ مگابایت مدل را می‌کشد هرگز

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

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

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

کلمه تلفظ به حروف فارسی یعنی چه
quantization کوانتیزیشن نمایشِ وزن‌ها با بیتِ کمتر و پله‌های محدود
scale اسکیل ضریبی که بازهٔ اعداد را به پله‌ها می‌نگارد
per-channel پر-چنل یک مقیاسِ جدا برای هر سطر به‌جای کلِ ماتریس
group size گروپ سایز تعدادِ وزن‌هایی که یک مقیاس را شریک‌اند
outlier اوت‌لایر وزنِ خیلی بزرگی که مقیاس را برای همه خراب می‌کند
simulated quantization سیمولیتد کوانتیزیشن گِرد کردن بدونِ ذخیرهٔ واقعیِ کم‌بیتی، برای سنجشِ کیفیت

🔧 اگر کار نکرد: اگر بعد از کوانتیزه کردن خروجی nan شد، scale جایی صفر شده — یعنی سطری تماماً صفر داشته‌ای. یک clamp(min=1e-8) روی scale بگذار. و اگر حافظهٔ Colab پر شد، copy.deepcopy سه نسخهٔ کاملِ مدل ساخته؛ هر بار یکی بساز، اندازه بگیر، و با del آزادش کن.

🤖 از دستیارت بپرس: «تفاوتِ post-training quantization با quantization-aware training چیست؟» بعد این را بپرس: «اگر مدل بعد از کوانتیزه شدن روی زبانِ من خیلی افت کرد، کدامشان کمکم می‌کند؟» — و همان‌جا می‌بینی چرا برای زبان‌های کم‌داده، کالیبره کردن با دادهٔ همان زبان مهم‌تر از انتخابِ الگوریتم است.

تمرین‌ها

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

در فصل بعد#

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

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

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