Glossary

The terms used in the course, with short definitions and the lesson where each is explained.

Activation function: A function applied to the weighted sum plus the bias to produce the neuron’s output. Examples: the step and the sigmoid. Explained in: The artificial neuron
Adam: An optimizer that combines momentum with a step size of its own for each weight, computed from moving averages of the gradient and its square (Kingma and Ba, 2015). Explained in: Training well: batches, epochs, and optimizers
Agent: A system that puts a language model in a loop of thinking, acting, and observing: the model asks for tools, a program runs them, and the result returns to its context, until a goal is met. Explained in: Agents and tools
AI governance: The rules, owners, and processes through which an organization decides which uses of AI it accepts and makes sure they are followed. It starts with a usage policy, an inventory of systems, an owner for each system, and an incident log. Explained in: Risks and governance
AI winter: A period of reduced funding and interest in artificial intelligence after unmet expectations. The first took place in the 1970s. Explained in: What a neuron cannot do
Alignment: Techniques to get a model to do what the person intends and be helpful, honest, and harmless, not just whatever is most likely given its training text. It turns a base model into an assistant. Explained in: From base model to assistant
Artificial neuron: A unit of computation that multiplies each input by a weight, adds the results, adds a bias, and applies an activation function: y = f(w·x + b). Explained in: The artificial neuron
Attention: A mechanism by which each token decides how much to look at the others: it compares its query with everyone’s keys, turns the scores into weights with softmax, and builds its new vector as the blend of the values with those weights. Explained in: Attention
Autoencoder: A two-piece network: an encoder, which sums up each data point in a few numbers (the code), and a decoder, which tries to rebuild it from the code. It is trained to bring the reconstruction error down. Explained in: Generating is learning a distribution
Autoregression: Writing one piece at a time using what has already been written as input: each word produced becomes part of the context for the next. Explained in: Predicting the next word
Axon: The long extension through which a biological neuron sends its pulse to other neurons when the combined signals are strong enough. In the artificial neuron it corresponds to the output. Explained in: The artificial neuron
Backpropagation: An algorithm that computes the gradient of the loss with respect to every weight of a network in a single backward sweep, applying the chain rule layer by layer. It computes the blames; it does not move the weights (in the 1986 paper, the name covered the whole learning procedure). Explained in: Backpropagation
Base model: A language model that has only gone through pretraining: it can continue texts, but it is not tuned to follow instructions or converse like an assistant. Explained in: Pretraining
Base rate: The actual frequency of an event in the population (for example, 1% of transactions being fraud). It conditions how many false alarms a detector generates. Explained in: Generalizing and evaluating
Batch: A small set of examples, picked at random, used to estimate the gradient in one training step. Explained in: Training well: batches, epochs, and optimizers
Benchmark: A fixed public exam (questions with their correct answers and a way to grade them) given in the same way to every model to compare them. Useful as a general reference; it does not tell you whether a system works for your case. Explained in: Evaluating AI systems
Bias (b): The term added at the end of the model: the prediction when the input is zero, that is, the height at which the line crosses the vertical axis. It is not the bias of data or of an unfair model, which is a different concept. Explained in: A model and its error
Bias (in an AI system): An error that repeats systematically against a group of people, often inherited from the data. It is detected by measuring the error by group, not the average. Not the bias b of a model (lesson 3). Explained in: Risks and governance
BPE (byte pair encoding): An algorithm that builds the vocabulary by merging, again and again, the most frequent pair of neighboring pieces in a training text. It began as a compression technique (Gage, 1994) and was adapted to language (Sennrich et al., 2016). Explained in: Tokens: the model’s alphabet
Build versus buy: The decision about how to carry out a use case: buy a ready-made product, build on a provider’s model (prompt and RAG), fine-tune a model on your examples, or, almost never, train one from scratch. Rule of thumb: buy what is common; build what uses your data. Explained in: Strategy for organizations
Calibration: How closely a system’s confidence matches how often it is actually right: of the answers given at 70% confidence, it should be right about 70% of the time, like a good weather forecast. Explained in: Hallucinations and limits
Catastrophic forgetting: Loss of earlier skills when a model keeps training on data of a single kind: the same parameters serve everything, and moving them for the new disturbs the old. Explained in: Fine-tuning and LoRA
Causal mask: In attention, it replaces the scores toward future tokens with minus infinity before softmax, which then gives them zero weight. Each token then looks only at earlier tokens and itself, and the model cannot copy the answer during training. Explained in: The complete transformer
Cell body: The central part of a biological neuron, where the signals arriving through the dendrites are combined. In the artificial neuron it corresponds to the weighted sum. Explained in: The artificial neuron
Chain of thought: The intermediate steps a model writes before its final answer. Each written step stays as context for the following tokens and adds computation; it can be requested in the prompt or come from a model trained to reason. Explained in: Reasoning models
Chain rule: If a quantity depends on another through a chain of steps, its total influence is the product of the influence of each step. It is the basis of backpropagation. Explained in: Backpropagation
Chinchilla: A DeepMind model (2022; 70 billion parameters, 1.4 trillion tokens) and the rule it left: with a fixed budget, parameters and data should grow together, about 20 tokens per parameter. Explained in: Scaling laws and costs
Chunking: Cutting documents into pieces, or chunks, that are indexed and retrieved separately. If they are too small, a fact can lose its context; if they are too large, the answer gets diluted. Explained in: RAG: read before answering
Classifier-free guidance: When generating, the noise estimate is computed with the hint (a label or a text) and without it, and their difference is exaggerated by the guidance scale: more fidelity to the hint, less variety. Explained in: Diffusion: from noise to image
CLIP: An OpenAI method (2021) that trains an image encoder and a text encoder together so each image and its description land close together in one shared vector space. It was trained on about 400 million image-and-text pairs taken from the internet. Explained in: From text to image
Compute: The amount of arithmetic operations needed to train or run a model. Along with data and algorithms, it is one of the three engines of progress in machine learning. Explained in: The deep learning big bang
Compute budget: The total number of FLOPs you decide to spend on training a model. Since C ≈ 6·N·D, it fixes the “area” split between model size and amount of data: if one goes up, the other goes down. Explained in: Scaling laws and costs
Conditioning: Giving a generative model an extra input (a label or a sentence’s vector) that steers what it produces. Image generators are conditioned on the prompt’s vector. Explained in: From text to image
Confidence interval: A range of reasonable values for a quantity measured on a sample, such as a system’s true accuracy; usually at 95%. Its margin shrinks with the square root of the number of cases: four times as many cases cut it in half. Explained in: Evaluating AI systems
Confusion matrix: A table with the hits and mistakes of each kind: true and false positives, true and false negatives. Explained in: Generalizing and evaluating
Contamination: When an exam’s questions (or answers) were in the data the model was trained on. It inflates the score, because it partly measures memory rather than ability. Explained in: Evaluating AI systems
Context window: The maximum number of tokens the model can read at once. The system prompt, the conversation, documents, and the answer it is writing all count. Whatever does not fit does not exist for the model. Explained in: Context and memory
Contrastive learning: Training by comparing correct pairs with wrong ones: pulling together in vector space what belongs together and pushing the rest apart, without hand-written labels. Explained in: From text to image
Convolution: An operation in which a small kernel sweeps an image and, at each position, multiplies and sums pixels by weights to produce an output pixel. Explained in: Convolutions and vision
Convolutional network (CNN): A neural network that uses convolutions, activations, and pooling to process grid-structured data such as images. Explained in: Convolutions and vision
Corpus: The collection of texts a language model is trained on, for example The Pile (825 GiB) or FineWeb (15 trillion tokens). It is built by collecting, filtering, and removing duplicates. Explained in: Pretraining
Cosine similarity: The cosine of the angle between two vectors: 1 if they point the same way, 0 if they are perpendicular, −1 if they oppose. It ignores length and measures direction only. Explained in: Embeddings: meaning as geometry
Credit assignment (sharing the blame): The problem of deciding how much each decision, weight, or neuron hidden in the middle of a system contributed to the final outcome (Minsky posed it this way in 1961, for reinforcement learning). In a differentiable network, backpropagation solves it efficiently. Explained in: Backpropagation
Data leakage: Information from the evaluation data that slips into training, inflating the measured result. Explained in: Generalizing and evaluating
Decision boundary: The set of points where the neuron changes its answer. With two inputs it is a straight line: w₁x₁ + w₂x₂ + b = 0. Explained in: The artificial neuron
Decode: Second phase: tokens are generated one at a time, and each one requires a full turn through the model that reads all the weights and the cache. It is usually limited by memory bandwidth. Explained in: Inference: how a model answers
Decoder-only: A transformer made only of blocks with a causal mask that predict the next token, without the original paper’s encoder half. It is the architecture of the GPT family. Explained in: The complete transformer
Deduplication: Removing repeated texts from the corpus, including near-identical ones. It measures what share of few-word chunks two texts have in common (Jaccard index, estimated with MinHash) and drops one if it exceeds a threshold. Explained in: Pretraining
Deep learning: Machine learning with many-layered neural networks that learn the useful features themselves, from edges to objects, from large amounts of data and compute. Explained in: The deep learning big bang
Deep network: A network with several hidden layers. Each layer builds on what the previous one already transformed; for certain functions, this reaches complex shapes with far fewer neurons than a single wide layer. Explained in: Layers and activations
Dendrite: In a biological neuron, each of the branches that receive signals from other neurons. In the artificial neuron they correspond to the inputs. Explained in: The artificial neuron
Denoising: The task of the network in a diffusion model: it takes a noisy image and the step number, and estimates the noise so it can be subtracted. Explained in: Diffusion: from noise to image
Derivative: The mathematical name for the slope of a curve at a point: how much one quantity changes for each small change in another. Explained in: Gradient descent
Diffusion model: A generative model that learns to undo a fixed process that mixes data with noise step by step (the forward process). It generates by starting from pure static and removing a little estimated noise, many times. Explained in: Diffusion: from noise to image
Discriminator: In a GAN, the network that receives a data point and estimates, between 0 and 1, how likely it is to be real rather than from the generator. At the ideal tie it answers 0.5. Explained in: GANs: the forger and the detective
Distribution: The way the data is spread out: which values (or combinations of values) are common, which are rare, and which never appear. With two measures it looks like a cloud of points. Explained in: Generating is learning a distribution
DPO (direct preference optimization): A method that learns from pairs of answers (preferred and rejected) by tuning the model directly: it raises the probability of the preferred one and lowers the rejected one’s, without training a separate reward model or using reinforcement learning. Explained in: From base model to assistant
Dropout: A technique against overfitting: at each training step every neuron of a layer is switched off at random with some probability (0.5 in AlexNet), so no neuron can depend on a particular other one. Explained in: The deep learning big bang
Embedding: A vector of numbers, learned from data, that represents something (a word, a sentence, an image) so that similar things end up close. Each word has a row in an embedding table. Explained in: Embeddings: meaning as geometry
Epoch: One full pass over all the training examples. With N examples and batches of B, an epoch is N/B steps. Explained in: Training well: batches, epochs, and optimizers
EU AI Act: Regulation (EU) 2024/1689, in force since August 1, 2024. It sorts uses of AI by risk (prohibited, high risk, transparency, and the rest) and applies in stages through 2028. It reaches companies outside the EU if their AI is used there. Explained in: Risks and governance
Eval set (gold cases): Your own set of real cases from your work, each with the answer or criterion your experts accept, that the system has not seen. It is used to compare systems and is rerun after every change. Explained in: Evaluating AI systems
Feature: One measurement of an example expressed as a number: the number of links in an email, the brightness of a pixel. The features of an example make up its vector. Explained in: The world as numbers
Feature map: The output image of a kernel: it shows where the pattern that kernel detects appears. Explained in: Convolutions and vision
Fine-tuning: Continuing to train an already pretrained model on a small set of your own examples (input and desired answer) to change its behavior, without starting from scratch. Explained in: Fine-tuning and LoRA
FLOP, FLOPs: Floating-point operation: an addition or a multiplication with decimals. A training run’s compute is counted in total FLOPs (≈ 6·N·D); a chip’s speed, in FLOPs per second. Explained in: Scaling laws and costs
Forward pass: Computing a network’s output: the numbers move on layer by layer, from input to output. Explained in: Layers and activations
FP16 (and FP32, INT8, INT4): Formats for storing each number in a model. FP16 uses 2 bytes and keeps about 3 significant digits; FP32, 4 bytes and about 7. INT8 (1 byte) and INT4 (½ byte) store an integer that, multiplied by a scale, approximates the value. BF16 is a 2-byte variant with FP32’s range. Explained in: GPUs, memory, and quantization
Function calling: The mechanism by which the model, instead of free text, writes a structured request: a tool’s name and its data. The program validates and runs it. Explained in: Agents and tools
GAN (generative adversarial network): A generative model made of two networks trained by competing: a generator that produces fake data and a discriminator that tries to tell it apart from real data (Goodfellow et al., 2014). Explained in: GANs: the forger and the detective
Generalization: Getting new cases right, ones not used for training. It is what you really want from a model. Explained in: Programming or learning
Generative model: A model that learns the distribution of its data (what is common, what is rare) and can therefore produce new, similar data. A model that classifies, by contrast, only learns the boundary between groups. Explained in: Generating is learning a distribution
Generator: In a GAN, the network that turns a randomly drawn number (or vector) into a fake data point. It never sees the real data: it learns from the discriminator’s answer. Explained in: GANs: the forger and the detective
GPU: Graphics processing unit: a chip with hundreds or thousands of simple cores, built to draw graphics and very efficient at multiplying matrices in parallel, the central operation of training. Explained in: The deep learning big bang
Gradient: The list of the slopes of the error, one for each weight. Seen as an arrow, it points to where the error rises fastest. Explained in: Gradient descent
Gradient descent: A method that adjusts the weights step by step, always against the slope of the error (the gradient), until it reaches a bottom. Explained in: Gradient descent
Grounding: Making every claim in the answer rest on a specific, checkable source, cited next to it. Explained in: RAG: read before answering
Hallucination: A fluent, confident answer from a model that is false or backed by no source. It follows from predicting plausible text, not from checking facts. Explained in: Hallucinations and limits
Hidden layer: A layer of neurons between input and output. It creates intermediate signals that the output combines; its values are not observed directly. Explained in: What a neuron cannot do
Hidden state: The vector of numbers a recurrent network carries from one step to the next: its memory of what it has read so far. It is rewritten at every step. Explained in: Sequences and memory
Human in the loop: A design in which the system stops before certain actions (irreversible ones, or those over a limit) and waits for a person’s decision: approve, correct, or reject. It costs attention and only protects if the review is real. Explained in: Agents and tools
Hyperparameter: A setting a person fixes for training (rate, batch size, epochs, optimizer, schedule). It is not learned with gradients. Explained in: Training well: batches, epochs, and optimizers
ImageNet: A database of more than fourteen million images labeled by people, in more than twenty-one thousand categories. Its ILSVRC contest subset (a thousand classes, more than 1.2 million training photos) was the proving ground of computer vision. Explained in: The deep learning big bang
Inference: Using an already trained model to answer a new case, with frozen parameters. Explained in: Programming or learning
Inference serving: Running an already trained model to answer real requests: with fixed weights, for many people at once, while managing wait time and cost. Explained in: Inference: how a model answers
Information leak: Data reaching someone who should not have it: what gets pasted into an outside service, what a model memorized, or what an assistant shows to someone without permission. Not to be confused with lesson 10’s “data leakage” (from the test into training). Explained in: Risks and governance
Instruction tuning: Fine-tuning a base model on pairs of a prompt and an ideal answer written by people, so that it treats what it is asked as a request rather than as the start of a text. Explained in: From base model to assistant
Jailbreak: Text designed to make a model stop refusing what its training taught it to refuse: a role-play, a story, another language, or a string of nonsense text. It is a form of prompt injection. Explained in: Risks and governance
Kernel (filter): The small grid of weights of a convolution. In a convolutional network, its values are learned during training. Explained in: Convolutions and vision
Knowledge cutoff: The date after which the training data includes no more text. The model does not know what came later unless it is given as context, and it does not always warn that it does not know. Explained in: Hallucinations and limits
KV cache (keys and values): Memory that keeps the keys and values already computed for earlier tokens so they are not recomputed on every turn. It saves arithmetic, but takes memory that grows with the context and with every conversation. Explained in: Inference: how a model answers
Language model: A model that, given some text (the context), gives a probability to every word or piece that can come next. It writes by adding one piece at a time. Explained in: Predicting the next word
Latent diffusion: Doing diffusion in the code space of an autoencoder, much smaller than the image, and decoding at the end. It is cheaper; that is how Stable Diffusion works. Explained in: Diffusion: from noise to image
Latent space: The space of a model’s codes (“latent” means hidden): each data point is a point, and nearby points tend to be similar data. Any point can be decoded. Explained in: Generating is learning a distribution
Layer: A group of neurons that receive the same inputs and compute at the same time. A network is a chain of layers: input, one or more hidden ones, and output. Explained in: Layers and activations
Layer normalization: Subtracts the average from a token’s list of numbers and divides it by its standard deviation, then applies two learned adjustments (gain and bias). It keeps the scale of the numbers stable when many blocks are stacked. Explained in: The complete transformer
Learning rate: A number (η) that multiplies the slope and sets the size of each step. Too small is slow; too large bounces or diverges. Explained in: Gradient descent
Linear separability: The property of a set of two-class points that can be separated by a line (or a plane, in more dimensions). Explained in: What a neuron cannot do
LLM-as-a-judge: Using a language model to grade another system’s answers against a rubric. It is cheap and scales, but it has biases (the order of the answers, their length) and must be checked against people’s grades. Explained in: Evaluating AI systems
LoRA (low-rank adaptation): A fine-tuning technique that freezes the original parameters and trains only a correction ΔW = B·A, the product of two thin tables. The pair B and A is called an adapter: it can be removed or swapped. Explained in: Fine-tuning and LoRA
Loss function: A single number that summarizes how wrong a model is on its data. Training is the search for the parameters that make it as small as possible. Explained in: A model and its error
Lost in the middle: An effect measured in several models: they make better use of information at the start or end of a long context than of what sits in the middle. Explained in: Context and memory
Low rank: A property of a table (matrix) that can be written as a sum of a few “column × row” pieces. The rank says how many pieces are needed; a low-rank table is described with far fewer numbers than rows × columns. Explained in: Fine-tuning and LoRA
LSTM (long short-term memory): A recurrent cell with a memory belt (the cell state) and three learned gates, forget, input, and output, that decide what is kept, what is written, and what is read. Proposed in 1997 by Hochreiter and Schmidhuber; the forget gate was added in 2000. Explained in: Sequences and memory
Machine learning: An approach in which a computer obtains the rules from examples instead of someone writing them. The term is associated with Arthur Samuel (1959). Explained in: Programming or learning
MCP (Model Context Protocol): An open standard, published by Anthropic in November 2024, for connecting AI applications to tools and data: a server offers them once and any compatible app discovers and uses them. Explained in: Agents and tools
Mean squared error (MSE): A loss that averages the squared errors. It punishes big errors far more than small ones and is measured in the units of the output, squared. Explained in: A model and its error
Memory bandwidth: How many bytes per second can travel from memory to the cores: 3,350 GB/s on an H100. When generating text token by token it is usually the speed limit, because every token requires reading all the parameters. Explained in: GPUs, memory, and quantization
Mixture of experts (MoE): An architecture in which each block has several networks (experts) and a router picks a few for every token. There are many parameters in total and few active per token: it saves arithmetic, not memory. Explained in: Inference: how a model answers
Mode collapse: A typical GAN failure: the generator produces only part of the variety in the data (for example, just one of several “mountains” or a single kind of image). Explained in: GANs: the forger and the detective
Model: A form of rule with adjustable numbers. Once trained, it is the learned rule. Explained in: Programming or learning
Multi-head attention: Several attentions in parallel, each one (a head) with its own matrices for Q, K, and V and its own map. Their results are joined and combined with a final matrix. Explained in: Attention
Noise schedule: The fixed recipe for how much noise is mixed in at each step of the forward process; it determines how much of the mix is still image at each step. Explained in: Diffusion: from noise to image
Nonlinearity: The property of a function that is not a straight line. It stops stacked layers from collapsing into one and lets a network fold space. Explained in: Layers and activations
Optimizer: The rule that turns the gradient into a change of the weights. Examples: SGD, SGD with momentum, and Adam. Explained in: Training well: batches, epochs, and optimizers
Overfitting: When a model learns the noise in its training data and therefore fails on new data. It shows as a large gap between training and validation error. Explained in: Generalizing and evaluating
Parallelism (data, pipeline, tensor): Splitting the training or use of a model across several GPUs: full copies that see different data (data), groups of layers in a row (pipeline), or each table of parameters cut into pieces (tensor). They are combined: Llama 3.1 405B used 8 × 16 × 128 = 16,384 GPUs. Explained in: GPUs, memory, and quantization
Parameter: Each of the numbers a model adjusts while training and in which it stores what it learned. Explained in: Programming or learning
Perceptron: A model proposed by Frank Rosenblatt in 1958: threshold units connected in a network that learn from examples. In its simplest version, a neuron with a step whose weights are corrected only when it is wrong. Explained in: The artificial neuron
Pilot: A small-scale test of a use case, with real users, a fixed time frame, a baseline measured beforehand, and a measurable goal. It ends in a data-based decision: expand, fix, or shut down. Explained in: Strategy for organizations
Pixel: The smallest dot of a digital image. In grayscale it is a number from 0 (black) to 255 (white); in color it is three numbers (red, green, and blue). Explained in: The world as numbers
Pooling: A size reduction that summarizes each block of a map (for example, with its maximum value). Explained in: Convolutions and vision
Positional encoding: A list of numbers specific to each place in the text, added to each token’s embedding so the model knows their order. In the original paper it comes from waves of different frequencies; GPT learns it in training, and other models use variants. Explained in: The complete transformer
Precision: Of everything the model flagged as positive, the fraction that really was: TP / (TP + FP). Explained in: Generalizing and evaluating
Prediction (ŷ): The number the model returns for a given input. Comparing it with the real value gives the error. Explained in: A model and its error
Prefill: First phase of inference: the whole input message is processed at once and the KV cache is filled. The wait until the first token depends on it. Explained in: Inference: how a model answers
Pretraining: The first stage of training a language model: over a huge corpus, the model guesses the next piece of text again and again and adjusts its parameters to lower the error. The result is a base model. Explained in: Pretraining
Prompt: The text used to ask a generative model for something; in an image generator, the description of the desired image. Explained in: From text to image
Prompt injection: An attack in which outside text (an email, a page, a document) carries orders the model obeys as if they came from its user. It is direct if the attacker types it into the chat and indirect if it arrives inside what the system reads. It has no complete fix: it is contained with permissions and human approval. Explained in: Risks and governance
Quantization: Storing a trained model’s parameters with fewer bits (8 or 4 instead of 16), rounding each one to the nearest mark of a scale shared by its group. It reduces memory and read time, with a loss of quality that has to be measured. Explained in: GPUs, memory, and quantization
Query, key, and value (Q, K, V): The three vectors each token produces: the query says what it is looking for, the key how it gets found, and the value what it hands over. They come from multiplying its vector by three learned weight matrices. Explained in: Attention
RAG (retrieval-augmented generation): A technique that, before generating, looks up in a collection of documents the chunks most similar to the question and includes them in the prompt, so the model answers from those sources without being retrained. Explained in: RAG: read before answering
Reasoning model: A language model trained (mainly with reinforcement learning) to write out its own thinking, sometimes thousands of tokens long, before answering. Examples: OpenAI’s o1 (2024) and DeepSeek-R1 (2025). Explained in: Reasoning models
Recall: Of all real positives, the fraction the model found: TP / (TP + FN). Explained in: Generalizing and evaluating
Recurrent neural network (RNN): A network that processes a sequence step by step with the same cell: at each step it receives the current input and the previous hidden state, and produces a new state. Explained in: Sequences and memory
Red teaming: Deliberately attacking a system, with people or with other models, to find its worst-case failures: harmful answers, leaks, deception. Each failure found becomes an evaluation case. Explained in: Evaluating AI systems
Regression: The task of predicting a number (a price, a grade, a temperature) rather than choosing a category. Linear regression uses a straight line. Explained in: A model and its error
Regularization: Any change to learning meant to reduce the error on new data, even if it does not lower the training error. The simplest penalizes model complexity (for example, large weights); early stopping and dropout are other forms. Explained in: Generalizing and evaluating
ReLU: Rectified linear unit: an activation function that returns zero if the sum is negative and the sum itself if it is positive, max(0, z). A hinge with a single corner. Explained in: Layers and activations
Reranking: A second step that reorders the top search candidates with a finer, slower model that reads the question and each chunk together. Explained in: RAG: read before answering
Residual connection (shortcut): Adding a block’s input to its output: y = x + F(x). It gives the gradient a direct path backward and made it possible to stack many more layers. Explained in: The deep learning big bang
Retrieval: The step that turns the question into a vector, compares it with the index, and fetches the k most similar chunks. Explained in: RAG: read before answering
Reward model: A model trained on comparisons between answers that returns a score: higher the more likely people are to prefer the answer. It acts as the judge during optimization; the probability that an answer wins is the sigmoid of the difference in scores. Explained in: From base model to assistant
RLHF (reinforcement learning from human feedback): Tunes a model so that its answers earn more points from a reward model trained on human preferences, with a penalty (the KL “leash”) that keeps it close to the starting model. Explained in: From base model to assistant
Sampling: Drawing a new data point that follows a distribution: common things come out often and rare things seldom. It is how a generative model generates. (Not to be confused with the audio samples of lesson 2.) Explained in: Generating is learning a distribution
Scaling law: A measured regularity, not a law of nature: a model’s loss falls as a power of its parameters, its data, or its compute. On a logarithmic scale it looks like a straight line: each ×10 multiplies the loss by the same number. Explained in: Scaling laws and costs
Self-attention: Attention in which queries, keys, and values come from the same sequence: each token looks at the other tokens of its own text, and at itself. Explained in: Attention
Self-supervised learning: Learning in which each example’s answer comes from the data itself, without labels added by people. In text: cover a piece and use the real piece as the right answer. Explained in: Pretraining
Semantic search: Search by meaning: the query and the documents are turned into vectors and the closest documents are returned, even if they share no words. Explained in: Embeddings: meaning as geometry
Sequence model: A model that processes data whose order matters and whose length varies, such as text, audio, or time series, usually by reading it step by step. Explained in: Sequences and memory
Sigmoid: The function σ(z) = 1/(1 + e⁻ᶻ): it turns any number into a value between 0 and 1, and equals 0.5 when z = 0. Explained in: The artificial neuron
Softmax: A function that turns any scores into positive probabilities that add up to one: it applies the exponential to each score and divides by the sum. Explained in: Predicting the next word
Stateless: Each call to the model starts from scratch and does not remember earlier ones. A conversation’s memory lives in the app, which resends the whole history on every turn. Explained in: Context and memory
Stochastic gradient descent (SGD): Gradient descent in which each step uses the gradient of a random batch instead of the gradient from all the examples. Explained in: Training well: batches, epochs, and optimizers
Sycophancy: An assistant’s tendency to tell people what they want to hear, such as agreeing with them or praising their work even when they are wrong. In part it is an effect of optimizing for human approval. Explained in: From base model to assistant
System prompt: Fixed instructions that whoever builds the app places at the front of the context: role, tone, and rules. The person chatting does not see them, but they ride along and take up room on every turn. Explained in: Context and memory
Temperature: A number that divides the scores before the softmax. Low sharpens the distribution (toward the greedy choice); high flattens it (toward chance). Explained in: Predicting the next word
Tensor: An array of numbers with any number of axes: a vector has one, a matrix has two, a color image has three (height, width, and channels). Explained in: The world as numbers
Test set: Held-out data used once at the end to report the expected performance on new cases. Explained in: Generalizing and evaluating
Test-time compute: Computation spent while answering rather than while training: thinking for more tokens, generating several answers and voting, or checking them. It improves the answer without changing the weights, at the cost of more money and waiting. Explained in: Reasoning models
Throughput: Tokens per second delivered by the whole system, summed over everyone served. It rises with batch size, at the expense of the speed each person gets (latency). Explained in: Inference: how a model answers
Token: A piece of text (a word, a word fragment, a symbol, or a basic code) taken from the vocabulary. It is the unit the model reads and generates, and the unit you are billed for. Explained in: Tokens: the model’s alphabet
Tokenizer: A program that cuts text into tokens and gives each one its number (and goes back the other way). It is built before the model is trained and stays fixed. Explained in: Tokens: the model’s alphabet
Tool use: A model’s ability to ask for an external function to be run (look up data, calculate, buy) and to use its result. The model only writes the request; the program around it runs it. Explained in: Agents and tools
Top-p (nucleus sampling): Sampling only among the smallest group of most likely words whose probability adds up to at least p. Top-k does the same with a fixed number, k, of words. Explained in: Predicting the next word
Total cost of ownership (TCO): Everything it costs to own a system over a period: what you pay once (building, integrating, preparing data and gold cases) and what you pay every month (tokens or licenses, hosting and monitoring, the people who review and maintain it). The price per token is only one part. Explained in: Strategy for organizations
Training data: Examples, each with its correct answer, from which a model adjusts its parameters. Explained in: Programming or learning
Transformer: A neural-network architecture made of a stack of blocks with the same shape. Each block combines attention (between tokens) and a network applied to each token, with residual connections and normalization. It was introduced in “Attention Is All You Need” (2017). Explained in: The complete transformer
Underfitting: When a model is too simple to capture the signal: it fails even on the training data. Explained in: Generalizing and evaluating
Universal approximation: Theorem: a network with one hidden layer and enough neurons can approximate any continuous function on a closed, bounded set, to any desired precision. It does not say how many neurons are needed nor that training will find them. Explained in: Layers and activations
Use case: A specific task that AI could change, with who does it, how often, and with what data. It is compared with others by frequency, value per occurrence, and risk. “Use AI in sales” is not a use case; “answer warranty questions by email” is. Explained in: Strategy for organizations
Validation set: Data the model does not use to fit itself, used to choose between models or hyperparameters. Explained in: Generalizing and evaluating
Vanishing gradient: The phenomenon in which the gradient (the blame) is multiplied by factors below one as it travels back through many steps or layers and ends up near zero, so what is far away is not learned. With factors above one the opposite happens: the gradient explodes. Explained in: Sequences and memory
Variational autoencoder (VAE): An autoencoder that sums up each data point as a cloud (center and size) instead of a point, and penalizes clouds that stray from a standard zone. That way the latent space has no holes and you can sample from it. Explained in: Generating is learning a distribution
Vector: An ordered list of numbers. In machine learning, each example reaches the model as a vector. Explained in: The world as numbers
Vector database: Software that stores vectors together with their text and metadata (source, date), and very quickly finds the ones most similar to a query vector, usually with approximate nearest-neighbor search. Explained in: RAG: read before answering
Vector space: A space whose points are vectors. In an embedding space, the distance or angle between two points measures how alike their meanings are. Explained in: Embeddings: meaning as geometry
Verifiable reward: A reward given by a rule that checks the answer (does it match the correct one? does it pass the tests?) instead of a learned judge. The basis of reinforcement learning with verifiable rewards (RLVR), used to train reasoning models. Explained in: Reasoning models
Verification: Checking an answer against an independent source (a document, a database, an expert) before acting on it; not against the same model. Its rigor should be proportional to the risk. Explained in: Hallucinations and limits
Vocabulary: The list of all the pieces (tokens) a tokenizer can produce, each with its number. Real ones have from about thirty-two thousand to about two hundred thousand; the lesson’s toy one, 656. Explained in: Tokens: the model’s alphabet
VRAM (GPU memory): A GPU’s own memory, on the same board as its cores. The parameters and data it computes with must be there. It is measured in gigabytes: 80 on an H100, 12 on an RTX 3060. On data-center GPUs it is a very fast type called HBM. Explained in: GPUs, memory, and quantization
Weight (w): In a linear model, the number that multiplies the input: the slope of the line. It tells how much the prediction rises for each unit the input grows. Explained in: A model and its error
XOR (exclusive or): A function that is one only when its two inputs differ. It is the classic example of a problem that is not linearly separable. Explained in: What a neuron cannot do