Glossary

A non-linear function applied element-wise to a neuron's output so a stack of layers can represent more than a single linear map.

The control loop an LLM agent runs — call the model, execute any tool calls it returns, feed the results back, repeat until it stops asking for tools.

A mechanism that lets a model weigh which other tokens in a sequence matter most when computing a representation for the current one.

The algorithm that computes gradients of the loss with respect to every weight in a network by applying the chain rule backwards.

A layer that normalizes activations across a mini-batch so each feature has roughly zero mean and unit variance, then rescales them with learned parameters.

A decoding strategy that keeps the top-k highest-probability partial sequences at each step instead of greedily picking one.

The statistical error introduced when a model is too simple to capture the true structure of the data — not the societal fairness kind.

Prompting an LLM to write out its reasoning step by step before giving a final answer, which usually improves accuracy on multi-step problems.

Splitting documents into smaller, retrievable pieces before embedding them so retrieval returns the right span instead of the wrong book.

The maximum number of tokens an LLM can consider in a single forward pass — prompt plus generated output.

A neural network architecture that uses learned convolution filters over local regions of an input grid — images, audio spectrograms, or any tensor with spatial structure.

A resampling technique that estimates how well a model will generalize by training and evaluating on multiple data splits.

A generative model that learns to reverse a gradual noising process — you train it to denoise, then sample by iteratively denoising pure noise.

When the data or relationships a model sees in production move away from what it was trained on, quietly degrading performance.

A regularization trick that randomly zeros out a fraction of activations during training so the network can't depend on any single neuron.

Training a smaller "student" model to mimic the outputs of a larger "teacher" so you get most of the quality at a fraction of the cost.

A dense vector that encodes the meaning of a piece of data so similar things land near each other in vector space.

The part of a model that reads an input sequence and produces a fixed-size or per-token vector representation for downstream use.

One full pass of the training algorithm over the entire training dataset.

The harmonic mean of precision and recall — a single number that punishes you for being lopsided on either.

The craft of deriving inputs that make a model's job easier — usually by encoding domain knowledge the raw data doesn't surface.

Teaching a model a new task by giving it a handful of example input/output pairs in the prompt rather than by fine-tuning.

Continuing training on a pretrained model with a smaller, task-specific dataset to specialize its behavior.

Two networks trained against each other — a generator that creates fake samples and a discriminator that tries to tell them from real ones.

An iterative optimization method that nudges parameters in the opposite direction of the gradient to reduce a loss.

When an LLM produces text that is fluent and confident but factually wrong or unsupported by its input.

A configuration value you set before training that controls how the model learns — distinct from the parameters the model learns itself.

Running a trained model to produce predictions on new inputs — the serving side of ML, as opposed to training.

A Python library from Google for high-performance numerical computing with autodiff, JIT compilation, and vectorization via a NumPy-like API.

An unsupervised algorithm that partitions n points into k clusters by iteratively assigning points to the nearest centroid and moving centroids to the mean of their cluster.

An asymmetric measure of how much one probability distribution differs from another — zero when they match, larger as they diverge.

The lower-dimensional vector space a model compresses its inputs into, where similar things end up near each other.

The scalar that controls how big a step the optimizer takes in the direction of the gradient — the single most important training hyperparameter.

A parameter-efficient fine-tuning method that freezes the base model and trains small low-rank update matrices on top.

A scalar score that measures how wrong a model's predictions are — the thing the optimizer tries to make smaller.

An architecture where only a few specialized sub-networks ("experts") fire for any given input, chosen by a learned router.

An open protocol for connecting LLM applications to tools, data sources, and prompts in a standard way — like USB for AI tool integrations.

Running several attention operations in parallel with different learned projections so the model can attend to multiple relationships at once.

A model built from stacked layers of linear transformations and non-linear activations, trained end-to-end with gradient descent.

The algorithm that updates model weights from their gradients — SGD, Adam, AdamW, Lion, and friends.

When a model memorizes training data instead of learning patterns that generalize to new data.

An intrinsic LLM metric — the exponentiated average negative log-likelihood the model assigns to held-out text. Lower is better.

Two complementary metrics for classification — precision is "of what I flagged, how much was right"; recall is "of what was actually there, how much did I catch".

An attack where malicious instructions hidden in untrusted input override the developer's prompt and steer the model into doing something it shouldn't.

Storing model weights and activations in lower precision (int8, int4) so the model is smaller, cheaper, and faster — at some quality cost.

An agent pattern that interleaves reasoning ("think") with tool calls ("act") so the model can observe results and adjust mid-task.

Anything you add to training that discourages the model from fitting noise — usually a penalty on weight magnitude or randomness in the forward pass.

A second-stage model that re-scores the top results from a fast retriever to push the most relevant ones to the top.

A pattern where you retrieve relevant documents at query time and stuff them into the LLM's prompt so it can ground its answer in real sources.

Fine-tuning a language model using a reward model trained on human preference data, with reinforcement learning to optimize for the reward.

The area under the ROC curve — a threshold-independent measure of how well a classifier ranks positives above negatives.

A function that turns a vector of real numbers into a probability distribution — exponentiate each, divide by the sum.

A scalar that divides logits before softmax at sampling time — lower temperature makes the model more deterministic, higher makes it more random.

The atomic unit an LLM actually reads and writes — usually a sub-word fragment, not a whole word.

The component that converts text to and from the integer token IDs an LLM actually consumes.

Taking a model pretrained on a large general dataset and reusing it — with or without further training — on a different, usually smaller, task.

A neural network architecture built on stacked self-attention and feed-forward layers — the backbone of every modern LLM.

When a model is too simple or trained too little to capture the structure in the data — high error on both training and test sets.

When gradients shrink exponentially as they propagate back through many layers, so early layers barely update and the network won't train.

A database whose primary index is built for fast approximate nearest-neighbour search over high-dimensional embeddings.

A gradient-boosted decision tree library known for winning tabular-data competitions and still being the right default for structured data.

A family of real-time object detection models that predict bounding boxes and class scores in a single forward pass.

Getting a model to perform a task it wasn't explicitly trained on, purely from a natural-language description of the task.