সরাসরি পর্বে যান
পর্ব ৭৮ · ৮৫-এর মধ্যে · মডিউল ১৩

Edge AI আর TinyML — microcontroller-এ ছোট model

Edge AI and TinyML — Small Models on a Microcontroller

Taught in Bangla, this lesson brings a model onto the device so the cold room reports "door open" instead of streaming readings. It follows the TinyML workflow from simulated data to an 8-8-3 network with 99 parameters that gets 298 of 300 test windows right, against 79.3% for a hand rule. It explains int8 scale, zero point and integer requantization, then runs both versions on the virtual BG-M3 board: 385 cycles for int8 versus 10,329 for soft-float with identical decisions, then a live run with its limits.

এই পর্বে যা শিখবেন

  • Edge AI আর TinyML কী, কখন model device-এ চালানো লাভজনক আর কখন নয়
  • TinyML-এর কাজের ধারা: data থেকে device-এ মাপা পর্যন্ত প্রতিটি ধাপ আর তার যাচাই
  • int8 quantization: scale আর zero point হিসাব, symmetric বনাম asymmetric, bias কেন int32
  • শুধু integer দিয়ে একটি dense layer: requantization-এর গুণক m ÷ 2sh, আর Clang-এর আসল assembly
  • Board-এ float বনাম int8: cycle, flash, accuracy মাপা, আর model-এর সীমা ও ঝুঁকি চেনা

১ · Edge AI কেন — model-কে device-এর কাছে আনা

পাড়ার একটি মুদি দোকানের কথা ভাবুন। প্রতিটি ক্রেতা এলে দোকানদার মালিককে ফোন করে জিজ্ঞেস করেন না “এই চাল কত দামে দেব?” তিনি নিজেই হিসাব করেন, নিজেই সিদ্ধান্ত নেন, আর দিনের শেষে মালিককে শুধু সারাংশ জানান। ফোনের খরচ বাঁচে, ক্রেতাকে দাঁড়িয়ে থাকতে হয় না, আর মালিকের লাইন ব্যস্ত থাকলেও দোকান চলে। Edge AI ঠিক এই ধারণা: শেখা একটি model-কে cloud-এ না রেখে যে যন্ত্র মাপ নেয় তার কাছেই চালানো।

পর্ব ৭০-এ device, gateway, edge computing আর cloud-এর স্তর দেখেছেন। এই পর্বে সবচেয়ে নিচের স্তরে যাব: কয়েক কিলোবাইট RAM-এর একটি microcontroller-এ model চালানো, যার প্রচলিত নাম TinyML. শেখা model দিয়ে নতুন input-এর উত্তর বের করাকে বলে inference; শেখানো (training) সাধারণত বড় কম্পিউটারে হয়, আর device শুধু inference চালায়।

কারণমানেবাজারঘরের cold room-এ
Latencyসিদ্ধান্ত মাপের পাশেই, network-এর আসা-যাওয়া নেইদরজা খোলা ধরা পড়ে কয়েক সেকেন্ডে, internet ধীর হলেও
গোপনীয়তাকাঁচা data device ছাড়ে নাঘরের প্রতি সেকেন্ডের ইতিহাস বাইরে যায় না, শুধু ঘটনা যায়
Bandwidthকম বার্তা, কম radio-সময়প্রতি 1 s-এ মাপ পাঠালে দিনে 86 400টি বার্তা; README-র telemetry প্রতি 10 s-এ, দিনে 8 640টি
শক্তিRadio প্রায়ই CPU-র চেয়ে বেশি শক্তি খায়Battery-চালিত sensor-এ পাঠানো কমালে আয়ু বাড়ে (পর্ব ৬২)
নির্ভরযোগ্যতাসংযোগ গেলেও কাজ চলেLoad-shedding-এ router বন্ধ, তবু device নিজে সতর্ক করতে পারে

দামও আছে। Device-এর সম্পদ খুব সীমিত: কোর্সের virtual বাজারঘর board BG-M3 (আসল কোনো পণ্য নয়, Cortex-M3 chip-এর আদলে বানানো একটি শিক্ষণ-মডেল) চলে 8 MHz-এ, flash মাত্র 128 KiB, SRAM 20 KiB, আর Cortex-M3-এ কোনো FPU নেই। তাই model হতে হবে ছোট, হিসাব হতে হবে integer-এ, আর model বদলাতে হলে firmware update লাগে। এই পর্বের ঠিকানা আর মান C-এর ধরনে, যেমন 0x20000000.

উপমা: Model হলো দোকানদারের অভিজ্ঞতা। বহু বছর দেখে তিনি জানেন কোন ক্রেতা দরদাম করবেন (training); প্রতিদিনের কাজে সেই অভিজ্ঞতা খাটান (inference). অভিজ্ঞতা অর্জন ধীর আর ব্যয়বহুল, খাটানো দ্রুত আর সস্তা। TinyML-এ প্রথমটি বড় কম্পিউটারে, দ্বিতীয়টি ছোট chip-এ।

২ · TinyML-এর কাজের ধারা — data থেকে device পর্যন্ত

একটি TinyML প্রকল্প কয়েকটি ধাপে চলে, আর প্রতিটি ধাপের একটি পরিমাপযোগ্য ফল থাকে। নিচের stepper এই পর্বের পুরো কাজটি এক নজরে দেখায়; প্রতিটি সংখ্যা পরের অংশগুলোর সত্যিকারের run থেকে নেওয়া।

  1. Data900জানালা
  2. Feature8পার্থক্য
  3. Trainfloat৯৯টি সংখ্যা
  4. Quantizeint8scale, zero point
  5. DeployC arrayfirmware
  6. মাপাcycleaccuracy
datasimulated, seed 78
৩ শ্রেণি: normal, door, fault
train: 3 × 200 = 600 জানালা
test : 3 × 100 = 300 জানালা
প্রতিটি জানালা: 17টি মাপ, 1 s পরপর
featureশুরুর মাপ থেকে কত উঠল
x[i] = T[2(i+1)] − T[0], i = 0..7
একক: sensor-এর LSB = 0.0625 °C
উদাহরণ (t = 24 s): 0 0 0 0 0 0 4 8
trainnumpy, gradient descent
8 → 8 (ReLU) → 3
parameter: 64 + 8 + 24 + 3 = 99
test accuracy: 0.9933 (298/300)
quantizepost-training, int8
float: 99 × 4 = 396 byte
int8 : 88 weight + 11 × 4 bias = 132 byte
int8 test accuracy: 298/300
deploycoldai.c, map file
.text (flash) : 3104 byte, পুরো firmware
classify_q    :  680 byte কোড
.bss (SRAM)   :   72 byte
মাপাBG-M3, 8 MHz
int8 : 385 cycle প্রতি জানালা
float: 10329 cycle (soft-float)
live : দরজা খোলার 4 s পরে "door open"
  1. Data. সবকিছুর শুরু data-তে। এখানে data simulated: lab-এর একটি script seed 78 দিয়ে তিন রকম ঘটনার ৯০০টি ১৭-সেকেন্ডের জানালা বানিয়েছে। আসল প্রকল্পে এটিই সবচেয়ে দীর্ঘ ধাপ।
  2. Feature. ১৭টি কাঁচা মাপ থেকে ৮টি সংখ্যা: প্রতি দুই সেকেন্ডে শুরুর তুলনায় তাপমাত্রা কত LSB উঠল। ছোট model-এ ভালো feature অর্ধেক কাজ করে দেয়।
  3. Train. ৮টি input, ৮টি hidden neuron, ৩টি output; মোট ৯৯টি সংখ্যা। Float-এ শেখানো, test data-য় 298/300 ঠিক।
  4. Quantize. প্রতিটি সংখ্যাকে ৮ বিটে আনা হয়, scale আর zero point দিয়ে। আকার 396 থেকে 132 byte, আর accuracy একই রইল।
  5. Deploy. int8 weight C-এর const array হয়ে flash-এ যায়। পুরো live firmware-এর কোড আর ধ্রুবক মিলে 3104 byte, SRAM-এ মাত্র 72 byte স্থায়ী data.
  6. মাপা. Device-এ চালিয়ে সময়, accuracy আর আচরণ মাপা। এখানে ধরা পড়ে এমন ভুল, যা কাগজে দেখা যায়নি; তখন আবার প্রথম ধাপে ফেরা।

বাস্তবে এই ধারা একটি চক্র, সরলরেখা নয়। Device-এ মাপার পর প্রায়ই দেখা যায় model বড়, বা ধীর, বা নতুন রকম data-য় ভুল করে; তখন feature বা model বদলে আবার train. Machine Learning কোর্স এই ধারার পরিসংখ্যান আর ML-এর দিক শেখায়; এখানে আমরা দেখব embedded দিক: সংখ্যা কীভাবে chip-এ বসে, কত cycle খায়, আর কোথায় ভাঙে।

৩ · বাজারঘরের প্রশ্ন — দরজা খোলা, নাকি compressor বিকল?

বাজারঘরের cold-storage monitor প্রতি 1 s-এ I2C sensor থেকে তাপমাত্রা পড়ে, আর README-র নিয়মে 8.00 °C-এর ওপরে পরপর ৩টি মাপ হলে alarm দেয় (পর্ব ৫১, পর্ব ৬৫)। কিন্তু 8 °C পৌঁছানোর অনেক আগেই দুটি আলাদা ঘটনা চেনা কাজের। দরজা খোলা: গরম বাতাস ঢুকে তাপমাত্রা দ্রুত ওঠে, দরজা বন্ধ হলে আবার নামে; দোকানের কর্মীকে মনে করিয়ে দিলেই যথেষ্ট। Compressor বিকল: তাপমাত্রা ধীরে কিন্তু থামাহীন ওঠে; মিস্ত্রি ডাকতে হবে, আর আগে জানলে মাছ-মাংস বাঁচে। স্বাভাবিক অবস্থায়ও compressor চলা-থামায় তাপমাত্রা সামান্য ওঠানামা করে।

সততার কথা: এই পর্বের সব data simulated, কোনো আসল cold room থেকে মাপা নয়। ঘটনার হার (দরজায় 0.06–0.20 °C/s ওঠা, বিকলে 0.02–0.05 °C/s) আর noise (σ = 0.03 °C) শেখানোর জন্য বেছে নেওয়া, কোনো পরিমাপের পরিসংখ্যান নয়। আসল প্রকল্পে প্রথম কাজ আসল ঘরে মাপ নিয়ে ঘটনাগুলোর label দেওয়া।

Model-টি একটি ছোট neural network, যাকে বলা হয় multilayer perceptron. প্রতিটি dense layer-এ প্রতিটি output হলো সব input-এর weight-গুণিত যোগফল আর একটি bias; প্রথম স্তরের পরে ReLU নামের activation function ঋণাত্মক মান শূন্য করে। শেষ স্তরের তিনটি score-এর মধ্যে সবচেয়ে বড়টি সিদ্ধান্ত। Training-এ softmax আর cross-entropy loss দিয়ে gradient descent চলে; তত্ত্ব আছে Deep Learning পর্ব ০৩ আর পর্ব ০৪-এ, আর Machine Learning পর্ব ১৩-এ। এখানে আমরা সেটি শুধু ব্যবহার করব।

