Decoding — greedy, beam search, temperature, top-k আর top-p

১ · একই model, ভিন্ন লেখা — decoding আসলে কী

আগের পর্বগুলোয় model শিখেছে একটি কাজ: prompt দেখে পরের token-এর probability দেওয়া। কিন্তু probability তো লেখা নয়। প্রতিটি ধাপে কোন token আসলে নেওয়া হবে, সেই নিয়মের নাম decoding. AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ এর প্রথম পরিচয় পেয়েছেন, পর্ব ৩০-এ greedy, আর পর্ব ৩৬-এ temperature. এই পর্বে পুরোটা একসঙ্গে, হিসাবসহ।

ধারণাগুলো দুই পরিবারে পড়ে। একটি খোঁজে, অন্যটি তোলে:

খোঁজার লক্ষ্য লেখা যায় এক লাইনে। Sequence x₁…x_n-এর probability হলো প্রতিটি ধাপের probability-র গুণফল (chain rule, পর্ব ৪৬ · Language modeling-এ এর বিস্তার):

log P(x₁…x_n) = ∑_t log P(x_t | x₁…x_t−1)

এখানে log হলো স্বাভাবিক লগ। গুণের বদলে যোগ করা হয়, কারণ অনেক ছোট সংখ্যার গুণফল কম্পিউটারে শূন্যে হারিয়ে যায়; এই যোগফলটিই log-probability. সব sequence ঘুরে দেখতে লাগত Vⁿটি পথ, যেখানে V হলো vocabulary-র আকার। GPT-2-এর V = 50,257 আর n = 20 হলে সংখ্যাটি প্রায় ১০^৯৪. তাই সবই আসলে আপস।

২ · Greedy আর beam search — কেন সেরা পথ হারায়

Greedy প্রতি ধাপে argmax নেয়, তাই একবার ভুল মোড় নিলে আর ফেরে না (পর্ব ৩০-এ ছোট উদাহরণ দেখেছেন)। Beam search প্রতি ধাপে সেরা W-টি আংশিক sequence ধরে রাখে; W-কে বলে beam width. W = ১ হলে এটিই greedy. বাজারঘর-এর একটি রিভিউ-বাক্যের ছোট গাছ দেখুন, যার সংখ্যাগুলো হাতে বানানো:

এক ধাপে কী ঘটে, হাতে দেখুন। W = ২, প্রথম ধাপ শেষ। সব স্কোর log-probability, তাই বড় মানে কম ঋণাত্মক:

এবার গাছটি কোডে। সব পথ ঘুরে দেখা brute force-এর সঙ্গে beam-এর ফল মিলিয়ে নিচ্ছি। প্রথম চালাতে কয়েক সেকেন্ড লাগতে পারে:

import math
TREE = {(): {"ভালো": .40, "মান": .35, "দাম": .25},
    ("ভালো",): {"ছিল": .5, "না": .3, "মান": .2},
    ("মান",): {"ভালো": .6, "খারাপ": .4},
    ("দাম",): {"কম": .95, "বেশি": .05},
    ("ভালো", "ছিল"): {"।": .5, "না": .5}, ("ভালো", "না"): {"।": 1.0},
    ("ভালো", "মান"): {"ছিল": 1.0}, ("মান", "ভালো"): {"ছিল": .8, "।": .2},
    ("মান", "খারাপ"): {"ছিল": .9, "।": .1}, ("দাম", "কম"): {"ছিল": .98, "।": .02},
    ("দাম", "বেশি"): {"ছিল": .7, "।": .3}}

def brute(path=(), lp=0.0):              # সব পথ ঘুরে দেখা
    if path not in TREE:
        return [(lp, path)]
    out = []
    for t, p in TREE[path].items():
        out += brute(path + (t,), lp + math.log(p))
    return out

def beam(W):
    beams, grown = [(0.0, ())], 0
    while any(p in TREE for _, p in beams):
        cand = []
        for lp, path in beams:
            for t, q in TREE[path].items():
                cand.append((lp + math.log(q), path + (t,))); grown += 1
        beams = sorted(cand, reverse=True)[:W]   # W-টি রাখা, বাকি চিরতরে বাদ
    return beams[0], grown

paths = sorted(brute(), reverse=True)
print("সব পথ:", len(paths), "| সেরা:", " ".join(paths[0][1]), f"{math.exp(paths[0][0]):.4f}")
for W in (1, 2, 3):
    (lp, p), n = beam(W)
    tag = "সেরা পেয়েছে" if p == paths[0][1] else "সেরা পায়নি"
    print(f"W={W} P={math.exp(lp):.4f} {' '.join(p)} | {n} বিস্তার | {tag}")

