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.

Compare training and validation loss over training or over model size: a widening gap with validation loss turning upward is the signature. Learning curves against training-set size tell you whether more data would help (gap closing) or the model is too simple (both curves high).

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.

Macro: compute F1 per class, then take the plain mean — every class counts equally, so rare classes matter. Micro: pool all true positives, false positives and false negatives first — dominated by frequent classes. Weighted: per-class F1 averaged by class frequency. Use macro when rare classes matter, as with drones versus birds.

RMSE squares errors, so a few large misses dominate; it is the right target when big errors are disproportionately costly, but one outlier can swamp it. MAE treats all errors linearly and corresponds to predicting the median; it can hide rare large failures. RMSE ≥ MAE always, and a large gap signals heavy-tailed errors. Report both, in the target's units.

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.

As dimensions grow, data becomes sparse: the volume to cover grows exponentially, and distances between points concentrate so nearest and farthest neighbours become almost equally far. It hurts distance-based methods (kNN, clustering, RBF kernels) and density estimation most. Remedies: feature selection, PCA or learned embeddings, regularisation — and noting that real data usually lies near a much lower-dimensional manifold.

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.

Stratified k-fold: keep class proportions in every fold; the default for imbalanced classification. Group k-fold: keep all samples from one entity (vehicle, patient, recording, tracked object) in the same fold, otherwise the model is tested on things it has effectively seen. Time-series split: always validate on data later than the training data.

Train on data up to time t, test on the next block, then move forward and repeat — either expanding the training window or sliding a fixed-size one. It mimics how the model will be used and shows how performance changes over time, not just on average.

Lag and rolling features computed near the boundary can reach into the test period, and neighbouring samples are strongly correlated. A gap (embargo) of at least the longest feature window stops that leakage.

Lags of the target and key signals; rolling statistics over several windows (mean, std, min, max, slope); exponentially weighted averages; differences and rates of change; time since an event; frequency-domain features such as band powers; and normalisation per operating condition so the model sees deviations rather than regime changes. Compute all of them using only past data.

Sort by time and cut three consecutive blocks: train on the earliest, validate on the next (for tuning and early stopping), test on the latest, touched once. Fit scalers and encoders on train only. Leave a gap between blocks at least as long as the longest lag or rolling window. If data comes from several vehicles or engines, also keep each unit in a single split. For the final model, retrain on train + validation with the chosen settings and report the test score.

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.

I start from what success means to the people using it — a clinical decision, a maintenance saving — not from the loss function. Then I pick metrics that capture that, even if they're harder to compute than the easy ones.

Next, the evaluation data: split at the entity level, stratified along the axes where the model has to generalise, with deliberate edge cases. Then baselines — a trivial one and the current method — so every number has something to be compared against.

A classic cautionary example: adapting a language model to clinical notes can cut perplexity several-fold while exact-match accuracy on clinical questions barely moves. A headline metric without task-level evaluation and failure analysis tells the wrong story.

A few things I insist on:

• Entity-level splits — by patient, vehicle or site, never by slice or window, or the model is tested on things it has effectively seen.
• Stratification along the axes where generalisation matters: site, scanner, protocol, demographics, operating condition.
• Hard and edge cases on purpose, not just whatever the random sample contained.
• Multiple institutions if at all possible — single-site benchmarks overstate performance.
• Enough samples that the confidence interval is narrower than the differences you want to detect.

Run each configuration with several seeds — three to five — and report mean ± standard deviation, not one lucky run. Compare models paired on the same test cases: a paired t-test if differences look normal, Wilcoxon signed-rank if not, or a paired bootstrap over test examples.

Report confidence intervals, not just p-values, and correct for multiple comparisons with Holm or Bonferroni when you test many models or metrics. Above all, look at the effect size: a significant 0.2-point gain may not matter to anyone.

One subtlety: with only five seeds, a two-sided Wilcoxon test can never reach p < 0.05 — the smallest possible p is 0.0625. So pairing over test examples, or a bootstrap, is usually the more useful test.

Break the aggregate apart. I look at results by subgroup — anatomy, site, difficulty, operating condition — and at where errors cluster, for example error heat-maps over the image or the input space, and which specific classes get confused.

