ছোট আর দ্রুত model — quantization, distillation আর pruning

পর্ব ৫৫ · Parameter-efficient fine-tuning-এ QLoRA 4-bit base ব্যবহার করেছিল, কিন্তু 4-bit আসলে কী, তা খুলে দেখা হয়নি। পর্ব ৪৮ · BERT পরিবার-এর Bangla BERT ভালো ফল দেয়, কিন্তু ৬২৭ MiB আর CPU-তে ধীর। এই পর্বে তিনটি কৌশলে model ছোট আর দ্রুত করব, আর প্রতিবার পর্ব ৫৮ · LLM মূল্যায়ন-এর নিয়মে মাপব মান কতটা টিকল। ১৬-bit সংখ্যার গঠন পর্ব ১২ · GPU performance-এ আছে। Desktop-এর run লেখার সময়ে (২০২৬ সালের নভেম্বর) এই version-এ: Python 3.12, torch 2.15.0, transformers 5.22.2, bitsandbytes 0.50.2, scikit-learn 1.9.1. কোন run GPU-তে আর কোনটি CPU-তে, তা পাশে লেখা আছে।

১ · কেন ছোট model — প্রতি parameter-এ কত byte

মুদি দোকানের খাতায় দোকানি ৪৭.৩৮ টাকা লেখেন না, লেখেন ৪৭ টাকা। প্রতিটি হিসাবে কয়েক পয়সা হারায়, কিন্তু খাতা অনেক সহজ হয়, আর মাসের শেষে মোট প্রায় একই থাকে। Model-এর ওজনেও একই কাজ করা যায়। এর নাম quantization.

ছোট model কেন দরকার? তিনটি খরচ। এক, memory: পুরো model GPU বা ফোনের RAM-এ ধরতে হবে। দুই, latency: একটি উত্তরে কত সময়। LLM-এ প্রতিটি নতুন token-এর জন্য সব ওজন memory থেকে একবার পড়তে হয়, তাই ওজন ছোট হলে পড়াও দ্রুত। তিন, টাকা আর বিদ্যুৎ: একই server-এ বেশি অনুরোধ। এর তিনটি উত্তর:

প্রথম হিসাবটি সরল: parameter-এর সংখ্যা × প্রতিটির byte. fp32-এ ৪ byte, bf16 বা fp16-এ ২, int8-এ ১, int4-এ আধা byte. তবে quantize করা ওজনের সঙ্গে scale-ও রাখতে হয়, আর কিছু অংশ (embedding, norm) প্রায়ই quantize করা হয় না। নিচের stepper-এ Qwen2.5-0.5B (Apache 2.0), যার parameter পর্ব ৫৫-এ গোনা হয়েছিল:

২ · Quantization-এর মূল সূত্র — scale আর zero point

ধরুন একটি tensor-এর মান −০.৫ থেকে ২.০৫-এর মধ্যে। int8-এ মাত্র ২৫৬টি ঘর। কাজ হলো এই দশমিক পরিসরকে ২৫৬টি সমান ধাপে ভাগ করা। প্রতিটি ধাপের মাপ scale s. আর আসল ০.০ কোন পূর্ণসংখ্যায় পড়বে, সেটি zero point z. সূত্র:

q = clip(round(x / s) + z, q_min, q_max)  ·   x̂ = (q − z) · s

এখানে x আসল দশমিক মান, q পূর্ণসংখ্যা, x̂ (“এক্স-হ্যাট”) ফিরিয়ে আনা মান, আর clip মানে সীমার বাইরে গেলে সীমায় আটকে দেওয়া। q থেকে x̂ ফেরানোকে বলে dequantization. Asymmetric পদ্ধতিতে s = (max − min) / (q_max − q_min) আর z = round(q_min − min / s). Symmetric পদ্ধতিতে z = ০ আর s = max|x| / ১২৭; হিসাব সহজ, কিন্তু পরিসর একদিকে হেলে থাকলে ঘর নষ্ট হয়।

এবার হাজারটি সংখ্যায় একই কাজ চালিয়ে দেখুন। দুই ধরনের ডেটা: শূন্যকেন্দ্রিক ওজন, আর ReLU-র পরের activation, যার সব মান শূন্য বা ধনাত্মক।

