Parameter-efficient fine-tuning — LoRA, QLoRA আর adapter

পর্ব ৪৮ · BERT পরিবার-এ আপনি Bangla BERT-এর সব ১৬.৪ কোটি parameter Sazzed-এর বাংলা YouTube মন্তব্যে শিখিয়েছেন। সেটিই full fine-tuning. পর্ব ৫৩ · Hugging Face ecosystem-এ Hub আর Auto class দেখেছেন। Trainer দিয়ে সাধারণ fine-tuning-এর রেসিপি পর্ব ৫৪ · Transformer fine-tuning — classification, NER আর বাংলা ডেটা-য় আছে। এই পর্বের প্রশ্ন অন্য: সব parameter না ছুঁয়ে কি একই কাজ হয়? Desktop-এর run লেখার সময়ে (২০২৬ সালের নভেম্বর) এই version-এ: Python 3.12, torch 2.15.0, transformers 5.22.2, peft 0.21.2, bitsandbytes 0.50.2. GPU-র run GPU-তে, বাকিটা CPU-তে, যেখানে যেটি তা লেখা আছে।

১ · Full fine-tuning-এর খরচ — memory হাতে হিসাব

একটি রেডিমেড শার্ট কিনলেন, হাতা একটু লম্বা। দর্জি পুরো শার্ট খুলে নতুন করে সেলাই করেন না; হাতায় দুটি সেলাই দেন। Full fine-tuning হলো পুরো শার্ট নতুন করে সেলাই করা। ফল ভালো হতে পারে, কিন্তু খরচ পুরো শার্টের।

খরচটি কোথায়, হিসাব করি। Adam আর AdamW প্রতিটি parameter-এর জন্য দুটি বাড়তি সংখ্যা মনে রাখে: gradient-এর চলমান গড় m (first moment) আর বর্গের চলমান গড় v (second moment). এর সূত্র মেশিন লার্নিং কোর্সের পর্ব ১৪-এ derive করা; PyTorch-এ ব্যবহার পর্ব ১৫ · Optimizer আর schedule-এ। সব fp32 হলে প্রতি parameter-এ:

ওজন ৪ + gradient ৪ + m ৪ + v ৪ = ১৬ byte

Mixed precision-এ ওজন আর gradient bf16-এ (২ + ২ byte) রাখলেও সাধারণত একটি fp32 “master” কপি (৪ byte) থাকে, ফলে মোট আবার ১৬ byte. এর ওপর আসে activation memory: backward-এর জন্য forward-এর মাঝের ফল জমা রাখা, যা batch আর sequence দৈর্ঘ্যের ওপর নির্ভর করে (পর্ব ১২ · GPU performance). নিচের stepper-এ আমাদের model, sagorsarker/bangla-bert-base (MIT লাইসেন্স), classifier head-সহ ১৬,৪৩,৯৮,০৮২টি parameter.

দ্বিতীয় খরচ জমা রাখার। বাজারঘর যদি পাঁচটি কাজে (রিভিউয়ের মনোভাব, অভিযোগের ধরন, ডেলিভারির প্রশ্ন…) একই base model আলাদা করে full fine-tune করে, তবে পাঁচটি পুরো কপি, প্রতিটি শত শত MB. LoRA-তে একটি base আর পাঁচটি ছোট adapter ফাইল।

২ · LoRA-র মূল ধারণা — ΔW = BA

Fine-tuning শেষে একটি ওজন matrix W₀ থেকে হয় W₀ + ΔW. Full fine-tuning ΔW-এর প্রতিটি ঘর আলাদা করে শেখে। LoRA (Low-Rank Adaptation; Hu ও সহলেখক, arXiv ২০২১, ICLR ২০২২) একটি অনুমান করে: নতুন কাজে মানিয়ে নেওয়ার পরিবর্তনটির “আসল” মাত্রা কম, অর্থাৎ ΔW-এর rank কম। তাহলে ΔW-কে দুটি সরু matrix-এর গুণফল হিসেবে লেখা যায়:

h = W₀x + (α / r) · B A x,   B ∈ ℝ^d×r, A ∈ ℝ^r×k, r ≪ min(d, k)

এখানে x হলো layer-এর input (দৈর্ঘ্য k), h output (দৈর্ঘ্য d), W₀ হলো pretrained ওজন, যা frozen থাকে, মানে gradient পায় না। A প্রথমে x-কে r মাত্রায় চাপে, B আবার d মাত্রায় ছড়ায়। r হলো LoRA rank, α (lora_alpha) একটি স্থির গুণক। BA-র rank কখনো r-এর বেশি হতে পারে না, কারণ মাঝের পথ মাত্র r চওড়া।

সংখ্যায়: d = k = ৭৬৮ হলে ΔW-তে ৫,৮৯,৮২৪টি ঘর। r = ৮-এ A আর B মিলিয়ে ৮ × (৭৬৮ + ৭৬৮) = ১২,২৮৮টি, প্রায় ২%. অনুমানটি কেন যুক্তিসঙ্গত? Aghajanyan ও সহলেখকেরা (২০২০) দেখান, বড় pretrained model অনেক কাজ খুব কম মাত্রার একটি উপস্থানে (intrinsic dimension) শিখতে পারে; LoRA-র লেখকেরা এই ফলকেই অনুপ্রেরণা বলেছেন। তবে এটি পর্যবেক্ষণ, প্রমাণ নয়: কাজ base model-এর জ্ঞান থেকে যত দূরে (নতুন ভাষা, নতুন ধরনের ডেটা), ছোট r তত কম যথেষ্ট হতে পারে।

৩ · Parameter আর memory হাতে গোনা

Interview-এ সবচেয়ে বেশি আসে এই হিসাব। নিয়মটি একটিই: প্রতিটি adapt করা Linear layer (in = k, out = d)-এ r(k + d)টি নতুন parameter. তারপর layer-এর সংখ্যা দিয়ে গুণ, আর যেগুলো পুরো শেখানো হয় (যেমন classifier head) সেগুলো যোগ।

peft library-ও ঠিক এই সংখ্যা দেয়। আর decoder model-এ? Qwen2.5-0.5B-এর (Apache 2.0) শুধু config নামিয়ে, ওজন না নামিয়ে, meta device-এ model বানিয়ে গোনা যায়। সত্যিকারের run, CPU-তে:

~/bazarghar-dl$ uv run python count_qwen.py
hidden 896 | layers 24 | ffn 4864 | kv heads 2 | vocab 151936 | tied True
['q_proj', 'v_proj']   r= 4  trainable    270,336  of 494,032,768  (0.055%)
['q_proj', 'v_proj']   r= 8  trainable    540,672  of 494,032,768  (0.109%)
['q_proj', 'v_proj']   r=32  trainable  2,162,688  of 494,032,768  (0.438%)
all-linear             r= 8  trainable  4,399,104  of 494,032,768  (0.890%)

এবার memory-র হিসাবটি নিজে চালান। একই Qwen-এর আকার থেকে full fine-tuning আর বিভিন্ন rank-এর LoRA:

# Qwen2.5-0.5B-এর config থেকে আকার (hidden 896, 24 layer, ffn 4864, kv 128)
h, layers, ffn, kv, vocab = 896, 24, 4864, 128, 151936
mods = {"q": (h, h), "k": (h, kv), "v": (h, kv), "o": (h, h),
        "gate": (h, ffn), "up": (h, ffn), "down": (ffn, h)}
per_layer = sum(i * o for i, o in mods.values()) + h + 2 * kv + 2 * h  # bias + norm
total = layers * per_layer + vocab * h + h     # embedding (tied) + শেষ norm
GB = 1e9

def lora_params(r, names):
    return layers * sum(r * (mods[m][0] + mods[m][1]) for m in names)

print(f"মোট parameter ≈ {total / 1e6:.1f} M")
full = total * 16                                # fp32 w + grad + Adam m + v
print(f"full fine-tuning (fp32 + AdamW): {full / GB:5.2f} GB")
print(f"   ওজন {total*4/GB:.2f} │ grad {total*4/GB:.2f} │ m+v {total*8/GB:.2f}")
print("target   r │  trainable │   %   │ bf16 base + adapter (GB)")
for names, label in [(("q", "v"), "q,v"), (tuple(mods), "all")]:
    for r in (4, 8, 32):
        p = lora_params(r, names)
        mem = total * 2 + p * 16                 # frozen bf16, adapter fp32 + grad + m + v
        print(f"{label:5s} {r:4d} │ {p:10,d} │ {100 * p / total:5.2f} │ {mem / GB:.3f}")
lin = layers * sum(i * o for i, o in mods.values())  # শুধু Linear ওজন 4-bit হয়
bits = 4 + 8 / 64 + 32 / (64 * 256)              # NF4 + double-quant ধ্রুবক
q = lin * bits / 8 + (total - lin) * 2 + lora_params(8, ("q", "v")) * 16
print(f"QLoRA q,v r=8: Linear {bits:.3f} bit/param, বাকি bf16 → {q / GB:.3f} GB")
print("activation বাদ; batch আর sequence দৈর্ঘ্যের ওপর নির্ভর করে")

মোট parameter ≈ 494.0 M
full fine-tuning (fp32 + AdamW):  7.90 GB
   ওজন 1.98 │ grad 1.98 │ m+v 3.95
target   r │  trainable │   %   │ bf16 base + adapter (GB)
q,v      4 │    270,336 │  0.05 │ 0.992
q,v      8 │    540,672 │  0.11 │ 0.997
q,v     32 │  2,162,688 │  0.44 │ 1.023
all      4 │  2,199,552 │  0.45 │ 1.023
all      8 │  4,399,104 │  0.89 │ 1.058
all     32 │ 17,596,416 │  3.56 │ 1.270
QLoRA q,v r=8: Linear 4.127 bit/param, বাকি bf16 → 0.466 GB
activation বাদ; batch আর sequence দৈর্ঘ্যের ওপর নির্ভর করে

৪ · B = 0 দিয়ে শুরু, আর α/r scaling

LoRA প্রবন্ধে A শুরু হয় এলোমেলো মানে, আর B শূন্যে। peft-এর ডিফল্টও তাই: A-তে Kaiming-uniform, B-তে শূন্য (লেখার সময়ে peft-এর নথি অনুযায়ী)। ফল: শুরুতে BA = ০, তাই model হুবহু pretrained model. Training শুরু হয় একটি জানা, ভালো জায়গা থেকে, কোনো এলোমেলো ধাক্কা ছাড়া।

কিন্তু দুটিই শূন্য হলে? তখন A-র gradient-এ B থাকে আর B-র gradient-এ Ax; দুটিই শূন্য, কেউ কখনো নড়ত না। একটিকে এলোমেলো রাখলেই চলে। নিচের কোড NumPy-তে একটি LoRA layer: ধাপ ০-এ output মেলে কি না, কোন matrix gradient পায়, আর এক ধাপ পর কী হয়।

import numpy as np
rng = np.random.default_rng(42)
d_in, d_out, r, alpha, n = 32, 24, 2, 4, 5
W = rng.normal(0, 0.3, (d_out, d_in))          # frozen pretrained weight
X = rng.normal(0, 1, (n, d_in))                # 5টি input সারি
bound = np.sqrt(6 / d_in)                      # Kaiming-uniform-এর মতো সীমা
A = rng.uniform(-bound, bound, (r, d_in))      # A: এলোমেলো
B = np.zeros((d_out, r))                       # B: শূন্য
s = alpha / r

def lora(X, A, B):
    return X @ W.T + s * (X @ A.T) @ B.T       # W x + (alpha/r) B A x

Y0 = lora(X, A, B)
print("step 0: max|lora - frozen| =", np.abs(Y0 - X @ W.T).max())

T = X @ W.T + rng.normal(0, 0.5, (n, d_out))   # নতুন কাজের লক্ষ্য
dY = (Y0 - T) / n                              # MSE loss-এর gradient (1/2 ধরে)
H = X @ A.T                                    # (n, r): A-র পরে
gB = s * dY.T @ H                              # dL/dB
gA = s * (dY @ B).T @ X                        # dL/dA
print("|grad B| =", round(float(np.linalg.norm(gB)), 4),
      "| |grad A| =", float(np.linalg.norm(gA)))

lr = 0.02
B1 = B - lr * gB                               # প্রথম ধাপে শুধু B নড়ে
loss = lambda Y: 0.5 * ((Y - T) ** 2).sum() / n
print("loss:", round(loss(Y0), 4), "->", round(loss(lora(X, A, B1)), 4))
print("rank(B1 @ A) =", np.linalg.matrix_rank(B1 @ A),
      "| trainable:", A.size + B.size, "vs full:", W.size)

step 0: max|lora - frozen| = 0.0
|grad B| = 3.595 | |grad A| = 0.0
loss: 2.5246 -> 2.283
rank(B1 @ A) = 2 | trainable: 112 vs full: 768

α/r কেন? r বদলালে BAx-এর মাপ বদলায়। লেখকেরা বলেছেন, α একবার ঠিক করে α/r দিয়ে গুণ করলে r বদলানোর পর learning rate নতুন করে খুঁজতে কম হয়। α = r হলে গুণক ১; আমাদের run-এ α = ২r, গুণক ২। এটি একটি সুবিধার নিয়ম, মৌলিক সূত্র নয়: Kalajdzievski (২০২৩) বড় r-এ α/√r (rsLoRA) প্রস্তাব করেন, peft-এ use_rslora=True. লেখার সময়ে peft-এর নথিতে ডিফল্ট r=8, lora_alpha=8; ডিফল্ট version-ভেদে বদলাতে পারে, তাই নিজে লিখে দিন।

৫ · Rank কত লাগে — SVD দিয়ে দেখা

কোনো ΔW-কে rank r-এর matrix দিয়ে সবচেয়ে ভালো কীভাবে কাছাকাছি আনা যায়? উত্তর truncated SVD: সবচেয়ে বড় r-টি singular value আর তাদের দিক রাখা (Eckart–Young উপপাদ্য; মেশিন লার্নিং কোর্সের পর্ব ৯)। এটি LoRA-র জন্য একটি “সেরা সম্ভাব্য” মাপকাঠি: rank r-এর কোনো BA এর চেয়ে কাছে যেতে পারে না। নিচে একটি জানা ΔW: আসলে rank ৪, সঙ্গে সামান্য গোলমাল।

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(42)
d = k = 64
U0 = rng.normal(size=(d, 4)); V0 = rng.normal(size=(4, k))
dW = U0 @ np.diag([8, 5, 3, 2]) @ V0 / 8       # আসল পরিবর্তন: rank 4
dW_noisy = dW + rng.normal(0, 0.05, (d, k))    # সঙ্গে ছোট গোলমাল

U, S, Vt = np.linalg.svd(dW_noisy)
print("প্রথম ৬টি singular value:", np.round(S[:6], 2))
full = np.linalg.norm(dW_noisy)
print(" r │ params │ rel. error")
for r in [1, 2, 4, 8, 16, 64]:
    approx = U[:, :r] * S[:r] @ Vt[:r]          # B = U_r S_r, A = V_r^T
    err = np.linalg.norm(dW_noisy - approx) / full
    print(f"{r:2d} │ {r * (d + k):6d} │ {err:.4f}")
print("full ΔW params:", d * k)

fig, ax = plt.subplots(figsize=(5, 3))
ax.semilogy(np.arange(1, 65), S, "o-", ms=3)
ax.axvline(4.5, ls="--", c="gray")
ax.set_xlabel("index i"); ax.set_ylabel("singular value (log)")
ax.set_title("Spectrum of a rank-4 update plus noise")
plt.show()

প্রথম ৬টি singular value: [57.92 34.13 22.95 14.83  0.76  0.72]
 r │ params │ rel. error
 1 │    128 │ 0.6034
 2 │    256 │ 0.3784
 4 │    512 │ 0.0412
 8 │   1024 │ 0.0363
16 │   2048 │ 0.0282
64 │   8192 │ 0.0000
full ΔW params: 4096

৬ · Target modules আর peft-এ LoraConfig

কোন layer-এ LoRA বসবে, সেটি target_modules. নামগুলো architecture-এর নিজের: BERT-এ query, key, value, dense; Qwen বা Llama-ধাঁচের model-এ q_proj, v_proj, gate_proj ইত্যাদি। নাম ভুল দিলে peft error দেয়; তাই আগে model.named_modules() print করে দেখুন। আমাদের run-এর মূল অংশ (পুরো script থেকে ছোট করা):

from peft import LoraConfig, get_peft_model
cfg = LoraConfig(task_type="SEQ_CLS", r=8, lora_alpha=16,
                 lora_dropout=0.1, target_modules=["query", "value"])
model = get_peft_model(model, cfg)      # base-এর সব ওজন frozen
model.print_trainable_parameters()
opt = torch.optim.AdamW([p for p in model.parameters() if p.requires_grad], lr=5e-4)

trainable params: 296,450 || all params: 164,694,532 || trainable%: 0.1800

কোন module বাছবেন, তার সার্বজনীন উত্তর নেই। LoRA প্রবন্ধ GPT-3-এ সীমিত parameter-এর বাজেটে W_q আর W_v দুটিতে ছোট r-কে একটিতে বড় r-এর চেয়ে ভালো পেয়েছিল। QLoRA প্রবন্ধ বলে, তাদের পরীক্ষায় সব Linear layer-এ LoRA বসানো full fine-tuning-এর মানে পৌঁছাতে জরুরি ছিল। দুটিই নিজের পরীক্ষার ফল; বাজেট আর কাজ বুঝে দুটিই চেষ্টা করে মাপুন।

৭ · সত্যিকারের run — full বনাম LoRA r = ৪, ৮, ৩২

একই কাজ, একই ডেটা, একই script, শুধু শেখার পদ্ধতি আলাদা। ডেটা পর্ব ৪২ · Text classification-এর Sazzed-এর বাংলা YouTube মন্তব্য (Mendeley Data, CC BY 4.0), পরিষ্কার করার পর ১০,৭০৯টি, positive/negative. শুধু প্রথম split (repeat ০, fold ০): train ৭,৫১০, validation ১,০৫৬, test ২,১৪৩, একই commenter দুই ভাগে পড়ে না। Model sagorsarker/bangla-bert-base, do_lower_case=False (পর্ব ৪৮-এর ফাঁদ মনে রেখে), সর্বোচ্চ ১০০ token, batch ৩২, ৩ epoch, AdamW, warm-up-সহ রৈখিক schedule, bf16 autocast, class weight, seed ০। Full-এ lr ২ × ১০^−৫, LoRA-তে ৫ × ১০^−৪, α = ২r, dropout ০.১। সব run GPU-তে, প্রতিটি আলাদা process-এ। সত্যিকারের run-এর ফল, script-এর JSON লাইন থেকে সাজানো:

Epoch-ভিত্তিক validation (সত্যিকারের log; প্রতিটি run-এর তিনটি লাইন এক লাইনে সাজানো):

full        epoch 1 val macro-F1 0.9354 | 2: 0.9443 | 3: 0.9498
lora r=8 qv epoch 1 val macro-F1 0.8935 | 2: 0.9301 | 3: 0.9348

৮ · Merge — adapter ওজনে মেশানো, আর কখন মেশাবেন না

Training-এর সময় দুটি পথ: W₀x আর (α/r)BAx. Inference-এ এটি একটু বাড়তি হিসাব। কিন্তু গুণ বণ্টনযোগ্য: W₀x + (α/r)BAx = (W₀ + (α/r)BA)x. তাই একবার W′ = W₀ + (α/r)BA বানিয়ে নিলে model আবার একটি সাধারণ model, বাড়তি latency শূন্য। LoRA প্রবন্ধের “no additional inference latency” দাবি এখান থেকেই। চালিয়ে দেখুন, আর precision কমালে কী হয় তাও:

import numpy as np
rng = np.random.default_rng(7)
d, r, alpha = 32, 8, 16
s = alpha / r
W = rng.normal(0, 0.2, (d, d))                 # frozen ওজন
A = rng.normal(0, 0.1, (r, d))                 # "শেখা" adapter (ধরে নেওয়া)
B = rng.normal(0, 0.1, (d, r))
X = rng.normal(0, 1, (100, d))

two_path = X @ W.T + s * (X @ A.T) @ B.T       # training-এর সময়ের দুই পথ
W_merged = W + s * B @ A                       # merge: একটি matrix
one_path = X @ W_merged.T
print("float64 merge: max diff =", f"{np.abs(two_path - one_path).max():.1e}")

for dt in (np.float32, np.float16):            # কম precision-এ merge করলে?
    Wm = (W.astype(dt) + (s * B @ A).astype(dt)).astype(dt)
    y = X.astype(dt) @ Wm.T
    print(f"{np.dtype(dt).name:8s} merge: max diff =",
          f"{np.abs(two_path - y.astype(np.float64)).max():.1e}")

W_back = W_merged - s * B @ A                  # unmerge: আবার আলাদা করা
print("unmerge ফিরে পেল W? ", np.allclose(W_back, W, atol=1e-12))
B2 = rng.normal(0, 0.1, (d, r)); A2 = rng.normal(0, 0.1, (r, d))
W_task2 = W + s * B2 @ A2                      # একই W, দ্বিতীয় কাজের adapter
print("adapter-এর আকার:", A.size + B.size, "সংখ্যা; W:", W.size)
print("দুই কাজের output আলাদা:", not np.allclose(X @ W_task2.T, one_path))

float64 merge: max diff = 2.7e-15
float32  merge: max diff = 9.0e-07
float16  merge: max diff = 2.0e-03
unmerge ফিরে পেল W?  True
adapter-এর আকার: 512 সংখ্যা; W: 1024
দুই কাজের output আলাদা: True

এবার সত্যিকারের model-এ। অংশ ৭-এর r = ৮ adapter (query, value) লোড করে CPU-তে fp32-এ ৫১২টি test মন্তব্যের logits নিলাম, তারপর peft-এর merge_and_unload() দিয়ে মিশিয়ে আবার। সত্যিকারের run:

~/bazarghar-dl$ uv run python merge_check.py
lora_A modules before merge: 24 | lora modules after: 0
type after merge: BertForSequenceClassification
max |logit diff| = 1.19e-06
same predicted label: 512 / 512
CPU time 512 texts: adapter 26.5 s | merged 27.2 s
adapter_model.safetensors: 1.14 MiB
merged model.safetensors: 627.2 MiB

কখন merge করবেন না? যখন একটি base-এর ওপর অনেক কাজ। বাজারঘরের একটি server-এ একটি Bangla BERT, সঙ্গে রিভিউয়ের মনোভাব, অভিযোগের ধরন আর ডেলিভারির প্রশ্নের তিনটি ছোট adapter: অনুরোধ অনুযায়ী adapter বদলানো যায় (peft-এ load_adapter আর set_adapter). Merge করলে প্রতিটি কাজের জন্য আবার পুরো কপি। আর একটি জিনিস: adapter কাজ করে শুধু সেই base-এর সঙ্গে, যার ওপর শেখানো হয়েছে। Base-এর আরেকটি revision বা আরেকটি model-এ লাগালে নীরবে ভুল ফল আসতে পারে; তাই adapter-এর সঙ্গে base-এর নাম আর commit hash লিখে রাখুন (পর্ব ৫৩)।

৯ · QLoRA, আর adapter, prefix, prompt tuning ও IA3

অংশ ৩-এর হিসাবে LoRA-র পর memory-র বড় অংশ frozen base. QLoRA (Dettmers, Pagnoni, Holtzman ও Zettlemoyer, ২০২৩) সেই base-কেই 4-bit-এ রাখে আর তার ওপর LoRA শেখায়। প্রবন্ধের দাবি, এতে ৬৫০০ কোটি parameter-এর একটি model একটি ৪৮ GB GPU-তে fine-tune করা গেছে, তাঁদের পরীক্ষায় 16-bit fine-tuning-এর মান ধরে রেখে। তিনটি কৌশল:

Forward-এর সময় প্রতিটি 4-bit block bf16-এ ফিরিয়ে (dequantize) গুণ হয়; gradient frozen 4-bit ওজনের ভেতর দিয়ে LoRA-তে পৌঁছায়, কিন্তু 4-bit ওজন নিজে কখনো বদলায় না। Quantization-এর scale আর zero point হাতে হিসাব পর্ব ৫৯ · ছোট আর দ্রুত model — quantization, distillation আর pruning-এ।

Windows-এ bitsandbytes একসময় আনুষ্ঠানিকভাবে সমর্থিত ছিল না; আমাদের lab-এ লেখার সময়ের version 0.50.2 install হয়েছে আর GPU-তে 4-bit চলেছে। একই কাজ, একই split, query আর value-তে r = ৮, base NF4 আর double quantization-এ, PagedAdamW দিয়ে। সত্যিকারের run, GPU-তে:

bnb_cfg = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True, bnb_4bit_compute_dtype=torch.bfloat16,
    llm_int8_skip_modules=["classifier"])
model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=False)
opt = bnb.optim.PagedAdamW(params, lr=5e-4, weight_decay=0.01)   # (script থেকে ছোট করা)

trainable params: 296,450 || all params: 164,694,532 || trainable%: 0.1800
  epoch 1 val macro-F1 0.9066
  epoch 2 val macro-F1 0.9358
  epoch 3 val macro-F1 0.9327
{"tag": "qlora r=8 qv", "total": 121635842, "trainable": 296450, "test_macro": 0.9250449450516139, "secs": 74.1, "peak_mib": 1580, "mem_after_load_mib": 344}

LoRA-র আত্মীয়রা (সংক্ষেপে). সব PEFT পদ্ধতির লক্ষ্য এক: base স্থির, শেখে অল্প কিছু। পার্থক্য কোথায় শেখে তাতে।

Lester ও সহলেখকদের পরীক্ষায় T5-এ prompt tuning model যত বড়, full fine-tuning-এর তত কাছে গেছে, ছোট model-এ পিছিয়ে ছিল। কোনটি “সেরা”, তার কোনো সার্বজনীন উত্তর নেই; LoRA এখন বেশি প্রচলিত, মূলত merge আর সহজ tooling-এর জন্য। Instruction ডেটায় LoRA দিয়ে SFT পর্ব ৫৬ · Instruction tuning — SFT ডেটা, chat template আর ফরম্যাট-এ, আর preference-এ পর্ব ৫৭ · Preference alignment — RLHF, reward model আর DPO-তে।

১০ · AI-এর যুগে — LoRA কোড যাচাই

LoRA-র কোড AI assistant খুব দ্রুত লেখে, কিন্তু peft, transformers আর bitsandbytes তিনটিই দ্রুত বদলায়, আর অনলাইনের উদাহরণ নানা version-এর।

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

• peft, transformers আর bitsandbytes-এর version লিখে নিজের version-এর নথিতে প্রতিটি argument মিলিয়েছি
• Trainable parameter হাতে গুনে print-এর সঙ্গে মিলিয়েছি; head শেখার তালিকায় আছে
• ধাপ ০-এ LoRA model আর base-এর output এক কি না দেখেছি
• প্রথমে একটি ছোট batch overfit করে দেখেছি loss নামে
• Full fine-tuning আর একটি সরল baseline-এর সঙ্গে একই split-এ, একাধিক seed-এ তুলনা করেছি
• Merge-এর আগে-পরে output মিলিয়েছি, base-এর নাম আর commit hash adapter-এর সঙ্গে লিখেছি; কোনো token বা ব্যক্তিগত ডেটা prompt-এ দিইনি