খরচের হিসাব: প্রতি ধাপে W-টি sequence এক batch-এ model-এ যায়, আর W × V প্রার্থীর মধ্যে সেরা W বাছাই হয়। পর্ব ৩৭-এর KV cache-ও W গুণ জায়গা নেয়, আর beam বদলালে cache-এর সারিগুলোও সাজিয়ে নিতে হয়।

৩ · কখন থামবে — EOS, length penalty আর থামার নিয়ম

Generation থামে তিনভাবে: model EOS token দিলে, max_new_tokens ফুরালে, অথবা নির্দিষ্ট লেখা (stop sequence) বেরোলে। EOS কেবল একটি সাধারণ token, model এটিও probability দিয়ে বেছে নেয়। Beam-এ কোনো প্রার্থী EOS পেলে সেটি “সমাপ্ত” তালিকায় যায়, বাকিরা এগোতে থাকে।

এখানেই ফাঁদ। প্রতি ধাপে একটি ঋণাত্মক সংখ্যা যোগ হয়, তাই লম্বা sequence-এর মোট স্কোর প্রায় সবসময় বেশি ঋণাত্মক। সরাসরি তুললে ছোট উত্তরই জেতে। এর ওষুধ length penalty. Hugging Face transformers-এর নথি অনুযায়ী (v5.22.2, ২০২৬ সালের নভেম্বরে পড়া) স্কোরকে দৈর্ঘ্যের ঘাত দিয়ে ভাগ করা হয়, যেখানে L হলো নতুন token-এর সংখ্যা আর α হলো length_penalty:

score = (∑ log P) / L^α

α যত বড়, লম্বা উত্তর তত এগিয়ে। α = 0 মানে কোনো ক্ষতিপূরণ নেই। ঋণাত্মক α ছোট উত্তরকে আরও সুবিধা দেয়।

Sampling-এ এই সমস্যা নেই, কারণ সেখানে মোট স্কোর তুলনা হয় না। আর JSON বা schema মানতে বাধ্য করা হলো constrained decoding; এটি পর্ব ৬২ (Structured output — JSON, schema আর যাচাই)-এর বিষয়।

৪ · Temperature — logit-কে ভাগ করা

এবার তোলার পরিবার। Softmax-এর আগে প্রতিটি logit z_i-কে T দিয়ে ভাগ করা হয়:

p_i = e^z_i/T / ∑_j e^z_j/T

দুটি token-এর probability-র অনুপাত তাই p_i/p_j = e^{(z_i−z_j)/T}. T কমলে অনুপাত বাড়ে, T বাড়লে ১-এর দিকে যায়। অনিশ্চয়তা মাপব entropy দিয়ে, H = −∑ p log₂ p বিটে (AI-এর ভিত্তি কোর্সের পর্ব ৩৮).

পরীক্ষায় অনুপাতের সূত্র দিয়ে দ্রুত যাচাই করা যায়। “ভালো” আর “মোটামুটি”-র logit-এর ফারাক ১.৫. T = ১-এ অনুপাত e^1.5 = ৪.৪৮ (.786 / .175), T = ০.৫-এ e³ = ২০.১, আর T = ২-এ e^0.75 = ২.১২. একবার সংখ্যা মিলিয়ে নিলে ভুল softmax সহজেই ধরা পড়ে।

একটি বিষয় মনে রাখুন। Temperature বণ্টনের আকার বদলায়, কিন্তু কোনো token বাদ দেয় না। বিশাল vocabulary-তে T = ১.৫ হলে অসংখ্য বাজে token-এর ছোট ছোট probability মিলে বড় একটি লেজ তৈরি হয়। সেই লেজ কাটার জন্যই পরের অংশ।

৫ · Top-k, top-p আর min-p — লেজ কাটা

তিনটিরই কাজ একই: কিছু token-এর probability শূন্য করে বাকিদের যোগফল আবার ১ করা। অর্থাৎ বণ্টনের support ছোট করা। পার্থক্য শুধু কাটার নিয়মে:

• Top-k: সবচেয়ে বড় k-টি রাখা। k স্থির, বণ্টন তীক্ষ্ণ হোক বা সমতল।
• Top-p (nucleus): বড় থেকে ছোট সাজিয়ে সবচেয়ে ছোট এমন দল রাখা, যাদের যোগফল অন্তত c. Model নিশ্চিত হলে দল ছোট, অনিশ্চিত হলে বড়।
• Min-p (শুধু পরিচিতি): সবচেয়ে বড় probability-র m গুণের নিচে যারা, তাদের বাদ। Nguyen ও সহলেখকরা ২০২৪ সালে এটি প্রস্তাব করেন (ICLR ২০২৫), আর ভালো ফলের দাবি তাঁদের নিজেদের পরীক্ষার; একে সর্বজনীন সিদ্ধান্ত ধরবেন না।

