Answers you can say, not topics you recognise

The unit of text a language model actually reads. Text is split into sub-word pieces by an algorithm like byte-pair encoding: start from characters and repeatedly merge the most frequent adjacent pair until you reach a fixed vocabulary size.

Common words end up as a single token; rare ones break into several. Rough rule: one token is about four characters of English, so roughly 0.75 words.

A learned vector that represents a discrete thing — a token, a patch, an entire image — as a point in a continuous space. The embedding table is a lookup: token id in, vector out.

The useful property is that geometry carries meaning: similar things land near each other, so distance and direction in that space are informative. That's what makes "representation" a meaningful word rather than jargon.

Parameters are learned by the optimiser from data — the weights and biases. Hyperparameters are set by you before or around training — learning rate, batch size, number of layers, weight decay, how long to train.

The clean test: did gradient descent choose it? Then it's a parameter. Learning rate is a hyperparameter, which is why it's tuned on the validation set and not learned.

A tensor is just an n-dimensional array. Scalar, vector, matrix, then everything above. A batch of RGB images is a 4D tensor shaped (batch, channels, height, width).

A channel is one feature map at every spatial position — the 3 of RGB at the input, and after a conv layer, one channel per learned filter. "64 channels" means 64 different learned feature detectors, each giving a value at every location.

The vector of partial derivatives of the loss with respect to every parameter. It points in the direction of steepest increase of the loss, which is why you step in the negative gradient direction.

Practically: each component says "if I nudge this one weight up slightly, how much does the loss change, and in which direction".

Batch is the group of samples processed together in one step. Iteration (or step) is one forward-backward-update cycle, so one weight update. Epoch is one full pass through the training set.

1000 samples at batch size 100 gives 10 iterations per epoch. People mix up epoch and iteration constantly.

Training: forward pass, loss, backward pass, update. Gradients are computed and stored, so memory use is much higher. Dropout is active, BatchNorm uses batch statistics.

Inference: forward pass only. No gradients (torch.no_grad()), dropout off, BatchNorm using running averages. This is what model.eval() switches — forgetting it is a classic bug that shows up as noisy or shifted predictions.

Dot products of two random vectors of dimension d_k have variance proportional to d_k, so the standard deviation grows like √d_k. Large scores push the softmax toward a one-hot distribution, where it saturates and its gradient goes to almost zero.

Say "so the gradients don't vanish" — that is the point. Dividing by √d_k keeps the score variance near 1, where softmax still learns.

O(n²d) time and O(n²) memory in the sequence length n. QKᵀ multiplies n × d_k by d_k × n, producing an n × n matrix.

That quadratic cost is why long context was hard, why flash attention exists (same maths, tiled so the n × n matrix is never materialised), and why linear-attention approximations get written.

In self-attention, Q, K and V all come from the same sequence — tokens attend to each other. In cross-attention, Q comes from one sequence while K and V come from another.

Cross-attention is how a decoder reads an encoder, and how modules in a perception stack read a shared feature map: the queries are the module's own, the keys and values come from the shared representation.

Before the softmax, you add −∞ to the scores at positions a token isn't allowed to see — future positions in a language model, or padding. After softmax those weights are exactly zero.

This is what makes a decoder autoregressive, and it is why training is parallel across all positions while generation is sequential: during training the whole target sequence is present and masked, but at inference each token must exist before the next can attend to it.

Give both reasons. Path length: every position reaches every other in one step rather than through n sequential hops, so long-range dependencies don't have to survive a chain of updates. Parallelism: it's a couple of matrix multiplications, so training parallelises across the sequence, which an RNN fundamentally cannot.

Separately, because attention is permutation-equivariant. Three flavours worth naming:

• Sinusoidal — fixed, different frequencies, lets the model read relative offsets.
• Learned absolute — one vector per position. Simple, doesn't extrapolate past the trained length.
• RoPE (rotary) — rotates Q and K by an angle proportional to position, so the dot product between two tokens depends only on their relative distance. What most current LLMs use.

Naming RoPE signals you're current.

LayerNorm normalises across the feature dimension within one token, independently of other samples. BatchNorm normalises each feature across the batch, so it depends on batch composition, needs running statistics at inference, and breaks with variable sequence lengths and small batches.

You want inference to be independent of what else is in the batch. Hence LayerNorm. RMSNorm is the cheaper modern variant that drops mean-centring.

The original paper was post-norm: LayerNorm(x + sublayer(x)). Current practice is pre-norm: x + sublayer(LayerNorm(x)).

It matters a lot. Pre-norm leaves a clean identity path down the residual stream, so deep stacks train stably without delicate learning-rate warmup. Post-norm at depth is notoriously fragile.

• Encoder-only (BERT): bidirectional, trained by masked prediction. Classification, embeddings.
• Decoder-only (GPT, Llama): causally masked, next-token prediction. Every modern LLM.
• Encoder-decoder (T5, the original): encodes one sequence, generates another, with cross-attention between them. Translation, and the structure perception stacks borrow.

Cut the image into patches (16×16, say), linearly embed each patch as a token, add positional embeddings, run a standard transformer. The only real change from text is how you make tokens.

The exponential of the mean cross-entropy loss. Loosely: how many tokens the model is effectively choosing between at each step. Lower is better.

And the thing to add: perplexity measures prediction, not truthfulness. A model can get dramatically better at predicting the next token and no better at being right.

• ReAct — interleave reasoning, action, observation. The default.
• Plan-and-execute — commit to a plan first. More sample-efficient, less adaptive.
• Reflection — critique the last attempt before the next one. Cheap to add, and strongest where each result is genuinely informative feedback.
• Multi-agent — separate roles, commonly a proposer and a critic.

Task success rate, number of tool calls, cost, latency, and variance across repeated runs. Overlap metrics and LLM-as-judge both have problems — judges favour longer answers and their own outputs.

And the structural point: you need baselines that each kill one alternative explanation — a human reference for scale, the existing product for commercial relevance, a one-shot LLM to isolate whether the loop does anything, and random search on a matched budget to isolate whether the LLM's prior does anything.

Four parts: an LLM that decides, tools it can call, a loop that feeds results back, and state it carries between steps. The defining property is that the model chooses the next step, not the programmer.

You describe each tool with a name, description and a JSON schema for its arguments. The model outputs a structured call; your code validates it, runs the tool and returns the result as a new message. Tool descriptions are prompts — vague ones cause wrong tool choices.

Short-term: the context window — summarise or trim as it fills. Long-term: write facts or past episodes to a store (vector database, files) and retrieve them when relevant. Memory is just retrieval; the same pitfalls as RAG apply.

Looping on the same action, calling tools with hallucinated arguments, stopping too early and claiming success, losing the goal in a long context, and over-trusting tool output. Guard with step limits, schema validation, explicit success checks and traces you actually read.

Least privilege on tools, sandboxes for code execution, human approval for irreversible actions (payments, deletion, sending messages), and treating all retrieved or tool-returned text as data, not instructions — the defence against prompt injection.

The Model Context Protocol: an open standard for exposing tools and data sources to LLM applications, so a tool is written once and used by any compatible client — rather than writing a custom integration per app.

Route easy steps to smaller models, cache repeated tool calls and prompts, cap steps and tokens, run independent tool calls in parallel, and measure cost per completed task, not per call.

Retrieval-augmented generation: fetch relevant documents at query time and put them in the prompt, so the model answers from them rather than from memory.

It gives fresh knowledge without retraining, access to private data, citations you can check, and fewer hallucinations. The weights never change.

Indexing (offline): load documents → clean → chunk → embed each chunk → store vectors plus metadata in an index.

Query (online): rewrite the query if needed → embed it → retrieve top-k (dense, often hybrid with BM25) → rerank → assemble the prompt with the chunks → generate with citations → optionally verify the answer is grounded.

It's a trade-off. Small chunks retrieve precisely but lose context; large chunks keep context but dilute the embedding and waste prompt space. Typical starting point: a few hundred tokens with 10–20% overlap.

Better: split on structure (headings, paragraphs, code blocks) rather than fixed length, and tune chunk size against retrieval recall on your own eval set.

Sparse (BM25): keyword matching. Great for exact terms, names, IDs, error codes. Misses synonyms.

Dense: embedding similarity. Captures meaning and paraphrase. Weak on rare exact tokens.

Hybrid runs both and fuses the rankings, usually with reciprocal rank fusion. It reliably beats either alone, which is why it's the production default.

A bi-encoder embeds query and document separately, so document vectors are precomputed and search is fast. Used for first-stage retrieval.

A cross-encoder reads query and document together and outputs a relevance score. Far more accurate but must run per pair, so it's used to rerank the top 20–100 candidates.

Approximate nearest neighbour search. HNSW builds a layered proximity graph and greedily walks it; IVF clusters vectors and searches only the nearest clusters; product quantisation compresses vectors to save memory. You trade a little recall for orders-of-magnitude speed.

Cosine ignores vector length; dot product doesn't. If embeddings are L2-normalised they're identical. Use what the embedding model was trained with.

Query rewriting (turn a chatty follow-up into a standalone question using chat history), multi-query (generate several phrasings and merge results), HyDE (generate a hypothetical answer and embed that, since answers look more like documents than questions do), and metadata filters (date, product, permissions).

Split it into two problems, because they fail differently.

Retrieval: recall@k, MRR, nDCG against a labelled set of question → relevant-chunk pairs. Generation: faithfulness (is every claim supported by the retrieved context?), answer relevance, and correctness against references. Tools like RAGAS automate parts with LLM judges; spot-check them by hand.

Models use information at the start and end of a long context better than the middle. So stuffing 50 chunks can hurt. Retrieve fewer, rerank, and put the most relevant chunks first or last.

Instruct the model to answer only from the provided context and to say when it can't; require citations per claim; set a retrieval score threshold below which you abstain; and run a groundedness check on the output.

Agentic RAG: the model decides when and what to search, possibly several times. GraphRAG: build a knowledge graph of entities for multi-hop and global questions. Contextual retrieval: prepend a short document-level summary to each chunk before embedding so it keeps its context. Self-RAG / corrective RAG: the model grades retrieved documents and re-retrieves if they're poor.

RAG for knowledge: facts that change, need citations, or are private. Fine-tuning for behaviour: format, style, domain jargon, tool use. They combine well — fine-tune the model to use retrieved context better.

Prompt injection through retrieved documents (a page saying 'ignore previous instructions'), and access-control leaks — retrieving chunks the user isn't allowed to see. Enforce permissions as filters at retrieval time, not in the prompt, and treat retrieved text as data.

Stores embeddings with their IDs and metadata, and answers k-nearest-neighbour queries fast. On top of the index it adds what a library like FAISS doesn't: inserts, updates and deletes, metadata filtering, persistence, replication, access control and often hybrid keyword search.

That's flat (brute-force) search: exact, simple, O(n·d) per query. It's fine — even on a GPU it's fast — up to roughly a million vectors. Beyond that, or at high query rates, latency and cost push you to approximate indexes.

Some true neighbours get missed. Measure recall@k: the fraction of the exact top-k (from a flat search) that the index returns. Tune for a target like 95% recall at your latency budget, on your own data and queries.

Run k-means to partition vectors into nlist clusters (Voronoi cells). Each vector is stored in its cluster's inverted list. At query time, find the nprobe nearest centroids and search only those lists. Raising nprobe raises recall and latency.

Hierarchical Navigable Small World: a multi-layer graph where each vector links to its nearest neighbours. Upper layers are sparse, with long-range links; the bottom layer has everything. A search enters at the top, greedily moves to the closest neighbour, drops a layer, and repeats. Roughly logarithmic search time with very high recall.

M: links per node — more means better recall and more memory. efConstruction: candidate list size while building — slower build, better graph. efSearch: candidate list size per query — the main recall-versus-latency dial at query time.

Split each vector into m sub-vectors, learn 256 centroids per sub-space with k-means, and store each sub-vector as its 1-byte centroid ID. A 128-float vector (512 bytes) becomes 8–16 bytes. Distances are approximated with lookup tables. Often combined with IVF as IVF-PQ.

Re-rank: retrieve a larger candidate set with the compressed codes, then compute exact distances on the full vectors for those candidates only. Most production systems do this.

Use whatever the embedding model was trained with. On L2-normalised vectors all three give the same ranking, so normalising lets you use the fastest inner-product index. Mixing metrics silently degrades results.

Post-filtering — search, then drop rows that fail the filter — can return far fewer than k results when the filter is selective. Pre-filtering restricts the search to matching rows but can break graph traversal. Good databases filter during traversal, or partition by common filters such as tenant.

Every stored vector must be re-embedded and the index rebuilt — vectors from different models live in different spaces and can't be compared. Store the source text and the model version with each vector, and plan migrations as a full re-index.

Graph indexes mark deleted nodes as tombstones and degrade over time, so they need periodic rebuilds. Many systems write new vectors to a small fresh segment searched alongside the main index, then merge in the background.

FAISS: a library, fastest and most flexible, no persistence or filtering. pgvector: when you already run Postgres and want joins and transactions. Qdrant, Milvus, Weaviate: when you need a service with filtering, scaling and updates. Benchmark recall and latency on your own data — published benchmarks rarely match your workload.

Bias is error from the model being too simple to represent the truth. Variance is error from the model being too sensitive to the particular training sample. High bias underfits, high variance overfits.

The caveat worth adding: very overparameterised networks break the simple story — they can interpolate the training data and still generalise. One sentence of that signals you've read past the textbook.

• L2 / weight decay — pulls weights toward zero, prefers smaller smoother solutions.
• L1 — drives weights to exactly zero, gives sparsity.
• Dropout — randomly zeroes activations in training, roughly approximating an ensemble of sub-networks. Off at inference.
• Early stopping — also regularisation; you're limiting how far the optimiser goes.
• Augmentation — for imaging, reach for this first, because data is what you lack.

Train fits parameters. Validation selects hyperparameters and decides when to stop. Test is touched once, at the end.

The subtlety: validation is a form of fitting too. Every hyperparameter you choose on it leaks a little information, which is exactly why the test set has to stay sealed.

With a softmax output, MSE gives small gradients when the model is confidently wrong, so it learns slowly in exactly the situation you care about. Cross-entropy's gradient stays proportional to the error.

Cross-entropy is also the maximum-likelihood objective for a categorical distribution, so it's the principled choice rather than a trick.

Dice = 2|A∩B| / (|A|+|B|). It is exactly F1 computed over voxels, with the segmentation's predicted and true masks as the two sets.

And the relation worth knowing: Dice = 2·IoU / (1 + IoU), so Dice is always ≥ IoU, and they rank models identically. If someone quotes one and you think in the other, you can convert.

Dice is a volume-overlap measure, so it is dominated by the bulk of a large structure. A segmentation can score 0.95 Dice while having one badly wrong protrusion, and Dice barely notices.

Hausdorff measures the worst boundary error, so it catches exactly that. Report both — and prefer the 95th-percentile Hausdorff, since the raw maximum is hostage to a single outlier voxel.

Adam keeps running averages of the gradient (first moment) and its square (second moment), and divides the step by the square root of the second moment — so every parameter gets its own effective learning rate, larger where gradients have been consistently small.

AdamW decouples weight decay from the gradient update, which is the correct formulation and is now standard.

Early in training the gradients are large and the adaptive moment estimates in Adam are still poorly conditioned, so full-size steps destabilise the model — especially with post-norm, where there's no clean identity path. Ramping the learning rate up over the first few hundred steps avoids that.

Pre-norm reduces the need for it considerably, which is part of why pre-norm won.

In this order:

1. Can it overfit a single batch? If not, the bug is in the code or the loss, not the model. This one test eliminates most causes.
2. Check the learning rate — too high diverges, too low looks like nothing happening.
3. Check the data and labels are actually aligned.
4. Check input normalisation.
5. Check gradients are reaching all parameters — anything accidentally frozen or detached.

Leading with the single-batch test marks you as someone who has actually debugged training.

k × k × C_in × C_out + C_out for a 2D layer (the trailing term is the bias). In 3D it's k³ × C_in × C_out + C_out.

The two things people forget: the C_in factor — each kernel spans all input channels — and the bias. Note the count is independent of input spatial size, which is the weight-sharing property.

It has no spatial extent, so it mixes channels — a learned linear projection applied at every spatial position. That's how you change channel count cheaply, which is what the bottleneck in a ResNet block is for.

Inserting gaps in the kernel enlarges the receptive field without adding parameters and without downsampling. That's exactly the trade segmentation needs: you want wide context but cannot afford to throw away the resolution that locates the boundary.

nnU-Net. Not a new architecture — an automatic configuration pipeline that picks patch size, spacing, normalisation and augmentation from the dataset's own properties. It remains a hard baseline to beat, and saying "I'd start from nnU-Net" is a sign of someone who knows the field.

Full 3D uses real spatial context but is memory-hungry, so you train on patches. 2D slice-by-slice is cheap but ignores through-plane context. 2.5D feeds a few adjacent slices as channels as a compromise.

The detail that sounds like experience: patch-based 3D training forces tiny batch sizes, which is why you use GroupNorm or InstanceNorm rather than BatchNorm.

(H/P) × (W/P), plus one if there's a CLS token. A 224×224 image at patch size 16 gives 14×14 = 196 patches, 197 tokens.

It matters because attention is quadratic in token count. Halving the patch size to 8 quadruples the tokens and multiplies attention cost by sixteen. In 3D it's (H/P)(W/P)(D/P), which is why volumetric transformers almost always use windowed or hierarchical attention rather than global.

Two ways to get a single vector for the whole image. The CLS token is an extra learned token prepended to the sequence; it attends to everything and its final state is used as the image representation. Global average pooling just averages all the patch tokens.

They perform comparably. CLS is inherited from BERT; GAP is simpler and common in later work.

• Swin — hierarchical, attention inside shifted local windows. Linear rather than quadratic in image size, and it restores a multi-scale feature pyramid, so it works as a detection and segmentation backbone.
• DINOv2 — self-supervised ViT. The practical default when you want strong general visual features without labels, and the obvious starting point for a foundation-model project.
• MAE — masked autoencoder. Mask ~75% of patches, reconstruct. The standard self-supervised recipe for ViTs.
• ConvNeXt — a CNN modernised with ViT-era design choices that matches ViT performance. The useful counterpoint: a lot of ViT's advantage was training recipe, not attention.
• UNETR / Swin-UNETR — transformer encoder with a convolutional decoder for 3D medical segmentation. This is what a ViT usually looks like in a medical imaging paper.

A differentiable module that applies a geometric transformation to a feature map. Three parts: a localisation network predicts the transformation parameters, a grid generator turns those into sampling coordinates for every output position, and a sampler reads the input at those coordinates using bilinear interpolation.

Because every step is differentiable, you can put it in the middle of a network and train the whole thing by backpropagation. Its original purpose was letting a network learn to crop, rotate and rectify its own input — a learned, differentiable form of spatial attention.

Follow the loop: the network takes the moving and fixed images and outputs a deformation field. The spatial transformer warps the moving image by that field. The loss compares the warped image to the fixed one, plus a regularisation term on the field.

Because the warp is differentiable, the gradient of that image-similarity loss flows back through the sampler, onto the deformation field, and into the network that produced it. So you never need a ground-truth deformation — the supervision comes from how well the warped image matches, which you can always compute.

This is the bridge between the registration section and this one, and it's worth being able to say in one breath.

Mechanically none — both are sampling grids fed to the same sampler. The difference is their form and where they come from.

The original STN predicts a global, low-dimensional transformation, typically a six-parameter affine, so the whole image moves together. Deformable registration predicts a dense field — a displacement vector at every voxel, millions of parameters — usually parameterised as a velocity field and exponentiated so the result is a diffeomorphism.

Same sampler, vastly different degrees of freedom, which is exactly why the dense case needs a regularisation term and the affine case doesn't.

Because the reconstruction term is typically a per-pixel Gaussian likelihood, which is minimised by predicting the conditional mean. When several outputs are plausible, the mean of them is a blur. The KL term pushing the posterior toward the prior adds to it.

GANs. The generator discovers a narrow set of outputs that reliably fool the discriminator and stops covering the rest of the distribution. Samples look fine individually and lack diversity collectively.

It's a consequence of the adversarial objective: nothing in it requires covering the data distribution, only fooling the current discriminator.

No. Contrastive methods (SimCLR, MoCo) need them, and their quality depends heavily on having many — hence large batches or a memory bank. Non-contrastive methods (BYOL, VICReg, Barlow Twins) and masked modelling (MAE, BERT) need none.

• SSD — same modality, same intensity scale.
• Normalised cross-correlation — same modality, intensities linearly related but not identical. Robust to bias field.
• Mutual information — different modalities. It measures statistical dependence rather than intensity agreement, which is why it's the standard answer for MR-to-CT.

A smooth, invertible transformation with a smooth inverse. It preserves topology — no tearing, no folding, structures stay connected and in the same order. It also gives inverse consistency, so registering A→B and B→A agree.

In practice you get it by parameterising a stationary velocity field and exponentiating it (scaling and squaring), which guarantees a diffeomorphism by construction. That representation is also what makes parallel transport possible — velocity fields live in a vector space where you can do algebra.

Held-out performance on a different site, scanner or hospital. Anything less is a weaker claim than it sounds — a random split within one dataset mostly measures how consistent that dataset's acquisition is.

The 3D analogue of a pixel — "volume element". A scan is a grid of them, each holding one intensity at a position, each a small cuboid of tissue.

The detail worth adding: voxels are frequently anisotropic — MRI often has thicker slices than in-plane resolution, say 0.9 × 0.9 × 3 mm. That's why resampling matters before registration, and why 3D convolutions with isotropic kernels can be the wrong assumption.

Linear regression predicts a continuous value and minimises squared error. Logistic regression predicts a probability by passing a linear score through a sigmoid, and minimises log loss.

Despite the name, logistic regression is a classifier. Its decision boundary is linear.

Recursively split the data on the feature and threshold that most reduce impurity (Gini or entropy for classification, variance for regression), until a stopping rule. Interpretable, handles mixed types, no scaling needed — and overfits badly alone.

Random forest: many deep trees trained in parallel on bootstrap samples with random feature subsets, averaged. Reduces variance.

Gradient boosting (XGBoost, LightGBM, CatBoost): shallow trees trained sequentially, each fitting the residual gradient of the previous ensemble. Reduces bias. Usually more accurate, more sensitive to tuning.

Bagging: train independent models on resampled data and average — cuts variance. Boosting: train models in sequence, each correcting its predecessor — cuts bias.

It finds the hyperplane with the maximum margin to the nearest points (the support vectors), with a soft-margin penalty for violations.

The kernel trick computes inner products in a high-dimensional feature space without ever building it, so a linear separator there is a non-linear one in input space (RBF kernel is the usual default).

Pick k centroids, assign each point to its nearest, move each centroid to the mean of its points, repeat until stable.

Failures: you must choose k (elbow, silhouette); sensitive to initialisation (use k-means++); assumes roughly spherical, equal-size clusters; sensitive to scale and outliers.

Finds orthogonal directions of maximum variance — the eigenvectors of the covariance matrix (computed via SVD in practice) — and projects onto the top k.

Caveats: linear only, and variance ≠ importance for your label. Standardise first, or large-scale features dominate.

It assumes features are conditionally independent given the class. Almost never true, yet it works surprisingly well for text classification because ranking, not calibrated probability, is what matters.

P(A|B) = P(B|A)·P(A) / P(B). Posterior ∝ likelihood × prior.

The classic trap: a 99%-accurate test for a 1-in-1000 disease. A positive result still means only about a 9% chance of disease, because false positives from the huge healthy population swamp the true positives.

MLE picks parameters that maximise the likelihood of the data. MAP maximises likelihood × prior. L2 regularisation is MAP with a Gaussian prior; L1 is MAP with a Laplace prior. That link is the line that impresses.

Type I: false positive — rejecting a true null (rate α). Type II: false negative — missing a real effect (rate β). Power is 1 − β.

Means of many independent samples are approximately normal regardless of the underlying distribution. It's why confidence intervals and A/B tests on averages work.

Entropy H(p) is the expected surprise of a distribution. Cross-entropy H(p,q) is the expected surprise when coding p with q. KL(p‖q) = H(p,q) − H(p): the extra cost. Minimising cross-entropy loss is minimising KL to the data distribution.

First ask why they're missing — at random, or informative? Options: drop, impute (mean/median, model-based), or add a missingness indicator feature. Tree boosters handle NaN natively.

One-hot for low cardinality. Target encoding or learned embeddings for high cardinality — with target encoding done out-of-fold, or you leak the label.

Information at training time that won't be available at prediction time. Examples: fitting a scaler on the full dataset before splitting; features computed from the future; duplicate or same-patient rows across splits; target-encoding without folds.

Symptom: validation scores too good to be true.

In rough order: use the right metric (PR-AUC, F1, recall at fixed precision); class-weighted loss or focal loss; resampling (undersample majority, oversample minority / SMOTE); tune the decision threshold. Don't resample the test set.

Split into k folds, train on k−1, validate on the rest, rotate, average. Use grouped CV when samples share an entity (patient, user), and time-based CV for temporal data. Too expensive for large deep models — use a single held-out set.

Start from characters (or bytes). Repeatedly find the most frequent adjacent pair in the training corpus and merge it into a new token, until the vocabulary reaches a target size (often 32k–200k).

Common words become single tokens; rare words split into pieces, so there is no out-of-vocabulary problem. WordPiece (BERT) and SentencePiece/Unigram are close relatives.

Words: huge vocabulary, and any unseen word becomes an unknown token. Characters: tiny vocabulary but very long sequences, which is expensive for attention and makes the model learn spelling from scratch. Sub-words sit in between.

Bag-of-words counts word occurrences, ignoring order. TF-IDF weights each count by how rare the word is across documents, so 'the' counts for little and 'myocarditis' for a lot.

Still useful: as a fast, explainable baseline for classification, and as BM25 in search, where it routinely beats dense retrieval on exact terms.

Train a shallow network to predict a word from its neighbours (CBOW) or neighbours from a word (skip-gram), using negative sampling to keep it cheap. Words appearing in similar contexts end up with similar vectors — the distributional hypothesis.

The famous result: king − man + woman ≈ queen.

BERT is an encoder trained with masked language modelling: it sees the whole sentence in both directions. Great for understanding tasks — classification, NER, embeddings.

GPT is a decoder trained on next-token prediction with a causal mask: it only sees the left context. Built for generation. T5 and BART are encoder–decoder, suited to translation and summarisation.

Hide about 15% of tokens and train the model to predict them from both sides. (BERT replaces 80% of those with [MASK], 10% with a random token, 10% unchanged, so the model can't rely on seeing [MASK] at fine-tune time.)

Fine-tune an encoder with a contrastive objective on pairs that should match (question–answer, paraphrases), pulling them together and pushing in-batch negatives apart. Mean-pool the token vectors. Sentence-BERT is the classic recipe; modern embedding models follow it.

Tagging spans like PERSON, DRUG, DATE. Framed as token classification with BIO tags (Begin, Inside, Outside), so 'acute myeloid leukaemia' becomes B-DISEASE I-DISEASE I-DISEASE. Evaluated with span-level F1, not token accuracy.

BLEU (n-gram precision, translation), ROUGE (n-gram recall, summarisation), BERTScore (embedding similarity), and increasingly LLM-as-judge plus human evaluation.

All the overlap metrics reward copying the reference's words, not being right.

The exponential of the average negative log-likelihood per token: roughly, how many tokens the model is choosing between at each step. Lower is better. Only comparable between models with the same tokeniser and the same test text.

Prompt an LLM when labels are scarce, the task changes often, or you need it working today. Fine-tune a small encoder when you have a few thousand labels, need low latency and cost at scale, or need stable, auditable behaviour. A common path: use the LLM to label data, then distil into a small model.

Abbreviations and ambiguity ('MS' = multiple sclerosis or mitral stenosis), negation ('no evidence of pneumonia'), copy-pasted note bloat, de-identification requirements, and a vocabulary general tokenisers split badly. Negation handling alone breaks many naive keyword systems.

Backprop through time multiplies by the same recurrent Jacobian at every step, so gradients shrink or blow up exponentially with length — vanishing/exploding gradients.

A separate cell state updated additively, gated by forget, input and output gates. The additive path lets gradients flow across many steps — the same idea as a residual connection. GRU is a simpler two-gate variant.

During training, feed the ground-truth previous token rather than the model's own prediction. Fast and stable, but creates exposure bias: at inference the model sees its own mistakes, which it never trained on.

Greedy: argmax each step, fast, repetitive. Beam: keep top-k partial sequences, good for translation. Sampling with temperature / top-k / top-p (nucleus): diverse, better for open-ended generation.

Pre-training: next-token prediction on trillions of tokens. Supervised fine-tuning: instruction–response pairs. Preference tuning: RLHF (reward model + PPO) or DPO directly on preference pairs. Each stage changes behaviour far more than knowledge.

RLHF trains a reward model on human preferences, then optimises the policy against it with RL plus a KL penalty to the reference model. DPO skips the reward model and RL loop, optimising a closed-form classification loss on preferred vs rejected pairs. DPO is simpler and stabler; RL-based methods remain strong for reasoning.

Freeze W; learn a low-rank update ΔW = BA with rank r ≪ d. Trains a tiny fraction of parameters and can be merged into W after training, so no inference latency cost. QLoRA does this on a 4-bit-quantised base.

Loss falls as a smooth power law in parameters, data and compute. Chinchilla showed many models were under-trained: compute-optimal is roughly ~20 tokens per parameter. In practice, models are now over-trained past that because inference cost dominates.

Chunk documents → embed → store in a vector index. At query time, embed the query, retrieve top-k by similarity (often hybrid with BM25, then rerank with a cross-encoder), put them in the prompt, generate with citations.

Most RAG failures are retrieval failures, so evaluate retrieval (recall@k) separately from generation.

Replace the FFN with many expert FFNs and a router that sends each token to the top-k. Total parameters are huge, but compute per token is that of a small model. Costs: load balancing, all-expert memory footprint, communication.

They are trained to produce probable text, not true text, and the objective rewards fluent guessing over saying 'I don't know'. Mitigations: retrieval grounding, calibrated abstention training, verification tools.

A small draft model proposes several tokens; the big model verifies them in one parallel pass and accepts the matching prefix. Same output distribution, 2–3× faster, because generation is memory-bandwidth-bound, not compute-bound.

Data: replicate the model, split the batch, all-reduce gradients. Tensor: split individual matrices across GPUs. Pipeline: split layers across GPUs, micro-batch to fill the bubble. Big runs combine all three.

Optimiser state, gradients and finally the parameters themselves across data-parallel workers, gathering them only when needed. Adam's states are 2× the parameters in fp32, so sharding them is the big memory win.

Compute in fp16/bf16 for speed and memory, keep a fp32 master copy of weights for the update. fp16 needs loss scaling to avoid gradient underflow; bf16 has fp32's exponent range, so it usually doesn't.

Store only some activations in the forward pass and recompute the rest during backward. Trades roughly 30% more compute for a large memory saving.

Rule of thumb ~16 bytes per parameter for mixed-precision Adam (weights, grads, fp32 master, two moments) ≈ 112 GB before activations. That's why you shard or use LoRA.

Collaborative: learn from the user–item interaction matrix (users like you liked this). Content-based: match item features to user profiles. Hybrids are standard; content features solve cold start.

Candidate generation narrows millions of items to hundreds cheaply — two-tower embeddings with approximate nearest neighbour search. Ranking scores those with a heavy model using rich features. Often a re-ranking stage adds diversity and business rules.

New users: popularity, onboarding questions, contextual features. New items: content features, exploration (bandits).

Agent, environment, state, action, reward, policy π(a|s), value function V(s) (expected return from s), Q(s,a) (expected return taking a in s), discount factor γ.

Exploit what you know pays off, or explore to find better. ε-greedy, UCB and Thompson sampling are the standard answers; multi-armed bandits are the simplest setting.

Value-based (Q-learning, DQN) learns Q and acts greedily — good for discrete actions. Policy gradient (REINFORCE, PPO) optimises the policy directly — handles continuous actions. Actor-critic combines both.

On-policy learns from data generated by the current policy (PPO). Off-policy can learn from any data, e.g. a replay buffer (Q-learning, DQN) — more sample efficient, less stable.

Data drift (input distribution shifts), concept drift (the input–label relationship changes), training–serving skew (features computed differently online), silent upstream breakages, and feedback loops where the model shapes its own future training data.

Input feature distributions (PSI, KS test), prediction distribution and confidence, latency and error rates, and delayed labels or proxy metrics once they arrive.

Batch: precompute predictions on a schedule — cheap, simple, stale. Online: predict on request — fresh, latency-bound, needs a feature store for consistent features.

When features at serving time are computed differently from training. The fix is one shared feature definition — a feature store — and logging serving features for retraining.

Offline eval → shadow mode (run alongside, don't serve) → canary to a small slice → A/B test on the business metric → gradual ramp, with automatic rollback triggers.

Version code, data and config together; fix seeds; log environment and hardware; track runs (MLflow, W&B). Even then GPU non-determinism means report variance across seeds.

1. Clarify the business goal and constraints (latency, scale). 2. Frame as an ML task and pick an offline metric tied to the business metric. 3. Data: sources, labels, leakage risks. 4. Features and model: start with a simple baseline. 5. Serving: batch or online, latency budget. 6. Evaluation: offline then A/B. 7. Monitoring and iteration.

Extreme imbalance, adversarial and drifting distribution, delayed labels, asymmetric costs. Tree boosting on behavioural features as baseline, a threshold tuned to the cost ratio, human review queue, frequent retraining.

Retrieval (BM25 + dense embeddings) then learning-to-rank (pointwise / pairwise / listwise) with click data, corrected for position bias. Metrics: NDCG, MRR offline; CTR and success online.

Global: feature importance, partial dependence. Local: SHAP (Shapley-value attributions), LIME, and for images saliency / Grad-CAM. Note they explain the model, not the world, and can be unstable.

Demographic parity (equal positive rate across groups), equalised odds (equal TPR and FPR), calibration within groups. Except in trivial cases they can't all hold at once — you have to choose.

A calibrated model's 0.8 predictions are right 80% of the time. Check with a reliability diagram / ECE. Fix post hoc with temperature scaling, Platt scaling, or isotonic regression on held-out data.

Aleatoric: noise in the data itself — a blurry scan, an ambiguous label. More data doesn't remove it.

Epistemic: the model's ignorance — inputs unlike the training data. More data, or the right data, does reduce it. Out-of-distribution inputs should show high epistemic uncertainty.

Keep dropout switched on at test time, run the same input several times, and treat the spread of predictions as uncertainty. Cheap — no retraining — and an approximation to Bayesian inference. In practice it usually underestimates uncertainty compared with ensembles.

Train several models from different random initialisations and average them. Disagreement between members is a strong uncertainty signal, and accuracy usually improves too. The cost is N times the training and inference.

A wrapper that turns any model's outputs into prediction sets (classification) or intervals (regression) with a guaranteed coverage rate, using a held-out calibration set. No assumptions about the model or the data distribution beyond exchangeability.

Hold out n calibration examples. Score each with a nonconformity score, e.g. 1 − p(true class). Take q̂ as the ⌈(n+1)(1−α)⌉/n quantile of those scores. For a new input, include every class whose score is ≤ q̂.

Result: the set contains the true label with probability at least 1 − α.

Score with the absolute residual |y − ŷ| on the calibration set, take the quantile q̂, and predict ŷ ± q̂. Those intervals are the same width everywhere; conformalised quantile regression (CQR) starts from quantile predictions so intervals widen where the data is noisier.

Distribution shift. The guarantee assumes calibration and test data are exchangeable. A new scanner, a new truck model or seasonal drift violates that. Fixes: recalibrate on recent data, weighted conformal under covariate shift, or adaptive conformal for time series.

Baselines: maximum softmax probability, energy score, Mahalanobis distance in feature space, ensemble disagreement. Evaluate with AUROC between in- and out-of-distribution sets — ideally with realistic shifts, not just a different dataset.

Let the model abstain when uncertain and hand those cases to a human. Plot a risk–coverage curve: error rate on accepted cases against the fraction accepted. In medicine and safety-critical systems, this is how uncertainty becomes a workflow.

Give an interval on remaining useful life instead of a point estimate, so maintenance is scheduled against the lower bound. Conformal intervals on RUL are a clean, defensible answer — and flag the distribution-shift caveat for new vehicle variants.

Trend, seasonality (fixed-period patterns) and residual noise. Many classical models assume stationarity — constant mean and variance — so you difference or detrend first.

Naive (tomorrow = today) and seasonal naive (next Monday = last Monday). They're often surprisingly hard to beat, and reporting against them is what makes a result credible. MASE is literally error scaled by the naive forecast's error.

MAE (robust, interpretable), RMSE (punishes large misses), MASE (scale-free, comparable across series). Avoid MAPE when values approach zero — it explodes and is asymmetric.

Point: one reading far off. Contextual: normal value, wrong context (high load at 3 a.m.). Collective: each point fine, the sequence abnormal (a vibration pattern).

Model normal behaviour and flag deviation: robust statistics (median and MAD rather than mean and std), Isolation Forest, forecast residuals, or autoencoder reconstruction error. Then set the threshold by the alert rate operators can actually handle.

Precision and recall at the operating threshold, precision@k, and the lead time — how early before the failure it fired. Labels are scarce, so get domain experts to review the top alerts.

Predict how many cycles or hours a component has before failure, from sensor history. Classic benchmark: NASA C-MAPSS turbofan engines, with run-to-failure trajectories.

Early in life a healthy engine shows no degradation, so predicting 300 vs 250 cycles is guesswork. A piecewise-linear target — constant (e.g. 125) until degradation begins, then decreasing — matches what the sensors can actually reveal and trains better.

They're right-censored: you know they lasted at least this long. Dropping them biases the model towards short lives. Survival analysis — Cox models, Weibull, deep survival models — uses them properly.

Fixed-length sliding windows; per-sensor normalisation, ideally per operating condition (load, ambient temperature) so the model sees degradation rather than regime changes; drop constant sensors.

Map floating-point values to low-bit integers with a scale and zero point: q = round(x/s) + z, and back as x ≈ s(q − z). Weights shrink 4× from fp32 to int8, and integer arithmetic is cheaper on hardware that supports it.

Symmetric fixes the zero point at 0 — simpler, good for weights. Asymmetric adds a zero point — better for skewed activations like post-ReLU. Per-channel gives each output channel its own scale and is noticeably more accurate for weights.

Post-training quantisation: quantise a trained model using a small calibration set to pick ranges. Fast, no retraining; fine for int8 on most CNNs.

Quantisation-aware training: insert fake-quantise ops during fine-tuning so the model learns to tolerate rounding (straight-through estimator for gradients). Needed when PTQ loses too much, typically at 4 bits or for small, sensitive models.

A few activation channels have huge outliers, so one scale per tensor wastes almost all the integer range on them. Fixes: LLM.int8 (keep outliers in fp16), SmoothQuant (shift the difficulty from activations into weights), GPTQ and AWQ (error-aware weight quantisation to 4 bits).

Unstructured removes individual weights — high sparsity, little accuracy loss. Structured removes whole channels, heads or layers — the model genuinely gets smaller and faster.

Train a small student to match a large teacher's soft output distribution, with temperature T > 1 to expose the 'dark knowledge' in wrong-class probabilities, usually mixed with the normal hard-label loss.

ONNX is a portable model format. Runtimes like TensorRT, OpenVINO or TFLite then optimise the graph for a target: fuse ops (conv + BN + ReLU into one kernel), choose fast kernels, use fp16/int8, plan memory. Often a 2–5× gain without touching accuracy.

Latency: time for one request (watch p95/p99, not just the mean). Throughput: requests per second. Batching raises throughput and usually hurts latency. Real-time perception cares about latency; offline scoring cares about throughput.

On the target hardware, with warm-up runs, synchronised timing on GPU, realistic input sizes and batch, many iterations, and percentiles reported. And check accuracy after every optimisation step.

Fixed memory and power budgets, int8 NPUs with limited operator support, deterministic real-time deadlines, and safety certification. Design for the accelerator's supported ops from the start, rather than converting at the end.

Name the levers precisely: 'post-training int8 quantisation with per-channel weights and a 500-image calibration set, exported through ONNX to TensorRT, latency from X to Y ms on Z hardware, accuracy drop under N points'. Precision of vocabulary is what interviewers listen for.

Camera: rich appearance, cheap, poor direct depth and weak at night or in glare. Radar: measures range and radial velocity directly, works in rain and fog, but sparse and low angular resolution. LiDAR: precise 3D points, degrades in heavy rain or fog, expensive, sparse at long range.

It transmits frequency-modulated chirps. The frequency difference between sent and received signal gives range; the phase change across successive chirps gives radial velocity (Doppler); differences across the antenna array give angle. FFTs turn these into a range–Doppler–angle cube, then detections.

Early: combine raw data — most information, needs exact calibration and sync. Late: each sensor detects objects, then merge lists — modular and robust to a sensor failing, but loses evidence that was weak in each sensor alone. Mid/feature-level, typically in BEV, is the current default.

Bird's-eye view: a top-down grid around the car. LiDAR and radar map into it naturally; camera features are 'lifted' into it using predicted depth (Lift-Splat-Shoot) or attention (BEVFormer). A shared BEV space makes fusion, planning and multi-camera reasoning simple.

Calibration: intrinsics for each camera, extrinsics (rotation and translation) between every sensor. Time synchronisation: at 30 m/s, 30 ms of misalignment is almost a metre. Plus ego-motion compensation for LiDAR sweeps.

Track a state (position, velocity) and its uncertainty P. Predict with a motion model — uncertainty grows. Update with a measurement — the Kalman gain weights prediction against measurement by their uncertainties, and P shrinks. Fusion falls out naturally: each sensor has its own noise covariance R.

Compute a cost between each track's prediction and each detection (distance, IoU, Mahalanobis), discard implausible pairs with a gate, and solve the assignment with the Hungarian algorithm. Unmatched detections start tentative tracks; unmatched tracks age out.

Points are unordered. PointNet applies a shared MLP per point then a symmetric max-pool, so order doesn't matter. Faster in practice: voxelise or group into vertical pillars (PointPillars) and use 2D/3D convolutions.

3D mAP over IoU or centre-distance thresholds; nuScenes adds NDS, combining mAP with errors in translation, scale, orientation, velocity and attributes. Tracking uses AMOTA and ID switches.

Depth is ambiguous from one image, and depth error grows with distance. Multi-view geometry, temporal stereo and learned depth help; radar or LiDAR resolve it directly — which is the core argument for fusion.

Pre-trained on huge, broad data, usually with self-supervision or weak supervision from captions, and then adapted to many tasks with little labelled data. Examples: CLIP and SigLIP (image–text), DINOv2 (self-supervised features), SAM (segmentation).

An image encoder and a text encoder map a batch of image–caption pairs into one space. A symmetric contrastive (InfoNCE) loss raises the similarity of the true pairs — the diagonal — and lowers all others. SigLIP replaces the softmax with a per-pair sigmoid loss, which scales better.

Embed text prompts like 'a photo of a {class}' for every class, embed the image, and pick the closest. No training on those classes. Prompt wording and ensembling several templates noticeably change accuracy.

A pre-trained vision encoder (ViT, often CLIP/SigLIP), a projector (MLP or Q-Former) mapping patch features into the LLM's token space, and an LLM. Training: first align the projector on caption data with both models frozen, then instruction-tune on visual Q&A. LLaVA is the reference design.

Segment Anything: a heavy image encoder run once per image, plus a light prompt encoder and mask decoder that respond to points, boxes or masks in real time. Trained on over a billion masks. Gives class-agnostic masks — it knows 'an object is here', not what it is.

Detecting objects named by arbitrary text, not a fixed class list. Grounding DINO and OWL-ViT align region features with text embeddings. Useful for rare classes and for auto-labelling data.

Vision-language-action model: a VLM whose output is robot or vehicle actions. RT-2 and OpenVLA discretise actions into tokens the LLM predicts; π0 adds a flow-matching action head for smooth continuous control. Trained on large teleoperation datasets such as Open X-Embodiment.

Linear probe on frozen features: fastest, tests representation quality, fine for small data. Full fine-tuning: best when data is plentiful and the domain differs. LoRA or adapters: most of the gain at a fraction of the cost.

Describing objects that aren't in the image, driven by language priors ('a kitchen usually has a fridge'). Measured with benchmarks like POPE; reduced with grounding, better data and preference tuning.

Supervised learning on expert demonstrations: input the state, predict the expert's action. Simple, stable, needs no reward function. The default first step for driving and robot manipulation.

Compounding error from covariate shift. The policy trains on expert states but runs on its own; one small mistake leads to an unfamiliar state, where it makes a bigger mistake. Error grows roughly with the square of the horizon.

Roll out the current policy, have the expert label the states it actually visits, add those to the dataset, retrain, repeat. It trains on the policy's own state distribution, cutting error growth to roughly linear. The cost: an expert available to label on demand.

Mean-squared-error regression averages the modes — passing an obstacle on the left or the right becomes driving straight into it. Use policies that model a distribution: mixtures, discretised actions, diffusion policies, or action chunking with a generative head (ACT).

Inverse RL infers the reward the expert seems to optimise, then runs RL on it — generalises better than copying actions but is expensive. GAIL trains a discriminator to tell expert from policy behaviour and uses it as the reward, adversarially.

Learn a policy from a fixed dataset of logged experience with no further interaction — attractive when exploring is dangerous or expensive, as with real vehicles or patients.

Q(s, a) = r + γ · max over a′ of Q(s′, a′): the value of an action is the immediate reward plus the discounted value of the best next action. Q-learning moves Q towards this target.

An experience replay buffer to break correlation between consecutive samples, and a target network updated slowly so the regression target doesn't chase itself. Double DQN then reduced overestimation.

Soft actor-critic: off-policy actor-critic for continuous actions that maximises reward plus policy entropy, so it keeps exploring and is robust. A standard choice for robotic control in simulation.

The agent maximises the reward you wrote, not what you meant — circling to collect points, exploiting a simulator bug. Shaped or learned rewards are especially prone. Mitigate with careful reward design, constraints and watching actual behaviour, not just the curve.

Domain randomisation of physics, sensor noise and visuals so reality looks like one more variation; system identification to match simulator parameters; then fine-tuning on a small amount of real data.

Model-free learns a policy or value directly from experience — simple, sample-hungry. Model-based learns the dynamics and plans with them (MPC, Dreamer) — far more sample-efficient, but model errors compound over long plans.

Imitation when good demonstrations exist and a reward is hard to write — usually the case for driving. RL when a reward is clear and you can simulate cheaply. In practice: pre-train by imitation, then fine-tune with RL or offline RL.