# فصل ۰۲ — `quantization` و مدلِ محلی

<div dir="rtl">

# فصل ۰۲ — `quantization` و مدلِ محلی

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

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

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

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

![وزنه‌هایی که به پله‌های محدودی گرد می‌شوند](/lesson-assets/t6-s02-quantization/prompt/01-image-rounded-steps.png)

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

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

## قبل از شروع

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

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

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

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

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

</div>

```python
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} مگابایت")
```

<div dir="rtl">

</div>

```text
پارامترها: 117653760
  با 32 بیت:   448.8 مگابایت
  با 16 بیت:   224.4 مگابایت
  با  8 بیت:   112.2 مگابایت
  با  4 بیت:    56.1 مگابایت
```

<div dir="rtl">

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

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

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

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

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

</div>

```python
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%}")
```

<div dir="rtl">

</div>

```text
  یک مقیاس برای کل     8 بیت → خطای نسبی 1.3693%
  یک مقیاس برای کل     4 بیت → خطای نسبی 25.1700%
  مقیاس برای هر سطر    8 بیت → خطای نسبی 0.8125%
  مقیاس برای هر سطر    4 بیت → خطای نسبی 14.6801%
```

<div dir="rtl">

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

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
لایه‌های خطیِ کوانتیزه‌شده: 73
```

<div dir="rtl">

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

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

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

</div>

```python
@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}")
```

<div dir="rtl">

</div>

```text
  مدل                       فارسی    انگلیسی
  ۸ بیت، هر سطر            0.9999     0.9999
  ۴ بیت، هر سطر            0.9574     0.9756
  ۴ بیت، یک مقیاس          0.2488     0.3278
```

<div dir="rtl">

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

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

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

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
  مدل                    دقتِ موضوع
  کاملِ ۳۲ بیت               0.9767
  ۸ بیت، هر سطر              0.9767
  ۴ بیت، هر سطر              0.9826
  ۴ بیت، یک مقیاس            0.6628
```

<div dir="rtl">

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

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
بزرگ‌ترین قدرمطلقِ هر سطرِ جدولِ embedding:
  کمینه: 0.0028 · میانه: 0.0647 · بیشینه: 0.6518
  نسبتِ بیشینه به میانه: 10.1
```

<div dir="rtl">

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

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

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

</div>

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

<div dir="rtl">

</div>

```text
پارامترهای لایه‌های خطی : 21381120 (18.2%)
پارامترهای جدولِ embedding: 96014208 (81.6%)
نسبتِ بیشینه به میانه در لایه‌های خطی: میانه 1.9 · بدترین 27.7 در encoder.layer.0.output.dense
```

<div dir="rtl">

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

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

</div>

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

<div dir="rtl">

</div>

```text
  چه چیزی گرد شد                  فارسی  انگلیسی      دقت
  فقط جدول، ۴ بیت، یک مقیاس      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
```

<div dir="rtl">

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

</div>

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

<div dir="rtl">

</div>

```text
توکن‌های فقط فارسی : 62 · میانهٔ بزرگ‌ترین قدرمطلق: 0.0765
توکن‌های فقط انگلیسی: 60 · میانهٔ بزرگ‌ترین قدرمطلق: 0.0881
```

<div dir="rtl">

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

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

## ۷. انتخاب

</div>

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

<div dir="rtl">

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

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

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

</div>

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

<div dir="rtl">

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

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

## تمرین‌ها

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

**تمرینِ اجباری:** `quantize_grouped(w, bits, group=64)` را بنویس — هر ۶۴ وزنِ کنارِ هم یک مقیاس. جدولِ بخشِ ۲ را با `group` برابرِ ۳۲ و ۶۴ و ۱۲۸ کامل کن و بعد جدولِ بخشِ ۴ را هم برایش بساز. **از کدام اندازهٔ گروه به بعد، بهبود ناچیز می‌شود؟** آن نقطه، انتخابِ عملیِ توست — چون گروهِ کوچک‌تر یعنی مقیاس‌های بیشتر یعنی حافظهٔ بیشتر.

**تمرینِ ستاره‌دار ⭐:** ادعای بخشِ ۴ را **جدی** بسنج: صد جفت جملهٔ فارسی-انگلیسی بساز (می‌توانی از جمله‌های `DOCS` ترمِ ۵ و ترجمه‌شان استفاده کنی) و **اختلافِ شباهت را با فاصلهٔ اطمینانِ `bootstrap` گزارش کن** (ترمِ ۵ فصلِ ۶). **آیا اختلاف از نویز بیرون می‌زند؟** بعد همین را برای یک زبانِ لاتینِ دیگر — مثلاً فرانسه — هم حساب کن. **جوابت به این سؤال جواب می‌دهد: مسئله «غیرلاتین بودن» است یا «کم‌داده بودن»؟**

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t6/s02-quantization (یادستان, Yaadestan)
