Reasoning prompt — chain-of-thought, self-consistency আর ধাপে ধাপে চিন্তা

এই পর্বের সব desktop run GPU-তে, একবারে একটি job: torch 2.15.0, transformers 5.22.2, Python 3.12, লেখার সময়ে। Model দুটি ছোট, open আর Apache 2.0 লাইসেন্সের, token ছাড়া নামানো যায়: Qwen/Qwen2.5-1.5B-Instruct আর Qwen/Qwen2.5-0.5B-Instruct (Hugging Face-এ model card আছে)। প্রশ্নগুলো কোর্সের নিজের হাতে লেখা, বাজারঘরের ৩০টি পাটিগণিত প্রশ্ন, উত্তর কোডে হিসাব করা; কোনো আসল দোকানের তথ্য নয়। Command সহজ করে দেখানো, model-এর লেখা হুবহু, কাটা অংশে “…”। সব সংখ্যা একটি স্থানীয় run-এর; বড় পণ্য একই prompt-এ অনেক আলাদা আচরণ করতে পারে, তাই এগুলো দিয়ে কোনো পণ্যের মান বিচার করা যায় না। Prompt-এর গঠনের প্রাথমিক কথা পর্ব ৬০ · Prompt-এর গঠন-এ; মাপার পদ্ধতি পর্ব ৫৮-এ।

১ · খাতায় কাজ দেখানো — ধাপ লিখলে হিসাব কেন বদলায়

অঙ্ক পরীক্ষার খাতার কথা ভাবুন। “৮৫০ টাকায় ১০% ছাড়, তারপর ১২০ টাকা ডেলিভারি” মাথায় এক লাফে করলে ভুল হয় সহজে। খাতায় লিখলে আগে ৮৫ টাকা ছাড়, তারপর ৭৬৫, তারপর ৮৮৫; ভুল হলে কোন লাইনে, তা-ও দেখা যায়।

Language model-এর ক্ষেত্রেও একই রকম কিছু ঘটে, তবে কারণটি যন্ত্রের। পর্ব ৪৯-এ দেখেছেন, decoder model একবারে একটি token লেখে, আর প্রতিটি token-এর জন্য একই সংখ্যক layer চলে। মানে প্রতি token-এ হিসাবের পরিমাণ মোটামুটি স্থির। “উত্তর: ৮৮৫” সরাসরি লিখতে হলে পুরো হিসাব ওই কয়েকটি token-এর ভেতরে সারতে হয়। আগে “৮৫০ × ০.১০ = ৮৫” লিখলে দুটি জিনিস বদলায়। এক, বেশি token মানে বেশি হিসাবের ধাপ। দুই, মধ্যবর্তী ফল “৭৬৫” এখন context-এ লেখা, তাই পরের ধাপ সেটি পড়েই এগোয়, মনে রাখতে হয় না। Nye ও সহকর্মীরা (২০২১) একে scratchpad বলেছিলেন: model-কে মধ্যবর্তী হিসাব লিখতে শেখানো।

এই কৌশলের সাধারণ নাম chain-of-thought (CoT): উত্তরের আগে model-কে মধ্যবর্তী যুক্তির ধাপ লিখতে দেওয়া। Wei ও সহকর্মীরা (২০২২) দেখান, prompt-এ কয়েকটি উদাহরণ দিলে, যেখানে প্রতিটি উত্তরের আগে ধাপগুলো লেখা, বড় model অঙ্কের word problem-এ অনেক ভালো করে। তাঁদের রিপোর্ট অনুযায়ী এই সুবিধা মূলত খুব বড় model-এ দেখা গিয়েছিল, প্রায় ১০০ বিলিয়ন parameter-এর কাছাকাছি বা তার বেশি; ছোট model-এ CoT কখনো ফল খারাপও করেছিল (পর্ব ৫১-এর emergent দাবির আলোচনা মনে রাখুন)। এই পর্বে সেই প্রশ্নটিই ছোট model-এ নিজে মাপবেন।

একটি সতর্কতা। “Model ভাবছে” কথাটি সুবিধার জন্য বলা; যা ঘটে তা পরের token-এর অনুমান, যার কিছু token মধ্যবর্তী হিসাবের মতো দেখায়। লেখা ধাপ আসল কারণ কি না, তা §৭-এর প্রশ্ন। LLM-এর মূল কাজের ধারণা AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ; এখানে তার ওপর দাঁড়িয়ে এগোব।

২ · CoT-এর তিন রূপ, আর উত্তরটি খুঁজে বের করা

