Deep learning-এর loss — cross-entropy, label smoothing আর বিশেষ loss

এই কোর্সের পর্ব ১০-এ CrossEntropyLoss-কে logits দিয়েছেন আর দেখেছেন আগে softmax বসালে কী হয়; পর্ব ১১-এ বাংলা রিভিউ padding করে সমান দৈর্ঘ্যের batch বানিয়েছেন। এই পর্বে প্রশ্নটি এক ধাপ ওপরে: কোন loss, আর কেন? Cross-entropy-র তথ্যতত্ত্ব AI-এর ভিত্তি কোর্সের পর্ব ৩৮-এ, আর maximum likelihood মেশিন লার্নিং কোর্সের পর্ব ১৮-এ; এখানে শুধু এক লাইনের মনে করিয়ে দেওয়া, তারপর deep network-এর অনুশীলন। PyTorch পাতায় চলে না, তাই PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে; পাতায় চালানো যায় এমন চারটি ব্লক একই ধারণা NumPy দিয়ে দেখায় (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)।

১ · Loss আসলে কী মাপে — likelihood-এর চোখে

Model x দেখে লক্ষ্যের একটি probability বণ্টন দেয়, আর আমরা চাই দেখা label-গুলোর likelihood সবচেয়ে বেশি হোক। গুণফলের log নিয়ে ঋণাত্মক করলে যোগফল আসে, যাকে কমানো সহজ: negative log-likelihood (NLL). কোন বণ্টন ধরছেন, তার ওপর loss-এর চেহারা নির্ভর করে:

Cross-entropy-র দুটি ব্যবহারিক কথা এই কোর্সে আগেই এসেছে, এখানে শুধু মনে করিয়ে দিই। এক, loss নেয় logits, আর ভেতরে log-sum-exp কৌশলে log-softmax করে, যাতে বড় logit-এ overflow না হয় (পর্ব ০৩, পর্ব ১০)। দুই, logits z-এর সাপেক্ষে gradient খুব সরল: ∂L/∂z = p − y, যেখানে y হলো one-hot লক্ষ্য (পর্ব ০৪-এর P − Y).

এই সরল gradient-এর একটি লুকানো পরিণতি আছে। সঠিক শ্রেণির জন্য gradient p_y − ১, যা কখনো শূন্য হয় না, শুধু শূন্যের দিকে যায়। ফলে training ডেটায় সব ঠিক হয়ে গেলেও loss সঠিক logit-কে আরও ওপরে ঠেলতে থাকে, আর model ক্রমে ০.৯৯৯-এর মতো চরম probability দিতে শেখে। Train set-এ এতে ক্ষতি নেই, কিন্তু নতুন ডেটায় ভুল উত্তরেও model অতি-আত্মবিশ্বাসী থাকে: একে বলে overconfidence. পরের দুই অংশ এই সমস্যার একটি সহজ ওষুধ নিয়ে।

২ · Label smoothing — লক্ষ্যকে একটু নরম করা

Label smoothing-এ one-hot লক্ষ্যের বদলে একটি নরম লক্ষ্য দেওয়া হয়। K শ্রেণি আর একটি ছোট সংখ্যা ε (প্রায়ই ০.১) নিয়ে:

q = (1 − ε)·y + ε/K   ·   L = −Σ_k q_k ln p_k   ·   ∂L/∂z = p − q

এখানে y one-hot লক্ষ্য, p = softmax(z) model-এর probability, আর q নরম লক্ষ্য। সঠিক শ্রেণি পায় ১ − ε + ε/K, বাকি প্রতিটি ε/K. Gradient-এর রূপ একই থাকে, শুধু লক্ষ্য বদলায়; তাই এখন p = q হলে gradient শূন্য, অর্থাৎ model-এর আর চরম probability দেওয়ার তাগিদ নেই। নিচের stepper-এ একটি উদাহরণ হাতে হিসাব করুন।

এবার কয়েকটি logit vector-এ দুই loss আর সঠিক logit-এর gradient পাশাপাশি দেখুন। নজর রাখুন শেষ দুই সারির চিহ্নের দিকে।