import numpy as np
rng = np.random.default_rng(42)
w = rng.normal(0, 0.05, 1000)                  # একটি layer-এর ওজনের মতো: শূন্যকেন্দ্রিক
a = np.maximum(rng.normal(0.3, 0.4, 1000), 0)  # ReLU-এর পরের activation: সব ≥ 0

def quant(x, bits, sym):
    if sym:                                    # symmetric: zero point = 0
        qmax = 2 ** (bits - 1) - 1             # int8-এ 127
        s, z, lo, hi = np.abs(x).max() / qmax, 0, -qmax, qmax
    else:                                      # asymmetric: [min, max] পুরো grid-এ
        lo, hi = 0, 2 ** bits - 1              # uint8-এ 0..255
        s = (x.max() - x.min()) / (hi - lo)
        z = int(np.round(lo - x.min() / s))
    q = np.clip(np.round(x / s) + z, lo, hi)   # float → পূর্ণসংখ্যা
    return q, s, z

def report(name, x, bits, sym):
    q, s, z = quant(x, bits, sym)
    xh = (q - z) * s                           # dequantize: পূর্ণসংখ্যা → float
    err = np.abs(x - xh)
    used = len(np.unique(q))
    print(f"{name:6s} {bits} {'sym ' if sym else 'asym'} │ {s:.5f} │ {z:3d} │ {used:3d}"
          f" │ {err.max():.5f} │ {s / 2:.5f} │ {np.sqrt((err**2).mean()) / x.std():.4f}")

print("ডেটা  bit মোড  │ scale s │ z   │ ঘর  │ max err │ s/2     │ rel RMSE")
for bits in (8, 4):
    report("weight", w, bits, True)
    report("weight", w, bits, False)
    report("act", a, bits, True)
    report("act", a, bits, False)
q, s, z = quant(a, 8, False)
print("activation-এ শূন্য:", int((a == 0).sum()), "টি │ ফিরে ঠিক 0.0?",
      bool(np.all((q[a == 0] - z) * s == 0)))

ডেটা  bit মোড  │ scale s │ z   │ ঘর  │ max err │ s/2     │ rel RMSE
weight 8 sym  │ 0.00144 │   0 │ 169 │ 0.00072 │ 0.00072 │ 0.0085
weight 8 asym │ 0.00134 │ 136 │ 179 │ 0.00067 │ 0.00067 │ 0.0080
act    8 sym  │ 0.01154 │   0 │ 106 │ 0.00576 │ 0.00577 │ 0.0091
act    8 asym │ 0.00575 │   0 │ 192 │ 0.00287 │ 0.00287 │ 0.0045
weight 4 sym  │ 0.02606 │   0 │  14 │ 0.01301 │ 0.01303 │ 0.1543
weight 4 asym │ 0.02276 │   8 │  16 │ 0.01135 │ 0.01138 │ 0.1329
act    4 sym  │ 0.20939 │   0 │   8 │ 0.10437 │ 0.10469 │ 0.1649
act    4 asym │ 0.09771 │   0 │  16 │ 0.04886 │ 0.04886 │ 0.0774
activation-এ শূন্য: 247 টি │ ফিরে ঠিক 0.0? True

৩ · Per-tensor, per-channel আর outlier

পুরো tensor-এর জন্য একটি scale হলো per-tensor quantization. প্রতিটি সারি বা কলামের নিজের scale হলে per-channel; আর ৬৪ বা ১২৮টি মানের প্রতিটি ছোট দলের নিজের scale হলে group-wise বা block-wise (পর্ব ৫৫-এর NF4 এভাবেই ৬৪-এর block নেয়)। Scale যত বেশি, বাড়তি জায়গা তত বেশি, কিন্তু ত্রুটি তত কম।

