Few-shot prompting — উদাহরণ বাছাই আর তার প্রভাব

এই পর্বের সব মাপ লেখার সময়ের (নভেম্বর ২০২৬) একটি স্থানীয় run-এর, দুটি ছোট open model আর ২০০টি মন্তব্যে। কোনো hosted পণ্য এখানে চালানো হয়নি, আর এই সংখ্যা দিয়ে কোনো বড় model বা পণ্যের মান বিচার করা যায় না; বড় model-এ ফল আলাদা হতেই পারে। Prompt-এর মূল গঠন আগের পর্বে (পর্ব ৬০ · Prompt-এর গঠন); log-likelihood দিয়ে নম্বর দেওয়া আর CI পর্ব ৫৮-এ।

১ · Zero, one আর few-shot — নির্দেশের পাশে নমুনা

বাজারঘরের গুদামে নতুন একজন কর্মী এলেন। তাঁকে বলা হলো, “গ্রাহকের মন্তব্য পড়ে খুশি না অখুশি, খাতায় লিখবেন।” প্রথম দিন তিনি অনেক প্রশ্ন করবেন: “একটু খুশি” কোন ঘরে? শুধু প্রশ্ন করা মন্তব্য? এবার খাতার প্রথম পাতায় আগের চারটি মন্তব্য আর তার পাশে লেখা রায় দেখিয়ে দিলে কাজটি অনেক পরিষ্কার হয়। লেখার ছাঁচ, শব্দ বাছাই, কোন ধরনের লেখা কোন ঘরে, সব নমুনা থেকেই বোঝা যায়। কর্মীর মাথায় নতুন কোনো প্রশিক্ষণ হয়নি, শুধু সামনে নমুনা আছে।

LLM-এর prompt-এ ঠিক এটিই করা হয়। নির্দেশের সঙ্গে কোনো উদাহরণ না দিলে সেটি zero-shot; একটি দিলে one-shot; কয়েকটি দিলে few-shot. প্রতিটি উদাহরণ একটি input আর তার কাঙ্ক্ষিত output-এর জোড়া, যাকে demonstration বলে। Model-এর weight একটুও বদলায় না; বদলায় শুধু input-এর লেখা। তবু আচরণ বদলায়, আর এই ঘটনাকে বলে in-context learning (ICL).

নামগুলো জনপ্রিয় হয় GPT-3-এর প্রবন্ধে (Brown ও সহকর্মী, ২০২০, “Language Models are Few-Shot Learners”). লেখকেরা প্রায় ১৭,৫০০ কোটি parameter-এর model-এ দেখান, prompt-এ কয়েকটি উদাহরণ দিলে অনেক task-এ নির্ভুলতা বাড়ে, আর বড় model-এ এই লাভ বেশি। তাঁরা নিজেরাই সতর্ক ছিলেন: model কি সত্যিই নতুন task “শেখে”, নাকি pretraining-এ দেখা কোনো ছাঁচ চিনে নেয়, তা প্রবন্ধে খোলা প্রশ্ন হিসেবে রাখা। এই বিতর্ক এখনো চলছে, আর এই পর্বে আমরা দাবি না করে মাপব। Prompt-এর বাকি অংশ, যেমন নির্দেশ, প্রসঙ্গ আর ফরম্যাট, আগের পর্বে আলাদা করে দেখেছেন (পর্ব ৬০ · Prompt-এর গঠন)। LLM কীভাবে পরের token অনুমান করে, তার সহজ রূপ AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ।

পণ্যগুলোর নথি কী বলে

পরিচিত সহায়কগুলোর নির্মাতারা উদাহরণ নিয়ে নিজেদের অফিসিয়াল নথিতে কী লিখেছেন, তা নিচে, লেখার সময়ে (নভেম্বর ২০২৬) পড়া। নথি পরিবর্তন হতে পারে, তাই বর্তমান সংস্করণ নিজে পড়ে নিন। এটি কোনো তুলনা বা ক্রম নয়।

অভিন্ন কথাটি স্পষ্ট: উদাহরণ ফরম্যাট আর ভঙ্গি ঠিক করে, আর সব উদাহরণ একই ছাঁচে লিখতে হয়। মতভেদও আছে: একটি নথি সব সময় উদাহরণ দিতে বলে, আরেকটি reasoning model-এর জন্য zero-shot-কে ভালো বলে (ভাবনার প্রশ্ন ২)। Hosted পণ্যগুলো এখানে চালানো যায় না (API key নেই), তাই সব মাপ ছোট open model-এ।

২ · একটি 4-shot prompt — গঠন আর label-এর নম্বর

