অধ্যায় 47 — Numerical Stability

📖 একটি ছোট গল্প

GPT-2 training-এ একটি layer-এর weight-এর mean 10¹⁵ হয়ে গেল। এরপর softmax-এ সব value zero হল। NaN (Not a Number) — training থেমে গেল। কারণ? Numerical instability। AI research-level কাজে এই সমস্যা daily basis-এ।

Intuitive Explanation

Computer-এর floating-point সংখ্যা (float32, float64) সীমিত precision নিয়ে কাজ করে। যখন সংখ্যাগুলো খুব বড় হয় বা খুব ছোট হয়, তখন overflow বা underflow হয়। AI-তে কয়েক লাখ multiplication chained হওয়ায় এই সমস্যা common।

Numerical stability মানে — algorithm এমনভাবে design করা যাতে intermediate steps-এ সংখ্যাগুলো manageable range-এ থাকে।

Overflow & Underflow

Overflow — সংখ্যা বেশি বড়

Softmax-এ exp(1000) দিলে float32-এ inf হয় — division by inf = NaN।

Underflow — সংখ্যা বেশি ছোট

Probabilities গুণ করতে করতে 10⁻³²⁴ এর নিচে চলে গেলে 0 হয়ে যায় — log-likelihood হারায় মানে।

e^{1000} \rightarrow \infty \quad \text{(overflow)} \qquad e^{-1000} \rightarrow 0 \quad \text{(underflow)}

Log-Sum-Exp Trick

Softmax ও cross-entropy-তে log(Σ e^(x_i)) বের করতে হয়। সরাসরি করলে overflow হয়।

\log\sum_i e^{x_i} = x_{max} + \log\sum_i e^{x_i - x_{max}}

সব x_i থেকে সর্বোচ্চ value বাদ দিলে exponentiated values 0 থেকে 1-এর মধ্যে থাকে — safe!

Numerically Stable Softmax

Stable softmax implementation:

\text{softmax}(x_i) = \frac{e^{x_i - \max(x)}}{\sum_j e^{x_j - \max(x)}}

Max বাদ দিলে largest numerator = 1, বাকিগুলো ≤ 1 — overflow impossible।

Layer Normalization Stability

Transformer-এ LayerNorm:

\text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}}

ε = 10⁻⁶ দিলে divide-by-zero বা sqrt(0) সমস্যা হয় না। Gradient flow-ও stable থাকে।

✨ টিপ

RMSNorm (modern alternative) — centering skip করে: \text{RMSNorm}(x) = x / \sqrt{\text{mean}(x^2) + \epsilon}। Llama, GPT-NeoX-এ ব্যবহৃত।

Python: Stable Softmax & LogSumExp

pythonPython · NumPy

import numpy as np

def stable_softmax(x):
    """Numerically stable softmax."""
    x_max = np.max(x, axis=-1, keepdims=True)
    exp_x = np.exp(x - x_max)     # largest = 1, rest ≤ 1
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

def logsumexp(x):
    """Stable log(sum(exp(x)))."""
    x_max = np.max(x)
    return x_max + np.log(np.sum(np.exp(x - x_max)))

# Test with large values
x = np.array([1000.0, 1001.0, 999.0])
print("Naive softmax:", np.exp(x) / np.sum(np.exp(x)))  # overflow!
print("Stable softmax:", stable_softmax(x))            # works!
print("LogSumExp:", logsumexp(x))

Mixed Precision Training

float16 (FP16) — memory কম, speed বেশি, কিন্তু dynamic range ছোট।
Gradient scaling — ছোট gradient underflow এড়াতে scale up করা হয়, update-র পর restore।
Loss scaling — loss × 2¹⁶ করে gradient-এর magnitude বাড়ানো।
bfloat16 — float32-এর range + float16-এর precision। TPU, A100 GPU-তে default।

Common Mistakes

Softmax-এ e^(x_i) সরাসরি — overflow guaranteed for large logits।
Probability গুণ করতে করতে underflow — log-probability ব্যবহার করুন।
Variance compute-তে Σx² − (Σx)²/N — catastrophic cancellation। Welford's algorithm ব্যবহার করুন।
Gradient check-এ finite difference step খুব ছোট — truncation + roundoff error।

Practice Tasks

stable_softmax-এ x = [0, 1000, -1000] দিয়ে চালান — NaN আসে কি?
LogSumExp-এর মান হাতে verify করুন — max(x) + log(1 + e⁻¹⁰⁰⁰ + e²⁰⁰⁰)।
Cross-entropy loss নিজে implement করুন — log-sum-exp trick সহ।

Interview Questions

Softmax-এ কেন numerical instability হয়? সমাধান কী?
Mixed precision training-এ gradient scaling কেন দরকার?
Log probability ব্যবহার করলে কী advantage?
LayerNorm-এ ε কেন যোগ করি?

Summary · সারসংক্ষেপ

Floating-point সীমিত precision — overflow/underflow AI training-এ common।
Log-sum-exp trick = x_max + log(Σe^(x_i − x_max)) — softmax stable করে।
LayerNorm/RMSNorm-এ ε numerical stability-এর জন্য।
Mixed precision (FP16/bfloat16) memory/speed বাড়ায় কিন্তু careful handling চাই।
Stable algorithm design = research-level AI-এ fundamental skill।

পূর্ববর্তী · CH 46

Probabilistic Graphical Models

পরবর্তী · CH 48

Matrix Calculus