Reference
Glossary
128 terms, each defined where it first appears in the course.
- Activations
- While a model processes a batch, it stores the intermediate results of every layer, called activations, so the backward pass can use them. Parameters, precision and memory
- Active parameters
- Active parameters count what a single token actually uses. Mixture of experts
- Adam
- The most widely used optimizer: it keeps running averages of each parameter's gradient to set its step size. How a base model is trained, end to end
- Annealing
- This is called annealing. How a base model is trained, end to end
- Artificial Analysis Intelligence Index
- The Artificial Analysis Intelligence Index, version 4.3.2, is a weighted average of 10 evaluations grouped into four categories (agents, coding, general capability and scientific reasoning) at 25% each. Evaluation
- Attention
- A mechanism that lets each token look back at the other tokens in the text and weigh which ones matter for the prediction. Attention and the transformer
- Backpropagation
- Backpropagation applies the chain rule of calculus layer by layer. How a model learns
- Base model
- A base model is what you get when a network has read an enormous amount of text and learned to predict what comes next. How a base model is trained, end to end
- Batch
- It uses a batch of many sequences, and the gradient is averaged over them. How a model learns
- Batching
- With batching, one read of the weights serves every request in the batch, so the cost per token falls. Inference and sampling
- Benchmark
- A benchmark is a fixed set of tasks with a way to score the answers. Evaluation
- Block scale
- The fix is a block scale: a group of values shares one scale factor, which stretches the tiny set of values to fit that group's range. Distillation and quantization
- Byte-pair encoding
- The most common method is byte-pair encoding, or BPE (Sennrich et al. adapted it for neural models). Tokens: how text becomes numbers
- Catastrophic forgetting
- Catastrophic forgetting is the tendency of a network to lose earlier skills when it is trained hard on something narrow. Supervised fine-tuning
- Chains of thought
- These reasoning models write long chains of thought and may revise themselves along the way. Preference tuning and reinforcement learning
- Chat template
- The fixed format that marks who is speaking in a conversation, so the model can tell system, user and assistant text apart. How a base model becomes an assistant, end to end
- Checkpoint
- A checkpoint is a saved snapshot of the parameters, usually together with the optimizer's running averages and the position in the data. How a model learns
- Code in thinking mode
- Code in thinking mode dropped from the first RL window to the second, even as direct mode improved. How a base model becomes an assistant, end to end
- Compute-bound
- Work above it is compute-bound. GPUs and parallelism
- Contamination
- Contamination means the test questions, or their answers, were in the training data. Evaluation
- Context parallelism
- context parallelism that grows with the context, to 16 at 256K: each GPU holds only a slice of the very long sequence; How a base model is trained, end to end
- Cross-entropy
- In cross-entropy loss, it is the negative logarithm of the probability given to the right answer. How a model learns
- Custom or restricted licences
- Custom or restricted licences are written by the lab for its own model. What "open" means for AI models
- DAPO
- Agora used DAPO, a variant of group-relative policy optimisation. How a base model becomes an assistant, end to end
- Data parallelism
- Training uses data parallelism, where several replicas of the model each process a different slice of the batch (see GPUs and parallelism). When training breaks
- Decode
- In decode, the model writes its answer one token at a time. Inference and sampling
- Deduplication
- Deduplication removes exact and near-exact copies, often with fuzzy matching that catches small edits. Pretraining data
- Dense
- In a dense model, every parameter takes part in processing every token. Mixture of experts
- Direct preference optimisation
- Direct preference optimisation, DPO, trains on pairs: a chosen answer and a rejected one. How a base model becomes an assistant, end to end
- Direct Preference Optimization
- Direct Preference Optimization (DPO) reaches a similar goal with less machinery. Preference tuning and reinforcement learning
- Distillation
- You can build a smaller model that behaves like the large one, which is distillation. Distillation and quantization
- Documents.
- Documents. Business documents with multi-step arithmetic score 0.38, against 0.74 for a comparison model, partly because it sometimes translates a required output keyword. How a base model becomes an assistant, end to end
- Dynamic sampling
- The method scales rewards within each group, uses no penalty term against the starting model, allows larger increases than decreases in probability, averages the loss per token, and, importantly, uses dynamic sampling: if all 8 answers score the same, the group teaches nothing and is replaced. How a base model becomes an assistant, end to end
- Effective training time
- That number is the effective training time: the share of wall-clock time that actually moves the model forward, rather than waiting, restarting or redoing lost work. When training breaks
- Embedding
- Each token ID is looked up in a table and replaced by a list of numbers called an embedding. Attention and the transformer
- Epochs
- Smaller machine learning tasks count progress in epochs: one pass over the whole dataset. How a model learns
- Expert parallel
- A fourth kind, expert parallel, places different experts of a mixture-of-experts model on different GPUs and sends each token to wherever its expert lives (see Mixture of experts). GPUs and parallelism
- Experts
- In a sparse MoE model, the feed-forward part of each layer is replaced by many parallel sub-networks called experts. Mixture of experts
- Extraction
- Crawlers collect billions of pages, and the raw HTML is turned into text by extraction: removing menus, ads and boilerplate and keeping the main content. Pretraining data
- Facts.
- Facts. It rarely says "I don't know": it abstains on only 5 percent of factual questions, and 93 percent of its non-correct answers are confident guesses. How a base model becomes an assistant, end to end
- FlashAttention
- a micro-batch of 1 per step, FlashAttention to avoid materialising the full attention matrix, and selective recomputation to trade a little compute for a lot of memory. How a base model is trained, end to end
- Frozen
- The mix is frozen before the run, so a result can be traced to a recipe. How a base model is trained, end to end
- FSDP
- ZeRO and its relative FSDP shard that state: each GPU keeps only a slice of the optimizer state, and in higher stages of the gradients and weights too, gathering pieces when needed. GPUs and parallelism
- GPU
- A GPU is built from many small processors that run the same instruction on different data. GPUs and parallelism
- Gradient
- The nudge comes from the gradient, which says which direction in the model's billions of dimensions lowers the loss. How a base model is trained, end to end
- Gradient descent
- Gradient descent moves each parameter a small step in the direction that lowers the loss. How a model learns
- GRPO
- DeepSeek's GRPO (group relative policy optimization) is a widely used recipe for this. Preference tuning and reinforcement learning
- HBM
- High-bandwidth memory: the memory stacked next to the GPU chip that holds weights and activations. GPUs and parallelism
- Heads
- Several attention calculations run side by side, each free to learn a different pattern. Attention and the transformer
- Held-out
- Because public tests leak and saturate, serious teams keep held-out evaluations: questions that were never published and never used for training or tuning. Evaluation
- Inference
- Inference means using a trained model to produce output. Inference and sampling
- Instruction dataset
- A collection of pairs, each an instruction and a good response, used for supervised fine-tuning. Supervised fine-tuning
- Key
- The key says what this token offers to others. Attention and the transformer
- KV cache
- This store is the KV cache, and at a million tokens it becomes a memory bottleneck. Attention and the transformer
- Language model
- A language model plays exactly this game, at enormous scale. What a language model actually is
- Language of thought.
- Language of thought. Reasoning traces are mostly in English, because only the final answer's language was rewarded. How a base model becomes an assistant, end to end
- Learning rate
- The step is then scaled by the learning rate. How a base model is trained, end to end
- Licence
- Each release comes with a licence, a legal document that sets the terms. What "open" means for AI models
- Load balancing
- Keeping tokens spread evenly across the experts so none sit idle and none are overloaded. Mixture of experts
- LoRA
- The best-known method is LoRA (low-rank adaptation). Supervised fine-tuning
- Loss
- The measure of wrong is the loss: for each position, minus the logarithm of the probability the model gave to the token that actually came next. How a base model is trained, end to end
- Loss mask
- Second, the loss mask: the model reads the whole conversation but learns only from the assistant's tokens. How a base model becomes an assistant, end to end
- Loss spikes
- Sudden jumps in the training loss, often a sign of instability that can ruin a run if not handled. When training breaks
- Master copy
- A master copy of the weights in FP32, so that tiny updates are not lost to rounding. Parameters, precision and memory
- Memory-bound
- Work that does fewer than that per byte is memory-bound: the arithmetic units wait for data. GPUs and parallelism
- Mixture of experts
- An architecture where each layer holds many specialist sub-networks, called experts, and a router sends each token to only a few of them. Scaling laws: how big, how long
- Model collapse
- The gradual loss of diversity and quality when models are trained on text that earlier models generated. Pretraining data
- On-policy distillation
- In on-policy distillation, the student writes its own answers and the teacher scores them, instead of the student only reading text the teacher wrote. Distillation and quantization
- Open weights
- Open weights is the most common meaning today. What "open" means for AI models
- Optimizer
- The rule that turns gradients into parameter updates. How a model learns
- Optimizer states
- Optimizer states: the Adam optimizer keeps two running averages per parameter (see Adam), usually in FP32. Parameters, precision and memory
- Over-training
- This is called over-training. Scaling laws: how big, how long
- Packing
- Training efficiency comes from packing. How a base model becomes an assistant, end to end
- Parameter
- A parameter is one adjustable number in the model, usually a weight inside a large matrix. Parameters, precision and memory
- Parameter-efficient fine-tuning
- Parameter-efficient fine-tuning avoids this by training a small number of added parameters and leaving the original weights frozen. Supervised fine-tuning
- Parameters
- Inside the model is a large collection of numbers called parameters, or weights. What a language model actually is
- Permissive licences
- Permissive licences allow nearly any use, including commercial products, with few conditions, usually things like keeping a notice of the original authors. What "open" means for AI models
- Policy
- The model's behaviour seen as a rule for choosing what to write next. Preference tuning and reinforcement learning
- Post-training
- The distance between the two is covered by post-training, which is a sequence of stages rather than one trick, and each stage fixes something the last one left or broke. How a base model becomes an assistant, end to end
- Post-training quantization
- Post-training quantization is the easy route, and 8-bit conversion of weights has been shown to work with little loss when a few unusually large outlier values are handled carefully (the LLM.int8 paper). Distillation and quantization
- Power law
- Loss followed a power law in three quantities: the number of parameters, the amount of training data, and the amount of compute. Scaling laws: how big, how long
- Precision
- How much space each one takes depends on its precision, the number of bits used to write it down. Parameters, precision and memory
- Prefill
- In prefill, the model reads your whole prompt at once. Inference and sampling
- Quantization
- Or you can keep the model as it is and store each number with fewer bits, which is quantization. Distillation and quantization
- Quantization-aware training
- Quantization-aware training builds the rounding into training so the model adapts. Distillation and quantization
- Query
- The query says what this token is looking for. Attention and the transformer
- Reasoning models
- These reasoning models write long chains of thought and may revise themselves along the way. Preference tuning and reinforcement learning
- Refusals.
- Refusals. Refusal calibration (0.35) and grounding and safety (0.60) fell after DPO and did not recover in RL. How a base model becomes an assistant, end to end
- Reinforcement learning
- In reinforcement learning (RL), the model generates an attempt, a reward scores it, and the model's weights are adjusted to make high-scoring attempts more likely. Preference tuning and reinforcement learning
- Reinforcement learning from human feedback
- Reinforcement learning from human feedback (RLHF) is the method behind InstructGPT. Preference tuning and reinforcement learning
- Replay
- Stage 2 adds it as an opt-in: 373,000 reasoning rows, 1.74 billion tokens, mixed with 792,000 direct-answer rows as replay, so that learning to think does not erase the ability to answer briefly. How a base model becomes an assistant, end to end
- Reward hacking
- When a model finds a way to score well on the reward without doing what the designer actually wanted. Preference tuning and reinforcement learning
- Roofline
- The roofline idea says attainable speed is the lower of two limits: the chip's peak arithmetic, or its memory bandwidth times how much arithmetic you do per byte moved. GPUs and parallelism
- Rotary embeddings
- Position is encoded by rotary embeddings, which turn each pair of query and key dimensions by an angle proportional to the token's position. How a base model is trained, end to end
- Router
- The router is a small learned layer. Mixture of experts
- Sampling
- A sampling rule turns that into a choice. Inference and sampling
- Saturation
- Saturation means models score so close to the maximum that the test no longer separates them. Evaluation
- Scaling laws
- Scaling laws are the empirical rules that make the guess an informed one. Scaling laws: how big, how long
- Sequence parallelism
- sequence parallelism, which splits the activations of the layers that tensor parallelism leaves whole; How a base model is trained, end to end
- SFT
- Supervised fine-tuning, usually shortened to SFT, closes that gap. Supervised fine-tuning
- Silent data corruption
- A hardware fault that quietly changes numbers in a calculation without raising an error, so training carries on with bad values. When training breaks
- Soft targets
- The teacher's probabilities, called soft targets, keep it. Distillation and quantization
- Sparse
- In a sparse MoE model, the feed-forward part of each layer is replaced by many parallel sub-networks called experts. Mixture of experts
- Speculative decoding
- Speculative decoding uses a small, fast model to guess several tokens ahead, then lets the large model check all of them in one pass. Inference and sampling
- Streaming multiprocessors
- NVIDIA's H100 has 132 streaming multiprocessors, and each one runs threads in groups of 32 called warps. GPUs and parallelism
- Subword tokenization
- Subword tokenization sits in between. Tokens: how text becomes numbers
- Supervised fine-tuning
- The first stage is supervised fine-tuning: show the model good conversations and train it, with the same next-token loss as before, to reproduce the assistant's side (SFT lesson). How a base model becomes an assistant, end to end
- Synthetic data
- Synthetic data is text generated by models, then filtered or checked. Pretraining data
- Temperature
- Temperature rescales the probabilities before choosing. Inference and sampling
- Tensor cores
- For matrix multiplication, the part that dominates language models, GPUs have special tensor cores. GPUs and parallelism
- Tensor parallelism
- tensor parallelism of 8: each big matrix is cut across 8 GPUs; How a base model is trained, end to end
- Thinking mode
- A thinking mode has the model write out its reasoning between think tags and then answer. How a base model becomes an assistant, end to end
- Tokenizer
- A tokenizer cuts text into pieces and maps each to a number (see Tokens). How a base model is trained, end to end
- Tokens
- The pieces are called tokens, and the program that cuts text into them is the tokenizer. Tokens: how text becomes numbers
- Top-k
- Top-k keeps only the k most likely tokens and samples among them. Inference and sampling
- Top-p
- Top-p (nucleus sampling) keeps the smallest set of tokens whose probabilities add up to p, then samples among them. Inference and sampling
- Total parameters
- Total parameters count everything stored. Mixture of experts
- Training
- That process is training, and the rest of this course is about how it works and what it costs. What a language model actually is
- Training recipe
- A training recipe is the written account of how those fit together: the data mix, the stages, the optimiser settings and what went wrong along the way. What "open" means for AI models
- Transformer
- The transformer, introduced in the paper Attention Is All You Need, is the machine that turns that row into a prediction for the next token. Attention and the transformer
- Value
- The value is the information it passes on if it is chosen. Attention and the transformer
- Vocabulary size
- The number of distinct tokens is the vocabulary size. Tokens: how text becomes numbers
- Warm-up
- It starts at zero and rises over a warm-up, because early updates are noisy and large steps can wreck the network. How a base model is trained, end to end
- Warmup
- Early in training the model is fragile, so the rate usually starts near zero and rises over the first steps, a period called warmup, then decays over the run. How a model learns
- Warps
- NVIDIA's H100 has 132 streaming multiprocessors, and each one runs threads in groups of 32 called warps. GPUs and parallelism
- Weights
- Inside the model is a large collection of numbers called parameters, or weights. What a language model actually is
- ZeRO
- ZeRO and its relative FSDP shard that state: each GPU keeps only a slice of the optimizer state, and in higher stages of the gradients and weights too, gathering pieces when needed. GPUs and parallelism