Top-k আর top-p-এর আসল পার্থক্য দেখা যায় দুই ধরনের বণ্টনে। প্রথমটিতে model প্রায় নিশ্চিত, দ্বিতীয়টিতে অনিশ্চিত:

Top-k সমতল বণ্টনে অর্ধেকের বেশি ভর ফেলে দেয়, তীক্ষ্ণ বণ্টনে অপ্রয়োজনীয় token রেখে দেয়। Top-p দুই জায়গাতেই বণ্টন দেখে সিদ্ধান্ত নেয়।

এবার সব নিয়ম NumPy-তে, আটটি শব্দের হাতে বানানো logit-এ। প্রতি সারিতে support আর entropy ছাপা হবে:

import numpy as np
np.set_printoptions(precision=3, suppress=True, linewidth=60)
words = ["ভালো", "সুন্দর", "দারুণ", "মোটামুটি", "খারাপ", "ছেঁড়া", "দেরি", "ফেরত"]
z = np.array([3.0, 2.5, 2.0, 1.2, 0.3, -0.2, -0.8, -1.5])   # হাতে বানানো

def softmax(z, T=1.0):
    e = np.exp(z / T - (z / T).max())      # overflow ঠেকাতে সর্বোচ্চ বিয়োগ
    return e / e.sum()
def H(p):                                  # entropy, bit-এ
    q = p[p > 0]
    return float(-(q * np.log2(q)).sum()) + 0.0
def keep(p, mask):                         # বাকিরা শূন্য, যোগফল আবার ১
    q = np.where(mask, p, 0.0)
    return q / q.sum()
def top_k(p, k):
    return keep(p, p >= np.sort(p)[-k])
def top_p(p, c):
    i = np.argsort(-p)
    n = np.searchsorted(np.cumsum(p[i]), c) + 1   # c ছোঁয়ার প্রথম ঘর
    m = np.zeros(len(p), bool); m[i[:n]] = True
    return keep(p, m)
def min_p(p, m):
    return keep(p, p >= m * p.max())
def show(name, p):
    print(f"{name:10s} support={(p > 0).sum()} H={H(p):.3f} max={p.max():.3f}")

p = softmax(z)
show("T=1", p)
for T in (0.01, 0.5, 2.0, 1000.0): show(f"T={T}", softmax(z, T))
show("top-k 3", top_k(p, 3)); show("top-p 0.9", top_p(p, 0.9))
show("min-p 0.2", min_p(p, 0.2))
q = top_p(p, 0.9); draw = np.random.default_rng(42).choice(8, 20000, p=q)
print("তত্ত্ব:", q.round(3)); print("নমুনা:", (np.bincount(draw, minlength=8) / 20000).round(3))
print("ছাঁটা:", [w for w, x in zip(words, q) if x == 0])

বাস্তবে এই নিয়মগুলো একসঙ্গে চলে, প্রতি ধাপে একটি ছোট পাইপলাইনের মতো:

T বদলালে কাটের ফল কেমন বদলায়, আর ক্রম উল্টে দিলে কী হয়, সেটি পরের কোডে। ছবি দুটির মূল কথা: T শুধু আকার বদলায়, top-p support কাটে।

import numpy as np, matplotlib.pyplot as plt
z = np.array([3.0, 2.5, 2.0, 1.2, 0.3, -0.2, -0.8, -1.5])

def softmax(z, T=1.0):
    e = np.exp(z / T - (z / T).max())
    return e / e.sum()
def H(p):
    q = p[p > 0]
    return float(-(q * np.log2(q)).sum())
def nucleus(p, c):
    i = np.argsort(-p)
    n = np.searchsorted(np.cumsum(p[i]), c) + 1
    q = np.zeros_like(p); q[i[:n]] = p[i[:n]]
    return q / q.sum()
def minp(p, m):
    q = np.where(p >= m * p.max(), p, 0.0)
    return q / q.sum()

print("T    top-p 0.9   min-p 0.2")
for T in (0.5, 1.0, 2.0, 4.0):
    p = softmax(z, T)
    print(f"{T:<4} {(nucleus(p, .9) > 0).sum():>5} {(minp(p, .2) > 0).sum():>10}")
b = nucleus(softmax(z, 2.0), .7)                # আগে T, পরে top-p
c = nucleus(softmax(z), .7); s = c[c > 0]       # আগে top-p, পরে T
a = s ** .5 / (s ** .5).sum()
print(f"আগে T, পরে top-p: support {(b > 0).sum()} H {H(b):.3f}")
print(f"আগে top-p, পরে T: support {len(a)} H {H(a):.3f}")

