Token, খরচ আর latency — caching, model বাছাই আর সংক্ষিপ্ত prompt

এই পর্বের desktop run: Python 3.12, torch 2.15.0 (CPU), transformers 5.22.2, tiktoken 0.14.0, লেখার সময়ে। Model Qwen/Qwen2.5-0.5B-Instruct (Apache 2.0) আর HuggingFaceTB/SmolLM2-360M-Instruct (Apache 2.0), দুটিই token ছাড়া নামানো যায়; CPU-তে ৩টি thread. সব বার্তা, নীতি আর পণ্যের লেখা এই পর্বের জন্য হাতে লেখা কাল্পনিক বাজারঘর ডেটা। সব সময়ের সংখ্যা একটি স্থানীয় যন্ত্রের একটি run-এর; hosted API-র সময় নেটওয়ার্ক, সারি আর server-এর ওপর নির্ভর করে, আর বড় পণ্য অন্যভাবে আচরণ করতে পারে। কোনো আসল দাম এই পাতায় নেই; হিসাব প্রতীকে আর আপনার বসানো দামে। Token আর LLM-এর মূল ধারণা AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ।

১ · Token — খরচ, সময় আর জায়গার একক, আর বাংলার বাড়তি দাম

Token দিয়ে তিনটি জিনিস মাপা হয়। খরচ: hosted API input আর output token-এর দাম আলাদা ধরে। সময়: প্রতিটি output token-এর জন্য model-এর একটি পূর্ণ pass লাগে (পর্ব ৪৯)। জায়গা: context window token-এ মাপা (পর্ব ৫২)। তাই একই কথা যত বেশি token-এ ভাঙে, তত বেশি টাকা, তত বেশি সময়, আর তত কম জায়গা বাকি থাকে।

পর্ব ৪০-এ দেখেছেন, BPE-ধরনের tokenizer যে ভাষার ডেটা বেশি দেখে, সে ভাষার শব্দ বড় টুকরোয় রাখে। বাংলার প্রতিটি অক্ষর UTF-8-এ ৩ byte, আর অনেক tokenizer-এর vocabulary-তে বাংলার টুকরো কম। এবার একই অর্থের তিনটি বাজারঘর লেখা (গ্রাহকের বার্তা, পণ্যের বর্ণনা, ফেরতের নীতি; হাতে লেখা কাল্পনিক) বাংলা আর ইংরেজিতে, সাতটি খোলা tokenizer আর tiktoken-এর দুটি public encoding-এ গোনা হলো।

~/bazarghar-dl$ uv run python tokcount.py      # সত্যিকারের run; warning-এর লাইন বাদ
tiktoken:cl100k_base                bn= 577 en= 128 ratio=4.51 banglish=50
tiktoken:o200k_base                 bn= 192 en= 126 ratio=1.52 banglish=42
Qwen/Qwen2.5-0.5B-Instruct          bn= 514 en= 133 ratio=3.86 banglish=53
Qwen/Qwen3-0.6B                     bn= 514 en= 133 ratio=3.86 banglish=53
HuggingFaceTB/SmolLM2-360M-Instruct bn= 882 en= 136 ratio=6.49 banglish=55
deepseek-ai/DeepSeek-V3             bn= 226 en= 129 ratio=1.75 banglish=48
bigscience/bloom-560m               bn= 142 en= 126 ratio=1.13 banglish=43
FacebookAI/xlm-roberta-base         bn= 173 en= 135 ratio=1.28 banglish=43
csebuetnlp/banglabert               bn= 102 en= 197 ratio=0.52 banglish=55

Python 3.12, transformers 5.22.2, tiktoken 0.14.0, লেখার সময়ে। শুধু tokenizer-এর ফাইল নামানো হয়েছে, model নয়; special token বাদ দিয়ে গোনা। নিচের কোডে এই সংখ্যাগুলো ডেটা হিসেবে বসানো, আর প্রতি শব্দে token (token fertility) আর ৮,০০০ token-এর context-এ কত বাংলা শব্দ আঁটে, তা হিসাব করা।