import numpy as np

def log_softmax(z):
    z = z - z.max()                              # stable: সবচেয়ে বড় logit বাদ
    return z - np.log(np.exp(z).sum())

def ce(z, y, eps=0.0):
    K = len(z)
    q = np.full(K, eps / K); q[y] += 1 - eps     # smoothed target (1−ε)y + ε/K
    lp = log_softmax(z)
    return -(q * lp).sum(), np.exp(lp) - q       # loss আর ∂L/∂z = p − q

y = 0                                            # সঠিক শ্রেণি 0, K = 3
for z in ([2.0, 0.5, -1.0], [0.0, 3.0, 0.0], [5.0, 0.0, 0.0], [10.0, 0.0, 0.0]):
    z = np.array(z)
    l0, g0 = ce(z, y); l1, g1 = ce(z, y, 0.1)
    print(f"z={str(z):15s} CE {l0:.4f} | LS {l1:.4f} || ∂/∂z0: CE {g0[0]:+.4f} | LS {g1[0]:+.4f}")

K, eps = 3, 0.1
q = np.full(K, eps / K); q[0] += 1 - eps
print("smoothed target:", q.round(4), "| LS-এর সর্বনিম্ন loss = H(q) =", round(-(q * np.log(q)).sum(), 4))
print("সেরা logit ব্যবধান z0 − z1 = ln(q0/q1) =", round(np.log(q[0] / q[1]), 4))

z=[ 2.   0.5 -1. ] CE 0.2413 | LS 0.3913 || ∂/∂z0: CE -0.2144 | LS -0.1477
z=[0. 3. 0.]      CE 3.0949 | LS 2.9949 || ∂/∂z0: CE -0.9547 | LS -0.8881
z=[5. 0. 0.]      CE 0.0134 | LS 0.3467 || ∂/∂z0: CE -0.0133 | LS +0.0534
z=[10.  0.  0.]   CE 0.0001 | LS 0.6668 || ∂/∂z0: CE -0.0001 | LS +0.0666
smoothed target: [0.9333 0.0333 0.0333] | LS-এর সর্বনিম্ন loss = H(q) = 0.2911
সেরা logit ব্যবধান z0 − z1 = ln(q0/q1) = 3.3322

৩ · Label smoothing সত্যিকারের training-এ — accuracy, confidence আর ECE

Probability কতটা বিশ্বাসযোগ্য, তা মাপে calibration: model যেসব অনুমানে ০.৮ বলে, তার প্রায় ৮০% ঠিক হলে model calibrated. একটি সংখ্যায় প্রকাশ করে expected calibration error (ECE): অনুমানগুলোকে confidence অনুযায়ী ঝুড়িতে ভাগ করে, প্রতিটি ঝুড়িতে গড় confidence আর আসল accuracy-র পার্থক্য, ঝুড়ির আকার দিয়ে ওজন করে যোগ। এর পুরো ব্যাখ্যা, reliability diagram আর temperature scaling মেশিন লার্নিং কোর্সের পর্ব ২৬-এ।

পরীক্ষা: Fashion-MNIST (Zalando Research-এর পোশাকের ২৮ × ২৮ ছবি, ১০টি শ্রেণি, MIT লাইসেন্স) থেকে ১২,০০০ train ছবি আর পুরো ১০,০০০ test ছবি। Model 784 → 512 → 256 → 10-এর MLP, AdamW, ৩০ epoch, কোনো regularization ছাড়া, যাতে ইচ্ছে করে overfit করে। একবার সাধারণ CE, একবার label_smoothing=0.1; প্রতিটি তিনটি seed-এ। ECE ১৫টি ঝুড়িতে। ডেটা torchvision-এর datasets.FashionMNIST দিয়ে পড়া।

সত্যিকারের run (ডেস্কটপ, CPU; uv project আগের পর্বগুলোর মতো, torch 2.15.0-এর CPU wheel):