Input হিসেবে ১৭টি কাঁচা মাপ না দিয়ে ৮টি feature দেওয়া হয়: শুরুর মাপ থেকে ২, ৪ … ১৬ সেকেন্ডে কত LSB উঠল। এতে ঘরের মূল তাপমাত্রা (4 °C না 5 °C) বাদ যায়, শুধু আকৃতি থাকে। আর একটি সুবিধা: পার্থক্যগুলো sensor-এর নিজের পূর্ণসংখ্যা (1 LSB = 0.0625 °C), তাই পরে int8-এ আনতে কোনো ভুল ঢোকে না। নিচের block পুরো data বানায় আর model শেখায়; প্রতি জানালা একটি sliding window-এর এক অবস্থান।

# Cold room-এর simulated data (seed 78) আর ছোট 8-8-3 model, numpy-তে (lab-এর train.py)
import numpy as np
rng = np.random.default_rng(78)
NAMES = ["normal", "door", "fault"]
def window(kind):                     # 17টি মাপ, 1 s পরপর, 1/16 °C এককে
    t = np.arange(17.0)
    T = 4.0 + rng.normal(0, 0.03, 17)
    if kind == 0:                     # compressor চলা-থামা: ধীরে ওঠানামা
        T += rng.uniform(-0.012, 0.012) * t
    elif kind == 1:                   # দরজা t0-তে খোলে, d সেকেন্ড পরে বন্ধ হয়
        t0, d = rng.uniform(-6, 12), rng.uniform(3, 15)
        T += rng.uniform(0.06, 0.2) * np.clip(t - t0, 0, d) - 0.08 * np.clip(t - t0 - d, 0, None)
    else:                             # compressor বিকল: ধীর, একটানা ওঠা
        T += rng.uniform(0.02, 0.05) * t
    q = np.round(T * 16)              # sensor: 0.0625 °C প্রতি LSB
    return np.clip(q[2::2] - q[0], -128, 127)      # ৮টি feature: শুরু থেকে কত উঠল
def dataset(n):
    y = np.repeat([0, 1, 2], n)
    return np.array([window(k) for k in y]), y

Xq, y = dataset(200); Xtq, yt = dataset(100)       # train 600, test 300
X, Xt = Xq * 0.0625, Xtq * 0.0625                  # float model-এর input °C-এ
W1 = rng.normal(0, 0.5, (8, 8)); b1 = np.zeros(8)
W2 = rng.normal(0, 0.5, (8, 3)); b2 = np.zeros(3)
for it in range(3000):                             # full-batch gradient descent
    h = np.maximum(X @ W1 + b1, 0); z = h @ W2 + b2
    p = np.exp(z - z.max(1, keepdims=True)); p /= p.sum(1, keepdims=True)
    g = p.copy(); g[np.arange(len(y)), y] -= 1; g /= len(y)
    gh = (g @ W2.T) * (h > 0)
    W2 -= 0.2 * h.T @ g; b2 -= 0.2 * g.sum(0); W1 -= 0.2 * X.T @ gh; b1 -= 0.2 * gh.sum(0)

predict = lambda A: (np.maximum(A @ W1 + b1, 0) @ W2 + b2).argmax(1)
print("train accuracy:", (predict(X) == y).mean(), " test accuracy:", (predict(Xt) == yt).mean())
for k in range(3):
    print(NAMES[k], "->", np.bincount(predict(Xt)[yt == k], minlength=3))

আসল আউটপুট (ব্রাউজারের Python, numpy):

train accuracy: 0.9983333333333333  test accuracy: 0.9933333333333333
normal -> [100   0   0]
door -> [ 1 98  1]
fault -> [  0   0 100]

আমার lab-এ (numpy 2.5.5) একই script হুবহু এই সংখ্যাগুলো দিয়েছে। শেষ তিন লাইন একটি confusion matrix: প্রতিটি আসল শ্রেণির ১০০টি জানালা model কোন শ্রেণিতে ফেলেছে। ৩০০টির মধ্যে ভুল মাত্র ২টি, দুটিই “door”: একটিকে normal আর একটিকে fault বলা হয়েছে। Train আর test set-এর accuracy কাছাকাছি (99.8% আর 99.3%), তাই model মুখস্থ করেনি। মনে রাখবেন, এটি simulated data-র ফল; আসল ঘরে এত পরিষ্কার হওয়ার কোনো নিশ্চয়তা নেই।

এখন একটি সৎ প্রশ্ন: এত কিছুর কি দরকার ছিল? সবচেয়ে সহজ নিয়মটি দেখি: ১৬ সেকেন্ডে মোট কত উঠল (x[7]), বেশি হলে door, মাঝারি হলে fault. নিচের block train data-য় সেরা দুটি সীমা খুঁজে test-এ চালায়।

# হাতে লেখা নিয়ম বনাম model: শুধু 16 s-এ মোট ওঠা (x[7]) দেখে সিদ্ধান্ত
def rule(A, hi, lo):                  # x[7] ≥ hi → door, ≥ lo → fault, নইলে normal
    r = A[:, 7]
    return np.where(r >= hi, 1, np.where(r >= lo, 2, 0))

acc, hi, lo = max(((rule(Xq, a, b) == y).mean(), a, b) for a in range(6, 40) for b in range(1, a))
print(f"best rule on train: door if rise >= {hi}/16 C, fault if >= {lo}/16 C, acc {acc:.3f}")
p = rule(Xtq, hi, lo)
print("rule test accuracy:", (p == yt).mean())
for k in range(3):
    print(NAMES[k], "->", np.bincount(p[yt == k], minlength=3))

আসল আউটপুট:

best rule on train: door if rise >= 14/16 C, fault if >= 5/16 C, acc 0.790
rule test accuracy: 0.7933333333333333
normal -> [100   0   0]
door -> [31 39 30]
fault -> [ 0  1 99]

নিয়মটি normal আর fault প্রায় নিখুঁত চেনে, কিন্তু ১০০টি door-এর মধ্যে মাত্র ৩৯টি। কারণ যে জানালায় দরজা খুলে আবার বন্ধ হয়ে তাপমাত্রা নেমে এসেছে, সেখানে “মোট ওঠা” ছোট; আকৃতিটি (ওঠা তারপর নামা) এই নিয়ম দেখে না। Model ৮টি বিন্দুর পুরো আকৃতি দেখে। তবে সিদ্ধান্তে লাফাবেন না: আকৃতি-দেখা একটি চতুর হাতে-লেখা নিয়মও (যেমন “জানালার সর্বোচ্চ ওঠা” আর “শেষে নামা”) হয়তো অনেক ভালো করত। ভাবনার প্রশ্ন ১-এ এ নিয়ে আরও কথা।

৪ · int8 quantization — scale আর zero point

Float-এ শেখা ৯৯টি সংখ্যা প্রতিটি ৪ byte. Microcontroller-এ সেগুলো ৮ বিটের পূর্ণসংখ্যায় আনার নাম int8 quantization. ধারণাটি দাঁড়িপাল্লার বাটখারার মতো: দোকানে প্রতিটি সম্ভাব্য ওজনের বাটখারা থাকে না, থাকে নির্দিষ্ট ধাপের কয়েকটি; প্রতিটি ওজন সবচেয়ে কাছের ধাপে মাপা হয়। এখানে ধাপ ২৫৬টি (−128 থেকে 127), আর এক ধাপের মাপ হলো scale s. যে পূর্ণসংখ্যা আসল 0.0-কে বোঝায়, সেটি zero point z:

আসল মান r ≈ s × (q − z)   ·   q = clamp(round(r ÷ s) + z, −128, 127)

মূল সূত্র

Symmetric (weight-এর জন্য): z = 0, s = max|w| ÷ 127. · Asymmetric (activation-এর জন্য): পাল্লা [rmin, rmax] হলে s = (rmax − rmin) ÷ 255, z = round(−128 − rmin ÷ s). · গোল করার ভুল সর্বোচ্চ s ÷ 2. · Bias: int32, scale = sx × sw, z = 0.

কেন দুই রকম? Weight-গুলো শূন্যের দুই পাশে প্রায় সমানভাবে ছড়ানো, তাই z = 0 রাখলে হিসাব সহজ। কিন্তু ReLU-র পরের মান কখনো ঋণাত্মক নয়; symmetric নিলে −128…−1-এর অর্ধেক ঘর অপচয় হতো। তাই সেখানে পাল্লাটি পুরো 256 ঘরে বসানো হয়: 0.0 যায় −128-এ। আর Python block-এর আগে একটি মজার ব্যাপার: input আগেই পূর্ণসংখ্যা (sensor-এর LSB), তাই sx = 0.0625, zx = 0; input-এর quantization বিনা মূল্যে।

Activation-এর পাল্লা জানতে model-কে কিছু প্রতিনিধিত্বমূলক data-য় চালাতে হয়; এই data-কে বলে calibration data. এখানে train data-র ৬০০টি জানালায় hidden মানের সর্বোচ্চ 9.8514 আর output score-এর পাল্লা −42.4027 থেকে 31.9203. Training শেষে, আবার না শিখিয়ে এই রূপান্তরকে বলে post-training quantization.

ছবি ৭৮.১ — দুটি পাল্লা, দুটি zero point

ওপরে hidden activation (ReLU-র পরে), নিচে output score; প্রতিটি রেখার ওপরে আসল মান, নিচে int8

Asymmetric int8 quantization-এর দুটি পাল্লা hidden: s = 0.038633, z = −128 0.0 9.85 −128 127 1.1267 q = −99 score: s = 0.291463, z = 17 −42.40 31.92 0.0 −128 127 z = 17 2.87 → q = 27
ছবি ৭৮.১ — Asymmetric quantization পাল্লাটিকে পুরো −128…127-এ টেনে বসায়। Score-এর পাল্লা শূন্যের দুই পাশে অসমান (বাঁয়ে 42.40, ডানে 31.92), তাই 0.0 মাঝখানে নয়, int8 17-এ পড়ে। সব সংখ্যা lab-এর quant.py-র run থেকে।

নিচের block ঠিক এই হিসাব করে, তারপর test data-য় শুধু integer দিয়ে model চালায়। এটি আগের block-এর model ব্যবহার করে (একই namespace).

# Post-training int8 quantization আর শুধু-integer inference (lab-এর quant.py)
def mult(M):                          # M ≈ m ÷ 2^sh, যেখানে 2^14 ≤ m < 2^15
    sh = 0
    while M * 2 ** (sh + 1) < 2 ** 15:
        sh += 1
    return int(round(M * 2 ** sh)), sh

rq = lambda acc, m, sh: (acc * m + (1 << (sh - 1))) >> sh     # গোল করে ভাগ

sx = 0.0625                           # input: sensor-এর নিজের LSB, zero point 0
sw1 = np.abs(W1).max() / 127; qW1 = np.round(W1 / sw1).astype(np.int64)
qb1 = np.round(b1 / (sx * sw1)).astype(np.int64)
H = np.maximum(X @ W1 + b1, 0)        # calibration: train data-য় hidden-এর পাল্লা
sh_, zh = H.max() / 255, -128
sw2 = np.abs(W2).max() / 127; qW2 = np.round(W2 / sw2).astype(np.int64)
qb2 = np.round(b2 / (sh_ * sw2)).astype(np.int64)
Z = H @ W2 + b2
sz = (Z.max() - Z.min()) / 255; zz = int(round(-128 - Z.min() / sz))
m1, s1 = mult(sx * sw1 / sh_); m2, s2 = mult(sh_ * sw2 / sz)