Ts = np.logspace(-1.5, 2, 60); cs = np.linspace(.05, 1, 96)
fig, ax = plt.subplots(1, 2, figsize=(7, 2.8))
ax[0].semilogx(Ts, [H(softmax(z, t)) for t in Ts]); ax[0].axhline(3, ls="--", c="gray")
ax[0].set(xlabel="temperature T", ylabel="entropy (bits)", title="T only reshapes")
ax[1].step(cs, [(nucleus(softmax(z), c) > 0).sum() for c in cs], where="post")
ax[1].set(xlabel="top-p threshold c", ylabel="tokens kept", title="top-p cuts the support")
fig.subplots_adjust(wspace=.35, bottom=.2)

৬ · Repetition penalty আর n-gram নিষেধ

লুপে আটকে গেলে দুটি জনপ্রিয় ওষুধ আছে। প্রথমটি repetition penalty, যেটি Keskar ও সহলেখকদের CTRL (২০১৯) থেকে এসেছে। আগে দেখা প্রতিটি token-এর logit z এবং penalty r > 1 হলে:

z > 0 হলে z / r; z < 0 হলে z × r

দুই শাখা কেন? ঋণাত্মক logit-কে ভাগ করলে সেটি শূন্যের দিকে যায়, মানে probability উল্টো বাড়ে। হাতে একটি উদাহরণ: z = 2, −1, 0.5, প্রথম দুটি আগে দেখা, r = 1.25. নতুন z = 1.6, −1.25, 0.5. Softmax-এর আগে-পরে p = .786, .039, .175 থেকে .719, .042, .239. না-দেখা token এগোল। কিন্তু খেয়াল করুন, দেখা হলেও ঋণাত্মক token-টির p সামান্য বাড়ল, কারণ সবচেয়ে বড় প্রতিদ্বন্দ্বী বেশি কমেছে। Penalty logit কমায়, প্রতিটি probability কমাবে এমন নিশ্চয়তা দেয় না।

দ্বিতীয় ওষুধ no_repeat_ngram_size: যে token দিলে একই n-gram দ্বিতীয়বার হবে, তাকে সরাসরি নিষিদ্ধ করা। যেমন n = ২-এ “মান ভালো মান” লেখার পরে “ভালো” আর আসতে পারবে না। এটি কড়া; বাক্যে “ঢাকা থেকে ঢাকা” বা একই নাম দুবার ন্যায্যভাবে দরকার হলেও আটকে দিতে পারে। নিচে ছোট একটি হাতে বানানো bigram model, যা নিজে থেকেই “মান ভালো মান ভালো” লুপে পড়ে:

import numpy as np
V = ["মান", "ভালো", "দাম", "কম", "।"]
# ছোট bigram model: সারি = আগের token, ঘর = পরের token-এর logit
Z = np.array([[-2.0,  1.2,  0.9, -1.0,  0.2],   # মান → ভালো
              [ 1.0, -2.0,  0.8, -1.0,  0.3],   # ভালো → মান
              [-1.0,  0.2, -2.0,  1.5,  0.4],   # দাম → কম
              [-1.0,  0.3,  0.6, -2.0,  1.2],   # কম → ।
              [ 1.0,  0.5,  0.8, -1.0, -3.0]])  #. → মান

def penalize(z, seen, r, wrong=False):
    z = z.copy()
    for t in seen:
        z[t] = z[t] / r if (z[t] > 0 or wrong) else z[t] * r
    return z

def greedy(r, n=12):
    ids = [0]
    for _ in range(n):
        ids.append(int(penalize(Z[ids[-1]], set(ids), r).argmax()))
    return ids

def uniq2(ids):
    g = list(zip(ids, ids[1:]))
    return len(set(g)) / len(g)

for r in (1.0, 1.1, 1.3, 2.0):
    ids = greedy(r)
    print(f"r={r}: uniq2={uniq2(ids):.2f}", " ".join(V[i] for i in ids))
z = np.array([1.0, -2.0, 0.0])
print("ঠিক নিয়ম:", penalize(z, {0, 1}, 1.3).round(3))
print("শুধু ভাগ:", penalize(z, {0, 1}, 1.3, wrong=True).round(3))

ছোট alphabet-এ এই penalty আরও বিপজ্জনক। অক্ষর-স্তরের model-এ “া” বা স্পেস তো বারবার আসবেই। তাই penalty-র মান token-এর আকারের ওপর নির্ভর করে; একই r সব model-এ এক ফল দেয় না। অংশ ৮-এ এটি মাপা হয়েছে।

৭ · GPT-2-তে সত্যিকারের তুলনা — মানুষের লেখার পাশে

এবার আসল model. openai-community/gpt2 (model card অনুযায়ী MIT লাইসেন্স), transformers 5.22.2, torch 2.15.0, Python 3.14.4, GPU-তে। Holtzman ও সহলেখকদের ধারণাটি ছোট আকারে পরীক্ষা করেছি: ছয়টি পুরোনো ইংরেজি উপন্যাস (Project Gutenberg, যেমন Alice in Wonderland, Frankenstein) থেকে seed ৪২ দিয়ে ৩০টি অনুচ্ছেদ। প্রথম ৪০ token হলো prompt; পরের ৮০ token হয় model লিখেছে, নয়তো মূল লেখকের লেখা। Sampling-এ seed ৪২, ৪৩, ৪৪ (তাই ৯০টি লেখা)। প্রতিটি লেখায় তিনটি মাপ:

• Unique n-gram ratio: আলাদা n-gram ÷ মোট n-gram (n-gram মানে পরপর n token). Repetition rate = ১ − এই অনুপাত।
• Unique 1-gram: একই হিসাব, একক token-এ। “the” বা যতিচিহ্ন মানুষের লেখাতেও ফিরে আসে, তাই এটি ১-এর অনেক নিচে থাকাই স্বাভাবিক।
• গড় token probability: লেখা শেষে অপরিবর্তিত model (T = ১, কোনো কাট নেই) প্রতিটি token-কে যে probability দেয়, তার গড়।

~/bazarghar-dl$ uv run python gpt2_run.py      # সত্যিকারের run
passage: 30 prompt 40 নতুন token 80
# প্রতি নিয়মের JSON থেকে সংক্ষিপ্ত করে নিচের টেবিল

এই একটি ছোট পরীক্ষায় চারটি জিনিস চোখে পড়ে:

• Beam আর greedy মানুষের থেকে অনেক দূরে: Model নিজে যে লেখাকে .৬৮৫ গড় probability দেয়, মানুষের লেখাকে দেয় মাত্র .১৬৮. প্রায় দুই-তৃতীয়াংশ 3-gram পুনরাবৃত্তি। মানুষ সবচেয়ে সম্ভাব্য পথে লেখে না।
• T = ১ আর top-p ০.৯ মাপে মানুষের কাছে: তিনটি সংখ্যাতেই কাছাকাছি। তবে এর মানে লেখাটি ভালো, এমন নয়; এই মাপগুলো অর্থ মাপে না।
• No-repeat 3 শুধু মাপ সারায়: 3-gram পুনরাবৃত্তি শূন্য, কারণ নিয়মে নিষিদ্ধ। গড় p তবু .৩৬০, মানুষের দ্বিগুণের বেশি।
• Rep ১.২ মাত্রা ছাড়ায়: Unique 1-gram .৯৯৩; “the” বা যতিচিহ্নও প্রায় ফেরে না। মানুষের .৭৫১-এর চেয়ে অনেক ওপরে, আর গড় p মানুষের নিচে নেমে গেছে। শূন্য পুনরাবৃত্তি লক্ষ্য নয়।

একটি prompt-এ আসল লেখা, seed ৪২, সম্পাদনা ছাড়া:

PROMPT: It was so long since she had been anything near the right size, that it felt quite strange at first; but she got used to it in a few minutes, and began talking to herself, as

greedy: if she were going to be able to talk to herself. "I'm not sure what I'm doing," she said, "but I'm not sure what I'm doing. I'm not sure what I'm doing. I'm not sure what I'm doing. I'm not sure what I'm doing. I'm not sure what I'm doing. I'm not sure what I

beam 5: if it were the only thing she could do. "I don't know what you're talking about," she said. "I don't know what you're talking about," I said. "I don't know what you're talking about," she said. "I don't know what you're talking about," I said. "I don't

beam 5, no-repeat 3: if it were the only thing she could do. "I'm so glad you're here," she said. "It's been a while since I've been here, but I'm glad I'm here." He looked at her, and said, with a smile, "I'm glad you like it here, too. It's so nice to be here, and it's

top-p 0.9: if to find out how much was in her back pocket. The bushy whiskers poking out of each other are emitting what looked to them like six of the six bristles and a slight hum as if they had been eaten by an angry goat, and perhaps some other creatures. Although it might take them all of three minutes to eat them, her expression had now changed as much as it

মানুষ (Lewis Carroll): usual. “Come, there’s half my plan done now! How puzzling all these changes are! I’m never sure what I’m going to be, from one minute to another! However, I’ve got back to my right size: the next thing is, to get into that beautiful garden—how _is_ that to be done, I wonder

লাইন-ভাঙা এখানে স্পেসে দেখানো হয়েছে। T = ১ আর rep ১.২-এর লেখা দেখানো হয়নি; T = ১-এর লেখায় কিছু অমার্জিত শব্দ ছিল। Top-p-এর লেখা পুনরাবৃত্ত নয়, কিন্তু সংলগ্নও নয়: ২০১৯ সালের একটি ছোট model বলে অর্থের জোর এমনই। Decoding দিয়ে model-এর সীমা পার করা যায় না।

Beam width বাড়ালে খরচ আর ফল

পাঁচটি ছোট prompt, প্রতিটিতে ঠিক ৪০টি নতুন token (min_new_tokens আর max_new_tokens সমান, তাই থামার প্রভাব নেই)। সময় মধ্যমা, log P আর unique 3-gram গড়:

~/bazarghar-dl$ uv run python gpt2_speed.py    # সত্যিকারের run, CPU-তে ৪ thread
cuda  width   1   2372 ms   16.9 token/s  log P -50.48  uniq3 0.65  peak 497 MiB
cuda  width   2   3321 ms   12.0 token/s  log P -49.87  uniq3 0.68  peak 497 MiB
cuda  width   4   3160 ms   12.7 token/s  log P -42.60  uniq3 0.62  peak 500 MiB
cuda  width   8   2936 ms   13.6 token/s  log P -37.04  uniq3 0.67  peak 532 MiB
cuda  width  16   3390 ms   11.8 token/s  log P -33.54  uniq3 0.56  peak 550 MiB
cuda  width  32   5170 ms    7.7 token/s  log P -24.86  uniq3 0.37  peak 620 MiB
cpu   width   1    866 ms   46.2 token/s  log P -50.48  uniq3 0.65
cpu   width   2   1306 ms   30.6 token/s  log P -49.87  uniq3 0.68
cpu   width   4   1403 ms   28.5 token/s  log P -42.60  uniq3 0.62
cpu   width   8   1759 ms   22.7 token/s  log P -37.03  uniq3 0.67
cpu   width  16   2236 ms   17.9 token/s  log P -33.54  uniq3 0.56

তিনটি শিক্ষা। এক: W বাড়লে log P সত্যিই ভালো হলো, −৫০.৪৮ থেকে −২৪.৮৬; খোঁজা তার লক্ষ্য পূরণ করছে। দুই: ঠিক তখনই লেখা বেশি পুনরাবৃত্ত, W = ৩২-এ unique 3-gram নামল .৩৭-এ। বেশি probability মানেই ভালো লেখা নয়। তিন: সময় W গুণ বাড়েনি, W = ১৬-এ CPU-তে আড়াই গুণের মতো, কারণ W-টি sequence এক batch-এ যায়, আর এত ছোট model-এ batch ভালোই কাজে লাগে। এই একই কারণে এখানে GPU-কে CPU-র চেয়ে ধীর দেখাচ্ছে: GPU তখন অন্য কাজের সঙ্গে ভাগ করা ছিল, আর একটি ছোট prompt-এ GPU-র সুবিধা কম। সময়গুলো এক দফা স্থানীয় মাপ, গতির সাধারণ তুলনা নয়। Peak-এ model-এর নিজের weight-ও আছে, তাই সংখ্যা প্রথম থেকেই বড় (পর্ব ১২).

৮ · ছোট বাংলা model-এ একই পরীক্ষা

এবার পর্ব ৩৬-এর MiniGPT একই নকশায় আবার train করা হলো: অক্ষর-স্তরের model, ১৮ লাখের কিছু বেশি parameter, vocabulary ৮৩, GPU-তে ৩,০০০ step. ডেটা উপেন্দ্রকিশোর রায়চৌধুরীর গল্প (bn.wikisource, ভারতে public domain) আর course-এর seeded বাজারঘর রিভিউ। Decoding এখানে হাতে লেখা, অংশ ৪–৬-এর নিয়মগুলোই। পরীক্ষা: training-এর বাইরের test গল্প থেকে ২০টি prompt, প্রতিটি ৬০ অক্ষর; এরপর ২০০ অক্ষর। Sampling-এ seed ৪২, ৪৩, ৪৪ (তাই ৬০টি লেখা), আর “মানুষ” মানে ওই গল্পের আসল পরের ২০০ অক্ষর। অক্ষর-স্তরে n-gram ছোট বলে এখানে ৬ অক্ষরের n-gram মাপা হয়েছে। এই টেবিল সংক্ষিপ্ত করা হয়েছে; মানগুলো run-এর JSON থেকে তিন দশমিকে নেওয়া:

~/bazarghar-dl$ uv run python bn_run.py     # সত্যিকারের run, GPU-তে, torch 2.15.0
step 2500 parameters 1817280 vocab 83       # val-এ সেরা checkpoint

“Train-এ থাকা শব্দ” হলো সেই ভাগ, যা training text-এর কোনো শব্দের সঙ্গে হুবহু মেলে। “সবচেয়ে লম্বা নকল” হলো training text-এ হুবহু পাওয়া সবচেয়ে লম্বা টুকরো। মানুষের লেখাতেও এই ভাগ .৮৯৫, কারণ test গল্পে নতুন শব্দ আছে। তাই এটি সঠিকতার মাপ নয়, শুধু একটি ইঙ্গিত।

টেবিল থেকে যা পড়া যায়, এক model-এর এক দফা পরীক্ষায়:

• একটি লিভার, দুই দিক: T বা top-p কমালে শব্দ বেশি ঠিক হয়, কিন্তু পুনরাবৃত্তিও বাড়ে। T = ১.৫-এ মাত্র ৬০% শব্দ মেলে, এটি বানানো শব্দে ভরা।
• Beam সবচেয়ে একঘেয়ে: গড় p .৭৮৮ মানুষের .৫০৮-এর চেয়ে অনেক ওপরে, আর training text থেকে নকলও সবচেয়ে লম্বা।
• Unique হারে কাছাকাছি: T = ০.৭ আর top-p ০.৯ মানুষের কাছে, তবে এই মিল ভালো গল্পের প্রমাণ নয়। নিচের নমুনা পড়ুন।
• অক্ষর-স্তরে penalty: Top-p ০.৯-এ rep ১.২ যোগ করলে পুনরাবৃত্তি সামান্য কমল, কিন্তু train-এ থাকা শব্দ .৯৩৯ থেকে .৮৯০-এ নামল। Greedy-তে নকলের দৈর্ঘ্য বাড়ল। অক্ষর তো ফিরে আসবেই, তাই penalty বেশিরভাগ অক্ষরকে সমানভাবে শাস্তি দেয়।

একই ছোট prompt-এ সত্যিকারের লেখা, seed ৪২, ১২০ অক্ষর, কোনো সম্পাদনা ছাড়া:

prompt: একদিন এক শিয়াল
greedy     : বললে, ‘আমার মতো কোনো করে দেখছি না।’ তখন সে বাঘ বললে, ‘আমি যে তো কি করতে পারব না।’ তখন সে বাঘ বললে, ‘আমাকে নেবে? আমার কাছ
beam 5     : বললে, ‘আচ্ছা, তাই হবে।’ শিয়াল বললে, ‘আচ্ছা, তাই হবে।’ শিয়াল বললে, ‘আচ্ছা, তাই হবে।’ বাঘ বললে, ‘আচ্ছা, তাই হবে।’ তারপর
T = 1.0    : নেমে যেতেও দেখতেই তো সেখানে নদীর জল খেতে হয়ে বাসা থেকে আবার দেখে চলতে আলতে পারে?’ সাবার চারটাকে ডাকাতি এমনি এক দজনা লুক
top-p 0.9  : নেমে যেতে পেলেই, তার সঙ্গে তাদের জল খেতে হয়ে বাসা থেকে বলল, ‘মামা, আমাকে বিয়ে দিয়ে দিয়েছিল।’ তখন সকলে পাথর মোটা গেল,

এখানে লাইন-ভাঙা স্পেস হিসেবে দেখানো হয়েছে, অক্ষর বদলানো হয়নি। Beam-এর লুপটি পড়ুন: ব্যাকরণ ঠিক, বানান ঠিক, কথা নেই। Sampling-এর লেখায় বৈচিত্র্য আছে, কিন্তু অর্থ নেই; সেটি model ছোট বলে, decoding দিয়ে সারবে না। আর ছাঁচে-বাঁধা রিভিউতে সব নিয়মই প্রায় একই ফল দেয়, কারণ সেখানে বণ্টন আগে থেকেই তীক্ষ্ণ: T = ০.৭-এ পাওয়া গেল “নকশিকাঁথা, ঢাকা থেকে সিলেট, ৬ দিনে পৌঁছেছে। রেটিং ৫। দামের তুলনায় ভালো, আবার কিনব।”

৯ · Seed, পুনরুৎপাদন আর API-র parameter

Sampling random, তাই seed ঠিক করলে আবার একই লেখা পাওয়ার কথা। কিন্তু কতটা? GPT-2-তে একই prompt-এ top-p ০.৯ দিয়ে সত্যিকারের পরীক্ষা, ১২ token:

~/bazarghar-dl$ uv run python gpt2_speed.py     # সত্যিকারের run; এখানে শুধু seed-এর অংশ
GPU seed 42 ক   ' for the stationery of 150,000 rupees and offers'
GPU seed 42 খ   ' for the stationery of 150,000 rupees and offers'
GPU seed 43     " cheap cigarettes, cigars and lighters. It's one of"
CPU seed 42 ক   ' solid Bakro meals, boiled in hot water, fresh,'
CPU seed 42 খ   ' solid Bakro meals, boiled in hot water, fresh,'
GPU seed 42 B=2 ' for the stationery of 150,000 rupees and offers'
greedy CPU == GPU: True ' a range of products including a range of handbags, jew'

একই ডিভাইসে একই seed একই লেখা দিল। কিন্তু একই seed CPU আর GPU-তে সম্পূর্ণ ভিন্ন লেখা দিল, কারণ দুই ডিভাইসের random number generator আলাদা। PyTorch-এর randomness নোটও (v2.15) বলে, release, platform বা CPU ও GPU-র মধ্যে পুরোপুরি একই ফলের নিশ্চয়তা নেই। Greedy-তে random নেই, তাই এই run-এ দুই ডিভাইসে একই ফল এসেছে। Batch-এ অন্য prompt যোগ করেও এখানে প্রথম সারি বদলায়নি, তবে সেটি একটি পর্যবেক্ষণ, নিশ্চয়তা নয়।

আরেকটি নীরব ফাঁদ, একই run থেকে:

generation_config.top_k = None  top_p = None  temperature = None
top_k না দেওয়া == top_k=50: True  == top_k=0: False

Config-এ None দেখাচ্ছে, অথচ do_sample=True লিখলে নীরবে top-k ৫০ চলে; v5.22.2-এর নথিও এই ডিফল্ট বলে। তাই “খাঁটি sampling” পেতে top_k=0 লিখতে হয়েছে। আর হুবহু ক্রমও এখান থেকে দেখা যায় (private একটি method দিয়ে ছাপানো, শুধু দেখার জন্য):

RepetitionPenaltyLogitsProcessor
NoRepeatNGramLogitsProcessor
TemperatureLogitsWarper
TopKLogitsWarper
TopPLogitsWarper
MinPLogitsWarper

Hosted API-তে নাম আর সীমা

আমাদের কাছে API key নেই, তাই এখানে কোনো hosted model চালানো হয়নি। নিচের টেবিল শুধু প্রতিটি সেবার নিজের নথি থেকে নেওয়া, ২০২৬ সালের নভেম্বরে নথিতে যেমন দেখা গেছে। এগুলো বদলায়, model-ভেদে আলাদা হয়, আর এটি কোনো তুলনা বা ক্রম নয়; ব্যবহারের আগে নিজের model-এর বর্তমান নথি দেখুন।

লক্ষ করুন, নতুন অনেক model-এ এই নিয়ন্ত্রণ কমেছে বা নেই। নথিগুলো কারণ স্পষ্ট করে না, তাই অনুমান করে লিখছি না। বাস্তব সিদ্ধান্ত একটাই: পুরোনো টিউটোরিয়ালের parameter চোখ বুজে পাঠাবেন না। একটি অনুরোধের আকার এমন হতে পারে; এটি চালানো হয়নি, শুধু আকার বোঝানোর জন্য নমুনা:

// নমুনা অনুরোধ (চালানো হয়নি)। Key কোডে লিখবেন না।
{"model": "<model-name>",
 "messages": [{"role": "user", "content": "শাড়ির ছোট বিবরণ লিখুন"}],
 "temperature": 0.7, "stop": ["\n\n"], "seed": 42}

কোন কাজে কোথা থেকে শুরু করবেন

নিচের টেবিল কোনো নিয়ম নয়, নিজের model-এ মাপার শুরুর জায়গা মাত্র; লাইব্রেরি নিজে চালালে তবেই এর সবগুলো হাতে থাকে:

১০ · AI-এর যুগে decoding — যা যাচাই করবেন

AI সহকারীরা decoding-এর কোড খুব দ্রুত লেখে, আর ভুলগুলোও দেখতে খুব বিশ্বাসযোগ্য। এই বিষয়ে যে ভুল বেশি দেখা যায়:

• Library-র version-এর নথিতে প্রতিটি argument খুঁজে দেখেছি
• ছোট একটি logit-এ top-p আর penalty হাতে মিলিয়েছি
• Support আর entropy ছাপিয়ে দেখেছি, শুধু চূড়ান্ত লেখা নয়
• model.eval() আর torch.no_grad() আছে, seed লেখা আছে
• বহু prompt আর বহু seed-এ মেপেছি, baseline হিসেবে greedy রেখেছি
• “Model বুঝে লিখেছে” দাবি করিনি; ভুল তথ্য আলাদা করে যাচাই করেছি