~/bazarghar-dl$ uv run python ls_calib.py
torch 2.15.0+cpu | torchvision 0.29.2+cpu | python 3.14.4
train (12000, 784) | test (10000, 784)
label_smoothing=0.0: acc 0.8605 | mean conf 0.9319 | ECE 0.0715 | test NLL 0.5337 | conf on wrong 0.776 | conf>0.99 64.0%
   per seed ECE: 0.0694 0.0726 0.0726 | acc: 0.8641 0.8519 0.8656
label_smoothing=0.1: acc 0.8671 | mean conf 0.8400 | ECE 0.0336 | test NLL 0.4675 | conf on wrong 0.660 | conf>0.99 0.2%
   per seed ECE: 0.0362 0.0308 0.0336 | acc: 0.8733 0.8562 0.8717
time 47 s (CPU)

পড়ে দেখুন। সাধারণ CE-তে accuracy ০.৮৬, কিন্তু গড় confidence ০.৯৩: model যতটা ঠিক, তার চেয়ে বেশি নিশ্চিত। ৬৪% ছবিতে সে ০.৯৯-এর বেশি probability দিয়েছে, আর ভুল উত্তরেও গড় confidence ০.৭৮. Label smoothing-এ গড় confidence ০.৮৪, accuracy-র (০.৮৭) কাছাকাছি; ECE গড়ে অর্ধেকের কম (০.০৭১৫ থেকে ০.০৩৩৬), আর প্রতিটি seed-এ প্রায় অর্ধেক বা তার কম; test NLL-ও কমেছে। Accuracy-র পার্থক্য (০.৮৬০৫ বনাম ০.৮৬৭১) seed-এর ওঠানামার (০.৮৫২ থেকে ০.৮৬৬) মধ্যে, তাই এখানে “accuracy বেড়েছে” বলা যায় না। এটি একটি ছোট model আর ডেটায় একটি স্থানীয় পরীক্ষা, সাধারণ নিয়ম নয়।

৪ · Imbalance-এর loss — class weight আর focal loss

বাজারঘরের cash-on-delivery অর্ডারের মধ্যে অল্প কিছু ফেরত আসে: ক্রেতা দরজায় পণ্য নেন না। এমন class imbalance-এ সাধারণ CE-র সমস্যা হলো গড়: ৯৭টি সাধারণ অর্ডারের ছোট ছোট loss মিলে ৩টি বিরল অর্ডারের loss-কে ছাপিয়ে যায়। Resampling, SMOTE আর threshold-এর আলোচনা মেশিন লার্নিং কোর্সের পর্ব ৫০-এ, আর WeightedRandomSampler পর্ব ১১-এ। Loss-এর দিক থেকে দুটি প্রচলিত উপায়:

Focal loss এসেছে Lin, Goyal, Girshick, He আর Dollár-এর ২০১৭ সালের প্রবন্ধ “Focal Loss for Dense Object Detection” থেকে (RetinaNet). সেখানে সমস্যা ছিল object detection: একটি ছবিতে হাজার হাজার সম্ভাব্য বাক্স, প্রায় সবই সহজ পটভূমি। তাদের পরীক্ষায় γ = ২, α = ০.২৫ ভালো কাজ করেছিল বলে রিপোর্ট করা; অন্য task-এ এই মান নিজে যাচাই করতে হয়। নিচের stepper-এ দেখুন কীভাবে focal loss সহজদের চুপ করায়।

import numpy as np, matplotlib.pyplot as plt

def focal(pt, gamma):                            # FL = −(1 − p_t)^γ · ln p_t
    return -(1 - pt) ** gamma * np.log(pt)

print("p_t     CE(γ=0)   γ=0.5     γ=1       γ=2       γ=5")
for pt in (0.1, 0.5, 0.9, 0.99):
    print(f"{pt:<6}", "  ".join(f"{focal(pt, g):8.5f}" for g in (0, 0.5, 1, 2, 5)))

# ১০০০টি সহজ negative (p_t = 0.95) বনাম ১০টি কঠিন positive (p_t = 0.2)
for g in (0, 2):
    easy, hard = 1000 * focal(0.95, g), 10 * focal(0.2, g)
    print(f"γ={g}: সহজদের মোট {easy:.3f}, কঠিনদের মোট {hard:.3f}, কঠিনের ভাগ {hard / (easy + hard):.1%}")