CoT prompt তিনভাবে লেখা হয়। প্রথম, few-shot CoT (Wei ও সহকর্মী, ২০২২): কয়েকটি প্রশ্ন, প্রতিটির সমাধান ধাপসহ, তারপর নতুন প্রশ্ন। উদাহরণ বাছাইয়ের সব প্রশ্ন পর্ব ৬১ · Few-shot prompting-এর বিষয়। দ্বিতীয়, zero-shot CoT (Kojima ও সহকর্মী, ২০২২): কোনো উদাহরণ নেই, শুধু একটি বাক্য, “Let's think step by step”. তাঁদের প্রবন্ধে InstructGPT (text-davinci-002) model-এ MultiArith নামের অঙ্কের set-এ নির্ভুলতা ১৭.৭% থেকে ৭৮.৭%, আর GSM8K-তে ১০.৪% থেকে ৪০.৭% হওয়ার কথা রিপোর্ট করা হয়েছিল। তাঁরা দুই ধাপে কাজ করেছিলেন: আগে যুক্তি লেখানো, তারপর আলাদা prompt-এ “উত্তরটি তাই …” বলে সংখ্যাটি বের করা। তৃতীয়, নির্দেশিত ধাপ: “আগে মোট দাম, তারপর ছাড়, তারপর ডেলিভারি হিসাব করুন”। এটি §৬-এর decomposition-এর কাছাকাছি।

এই পর্বের run-এ দুটি prompt, একই প্রশ্নে:

দুই prompt-এই উত্তরের একটি নির্দিষ্ট লাইন চাওয়া হয়েছে, কারণ CoT-এর লম্বা লেখায় অনেক সংখ্যা থাকে। কোনটি চূড়ান্ত উত্তর, তা বের করার কাজটিকে বলে answer extraction. এটি ভুল হলে model ঠিক হলেও নম্বর ভুল আসে, আর উল্টোটাও। বাংলায় কাজটি আরও জটিল: “১,০৮০”, “1080”, “১০৮০.০০ টাকা” তিনটি একই সংখ্যা (পর্ব ৫৮-এর normalisation মনে করুন)। নিচের extractor এই run-এ সত্যিই ব্যবহার করা হয়েছে। এটি শেষ “উত্তর:”-এর পরের প্রথম সংখ্যা নেয়; না পেলে পুরো লেখার শেষ সংখ্যা।

import re
BN = str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789")
NUM = re.compile(r"-?\d+(?:,\d{3})*(?:\.\d+)?")

def extract(text):
    """শেষ 'উত্তর:'-এর পরের প্রথম সংখ্যা; না পেলে লেখার শেষ সংখ্যা"""
    t = text.translate(BN)                        # বাংলা অঙ্ক → 0-9
    marks = list(re.finditer(r"(?:উত্তর|answer)\s*[:：]?", t, flags=re.I))
    if marks:
        after = NUM.findall(t[marks[-1].end():])
        if after:
            return float(after[0].replace(",", ""))
    nums = NUM.findall(t)
    return float(nums[-1].replace(",", "")) if nums else None

TESTS = [
    ("উত্তর: ১,০৮০ টাকা", 1080),
    ("১২০০ × ০.৮৫ = ১০২০, সঙ্গে ৬০ টাকা ডেলিভারি = ১০৮০ টাকা", 1080),
    ("Answer: 1,710 taka", 1710),
    ("মোট দাম ৫৫০ টাকা। ডেলিভারি ফ্রি, কারণ অর্ডার ৫০০ টাকার বেশি।", 550),
    ("উত্তর: ছাড়ের পর ১০২০, ডেলিভারিসহ ১০৮০", 1080),
    ("উত্তর: 1080.00", 1080),
    ("দুঃখিত, হিসাবটি করা গেল না।", 1080),
]
for text, gold in TESTS:
    p = extract(text)
    mark = "ঠিক" if p is not None and abs(p - gold) < 1e-9 else "ভুল"
    print(f"{mark:4} pred={p!s:7} | {text}")

ঠিক  pred=1080.0  | উত্তর: ১,০৮০ টাকা
ঠিক  pred=1080.0  | ১২০০ × ০.৮৫ = ১০২০, সঙ্গে ৬০ টাকা ডেলিভারি = ১০৮০ টাকা
ঠিক  pred=1710.0  | Answer: 1,710 taka
ভুল  pred=500.0   | মোট দাম ৫৫০ টাকা। ডেলিভারি ফ্রি, কারণ অর্ডার ৫০০ টাকার বেশি।
ভুল  pred=1020.0  | উত্তর: ছাড়ের পর ১০২০, ডেলিভারিসহ ১০৮০
ঠিক  pred=1080.0  | উত্তর: 1080.00
ভুল  pred=None    | দুঃখিত, হিসাবটি করা গেল না।

