Broadcasting — অ্যারের জাদু

NumPy-এর সবচেয়ে চতুর design — stride। প্রতিটি ndarray-এ shape ছাড়াও একটি strides tuple আছে — "এই axis-এ পরবর্তী element-এ যেতে কত byte লাফাও।"

সাধারণ stride: একটি (৩, ৪) float64 array-এ — প্রতি element ৮ byte। Strides হবে (৩২, ৮) — অর্থাৎ row-এ যেতে ৩২ byte (৪ × ৮), column-এ ৮ byte।

Broadcasting-এর জাদু:

• একটি (৪,) array — strides (৮,), total memory ৩২ byte।
• এটাকে (৩, ৪)-এ broadcast করতে — NumPy strides বানায় (0, ৮)।
• "Row-এ যেতে 0 byte লাফাও" — অর্থাৎ একই memory location আবার পড়ো।
• Logical view (৩, ৪), physical memory ৩২ byte — copy নেই।

কেন এটা genius:

• Memory: ১ million row + (৫,) bias = ১ million × ৫ × ৮ byte সাশ্রয় (৪০ MB)। Big data-এ critical।
• Speed: Cache-friendly — একই memory বারবার পড়লে CPU cache hit বেশি।
• Composable: Multiple broadcast operation chain করলেও কোনো intermediate copy নেই।

Trade-off:

• broadcast_to result read-only — কারণ একই memory একাধিক index-এ map। লিখতে দিলে data corruption।
• কোনো কোনো operation (যেমন np.sort) view-তে কাজ করে না — internally copy বানায়।
• Memory layout non-contiguous হলে — পরের কিছু operation slow হতে পারে।

যাচাই: চালান —

import numpy as np
a = np.array([1,2,3,4])
b = np.broadcast_to(a, (3,4))
print(b.strides)         # (0, 8) — row stride 0!
print(b.base is a)       # True
print(a.nbytes, b.nbytes) # 32, 32 — same memory

মূল উপলব্ধি: Broadcasting "magic" নয় — clever indexing। এই principle জানলে — আপনি memory-efficient ML pipeline ডিজাইন করতে পারবেন। PyTorch/TensorFlow-ও একই principle ব্যবহার করে (যেমন expand বনাম repeat)।

Normalization layer — DL-এ training stability ও convergence speed-এর সবচেয়ে বড় breakthrough (Ioffe & Szegedy ২০১৫, Ba et al. ২০১৬)। সবগুলোই broadcasting-এর pattern।

Setup: একটি batch — shape (N, D), যেখানে N = batch size (যেমন ৩২), D = feature dim (যেমন ৭৬৮)।

(১) Batch Normalization (BN):

• Idea: "এই batch জুড়ে প্রতিটি feature-এর গড় ০, std ১ করো।"
• mean = X.mean(axis=0) → shape (D,) — N dimension reduced।
• std = X.std(axis=0) → shape (D,)।
• X_norm = (X - mean) / (std + eps) — broadcasting (N, D) - (D,) → (N, D)।
• প্রতিটি feature-এর statistic batch জুড়ে নেওয়া — sample-এর মধ্যে dependence।

(২) Layer Normalization (LN):

• Idea: "প্রতিটি sample-এর ভেতরে সব feature-এর গড় ০, std ১ করো।"
• mean = X.mean(axis=1, keepdims=True) → shape (N, 1)।
• std = X.std(axis=1, keepdims=True) → shape (N, 1)।
• X_norm = (X - mean) / (std + eps) — broadcasting (N, D) - (N, 1) → (N, D)।
• Sample-এর মধ্যে independence — Transformer-এর preferred।

keepdims-এর ভূমিকা:

• keepdims=True না দিলে — mean shape (N,), broadcasting (N, D) - (N,) → confusion বা error।
• keepdims=True shape (N, 1) রাখে — broadcasting clean ও explicit।

(৩) Affine transform (γ, β):

• Normalized output-এ learnable scale ও shift: Y = γ * X_norm + β।
• γ, β shape (D,) — broadcasting (N, D) * (D,) → (N, D)।
• মডেল শিখে — কোন feature বেশি/কম important।

RMSNorm (Llama-এ ব্যবহৃত):

• Mean বাদ — শুধু RMS দিয়ে scale: X / sqrt(mean(X²))।
• আরও দ্রুত, একই accuracy — broadcasting pattern same।

মূল উপলব্ধি: এই সব normalization variant — আসলে একই broadcasting pattern ভিন্ন axis-এ। যেদিকে statistic নেওয়া হল — সেই axis "1" হয়ে gone, বাকি broadcast। DL-এর hottest research এই axis-choice নিয়ে।

এই bug শ্রেণিকক্ষে সহজ মনে হয়, production-এ disastrous। কারণ — code চলে, ফল আসে, কিন্তু metric অদ্ভুত। Debug কঠিন কারণ কোথাও exception নেই।

সবচেয়ে সাধারণ cases:

• (N,) + (N,1) → (N, N) — element-wise চাইলে disaster।
• (N,) - (1, N) → (1, N) — শুধু একটি sample।
• predictions.shape (N, 1) ও labels.shape (N,) — loss N×N matrix হয়ে যায়, mean-ও ভুল।
• Last layer-এ squeeze ভুলে গেলে — pyTorch-এ classic Kaggle bug।

Defense (১) — সবসময় shape print/assert:

def normalize(X, mean, std):
    assert X.ndim == 2, f"X must be 2D, got {X.shape}"
    assert mean.shape == (X.shape[1],), f"mean shape mismatch: {mean.shape}"
    assert std.shape == (X.shape[1],), f"std shape mismatch: {std.shape}"
    return (X - mean) / std

Defense (২) — explicit reshape:

• x.flatten() বা x.squeeze() দিয়ে unwanted dim সরান।
• x.reshape(-1) বা x.reshape(N, 1) — intent স্পষ্ট।
• Broadcast-এর আগে print(a.shape, b.shape) — debug-এর সর্বোত্তম বন্ধু।

Defense (৩) — unit test for shape:

def test_loss_shape():
    pred = np.random.randn(32, 1)
    label = np.random.randn(32)
    loss = ((pred - label.reshape(-1, 1)) ** 2).mean()
    assert np.isscalar(loss) or loss.ndim == 0

Defense (৪) — type/shape annotation:

• jaxtyping বা torchtyping — function signature-এ shape declare।
• Example: def f(x: Float[Tensor, "batch d"]) -> ...
• Runtime check + IDE hint — production-এ priceless।

Defense (৫) — einsum বা einops:

• einops.rearrange(x, "n d -> n 1 d") — explicit, readable।
• np.einsum("ij,j->i", X, w) — broadcasting confusion-এর জায়গায় নিজে অক্ষর দিয়ে contract।
• আধুনিক DL codebase (PyTorch, JAX) এই দিকে যাচ্ছে।

Detection in training:

• Loss সঠিক shape-এ আসছে কিনা — first iteration-এ assert।
• Gradient-এর shape parameter shape-এর সমান কিনা — checkpoint-এ।
• Loss curve অস্বাভাবিক plateau-এ গেলে — broadcast bug সন্দেহ করুন।

মূল উপলব্ধি: Broadcasting code-কে concise করে — কিন্তু "magic" থেকে cost আছে। Senior ML engineer-রা প্রতি broadcast-এর আগে shape verify করেন। এই discipline পারলে — আপনার ভুল model debugging-এ কয়েক দিন বাঁচবে।

এই তিনটি operation আধুনিক AI-এর backbone। তিনটিই — একই broadcasting pattern, ভিন্ন interpretation।

(১) Outer product:

• দু'টি vector $u \in \mathbb{R}^m, v \in \mathbb{R}^n$ — outer product $u \otimes v \in \mathbb{R}^{m \times n}$।
• $(u \otimes v)_{ij} = u_i \cdot v_j$।
• Broadcasting: u[:, None] * v[None, :] → (m, 1) * (1, n) → (m, n)।
• Use: low-rank matrix approximation, attention weight construction।

(২) Pairwise distance matrix:

• N points in D-dim — distance matrix $D \in \mathbb{R}^{N \times N}$, $D_{ij} = \|x_i - x_j\|$।
• Naive: double loop, O(N²) iteration। Slow।
• Broadcasting:

  diff = X[:, None, :] - X[None, :, :]   # (N, 1, D) - (1, N, D) → (N, N, D)
  dist = np.sqrt((diff ** 2).sum(axis=-1)) # (N, N)

• একটি vectorized expression — C-level speed।
• Use: k-NN, clustering, retrieval, embedding evaluation।

(৩) Attention score:

• Query $Q \in \mathbb{R}^{N \times d}$, Key $K \in \mathbb{R}^{M \times d}$ — score matrix $S \in \mathbb{R}^{N \times M}$।
• $S_{ij} = q_i \cdot k_j / \sqrt{d}$ — সব query-key pair-এর dot product।
• Broadcasting + matmul: S = Q @ K.T / np.sqrt(d)।
• Or explicit broadcasting: (Q[:, None, :] * K[None, :, :]).sum(axis=-1)।
• Softmax row-wise: A = softmax(S, axis=-1) — broadcasting (N, M) - (N, 1) max-trick।
• Output: A @ V — (N, M) @ (M, d) → (N, d)।

সাধারণ pattern:

• Add a "1" dim → broadcast → reduce: এই তিনটিই একই গান।
• $(N, D) \to (N, 1, D)$ এবং $(M, D) \to (1, M, D)$ — combined $(N, M, D)$ — reduce-এ pair-wise quantity।
• matmul = optimized version of "broadcast + multiply + sum"।

Memory consideration:

• $(N, M, D)$ intermediate — N=M=১০০০, D=৭৬৮ হলে ৩ GB! OOM common।
• matmul দিয়ে — intermediate এড়িয়ে directly $(N, M)$ result।
• Flash Attention — block-wise compute, memory-efficient।
• einsum ও einops এই pattern explicit ও optimizable করে।

Self-attention এ দু'টি ব্যবহার:

• Q-K দূরত্ব = "এই word অন্য কোন word-এর সাথে relevant?"
• Outer-style construction — multi-head এ batch-wise।
• $O(N^2)$ memory — Transformer scaling-এর মূল bottleneck।

মূল উপলব্ধি: Modern AI-এর সব "linear algebra heavy lifting" — broadcasting + reduction-এর variation। এই pattern চিনলে — Transformer code পড়া, custom attention লেখা, debugging — সবই সহজ। GPT, BERT, ViT — সব broadcasting-এর উপর দাঁড়িয়ে।