Glossary
328 terms, each defined in one or two sentences, with links to where the idea is explained properly.
A
- A/B testing
- Serving two model versions to randomly assigned groups of users and comparing a business or quality metric between them. It measures real effect rather than offline score, and it needs enough traffic to reach a significant result.
- Accuracy
- The fraction of predictions that are correct. It is the obvious metric and a misleading one whenever classes are imbalanced, since predicting the majority class every time can score highly.
- Activation function
- The non-linear function applied to each unit's weighted sum, without which stacked layers would collapse into one linear map. ReLU and its variants such as GELU and SiLU are standard in hidden layers, with sigmoid and softmax reserved for outputs.
- Activation patching
- Testing whether a part of a network matters for a behaviour by replacing its activation with the value from a different input and watching how the output changes. It gives causal evidence, unlike reading off attention or gradients.
- Actor-critic
- An RL design with two learned parts, an actor that chooses actions and a critic that estimates value and tells the actor how good each action was. Most modern policy-gradient methods take this form.
- Adam
- An optimiser that keeps running averages of both the gradient and its square for every parameter and uses them to scale each step individually. It needs little tuning and is the default for most deep learning work.
- AdamW
- Adam with weight decay applied directly to the parameters rather than folded into the gradient, which makes the decay behave as intended. It is the optimiser used to train most transformer models.
- Advantage
- How much better an action turned out than the average expected from its state, used in place of the raw return to reduce noise in policy-gradient updates. GRPO estimates it by comparing samples within a group.
- Adversarial example
- An input altered in a way imperceptible to a person that makes a model give a confidently wrong answer, such as an image with carefully computed pixel noise. They show that model decision boundaries differ from human ones in ways that can be exploited.
- Agent
- A program that runs a model in a loop, letting it call tools, read the results and decide what to do next until a task is finished. The model supplies the judgement and the surrounding code supplies the tools, limits and memory.
- Agentic workflow
- A fixed sequence of model calls and tool steps designed by a developer, as opposed to an agent that decides its own steps. Workflows are more predictable and cheaper to test, and they cover many tasks that are marketed as agents.
- AI engineer
- A recent title for engineers who build products on top of foundation models through APIs, prompting, retrieval and agents, rather than training models themselves. The skills are closer to software engineering and evaluation than to statistics.
- AI governance
- The policies, processes and roles an organisation uses to decide how models are built, tested, deployed and monitored, including who signs off on risk. It overlaps with regulation such as the EU AI Act and with safety engineering.
- Alignment
- The work of making a model's behaviour match what its developers and users intend, including following instructions, refusing harmful requests and being honest about uncertainty. In practice it covers instruction tuning, preference training and the evaluation around them.
- ANN
- Short for artificial neural network. In retrieval contexts the same letters mean approximate nearest neighbour search, so check which is meant.
- Apache-2.0 and MIT
- The two permissive open-source licences most often used for model weights and code, allowing commercial use and modification with attribution. Apache-2.0 adds an explicit patent grant, which is why many companies prefer it.
- Applied scientist
- A title used mainly by large technology companies for researchers who apply and extend ML methods on product problems, usually with a doctorate. It overlaps heavily with research scientist and senior ML engineer.
- Approximate nearest neighbour (ANN) search
- Finding vectors close to a query without comparing against every vector in the index, by accepting a small chance of missing the true closest ones. It is what makes search over millions of embeddings fast enough to serve.
- Artificial neural network
- A model built from layers of simple units, each computing a weighted sum of its inputs followed by a non-linear activation. The weights are learned, and with enough layers and data such networks can approximate very complicated functions.Hub: deep learning. Related: MLP (multilayer perceptron), Activation function, Weights, Deep learning
- ASR (automatic speech recognition)
- Turning recorded speech into text. Current systems are encoder-decoder or CTC transformers trained on hundreds of thousands of hours of audio, and they are scored by word error rate.
- Attention
- A mechanism that lets each position in a sequence gather information from other positions, weighting them by how well a learned query matches each learned key. Self-attention relates positions within one sequence, and multi-head attention runs several such lookups side by side.
- Attention map
- A visualisation of attention weights showing which tokens or patches a position attended to. It is tempting to read as an explanation, but attention weights are only loosely related to what the model actually used.
- Autoencoder
- A network trained to compress its input to a small code and then reconstruct the input from that code. The bottleneck forces it to learn the important structure, and the encoder half is useful for compression, denoising and anomaly detection.
- Autoregressive
- Generating a sequence by predicting each element from the ones before it, then feeding the prediction back as input. It is why language models produce text token by token and why generation cost grows with output length.
B
- Backdoor (trojan)
- Hidden behaviour trained into a model that activates only on a specific trigger, such as a rare phrase, and is otherwise invisible in evaluation. It is the usual goal of data poisoning and is hard to detect after the fact.
- Backpropagation
- The algorithm that computes the gradient of the loss with respect to every weight in a network by applying the chain rule backwards from the output. Automatic differentiation in PyTorch and JAX does it for you, but understanding it explains most training failures.
- Bagging (bootstrap aggregating)
- Training several copies of a model on random resamples of the training set and averaging their predictions. It reduces variance, which is why it helps unstable learners such as deep trees.
- Base model
- A pretrained model that has not been instruction tuned, so it continues text rather than answering questions. It is the right starting point for fine-tuning and the wrong one for chatting.
- Batch inference
- Running a model over a large set of inputs offline on a schedule rather than answering requests one at a time. It is cheaper and simpler than online serving whenever predictions are not needed immediately.
- Batch normalisation
- A layer that standardises each channel's activations using the mean and variance of the current batch, then rescales them with learned parameters. It stabilises training of convolutional networks but behaves differently at inference, which causes surprises.
- Batch size
- The number of training examples processed together before the parameters are updated once. Larger batches use hardware more efficiently and give smoother gradients, but need more memory and sometimes a higher learning rate.
- Bayesian (methods)
- An approach that treats model parameters as uncertain quantities with probability distributions, updated from a prior belief as data arrives. It gives calibrated uncertainty at the price of harder computation, and the word also labels naive Bayes and Bayesian optimisation.
- Benchmark
- A fixed dataset and scoring protocol used to compare models on the same task. A benchmark number means little without the name, the version and the date it was read, and public benchmarks leak into training data over time.
- bfloat16
- A 16-bit floating-point format that keeps the 8-bit exponent of 32-bit floats and gives up precision in the mantissa instead. It covers the same range as float32, which avoids the overflow problems of float16 and makes it the standard training precision on modern hardware.
- Bias (fairness)
- A model producing systematically worse or different outcomes for some groups of people, usually because the training data under-represents them or encodes past discrimination. It is measured by comparing error rates across groups, and it is distinct from statistical bias.
- Bias (statistical)
- A systematic error in a model's predictions that persists no matter how much data it sees, usually because the model class cannot represent the true relationship. The word also names the constant term added in a linear layer.
- Bias-variance trade-off
- The tension between a model that is too rigid to fit the data (high bias) and one so flexible that it fits the noise in any particular sample (high variance). Model selection is largely a search for the point between the two.
- BM25
- A keyword ranking function that scores documents by how often the query terms appear, discounted for common terms and long documents. It needs no model, handles rare words and codes well, and remains a strong baseline that embedding search often fails to beat alone.
- Bounding box
- The rectangle, given by its corner or centre coordinates and size, that a detector predicts around an object. Box formats differ between libraries, and mixing them up is a classic bug.
- BPE (byte-pair encoding)
- A tokeniser-building algorithm that starts from single bytes or characters and repeatedly merges the most frequent adjacent pair until the vocabulary reaches a chosen size. It is the basis of the tokenisers used by GPT, Llama and most other current models.
C
- Calibration
- Whether a model's stated confidence matches its actual accuracy, so that predictions made with 80 percent confidence are right about 80 percent of the time. Many models are overconfident, and temperature scaling on a validation set is a common fix.
- Canary release
- Routing a small fraction of traffic to a new model version and expanding it only if the metrics hold up. It limits the damage from a bad release and is the usual way to roll out models in production.
- Catastrophic forgetting
- A model losing abilities it had before fine-tuning because the new training overwrote the weights that supported them. Low learning rates, mixing in general data and adapter methods all reduce it.
- Chain of thought
- Prompting or training a model to write out intermediate reasoning steps before giving an answer. It improves results on arithmetic and multi-step problems, and reasoning models build the behaviour in.
- Checkpoint
- A saved snapshot of a model's weights, and often its optimiser state, taken during or at the end of training. Published models are checkpoints, and intermediate ones let a crashed run resume.
- Chunking
- Splitting documents into pieces small enough to embed and to fit several into a prompt, usually a few hundred tokens with some overlap. Chunk boundaries that cut through a table or an argument are a frequent cause of poor RAG answers.
- Circuit
- A small subgraph of a network, a set of attention heads and neurons, that together implement one identifiable behaviour, such as copying a name from earlier in the text. Finding and verifying circuits is a core activity of mechanistic interpretability.
- Class imbalance
- A classification dataset in which some classes are far rarer than others, such as fraud among legitimate transactions. Accuracy becomes misleading, and resampling, class weights and metrics such as F1 or ROC-AUC are needed instead.
- Classification
- Predicting which of a fixed set of categories an input belongs to, such as spam or not spam. Binary classification has two classes, multiclass has several, and multilabel allows more than one at once.
- Classifier-free guidance
- A trick for conditional diffusion models that pushes each denoising step further in the direction the prompt suggests, by comparing the model's prediction with and without the prompt. Higher guidance follows the prompt more closely at the cost of variety and sometimes quality.
- CLIP
- A pair of encoders, one for images and one for text, trained contrastively on image and caption pairs so that matching pairs land close in a shared embedding space. It enables zero-shot image classification and provides the image encoder for many multimodal and text-to-image models.Hub: computer vision. Related: Contrastive learning, ViT (vision transformer), Multimodal, Text-to-image
- Clustering
- Grouping data points so that members of a group are more similar to each other than to the rest, without any labels saying what the groups are. Used for segmentation, deduplication and exploring an unfamiliar dataset.
- CNN (convolutional neural network)
- A network built from convolution and pooling layers that scan small filters across an image, so the same feature detector is reused at every position. CNNs were the dominant vision architecture from 2012 until vision transformers, and they remain efficient for small devices.
- Community licence
- A custom licence used by Meta for Llama and by others for similar releases, permitting most uses but adding conditions such as attribution, an acceptable-use policy and extra terms above a user threshold. Such models are open weights, restricted.
- Compute budget
- The total processing, usually quoted in GPU-hours or floating-point operations, available for training or running a model. It sets what is possible more than any other single resource, and estimates of frontier training runs reach hundreds of millions of dollars.Hub: careers and industry. Related: FLOPS, Scaling laws, GPU (graphics processing unit), Token pricing
- Confusion matrix
- A table with true classes as rows and predicted classes as columns, showing how many examples fell into each cell. Precision, recall and most other classification metrics are read straight off it.
- Constitutional AI
- An alignment approach from Anthropic in which a model critiques and revises its own responses against a written set of principles, and those revisions and AI-generated preferences are used for further training. It reduces the amount of human labelling needed for harmlessness training.
- Contamination
- Benchmark questions or answers appearing in a model's training data, which inflates its score without improving its ability. It is hard to rule out for any model trained on web text, and it is a form of data leakage.
- Context window
- The maximum number of tokens a model can attend to at once, covering the prompt and the output together. Anything beyond it is cut off, and attention cost grows with its length, so a large window is not free.
- Continuous batching
- Scheduling LLM requests so that new ones join the batch as soon as others finish, rather than waiting for a whole batch to complete. It keeps the GPU busy and is standard in serving engines.
- Contrastive learning
- A training objective that pulls representations of matching pairs together and pushes non-matching pairs apart. It is how embedding models and CLIP learn without explicit labels for every example.
- Convolution
- Sliding a small learned filter over an input and computing a weighted sum at each position, producing a map of where the filter's pattern occurs. Early layers learn edges and textures, later ones learn parts and objects.
- Cosine similarity
- The cosine of the angle between two vectors, which measures how similar their directions are regardless of their lengths. It is the usual similarity score between embeddings, and for normalised vectors it equals the dot product.
- Cross-entropy
- The standard loss for classification, equal to the negative log of the probability the model assigned to the correct class. Language model pretraining is cross-entropy over the vocabulary at every token position.
- Cross-validation
- Estimating performance by splitting the data into k folds, training on all but one and testing on the held-out fold, then rotating and averaging. It uses small datasets fully and gives a spread of scores rather than a single lucky number.Hub: evaluation and benchmarks. Related: Validation set, Stratified sampling, Hyperparameter, Data leakage
- CTC (connectionist temporal classification)
- A loss function for mapping a long input sequence, such as audio frames, to a shorter output sequence, such as characters, without knowing which frames align to which characters. The model may emit a blank symbol, and repeated symbols between blanks are collapsed.
- CUDA
- NVIDIA's programming platform and libraries for running general computation on its GPUs. PyTorch, JAX and almost every deep learning tool are built on it, which is the main source of NVIDIA's position in the market and of the difficulty of moving to other hardware.
D
- Data augmentation
- Creating extra training examples by transforming existing ones in ways that preserve the label, such as flipping or cropping images or paraphrasing text. It is a cheap form of regularisation that also teaches the model which variations do not matter.
- Data drift
- The distribution of a model's live inputs moving away from the training data, for example new product categories or a changed sensor. It often precedes model drift and can be detected without any labels.
- Data exfiltration
- Getting private data out of a system through a model, for example by injecting instructions that make an agent include secrets in a web request or a rendered image link. Limiting what tools an agent can call and what it can send out is the main defence.
- Data leakage
- Information from outside the training set, often from the test set or from the future, reaching the model during training or feature construction. It produces evaluation scores that collapse in production, and it is the most common way a project fools itself.
- Data parallelism
- Training on several devices by giving each a full copy of the model and a different slice of each batch, then averaging their gradients. It is the simplest way to scale and works until the model no longer fits on one device.
- Data poisoning
- Planting examples in a training set so the resulting model behaves in a way the attacker wants, such as misclassifying a specific input. Web-scale scraping makes it feasible, and a few hundred documents can be enough.
- Data scientist
- A role centred on analysing data to answer questions and build predictive models, typically in notebooks with statistics and classical ML. Its boundary with analytics on one side and ML engineering on the other varies from company to company.
- Dataset
- A collection of examples assembled for training or evaluating a model, with a documented source, format and licence. How it was gathered and cleaned shapes what the model can learn more than most architectural choices.
- Decision tree
- A model that classifies or predicts by asking a sequence of yes or no questions about the features, each splitting the data further. Single trees are easy to read but overfit readily, so they are usually combined into ensembles.
- Decoder
- The part of a model that generates output tokens one at a time, each attending only to earlier positions. Nearly every chat model is a decoder-only transformer.
- Deep learning
- Machine learning with neural networks of many stacked layers, trained end to end by gradient descent. The depth lets the network build up its own features from raw inputs such as pixels, audio samples or tokens.Hub: deep learning. Related: Artificial neural network, Backpropagation, Machine learning, Transformer
- Denoising
- Predicting the clean version of a corrupted input, the single task a diffusion model is trained on at many noise levels. Generation is the repeated application of this step.
- Differential privacy
- A mathematical guarantee that a computation's output changes only slightly whether or not any one person's record is included, achieved by adding calibrated noise. Applied to training it limits what a model can memorise about any individual, at some cost in accuracy.
- Diffusion model
- A generative model trained to remove a small amount of noise from a sample, then run repeatedly from pure noise to produce an image, audio clip or video. It is the method behind most current image generators.Hub: generative models. Related: Denoising, Latent diffusion, Flow matching, Classifier-free guidance
- Dimensionality reduction
- Mapping high-dimensional data to fewer dimensions while keeping as much of its structure as possible, for visualisation, compression or noise removal. PCA is the linear workhorse, and t-SNE and UMAP are the usual choices for plots.
- Discount factor
- A number between 0 and 1 that reduces the weight of rewards the further they lie in the future. It keeps the sum of rewards finite and expresses how far ahead the agent should plan.
- Distillation
- Training a smaller student model to reproduce the outputs or internal behaviour of a larger teacher model. It transfers much of the teacher's ability at a fraction of the inference cost, and generating synthetic training data from a strong model is a loose form of it.
- DPO (direct preference optimisation)
- A method that trains a model on pairs of preferred and rejected responses directly, using a loss that stands in for the reward model and RL loop of RLHF. It is simpler and cheaper to run, which has made it the common choice for open models.
- Dropout
- Randomly zeroing a fraction of a layer's activations during each training step so that no unit can rely on any particular other unit. It is turned off at inference, and it remains a simple, effective regulariser for small and medium networks.
E
- Embedding
- A vector of a few hundred to a few thousand numbers that represents a piece of text, an image or another item so that similar items end up close together. Embeddings are the data structure behind semantic search, recommendation and clustering.
- Embedding model
- An encoder trained, usually by contrastive learning, to map inputs to embeddings where distance reflects meaning. Small ones run on a laptop in milliseconds, and the choice of model fixes the vector dimension for the whole index.
- Encoder
- The part of a model that reads an input and turns it into a representation, with every position able to see every other. BERT-style models and embedding models are encoders, and they are what you want for classification and retrieval rather than generation.
- Ensemble
- A prediction made by combining several models, by voting, averaging or feeding their outputs into another model. Ensembles usually beat any single member because their errors are partly independent.
- Epoch
- One full pass through the training set. Training is usually described as a number of epochs, though large language models often see most of their data only once.
- EU AI Act
- The European Union regulation, in force since August 2024 with obligations phasing in through 2027, that classifies AI systems by risk and sets requirements for high-risk uses and for general-purpose models. It applies to any provider whose systems are used in the EU.
- Evaluation harness
- Software that runs a model over a set of test cases, scores the outputs and reports the results in a repeatable way. For language models it handles prompting, sampling settings and answer extraction, each of which can move the score by several points.
- Experiment tracking
- Recording the code version, data, hyperparameters, metrics and artefacts of every training run so results can be compared and reproduced. Tools such as MLflow and Weights and Biases do this, and a spreadsheet is better than nothing.
- Explainability
- Producing a human-readable account of a model's decision, such as which features counted most, often for a user or regulator rather than a researcher. Explanations can be faithful to the model or merely plausible, and the two are not the same.
- Exploding gradient
- Gradients growing without bound through deep or recurrent networks, producing huge updates and a loss that jumps to NaN. Gradient clipping and lower learning rates are the usual response.
- Exploration versus exploitation
- The choice between trying actions whose value is uncertain and repeating those known to pay off. Too little exploration locks in a poor strategy, too much wastes reward, and every RL algorithm has some rule for the balance.
F
- F1 score
- The harmonic mean of precision and recall, giving one number that is high only when both are. It is the usual summary for imbalanced classification, and the macro-averaged version treats every class equally.
- Feature
- One measurable property of an input that a model reads, such as a column in a table or a pixel value. In deep learning the word also covers properties the network invents for itself in its hidden layers.
- Feature attribution
- Assigning each input feature a score for how much it contributed to a particular prediction. Gradient-based methods, SHAP and perturbation methods all do this with different assumptions and often different answers.
- Feature engineering
- Transforming raw inputs into columns a model can use well, such as extracting the day of the week from a timestamp or taking the ratio of two measurements. It matters most for tabular data and classical models, where the model will not invent such features itself.
- Feature scaling
- Rescaling each input column so that features with large ranges do not dominate those with small ones, typically by standardising to zero mean and unit variance or squashing to a fixed interval. Distance-based and gradient-based models are sensitive to it, tree models mostly are not.
- Feature store
- A system that computes, stores and serves features so the same definitions are used for training and for live inference. It exists to prevent the mismatch between offline and online features that quietly degrades production models.
- Federated learning
- Training a shared model across many devices or organisations that each keep their data local, sending only model updates to a central server. It reduces data movement but updates can still leak information, so it is often combined with differential privacy.
- Few-shot
- Including a handful of worked examples of the task in the prompt so the model can copy their pattern. It is the cheapest way to fix output format and style problems before reaching for fine-tuning.
- FID (Fréchet inception distance)
- A score for generated images that compares the statistics of their features, taken from a pretrained classifier, with those of real images. Lower is better, and it is sensitive to the sample size and the reference set.
- Fine-tuning
- Continuing to train a pretrained model on a smaller, task-specific dataset so its behaviour shifts towards that task. It ranges from updating every weight to touching only a few adapter matrices.
- Flash attention
- An implementation of attention that computes the result in tiles that fit in on-chip GPU memory, so the full attention matrix is never written out. It gives the same answer as standard attention with far less memory traffic, which makes long contexts practical.
- FLOPS
- Floating-point operations per second, the headline measure of compute, with the training cost of a model quoted as a total count of operations. Peak figures depend on precision and are rarely reached, so measured utilisation is the number to watch.Hub: hardware and acceleration. Related: Tensor core, Compute budget, Memory-bound and compute-bound
- Flow matching
- A way of training generative models to learn a direct path from noise to data as a vector field, which can then be followed in a few straight steps. It generalises diffusion training, is simpler to derive and is used by several recent image and video models.
- Foundation model
- A large model pretrained on broad data so that it can be adapted to many downstream tasks by prompting or fine-tuning rather than trained from scratch for each. The term covers language, vision and multimodal models.Hub: transformers and llms. Related: LLM (large language model), Pretraining, Fine-tuning, Base model
- Frontier model
- A model at or near the most capable level available at a given time, usually from one of a handful of well-funded labs. The term is used in policy as well as marketing, and what counts as frontier moves every few months.Hub: careers and industry. Related: LLM (large language model), Compute budget, AI governance, Scaling laws
- FSDP (fully sharded data parallel)
- PyTorch's method for spreading a model's parameters, gradients and optimiser state across devices and gathering each layer only when it is needed. It makes data parallel training possible for models that would not otherwise fit, and it is the usual choice for fine-tuning on a few GPUs.Hub: hardware and acceleration. Related: Data parallelism, Model parallelism, Gradient checkpointing
- Function calling
- A model emitting a structured request to run a named function with specific arguments, which the calling program executes before returning the result for the model to continue. Also called tool use, it is the basic mechanism agents are built on.Hub: prompting and agents. Related: Tool use, Agent, Structured output, MCP (Model Context Protocol)
G
- GAN (generative adversarial network)
- A pair of networks trained against each other, a generator that produces samples and a discriminator that tries to tell them from real data. GANs produced the first convincing synthetic faces, and they survive in vocoders and image upscalers although diffusion has replaced them for most image generation.Hub: generative models. Related: Diffusion model, Mode collapse, VAE (variational autoencoder), Vocoder
- Gated model
- A model repository on the Hugging Face Hub that requires accepting terms or requesting access before the files can be downloaded. Code must then authenticate with a token, which is a frequent setup problem for newcomers.
- Generalisation
- How well a model performs on data it was not trained on. It is the only thing that matters in practice, which is why evaluation on held-out data is treated so seriously.
- GGUF
- The single-file model format used by llama.cpp, holding quantised weights, the tokeniser and metadata together. It is the format most people use to run open models on laptops and phones.
- GPU (graphics processing unit)
- A processor with thousands of simple cores and very high memory bandwidth, built for graphics and now the workhorse of deep learning because neural networks are mostly large matrix multiplications. NVIDIA's data-centre parts dominate training, with AMD, Apple and others competing on inference.
- Gradient
- The vector of partial derivatives of the loss with respect to every parameter, pointing in the direction that increases the loss fastest. Training moves parameters the opposite way.
- Gradient boosting
- Building an ensemble by adding small trees one at a time, each fitted to the errors the previous ones still make. Libraries such as XGBoost, LightGBM and CatBoost implement it and dominate tabular competitions.
- Gradient checkpointing
- Saving memory during training by discarding intermediate activations and recomputing them during the backward pass. It trades roughly a third more compute for fitting larger models or batches on the same hardware.
- Gradient clipping
- Rescaling the gradient whenever its norm exceeds a threshold, so a single bad batch cannot throw the parameters far off. Nearly every transformer training recipe clips at a norm of about 1.
- Gradient descent
- The basic training procedure of repeatedly computing the gradient of the loss and taking a small step against it. The step size is set by the learning rate, and almost every optimiser in use is a variation on this loop.
- Ground truth
- The reference answers an evaluation compares predictions against, usually human labels. The phrase hides how noisy labels often are, and disagreement between labellers sets a ceiling on measurable accuracy.
- Grounding
- Tying a model's answer to specific supplied evidence, such as retrieved passages or tool results, so claims can be checked against a source. A grounded answer can still be wrong, but the reader can see where it came from.
- Grouped-query attention (GQA)
- Having several attention heads share one set of keys and values, which shrinks the KV cache by that factor with little loss in quality. Most open models released since 2023 use it.
- GRPO (group relative policy optimisation)
- A reinforcement learning method for language models that samples several responses to each prompt and scores each one against the group's average, removing the need for a separate value network. It became known through its use in training reasoning models on verifiable tasks such as maths.
- Guardrails
- Checks placed around a model, such as input filters, output classifiers, allowed-tool lists and rate limits, that enforce policy independently of the model's own training. They are the engineering layer of safety and should not be the only layer.
H
- Hallucination
- The field's term for a model producing a confident, fluent answer that is wrong or invented, such as a citation that does not exist. It follows from predicting plausible text rather than checking facts, and no model is free of it.
- HBM (high bandwidth memory)
- Stacked memory mounted beside a GPU or accelerator die and connected by thousands of wires, giving bandwidth of several terabytes per second. Its capacity, 80 GB to 288 GB per device at the time of writing, sets the largest model that fits on one accelerator.
- HNSW (hierarchical navigable small world)
- A graph-based index for approximate nearest-neighbour search in which each vector links to nearby vectors across several layers, so a query walks the graph towards its neighbours. It is the index most vector databases use by default.
- Hugging Face Hub
- The public repository where most open models, datasets and demos are published, with git-based storage, model cards and a download API used by the transformers library. It is the de facto distribution point for open weights.
- Hybrid search
- Combining keyword and embedding retrieval, typically by merging the two ranked lists, so that each covers the other's weaknesses. It is the default recommendation for production RAG.
- Hyperparameter
- A setting chosen before training rather than learned from data, such as the learning rate, batch size, tree depth or number of layers. Hyperparameters are tuned against the validation set, never the test set.
I
- Image classification
- Assigning a whole image one label from a fixed set, such as the thousand ImageNet classes. It is the simplest vision task and the usual way to pretrain a backbone for harder ones.
- Imputation
- Filling in missing values before training, by a constant, a column statistic or a prediction from the other columns. Which strategy is right depends on why the values are missing, and the fact of missingness is often worth keeping as its own feature.
- In-context learning
- A model picking up a task from examples or instructions in its prompt without any change to its weights. It is the ability that makes prompting work at all, and it strengthens with model scale.
- Indirect prompt injection
- Prompt injection delivered through content the model reads rather than by the user, such as a web page, email or document fed to an agent. It is the main security concern for agents with tools, since the injected text can trigger real actions.
- Inference
- Running a trained model on new inputs to produce predictions, as opposed to training it. For language models the cost of inference, measured in tokens per second and memory, usually dominates the lifetime cost of the system.
- Instruct model
- A base model that has been through instruction tuning and usually preference training, so it follows requests in a chat format. Model names mark this with suffixes such as Instruct, Chat or IT.
- Instruction tuning
- Fine-tuning a base language model on examples of instructions paired with good responses so that it answers requests rather than continuing text. It is what turns a raw pretrained model into something usable as an assistant.
- Interpretability
- The study of why a model produced a given output, from methods that attribute a prediction to input features through to reverse-engineering the computation inside the network. It serves debugging, safety and regulatory needs.
- IoU (intersection over union)
- The area where a predicted box or mask overlaps the true one divided by the area they cover together, ranging from 0 to 1. A detection usually counts as correct when IoU exceeds 0.5.
J
- Jailbreak
- A prompt crafted to make a model ignore its safety training and produce output it would normally refuse, through role-play, encoding tricks or many-shot pressure. Defences reduce the success rate but none has eliminated it.
- JAX
- Google's numerical library that combines a NumPy-like API with automatic differentiation, just-in-time compilation through XLA and easy mapping across devices. It is the main framework for TPU work and for research groups that want function transformations such as vmap and pmap.Hub: hardware and acceleration. Related: TPU (tensor processing unit), PyTorch, Gradient, Data parallelism
K
- k-means
- A clustering algorithm that places k centres in the data and alternates between assigning each point to its nearest centre and moving each centre to the mean of its points. You must choose k, and the result depends on the starting positions.
- k-NN (k-nearest neighbours)
- A method that predicts for a new point by looking up the k closest training examples and taking their majority label or average value. There is no training step, so all the cost falls on search at prediction time, which is also the idea behind vector search.
- Knowledge cutoff
- The date after which a model's training data contains nothing, so events beyond it are unknown to the model unless supplied in the prompt. Retrieval and tool use exist partly to work around it.
- KV cache
- The stored keys and values from attention for every earlier token, kept so each new token only needs to compute its own. It makes generation fast but grows with context length and batch size, and it is the main memory consumer during inference.Hub: efficient ml. Related: Attention, PagedAttention, Context window, Grouped-query attention (GQA)
L
- Label
- The known answer attached to a training example, such as the species in an iris record or the category of an image. Labels are what supervised learning tries to predict and what evaluation compares against.
- Latency
- The time from sending a request to receiving the response. For language models it splits into time to first token, which users feel, and time per output token, which sets how fast text streams.
- Latent diffusion
- Running the diffusion process in the compressed latent space of a VAE rather than on raw pixels, which cuts compute by a large factor. Stable Diffusion made it the standard design for text-to-image systems.
- Latent space
- The compressed internal representation a model maps inputs into, where nearby points correspond to similar inputs. Interpolating or editing in this space is how many generative and embedding tricks work.
- Layer normalisation
- Standardising the activations of each example across its features rather than across the batch, so it works for any batch size and for sequences. Transformers use it (or the RMSNorm variant) before or after every attention and MLP block.
- Leaderboard
- A published ranking of models on one or more benchmarks or on human preference votes. Rankings move as models are added and protocols change, so any figure quoted from one needs a date.
- Learning rate
- The multiplier applied to the gradient when updating parameters, so the size of each training step. Too high and the loss diverges, too low and training crawls, which is why it is the first hyperparameter to tune.
- Learning-rate schedule
- A rule for changing the learning rate over training rather than holding it fixed, typically a short warm-up from zero followed by a cosine or linear decay. Transformer training is sensitive to it, and a missing warm-up is a frequent cause of early divergence.
- Linear regression
- A model that predicts a number as a weighted sum of the input features plus a constant, fitted by minimising squared error. It is the simplest useful model and the baseline every other regressor should beat.Hub: classical ml. Related: Regression, MSE (mean squared error), Logistic regression, Gradient descent
- llama.cpp
- An open-source C and C++ inference engine for running quantised language models on ordinary CPUs, Apple Silicon and consumer GPUs. It defined the GGUF format and sits underneath Ollama and many desktop applications.
- LLM (large language model)
- A transformer trained on a very large text corpus to predict the next token, then usually tuned to follow instructions. Models from a few hundred million to over a trillion parameters all carry the name.
- LLM-as-judge
- Using a language model to grade another model's outputs, usually against a rubric or a reference answer, where exact matching is impossible. It scales cheaply but inherits the judge's biases, such as preferring longer answers and its own style.
- Logistic regression
- A linear model for classification that passes the weighted sum of features through a sigmoid to give a probability. Despite the name it is a classifier, and it remains hard to beat on small tabular problems.
- Logit lens
- Applying the model's final output layer to the activations at earlier layers to see what the model would predict at that depth. It gives a rough picture of how a prediction forms across the layers of a transformer.
- Logits
- The raw scores a model produces for each possible class or token before softmax turns them into probabilities. Temperature and other sampling controls operate on them.
- LoRA (low-rank adaptation)
- A fine-tuning method that freezes the original weights and learns a small pair of low-rank matrices added to each chosen layer. The trainable part is often under 1 percent of the model, so it fits on a single GPU or a laptop and the result ships as a small adapter file.Hub: fine tuning and alignment. Related: PEFT (parameter-efficient fine-tuning), QLoRA, Fine-tuning, Weights
- Loss function
- A formula that scores how far a model's predictions are from the targets, giving a single number that training tries to reduce. Mean squared error and cross-entropy are the two you will meet first.
M
- Machine learning
- Building programs whose behaviour is fitted to data rather than written out by hand. A learning algorithm adjusts a model's parameters until its outputs on example inputs match the outcomes you care about.
- Machine learning engineer
- An engineer who builds, trains and ships models as part of a software system, owning data pipelines, training code and serving. The role sits between data science and software engineering and in many teams has absorbed both.
- mAP (mean average precision)
- The standard detection score, obtained by averaging precision across recall levels for each class and then across classes, often at several IoU thresholds. Higher is better, and the exact protocol must be stated for numbers to be comparable.
- Markov decision process (MDP)
- The mathematical frame for reinforcement learning, with states, actions, a transition rule and a reward, where the next state depends only on the current state and action. Most RL algorithms assume the problem is one, at least approximately.
- MCP (Model Context Protocol)
- An open protocol, published by Anthropic in November 2024, for connecting models to tools, data sources and prompts through a standard client and server interface. It lets one tool server work with any client application that speaks the protocol.
- Mechanistic interpretability
- Reverse-engineering the internal computation of a trained network into human-understandable parts, such as identifying features in activations and the circuits that combine them. It treats the model as a program to be decompiled rather than a black box to be probed.Hub: interpretability. Related: Sparse autoencoder (SAE), Circuit, Superposition, Activation patching
- Mel spectrogram
- A spectrogram whose frequency axis is warped to the mel scale, which spaces bands the way human hearing does, with finer resolution at low frequencies. It is the standard input to speech recognisers and the standard intermediate output of speech synthesisers.
- Membership inference
- An attack that determines whether a particular record was in a model's training set, usually by noticing that the model is more confident on examples it has seen. It is a privacy risk for models trained on personal data and a test for memorisation.
- Memory bandwidth
- How many bytes per second a processor can move between its memory and its compute units. Generating each token of an LLM reads every weight once, so for small batches bandwidth rather than FLOPS sets the speed.
- Memory-bound and compute-bound
- A workload is memory-bound when the processor waits on data movement and compute-bound when it waits on arithmetic. LLM decoding at small batch sizes is memory-bound, which is why quantisation speeds it up and why batching raises throughput.
- MFCC (mel-frequency cepstral coefficients)
- A compact set of numbers per audio frame derived from the mel spectrogram, capturing the shape of the spectrum in a dozen or so values. They were the standard speech feature for decades and still appear in small keyword and speaker systems.
- Mixed precision
- Training or running a model with most arithmetic in 16-bit floating point while keeping a 32-bit master copy of the weights for updates. It roughly halves memory and can double throughput on tensor cores, and bfloat16 has made it safe by default.
- Mixture of experts (MoE)
- A transformer whose MLP layers are split into several expert sub-networks, with a small router sending each token to only a few of them. Total parameters can be large while the compute per token stays small, which is why such models quote total and active counts.
- MLOps
- The practices and tooling for getting models from a notebook into production and keeping them working there, covering versioning, pipelines, serving, monitoring and retraining. It borrows from DevOps but must also track data and models, not only code.
- MLOps engineer
- An engineer responsible for the pipelines, serving infrastructure and monitoring that keep models running in production. The role grew out of DevOps and platform engineering as teams found models needed their own operational tooling.
- MLP (multilayer perceptron)
- The plainest neural network, a stack of fully connected layers with an activation between each. It is the building block inside transformer blocks and the usual choice for tabular inputs.
- MLX
- Apple's array framework for machine learning on Apple Silicon, with a NumPy-like API, lazy evaluation and unified memory. Its mlx-lm package runs and fine-tunes open language models on a Mac.
- MMLU
- A multiple-choice benchmark of about 14,000 questions across 57 academic and professional subjects, used for years as the headline knowledge score for language models. Top models now score above 90 percent, so harder successors such as MMLU-Pro have taken over.
- Mode collapse
- A GAN failure in which the generator produces only a few kinds of output that fool the discriminator and ignores the rest of the data's variety. It is one of the reasons GAN training is hard to make reliable.
- Model
- A function with adjustable parameters that maps inputs to predictions, together with the values those parameters took after training. A linear regression with two coefficients and a 70 B parameter language model are both models in this sense.
- Model card
- A short structured document describing a model's intended use, training data, evaluation results, limitations and licence. The Hugging Face Hub expects one per repository, and the sections prompt the questions a user should ask.Hub: mlops and deployment. Related: Model registry, Hugging Face Hub, Model licence, Bias (fairness)
- Model drift
- A deployed model's accuracy declining over time because the world it predicts has changed since training. It is detected by monitoring and fixed by retraining, which is why production systems need a retraining path from the start.
- Model extraction
- Reconstructing a model's behaviour or weights by querying it repeatedly through an API and training a copy on the answers. It is a concern for providers of closed models, and distillation from a competitor's outputs is a commercial form of it.
- Model licence
- The legal terms attached to a model's weights, which may be a standard software licence, a custom community licence with use and scale restrictions, or a responsible AI licence with a list of forbidden uses. Read it before shipping, since it may differ from the code's licence.
- Model parallelism
- Splitting a single model across devices, either by layers (pipeline parallelism) or by cutting individual weight matrices (tensor parallelism), so that models larger than one device's memory can be trained or served. It needs fast links between the devices.
- Model registry
- A catalogue of trained model versions with their metadata, lineage and deployment status, so that the model serving traffic can always be identified and rolled back. It is the model equivalent of a package repository.
- Model serving
- Running a model behind an interface, usually an HTTP endpoint, so that other software can request predictions. The serving layer handles batching, concurrency, versioning and hardware placement, and for LLMs it is a specialised engine such as vLLM.
- Momentum
- An addition to gradient descent that keeps a running average of past gradients and steps along that instead of the raw gradient. It smooths noisy updates and speeds progress along consistent directions.
- Monitoring
- Watching a deployed model's inputs, outputs and performance over time to catch failures, drift and abuse. Unlike ordinary services, a model can be fully available and returning confident wrong answers, so monitoring must look at the predictions themselves.
- MSE (mean squared error)
- The average of the squared differences between predictions and targets, the standard loss and metric for regression. Squaring punishes large errors heavily, and its square root (RMSE) is in the units of the target.
- Multimodal
- A model that accepts or produces more than one kind of data, such as text together with images, audio or video. Most current frontier models take images as input, and some also take and emit speech.Hub: transformers and llms. Related: CLIP, ViT (vision transformer), LLM (large language model), Text-to-image
N
- Naive Bayes
- A fast classifier that applies Bayes' rule under the simplifying assumption that features are independent given the class. The assumption is almost never true, yet it works well for text classification such as spam filtering.
- Neural audio codec
- A learned encoder and decoder that compresses audio into a short sequence of discrete tokens and reconstructs it. Such tokens let language models generate and understand speech and music with the same machinery they use for text.
- Normalising flow
- A generative model built from a chain of invertible transformations, so that the exact probability of any sample can be computed. Flows are less common than diffusion for images but remain useful where likelihoods matter.
- NPU (neural processing unit)
- A low-power accelerator for neural network inference built into phones and laptops, such as Apple's Neural Engine or the units in recent Intel, AMD and Qualcomm chips. It runs small quantised models efficiently but lacks the memory for large ones.
O
- Object detection
- Finding every object of interest in an image and returning a bounding box and class for each. Detectors are judged by mean average precision at a chosen overlap threshold.
- Objective
- The quantity that training optimises, usually the loss averaged over a batch plus any regularisation terms. Loss and objective are often used interchangeably, but the objective can include penalties the loss does not.
- OCR (optical character recognition)
- Extracting text from images or scanned pages, including its position on the page. Modern systems combine a text detector with a recogniser, and multimodal language models now read many documents directly.
- Ollama
- A desktop and server application that downloads open models and runs them locally with a one-line command and a simple HTTP API. It is built on llama.cpp and is the easiest way to try an open model on a laptop.
- On-policy and off-policy
- An on-policy method learns only from actions taken by the current policy, while an off-policy method can learn from data collected by older policies or other agents. PPO is on-policy, Q-learning is off-policy, and the difference decides whether a replay buffer is usable.
- One-hot encoding
- Representing a categorical value as a vector with a single 1 in the position for that category and 0 elsewhere. It avoids implying an order between categories but produces wide, sparse inputs when there are many of them.
- ONNX (Open Neural Network Exchange)
- An open format for describing a trained model as a graph of standard operators, so that a model trained in one framework can run in another runtime. ONNX Runtime executes such files on CPUs, GPUs and NPUs and is a common route to deployment outside Python.
- Open data
- Datasets published under a licence that allows reuse, with documentation of how they were collected. Open training data is the part of an open model most often missing, because of copyright and privacy.
- Open weights
- A model whose trained parameters are published for download, whether or not the training code, data or an open-source licence come with them. Most open models are open weights under a custom licence, which is not the same as open source.
- Open-source model
- A model released under a licence that the Open Source Initiative would recognise, such as Apache-2.0 or MIT, with no restrictions on use or users, ideally alongside its training code and data. Fewer models meet this bar than the marketing suggests.
- Overfitting
- When a model learns details of its training data, including noise, that do not hold for new data, so training error keeps falling while validation error rises. More data, regularisation and early stopping are the usual remedies.
P
- PagedAttention
- Managing the KV cache in fixed-size blocks allocated on demand, the way an operating system pages memory, instead of reserving the maximum context for every request. Introduced by vLLM, it cuts wasted memory and lets many more requests share a GPU.
- Parameter
- A number inside a model that training is allowed to change, such as a weight or a bias term. Parameter counts are the usual shorthand for model size, so a 7 B model has about seven thousand million of them.
- pass@k
- A code-generation metric giving the probability that at least one of k sampled solutions passes the tests. pass@1 is the strict single-attempt score and the one most often quoted.
- PCA (principal component analysis)
- A linear method that finds the directions along which data varies most and projects onto the top few of them. It is the standard first tool for dimensionality reduction and for inspecting what a set of embeddings looks like.
- Peer review
- Evaluation of a paper by other researchers before a conference or journal accepts it. The main ML venues, NeurIPS, ICML and ICLR, receive more than ten thousand submissions a year each, and their reviews are known to be noisy.
- PEFT (parameter-efficient fine-tuning)
- The family of techniques that adapt a large model by training only a small number of added or selected parameters. LoRA is the best known, and the Hugging Face library of the same name implements several.
- Perplexity
- The exponential of the average cross-entropy per token, which can be read as how many equally likely choices the model was effectively picking between. Lower is better, but it only compares models that share a tokeniser and a test text.
- Pickle deserialisation
- Loading a Python pickle file, which can execute arbitrary code embedded in it. Older PyTorch checkpoints are pickles, so loading a model file from an untrusted source is equivalent to running untrusted code, which is why safetensors exists.
- PII (personally identifiable information)
- Data that identifies a person, such as names, addresses, identifiers and anything that can be linked to them. Keeping it out of training data, prompts and logs is a legal requirement in most jurisdictions and a frequent cause of incidents.
- Policy
- The rule an agent follows to choose an action in each state, often a neural network that outputs action probabilities. Training a policy is the goal of reinforcement learning, and in RLHF the language model is the policy.
- Policy gradient
- A family of methods that adjust the policy's parameters directly in the direction that makes rewarded actions more likely. PPO and GRPO are both policy-gradient methods.
- Pooling
- Shrinking a feature map by replacing each small window with its maximum or average, which reduces computation and makes the result less sensitive to exact position. Global average pooling collapses a whole map to one number per channel before classification.
- Positional encoding
- Information added to token representations so that attention, which is otherwise blind to order, can tell where each token sits in the sequence. Rotary position embeddings (RoPE) are the common choice in current open models.
- Post-training quantisation
- Quantising a finished model without further training, usually with a small calibration set to choose the scales. GPTQ and AWQ are the common weight-only methods for language models, and quantisation-aware training is the costlier alternative.
- PPO (proximal policy optimisation)
- A policy-gradient algorithm that limits how far the policy can change in each update by clipping the objective, which makes training stable enough to be a default. It was the RL algorithm used in the original RLHF pipelines.
- Precision
- Of the examples the model flagged as positive, the fraction that really were. High precision means few false alarms, which matters when acting on a positive is costly.
- Preference data
- Training examples made of a prompt and two or more candidate responses with a judgement of which is better. It is the raw material for reward models and for DPO, and its quality bounds everything built on it.
- Preprint
- A paper published on a server such as arXiv before or without peer review. Most ML results appear first as preprints, and many are never reviewed, so the lack of a venue is normal but the claims deserve more scepticism.
- Pretraining
- The first and most expensive stage of building a foundation model, in which it learns general patterns from a huge unlabelled corpus using a self-supervised objective. Everything after it, from instruction tuning to alignment, adjusts a model that already knows the language.Hub: transformers and llms. Related: Self-supervised learning, Foundation model, Scaling laws, Base model
- Probing
- Training a small classifier on a model's internal activations to test whether some property, such as part of speech or truthfulness, is linearly readable from them. A successful probe shows the information is present, not that the model uses it.
- Prompt
- The text, and any images or other inputs, given to a model to produce a response. For chat models it includes the system prompt, the conversation so far and any tool results, all of which count against the context window.
- Prompt caching
- Reusing the computed attention state for a prompt prefix that repeats across requests, such as a long system prompt, instead of recomputing it each time. Providers charge less for cached tokens and respond faster.
- Prompt engineering
- Writing and testing prompts so a model produces the output a task needs, covering instructions, examples, format and the handling of edge cases. It is a skill rather than a job title in most teams, and evaluation matters more than clever wording.
- Prompt injection
- Text in a model's input that hijacks its instructions, typically making it ignore the system prompt or perform an action the user did not ask for. Because instructions and data share the same channel, it is a structural weakness rather than a bug that can be patched once.Hub: safety security and privacy. Related: Indirect prompt injection, Jailbreak, System prompt, Agent
- Pruning
- Removing weights, neurons or whole layers that contribute little, leaving a smaller or sparser model. Unstructured sparsity rarely speeds up ordinary hardware, so structured pruning that drops whole blocks is what delivers gains in practice.
- PyTorch
- The open-source deep learning framework, governed by the PyTorch Foundation, that most research code and most open model releases are written in. It defines tensors and automatic differentiation in Python with eager execution, and its compiler mode generates fused GPU kernels.
Q
- Q-learning
- A method that learns the expected return of each action in each state and picks the best, updating estimates from observed rewards. The deep version, DQN, was the first to play Atari games from pixels.
- QLoRA
- LoRA applied on top of a base model whose weights have been quantised to 4-bit, so a model that would not otherwise fit in memory can still be adapted. The adapter itself is trained in higher precision.
- Quantisation
- Storing weights, and sometimes activations, in fewer bits than they were trained in, such as 8-bit integers or 4-bit groups with a shared scale. It cuts memory and speeds up memory-bound inference, with a quality loss that is small at 8 bits and noticeable below 4.
R
- RAG (retrieval-augmented generation)
- Answering a query by first retrieving relevant documents from a store and then giving them to a language model as context for its reply. It lets a model use private or recent information without retraining, and its quality is dominated by the retrieval step.
- RAIL licence
- A Responsible AI Licence, which grants broad rights to use a model but lists prohibited applications, such as generating disinformation. It is open weights with use restrictions and so not open source by the usual definition.
- Random forest
- An ensemble of decision trees, each trained on a random sample of the rows and a random subset of the features, whose votes are averaged. It needs little tuning and is a reliable first model for tabular data.Hub: classical ml. Related: Decision tree, Bagging (bootstrap aggregating), Ensemble, Gradient boosting
- Rate limit
- The cap a provider places on requests or tokens per minute for an API key, often tiered by spending history. Production code must handle the resulting errors with retries and backoff, and limits are a practical reason to keep a fallback provider.
- Reasoning model
- A language model trained to produce a long chain of intermediate tokens before its final answer, trading more inference compute for better results on maths, code and multi-step tasks. The intermediate text may be hidden, summarised or shown depending on the provider.
- Recall
- Of the examples that really were positive, the fraction the model flagged. High recall means few misses, which matters when a miss is costly, such as in screening.
- Receptive field
- The region of the input image that can influence one activation in a given layer. It grows with depth, and a network whose final receptive field is smaller than the objects it must recognise will struggle.
- Red-teaming
- Deliberately attacking a model or system to find harmful outputs, jailbreaks and failure modes before release, by people or by other models. The findings feed back into training data and guardrails.
- Regression
- Predicting a continuous number, such as a price or a temperature, from input features. Contrast with classification, which predicts a category.
- Regularisation
- Any technique that discourages a model from fitting the training data too closely, such as penalising large weights, dropping units at random or stopping early. It trades a little training accuracy for better generalisation.
- Reinforcement learning
- Learning what to do by acting in an environment and receiving rewards, with no examples of correct actions. The learner must trade off exploring new actions against exploiting those known to work, and credit for a reward may belong to actions taken long before.
- Replay buffer
- A store of past transitions that an off-policy algorithm samples from for training, instead of learning only from the most recent step. It breaks the correlation between consecutive samples and reuses data.
- Reproducibility
- Being able to obtain the same result again from the published code, data, seeds and environment. GPU non-determinism, undisclosed training data and moving dependencies make it harder in machine learning than in most software.
- Reranker
- A model that reads the query together with each candidate document and scores their relevance more carefully than the first-stage search could. It is applied to the top few dozen results, since reading every pair is too slow for a whole collection.
- Research engineer
- An engineer embedded with researchers who builds the infrastructure, training runs and experiments their work needs. It is the most common route into frontier labs for strong engineers without a doctorate.
- Research scientist
- A role focused on developing new methods and publishing results, in a company lab or academia. It usually expects a doctorate and a record of papers, and at frontier labs it includes large-scale training work.
- Residual connection
- Adding a layer's input directly to its output so the layer only has to learn a correction. Residual paths let gradients flow through very deep networks and are the reason transformers and ResNets can be stacked dozens or hundreds of layers deep.
- Reward
- The numeric signal an environment returns after an action, which the agent tries to maximise over time. Designing it is the hardest part of many RL problems, because the agent will exploit any shortcut the reward allows.
- Reward model
- A model trained on human or automated preference judgements to score how good a response is, used as the training signal in RLHF. Its mistakes become the policy's mistakes, since the policy learns to exploit whatever the reward model over-rates.
- RLHF (reinforcement learning from human feedback)
- Training a language model to prefer responses people rate highly, by fitting a reward model to human comparisons and then optimising the language model against it with reinforcement learning. It was the method behind the first widely used chat assistants.
- RNN (recurrent neural network)
- A network that processes a sequence one step at a time while carrying a hidden state forward, so earlier inputs can influence later outputs. LSTM and GRU variants tamed its gradient problems, but transformers have replaced it for most language work.
- ROC-AUC
- The area under the curve of true positive rate against false positive rate as the decision threshold is varied, equal to the chance that a random positive scores above a random negative. A value of 0.5 is random and 1.0 is perfect, and it is independent of any chosen threshold.
S
- safetensors
- Hugging Face's file format for model weights, a plain tensor layout with a JSON header that can be loaded without executing code. It replaced pickle-based PyTorch files on the Hub because pickle files can run arbitrary code when opened.
- Saliency map
- A heat map over an input image or text showing which parts most influenced the output, usually from the gradient of the prediction with respect to the input. Easy to produce, easy to over-read, and often noisy.
- Sampling temperature
- A number the logits are divided by before sampling, so values below 1 sharpen the distribution towards the likeliest token and values above 1 flatten it. Temperature 0 means always taking the top token, which is deterministic but not always better.
- Sandboxing
- Running an agent's tools, particularly code execution and file access, inside an isolated environment with limited permissions and network access. It bounds the damage a prompt injection or a model error can do.
- Scaling laws
- Empirical relationships showing that language model loss falls predictably as parameters, data and compute grow together. They guide how large a model to train for a given budget, with the 2022 Chinchilla result shifting the balance towards more data per parameter.
- Self-supervised learning
- Training on unlabelled data by hiding part of each example and asking the model to recover it, so the data supplies its own targets. Predicting the next token in text and reconstructing masked image patches are both examples.Hub: ml foundations. Related: Pretraining, Autoregressive, Contrastive learning, Unsupervised learning
- Semantic search
- Finding documents by the similarity of their embeddings to the query's embedding rather than by shared words. It handles paraphrase and synonyms well and exact identifiers badly, which is why it is often paired with keyword search.
- Semantic segmentation
- Labelling every pixel of an image with a class, producing a mask rather than boxes. Instance segmentation goes further and separates individual objects of the same class.Hub: computer vision. Related: Object detection, Image classification, IoU (intersection over union)
- Sequence-to-sequence
- A model that reads an input sequence and writes an output sequence of possibly different length, as in translation or summarisation. Classic versions pair an encoder with a decoder, and the attention mechanism was invented to connect the two.
- SFT (supervised fine-tuning)
- Fine-tuning a language model with ordinary next-token cross-entropy on curated prompt and response pairs. It is the first stage after pretraining in most alignment pipelines, before any preference-based method.
- Shadow deployment
- Running a new model alongside the current one on live traffic while only the current one's answers are used, so the new model can be compared under real conditions at no risk to users. It costs double the compute for the duration.
- SHAP (Shapley additive explanations)
- A feature attribution method that borrows the Shapley value from game theory to share a prediction fairly among the input features. It is the standard tool for explaining tabular models and has fast exact versions for tree ensembles.
- Sigmoid
- An S-shaped function that squashes any real number into the range 0 to 1, used to turn a score into a probability for binary outputs. Its flat tails are one cause of vanishing gradients when it is used in deep hidden layers.
- Softmax
- A function that turns a vector of scores into probabilities that are positive and sum to 1, by exponentiating each score and dividing by the total. It sits at the output of nearly every classifier and inside every attention layer.
- Sparse autoencoder (SAE)
- An autoencoder trained on a model's internal activations with a sparsity penalty, so that each activation decomposes into a few active features out of a very large dictionary. It has become the main tool for finding interpretable features in language models.Hub: interpretability. Related: Autoencoder, Superposition, Mechanistic interpretability, Steering vector
- Speaker diarisation
- Working out who spoke when in a recording by segmenting it and grouping segments by voice. It is a separate step from recognising the words and is often the weaker part of a meeting transcript.
- Spectrogram
- A picture of a sound showing how much energy is present at each frequency over time, computed by taking short overlapping Fourier transforms of the waveform. It turns audio into something image and sequence models can process.
- Speculative decoding
- Letting a small, fast draft model propose several tokens and having the large model verify them in one forward pass, keeping the prefix that matches. Output is identical to the large model's own sampling, and speed-ups of two to three times are typical.
- Speech-to-text
- Another name for automatic speech recognition, common in product and API naming.
- Steering vector
- A direction in activation space, found from contrasting examples or from a sparse autoencoder feature, that is added to a model's activations at inference to push its behaviour, such as making it more formal or more honest. It changes behaviour without changing weights.
- Stochastic gradient descent (SGD)
- Gradient descent where each step uses the gradient from a small random batch instead of the whole dataset. The noise makes individual steps rougher but lets training scale to datasets that do not fit in memory.
- Stratified sampling
- Splitting data so that each split keeps the same proportion of classes or groups as the whole. It stops a small validation set from losing a rare class entirely.
- Structured output
- Making a model return data in a fixed machine-readable form, usually JSON matching a schema, rather than free text. Providers can constrain decoding to the schema, which is more reliable than asking nicely and parsing the result.
- Superposition
- A network representing more distinct features than it has dimensions by storing them as overlapping directions in activation space. It explains why single neurons are rarely interpretable and motivates methods that unmix the features.
- Supervised learning
- Training from examples that each carry a known answer, so the model learns to reproduce the answer from the input. Classification and regression are the two common forms.
- SVM (support vector machine)
- A classifier that finds the boundary with the widest margin between classes, optionally after mapping the inputs to a higher-dimensional space with a kernel. It was the leading method for many tasks before deep learning and still suits small, clean datasets.
- Synthetic data
- Training or test data generated by a program or another model rather than collected from the world. It fills gaps and protects privacy, but it inherits the biases and blind spots of whatever produced it.
- System prompt
- Instructions placed at the start of the context by the developer rather than the end user, setting the model's role, rules and output format. Models are trained to give it priority, but it is still only text and can be overridden by a determined attacker.
T
- Tensor
- A multi-dimensional array of numbers, the data type every deep learning framework is built around. A batch of images is a 4-dimensional tensor of batch, channels, height and width, and the shape is the first thing to check when code fails.
- Tensor core
- A unit inside NVIDIA GPUs that multiplies small matrices in one operation, with the greatest speed-up at 16-bit and lower precisions. Mixed precision and quantised inference exist largely to use them.Hub: hardware and acceleration. Related: Mixed precision, bfloat16, GPU (graphics processing unit), FLOPS
- TensorRT
- NVIDIA's inference optimiser and runtime that takes a trained model and produces a fused, precision-tuned engine for a specific GPU. TensorRT-LLM is the variant for language models, and the engines are not portable between GPU generations.Hub: hardware and acceleration. Related: CUDA, ONNX (Open Neural Network Exchange), vLLM, Quantisation
- Test set
- Data kept untouched until the model is finished, used once to report its final performance. Looking at it during development, even indirectly, turns it into another validation set.
- Text-to-image
- Generating an image from a written description, usually by conditioning a latent diffusion or flow model on a text encoder's output. Output quality, prompt adherence and speed are the three axes on which systems differ.
- Throughput
- The amount of work a serving system completes per unit time, such as requests per second or tokens per second across all users. It usually trades against latency, since batching requests raises one and lowers the other.
- Token
- The unit a language model reads and writes, usually a word fragment of a few characters rather than a whole word. English runs at roughly three quarters of a word per token, and pricing, context limits and speed are all counted in them.Hub: transformers and llms. Related: Tokeniser, BPE (byte-pair encoding), Context window, Token pricing
- Token pricing
- The charging model of hosted LLM APIs, a price per million input tokens and a usually higher price per million output tokens, with discounts for cached or batched requests. Prices change often, so compare them at the time of writing and account for both directions.
- Tokeniser
- The component that splits text into tokens and maps each to an integer id, and that reverses the process on output. Each model family has its own, so token counts for the same text differ between models.
- Tool use
- The general name for a model invoking external functions, searches or code during a conversation.
- Top-p sampling (nucleus sampling)
- Sampling the next token only from the smallest set of tokens whose probabilities add up to p, discarding the long tail. Top-k sampling is the related rule that keeps a fixed number of tokens instead.
- TPU (tensor processing unit)
- Google's own accelerator for neural networks, built around large systolic arrays for matrix multiplication and available through Google Cloud. JAX and TensorFlow target it directly, and PyTorch reaches it through XLA.
- Training set
- The portion of the data the model's parameters are fitted on. Anything in it is, by definition, not a fair test of generalisation.
- Transfer learning
- Reusing what a model learned on one task or dataset as the starting point for another, instead of training from random weights. Fine-tuning a pretrained network is the most common form, and it is why small datasets can still produce good models.
- Transformer
- The network architecture behind modern language models, built from repeated blocks of attention and MLP layers joined by residual connections and normalisation. Introduced in 2017, it processes all positions of a sequence in parallel rather than one at a time.
- Triton
- A Python-based language and compiler from OpenAI for writing GPU kernels at the level of blocks rather than individual threads, used inside PyTorch's compiler and in many inference engines. The name is shared with NVIDIA's Triton Inference Server, which is a different product.
- TTS (text-to-speech)
- Generating spoken audio from text, usually by predicting an acoustic representation such as a mel spectrogram or codec tokens and then converting it to a waveform with a vocoder. Voice cloning from a short sample is a feature of many current systems and a source of misuse concerns.
U
- Underfitting
- When a model is too simple or too lightly trained to capture the pattern in the data, so it performs poorly even on the training set. The cure is usually more capacity, more training or better features.
- Unified memory
- A design in which the CPU and GPU share one pool of memory, as on Apple Silicon, so a model needs no copying between the two and can use most of the machine's RAM. It is why a laptop with 64 GB can run models that a 24 GB discrete GPU cannot.
- Unsupervised learning
- Finding structure in data that carries no answers, for example grouping similar records or compressing them to fewer dimensions. Clustering and dimensionality reduction are the typical tasks.
V
- VAE (variational autoencoder)
- An autoencoder whose code is a probability distribution rather than a point, trained so that the codes fill a smooth space that can be sampled from. It is the component that compresses images into the latent space where latent diffusion models work.
- Validation set
- Data held back from training and used to choose hyperparameters, compare models and decide when to stop. Because those choices are made against it, its score is slightly optimistic, which is why a separate test set exists.
- Value function
- An estimate of the total future reward expected from a state, or from taking a given action in a state. Learning it lets an agent judge actions without waiting for the final outcome.
- Vanishing gradient
- Gradients shrinking towards zero as they are propagated back through many layers, so early layers stop learning. ReLU activations, careful initialisation, normalisation layers and residual connections are the standard fixes.
- Vector database
- A store that indexes embeddings for fast nearest-neighbour search, usually alongside the original text and metadata for filtering. Dedicated products exist, but for small collections a NumPy array or a pgvector column does the same job.
- Vendor lock-in
- Dependence on one provider's models, APIs or hardware that makes switching costly, whether because prompts are tuned to a specific model, data lives in its platform or code targets CUDA. Open weights, standard APIs and abstraction layers reduce it, at some cost in convenience.
- ViT (vision transformer)
- A transformer applied to images by cutting each one into fixed-size patches, embedding each patch as a token and running standard attention over the sequence. With enough data it matches or beats CNNs, and it is the image side of most multimodal models.
- vLLM
- An open-source inference engine for serving language models on GPUs, known for introducing PagedAttention and continuous batching. It exposes an OpenAI-compatible API and is a common choice for self-hosted deployments.
- Vocoder
- In neural speech synthesis, the model that turns an intermediate representation such as a mel spectrogram into an audio waveform. Modern vocoders are small GAN or diffusion models that run faster than real time.
- Voice activity detection (VAD)
- Deciding which parts of an audio stream contain speech and which are silence or noise. It gates recognisers so they do not transcribe background sound and splits long recordings into chunks.
W
- Wake word
- A short phrase that a small always-on model listens for before the main speech system starts, trading a tiny model's constant cost for a large model's occasional one. False accepts and misses are tuned against each other per deployment.
- Watermarking
- Embedding a statistical pattern in generated text, images or audio so that a detector can tell the output came from a model. Text watermarks work by biasing token choices and can be weakened by paraphrasing.
- Weight decay
- Shrinking every weight slightly towards zero at each update, which penalises large weights and acts as regularisation. It is the neural network form of L2 regularisation.
- Weights
- The learned parameters of a neural network, chiefly the matrices that multiply each layer's inputs. Releasing a model usually means releasing its weights as a file, which is what 'open weights' refers to.
- Word error rate (WER)
- The standard ASR metric, equal to the number of word substitutions, insertions and deletions needed to turn the transcript into the reference, divided by the reference length. It can exceed 100 percent and depends heavily on how text is normalised before comparison.
Z
- Zero-shot
- Asking a model to perform a task from the instruction alone, with no worked examples in the prompt. Large instruction-tuned models do this well for common tasks, and it is the natural first thing to try.