৩ · সত্যিকারের run — direct বনাম CoT, দুটি ছোট model

প্রশ্নগুলোতে আছে শতাংশ ছাড়, পরপর দুটি ছাড়, ছাড়ের সীমা, ফ্রি-ডেলিভারির সীমা, জেলাভেদে আর ওজনভেদে চার্জ, লাভের শতাংশ; কিছু সংখ্যা বাংলা অঙ্কে, একটিতে কমা। তুলনার জন্য প্রতিটির ইংরেজি অনুবাদও আছে। Decoding: direct আর CoT দুটিই greedy, direct-এ সর্বোচ্চ ২৪টি নতুন token, CoT-এ ৫১২. Chat template-এ শুধু user বার্তা, তাই Qwen-এর ডিফল্ট system বার্তা যোগ হয়েছে (পর্ব ৫২)।

$ python run.py q15 direct_bn,cot_bn,direct_en,cot_en,sc_bn     # সত্যিকারের run, ছোট করা
q15 direct_bn|greedy acc=0.100 mean_out_tok=  11.6 cut=1 (3s)
q15 cot_bn|greedy    acc=0.133 mean_out_tok= 331.5 cut=6 (39s)
q15 direct_en|greedy acc=0.133 mean_out_tok=   7.2 cut=0 (40s)
q15 cot_en|greedy    acc=0.833 mean_out_tok= 248.7 cut=0 (64s)
q15 sc_bn|s0         acc=0.133 mean_out_tok= 355.6 cut=10 (107s)
…
q15 sc_bn|s9         acc=0.133 mean_out_tok= 331.9 cut=3 (456s)
peak GPU alloc MB: 3389 | torch 2.15.0+cu132 | total 456s

cut মানে কতটি উত্তর token-এর সীমায় কেটে গেছে। দুই model-এর পুরো ছবি (৩০টি প্রশ্ন, প্রশ্ন ধরে bootstrap-এর ৯৫% CI):

তিনটি জিনিস চোখে পড়ে। এক, ইংরেজিতে CoT-এর লাফ বিশাল আর দৈবের নয়: ১.৫B-এ ২১টি প্রশ্নে শুধু CoT ঠিক, একটিতেও শুধু direct নয় (§৫)। দুই, বাংলায় একই model আর একই প্রশ্নে CoT প্রায় কিছুই করেনি; পার্থক্য CI-এর ভেতরে। তিন, ০.৫B বাংলা direct-এ ২৫টি উত্তর ২৪ token-এ কেটে গেছে, অর্থাৎ নির্দেশ মানেনি। এখানে ভাষার প্রভাব CoT-এর চেয়েও বড়। Input-এর দামও আলাদা: একই অর্থের CoT prompt বাংলায় গড়ে ১৯৯.৯ token, ইংরেজিতে ৮৭.২ (পর্ব ৪০)।

ভুলের নমুনা, হুবহু

নিচের লেখাগুলো model-এর output, সম্পাদনা ছাড়া; লম্বা অংশ “…” দিয়ে কাটা। Decoding greedy.

# ১.৫B, বাংলা, প্রশ্ন ৭ (রাজশাহী, ৮৫০ টাকা, ১০% ছাড়; ঠিক উত্তর ৮৮৫)
আমি আপনাকে সহায়তা করতে পারি না যদিও আমি এই অনুচ্ছেদের সংজ্ঞানুসারে কোনও সঠিক সমাধান দেবো না। …
উত্তর: নেই

# ০.৫B, বাংলা, প্রশ্ন ১৪ (পার্সেলের ওজন; ঠিক উত্তর ১২০) — ৫১২ token-এ কাটা
উত্তর: 120

ভার্গের একটি পার্সেল আছে, তবে এই পার্সেলের একটি ডেলিভারি ছিল ৩.৫ কেজি। … এটি একটি পার্সেল থাকে। এটি একটি পার্সেল থাকে। এটি একটি পার্সেল থাকে। …

# ১.৫B, ইংরেজি, প্রশ্ন ৭ (ঠিক উত্তর ৮৮৫) — শেষ অংশ
     - If delivered within Dhaka: Total payment = Discounted price + Delivery fee = 765 + 60 = 825 taka.
     - If delivered outside Dhaka: Total payment = Discounted price + Delivery fee = 765 + 120 = 885 taka.
…
Answer: 825 or 885