এই পর্বের task: YouTube-এর বাংলা নাটকের মন্তব্য ইতিবাচক না নেতিবাচক। ডেটা Sazzed ও Jayarathna-র (২০১৯) সংগ্রহ, Mendeley Data-তে CC BY 4.0 license-এ (DOI 10.17632/p6zc7krs37.4), যা পর্ব ৪২-এ পরিষ্কার করা হয়েছিল: ১০,৭০৯টি অনন্য মন্তব্য, প্রায় ২৮.৫% নেতিবাচক। প্রায় একই মন্তব্যগুলো একটি দলে রাখা। এখান থেকে নেওয়া হলো ২০০টি মন্তব্যের একটি স্থির test নমুনা, ১০০টি নেতিবাচক আর ১০০টি ইতিবাচক, যাতে “সবসময় ইতিবাচক” বললে ঠিক ০.৫০ আসে। উদাহরণ নেওয়া হয় আলাদা একটি ভাণ্ডার (pool) থেকে: test-এর কোনো দলের সদস্য সেখানে নেই, আর প্রতিটি মন্তব্য ৬০ token-এর মধ্যে, মোট ৬,০০৮টি। অনেক মন্তব্যে গালি আছে; পাতায় শুধু ভদ্রগুলো দেখানো, মাপা হয়েছে সবগুলোতে।

Prompt-এর ছাঁচ সব run-এ এক: প্রথমে এক লাইনের নির্দেশ, তারপর k-টি উদাহরণ “মন্তব্য: … / অনুভূতি: …” আকারে, শেষে নতুন মন্তব্য আর ফাঁকা “অনুভূতি:”। পুরোটা একটি user message, যা model-এর chat template-এ মোড়া হয় (পর্ব ৫৬)। উত্তর লিখতে দেওয়ার বদলে দুটি label শব্দের প্রতিটির log-likelihood মাপা হয়, ঠিক পর্ব ৫৮-এর multiple-choice-এর মতো। যার যোগফল বড়, সেটিই রায়। নিচের stepper-এ একটি 4-shot prompt ধাপে ধাপে জোড়া লাগানো হয়েছে; token-এর হিসাব Qwen2.5-এর tokenizer-এ সত্যিকারের গোনা।

দুটি label-এর সম্ভাবনা এখানে শুধু এই দুটির মধ্যে আবার ভাগ করা: p(ইতি) = e^a ÷ (e^a + e^b), যেখানে a আর b দুই label-এর log-likelihood. এটি softmax, আর এর মানে শুধু a − b-র ওপর নির্ভর করে। এই পার্থক্যটিকে বলব label-এর log-odds; §৮-এর calibration পুরোটা এর ওপর দাঁড়িয়ে।

৩ · সত্যিকারের run — 0, 1, 4 আর 8-shot

Model দুটি: Qwen/Qwen2.5-1.5B-Instruct (প্রায় ১৫০ কোটি parameter) আর তুলনার জন্য Qwen/Qwen2.5-0.5B-Instruct (প্রায় ৪৯ কোটি), দুটিই Apache 2.0, token ছাড়া নামানো, revision hash ধরে, ফাইলের sha256 মিলিয়ে। সব GPU-তে, bf16-এ: torch 2.15.0, transformers 5.22.2, Python 3.12, লেখার সময়ে। প্রতিটি অবস্থা একই ২০০টি মন্তব্যে। Random উদাহরণ পাঁচটি আলাদা seed-এ টানা, তাই প্রতিটি k-এর পাঁচটি সংখ্যা; similar উদাহরণ প্রতিটি মন্তব্যের জন্য আলাদা, ভাণ্ডারের সবচেয়ে কাছের k-টি (§৫)। Script-এর মূল অংশ আর আউটপুট, নিচে ছোট করে; সংখ্যাগুলো হুবহু।

@torch.no_grad()             # মূল অংশ, batch ছাড়া সহজ রূপে
def score(tok, model, prompts):       # প্রতিটি prompt-এর পরে দুটি label-এর log-likelihood
    lab = [tok(l, add_special_tokens=False)["input_ids"] for l in ["নেতিবাচক", "ইতিবাচক"]]
    out = []
    for p in prompts:
        pid = tok(p, add_special_tokens=False)["input_ids"]
        row = []
        for li in lab:
            ids = torch.tensor([pid + li]).cuda()
            h = model.model(input_ids=ids).last_hidden_state[0, len(pid) - 1:-1]
            lp = model.lm_head(h).float().log_softmax(-1)
            row.append(lp[torch.arange(len(li)), ids[0, len(pid):]].sum().item())
        out.append(row)
    return np.array(out)              # (n, 2); রায় = যে কলাম বড়

~/bazarghar-dl$ uv run python fewshot.py q15 sweep cuda    # সত্যিকারের run, GPU-তে
q15 k0                     acc=0.510 pred_pos=0.590 tokens= 151.3 secs=11.6
q15 rand_k1_s0             acc=0.540 pred_pos=0.060 tokens= 232.3 secs=15.9
q15 rand_k1_s4             acc=0.445 pred_pos=0.465 tokens= 211.3 secs=14.7
q15 sim_k1                 acc=0.560 pred_pos=0.070 tokens= 205.6 secs=14.3
q15 rand_k4_s0             acc=0.645 pred_pos=0.195 tokens= 421.3 secs=26.0
q15 rand_k4_s2             acc=0.500 pred_pos=1.000 tokens= 374.3 secs=24.0
q15 rand_k4_s4             acc=0.745 pred_pos=0.305 tokens= 407.3 secs=25.0
q15 sim_k4                 acc=0.870 pred_pos=0.500 tokens= 374.1 secs=25.1
q15 rand_k8_s1             acc=0.770 pred_pos=0.580 tokens= 618.3 secs=37.2
q15 rand_k8_s2             acc=0.500 pred_pos=1.000 tokens= 619.3 secs=37.2
q15 sim_k8                 acc=0.890 pred_pos=0.510 tokens= 602.6 secs=39.5
… (২১টির ১১টি লাইন দেখানো)
peak GPU memory allocated (GB): 3.74