pt = np.linspace(0.01, 1, 300)
for g in (0, 0.5, 1, 2, 5):
    plt.plot(pt, focal(pt, g), label=f"gamma = {g}" + (" (CE)" if g == 0 else ""))
plt.axvspan(0.6, 1, color="gray", alpha=0.1)
plt.text(0.62, 3.6, "well-classified")
plt.ylim(0, 4.5); plt.xlabel("p_t (probability of the true class)"); plt.ylabel("loss")
plt.title("Focal loss down-weights easy examples"); plt.legend(); plt.show()

p_t     CE(γ=0)   γ=0.5     γ=1       γ=2       γ=5
0.1     2.30259   2.18442   2.07233   1.86509   1.35965
0.5     0.69315   0.49013   0.34657   0.17329   0.02166
0.9     0.10536   0.03332   0.01054   0.00105   0.00000
0.99    0.01005   0.00101   0.00010   0.00000   0.00000
γ=0: সহজদের মোট 51.293, কঠিনদের মোট 16.094, কঠিনের ভাগ 23.9%
γ=2: সহজদের মোট 0.128, কঠিনদের মোট 10.300, কঠিনের ভাগ 98.8%

৫ · বাজারঘরের ফেরত-অর্ডার — চার রকম loss-এর সত্যিকারের তুলনা

তত্ত্ব শুনতে ভালো; এবার মেপে দেখি। বাজারঘরের seeded কৃত্রিম ডেটা: প্রতিটি অর্ডারের ৮টি কৃত্রিম সংখ্যাগত feature (standardized), আর একটি অ-রৈখিক নিয়মে ফেরত আসার সম্ভাবনা; ২০,০০০ train আর ২০,০০০ test অর্ডার, ফেরত মাত্র ৩.২%. Model 8 → 64 → 64 → 2-এর MLP, AdamW, ১৫ epoch. চারটি loss, প্রতিটি তিনটি seed-এ। মাপা হলো ০.৫ threshold-এ recall আর precision, threshold-নিরপেক্ষ PR AUC (average precision), আর recall অন্তত ০.৮ রাখলে সর্বোচ্চ precision. এই মাপগুলো AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ।

~/bazarghar-dl$ uv run python imbalance.py
torch 2.15.0+cpu | scikit-learn 1.9.1 | python 3.14.4
train 20000, rare class 3.20% | test rare 3.38%
class weights (balanced): [0.52, 15.6]
loss                 recall@0.5   precision@0.5  PR-AUC       precision@recall0.8
plain CE             0.215±0.024  0.671±0.030    0.415±0.005  0.174±0.008
weighted CE          0.831±0.021  0.155±0.010    0.408±0.004  0.172±0.003
focal g=2            0.223±0.021  0.643±0.046    0.410±0.003  0.181±0.004
focal g=2 + weight   0.824±0.028  0.153±0.015    0.399±0.005  0.169±0.001
3 seeds each, time 19 s (CPU)

এই টেবিলটি এই পর্বের সবচেয়ে জরুরি শিক্ষা। ০.৫ threshold দেখলে মনে হয় class weight যাদু করেছে: recall ০.২১৫ থেকে ০.৮৩১. কিন্তু precision ০.৬৭১ থেকে ০.১৫৫-এ পড়েছে। Threshold-নিরপেক্ষ PR AUC চারটিতেই প্রায় এক (০.৩৯৯ থেকে ০.৪১৫), আর recall ০.৮ রাখলে সবার precision ০.১৭-০.১৮. অর্থাৎ model-গুলো অর্ডারগুলোকে প্রায় একই ক্রমে সাজায়; class weight মূলত probability-কে ওপরে ঠেলে ০.৫ threshold-কে সরিয়ে দিয়েছে। সাধারণ CE-র model-এ threshold নামিয়েও প্রায় একই জায়গায় পৌঁছানো যেত। Focal loss (γ = ২) এখানে PR AUC বাড়ায়নি।

