در این فصل چه یاد میگیری#
فصلِ قبل آموزش را ارزان کرد. اجرا هنوز گران است: ۴۴۸ مگابایت برای مدلی که «کوچک» حساب میشود.
در این فصل وزنها را از ۳۲ بیت به ۸ و ۴ بیت میبریم و خودمان کدش را مینویسیم — سه خط ریاضی، نه بیشتر. حافظه یکهشتم میشود. و بعد سه چیز را اندازه میگیریم که هیچکدام از قبل معلوم نیست:
- یک تصمیمِ ظاهراً بیاهمیت، دقت را از ۰٫۹۸ به ۰٫۶۶ میاندازد.
- افتِ کیفیت روی فارسی از انگلیسی بیشتر است — و میسنجیم چه بخشی از آن واقعاً به جدولِ
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 را صدا بزنیم، خودمان یک پلِ کوچک بینِ فضای تصویر و فضای متن آموزش میدهیم — همان کاری که مدلهای چندوجهی در مقیاسِ بزرگ میکنند.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.