সংখ্যাগত স্থিরতা — কেন NaN আসে

Mixed precision training — modern LLM-এর foundation. ২০১৭-এর Volta GPU-র Tensor Cores-এর পর থেকে standard. কারণ purely economic: speed, memory, energy.

(১) কেন float16/bfloat16?

• Memory: float16 = float32-এর অর্ধেক। 70B model float32-এ 280GB, float16-এ 140GB.
• Speed: Tensor Cores float16/bfloat16-এ ২-৪x দ্রুত।
• Bandwidth: GPU memory ↔ compute — ছোট data দ্রুত transfer.
• Cost: GPU hour ও power dramatic কমে।

(২) float16 বনাম bfloat16:

• float16: 1 sign + 5 exp + 10 mantissa. Range $\pm 6.5 \times 10^{4}$, precision ~৩-৪ ডিজিট।
  • সমস্যা: গ্রেডিয়েন্ট ছোট হলে underflow.
  • Solution: loss scaling — gradient × 2^k, পরে unscale.
• bfloat16: 1 sign + 8 exp + 7 mantissa. Range float32-এর সমান $\pm 3.4 \times 10^{38}$, precision কম।
  • Google TPU-তে designed.
  • Range বড় তাই overflow/underflow rare.
  • Loss scaling লাগে না — সরল।
  • আজকের LLM training-এ favorite.

(৩) Mixed precision strategy:

• Forward + backward: float16/bfloat16 (দ্রুত)।
• Master weights: float32 (precision সংরক্ষণ)।
• Optimizer state: float32 (Adam-এর variance)।
• Loss accumulation: float32 (small loss numbers)।
• Layer norm, softmax: float32 (numerically sensitive)।

(৪) Trade-offs:

• Pros: 2-4x speed, half memory, similar accuracy.
• Cons: Loss scaling-এর hyperparameter, debug কঠিন, NaN-prone.
• Edge case: ছোট architecture-এ pure float32 মাঝে মাঝে ভাল।

(৫) Production checklist:

• PyTorch torch.cuda.amp.autocast() — automatic.
• NaN detection: torch.isnan(loss).any() regular check.
• Gradient scaler: GradScaler()।
• Tensor Cores enable: A100, H100-এ standard.

(৬) আরও আগামীর দিক:

• FP8 (Hopper, ২০২২): H100-এ — half memory of FP16.
• INT8 / INT4 inference: Quantization — production-এ ৫-১০x দ্রুত।
• FP4 (২০২৫+): Research, extreme efficiency.

মূল উপলব্ধি: Floating-point precision — শুধু gণিতিক detail না, AI-এর economics. GPT-4 training cost $100M — half precision না হলে $400M হতো। যিনি bfloat16-এর nuances বুঝেন — তিনি modern AI infrastructure-এ valuable.

এই trick — log-sum-exp-এর foundation — অসাধারণ সরল কিন্তু গভীর। সব deep learning framework-এ অভ্যন্তরীণ। দেখুন কেন কাজ করে।

গাণিতিক প্রমাণ:

মূল softmax: $\text{softmax}(x_i) = \dfrac{e^{x_i}}{\sum_j e^{x_j}}$

$m = \max_j x_j$ subtract করুন:

$\dfrac{e^{x_i - m}}{\sum_j e^{x_j - m}} = \dfrac{e^{x_i} \cdot e^{-m}}{\sum_j e^{x_j} \cdot e^{-m}} = \dfrac{e^{-m}}{e^{-m}} \cdot \dfrac{e^{x_i}}{\sum_j e^{x_j}} = \text{softmax}(x_i)$

$e^{-m}$ numerator ও denominator-এ গুণ — cancel. গণিত একই।

(১) কেন overflow এড়ায়?

• Subtraction-এর পর: $x_i - m \leq 0$ সবার জন্য (max-এ $0$)।
• $e^{0} = 1$ সর্বোচ্চ। $e^{\text{negative}} \in (0, 1]$।
• সর্বোচ্চ exponent শূন্য — overflow অসম্ভব।

(২) Underflow concern?

• Subtraction-এর পর কিছু $x_i - m$ খুব negative হতে পারে — $e^{-1000} \to 0$।
• কিন্তু অন্তত একটি term ($\max$) = $1$ — denominator কখনো ০ হবে না।
• তাই division safe.

(৩) Log-sum-exp variant:

আরও সাধারণ trick: $\log\sum_j e^{x_j}$ গণনায়:

$\log\sum_j e^{x_j} = m + \log\sum_j e^{x_j - m}$

এটি cross-entropy, log-likelihood, attention scoring — সবেই ব্যবহৃত।

(৪) PyTorch ভেতরে কী চলছে?

• torch.softmax, torch.log_softmax — সবেই এই trick.
• CUDA kernel-এ optimized.
• Backward pass-এ gradient calculation-ও stable.

(৫) কেন আগে নয়?

• "Stable softmax" trick পুরোনো (১৯৭০-এর scientific computing literature)।
• Neural network early days-এ overlooked — অনেক bug source.
• ২০১২ AlexNet-এর পর CUDA library-এ standard.

(৬) Attention-এ critical:

• Transformer attention: $\text{softmax}\left(\dfrac{QK^T}{\sqrt{d_k}}\right)V$।
• $QK^T$ values অনেক বড় হতে পারে — stable softmax ছাড়া NaN.
• Flash Attention (Dao et al. ২০২২) — log-sum-exp trick + GPU memory hierarchy.

(৭) যেকোনো language-এ implementation:

• NumPy: x - np.max(x, axis=-1, keepdims=True)
• PyTorch: F.log_softmax(x, dim=-1)
• JAX: jax.nn.log_softmax(x)
• TensorFlow: tf.nn.log_softmax(x)

মূল উপলব্ধি: এই এক-লাইনের trick numerical computing-এর সৌন্দর্য। গণিত একই, সংখ্যাগতভাবে অপরিহার্য। ভাল ML engineer এই detail-এ মনোযোগ দেয় — যা separates production থেকে toy code.

NaN debugging — production ML-এর সবচেয়ে frustrating অভিজ্ঞতা। ২ ঘণ্টায় training, ১,০০,০০০ step পরে loss NaN — কী করবেন? Systematic approach:

(১) প্রথম response — থামান, বিশ্লেষণ:

• Training-এ NaN early detection: if torch.isnan(loss): break।
• Last good checkpoint থেকে resume — disaster avoid.
• Logs সংরক্ষণ: loss, grad norm, learning rate, weights min/max.

(২) Common causes — ranked:

1. Exploding gradient (50% cases):
   • Symptom: loss-এর আগে gradient norm explode.
   • Fix: gradient clipping (clip_grad_norm_, max=1.0)।
2. Learning rate বেশি (20%):
   • Symptom: শুরুতেই NaN.
   • Fix: warmup, ১০x ছোট LR.
3. Bad data (15%):
   • Symptom: নির্দিষ্ট batch-এ NaN.
   • Fix: torch.isfinite(x).all() assertion.
4. log(0) variant (10%):
   • Symptom: cross-entropy-এ predictions extreme.
   • Fix: epsilon, label smoothing.
5. Mixed precision overflow (5%):
   • Symptom: float16-এ specific operation.
   • Fix: ঐ operation float32-এ wrap.

(৩) PyTorch debugging tools:

• torch.autograd.set_detect_anomaly(True) — backward-এ NaN-এর source trace.
• torch.utils.checkpoint — memory-efficient debugging.
• Hooks: প্রতিটি layer-এ output check.
• TensorBoard: loss, grad histogram visualize.
• Weights & Biases: production logging.

(৪) Bisection technique:

• Loss এ NaN — কোন layer-এ?
• Forward pass-এ layer-wise output check.
• Output finite হলে — পরের layer-এ যান।
• প্রথম যে layer NaN return করে — সেটিই সমস্যা।

(৫) Numerical safety checks:

def assert_finite(t, name):
    if not torch.isfinite(t).all():
        nan_count = torch.isnan(t).sum().item()
        inf_count = torch.isinf(t).sum().item()
        raise ValueError(f"{name}: {nan_count} NaN, {inf_count} Inf")

# Forward pass-এ
x = embedding(input_ids)
assert_finite(x, "embedding")
x = attention(x)
assert_finite(x, "attention")

(৬) Real-world example workflows:

• "Training stable for 1k steps, NaN at 1001":
  • Sample at step 1000 corrupt? — data check.
  • Specific weight saturate? — weight histogram.
  • LR scheduler-এ jump? — log scheduler values.
• "NaN in attention only at long sequences":
  • $QK^T$ values too large?
  • Stable softmax confirm.
  • Sequence length-নির্ভর scaling factor.
• "NaN only on certain GPUs":
  • cuDNN version mismatch?
  • Tensor Core specific (Ampere vs Hopper)?

(৭) Prevention > cure:

• Initial training run-এ verbose logging.
• Gradient clipping সর্বদা।
• Warmup mandatory.
• Validation NaN check প্রতি epoch.
• Smaller model দিয়ে dry-run.

(৮) যখন সব ব্যর্থ:

• Learning rate aggressive কমান (১০-১০০x)।
• Smaller batch, smaller model.
• float32 fallback.
• Loss curve community-তে share — কেউ same experience.

মূল উপলব্ধি: NaN debugging শিল্প — empirical, frustrating, কিন্তু skill. প্রতিটি ভাল ML engineer তার career-এ ১০০+ NaN debug করে। প্রতিটি বার শিখলে — এক একটি মূল্যবান lesson. Patient, systematic approach — that's the only way.

Quantization — phone-এ Llama চালানোর secret. ২০২২ থেকে এর গবেষণা explosive. GPU-তে train, edge-এ deploy — quantization এর ব্রিজ।

(১) Quantization কী?

• Float32 (৩২ bits) → INT8 (৮ bits) → INT4 (৪ bits)।
• Real number → Integer mapping: $x_{\text{int}} = \text{round}(x_{\text{float}} / s + z)$।
• $s$ = scale factor, $z$ = zero point.

(২) কেন critical?

• Memory: 4x to 8x reduction. 7B model float32-এ 28GB, INT4-এ 3.5GB — phone-এ চলে।
• Speed: Integer math float-এর চেয়ে ৪-৮x দ্রুত।
• Energy: Mobile battery-এ critical.
• Bandwidth: Memory ↔ compute small data.

(৩) Quantization-এর ধরন:

• Post-Training Quantization (PTQ):
  • Train float-এ, deploy int-এ।
  • সরল, কিন্তু accuracy drop সম্ভব।
  • GPTQ, AWQ — popular.
• Quantization-Aware Training (QAT):
  • Training-এই quantization simulate.
  • ভাল accuracy, কিন্তু expensive.
• Dynamic vs Static:
  • Dynamic: runtime-এ activation quantize.
  • Static: pre-computed scales.

(৪) কেন accuracy ধরে রাখে?

• Redundancy: Modern model overparameterized — extra precision অপ্রয়োজন।
• Robustness: Activation noise-এ trained network resilient.
• Critical layers identified: Sensitive layers (first, last) higher precision.
• Outlier handling: AWQ, SmoothQuant — extreme values protect.

(৫) Trade-offs:

• INT8: প্রায় lossless (~১% accuracy drop)।
• INT4: ১-৫% drop, কিন্তু 4x compression.
• INT2/INT1: research, large degradation.

(৬) Real-world examples:

• Llama.cpp: CPU-তে quantized Llama চালায়। M1 Mac-এ 7B model.
• GGUF format: Various quantization levels (Q4_K, Q5_K, Q8_0)।
• iPhone Neural Engine: INT8 default.
• Edge TPU: INT8 only.

(৭) Calibration data:

• Quantization-এ scale calculate-এর জন্য representative data.
• ৫০০-১০০০ samples enough.
• Domain-specific calibration — better accuracy.

(৮) আগামী direction:

• Mixed-precision quantization: Layer-by-layer optimal precision.
• 1-bit LLM (BitNet, ২০২৪): Weight $\in \{-1, 0, 1\}$।
• Hardware-aware: GPU/TPU/NPU-specific quantization.
• Activation quantization: Weight + activation দু'টোই।

(৯) Bangladesh context:

• Cheap Android phone-এ AI চালানো — quantization indispensable.
• Bangla LLM-এর mobile deployment.
• Edge inference — internet ছাড়া AI.
• Banglalink/Robi data limit-এ — local model.

মূল উপলব্ধি: Quantization বুঝলে — full picture দেখতে পান। Training (full precision) → Optimization (mixed precision) → Deployment (quantized)। প্রতিটি stage-এর numerical considerations. আজকের production AI engineer তিন stage-ই বোঝেন।