কলামগুলো: acc ২০০টিতে নির্ভুলতা; pred_pos কত ভাগ মন্তব্যকে ইতিবাচক বলেছে (ঠিক উত্তরে ০.৫০); tokens গড় prompt-এর দৈর্ঘ্য; secs ২০০টি মন্তব্যের মোট সময়। পুরো ছবি এক সারণিতে, সঙ্গে দুটি সাধারণ তুলনা: একই ৬,০০৮টি সারিতে শেখানো TF-IDF + logistic regression (পর্ব ৪২-এর baseline, এখানে একই ২০০টিতে আবার মাপা), আর “সবচেয়ে কাছের k-টি মন্তব্যের label-এর ভোট”, যেখানে কোনো LLM নেই। “ইংরেজি label” কলামে মন্তব্য বাংলাই, শুধু নির্দেশ আর label শব্দ (positive/negative) ইংরেজিতে।

এবার CI নিজে হিসাব করুন। প্রতিটি অবস্থার ২০০টি ঠিক-ভুল সত্যিকারের run থেকে ফাইলে রাখা; কোড Wilson interval আর একই মন্তব্যের সূচকে জোড়া bootstrap দেয় (পর্ব ৫৮, মেশিন লার্নিং কোর্সের পর্ব ২১)।

import numpy as np
# runs_ok.txt: প্রতি লাইনে একটি অবস্থা, তারপর ২০০টি test মন্তব্যে ঠিক (1) না ভুল (0)
R = {}
for line in open("runs_ok.txt", encoding="utf-8"):
    name, bits = line.strip().split("|")
    R[name] = np.array([int(b) for b in bits])

def wilson(c, n, z=1.96):                      # ছোট n-এ normal-এর চেয়ে ভালো CI
    p = c / n; den = 1 + z * z / n
    mid = (p + z * z / (2 * n)) / den
    h = z * np.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / den
    return mid - h, mid + h

print(f"{'অবস্থা':16}{'acc':>6}  95% Wilson CI")
for k in (0, 1, 4, 8):
    names = ["0-shot"] if k == 0 else [f"random k={k} s{s}" for s in range(5)] + [f"similar k={k}"]
    for nm in names:
        if nm.endswith(("s1", "s2", "s3")): continue     # জায়গা বাঁচাতে s0 আর s4 দেখাই
        x = R[nm]; lo, hi = wilson(x.sum(), len(x))
        print(f"{nm:16}{x.mean():6.3f}  [{lo:.3f}, {hi:.3f}]")
    if k:
        a = [R[f"random k={k} s{s}"].mean() for s in range(5)]
        print(f"{'  ৫ seed-এর ছড়ানো':16} {min(a):.3f}–{max(a):.3f}, sd {np.std(a, ddof=1):.3f}")

rng = np.random.default_rng(0)                  # জোড়া bootstrap: একই মন্তব্যের সূচক দুই পাশে
def paired(a, b, B=10000):
    i = rng.integers(0, len(a), (B, len(a)))
    d = (a[i] - b[i]).mean(1)
    return (a - b).mean(), *np.percentile(d, [2.5, 97.5])
for a, b in (("similar k=4", "random k=4 s0"), ("random k=4 s0", "0-shot")):
    m, lo, hi = paired(R[a], R[b])
    print(f"{a} − {b}: {m:+.3f} [{lo:+.3f}, {hi:+.3f}]")

অবস্থা             acc  95% Wilson CI
0-shot           0.510  [0.441, 0.578]
random k=1 s0    0.540  [0.471, 0.608]
random k=1 s4    0.445  [0.378, 0.514]
similar k=1      0.560  [0.491, 0.627]
  ৫ seed-এর ছড়ানো 0.445–0.540, sd 0.039
random k=4 s0    0.645  [0.577, 0.708]
random k=4 s4    0.745  [0.680, 0.800]
similar k=4      0.870  [0.816, 0.910]
  ৫ seed-এর ছড়ানো 0.500–0.745, sd 0.098
random k=8 s0    0.710  [0.644, 0.768]
random k=8 s4    0.705  [0.638, 0.764]
similar k=8      0.890  [0.839, 0.926]
  ৫ seed-এর ছড়ানো 0.500–0.770, sd 0.105
similar k=4 − random k=4 s0: +0.225 [+0.145, +0.305]
random k=4 s0 − 0-shot: +0.135 [+0.030, +0.240]

৪ · উদাহরণ কী শেখায় — ফরম্যাট, না label-এর মানে?