import pandas as pd
# সত্যিকারের run: একই অর্থের তিনটি বাজারঘর লেখা (বার্তা, পণ্যের বর্ণনা, নীতি)
# বাংলা: ৭৭ শব্দ, ৪৮২ অক্ষর; ইংরেজি: ৯৬ শব্দ, ৫৭০ অক্ষর
COUNTS = {  # tokenizer: (বাংলা token, ইংরেজি token, Banglish বার্তা, বাংলা বার্তা)
    "tiktoken cl100k_base": (577, 128, 50, 169),
    "tiktoken o200k_base":  (192, 126, 42, 60),
    "Qwen2.5 (= Qwen3)":    (514, 133, 53, 149),
    "SmolLM2":              (882, 136, 55, 251),
    "DeepSeek-V3":          (226, 129, 48, 69),
    "BLOOM":                (142, 126, 43, 44),
    "XLM-R":                (173, 135, 43, 50),
    "BanglaBERT":           (102, 197, 55, 29),
}
BN_WORDS, EN_WORDS = 77, 96
df = pd.DataFrame(COUNTS, index=["bn", "en", "banglish", "bn_msg"]).T
df["bn/en"] = (df.bn / df.en).round(2)
df["tok/শব্দ bn"] = (df.bn / BN_WORDS).round(2)
# একটি ৮,০০০ token-এর context-এ কত বাংলা শব্দ আঁটে?
df["8k-তে শব্দ"] = (8000 / df["tok/শব্দ bn"]).round(-1).astype(int)
cols = ["bn", "en", "bn/en", "tok/শব্দ bn", "8k-তে শব্দ"]
print(df.sort_values("bn/en", ascending=False)[cols].to_string())
print("ইংরেজি token/শব্দ:", (df.en / EN_WORDS).round(2).min(), "থেকে",
      (df.en / EN_WORDS).round(2).max())
m = df[["bn_msg", "banglish"]].loc[["Qwen2.5 (= Qwen3)", "tiktoken o200k_base"]]
print("শুধু বার্তাটি, বাংলা বনাম Banglish:")
print(m.to_string())

                       bn   en  bn/en  tok/শব্দ bn  8k-তে শব্দ
SmolLM2               882  136   6.49        11.45         700
tiktoken cl100k_base  577  128   4.51         7.49        1070
Qwen2.5 (= Qwen3)     514  133   3.86         6.68        1200
DeepSeek-V3           226  129   1.75         2.94        2720
tiktoken o200k_base   192  126   1.52         2.49        3210
XLM-R                 173  135   1.28         2.25        3560
BLOOM                 142  126   1.13         1.84        4350
BanglaBERT            102  197   0.52         1.32        6060
ইংরেজি token/শব্দ: 1.31 থেকে 2.05
শুধু বার্তাটি, বাংলা বনাম Banglish:
                     bn_msg  banglish
Qwen2.5 (= Qwen3)       149        53
tiktoken o200k_base      60        42

কোম্পানিগুলোর নিজের নথি “প্রতি token-এ কত অক্ষর” নিয়ে কী বলে, লেখার সময়ে (নভেম্বর ২০২৬): Google-এর Gemini নথি ইংরেজিতে প্রায় ৪ অক্ষরে এক token; Anthropic-এর শব্দকোষ পুরনো model-এ প্রায় ৩.৫ ইংরেজি অক্ষর, আর নতুন কিছু model একই লেখায় প্রায় ৩০% বেশি token দেয় বলে token গোনার নথিতে লেখা; DeepSeek-এর নথি ইংরেজির এক অক্ষরে প্রায় ০.৩ token, চীনা এক অক্ষরে প্রায় ০.৬; Kimi-র নথি ৩–৪ ইংরেজি অক্ষরে এক token. OpenAI-এর token গোনার নথি উল্টো সতর্ক করে, “অক্ষর ÷ ৪” ধরনের আন্দাজ ভুল। বাংলার কথা কোনো নথিতে পাইনি। তাই নিয়ম একটাই: আন্দাজ নয়, নিজের লেখা নিজের tokenizer-এ গুনুন।

২ · খরচের হিসাব — দাম প্রতি ১০ লাখ token, input আর output আলাদা

API-র দাম সাধারণত লেখা থাকে প্রতি ১০ লাখ (1M) token-এ, input আর output আলাদা। একটি অনুরোধের খরচ:

C = (T_in × P_in + T_out × P_out) ÷ 10⁶

এখানে T_in হলো input token (system prompt, কথোপকথনের ইতিহাস, গ্রাহকের বার্তা, সব মিলে), T_out output token, আর P_in, P_out প্রতি ১০ লাখ token-এর দাম। মাসের খরচ = অনুরোধের সংখ্যা R × গড় C. আসল দাম model-ভেদে আলাদা আর প্রায়ই বদলায়, তাই এই পাতায় টাকার কোনো অঙ্ক নেই, শুধু আপেক্ষিক খরচ-একক: P_in = ১.০০ আর P_out = ৪.০০ “একক”; output token-কে input-এর চার গুণ ভারী ধরা হলো। নিজের হিসাবে নিজের model-এর দামের পাতা থেকে সংখ্যা বসান।

প্রতিটি অনুরোধে পুরো ইতিহাস আবার পাঠাতে হয়, কারণ API নিজে থেকে আগের কথা মনে রাখে না (পর্ব ৫২)। তাই চার বার্তার কথোপকথনের চতুর্থ অনুরোধে আগের তিনটির সব token আবার input হিসেবে গোনা হয়। বাজারঘরের সহায়তা-bot-এর একটি মাস ধাপে ধাপে:

এবার একই হিসাব কোডে, যাতে আপনি নিজের দাম আর সংখ্যা বসিয়ে দেখতে পারেন। P_IN, P_OUT, READ, WRITE আর BATCH_DISC বদলে আবার চালান; caching আর batch-এর গুণক §৩ আর §৬-এর সারণি থেকে নিজের API-র জন্য বেছে নিন।

# বাজারঘরের সহায়তা-bot-এর এক মাসের খরচ। দাম নিজের API-র নথি থেকে বসান।
P_IN, P_OUT = 1.00, 4.00   # খরচ-একক (টাকা নয়): প্রতি ১০ লাখ (1M) input/output token-এ
READ, WRITE = 0.10, 1.25   # cache-এ পড়া আর লেখা token-এর গুণক (নথিভেদে আলাদা)
BATCH_DISC = 0.50          # batch-এ ছাড় (নথিভেদে আলাদা, কোথাও নেই)

def month_cost(R, sys_tok, other_in, out_tok, hit=0.0, batch=0.0):
    """R অনুরোধ; sys_tok সবার এক অংশ, other_in বাকি input, out_tok উত্তর"""
    M = 1e6
    cached = R * sys_tok * hit                 # cache থেকে পড়া
    written = R * sys_tok * (1 - hit) if hit else 0
    plain = R * other_in + (0 if hit else R * sys_tok)
    c_in = (cached * READ + written * WRITE + plain) * P_IN / M
    c_out = R * out_tok * P_OUT / M
    f = 1 - batch * BATCH_DISC                 # batch-এ যাওয়া ভাগে ছাড়
    return (c_in + c_out) * f, c_in * f, c_out * f

R = 30 * 1200 * 4          # ৩০ দিন × ১,২০০ কথোপকথন × ৪টি অনুরোধ
base = dict(R=R, sys_tok=1500, other_in=460, out_tok=120)
print(f"অনুরোধ/মাস: {R:,}")
print(f"{'অবস্থা':28}{'input':>9}{'output':>9}{'মোট':>9}")
for name, kw in [("cache নেই", {}),
                 ("cache, hit 90%", {"hit": 0.9}),
                 ("cache 90% + 20% batch-এ", {"hit": 0.9, "batch": 0.2}),
                 ("system prompt ৬০০ token-এ ছাঁটা", {"sys_tok": 600}),
                 ("উত্তর ১২০ → ৬০ token", {"out_tok": 60})]:
    tot, ci, co = month_cost(**{**base, **kw})
    print(f"{name:28}{ci:9.2f}{co:9.2f}{tot:9.2f}")
# বাংলা বনাম ইংরেজি: একই কথা, token ৩.৮৬ গুণ (Qwen2.5-এর tokenizer, নিচে §১-এর সারণি)
tot_bn, *_ = month_cost(**base)
tot_en, *_ = month_cost(R=R, sys_tok=1500 / 3.86, other_in=460 / 3.86, out_tok=120 / 3.86)
print(f"একই bot ইংরেজিতে হলে: {tot_en:.2f}  (বাংলায় {tot_bn:.2f}, {tot_bn / tot_en:.2f} গুণ)")

অনুরোধ/মাস: 144,000
অবস্থা                          input   output      মোট
cache নেই                      282.24    69.12   351.36
cache, hit 90%                 112.68    69.12   181.80
cache 90% + 20% batch-এ        101.41    62.21   163.62
system prompt ৬০০ token-এ ছাঁটা   152.64    69.12   221.76
উত্তর ১২০ → ৬০ token           282.24    34.56   316.80
একই bot ইংরেজিতে হলে: 91.03  (বাংলায় 351.36, 3.86 গুণ)

৩ · Prompt caching — একই শুরু একবার হিসাব, তারপর সস্তায় পড়া

পর্ব ৩৭-এ KV cache দেখেছেন: generation-এর সময় আগের token-গুলোর key আর value জমিয়ে রাখা হয়, যাতে আবার হিসাব না লাগে। Prompt caching একই ধারণা, কিন্তু অনুরোধের পর অনুরোধ জুড়ে। বাজারঘরের প্রতিটি অনুরোধ শুরু হয় হুবহু একই ১,৫০০ token-এর নীতি দিয়ে। প্রথম অনুরোধে সেই অংশের হিসাব জমা থাকলে পরের অনুরোধ শুধু নতুন অংশটুকু হিসাব করে। একে বলে prefix caching: মিল থাকতে হবে একদম শুরু থেকে, token ধরে। নীতির মাঝখানে একটি শব্দ বা শুরুতে আজকের তারিখ বসালে সেখান থেকে বাকিটা আর মেলে না।