৬ · Regression-এর loss — MSE, L1, Huber আর outlier

বাজারঘর ঢাকার ভেতরে ডেলিভারির দিন অনুমান করতে চায়। বেশিরভাগ অর্ডার ২-৩ দিনে পৌঁছায়, কিন্তু বন্যা বা হরতালে কয়েকটি ২০ দিন আটকে থাকে। এমন outlier-এর সামনে তিনটি loss তিনভাবে আচরণ করে। ভুল r = y − ŷ ধরে:

• MSE: r². ভুল দ্বিগুণ হলে জরিমানা চারগুণ; gradient 2r, তাই বড় ভুল বড় টান দেয়।
• L1 (MAE): |r|. Gradient সবসময় ±১, ভুল যত বড়ই হোক; শূন্যের কাছে gradient লাফ দেয়, তাই শেষ দিকে শেখা একটু অস্থির হতে পারে।
• Huber (সীমা δ): |r| ≤ δ হলে ½r², নইলে δ(|r| − ½δ). ছোট ভুলে MSE-র মতো মসৃণ, বড় ভুলে L1-এর মতো স্থির ঢাল δ. PyTorch-এ nn.HuberLoss(delta=δ), আর তার আত্মীয় SmoothL1, nn.SmoothL1Loss(beta=β), যা Huber-কে β দিয়ে ভাগ করা রূপ।

সবচেয়ে সরল “model” হলো একটি constant c, যা সব অর্ডারে একই দিন বলে। কোন c কোন loss-কে সবচেয়ে কম করে? নিচের ব্লকে ৪০টি অর্ডার, যার ৩টি বন্যা-হরতালে আটকে থাকা।

import numpy as np

rng = np.random.default_rng(42)                  # বাজারঘর: ঢাকার ভেতরে ডেলিভারির দিন
days = np.round(rng.gamma(6, 0.4, 40), 1)        # সাধারণ অর্ডার, গড় প্রায় ২.৪ দিন
days[:3] = [14.0, 18.0, 21.0]                    # বন্যা আর হরতালে আটকে থাকা ৩টি অর্ডার

def huber(r, d=1.0):
    a = np.abs(r)
    return np.where(a <= d, 0.5 * r**2, d * (a - 0.5 * d))

losses = {"MSE": lambda r: r**2, "L1": np.abs, "Huber δ=1": huber}
grid = np.linspace(0, 10, 10001)                 # সব constant c পরীক্ষা: অনুমান = c
for name, f in losses.items():
    c = grid[np.argmin([f(days - g).mean() for g in grid])]
    print(f"{name:9s}: সেরা constant c = {c:.3f}")
print(f"তুলনা: mean {days.mean():.3f} | median {np.median(days):.3f}")

c = 2.5                                          # c = 2.5-এ প্রতিটি অর্ডারের টান (−∂loss/∂c)
pull = {"MSE": 2 * (days - c), "L1": np.sign(days - c),
        "Huber δ=1": np.clip(days - c, -1, 1)}
for name, g in pull.items():
    print(f"{name:9s}: ৩টি outlier-এর মোট টান {g[:3].sum():6.2f} | বাকি ৩৭টির {g[3:].sum():6.2f}")

MSE      : সেরা constant c = 3.530
L1       : সেরা constant c = 2.400
Huber δ=1: সেরা constant c = 2.448
তুলনা: mean 3.530 | median 2.400
MSE      : ৩টি outlier-এর মোট টান  91.00 | বাকি ৩৭টির  -8.60
L1       : ৩টি outlier-এর মোট টান   3.00 | বাকি ৩৭টির  -5.00
Huber δ=1: ৩টি outlier-এর মোট টান   3.00 | বাকি ৩৭টির  -4.60