কেন এটি এত জরুরি? ক্লাসের ৩০ জনের নম্বর একটি স্কেলে আঁকতে গিয়ে যদি একজনের নম্বর ভুলে ১০০০ লেখা থাকে, বাকিদের সবাই শূন্যের কাছে জড়ো হয়ে যায়। Dettmers ও সহলেখকেরা (LLM.int8(), ২০২২) দেখান, বড় transformer-এ কয়েকটি নির্দিষ্ট hidden মাত্রায় খুব বড় activation (outlier feature) নিয়মিত দেখা দেয়, আর তাঁদের পরীক্ষায় প্রায় ৬৭০ কোটি parameter থেকে বড় model-এ এই সমস্যা প্রকট হয়েছিল। নিচের কোডে ৬৪টি token × ১৬টি feature-এর একটি activation, যার feature ৫ বাকিদের প্রায় ৬০ গুণ বড়:

import numpy as np
rng = np.random.default_rng(42)
X = rng.normal(0, 1, (64, 16))                 # 64টি token × 16টি feature (activation)
X[:, 5] *= 60                                  # feature 5: outlier, বাকিদের চেয়ে ~60 গুণ বড়
W = rng.normal(0, 0.1, (16, 8))                # পরের Linear layer-এর ওজন
Y = X @ W                                      # আসল (float) output

def q8(x, axis=None):                          # symmetric int8, scale নির্দিষ্ট axis ধরে
    s = np.abs(x).max(axis=axis, keepdims=axis is not None) / 127
    return np.clip(np.round(x / s), -127, 127) * s

def rel_err(Xh, cols=slice(None)):
    return np.linalg.norm(Xh[:, cols] - X[:, cols]) / np.linalg.norm(X[:, cols])

normal = [c for c in range(16) if c != 5]
cases = {
    "per-tensor": q8(X),
    "per-token (সারি)": q8(X, axis=1),
    "per-feature (কলাম)": q8(X, axis=0),
}
out = np.arange(16) == 5                       # LLM.int8 ধারণা: outlier কলাম float-এ
cases["outlier আলাদা"] = q8(np.where(out, 0, X)) + np.where(out, X, 0)
print("scale per-tensor:", round(np.abs(X).max() / 127, 4),
      "│ সাধারণ কলামের |x| সর্বোচ্চ:", round(np.abs(X[:, normal]).max(), 2))
print(f"{'পদ্ধতি':20s} │ সাধারণ কলামে ত্রুটি │ output Y-তে ত্রুটি")
for name, Xh in cases.items():
    ey = np.linalg.norm(Xh @ W - Y) / np.linalg.norm(Y)
    print(f"{name:20s} │ {rel_err(Xh, normal):18.4f} │ {ey:.4f}")
z = np.round(X[:, normal] / (np.abs(X).max() / 127))
print("per-tensor-এ সাধারণ কলামের কতগুলো মান 0-তে নামল:", f"{(z == 0).mean():.0%}")

scale per-tensor: 1.7237 │ সাধারণ কলামের |x| সর্বোচ্চ: 3.18
পদ্ধতি               │ সাধারণ কলামে ত্রুটি │ output Y-তে ত্রুটি
per-tensor           │             0.4991 │ 0.0350
per-token (সারি)     │             0.1572 │ 0.0115
per-feature (কলাম)   │             0.0059 │ 0.0075
outlier আলাদা        │             0.0076 │ 0.0005
per-tensor-এ সাধারণ কলামের কতগুলো মান 0-তে নামল: 63%

বাস্তবের প্রচলিত পদ্ধতিগুলো এই সমস্যারই নানা সমাধান। নিচের বিবরণ প্রতিটির মূল প্রবন্ধ বা নথি থেকে, সংক্ষেপে:

দুটি শব্দজোড়া মনে রাখুন। Post-training quantization (PTQ): শেখা model-কে পরে quantize করা, training ছাড়া; ওপরের সবগুলোই এই দলে। Quantization-aware training (QAT): training-এর সময়ই rounding-এর প্রভাব নকল করা, যাতে model তা সামলাতে শেখে; খরচ বেশি, কম bit-এ মান সাধারণত ভালো। আর activation-এর scale যদি আগে থেকে calibration ডেটায় ঠিক করা থাকে তবে static, প্রতিটি batch-এ নতুন করে মাপা হলে dynamic.

৪ · PyTorch-এ dynamic int8, CPU-তে — সত্যিকারের run

