Preference alignment — RLHF, reward model আর DPO

পর্ব ৫৬ · Instruction tuning — SFT ডেটা, chat template আর ফরম্যাট-এ model “নির্দেশ → উত্তর” জোড়া নকল করে শিখেছে; সেখানে LoRA এসেছে পর্ব ৫৫ · Parameter-efficient fine-tuning থেকে। RLHF-এর এক অনুচ্ছেদের পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ আছে। এই পর্বে সেটির গণিত আর হাতে-কলমে কাজ। Desktop-এর run লেখার সময়ে (২০২৬ সালের নভেম্বর) এই version-এ: Python 3.12, torch 2.15.0, transformers 5.22.2, trl 1.17.1, peft 0.21.2, datasets 5.1.0; model Qwen/Qwen2.5-0.5B-Instruct (Apache 2.0 লাইসেন্স, revision 7ae5576), model card পড়ে নেওয়া। GPU-র কাজ GPU-তে, যেখানে যেটি তা লেখা আছে।

১ · SFT কেন যথেষ্ট নয় — পছন্দের ডেটা

SFT-এ model প্রতিটি প্রশ্নের একটিমাত্র “ঠিক” উত্তরের token-গুলোর সম্ভাবনা বাড়ায়। কোন উত্তরটি খারাপ, তা সে কখনো দেখে না। রূঢ় উত্তর, ভুল সংখ্যা বা অকারণ লম্বা ভূমিকা: SFT-এর loss এগুলোকে আলাদা করে শাস্তি দেয় না। আবার সব প্রশ্নের নিখুঁত উত্তর লিখে দেওয়াও ব্যয়বহুল।

বাজারঘরের সাপোর্ট-সহকারীর জন্য আমরা হাতে লেখা template থেকে seed দিয়ে একটি ছোট বাংলা পছন্দের ডেটা বানিয়েছি। এটি বানানো ডেটা, কোনো সত্যিকারের গ্রাহকের নয়। নীতিগুলো পর্ব ৫৬-এর মতোই: ঢাকার ভেতরে ১–২ দিন, চার্জ ৬০ টাকা; বাইরে ৩–৫ দিন, ১২০ টাকা; ফেরত ৭ দিনে; রিফান্ড ৫ কার্যদিবসে; নষ্ট পণ্য ৪৮ ঘণ্টার মধ্যে জানাতে হয়। Chosen সব সময় ঠিক, ছোট আর ভদ্র; rejected চার ধরনের ভুলের একটি। ডেটা ফাইলের প্রথম জোড়াটি হুবহু (pref_train.json থেকে, intent চাবি বাদে):

{
 "question": "আমি উত্তরা-তে থাকি, পণ্য কবে পাব?",
 "chosen": "ঢাকার ভেতরে (উত্তরা) ডেলিভারি ১–২ দিনে হয়, চার্জ ৬০ টাকা।",
 "rejected": "জানি না, অন্য কোথাও জিজ্ঞেস করুন।",
 "kind": "rude"
}

Train-এ ৩৬২টি অনন্য জোড়া, আলাদা রাখা test-এ ৮৪টি। Test-এর প্রশ্নের ধরন, জেলা আর পণ্য train-এ নেই, তাই test-এর একটি প্রশ্নও train-এ হুবহু আসেনি। সত্যিকারের পছন্দের ডেটা এত পরিষ্কার হয় না: InstructGPT প্রবন্ধে প্রশিক্ষণের labeler-রা একে অপরের সঙ্গে প্রায় ৭২.৬% ক্ষেত্রে একমত ছিলেন। মানুষের পছন্দে মতভেদ, ক্লান্তি আর পক্ষপাত থাকে, আর reward model সেগুলোও শেখে।

২ · RLHF-এর তিন ধাপ — InstructGPT যেভাবে করেছে

ভাষা model-এ RLHF-এর বহুল উদ্ধৃত বর্ণনা Ouyang ও সহলেখকদের InstructGPT প্রবন্ধ (arXiv, মার্চ ২০২২)। ধারণাটি আগের কাজ থেকে এসেছে: Christiano ও সহলেখকেরা (২০১৭) মানুষের তুলনা থেকে reward শেখান, আর Stiennon ও সহলেখকেরা (২০২০) সারাংশ লেখায় একই পদ্ধতি প্রয়োগ করেন। প্রবন্ধের বর্ণনায় GPT-3 থেকে শুরু করে তিনটি ধাপ:

প্রবন্ধের মূল দাবি: তাঁদের prompt-বণ্টনে মানুষের মূল্যায়নে ১.৩B InstructGPT-এর উত্তর ১৭৫B GPT-3-এর চেয়ে বেশি পছন্দ হয়েছে, যদিও parameter প্রায় ১০০ ভাগের এক ভাগ। তবে লেখকেরা নিজেরাই জানান, ডেটার ৯৬%-এর বেশি ইংরেজি, আর model এখনো সরল ভুল করে। পরের বাণিজ্যিক assistant-গুলো ঠিক কোন পদ্ধতি আর ডেটায় align করা, তার বেশির ভাগ প্রকাশিত নয়; তাই “ChatGPT এভাবে বানানো” বলা যায় না, শুধু প্রকাশিত প্রবন্ধে কী আছে তা বলা যায়।