Deep network-এ আরেকটি কারণে Huber জনপ্রিয়: বড় ভুলে MSE-র gradient বিশাল হয়ে training অস্থির করতে পারে, আর Huber তা সীমিত রাখে। Fast R-CNN (Girshick, ২০১৫) bounding box regression-এ SmoothL1 ব্যবহার করেছিল; reinforcement learning-এর DQN-ধারার কাজেও Huber-ধরনের loss দেখা যায়। δ-এর একক লক্ষ্যের এককের সমান (এখানে দিন), তাই লক্ষ্য scale করলে δ-ও বদলাতে হয়।

৭ · Multi-label, KL divergence আর contrastive loss — এক নজরে

Multi-label. একটি পণ্য একসঙ্গে “দেশি”, “অর্গানিক” আর “ছাড়” হতে পারে: এটি multi-label classification. এখানে softmax চলে না, কারণ softmax শ্রেণিগুলোকে প্রতিযোগী করে। প্রতিটি ট্যাগ একটি আলাদা হ্যাঁ/না: C টি logit, (N, C) আকারের float ০/১ লক্ষ্য, আর BCEWithLogitsLoss. বিরল ট্যাগের জন্য pos_weight প্রতিটি ট্যাগের positive-এর loss বাড়ায়। Threshold প্রতিটি ট্যাগে আলাদা বাছা যায় (মেশিন লার্নিং কোর্সের পর্ব ২৫)।

KL divergence. লক্ষ্য যখন one-hot নয়, একটি পুরো বণ্টন, তখন KL divergence KL(p ‖ q) = Σ p ln(p/q) দিয়ে দুটি বণ্টনের দূরত্ব মাপা হয়। সবচেয়ে পরিচিত ব্যবহার knowledge distillation: বড় teacher model-এর logits-কে temperature T দিয়ে ভাগ করে softmax নিলে একটি নরম বণ্টন আসে, যাতে “শার্ট টি-শার্টের কাছাকাছি” ধরনের তথ্য থাকে; ছোট student সেটি নকল করতে শেখে। পুরো পদ্ধতি পর্ব ৫৯ (quantization, distillation আর pruning)-এ। PyTorch-এর nn.KLDivLoss-এর একটি ফাঁদ: input হতে হবে log-probability, target সাধারণ probability, আর গণিতের KL পেতে reduction="batchmean".

Ranking আর contrastive. কখনো শ্রেণি নয়, দূরত্বই লক্ষ্য: “এই দুটি রিভিউ একই পণ্যের কথা বলছে”। Triplet loss max(০, d(a, p) − d(a, n) + margin) একটি anchor-কে তার positive-এর কাছে আর negative থেকে অন্তত margin দূরে চায়। InfoNCE আরও সরল: একটি batch-এর সব জোড়ার similarity-কে temperature দিয়ে ভাগ করে cross-entropy, যেখানে সঠিক জোড়া হলো “সঠিক শ্রেণি”, আর batch-এর বাকিরা negative. এটাই contrastive learning-এর মূল loss. বিস্তারিত পর্ব ৬৭ (Sentence embedding আর semantic search) আর পর্ব ৮২ (CLIP-সহ multimodal model)-এ।

চারটি loss-এর ছোট সত্যিকারের run:

~/bazarghar-dl$ uv run python previews.py
torch 2.15.0+cpu | python 3.14.4
multi-label BCE: 0.2407 | pos_weight=3: 0.5412
teacher soft target T=2: [0.7361, 0.1643, 0.0996]
KLDivLoss(batchmean): 0.1526 | by hand sum p*log(p/q): 0.1526
KLDivLoss default reduction warning: reduction: 'mean' divides the total loss by both the batch s
TripletMarginLoss(margin=1): 0.5833
InfoNCE (cross_entropy on similarity, diagonal = positive): 0.0017

Teacher-এর logits [৪, ১, ০] T = ২ দিয়ে নরম হয়ে [০.৭৩৬১, ০.১৬৪৩, ০.০৯৯৬]; batchmean-এর KL হাতের হিসাবের সঙ্গে হুবহু ০.১৫২৬. Default reduction="mean" দিলে PyTorch সতর্ক করে যে এটি batch আর শ্রেণি দুটির সংখ্যা দিয়েই ভাগ করে, যা KL-এর সংজ্ঞা নয়। শেষ লাইনে InfoNCE আসলে F.cross_entropy(similarity, torch.arange(N)): contrastive loss-ও শেষে cross-entropy.