প্রথমে একটি teacher বানালাম, যা এই পর্বের সব পরীক্ষায় লাগবে: sagorsarker/bangla-bert-base (MIT, do_lower_case=False), পর্ব ৪২ · Text classification-এর Sazzed-এর বাংলা YouTube মন্তব্যে (Mendeley Data, CC BY 4.0), প্রথম split (train ৭,৫১০, validation ১,০৫৬, test ২,১৪৩), পর্ব ৫৫-এর full fine-tuning-এর একই রেসিপিতে, GPU-তে ৩ epoch, ১০০.৯ সেকেন্ড। Test macro-F1 ০.৯৪২৫, পর্ব ৫৫-এর সংখ্যার সঙ্গে হুবহু।

এবার এই model-কে CPU-তে dynamic int8-এ নিলাম। Dynamic মানে: Linear layer-এর ওজন আগে থেকেই int8-এ রাখা হয়, আর activation-এর scale প্রতিটি batch চলার সময় মেপে quantize করা হয়, তাই calibration ডেটা লাগে না। মূল লাইন একটিই (script থেকে ছোট করা):

model = AutoModelForSequenceClassification.from_pretrained("teacher").eval()
qmodel = torch.ao.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8)

প্রতিটি model-এ মাপা হয়েছে: state_dict-এর আকার, ২০০টি test মন্তব্যে এক এক করে (batch ১) সময়ের median, পুরো ২,১৪৩টি test ৬৪-এর batch-এ, আর macro-F1. CPU-তে ৩টি thread, warm-up-এর পর। সত্যিকারের run, JSON লাইন থেকে সাজানো:

৫ · bitsandbytes-এ 8-bit আর 4-bit — একটি ছোট LLM

এবার decoder LLM: Qwen/Qwen2.5-0.5B (base, Apache 2.0, revision 060db64). bitsandbytes দিয়ে তিনভাবে লোড: bf16, 8-bit (LLM.int8()) আর 4-bit NF4, double quantization-সহ। মাপা হয়েছে memory footprint, peak GPU memory, উপেন্দ্রকিশোরের তিনটি গল্পে (bn.wikisource, পাতায় PD-India ট্যাগ) perplexity, আর greedy generation-এর গতি। GPU-তে, প্রতিটি precision আলাদা process-এ:

bnb8 = BitsAndBytesConfig(load_in_8bit=True)
bnb4 = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
           bnb_4bit_use_double_quant=True, bnb_4bit_compute_dtype=torch.bfloat16)
model = AutoModelForCausalLM.from_pretrained(path, quantization_config=bnb4, device_map={"": 0})
# perplexity: 8,192 token, ৫১২-এর আলাদা জানালায় (script থেকে ছোট করা)

একই prompt (“শিয়াল পণ্ডিত একদিন বনের ধারে বসে ভাবছিল,”), greedy decoding, seed ০; script প্রথম ৪০টি token decode করে print করে, তাই শেষের ভাঙা অক্ষর “…” দিয়ে বদলানো আর লাইনের শুরুতে precision-এর নাম যোগ করা হয়েছে। সত্যিকারের output:

bf16  GEN:  এবং একদিন বনের ধারে বসে ভাবছিল, এবং এ…
int8  GEN:  এবং একটি পরিবর্তন করে এবং একটি পরিবর্…
nf4   GEN:  এই বিবেচনা সম্পর্কে সম্পর্কে সম্পর্কে স…

৬ · Knowledge distillation — teacher, student আর temperature

অভিজ্ঞ ডাক্তার রোগ নির্ণয়ে শুধু “টাইফয়েড” বলেন না। বলেন, “সম্ভবত টাইফয়েড, তবে ডেঙ্গুও হতে পারে, ম্যালেরিয়ার সম্ভাবনা কম।” নবীন ডাক্তার এই দ্বিধা থেকেও শেখেন: কোন রোগগুলো একে অপরের কাছাকাছি। Model-এর বেলায় এই নরম উত্তর হলো softmax-এর পুরো বণ্টন, শুধু সবচেয়ে বড়টি নয়। বাজারঘরের রিভিউ “ডেলিভারি দেরিতে, কিন্তু জিনিস ভালো” পড়ে একটি ভালো teacher হয়তো বলে ভালো ০.৬, খারাপ ০.৪; hard label শুধু বলে “ভালো”।