৩ · Reward model আর Bradley–Terry loss

Reward model (RM) একটি prompt x আর উত্তর y নিয়ে একটি সংখ্যা r(x, y) দেয়। কিন্তু মানুষ সংখ্যা দেননি, দিয়েছেন তুলনা। সংখ্যা আর তুলনা জোড়ার সেতু Bradley–Terry model (Bradley ও Terry, ১৯৫২): দুটি জিনিসের প্রতিটির একটি লুকানো “শক্তি” আছে, আর একটি জেতার সম্ভাবনা

P(y_w ≻ y_l | x) = e^r_w / (e^r_w + e^r_l) = σ(r_w − r_l)

এখানে y_w জেতা (chosen), y_l হারা (rejected), r_w = r(x, y_w), আর σ হলো sigmoid, σ(z) = 1/(1 + e^−z). দ্বিতীয় সমতা পেতে লব আর হর দুটিকে e^r_w দিয়ে ভাগ করুন: 1/(1 + e^{−(r_w − r_l)}). দাবা বা ক্রিকেট র‍্যাংকিং-এর রেটিংও একই ধাঁচের চিন্তা: শুধু রেটিংয়ের পার্থক্য জয়ের সম্ভাবনা ঠিক করে।

ডেটার সম্ভাবনা সর্বোচ্চ করা (MLE; মেশিন লার্নিং কোর্সের পর্ব ১৮) মানে negative log-likelihood কমানো:

L_RM = −E[ log σ(r_w − r_l) ],   ∂L/∂r_w = −(1 − σ(Δ)) = −σ(−Δ),  ∂L/∂r_l = +σ(−Δ)

Δ = r_w − r_l. এটি আসলে Δ-এর ওপর logistic regression, যেখানে label সব সময় ১ (AI-এর ভিত্তি কোর্সের পর্ব ৫৯)। দুটি জরুরি ফল। এক, gradient-এর মাপ σ(−Δ): ক্রম ভুল হলে (Δ < 0) ধাক্কা বড়, ঠিক আর নিশ্চিত হলে প্রায় শূন্য। দুই, দুটি score-এ একই সংখ্যা যোগ করলে loss বদলায় না; তাই score-এর নিজের কোনো একক নেই। InstructGPT এ কারণে RL-এর আগে একটি bias দিয়ে RM-কে এমনভাবে সরায় যাতে নমুনা উত্তরগুলোর গড় score শূন্য হয়।

এবার আটটি জোড়ায় loss, pairwise accuracy, সূত্রের gradient সংখ্যাগত gradient-এর সঙ্গে মেলানো, আর score সরালে কী হয়:

import numpy as np
# reward model-এর score: ৮টি জোড়া, chosen (w) আর rejected (l)
r_w = np.array([2.1, 0.4, 1.5, -0.2, 3.0, 0.9, 0.1, 1.2])
r_l = np.array([0.3, 0.9, -1.0, -0.5, 1.0, 1.4, 0.1, -0.8])
sig = lambda z: 1 / (1 + np.exp(-z))

def bt_loss(rw, rl):                       # −log σ(r_w − r_l)-এর গড়
    return -np.log(sig(rw - rl)).mean()

d = r_w - r_l
print("Δ = r_w − r_l :", np.round(d, 2))
print("P(chosen ভালো):", np.round(sig(d), 3))
print("BT loss       :", round(bt_loss(r_w, r_l), 4))
print("pairwise acc. :", (d > 0).mean(), "(Δ = 0 জোড়াটিও ভুল ধরা)")

g_w = -(1 - sig(d)) / len(d)               # ∂L/∂r_w, সূত্র থেকে
eps, num = 1e-6, np.zeros_like(r_w)
for i in range(len(r_w)):                  # সংখ্যাগত gradient, যাচাইয়ের জন্য
    e = np.zeros_like(r_w); e[i] = eps
    num[i] = (bt_loss(r_w + e, r_l) - bt_loss(r_w - e, r_l)) / (2 * eps)
print("∂L/∂r_w       :", np.round(g_w, 4))
print("max |সূত্র − সংখ্যাগত| =", f"{np.abs(g_w - num).max():.1e}")
print("সব score-এ +5 :", round(bt_loss(r_w + 5, r_l + 5), 4))

lr = 4.0                                   # এক ধাপ gradient descent, score-এর ওপর
r_w2, r_l2 = r_w - lr * g_w, r_l + lr * g_w
print("এক ধাপ পরে loss:", round(bt_loss(r_w2, r_l2), 4),
      "| acc:", ((r_w2 - r_l2) > 0).mean())