Then compare failure modes across models: if they fail on the same cases, the problem is likely the data or labels; if differently, an ensemble may help. Finally, I read the worst N cases myself. Systematic errors tell you far more than one more decimal of the average.

Hold out entire sites or institutions as an external test set, and use leave-one-site-out cross-validation to see how much performance varies. The key number is the drop from internal to external performance.

Test-time augmentation is a useful diagnostic for sensitivity to acquisition changes, and in production I'd keep monitoring metrics per site. A model validated only on its training distribution tells you nothing about deployment.

The headline is task completion rate — binary success against objective criteria — broken down by complexity: simple tasks of 5–10 steps, medium of 10–50, complex of 50–200 or more. Underneath that I measure:

• Tool-call accuracy: right tool, right parameters, correct reading of the result.
• Error recovery: inject failures and see whether it recovers.
• Context retention: does a constraint given at step 1 still hold at step 50?
• Cost per successful completion, not per call.

Agents are non-deterministic, so every task runs three to five times and I report the spread.

• SWE-bench (Verified, Pro): coding agents resolve real GitHub issues, judged by running the repository's tests.
• WebArena: realistic tasks in self-hosted websites through a browser.
• τ-bench: customer-service conversations where the agent must follow domain rules and policies.
• AgentBench: many environments, broad but shallow.

The key point is that each reflects a specific task distribution, tool set and harness, so scores don't transfer directly to your deployment. You still need a custom evaluation on tasks that look like your production traffic.

• 20–30 tasks taken from production logs, or simulated from the inputs you expect.
• 5–10 of them with injected failures at specific steps — a tool error, a missing file, a contradictory instruction.
• Each task run at least three times.
• Scored at the task level; step-level scores are for debugging only.
• Cost per completed task recorded for every candidate model.

Report success-rate distributions, not single point estimates — with 30 tasks, one flip is more than three percentage points.

• Hallucinated actions: calling tools that don't exist, or with wrong parameters.
• Loops: repeating the same failed action.
• Context saturation: losing early constraints as the trace grows.
• Termination failures: stopping early, or carrying on after the task is done.
• Cascading errors: one wrong tool output poisons every later step.
• Happy-path bias in the evaluation itself: testing only easy paths, and missing the failures that matter most in production.

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.

Greedily. At a node it tries every feature and every candidate threshold (midpoints between sorted values), computes the impurity of the two children weighted by their size, and keeps the split with the largest drop in impurity. Then it recurses on each child until a stopping rule. It never revisits earlier splits, so the result is good, not optimal — finding the optimal tree is NP-hard.

Gini = 1 − Σ pₖ² : the chance two random samples from the node have different labels. Entropy = −Σ pₖ log₂ pₖ : bits needed to encode a label. For a 50/50 node Gini is 0.5 and entropy is 1; for a pure node both are 0. They pick the same split in the vast majority of cases; Gini is slightly cheaper (no logarithm), which is why it's the scikit-learn default.

Parent: 10 samples, 5 fault and 5 ok → entropy 1.0. Split into left 4 (all ok, entropy 0) and right 6 (5 fault, 1 ok, entropy ≈ 0.65). Weighted child entropy = 0.4·0 + 0.6·0.65 ≈ 0.39. Information gain ≈ 1.0 − 0.39 = 0.61 bits. Being able to do this by hand is a common interview check.

The same greedy splitting, but impurity is the variance (mean squared error) of the target in a node, and each leaf predicts the mean of its training targets (or the median with an absolute-error criterion). The result is a piecewise-constant function — a staircase.

Pre-pruning limits growth: max_depth, min_samples_leaf, min_samples_split, max_leaf_nodes, min_impurity_decrease. Post-pruning grows a full tree then cuts back: cost-complexity pruning minimises error + α·(number of leaves), with α (ccp_alpha in scikit-learn) chosen by cross-validation. min_samples_leaf is usually the single most useful knob.

It has high variance: a small change in the data can change the top split, and every split below it changes too, giving a completely different tree. That instability is exactly what averaging many trees (bagging, random forests) exploits.

Natively in some implementations (LightGBM, CatBoost, and recent scikit-learn versions can split categories into groups and route missing values to the better side). Otherwise you encode them: ordinal encoding often works well for trees; one-hot encoding a high-cardinality feature tends to hurt, because each binary column carries very little signal per split.

Train many deep trees, each on a bootstrap sample of the rows, and at every split consider only a random subset of features (typically √p for classification, p/3 or all for regression). Average the predictions (or vote). The feature subsampling decorrelates the trees, so averaging cuts variance far more than plain bagging would.

The variance of an average of B trees with variance σ² and pairwise correlation ρ is ρσ² + (1−ρ)σ²/B. Adding trees shrinks only the second term; the first stays. Lowering ρ — by restricting features per split — is what lets the forest keep improving.

Each bootstrap sample leaves out about a third of the rows (the chance a row is never drawn is (1 − 1/n)ⁿ ≈ 37%). Predicting each row using only the trees that didn't see it gives a nearly free validation estimate — no separate hold-out needed. It isn't valid for time series or grouped data, for the same reasons random cross-validation isn't.

Extremely Randomised Trees pick the threshold for each candidate feature at random instead of searching for the best one, and by default train on the full dataset rather than bootstrap samples. Each tree is weaker but the trees are less correlated and much faster to build, so the ensemble often matches a random forest with lower variance — a good, cheap member for an ensemble.

When the model must be explained or audited — a depth-3 tree can be read aloud as rules — or as a surrogate that approximates a complex model's behaviour for explanation. Also, because a trained tree is just nested if-statements, it compiles trivially to C for embedded targets.

Tabular data with mixed numeric and categorical features, up to millions of rows — sensor summaries, logs, engineering parameters. They usually beat neural networks there, need little preprocessing (no scaling, native missing values) and train in minutes. Neural networks win on raw images, audio, text and long raw sequences.

It uses the first and second derivatives (gradient g and hessian h) of the loss for each row. For a candidate split, gain ≈ ½[G_L²/(H_L+λ) + G_R²/(H_R+λ) − (G_L+G_R)²/(H_L+H_R+λ)] − γ, where G and H are summed over each side. It takes the split with the highest gain and only keeps it if gain exceeds γ. λ shrinks leaf values; γ is a minimum gain to split.

XGBoost: grows trees level by level; robust default. LightGBM: grows leaf-wise (always splits the best leaf) on histogram-binned features — much faster on large data, but overfits more easily on small data. CatBoost: handles categorical features natively with ordered target statistics, which avoids target leakage; strong out of the box.

learning_rate with n_estimators chosen by early stopping; tree size (max_depth or LightGBM's num_leaves); min_child_weight / min_data_in_leaf; row and column subsampling (subsample, colsample_bytree); L1/L2 on leaf weights (alpha, lambda); and gamma, the minimum gain to split.

Fix a moderate learning rate (0.05–0.1) and use early stopping on a validation fold for the number of trees. Tune tree size and min-leaf size, then subsampling, then L1/L2. Finally lower the learning rate and raise the number of trees for the last bit of accuracy.

Three built-in kinds: split count (how often a feature is used), gain (total loss reduction it delivers) and cover. Better: permutation importance on validation data (drop in score when a feature is shuffled) and SHAP values, which give consistent per-prediction attributions.

You force the prediction to only increase (or decrease) with a feature, e.g. wear should never fall as operating hours rise. It removes physically impossible wiggles, makes the model easier to trust, and usually costs little accuracy.

Voting/averaging: average the models' probabilities, optionally weighted. Blending: train a meta-model on predictions for one held-out split. Stacking: train it on out-of-fold predictions for every training row, so it uses all the data. Stacking is the most data-efficient; averaging is the hardest to overfit.

When the members make different errors. Three boosted-tree libraries on the same features are highly correlated, so the gain is often small; mixing model families (trees with a linear model or a neural network) or different feature sets helps more. Always compare the ensemble against its best single member.

State, in order: the members and why each (e.g. ExtraTrees for variance, XGBoost and LightGBM for accuracy); how they were combined (averaged probabilities, weights tuned on out-of-fold predictions, or a meta-model); how the decision threshold was set if you optimised macro-F1; the validation scheme behind the number; and how much the ensemble beat the best single model. Precision about the combination method is what interviewers probe.

The discrete Fourier transform of N samples: amplitude and phase at N frequency bins from 0 to fs. Bin spacing is Δf = fs/N = 1/T, where T is the record length in seconds. Usable range is up to the Nyquist frequency fs/2.

The FFT treats the record as one period of an endlessly repeating signal. If a sine doesn't complete a whole number of cycles, the repeated record has a jump at the edges, and the sine's energy spreads into neighbouring bins and far-off sidelobes, hiding weaker components.

They taper the record to zero at both ends, removing the edge jump, so sidelobes drop sharply. The cost is a wider main lobe (poorer resolution) and lost energy, which you correct with an amplitude or energy correction factor.

Hann: the general default, first sidelobe about −31 dB and sidelobes falling fast; good for random signals and Welch averaging. Hamming: lower first sidelobe (about −43 dB) but sidelobes fall slowly; good for separating close tones of similar level. Flat-top: very wide main lobe but amplitude error under about 0.01 dB; use when the exact amplitude of a tone matters, as in calibration. Rectangular is right only for transients that die out within the record, or signals periodic in the window.

The power spectral density shows how a signal's power is distributed over frequency, in units per Hz. A single FFT periodogram of a random signal is very noisy: its standard deviation is about as large as the value itself, however long the record. You need averaging.

Split the record into segments (often 50% overlap with a Hann window), window each, take the FFT, and average the squared magnitudes. Variance falls roughly with the number of averages. The trade-off: shorter segments mean more averages but coarser Δf.

The window down-weights each segment's edges, so data there would be under-used. Overlapping recovers it and gives more averages from the same record. Beyond about 50–67% overlap the extra segments are highly correlated and add little.

G_xy(f): the average of X*(f)·Y(f) across segments, for input x and output y. Its magnitude shows shared power at each frequency, and its phase the time or phase lag between them. It's the building block of frequency-response and coherence estimates.

γ² = |G_xy|² / (G_xx·G_yy), between 0 and 1 at each frequency: the fraction of the output explained linearly by the input. Low coherence means noise, non-linearity, leakage or an unmeasured input. Check it before trusting any frequency-response estimate.

H1 = G_yx / G_xx is unbiased when noise is on the output and biased low when the input is noisy. H2 = G_yy / G_xy is unbiased when noise is on the input and biased high with output noise. In a structural test, output SNR is worst at antiresonances, so H1 is better there; at resonances the shaker force drops and input noise dominates, so H2 is better. H1/H2 = γ², so where coherence is high they agree.

Identify where the noise enters. If the input measurement is clean and the response sensor noisy, use H1; if the force or input signal is noisy, use H2; if both, consider Hv (a geometric-mean / total-least-squares estimate). Low SNR also calls for more averages, and coherence tells you where the estimate is unreliable.

Band powers from a Welch PSD in physically meaningful bands, dominant frequency and its amplitude, spectral centroid, and for vibration the kurtosis and crest factor (peak over RMS), which rise early with bearing faults. Order tracking normalises by shaft speed for rotating machinery.

The controller computes the error between the setpoint and the measurement. Its output is Kp·e + Ki·∫e dt + Kd·de/dt: the proportional term reacts to the current error, the integral term to accumulated error, the derivative term to how fast the error is changing. Tuning the three gains trades speed against overshoot and stability.

When the actuator saturates (a valve fully open, a dosing limit reached), the error persists and the integral keeps growing. When conditions change, the huge stored integral causes a long overshoot. Fixes: clamp the integrator, or stop integrating while saturated.

Differentiating a noisy sensor amplifies high-frequency noise, making the actuator jitter. It's usually low-pass filtered or computed on the measurement rather than the error, to avoid a spike when the setpoint jumps.

Rarely the PID loop itself. More often the calibrated lookup maps and feedforward terms around it — e.g. how much reductant to dose for a given exhaust state — or a virtual sensor estimating a quantity that's expensive or slow to measure, or a model-predictive controller that plans ahead using a learned model. The PID stays as a robust feedback layer.

State: sensor readings (exhaust temperature, flow, NOx upstream and downstream, catalyst temperature and age). Action: dosing rate or setpoint adjustments. Reward: minus NOx emitted, minus a penalty for reductant use and for ammonia slip, with hard limits as constraints. Training would happen in a simulator or on logged data.

Q-learning needs a max over actions, which is awkward for continuous actions. Policy-gradient and actor-critic methods (PPO, SAC, TD3) output continuous actions directly, so they are the natural fit. With only logged data, use an offline method.

Exploration is unsafe on real hardware; a learned policy has no stability or performance guarantee like a tuned PID; it can exploit simulator errors that don't exist in reality; behaviour on rare states is untested; and regulators need predictable, explainable behaviour. Mitigations: train in simulation, constrain actions, wrap it in a rule-based safety shield, evaluate offline, and test hardware-in-the-loop.

The relationship between inputs and the target changes over time. Types: sudden (a new sensor firmware), gradual or incremental (catalyst ageing, component wear), and recurring (seasons). Data drift — inputs changing while the relationship holds — is a different problem.

Watch prediction residuals once ground truth arrives, with change detectors like Page-Hinkley or ADWIN; watch input distributions (PSI, KS tests); and compare against a physics model or a reference fleet. For slow drift, plot error against age or mileage, not just time.

If ageing is measurable, add it as a feature — operating hours, thermal load history or an estimated health index — so one model spans the whole life. Otherwise retrain on a recent sliding window or weight recent data more, or update incrementally with an online learner. Validate each update before deploying.

A TCN uses causal, dilated 1-D convolutions: training is fully parallel, gradients are stable, and the receptive field grows exponentially with depth but is fixed. An LSTM processes steps sequentially — slower to train, harder gradient flow — but carries a compact state, so inference on a stream is cheap per step and context is not hard-capped. TCNs often match or beat LSTMs on benchmarks; LSTMs remain attractive on microcontrollers for step-by-step streaming.

With kernel size k and dilations doubling each layer (1, 2, 4…), the receptive field is roughly 1 + (k−1)(2^L − 1) steps after L layers. Anything further back is invisible, so choose depth to cover the slowest dynamics you care about, such as catalyst thermal lag.

Feedforward: a calibrated lookup table (a map) that sets the actuator from the operating point — e.g. reductant dose from engine speed, load, exhaust temperature and flow — before any error appears. Feedback: a PID loop that corrects the remaining error using a sensor. The map does most of the work quickly; the PID cleans up what the map got wrong.

Using different PID gains at different operating points — looked up from a map of speed, load or temperature — because a plant behaves differently across its range. It's the classical way to handle non-linearity, and the natural place an ML model can provide smoother or better-tuned gains.

Three common places: replacing or correcting the feedforward map with a learned model that generalises better between calibration points; acting as a virtual sensor that estimates something not directly measured, like stored ammonia on the catalyst; or providing a learned plant model for a model-predictive controller. The PID feedback usually stays as the safety net.

A prior over functions: any finite set of function values is jointly Gaussian, defined by a mean function (often zero) and a kernel k(x, x′) giving the covariance between any two inputs. Conditioning on observed data gives a closed-form posterior mean and variance at every new point.

Your assumptions about the function: smoothness, length-scale (how far apart inputs must be before values become unrelated), periodicity, and noise level. RBF assumes infinitely smooth functions; Matérn (ν = 3/2 or 5/2) allows rougher, more physical behaviour; kernels can be added and multiplied to combine structure.

k(x, x′) = σ_f² · exp(−‖x − x′‖² / 2ℓ²), plus a noise term σ_n² on the diagonal. ℓ, the length-scale, sets how quickly correlation decays; σ_f² the vertical scale of variation; σ_n² the observation noise. With ARD, each input dimension gets its own ℓ, which doubles as a relevance measure.

By maximising the log marginal likelihood of the data, integrating out the function. It has a data-fit term and a complexity penalty (the log-determinant of the covariance), so it automatically trades fit against flexibility — Occam's razor built in. Gradient-based, with several restarts because it can have multiple optima.

Small data (tens to a few thousand points), smooth physical relationships, and a need for uncertainty that grows away from the data. Common in experimental science, calibration, surrogate modelling of expensive simulations, and Bayesian optimisation.

Exact inference inverts an n × n matrix: O(n³) time and O(n²) memory, so it becomes impractical past roughly 10,000 points. Sparse GPs use m ≪ n inducing points (about O(nm²)); structured kernels and GPU libraries (GPyTorch) push further.

A GP that models several related outputs jointly, so learning one helps predict the others. The common form, the linear model of coregionalisation, writes the covariance as a product of an input kernel and a matrix of correlations between outputs. Useful when outputs are physically coupled, such as temperatures at several points along a combustor.

Lead with the problem (for example, reconstructing a physical field from a few measurements), why a GP (small data, smooth behaviour, uncertainty needed), which kernel and how its hyperparameters were fitted, whether outputs were modelled jointly and why, and how the predicted uncertainty was checked against held-out or experimental data.

The posterior mean of a GP equals the kernel ridge regression solution with the same kernel and regularisation. What the GP adds is the predictive variance and a principled way, the marginal likelihood, to choose hyperparameters.

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.

Put the model in eval mode and export to ONNX with fixed input shapes and a chosen opset. Check it with onnxruntime against PyTorch on golden test vectors. Generate C code from the ONNX graph — or hand-write it for a small network — with static buffers and, if needed, fixed-point arithmetic. Compare the C output against onnxruntime on the same vectors, then on the target processor, and climb MIL → SIL → PIL → HIL before it controls anything.

model.eval() first, so dropout is off and batch norm uses running statistics. Fixed input shapes unless you truly need dynamic axes — embedded code generators want static shapes. An opset your target toolchain supports. Operators the toolchain supports — avoid exotic layers. Then run onnx.checker and look at the graph (e.g. in Netron) to see what was actually exported.

Keep a fixed set of golden vectors — real inputs covering the operating range plus edge cases — with PyTorch's outputs. Run them through onnxruntime, the generated C on a PC, and the C on the target, and compare with a stated tolerance (e.g. max absolute error below 1e-5 for float, a few LSBs for fixed-point). Automate it so every re-export is checked.

Options, roughly from simplest to most industrial: hand-write the C for a small MLP or GRU (a few matrix–vector products and activations — fully transparent); open-source generators such as onnx2c; compilers with ahead-of-time C output such as Apache TVM; TensorFlow Lite Micro if you go via TFLite; and in automotive, often MATLAB/Simulink — import the network, then generate C with Embedded Coder — because the rest of the control software already lives there. Name what the team uses and why.

No dynamic memory allocation — all buffers static and sized at compile time. A bounded, predictable worst-case execution time that fits the control task's period (e.g. every 10 ms). Limited RAM and flash. Sometimes no or slow floating point. Coding standards such as MISRA C, integration as a software component in an AUTOSAR architecture, and functional-safety processes (ISO 26262).

Count it: 20 inputs → 64 → 64 → 1 has 20·64 + 64·64 + 64·1 = 5,440 weights plus 129 biases ≈ 5,600 parameters — about 22 KB in float32 or 5.6 KB in int8, plus a few hundred bytes of activation buffers. Doing this arithmetic out loud shows you design for the target from the start.

Use fixed-point arithmetic: represent values as integers with an implied binary point (Q-format, e.g. Q15), choose scales per layer from the observed ranges, use wider accumulators for sums, and saturate rather than overflow. It's the same idea as int8 quantisation, applied by hand or by the code generator — and it must be re-verified against the float model.

Export a single-step function — inputs and previous hidden state in, output and new hidden state out — and call it once per control cycle, keeping the state in a static buffer. Define what happens at start-up and after a sensor fault (reset the state). A TCN instead keeps a ring buffer of the last N inputs.

Stages of in-the-loop testing. MIL: the model runs with a simulated plant. SIL: the generated C code runs on a PC against the simulator. PIL: the code runs on the target processor, checking numerics and timing. HIL: the real ECU runs against a real-time simulation of the engine and sensors. Each step replaces one simulated piece with the real one.

Decide the target first: available memory, cycle time, floating point or not, supported operators. Then prefer the smallest model that meets accuracy — gradient-boosted trees (which compile to nested if-statements), a small MLP, or a GRU — over a large network you'd have to compress later. Simplicity also makes verification and safety arguments easier.

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.