Deep learning model deploy — ONNX, TorchScript আর edge device

মেশিন লার্নিং কোর্সের পর্ব ৬৮-এ scikit-learn-এর model FastAPI আর ONNX দিয়ে চালু করা হয়েছিল, আর পর্ব ৬৯-এ চালু model-এর test আর নজরদারি। সেই ভিত্তি এখানে ধরে নিচ্ছি। Deep learning-এ নতুন যা আসে: model একটি গণনার graph, যাকে PyTorch থেকে বের করে আনতে হয়; ওজন লাখ থেকে কোটিতে; আর একই model GPU-হীন server, ফোন বা browser-এ চালাতে হতে পারে। Quantization-এর মূল সূত্র পর্ব ৫৯ · Quantization আর distillation-এ আছে; LLM-বিশেষ serving (KV cache, continuous batching) পর্ব ৮৩ · LLM serving-এর বিষয়, এখানে নয়। Desktop-এর সব run লেখার সময়ে (নভেম্বর ২০২৬) এই version-এ, CPU-তে ৩টি thread: Python 3.12, torch 2.15.0, onnx 1.23.2, onnxscript 0.7.2, onnxruntime 1.31.1, transformers 5.22.2, fastapi 0.162.2, uvicorn 0.54.0. শুধু একটি fine-tuning GPU-তে, তা পাশে লেখা আছে।

১ · Deploy মানে কী — train থেকে নজরদারি পর্যন্ত একটি পথ

একটি পোশাক কারখানার কথা ভাবুন। ডিজাইনারের নমুনা জামা হলো শেখানো model. নমুনা দিয়ে দোকান চলে না: যেকোনো মেশিনে চলে এমন কাটিং প্যাটার্ন (export), কাপড় বাঁচাতে ছোট করা প্যাটার্ন (optimise), লেবেল আর ব্যাচ নম্বরসহ প্যাকেট (package), দোকান (serve), আর ফেরত আসা জামা দেখা (monitor). কোনো ব্যাচে ত্রুটি পেলে আগের প্যাটার্নে ফেরা হয়।

Deploy মানে model-কে এমন জায়গায় চালু করা, যেখানে আসল ব্যবহারকারী বা অন্য program তাকে ডাকে, আর সেটি নির্ভরযোগ্যভাবে, মাপা সময়ে উত্তর দেয়। নিচের ছবিতে ছয়টি ধাপ:

প্রতিটি ধাপে কী হাতে আসে, তা লিখে রাখা জরুরি। Deep learning model-এর “চালানোর জিনিস” শুধু ওজন নয়:

মেশিন লার্নিং কোর্সের পর্ব ৬৮-এ এই ফাঁদের নাম ছিল training–serving skew. Deep learning-এ এর সাধারণ রূপ: ছবি ০–১-এ না নিয়ে পাঠানো, RGB আর BGR উল্টে যাওয়া, বা অন্য tokenizer. Model তখনো উত্তর দেয়, শুধু ভুল উত্তর।

২ · Export ফরম্যাট — TorchScript, torch.export আর ONNX

PyTorch-এ model একটি সাধারণ Python program: forward() চলার সময় এক এক করে কাজ হয় (eager mode, পর্ব ৯ · nn.Module). Server-এ বা ফোনে Python না-ও থাকতে পারে। তাই model-এর গণনাকে একটি স্থির graph-এ লিখে ফেলা হয়: কোন operation, কোন ক্রমে, কোন আকারের tensor-এ। এটিই export. তিনটি প্রধান পথ, প্রতিটির অবস্থা লেখার সময়ের (নভেম্বর ২০২৬) নথি থেকে, পরিবর্তন হতে পারে:

দুটি শব্দ মনে রাখুন। Opset হলো ONNX-এর operation-তালিকার version: একটি ফাইল যে opset-এ লেখা, runtime-কে তা চিনতে হয়; পুরনো runtime নতুন opset না-ও চিনতে পারে। আর dynamic shape: export-এর সময় একটি উদাহরণ input দিতে হয়, আর কোন মাত্রা (batch, token-সংখ্যা) পরে বদলাতে পারবে তা না বললে graph সেই উদাহরণের আকারেই আটকে যায়। নথি অনুযায়ী dynamo exporter-এ পুরনো dynamic_axes-এর বদলে dynamic_shapes ব্যবহারের কথা।

নিচের stepper একটি সত্যিকারের run: Fashion-MNIST-এর (Zalando Research, MIT) ছোট CNN, CPU-তে ২ epoch-এ ১৩.৬ সেকেন্ডে শেখানো, ১০,০০০ test ছবিতে accuracy ০.৮৭৯১, seed ০। একই model চারটি রূপে:

x: (N, 1, 28, 28)
c1 Conv+ReLU+MaxPool
   → (N, 16, 14, 14)
c2 Conv+ReLU+MaxPool
   → (N, 32, 7, 7)
flatten → (N, 1568)
fc1+ReLU → (N, 64)
fc2 → (N, 10) logits
state_dict: 416.5 KiB

FutureWarning:
`torch.jit.trace` is
deprecated. Please switch
to `torch.compile` or
`torch.export`.
aten::_convolution 2
aten::relu 3
aten::max_pool2d 2
aten::flatten 1
aten::linear 2
+ prim:: node 52টি

# উদাহরণের batch = 1
UserError: Constraints
violated (batch)! ...
specialized it to be a
constant (1).
# batch = 2, Dim 1..1024
aten.conv2d 2
aten.relu 3
aten.max_pool2d 2
aten.flatten 1
aten.linear 2

Conv Relu MaxPool
Conv Relu MaxPool
Reshape Gemm Relu Gemm
in:  image
     ['batch', 1, 28, 28]
out: logits ['batch', 10]
ওজন 105,868 (9টি tensor)
cnn.onnx       12.6 KiB
cnn.onnx.data 413.1 KiB

max|diff|, PyTorch বনাম ORT
batch 1  (1, 10)  1.431e-06
batch 32 (32, 10) 2.861e-06
batch 7  (7, 10)  2.384e-06
10,000 test:      3.8e-06
সিদ্ধান্ত একই: 10,000/10,000
accuracy 0.8791 = 0.8791

৩ · ONNX Runtime-এ CNN — fp32 বনাম int8, সত্যিকারের run

ONNX Runtime (ORT) একটি C++ engine, যা ONNX graph পড়ে, পাশাপাশি থাকা operation জুড়ে দেয় (যেমন Conv-এর পরে ReLU একটি kernel-এ; এর নাম operator fusion), আর প্রতিটি operation যে হার্ডওয়্যারে চলবে তা বেছে দেয়। এই “হার্ডওয়্যার-সংযোগ”-কে ORT বলে execution provider: CPU-র জন্য CPUExecutionProvider, NVIDIA GPU-র জন্য CUDA বা TensorRT, Intel-এর জন্য OpenVINO, ইত্যাদি। Thread-এর সংখ্যা ঠিক হয় intra_op_num_threads দিয়ে।

একই CNN চারটি রূপে মাপা হলো: warm-up-এর পর batch ১-এ ৩০০টি, batch ৩২-এ ১০০টি মাপ; accuracy পুরো ১০,০০০ test ছবিতে। “সিদ্ধান্ত বদল” মানে PyTorch fp32-এর সঙ্গে কতগুলো ছবিতে শ্রেণি আলাদা। সত্যিকারের run, JSON থেকে সাজানো; একটি যন্ত্রের একটি run, সাধারণ নিয়ম নয়:

৪ · Deploy-এর জন্য quantization — dynamic বনাম static calibration

পর্ব ৫৯-এর সূত্র এক লাইনে: x̂ = s · (q − z), যেখানে x আসল দশমিক মান, q পূর্ণসংখ্যা, s scale আর z zero point. ORT-এর নথিও ঠিক এই সূত্রে লেখে: val_fp32 = scale * (val_quantized - zero_point). Deploy-এ প্রশ্ন একটাই: activation-এর scale কখন ঠিক হবে?

ORT দুই ধরনের ফাইল বানাতে পারে। QOperator: প্রতিটি operation-এর নিজের int8 রূপ (ConvInteger, MatMulInteger). QDQ: মূল operation অক্ষত, আগে-পরে QuantizeLinear আর DequantizeLinear-এর জোড়া, যা runtime সুযোগ পেলে int8 kernel-এ মিলিয়ে চালায়। আমাদের static ফাইলে ৮টি Quantize আর ১৬টি Dequantize node; dynamic-এ ২টি ConvInteger, ২টি MatMulInteger আর ৪টি DynamicQuantizeLinear. Quantize-এর আগে নথির পরামর্শমতো quant_pre_process চালানো হয়েছে।

নিচের stepper-এ dynamic int8 ঠিক কী করে, তা আমাদের CNN-এর শেষ layer fc2-এর সারি ০ (শ্রেণি “T-shirt/top”-এর ৬৪টি ওজন) আর প্রথম test ছবির activation দিয়ে, হাতে। সব সংখ্যা desktop run থেকে:

একই হিসাব পুরো সারিতে, পাতার Python-এ। সারির ৬৪টি ওজন আর একটি ছবির activation নিচের ছোট CSV ফাইলে (ওজন ৫ দশমিকে, activation ৩ দশমিকে রাখা, তাই শেষ অঙ্কে desktop-এর সঙ্গে সামান্য পার্থক্য হতে পারে):

import numpy as np
d = np.loadtxt("fc2_row0.csv", delimiter=",", skiprows=1)
w, a = d[:, 0], d[:, 1]          # fc2-এর সারি ০-এর ৬৪টি ওজন, একটি ছবির fc1 activation
s_ort = 0.0020594562             # ORT-এর int8 ফাইলে লেখা fc2.weight_scale (পুরো tensor)

def q_sym(x, s):                 # symmetric int8, zero point 0
    return np.clip(np.round(x / s), -127, 127)

print("ধরন       │ scale     │ q-পরিসর   │ max err  │ s/2      │ rel RMSE")
for name, s in [("per-tensor", s_ort), ("per-row", np.abs(w).max() / 127)]:
    q = q_sym(w, s)
    err = np.abs(w - q * s)                      # dequantize করে ত্রুটি
    rel = np.sqrt((err ** 2).mean()) / w.std()
    print(f"{name:10s} │ {s:.7f} │ {int(q.min()):4d}..{int(q.max()):3d} │"
          f" {err.max():.6f} │ {s / 2:.6f} │ {rel:.4f}")

# activation: dynamic uint8, scale মাপা হয় চলার সময়ে, প্রতিটি input-এ
sx = (a.max() - min(a.min(), 0)) / 255
zx = int(np.round(-min(a.min(), 0) / sx))
qa = np.clip(np.round(a / sx) + zx, 0, 255)
qw = q_sym(w, s_ort)
acc = int(np.dot(qw.astype(np.int64), (qa - zx).astype(np.int64)))  # পূর্ণসংখ্যার যোগফল
approx, exact = acc * s_ort * sx, float(np.dot(w, a))
print(f"activation: শূন্য {int((a == 0).sum())}টি, max {a.max():.3f},"
      f" s_x = {sx:.6f}, z_x = {zx}")
print(f"পূর্ণসংখ্যার যোগফল = {acc} → × s × s_x = {approx:.4f}")
print(f"float dot = {exact:.4f} │ পার্থক্য {abs(approx - exact):.4f}")

ধরন       │ scale     │ q-পরিসর   │ max err  │ s/2      │ rel RMSE
per-tensor │ 0.0020595 │  -72.. 65 │ 0.001006 │ 0.001030 │ 0.0076
per-row    │ 0.0011745 │ -127..114 │ 0.000587 │ 0.000587 │ 0.0042
activation: শূন্য 31টি, max 12.987, s_x = 0.050929, z_x = 0
পূর্ণসংখ্যার যোগফল = -47048 → × s × s_x = -4.9347
float dot = -4.9256 │ পার্থক্য 0.0091

৫ · বাংলা DistilBERT — ONNX Runtime-এ fp32 আর int8, ফোনের মতো ১ thread

এবার একটি বাংলা model. পর্ব ৪৮-এর Bangla BERT-এর ওজন আর হাতে নেই, তাই নতুন করে শেখানো হলো: distilbert/distilbert-base-multilingual-cased (Apache 2.0, model card অনুযায়ী), পর্ব ৪২ · Text classification-এর Sazzed-এর বাংলা YouTube মন্তব্যে (Mendeley Data, CC BY 4.0), একই প্রথম split (train ৭,৫১০, validation ১,০৫৬, test ২,১৪৩)। GPU-তে ৩ epoch, ৭৬.০ সেকেন্ড, মাপা সর্বোচ্চ GPU memory ২,৮১০ MiB, seed ০; validation macro-F1 ০.৯৩০৪। পর্ব ৪৮-এ একই model-এর ৫ ভাগের গড় macro-F1 ০.৯২৪; এখানকার test-এর ০.৯২৫৮ (নিচে) তার কাছাকাছি।