def infer_q(xq):                      # শুধু integer: board-এর C-তে ঠিক এটিই চলে
    hq = np.clip(zh + rq(xq.astype(np.int64) @ qW1 + qb1, m1, s1), zh, 127)
    return np.clip(zz + rq((hq - zh) @ qW2 + qb2, m2, s2), -128, 127)

print(f"s_w1={sw1:.6f} s_h={sh_:.6f} zp_h={zh} s_w2={sw2:.6f} s_z={sz:.6f} zp_z={zz}")
print(f"M1={sx * sw1 / sh_:.6f} -> m1={m1}, sh1={s1}   M2={sh_ * sw2 / sz:.6f} -> m2={m2}, sh2={s2}")
pf, pq = predict(Xt), infer_q(Xtq).argmax(1)
print("float acc:", (pf == yt).mean(), " int8 acc:", (pq == yt).mean(), " agree:", (pf == pq).sum(), "/ 300")
print("x=[0,0,0,0,0,0,4,8] -> int8 scores", infer_q(np.array([[0, 0, 0, 0, 0, 0, 4, 8]]))[0].tolist())

আসল আউটপুট:

s_w1=0.028285 s_h=0.038633 zp_h=-128 s_w2=0.034490 s_z=0.291463 zp_z=17
M1=0.045759 -> m1=23991, sh1=19   M2=0.004572 -> m2=19175, sh2=22
float acc: 0.9933333333333333  int8 acc: 0.9933333333333333  agree: 300 / 300
x=[0,0,0,0,0,0,4,8] -> int8 scores [9, 27, 11]

Weight-এর scale 0.028285: প্রথম স্তরের সবচেয়ে বড় |w| (3.5922) ভাগ 127. গোল করার ভুল তাই সর্বোচ্চ অর্ধেক ধাপ; lab-এর হিসাবে বাস্তব সর্বোচ্চ 0.013819, সীমা 0.014142-এর ভেতরে। Score-এর zero point 17 ছবি ৭৮.১-এর সবুজ দাগ। সবচেয়ে গুরুত্বপূর্ণ লাইন তৃতীয়টি: int8 model-এর accuracy float-এর সমান, আর ৩০০টি জানালার প্রতিটিতে সিদ্ধান্ত একই। M1, m1 আর sh1 কী, তা পরের অংশে। শেষ লাইনের তিনটি score (9, 27, 11) পরে board-এর run-এ হুবহু ফিরে আসবে।

৫ · শুধু integer দিয়ে একটি dense layer — requantization

Float-এ একটি neuron: y = Σ wi xi + b. প্রতিটি মানের জায়গায় s(q − z) বসালে, আর weight-এর z = 0 ধরলে:

qy = zy + M × [ Σ qw,i (qx,i − zx) + qb ]   ·   M = sx sw ÷ sy

বন্ধনীর ভেতরের সবটুকু integer: ৮ বিট × ৮ বিটের গুণ, ৩২ বিটের যোগফলে জমা। এই এক জোড়া গুণ-যোগকে বলে MAC. এজন্যই bias-কে int32-এ sx × sw scale-এ রাখা হয়: তখন সেটি যোগফলের সাথে সরাসরি যোগ করা যায়। বাকি থাকে একটি ভগ্নাংশ M, যা দিয়ে যোগফলকে output-এর scale-এ ফেরানো হয়; এই ধাপের নাম requantization. FPU ছাড়া M দিয়ে গুণ কীভাবে? পর্ব ৪০-এর fixed-point কৌশলে: M ≈ m ÷ 2sh, যেখানে m একটি ১৫ বিটের পূর্ণসংখ্যা। প্রথম স্তরে M1 = 0.0625 × 0.028285 ÷ 0.038633 = 0.045759 ≈ 23991 ÷ 219. গুণ, অর্ধেক যোগ, তারপর ডানে ১৯ ঘর shift: গোল করা ভাগ।

ReLU-ও এখানে বিনা খরচে: hidden-এর z = −128 মানে আসল 0.0, তাই −128-এর নিচের সবকিছু −128-এ আটকে দিলেই ঋণাত্মক মান শূন্য। নিচে board-এ চলা আসল কোড, lab-এর nn_int8.h থেকে:

static inline int32_t rq(int32_t acc, int32_t m, int sh)   /* acc x m / 2^sh, rounded */
{
    return (int32_t)(((int64_t)acc * m + ((int64_t)1 << (sh - 1))) >> sh);
}

static int classify_q(const int8_t x[8], int32_t *zout)
{
    int8_t h[8];
    for (int j = 0; j < 8; j++) {                 /* layer 1: 8 -> 8, ReLU */
        int32_t acc = qB1[j];
        for (int i = 0; i < 8; i++)
            acc += x[i] * qW1[j][i];              /* input zero point = 0 */
        h[j] = (int8_t)clamp8(ZP_H + rq(acc, M1, SH1), ZP_H);  /* ReLU = clamp */
    }
    int best = 0;
    int32_t best_z = -129;
    for (int k = 0; k < 3; k++) {                 /* layer 2: 8 -> 3 */
        int32_t acc = qB2[k];
        for (int j = 0; j < 8; j++)
            acc += (h[j] - ZP_H) * qW2[k][j];
        int32_t z = clamp8(ZP_Z + rq(acc, M2, SH2), -128);
        if (zout) zout[k] = z;                    /* optional: the 3 int8 scores */
        if (z > best_z) { best_z = z; best = k; }
    }
    return best;
}

clamp8(v, lo) মানকে lo থেকে 127-এর মধ্যে রাখে। qW1, M1, SH1 ইত্যাদি lab-এর gen_model.py-র বানানো model_q.h থেকে আসে; weight সেখানে static const int8_t, তাই flash-এ থাকে, RAM-এ নয় (পর্ব ৩১)। এবার t = 24 s-এর দরজা-খোলা জানালায় সবচেয়ে “door-প্রেমী” hidden neuron (৬ নম্বর, শূন্য থেকে গোনা) কী হিসাব করে, ধাপে ধাপে দেখি।

Neuron ৬-এর হিসাব (সব মান board-এর কোডের মতো integer)
ধাপ
x₆, x₇
q_w, q_b
acc
acc×m + 2¹⁸
ফল
আসল মানে
  1. Input. জানালার ৮টি পার্থক্যের মধ্যে শুধু শেষ দুটি শূন্য নয়: 4 আর 8 LSB, অর্থাৎ 0.25 আর 0.5 °C. Input-এর zero point 0, তাই এগুলো যেমন আছে তেমনই গুণ হবে।
  2. Weight আর bias. এই neuron-এর শেষ দুটি int8 weight 95 আর 49 (float-এ 2.6808 আর 1.3838, ভাগ 0.028285). Bias int32-এ −133: −0.2354 ÷ (0.0625 × 0.028285) ≈ −133.2.
  3. MAC. acc = 4 × 95 + 8 × 49 − 133 = 380 + 392 − 133 = 639. বাকি ছয়টি input শূন্য, তাদের গুণফলও শূন্য। Board-এ এর প্রতিটি গুণ-যোগ একটি mla instruction.
  4. m দিয়ে গুণ. 639 × 23991 = 15330249; গোল করতে অর্ধেক, 218 = 262144, যোগ করে 15592393. এটি ৩২ বিটে আঁটে, তবু কোড ৬৪ বিটে গুণ করে, কারণ বড় acc-তে উপচে পড়তে পারত।
  5. Shift. 15592393 ÷ 219 = 29.74, ডানে shift নিচের দিকে ছাঁটে: 29. মোট কাজ: acc × M1 = 639 × 0.045759 = 29.24, অর্ধেক যোগের পরে 29-ই।
  6. Zero point আর ReLU. h_q = −128 + 29 = −99. এটি −128-এর ওপরে, তাই ReLU কিছু কাটেনি। আসল মানে (−99 + 128) × 0.038633 = 1.1204; float model বলত 1.1267. পার্থক্য 0.0063, এক ধাপের (0.0386) চেয়ে অনেক ছোট।

MAC যে সত্যিই এক instruction, তা compiler-এর output-এ দেখা যায়। একই ধাপ float-এ লিখলে কী হয়, পাশাপাশি:

সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), --target=thumbv7m-none-eabi -mcpu=cortex-m3 -mfloat-abi=soft -O2 -S:

/* mac.c */
int32_t mac_q(int32_t acc, int8_t x, int8_t w) { return acc + x * w; }
float   mac_f(float acc, float x, float w)      { return acc + x * w; }
int32_t rq1(int32_t acc) { return (int32_t)(((int64_t)acc * 23991 + (1LL << 18)) >> 19); }

mac_q:
	mla	r0, r2, r1, r0
	bx	lr
mac_f:
	push	{r4, lr}
	mov	r4, r0
	mov	r0, r1
	mov	r1, r2
	bl	__aeabi_fmul
	mov	r1, r4
	bl	__aeabi_fadd
	pop	{r4, pc}
rq1:
	movs	r1, #0
	mov.w	r2, #262144
	movw	r3, #23991
	smlal	r2, r1, r0, r3
	lsrs	r0, r2, #19
	orr.w	r0, r0, r1, lsl #13
	bx	lr

(Directive-এর লাইন বাদ।) int8-এর MAC একটি mla. Float-এর একই কাজে দুটি library ফাংশন ডাকা হয়, __aeabi_fmul আর __aeabi_fadd: এটিই soft-float, যেখানে প্রতিটি float হিসাব integer instruction দিয়ে লেখা কয়েক ডজন instruction-এর একটি ফাংশন। Requantization-এর ৬৪ বিটের গুণ-যোগ একটি smlal, তারপর দুটি shift আর একটি OR-এ ৬৪ বিটের ডানে-shift. ARM-এর Cortex-M3 Technical Reference Manual-এর instruction timing table অনুযায়ী Cortex-M3-এ MUL এক cycle আর MLA দুই cycle; SMLAL-এর মতো long multiply কয়েক cycle নেয়, operand-এর আকারভেদে।

৬ · Board-এ float বনাম int8 — cycle, flash আর accuracy

এবার পুরো model board-এ। Lab-এর tinyml.c test data-র ৩০০টি জানালা firmware-এর ভেতরে রাখে, প্রথমে int8 classify_q() দিয়ে সবকটি চালায়, তারপর একই weight-এর float সংস্করণ classify_f() দিয়ে। সময় মাপা হয় SysTick-এর VAL register দিয়ে: interrupt বন্ধ, LOAD = 0xFFFFFF, আর আগে-পরে VAL পড়ে বিয়োগ (২৪ বিটে)। Float সংস্করণের জন্য soft-float ফাংশনগুলো লাগে, যা board.py-র সাধারণ build-এ (-nostdlib) নেই; তাই lab-এর build_fw.py board-এর হুবহু একই flag আর linker script-এ build করে, শুধু link-এর সময় Zig-এর compiler-rt library যোগ করে।

সত্যিকারের run · board.py (reference lab-এর copy), firmware Clang 22.1.8 (ziglang 0.17.1) দিয়ে compile করা:

$ python -B build_fw.py fw/tinyml.c build/tinyml.elf --crt
built build\tinyml.elf
$ python -B bg/board.py run build/tinyml.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.1061 ms] UART: tinyml: 8-8-3 cold-room model, 300 test windows
[   402.7398 ms] UART: int8 : correct 298/300, cycles 115609 = 385 per window
[   402.8281 ms] UART: float: correct 298/300, cycles 3098915 = 10329 per window
[   402.8916 ms] UART: int8 and float agree on 300 windows (timer read cost 2 cycles)
[   402.9551 ms] UART: true normal -> int8 says normal/door/fault: 100 0 0
[   403.0155 ms] UART: true door   -> int8 says normal/door/fault: 1 98 1
[   403.0780 ms] UART: true fault  -> int8 says normal/door/fault: 0 0 100
[   403.0789 ms] exit(0) after 3224631 cycles

তিনটি জিনিস পড়ুন। প্রথম, board-এর C কোডের confusion matrix ব্রাউজারের Python-এর সাথে হুবহু এক (100 0 0, 1 98 1, 0 0 100): integer হিসাব bit-এর পর্যায়ে মিলে গেছে। দ্বিতীয়, int8 এক জানালায় 385 cycle, float 10 329: প্রায় ২৭ গুণ। তৃতীয়, float firmware-এর সিদ্ধান্তও ৩০০টিতেই int8-এর সাথে এক, যদিও board-এর float ৩২ বিটের আর numpy-র হিসাব ৬৪ বিটের।

Cycle সংখ্যা কতটা বিশ্বাসযোগ্য? BG-M3-এ এক instruction = এক cycle (Spec decision 17), তাই এগুলো আসলে instruction-গণনা। আসল Cortex-M3-এ MLA দুই cycle, long multiply আর branch আরও বেশি, আর flash-এর wait state যোগ হয়; তাই আসল chip-এ দুটি সংখ্যাই বড় হবে, আর অনুপাত ২৭ না হয়ে অন্য কিছু হতে পারে। দিকটি কিন্তু নিশ্চিত: FPU-হীন chip-এ প্রতিটি float গুণ আর যোগ একটি ফাংশন-ডাক, integer MAC একটি instruction. আসল chip-এর সময় datasheet আর আসল board-এ মাপা থেকে আসে, এই emulator থেকে নয়।

8 MHz-এ 385 cycle মানে প্রায় 48 µs; cold room প্রতি সেকেন্ডে একবার জিজ্ঞেস করে, তাই CPU-র প্রায় সব সময় ঘুমে কাটতে পারে (পর্ব ৬০)। এবার আকার। পর্ব ৩৭-এ দেখা map file থেকে lab-এর একটি ছোট script দরকারি লাইনগুলো বের করে:

সত্যিকারের run · ld.lld-এর map file, lab-এর sizes.py (byte):

$ python sizes.py build/tinyml.map build/coldai.map
== build/tinyml.map
    96  .isr_vector
  8712  .text
   990    tinyml.o .text.main
   668    tinyml.o .text.classify_q
  2420    tinyml.o .text.classify_f
   308    compiler_rt __aeabi_fmul
   450    compiler_rt add_f32
    12    compiler_rt __aeabi_fadd
    96    compiler_rt __aeabi_fcmpgt
   116    compiler_rt __aeabi_i2f
  2400    tinyml.o .rodata.test_x
   300    tinyml.o .rodata.test_y
    64    tinyml.o .rodata.qW1
     0  .data
   600  .bss
== build/coldai.map
    96  .isr_vector
  3104  .text
   730    coldai.o .text.main
   680    coldai.o .text.classify_q
    12    coldai.o .rodata.main.name
    64    coldai.o .rodata.qW1
     0  .data
    72  .bss
    68    coldai.o .bss.main.win
অংশint8float
Model-এর সংখ্যা (হিসাব)88 + 44 = 132 byte99 × 4 = 396 byte
Inference ফাংশন (map)668 byte + qW1 64 byte2420 byte
Soft-float library (map)লাগে না308 + 450 + 12 + 96 + 116 = 982 byte
Cycle প্রতি জানালা (BG-M3)38510 329
Test accuracy298/300298/300

একটি মজার জিনিস: qW1 ছাড়া বাকি weight map-এ আলাদা দেখা যাচ্ছে না। কারণ -O2-এ Clang loop খুলে ফেলেছে আর ধ্রুবক weight-গুলো সরাসরি কোডের ভেতরে (instruction-এর মান বা literal pool হিসেবে) বসিয়েছে; তাই ফাংশনের আকারেই weight-এর অংশ। Float ফাংশন 2420 byte হওয়ার একটি কারণও এটি: প্রতিটি float weight ৪ byte, আর প্রতিটি গুণ-যোগে ফাংশন-ডাকের কোড। Live firmware coldai.c-তে float একেবারে নেই, তাই সেটি board.py-র সাধারণ build-এই হয়েছে; পুরো firmware flash-এ 96 + 3104 = 3200 byte, আর স্থায়ী SRAM 72 byte, যার 68 byte ১৭টি মাপের জানালা। BG-M3-এর 128 KiB flash আর 20 KiB SRAM-এর তুলনায় খুবই সামান্য।

পরের stepper একই জানালায় float আর int8 model পাশাপাশি চালায়, প্রতিটি স্তরের পরে।

Float (lab-এর numpy) আর int8 (board-এর কোড), পাশাপাশি
ধাপ
float
int8
  1. Input. Float model দেখে °C (0.25 আর 0.5), int8 দেখে sensor-এর পূর্ণসংখ্যা (4 আর 8). sx = 0.0625 আর zx = 0, তাই দুটি হুবহু একই তথ্য; এখানে কোনো ভুল ঢোকেনি।
  2. Hidden স্তর. int8-এর মান (q − z) × 0.038633 করলে 0.502, 0.734, 0, 0.966, 0, 0, 1.120, 0.927; float-এ 0.497, 0.734, 0, 0.974, 0, 0, 1.127, 0.938. প্রতিটি পার্থক্য এক ধাপের (0.0386) কম। তিনটি neuron দুই model-এই ReLU-তে শূন্য।
  3. দ্বিতীয় স্তরের যোগফল. int8-এ acc = qb + Σ qw(h − z): −1668, 2117 আর −1351. এগুলোর scale sh × sw2, এখনো score-এর scale-এ নয়।
  4. Requantize. M2 = 19175 ÷ 222 দিয়ে গুণ-shift: −8, 10, −6; zero point 17 যোগ করে 9, 27, 11. ঠিক এই তিনটি সংখ্যা ব্রাউজারের block আর board-এর live run দুটিতেই এসেছে।
  5. আসল মানে. (q − 17) × 0.291463: −2.332, 2.915, −1.749. Float-এর −2.221, 2.871, −1.801-এর সাথে প্রতিটির পার্থক্য এক ধাপের (0.29) কম। ৩০০টি test জানালায় এই পার্থক্যের সর্বোচ্চ ছিল 0.3497, প্রায় ১.২ ধাপ।
  6. সিদ্ধান্ত. দুটিতেই দ্বিতীয় score সবচেয়ে বড়: door. Softmax-এ সম্ভাবনা float-এ 0.985, int8-এ 0.986. Device-এ softmax-এর দরকারই নেই: সবচেয়ে বড় score খুঁজলেই চলে, কারণ softmax ক্রম বদলায় না।

৭ · Cold room-এ live — model যখন সত্যিকারের sensor পড়ে

Test data-য় ভালো করা আর live চলা এক কথা নয়। Lab-এর coldai.c reference-এর coldroom.c-র মতোই প্রতি 1 s-এ I2C sensor (ঠিকানা 0x48) পড়ে, শেষ ১৭টি মাপ একটি ring buffer-এ রাখে, আর প্রতি সেকেন্ডে model চালিয়ে শ্রেণি বদলালে একটি লাইন ছাপে। Script-এর ঘটনা: 20 s পর্যন্ত 4.00 °C; 20 s-এ দরজা খোলে, তাপমাত্রা প্রতি সেকেন্ডে 0.125 °C ওঠে; 30 s-এ বন্ধ হয়, প্রতি সেকেন্ডে 0.0625 °C নামে; 50 থেকে 60 s স্থির; 60 s-এ compressor থামে, তাপমাত্রা প্রতি সেকেন্ডে আধা LSB (0.03125 °C) ওঠে। দরজার হার training-এর পাল্লার ভেতরে (0.06–0.20), বন্ধের পরে নামার হার training-এর 0.08 থেকে একটু কম, বিকলের হার পাল্লার ভেতরে (0.02–0.05).

সত্যিকারের run · board.py, coldai.c (board.py build, কোনো float নেই) আর coldai.json:

$ python -B bg/board.py build fw/coldai.c -o build/coldai.elf
built build/coldai.elf
$ python -B bg/board.py run build/coldai.elf --script fw/coldai.json --cycles 800000000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > cold-room temperature: +4.00 C
[     0.0456 ms] UART: cold-room AI: 8-8-3 int8 model, window 16 s
[ 17000.1425 ms] UART: t=17 s T=4.00 C scores 33 7 -4 -> normal
[ 20200.0000 ms] > door opened
[ 24000.1464 ms] UART: t=24 s T=4.50 C scores 9 27 11 -> door open
[ 30200.0000 ms] > door closed
[ 51000.1467 ms] UART: t=51 s T=4.00 C scores 40 38 -92 -> normal
[ 60200.0000 ms] > compressor stops (fault)
[ 68000.1485 ms] UART: t=68 s T=4.25 C scores 16 17 11 -> door open
[ 72000.1518 ms] UART: t=72 s T=4.37 C scores 7 17 27 -> compressor fault
[ 90000.0786 ms] exit(0) after 720000629 cycles

(Script-এর প্রতি সেকেন্ডের তাপমাত্রা-বদলের লাইনগুলো "quiet": true দিয়ে লুকানো।) 72 s-এর T=4.37: আসল মান 70 LSB = 4.375 °C, কিন্তু firmware-এর ছাপার হিসাব (t16 × 25 ÷ 4) শূন্যের দিকে ছাঁটে, README-তে লেখা নিয়ম অনুযায়ী। Lab-এর Python-এ একই integer model একই script-এ চালিয়ে প্রতিটি লাইনের score হুবহু মিলেছে।

coldai.c, board-এর run
সময়
আসলে যা ঘটছে
x (৮টি)
score n/d/f
model বলে
  1. 17 s, প্রথম পূর্ণ জানালা. ১৭টি মাপ জমার আগে model চলে না। সব পার্থক্য শূন্য, normal-এর score 33, বাকি দুটির অনেক ওপরে।
  2. 24 s, দরজা ধরা পড়ল. দরজা খোলার 4 s পরে, তাপমাত্রা মাত্র 4.50 °C. README-র threshold alarm (8.00 °C-এর ওপরে পরপর ৩টি মাপ) এই পুরো run-এ একবারও বাজত না, কারণ তাপমাত্রা 5.25 °C-এর ওপরে ওঠেনি।
  3. 51 s, স্বাভাবিকে ফেরা. দরজা বন্ধ হয়েছে 30 s-এ, কিন্তু নামতে থাকা জানালাকেও model “door” বলে চলল (training-এ দরজার জানালায় এই নামা ছিল)। ঘর 4.00 °C-এ স্থির হওয়ার পরে normal, তাও অল্প ব্যবধানে: 40 বনাম 38.
  4. 68 s, ভুল. Compressor থেমেছে 60 s-এ। ধীর ওঠার শুরুতে জানালার প্রথম অংশ সমতল, শেষে হঠাৎ ওঠা; আকৃতিটি “দরজা খোলার শুরু”-র মতো দেখায়। Model ৪ সেকেন্ড ধরে “door open” বলল, 16 বনাম 17-এর মতো খুব কাছাকাছি score-এ।
  5. 72 s, ঠিক উত্তর. জানালায় একটানা ধীর ওঠা স্পষ্ট হতেই fault: 27, যা বাকি দুটির চেয়ে ১০ বেশি। ঘটনা শুরুর 12 s পরে, তাপমাত্রা তখন মাত্র 4.375 °C. মানুষ বা threshold alarm এত আগে টের পেত না।