প্রথমটিতে সাধারণ অঙ্কে model সাহায্য করতে অস্বীকার করেছে। দ্বিতীয়টিতে প্রথম লাইনেই উত্তর ঠিক, তারপর অর্থহীন পুনরাবৃত্তি; উত্তর “ঠিক” গোনা হলো, অথচ কোনো ধাপ সেটিকে সমর্থন করে না (§৭)। তৃতীয়টিতে হিসাব ঠিক, কিন্তু “রাজশাহী ঢাকার বাইরে” সিদ্ধান্তটি না নিয়ে দুটি উত্তর; extractor প্রথমটি, ৮২৫, নিয়েছে।

৪ · Self-consistency — অনেক পথ, একটি ভোট

Greedy CoT একটি পথ লেখে। পথের শুরুতে একটি ভুল হলে পুরো উত্তর ভুল। Wang ও সহকর্মীদের (২০২২) self-consistency বলে: একই CoT prompt কয়েকবার চালান, প্রতিবার temperature দিয়ে sample করে (পর্ব ৫০), তারপর চূড়ান্ত উত্তরগুলোর মধ্যে সবচেয়ে বেশিবার আসা উত্তরটি নিন, অর্থাৎ majority vote. প্রবন্ধে কয়েকটি বড় model-এ GSM8K-সহ অঙ্কের set-এ greedy CoT-এর চেয়ে স্পষ্ট উন্নতি রিপোর্ট করা হয়েছিল।

এই পর্বের run-এ প্রতিটি প্রশ্নে ১০টি নমুনা: temperature ০.৭, top-p ০.৯৫, seed ১০০০ থেকে ১০০৯ (প্রতিটি নমুনা-ক্রমে একটি), সর্বোচ্চ ৫১২ token. k = ৫ মানে প্রথম ৫টি নমুনার ভোট। সমান ভোট হলে আগে আসা উত্তরটি জেতে; নিয়মটি আগে থেকে লিখে রাখা দরকার, কারণ ছোট set-এ টাই কম নয়।

এবার চারটি অবস্থার ৩০ × ১০টি নমুনা নিজে বিশ্লেষণ করুন। নিচের CSV-তে প্রতিটি নমুনার বের করা উত্তর (ফাঁকা = কোনো সংখ্যা পাওয়া যায়নি)। কোড k = ১, ৫, ১০-এর ভোট, প্রশ্ন ধরে bootstrap CI, আর ১০টি থেকে এলোমেলো k-টি বেছে গড় accuracy-র রেখা আঁকে। প্রথম চালানোয় pandas আর matplotlib লোড হতে কয়েক সেকেন্ড লাগে।

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from collections import Counter
df = pd.read_csv("sc_samples.csv")            # সত্যিকারের run: প্রতি প্রশ্নে ১০টি CoT নমুনার বের করা উত্তর
S = [f"s{i}" for i in range(10)]
rng = np.random.default_rng(42)

def vote(answers):                            # সমান ভোটে আগে আসা উত্তর জেতে
    a = [x for x in answers if not np.isnan(x)]
    return Counter(a).most_common(1)[0][0] if a else np.nan

def boot_ci(ok, B=2000):                      # প্রশ্ন ধরে bootstrap
    idx = rng.integers(0, len(ok), (B, len(ok)))
    return np.percentile(ok[idx].mean(1), [2.5, 97.5])

fig, ax = plt.subplots(figsize=(5, 3.2))
for model, g in df.groupby("model", sort=False):
    X, gold = g[S].to_numpy(), g["gold"].to_numpy()
    for k in (1, 5, 10):
        ok = np.array([vote(row[:k]) == y for row, y in zip(X, gold)], float)
        lo, hi = boot_ci(ok)
        print(f"{model} k={k:2d}  accuracy {ok.mean():.3f}  CI [{lo:.2f}, {hi:.2f}]")
    curve = []                                # k-টি নমুনা এলোমেলো বেছে গড় accuracy
    for k in range(1, 11):
        hits = [np.mean([vote(row[rng.choice(10, k, replace=False)]) == y
                         for row, y in zip(X, gold)]) for _ in range(50)]
        curve.append(np.mean(hits))
    ax.plot(range(1, 11), curve, marker="o", label=model)
    print(f"{model} এলোমেলো k: k=1 {curve[0]:.3f}, k=3 {curve[2]:.3f}, k=10 {curve[9]:.3f}")
ax.set_xlabel("samples per question (k)"); ax.set_ylabel("majority-vote accuracy")
ax.set_title("Self-consistency, 30 Bazarghar problems"); ax.legend(fontsize=8)
plt.show()

1.5B-bn k= 1  accuracy 0.133  CI [0.03, 0.27]
1.5B-bn k= 5  accuracy 0.133  CI [0.03, 0.27]
1.5B-bn k=10  accuracy 0.200  CI [0.07, 0.37]
1.5B-bn এলোমেলো k: k=1 0.109, k=3 0.112, k=10 0.199
1.5B-en k= 1  accuracy 0.867  CI [0.73, 0.97]
1.5B-en k= 5  accuracy 0.900  CI [0.80, 1.00]
1.5B-en k=10  accuracy 0.800  CI [0.63, 0.93]
1.5B-en এলোমেলো k: k=1 0.762, k=3 0.802, k=10 0.815
0.5B-bn k= 1  accuracy 0.000  CI [0.00, 0.00]
0.5B-bn k= 5  accuracy 0.000  CI [0.00, 0.00]
0.5B-bn k=10  accuracy 0.000  CI [0.00, 0.00]
0.5B-bn এলোমেলো k: k=1 0.000, k=3 0.000, k=10 0.000
0.5B-en k= 1  accuracy 0.433  CI [0.27, 0.60]
0.5B-en k= 5  accuracy 0.533  CI [0.37, 0.70]
0.5B-en k=10  accuracy 0.700  CI [0.53, 0.87]
0.5B-en এলোমেলো k: k=1 0.475, k=3 0.550, k=10 0.681

৫ · Token-এর দাম — accuracy কত টাকায় কেনা হলো

প্রতিটি output token-এর দাম আর সময় আছে (পর্ব ৬৫ · Token, খরচ আর latency). তুলনার একটি সহজ মাপ হলো প্রতি সঠিক উত্তরে token: গড় output token ÷ accuracy. Direct-এ ১০ token আর accuracy ০.৫০ হলে একটি সঠিক উত্তরের পেছনে গড়ে ২০ token. সঙ্গে জোড়া তুলনা (paired comparison): একই প্রশ্নে দুই পদ্ধতির ঠিক-ভুল পাশাপাশি রেখে b = শুধু নতুনটি ঠিক, c = শুধু পুরনোটি ঠিক, আর exact McNemar test (মেশিন লার্নিং কোর্সের পর্ব ২২)। নিচের CSV-তে প্রতিটি প্রশ্নে চার পদ্ধতির ফল আর token; self-consistency-র token মানে k-টি নমুনার যোগফল।

import numpy as np
import pandas as pd
from scipy.stats import binomtest
pd.set_option("display.width", 70)
df = pd.read_csv("runs_tok.csv")              # সত্যিকারের run: প্রতি প্রশ্নে ঠিক কি না, আর output token
rng = np.random.default_rng(42)

t = (df.groupby(["model", "method"], sort=False)
       .agg(acc=("ok", "mean"), out_tok=("out_tok", "mean")).round(3))
t["tok_per_ok"] = (t["out_tok"] / t["acc"].where(t["acc"] > 0)).round(0)
print(t.to_string(), "\n")

for model, g in df.groupby("model", sort=False):     # একই প্রশ্নে জোড়া তুলনা
    w = g.pivot(index="item", columns="method", values="ok")
    for a, b in (("direct", "cot"), ("cot", "sc_k10")):
        d = (w[b] - w[a]).to_numpy()
        only_b, only_a = int((d > 0).sum()), int((d < 0).sum())
        p = binomtest(only_b, only_b + only_a, 0.5).pvalue if only_a + only_b else 1.0
        boots = d[rng.integers(0, len(d), (4000, len(d)))].mean(1)
        lo, hi = np.percentile(boots, [2.5, 97.5])
        print(f"{model} {b}−{a}: {d.mean():+.3f} CI [{lo:+.2f}, {hi:+.2f}]"
              f" b={only_b} c={only_a} p={p:.2g}")

                  acc   out_tok  tok_per_ok
model   method                             
1.5B-bn direct  0.100    11.567       116.0
        cot     0.133   331.467      2492.0
        sc_k5   0.133  1842.967     13857.0
        sc_k10  0.200  3563.067     17815.0
1.5B-en direct  0.133     7.200        54.0
        cot     0.833   248.700       299.0
        sc_k5   0.900  1206.700      1341.0
        sc_k10  0.800  2433.767      3042.0
0.5B-bn direct  0.000    20.767         NaN
        cot     0.067   246.700      3682.0
        sc_k5   0.000  1535.567         NaN
        sc_k10  0.000  3072.300         NaN
0.5B-en direct  0.067     7.400       110.0
        cot     0.633   275.033       434.0
        sc_k5   0.533  1470.700      2759.0
        sc_k10  0.700  2950.700      4215.0 

1.5B-bn cot−direct: +0.033 CI [-0.13, +0.20] b=4 c=3 p=1
1.5B-bn sc_k10−cot: +0.067 CI [-0.10, +0.23] b=5 c=3 p=0.73
1.5B-en cot−direct: +0.700 CI [+0.53, +0.87] b=21 c=0 p=9.5e-07
1.5B-en sc_k10−cot: -0.033 CI [-0.17, +0.07] b=1 c=2 p=1
0.5B-bn cot−direct: +0.067 CI [+0.00, +0.17] b=2 c=0 p=0.5
0.5B-bn sc_k10−cot: -0.067 CI [-0.17, +0.00] b=0 c=2 p=0.5
0.5B-en cot−direct: +0.567 CI [+0.40, +0.73] b=17 c=0 p=1.5e-05
0.5B-en sc_k10−cot: +0.067 CI [-0.10, +0.23] b=4 c=2 p=0.69

খরচের অঙ্কটি সাধারণ সূত্রে লেখা যায়। প্রতিটি প্রশ্নে input token I, output token O, আর প্রতি দশ লাখ token-এ দাম যথাক্রমে Q আর P টাকা হলে n প্রশ্নের খরচ

খরচ = n × (I × Q + k × O × P) ÷ ১০^৬

যেখানে k = ১ সাধারণ CoT-এ, আর self-consistency-তে নমুনার সংখ্যা (প্রতিটি নমুনা আলাদা request হলে input-ও k বার গোনা হয়)। দাম বদলায়, তাই এখানে সংখ্যা নেই; নিজের দাম বসান (অনুশীলন ১)।

৬ · Least-to-most — বড় প্রশ্ন ছোট প্রশ্নে ভাঙা

CoT model-কে ধাপ লিখতে বলে, কিন্তু কোন ধাপ, কোন ক্রমে, তা model-এর ওপর ছেড়ে দেয়। Least-to-most prompting (Zhou ও সহকর্মী, ২০২২) কাজটি দুই ভাগে করে। প্রথম ভাগে model বা মানুষ প্রশ্নটিকে ছোট উপ-প্রশ্নে ভাঙে, সহজ থেকে কঠিন ক্রমে। দ্বিতীয় ভাগে উপ-প্রশ্নগুলো একে একে সমাধান হয়, আর প্রতিটির উত্তর পরের উপ-প্রশ্নের prompt-এ যোগ হয়। প্রবন্ধে দেখানো হয়েছিল, উদাহরণের চেয়ে কঠিন প্রশ্নে, যেমন SCAN নামের নির্দেশ-অনুবাদের task-এ, এটি সাধারণ CoT-এর চেয়ে ভালোভাবে সাধারণীকরণ করে; বড় model-এ, তাঁদের পরীক্ষায়।

বাজারঘরের একটি কঠিন অর্ডারে চারটি নিয়ম একসঙ্গে: ৩টিতে ছাড়, ছাড়ের সীমা, ফ্রি-ডেলিভারির সীমা আর ঢাকার বাইরের চার্জ। §৩-এ দেখেছেন, ছোট model এমন প্রশ্নে নিয়ম বাদ দেয় বা উল্টো খাটায়। নিচের কোড কোনো model ছাড়াই, সাধারণ Python-এ, দেখায় একটি model-এর কোন ধাপগুলো কোন ক্রমে মানা উচিত। প্রতিটি ফাংশন একটি উপ-প্রশ্ন।

# প্রশ্ন: ৩টি মধুর বয়াম, প্রতিটি ৬০০ টাকা; ৩টি কিনলে মোট দামে ১৫% ছাড়, তবে ছাড় সর্বোচ্চ ২৫০ টাকা।
# ১৭০০ টাকার কম অর্ডারে ডেলিভারি ৮০ টাকা, নইলে ফ্রি। ঢাকার বাইরে হলে আরও ৪০ টাকা। গ্রাহক খুলনায়।
order = {"qty": 3, "unit": 600, "pct": 15, "cap": 250, "free_from": 1700,
         "fee": 80, "outside_extra": 40, "outside_dhaka": True}

def subtotal(o):          return o["qty"] * o["unit"]
def discount(o, sub):     return min(sub * o["pct"] / 100, o["cap"]) if o["qty"] >= 3 else 0
def delivery(o, after):   return (0 if after >= o["free_from"] else o["fee"]) + (o["outside_extra"] if o["outside_dhaka"] else 0)

steps = []                                     # least-to-most: ছোট প্রশ্ন আগে, তার উত্তর পরের প্রশ্নে
sub = subtotal(order);              steps.append(("ছাড়ের আগে মোট দাম কত?", sub))
d = discount(order, sub);           steps.append(("ছাড় কত (সীমা মেনে)?", d))
after = sub - d;                    steps.append(("ছাড়ের পর দাম কত?", after))
fee = delivery(order, after);       steps.append(("ডেলিভারি কত (ফ্রি-সীমা ছাড়ের পরের দামে)?", fee))
total = after + fee;                steps.append(("গ্রাহক মোট কত দেবেন?", total))
for i, (q, a) in enumerate(steps, 1):
    print(f"ধাপ {i}: {q:42} → {a:g}")