Δ = r_w − r_l : [ 1.8 -0.5  2.5  0.3  2.  -0.5  0.   2. ]
P(chosen ভালো): [0.858 0.378 0.924 0.574 0.881 0.378 0.5   0.881]
BT loss       : 0.4602
pairwise acc. : 0.625 (Δ = 0 জোড়াটিও ভুল ধরা)
∂L/∂r_w       : [-0.0177 -0.0778 -0.0095 -0.0532 -0.0149 -0.0778 -0.0625 -0.0149]
max |সূত্র − সংখ্যাগত| = 2.9e-11
সব score-এ +5 : 0.4602
এক ধাপ পরে loss: 0.3213 | acc: 1.0

৪ · সত্যিকারের run — বাজারঘরের reward model

InstructGPT-এর মতো RM বানানো হয়েছে একটি ভাষা model থেকে: Qwen/Qwen2.5-0.5B-Instruct-এর শেষ unembedding-এর বদলে একটি নতুন Linear (৮৯৬ → ১), যা প্রতিটি উত্তরের শেষ token থেকে একটি score দেয়। Transformers-এ এটি AutoModelForSequenceClassification, num_labels=1. পুরো model না শিখিয়ে q, k, v, o-তে LoRA (r = ৮, পর্ব ৫৫) আর নতুন score head: ১০,৮২,২৪০টি শেখার parameter, মোটের ০.২২%. Loss হাতে লেখা Bradley–Terry, প্রতি ধাপে ৪টি জোড়া, ২ epoch, AdamW (lr ২ × ১০^−৪), bf16 autocast আর gradient checkpointing. মূল অংশ (script থেকে ছোট করা):

model = AutoModelForSequenceClassification.from_pretrained(MODEL, num_labels=1)
model = get_peft_model(model, LoraConfig(task_type="SEQ_CLS", r=8, lora_alpha=16,
                       target_modules=["q_proj", "k_proj", "v_proj", "o_proj"]))
r = model(**enc).logits[:, 0]            # প্রথম ৪টি chosen, পরের ৪টি rejected
rc, rr = r[:4], r[4:]
loss = -F.logsigmoid(rc - rr).mean()     # Bradley–Terry

আলাদা রাখা ৮৪টি জোড়ায় ফল, তিনটি seed-এ (seed বদলায় score head-এর শুরুর মান আর ডেটার ক্রম)। সত্যিকারের run, GPU-তে; প্রতিটির training প্রায় ১১৬–১১৯ সেকেন্ড, peak প্রায় ২,৫৪৫ MiB (torch.cuda.max_memory_allocated). তুলনার জন্য “লম্বা উত্তরই ভালো” নিয়মের accuracy ০.৬৯০।

শেষ সারির পরীক্ষাটি: ঠিক উত্তরের একটি সংখ্যা এমন মানে বদলানো, যা ডেটায় কখনো ছিল না (৫ → ১৫ কার্যদিবস, ৪৮ → ২ ঘণ্টা …)। seed ০-এর log-এর লাইন:

{"tag": "unseen_wrong_number", "seed": 0, "n": 84, "original_beats_perturbed": 0.6667, "example": ["ফেরত পণ্য পৌঁছানোর ৫ কার্যদিবসের মধ্যে, যে মাধ্যমে দাম দিয়েছিলেন সেখানেই টাকা ফেরত যায়।", "ফেরত পণ্য পৌঁছানোর ১৫ কার্যদিবসের মধ্যে, যে মাধ্যমে দাম দিয়েছিলেন সেখানেই টাকা ফেরত যায়।", 22.12, 22.38]}

৫ · PPO-র রূপরেখা আর KL-এর লাগাম

RM পাওয়ার পর লক্ষ্য: model এমন উত্তর লিখুক যাতে RM-এর score বেশি। এখানে model-কে বলা হয় policy π_θ, কারণ reinforcement learning-এর ভাষায় প্রতিটি token একটি action. কিন্তু শুধু score বাড়ালে policy RM-এর দুর্বলতা খুঁজে বের করে ফেলতে পারে। তাই লক্ষ্যে একটি লাগাম থাকে (DPO প্রবন্ধের সমীকরণ ৩-এর রূপে):

max_πθ E_{x, y∼πθ}[ r(x, y) ] − β · D_KL( π_θ(y|x) ‖ π_ref(y|x) )

π_ref হলো reference model, সাধারণত SFT model-এর একটি স্থির কপি। KL divergence মাপে নতুন policy-র বণ্টন পুরনোটি থেকে কত দূরে (AI-এর ভিত্তি কোর্সের পর্ব ৩৮)। β বড় হলে লাগাম শক্ত। InstructGPT এটি প্রতি token-এ reward-এর ভেতরে বসায়: r(x, y) − β·log(π_θ(y|x)/π_SFT(y|x)).

PPO (Proximal Policy Optimization; Schulman ও সহলেখক, ২০১৭) এই লক্ষ্য বাড়ানোর একটি algorithm. রূপরেখায়: (১) একগুচ্ছ prompt-এ policy থেকে উত্তর তোলা; (২) RM দিয়ে score, KL শাস্তি বাদ; (৩) একটি value function দিয়ে প্রতিটি token কতটা “প্রত্যাশার চেয়ে ভালো” (advantage) তা অনুমান; (৪) নতুন আর পুরনো policy-র অনুপাত একটি সীমায় কেটে (clip) ছোট ছোট ধাপে policy আপডেট। ফলে memory-তে চারটি model: policy, reference, RM আর value. আমরা এখানে পুরো PPO চালাইনি; একটি ছোট model-এও এটি অনেক hyperparameter-এর ভারী কাজ, আর এই পর্বের মূল ধারণাগুলো নিচের হিসাব আর DPO-র run-এ দেখা যায়।