Knowledge distillation-এর আধুনিক রূপ Hinton, Vinyals ও Dean-এর ২০১৫ সালের প্রবন্ধে; বড় model-এর আচরণ ছোট model-এ নেওয়ার ধারণা আরও আগের (Buciluǎ, Caruana ও Niculescu-Mizil, ২০০৬, “model compression”). KL divergence আর nn.KLDivLoss-এর ফাঁদ পর্ব ১৩ · Loss function-এ আছে; এখানে পুরো পদ্ধতি। Teacher-এর logit z_t আর student-এর z_s-কে একটি temperature T দিয়ে ভাগ করে softmax নেওয়া হয়: p_T = softmax(z_t/T), q_T = softmax(z_s/T). T > ১ হলে বণ্টন নরম হয়, ছোট probability-গুলো চোখে পড়ে। এগুলোই soft target. Loss:

L = α · CE(y, softmax(z_s)) + (1 − α) · T² · KL(p_T ‖ q_T)

প্রথম অংশ সাধারণ cross-entropy, আসল label y-এর সঙ্গে, T = ১-এ। দ্বিতীয় অংশ teacher-এর নরম বণ্টনের সঙ্গে মিল। α দুটির ভার ঠিক করে। আর T² কেন? Student-এর logit-এর সাপেক্ষে KL অংশের gradient হলো (q_T − p_T)/T. বড় T-এ q আর p দুটিই সমান বণ্টনের কাছে যায়, তাই পার্থক্যও মোটামুটি 1/T হারে ছোট হয়; সব মিলিয়ে gradient প্রায় 1/T² হারে কমে। T² দিয়ে গুণ করলে মাপ মোটামুটি স্থির থাকে, আর T বদলালে α নতুন করে খুঁজতে হয় না। Hinton ও সহলেখকেরা প্রবন্ধে ঠিক এই কারণ লিখেছেন।

এবার চারটি temperature-এ loss আর gradient, আর gradient-এর সূত্রটি finite difference দিয়ে যাচাই:

import numpy as np
np.set_printoptions(precision=3, suppress=True)
zt = np.array([3.0, 1.0, -1.0])                # teacher logits: ভালো, মাঝারি, খারাপ
zs = np.array([2.0, 1.5, -0.5])                # student logits
y = 0                                          # আসল (hard) label: "ভালো"

def softmax(z, T=1.0):
    e = np.exp((z - z.max()) / T)
    return e / e.sum()

def kd_loss(zs, T):                            # T² · KL(p_T ‖ q_T)
    p, q = softmax(zt, T), softmax(zs, T)
    return T**2 * np.sum(p * (np.log(p) - np.log(q)))

print("T   │ teacher-এর p_T      │ KD     │ |g|    │ T² ছাড়া │ যাচাই")
for T in (1, 2, 4, 8):
    p, q = softmax(zt, T), softmax(zs, T)
    g = T * (q - p)                            # বিশ্লেষণী gradient: d loss / d zs
    eps, num = 1e-6, np.zeros(3)
    for i in range(3):                         # finite difference দিয়ে যাচাই
        d = np.zeros(3); d[i] = eps
        num[i] = (kd_loss(zs + d, T) - kd_loss(zs - d, T)) / (2 * eps)
    print(f"T={T} │ {p} │ {kd_loss(zs, T):.4f} │ {np.linalg.norm(g):.4f}"
          f" │ {np.linalg.norm(g) / T**2:.4f} │ {np.abs(g - num).max():.0e}")

T, alpha = 2, 0.5
ce = -np.log(softmax(zs)[y])                   # hard label-এর cross-entropy (T=1)
total = alpha * ce + (1 - alpha) * kd_loss(zs, T)
print(f"hard CE={ce:.4f} │ মোট = {alpha}·CE + {1 - alpha}·KD = {total:.4f}")