# একটি সাধারণ ভুল: ফ্রি-সীমা ছাড়ের আগের দামে দেখা
wrong = after + delivery(order, sub)
print(f"\nভুল ক্রমে (ফ্রি-সীমা ছাড়ের আগের দামে): {wrong:g}  বনাম ঠিক: {total:g}")

ধাপ 1: ছাড়ের আগে মোট দাম কত?                     → 1800
ধাপ 2: ছাড় কত (সীমা মেনে)?                       → 250
ধাপ 3: ছাড়ের পর দাম কত?                          → 1550
ধাপ 4: ডেলিভারি কত (ফ্রি-সীমা ছাড়ের পরের দামে)?  → 120
ধাপ 5: গ্রাহক মোট কত দেবেন?                       → 1670

ভুল ক্রমে (ফ্রি-সীমা ছাড়ের আগের দামে): 1590  বনাম ঠিক: 1670

শিক্ষা: যে হিসাবের নিয়ম আপনি জানেন, তা model-কে আন্দাজ করতে দেবেন না। এক পথ, prompt-এ উপ-প্রশ্নগুলো ক্রমসহ লিখে দেওয়া। আরও নিরাপদ পথ, model দিয়ে শুধু অর্ডারের সংখ্যাগুলো বের করা (পর্ব ৬২ · Structured output-এর JSON), আর হিসাবটি উপরের মতো কোডে করা। Gao ও সহকর্মীদের PAL (২০২২) আর Chen ও সহকর্মীদের Program of Thoughts (২০২২) এই ভাবনারই প্রবন্ধ: model যুক্তি লেখে কোড হিসেবে, আর Python interpreter হিসাবটি করে।

৭ · লেখা যুক্তি কি আসল কারণ? — faithfulness-এর প্রশ্ন

CoT দেখতে ব্যাখ্যার মতো, কিন্তু একে “model কেন এই উত্তর দিল”-র প্রমাণ ধরা যায় না। Turpin ও সহকর্মীরা (২০২৩) few-shot উদাহরণে একটি লুকানো ঝোঁক ঢুকিয়েছিলেন, যেমন সব উদাহরণের সঠিক উত্তর বিকল্প “(A)”-তে রাখা। তাঁদের রিপোর্ট অনুযায়ী model-গুলো প্রায়ই তখন “(A)”-র দিকে ঝুঁকেছে, আর তার পক্ষে বিশ্বাসযোগ্য CoT লিখেছে, কিন্তু ব্যাখ্যায় ঝোঁকটির কথা উল্লেখ করেনি। BIG-Bench Hard-এর ১৩টি task-এ নির্ভুলতা সর্বোচ্চ প্রায় ৩৬% পর্যন্ত কমেছিল বলে তাঁরা লেখেন। অর্থাৎ লেখা যুক্তি আর উত্তরের আসল কারণ আলাদা হতে পারে। একে বলে CoT-এর faithfulness-এর সমস্যা।

Lanham ও সহকর্মীরা (২০২৩) উল্টো দিক থেকে মেপেছিলেন: CoT মাঝপথে কেটে দিলে বা ভেতরে ভুল ঢুকিয়ে দিলে উত্তর কতটা বদলায়। উত্তর না বদলালে বোঝা যায়, লেখা ধাপের ওপর উত্তর তেমন নির্ভর করছিল না। তাঁদের রিপোর্টে task ভেদে নির্ভরতা অনেক আলাদা ছিল। §৩-এর ০.৫B উত্তরটিও মনে করুন: শেষ সংখ্যা ঠিক, অথচ কোনো ধাপ তাকে সমর্থন করে না।

৮ · Reasoning model আর “thinking” সেটিং — ছয়টি পণ্যের নথি

২০২৪ সাল থেকে reasoning model এসেছে: training-এর সময়েই, মূলত reinforcement learning দিয়ে, উত্তরের আগে লম্বা মধ্যবর্তী লেখা তৈরি করতে শেখানো model; DeepSeek-R1-এর প্রবন্ধ (২০২৫) এর একটি খোলা বিবরণ দেয়। CoT তখন prompt-এর কৌশল নয়, একটি সেটিং। “Thinking” নথির ভাষা; আসলে এটি উত্তরের আগে বাড়তি token.

মূল ধারণা সবার এক। এক, একটি সেটিং দিয়ে বাড়তি লেখার মাত্রা ঠিক হয় (effort বা level বা budget). দুই, সেই লেখার পুরোটা আপনি সাধারণত দেখেন না; কেউ সারাংশ দেয়, কেউ সংকেতায়িত (encrypted) রূপ, কেউ পুরো লেখা। তিন, না দেখলেও সেই token-এর দাম দিতে হয়, আর সেগুলো output-এর সীমার ভেতরে গোনা হয়। নিচের সারণির সব তথ্য প্রতিটি প্রতিষ্ঠানের নিজের developer নথি থেকে, লেখার সময়ে (নভেম্বর ২০২৬) পড়া; নথি প্রায়ই বদলায়, তাই পরিবর্তন হতে পারে। Model ভেদে নিয়ম আলাদা, তাই নিজের model-এর পাতা দেখে নিন। এটি মান তুলনা নয়।

তিনটি ব্যবহারিক কথা। প্রথম, খরচ লুকানো থাকতে পারে; Anthropic-এর নথি সরাসরি লেখে, বিলের output token দেখা token-এর সঙ্গে মিলবে না। তাই খরচ মাপুন usage-এর ঘর থেকে, লেখা গুনে নয় (পর্ব ৬৫ · Token, খরচ আর latency). দ্বিতীয়, সীমা ছোট দিলে উত্তরই হারাতে পারে। OpenAI-এর নথি সতর্ক করে, max_output_tokens ফুরিয়ে গেলে উত্তর “incomplete” হয়, দেখা যায় এমন লেখা না-ও থাকতে পারে। তৃতীয়, বহু ধাপের কথোপকথনে কিছু API চায় আগের reasoning অংশ হুবহু ফেরত পাঠাতে (Gemini-র signature, DeepSeek আর Kimi-তে tool ব্যবহারের সময় reasoning_content).

আর prompt? OpenAI-এর reasoning best practices নথি (লেখার সময়ে) সরাসরি বলে “Avoid chain-of-thought prompts”: এই model-গুলো নিজেই ভেতরে ধাপ লেখে, তাই “ধাপে ধাপে ভাবুন” বলা দরকার নেই, কখনো ক্ষতিও করতে পারে। একই নথি পরিষ্কার লক্ষ্য, শর্ত আর output-এর ফরম্যাট দিতে বলে। অর্থাৎ এই পর্বের CoT prompt সবচেয়ে কাজের সাধারণ instruct model-এ, বিশেষ করে নিজের চালানো ছোট open model-এ; reasoning model-এ কাজ সরে যায় effort সেটিং আর ভালো মূল্যায়নের দিকে।

নমুনা request (OpenAI Responses API-র নথির ধাঁচে; key নেই বলে চালানো হয়নি, কোনো উত্তরও দেখানো হচ্ছে না):

{
  "model": "<আপনার reasoning model>",
  "reasoning": { "effort": "low", "summary": "auto" },
  "max_output_tokens": 2000,
  "input": "৩টি মধুর বয়াম ... মোট কত? শেষ লাইনে: উত্তর: <সংখ্যা>"
}

উত্তরের usage-এ output_tokens-এর পাশে reasoning_tokens দেখে বুঝবেন, বিলের কতটা ভেতরের লেখা।

৯ · কখন CoT, কখন নয় — একটি সিদ্ধান্তের তালিকা

প্রবন্ধ, নথি আর এই run মিলিয়ে শুরুর অনুমান; প্রতিটি নিজের eval set-এ মেপে নিন (পর্ব ৬৬ · Prompt পরীক্ষা)।

১০ · AI-এর যুগে — reasoning prompt নিয়ে AI সহকারীর সঙ্গে কাজ

CoT আর self-consistency-র কোড AI assistant দ্রুত লিখে দেয়, কিন্তু ভুলগুলো ক্র্যাশ করে না, নম্বর শুধু একটু বদলায়।

AI-এর দেওয়া reasoning-কোড আর দাবির চেকলিস্ট

• Library-র version আর model-এর নাম ও revision লিখে রেখেছি; argument নিজের version-এর নথিতে মিলিয়েছি
• দুটি sample-এর লেখা আলাদা কি না দেখেছি; seed আর decoding সেটিং লেখা আছে
• Extractor-এর অমিলগুলো নিজে পড়েছি, শুধু নম্বর দেখিনি
• প্রতিটি accuracy-র পাশে n আর CI; তুলনা একই প্রশ্নে জোড়ায়
• গড় token আর প্রতি সঠিক উত্তরের token রিপোর্ট করেছি
• CoT-এর লেখাকে সিদ্ধান্তের প্রমাণ ধরিনি; উদ্ধৃত প্রবন্ধ আর নথি নিজে খুলেছি