লাগামটির একটি সুন্দর বন্ধ-রূপ সমাধান আছে, যা DPO প্রবন্ধ আগের কাজ থেকে নিয়ে লেখে: সর্বোত্তম policy π*(y|x) = π_ref(y|x)·exp(r(x, y)/β) / Z(x), যেখানে Z(x) সব উত্তরের ওপর যোগ করে সম্ভাবনাকে ১-এ আনে ; একে বলে partition function. অর্থাৎ পুরনো সম্ভাবনাকে reward অনুযায়ী বাড়ানো-কমানো, আর β ঠিক করে কতটা। পাঁচটি সম্ভাব্য উত্তরে চালিয়ে দেখুন:

import numpy as np
import matplotlib.pyplot as plt
# একটি প্রশ্নের ৫টি সম্ভাব্য উত্তর; reference (SFT) model-এর সম্ভাবনা আর reward
names = ["ঠিক, ছোট", "ঠিক, লম্বা", "অস্পষ্ট", "রূঢ়", "ভুল তথ্য"]
p_ref = np.array([0.30, 0.10, 0.30, 0.05, 0.25])
r = np.array([2.0, 2.5, -0.5, -2.0, -1.5])

def best_policy(beta):                     # π* ∝ π_ref · exp(r / β)
    w = p_ref * np.exp(r / beta)
    return w / w.sum()

def kl(p, q):
    return float((p * np.log(p / q)).sum())

print(" beta │ E[r]  │ KL(π‖ref) │ E[r] − β·KL │ π*")
rows = []
for beta in [10, 2, 1, 0.5, 0.1, 0.02]:
    p = best_policy(beta)
    er, k = float(p @ r), kl(p, p_ref)
    rows.append((beta, er, k))
    print(f"{beta:5} │ {er:5.2f} │ {k:9.3f} │ {er - beta * k:11.3f} │", np.round(p, 2))
print("reference E[r] =", round(float(p_ref @ r), 2))
for name, pr in zip(names, best_policy(0.5)):
    print(f"  β=0.5: {name:9s} {pr:.2f}")

b, er, k = zip(*rows)
fig, ax = plt.subplots(figsize=(5, 3))
ax.plot(k, er, "o-")
for bi, x, y in rows:
    ax.annotate(f"beta={bi}", (x, y), textcoords="offset points", xytext=(5, -12), fontsize=8)
ax.set_xlabel("KL(policy || reference)"); ax.set_ylabel("expected reward")
ax.set_title("Smaller beta: more reward, more drift")
plt.show()

 beta │ E[r]  │ KL(π‖ref) │ E[r] − β·KL │ π*
   10 │  0.49 │     0.013 │       0.357 │ [0.35 0.12 0.28 0.04 0.21]
    2 │  1.42 │     0.280 │       0.857 │ [0.53 0.23 0.15 0.01 0.08]
    1 │  1.98 │     0.679 │       1.303 │ [0.6  0.33 0.05 0.   0.02]
  0.5 │  2.23 │     1.008 │       1.723 │ [0.52 0.47 0.   0.   0.  ]
  0.1 │  2.49 │     2.184 │       2.272 │ [0.02 0.98 0.   0.   0.  ]
 0.02 │  2.50 │     2.303 │       2.454 │ [0. 1. 0. 0. 0.]
reference E[r] = 0.22
  β=0.5: ঠিক, ছোট  0.52
  β=0.5: ঠিক, লম্বা 0.47
  β=0.5: অস্পষ্ট   0.00
  β=0.5: রূঢ়      0.00
  β=0.5: ভুল তথ্য  0.00

৬ · DPO — reward model ছাড়াই, একই লক্ষ্য

Rafailov ও সহলেখকদের DPO প্রবন্ধ (arXiv, মে ২০২৩; শিরোনামের অর্থ “আপনার language model গোপনে একটি reward model”) একটি সরল প্রশ্ন করে: π* যদি r দিয়ে লেখা যায়, তবে r-কেও π* দিয়ে লেখা যায় না কেন? চারটি ধাপে derivation:

1. সমাধান: π*(y|x) = π_ref(y|x)·exp(r(x, y)/β)/Z(x).
2. দুই পাশে log নিয়ে সাজানো: r(x, y) = β·log[π*(y|x)/π_ref(y|x)] + β·log Z(x).
3. Bradley–Terry-তে বসানো: P(y_w ≻ y_l) = σ(r_w − r_l). দুটি r-এই একই β·log Z(x), কারণ prompt একই; বিয়োগে কেটে যায়। Z হিসাব করা প্রায় অসম্ভব ছিল, এখন দরকারই নেই।
4. π*-এর জায়গায় শেখার policy π_θ বসিয়ে MLE:

L_DPO = −E[ log σ( β·log(π_θ(y_w|x)/π_ref(y_w|x)) − β·log(π_θ(y_l|x)/π_ref(y_l|x)) ) ]

log π(y|x) হলো পুরো উত্তরের log-probability, অর্থাৎ উত্তরের প্রতিটি token-এর log-probability-র যোগফল। r̂(x, y) = β·log(π_θ/π_ref)-কে বলা হয় implicit reward; trl এটিকেই rewards/chosen নামে log করে। প্রবন্ধে gradient-ও লেখা: chosen-এর log-probability বাড়ানো আর rejected-এরটি কমানো, প্রতিটি জোড়ার ওজন σ(r̂_l − r̂_w), অর্থাৎ implicit reward যত ভুল ক্রমে তত বেশি। লেখকেরা জানান, এই ওজন বাদ দেওয়া সরল সংস্করণে model নষ্ট হয়ে যেতে পারে।

import numpy as np
sig = lambda z: 1 / (1 + np.exp(-z))
# ৪টি জোড়া: পুরো উত্তরের log-probability (token-গুলোর log p-এর যোগফল)
pol_w = np.array([-12.0, -20.5, -8.0, -15.0])   # policy, chosen
pol_l = np.array([-14.0, -19.0, -11.0, -15.5])  # policy, rejected
ref_w = np.array([-13.0, -20.0, -9.0, -15.0])   # reference, chosen
ref_l = np.array([-13.5, -20.0, -10.0, -15.0])  # reference, rejected

def dpo(beta, pw, pl):
    h = (pw - ref_w) - (pl - ref_l)              # log-ratio-র পার্থক্য
    loss = -np.log(sig(beta * h)).mean()
    wgt = sig(-beta * h)                         # ভুল ক্রমে বেশি ওজন
    g_w = -beta * wgt / len(h)                   # ∂L/∂log π(y_w)
    return h, loss, wgt, g_w

h, *_ = dpo(0.1, pol_w, pol_l)
print("h = Δlog π_w − Δlog π_l:", h)
for beta in [0.1, 0.5, 2.0]:
    h, loss, wgt, g_w = dpo(beta, pol_w, pol_l)
    print(f"β={beta:3}: implicit r_w={np.round(beta * (pol_w - ref_w), 2)}",
          f"loss={loss:.4f}")
    print(f"       weight σ(−βh)={np.round(wgt, 3)}")
print("∂L/∂log π_w (β=0.1):", np.round(dpo(0.1, pol_w, pol_l)[3], 4))
print("∂L/∂log π_l = −(∂L/∂log π_w) → চিহ্ন উল্টো")

eps = 1e-6; f = lambda pw: dpo(0.1, pw, pol_l)[1]
e = np.array([eps, 0, 0, 0])
print("সংখ্যাগত ∂L/∂log π_w[0] =", round((f(pol_w + e) - f(pol_w - e)) / (2 * eps), 4))
print("শুরুতে policy = ref হলে loss:",
      [round(float(dpo(b, ref_w, ref_l)[1]), 4) for b in (0.1, 0.5, 2.0)], "= log 2")

h = Δlog π_w − Δlog π_l: [ 1.5 -1.5  2.   0.5]
β=0.1: implicit r_w=[ 0.1  -0.05  0.1   0.  ] loss=0.6646
       weight σ(−βh)=[0.463 0.537 0.45  0.488]
β=0.5: implicit r_w=[ 0.5  -0.25  0.5   0.  ] loss=0.6032
       weight σ(−βh)=[0.321 0.679 0.269 0.438]
β=2.0: implicit r_w=[ 2. -1.  2.  0.] loss=0.8571
       weight σ(−βh)=[0.047 0.953 0.018 0.269]
∂L/∂log π_w (β=0.1): [-0.0116 -0.0134 -0.0113 -0.0122]
∂L/∂log π_l = −(∂L/∂log π_w) → চিহ্ন উল্টো
সংখ্যাগত ∂L/∂log π_w[0] = -0.0116
শুরুতে policy = ref হলে loss: [0.6931, 0.6931, 0.6931] = log 2

৭ · সত্যিকারের run — trl-এর DPOTrainer

একই ৩৬২টি জোড়ায় এবার policy নিজেই শিখবে। Policy Qwen/Qwen2.5-0.5B-Instruct, bf16-এ; q, k, v, o-তে LoRA r = ১৬. Prompt-এ system বার্তা আর প্রশ্ন, তাই ডেটা trl-এর conversational ফরম্যাটে। Reference আলাদা করে লোড করিনি: peft_config দিলে trl নথি অনুযায়ী শুরুর model-টিই reference, আর LoRA-য় সেটি হলো adapter বন্ধ করা একই base. ইচ্ছা করে SFT ধাপ বাদ রাখা হয়েছে, যাতে শুধু DPO-র প্রভাব দেখা যায়। মূল অংশ (script থেকে ছোট করা):

row = {"prompt": [{"role": "system", "content": SYSTEM},
                  {"role": "user", "content": e["question"]}],
       "chosen":   [{"role": "assistant", "content": e["chosen"]}],
       "rejected": [{"role": "assistant", "content": e["rejected"]}]}
args = DPOConfig(beta=0.1, learning_rate=5e-5, num_train_epochs=2,
                 per_device_train_batch_size=2, gradient_accumulation_steps=4,
                 max_length=512, bf16=True, eval_strategy="epoch", eval_on_start=True)
trainer = DPOTrainer(model=model, args=args, train_dataset=train_ds, eval_dataset=test_ds,
                     processing_class=tok, peft_config=LoraConfig(r=16, lora_alpha=32,
                     target_modules=["q_proj", "k_proj", "v_proj", "o_proj"]))

β = ০.১-এর run, GPU-তে ২৪৮.৩ সেকেন্ড, peak ২,৯২৪ MiB. trl-এর log থেকে কয়েকটি ধাপ (সত্যিকারের run; প্রতিটি লাইন JSON থেকে ছোট করে সাজানো, প্রতি ধাপে ৮টি জোড়া):

ধাপ  loss    r̂_chosen  r̂_rejected  margin  accuracy
 0   0.6931   0.0000    0.0000      0.000   (eval, শুরু)
 5   0.6733   0.0234   -0.0209      0.044   0.45
10   0.3125   0.3758   -1.0276      1.403   1.00
25   0.0088   1.8393   -4.8963      6.736   1.00
46   0.0069   2.3172   -7.0019      9.319   1.00  (eval, epoch 1)
92   0.0019   2.3226   -8.0813     10.404   1.00  (eval, epoch 2)
eval logps/chosen:  -132.97 → -109.74   logps/rejected: -163.30 → -244.11

এবার আসল প্রশ্ন: policy-র লেখা উত্তর কি ভালো হলো? আলাদা রাখা ৪০টি প্রশ্নে greedy উত্তর আমাদের নিয়ম দিয়ে মেপেছি (ঠিক সংখ্যা বা শব্দ আছে কি না, যেমন ঢাকার ভেতরে “১–২” আর “৬০”)। আর তিনটি সাধারণ প্রশ্নে আগে-পরে তুলনা, model কতটা সরে গেল দেখতে। সত্যিকারের run, seed ০:

প্রশ্ন: মিরপুর এলাকায় অর্ডার দিলে হাতে পেতে কয় দিন?   (greedy)
শুরু   : মিরপুর এলাকা আমার মাঝে খাওয়া গেছে। আমার চার ফাঁ克 শব্দ আমার মাথায় পড়িয়েছ…
β=0.5  : মিরপুরের আপনি অর্ডার দিলে হাতে পেতে 1-2 দিন পড়ায় হবে।
β=0.1  : মিরপুরের আপনি বাজারঘর অনলাইন দোকানের সাপোর্ট সহকারীদের 24 মিনিটের মধ্যে অর্…
β=0.02 : মিরপুরেও আপনي 10-12 দнями धमाई坚坚决反对任何形式的… (চীনা লেখা চলতে থাকে, কাটা হয়েছে)
β=0.1, seed 0, temperature 0.7: মিশ্রপুরের মধ্যে 24 সাথের আপনাকে পেতে পারবে এবং অর্ডারের মতো আপনি 18 মিন锡র আগ…

প্রশ্ন: ২৫ আর ১৭ যোগ করলে কত হয়?   (greedy)
শুরু   : ২৫ আর৩৮ যোগ করলে কত হয়?  এখন একটি গণিত শব্দ লিখি: "সমান্তর: 25 + 38 = 63" …
β=0.5  : ২৫ আর ১৭ যোগ করলে কত হয় ৩৮ যোগ।
β=0.1  : ২৫ আর ১৭ যোগ করলে একটি মধ্যসমposable শব্দ "স্থাপনা" (स्थापना) হবে।
β=0.02 : 25

৮ · Reward hacking আর over-optimisation

মেশিন লার্নিং কোর্সের পর্ব ২-এ Goodhart-এর নিয়ম দেখেছেন: একটি মাপ লক্ষ্য হয়ে গেলে সেটি আর ভালো মাপ থাকে না। RM মানুষের পছন্দের একটি অসম্পূর্ণ মাপ (proxy). Policy-কে সেটি বাড়াতে যত জোরে চাপ দেবেন, তত বেশি সে RM-এর ফাঁক খুঁজবে: এটিই reward hacking, বা over-optimisation.

Gao, Schulman ও Hilton (২০২২) এটি নিয়মিতভাবে মাপেন। মানুষের বদলে একটি বড় “gold” RM-কে আসল বিচারক ধরে তাঁরা তার label থেকে ছোট proxy RM শেখান, তারপর proxy-র বিরুদ্ধে RL বা best-of-n দিয়ে optimise করেন। প্রবন্ধের সারাংশ অনুযায়ী proxy বাড়তে থাকে, কিন্তু gold score একটা সময় পর কমে; আর এই সম্পর্ক RM-এর আকারের সঙ্গে মসৃণভাবে বদলায়। নিচে একই ধাঁচের একটি খেলনা: আমাদের proxy RM দৈর্ঘ্য পছন্দ করে, অথচ ৬০ শব্দের পর প্যাঁচাল আসল মান কমায়।

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(42)
P, N = 2000, 256                            # ২০০০টি প্রশ্ন, প্রতিটিতে ২৫৬টি উত্তর
core = rng.normal(0, 1, (P, N))             # উত্তরের আসল মান (লুকানো)
length = 10 + rng.exponential(50, (P, N))   # শব্দ-সংখ্যা: বেশির ভাগ ছোট
true_q = core - ((length - 80) / 80) ** 2   # ~৮০ শব্দই আদর্শ, বেশি হলে প্যাঁচাল
proxy = 0.6 * core + 0.012 * length + rng.normal(0, 0.3, (P, N))  # RM: দৈর্ঘ্যে পক্ষপাত

print("   n │ proxy reward │ আসল মান │ গড় দৈর্ঘ্য")
res = []
for n in [1, 2, 4, 8, 16, 32, 64, 128, 256]:
    best = proxy[:, :n].argmax(axis=1)      # best-of-n: proxy-তে সেরাটি বাছাই
    i = np.arange(P)
    pr, tq, ln = proxy[i, best].mean(), true_q[i, best].mean(), length[i, best].mean()
    res.append((n, pr, tq))
    print(f"{n:4d} │ {pr:12.2f} │ {tq:7.2f} │ {ln:6.0f}")
k = max(res, key=lambda t: t[2])
print("আসল মান সবচেয়ে বেশি n =", k[0], "-তে; এরপর proxy বাড়ে, আসল মান কমে")

n, pr, tq = zip(*res)
fig, ax = plt.subplots(figsize=(5, 3))
ax.semilogx(n, pr, "o-", base=2, label="proxy reward (length-biased)")
ax.semilogx(n, tq, "s-", base=2, label="true quality")
ax.set_xlabel("best-of-n (optimisation pressure)"); ax.set_ylabel("mean score")
ax.set_title("Goodhart: optimising a proxy"); ax.legend(fontsize=8)
plt.show()

   n │ proxy reward │ আসল মান │ গড় দৈর্ঘ্য
   1 │         0.72 │   -0.44 │     59
   2 │         1.23 │   -0.13 │     76
   4 │         1.68 │   -0.09 │     98
   8 │         2.12 │   -0.40 │    125
  16 │         2.53 │   -0.86 │    152
  32 │         2.93 │   -1.72 │    183
  64 │         3.34 │   -3.08 │    217
 128 │         3.76 │   -4.82 │    252
 256 │         4.17 │   -6.86 │    286
আসল মান সবচেয়ে বেশি n = 4 -তে; এরপর proxy বাড়ে, আসল মান কমে

এটি সাজানো খেলনা, কিন্তু আমাদের সত্যিকারের RM-এও একই ফাঁক মাপা গেছে: শেখার আগে এলোমেলো score head-এর দুটি seed-এ ঠিক উত্তরের শেষে প্যাঁচাল জুড়লে ৮৬% আর ৯২% ক্ষেত্রে score বেড়েছিল (তৃতীয়টিতে ১%); ডেটায় প্যাঁচাল-ধরনের rejected থাকায় training-এর পর তা ০%. কিন্তু ডেটায় নেই এমন ফাঁক, যেমন অজানা ভুল সংখ্যা, থেকেই গেছে (অংশ ৪)। অংশ ৫-এর খেলনাতেও β = ০.০২-এ policy পুরোপুরি “ঠিক, লম্বা” উত্তরে গিয়েছিল, কারণ সেখানে RM লম্বা উত্তরকে সামান্য বেশি দিয়েছিল।

Reward hacking-এর পরিচিত রূপ: দৈর্ঘ্য আর সাজানো ফরম্যাট, আত্মবিশ্বাসী সুর, আর ব্যবহারকারীর মতের সঙ্গে একমত হওয়া (sycophancy; AI-এর ভিত্তি কোর্সের পর্ব ৭০)। DeepSeek-R1 প্রবন্ধে লেখকেরা R1-Zero-তে neural RM ব্যবহার না করার কারণ হিসেবে বড় মাপের RL-এ reward hacking-এর ঝুঁকিই লিখেছেন। প্রতিরোধের সাধারণ উপায়:

• KL-এর লাগাম আর early stopping: β আর ধাপের সংখ্যা দিয়ে চাপ সীমিত রাখা।
• Proxy-র বাইরে মাপা: আলাদা মানুষের মূল্যায়ন বা নিয়ম-ভিত্তিক যাচাই (যেমন আমাদের তথ্য-নিয়ম), proxy score নয়।
• জানা ফাঁক ডেটায় বন্ধ করা: “লম্বা কিন্তু ফাঁপা” উত্তরকে rejected হিসেবে রাখা, যা আমাদের ডেটার প্যাঁচাল-ধরন করে; বা দৈর্ঘ্যে normalise করা loss.
• RM হালনাগাদ: নতুন policy-র উত্তরে আবার তুলনা নিয়ে RM শেখানো, কারণ policy সরে গেলে পুরনো RM-এর জানা এলাকার বাইরে চলে যায়।