এই run থেকে তিনটি প্রকৌশলী শিক্ষা। এক, model-এর প্রতিটি সিদ্ধান্তকে একক সত্য ধরবেন না। README-র alarm-এর মতো “পরপর ৩টি একই সিদ্ধান্ত” নিয়ম এখানে door-এর ভুলটি থামাত না (৪টি পরপর ভুল ছিল), কিন্তু score-এর ব্যবধান কম হলে (যেমন 1) সিদ্ধান্ত না দেওয়ার নিয়ম থামাত; দুটিই সস্তা, firmware-এ লেখা যায় (পর্ব ৫৫-এর state machine). দুই, model শুধু সেটুকু জানে যা training data দেখিয়েছে। Training-এ “বিকলের শুরু” আলাদা করে ছিল না; আসল data-য় আসলে কী থাকবে, কেউ জানে না। যে input training-এর পাল্লার বাইরে, তাকে বলে out-of-distribution; সেখানে model-এর উত্তর অর্থহীন হতে পারে, অথচ আত্মবিশ্বাসী দেখায়। সময়ের সাথে আসল data সরে গেলে (নতুন compressor, গ্রীষ্ম, sensor পুরোনো হওয়া) তাকে বলে distribution shift; বিস্তারিত Machine Learning পর্ব ৫৯-এ। তিন, নিরাপত্তার পথ আলাদা রাখুন: 8.00 °C-এর threshold alarm, তার hysteresis আর watchdog (পর্ব ৬১) model ছাড়াই চলবে। Model আগাম সতর্কতা দেয়, শেষ রক্ষা নয়।

৮ · Framework, hardware আর সীমা

এই পর্বে model-টি হাতে লেখা C-তে চালানো হয়েছে, যাতে প্রতিটি সংখ্যা দেখা যায়। বাস্তব প্রকল্পে সাধারণত একটি framework ব্যবহার হয়। কয়েকটি পরিচিত নাম (বিষয় হিসেবে; সংস্করণ আর বৈশিষ্ট্য তাদের documentation-এ মিলিয়ে নেবেন):

নামকী করে
LiteRT for Microcontrollers (আগের নাম TensorFlow Lite for Microcontrollers, TFLM)Google-এর ছোট inference runtime: converter-এ তৈরি model ফাইল C array হিসেবে flash-এ রাখে, আর একটি নির্দিষ্ট আকারের memory-খণ্ডে (tensor arena) সব activation রাখে। Google ২০২৪ সালে TensorFlow Lite-এর নাম LiteRT করে।
CMSIS-NNARM-এর Cortex-M-এর জন্য optimize করা neural network kernel-এর library (convolution, dense, pooling ইত্যাদি); DSP বা vector extension থাকলে তা ব্যবহার করে। LiteRT for Microcontrollers-এর মতো runtime এগুলো ভেতরে ডাকতে পারে।
Edge ImpulseData সংগ্রহ, training, quantization আর firmware-এ deploy পর্যন্ত একটি পুরো প্ল্যাটফর্ম; অনেক MCU board সমর্থন করে বলে প্রচলিত।
Cortex-M4/M7/M33-এর DSP extensionSIMD instruction, যেমন SMLAD: এক instruction-এ দুটি ১৬-বিট গুণ-যোগ। Cortex-M3-এ এগুলো নেই।
Cortex-M55 (Helium) আর Ethos-U55Helium হলো Cortex-M-এর vector extension (MVE); Ethos-U55 একটি ছোট NPU, যা Cortex-M-এর পাশে বসে। দুটিই ARM ২০২০ সালে ঘোষণা করেছিল।

কোনটি বাছবেন? ছোট dense model, এক-দুটি layer হলে এই পর্বের মতো হাতে লেখা C সবচেয়ে ছোট আর পুরো বোঝা যায়। Convolution-সহ বড় model, অনেক রকম layer, বা দলগত কাজে framework সময় বাঁচায়, আর বহু পরীক্ষিত kernel দেয়; দাম হলো runtime-এর বাড়তি flash আর একটি নতুন জিনিস শেখা। সিদ্ধান্তের আগে map file আর cycle মেপে দেখুন, অনুমানে নয়। Deploy-এর সাধারণ দিক, যেমন ONNX বা phone-এর জন্য model রূপান্তর, Deep Learning পর্ব ৮৪-এ; quantization, distillation আর pruning-এর ML দিক Deep Learning পর্ব ৫৯-এ।

TinyML-এর সীমা, সংক্ষেপে। (১) Memory: বড় model, বিশেষ করে ছবি আর শব্দের, কয়েকশো কিলোবাইট বা তার বেশি চাইতে পারে, যা অনেক MCU-তে আঁটে না। (২) Device-এ training প্রায় হয় না; model বদলাতে firmware বা model ফাইল নতুন করে পাঠাতে হয়, যা পর্ব ৭৫ (IoT cloud আর device management) আর পর্ব ৭৭ (secure boot আর নিরাপদ firmware update)-এর OTA পথ ধরে চলে, signature যাচাইসহ। (৩) Model নিজেও একটি সম্পদ: flash থেকে পড়ে নেওয়া বা বদলে দেওয়া রোধ করতে debug port বন্ধ আর signed update লাগে (Cybersecurity পর্ব ৩৫)। (৪) যাচাই কঠিন: model ৯৯% ঠিক মানে ১% ভুল, তাই নিরাপত্তার সিদ্ধান্ত কখনো একা model-এর হাতে নয় (পর্ব ৬৩)। (৫) Host-এ পরীক্ষা: Python-এর integer model আর firmware-এর output bit-এর পর্যায়ে মেলানো একটি শক্তিশালী unit test, যেমন এই পর্বে মিলেছে (পর্ব ৬৪)।

আরও গভীরে: এই পর্বের quantization ধাঁচ, অর্থাৎ r = s(q − z), int32 bias আর M = m × 2−n দিয়ে শুধু-integer requantization, ২০১৮ সালে Google-এর Benoit Jacob ও সহকর্মীদের CVPR-এ প্রকাশিত “Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference” প্রবন্ধে বিস্তারিত বর্ণিত, আর TensorFlow Lite-এর int8 পথ এই ধাঁচের ওপর দাঁড়ানো। সেখানে M-কে [0.5, 1) পাল্লার একটি ৩২-বিট fixed-point সংখ্যা আর একটি shift-এ ভাঙা হয়, যা আমাদের ১৫-বিটের m-এর চেয়ে সূক্ষ্ম। TensorFlow Lite-এর quantization নির্দেশিকায় convolution-এর weight সাধারণত প্রতি output channel-এ আলাদা scale (per-channel) পায়, যা একটি per-tensor scale-এর চেয়ে কম ভুল দেয়; এই পর্বে সরলতার জন্য পুরো tensor-এ একটি scale নেওয়া হয়েছে। খুব কম bit-এ (৪ বা তার কম) প্রায়ই quantization-aware training লাগে।

পরীক্ষা ও ইন্টারভিউতে: (১) “MCU-তে int8 কেন, float নয়?” → model চার গুণ ছোট, MAC একটি integer instruction, আর FPU-হীন chip-এ float মানে soft-float ফাংশন-ডাক; এখানে 385 বনাম 10 329 cycle. (২) “Scale আর zero point-এর সূত্র?” → r ≈ s(q − z); asymmetric-এ s = (rmax − rmin) ÷ 255, z = round(−128 − rmin ÷ s). (৩) “Weight symmetric কেন?” → z = 0 হলে MAC-এ zero point বিয়োগের বাড়তি কাজ লাগে না, আর weight সাধারণত শূন্যের দুই পাশে ছড়ানো। (৪) “Bias কেন int32, কোন scale-এ?” → accumulator-এর scale sxsw-এ রাখলে সরাসরি যোগ করা যায়, আর মান ৮ বিটে আঁটে না। (৫) “Requantization-এ ভগ্নাংশ M কীভাবে?” → M ≈ m ÷ 2sh: ৬৪-বিট গুণ, অর্ধেক যোগ, ডানে shift.

৯ · AI-এর যুগে TinyML-এর কোড আর হিসাব যাচাই

“এই model-কে microcontroller-এ চালানোর C কোড দিন” লিখলে AI assistant দ্রুত কোড দেয়। কিন্তু quantization-এর ভুল প্রায়ই নিঃশব্দ: কোড compile হয়, চলে, শুধু উত্তর ভুল। এই পর্বের অনুশীলন ২-এ zero point ভুলে যাওয়ায় accuracy 298 থেকে 100-এ নেমেছে, অথচ কোনো warning আসেনি। সবচেয়ে চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Activation-এর zero point বিয়োগ করতে ভোলে, বা weight-এর জন্য asymmetric আর activation-এর জন্য symmetric গুলিয়ে ফেলেHost-এ একটি integer reference (এই পর্বের infer_q) বানিয়ে firmware-এর score bit-এর পর্যায়ে মেলানো
Accumulator int16_t রাখে, বা requantization-এ ৩২ বিটে গুণ করে উপচে পড়েসবচেয়ে খারাপ |acc| হাতে হিসাব (৮ × 128 × 127 + |b|); চরম input-এ পরীক্ষা
FPU না থাকলেও float কোড দেয়, বা নির্দিষ্ট MCU-তে FPU আছে বলে ধরে নেয়Chip-এর datasheet দেখা; map file-এ __aeabi_f… খোঁজা
Framework-এর API, ফাংশনের নাম বা সংস্করণ বানিয়ে বলে, পুরোনো TFLM নাম আর নতুন LiteRT নাম মেশায়Framework-এর অফিসিয়াল documentation আর example-এর সাথে মেলানো
Accuracy-র দাবি করে, কিন্তু quantization-এর পরে আবার মাপে না, বা test data-য় training data মেশায়Float আর int8 দুটির accuracy আলাদা test set-এ মাপা
Model-এর সিদ্ধান্তকেই alarm বানায়, threshold-এর নিরাপত্তা পথ সরিয়ে দেয়নকশায় model-কে সহকারী রাখা; নিরাপত্তার নিয়ম আলাদা আর পরীক্ষিত

AI-কে প্রসঙ্গ, সংখ্যা আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি একটি ARM Cortex-M3 microcontroller-এ (FPU নেই, C11, Clang -O2, flash 128 KiB, SRAM 20 KiB) একটি ছোট dense neural network চালাব: 8 input → 8 hidden (ReLU) → 3 output. Input int8, scale 0.0625, zero point 0. Weight int8 symmetric (per-tensor), bias int32 (scale = s_in × s_w), activation int8 asymmetric. ১. একটি generic dense_q() function লেখো, শুধু integer-এ: zero point বিয়োগ, int32 accumulator, requantization M ≈ m / 2^sh (int64 গুণ, round half up), clamp, আর ReLU-র জন্য zero point-এ clamp. ২. দেখাও, কোন ধাপে কোন scale; M কীভাবে m আর sh-এ ভাঙবে, একটি সংখ্যার উদাহরণসহ। ৩. সবচেয়ে খারাপ |accumulator| হিসাব করে দেখাও যে int32-এ আঁটে। ৪. Host-এ Python-এ একই integer হিসাবের reference আর তিনটি পরীক্ষা দাও, যাতে firmware-এর output bit-এর পর্যায়ে মেলানো যায়। ৫. কোনো framework-এর API বা chip-এর বৈশিষ্ট্য নিয়ে নিশ্চিত না হলে বলো "নিশ্চিত নই, documentation দেখুন"; বানিয়ে বলবে না।

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

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Cold room-এর ঘটনা চিনতে model 99.3%, সরল নিয়ম 79.3%. তাহলে কি সবসময় model-ই বাছবেন? কখন একটি হাতে লেখা নিয়ম বা একটি সাধারণ sensor বেশি বুদ্ধিমানের কাজ?

সংখ্যা দুটি সত্য, কিন্তু তুলনাটি ন্যায্য নয়। নিয়মটি ছিল সবচেয়ে বোকা রূপ: শুধু ১৬ সেকেন্ডের মোট ওঠা। তার ব্যর্থতার কারণ আমরা জানি: দরজা খুলে আবার বন্ধ হওয়া জানালায় মোট ওঠা ছোট। একজন প্রকৌশলী এটি দেখে নিয়মে আরেকটি শর্ত যোগ করতেন, যেমন “জানালার মধ্যে সর্বোচ্চ ওঠা” বা “শেষ চার সেকেন্ডে নামছে কি না”। হয়তো তিন লাইনের সেই নিয়মও model-এর কাছাকাছি যেত। Model-এর আসল সুবিধা তখন, যখন নিয়মটি মানুষ লিখতে পারে না: অনেক sensor একসাথে, বা কম্পন আর শব্দের মতো জটিল সংকেত, যেখানে “compressor-এর bearing নষ্ট হচ্ছে” এর আকৃতি কেউ হাতে বর্ণনা করতে পারে না।

আরেকটি বিকল্প প্রায়ই ভুলে যাওয়া হয়: সঠিক sensor. দরজা খোলা জানার সবচেয়ে নির্ভরযোগ্য উপায় দরজায় একটি reed switch বা চুম্বক-সুইচ, যা GPIO-তে একটি input (পর্ব ৪১)। কোনো training নেই, কোনো ভুল শ্রেণি নেই, আর firmware-এ এক লাইন। তাপমাত্রা থেকে দরজা অনুমান করা তখনই যুক্তিসংগত, যখন অনেক পুরোনো ঘরে নতুন তার টানা কঠিন বা ব্যয়বহুল।

Model বাছার দামও হিসাবে রাখুন। Data সংগ্রহ আর label দেওয়া সময়সাপেক্ষ; model-এর ভুল ব্যাখ্যা করা কঠিন (“কেন 68 s-এ door বলল?” এর উত্তর ৯৯টি সংখ্যায় লুকানো); ঘর বা ঋতু বদলালে আবার training লাগতে পারে; আর প্রতিটি model-বদল একটি firmware update. একটি নিয়মের ভুল কোড পড়ে বোঝা যায়, পরীক্ষার কেস লেখা সহজ, আর পরীক্ষক বা নিয়ন্ত্রক সংস্থাকে বোঝানো সহজ।

ব্যবহারিক ধারা তাই এমন: প্রথমে সরলতম baseline (একটি নিয়ম, একটি sensor) বানিয়ে মাপুন; তারপর দেখুন কোথায় সেটি ব্যর্থ, আর সেই ব্যর্থতা কি নিয়ম বদলে সারানো যায়। নিয়ম যখন জটিল হয়ে বারবার ভাঙে আর data যথেষ্ট আছে, তখন model. আর model এলেও baseline-টি রেখে দিন: তুলনার মাপকাঠি হিসেবে, আর model ব্যর্থ হলে নিরাপদ বিকল্প হিসেবে।

মূল উপলব্ধি: Model তখনই বাছুন, যখন সরলতম নিয়ম আর সঠিক sensor মেপে দেখা গেছে অপর্যাপ্ত; baseline সবসময় রাখুন, কারণ ব্যাখ্যা, পরীক্ষা আর রক্ষণাবেক্ষণে নিয়ম সস্তা।

প্র ০২এই পর্বের model simulated data-য় শেখানো, আর live run-এ compressor বিকলের শুরুতে “door” বলেছে। আসল দোকানে deploy করার আগে data নিয়ে কী কী করবেন, আর deploy-এর পরে model-কে কীভাবে নজরে রাখবেন?

Simulated data-র সবচেয়ে বড় বিপদ হলো, model শেখে আমাদের অনুমান, বাস্তব নয়। আমরা ধরে নিয়েছিলাম দরজায় তাপমাত্রা সরলরেখায় ওঠে, বিকলে একটি নির্দিষ্ট হারে, আর noise গাউসীয়। আসল ঘরে defrost চক্র থাকতে পারে, যেখানে heater চালু হয়ে তাপমাত্রা নিয়মিত ওঠে; ভারী মাল ঢোকানোর সময় দরজা অনেকক্ষণ খোলা থাকে; sensor ঠান্ডা বাতাসের পথে বসানো হলে প্রতিটি compressor চক্র অনেক বড় ঢেউ তোলে। এদের কোনোটিই training-এ নেই, তাই model সেগুলোকে তিনটি শ্রেণির কোনো একটিতে জোর করে ফেলবে।

Deploy-এর আগে তাই আসল data: কয়েক সপ্তাহ ধরে বিভিন্ন ঘরে প্রতি সেকেন্ডের মাপ রেকর্ড, সঙ্গে একটি ঘটনা-খাতা (কখন দরজা খোলা হলো, কখন মিস্ত্রি এলেন)। দরজার reed switch এখানে label-এর চমৎকার উৎস: প্রশিক্ষণের সময় সেটি “সত্য” দেয়, পরে না থাকলেও চলে। Data ভাগ করুন সময় ধরে বা ঘর ধরে, এলোমেলোভাবে নয়: নইলে একই ঘটনার পাশাপাশি জানালা train আর test দুই দিকেই পড়ে, আর accuracy মিথ্যা বড় দেখায়। আর একটি শ্রেণি যোগ করার কথা ভাবুন, যেমন “অজানা”, বা score-এর ব্যবধান কম হলে উত্তর না দেওয়া।

Deploy-এর পরে নজরদারি। Device প্রতিটি সিদ্ধান্তের সাথে score আর input-এর সারাংশ (যেমন জানালার সর্বোচ্চ ওঠা) telemetry-তে পাঠাতে পারে, প্রতি সেকেন্ডের কাঁচা data নয়। Dashboard-এ দেখা যায় কোন শ্রেণি কত ঘন ঘন আসছে; হঠাৎ “door”-এর হার বেড়ে গেলে হয় দোকানে কিছু বদলেছে, নয় model ভুল করছে। Input-এর বণ্টন (যেমন ঘরের গড় তাপমাত্রা, ওঠার হারের পাল্লা) training-এর সাথে তুলনা করলে distribution shift ধরা যায়, label ছাড়াই। মাঝে মাঝে কর্মীদের কাছ থেকে নিশ্চিতকরণ (“সত্যিই দরজা খোলা ছিল?”) নতুন label দেয়, যা পরের training-এ যায়।

এই চক্রটি, data → model → deploy → নজরদারি → নতুন data, ML-এর জগতে পরিচিত; Machine Learning কোর্সের distribution shift আর monitoring-এর পর্বগুলো এর পরিসংখ্যানের দিক দেখায়। Embedded-এর বাড়তি কাজ হলো প্রতিটি নতুন model নিরাপদে device-এ পৌঁছানো, যাচাই করা আর দরকারে আগের model-এ ফিরতে পারা।

মূল উপলব্ধি: Simulated data দিয়ে শুধু পাইপলাইন পরীক্ষা হয়, model-এর মান নয়; আসল label-সহ data, সময়-ভিত্তিক ভাগ, অনিশ্চিত হলে উত্তর না দেওয়া আর deploy-এর পরে নজরদারি ছাড়া field-এ model অন্ধ।

প্র ০৩৩২ বিটের float থেকে ৮ বিটে নামালে তথ্য তো হারায়। তবু এই পর্বে accuracy একটুও কমল না। int8 কেন এত ভালো কাজ করে, আর কখন সত্যিই ক্ষতি হয়?

একটি neural network-এর সিদ্ধান্ত নির্ভর করে score-গুলোর ক্রমের ওপর, প্রতিটি সংখ্যার শেষ দশমিকের ওপর নয়। Quantization প্রতিটি weight-এ সর্বোচ্চ অর্ধেক ধাপের ভুল আনে; অনেক weight-এর যোগফলে এই ভুলগুলো আংশিকভাবে কাটাকাটি হয়, কারণ কিছু ওপরে, কিছু নিচে গোল হয়। এখানে ৩০০টি জানালায় score-এর সর্বোচ্চ পার্থক্য ছিল 0.35, অথচ জেতা আর হারা score-এর ব্যবধান প্রায় সবসময় তার চেয়ে অনেক বড়। যে কয়েকটি জানালায় ব্যবধান খুব কম, শুধু সেখানেই সিদ্ধান্ত উল্টাতে পারে, আর এই data-য় তেমন একটিও ছিল না।

শিল্পে int8-এর জনপ্রিয়তার ইতিহাসও আছে। ২০১০-এর দশকের মাঝামাঝি phone-এ neural network চালানোর চাপে Google-সহ অনেক দল ৮ বিটের হিসাব নিয়ে কাজ করে; Google-এর gemmlowp library আর ২০১৮ সালের Jacob ও সহকর্মীদের CVPR প্রবন্ধ affine quantization আর শুধু-integer requantization-কে একটি মানক রূপ দেয়, যা TensorFlow Lite-এ গৃহীত হয়। সেই প্রবন্ধে তাঁরা MobileNet-এর মতো model-এ কম accuracy-ক্ষতিতে int8-এ গতি আর আকারের লাভ দেখান; সঠিক সংখ্যা মূল প্রবন্ধে দেখুন।

কখন ক্ষতি হয়? প্রথমত, outlier: একটি tensor-এ একটি বিশাল weight থাকলে per-tensor scale বড় হয়, আর বাকি সব ছোট weight কয়েকটি ধাপে গুঁড়িয়ে যায়। Per-channel scale এর প্রধান ওষুধ। দ্বিতীয়ত, ভুল calibration: activation-এর পাল্লা যদি এমন data থেকে নেওয়া হয় যা আসল input-এর মতো নয়, তাহলে বাস্তবে মান clamp হয়ে কেটে যায়, বা ধাপগুলো অপ্রয়োজনে মোটা হয়। তৃতীয়ত, খুব কম bit: ৪ বা ২ বিটে ধাপ এত মোটা যে post-training পদ্ধতি প্রায়ই ভাঙে; তখন quantization-aware training, যেখানে শেখার সময়ই গোল করার প্রভাব নকল করা হয়। চতুর্থত, কিছু স্তর স্বভাবতই সংবেদনশীল, যেমন খুব ছোট model-এর প্রথম বা শেষ স্তর; সেগুলোকে বেশি bit-এ রাখা একটি প্রচলিত আপস।

