Concepts

The nonlinear step that reshapes a layer's output so stacked layers can model richer patterns than repeated linear transforms alone.

Quantizing live intermediate activations during execution instead of only shrinking stored weights.

The post-pretraining goal of shaping a broadly capable base model toward helpful, safer, preference-following behavior before or during deployment.

A positional idea that subtracts larger attention penalties for farther token pairs instead of storing explicit position embeddings.

Running representative inputs through a model to estimate the ranges or scales a quantized deployment will need.

A diffusion inference technique that steers denoising by comparing prompt-conditioned and prompt-free predictions, then blending them with a guidance scale.

Common techniques that stretch usable context beyond a model's original training window without rebuilding the entire architecture from scratch.

Choosing some quantization scales or converted values at runtime instead of fixing every low-precision detail ahead of deployment.

A learned vector that turns discrete tokens, image patches, or other inputs into numbers a model can process.

Floating-point operations counted to estimate how much arithmetic work a model needs during inference, before teams compare serving cost, throughput plans, or hardware capability.

A generative training objective that teaches a model how samples should move from a simple or noisy starting state toward real data.

Saved key and value tensors from earlier tokens that let later generation steps reuse attention state instead of recomputing the full prefix.

Compressing the cached keys and values kept across autoregressive decode steps to reduce long-context serving memory.

A learned compressed representation space where models store internal codes instead of raw pixels or token ids, then decode or denoise back to visible outputs.

How quickly weights, activations, and KV cache bytes can move between memory and compute during model serving, and why that movement can cap useful throughput.

A broad sparse-routing architecture pattern that activates only a few expert sub-networks per token instead of one dense path for every token.

Keeping activations on a predictable scale so deep model stacks stay trainable and their sublayers receive stable inputs.

Learning from examples or trajectories produced by the model or agent policy that is currently being updated.

A small generated concept page that demonstrates the page-spec bundle workflow end to end.

How transformers inject order into otherwise permutation-invariant attention through absolute, relative, and rotary position schemes.

Converting an already trained model to lower precision after training so it can use less memory or run more efficiently.

The prompt-processing stage that reads the full input once, builds the first attention state, and sets up generation before any reply token appears.

The serving setup that separates prompt processing from token-by-token generation because the two stages stress hardware, memory, and latency in different ways.

Storing or computing with fewer bits so models use less memory and sometimes run more efficiently, with tradeoffs around quality, calibration, and hardware support.

Training or fine-tuning with simulated low-precision effects so a model can adapt before deployment.

Training-time and model-design choices that discourage brittle memorization so a model is more likely to perform well on new examples.

A throughput-ceiling chart that shows when memory movement or arithmetic compute limits attainable performance, using arithmetic intensity to explain which bound is active.

How a token reads other tokens from the same sequence so a transformer can mix context before producing the next representation.

Training material produced or transformed by one model to teach another, distinct from raw web corpora collected for pretraining or demonstrations written directly by people.

A positive scaling factor applied to logits before softmax to make the next-token distribution sharper or flatter.

Extra prompt-derived vectors that steer an image generator while the denoiser removes noise step by step.

How tokenizers turn raw text into reusable pieces before embeddings, attention, and next-token prediction begin.

How attention, feed-forward layers, normalization, residuals, and position information repeat inside each decoder-style transformer block.

Models that produce moving visual sequences by generating or refining frames—or visual tokens arranged over time—while keeping motion, identity, and appearance coherent from one moment to the next.

How images and video frames become patches, discrete codes, or latent tokens so sequence-based models can read visual data.

Compressing stored model weights into fewer bits while most runtime activations stay at a higher precision.

Why lowering model weights to 4-bit often cuts memory more than it cuts end-to-end latency or throughput.

Why stretching sequence length strains attention compute, KV-cache memory, position schemes, and retrieval quality even when a model advertises a large context window.