তাই prompt সাজানোর নিয়ম: যা সবার জন্য এক আর কম বদলায় (নির্দেশ, নীতি, tool-এর বর্ণনা, few-shot উদাহরণ) তা আগে; যা প্রতিবার বদলায় (গ্রাহকের নাম, তারিখ, নতুন বার্তা) তা শেষে। Google আর OpenAI দুজনের নথিই বড় আর সাধারণ অংশ শুরুতে রাখতে বলে।

নিচের সারণি প্রতিটি কোম্পানির নিজের API নথি থেকে, লেখার সময়ে (নভেম্বর ২০২৬) পড়া। নিয়ম model-ভেদে আলাদা আর পরিবর্তন হতে পারে; ব্যবহারের আগে নথিটি নিজে খুলে মিলিয়ে নিন। দাম টাকায় নয়, নথি যেভাবে বলে সেভাবে, সাধারণ input-এর তুলনায় লেখা। যেখানে বিষয়টি নথিতে খুঁজে পাইনি, সেখানে তা-ই লেখা। কোনটি “ভালো”, এই সারণি তা বলে না।

সারণির তিন শিক্ষা: cache অল্প সময় বাঁচে; ন্যূনতম দৈর্ঘ্যের নিচে cache হয় না; আর কোথাও লেখার দাম বাড়তি, তাই hit কম হলে লোকসানও হতে পারে। নিচের stepper §২-এর একই bot-এ সেই হিসাব দেখায়।

সারণির শেষ কলামটি এখানে কাজে লাগে: আন্দাজ নয়, প্রতিটি উত্তরের usage-এ cache-এর token গুনে আসল cache hit rate বের করুন। Hit কম হলে প্রায়ই কারণ prompt-এর শুরুতে বদলানো কিছু, বা অনুরোধের মাঝে বিরতি cache-এর আয়ু (TTL)-এর চেয়ে বেশি।

৪ · Latency-র দুই অংশ — প্রথম token পর্যন্ত, তারপর প্রতি সেকেন্ডে কত

প্রথম অংশের নাম prefill: পুরো prompt একটি pass-এ model-এ চলে আর KV cache ভরে। এর শেষে প্রথম token আসে; অনুরোধ পাঠানো থেকে এই পর্যন্ত সময় time to first token (TTFT), যাকে first-token latency-ও বলে। দ্বিতীয় অংশ decode: প্রতি ধাপে একটি নতুন token, আগের KV cache-এর সাহায্যে। এর গতি মাপা হয় tokens per second (r) দিয়ে। N token-এর উত্তরে:

মোট সময় ≈ TTFT + (N − 1) ÷ r

Hosted API-তে TTFT-এর ভেতরে নেটওয়ার্ক আর server-এর সারিতে অপেক্ষাও থাকে। Anthropic-এর latency নথি TTFT শব্দটি সংজ্ঞা দিয়ে ব্যবহার করে, আর OpenAI-এর latency নথির সাতটি নীতির মধ্যে আছে কম token লেখা, কম input, কম অনুরোধ আর ব্যবহারকারীকে কম অপেক্ষা করানো (লেখার সময়ে, নভেম্বর ২০২৬)।

এবার নিজের যন্ত্রে মাপা। Streaming-এ প্রতিটি token আসার মুহূর্ত লিখে রাখা যায়। transformers-এর generate() একটি streamer নেয়, যার put() প্রতিটি নতুন token-এ ডাকা হয়। মূল অংশ (একটু ছোট করে দেখানো):

class Clock(BaseStreamer):          # প্রথম put() = prompt নিজেই, বাদ
    def __init__(self): self.t, self.first = [], True
    def put(self, value):
        if self.first: self.first = False; return
        self.t.append(time.perf_counter())
    def end(self): pass

c = Clock(); t0 = time.perf_counter()
model.generate(ids, max_new_tokens=48, min_new_tokens=48, do_sample=False, streamer=c)
ttft = c.t[0] - t0
tps = (len(c.t) - 1) / (c.t[-1] - c.t[0])

System prompt-এ §৩-এর নীতির ২, ৬, ১২ আর ২৫টি নিয়ম, তারপর পুরো নীতি দুবার আর চারবার, যাতে prompt ২৩৪ থেকে ৮,২২৮ token পর্যন্ত যায়। প্রতি দৈর্ঘ্যে তিনবার, আগে একবার warm-up বাদ দিয়ে:

~/bazarghar-dl$ uv run python latency.py length      # সত্যিকারের run, CPU-তে ৩ thread
2     prompt=  234  ttft=1.185s tps=10.3  ttft=1.018s tps=12.0  ttft=1.009s tps=10.1
6     prompt=  524  ttft=2.359s tps=10.8  ttft=2.283s tps=9.3  ttft=2.228s tps=10.5
12    prompt=  978  ttft=3.947s tps=10.2  ttft=3.873s tps=9.6  ttft=3.936s tps=10.7
25    prompt= 2099  ttft=9.346s tps=10.1  ttft=8.921s tps=10.3  ttft=9.049s tps=10.1
25x2  prompt= 4142  ttft=19.651s tps=8.2  ttft=20.444s tps=8.9  ttft=19.686s tps=8.9
25x4  prompt= 8228  ttft=43.278s tps=7.1  ttft=42.125s tps=7.4  ttft=38.511s tps=6.4

এই সংখ্যাগুলো পাতার কোডে বসিয়ে একটি latency model fit করা হলো: TTFT prompt-এর দৈর্ঘ্যের রৈখিক আর দ্বিঘাত function হিসেবে, আর decode-এর গতিও দৈর্ঘ্যের function হিসেবে। তারপর কয়েকটি বাস্তব অবস্থার মোট সময় অনুমান।

import numpy as np
import matplotlib.pyplot as plt
# সত্যিকারের run: Qwen2.5-0.5B-Instruct, CPU-তে ৩টি thread, greedy, ৪৮টি নতুন token
# প্রতিটি prompt-দৈর্ঘ্যে ৩ বার (warm-up বাদ): TTFT (সেকেন্ড) আর tokens/s
T = np.array([234, 524, 978, 2099, 4142, 8228])
TTFT = np.array([[1.185, 1.018, 1.009], [2.359, 2.283, 2.228], [3.947, 3.873, 3.936],
                 [9.346, 8.921, 9.049], [19.651, 20.444, 19.686], [43.278, 42.125, 38.511]])
TPS = np.array([[10.3, 12.0, 10.1], [10.8, 9.3, 10.5], [10.2, 9.6, 10.7],
                [10.1, 10.3, 10.1], [8.2, 8.9, 8.9], [7.1, 7.4, 6.4]])
ttft, tps = TTFT.mean(1), TPS.mean(1)
lin = np.polyfit(T, ttft, 1)            # TTFT ≈ a·T + b
quad = np.polyfit(T, ttft, 2)           # attention-এর T² অংশসহ
r_fit = np.polyfit(T, tps, 1)           # লম্বা context-এ decode-ও ধীর
print(f"রৈখিক: TTFT ≈ {lin[1]:.2f} + {lin[0]*1000:.2f} s × (T/1000)")
print(f"prefill-এর গতি ≈ {1/lin[0]:.0f} token/s; decode ≈ {tps[:4].mean():.1f} token/s")
for n, f in (("রৈখিক", lin), ("দ্বিঘাত", quad)):
    err = np.abs(np.polyval(f, T) - ttft).max()
    print(f"{n:8} fit-এর সর্বোচ্চ ভুল: {err:.2f} s")

def total(T_in, n_out):                  # মোট সময় = TTFT + (N − 1) ÷ r
    return np.polyval(quad, T_in) + (n_out - 1) / np.polyval(r_fit, T_in)
for T_in, n in ((300, 120), (1500, 120), (1500, 400), (6000, 120)):
    s = total(T_in, n)
    print(f"prompt {T_in:5}, উত্তর {n:3}: মোট {s:5.1f} s, TTFT-এর ভাগ "
          f"{np.polyval(quad, T_in) / s:.0%}")

fig, ax = plt.subplots(figsize=(5.2, 3.2))
ax.errorbar(T, ttft, yerr=TTFT.std(1), fmt="o", label="measured (mean of 3)")
x = np.linspace(0, 8500, 100)
ax.plot(x, np.polyval(lin, x), "--", label="linear fit")
ax.plot(x, np.polyval(quad, x), label="quadratic fit")
ax.set_xlabel("prompt tokens"); ax.set_ylabel("TTFT (s)"); ax.legend()

রৈখিক: TTFT ≈ -0.76 + 5.07 s × (T/1000)
prefill-এর গতি ≈ 197 token/s; decode ≈ 10.3 token/s
রৈখিক    fit-এর সর্বোচ্চ ভুল: 0.78 s
দ্বিঘাত  fit-এর সর্বোচ্চ ভুল: 0.40 s
prompt   300, উত্তর 120: মোট  12.3 s, TTFT-এর ভাগ 9%
prompt  1500, উত্তর 120: মোট  18.5 s, TTFT-এর ভাগ 36%
prompt  1500, উত্তর 400: মোট  46.4 s, TTFT-এর ভাগ 14%
prompt  6000, উত্তর 120: মোট  44.1 s, TTFT-এর ভাগ 66%

৫ · নিজের যন্ত্রে prefix cache — একই নীতি, প্রায় ২২ গুণ দ্রুত প্রথম token

Hosted API-র cache ভেতরে কী করে, তা বাইরে থেকে দেখা যায় না; কিন্তু ধারণাটি নিজের যন্ত্রে চালানো যায়। §৩-এর ২৫টি নিয়মের নীতি (chat template-সহ ২,০৪৭ token) একবার model-এ চালিয়ে তার KV cache রাখা হলো। তারপর পাঁচটি আলাদা গ্রাহক-প্রশ্নে দুইভাবে উত্তর: পুরো prompt নতুন করে, আর জমা cache-এর একটি কপি থেকে শুরু করে। মূল অংশ (একটু ছোট করে দেখানো):

pre_ids = tok(apply_chat_template([system_only]), return_tensors="pt").input_ids
base = DynamicCache()
model(pre_ids, past_key_values=base, use_cache=True)     # নীতি একবার, ২,০৪৭ token

for q in QUESTIONS:
    ids = ids_for(POLICY, q)                  # শুরুর ২,০৪৭ token হুবহু একই
    full   = run(ids, 40)                                   # cache ছাড়া
    cached = run(ids, 40, past=copy.deepcopy(base))         # বাকিটুকুর prefill
    same = full.text == cached.text

~/bazarghar-dl$ uv run python latency.py cache       # সত্যিকারের run, CPU-তে ৩ thread
prefix tokens=2047 prefill once=12.039s
prompt=2099 new= 52 ttft full=8.108s cached=0.374s x21.7 same=True
prompt=2083 new= 36 ttft full=7.819s cached=0.317s x24.6 same=True
prompt=2101 new= 54 ttft full=7.824s cached=0.421s x18.6 same=True
prompt=2080 new= 33 ttft full=8.266s cached=0.314s x26.3 same=True
prompt=2103 new= 56 ttft full=8.241s cached=0.437s x18.9 same=True

৬ · Batch, streaming আর model বাছাই

Batch: সব কাজের তাড়া নেই। রাতে দিনের সব রিভিউর সারাংশ, পুরনো অর্ডারের শ্রেণিকরণ, eval set চালানো: এগুলো একসঙ্গে জমা দিয়ে কয়েক ঘণ্টা পরে নেওয়া যায়। কয়েকটি কোম্পানি এর জন্য কম দাম রাখে, কারণ তারা কাজটি ফাঁকা সময়ে চালাতে পারে। Streaming: মোট সময় কমায় না, কিন্তু ব্যবহারকারী TTFT-এর পরেই লেখা দেখতে শুরু করেন (ভাবনার প্রশ্ন ২)। নিচের সারণি আবার প্রতিটি কোম্পানির নিজের নথি থেকে, লেখার সময়ে (নভেম্বর ২০২৬); পরিবর্তন হতে পারে।

ছয়টির সবকটিতে streaming চালু হয় অনুরোধে stream ধরনের একটি parameter দিয়ে। নিচে অনুরোধের আকার, নথির কাঠামো অনুসরণ করে; চালানো হয়নি, কারণ এখানে কোনো API key নেই:

# নমুনা (চালানো হয়নি): শুধু body-র মূল অংশ; model-এর নাম নিজে বসান
# Claude: স্থির নীতির শেষে cache-এর চিহ্ন, তারপর প্রশ্ন; উত্তর streaming-এ
{"model": "…", "max_tokens": 300, "stream": true,
 "system": [{"type": "text", "text": "…বাজারঘরের ২৫টি নিয়ম…",
             "cache_control": {"type": "ephemeral"}}],
 "messages": [{"role": "user", "content": "খুলনায় ডেলিভারি চার্জ কত?"}]}
# OpenAI, xAI, DeepSeek, Kimi: caching নিজে থেকে; স্থির অংশ আগে রাখলেই হয়
{"model": "…", "stream": true,
 "messages": [{"role": "system", "content": "…বাজারঘরের ২৫টি নিয়ম…"},
              {"role": "user", "content": "খুলনায় ডেলিভারি চার্জ কত?"}]}

Model বাছাই: ছোট model সাধারণত প্রতি token-এ সস্তা আর দ্রুত। কিন্তু বাংলায় দুটি বাড়তি প্রশ্ন: নির্ভুলতা কতটা নামে, আর tokenizer বাংলাকে কত টুকরোয় ভাঙে। একই ৪০টি বার্তার শ্রেণিকরণে (§৭-এর কাজ, পুরো prompt) দুই ছোট খোলা model:

৭ · সংক্ষিপ্ত prompt — কত token বাঁচে, কতটা নির্ভুলতা যায়

সবচেয়ে সহজ সাশ্রয় মনে হয় prompt ছোট করা। কিন্তু কী কাটছেন? বাজারঘরের ৪০টি গ্রাহক-বার্তা (বাংলা আর Banglish, পাঁচ শ্রেণিতে ৮টি করে: delivery, return, payment, product, complaint; হাতে লেখা কাল্পনিক) শ্রেণিতে ফেলার জন্য পাঁচটি system prompt:

• full (১,০০৮ token): কাজের বর্ণনা, প্রতিটি শ্রেণির সংজ্ঞা, পাঁচটি উদাহরণ, আর “শুধু নামটি লেখো”।
• medium আর medium2 (১৯৭ আর ২১৪): সংজ্ঞা এক লাইনে, উদাহরণ নেই; দুটি আলাদা ভাষ্য।
• short আর short2 (৪৫ আর ৬৪): শুধু পাঁচটি নাম; দুটি ভাষ্য।

Model Qwen2.5-1.5B-Instruct (Apache 2.0), GPU-তে, bfloat16. মাপ দুইভাবে: (ক) পাঁচটি শ্রেণি-নামের log-likelihood তুলনা (পর্ব ৫৮-এর পদ্ধতি), যাতে format-এর ভুল বাদ দিয়ে শুধু বোঝা মাপা যায়; (খ) greedy-তে সর্বোচ্চ ৬টি token লিখিয়ে উত্তর থেকে নাম খোঁজা, যা আসল ব্যবহারের কাছাকাছি।

~/bazarghar-dl$ uv run python gpu_run.py        # সত্যিকারের run, GPU-তে; লোডের লাইন বাদ
full     ll_acc=0.775 gen_acc=0.750 unparsed=1 in_tok=1055.7
medium   ll_acc=0.600 gen_acc=0.425 unparsed=15 in_tok=244.7
medium2  ll_acc=0.550 gen_acc=0.600 unparsed=2 in_tok=261.7
short    ll_acc=0.350 gen_acc=0.025 unparsed=39 in_tok=92.7
short2   ll_acc=0.525 gen_acc=0.425 unparsed=8 in_tok=111.7
peak GPU memory allocated: 3.25 GiB

প্রতিটি বার্তার ফল (সঠিক ১, ভুল ০) নিচের কোডে বসানো। কোড bootstrap দিয়ে নির্ভুলতার CI, একই বার্তায় full-এর সঙ্গে জোড়া পার্থক্য (মেশিন লার্নিং কোর্সের পর্ব ২২), আর আপনার বসানো দামে ১০,০০০ বার্তার input-খরচ হিসাব করে।

import numpy as np
import matplotlib.pyplot as plt
# সত্যিকারের run: Qwen2.5-1.5B-Instruct, ৪০টি বার্তা (প্রতি শ্রেণিতে ৮টি),
# পাঁচ শ্রেণির log-likelihood তুলনা। ১ = সঠিক, ০ = ভুল; বার্তার ক্রম সব prompt-এ এক
RUNS = {  # নাম: (গড় input token, ৪০টি ফল)
 "full":    (1055.7, "1111011111011111111011111111111001110000"),
 "medium":  (244.7,  "1111010110111110111011111110011000000000"),
 "medium2": (261.7,  "1111011111111111110010110010001000000000"),
 "short":   (92.7,   "1111010110010010000000101011100000000000"),
 "short2":  (111.7,  "1111111110011111000001110000000001110100"),
}
P_IN = 1.00                                # আপনার input-এর দাম, প্রতি 1M token
rng = np.random.default_rng(65)
X = {k: np.array([int(c) for c in s]) for k, (_, s) in RUNS.items()}
idx = rng.integers(0, 40, (5000, 40))      # একই বার্তা-নমুনা সব prompt-এ (জোড়া)
print(f"{'prompt':8}{'token':>6}{'খরচ/10k':>9}{'নির্ভুল':>8}   95% CI        full-এর তুলনায়")
for k, (tok, _) in RUNS.items():
    a = X[k][idx].mean(1)
    d = (X[k] - X["full"])[idx].mean(1)
    lo, hi = np.percentile(a, [2.5, 97.5])
    dl, dh = np.percentile(d, [2.5, 97.5])
    diff = "—" if k == "full" else f"{X[k].mean()-X['full'].mean():+.2f} [{dl:+.2f},{dh:+.2f}]"
    print(f"{k:8}{tok:6.0f}{tok * 10000 * P_IN / 1e6:9.2f}{X[k].mean():8.3f}"
          f"   [{lo:.2f}, {hi:.2f}]  {diff}")
per_class = {k: [int(X[k][i*8:(i+1)*8].sum()) for i in range(5)] for k in X}
print("শ্রেণি অনুযায়ী সঠিক (৮টির মধ্যে): delivery, return, payment, product, complaint")
for k, v in per_class.items():
    print(f"  {k:8}{v}")

fig, ax = plt.subplots(figsize=(5, 3))
for k, (tok, _) in RUNS.items():
    ax.scatter(tok, X[k].mean()); ax.annotate(k, (tok, X[k].mean()), xytext=(4, 4),
                                              textcoords="offset points")
ax.set_xscale("log"); ax.set_xlabel("input tokens per message (log)")
ax.set_ylabel("accuracy (n = 40)"); ax.set_ylim(0, 1)

prompt   token  খরচ/10k নির্ভুল   95% CI        full-এর তুলনায়
full      1056    10.56   0.775   [0.65, 0.90]  —
medium     245     2.45   0.600   [0.45, 0.75]  -0.18 [-0.33,-0.05]
medium2    262     2.62   0.550   [0.40, 0.70]  -0.22 [-0.38,-0.07]
short       93     0.93   0.350   [0.20, 0.50]  -0.43 [-0.57,-0.28]
short2     112     1.12   0.525   [0.38, 0.68]  -0.25 [-0.42,-0.07]
শ্রেণি অনুযায়ী সঠিক (৮টির মধ্যে): delivery, return, payment, product, complaint
  full    [7, 7, 7, 7, 3]
  medium  [6, 6, 7, 5, 0]
  medium2 [7, 8, 5, 2, 0]
  short   [6, 3, 1, 4, 0]
  short2  [8, 6, 3, 0, 4]

Caching হিসাব বদলে দেয়। full-এর ১,০৫৬ token-এর ১,০০৮টি স্থির system prompt; বার্তাভেদে বদলায় গড়ে মাত্র ৪৮টি। পড়া ০.১ গুণ ধরলে full-এর কার্যকর input প্রায় ১,০০৮ × ০.১ + ৪৮ ≈ ১৪৯ token-সমান, short2-এর (১১২) কাছাকাছি, অথচ নির্ভুলতা অনেক বেশি। তবে একটি ফাঁদ: ১,০০৮ হলো Qwen-এর tokenizer-এ গোনা; অন্য model-এ সংখ্যা আলাদা হবে, আর §৩-এর সারণির ১,০২৪ বা ২,০৪৮-এর মতো ন্যূনতম দৈর্ঘ্যের নিচে পড়লে cache হবেই না। তাই সিদ্ধান্ত তিনটি সংখ্যা একসঙ্গে দেখে: নির্ভুলতা (CI-সহ), cache-এর পরের কার্যকর token, আর TTFT. এই run একটি model, একটি task আর ৪০টি বার্তার; নিজের কাজে আবার মাপুন।

৮ · Context window-এর বাজেট — কোন অংশ কত token পাবে

Context window একটি নির্দিষ্ট আকারের থলে। কোম্পানিগুলো model-ভেদে আলাদা আকার লেখে, আর তা বদলায়; তাই এখানে একটি সাধারণ হিসাব। একটি context বাজেট লিখে রাখুন:

W ≥ T_system + T_{ইতিহাস} + T_তথ্য + T_{বার্তা} + T_{উত্তরের জন্য রাখা}

W হলো window-এর আকার, T_তথ্য হলো খুঁজে আনা নথি (পর্ব ৬৯ · RAG-এ বিস্তারিত)। ধরুন W = ৮,১৯২: system ১,৫০০, উত্তরের জন্য ৫১২, নতুন বার্তা ১০০; ইতিহাস আর তথ্যের জন্য বাকি ৬,০৮০ token. Qwen2.5-এর tokenizer-এ বাংলা প্রতি শব্দে ৬.৬৮ token (§১), তাই এটি প্রায় ৯১০ বাংলা শব্দ; o200k_base-এর মতো অনুপাতে (২.৪৯) প্রায় ২,৪৪০ শব্দ। একই window, বাংলায় আঁটে অনেক কম।

বাজেট ছাড়ালে কী কাটবেন, তা আগে থেকে ঠিক রাখুন: প্রথমে পুরনো ইতিহাস (শেষ কয়েকটি বার্তা রেখে বাকিগুলোর ছোট সারাংশ), তারপর কম প্রাসঙ্গিক তথ্য; system-এর নীতি আর উত্তরের জায়গা কখনো নয়। উত্তরের জায়গা না রাখলে উত্তর মাঝপথে কাটা পড়ে। কথোপকথনের ইতিহাস সামলানোর নকশা পর্ব ৬৪-এ।

৯ · AI-এর যুগে — খরচ আর গতির দাবি যাচাই

খরচ আর গতির প্রশ্নে AI assistant আত্মবিশ্বাসী সংখ্যা দেয়, যা প্রায়ই পুরনো বা বানানো। ভুলগুলো চুপচাপ বিলে আসে।

খরচ আর latency-র চেকলিস্ট

• নিজের বাংলা লেখার token নিজের model-এর tokenizer বা গোনার উপায়ে মেপেছি
• দাম আর গুণক কোম্পানির পাতা থেকে, তারিখসহ লিখে রেখেছি
• Prompt-এর স্থির অংশ আগে, বদলানো অংশ শেষে; usage-এ cache hit দেখছি
• TTFT আর tokens/s আলাদা, warm-up বাদ দিয়ে কয়েকবার মেপেছি
• ছোট prompt বা ছোট model-এ নির্ভুলতা eval set-এ জোড়া CI-সহ মেপেছি
• Context বাজেট লেখা আছে; উত্তরের জন্য জায়গা রাখা