Min ও সহকর্মীরা (২০২২, “Rethinking the Role of Demonstrations”) একটি সহজ পরীক্ষা করেন: উদাহরণের সঠিক label সরিয়ে random label বসানো। তাঁদের দেখা অনেক classification task-এ নির্ভুলতা সামান্যই কমে। তাঁদের ব্যাখ্যা, উদাহরণের বড় কাজ তিনটি: label-এর জগৎ দেখানো (উত্তর কোন শব্দগুলো), input-এর ধরন দেখানো, আর ফরম্যাট দেখানো। Wei ও সহকর্মীরা (২০২৩) আবার দেখান, label পুরো উল্টে দিলে বড় model প্রায়ই সেই উল্টো নিয়ম মানে। দুটি দাবিই নিজের model-এ মাপা যায়।

ফরম্যাট। একই 1.5B model-কে label না মেপে উত্তর লিখতে দেওয়া হলো (greedy, ১২টি নতুন token, ইংরেজি label শব্দ positive/negative). 0-shot-এ ২০০টি উত্তরের ১২৬টি “Positive”, ৬৮টি “Negative”, বাকিগুলো “The sentiment of…” ধরনের বাক্য: অর্থে ঠিক উত্তর ০.৭৪৫ (বড়-ছোট হাতের অক্ষর উপেক্ষা করে), কিন্তু label শব্দের হুবহু মিল ০/২০০. মাত্র একটি উদাহরণ দিতেই ২০০টির ২০০টি উত্তর হুবহু positive বা negative, ছোট হাতের অক্ষরে, উদাহরণের মতো। উদাহরণ প্রথমেই শেখাল উত্তর কেমন দেখতে হবে।

Label-এর মানে। ৮টি সুষম উদাহরণ তিন রূপে, তিনটি seed-এ: সঠিক label, পুরো উল্টানো label, আর random label (বাংলা label শব্দ, log-likelihood দিয়ে নম্বর):

Random label-এ পতন মাঝারি, একটি seed-এ কিছুই না: Min ও সহকর্মীদের পর্যবেক্ষণের সঙ্গে মেলে। কিন্তু পুরো উল্টালে নির্ভুলতা দৈবের নিচে নামল, AUC ০.৫-এর নিচে: model উদাহরণের উল্টো mapping কিছুটা মেনেছে, পুরোপুরি নয়। অর্থাৎ এই model-এ উদাহরণ ফরম্যাট আর label-এর মানে, দুটিই কিছুটা বহন করে। ছোট 0.5B-তে বাংলা label-এ তিন রূপেই রায় প্রায় সব “নেতিবাচক”, পার্থক্যই দেখা যায়নি। Model যত ছোট, নিজের ঝোঁক তত বেশি জেতে।

৫ · উদাহরণ বাছাই — random বনাম similar

পরীক্ষার আগে আগের বছরের প্রশ্ন দেখার সময় কেউ এলোমেলো প্রশ্ন দেখেন না; এবারের প্রশ্নের মতো প্রশ্ন খোঁজেন। Few-shot-এও একই ভাবনা: প্রতিটি নতুন মন্তব্যের জন্য ভাণ্ডার থেকে তার সবচেয়ে কাছের উদাহরণ বাছা। Liu ও সহকর্মীরা (২০২২, “What Makes Good In-Context Examples for GPT-3?”) sentence embedding-এর k-nearest neighbors দিয়ে উদাহরণ বেছে GPT-3-এ random-এর চেয়ে ভালো ফল পাওয়ার কথা জানান।

“কাছে” মাপার জন্য এখানে embedding model নয়, অক্ষরের character n-gram-এর TF-IDF আর cosine similarity (AI-এর ভিত্তি কোর্সের পর্ব ৬৭, পর্ব ৩৩)। বাংলা মন্তব্যে বানান এলোমেলো (“অসাধারন”, “অসাধারণ”), তাই অক্ষরের টুকরো শব্দের চেয়ে বেশি মেলে, আর এটি পাতার ভেতরেই চলে। Sentence embedding দিয়ে খোঁজা পর্ব ৬৭ · Sentence embedding আর semantic search-এ আসবে। নিচের কোডে ২০টি আসল মন্তব্যের ছোট ভাণ্ডার; একই prompt-builder random আর similar দুইভাবে চালায়। প্রথম চালাতে scikit-learn আসতে প্রায় ১০ সেকেন্ড লাগে।

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
# ২০টি সত্যিকারের মন্তব্য (Sazzed ও Jayarathna, CC BY 4.0), 0 = নেতিবাচক, 1 = ইতিবাচক
POOL = [("ফিনিশিং টা ভালো লাগলো না।", 0), ("যতসব ফালতু নাটক", 0),
 ("আসলে পোশাক টা ভালো ছিলো নাহ", 0), ("জোর করে হাসানোর চেষ্টা। ফালতু", 0),
 ("নাটকে একটু নেকামি বেশি হয়েছে,", 0), ("বাজে একটা নাটক!!", 0),
 ("ফালতু রকমের নাটক! সময়টাই নষ্ট", 0), ("সম্পূর্ণ ফালতু নাটক.....", 0),
 ("ঠিক ছিল কিন্তু এতোটা খারাপ অভিনয় না করলেই হতো", 0),
 ("নাটকের একটা ব্যার্থতা যে আগে থেকেই জানতাম কি হবে", 0),
 ("নাটকটা অনেক ভালো লাগলো", 1), ("ভালোই লাগছে নাটক", 1), ("খুব সুন্দর .", 1),
 ("শেষ টুকু খুব ভালো লাগছে", 1), ("গল্প টা সুন্দর ছিলো", 1),
 ("অসাধারন, পরের পর্ব চাই", 1), ("ভালো লাগার মত নাটক", 1),
 ("আনন্দ পেলাম এই নাটকটা দেখে", 1), ("অনেক ভাল লেগেছে।সব কিছু গোছানো ছিল", 1),
 ("ভাই এক কথায় অসাধারণ...", 1)]