Export-এ batch আর token-সংখ্যা দুটিই dynamic (input ['batch', 'seq']), opset ২০, ২৮৭টি node, ৪.৫ সেকেন্ডে। পথে তিনটি সত্যিকারের বাধা এসেছিল, যা আপনিও পেতে পারেন:

pre_process with symbolic shape inference -> Exception : Incomplete symbolic shape inference
pre_process with skip_symbolic_shape=True -> ok
quantize_dynamic -> InferenceError : [ShapeInferenceError] Inferred shape and existing shape differ in dimension 0: (768) vs (2)
value_info entries removed: 414
quantize_dynamic after clearing value_info -> ok

এক, ORT-এর symbolic shape inference নতুন exporter-এর graph পুরো বোঝেনি; ধাপটি বাদ দেওয়া গেছে। দুই, exporter-এর লেখা আকার-টীকা (value_info) quantizer-এর হিসাবের সঙ্গে মেলেনি; টীকা মুছে দিলে quantizer নিজে আবার হিসাব করে। আগে আরেকটি: pre-processing আলাদা ফোল্ডারে গিয়ে .onnx.data পায়নি; একটিমাত্র ৫১৭ MiB-এর ফাইলে লিখে সমাধান। প্রতিটির পর output আবার মেলানো হয়েছে।

নিচের ছকে ২,১৪৩টি test মন্তব্যে macro-F1, PyTorch fp32-এর সঙ্গে বদলানো সিদ্ধান্ত আর logit-এর সর্বোচ্চ পার্থক্য। সময়: ২০০টি এলোমেলো মন্তব্য এক এক করে (batch ১), আর ৪০টি এলোমেলো ৩২-এর batch, warm-up-এর পর; “পুরো test” মানে দৈর্ঘ্য অনুযায়ী সাজিয়ে ৬৪-এর batch-এ। ১ thread দিয়ে কম শক্তির CPU-র একটি মোটা নকল, ফোনের মাপ নয়। সত্যিকারের run:

কোন সেটিং দায়ী, তা দেখতে একই pre-processed graph থেকে আরও চারটি int8 রূপ বানিয়ে শুধু মান আর batch ১-এর সময় মাপা হলো (৩ thread; আলাদা run, যন্ত্রে অন্য কাজও চলছিল, তাই সময় একটু ওঠানামা করে):

৬ · Latency budget — p50, p95, batch আর thread

Percentile আর tail latency-র সংজ্ঞা সিস্টেম ডিজাইন কোর্সের পর্ব ৪-এ: nearest-rank-এ p95 হলো সাজানো তালিকার ⌈০.৯৫ × n⌉-তম মান। এখানে প্রশ্ন সিদ্ধান্তের: budget দেওয়া থাকলে কোন model, কোন batch আকার, কয়টি thread? Stepper-এর প্রথম তিন ধাপ অংশ ৫-এর run, বাকিগুলো একই model-এর আলাদা sweep:

এবার নিজে হিসাব করুন। নিচের CSV-তে অংশ ৫-এর int8 model-এর ২০০টি সত্যিকারের সময় (batch ১, ৩ thread, ms). কোড percentile, budget-এর বিচার আর Little-এর সূত্র (L = λ · W: গড়ে একসঙ্গে চলমান অনুরোধ = আগমনের হার × প্রতিটির গড় সময়) দিয়ে একটি worker-এর ক্ষমতা আন্দাজ করে। প্রথমবার matplotlib লোড হতে কয়েক সেকেন্ড লাগে।

import numpy as np
import matplotlib.pyplot as plt
ms = np.loadtxt("t_int8_b1.csv", skiprows=1)   # ২০০টি সত্যিকারের মাপ: batch 1, int8, 3 thread
s = np.sort(ms)

def nearest_rank(q):                           # সাজানো তালিকার ⌈q·n⌉-তম মান
    return s[int(np.ceil(q * len(s))) - 1]

print(f"n = {len(ms)}, গড় {ms.mean():.2f} ms, সর্বনিম্ন {s[0]:.2f}, সর্বোচ্চ {s[-1]:.2f}")
for q in (0.50, 0.95, 0.99):
    print(f"p{int(q * 100):<3d} nearest-rank {nearest_rank(q):6.2f} │ NumPy linear {np.percentile(ms, q * 100):6.2f}")
budget = 20.0
verdict = "পাস" if nearest_rank(0.95) <= budget else "ফেল"
print(f"budget p95 ≤ {budget} ms → {verdict}; budget-এর চেয়ে ধীর: {(ms > budget).mean():.1%}")

cap = 1000 / ms.mean()                         # একটি worker, একবারে একটি অনুরোধ
print(f"একটি worker-এর সর্বোচ্চ ≈ {cap:.0f} অনুরোধ/সেকেন্ড")
for lam in (50, 100, 150):                     # আগমনের হার, অনুরোধ/সেকেন্ড
    print(f"λ = {lam:3d}/s → ব্যস্ততা ρ = {lam / cap:4.0%},"
          f" L = λ·W ≥ {lam * ms.mean() / 1000:.2f} (অপেক্ষা বাদে)")

fig, ax = plt.subplots(figsize=(6, 3))
ax.hist(ms, bins=30, color="#2563eb")
for q, c in ((0.50, "#059669"), (0.95, "#d97706")):
    ax.axvline(nearest_rank(q), color=c, ls="--", label=f"p{int(q * 100)}")
ax.set_xlabel("latency (ms), batch 1, int8, 3 threads")
ax.set_ylabel("count")
ax.legend()
plt.show()

n = 200, গড় 7.81 ms, সর্বনিম্ন 2.40, সর্বোচ্চ 21.91
p50  nearest-rank   6.15 │ NumPy linear   6.18
p95  nearest-rank  18.21 │ NumPy linear  18.21
p99  nearest-rank  20.47 │ NumPy linear  20.48
budget p95 ≤ 20.0 ms → পাস; budget-এর চেয়ে ধীর: 2.0%
একটি worker-এর সর্বোচ্চ ≈ 128 অনুরোধ/সেকেন্ড
λ =  50/s → ব্যস্ততা ρ =  39%, L = λ·W ≥ 0.39 (অপেক্ষা বাদে)
λ = 100/s → ব্যস্ততা ρ =  78%, L = λ·W ≥ 0.78 (অপেক্ষা বাদে)
λ = 150/s → ব্যস্ততা ρ = 117%, L = λ·W ≥ 1.17 (অপেক্ষা বাদে)

৭ · FastAPI service — ইনপুট যাচাই, micro-batching আর health check

FastAPI-র মূল কথা Full-Stack Web Frameworks কোর্সের পর্ব ৬৯-এ, আর model-এর জন্য /health ও /predict-এর নকশা মেশিন লার্নিং কোর্সের পর্ব ৬৮-এ। Deep learning-এ তিনটি জিনিস যোগ হয়: tokenizer-কে model-এর সঙ্গে একই process-এ রাখা, লেখার দৈর্ঘ্যের সীমা (না হলে একটি বিশাল লেখা সবার সময় খায়), আর অনেক ছোট অনুরোধ জোড়া দিয়ে একবারে চালানোর micro-batching: সারিতে আসা অনুরোধ সর্বোচ্চ ১৬টি বা ৫ ms পর্যন্ত জমিয়ে একটি batch. Service শুধু 127.0.0.1-এ খোলা, model অংশ ৫-এর per-channel + reduce-range int8:

# serve.py — ছোট করা (পুরো ফাইল ৭৩ লাইন)
class Req(BaseModel):
    model_config = ConfigDict(extra="forbid")          # অজানা field হলে 422
    texts: list[Annotated[str, StringConstraints(strip_whitespace=True,
                min_length=1, max_length=500)]] = Field(min_length=1, max_length=32)

def infer(texts):                                      # tokenizer + ORT int8, একসঙ্গে
    enc = tok(texts, truncation=True, max_length=100, padding=True, return_tensors="np")
    z = sess.run(None, {"input_ids": enc["input_ids"].astype(np.int64),
                        "attention_mask": enc["attention_mask"].astype(np.int64)})[0]
    e = np.exp(z - z.max(1, keepdims=True))
    return (e[:, 1] / e.sum(1)).tolist()

async def batcher():                                   # micro-batch: ≤ 16টি লেখা বা 5 ms
    while True:
        items = [await queue.get()]
        t_end = time.perf_counter() + MAX_WAIT
        while sum(len(t) for t, _ in items) < MAX_BATCH and (left := t_end - time.perf_counter()) > 0:
            try: items.append(await asyncio.wait_for(queue.get(), left))
            except asyncio.TimeoutError: break
        probs = await asyncio.to_thread(infer, [s for t, _ in items for s in t])
        ...                                            # প্রতিটি অনুরোধকে নিজের অংশ ফেরত

@app.get("/health")
async def health():
    return {"status": "ok", "model_version": VERSION, "runtime": f"onnxruntime {ort.__version__}", "batching": BATCH}

সত্যিকারের run: একটি script server চালু করে তার PID রাখে, অনুরোধ পাঠায়, তারপর সেই PID ধরেই বন্ধ করে। লোড: test থেকে seed ৪২-এ বাছা ৩২০টি মন্তব্য, একসঙ্গে সর্বোচ্চ ১৬টি অনুরোধ (প্রতিটিতে একটি লেখা)। Output (ছোট করা: server চালু হওয়ার লাইন বাদ, দুটি load test-এর আগে বাংলা লেবেল যোগ):

test texts: 2143 | longer than 500 chars: 18 | longest: 1474
GET /health -> 200 {'status': 'ok', 'model_version': 'bazarghar-sentiment-2026.11.1', 'runtime': 'onnxruntime 1.31.1', 'batching': False}
POST /predict -> 200 {'model_version': 'bazarghar-sentiment-2026.11.1', 'p_positive': [0.9873, 0.0064], 'label': ['positive', 'negative']}
bad {"texts": []} -> 422 too_short
bad {"texts": ["   "]} -> 422 string_too_short
bad {"texts": ["ককককককক… (৫০১ অক্ষর) -> 422 string_too_long
bad {"text": "hi"} -> 422 missing
batching বন্ধ: {"p50": 126.95, "p95": 156.05, "mean": 126.47, "n": 320, "rps": 122.13, "wall_s": 2.62}
batching চালু: {"p50": 212.57, "p95": 287.46, "mean": 214.82, "n": 320, "rps": 71.97, "wall_s": 4.45}
server stopped, exit code 1   # দুবারই, নিজের PID ধরে terminate

Package: Dockerfile, নমুনা. Server-এ পাঠানোর সাধারণ পথ container: model-এর ফাইল, tokenizer, কোড আর ঠিক version-এর library একটি image-এ। নিচের Dockerfile একটি নমুনা, এই পর্বে চালানো হয়নি (Docker চালু করা হয়নি); কাঠামো দেখানোর জন্য। Multi-stage build আর non-root user-এর যুক্তি ক্লাউড ও DevOps কোর্সের পর্ব ৩৮-এ।

# নমুনা — চালানো হয়নি
FROM python:3.12-slim
WORKDIR /app
COPY requirements.lock .
RUN pip install --no-cache-dir -r requirements.lock
# ওজন, tokenizer আর কোড একসঙ্গে; .onnx.data থাকলে সেটিও
COPY bert_int8_pcrr.onnx serve.py ./
COPY bert_ft/tokenizer* bert_ft/vocab.txt ./bert_ft/
ENV MODEL_VERSION=bazarghar-sentiment-2026.11.1 OMP_NUM_THREADS=3
RUN useradd -m app
USER app
EXPOSE 8000
CMD ["uvicorn", "serve:app", "--host", "0.0.0.0", "--port", "8000"]

Container-এর ভেতরে 0.0.0.0 লাগে, যাতে বাইরের port-mapping কাজ করে; কিন্তু container-টি নিজে কোথায় খোলা থাকবে (শুধু ভেতরের নেটওয়ার্কে, gateway-এর পেছনে), তা আলাদা সিদ্ধান্ত। আমাদের desktop-এর পরীক্ষায় server শুধু 127.0.0.1-এ খোলা হয়েছিল।

৮ · Edge device — ফোন, browser আর বিশেষ হার্ডওয়্যার

Edge device মানে ব্যবহারকারীর নিজের যন্ত্র: ফোন, browser, দোকানের ছোট কম্পিউটার। লাভ: ইন্টারনেট ছাড়াও চলে (দুর্বল নেটওয়ার্ক বা লোডশেডিং-এর সময় কাজের), ডেটা যন্ত্র ছাড়ে না, server-এর খরচ নেই। দাম: কম memory আর thread, ব্যাটারি, app-এর আকার। নিচের বিবরণ প্রতিটির নিজের নথি থেকে, লেখার সময়ে (নভেম্বর ২০২৬), পরিবর্তন হতে পারে; তুলনামূলক মান বিচার করা হয়নি:

যেকোনো runtime বাছাইয়ে প্রশ্ন একই: আমার model-এর সব operation এটি চেনে কি না, int8 বা fp16 সমর্থন আছে কি না, আর লক্ষ্য-যন্ত্রে সময় কত। শেষটির বিকল্প নেই; আমাদের কাছে ফোন ছিল না, তাই ১ thread-এর মাপগুলো কেবল “কম CPU”-র নকল।

Budget মেলানো একটি ছোট হিসাব: প্রতিটি লক্ষ্য-যন্ত্রের সর্বোচ্চ আকার আর p95, আর প্রতিটি প্রার্থী model-এর মাপা আকার ও p95. নিচের কোডে আমাদের desktop-এ মাপা সংখ্যা ডেটা হিসেবে বসানো; budget-গুলো উদাহরণ, বাজারঘরের দলের ধরা লক্ষ্য:

import pandas as pd
pd.set_option("display.width", 70)
cand = pd.DataFrame([            # desktop-এ মাপা: আকার MiB, macro-F1, p95 ms (3 আর 1 thread)
    ("PyTorch fp32", 516.2, 0.9258, 33.0, 79.5),
    ("ORT fp32", 517.2, 0.9258, 28.9, 75.2),
    ("ORT int8", 129.3, 0.9061, 18.2, 45.3),
    ("int8 pc+rr", 129.5, 0.9190, 17.9, 61.9),
], columns=["model", "mib", "f1", "p95_3t", "p95_1t"])

targets = {                      # উদাহরণ-লক্ষ্য: সর্বোচ্চ MiB, কোন p95, সর্বোচ্চ ms, সর্বনিম্ন F1
    "server": (1024, "p95_3t", 50, 0.92),
    "phone": (150, "p95_1t", 50, 0.90),
    "phone-strict": (150, "p95_1t", 40, 0.91),
}
for name, (mx, col, lim, f1) in targets.items():
    chk = pd.DataFrame({"model": cand.model, "size": cand.mib <= mx,
                        "speed": cand[col] <= lim, "quality": cand.f1 >= f1})
    chk["pass"] = chk[["size", "speed", "quality"]].all(axis=1)
    ok = list(chk.model[chk["pass"]])
    print(f"{name:12s} → {', '.join(ok) if ok else 'কোনোটিই নয়'}")
    if not ok:
        print(chk.to_string(index=False))

server       → PyTorch fp32, ORT fp32
phone        → ORT int8
phone-strict → কোনোটিই নয়
       model  size  speed  quality  pass
PyTorch fp32 False  False     True False
    ORT fp32 False  False     True False
    ORT int8  True  False    False False
  int8 pc+rr  True  False     True False

৯ · Version, rollback আর নজরদারি

চালু করার পর তিনটি অভ্যাস model-কে নিরাপদ রাখে।

এক, প্রতিটি উত্তরে version. আমাদের service প্রতিটি উত্তরে model_version ফেরত দেয়। সেই নামের পেছনে একটি স্থির রেকর্ড থাকা চাই: কোন ডেটা আর split, কোন কোডের অবস্থা, কোন seed, test-এর মাপ, export-এর opset, runtime-এর version, আর ফাইলের hash. এমন রেকর্ড রাখার জায়গাকে বলে model registry; ছোট দলে একটি ফোল্ডার আর একটি JSON ফাইলও যথেষ্ট, যদি নিয়ম মেনে রাখা হয়। পর্ব ১৯ · Experiment tracking-এর রেকর্ড এখান থেকেই শুরু, আর মানুষের পড়ার জন্য একটি model card.

দুই, ধাপে ধাপে চালু, আর ফেরার পথ খোলা. নতুন model আগে shadow-এ: আসল অনুরোধের কপি পায়, উত্তর দেখানো হয় না, শুধু পুরনোটির সঙ্গে মেলানো হয়। তারপর canary: অল্প কিছু ব্যবহারকারী, তারপর বেশি। সমস্যা হলে rollback: আগের version-এর ফাইলে ফেরা, যা মুছে ফেলা চলবে না। নতুন model-এর input-output চুক্তি (input-এর নাম, আকার, শ্রেণির ক্রম) পুরনোটির সমান রাখুন, তাহলে ফেরা মানে শুধু একটি pointer বদলানো। এই কৌশলগুলোর সাধারণ রূপ মেশিন লার্নিং কোর্সের পর্ব ৬৮ আর ক্লাউড ও DevOps কোর্সের পর্ব ৫৯-এ আছে।

তিন, ভেতরে কী ঢুকছে আর কী বের হচ্ছে, তা দেখা. Label প্রায়ই দেরিতে আসে, তাই মানের আগে লক্ষণ দেখতে হয় (মেশিন লার্নিং কোর্সের পর্ব ৬৯-এর চার স্তর)। Deep learning-এ যা নজরে রাখা কাজের:

• Input-এর লক্ষণ: ছবির আকার আর উজ্জ্বলতা; লেখার token-সংখ্যা, অচেনা token-এর হার, রোমান হরফে লেখা বাংলার ভাগ। Data drift-এর প্রথম ইঙ্গিত এখানে।
• Output-এর লক্ষণ: শ্রেণির অনুপাত আর softmax-এর সর্বোচ্চ probability-র বণ্টন; হঠাৎ বদল হলে খতিয়ে দেখুন।
• System-এর মাপ: p50/p95, error-এর হার, ৪২২-এর হার (ভুল input), CPU আর memory. ৪২২ বেড়ে যাওয়া মানে কোনো client ভুল ফরম্যাটে পাঠাচ্ছে।
• মান, যখন label আসে: একই slice-এ (জেলা, পণ্যের ধরন, লেখার ধরন) মাপুন; ইনপুট-আউটপুটের সম্পর্কই বদলে যাওয়া হলো concept drift, যার উত্তর আবার শেখানো।

ব্যক্তিগত তথ্য থাকলে log-এ পুরো লেখা না রেখে দৈর্ঘ্য, ভাষা আর confidence-এর মতো সারাংশ রাখুন। বাংলাদেশে ব্যক্তিগত উপাত্ত সুরক্ষা আইন ২০২৬ আর সংশ্লিষ্ট আইন এখন প্রযোজ্য; log আর retention-এর নিয়ম ঠিক করার আগে আইনজ্ঞের পরামর্শ নিন।

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

Export আর serving-এর কোড AI assistant দ্রুত লেখে, কিন্তু এই ক্ষেত্রের API দ্রুত বদলায়। আমাদের run-এই torch 2.15.0 torch.jit.trace-কে deprecated বলেছে, ONNX exporter-এর ডিফল্ট torch 2.9-এ বদলেছে, আর dynamic_axes-এর জায়গায় dynamic_shapes এসেছে। পুরনো টিউটোরিয়াল থেকে শেখা AI প্রায়ই পুরনো পথ দেয়।

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

• torch, onnx আর onnxruntime-এর version লিখে নিজের version-এর নথিতে API মিলিয়েছি
• Export-এর আগে model.eval(); ORT-এর output-এর max |diff| আর সিদ্ধান্ত মিলিয়েছি, অন্য batch আকারেও
• Preprocessing আর tokenizer model-এর সঙ্গে একই package-এ, version নম্বরসহ
• int8-এর আগে-পরে একই test-এ মান, বদলানো উত্তরের সংখ্যা আর warm-up-এর পর p50/p95 মেপেছি
• Service-এ ইনপুটের সীমা, /health, আর নিজের PID ধরে বন্ধ করার ব্যবস্থা আছে
• কোনো token, গোপন চাবি বা গ্রাহকের লেখা prompt-এ দিইনি