Renaissance LabsLearn

Reference

Glossary

128 terms, each defined where it first appears in the course.

A

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

B

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

C

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

D

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

E

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

F

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

G

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

H

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

I

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

K

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

L

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

M

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

O

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

P

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

Q

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

R

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

S

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
Shared experts
Some designs add shared experts that every token uses, alongside the routed ones. Mixture of experts
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

T

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

V

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

W

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

Z

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