৮ · Reduction আর masking — গড়টা আসলে কিসের ওপর

প্রতিটি PyTorch loss প্রথমে প্রতিটি উদাহরণের (বা token-এর) জন্য একটি করে loss বানায়, তারপর reduction দিয়ে একটি সংখ্যায় আনে: 'none' সব আলাদা রাখে, 'sum' যোগ করে, 'mean' (default) গড় করে। Token-ভিত্তিক task-এ (প্রতিটি শব্দের tag, পরের token অনুমান) sequence-গুলো padding দিয়ে সমান করা থাকে (পর্ব ১১)। Padding-এর ঘরে কোনো আসল label নেই, তাই সেগুলো loss থেকে বাদ দিতে হয়। CrossEntropyLoss-এর ignore_index (default −১০০) ঠিক এই কাজ করে: লক্ষ্য −১০০ হলে সেই ঘরের loss শূন্য, আর 'mean' শুধু বাকি ঘরের সংখ্যা দিয়ে ভাগ করে।

নিজে mask দিয়ে করলে নিয়ম একটাই: masked গড় = Σ(loss × mask) / Σ mask. নিচের ব্লকে তিনটি বাংলা রিভিউ (দৈর্ঘ্য ৭, ৩, ২), padding করে সবাই ৭; দুটি প্রচলিত ভুল আর একটি বৈধ বিকল্প।

import numpy as np

rng = np.random.default_rng(42)                  # ৩টি বাংলা রিভিউ, token-level task, ৪টি tag
lengths = np.array([7, 3, 2])                    # আসল দৈর্ঘ্য; padding করে সবাই ৭
B, T, C = 3, 7, 4
logits = rng.normal(0, 1.5, (B, T, C))
target = rng.integers(0, C, (B, T))
mask = np.arange(T)[None, :] < lengths[:, None]  # True = আসল token, False = padding
target[~mask] = 0                                # padding-এ বসানো ভুয়া label 0

z = logits - logits.max(-1, keepdims=True)
logp = z - np.log(np.exp(z).sum(-1, keepdims=True))
tok_loss = -np.take_along_axis(logp, target[..., None], -1)[..., 0]   # (B, T)

print("mask:\n", mask.astype(int))
print("ভুল ১, সব ঘরের গড় (padding-সহ)    :", round(tok_loss.mean(), 4))
print("ভুল ২, (loss*mask).mean()           :", round((tok_loss * mask).mean(), 4))
right = (tok_loss * mask).sum() / mask.sum()
print("ঠিক, masked token গড় (sum/count)   :", round(right, 4), "| আসল token", mask.sum())
per_seq = (tok_loss * mask).sum(1) / lengths
print("অন্য পছন্দ, প্রতি রিভিউর গড়ের গড়  :", round(per_seq.mean(), 4), "| প্রতি রিভিউ", per_seq.round(4))

mask:
 [[1 1 1 1 1 1 1]
 [1 1 1 0 0 0 0]
 [1 1 0 0 0 0 0]]
ভুল ১, সব ঘরের গড় (padding-সহ)    : 1.3113
ভুল ২, (loss*mask).mean()           : 0.6608
ঠিক, masked token গড় (sum/count)   : 1.1565 | আসল token 12
অন্য পছন্দ, প্রতি রিভিউর গড়ের গড়  : 1.4048 | প্রতি রিভিউ [0.9426 0.7355 2.5364]

PyTorch-এ একই জিনিসগুলো, সঙ্গে weight-এর একটি সূক্ষ্ম নিয়ম। দুটি বাক্য, প্রতিটিতে ৪টি অবস্থান, ৫টি শ্রেণি, তিনটি padding ঘর (−১০০):

~/bazarghar-dl$ uv run python reduction.py
torch 2.15.0+cpu | python 3.14.4
reduction='none' : tensor([0.4433, 0.6587, 0.4278, 0.0000, 0.5727, 3.1816, 0.0000, 0.0000])
reduction='sum'  : tensor(5.2840)
reduction='mean' : tensor(1.0568)
logits (B, C, T) form: 1.0568084716796875
weight + mean : 2.0011656284332275
sum / count   : 3.602097749710083 | sum / sum(w): 2.0011653900146484
label_smoothing=0.1: 0.3913113474845886 | by hand: 0.3913113474845886
bad class index: IndexError - Target 7 is out of bounds.
all ignored -> mean: nan
HuberLoss(delta=2): tensor([0.0450, 0.3200, 6.0000]) | 2*SmoothL1(beta=2): tensor([0.0450, 0.3200, 6.0000])

• 'mean' = ৫.২৮৪০ / ৫ = ১.০৫৬৮: ৮টি ঘরের মধ্যে ৫টি আসল; ignore করা ঘর ভাগের সংখ্যায় নেই।
• আকার: sequence-এর জন্য logits (B, T, C) হলে CrossEntropyLoss চায় (B, C, T), তাই logits.transpose(1, 2); অথবা (B·T, C)-তে চ্যাপ্টা করুন। দুটি পথ একই ১.০৫৬৮.
• Weight-এর গড়: শ্রেণি ৪-এর weight ৫ দিলে 'mean' দেয় ২.০০১২, যা weighted যোগফল ÷ weight-এর যোগফল; token সংখ্যা দিয়ে ভাগ করলে আসত ৩.৬০২১. নিজে 'none' নিয়ে গড় করলে এই পার্থক্য মনে রাখুন।
• দুটি বিপদ: শ্রেণি-সূচক পরিসরের বাইরে হলে IndexError (GPU-তে প্রায়ই অস্পষ্ট CUDA error হয়ে আসে); আর একটি batch-এর সব ঘর ignore হলে 'mean' দেয় nan, যা পুরো training নষ্ট করতে পারে। খুব ছোট বা পুরো padding-এর batch থাকলে আগে পরীক্ষা করুন।
• Huber বনাম SmoothL1: HuberLoss(delta=2) = ২ × SmoothL1Loss(beta=2); β = ১-এ দুটি এক।

৯ · Task দেখে loss বাছাই

সব মিলিয়ে প্রশ্নগুলো একই ক্রমে: output কী রকম (একটি শ্রেণি, কয়েকটি ট্যাগ, সংখ্যা, দূরত্ব)? ডেটায় noise বা outlier কেমন? শ্রেণির ভারসাম্য কেমন? আর শেষে কোন metric-এ বিচার হবে? নিচের stepper-এ বাজারঘরের পাঁচটি task.

১০ · AI-এর যুগে — AI-এর বাছা loss যাচাই

“Imbalanced ডেটার জন্য একটি loss দাও” বললে AI assistant প্রায়ই সঙ্গে সঙ্গে focal loss লিখে দেয়, কারণ নামটি পরিচিত। এই পর্বের প্রায় সব ভুলই চুপচাপ: কোড চলে, loss নামে, শুধু metric বা probability ভুল। তাই নিচের জায়গাগুলো আলাদা করে দেখুন।

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

• Output আর লক্ষ্যের shape ও dtype ছাপিয়ে দেখেছি: শ্রেণি-সূচক int64, multi-label লক্ষ্য float
• নিজের লেখা loss একটি ছোট উদাহরণে হাতে হিসাব বা PyTorch-এর built-in-এর সঙ্গে মিলিয়েছি
• Padding বা ignore করা ঘর গড়ে ঢোকেনি, আর সব-padding batch-এ nan আসে না
• নতুন loss-এর লাভ threshold-নিরপেক্ষ metric-এ আর কয়েকটি seed-এ দেখেছি, একটি run-এ নয়
• Probability ব্যবহার করলে ECE বা reliability diagram দেখেছি
• প্রবন্ধের নাম, বছর আর “সেরা” hyperparameter-এর দাবি মূল সূত্রে মিলিয়েছি; কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি