ML & LLM Interview Q&A: 144 Questions

Comprehensive interview questions and answers for ML/LLM coding interviews.

Table of Contents

1. Classical ML
2. LLM Fundamentals
3. LLM Inference
4. Training Techniques
5. Optimization
6. Regularization
7. Bias & Variance
8. Information Theory
9. Discriminative vs Generative Models
10. Kernel Functions
11. NLP Basics
12. MLE and MAP Estimation
13. Multimodal Models and Embeddings
14. RAG (Retrieval-Augmented Generation)
15. Linear and Logistic Regression Derivations
16. RAG Retrieval Methods
17. NLP Problems: Standard Solution Procedures
18. Foundation Models: Evolution from BERT to GPT-4
19. Multimodal Integration and World Models
20. GPT Implementation, Training, and Decoding
21. Prompt Tuning and Prefix Tuning
22. Diffusion Models
23. Perplexity and Related Concepts
24. Causal Attention
25. Advanced Attention Mechanisms (GQA, Paged Attention)
26. Mixture of Experts (MoE)
27. State Space Models (SSM)
28. Classical ML: Trees, Ensembles, and Dimensionality
29. Evaluation and Data Discipline
30. Training Fundamentals
31. Modern LLM Systems

Classical ML

Q1: Implement linear regression from scratch.

In 30 seconds. “Linear regression predicts a weighted sum of the features plus an intercept, and I score it with mean squared error. Fitting is just gradient descent: predict, take the residual, and push the weights in the direction that shrinks it — the weight gradient is X.T @ residual / n and the bias gradient is the mean residual. It’s a convex problem, so with a sane learning rate you land on the global optimum.”

The short version.

• Model: $\hat{y}=Xw+b$. Loss: MSE.
• Weight gradient: dw = X.T @ (y_pred - y) / n. Bias gradient: db = mean(y_pred - y).
• Update: w -= lr * dw, b -= lr * db, repeat.
• Convex bowl → one minimum, no local traps.
• Standardise features first, or the biggest-scale column owns the step size.

class LinearRegression:
    def __init__(self, lr=0.01, n_iter=1000):
        self.lr = lr
        self.n_iter = n_iter
        self.weights = None
        self.bias = None
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        
        for _ in range(self.n_iter):
            y_pred = X.dot(self.weights) + self.bias
            dw = (1/n_samples) * X.T.dot(y_pred - y)
            db = (1/n_samples) * np.sum(y_pred - y)
            self.weights -= self.lr * dw
            self.bias -= self.lr * db
    
    def predict(self, X):
        return X.dot(self.weights) + self.bias

Why it works.

Linear regression assumes the target is a weighted sum of the features plus a constant offset, so the model is $\hat{y}=Xw+b$, where $X$ is the $n\times d$ design matrix ($n$ rows of data, $d$ features per row), $w$ is the length-$d$ vector of weights, and $b$ is a single scalar called the bias or intercept. “Fitting” means choosing $w$ and $b$ so the predictions are as close as possible to the observed targets, where “close” is measured by the mean squared error.

Gradient descent is the method used here. The gradient $\nabla J$ is the vector of partial derivatives; it points in the direction of steepest increase of the loss, so stepping in the negative gradient direction reduces the loss. Doing that repeatedly with a small step size walks downhill to the bottom of the bowl.

Line by line. __init__ stores the two hyperparameters — lr, the step size, and n_iter, how many full passes to take — and leaves the parameters as None because they cannot be sized until we see the data. In fit, X.shape gives us n_samples and n_features, and the weights are initialised to a zero vector of length n_features with the bias at zero; for a convex problem the starting point does not affect the final answer, only how long it takes to get there. Inside the loop, y_pred = X.dot(self.weights) + self.bias is one matrix-vector product that computes all $n$ predictions at once. y_pred - y is the residual vector $e$. X.T.dot(y_pred - y) contracts that residual against every feature column simultaneously, giving all $d$ partial derivatives in one operation, and dividing by n_samples turns the sum into a mean so the learning rate does not have to be retuned when the dataset size changes. np.sum(y_pred - y) / n_samples is the bias gradient. The two subtraction lines take the downhill step. predict simply reapplies the learned affine map. This is full-batch gradient descent: every iteration touches every row, which is exact but slow on large data; swapping in a random subset per step turns it into stochastic (mini-batch) gradient descent.

The math, and what it buys you.

The loss being minimised is the average of the squared gaps:

$$J(w,b)=\frac{1}{n}\sum _{i=1}^n{\left({\hat{y}}_i-y_i\right)}^2$$

The squares matter for two reasons: they make every error positive so overshoots and undershoots do not cancel, and they make $J$ a smooth convex bowl in $(w,b)$, which means there is exactly one minimum and gradient descent cannot get stuck anywhere else.

Where the gradients come from. Write the residual for row $i$ as $e_i={\hat{y}}_i-y_i$. Differentiating the MSE with respect to weight $j$ and applying the chain rule (the outer derivative of $e_i^2$ is $2e_i$, the inner derivative of ${\hat{y}}_i={\sum }_j{x}_{ij}{w}_j+b$ with respect to $w_j$ is $x_{ij}$):

$$\frac{\partial J}{\partial w_j}=\frac{2}{n}\sum _{i=1}^n{e}_i{x}_{ij},\frac{\partial J}{\partial b}=\frac{2}{n}\sum _{i=1}^n{e}_i$$

Stacked over all $j$, the first expression is exactly $\frac{2}{n}{X}^{\top }e$ — which is the one line of code in fit. The code drops the factor of 2 because it is a constant that just rescales the learning rate — a common and harmless simplification. Notice what the weight gradient says intuitively: a feature gets a large gradient when it is large and correlated with the direction we are currently getting wrong. The bias gradient is just the average residual, which nudges the whole prediction line up or down.

Good and bad.

• Good: convex, so a global optimum is guaranteed; $O(nd)$ per step, so it streams over data too big for memory; the same recipe extends unchanged to models with no closed form.
• Bad: needs feature standardisation — because the same lr is used for every weight, features on wildly different scales converge at wildly different rates and the loss surface becomes a long narrow valley that gradient descent zigzags down.
• Bad: learning-rate sensitive. Too large and the updates overshoot the minimum and the loss diverges to nan; too small and it crawls.

Follow-up: Why iterate at all when linear regression has a closed-form solution? The normal equation $w=(X^{\top }X{)}^{-1}{X}^{\top }y$ gives the exact optimum in one shot, and for a few thousand features it is the better choice. But it costs roughly $O(d^3)$ to invert (or factorise) a $d\times d$ matrix and requires $X^{\top }X$ to be invertible, which fails under exact multicollinearity. Gradient descent costs $O(nd)$ per step, streams over data that does not fit in memory, extends unchanged to models with no closed form, and degrades gracefully when features are collinear.

Why the interviewer asks this. It is the cheapest possible check that you can go from a loss function to its gradient to working vectorised code without reaching for a library.

Saying it out loud. “The model’s just a weighted sum of the features plus an intercept, and I’m scoring it with mean squared error. I initialise the weights at zero, and then each iteration I predict, take the residual — prediction minus truth — and push the weights in the direction that shrinks it. The weight gradient is X transpose times the residual over n, and the bias gradient is just the mean residual. It’s a convex problem, so as long as my learning rate is sane I’ll land at the global optimum. In practice I’d standardise the features first, otherwise one big-scale column dominates the step size.”

Q2: What’s the difference between linear and logistic regression?

In 30 seconds. “They share the same linear core — weights dot features plus a bias. Linear regression uses that number directly as the prediction; logistic regression squashes it through a sigmoid so it comes out as a probability, which means the linear part is really modelling log-odds. And because the output changed, the loss has to change too: MSE on top of a sigmoid loses convexity and kills the gradient exactly when the model is most wrong.”

The short version.

Key Difference:

• Linear: y = w*x + b
• Logistic: p = sigmoid(w*x + b), then classify p > 0.5

Why it works.

The two models share a linear core, $z=w^{\top }x+b$. Linear regression stops there and treats $z$ as the prediction. Logistic regression pushes $z$ through the sigmoid (also called the logistic function),

$$\sigma (z)=\frac{1}{1+e^{-z}}$$

which is a smooth S-shaped squash from the whole real line into the open interval $(0,1)$, so the output can be read as a probability. Inverting it shows what the linear part really means: $z=\log \frac{p}{1-p}$, the log-odds (the log of the ratio of the probability of the event to the probability of its complement). So logistic regression is a linear model in log-odds space, not in probability space. A one-unit increase in a feature adds a fixed amount to the log-odds, which multiplies the odds by a constant factor $e^{w_j}$ — that is the standard way to interpret a logistic coefficient.

The math, and what it buys you.

Why log loss and not MSE — the part follow-ups probe. There are two independent reasons.

The first is optimisation geometry. With MSE the logistic objective ${\sum }_i(\sigma (z_i)-y_i{)}^2$ is not convex in $w$, because the sigmoid’s own curvature flips sign at $z=0$; the composition can have multiple local minima and flat plateaus, so gradient descent’s answer depends on where it started. Log loss, $-{\sum }_i[y_i\log p_i+(1-y_i)\log (1-p_i)]$, is convex in $w$, so there is a single optimum.

The second is gradient behaviour, and it is easy to see numerically. Differentiating MSE through the sigmoid gives a factor of ${\sigma }^{\prime }(z)=p(1-p)$ in the gradient. Suppose the true label is $y=1$ but the model is confidently wrong with $p=0.001$ (so $z\approx -6.9$). Then ${\sigma }^{\prime }=0.001\times 0.999\approx 0.000999$, and the MSE gradient with respect to $z$ is $2(p-y)p(1-p)=2(-0.999)(0.000999)\approx -0.002$ — nearly zero. The model is as wrong as it can be and the update is vanishingly small; it is stuck. Under log loss the $p(1-p)$ term cancels exactly against the derivative of the log, leaving the strikingly simple

$$\frac{\partial \mathcal{L}}{\partial z}=p-y$$

which for the same case is $0.001-1=-0.999$: a full-strength correction. The size of the update is proportional to how wrong the probability is, which is exactly what you want. (The same cancellation is why softmax-with-cross-entropy is implemented as a single fused op in every framework.)

Good and bad.

• Linear regression — good: directly interpretable coefficients in the target’s own units; closed-form solution available. Bad: unbounded output, so it is meaningless as a probability, and MSE punishes it hard on classification labels.
• Logistic regression — good: calibrated probabilities, convex loss, clean $p-y$ gradient, coefficients readable as odds ratios. Bad: still a linear boundary in feature space; needs feature engineering or kernels for anything curved.

Follow-up: Can you use logistic regression on more than two classes? Yes — replace the sigmoid with the softmax, $p_k=e^{z_k}/{\sum }_j{e}^{z_j}$, one linear score per class, and the loss becomes multiclass cross-entropy. The gradient keeps the same $p-y$ form with $y$ as a one-hot vector. This is multinomial logistic regression, also known as softmax regression, and it is precisely the output layer of almost every classification neural network.

Why the interviewer asks this. The surface answer is memorised by everyone; the real question underneath is whether you know why the loss function changes, not just that it does.

Saying it out loud. “They share the same linear core — weights dot features plus a bias. Linear regression uses that number directly as the prediction; logistic regression squashes it through a sigmoid so it comes out as a probability, which means the linear part is really modelling log-odds. And you have to switch the loss too. If you put MSE on top of a sigmoid you lose convexity, and worse, when the model’s confidently wrong the sigmoid derivative kills the gradient so it can’t recover. With log loss all that cancels and the gradient is just predicted minus actual — big error, big update.”

Q3: Explain KNN algorithm.

In 30 seconds. “KNN doesn’t really train — it memorises the data. At prediction time you measure the distance from the new point to everything you stored, take the k closest, and let them vote, or average them for regression. Small k chases noise, big k smooths toward the majority class — that’s the bias-variance dial. Two gotchas: scale your features, and don’t expect it to work in high dimensions.”

The short version.

• Lazy, non-parametric. Training: O(1), just store. Prediction: O(n) per query, compare to all points.
• Predict: find the k nearest neighbours → majority vote (classification) or mean (regression).
• Distance: usually Euclidean $\sqrt{\sum (x_i-y_i{)}^2}$; Manhattan or cosine also used.
• Small k = sensitive to noise (high variance). Large k = smoother boundary (high bias). Rule of thumb: $k=\sqrt{n}$; prefer odd $k$ for binary problems so votes cannot tie.
• Must standardise features, and it degrades badly as dimension grows.

Why it works.

K-Nearest Neighbors makes one assumption and nothing else: points that are close together in feature space tend to have similar labels. So there is no model to fit — no weights, no loss function, no gradient. “Training” is memorising the dataset, which is why it is called a lazy learner (all the work is deferred to prediction time) and a non-parametric method (the number of things it remembers grows with the data rather than being fixed in advance).

To predict for a new point $x$, compute the distance from $x$ to every stored training point, sort, take the $k$ closest, and let them vote. For classification the prediction is the most common label among those $k$; for regression it is their mean.

import numpy as np
from collections import Counter

class KNN:
    def __init__(self, k=3):
        self.k = k

    def fit(self, X, y):
        # "Training" is just storage - nothing is learned.
        self.X_train = np.asarray(X, dtype=float)
        self.y_train = np.asarray(y)
        return self

    def predict(self, X):
        X = np.asarray(X, dtype=float)
        # Squared Euclidean distance from every test point to every train point.
        # Shape: (n_test, 1, n_features) - (1, n_train, n_features) -> (n_test, n_train)
        d2 = ((X[:, None, :] - self.X_train[None, :, :]) ** 2).sum(axis=2)
        # argpartition puts the k smallest in front in O(n) instead of O(n log n).
        idx = np.argpartition(d2, kth=self.k - 1, axis=1)[:, :self.k]
        neigh = self.y_train[idx]
        return np.array([Counter(row).most_common(1)[0][0] for row in neigh])

Reading it in order: fit casts and stores, and that is genuinely all it does. In predict, the broadcasting trick X[:, None, :] - self.X_train[None, :, :] creates an array of every coordinate-wise difference between every test point and every training point, squaring and summing along the feature axis gives the squared distance matrix. We use squared distance rather than taking the square root because the square root is monotonic — it does not change which neighbours are closest — and skipping it saves time. np.argpartition is used instead of argsort because we only need to know which $k$ are smallest, not their internal order, and partitioning is linear rather than $n\log n$. Indexing y_train by those positions gives the neighbours’ labels, and Counter(...).most_common(1) performs the majority vote. For regression the last line becomes neigh.mean(axis=1).

Why $k$ controls the bias-variance tradeoff. With $k=1$ every training point is classified perfectly by itself, and the decision boundary wraps tightly around individual points — including mislabelled ones. That is high variance: reshuffle the training set and the boundary moves a lot. As $k$ grows, each prediction averages more neighbours, noise cancels, and the boundary smooths; push $k$ to $n$ and the model always predicts the global majority class, which is maximum bias. Choose $k$ by cross-validation.

Good and bad.

• Good: zero training cost, no assumptions about the decision boundary’s shape, naturally multiclass, and trivially updated by appending new data.
• Bad — scaling: Euclidean distance sums squared differences across features, so a feature measured in the thousands (say, income) drowns out one measured in single digits (say, number of bedrooms). Standardise before using KNN, always.
• Bad — curse of dimensionality: as dimension $d$ grows, the ratio between the distance to the nearest and the farthest point converges to 1, so “nearest” stops carrying information. KNN is strong in low dimensions and weak in high ones unless you reduce dimensionality first.
• Bad — inference cost: every query touches the whole training set, and the whole training set must stay in memory.

Follow-up: How do you make prediction faster than $O(nd)$ per query? Build a spatial index — a KD-tree or ball tree — which prunes whole regions and gives roughly $O(\log n)$ queries in low dimensions, though both degrade to brute force past about 20 dimensions. Beyond that, use approximate nearest neighbour methods (HNSW graphs, IVF or product quantisation as in FAISS), which trade an exact guarantee for orders-of-magnitude speedups; this is the same machinery behind modern vector databases for embedding retrieval.

Why the interviewer asks this. It is a quick probe of whether you understand that some models pay their cost at training time and others at inference time, and whether you remember that distance-based methods need feature scaling.

Saying it out loud. “KNN doesn’t really train — it just stores the data. At prediction time you measure the distance from the new point to everything you stored, grab the k closest, and take a majority vote, or an average if it’s regression. Small k gives you a jagged boundary that chases noise; big k smooths everything out until you’re basically predicting the majority class. Two gotchas I’d always mention: you have to scale your features, because otherwise whichever column has the biggest units owns the distance, and it falls apart in high dimensions because everything ends up roughly equidistant.”

Q4: How does K-means clustering work?

In 30 seconds. “K-means minimises the total squared distance from each point to its cluster’s centre. It alternates two steps — assign every point to the nearest centre, then move each centre to the mean of the points that chose it. Each step is the exact best move given the other, so the objective only goes down and it always converges — but only to a local optimum, which is why you use k-means++ seeding and multiple restarts.”

The short version.

• Algorithm: initialise $k$ centroids → assign each point to nearest centroid → move each centroid to the mean of its members → repeat.
• Converges when centroids stop moving, or max iterations is hit.
• Objective: within-cluster sum of squares (inertia). Both steps are exact minimisers, so inertia is monotonically non-increasing.
• Initialisation matters: random seeding can give poor results; k-means++ spreads the initial centres out.
• Limitations: assumes spherical, similarly-sized clusters; you must specify $k$; sensitive to initialisation and outliers.

Why it works.

K-means partitions $n$ points into $k$ groups by minimising the within-cluster sum of squares, also called inertia. Minimising this jointly over both the assignments and the centroids is NP-hard, so the standard algorithm — Lloyd’s algorithm — alternates between optimising one while holding the other fixed. That is the whole trick, and it is why each of the two steps in the loop is not arbitrary but is the exact minimiser given the other.

Holding centroids fixed, the assignment that minimises the objective is obviously “put each point with its nearest centroid” — each point’s contribution is minimised independently. Holding assignments fixed, the point $\mu$ minimising ${\sum }_{x\in C_j}\Vert x-\mu {\Vert }^2$ is the arithmetic mean of $C_j$ (set the derivative to zero and solve). Since each step can only decrease the objective and there are finitely many possible assignments, it is monotonically non-increasing and the algorithm must terminate — but only at a local minimum, which is exactly why initialisation matters.

The math, and what it buys you.

The objective is a single line, and everything about the algorithm’s behaviour follows from it:

$$J=\sum _{j=1}^k\sum _{x\in C_j}\Vert x-{\mu }_j{\Vert }^2$$

where $C_j$ is the set of points assigned to cluster $j$ and ${\mu }_j$ is that cluster’s centroid (its mean vector). Because $J$ uses squared Euclidean distance and summarises each cluster by a single mean, the algorithm is implicitly committed to round, equally-sized, outlier-free clusters — the limitations are not bugs, they are what this formula asks for.

import numpy as np

def kmeans(X, k, n_iter=100, tol=1e-6, seed=0):
    rng = np.random.default_rng(seed)
    X = np.asarray(X, dtype=float)
    n = X.shape[0]

    # --- k-means++ seeding: spread the initial centroids out ---
    centers = [X[rng.integers(n)]]
    for _ in range(k - 1):
        d2 = np.min(((X[:, None, :] - np.array(centers)[None, :, :]) ** 2).sum(2), axis=1)
        probs = d2 / d2.sum()                      # far-from-everything points are likelier
        centers.append(X[rng.choice(n, p=probs)])
    centers = np.array(centers)

    for _ in range(n_iter):
        # Assignment step: nearest centroid for every point
        d2 = ((X[:, None, :] - centers[None, :, :]) ** 2).sum(axis=2)
        labels = d2.argmin(axis=1)
        # Update step: centroid = mean of its members (keep old center if empty)
        new_centers = np.array([X[labels == j].mean(axis=0) if np.any(labels == j)
                                else centers[j] for j in range(k)])
        if np.linalg.norm(new_centers - centers) < tol:
            centers = new_centers
            break
        centers = new_centers

    inertia = ((X - centers[labels]) ** 2).sum()
    return centers, labels, inertia

Step by step: the seeding block implements k-means++, which picks the first centre uniformly at random and then picks each subsequent centre with probability proportional to its squared distance from the nearest already-chosen centre. That biases the initial centres to be far apart, which avoids the classic failure where two centres land inside the same true cluster and split it while merging two others; it also comes with a proof that the expected inertia is within $O(\log k)$ of optimal. Inside the main loop, the distance matrix is built by the same broadcasting pattern as KNN, argmin along the centroid axis performs the assignment, and the list comprehension recomputes each centroid as the mean of its members — with a guard, because a cluster can end up empty and mean of an empty slice is nan. The convergence check compares how far the centres moved; when that is below tolerance nothing more will change. inertia is the objective value, useful for comparing runs.

Choosing $k$. Inertia decreases monotonically with $k$ (at $k=n$ it is zero), so you cannot just minimise it. The elbow method plots inertia against $k$ and looks for the bend where extra clusters stop buying much; the silhouette score, which compares each point’s mean distance to its own cluster against its mean distance to the nearest other cluster, gives a value in $[-1,1]$ that can be maximised directly and is usually the more defensible choice.

Good and bad.

• Good: $O(nkd)$ per iteration — linear in the number of points, so it scales to large data where hierarchical clustering ($O(n^2)$ memory at least) does not. Simple, and guaranteed to converge.
• Bad — shape assumption: it will happily slice a long thin cluster in half or merge two crescents. DBSCAN or a Gaussian mixture handles elongated or nested shapes.
• Bad — outliers: squared distance means one far-away point drags a centroid toward it. K-medoids, which uses actual data points as centres, is the robust alternative.
• Bad — local optima: standard practice is n_init restarts keeping the lowest-inertia run; scikit-learn does this by default.

Follow-up: What is the time complexity? Each iteration is $O(nkd)$ — every point against every centroid in $d$ dimensions — for $t$ iterations and $r$ restarts, so $O(tnkd\cdot r)$ overall. It is linear in the number of points, which is why K-means scales to large data where hierarchical clustering ($O(n^2)$ memory at least) does not.

Why the interviewer asks this. They want to hear that the two steps are coordinate descent on a specific objective, not a heuristic someone made up — and that you know why it only ever finds a local optimum.

Saying it out loud. “K-means is trying to minimise the total squared distance from each point to its cluster’s centre. It alternates two steps: assign every point to the nearest centre, then move each centre to the mean of the points that picked it. Each step is the exact best move given the other one, so the objective only goes down and it has to converge — but only to a local optimum, which is why you use k-means++ seeding and multiple restarts. It assumes round, similarly-sized clusters, so if the real shapes are elongated or nested, DBSCAN or a Gaussian mixture is a better fit.”

LLM Fundamentals

Q5: Explain the transformer architecture.

In 30 seconds. “Every token carries a vector up through the stack, and each layer reads that vector, computes something, and adds its result back — that’s the residual stream. Inside a block there are exactly two jobs: attention moves information between positions, and the feed-forward net adds nonlinear capacity within a position. LayerNorm keeps the scale under control, positional information has to be injected because attention itself is order-blind, and modern LLMs are decoder-only with a causal mask, pre-norm, and rotary positions.”

The short version.

Components:

1. Embedding Layer: Token → Dense vectors
2. Position Encoding: Add position info
3. Transformer Blocks (N layers):
   • Multi-Head Self-Attention
   • Feed-Forward Network
   • Layer Normalization
   • Residual Connections
4. Output Layer: Project to vocabulary

Key Innovation:

• Self-attention: Relate all positions
• Parallel processing: All positions at once
• Long-range dependencies: No RNN limitations

The three configurations, side by side.

Why it works.

The clearest mental model of a transformer is the residual stream. Every token carries a vector of width $d_{\text{model}}$ from the bottom of the network to the top, and each sublayer reads from that vector, computes something, and adds the result back. That is what the residual connection means: the block computes $x\leftarrow x+\text{Sublayer}(\text{LayerNorm}(x))$, not $x\leftarrow \text{Sublayer}(x)$. Because the update is additive, gradients flow to the bottom layer along an unobstructed path (the derivative of $x+f(x)$ has an identity term in it), which is what makes stacking 100 blocks trainable at all.

Within a block the two sublayers have complementary jobs. Attention moves information between token positions — it is the only operation in the whole architecture that lets position $i$ see position $j$. The feed-forward network (FFN) processes each position independently, applying the same two-layer MLP to every token separately: it projects up to an inner width (classically $4\times d_{\text{model}}$), applies a nonlinearity such as GELU or SwiGLU, and projects back down. Attention mixes across tokens; the FFN adds nonlinear capacity within a token. Note that the FFN holds roughly two-thirds of the parameters in a standard block ($8d^2$ versus attention’s $4d^2$), which is why it is the usual target for mixture-of-experts sparsification.

Layer normalisation rescales each token’s vector to zero mean and unit variance across its features (then applies a learned gain and bias), which keeps activation magnitudes stable as depth grows. The original 2017 paper put it after the residual addition (post-LN); essentially every modern LLM puts it before the sublayer (pre-LN), because post-LN needs a learning-rate warmup to train deep stacks without diverging while pre-LN is stable out of the box. Many current models further simplify to RMSNorm, which divides by the root-mean-square and skips the mean subtraction and the bias.

Position encoding is needed because attention is permutation-equivariant: with no positional signal, “dog bites man” and “man bites dog” produce identical sets of representations. The original design added fixed sinusoids of geometrically spaced frequencies to the embeddings; current models overwhelmingly use RoPE (rotary position embedding), which rotates the query and key vectors by an angle proportional to position so that the attention score depends only on the relative offset between two tokens — that relative property is what makes context-length extension via frequency scaling possible.

Three configurations, in prose. The original paper is an encoder-decoder, built for translation: a bidirectional encoder reads the source, and a decoder generates the target while cross-attending to the encoder’s output. Encoder-only models (BERT) keep bidirectional attention and are trained by masked-token prediction; they are for understanding tasks like classification and retrieval, and cannot generate autoregressively. Decoder-only models (GPT, Llama, Claude) use causal masking — position $i$ may attend only to positions $\le i$ — and are trained to predict the next token; this is the dominant design for LLMs today because a single next-token objective scales cleanly and covers generation, classification, and everything else via prompting.

Good and bad.

• Good: all positions are processed in parallel during training (no RNN recurrence), long-range dependencies are one hop away rather than $n$ hops, and the additive residual stream makes very deep stacks trainable.
• Bad: attention is $O(n^2)$ in sequence length; there is no built-in notion of order, so positions must be injected; and the parameter count is dominated by the FFN, which is mostly idle capacity for any given token.

Follow-up: Where does the quadratic cost come from, and what is done about it? The attention score matrix is $n\times n$ for sequence length $n$, so compute is $O(n^{2}d)$ and, naively, memory is $O(n^2)$ too. FlashAttention removes the memory term by tiling the computation and never materialising the full matrix — it is exact, just IO-aware. The compute term is attacked by sparse or sliding-window attention (attend only to a local neighbourhood plus a few global tokens) and by linear-attention or state-space alternatives such as Mamba, which trade some expressivity for $O(n)$ scaling.

Why the interviewer asks this. It is an open door: they want to see which level of detail you naturally reach for, and whether you can say what each component is for rather than just listing the diagram top to bottom.

Saying it out loud. “The way I picture it, every token carries a vector up through the stack, and each layer reads that vector, computes something, and adds its result back — that’s the residual stream. Inside a block there are two jobs. Attention is the only thing that moves information between positions. The feed-forward net works on each token on its own and gives you the nonlinear capacity — it’s also where most of the parameters live. LayerNorm keeps the scale under control, and you need positional information injected somewhere because attention on its own has no idea what order the tokens came in. Modern LLMs are decoder-only with a causal mask, pre-norm, and rotary positions.”

Q6: How does self-attention work?

In 30 seconds. “Each token projects into a query, a key, and a value. The query dotted with every key scores relevance, you divide by root d-k so the softmax doesn’t saturate, softmax turns the scores into weights that sum to one, and the output is a weighted average of the values. The clean way to say it: query-key decides where you look, value-output decides what gets copied — it’s a soft, content-addressable lookup.”

The short version.

Formula:

Attention(Q, K, V) = softmax(QK^T / √d_k) × V

Steps:

1. Compute Q, K, V from input
2. Compute attention scores: Q @ K^T
3. Scale by √d_k (prevent large values)
4. Softmax to get attention weights
5. Apply weights to V

Why it works.

Start from the projections. Each token’s residual-stream vector $x_i\in {\mathbb{R}}^{d_{\text{model}}}$ is multiplied by three learned matrices to give a query $q_i=W_Q{x}_i$, a key $k_i=W_K{x}_i$, and a value $v_i=W_V{x}_i$. The useful way to read this is that attention factors into two independent circuits:

• The QK circuit decides where to look. The score between positions $i$ and $j$ is $q_i\cdot k_j=x_i^{\top }{W}_Q^{\top }{W}_K{x}_j$, so only the product $W_Q^{\top }{W}_K$ matters — a single bilinear form saying “how much does a token like me want to read from a token like that?” This circuit produces the attention pattern and nothing else; it never touches the content that gets copied.
• The OV circuit decides what to move. Once the weights are fixed, the output is ${\sum }_j{\alpha }_{ij}{W}_O{W}_V{x}_j$, so only the product $W_O{W}_V$ matters — a linear map saying “if I read from a token, what do I write into my residual stream?”

Splitting it this way explains attention’s real function: it is a soft, content-addressable lookup. The QK circuit computes addresses, the softmax turns them into a normalised mixing weight, and the OV circuit is the payload. A concrete example is the induction head found in real models: the QK circuit matches the current token against earlier occurrences of the same token, and the OV circuit copies whatever followed it last time, which is how models do in-context pattern completion.

Causal masking. In a decoder, position $i$ must not see the future, or the model could cheat at next-token prediction. This is implemented by adding $-\infty$ (in practice a large negative number like $-10^9$) to all scores where $j>i$ before the softmax, so those weights come out as exactly zero after exponentiation. Doing it pre-softmax rather than zeroing afterwards matters, because it keeps the remaining weights correctly normalised to sum to one.

The math, and what it buys you.

Why divide by $\sqrt{d_k}$ — with numbers. The scaling factor is not decoration; it is what keeps the softmax’s gradient alive. Suppose the entries of $q$ and $k$ are roughly independent with mean 0 and variance 1. Their dot product is a sum of $d_k$ such products, so it has variance $d_k$ and typical magnitude $\sqrt{d_k}$. With $d_k=64$ that is around $\pm 8$; with $d_k=128$, around $\pm 11$. Feed scores that large into a softmax and it saturates — one weight goes to essentially 1 and the rest to essentially 0. Concretely, softmax over $[8,0]$ gives $[0.99966,0.00034]$, and the gradient of the softmax is proportional to $p(1-p)$, so at $p=0.99966$ the gradient is about $3.4\times 10^{-4}$: the attention pattern freezes and stops learning. Dividing by $\sqrt{d_k}$ renormalises the scores to unit variance regardless of head width, so the softmax stays in its responsive range. Softmax over $[1,0]$ gives $[0.73,0.27]$ with a healthy gradient.

A small worked example. Take $d_k=2$ and three tokens with $q_2=[1,0]$ and keys $k_1=[1,0]$, $k_2=[0,1]$, $k_3=[1,1]$. The raw scores for query 2 are $q_2\cdot k_j=[1,0,1]$. Scaling by $\sqrt{2}\approx 1.414$ gives $[0.707,0,0.707]$. Exponentiating gives $[2.028,1.0,2.028]$, which sums to $5.056$, so the attention weights are $[0.401,0.198,0.401]$. The output for position 2 is $0.401v_1+0.198v_2+0.401v_3$ — a convex combination of the value vectors, weighted by query-key similarity. Every row of the attention matrix is a probability distribution over positions in exactly this way.

Follow-up: Why do we need three separate projections — why not just use $x$ itself? Because $x\cdot x$ is maximised by $x$ itself, so unprojected attention would collapse to every token attending mostly to itself, and the score would be forced to be symmetric — position $i$ would attend to $j$ exactly as much as $j$ attends to $i$. Separate $W_Q$ and $W_K$ break that symmetry and let “what I’m looking for” differ from “what I advertise”. A separate $W_V$ then decouples relevance from content, so a token can be highly relevant as an address while contributing something entirely different as a payload.

Why the interviewer asks this. They want to know whether “query, key, value” is a phrase you repeat or a structure you can decompose — the split between where attention looks and what it copies is the tell.

Saying it out loud. “Each token projects into three vectors — a query, a key, and a value. The query is what this token is looking for, the key is what each other token advertises, and the dot product between them scores relevance. You divide by root d-k because otherwise the dot products grow with the head dimension, the softmax saturates, and the gradient dies. Then softmax turns those scores into weights that sum to one, and the output is a weighted average of the value vectors. So really there are two separate circuits: query-key decides where you look, and value-output decides what gets copied back into your representation. In a decoder you mask out the future before the softmax so a token can’t see what comes after it.”

Q7: What is multi-head attention?

In 30 seconds. “Multi-head attention splits the model dimension across heads rather than duplicating it — 512 dimensions and 8 heads means each head works in 64, so the parameter count is identical to one wide head. What you buy is several attention distributions running in parallel instead of one. A single softmax has to spend all its probability mass in one place; eight heads can do eight different lookups at once.”

The short version.

• Concept: instead of one attention, use multiple heads; each learns different relationships; concatenate, then project.
• Implementation: split $d_{\text{model}}$ into num_heads × $d_k$ → each head gets its own Q, K, V slice → attention per head → concatenate → final projection $W_O$.
• Parameters are partitioned, not multiplied: total is $4d_{\text{model}}^2$, the same as a single full-width head.
• Why it helps: different heads attend to different aspects — one for syntax, one for semantics — which one distribution cannot do.
• The modern wrinkle: KV cache scales with head count at inference, hence MQA and GQA.

Why it works.

A single head produces one attention distribution per query position — it must commit to one weighted average. That is a hard constraint: a pronoun resolving its antecedent and a verb finding its subject are different lookups that a single softmax cannot perform at once, because probability mass spent on one is taken from the other. Eight heads give eight independent distributions whose results are summed into the residual stream, so the block can perform several distinct retrievals in parallel. The cost is that each head sees a lower-rank slice of the space, which is a real limitation — this is why very small $d_k$ (below about 32) tends to hurt, and why head count and head dimension are tuned together rather than head count alone being maximised.

The math, and what it buys you.

The dimension arithmetic is the thing to be able to recite, because it shows the heads are free. With $d_{\text{model}}=512$ and $h=8$ heads, each head gets $d_k=d_{\text{model}}/h=64$. In practice you keep one big $512\times 512$ matrix for $W_Q$ (and likewise $W_K$, $W_V$), project once, then reshape the result from $(\text{batch},n,512)$ to $(\text{batch},n,8,64)$ and transpose to $(\text{batch},8,n,64)$ so the eight heads become a batch dimension. Every head runs the scaled-dot-product attention of Q6 independently on its own 64-dimensional slice, producing $(\text{batch},8,n,64)$. Transposing back and reshaping concatenates the heads into $(\text{batch},n,512)$, and the output projection $W_O$ (also $512\times 512$) mixes them before the result is added to the residual stream. Total parameters: $4d_{\text{model}}^2$, identical to one head of full width — so multi-head attention buys parallel lookups at zero parameter cost.

Good and bad.

• Good: several independent retrievals per layer for the same parameter budget; heads specialise (positional heads, induction heads, syntax heads) and are individually interpretable.
• Bad: each head operates in a lower-rank subspace, so pushing $d_k$ below roughly 32 degrades quality; and head count directly inflates the inference KV cache, which is why MQA and GQA exist.

Follow-up: What are MQA and GQA, and why do they exist? The KV cache at inference stores one key and one value vector per head per token, so its size scales with head count — and at generation time the arithmetic is memory-bandwidth-bound, meaning the GPU spends most of its time reading that cache rather than doing math. Multi-query attention (MQA) keeps $h$ separate query heads but shares a single key/value head across all of them, shrinking the cache by a factor of $h$; it is fast but measurably degrades quality. Grouped-query attention (GQA) is the compromise now used by most open models: heads are split into $g$ groups (say 8 groups over 64 query heads) with one KV head per group, recovering most of the quality at most of the speed. Nothing about the query side changes; only the number of distinct K and V projections does.

Why the interviewer asks this. The giveaway answer is “heads learn different things”, which is true but unfalsifiable; they are checking whether you know the dimensions split rather than multiply, and ideally that you know why inference pushed the field toward GQA.

Saying it out loud. “Multi-head attention splits the model dimension across heads rather than duplicating it — 512 dimensions and 8 heads means each head works in 64. So the parameter count is the same as one wide head, but instead of one attention distribution you get eight running in parallel, and you concatenate them and pass them through an output projection. The reason that matters is that a single softmax has to spend its probability mass in one place; with several heads the layer can do several different lookups at once. The modern wrinkle is that KV cache size scales with head count at inference, so people share key and value heads across groups of query heads — that’s grouped-query attention.”

LLM Inference

Q8: How does KV caching work?

In 30 seconds. “Because of the causal mask, once you’ve computed a token’s key and value they never change — nothing later can affect them. So instead of recomputing the whole sequence every step, you keep K and V and compute only the query for the new token. It turns generation from cubic in sequence length to quadratic, exactly, with no quality trade. The catch is memory: roughly half a megabyte per token on a 7B model.”

The short version.

• Problem: autoregressive generation recomputes attention over all previous tokens at every step.
• Solution: cache K and V for previous tokens; for the new token compute only Q, reuse cached K/V, append the new K/V.
• Why only K and V: old queries are never used again; the one new query must be scored against every previous key and value.
• Exact, not approximate. Same outputs, up to float reduction order.
• Speedup: 10-100x for generation. Cost: linear-in-context GPU memory.

Step 1: Token 1 → Compute Q1, K1, V1, cache K1, V1
Step 2: Token 2 → Compute Q2, K2, V2
        → Attention: Q2 @ [K1, K2]^T, use [V1, V2]
        → Cache: [K1, K2], [V1, V2]
Step 3: Token 3 → Compute Q3, K3, V3
        → Attention: Q3 @ [K1, K2, K3]^T, use [V1, V2, V3]
        → Cache: [K1, K2, K3], [V1, V2, V3]

Why it works.

The reason caching is even possible is causal masking. In a decoder, position $j$ attends only to positions $\le j$, so once token $j$’s key and value vectors are computed they are final — no later token can change them, because nothing later flows into them. That is a property of the mask, not an approximation; KV caching is mathematically exact, producing bit-comparable outputs (up to floating-point reduction order), not a speed-for-quality trade.

Why keys and values but not queries: at each generation step you have exactly one new token, so you need exactly one new query — the queries of earlier tokens are never used again, because their outputs were already computed and consumed. But that single new query must be scored against every previous key and must read from every previous value. So K and V accumulate; Q does not.

The math, and what it buys you.

What this does to the cost. Without a cache, generating token $t$ means a full forward pass over $t$ tokens, which is $O(t^{2}d)$ of attention work, and generating a whole sequence of length $n$ costs $O(n^{3}d)$. With the cache, each step is one query against $t$ keys, so $O(td)$ per step and $O(n^{2}d)$ overall — a factor of $n$ saved. This is also why LLM inference has two distinct phases with very different characteristics: prefill, where the whole prompt is processed in one parallel pass and the GPU is compute-bound, and decode, where one token is produced at a time and the GPU is memory-bandwidth-bound because it must stream the entire cache and all model weights per token.

The cost is memory, and this formula is the one to know — it tells you how many concurrent requests a GPU can hold:

$$\text{cache bytes}=2\times n_{\text{layers}}\times n_{\text{kv heads}}\times d_{\text{head}}\times \text{seq len}\times \text{batch}\times \text{bytes per element}$$

The leading 2 is for K and V. Take a 7B-class model with 32 layers, 32 KV heads, head dimension 128, in FP16 (2 bytes): that is $2\times 32\times 32\times 128\times 2=524,288$ bytes per token, or about 0.5 MB. At 4,096 tokens of context that is roughly 2 GB for a single sequence — and it scales linearly with batch size, so 16 concurrent requests at that length is about 32 GB, comfortably more than the model weights themselves. This is the single biggest constraint on serving throughput, and it is what motivates GQA (fewer KV heads), KV-cache quantisation to INT8 or FP8, and PagedAttention in vLLM, which stores the cache in fixed-size non-contiguous blocks like OS virtual memory so that fragmentation and over-reservation stop wasting the majority of GPU memory.

Good and bad.

• Good: exact, no quality cost; removes a whole factor of $n$ from generation; enables prefix caching across requests that share a system prompt.
• Bad: memory grows linearly with context and batch, and quickly exceeds the weights themselves; fragmentation wastes more of it unless you use a paged allocator; and any change at the front of a prompt invalidates everything after it.

Follow-up: What breaks if the prompt changes at the front? Everything downstream of the change, because each cached key depends on all preceding tokens through the attention of earlier layers. This is why prefix caching works — a shared system prompt at the start can be computed once and reused across requests — but appending to the beginning of a prompt invalidates the whole cache. It is a concrete reason to put stable content first and variable content last in prompt templates.

Why the interviewer asks this. It separates people who have read about transformers from people who have served them; the memory formula and the prefill/decode distinction are what a serving engineer actually reasons about.

Saying it out loud. “Because of the causal mask, once you’ve computed a token’s key and value they never change — nothing later can affect them. So instead of recomputing the whole sequence every step, you keep K and V around and just compute the query for the new token. You don’t cache queries because old queries are never used again. It turns generation from cubic in sequence length to quadratic. The catch is memory: the cache is roughly half a megabyte per token on a 7B model, so at long context and decent batch sizes it gets bigger than the weights — that’s why people use grouped-query attention, quantise the cache, and use paged allocators like vLLM.”

Q9: What is quantization and why use it?

In 30 seconds. “Quantisation stores weights as low-bit integers plus a scale, so you can reconstruct an approximate float. The accuracy cost is just bounded rounding error — what actually hurts is outliers, because one huge weight blows up the scale for everything sharing it. And the win is bigger than the arithmetic suggests, because decoding is memory-bandwidth-bound: halving the bytes roughly halves latency before you touch the math.”

The short version.

• Each halving of precision is roughly 2x smaller and 2x faster: FP32 → FP16 → INT8 → INT4.
• Why: memory (bigger models fit), speed (bandwidth-bound decode), cost (cheaper inference).
• Process: find min/max of the weights → compute a scale factor → round to the integer range → store the scale for dequantisation.
• Trade-off: small accuracy loss; INT8/INT4 need calibration.
• The real enemy is outliers, not average precision — hence group-wise scales.

Why it works.

Quantisation replaces a high-precision tensor with low-precision integers plus a small amount of metadata to reconstruct approximate floats.

Why the speedup is bigger than the arithmetic suggests. During single-token decoding the GPU is memory-bandwidth-bound: it must read every weight from HBM to produce one token, and the matrix multiplies are small. Halving the bytes per weight therefore roughly halves the time per token even if the arithmetic itself runs at the same rate. This is why weight-only quantisation — store INT4, dequantise to FP16 in the kernel, multiply in FP16 — is so popular for LLM serving: it captures the bandwidth win without needing integer matmul support or activation calibration.

The families worth naming. Post-training quantisation (PTQ) converts an already-trained model, optionally using a few hundred calibration samples to set activation ranges; GPTQ (which uses second-order information to compensate rounding error weight by weight) and AWQ (which scales up the channels the activations actually depend on before quantising) are the standard 4-bit PTQ methods. Quantisation-aware training (QAT) simulates rounding during training with a straight-through estimator for the gradient, costing a training run but retaining more accuracy at very low bit widths. QLoRA is the hybrid people actually use for fine-tuning: freeze a 4-bit NF4 base model and train small LoRA adapters in higher precision on top.

The math, and what it buys you.

The whole scheme is one affine map between floats and integers. The standard asymmetric (affine) scheme picks a scale $s$ and a zero-point $z$ so that

$$q=\text{round}\left(\frac{x}{s}\right)+z,\hat{x}=s(q-z)$$

with $s=(x_{\max }-x_{\min })/(q_{\max }-q_{\min })$ and $z$ chosen so that real zero maps exactly to an integer (which matters, because padding and ReLU outputs produce a lot of exact zeros and you do not want them to drift). The symmetric variant fixes $z=0$ and uses $s=\max |x|/q_{\max }$; it is cheaper because the dequantisation has no offset term, and it is the usual choice for weights, which are roughly zero-centred.

A worked example — and it shows exactly where the danger is. Suppose a weight block ranges over $[-0.8,1.2]$ and we quantise to INT8, which covers $[-128,127]$. Asymmetrically, $s=(1.2-(-0.8))/255=0.00784$. A weight of $0.5$ maps to $\text{round}(0.5/0.00784)=64$ (plus the zero-point offset), and dequantising gives $64\times 0.00784=0.5018$ — an error of about 0.0018, roughly half a step of $s$. That bounded round-off is the entire accuracy cost. Now note what happens with one outlier: if a single weight in the block were $12.0$, the scale would jump to $0.05$ and every ordinary weight would carry 27 times more error. Outliers, not average precision, are what actually break quantisation — which is why modern methods quantise in small groups (say 64 or 128 weights sharing one scale) rather than per-tensor, and why LLM.int8() keeps a handful of outlier channels in FP16 while quantising the rest.

Good and bad.

• Good: proportional memory savings, proportional latency savings during bandwidth-bound decode, and lower serving cost; INT8 is effectively free in quality terms.
• Bad — the honest trade-off: INT4 with good grouping loses a little, and it loses it unevenly — long-chain reasoning, arithmetic, and rarely-seen languages degrade before general fluency does, so a perplexity check alone can look fine while a task benchmark drops. Below 4 bits quality falls off sharply without specialised methods.
• Bad: activation quantisation needs calibration data and can be exceeded at run time; outlier channels make naive per-tensor scales lossy.

Follow-up: Why not just quantise activations too? You can, and INT8 activations are what let you use integer tensor cores for a genuine compute win. But activations depend on the input, so their range must be estimated from calibration data and can be exceeded at run time, and transformer activations contain systematic large-magnitude outlier channels that make per-tensor activation scales very lossy. That is exactly the problem LLM.int8() and SmoothQuant (which migrates the difficulty from activations into weights by rescaling) were designed to solve.

Why the interviewer asks this. They want to know if you can reason about the deployment constraint — memory bandwidth — rather than reciting bit widths.

Saying it out loud. “Quantisation is storing weights as low-bit integers plus a scale, so you can reconstruct an approximate float. The accuracy cost is just rounding error, bounded by half a step of the scale — the thing that actually hurts is outliers, because one huge weight blows up the scale for everything sharing it. That’s why people quantise in small groups instead of per-tensor. And the reason it’s such a big win for LLMs is that decoding is memory-bandwidth-bound: you’re reading every weight from memory to emit one token, so halving the bytes roughly halves your latency even before you touch the arithmetic. INT8 is basically free, INT4 with good grouping is usually acceptable, and below that you need real work.”

Q10: Explain top-p (nucleus) sampling.

In 30 seconds. “Top-p keeps the smallest set of tokens whose probabilities add up to p — say 0.9 — and samples from that after renormalising. The point is that the set size adapts: when the model is confident that’s one token and you’re effectively greedy; when it’s genuinely uncertain it might be hundreds. Fixed top-k can’t do either — it lets junk in when the model is sure and cuts off good options when it isn’t.”

The short version.

Algorithm:

1. Sort tokens by probability (descending)
2. Compute cumulative probability
3. Find smallest set where cum_prob >= p
4. Sample from this “nucleus”
5. Renormalize probabilities

Probabilities: [0.5, 0.3, 0.1, 0.05, 0.03, ...]
Cumulative:    [0.5, 0.8, 0.9, 0.95, 0.98, ...]
Top-p=0.9: Nucleus = first 3 tokens (cum_prob = 0.9)

Why it works.

The problem top-p solves is that a language model’s next-token distribution has wildly varying shape from step to step. After “the capital of France is” the distribution is nearly a spike — one token holds most of the mass. After “she opened the door and saw a” it is broad, with hundreds of plausible continuations. Top-k with a fixed $k$ handles neither well: at the spike it admits $k-1$ tokens that should have been ruled out, and at the broad step it truncates hundreds of legitimate options. Top-p instead fixes the probability mass to keep and lets the count float, so the nucleus is 1 token in the first case and several hundred in the second. That is the entire argument for it.

What it is actually fixing. The tail of a softmax over a 100k-token vocabulary contains tens of thousands of tokens each with tiny probability, but their sum can be a few percent. Sample long enough and you will draw from that tail, and one bad token conditions everything after it — the model has no way to take it back, and degeneration into incoherence follows. Truncation sampling exists because the model’s tail is less trustworthy than its head, not because the tail has zero mass.

How it composes with temperature. Temperature $T$ rescales the logits before the softmax, $p_i\propto \exp (z_i/T)$. Below 1 it sharpens the distribution and above 1 it flattens it. Order matters: temperature is applied first, then top-k/top-p truncation, then renormalisation. So raising temperature does not only make sampling more random — it also enlarges the nucleus, because flattening the distribution means more tokens are needed to accumulate mass $p$. The two knobs interact, which is why tuning both at once tends to be confusing and why most practitioners fix one (commonly $T=1$ with $p\approx 0.9$–$0.95$, or $p=1$ with a tuned temperature).

The math, and what it buys you.

Running the numbers on two different steps shows the adaptivity directly. Take probabilities $[0.5,0.3,0.1,0.05,0.03,0.02]$ over six tokens, with $p=0.9$. The cumulative sums are $[0.5,0.8,0.9,0.95,0.98,1.0]$. The smallest prefix reaching 0.9 is the first three, so the nucleus is $\{0.5,0.3,0.1\}$, summing to 0.9, and after renormalising (dividing by 0.9) we sample from $[0.556,0.333,0.111]$. Now take the peaked case $[0.95,0.02,0.015,0.01,0.005]$: the first token alone already reaches 0.95 which is $\ge 0.9$, so the nucleus is a single token and generation is effectively greedy at that step. Same $p$, completely different set size — which is exactly what you want. (Note the standard convention: the nucleus is the smallest prefix whose cumulative probability is at least $p$, so the kept mass is always $\ge p$, never less.)

Good and bad.

• Top-p — good: adapts to the model’s confidence step by step; cuts the untrustworthy tail without capping variety when variety is warranted; one intuitive knob.
• Top-p — bad: interacts confusingly with temperature; a single $p$ is still a blunt global setting; and it does nothing for a model whose head of the distribution is simply wrong.
• Top-k — good: trivially cheap and bounded. Bad: fixed set size is wrong at both ends of the confidence range.

Follow-up: When would you not want to sample at all? Whenever there is a single correct answer and diversity is a liability: extraction, classification, structured or JSON output, most tool-call arguments, and any evaluation you want to be reproducible. There greedy decoding ($T\to 0$, equivalently top-k of 1) is right. Sampling is for open-ended generation where you want variety across runs. A common middle ground for reasoning tasks is to sample several times at moderate temperature and take a majority vote over final answers — self-consistency — which uses diversity as a search strategy rather than as an end in itself.

Why the interviewer asks this. Decoding parameters are the knobs everyone touches and few can explain; being able to say precisely why the adaptive cutoff beats a fixed one is a small but reliable signal.

Saying it out loud. “Top-p keeps the smallest set of tokens whose probabilities add up to p — say 0.9 — and samples from that after renormalising. The point is that the set size adapts. When the model’s confident, that’s one or two tokens and you’re basically greedy; when it’s genuinely uncertain, it might be hundreds. Fixed top-k can’t do that: it lets junk in when the model is sure and cuts off good options when it isn’t. And it composes with temperature — temperature is applied first, so cranking it up doesn’t just add randomness, it also widens the nucleus.”

Training Techniques

Q11: Explain RLHF (Reinforcement Learning from Human Feedback).

In 30 seconds. “RLHF is three stages: fine-tune on human demonstrations to teach the model what a response looks like, train a reward model on preference pairs because people compare far better than they score, then run RL — usually PPO — to push the policy toward higher reward with a KL leash back to the SFT model. The fragile stage is the reward model: the policy actively hunts its blind spots, so true quality peaks and then declines while the score keeps rising.”

The short version.

• Why RLHF: align models with human preferences; helpful, harmless, honest; better response quality.
• Challenges: collecting human feedback, training the reward model, RL complexity.

Why it works.

Stage 1, supervised fine-tuning (SFT). Start from a pretrained base model, which can only continue text, and train it on human-written prompt-response pairs with ordinary next-token cross-entropy. This does not teach new knowledge; it teaches format — that a question should be answered rather than continued with more questions. It also matters technically, because the RL stage needs a starting policy that already produces plausible outputs; RL from a raw base model would spend its entire budget rediscovering the response format.

Stage 2, the reward model (RM). Humans are unreliable at assigning absolute scores (“how good is this answer out of 10?”) but quite reliable at comparisons (“which of these two is better?”), so the data collected is preference pairs.

Stage 3, RL optimisation. The policy generates responses, the RM scores them, and PPO updates the policy to raise expected reward while a KL penalty against the frozen SFT model keeps it from wandering.

Why the reward model is the weak link. It is trained on a finite sample of on-distribution responses, but the policy immediately starts producing responses the RM never saw. Since the policy is explicitly optimising the RM’s output, it will find and exploit whatever regions the RM overestimates — this is Goodhart’s law in its purest engineering form. Empirically, measured true quality rises, peaks, and then falls while the RM’s score keeps climbing. The standard mitigations are the KL penalty (Q17), early stopping on the KL budget rather than on RM score, and periodically collecting fresh preferences on the current policy’s outputs, which is what “iterated RLHF” means.

The math, and what it buys you.

The reward model is usually the SFT model with the token-prediction head replaced by a scalar head, trained with the Bradley-Terry loss:

$${\mathcal{L}}_{RM}=-\log \sigma (r_{\varphi }(x,y_w)-r_{\varphi }(x,y_l))$$

where $y_w$ is the preferred (“won”) response, $y_l$ the rejected one, and $\sigma$ the sigmoid. Note what this objective does and does not pin down: it constrains differences in reward, so the scale is arbitrary and the absolute value of a reward is meaningless — only comparisons within a prompt are trustworthy. The model implicitly assumes preferences follow the Bradley-Terry model, that the probability a human prefers $y_w$ is $\sigma (r_w-r_l)$.

The RL stage then optimises a per-token objective that is reward minus drift:

$$R(x,y)=r_{\varphi }(x,y)-\beta \log \frac{{\pi }_{\theta }(y\mid x)}{{\pi }_{\text{ref}}(y\mid x)}$$

The reward is sparse and terminal — one scalar for the whole response — which is why a value model is needed to spread credit back over the tokens, and why this stage is the fragile one.

Good and bad.

• Good: captures preferences that cannot be written down as a loss; can exceed the quality of the demonstrations, because it optimises judgement rather than imitation.
• Bad: expensive human data; three stages of machinery and up to four models in GPU memory; and the learned reward is hackable by construction.

Follow-up: What replaced parts of this pipeline? Two things, mostly. RLAIF / Constitutional AI replaces human labels with model-generated preferences guided by a written set of principles, which makes the preference data far cheaper to scale. And for anything with a checkable answer, RLVR — reinforcement learning from verifiable rewards — replaces the learned reward model with a program that checks correctness, which removes the hackable component entirely. DPO (Q12) removes the RL loop while keeping human preferences.

Why the interviewer asks this. They are checking that you know why there are three stages rather than one, and ideally that you can name which stage actually breaks in practice.

Saying it out loud. “It’s three stages. First you fine-tune on human-written demonstrations, which mostly teaches the model what a response is supposed to look like. Then you collect preference pairs — people are much better at saying which of two answers is better than at scoring one in isolation — and train a reward model on those comparisons. Then you run RL, usually PPO, to push the policy toward higher reward, with a KL penalty back to the SFT model so it doesn’t drift off. The fragile bit is the reward model: the policy is actively searching for its blind spots, so true quality tends to peak and then decline while the reward score keeps going up.”

Q12: What is DPO and how does it differ from RLHF?

In 30 seconds. “DPO comes from noticing that the KL-constrained RLHF objective has a closed-form optimal policy. Invert it, and the reward can be written as the policy’s log-ratio against the reference; plug that into the preference likelihood and the intractable normaliser cancels. So you get a plain supervised loss on preference pairs — no reward model, no sampling, no RL loop. The cost is that it’s off-policy: it only ever sees the pairs in your dataset.”

The short version.

• Directly optimises the policy to prefer chosen over rejected.
• No reward model needed; uses the reference model instead.

DPO Loss:

Loss = -log(σ(β * (log π_chosen - log π_rejected - log π_ref_chosen + log π_ref_rejected)))

Where σ is sigmoid, β is temperature.

Why it works.

The insight is that the language model is its own reward model — the log-ratio to the reference is an implicit reward — so you never have to instantiate a separate one, and you never have to sample from the policy during training. DPO is a supervised loss on a fixed dataset of pairs.

What the gradient does. Differentiating gives a weight of $\sigma ({\hat{r}}_l-{\hat{r}}_w)$ on each pair: the update is large when the implicit reward currently ranks the pair wrongly and small when it already ranks it correctly. So DPO automatically focuses on the examples it has not yet learned, which is the same self-limiting behaviour that makes the logistic loss well-behaved.

The math, and what it buys you.

This derivation is the whole answer — it turns DPO from a heuristic into a consequence. The KL-constrained RLHF objective has a known closed-form optimum. If you maximise expected reward minus $\beta$ times KL to the reference, the optimal policy is

$${\pi }^{\ast }(y\mid x)=\frac{1}{Z(x)}{\pi }_{\text{ref}}(y\mid x)\exp \left(\frac{1}{\beta }r(x,y)\right)$$

that is, the reference policy reweighted by exponentiated reward. This is not usable directly because the partition function $Z(x)$ sums over all possible responses. But rearrange it to solve for the reward instead:

$$r(x,y)=\beta \log \frac{{\pi }^{\ast }(y\mid x)}{{\pi }_{\text{ref}}(y\mid x)}+\beta \log Z(x)$$

Now substitute this into the Bradley-Terry preference likelihood $\sigma (r(x,y_w)-r(x,y_l))$. Because the two responses share the same prompt $x$, the intractable $\beta \log Z(x)$ term appears in both and cancels exactly. What is left is a loss over the policy alone:

$${\mathcal{L}}_{\text{DPO}}=-\log \sigma \left(\beta \log \frac{{\pi }_{\theta }(y_w\mid x)}{{\pi }_{\text{ref}}(y_w\mid x)}-\beta \log \frac{{\pi }_{\theta }(y_l\mid x)}{{\pi }_{\text{ref}}(y_l\mid x)}\right)$$

That is the formula in the box above, now with a reason.

Good and bad.

• DPO — good: one model in memory, a stable supervised loss, no reward-model training and no sampling loop; reference log-probs can be precomputed once for the whole dataset.
• DPO — bad: trains on a fixed, off-policy dataset, so it never sees the responses the current policy actually generates. A known pathology follows from the loss: nothing constrains the absolute likelihood of the chosen response, only the gap, so the optimiser can and often does reduce the probability of both responses while widening the difference — pushing mass onto entirely unseen text. Practical fixes include adding an SFT term on the chosen responses (this is roughly what RPO/CPO do), and running iterative DPO where you periodically sample from the current policy, label those samples, and retrain.
• RLHF — good: the online loop keeps collecting fresh samples and scoring them, which is how it discovers and corrects new failure modes. Bad: four models, a hackable proxy, and a fragile optimisation.

Follow-up: What does $\beta$ control in DPO? It is the same KL strength as in RLHF, but it enters as the inverse temperature of the implicit reward. Small $\beta$ (say 0.01) means the policy is allowed to move far from the reference and fits preferences aggressively; large $\beta$ (0.5) keeps it tethered. Typical values are 0.1 to 0.5. Because the reference model appears explicitly in the loss, its log-probabilities can be precomputed once for the whole dataset, so DPO needs only one model in memory during training rather than PPO’s three or four.

Why the interviewer asks this. DPO is the standard alignment method most teams actually run; knowing that it comes from analytically solving the RLHF objective — rather than being a separately invented heuristic — is what distinguishes reading the paper from reading a blog summary.

Saying it out loud. “DPO comes from noticing that the KL-constrained RLHF objective has a closed-form optimal policy, and if you invert it you can write the reward in terms of the policy’s log-ratio against the reference. Plug that into the preference likelihood and the intractable normalising term cancels, because both responses share a prompt. So you end up with a plain supervised loss on preference pairs — no reward model, no sampling, no RL loop. The cost is that it’s off-policy: it only ever sees the pairs in your dataset, so it can’t discover new failure modes the way an online loop does. And there’s a known quirk where it lowers the probability of the chosen response too, as long as the gap widens.”

Q13: Explain PPO (Proximal Policy Optimization) in detail. Why is it used in RLHF?

In 30 seconds. “PPO exists so you can reuse a batch of samples for more than one gradient step. You do that with an importance ratio — new policy probability over old — but that ratio has ugly variance if the policy moves too far, so PPO clips it to a narrow band around one and takes the pessimistic branch with a min. Once you’ve pushed a good action up by twenty percent the gradient goes flat for that batch, but a bad action whose probability rose still gets the full correction.”

The short version.

• What it is: a policy-gradient algorithm that prevents large policy updates by clipping the objective.
• The ratio $r(\theta )={\pi }_{\theta }(a|s)/{\pi }_{{\theta }_{old}}(a|s)$ is what lets you reuse a batch; the clip is what stops the variance exploding.
• Why clipping: prevents destabilising updates, changes the policy gradually, and makes the same data reusable across epochs.

Why PPO in RLHF:

1. Stability: Language models are sensitive - need stable updates
2. Sample efficiency: Human feedback is expensive - reuse data
3. KL constraint: Keeps policy close to reference
4. Proven: Works well in practice (ChatGPT, Claude)

PPO Algorithm:

1. Collect trajectories with current policy
2. Compute advantages A(s,a)
3. For K epochs:
   • Compute ratio r(θ) = π_θ / π_θ_old
   • Compute clipped objective
   • Update policy
4. Update old policy

Why it works.

Vanilla policy gradient computes ${\nabla }_{\theta }\mathbb{E}[R]$ from samples drawn by the current policy, so as soon as you take one gradient step the data is stale and must be thrown away. That is intolerable when each sample requires generating a full response from a large language model. Importance sampling fixes it: you can estimate an expectation under ${\pi }_{\theta }$ using samples from ${\pi }_{{\theta }_{old}}$ by reweighting each sample by $\rho ={\pi }_{\theta }(a\mid s)/{\pi }_{{\theta }_{old}}(a\mid s)$. That is where the ratio in the objective comes from — it is what licenses multiple epochs over the same batch.

The problem is that importance sampling has unbounded variance: if the policy moves far from the sampler, some ratios blow up and a single sample dominates the gradient. TRPO handled this with a hard KL trust-region constraint and a second-order solve. PPO’s contribution is to get almost the same effect with a first-order trick — clip the ratio and take the pessimistic branch.

The advantage, and why RLHF needs a value model. $A(s,a)=Q(s,a)-V(s)$ asks “was this action better than the average action from this state”, and subtracting the state-value baseline $V$ removes variance without introducing bias. PPO estimates it with GAE (generalised advantage estimation), an exponentially weighted average over $n$-step temporal-difference errors controlled by $\lambda$, which trades bias against variance. In RLHF the reward arrives only at the end of the response, so the value model’s job is to spread that single scalar back across hundreds of token-level decisions. This is precisely the component GRPO removes.

The math, and what it buys you.

L^CLIP(θ) = E[min(r(θ)A, clip(r(θ), 1-ε, 1+ε)A)]

Where:
- r(θ) = π_θ(a|s) / π_θ_old(a|s) (importance sampling ratio)
- A: Advantage estimate
- ε: Clipping parameter (typically 0.1-0.3)

$$L^{CLIP}=\mathbb{E}\left[\min \right(\rho A,\text{clip}(\rho ,1-ϵ,1+ϵ)A\left)\right]$$

Read the four cases and it becomes obvious what the formula buys you. With $ϵ=0.2$: if the advantage $A>0$ (the action was better than expected) and $\rho$ has already grown past $1.2$, the clipped branch is flat, so the gradient is zero — you have already increased this action’s probability enough for one batch, stop. If $A>0$ and $\rho <1$, no clipping applies and you get the full gradient. If $A<0$ and $\rho$ has fallen below $0.8$, again flat, stop pushing it down. If $A<0$ and $\rho >1$, the unclipped term is more negative, and the min selects it — so a bad action whose probability accidentally increased still gets a full corrective gradient. The min is what makes the bound pessimistic rather than merely bounded: it only ever removes incentive to move further, never removes a correction.

Good and bad.

• Good: sample-efficient (multiple epochs per batch), first-order and cheap compared with TRPO’s second-order solve, and empirically the most reliable RLHF optimiser at scale.
• Bad — memory. The full RLHF-PPO loop keeps four models live: the policy being trained, a frozen reference for the KL term, the reward model, and the value model. That is the practical reason PPO-based RLHF is hard to run, and the reason both DPO (drop the RL loop) and GRPO (drop the critic) found adoption.
• Bad: many interacting hyperparameters ($ϵ$, epochs per batch, GAE $\lambda$, KL $\beta$, entropy bonus), and a value model that is itself hard to calibrate on long generations.

Follow-up: What typically goes wrong when PPO training destabilises? Watch three numbers. If the KL to the reference climbs steadily, the policy is drifting and reward hacking usually follows — most implementations use an adaptive $\beta$ that increases when KL exceeds a target. If the clip fraction (the share of tokens hitting the clip boundary) rises above roughly 20-30%, the policy is moving too fast per batch, so lower the learning rate or take fewer epochs per batch. If entropy collapses, the policy has converged to a narrow set of phrasings — mode collapse — and an entropy bonus or a stronger KL term is the usual response.

Why the interviewer asks this. They want to see whether you can explain the clip as a variance-control mechanism for importance sampling, rather than as “it stops big updates”.

Saying it out loud. “PPO exists so you can reuse a batch of samples for more than one gradient step. You do that with an importance ratio — new policy probability over old — but that ratio has nasty variance if the policy moves too far, so PPO clips it to a narrow band around one and takes the pessimistic branch with a min. The effect is that once you’ve pushed a good action’s probability up by twenty percent, the gradient goes flat for that batch, but if a bad action’s probability went up you still get the full correction. In RLHF you also need a value model, because the reward only shows up at the end of the response and something has to spread that credit across all the tokens.”

Q14: What is GRPO (Group Relative Policy Optimization)? When is it useful?

In 30 seconds. “GRPO is PPO with the critic deleted. Instead of learning a value function to predict expected reward, you sample a whole group of completions for the same prompt — say sixteen — and use the group’s own mean reward as the baseline. So the advantage is just ‘did this attempt beat my other attempts at this problem’. That kills one of the four models in memory, and it pairs beautifully with verifiable rewards. The cost is generation: sixteen completions per prompt instead of one.”

The short version.

• GRPO (Shao et al., DeepSeekMath, 2024; the algorithm behind DeepSeek-R1) is a variant of PPO that removes the learned value network.
• The “group” is a group of sampled responses to the same prompt, not a group of users. For each prompt, the policy samples $G$ completions (typically 8-64), each is scored, and the group’s own reward statistics serve as the baseline that PPO would otherwise get from a critic.
• Use cases: reasoning with verifiable answers — mathematics, competitive programming, unit-test-checked code — its original and strongest domain; and any setting where sampling several completions is cheap relative to training a critic.

Note on a correction. An earlier version of this answer described GRPO as optimising across demographic or user groups with different preferences. That is not what GRPO is. The “group” is a group of sampled completions for one prompt, and the method’s purpose is to eliminate the value network. The text above has been corrected.

Why it works.

Any policy-gradient method needs a baseline subtracted from the reward, because $\mathbb{E}[\nabla \log \pi \cdot b]=0$ for any $b$ that does not depend on the action — so subtracting a baseline reduces variance without introducing bias. PPO learns that baseline with a value network. GRPO observes that if you sample $G$ completions from the same prompt, their mean reward is already an unbiased, zero-cost estimate of that prompt’s expected return. No network, no training, no calibration drift. Dividing by the group standard deviation additionally normalises the advantage scale across prompts, so an easy prompt where everything scores 0.9-1.0 and a hard prompt where everything scores 0.0-0.1 contribute comparably sized gradients.

Why GRPO, in three points.

• No critic: PPO needs a value model roughly the size of the policy, so it holds four models in memory (policy, reference, reward, value). Dropping the critic cuts memory and removes a second network that itself has to be trained and can be badly calibrated on long generations.
• Natural fit for verifiable rewards: When the reward is a rule-based checker — does the maths answer match, do the unit tests pass — you get a clean scalar per sample and no reward model is needed either, leaving just policy and reference.
• Comparison is the signal: The advantage says “was this attempt better or worse than my other attempts at the same problem”, which is exactly the credit-assignment question, and it needs no learned estimate of expected return.

How this pairs with verifiable rewards. GRPO became prominent because it composes so cleanly with rule-based rewards. If your reward is “does the final answer match” or “do the tests pass”, you have removed the reward model; GRPO removes the value model; and you are left with a policy and a frozen reference. That configuration — sample many attempts, check them, upweight the ones that worked — is what produced the long chain-of-thought behaviour in DeepSeek-R1, where the model learned to backtrack and re-derive without ever being shown a demonstration of doing so.

The math, and what it buys you.

For a prompt $q$, sample outputs $o_1,\dots ,o_G\sim {\pi }_{{\theta }_{old}}(\cdot \mid q)$ with rewards $r_1,\dots ,r_G$. The advantage for output $i$ is the reward standardised within the group — this one line is what replaces the entire value network:

$${\hat{A}}_i=\frac{r_i-\text{mean}(r_1,\dots ,r_G)}{\text{std}(r_1,\dots ,r_G)}$$

and this scalar is assigned to every token of that output. The objective is then the usual PPO clipped surrogate with a KL term:

$${\mathcal{L}}_{\text{GRPO}}=\mathbb{E}\left[\frac{1}{G}\sum _{i=1}^G\frac{1}{|o_i|}\sum _t\min ({\rho }_{i,t}{\hat{A}}_i,\text{clip}({\rho }_{i,t},1-ϵ,1+ϵ){\hat{A}}_i)\right]-\beta D_{KL}({\pi }_{\theta }\parallel {\pi }_{ref})$$

where ${\rho }_{i,t}={\pi }_{\theta }(o_{i,t}\mid q,o_{i,<t})/{\pi }_{{\theta }_{old}}(o_{i,t}\mid q,o_{i,<t})$ is the per-token importance ratio.

A worked example.

• Prompt: a maths problem. Sample 8 chains of thought; 3 reach the right answer, 5 do not.
• Rewards are $[1,1,1,0,0,0,0,0]$, so mean $=0.375$ and std $\approx 0.484$.
• Advantages are $\approx +1.29$ for the three correct chains and $\approx -0.77$ for the five wrong ones, pushing probability mass toward whatever the successful chains did — with no value network anywhere in the loop.

Good and bad.

• Good: one fewer model to hold and train; a baseline that cannot be miscalibrated because it is measured, not predicted; and a clean composition with rule-based rewards.
• Bad — the standard-deviation divisor. If every completion in a group gets the same reward — all correct or all wrong — the standard deviation is zero, the advantage is undefined or zero, and the prompt contributes nothing; those prompts are simply wasted compute. And dividing by the standard deviation systematically upweights prompts where the group happened to disagree, which is a difficulty bias rather than a learning signal. Later variants (Dr. GRPO and the loss-normalisation fixes in DAPO) drop the standard-deviation divisor and change the token-length normalisation for exactly these reasons.
• Bad — sampling cost. Group size is a real hyperparameter: too small and the baseline is noisy, too large and you are paying for redundant samples.

Follow-up: What is the practical cost? Compute at sampling time. You are generating $G$ full completions per prompt instead of one, so a group size of 16 means 16 times the generation work per prompt — and generation, not the gradient step, dominates RL wall-clock for LLMs. The trade you are making is critic memory and critic instability in exchange for sampling throughput, which is a good trade when generation is well-optimised and a bad one when it is not. Group size is a real hyperparameter: too small and the baseline is noisy, too large and you are paying for redundant samples.

Why the interviewer asks this. It is a recency check with substance: GRPO is only useful to know if you can say what it removes and what it costs, not just that DeepSeek used it.

Saying it out loud. “GRPO is PPO with the critic deleted. Instead of learning a value function to tell you what reward to expect from a prompt, you sample a whole group of completions for that prompt — say sixteen — and use the group’s own mean reward as the baseline, standardised by the group’s standard deviation. So the advantage is just ‘did this attempt beat my other attempts at the same problem’. That kills one of the four models you’d otherwise hold in memory, and it pairs beautifully with verifiable rewards like ‘did the tests pass’, because then you don’t need a reward model either. The cost is generation: you’re producing sixteen completions per prompt instead of one.”

Q15: What are the main challenges in RL alignment? How do you address them?

In 30 seconds. “Almost all of these are one problem wearing different hats: you’re optimising a learned proxy for human judgement, and the policy is actively hunting for places where that proxy is wrong. True quality goes up, peaks, then falls while the reward score keeps climbing. The main lever is the KL penalty, because it bounds how far you can get from the region where the reward model was actually trained.”

The short version.

Why it works.

The common root. Four of the five challenges above are the same phenomenon seen from different angles: you are optimising a proxy (a learned reward model) rather than the thing you care about (human judgement), using a policy that actively searches the proxy’s input space. Reward hacking is the proxy being exploited; distribution shift is the proxy being evaluated off its training distribution; mode collapse is the policy concentrating on the narrow region where the proxy scores highest; instability is the optimisation running away in that direction. Framing it as one problem rather than five is what makes the mitigations cohere — the KL penalty appears in three of the five rows because it directly bounds how far into unmeasured territory the policy is allowed to go.

On feedback quality specifically. The failure is not only noise but systematic bias, and the biases are known: annotators reliably prefer longer responses, more confident phrasing, and more formatting (lists, bold headers) independent of content. Length bias is severe enough that some RLHF runs produce models that are longer and no better, and length-controlled evaluation exists precisely because of it. Mitigations are measurement-first — check the correlation between reward and response length, and if it is high, either debias the reward (subtract a length term) or resample the preference data to decorrelate them.

The math, and what it buys you.

A number worth having. Gao, Schulman and Hilton’s scaling-law study of reward-model overoptimisation found that true reward, plotted against the square root of the KL divergence from the initial policy, rises and then falls in a predictable arc, with the peak moving further out as the reward model gets larger and is trained on more data. The practical implication is concrete: KL distance is the right x-axis for deciding when to stop, and “stop when the RM score plateaus” is the wrong criterion because the RM score keeps rising past the point where quality starts dropping.

Follow-up: How would you tell reward hacking apart from genuine improvement? Use a held-out signal the policy is not being optimised against. Concretely: a separate reward model trained on different data or with a different seed (if scores diverge between the two, at least one is being gamed), pairwise human evaluation on a fresh sample, and task benchmarks the RM never saw. Add cheap behavioural monitors for the known degenerate modes — mean response length, refusal rate, n-gram repetition, entropy — because hacking usually shows up as a sharp change in one of those before it shows up in an aggregate score.

Why the interviewer asks this. The list is easy to memorise; they are listening for whether you understand that these are symptoms of proxy optimisation and can name what you would actually monitor.

Saying it out loud. “Almost all of these are one problem wearing different hats: you’re optimising a learned proxy for human judgement, and the policy is actively hunting for places where that proxy is wrong. So true quality goes up, peaks, and then falls while the reward score keeps climbing. The main lever is the KL penalty back to the reference model, because it bounds how far you can get from the region where the reward model was actually trained. Beyond that I’d hold out a second reward model and some real human eval as an unhacked signal, and I’d watch for the obvious tells — response length creeping up, entropy collapsing, refusal rate spiking.”

Q16: How do you prevent reward hacking in RLHF?

In 30 seconds. “Reward hacking isn’t a bug you fix — it’s what optimisation does to any imperfect proxy; the policy’s whole job is to find where your reward model is wrong. The concrete versions are consistent: longer, more sycophantic, more heavily formatted, more confident hedging. The main defence is the KL penalty, then a pessimistic reward-model ensemble, then monitoring length, entropy and refusal rate — because hacking shows up there before it shows up in any aggregate score.”

The short version.

• What it is: the model finds unintended ways to maximise reward (e.g. always saying “I can’t answer”).
• Prevention: careful reward design (multiple signals, penalise known hacks); regularisation (KL penalty); reward-model robustness (diverse training, bias detection); monitoring (track patterns, detect anomalies); constrained optimisation (hard/soft constraints); iterative refinement (identify hacks, refine the reward).
• Expect it by default. You need a detection story, not only a prevention story.

Why it works.

Why this is hard rather than just fiddly. Reward hacking is not a bug in a particular reward model; it is what optimisation does to any imperfect proxy. Goodhart’s law in its sharpest form: the reward model and human judgement agree on the distribution where preferences were collected, and the optimiser’s job is to leave that distribution. So the goal is never “build an unhackable reward” — it is to make the gap costly to reach and to notice when it has been reached.

Concrete hacks that actually show up. Naming these is more convincing in an interview than abstractions. Length inflation: annotators mildly prefer longer answers, so the policy learns to pad, and reward rises with word count. Sycophancy: agreeing with the user’s stated view scores well, so the model stops contradicting false premises. Formatting theatre: bullet points, bold headers and a confident summary paragraph score well independent of content. Hedged non-answers: on hard prompts, a fluent refusal outscores a wrong attempt, so the model learns to refuse more. Confident fabrication: certainty is rewarded, uncertainty is not, so calibration degrades. Each is a case of the reward model having learned a correlate of quality rather than quality.

The one mechanism to explain properly. Of the six prevention items listed above, the KL penalty is the load-bearing one, and the reason is stated precisely in Q17: it caps how far the policy can travel from the region where the reward model’s judgements were actually validated. Reward-model ensembles are the second most useful, because a hack usually exploits an idiosyncrasy of one model’s error surface; taking the minimum (pessimistic) score across an ensemble, rather than the mean, penalises responses that any member distrusts and measurably delays overoptimisation.

Follow-up: What if the reward is a verifier rather than a learned model? It is harder to hack but not immune, and the failures are different in kind: unit tests get special-cased (if input == test_case_1: return 42), maths answers get asserted without a valid derivation, and any reward that only checks the final answer will accept a correct answer reached by an incoherent chain. So the mitigation shifts from KL-style constraints to test coverage, hidden held-out tests, and process-level checking of the reasoning rather than only the outcome.

Why the interviewer asks this. Anyone can list mitigations; they want to hear that you expect hacking by default and have a detection story, not just a prevention story.

Saying it out loud. “I’d start by saying reward hacking isn’t a bug you fix, it’s what optimisation does to any imperfect proxy — the policy’s whole job is to find where your reward model is wrong. The concrete versions are pretty consistent: answers get longer, more sycophantic, more heavily formatted, and more prone to a confident hedge instead of a real attempt. The main defence is the KL penalty, which keeps the policy near the distribution the reward model was actually trained on. After that I’d ensemble a couple of reward models and take the pessimistic score, and I’d monitor length, entropy and refusal rate, because hacking normally shows up there before it shows up in any aggregate metric.”

Q17: Explain the KL penalty in RLHF. Why is it important?

In 30 seconds. “The KL penalty measures how far the policy has drifted from the frozen reference model and charges it for that drift. It matters because the reward model was only ever validated near the reference distribution — that’s where the preference data came from — so KL distance is a direct measure of how far outside your measurements you’ve wandered. Too small a beta and the policy runs off and hacks the reward; too large and it can’t learn.”

The short version.

• What it is: KL divergence measures how different the policy is from the reference; the penalty prevents large deviations.
• Why it matters: prevents mode collapse (keeps the policy diverse), prevents reward hacking (constrains to reasonable behaviours), maintains SFT capabilities, adds stability, and acts as a trust region.
• Choosing $\beta$: too small and the policy deviates too much; too large and it cannot learn. Typical $\beta =0.1$–$0.5$ — but it is usually adaptive, not fixed.

KL(π_θ || π_ref) = E[log(π_θ(a|s) / π_ref(a|s))]

In practice:
KL_penalty = β * (log π_θ - log π_ref)

Why it works.

What the penalty is doing, geometrically. KL divergence $D_{KL}({\pi }_{\theta }\parallel {\pi }_{\text{ref}})$ measures how much the trained policy’s distribution has moved from the frozen reference. Adding $-\beta D_{KL}$ to the reward turns unconstrained reward maximisation into a trust region: the policy may buy reward, but it pays in distance, and the exchange rate is $\beta$. The reason this is the right currency is that the reward model’s judgements are only validated near the reference distribution — that is where the preference data was collected. KL distance is therefore a direct proxy for “how far outside my measurement is this”.

How it is actually computed. You cannot evaluate the true expectation over all sequences, so implementations use the per-token log-ratio of the sampled tokens, $\log {\pi }_{\theta }(y_t\mid \cdot )-\log {\pi }_{\text{ref}}(y_t\mid \cdot )$, as a single-sample estimator and subtract $\beta$ times it from the reward at each token. That naive estimator is unbiased but high-variance and can go negative, which is confusing to read on a dashboard; the common fix is the low-variance estimator ${\hat{k}}_3=(\rho -1)-\log \rho$ where $\rho ={\pi }_{\text{ref}}/{\pi }_{\theta }$, which is always non-negative and much less noisy. Note also the implementation choice: adding the penalty into the reward (so it flows through the advantage and the value function) behaves differently from adding it as a separate loss term, and the two are not equivalent — the original RLHF papers put it in the reward.

Adaptive $\beta$. Because the right $\beta$ depends on the reward model’s scale, most implementations do not fix it. They set a target KL and use a controller that raises $\beta$ when measured KL exceeds the target and lowers it when it falls below. This makes the hyperparameter you tune (“how far am I willing to drift”) interpretable in a way a raw coefficient is not.

The math, and what it buys you.

A small worked example of what $\beta$ buys. Suppose at some token the reference gives probability 0.10 to the token the policy sampled and the policy now gives it 0.60. The log-ratio is $\log (0.6/0.1)=1.79$. With $\beta =0.1$ the penalty is $0.179$ reward units at that token; with $\beta =0.5$ it is $0.90$. If the reward model’s scale is such that a typical good-versus-bad gap is around 1 unit, then at $\beta =0.5$ this single-token deviation has consumed most of the available reward and the policy will not make it unless the payoff is genuinely large — whereas at $\beta =0.1$ it is nearly free. That is the whole tuning intuition, and it also explains why $\beta$ cannot be transferred between runs without checking the reward model’s scale.

Good and bad.

• Good: it is the single most effective brake on reward hacking, it preserves SFT capabilities, and — as an adaptive target-KL controller — it turns an opaque coefficient into a quantity you can reason about.
• Bad: too large and learning stalls; the naive per-token estimator is noisy and can read negative; and the direction used is mode-seeking, which is part of why RLHF measurably reduces output diversity.

Follow-up: Which direction of KL is used, and does it matter? RLHF uses the forward-from-the-policy form $D_{KL}({\pi }_{\theta }\parallel {\pi }_{\text{ref}})$, which is mode-seeking: it heavily punishes the policy for putting mass where the reference puts almost none, but does not punish it for abandoning modes the reference covered. That asymmetry is convenient — it blocks the policy from inventing wholly new behaviour — but it is also part of why RLHF reduces output diversity, since dropping modes is cheap under this direction. The reverse direction would be mass-covering and would preserve diversity, but it would require sampling from the reference, which is more expensive.

Why the interviewer asks this. It is the one hyperparameter that decides whether an RLHF run works, so knowing what it trades off — and that it is usually adaptive — is a strong signal of hands-on experience.

Saying it out loud. “The KL penalty measures how far the policy has drifted from the frozen reference model and charges the policy for that drift. The reason it matters is that your reward model was only ever validated near the reference distribution — the preference data came from there — so KL distance is basically a measure of how far outside your measurements you’ve wandered. Too small a beta and the policy runs off and hacks the reward; too large and it can’t learn anything. In practice people don’t fix beta at all — they set a target KL and let a controller adjust beta to hit it, which makes the knob you’re tuning something you can actually reason about.”

See 08_training_techniques/rl_alignment_qa.md for even more detailed answers!

Optimization

Q18: Explain the Adam optimizer.

In 30 seconds. “Adam is two ideas glued together. The first moment is momentum — an exponential average of gradients, so consistent directions build up and noisy ones cancel. The second moment averages squared gradients, and dividing by its square root gives every parameter its own effective learning rate, roughly the signal-to-noise ratio of that parameter’s gradient. The bias correction exists because both averages start at zero and are wildly too small at step one.”

The short version.

• Adam = Adaptive Moment Estimation.
• First moment (m): exponential moving average of gradients — momentum.
• Second moment (v): exponential moving average of squared gradients — a per-parameter learning rate.
• Bias correction: fixes the toward-zero bias of both averages in early steps.
• Defaults: ${\beta }_1=0.9$ (momentum), ${\beta }_2=0.999$ (variance), $\alpha =0.001$ (learning rate).
• Cost: two extra values per parameter in memory.

m_t = β1 * m_{t-1} + (1-β1) * g_t
v_t = β2 * v_{t-1} + (1-β2) * g_t²
m_hat = m_t / (1 - β1^t)
v_hat = v_t / (1 - β2^t)
θ_t = θ_{t-1} - α * m_hat / (√v_hat + ε)

Why it works.

Adam is momentum and RMSProp stacked, plus a correction for how they start.

The first moment is momentum. $m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t$ is an exponential moving average of past gradients, which with ${\beta }_1=0.9$ has an effective window of about $1/(1-{\beta }_1)=10$ steps. Averaging helps because minibatch gradients are noisy estimates of the true gradient: components that point consistently in one direction survive the average, components that flip sign cancel. In a long narrow ravine — the typical shape of a neural loss surface — this damps the oscillation across the valley and accumulates speed along it.

The second moment is a per-parameter learning rate. $v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2$ tracks the average squared gradient with a much longer window, about 1000 steps at ${\beta }_2=0.999$. Dividing the step by $\sqrt{{\hat{v}}_t}$ means a parameter whose gradients have been consistently large takes small steps and one whose gradients have been small takes large ones. The effective step size becomes roughly $\alpha \cdot \text{mean}(g)/\text{RMS}(g)$, which is close to a signal-to-noise ratio: parameters with a consistent gradient direction move at nearly the full learning rate, parameters whose gradient is mostly noise barely move. This is why Adam works out of the box on problems — like transformers, with embeddings whose gradients are extremely sparse and layer norms whose gradients are not — where a single global learning rate would be badly wrong for most parameters.

Epsilon sits inside the square root’s denominator to stop division by zero, but it also quietly sets a floor: with $ϵ=10^{-8}$, any parameter whose gradient RMS falls below that gets a step proportional to $g/ϵ$ rather than a normalised one. Raising $ϵ$ to $10^{-6}$ or $10^{-4}$ is a standard stability fix for large-model training.

The math, and what it buys you.

Bias correction is not cosmetic — here is the number that shows it. Both averages start at zero, so early on they are biased toward zero. Concretely: at $t=1$, $v_1=(1-0.999)g_1^2=0.001g_1^2$, so $\sqrt{v_1}\approx 0.032|g_1|$ — about 30 times too small, which would make the first step about 30 times too large and can blow the model up immediately. The correction divides by $1-{\beta }_2^t$, which at $t=1$ is exactly $0.001$, restoring ${\hat{v}}_1=g_1^2$. The correction decays to nothing as ${\beta }^t\to 0$, so it only matters for roughly the first few thousand steps — precisely the fragile part of training. (Even with it, transformers usually still need learning-rate warmup, because the variance of Adam’s update, not just its mean, is large when $v$ is estimated from few samples.)

Worked micro-example — what the adaptivity actually does. Take a parameter with a steady gradient $g=0.1$ every step, $\alpha =0.001$. After a few steps $\hat{m}\approx 0.1$ and $\hat{v}\approx 0.01$, so $\sqrt{\hat{v}}=0.1$ and the update is $0.001\times 0.1/0.1=0.001$ — the full learning rate. Now a parameter whose gradient alternates $+0.1,-0.1$: $\hat{m}\approx 0$ but $\hat{v}\approx 0.01$ still, so the update is near zero. Same gradient magnitude, opposite treatment, based purely on consistency.

Good and bad.

• Good: works out of the box across very different architectures; per-parameter adaptivity handles sparse embedding gradients and dense norm gradients in the same run; momentum smooths minibatch noise.
• Bad: memory — two extra values per parameter; sensitivity to $ϵ$ at scale; and it still needs learning-rate warmup for transformers despite the bias correction.

Follow-up: Why does Adam use so much memory? It stores $m$ and $v$ per parameter, so with FP32 master weights the optimiser state is 8 bytes per parameter on top of the 4 bytes of weights and 4 of gradients — roughly 16 bytes per parameter in total, meaning a 7B model needs about 112 GB just to hold training state before activations. This is exactly what ZeRO shards across devices, what 8-bit Adam quantises, and what memory-light optimisers like Adafactor (which factorises $v$ into row and column statistics) and Lion (which keeps only momentum) are trying to avoid.

Why the interviewer asks this. Everyone uses Adam; few can say what the second moment is doing or why the bias correction exists, and the bias-correction question in particular has a crisp right answer.

Saying it out loud. “Adam is two ideas together. The first moment is momentum — an exponential average of the gradients, so consistent directions build up and noisy ones cancel. The second moment is an average of squared gradients, and dividing by its square root gives every parameter its own effective learning rate; roughly you’re stepping by the signal-to-noise ratio of that parameter’s gradient. The bias correction is there because both averages start at zero, so early on they’re way too small — at step one the second moment is a thousandth of its true value, which would make your first step enormous. And the cost is memory: two extra values per parameter.”

Q19: What’s the difference between Adam and AdamW?

In 30 seconds. “For plain SGD, adding an L2 term to the loss and decaying the weights are the same operation. For Adam they aren’t, because the L2 term goes through the second-moment normalisation along with the real gradient — so parameters with big gradient histories get their decay divided down and end up barely regularised, while quiet parameters get hammered. AdamW applies the decay straight to the weights after the adaptive step, so everything shrinks by the same proportion.”

The short version.

# Adam: weight decay in gradient
gradient = gradient + weight_decay * params

# AdamW: weight decay separate
params = params - lr * (adam_update + weight_decay * params)

Why it works.

L2 regularisation and weight decay are the same thing for plain SGD and different things for Adam — that is the whole content of the AdamW paper.

With L2 regularisation you add $\frac{\lambda }{2}\Vert w{\Vert }^2$ to the loss, so the gradient becomes $g+\lambda w$. Feed that into Adam and the penalty term goes through the same second-moment normalisation as everything else. Because the denominator is large for parameters with large historical gradients, the decay those parameters receive is divided down. The consequence is backwards: parameters with big, consistent gradients — the ones doing the most work and most at risk of growing large — get the least regularisation, while parameters with tiny gradients get the most. The decay strength ends up coupled to the gradient history, which is not what anyone intends when they set a weight decay value.

AdamW removes the penalty from the gradient entirely and applies it directly to the weights after the adaptive step. Now every parameter shrinks by the same relative amount per step regardless of its gradient statistics, which is what “weight decay” is supposed to mean. A practical side effect: the two hyperparameters decouple, so tuning the learning rate no longer silently changes the effective regularisation, which is why AdamW’s hyperparameters transfer between runs far better.

The math, and what it buys you.

Adam with L2 in the gradient gives

$$\Delta w=-\alpha \frac{\hat{m}(g+\lambda w)}{\sqrt{\hat{v}(g+\lambda w)}+ϵ}$$

— note the $\lambda w$ sitting inside the normalisation. AdamW instead applies

$$w\leftarrow w-\alpha \left(\frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}+\lambda w\right)$$

Numeric illustration of what that difference costs you. Two parameters, both at $w=1.0$, both with $\lambda =0.01$. Parameter A has had a gradient RMS around $1.0$; parameter B around $0.01$. Under Adam-with-L2 the decay contributions are roughly $\lambda w/\sqrt{\hat{v}}$, so A gets $0.01/1.0=0.01$ and B gets $0.01/0.01=1.0$ — a hundredfold difference in regularisation strength that nobody asked for. Under AdamW both get exactly $\alpha \lambda w$.

Good and bad.

• AdamW — good: better generalisation, more principled decay, and hyperparameters that transfer. Bad: because the decay now hits every parameter uniformly, you generally want to exclude biases, LayerNorm gains and (often) embeddings from it — decaying a normalisation gain toward zero has no regularising interpretation and just fights the layer. Every serious training script has a parameter-group split doing exactly this.
• Practical values: $\lambda =0.1$ for large transformer pretraining, $0.01$ for fine-tuning; note these are much larger than classic L2 values, another consequence of the rescaling.

Follow-up: If AdamW is strictly better, why does torch.optim.Adam still have a weight_decay argument? Because it implements the coupled L2 form, which is what the original Adam paper described and what a lot of older code depends on for reproducibility. Adam(weight_decay=0.01) and AdamW(weight_decay=0.01) do genuinely different things — a real source of silent discrepancies when porting a config between codebases.

Why the interviewer asks this. It looks like trivia but has a real mechanism behind it, and the answer reveals whether you have ever debugged why a regularisation setting did not behave as expected.

Saying it out loud. “For plain SGD, adding an L2 term to the loss and decaying the weights directly are the same operation. For Adam they aren’t, because the L2 term goes through the second-moment normalisation along with the real gradient. That means parameters with big gradient histories get their decay divided down and end up barely regularised, while quiet parameters get hammered — the opposite of what you want. AdamW just applies the decay straight to the weights after the adaptive step, so everything shrinks by the same proportion. It also decouples the two hyperparameters, so changing your learning rate stops secretly changing your regularisation.”

Regularization

Q20: Explain L1 vs L2 regularization.

In 30 seconds. “Both penalise the size of the weights, but the shape of the penalty changes the outcome. L2’s gradient is proportional to the weight, so as a weight gets small the pressure on it gets small too — it shrinks toward zero and never arrives. L1’s gradient is a constant lambda times the sign, so the push is just as strong at 0.001 as at 10; if the data’s pull is weaker than lambda, the weight is pinned at exactly zero. That’s why L1 selects features and L2 doesn’t.”

The short version.

Elastic Net: Combines both.

Why it works.

This is the part an interviewer will push on, and the cleanest explanation is about what happens near zero. Consider a single weight $w$ with data-fit gradient $g$ at the optimum of the unregularised loss.

Under L2, the penalty gradient is $2\lambda w$. As $w\to 0$ that gradient also $\to 0$, so the shrinkage force vanishes exactly where you would need it to be strongest. The weight settles wherever the data-fit gradient balances $2\lambda w$, which for any nonzero $g$ is a nonzero $w$.

Under L1, the penalty gradient is $\lambda \cdot \text{sign}(w)$, which has magnitude $\lambda$ no matter how small $w$ is. So there is a constant force pushing toward zero that does not weaken on approach. If the data-fit gradient at $w=0$ has magnitude less than $\lambda$, it cannot overcome that force and the weight is pinned at exactly zero.

The geometric picture, stated properly. The constraint region for L1 is a diamond (a cross-polytope) whose corners lie on the axes; for L2 it is a sphere with no corners. The solution is where the elliptical contours of the squared-error loss first touch the constraint region, and an ellipse touching a diamond will generically touch at a corner — a corner being exactly a point where some coordinates are zero. A sphere has no preferred points, so contact happens at a generic location with all coordinates nonzero. This picture and the soft-threshold formula below are two views of the same fact.

The math, and what it buys you.

Solve the one-dimensional case under L2 and you get proportional shrinkage: ${\hat{w}}_{\text{ridge}}={\hat{w}}_{\text{OLS}}/(1+\lambda )$ — everything scaled down by a constant factor, nothing set to zero. The closed form for L1 in the orthonormal case is the soft-threshold operator, and it states the sparsity result outright:

$${\hat{w}}_{\text{lasso}}=\text{sign}({\hat{w}}_{\text{OLS}})\cdot \max (|{\hat{w}}_{\text{OLS}}|-\lambda ,0)$$

which says it plainly: subtract $\lambda$ from the magnitude, and if that goes negative, clamp to zero.

A worked number. With $\lambda =0.5$ and OLS estimates $[3.0,0.4,-0.3]$: L1 gives $[2.5,0,0]$ — the two small coefficients are eliminated and the large one is shifted. L2 with the same $\lambda$ gives $[2.0,0.267,-0.2]$ — everything shrunk by a third, nothing removed. Same regularisation strength, completely different structure in the answer.

Good and bad.

• L1 — good: genuine feature selection and interpretable sparse models. Bad: not differentiable at zero, so plain gradient descent cannot land exactly on zero — solvers use coordinate descent, proximal gradient (ISTA/FISTA), or LARS; and it handles correlated features badly, picking one of two near-identical predictors essentially arbitrarily, unstably across resamples.
• L2 — good: smooth, closed-form, stable under correlated features, the default. Bad: never produces exact zeros, so it does no selection.
• Elastic net, ${\lambda }_1\Vert w{\Vert }_1+{\lambda }_2\Vert w{\Vert }_2^2$, exists specifically to keep sparsity while making correlated groups enter or leave together.

Follow-up: Should you regularise the intercept? No. The intercept is not a feature weight; shrinking it biases predictions toward zero output rather than toward a simpler function, and it makes the fit depend on where you happened to centre the target. Standard implementations exclude it — and for the same reason you should standardise features before regularising, since otherwise the penalty is applied in units that depend on arbitrary measurement scales.

Why the interviewer asks this. The “L1 gives sparsity” fact is universal knowledge; the constant-gradient-near-zero explanation is not, and it is a clean test of whether you think in terms of what the optimiser actually does.

Saying it out loud. “Both add a penalty on the size of the weights, but the shape of the penalty changes the outcome. L2’s gradient is proportional to the weight, so as a weight gets small the pressure on it gets small too — it shrinks toward zero and never arrives. L1’s gradient is a constant lambda times the sign, so the push toward zero is just as strong at 0.001 as at 10. If the data’s pull on that weight is weaker than lambda, it gets pinned at exactly zero. That’s why L1 does feature selection and L2 doesn’t. Geometrically it’s the diamond-versus-circle picture — the diamond has corners on the axes and the loss contours tend to hit a corner.”

Q21: How does dropout work?

In 30 seconds. “During training you randomly zero activations with probability p and scale the survivors up by 1/(1-p), so the expected value into the next layer is unchanged; at inference you do nothing at all. It helps because no unit can depend on a specific other unit being present — you don’t get fragile co-adapted feature groups. The old ‘use 0.5’ advice is out of date: transformers use about 0.1 and large-scale pretraining often uses none.”

The short version.

• Training: zero each activation with probability $p$; scale survivors by $1/(1-p)$. Prevents co-adaptation.
• Inference (inverted dropout, what frameworks implement): a no-op.
• Classic formulation: no scaling at training, multiply all activations by $(1-p)$ at test time. Equivalent in expectation.
• Why it works: prevents co-adaptation; forces robustness; acts as an ensemble of $2^n$ subnetworks.
• Rates (classic advice): input 0.1-0.2, hidden 0.5, output usually none. Modern practice: ~0.1 in transformers, often 0 in LLM pretraining.

Why it works.

Why it regularises, in three compatible framings. Co-adaptation: a unit cannot rely on a specific other unit being present, because that other unit vanishes half the time, so features must be individually useful rather than useful only in a fixed committee. Implicit ensembling: a network with $n$ droppable units defines $2^n$ subnetworks sharing weights; training samples one per minibatch and inference with the scaled weights approximates averaging over all of them, which is a very cheap ensemble. Noise injection: dropout is multiplicative Bernoulli noise on activations, and it can be shown that for a linear model with squared loss it reduces exactly to an L2 penalty scaled by each feature’s magnitude — an adaptive weight decay.

The two implementations, and which one you are using. Classic dropout zeroes activations with probability $p$ at training time and does nothing else, then at test time multiplies every activation by $(1-p)$ to match the expected value. Inverted dropout — what PyTorch, TensorFlow and everyone else actually implements — does the scaling at training time instead: zero with probability $p$, then divide the survivors by $(1-p)$. Test time is then a pure no-op, which is what you want, because inference should not need to know the training configuration. (The bullet list above states the classic form as well; note that in real frameworks the $1/(1-p)$ scaling happens during training and inference does nothing.)

The math, and what it buys you.

One line explains the mysterious $1/(1-p)$: if a unit has value $a$ and survives with probability $1-p$, then

$$\mathbb{E}[\text{output}]=(1-p)\cdot \frac{a}{1-p}+p\cdot 0=a$$

The expectation is preserved exactly, so the layers downstream see inputs with unchanged mean magnitude and do not have to be retuned between training and inference. That is the entire purpose of the factor.

Good and bad.

• Good: an extremely cheap ensemble; effective on small datasets and fully connected layers; no extra parameters.
• Bad — where the “0.5 for hidden layers” advice no longer holds. That rate comes from 2012-era fully connected vision networks. Convolutional layers use little or no dropout (spatial correlation means zeroing individual pixels removes little information — use DropBlock or SpatialDropout if you want it), and transformers use around 0.1 on attention weights and on the residual branches. Large-scale language model pretraining frequently uses dropout of 0 entirely, because with a corpus far larger than the parameter count the model is not in the overfitting regime and dropout just slows convergence; it comes back for fine-tuning on small datasets.
• Bad — a real interaction to know. Dropout and batch normalisation conflict. Dropout changes the variance of activations between training and inference, while batch norm has stored running statistics estimated under the training-time (noisy) distribution, so the two disagree at test time and accuracy drops. The usual resolutions are to put dropout only after all batch-norm layers, or to drop one of the two — which is part of why modern architectures with layer norm and heavy data augmentation often use very little dropout.

Follow-up: What is Monte Carlo dropout? Leave dropout on at inference and run the same input through several times, then look at the spread of the predictions. Gal and Ghahramani showed this approximates Bayesian inference in a deep Gaussian process, so the variance across runs is a usable uncertainty estimate. It is one of the cheapest ways to get calibrated uncertainty out of a network that was not designed for it — at the cost of several forward passes per prediction.

Why the interviewer asks this. The scaling factor is the detail that separates people who have read the paper from people who have used the API, and the “why 1/(1-p)” question has an exact answer.

Saying it out loud. “During training you randomly zero out activations with probability p, and you scale the survivors up by one over one minus p so the expected value going into the next layer doesn’t change. Then at inference you do nothing at all — that’s inverted dropout, which is what every framework actually implements. The reason it helps is that no unit can depend on any specific other unit being there, so you don’t get fragile co-adapted groups of features; another way to say it is that you’re training an exponential ensemble of subnetworks that share weights. The old advice of 0.5 is out of date though — transformers use about 0.1, and large-scale pretraining often uses none at all.”

Bias & Variance

Q22: Explain bias-variance tradeoff.

In 30 seconds. “Squared test error splits into bias squared, variance, and irreducible noise. Bias is how far the average model over all possible training sets is from the truth — the model class being too rigid. Variance is how much your particular fit moves when you resample the data. I care because it’s a diagnosis: high training error means bias and more data won’t help; low training error with a big test gap means variance, and data or regularisation will.”

The short version.

• Irreducible error is label noise; no model removes it, which is why 100% accuracy is usually not the target.
• Goal: find the balance where the sum of the two controllable terms is minimised.

Why it works.

Read the decomposition’s terms carefully, because the definitions matter. Bias is how far the average model — averaged over training sets you might have drawn — is from the truth; it is a property of the model class, not of any one fit. Variance is how much a particular fit bounces around that average when the training set changes. Irreducible error ${\sigma }^2$ is label noise. The reason there is a tradeoff at all is that the two controllable terms respond in opposite directions to model flexibility: more capacity lets the average fit track the truth (bias down) but also lets each individual fit chase the noise in its particular sample (variance up).

Making it concrete. Fit polynomials to points from a sine curve plus noise. Degree 1: every training set gives roughly the same straight line, so variance is tiny, but no line is close to a sine, so bias is large. Degree 15: each training set gives a wildly different wiggly curve that passes through its own points exactly, so bias is near zero and variance is enormous. Degree 3-4 is where the sum is minimised.

How the standard fixes map onto the terms. More training data reduces variance and does nothing to bias — which is why adding data does not fix an underfitting model. Regularisation adds bias deliberately to buy a larger reduction in variance. Bagging (random forests) averages many high-variance, low-bias trees, and because averaging $B$ roughly-independent estimators divides variance by up to $B$ while leaving bias unchanged, it attacks variance specifically; feature subsampling exists to decorrelate the trees so that division is closer to real. Boosting works the other way: it fits shallow, high-bias stumps sequentially, each correcting the previous residuals, so it reduces bias — which is why boosted models can overfit with too many rounds while random forests largely do not.

The math, and what it buys you.

The whole discussion rests on one exact identity. For squared error, the expected test error at a point $x$ — expectation taken over random draws of the training set — decomposes into three terms:

$$\mathbb{E}\left[(y-\hat{f}(x){)}^2\right]=\underset{{\text{bias}}^2}{\underbrace{{\left(\mathbb{E}[\hat{f}(x)]-f(x)\right)}^2}}+\underset{\text{variance}}{\underbrace{\mathbb{E}\left[{\left(\hat{f}(x)-\mathbb{E}[\hat{f}(x)]\right)}^2\right]}}+\underset{\text{irreducible}}{\underbrace{{\sigma }^2}}$$

What it buys you is the diagnosis: because the terms are separate and additive, each of your training numbers points at exactly one of them.

Good and bad.

• The framework is good for: deciding what to do next from two error numbers, and for explaining why bagging and boosting are different tools.
• One honest caveat worth raising. The classical U-shaped curve is not the whole story for modern overparameterised networks. Past the interpolation threshold — where the model has enough capacity to fit the training data exactly — test error can decrease again with further capacity, a phenomenon called double descent, observed in both model size and training time. So “more parameters means more variance” is a reliable rule for classical models and an unreliable one for large neural networks, where implicit regularisation from the optimiser changes the picture.

Follow-up: You have 8% training error and 10% test error, and human performance is 1%. What do you do? The gap is only 2 points, so variance is not the problem; the 7-point gap between human performance and training error is bias. Adding data or regularising will not help. Increase capacity, train longer, engineer better features, or check whether the input actually contains the information needed. The diagnostic move is always to compare training error against an irreducible-error estimate first, and only then look at the train-test gap.

Why the interviewer asks this. It is really a debugging question in disguise — they want to know whether, shown two error numbers, you would reach for the right fix.

Saying it out loud. “If you decompose squared test error, it splits into bias squared, variance, and irreducible noise. Bias is how far the average model over all possible training sets is from the truth — that’s about the model class being too rigid. Variance is how much your particular fit moves around when you resample the data. Simple models are stable but wrong; complex ones fit their own sample beautifully and don’t generalise. The reason I care is diagnosis: if training error is already high, that’s bias, and more data won’t help — I need capacity. If training error is low and test error is much higher, that’s variance, and data or regularisation will help.”

Information Theory

Q23: Explain entropy. What does it measure?

In 30 seconds. “Entropy is the expected surprise of a distribution — surprise being minus log p, which is the only form that makes independent events add. The concrete meaning is compression: entropy in bits is the smallest average number of bits per symbol you can encode the source in. A fair coin is one bit and you can’t do better; a ninety-ten coin is under half a bit because you can exploit the skew.”

The short version.

• Formula: $H(X)=-\sum p(x){\log }_{2}p(x)$ — the expected surprisal.
• High entropy = high uncertainty (uniform); low entropy = concentrated; zero = deterministic.
• Fair coin: $H=1$ bit. Biased 90/10 coin: $H\approx 0.47$ bits. Deterministic: $H=0$.
• Bounds: $0\le H(X)\le \log n$ for $n$ outcomes, using the convention $0\log 0=0$.
• Uses: decision trees (information gain), compression (a lower bound on code length), feature selection.

Why it works.

Where the formula comes from. Entropy is not an arbitrary functional; it is forced by requiring that a measure of information be additive over independent events. The information content, or surprisal, of an outcome with probability $p$ is $-\log p$: it is zero for a certain event, grows as the event gets rarer, and — critically — the surprisal of two independent events is $-\log (p_1{p}_2)=-\log p_1-\log p_2$, so it adds. Only the logarithm turns multiplication of probabilities into addition. Entropy is then just the expected surprisal, $H(X)=\mathbb{E}[-\log p(X)]$, which is what the formula says.

The operational meaning is the one to give in an interview. Shannon’s source coding theorem says $H(X)$ in bits is the minimum average number of bits per symbol needed to encode messages from $X$ — no scheme does better, and schemes exist that get arbitrarily close. So entropy is not a metaphor for uncertainty; it is a compression bound.

Units. The base of the logarithm is only a unit choice: base 2 gives bits, base $e$ gives nats. Machine learning code uses nats because $\log$ is the natural log; multiply by ${\log }_{2}e\approx 1.443$ to convert.

The math, and what it buys you.

Running the biased coin gives the compression claim a number: $H=-0.9{\log }_{2}0.9-0.1{\log }_{2}0.1=0.137+0.332=0.469$ bits — meaning a long sequence of such flips can be compressed to under half a bit per flip, which run-length encoding does in practice. The fair coin gives exactly 1 bit, and no scheme beats it.

The connection to language models. Perplexity, the standard LM metric, is exactly $2^H$ (or $e^H$ in nats) where $H$ is the cross-entropy per token. It is interpretable as an effective vocabulary size: a perplexity of 20 means the model is, on average, as uncertain as if it were choosing uniformly among 20 tokens. This is why perplexity 10 versus 20 is a much bigger improvement than the numbers suggest — it is one full bit of information per token.

Follow-up: Why is entropy used for decision-tree splits? A split is scored by information gain, $H(\text{parent})-{\sum }_k\frac{n_k}{n}H({\text{child}}_k)$: how much uncertainty about the label the split removes. It is always non-negative (conditioning cannot increase entropy on average), and it is zero exactly when the feature is independent of the label. Note the known failure mode: raw information gain favours high-cardinality features, since splitting on a unique ID gives pure children and maximal gain while generalising not at all — which is why C4.5 uses gain ratio, normalising by the entropy of the split itself.

Why the interviewer asks this. They usually want the compression interpretation, because it is the one that shows you understand entropy as a quantity with units rather than a vague synonym for disorder.

Saying it out loud. “Entropy is the expected surprise of a distribution — surprise being minus log p, which is the only form that makes independent events add up. The concrete meaning is compression: entropy in bits is the smallest average number of bits per symbol you can encode the source in. A fair coin is one bit and you can’t do better; a ninety-ten coin is under half a bit because you can exploit the skew. It’s maximised by the uniform distribution and zero when one outcome is certain. In language modelling it’s the same quantity — perplexity is just two to the entropy, so you can read it as an effective vocabulary size.”

Q24: What is cross-entropy? Why is it used as a loss function?

In 30 seconds. “Cross-entropy is the expected number of bits you pay to encode data from P using a code built for Q, and it exceeds the true entropy by exactly the KL divergence — so minimising it is minimising KL from the data to your model. It’s also just the negative log-likelihood, and it’s a proper scoring rule, meaning you minimise it by reporting honest probabilities rather than by being overconfident.”

The short version.

• Formula: $H(P,Q)=-\sum p(x)\log q(x)$.
• Penalises confident wrong predictions: $-\log (0.1)=3.32$ — a large penalty, unbounded as $q\to 0$.
• Encourages calibrated probabilities: it is a strictly proper scoring rule.
• Always $\ge$ entropy: $H(P,Q)\ge H(P)$, with equality only when $Q=P$. The gap is the KL divergence.
• Smooth gradients, and the same object as negative log-likelihood.
• Uses: classification (the default loss), language modelling, any probabilistic prediction.

Why it works.

Three derivations arrive at the same loss, which is the real reason to trust it.

From coding. $H(P,Q)=-{\sum }_{x}p(x)\log q(x)$ is the average number of bits used if you build an optimal code for $Q$ but the data actually comes from $P$. It exceeds the true entropy $H(P)$ by exactly $D_{KL}(P\parallel Q)$ — the wasted bits from being wrong. Since $H(P)$ is fixed by the data, minimising cross-entropy is identical to minimising KL divergence from the true distribution to the model. That is the cleanest statement of what training a classifier does.

From maximum likelihood. The probability the model assigns to the whole dataset is ${\prod }_{i}q(y_i\mid x_i)$. Taking logs turns the product into a sum, and negating turns maximisation into minimisation: $-{\sum }_i\log q(y_i\mid x_i)$. With one-hot labels this is exactly the cross-entropy. So cross-entropy loss is not a heuristic scoring function — it is the negative log-likelihood, and every guarantee that maximum likelihood carries comes with it.

From calibration. Cross-entropy is a strictly proper scoring rule, meaning its expected value is uniquely minimised when the model reports its true beliefs. If the real probability of the positive class is 0.7 and you report 0.9 to look decisive, your expected loss goes up. Accuracy is not proper — reporting 0.99 and reporting 0.51 score identically — which is precisely why you train on cross-entropy and only report accuracy.

The math, and what it buys you.

Worked numbers on the “penalises confident wrong predictions” claim. With the true label being class 1: predicting $q=0.9$ costs $-\log 0.9=0.105$ nats; $q=0.5$ costs $0.693$; $q=0.1$ costs $2.303$; $q=0.01$ costs $4.605$. The loss grows without bound as $q\to 0$, so a single confidently wrong prediction can dominate a whole batch. That unboundedness is a feature during training — it produces the large gradient that fixes the mistake — but it is also why numerically you must never compute $\log (\text{softmax}(z))$ separately (a rounded-to-zero probability gives $-\infty$) and instead use the fused log_softmax / cross_entropy op, which subtracts the max logit before exponentiating.

Good and bad.

• Good: identical to maximum likelihood, so it inherits its guarantees; proper, so it produces calibrated probabilities; and its gradient scales with how wrong you are.
• Bad: unbounded, so a single mislabelled example can dominate a batch; numerically dangerous unless fused with the softmax; and dominated by the majority class under imbalance.

Follow-up: What if the classes are heavily imbalanced? Plain cross-entropy is dominated by the majority class simply because there are more of its terms. Class weighting multiplies each term by $w_c$ (often inversely proportional to class frequency) to rebalance. Focal loss goes further and multiplies by $(1-q_y{)}^{\gamma }$, which shrinks the contribution of already-well-classified examples so training focuses on the hard ones — it was designed for dense object detection where the background class outnumbers objects by a thousand to one. Both keep the log-likelihood structure and just reweight it.

Why the interviewer asks this. The good answer connects cross-entropy to KL divergence and to maximum likelihood, showing you see one object rather than three unrelated formulas.

Saying it out loud. “Cross-entropy is the expected number of bits you pay for encoding data from P using a code built for Q, and it beats the true entropy by exactly the KL divergence — so minimising it is minimising KL from the data distribution to your model. It’s also just the negative log-likelihood, so you get all the maximum-likelihood guarantees for free. And it’s a proper scoring rule, which means you minimise it by reporting your honest probabilities, not by being overconfident. The practical property is that the loss goes to infinity as your predicted probability for the true class goes to zero, so confidently wrong predictions produce big corrective gradients.”

Q25: Explain KL divergence. Why is it asymmetric?

In 30 seconds. “KL is an expectation under its first argument, and that single fact is the whole reason it’s asymmetric. Forward KL only looks where P has mass and blows up if your model puts near-zero probability there — so it’s mass-covering, and that’s what maximum likelihood minimises. Reverse KL punishes putting mass where P has none but happily ignores a whole mode — mode-seeking, which is what variational inference uses, and why VI underestimates posterior variance.”

The short version.

Properties:

• $KL(P\parallel Q)\ge 0$, and $=0$ if and only if $P=Q$.
• Not a metric — it fails the triangle inequality, and it is not symmetric.
• Uses: RLHF KL penalty, VAEs (posterior vs prior), model comparison, regularisation.

Why it works.

The formula $D_{KL}(P\parallel Q)={\sum }_{x}p(x)\log \frac{p(x)}{q(x)}$ is an expectation under $P$. That single fact drives everything. Only the regions where $p(x)$ is large contribute; regions where $p(x)=0$ contribute nothing no matter what $Q$ does there. And if $q(x)\to 0$ where $p(x)>0$, the log blows up and the divergence goes to infinity. In one sentence: $D_{KL}(P\parallel Q)$ punishes $Q$ for failing to cover $P$, and is indifferent to $Q$ putting mass where $P$ has none.

Now fit a single Gaussian $Q$ to a bimodal $P$ and the two directions give visibly different answers:

• Forward KL, $D_{KL}(P\parallel Q)$ — mass-covering / zero-avoiding. $Q$ must be nonzero everywhere $P$ is, or it takes an infinite penalty. So the fitted Gaussian stretches wide to span both modes, placing most of its mass in the empty valley between them. This is the direction minimised by maximum likelihood, which is why a maximum-likelihood language model will assign some probability to almost everything.
• Reverse KL, $D_{KL}(Q\parallel P)$ — mode-seeking / zero-forcing. Now the expectation is under $Q$, so $Q$ is punished for putting mass where $P$ is small, but not for ignoring a mode entirely. The fitted Gaussian collapses onto one mode and abandons the other. This is the direction in the VAE’s ELBO and in variational inference generally, and it is the standard explanation for posterior-variance underestimation in VI and for mode collapse in some distillation setups.

The math, and what it buys you.

A numeric example that makes the asymmetry undeniable. Let $P=[0.5,0.5,0]$ and $Q=[0.9,0.05,0.05]$ over three outcomes. Forward: $0.5\log (0.5/0.9)+0.5\log (0.5/0.05)+0=-0.294+1.151=0.857$ nats. Reverse: $0.9\log (0.9/0.5)+0.05\log (0.05/0.5)+0.05\log (0.05/0)=\infty$, because $Q$ puts mass on an outcome $P$ rules out. Same pair of distributions, radically different numbers — which is also a concrete demonstration that KL is not a distance and cannot be used where symmetry is assumed.

Why it is non-negative. By Jensen’s inequality applied to the convex function $-\log$: $-\sum p\log (q/p)\ge -\log \sum p\cdot (q/p)=-\log \sum q=-\log 1=0$, with equality only when $q=p$ everywhere. This result is Gibbs’ inequality, and it is what guarantees cross-entropy is always at least entropy.

Follow-up: If KL is infinite whenever supports mismatch, how is it used in practice? By construction, mostly. In RLHF the reference and policy are the same architecture over the same vocabulary with softmax outputs, so every token has nonzero probability under both and KL is finite. In VAEs both terms are Gaussians with full support and the KL has a closed form. Where support genuinely mismatches — comparing empirical samples from a generator against real data, the original GAN setting — KL and JS both become useless (constant or infinite, giving no gradient), which is exactly the motivation for the Wasserstein distance, which stays finite and differentiable for disjoint supports.

Why the interviewer asks this. “It’s asymmetric” is the memorised answer; the follow-up is always “so what?”, and mode-seeking versus mass-covering is the answer that shows you know when the choice of direction changes your model’s behaviour.

Saying it out loud. “KL is an expectation under the first argument, and that’s the whole reason it’s asymmetric. Forward KL, P given Q, only looks at places where P has mass, and it goes to infinity if your model puts near-zero probability there — so it’s mass-covering, it forces your model to spread out and cover everything. That’s what maximum likelihood minimises. Reverse KL is the opposite: it punishes you for putting mass where P doesn’t have any, but it’s perfectly happy to ignore a whole mode. So it’s mode-seeking, and that’s what variational inference uses — which is exactly why VI tends to underestimate posterior variance.”

Q26: What is mutual information? How is it used in feature selection?

In 30 seconds. “Mutual information is how much knowing one variable reduces your uncertainty about the other — equivalently, the KL divergence between the true joint and the product of the marginals, so it literally measures distance from independence. People reach for it over correlation because correlation only sees linear structure: if Y is X squared with X centred at zero, correlation is exactly zero and MI is maximal.”

The short version.

• Formula: $I(X;Y)=H(X)+H(Y)-H(X,Y)$.
• $I=0$ means independent; $I>0$ means dependent; $I(X;Y)=H(X)$ means $Y$ determines $X$.
• Feature selection: compute $I(X_i;Y)$ per feature, keep the high ones.
• Why: captures non-linear relationships (unlike correlation), removes irrelevant features ($I\approx 0$), has an information-theoretic foundation.
• Two failure modes: the plug-in estimator is biased upward with many bins, and ranking features one at a time misses interactions.

Why it works.

Three equivalent readings of the same quantity. $I(X;Y)=H(X)-H(X\mid Y)=H(Y)-H(Y\mid X)=H(X)+H(Y)-H(X,Y)$. The first says “how much does knowing $Y$ reduce my uncertainty about $X$”; the second is the same statement with the roles swapped, which is why MI is symmetric; the third is the inclusion-exclusion form given above. A fourth reading is the most useful theoretically: $I(X;Y)=D_{KL}(P(X,Y)\parallel P(X)P(Y))$ — mutual information is the KL divergence between the true joint and the joint you would have if they were independent. That immediately gives you $I\ge 0$ (KL is non-negative) and $I=0$ exactly under independence.

One correction to the note above. The line “$I(X;Y)=H(X)$: X completely determines Y” has it backwards. $I(X;Y)=H(X)$ means $H(X\mid Y)=0$, i.e. knowing $Y$ leaves no uncertainty about $X$ — so $Y$ determines $X$. In general $I(X;Y)\le \min (H(X),H(Y))$, and it equals $H(X)$ precisely when $X$ is a deterministic function of $Y$.

The math, and what it buys you.

Worked example against correlation — the one to have ready. Let $X$ be uniform on $[-1,1]$ and $Y=X^2$. Pearson correlation is exactly 0 — the relationship is symmetric about zero, so the linear term cancels — yet $Y$ is a deterministic function of $X$, so $I(X;Y)=H(Y)>0$, in fact maximal for that pair. A correlation-based filter discards this feature; a mutual-information filter keeps it. This makes “captures non-linear relationships” concrete instead of asserted.

How it is actually estimated, and why that matters. For discrete variables you count joint and marginal frequencies and plug in — but the plug-in estimator is biased upward, and the bias grows with the number of bins relative to the sample size. In the limit, a feature with as many distinct values as there are samples gets maximal apparent MI while carrying no signal at all, which is the same high-cardinality trap that afflicts decision-tree information gain. For continuous variables, binning is crude and bin-width-sensitive; the standard alternative is the Kraskov (KSG) $k$-nearest-neighbour estimator, which is what sklearn.feature_selection.mutual_info_regression uses. Normalised variants — dividing by $\min (H(X),H(Y))$ or by $\sqrt{H(X)H(Y)}$, or the adjusted mutual information — put values on a comparable $[0,1]$ scale and partially correct the cardinality bias.

Good and bad.

• Good: model-agnostic, cheap as a first-pass filter over thousands of candidate features, sensitive to any dependence rather than only linear ones, and invariant to monotone reparameterisation.
• Bad — the real limitation of MI feature selection. Ranking features by individual $I(X_i;Y)$ is a univariate filter: it evaluates each feature in isolation. That misses both directions of interaction. It keeps redundant features — ten copies of the same predictor all score high and all get selected. And it discards features that are only useful jointly: in an XOR relationship, $I(X_1;Y)=I(X_2;Y)=0$ while $I(X_1,X_2;Y)$ is maximal, so a univariate filter throws away both of the only useful features. The fix is a criterion that accounts for the already-selected set, such as mMRM (maximum relevance, minimum redundancy), which selects to maximise $I(X_i;Y)-\frac{1}{|S|}{\sum }_{j\in S}I(X_i;X_j)$.
• Bad: upward estimation bias with high-cardinality features.

Follow-up: When would you use MI over a model-based importance measure? When you want something model-agnostic and cheap as a first-pass filter over thousands of candidate features, or when you need a dependence measure that is invariant to monotone reparameterisation of the features. When you can afford it, wrapper or embedded methods — permutation importance, L1 paths, tree-based importances — usually select better because they account for feature interactions and for the specific model you intend to deploy.

Why the interviewer asks this. They want to see whether you know MI’s failure modes — estimation bias and the univariate blind spot — not just that it beats correlation on nonlinear data.

Saying it out loud. “Mutual information is how much knowing one variable reduces your uncertainty about the other. My favourite way to state it is that it’s the KL divergence between the true joint distribution and the product of the marginals — so it’s literally measuring how far the two are from independent. The reason people reach for it over correlation is that correlation only sees linear structure: if Y equals X squared with X centred at zero, correlation is exactly zero but mutual information is maximal. The catch is that estimating it is biased upward with lots of bins, and ranking features one at a time misses interactions — an XOR pair scores zero individually and everything jointly.”

Q27: Compare Gini impurity and entropy. When would you use each?

In 30 seconds. “They’re measuring the same thing and they’re almost the same curve — Taylor-expand entropy around a half and you get the Gini form back. Both are zero on a pure node, maximal when the classes are balanced, and they pick the same split the overwhelming majority of the time. If someone’s tuning Gini versus entropy they’re on the wrong knob: depth, minimum leaf size and high-cardinality bias matter far more.”

The short version.

Why it works.

Why they behave alike — they are the same curve to first order. Both are concave functions of the class proportions, both are zero for a pure node and maximal at the uniform distribution, and both reward splits that produce purer children. At $p=0.5$ Gini peaks at 0.5 and entropy at 1.0; halve the entropy and the two curves agree to within about 0.03 everywhere on $[0,1]$. In fact the first two terms of the Taylor expansion of entropy about $p=0.5$ give exactly the Gini form, which is the formal reason “results are usually very similar” — they are not similar by coincidence.

The one real difference. Entropy’s $-\log p$ term goes to infinity as $p\to 0$, so entropy is steeper near the pure ends of the range, which makes it slightly more willing to isolate a small pure subgroup. Gini, being quadratic, is flatter there and has a mild preference for splits that produce one large, mostly-pure child — it can be shown to favour balanced, high-purity partitions. In practice this is a second-order effect. The speed argument for Gini (no logarithm) was material in the 1980s and is largely irrelevant now that logs are a single instruction and split search is dominated by sorting.

The math, and what it buys you.

A worked comparison, showing the two criteria agree. A node with 80 positives and 20 negatives has Gini $=1-(0.8^2+0.2^2)=0.32$ and entropy $=0.722$ bits. Split it into a pure child of 60 positives and an impure child of 20 positives / 20 negatives. Weighted Gini afterwards is $0.6\times 0+0.4\times 0.5=0.20$, a reduction of 0.12. Weighted entropy is $0.6\times 0+0.4\times 1.0=0.40$, a reduction of 0.322 bits. Different units, same ranking — and that is the general pattern: published comparisons find the two criteria disagree on the chosen split in only a small minority of cases, and the resulting trees differ in accuracy by amounts well inside cross-validation noise.

Good and bad.

• Gini — good: cheap, the CART default, mildly favours balanced high-purity partitions. Entropy — good: an information-theoretic reading (information gain), slightly better at peeling off small pure groups.
• Bad, for both — what matters far more. Neither criterion addresses the actual failure mode of impurity-based splitting: bias toward high-cardinality features. A feature with many distinct values can carve out pure children by memorising, so it wins on both Gini and entropy while generalising not at all. C4.5’s gain ratio normalises information gain by the entropy of the split itself; CART restricts to binary splits, which limits the damage. If you are choosing between Gini and entropy you are tuning a knob that barely moves; if you are ignoring cardinality bias, tree depth, minimum leaf size, and the number of trees, you are ignoring the knobs that do.

Follow-up: What about regression trees? Impurity is replaced by variance (equivalently, mean squared error within the node): score a split by the weighted reduction in variance of the target. Mean absolute error is the robust alternative when outliers matter, at the cost of being slower to compute since the optimal constant becomes the median rather than the mean. Gradient boosting generalises this further by fitting each tree to the gradient of an arbitrary differentiable loss, so the splitting criterion is derived from the loss rather than fixed.

Why the interviewer asks this. Often to see whether you will claim a meaningful difference where there is not one — the strong answer is that they are nearly the same function and the real hyperparameters are elsewhere.

Saying it out loud. “They’re measuring the same thing and they’re almost the same curve — if you Taylor-expand entropy around a half you get the Gini form back. Both are zero on a pure node and maximal when the classes are balanced, and in practice they pick the same split the overwhelming majority of the time. Entropy is a bit steeper near purity so it’s slightly keener to peel off a small clean group; Gini is a bit cheaper because there’s no logarithm, though that hardly matters now. Honestly, if someone’s tuning Gini versus entropy they’re spending effort on the wrong knob — depth, minimum leaf size and high-cardinality bias matter far more.”

Q28: What is Jensen-Shannon divergence? How does it differ from KL?

In 30 seconds. “JS is the symmetrised KL: build the midpoint mixture of the two distributions and average the KL from each one to that midpoint. The mixture has mass wherever either distribution does, so you never divide by zero and the value is capped at log 2 — where KL between disjoint distributions is just infinity. The catch is that same cap: if two distributions barely overlap, JS pins at its maximum and the gradient goes flat, which is the standard story for why GANs were hard to train.”

The short version.

Definition: $JS(P\parallel Q)=0.5KL(P\parallel M)+0.5KL(Q\parallel M)$, where $M=0.5(P+Q)$.

One precision fix on the standard claims. JS divergence itself is bounded by $\log 2$ (that is 1 when measured in bits, $0.693$ in nats) and is not a metric — it fails the triangle inequality. What is a true metric is its square root, $\sqrt{JS}$, sometimes called the Jensen-Shannon distance; that is the quantity scipy.spatial.distance.jensenshannon returns. So the table should read: bounded by $\log 2$, and metric after taking the square root.

Why it works.

Why the mixture fixes KL’s blowup. The failure mode of KL is that $D_{KL}(P\parallel Q)=\infty$ whenever $Q$ assigns zero probability somewhere $P$ does not. JS compares each distribution not to the other but to the midpoint $M=\frac{1}{2}(P+Q)$, and $M$ is nonzero wherever either is nonzero. So the ratio $p/m$ can never exceed 2, the log never exceeds $\log 2$, and the whole quantity stays finite even for completely disjoint supports. Take the extreme case: $P$ and $Q$ with no overlap at all. Then wherever $p>0$ we have $m=p/2$, so $D_{KL}(P\parallel M)=\sum p\log 2=\log 2$, and likewise for $Q$, giving $JS=\log 2$ — the maximum. Contrast $D_{KL}(P\parallel Q)=\infty$ for the same pair.

The math, and what it buys you.

A worked example. With $P=[0.5,0.5,0]$ and $Q=[0,0.5,0.5]$: $M=[0.25,0.5,0.25]$. Then $D_{KL}(P\parallel M)=0.5\log 2+0.5\log 1=0.347$ nats and by symmetry $D_{KL}(Q\parallel M)=0.347$, so $JS=0.347$ nats (0.5 bits) — a finite, interpretable number, where forward KL between $P$ and $Q$ is infinite in both directions. That finiteness is what JS buys you.

The GAN connection, and its punchline. Goodfellow’s original analysis showed that with an optimal discriminator, the generator’s objective reduces to minimising $2JS(P_{\text{data}}\parallel P_{\text{gen}})-\log 4$. That looks like good news until you notice the consequence of the boundedness argument above: early in training the generator’s output distribution and the real data distribution lie on nearly disjoint low-dimensional manifolds, so JS sits pinned at its maximum $\log 2$ and its gradient is essentially zero. The generator gets no useful signal — this is the vanishing-gradient explanation for GAN training instability. Wasserstein GAN replaced JS with the earth-mover distance precisely because it varies smoothly with how far apart two disjoint distributions are, rather than saturating.

Good and bad.

• JS — good: symmetric, always finite, bounded, interpretable, and stable when the two distributions are very different in shape.
• JS — bad: saturates on nearly disjoint supports, so it provides no gradient exactly when you most need one; and it throws away the directional information that makes KL useful.
• KL — good: the direction is the modelling choice (mass-covering vs mode-seeking), and it has closed forms in the Gaussian cases you meet in practice. Bad: infinite on support mismatch.

Follow-up: When would you still prefer KL? Whenever the asymmetry is the point. Maximum-likelihood training is forward KL and you want its mass-covering behaviour; variational inference is reverse KL and you want its mode-seeking behaviour; the RLHF penalty is one-directional because “how far has the policy moved from the reference” is inherently a directed question. Reach for JS when you need a symmetric, bounded comparison — measuring drift between two data distributions in monitoring, comparing two clusterings, or any case where you would otherwise be embarrassed to report a value of infinity.

Why the interviewer asks this. Usually to get to the GAN story: knowing that JS saturates on disjoint supports, and that this is why WGAN exists, is what the question is really reaching for.

Saying it out loud. “JS is the symmetrised version of KL — you build the midpoint mixture of the two distributions and average the KL from each one to that midpoint. The reason that helps is that the mixture has mass wherever either distribution does, so you can never divide by zero and the value is capped at log 2. KL between disjoint distributions is just infinity, which is useless. The catch is that capped behaviour: if two distributions barely overlap, JS is pinned at its maximum and the gradient is flat. That’s the standard explanation for why GANs were so hard to train and why Wasserstein distance replaced it.”

See 33_information_theory/interview_qa.md for even more detailed answers!

Discriminative vs Generative Models

Q29: Explain the difference between discriminative and generative models.

In 30 seconds. “A discriminative model learns the conditional — given the input, what’s the label — so it only models what separates the classes. A generative model learns the joint, which means it has to describe what the data itself looks like. That’s strictly more work, so with limited data the generative model’s assumptions act as a prior and it wins; with plenty of data the discriminative model wins because it isn’t spending capacity on the input distribution.”

The short version.

When to use:

• Discriminative: When you only need predictions, have limited data.
• Generative: When you need to generate data, have missing data, or want to understand the distribution.

Why it works.

The real dividing line is what the model spends its capacity on. A discriminative model only ever has to answer “given this input, which label?”, so it can ignore everything about the input that does not separate classes. A generative model has to account for the input itself — $P(X\mid Y)$ requires describing what the data looks like — which is strictly more information and usually a much harder estimation problem.

The math, and what it buys you.

The canonical worked contrast: naive Bayes versus logistic regression. These two are a generative-discriminative pair: with the same features and a matched parametric form, they define the same hypothesis class of linear decision boundaries but fit it differently. Naive Bayes estimates $P(X\mid Y)$ and $P(Y)$ by counting, assuming features are conditionally independent given the label, then applies Bayes’ rule. Logistic regression parameterises $P(Y\mid X)$ directly and maximises conditional likelihood. Ng and Jordan’s result on this pair is the fact worth citing: naive Bayes converges to its (higher) asymptotic error much faster — in $O(\log d)$ samples versus $O(d)$ for logistic regression — so the generative model wins on small data and the discriminative model wins once there is enough data, with a crossover point. That is the mechanism behind the “data efficiency” row in the table, and it is more useful than the row itself: the generative model’s assumptions act as a strong prior, which helps when data is scarce and hurts when the assumptions are wrong and data is plentiful.

Good and bad.

• Discriminative — good: spends all capacity on the decision boundary; better asymptotic accuracy; simpler estimation. Bad: cannot sample, cannot marginalise over missing features, and will confidently classify pure noise.
• Generative — good: can generate, can marginalise, gives you $P(X)$ so anomaly detection is a quantity it can report; strong prior helps in low-data regimes. Bad: must model the input distribution, which is harder and wastes capacity if the assumptions are wrong.

A caution about modern usage. The table’s “generative models are more complex” is a statement about classical estimation, and today’s usage of the word has drifted. A modern autoregressive language model is generative in the strict sense — it models $P(X)$, factorised as ${\prod }_{t}P(x_t\mid x_{<t})$ — and it is spectacularly effective, not handicapped. What changed is that modelling $P(X)$ over text turned out to be a rich enough task that solving it produces general capability, and that conditioning ($P(\text{answer}\mid \text{question})$) can be obtained from the same model by prompting. So “generative is less data efficient for classification” is still true when comparing matched pairs on a fixed task, and simultaneously the most capable classifiers available today are generative models used zero-shot. Both are true; they are answers to different questions.

Follow-up: Which family handles missing features better, and why? Generative. Because it models the joint, a missing feature can be marginalised out — integrate $P(X,Y)$ over the unobserved variable and carry on with a properly normalised answer. A discriminative model has no distribution over $X$ to integrate against, so it must impute the missing value first and then hope the imputation error does not move the decision boundary. Anomaly detection is the same argument: a generative model gives you $P(X)$ directly, so “this input is unlike anything I was trained on” is a quantity it can report, whereas a discriminative model will confidently assign a class to pure noise.

Why the interviewer asks this. It is a check on whether you can name a consequence of the distinction — data efficiency, missing values, anomaly detection — rather than only restating the two formulas.

Saying it out loud. “A discriminative model learns the conditional — given the input, what’s the label — so it only has to model what separates the classes. A generative model learns the joint, which means it has to describe what the data itself looks like. That’s strictly more work, so with limited data the generative model’s assumptions act as a prior and it does better, but once you have plenty of data the discriminative model wins because it isn’t wasting capacity on the input distribution. Naive Bayes versus logistic regression is the classic pair. The nice side effect of going generative is that you can sample, marginalise over missing features, and score how unusual an input is.”

Q30: What are the assumptions of linear regression?

In 30 seconds. “I’d group them by what they protect. Linearity and errors uncorrelated with the predictors are what make the coefficients unbiased — if those fail, more data won’t save you. Homoscedasticity and independence don’t bias the coefficients, they bias your standard errors. Normality only matters for small-sample inference. And multicollinearity isn’t really a model assumption at all — it doesn’t hurt prediction, it just makes individual coefficients unstable.”

The short version.

What happens if violated: poor predictions, wrong standard errors, unreliable tests. See 34_discriminative_generative/model_assumptions_detailed.md for detailed explanations.

Why it works.

The five assumptions are not equally important, and they do not all protect the same thing. Split them:

Needed for the coefficient estimates to be unbiased: linearity and exogeneity (errors uncorrelated with the predictors). If these fail, $\hat{\beta }$ is estimating the wrong thing and no amount of data fixes it. This is the serious one — omitted variable bias lives here.

Needed for the standard errors, p-values and confidence intervals to be correct: homoscedasticity and independence of errors. If these fail, $\hat{\beta }$ is still unbiased, but your uncertainty estimates are wrong — typically too small, so you declare significance that is not there. The fix is often not to change the model but to change the variance estimator: heteroscedasticity-consistent (Huber-White, HC3) standard errors, or clustered standard errors for grouped data.

Needed only for exact small-sample inference: normality of errors. By the central limit theorem the sampling distribution of $\hat{\beta }$ is approximately normal for large $n$ regardless of the error distribution, so this assumption fades as $n$ grows. Note also what it is not: nothing requires $X$ or $y$ to be normally distributed — only the residuals, and only for inference.

Not an assumption of the model at all: no multicollinearity. Perfect collinearity makes $X^{\top }X$ singular so the solution is not unique; severe-but-imperfect collinearity leaves predictions and $R^2$ completely fine and only inflates the variance of individual coefficients. So if you care about prediction, collinearity is close to a non-issue; if you care about interpreting a specific coefficient, it is fatal.

Why residual plots are the single most useful diagnostic. Plot residuals against fitted values and you can see three assumptions at once: curvature indicates a linearity violation, a funnel shape indicates heteroscedasticity, and clusters or drift indicate dependence. It is worth remembering Anscombe’s quartet here — four datasets with identical means, variances, correlations and regression lines but completely different structure, visible instantly in a plot and invisible in the summary statistics.

The math, and what it buys you.

The variance inflation factor puts a number on how much collinearity costs you:

$${\text{VIF}}_j=\frac{1}{1-R_j^2}$$

where $R_j^2$ is from regressing feature $j$ on the others. A VIF of 10 means that coefficient’s standard error is $\sqrt{10}\approx 3.2$ times larger than it would be with uncorrelated features — which tells you directly whether the instability is bad enough to act on.

Follow-up: Do these assumptions apply to ridge and lasso? The estimation assumptions do not carry over cleanly, because both are deliberately biased estimators — the whole point of regularisation is to trade bias for variance, so unbiasedness was never on offer. Linearity still matters for the model to be right. Inference is genuinely harder: the standard $t$-tests do not apply to lasso coefficients, since the selection step is data-dependent, which is why post-selection inference is its own research area. In practice people using regularised regression for prediction check linearity and residual structure and skip the inference machinery entirely.

Why the interviewer asks this. Listing five assumptions is memorisation; saying which ones break unbiasedness versus which only break the standard errors is understanding.

Saying it out loud. “I’d group them by what they protect. Linearity and having errors uncorrelated with your predictors are what make the coefficients unbiased — if those fail, your estimates are wrong and more data won’t save you. Homoscedasticity and independent errors don’t bias the coefficients, they bias your standard errors, so you’d get significance you haven’t earned; often the fix is just robust or clustered standard errors rather than a different model. Normality only matters for small-sample inference and washes out with the central limit theorem. And multicollinearity isn’t really a model assumption at all — it doesn’t hurt prediction, it just makes individual coefficients unstable and uninterpretable.”

Q31: What are the assumptions of logistic regression?

In 30 seconds. “The load-bearing assumption is that the log-odds are linear in the features — not the probability. So anything genuinely non-monotone, like risk being high at both extremes of a measurement, can’t be represented without extra terms. You also need independent observations and enough events, not just rows. And the one that bites in practice is complete separation: coefficients run to infinity and the fit doesn’t converge — a little L2 fixes it.”

The short version.

1. Binary outcome. $Y\in \{0,1\}$; use multinomial logistic for multi-class.
2. Linearity of log-odds. Check with the Box-Tidwell test; fix with polynomial terms, splines or interactions.
3. Independence of observations; use mixed-effects models for correlated data.
4. No multicollinearity — same story as linear regression.
5. Enough data, and specifically enough events: 10-20 per predictor.

Differences from linear regression:

• No normality assumption (errors are binary).
• No homoscedasticity (variance is $p(1-p)$ by construction).
• The probability is sigmoid — non-linear — not linear.

Why it works.

Linearity of the log-odds is the assumption that actually does the work. The model is $\log \frac{p}{1-p}=w^{\top }x+b$, so it is a linear model in log-odds space. On the probability scale the same relationship is S-shaped, which is why “logistic regression is a linear model” confuses people — it is linear in the link, not in the output. The practical consequence: a genuinely non-monotone relationship (risk high at both low and high values of a feature, as with blood pressure or dosage) cannot be captured, and no amount of data will reveal it. You have to add the quadratic term, spline the feature, or bin it.

Complete separation is a failure mode worth naming. If some hyperplane perfectly separates the classes, the likelihood is maximised by pushing the coefficients to infinity — every step further increases the fitted probabilities toward 0 and 1 and keeps reducing the loss. There is no finite MLE. Symptoms are enormous coefficients, standard errors in the thousands, and non-convergence warnings. This happens routinely with small samples, rare outcomes, or a feature that encodes the label. The standard remedies are exactly the regularisers you would use anyway — an L2 penalty makes the objective strictly convex and guarantees a finite solution, which is why sklearn’s LogisticRegression applies L2 by default — or Firth’s penalised likelihood in a statistics setting.

On the “large sample size” rule. The real constraint is the number of events, not the number of rows. The classical rule of thumb is 10-20 events per predictor variable (EPV): with 1,000 rows but only 30 positives, you can support two or three predictors, not fifty. This is why rare-outcome problems are hard even with large datasets.

Follow-up: How do you read a fitted coefficient? $w_j$ is the change in log-odds per unit change in feature $j$, holding the others fixed, so $e^{w_j}$ is the odds ratio — a multiplicative effect on the odds. A coefficient of 0.7 means $e^{0.7}\approx 2$, so the odds double per unit. Two cautions worth voicing: odds ratios are not risk ratios and diverge badly when the base rate is high (doubling odds from 0.9 raises probability only from 0.47 to 0.64), and the effect on probability is not constant — it is largest near $p=0.5$ and near zero out in the tails, because that is where the sigmoid is steep.

Why the interviewer asks this. Mostly to see whether you know what “linear” refers to in logistic regression, and whether you have ever met separation in a real fit.

Saying it out loud. “The load-bearing assumption is that the log-odds are linear in the features — not the probability, the log-odds. So the relationship on the probability scale is S-shaped, and anything genuinely non-monotone, like risk being high at both extremes of a measurement, just can’t be represented without adding terms. You also need independent observations and you need enough events, not just enough rows — the rule of thumb is ten to twenty positive cases per predictor. And the one that bites in practice is complete separation: if a feature perfectly splits the classes the coefficients run off to infinity and the fit doesn’t converge. A little L2 fixes it, which is why sklearn regularises by default.”

Q32: What are the assumptions of SVM?

In 30 seconds. “The main one is feature scaling, and it isn’t optional — the SVM maximises a margin measured as Euclidean distance, so whichever feature has the biggest numeric range dominates the geometry, and with an RBF kernel that’s even more true. Beyond that they’re really choices rather than assumptions: pick a kernel that matches the structure, tune C and gamma together because they interact, and watch class imbalance since the margin doesn’t know one class matters more.”

The short version.

1. Separable data. Hard-margin needs linear separability; soft-margin tolerates violations. Fix: kernel, or allow margin violations.
2. Feature scaling — critical. SVM is very sensitive to scale. Always StandardScaler or MinMaxScaler.
3. Appropriate kernel. Linear for linearly separable; RBF for non-linear local structure; polynomial for polynomial relationships. Cross-validate.
4. Balanced classes. Sensitive to imbalance; use class weights, SMOTE, cost-sensitive learning.

What SVM does not assume: normal distributions, linear relationships (with kernels), or a large sample size.

Where the “assumptions” framing is loose. SVM is not a probabilistic model, so it has no likelihood and therefore no distributional assumptions in the sense that linear regression has them. What it has are requirements for the geometry to be meaningful (scaling), a modelling choice that must match the data (the kernel), and a known sensitivity (class imbalance, because the margin term does not know that one class matters more; class_weight='balanced' rescales $C$ per class to fix it). It is worth saying this explicitly in an interview, because it shows you know why the question is phrased differently for SVM than for regression.

Why it works.

Why feature scaling is not a preference but a consequence of the objective. The linear SVM maximises the margin, and the margin is $2/\Vert w\Vert$ measured in Euclidean distance in feature space. So the geometry of the answer depends directly on the units of your features. If income is in dollars (range $10^4$–$10^5$) and age is in years (range 20–80), a one-unit change in age is geometrically negligible next to a one-unit change in income, so the maximum-margin hyperplane will be almost entirely determined by income regardless of which feature is actually informative. The RBF kernel makes it worse: $\exp (-\gamma \Vert x-y{\Vert }^2)$ is dominated by whichever feature has the largest numeric spread, so the other features effectively vanish from the similarity computation. This is why scaling is marked “critical” — it is not a tuning nicety, it is required for the objective to mean what you intend.

What “support vector” means and why it matters. Only the points on or inside the margin have nonzero dual coefficients; the solution depends on those alone. Delete every other training point and refit and you get the identical boundary. That is a genuinely unusual property — it makes SVM robust to far-away outliers of the correct class, but it also means a single mislabelled point sitting inside the opposite class’s region becomes a support vector and can move the boundary substantially, especially with large $C$.

The math, and what it buys you.

The regularisation parameter C, which the assumption list omits. Soft-margin SVM minimises

$$\frac{1}{2}\Vert w{\Vert }^2+C\sum _i{\xi }_i$$

where ${\xi }_i$ are slack variables measuring how far each point violates its margin. $C$ is the exchange rate between a wide margin and few violations. Small $C$ means violations are cheap, so the margin grows, more points end up as support vectors, and the model is smoother and higher-bias. Large $C$ means violations are expensive, so the boundary contorts to classify training points correctly — low bias, high variance, and in the limit $C\to \infty$ you recover the hard-margin SVM, which does not exist for non-separable data. $C$ and $\gamma$ interact strongly, which is why they are always tuned jointly on a 2-D grid rather than one at a time.

Good and bad.

• Good: strong margins generalise well in high dimensions; the solution depends only on the support vectors, so far-away correct points are irrelevant; kernels give non-linearity without explicit feature maps.
• Bad: requires scaling to be meaningful at all; no probabilities out of the box; sensitive to class imbalance and to mislabelled points near the boundary; and $C$/$\gamma$ tuning is a 2-D search.

Follow-up: SVM does not output probabilities — what do you do if you need them? The decision function is a signed distance from the hyperplane, not a probability. Platt scaling fits a one-dimensional logistic regression to those distances on held-out data, which is what probability=True triggers in scikit-learn — note it runs an internal cross-validation, so it is slow and can produce probabilities that disagree with predict. Isotonic regression is the non-parametric alternative and fits better when you have enough calibration data. If probabilities are central to your problem, though, logistic regression or a gradient-boosted model is usually the better starting point.

Why the interviewer asks this. Scaling is the answer they are fishing for; the good candidate explains why the objective demands it rather than just asserting it.

Saying it out loud. “The main one is feature scaling, and it’s not optional — the SVM maximises a margin measured as Euclidean distance, so whichever feature has the biggest numeric range dominates the geometry. With an RBF kernel that’s even more true, because the distance in the exponent is driven by the largest-scale feature. Beyond that it’s really about choices rather than assumptions: pick a kernel that matches the structure, tune C and gamma together because they interact, and watch out for class imbalance since the margin doesn’t know one class matters more. And it’s not probabilistic, so if you need calibrated probabilities you have to bolt on Platt scaling afterwards.”

Q33: Explain Bayes’ theorem in detail.

In 30 seconds. “Bayes’ theorem is how you update a belief when evidence arrives — posterior proportional to likelihood times prior. My go-to example is the medical test: one percent prevalence, ninety-five percent accurate, and a positive result still means only about a sixteen percent chance you’re sick, because the false positives from the huge healthy group swamp the true positives. The odds form makes it even quicker: prior odds times the likelihood ratio.”

The short version.

P(A|B) = P(B|A) * P(A) / P(B)

• Prior P(A): belief about A before seeing evidence.
• Likelihood P(B|A): probability of the evidence given A.
• Evidence P(B): total probability of B — where all the computational work lives.
• Posterior P(A|B): updated belief after seeing B.
• The headline example: 1% prevalence, 95% accurate test, positive result → only ~16% chance of disease, because of false positives from the large healthy population.
• Uses: naive Bayes, spam detection, medical diagnosis, recommendation systems.

See 34_discriminative_generative/bayes_theorem_detailed.md for comprehensive explanation!

Why it works.

Why the denominator is where the work is. $P(B)$ is computed by the law of total probability, ${\sum }_{A}P(B\mid A)P(A)$, summing over every hypothesis. For a handful of discrete hypotheses this is arithmetic. For continuous parameters it becomes an integral over the whole parameter space that is usually intractable, and that single fact is the reason Bayesian computation exists as a field: MCMC samples from the posterior without ever evaluating the denominator (Metropolis-Hastings only needs ratios, in which it cancels), and variational inference sidesteps it by optimising a bound instead.

How naive Bayes uses this. Classify by $\arg {\max }_{y}P(y){\prod }_{j}P(x_j\mid y)$ — the denominator is dropped because it is the same for every class and cannot change the argmax. The “naive” part is the product: assuming features are conditionally independent given the class. That assumption is essentially always false in text (words are correlated), yet the classifier works well, because the argmax only needs the class ranking to be right, not the probabilities. The probabilities themselves come out wildly overconfident — typically saturated at 0 or 1 — which is why naive Bayes should not be trusted for calibrated output.

The math, and what it buys you.

Working the medical example all the way through, because the number is the point. Let $D$ be “has the disease” and $+$ be “tests positive”. Given prevalence $P(D)=0.01$, sensitivity $P(+\mid D)=0.95$, and specificity $P(-\mid \neg D)=0.95$ (so the false-positive rate is $P(+\mid \neg D)=0.05$):