LAB = ["নেতিবাচক", "ইতিবাচক"]
vec = TfidfVectorizer(analyzer="char_wb", ngram_range=(2, 4), sublinear_tf=True)
P = vec.fit_transform([t for t, _ in POOL])  # সারি L2-normalised: dot = cosine

def build(query, k=4, how="random", seed=0):
    if how == "random":
        idx = np.random.default_rng(seed).choice(len(POOL), k, replace=False)
    else:
        sim = (vec.transform([query]) @ P.T).toarray()[0]
        idx = np.argsort(-sim)[:k][::-1]          # সবচেয়ে কাছেরটি শেষে, প্রশ্নের ঠিক আগে
    lines = [f"মন্তব্য: {POOL[i][0]}\nঅনুভূতি: {LAB[POOL[i][1]]}" for i in idx]
    return idx, "\n\n".join(lines + [f"মন্তব্য: {query}\nঅনুভূতি:"])

q = "অভিনয় ভালো হয়নি"
for how in ("random", "similar"):
    idx, prompt = build(q, how=how)
    labs = [POOL[i][1] for i in idx]
    sims = (vec.transform([q]) @ P[idx].T).toarray()[0]
    print(f"[{how}] label: ইতি {sum(labs)}, নেতি {len(labs) - sum(labs)}",
          "| cosine:", np.round(sims, 2))
print("\n" + prompt)

[random] label: ইতি 2, নেতি 2 | cosine: [0.   0.03 0.03 0.12]
[similar] label: ইতি 1, নেতি 3 | cosine: [0.16 0.19 0.19 0.35]

মন্তব্য: নাটকে একটু নেকামি বেশি হয়েছে,
অনুভূতি: নেতিবাচক

মন্তব্য: নাটকটা অনেক ভালো লাগলো
অনুভূতি: ইতিবাচক

মন্তব্য: ফিনিশিং টা ভালো লাগলো না।
অনুভূতি: নেতিবাচক

মন্তব্য: ঠিক ছিল কিন্তু এতোটা খারাপ অভিনয় না করলেই হতো
অনুভূতি: নেতিবাচক

মন্তব্য: অভিনয় ভালো হয়নি
অনুভূতি:

Similar কেন এত ভালো: model কি নকল করছে?

§৩-এর সারণিতে similar 4-shot ০.৮৭০, আর LLM ছাড়া কাছের চারটির ভোট ০.৮৯০. দুটির মিল মাপলে: ২০০টির ১৪৮টিতে কাছের চারটির label সব একই, আর সেখানে 1.5B model ৯৬% ক্ষেত্রে সেই label-ই বলেছে। বাকি ৫২টিতে, যেখানে কাছের উদাহরণগুলো দুই ভাগ, model-এর নির্ভুলতা মাত্র ০.৬৫. অর্থাৎ বড় লাভটি মূলত k-NN ভোটের, model সেটি পড়ে নকল করছে। এটি খারাপ নয়, কিন্তু তখন প্রশ্ন ওঠে: একটি ১৫০ কোটি parameter-এর model দিয়ে ভোট গোনার দরকার কী?

দ্বিতীয় ফাঁদ: যমজ মন্তব্য। Test আর ভাণ্ডারে একই দলের কোনো মন্তব্য নেই, তবু ২০০টির ২৬টির সবচেয়ে কাছের প্রতিবেশীর cosine ০.৮-এর বেশি; YouTube-এ একই কথা বহুজন প্রায় একইভাবে লেখেন। Test-এর near-duplicate ভাণ্ডারে থাকলে similar বাছাই নম্বর ফুলিয়ে দেয়, যেমন পর্ব ৪২-এ classifier-এর বেলায় দেখেছিলেন। দল ধরে ভাগ না করলে ফাঁসটি আরও বড় হতো।

৬ · ক্রম — একই চারটি উদাহরণ, ২৪ রকম সাজানো

মানুষের কাছে চারটি উদাহরণ কোন ক্রমে দেওয়া হলো, তাতে খুব একটা আসে যায় না। একটি causal language model-এর কাছে আসে যায়: সে লেখাটি বাঁ থেকে ডানে পড়ে, আর প্রতিটি token-এর অনুমান আগের সব token-এর ওপর নির্ভর করে (পর্ব ৪৯)। Lu ও সহকর্মীরা (২০২২, “Fantastically Ordered Prompts and Where to Find Them”) দেখান, একই উদাহরণের শুধু ক্রম বদলে কিছু task-এ নির্ভুলতা প্রায় দৈব থেকে বেশ উঁচু পর্যন্ত ঘোরে। Zhao ও সহকর্মীরা (২০২১) GPT-3-এ recency bias দেখেন: শেষের দিকের উদাহরণের label model বেশি বলে।