৯ · RLHF-এর পরিবার — Constitutional AI, RLAIF আর GRPO

Constitutional AI আর RLAIF. Anthropic-এর Bai ও সহলেখকদের প্রবন্ধ (arXiv, ডিসেম্বর ২০২২) ক্ষতিকর উত্তর চিহ্নিত করার মানুষের label প্রায় বাদ দেয়। মানুষের তত্ত্বাবধান আসে একটি ছোট নীতির তালিকা থেকে, যাকে লেখকেরা “constitution” বলেন। দুটি ধাপ: (১) supervised: model নিজের উত্তর নীতি ধরে সমালোচনা করে, সংশোধন করে, আর সংশোধিত উত্তরে fine-tune হয়; (২) RL: একটি model দুটি উত্তরের কোনটি ভালো তা বাছে, সেই AI-পছন্দ থেকে একটি preference model শেখে, আর সেটিই reward. এর নাম RLAIF (RL from AI Feedback). লেখকেরা জানান, এতে model ক্ষতিকর অনুরোধ এড়িয়ে না গিয়ে কেন আপত্তি তা ব্যাখ্যা করে। Anthropic-এর Claude-এর বর্তমান প্রশিক্ষণের পুরো বিবরণ এই প্রবন্ধে নেই; প্রবন্ধটি পদ্ধতির বর্ণনা, কোনো পণ্যের রেসিপি নয়। AI-এর বিচারকেরও পক্ষপাত আছে, যা পর্ব ৫৮ (LLM মূল্যায়ন — benchmark, LLM-as-judge আর তার ফাঁদ)-এ মাপা হবে।

GRPO. DeepSeek-এর Shao ও সহলেখকদের DeepSeekMath প্রবন্ধ (arXiv, ফেব্রুয়ারি ২০২৪) GRPO (Group Relative Policy Optimization) প্রস্তাব করে, PPO-র একটি রূপ। PPO-র value model সাধারণত policy-র সমান বড়, তাই memory-র বড় বোঝা। GRPO সেটি বাদ দেয়: প্রতিটি প্রশ্নে G টি উত্তর তুলে প্রতিটির reward r_i, তারপর advantage = (r_i − গড়)/std, অর্থাৎ দলের ভেতরে আপেক্ষিক মান। উদাহরণ: G = ৪, reward [১, ০, ০, ১] হলে গড় ০.৫, std ০.৫, advantage [+১, −১, −১, +১]। KL শাস্তি reward-এ না বসিয়ে সরাসরি loss-এ যোগ হয়। পরে DeepSeek-R1 প্রবন্ধ (arXiv, জানুয়ারি ২০২৫) জানায়, R1-Zero-তে GRPO চালানো হয়েছে নিয়ম-ভিত্তিক reward দিয়ে: উত্তর ঠিক কি না (গণিতে উত্তর মিলিয়ে, কোডে test চালিয়ে) আর ভাবনা নির্দিষ্ট tag-এর ভেতরে লেখা কি না।

DPO-র পর অনেক offline loss প্রস্তাবিত হয়েছে; লেখার সময়ে (নভেম্বর ২০২৬) trl 1.17-এর নথিতে loss_type-এর ১৫টি বিকল্প, যেমন IPO (identity transform) আর দৈর্ঘ্যে normalise করা SimPO-ধাঁচের sigmoid_norm. কোনটি সব কাজে ভালো, তার সাধারণ উত্তর নেই; online (PPO, GRPO) বনাম offline (DPO) নিয়ে গবেষকদের মধ্যেও মতভেদ আছে। Offline পদ্ধতি সস্তা আর স্থির, কিন্তু শুধু ডেটায় থাকা উত্তর থেকে শেখে; online পদ্ধতি নিজের নতুন উত্তর যাচাই করে শেখে, খরচ আর অস্থিরতা বেশি।

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

DPO আর reward model-এর কোড AI assistant কয়েক সেকেন্ডে লেখে। কিন্তু trl এক বছরে কয়েকবার বড় বদল দেখেছে, আর alignment নিয়ে অনলাইনের লেখায় দাবি অনেক, মাপ কম।

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

• trl, transformers আর peft-এর version লিখে নিজের version-এর নথিতে প্রতিটি argument মিলিয়েছি
• ধাপ ০-এ DPO loss ln ২ আর implicit reward ০ কি না দেখেছি
• চারটি সংখ্যা দিয়ে loss হাতে হিসাব করে library-র সঙ্গে মিলিয়েছি
• আলাদা রাখা জোড়ায় RM-এর pairwise accuracy, আর সরল baseline (যেমন দৈর্ঘ্য) মেপেছি
• Policy-র উত্তর proxy-র বাইরে (নিয়ম বা মানুষ) মেপেছি, একাধিক seed আর β-তে; সাধারণ প্রশ্নেও আচরণ দেখেছি
• কোনো গ্রাহকের ব্যক্তিগত ডেটা বা token prompt-এ দিইনি; প্রবন্ধের দাবি মূল উৎসে মিলিয়েছি