T   │ teacher-এর p_T      │ KD     │ |g|    │ T² ছাড়া │ যাচাই
T=1 │ [0.867 0.117 0.016] │ 0.1812 │ 0.3674 │ 0.3674 │ 7e-11
T=2 │ [0.665 0.245 0.09 ] │ 0.2664 │ 0.4590 │ 0.1147 │ 3e-10
T=4 │ [0.506 0.307 0.186] │ 0.2800 │ 0.4595 │ 0.0287 │ 1e-09
T=8 │ [0.419 0.326 0.254] │ 0.2708 │ 0.4405 │ 0.0069 │ 7e-09
hard CE=0.5239 │ মোট = 0.5·CE + 0.5·KD = 0.3952

৭ · সত্যিকারের distillation — Bangla BERT থেকে ছোট BiGRU

Teacher: অংশ ৪-এর Bangla BERT (১৬.৪ কোটি parameter, test macro-F1 ০.৯৪২৫)। Student: একটি ছোট BiGRU (পর্ব ২৯ · LSTM আর GRU): ৬৪ মাত্রার embedding, দুই দিকের GRU, mean আর max pooling, তারপর একটি Linear; মোট ৬৫,৭৮,১১৪টি parameter, teacher-এর ২৫ ভাগের এক ভাগ, বেশির ভাগই embedding-এ। একই tokenizer, একই split. Student CPU-তে ৮ epoch, Adam, lr ২ × ১০^−৩; validation-এর সেরা epoch-এর ওজন test-এ। Teacher-এর logit একবার হিসাব করে রাখা হয়েছে, তাই distillation-এর সময় teacher আর চালাতে হয় না। প্রতিটি সেটিং তিনটি seed-এ (০, ১, ২); KD-তে α = ০.৫। সত্যিকারের run, JSON লাইন থেকে সাজানো:

৮ · Pruning — magnitude, structured বনাম unstructured

বাগানের মালি গাছের সব ডাল কাটেন না; শুকনো আর ছোট ডাল ছাঁটেন, গাছ টিকে থাকে। Magnitude pruning-এর ধারণা একই: যে ওজনের পরম মান সবচেয়ে ছোট, তার প্রভাবও সম্ভবত ছোট, তাই সেটি শূন্য করা। শূন্যের অনুপাতকে বলে sparsity. যেকোনো জায়গার আলাদা আলাদা ওজন শূন্য করা হলো unstructured; পুরো neuron, attention head বা layer কেটে ফেলা structured. প্রথমটিতে কম ক্ষতিতে বেশি শূন্য করা যায়; দ্বিতীয়টিতে matrix সত্যিই ছোট হয়। একটি layer-এ তিনটি পদ্ধতি পাশাপাশি, retraining ছাড়া:

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(42)
d_in, d_out = 128, 64
W = rng.standard_t(df=4, size=(d_out, d_in)) * 0.05  # প্রশিক্ষিত ওজনের মতো: লম্বা লেজ
X = rng.normal(0, 1, (500, d_in))
Y = X @ W.T

def out_err(Wp):
    return np.linalg.norm(X @ Wp.T - Y) / np.linalg.norm(Y)

sp = np.array([0, 0.2, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95])
mag, rnd, row = [], [], []
for s in sp:
    thr = np.quantile(np.abs(W), s)            # magnitude: ছোট |w| শূন্য
    mag.append(out_err(np.where(np.abs(W) >= thr, W, 0) if s else W))
    keep = rng.random(W.shape) >= s            # তুলনা: এলোমেলো ওজন শূন্য
    rnd.append(out_err(W * keep))
    k = int(round(s * d_out))                  # structured: পুরো সারি (neuron) বাদ
    Wr = W.copy(); Wr[np.argsort(np.linalg.norm(W, axis=1))[:k]] = 0
    row.append(out_err(Wr))
print(" sparsity │ magnitude │ random │ সারি বাদ")
for s, m, r, w in zip(sp, mag, rnd, row):
    print(f"   {s:4.0%}   │  {m:.4f}   │ {r:.4f} │ {w:.4f}")
nz = np.abs(W) >= np.quantile(np.abs(W), 0.9)
print("90%-এ বাকি ওজন:", int(nz.sum()), "of", W.size,
      "│ dense গুণে তবু গুণ:", d_out * d_in, "টি")