আমরা §২-এর চারটি উদাহরণ (দুটি নেতিবাচক, দুটি ইতিবাচক) সম্ভাব্য সব ৪! = ২৪ ক্রমে সাজিয়ে 1.5B model-এ ২০০টি মন্তব্যে চালালাম। নিচের stepper একটি মন্তব্য দিয়ে শুরু করে পুরো ছবিতে যায়।

শেষ ধাপের ফল প্রথমে অবাক করে। একটি সম্ভাব্য ব্যাখ্যা: model label-এর ক্রমটিকেও একটি নকশা হিসেবে পড়ছে (দুটি নেতি, দুটি ইতি, তাহলে এবার…?)। আমরা এটি প্রমাণ করিনি; শুধু মেপেছি যে এই model-এ, এই চারটি উদাহরণে, দিকটি উল্টো। শিক্ষা হলো আকার: ক্রম একা ০.২১-এর মতো নির্ভুলতা সরাতে পারে, আর দিকটি model ধরে বদলায়। প্রতিকার: label পালা করে সাজানো, কয়েকটি ক্রমে চালিয়ে ফল মেলানো, আর ক্রম বেছে নিতে হলে আলাদা dev set ব্যবহার করা, test নয়।

৭ · Label-এর ভারসাম্য আর majority-label bias

বাজারের এক দোকানদারকে পরপর চারজন ক্রেতা বললেন “দাম বেশি”। পঞ্চম ক্রেতা কিছু বলার আগেই তিনি ধরে নেন, ইনিও দরাদরি করবেন। Model-এর ক্ষেত্রেও উদাহরণে যে label বেশি, সেটি বেশি বলার প্রবণতাকে Zhao ও সহকর্মীরা (২০২১) বলেন majority-label bias. §৩-এর ০.৫০০-এর seed-টি মনে আছে? তার চারটি উদাহরণই ইতিবাচক ছিল, আর model ২০০টির সবগুলোকেই ইতিবাচক বলেছিল; 8-shot-এ আটটিই ইতিবাচক এমন seed-এও একই ফল।

এবার এটি নিয়ন্ত্রিতভাবে মাপা হলো: ভাণ্ডার থেকে চারটি ইতিবাচক আর চারটি নেতিবাচক মন্তব্যের দুটি আলাদা সেট; প্রতিটি থেকে ০, ১, ২, ৩ বা ৪টি ইতিবাচক নিয়ে বাকিটা নেতিবাচক দিয়ে 4-shot prompt. নিচের কোডে সেই দশটি run-এর গোনা সংখ্যা।

import numpy as np
import matplotlib.pyplot as plt
# সত্যিকারের run, Qwen2.5-1.5B-Instruct: 4-shot prompt-এ কয়টি উদাহরণ ইতিবাচক,
# আর ২০০টি মন্তব্যের (১০০ ইতি, ১০০ নেতি) কয়টিকে model ইতিবাচক বলল
n_pos   = np.array([0, 1, 2, 3, 4])
set_a   = np.array([5, 18, 122, 169, 199])     # উদাহরণের এক সেট
set_b   = np.array([0, 49, 129, 83, 200])      # আরেক সেট
correct = {"set_a": [103, 108, 120, 119, 101], "set_b": [100, 117, 149, 143, 100]}

