Part I: ML Foundations

Rank is the number of dimensions (the length of the shape tuple), which is 3. The values in the shape tuple are the sizes along each dimension.

NumPy/PyTorch broadcast rules expand size-1 dimensions to match the other operand. Dimension 0 expands to 5, dimension 1 expands to 4, giving (5, 4).

Transpose swaps axes, which swaps the strides. The original (6, 1) becomes (1, 6). No data is copied — only the metadata changes, so the tensor is no longer contiguous.

float64 uses 8 bytes per element vs 4 for float32, doubling memory while extending dynamic range to roughly ±1.8×10^308. The other options either reduce memory or keep it the same.

The weight matrix W has shape (256, 512) giving 131,072 parameters, plus one bias term per output feature (256). Total is 131,072 + 256 = 131,328.

The composition of linear functions is itself linear: W2(W1x) = (W2W1)x. Without nonlinearities, a 100-layer network is mathematically identical to a single linear layer.

ReLU is exactly zero for all negative inputs, which can permanently kill neurons. GELU is smooth near zero and has non-zero gradient for most negative inputs, making optimization more robust.

If weights are too large the signal variance grows exponentially with depth; too small and it shrinks to zero. Xavier init targets a variance that keeps activations roughly unit-variance through the whole forward pass.

Each sample in the batch produces its own set of intermediate activations that must be held in memory until the backward pass uses them to compute gradients. Peak activation memory is therefore O(batch_size × depth).

With forward-mode you need one pass per input dimension. With reverse-mode you need one pass per output dimension. For ML (scalar loss, millions of parameters), one backward pass gives all gradients simultaneously.

detach() cuts a specific tensor out of the computation graph — gradients will not flow through it during backward. no_grad() is a context manager that tells autograd not to record any operations performed inside it.

Checkpointing stores only the inputs to designated segments (not the intermediate activations). During backward, those segments are re-run in forward mode to regenerate the activations needed for gradient computation.

In Adam, L2 regularization interacts with the adaptive learning rates and is effectively scaled down for parameters with large gradients. AdamW bypasses the optimizer state and subtracts a fixed fraction of the weight directly, matching the intended regularization effect.

Adam stores two moving averages per parameter — the first moment (mean gradient) and the second moment (mean squared gradient) — each in fp32 (4 bytes). That's 8 bytes of optimizer state per parameter, on top of the parameter itself.

log(p) for any probability 0 < p ≤ 1 is non-positive. To turn 'maximize log-likelihood' into a standard minimization problem we negate it, giving a loss that is zero when the predicted probability is 1 and grows toward infinity as it approaches 0.

At step 0 Adam's moment estimates are initialized to zero and haven't tracked any gradients yet. Taking a full-size step with uninitialized moments can send parameters to extreme values. Warmup gives the moment estimates time to stabilize before full-scale updates happen.

BPE starts from single bytes or characters and greedily merges the most frequent adjacent pair into a new compound symbol. This is repeated until the target vocabulary size is reached, building up common subwords organically.

'strawberry' is typically split into tokens like 'straw' + 'berry' — the individual character 'r' never appears as a distinct token. Counting characters requires the model to reason about subword internals it was never trained to track.

If both tokenizers share the same vocabulary size the embedding layer won't error. Token IDs for the same text will differ, meaning the model sees different integer sequences than it was trained on — degrading quality silently.

An English-biased BPE tokenizer will have few or no merged tokens for rare morphological forms. Each such word is split into many pieces, making sequences longer. Attention cost scales quadratically with sequence length, so multilingual text is proportionally more expensive.

Random dot products of d_k-dimensional unit-variance vectors have variance d_k. Dividing by √d_k normalizes that to variance 1, keeping logits in a range where softmax gradients don't vanish.

The score matrix has one entry per (query, key) pair — s² entries. Materializing it is the reason FlashAttention exists.

The H heads partition the model dimension so total compute is roughly the same as single-head attention with dimension d_model. Each head sees a d_model/H-sized slice.

The causal mask enforces that position i cannot use information from positions > i — a constraint for autoregressive generation. Encoders (e.g., BERT) are doing representation learning over the full input, so every position can freely attend to every other position.

Post-norm places LayerNorm after the residual addition; at initialization this can produce very large or very small gradient norms deep in the network. Pre-norm normalizes inputs before each sub-layer, keeping gradient scale predictable and making training robust without warmup.

RoPE applies a rotation matrix to Q and K, chosen so that the dot product QK^T depends only on the relative distance between positions. This gives the model a built-in sense of relative position and generalizes better to longer contexts than absolute embeddings.

SwiGLU is a gated linear unit: FFN(x) = (Swish(W1 x) ⊙ W2 x) W3. The Swish-activated branch acts as a soft gate on the other branch, improving expressiveness. To keep FLOPs comparable to the original FFN, the intermediate dimension is typically reduced from 4d to roughly 2.67d.

A decoder-only model pretrained on next-token prediction can be fine-tuned or prompted for any task without architectural changes. Encoder-decoder models require task-specific design choices about what goes in the encoder vs decoder, adding complexity that doesn't pay off at large scale.

During prefill the GPU computes attention over the full prompt in a single forward pass — this is arithmetic-intensive. During decode each step produces only one new token and the bottleneck is reading the KV cache from HBM, making it memory-bandwidth-bound.

Top-k always considers exactly k options regardless of how peaked or flat the distribution is. Top-p is dynamic — when the model is very confident one token dominates and the nucleus is small; when uncertain many tokens share probability mass and the nucleus is larger.

GPU operations like matrix multiplications may execute in different orders depending on hardware state and parallelism, producing slightly different floating-point results. When two tokens have nearly identical logits, these tiny differences can flip which token has the maximum.

Beam search maximizes the probability of the output sequence, which tends to produce bland, repetitive text. For open-ended generation, users strongly prefer diverse samples from well-tuned temperature + nucleus sampling. Memory cost is a secondary concern.

A bi-encoder embeds each piece of text separately, enabling pre-computation and ANN search. A cross-encoder sees the concatenated (query, document) pair, allowing full cross-attention between them — higher quality but impossible to pre-compute, so it's only practical for re-scoring a short candidate list.

For a batch of N (query, positive) pairs, in-batch negatives turns the problem into N-way classification: the model must assign higher similarity to the true positive than to all N-1 other positives in the batch, which act as negatives. This is efficient because no extra negative mining is needed.

After L2 normalization, cosine_similarity(a, b) = dot(a, b), so you can use fast dot-product ANNS indexes (like FAISS inner product). It also ensures similarity reflects direction (semantic meaning) rather than magnitude (length of the text), which is almost always what you want.

ColBERT stores one embedding per document token (not one per document). At query time each query-token embedding picks its maximum similarity across all document-token embeddings; these max-sims are summed. This 'late interaction' gives near-cross-encoder quality at near-bi-encoder speed.

Model authors have every incentive to run evals on their own infrastructure and may not prevent training-set contamination. Independent reproduction on held-out data almost always shows lower numbers. This is the single most important thing to scrutinize.

GGUF Q4_K_M is a 4-bit quantization format used by llama.cpp. At ~4 bits per weight (vs 32 for fp32 or 16 for bf16), the model is 8× smaller than fp32 and 4× smaller than bf16, making it runnable on consumer hardware at the cost of some quality.

Many models advertise large context windows through simple RoPE scaling without training on long sequences. The model may produce syntactically valid output at 128k tokens, but retrieval and reasoning quality often degrades severely beyond the actual training context length.

Fine-tuning does not change the license of the underlying base model. A Llama-2 fine-tune inherits Llama-2's community license terms. Using a 'permissively licensed' fine-tune that sits on a restrictive base in a commercial product is a legal risk that model cards often obscure.