fig, ax = plt.subplots(figsize=(5, 3))
ax.plot(sp * 100, mag, "o-", label="magnitude (unstructured)")
ax.plot(sp * 100, rnd, "s--", label="random")
ax.plot(sp * 100, row, "^:", label="whole rows (structured)")
ax.set_xlabel("sparsity (%)"); ax.set_ylabel("relative output error")
ax.set_title("Pruning one layer, no retraining"); ax.legend(fontsize=8)
plt.show()

 sparsity │ magnitude │ random │ সারি বাদ
     0%   │  0.0000   │ 0.0000 │ 0.0000
    20%   │  0.0498   │ 0.4261 │ 0.3822
    40%   │  0.1423   │ 0.6294 │ 0.5634
    50%   │  0.2043   │ 0.7102 │ 0.6350
    60%   │  0.2801   │ 0.7613 │ 0.7020
    70%   │  0.3720   │ 0.8202 │ 0.7770
    80%   │  0.4830   │ 0.8852 │ 0.8425
    90%   │  0.6374   │ 0.9433 │ 0.9221
    95%   │  0.7470   │ 0.9759 │ 0.9571
90%-এ বাকি ওজন: 820 of 8192 │ dense গুণে তবু গুণ: 8192 টি

সত্যিকারের run, Bangla BERT teacher-এ. Encoder-এর সব Linear ওজনে (৮,৪৯,৩৪,৬৫৬টি) global magnitude pruning, কোনো retraining ছাড়া, আর তুলনায় FFN-এর neuron (intermediate layer-এর সারি) কাটা। Test macro-F1, GPU-তে মাপা:

তারপর CPU-তে সময়, অংশ ৪-এর একই নিয়মে: ৯০% শূন্য করা model (আকার একই), আর FFN-এর অর্ধেক neuron সত্যিই কেটে ছোট Linear বানানো model (৩০৭২ থেকে ১৫৩৬ মাপ)। সত্যিকারের run:

৯ · কোনটি কখন — তিন কৌশলের তুলনা

তিনটি কৌশল একে অপরের বিকল্প নয়; প্রায়ই একসঙ্গে লাগে। আমাদের মাপা ফলের আলোকে একটি সংক্ষিপ্ত ছক:

ছোট করা model-কে নতুন model হিসেবে মাপুন: একই held-out সেট, আগে-পরে জোড়া তুলনা, বদলানো উত্তরের সংখ্যা, আর সময় আসল যন্ত্রে। ছোট করা model চালু করার কাজ (FastAPI, batch scoring, ONNX) মেশিন লার্নিং কোর্সের পর্ব ৬৮-এ; একই model ONNX Runtime-এ চালিয়ে আরও গতি পাওয়া যেতে পারে, তা এখানে মাপা হয়নি। এটি এক জোড়া মাপের ব্যাপার নয়: MLOps নিয়ে পরের একটি কোর্সে model-এর version আর নজরদারি আরও বিস্তারে আসবে।

১০ · AI-এর যুগে — ছোট করার কোড আর দাবি যাচাই

Quantization আর distillation-এর কোড AI assistant দ্রুত লেখে, কিন্তু এই ক্ষেত্রের API খুব দ্রুত বদলায়: আমাদের run-এই torch.ao.quantization নিজে deprecation-এর সতর্কবার্তা দিয়েছে, আর bitsandbytes-এর argument transformers-এর version-ভেদে আলাদা।

AI-এর লেখা compression কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• torch, transformers আর bitsandbytes-এর version লিখে নিজের version-এর নথিতে argument মিলিয়েছি
• ছোট একটি tensor-এ quantize-dequantize হাতে হিসাব করে কোডের সঙ্গে মিলিয়েছি
• model.eval() আর no_grad আছে; একই input-এ দুবার একই output আসে
• আগে-পরে একই held-out সেটে মান, বদলানো উত্তরের সংখ্যা আর warm-up-এর পর সময় মেপেছি
• Distillation-এর লাভ দাবির আগে একই student hard label-এ, কয়েকটি seed-এ শিখিয়েছি
• কোনো token, ব্যক্তিগত ডেটা বা গ্রাহকের লেখা prompt-এ দিইনি