for name, pred in (("set_a", set_a), ("set_b", set_b)):
    print(name)
    for k, p, c in zip(n_pos, pred, correct[name]):
        bar = "#" * int(p // 20)
        print(f"  ইতি-উদাহরণ {k}/4 → ইতি-রায় {p:3d} {bar:10s} acc {c / 200:.3f}")
both = np.concatenate([set_a, set_b]) / 200
x = np.concatenate([n_pos, n_pos])
slope, icpt = np.polyfit(x, both, 1)
print(f"প্রতিটি বাড়তি ইতি-উদাহরণে ইতি-রায় গড়ে {slope:+.3f} (ভাগ)")
print("সম্পর্ক r =", round(np.corrcoef(x, both)[0, 1], 3))

fig, ax = plt.subplots(figsize=(5, 3.2))
ax.plot(n_pos, set_a / 200, "o-", label="demo set A")
ax.plot(n_pos, set_b / 200, "s--", label="demo set B")
ax.axhline(0.5, color="gray", lw=1, ls=":", label="true share (0.5)")
ax.set_xlabel("positive examples in the 4-shot prompt")
ax.set_ylabel("share predicted positive")
ax.set_xticks(n_pos); ax.legend(fontsize=8)
plt.show()

set_a
  ইতি-উদাহরণ 0/4 → ইতি-রায়   5            acc 0.515
  ইতি-উদাহরণ 1/4 → ইতি-রায়  18            acc 0.540
  ইতি-উদাহরণ 2/4 → ইতি-রায় 122 ######     acc 0.600
  ইতি-উদাহরণ 3/4 → ইতি-রায় 169 ########   acc 0.595
  ইতি-উদাহরণ 4/4 → ইতি-রায় 199 #########  acc 0.505
set_b
  ইতি-উদাহরণ 0/4 → ইতি-রায়   0            acc 0.500
  ইতি-উদাহরণ 1/4 → ইতি-রায়  49 ##         acc 0.585
  ইতি-উদাহরণ 2/4 → ইতি-রায় 129 ######     acc 0.745
  ইতি-উদাহরণ 3/4 → ইতি-রায়  83 ####       acc 0.715
  ইতি-উদাহরণ 4/4 → ইতি-রায় 200 ########## acc 0.500
প্রতিটি বাড়তি ইতি-উদাহরণে ইতি-রায় গড়ে +0.243 (ভাগ)
সম্পর্ক r = 0.932

৮ · Calibration — content-free input দিয়ে ঝোঁক মাপা

দাঁড়িপাল্লায় কিছু না রেখেই যদি কাঁটা ২০ গ্রাম দেখায়, দোকানদার প্রতিটি ওজন থেকে ২০ গ্রাম বাদ দেন। Zhao ও সহকর্মীদের “Calibrate Before Use” (২০২১) প্রবন্ধের ভাবনাও এমন। Prompt-এ আসল মন্তব্যের জায়গায় অর্থহীন একটি input বসান, যেমন “N/A”, ফাঁকা লেখা বা “[MASK]”; একে বলে content-free input. এখানে model-এর ঠিক উত্তর থাকার কথা নয়, তাই নিরপেক্ষ model দুই label-এ প্রায় ০.৫ দিত। যা দেয়, সেটিই prompt-এর নিজস্ব ঝোঁক, যার মধ্যে majority-label, recency আর common-token bias মিশে থাকে। প্রবন্ধে সংশোধনটি q = softmax(W p), যেখানে W = diag(p_cf)^−১: প্রতিটি label-এর সম্ভাবনাকে content-free সম্ভাবনা দিয়ে ভাগ করে আবার normalise. দুই label-এ এটি একটি বিয়োগ মাত্র:

calibrated log-odds = log-odds − log(p_cf ÷ (১ − p_cf))

এর নাম contextual calibration. লেখকেরা GPT-3-এ অনেক task-এ নির্ভুলতা বাড়া আর prompt-ভেদে ছড়ানো কমার কথা জানান। মেশিন লার্নিং কোর্সের পর্ব ২৬-এর Platt scaling-এর সঙ্গে পার্থক্য: এখানে কোনো লেবেল করা ডেটা লাগে না।

এবার একই হিসাব চারটি prompt-এ, নিজে চালিয়ে দেখুন। প্রতিটি মন্তব্যের log-odds সত্যিকারের run থেকে, দুই দশমিকে গোল করে রাখা। তৃতীয় নিয়মটি “batch-গড়”: লেবেলহীন সব input-এর গড় log-odds বিয়োগ, যা Zhou ও সহকর্মীদের batch calibration-এর (২০২৪) সরল রূপ।

import numpy as np
# logodds.txt: প্রথম লাইনে ২০০টি ঠিক label; পরে প্রতি prompt-এ তিনটি content-free
# input-এর log-odds আর ২০০টি মন্তব্যের log-odds (ইতি − নেতি), সত্যিকারের run থেকে
lines = open("logodds.txt", encoding="utf-8").read().split("\n")
y = np.array([int(c) for c in lines[0].split("|")[1]])

def wilson(c, n, z=1.96):
    p = c / n; den = 1 + z * z / n; mid = (p + z * z / (2 * n)) / den
    h = z * np.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / den
    return f"{p:.3f} [{mid - h:.2f}, {mid + h:.2f}]"

def sigmoid(x): return 1 / (1 + np.exp(-x))
for line in lines[1:]:
    if not line: continue
    name, cf, m = line.split("|")
    cf = np.array(cf.split(), dtype=float); m = np.array(m.split(), dtype=float)
    p_cf = sigmoid(cf).mean()                 # তিন content-free input-এর গড় p(ইতি)
    c = np.log(p_cf / (1 - p_cf))             # W = diag(1/p_cf) মানে এই log-odds বিয়োগ
    rules = {"কাঁচা": m, "content-free": m - c, "batch-গড়": m - m.mean()}
    print(f"{name}  p_cf(ইতি)={p_cf:.3f}")
    for rule, s in rules.items():
        pred = (s > 0).astype(int)
        print(f"   {rule:13s} acc {wilson((pred == y).sum(), len(y))}  ইতি-রায় {pred.sum():3d}")

0.5B EN 0-shot  p_cf(ইতি)=0.906
   কাঁচা         acc 0.525 [0.46, 0.59]  ইতি-রায় 191
   content-free  acc 0.645 [0.58, 0.71]  ইতি-রায়  67
   batch-গড়     acc 0.655 [0.59, 0.72]  ইতি-রায় 103
1.5B 4-shot all-pos  p_cf(ইতি)=0.856
   কাঁচা         acc 0.500 [0.43, 0.57]  ইতি-রায় 200
   content-free  acc 0.510 [0.44, 0.58]  ইতি-রায় 198
   batch-গড়     acc 0.645 [0.58, 0.71]  ইতি-রায়  99
1.5B 4-shot 1 pos  p_cf(ইতি)=0.078
   কাঁচা         acc 0.745 [0.68, 0.80]  ইতি-রায়  61
   content-free  acc 0.630 [0.56, 0.69]  ইতি-রায় 170
   batch-গড়     acc 0.805 [0.74, 0.85]  ইতি-রায়  89
1.5B 4-shot PPNN  p_cf(ইতি)=0.473
   কাঁচা         acc 0.750 [0.69, 0.80]  ইতি-রায় 132
   content-free  acc 0.710 [0.64, 0.77]  ইতি-রায় 142
   batch-গড়     acc 0.735 [0.67, 0.79]  ইতি-রায়  97

৯ · লম্বা prompt-এর দাম, আর কখন few-shot নয়

প্রতিটি উদাহরণ প্রতিটি অনুরোধে আবার পাঠানো হয়। আমাদের run-এ গড় prompt 0-shot-এ ১৫১ token, random 8-shot-এ ৬১৮ থেকে ৭০৭; ২০০টি মন্তব্যের সময় GPU-তে ১১.৬ সেকেন্ড থেকে প্রায় ৪০ সেকেন্ড। Hosted API-তে দাম সাধারণত input আর output token ধরে। মাসে N-টি মন্তব্য, গড় prompt T token, আর প্রতি ১০ লাখ input token-এর দাম P হলে:

মাসিক input খরচ = N × T × P ÷ ১০^৬

N = ১,০০,০০০ হলে 0-shot-এ ১.৫১ কোটি token, 8-shot-এ (T ≈ ৬৫০) ৬.৫ কোটি token, প্রায় ৪.৩ গুণ। P-এর মান নিজের পণ্যের বর্তমান মূল্যতালিকা থেকে বসান; দাম বদলায়, তাই এখানে লিখছি না। বাংলায় খরচ আরও বেশি: “নেতিবাচক” একাই ৮ token, “negative” ১ token (পর্ব ৪০)। দুটি কৌশল: এক, সব অনুরোধে একই উদাহরণ একই ক্রমে রাখলে prompt-এর শুরুটা হুবহু এক থাকে, যা অনেক পণ্যের prompt caching কাজে লাগাতে পারে। প্রতিটি মন্তব্যে আলাদা similar উদাহরণ দিলে সেই সুবিধা হারায়। Caching-এর হিসাব পর্ব ৬৫ · Token, খরচ আর latency-তে। দুই, কম কিন্তু ভালো উদাহরণ: আমাদের run-এ 4 থেকে 8-shot-এ যাওয়ার লাভ (random seed ০-এ +০.০৬৫) CI-তে শূন্য ছুঁয়েছে।

আর একটি সৎ প্রশ্ন: আদৌ LLM কেন? এই task-এ ৬,০০৮টি লেবেল করা মন্তব্য হাতে ছিল, আর তা দিয়ে শেখানো TF-IDF + logistic regression ২০০টিতে ০.৯৪৫, এক সেকেন্ডের ভগ্নাংশে, কোনো GPU ছাড়া। পর্ব ৪৮-এ fine-tuned Bangla BERT-ও একই জায়গায় থেমেছিল। Few-shot-এর আসল জায়গা তখন, যখন লেবেল করা ডেটা প্রায় নেই, task ঘন ঘন বদলায়, বা উত্তর একটি label-এর বেশি কিছু (ব্যাখ্যা, সারাংশ, নির্দিষ্ট ফরম্যাট)। হাজার হাজার লেবেল থাকলে আগে একটি সাধারণ classifier বা fine-tuning (পর্ব ৫৪, পর্ব ৫৫) মেপে দেখুন।

১০ · AI-এর যুগে — few-shot prompt বানাতে সহায়কের সাহায্য

AI সহায়ক মুহূর্তে কুড়িটি উদাহরণ আর scoring-এর কোড লিখে দেয়। এখানকার ভুল প্রায় কখনো ক্র্যাশ করে না; নম্বর শুধু একটু বদলায়। সহায়ক প্রবন্ধ বা পণ্যের পরামর্শও প্রায়ই স্মৃতি থেকে বলে; মূল উৎস নিজে খুলে দেখুন।

Few-shot prompt চালুর আগে চেকলিস্ট

• উদাহরণ আসল ডেটা থেকে, test-এর দল বাদ দিয়ে; label গুনে দেখেছি
• 0-shot, কয়েকটি k আর একটি সাধারণ baseline (TF-IDF বা কাছের-লেবেল) একই test-এ মেপেছি
• কয়েকটি seed আর ক্রমে চালিয়ে ছড়ানো আর CI লিখেছি
• Label শব্দ আর ভাষা বদলে দেখেছি; কোন label কত token, জানি
• Calibration dev set-এ বেছেছি, test-এ শুধু একবার
• Model-এর নাম, revision, prompt-এর পুরো ছাঁচ আর library-র version লিখে রেখেছি