শিক্ষাটি পদ্ধতির: quantization-এর পরে accuracy সবসময় আবার মাপুন, শুধু গড় নয়, প্রতিটি শ্রেণির confusion matrix-ও। আর সবচেয়ে কম ব্যবধানের জানালাগুলো আলাদা করে দেখুন, কারণ সেখানেই float আর int8 প্রথম আলাদা হবে।

মূল উপলব্ধি: int8 কাজ করে কারণ সিদ্ধান্ত score-এর ক্রমে, আর অর্ধেক-ধাপের ভুল যোগফলে কাটাকাটি হয়; outlier, ভুল calibration আর খুব কম bit-এ এটি ভাঙে, তাই প্রতিবার আবার মাপা বাধ্যতামূলক।

প্র ০৪এই পর্বে model হাতে লেখা C-তে চলেছে। LiteRT for Microcontrollers (আগের TFLM)-এর মতো একটি interpreter-ভিত্তিক framework আর এই “model-কে সরাসরি C কোড বানানো” পথের মধ্যে আসল আপস কী?

Interpreter-ভিত্তিক runtime-এ model একটি ডেটা-ফাইল: কোন layer, কোন ক্রমে, কোন weight আর scale. Converter সেটি একটি byte array বানায়, যা C ফাইলে ধ্রুবক হিসেবে flash-এ যায়। Runtime চালুর সময় ফাইলটি পড়ে, প্রতিটি layer-এর জন্য একটি kernel ফাংশন খুঁজে নেয় (যেগুলো firmware-এ link করা আছে), আর একটি নির্দিষ্ট আকারের memory-খণ্ডে সব activation-এর জায়গা ভাগ করে দেয়। লাভ: model বদলাতে কোড বদলাতে হয় না, শুধু array; একই kernel বহু model চালায়; আর kernel-গুলো বহু প্রকল্পে পরীক্ষিত। Google-এর TFLM-বিষয়ক প্রবন্ধ (David ও সহকর্মী, MLSys ২০২১) এই নকশার যুক্তি বর্ণনা করে: heap এড়ানো, নির্দিষ্ট memory, আর বহু রকম MCU-তে বহনযোগ্যতা।

দাম: runtime নিজের কোড আর model-ফাইলের বিবরণ পড়ার কাজ, যা কয়েক কিলোবাইট flash নিতে পারে; প্রতিটি layer-এ ফাংশন-ডাক আর কিছু বাড়তি পরীক্ষা। আমাদের ৯৯টি সংখ্যার model-এ runtime-এর আকার model-এর চেয়ে অনেক গুণ বড় হতো। হাতে লেখা বা স্বয়ংক্রিয়ভাবে তৈরি C-তে compiler সব জানে: আকার ধ্রুবক, weight ধ্রুবক, তাই loop খুলে weight কোডে বসিয়ে দিতে পারে, যেমন এখানে Clang করেছে। ক্ষুদ্রতম আর দ্রুততম ফল আসে, কিন্তু প্রতিটি model-বদল একটি নতুন build, আর হাতে লেখা কোডে ভুলের ঝুঁকি (অনুশীলন ২-এর zero point).

দুটির মাঝে আছে code generation: একটি tool model পড়ে সরাসরি C বানায়, প্রায়ই memory-পরিকল্পনাসহ। গবেষণায় MIT-র MCUNet (২০২০, NeurIPS) দেখিয়েছিল যে model-এর নকশা আর inference engine একসাথে MCU-র memory-সীমার জন্য বানালে আরও বড় কাজ ছোট chip-এ আঁটানো যায়; বিস্তারিত তাঁদের প্রবন্ধে। Edge Impulse-এর মতো প্ল্যাটফর্মও model থেকে সরাসরি C তৈরির বিকল্প দেয় বলে তাদের documentation-এ বর্ণিত।

বাছাইয়ের প্রশ্নগুলো তাই: model কতবার বদলাবে? দলের কতজন quantization-এর গণিত বোঝেন? Flash-এ কত জায়গা খালি? Convolution বা recurrent-এর মতো জটিল layer আছে কি? আর যাচাই: framework হোক বা হাতে লেখা, host-এর reference আর device-এর output মেলানো, আর map file দেখা, দুই পথেই একই।

মূল উপলব্ধি: Interpreter নমনীয়তা আর পরীক্ষিত kernel দেয় flash আর কিছু গতির দামে; সরাসরি C ক্ষুদ্রতম আর দ্রুততম, কিন্তু প্রতিটি বদল নতুন build আর নিজের দায়িত্বে নির্ভুলতা; model যত ছোট, সরাসরি C তত যুক্তিসংগত।

প্র ০৫“Device-এ হিসাব করলে শক্তি বাঁচে” কথাটি কি সবসময় সত্য? একটি battery-চালিত cold-room sensor-এর জন্য radio, CPU আর ঘুমের সময় মিলিয়ে কীভাবে সিদ্ধান্ত নেবেন?

কথাটি প্রায়ই সত্য, কিন্তু নিয়ম নয়, হিসাব। একটি battery-চালিত device-এর শক্তি তিন ভাগে যায়: ঘুম, CPU-র কাজ আর radio. পর্ব ৬২-এর মতো প্রতিটির current × সময় যোগ করে গড় current বের করতে হয়। Radio-র transmit current সাধারণত MCU-র active current-এর চেয়ে বেশি, আর একটি বার্তা পাঠাতে radio-কে জাগানো, network-এ যুক্ত হওয়া আর উত্তরের অপেক্ষা মিলিয়ে অনেক মিলিসেকেন্ড লাগতে পারে। অন্যদিকে আমাদের model-এর inference BG-M3-এ মাত্র 385 cycle; আসল chip-এ কয়েকগুণ বেশি হলেও তা মাইক্রোসেকেন্ডের ঘরে। তাই প্রতি সেকেন্ডে কাঁচা মাপ পাঠানোর বদলে device-এ সিদ্ধান্ত নিয়ে শুধু ঘটনা পাঠানো এখানে প্রায় নিশ্চিতভাবে শক্তি বাঁচায়। সঠিক অনুপাত বলতে হলে আসল radio আর MCU-র datasheet-এর current আর মাপা সময় লাগে; এখানে কোনো সংখ্যা বানিয়ে বলছি না।

কিন্তু উল্টো ঘটনাও আছে। বড় model, যেমন ছবি চেনার convolution network, ছোট MCU-তে কয়েকশো মিলিসেকেন্ড বা তার বেশি চলতে পারে; তখন CPU-র শক্তি একটি ছোট বার্তা পাঠানোর চেয়ে বেশি হতে পারে, বিশেষ করে যখন ঘটনা বিরল আর রেডিও খুব সাশ্রয়ী (যেমন LPWAN, পর্ব ৭২)। আর device যদি প্রতিবার model চালাতে ঘুম থেকে উঠে অনেকক্ষণ জেগে থাকে, ঘুমের লাভ হারায় (পর্ব ৬০)।

এই কারণে বহু “সবসময় শোনা” যন্ত্রে স্তরভিত্তিক নকশা দেখা যায়: একটি খুব সস্তা প্রথম ধাপ (একটি threshold, বা খুব ছোট model) প্রায় সারাক্ষণ চলে, আর কিছু সন্দেহজনক মনে হলে তবেই বড় model বা radio জাগে। Phone-এর wake-word শোনার কাজ কম-শক্তির আলাদা প্রসেসরে চলে বলে প্রচলিত বর্ণনা, এই ধারণারই উদাহরণ। আমাদের cold room-এ প্রথম ধাপ হতে পারে “জানালায় কোনো ওঠা নেই, তাই model চালানোর দরকার নেই”।

Hardware-ও বদলাচ্ছে। ARM-এর Helium vector extension আর Ethos-U-র মতো ছোট NPU, বা অন্য নির্মাতাদের MCU-তে যুক্ত vector instruction, একই কাজ কম cycle আর কম শক্তিতে করার জন্য বানানো। তবু সিদ্ধান্তের পদ্ধতি একই থাকে: প্রতিটি নকশার শক্তি-বাজেট হিসাব, আর আসল board-এ মেপে যাচাই।

মূল উপলব্ধি: Edge-এ হিসাব শক্তি বাঁচায় যখন inference-এর খরচ radio-তে বাঁচানো খরচের চেয়ে কম; ছোট model আর ঘন ঘন মাপে এটি প্রায় নিশ্চিত, বড় model আর বিরল ঘটনায় হিসাব করে, মেপে দেখতে হয়।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর lab-এ board-এ চালিয়ে বা হিসাব-script দিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — যেকোনো আকারের int8 dense layer: classify_q()-তে দুটি স্তর আলাদা করে লেখা। একটি সাধারণ ফাংশন dense_q() লিখুন, যা input-এর সংখ্যা, input-এর zero point, weight ([out][in] ক্রমে), int32 bias, output-এর সংখ্যা, m, sh, output-এর zero point আর ReLU আছে কি না নেয়। তারপর দুটি ডাকে পুরো 8-8-3 model চালান। দরজা-খোলার জানালা (0 0 0 0 0 0 4 8)-য় score কী আসা উচিত?
    static void dense_q(const int8_t *in, int n_in, int32_t zp_in,
                        const int8_t *w, const int32_t *b, int n_out,
                        int32_t m, int sh, int32_t zp_out, int relu, int8_t *out)
    {
        for (int j = 0; j < n_out; j++) {
            int32_t acc = b[j];
            for (int i = 0; i < n_in; i++)
                acc += (in[i] - zp_in) * w[j * n_in + i];
            int32_t v = zp_out + (int32_t)(((int64_t)acc * m + ((int64_t)1 << (sh - 1))) >> sh);
            int32_t lo = relu ? zp_out : -128;
            out[j] = (int8_t)(v < lo ? lo : (v > 127 ? 127 : v));
        }
    }
    /* model: */
    dense_q(x, 8, 0,    &qW1[0][0], qB1, 8, M1, SH1, ZP_H, 1, h);
    dense_q(h, 8, ZP_H, &qW2[0][0], qB2, 3, M2, SH2, ZP_Z, 0, z);

    ReLU-তে নিচের সীমা output-এর zero point, নইলে −128. দ্বিতীয় ডাকে input-এর zero point ZP_H (−128), তাই in[i] - zp_in নিজেই h − z করে। প্রত্যাশিত score 9, 27, 11, অর্থাৎ ব্রাউজারের block-এর সমান। সত্যিকারের run (lab-এর ex.c, board-এ): task1 dense_q door scores: 9 27 11 test correct 298/300. লক্ষ করুন, sh এখানে চলক, তবু Clang ৬৪ বিটের shift instruction-এর ক্রম দিয়ে inline করেছে, আলাদা library লাগেনি (board.py-র সাধারণ build-এই link হয়েছে)।

  2. ভুল খুঁজুন — দুটি চেনা quantization-ভুল: একজন দ্বিতীয় স্তর এভাবে লিখলেন:
    for (int k = 0; k < 3; k++) {
        int16_t acc = qB2[k];
        for (int j = 0; j < 8; j++)
            acc += h[j] * qW2[k][j];       /* h[j]: int8, zero point -128 */
        z[k] = clamp8(ZP_Z + rq(acc, M2, SH2), -128);
    }
    দুটি ভুল কী? কোনটি test data-য় ধরা পড়বে, কোনটি পড়বে না, আর কেন দুটিই সারাতে হবে?

    ভুল ১: zero point বিয়োগ নেই. h[j]-এর আসল মান sh(h[j] + 128); কোড h[j]-কেই মান ধরেছে, তাই প্রতিটি neuron-এর অবদান 128 × weight পরিমাণ সরে যায়। ReLU-তে শূন্য হওয়া neuron (h = −128) সবচেয়ে বড় ঋণাত্মক মান হয়ে যায়। সত্যিকারের run (lab-এর ex.c, শুধু এই ভুল): task2 bug 1: door scores 78 -128 127 correct 100/300, says normal/door/fault 7 0 293. Model প্রায় সবকিছুকে fault বলছে; accuracy 298 থেকে 100. Compiler কোনো warning দেয়নি।

    ভুল ২: int16_t accumulator. শুধু এই ভুলে run: task2 bug 2: door scores 9 27 11 correct 298/300. Test-এ কিছুই ধরা পড়ল না! কারণ lab-এর হিসাবে train data-য় দ্বিতীয় স্তরের সর্বোচ্চ |acc| ছিল 31946, test-এ 30839, দুটিই int16-এর সীমা 32767-এর নিচে, প্রায় গা ঘেঁষে। সবচেয়ে খারাপ সম্ভাব্য মান কিন্তু 8 × 255 × 127 + |b| = 259 080 + |b|, int16-এর অনেক বাইরে। হঠাৎ 8 °C লাফানো একটি জানালায় (0 0 0 0 127 127 127 127) run দেখায়: task2 jump window, int32: -109 127 12 int16 (bug 2): -109 -128 12. int32-এ সিদ্ধান্ত door, int16-এ door-এর score উপচে উল্টো চিহ্নে লাফিয়ে −128, আর সিদ্ধান্ত fault. শিক্ষা: পরীক্ষায় পাশ মানে নির্ভুল নয়; accumulator-এর type সবচেয়ে খারাপ মানের হিসাব থেকে বাছুন। সংশোধিত লাইন: int32_t acc = qB2[k]; আর acc += (h[j] - ZP_H) * qW2[k][j];.

  3. হিসাব — scale, zero point আর আকার: (ক) Output score-এর calibration পাল্লা −42.4027 থেকে 31.9203. Asymmetric int8-এর s আর z কত? Float score 2.8709 কোন int8-এ যাবে, আর সেটি ফিরিয়ে আনলে কত? (খ) কেউ model বড় করে 16 input → 16 hidden → 4 output করতে চান। মোট parameter কত, float-এ আর int8-এ (int32 bias-সহ) কত byte, আর এক inference-এ কতগুলো MAC (8-8-3-এর তুলনায়)?

    (ক) s = (31.9203 + 42.4027) ÷ 255 = 74.3230 ÷ 255 = 0.291463. z = round(−128 + 42.4027 ÷ 0.291463) = round(−128 + 145.48) = round(17.48) = 17. 2.8709 ÷ 0.291463 = 9.85 → গোল করে 10, যোগ z: q = 27. ফেরত: (27 − 17) × 0.291463 = 2.9146; ভুল 0.0437, অর্ধেক ধাপের (0.1457) কম। এটিই board-এর score 27. (খ) Parameter: 16 × 16 + 16 + 16 × 4 + 4 = 340. Float: 340 × 4 = 1360 byte. int8: weight 256 + 64 = 320 byte, bias 20 × 4 = 80 byte, মোট 400 byte. MAC: 16 × 16 + 16 × 4 = 320, যেখানে 8-8-3-এ 8 × 8 + 8 × 3 = 88; প্রায় ৩.৬ গুণ। আকার দুটিই BG-M3-এর flash-এ সহজে আঁটে; সময় কত বাড়ে তা অনুমান নয়, board-এ মেপে বলুন। সব সংখ্যা lab-এর হিসাব-script-এ মেলানো।

  4. আগে বলুন, তারপর মেলান — দুটি hidden neuron: Input 0 0 0 0 0 0 4 8 (zero point 0). Hidden neuron ০-এর শেষ দুটি weight −27 আর −101, bias 1192; neuron ৪-এর −63 আর −65, bias −43. m = 23991, sh = 19, output zero point −128, ReLU আছে। প্রতিটির acc, shift-এর ফল আর int8 output কী? Neuron ০-এর আসল মান কত?

    Neuron ০: acc = 4 × (−27) + 8 × (−101) + 1192 = −108 − 808 + 1192 = 276. 276 × 23991 = 6621516, যোগ 262144 = 6883660, ÷ 219 = 13.13 → 13. h = −128 + 13 = −115; আসল মান 13 × 0.038633 = 0.5022 (float model-এ 0.4972). Neuron ৪: acc = 4 × (−63) + 8 × (−65) − 43 = −252 − 520 − 43 = −815. −815 × 23991 = −19552665, যোগ 262144 = −19290521; ডানে shift নিচের দিকে ছাঁটে: −36.79 → −37. −128 − 37 = −165, যা ReLU-র সীমা −128-এর নিচে, তাই −128, অর্থাৎ আসল 0.0. দুটি মান lab-এর detail.py-র ছাপা hidden ভেক্টরের (−115, −109, −128, −103, −128, −128, −99, −104) প্রথম আর পঞ্চম ঘরের সাথে মেলে। খেয়াল করুন, ঋণাত্মক সংখ্যার shift শূন্যের দিকে নয়, −∞-এর দিকে ছাঁটে; অর্ধেক যোগ করায় তবু ফলটি সবচেয়ে কাছের পূর্ণসংখ্যা।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএকটি TinyML প্রকল্পের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. সমস্যা আর device-এর সীমা লিখে রাখা: latency, flash, RAM, শক্তি
  2. আসল data সংগ্রহ করে ঘটনার label দেওয়া
  3. Feature ঠিক করে float model train আর আলাদা test set-এ মাপা
  4. Calibration data দিয়ে int8-এ quantize করে accuracy আবার মাপা
  5. Weight C array-তে নিয়ে firmware build আর map file-এ flash ও RAM দেখা
  6. Device-এ cycle আর live আচরণ মেপে, field data নিয়ে আবার শুরু

FPU নেই এমন একটি Cortex-M3-এর জন্য Clang দিয়ে C-তে acc + x * w লেখা হলো, যেখানে তিনটিই float. Compile-এর পরে এটি কী হয়?

  • একটি floating-point গুণ-যোগ instruction
  • দুটি library ফাংশন-ডাক, একটি গুণের আর একটি যোগের
  • Compile error, কারণ float সমর্থিত নয়
  • Compiler নিজেই int8-এ রূপান্তর করে একটি mla বানায়

ReLU-র পরে একটি activation-এর calibration পাল্লা 0 থেকে 10.2. Asymmetric int8 (−128 থেকে 127)-এ scale s আর zero point z কত?

  • s = 0.04, z = −128
  • s ≈ 0.0803, z = 0
  • s = 0.04, z = 0
  • s = 0.08, z = −128

int8 quantized dense layer-এ bias সাধারণত int32-এ, scale sx × sw আর zero point 0 দিয়ে রাখা হয়। এর প্রধান কারণ কী?

  • Int32-এ রাখলে flash বাঁচে
  • Bias সবসময় ধনাত্মক, তাই বড় type লাগে
  • Accumulator-এর scale sxsw-এ থাকলে bias সরাসরি যোগ করা যায়, আর মানটি ৮ বিটে আঁটে না
  • ReLU bias-এর ওপর আলাদা করে প্রয়োগ করতে হয়

একটি cold-room sensor-এ ছোট model চালানোর পক্ষে কোন যুক্তিটি ঠিক নয়?

  • Network ধীর হলেও ঘটনা দ্রুত ধরা পড়ে
  • পাঠানো বার্তার সংখ্যা অনেক কমে
  • সংযোগ বিচ্ছিন্ন হলেও device সতর্ক করতে পারে
  • Device-এ model নতুন করে train করা cloud-এর চেয়ে সবসময় সস্তা

Requantization-এর গুণক M = 0.045759 FPU ছাড়া m ÷ 2sh আকারে রাখতে হবে, শর্ত 214 ≤ m < 215. কোন জোড়াটি সঠিক?

  • m = 23991, sh = 19
  • m = 23991, sh = 15
  • m = 47982, sh = 20
  • m = 12, sh = 8

তাপমাত্রার জানালা দেখে “normal / door / fault” বলা একটি model শুধু simulated data-য় শেখানো। Field-এ একটি sensor-ত্রুটিতে হঠাৎ মাপ 8 °C নেমে গেল, যা training-এ কখনো ছিল না। সবচেয়ে ভালো নকশা কোনটি?

  • Model যা বলে তা-ই মানা, কারণ test accuracy 99%
  • প্রতি ঘণ্টায় device-এ model আবার train করা
  • Input-এর যুক্তিসংগত পাল্লা আলাদাভাবে পরীক্ষা করা, আর threshold alarm model-নিরপেক্ষ রাখা
  • Model-এর hidden neuron দ্বিগুণ করা

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Edge AI: শেখা model device-এর কাছে চালানো; লাভ latency, গোপনীয়তা, কম radio আর শক্তি, সংযোগ ছাড়াও কাজ। Training সাধারণত বড় কম্পিউটারে, device শুধু inference.
  2. TinyML-এর ধারা: data → feature → float train → int8 quantize → C array-তে deploy → device-এ মাপা, আর আবার শুরু। প্রতিটি ধাপে একটি পরিমাপযোগ্য ফল।
  3. int8: r ≈ s(q − z); weight symmetric (z = 0, s = max|w| ÷ 127), activation asymmetric (s = পাল্লা ÷ 255), bias int32 scale sxsw-এ।
  4. Requantization: int32 MAC, তারপর M ≈ m ÷ 2sh দিয়ে ৬৪-বিট গুণ, অর্ধেক যোগ, shift; ReLU = zero point-এ clamp. FPU-হীন chip-এ float মানে soft-float ফাংশন-ডাক।
  5. সীমা: simulated data-র model বাস্তবে ভুল করতে পারে, out-of-distribution input-এ আত্মবিশ্বাসী ভুল দেয়; নিরাপত্তার threshold alarm আলাদা রাখুন, host-এর reference দিয়ে firmware-এর output মেলান।

পরের পর্বে: পর্ব ৭৯ (এমবেডেড আর IoT নকশার case study — smart home, শিল্প আর wearable). এ পর্যন্ত শেখা সবকিছু এক জায়গায়: বাজারঘরের smart scale, cold-room monitor আর গুদামের gateway-র requirement থেকে MCU, sensor, radio, শক্তি, firmware-এর কাঠামো আর ঝুঁকি পর্যন্ত পুরো নকশার সিদ্ধান্ত।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান