A Large Language Model Glossary
A technical and historical reference to the language of modern LLMs: Transformer architecture, tokenization, pretraining, scaling, post-training, RLHF, preference optimization, retrieval, agents, inference, evaluation, safety, landmark researchers, and the projects that shaped the field.
Useful systems combine model architecture, tokenization, training data, post-training, prompts, retrieval, tools, serving infrastructure, evaluation, permissions, and application logic.
The Transformer made large-scale sequence modeling practical, GPT and BERT established powerful pretraining paradigms, instruction tuning and RLHF shaped assistants, and retrieval plus tools turned models into components of larger software systems.
Activation checkpointing
Activation checkpointing saves memory during training by storing only selected intermediate activations and recomputing others during backpropagation.
Why it matters: The method trades additional computation for lower memory use, enabling larger models or longer sequences.
Adapter
An adapter is a small trainable module inserted into a pretrained model so that the model can be adapted to a task or domain without updating all of its original parameters.
Why it matters: Adapters are part of parameter-efficient fine-tuning and reduce the storage and training cost of maintaining many specialized variants of a large model.
Agent
An LLM agent is a system that uses a language model as part of a loop that observes state, chooses actions, calls tools or environments, evaluates results, and continues until a task is complete or a stopping condition is reached.
Why it matters: The agent is larger than the model. Reliability depends on tool interfaces, state management, permissions, planning, verification, and recovery from failed actions.
AI feedback
AI feedback uses one model or automated evaluator to critique, rank, label, or otherwise supervise outputs from another model.
Why it matters: AI feedback can scale preference generation beyond direct human labeling, but it can also reproduce evaluator errors and hidden assumptions.
Alec Radford
Alec Radford is a machine-learning researcher and lead or co-lead author on influential OpenAI work including the original GPT paper, GPT-2, and research on learning from human preferences.
Why it matters: The GPT line helped establish generative pretraining followed by adaptation or prompting as a dominant paradigm for language models.
ALiBi
ALiBi, or Attention with Linear Biases, adds distance-dependent biases to attention scores instead of using conventional learned or sinusoidal position embeddings.
Why it matters: It was proposed as a way to improve length extrapolation while keeping positional treatment simple.
Alignment
LLM alignment is the effort to make model behavior better match intended human goals, instructions, policies, and constraints rather than merely optimizing next-token prediction.
Why it matters: Alignment methods include instruction tuning, preference optimization, RLHF, RLAIF, safety tuning, system instructions, and evaluation of undesirable behaviors.
Ashish Vaswani
Ashish Vaswani is a computer scientist and the first author of the 2017 paper Attention Is All You Need, which introduced the Transformer architecture.
Why it matters: The Transformer replaced recurrent sequence processing with attention-based computation that could be parallelized efficiently during training.
Attention
Attention computes a weighted combination of representations so that a model can use information from different token positions when forming a new representation.
Why it matters: Attention is the core operation of the Transformer and underlies most modern large language models.
Attention Is All You Need
Attention Is All You Need is the 2017 paper by Ashish Vaswani and colleagues that introduced the Transformer architecture using attention rather than recurrence or convolution as the primary sequence mechanism.
Why it matters: The paper became the architectural foundation for BERT, GPT-style models, T5, and much of modern generative AI.
Autoregressive decoding
Autoregressive decoding generates a sequence one token at a time, conditioning each new token on the tokens already present in the context.
Why it matters: This serial dependency is a major reason LLM generation has different performance characteristics from prompt processing and motivates techniques such as KV caching and speculative decoding.
Autoregressive language model
An autoregressive language model predicts the next token conditioned on previous tokens and can generate text by repeatedly feeding its own generated tokens back into the context.
Why it matters: Most GPT-style models are autoregressive decoder-only Transformers.
AWQ
Activation-aware Weight Quantization, or AWQ, is a post-training quantization approach that protects weights associated with important activation channels while compressing the rest.
Why it matters: AWQ is one of several practical methods used to run open LLMs with lower memory requirements.
Batching
Batching processes multiple sequences together so that accelerator hardware can perform more useful work in parallel.
Why it matters: Batching can improve throughput, but variable sequence lengths and generation times complicate efficient serving.
Beam search
Beam search keeps several high-scoring partial sequences during generation instead of committing to one token path at each step.
Why it matters: It is useful for tasks such as translation and structured generation, though open-ended chat models often use sampling rather than beam search.
Beginning-of-sequence token
A beginning-of-sequence token is a special token used to indicate the start of a sequence or conversation in some model and tokenizer designs.
Why it matters: Special tokens are part of the model's learned interface, so using the wrong template or token convention can materially change behavior.
Benchmark contamination
Benchmark contamination occurs when evaluation examples, close variants, solutions, or benchmark-specific information appear in training or adaptation data.
Why it matters: Contamination can inflate scores and make a model look more capable of generalization than it actually is.
BERT
BERT, introduced by Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova, is an encoder-only Transformer pretrained with bidirectional context for language understanding tasks.
Why it matters: BERT helped establish large-scale pretraining followed by task-specific fine-tuning as a standard NLP workflow and demonstrated the power of Transformer encoders.
BIG-bench
BIG-bench is a collaborative benchmark project containing a large and diverse collection of tasks designed to probe capabilities and limitations of language models.
Why it matters: It helped expand evaluation beyond a small set of standard NLP tasks and became part of research on how capabilities change with scale.
BigScience
BigScience was an open collaborative research project that brought together hundreds of researchers to study and build large multilingual language models, culminating in BLOOM.
Why it matters: The collaboration became a landmark experiment in distributed governance and documentation for large-scale AI research.
BLOOM
BLOOM is a 176-billion-parameter multilingual autoregressive language model created through the BigScience collaboration and released with its weights and extensive documentation.
Why it matters: The project was a major community effort to make large-model development, data, governance, and evaluation more transparent and internationally collaborative.
Byte pair encoding
Byte pair encoding, or BPE, is a subword tokenization method that repeatedly merges frequent symbol pairs to build a vocabulary of reusable units.
Why it matters: BPE reduces out-of-vocabulary problems and lets language models represent rare words using combinations of common subword pieces.
C4
C4, the Colossal Clean Crawled Corpus, is a large cleaned English text corpus derived from Common Crawl and introduced as part of the T5 research program.
Why it matters: C4 became an influential pretraining dataset and an example of how filtering and preprocessing choices shape foundation-model data.
Cache eviction
Cache eviction removes stored KV-cache blocks or other cached state when memory is constrained, a session ends, or a serving system needs to admit new work.
Why it matters: Cache policy affects long-session performance, concurrency, and the ability to reuse prefix computation.
Causal attention
Causal attention masks future positions so that a token can attend only to itself and earlier tokens during autoregressive language modeling.
Why it matters: The causal mask prevents a decoder-only model from seeing the answer token before it is supposed to predict it.
Causal language model
A causal language model is trained to predict each token using only preceding context rather than using information from future tokens.
Why it matters: Causal language modeling is the standard pretraining objective for GPT-style decoder-only models.
Chain-of-thought prompting
Chain-of-thought prompting encourages a language model to generate intermediate reasoning steps before producing an answer. The 2022 work by Jason Wei and colleagues showed large gains on several multi-step reasoning benchmarks for sufficiently large models.
Why it matters: The technique helped establish test-time reasoning traces as an important way to elicit capabilities without updating model weights.
Chat template
A chat template defines how system instructions, user messages, assistant messages, separators, role markers, and special tokens are serialized into the token sequence a chat model actually receives.
Why it matters: A model can perform poorly if messages are formatted differently from the conversation structure used during instruction tuning.
ChatGPT
ChatGPT was introduced by OpenAI in November 2022 as a conversational system trained using methods related to InstructGPT and reinforcement learning from human feedback.
Why it matters: Its public research preview made instruction-following language models accessible to a mass audience and accelerated interest in LLM products, alignment, and agentic workflows.
Checkpoint
A checkpoint is a saved snapshot of model parameters and often optimizer or training state at a particular point during training.
Why it matters: Checkpoints support recovery, evaluation over training time, branching into specialized models, and reproducible experiments.
Chinchilla
Chinchilla is the 70-billion-parameter model used in DeepMind's 2022 study of compute-optimal language-model training, which found that many large models had been trained with too few tokens relative to their parameter count.
Why it matters: The work shifted scaling practice toward balancing model size and training data under a fixed compute budget.
Christopher Manning
Christopher D. Manning is a computer scientist whose research has shaped statistical NLP, neural language processing, linguistic representation, and modern foundation-model research.
Why it matters: His work and students have influenced many areas of language understanding, evaluation, representation learning, and preference optimization.
Chunking
Chunking divides documents or other source material into smaller passages before embedding, indexing, or retrieval.
Why it matters: Chunk size and overlap strongly affect RAG because the chunks determine what evidence can be retrieved together and how much irrelevant context is introduced.
Citation grounding
Citation grounding links a generated claim to specific retrieved evidence or source material that can be inspected by a user or system.
Why it matters: Citations can improve auditability, but they must be checked because a model can cite a source that does not actually support the claim.
Colin Raffel
Colin Raffel is a machine-learning researcher and lead author of the T5 work that framed many NLP tasks within a unified text-to-text transfer-learning system.
Why it matters: T5 influenced instruction tuning, dataset design, encoder-decoder language models, and the idea of treating diverse NLP problems through one textual interface.
Common Crawl
Common Crawl is a nonprofit project that collects and publishes large web-crawl datasets. Many language-model corpora use Common Crawl data directly or through heavily filtered derivatives.
Why it matters: Web-scale text gives models broad coverage, but it also introduces issues of duplication, quality, licensing, personal data, language imbalance, and benchmark contamination.
Constitutional AI
Constitutional AI is an Anthropic research approach in which a model critiques and revises outputs using a written set of principles, then can be trained further using AI-generated preference feedback.
Why it matters: The method is important because it explores how explicit principles and AI feedback can reduce dependence on direct human labels for every preference comparison.
Constrained decoding
Constrained decoding restricts token choices so generated output satisfies a grammar, schema, vocabulary, regular expression, or other formal rule.
Why it matters: It is useful for reliable JSON, code structures, database queries, tool arguments, and other machine-consumed outputs.
Context length
Context length is the maximum number of tokens a model can process within one inference window, including instructions, conversation history, retrieved documents, tool results, and generated tokens.
Why it matters: A larger context window increases capacity, but usable attention, cost, latency, and reliability do not necessarily improve linearly with the advertised token limit.
Context poisoning
Context poisoning is the insertion of misleading, malicious, or conflicting information into the model's active context, retrieval results, memory, or tool output.
Why it matters: It can cause a model to follow hostile instructions, cite false evidence, or make decisions based on manipulated state.
Context window
A context window is the bounded token sequence available to a language model for its current computation.
Why it matters: Anything outside the context must be represented through model parameters, retrieval, external memory, summaries, tools, or another mechanism.
Continuous batching
Continuous batching dynamically adds and removes requests from a serving batch as sequences finish instead of waiting for an entire fixed batch to complete.
Why it matters: It improves accelerator utilization for LLM serving where requests have different prompt lengths and generation durations.
Cross-attention
Cross-attention lets one sequence attend to representations from another sequence, such as a decoder attending to an encoded source document or a text model attending to visual features.
Why it matters: It is common in encoder-decoder models and multimodal architectures.
Cross-entropy loss
Cross-entropy loss measures how much probability a model assigns to the correct target token relative to alternatives and is the standard objective for next-token language modeling.
Why it matters: Minimizing token-level cross-entropy produces better next-token prediction, but that training objective does not directly encode truthfulness, usefulness, or safety.
Curriculum learning
Curriculum learning changes the order or distribution of training examples so the model encounters data according to a designed progression rather than a fixed random mixture.
Why it matters: For large models, curriculum can refer to difficulty, sequence length, data quality, language, domain, or synthetic-data schedules.
Data contamination
Data contamination is the presence of evaluation, private, copyrighted, duplicated, low-quality, or otherwise unintended material in training or adaptation data.
Why it matters: Contamination can affect benchmark validity, privacy, memorization, licensing risk, and claims about generalization.
Data deduplication
Data deduplication removes exact or near-duplicate content from a training corpus.
Why it matters: Deduplication can reduce memorization, improve data efficiency, and make it harder for a small number of repeated documents to dominate training.
Data mixture
A data mixture is the weighted combination of different domains, languages, sources, or task types used during pretraining or post-training.
Why it matters: Changing the mixture can alter capabilities substantially even when model architecture and total token count stay the same.
Data parallelism
Data parallelism places replicas of a model on multiple devices and gives each replica different training examples, then synchronizes gradients or parameter updates.
Why it matters: It is the simplest form of distributed training but becomes insufficient when the model itself no longer fits on one device.
Data poisoning
Data poisoning is the deliberate insertion or modification of training, retrieval, fine-tuning, or evaluation data to influence model behavior.
Why it matters: LLM applications can face poisoning at several layers, including pretrained corpora, fine-tuning sets, vector indexes, user memory, and tool-connected knowledge bases.
Decode phase
The decode phase is the token-by-token generation stage after a prompt has been processed. Each step usually produces one new token per sequence and reuses cached attention state.
Why it matters: Decode is often limited by memory bandwidth and serial dependency rather than by the same compute pattern as prompt prefill.
Decoder
A decoder generates or predicts output tokens from previous context and, in encoder-decoder models, may also attend to encoder representations.
Why it matters: Decoder-only Transformers power most autoregressive chat and completion models.
Decoder-only Transformer
A decoder-only Transformer uses causal self-attention and a stack of decoder-style blocks to predict the next token from previous tokens.
Why it matters: GPT-style large language models use this architecture because one pretraining objective naturally supports open-ended generation and in-context task specification.
Denny Zhou
Denny Zhou is an AI researcher known for work on language-model reasoning, including chain-of-thought prompting and related inference techniques.
Why it matters: His work helped establish multi-step reasoning prompts as a practical axis of language-model capability.
Dense model
A dense model activates essentially the same parameter blocks for every token rather than routing tokens through a subset of specialized experts.
Why it matters: Dense architectures are simpler to train and serve than mixture-of-experts models, but all parameters participate in each forward pass.
Dense retrieval
Dense retrieval embeds queries and candidate passages into vector representations and ranks candidates using vector similarity.
Why it matters: It can retrieve semantically related content even when query and document use different words, making it a common component of RAG systems.
Direct Preference Optimization
Direct Preference Optimization, or DPO, trains a language model directly from preference pairs using a classification-style objective rather than first training a reward model and then running reinforcement learning.
Why it matters: DPO became influential because it offers a comparatively simple way to perform preference optimization with human or synthetic comparison data.
Distillation
Knowledge distillation trains a smaller or more efficient model to imitate outputs, distributions, reasoning patterns, or representations from a larger teacher model.
Why it matters: Distillation can reduce deployment cost and latency while retaining part of a larger model's capabilities.
Distributed training
Distributed training coordinates model computation and optimizer updates across multiple accelerators or machines.
Why it matters: Large LLMs require combinations of data, tensor, pipeline, and expert parallelism plus high-speed interconnects and fault-tolerant training infrastructure.
DPO
DPO is the common abbreviation for Direct Preference Optimization, a method for fitting a model to preferred and dispreferred response pairs without an explicit reinforcement-learning stage.
Why it matters: It is widely used in open and commercial model post-training because the optimization pipeline is relatively straightforward.
Edward Hu
Edward J. Hu is the first author of the LoRA paper, which introduced low-rank adaptation as a parameter-efficient way to fine-tune large pretrained models.
Why it matters: LoRA became one of the most widely used methods for adapting open LLMs because it sharply reduces trainable parameter count and memory use.
Elo rating
Elo rating is a ranking system originally developed for competitive games that can be adapted to model comparisons based on pairwise wins and losses.
Why it matters: It produces an intuitive relative ranking, but results depend on the comparison pool, judge quality, prompt distribution, and statistical assumptions.
Embedding
An embedding is a learned vector representation that places text, tokens, documents, images, or other objects in a numerical space where geometric relationships can encode useful similarity.
Why it matters: Embeddings power semantic retrieval, clustering, recommendation, RAG, classification, and many forms of multimodal alignment.
Encoder
An encoder transforms an input sequence into contextual representations without necessarily generating output tokens autoregressively.
Why it matters: Encoder-only models such as BERT are strong for understanding, classification, retrieval, and representation tasks.
Encoder-decoder Transformer
An encoder-decoder Transformer first builds representations of an input sequence and then generates an output sequence while attending to those encoded representations.
Why it matters: The architecture is natural for translation, summarization, transformation, and text-to-text models such as T5.
Encoder-only Transformer
An encoder-only Transformer uses bidirectional attention so each input position can use context from both directions.
Why it matters: BERT popularized the architecture for language understanding tasks where a full input is available before prediction.
End-of-sequence token
An end-of-sequence token is a special token that marks the completion of a sequence or generation in a model's learned token vocabulary.
Why it matters: Stopping behavior can depend on whether the model emits an EOS token, encounters a stop string, reaches a token limit, or is interrupted externally.
Epoch
An epoch is one complete pass through a training dataset, though at foundation-model scale training is often discussed in tokens, steps, or compute rather than neat full-dataset passes.
Why it matters: Repeated exposure to the same data can improve fit but may also increase memorization or overfitting.
Evaluation
LLM evaluation is the process of measuring model or system behavior across tasks, users, risks, costs, and operating conditions.
Why it matters: A production evaluation program typically needs task metrics, human judgment, adversarial testing, latency, cost, grounding, and application-specific failure analysis.
Evaluation harness
An evaluation harness is software that standardizes how models are prompted, scored, configured, and compared across a suite of tasks.
Why it matters: Small differences in prompting, tokenization, sampling, few-shot examples, and answer extraction can materially change benchmark results.
Expert parallelism
Expert parallelism distributes different experts in a mixture-of-experts model across devices or machines.
Why it matters: It enables very large sparse models but introduces routing, communication, balancing, and serving complexity.
Feed-forward network
The feed-forward network, often called the MLP block in a Transformer, applies learned nonlinear transformations independently to each token position after attention has mixed information across positions.
Why it matters: In many LLMs the feed-forward layers contain a large share of the total parameters and are the natural location for mixture-of-experts routing.
Few-shot prompting
Few-shot prompting provides a model with a small number of demonstrations in the prompt before asking it to perform a related task.
Why it matters: GPT-3 made few-shot in-context learning a central part of the modern LLM paradigm by showing that large pretrained models could adapt to tasks without gradient updates.
Fine-tuning
Fine-tuning continues training a pretrained model on a smaller task, domain, behavior, or preference dataset.
Why it matters: Fine-tuning can specialize a model, but it changes model weights and therefore has different cost, governance, and rollback implications from prompting or retrieval.
FLAN
FLAN is a Google research line on instruction tuning, beginning with work showing that fine-tuning a large language model on many tasks expressed as natural-language instructions substantially improved zero-shot performance on unseen tasks.
Why it matters: FLAN helped establish instruction tuning as a major post-pretraining step for general-purpose language models.
FlashAttention
FlashAttention is an exact attention algorithm introduced by Tri Dao and colleagues that reduces costly memory movement by making attention computation aware of the GPU memory hierarchy.
Why it matters: It significantly improved practical Transformer speed and made longer contexts more efficient without changing the mathematical attention result.
FLOPs
FLOPs refers to floating-point operations and is commonly used to estimate the computational work required to train or run a model.
Why it matters: Compute estimates help compare training regimes, hardware efficiency, scaling strategies, and the cost of different architectures.
Foundation model
A foundation model is trained on broad data at scale and can be adapted to many downstream tasks through prompting, fine-tuning, retrieval, tools, or additional training.
Why it matters: LLMs are one important class of foundation model, but foundation models also exist in vision, audio, biology, robotics, and multimodal AI.
Function calling
Function calling is a structured interface in which a language model selects a named function or tool and emits machine-readable arguments rather than only free-form text.
Why it matters: It turns model outputs into actions while giving the surrounding application an opportunity to validate permissions, types, and execution.
GPT
GPT, introduced in the 2018 paper Improving Language Understanding by Generative Pre-Training, used generative Transformer pretraining on unlabeled text followed by discriminative fine-tuning on supervised tasks.
Why it matters: The work helped establish the idea that a single pretrained generative language model could transfer across many downstream language tasks.
GPT-2
GPT-2 was a 2019 OpenAI autoregressive Transformer trained on a large web-text dataset to predict the next token and evaluated across multiple language tasks without task-specific training.
Why it matters: GPT-2 highlighted the growing zero-shot capabilities of scaled language models and sparked discussion about staged model release and misuse risk.
GPT-3
GPT-3 was a 175-billion-parameter autoregressive language model introduced in 2020 that demonstrated strong zero-shot, one-shot, and few-shot task performance using natural-language prompts without task-specific gradient updates.
Why it matters: GPT-3 made in-context learning a defining capability of large language models and helped move prompting into the center of AI application design.
GPTQ
GPTQ is a post-training weight-quantization method designed to compress large generative Transformer models while preserving accuracy well enough for efficient inference.
Why it matters: It became part of the practical open-model ecosystem for running large models with reduced GPU memory requirements.
Gradient accumulation
Gradient accumulation sums gradients across several microbatches before performing an optimizer update.
Why it matters: It allows an effective large batch size even when accelerator memory cannot hold the full batch at once.
Gradient clipping
Gradient clipping limits gradient magnitude before an optimizer update to reduce instability from unusually large gradients.
Why it matters: It is a common stabilization technique in deep-network and Transformer training.
Grammar-constrained generation
Grammar-constrained generation uses a formal grammar to mask invalid next tokens during decoding so every completed output obeys a specified syntax.
Why it matters: It separates syntactic validity from semantic validity and can sharply reduce malformed machine-readable output.
Greedy decoding
Greedy decoding selects the highest-probability next token at every generation step.
Why it matters: It is deterministic and simple, but local choices can produce repetitive or suboptimal sequences and may reduce diversity.
Grounding
Grounding connects an LLM's generation to external evidence, tools, databases, sensory information, rules, or another source of truth rather than relying only on model parameters.
Why it matters: Grounding can reduce some factual errors and improve auditability, but it depends on retrieval quality, source quality, and how faithfully the model uses the evidence.
Grouped-query attention
Grouped-query attention, or GQA, shares key and value projections across groups of query heads, sitting between full multi-head attention and multi-query attention.
Why it matters: GQA can reduce KV-cache memory and speed inference while preserving more expressiveness than sharing one key-value pair across all query heads.
GSM8K
GSM8K is a dataset of grade-school mathematics word problems designed to test multi-step arithmetic reasoning.
Why it matters: The benchmark became prominent in research on chain-of-thought prompting, reasoning traces, verifiers, and test-time computation.
Guardrail
A guardrail is a model, rule, policy, classifier, validator, permission boundary, or workflow control intended to constrain AI-system behavior.
Why it matters: Guardrails are system components rather than magic guarantees and should be evaluated for bypasses, false positives, and interaction with tools or business processes.
Hallucination
Hallucination is the common label for generated content that is unsupported, fabricated, internally inconsistent, or wrong while being presented as if it were valid.
Why it matters: Hallucination is not one single failure mechanism. It can arise from model uncertainty, retrieval failure, prompt ambiguity, decoding choices, stale knowledge, or an application asking the model to answer beyond available evidence.
Hannaneh Hajishirzi
Hannaneh Hajishirzi is an AI researcher whose work spans natural language processing, question answering, reasoning, and instruction-following models, including co-authorship of Self-Instruct.
Why it matters: Self-Instruct helped demonstrate how synthetic instructions can bootstrap general instruction-following behavior.
HELM
HELM, the Holistic Evaluation of Language Models, is a Stanford CRFM project designed to evaluate language models across multiple scenarios and metrics rather than relying on one aggregate benchmark score.
Why it matters: HELM helped popularize multidimensional evaluation that includes accuracy, calibration, robustness, fairness, efficiency, and other concerns.
Hugo Touvron
Hugo Touvron is a machine-learning researcher who led the original LLaMA paper and played a central role in Meta's Llama model research.
Why it matters: The LLaMA project helped expand research access to capable foundation language models and influenced the modern open-weight model ecosystem.
Human preference data
Human preference data contain judgments comparing candidate outputs, demonstrations of desired behavior, critiques, ratings, or other signals about what people prefer a model to do.
Why it matters: Preference data are central to RLHF and direct preference optimization, but they encode the instructions, demographics, incentives, and judgment criteria of the people and organizations collecting them.
HumanEval
HumanEval is a benchmark introduced with OpenAI's Codex work containing programming problems evaluated by running generated code against tests.
Why it matters: It helped popularize pass@k evaluation for code-generating language models and made executable correctness a practical benchmark signal.
Hybrid retrieval
Hybrid retrieval combines multiple retrieval signals, commonly sparse lexical search and dense vector similarity.
Why it matters: The combination can preserve exact-match precision for names or identifiers while also retrieving semantically related passages.
Ilya Sutskever
Ilya Sutskever is a machine-learning researcher whose work spans deep learning, sequence modeling, generative models, and the GPT research line. He co-authored the original GPT and GPT-2 work and earlier influential neural-network research.
Why it matters: His work helped connect large-scale neural sequence modeling with generative pretraining and modern foundation models.
In-context learning
In-context learning is the ability of a pretrained language model to change its behavior based on instructions, examples, or patterns placed in the prompt without updating model weights.
Why it matters: It is one of the defining capabilities of large autoregressive models and turns the context window into a temporary task specification.
Inference
Inference is the process of running a trained language model to compute probabilities, representations, or generated outputs from new inputs.
Why it matters: For LLMs, inference cost is shaped by prompt length, generated length, model size, precision, batching, attention implementation, hardware, and serving architecture.
Inference server
An inference server is the software layer that receives model requests, tokenizes inputs, schedules accelerator work, manages caches, performs decoding, streams results, and enforces service limits.
Why it matters: Serving quality depends on scheduling and memory management as much as on the raw model.
Inference-time compute
Inference-time compute is additional computation spent after training to improve an answer, for example through longer reasoning, multiple samples, search, verification, tool calls, or iterative refinement.
Why it matters: The concept separates capability gains achieved by training a larger model from gains achieved by spending more computation on an individual problem.
InstructGPT
InstructGPT was an OpenAI research line that fine-tuned GPT-3 models using demonstrations, human preference comparisons, a reward model, and reinforcement learning so the models followed user instructions more effectively.
Why it matters: The work became a landmark practical demonstration of RLHF for general-purpose language-model alignment.
Instruction tuning
Instruction tuning fine-tunes a pretrained language model on many tasks expressed as natural-language instructions and desired responses.
Why it matters: It teaches models to treat instructions as a general interface and was a major step toward modern assistants and chat models.
Jacob Devlin
Jacob Devlin is a computer scientist and first author of the BERT paper, which introduced deep bidirectional Transformer pretraining for language understanding.
Why it matters: BERT helped trigger the rapid adoption of large pretrained language representations across NLP.
Jailbreak
A jailbreak is an input strategy intended to make a deployed language model ignore or circumvent behavioral restrictions, policies, or safety controls.
Why it matters: Jailbreak resistance is an application-security and alignment problem because model behavior depends on prompts, context hierarchy, tools, and downstream permissions.
Jailbreak resistance
Jailbreak resistance is the ability of a deployed model system to maintain intended behavioral constraints under adversarial prompting, roleplay, obfuscation, multi-turn pressure, or malicious retrieved content.
Why it matters: It is an ongoing robustness property rather than a one-time filter because attack strategies adapt to the model and application.
Jared Kaplan
Jared Kaplan is a physicist and AI researcher who was first author of the 2020 Scaling Laws for Neural Language Models paper, which quantified empirical relationships among model size, dataset size, compute, and language-model loss.
Why it matters: Scaling-law research influenced how organizations planned large-model training runs and allocated compute among model parameters and data.
Jason Wei
Jason Wei is an AI researcher known for work on instruction tuning, chain-of-thought prompting, and studies of capabilities that change with language-model scale.
Why it matters: His chain-of-thought work helped establish intermediate reasoning prompts as an important test-time technique for large language models.
Jordan Hoffmann
Jordan Hoffmann is an AI researcher and first author of the 2022 Chinchilla paper on compute-optimal large language-model training.
Why it matters: The work showed that many language models could gain more from additional training data rather than simply increasing parameter count under the same compute budget.
KV cache
The key-value cache stores attention key and value tensors computed for earlier tokens so an autoregressive model does not recompute them at every generation step.
Why it matters: KV-cache memory often becomes a major serving constraint for long contexts, large batches, and large models.
Latency
Latency is the elapsed time between a request and a useful response, which can include queueing, prompt processing, time to first token, token generation, network overhead, and tool calls.
Why it matters: User experience can depend as much on latency distribution and first-token delay as on raw tokens per second.
Layer normalization
Layer normalization normalizes activations within a neural-network layer to stabilize optimization and signal scale.
Why it matters: Transformers rely heavily on normalization, with modern architectures using variants such as LayerNorm and RMSNorm.
Learning rate
The learning rate controls the size of parameter updates made during optimization.
Why it matters: Large-model training is highly sensitive to learning-rate schedules, warmup, batch size, optimizer state, and numerical precision.
LLaMA
LLaMA was Meta's 2023 family of foundation language models ranging from 7B to 65B parameters, trained on trillions of tokens with an emphasis on strong performance at smaller sizes using publicly available data sources.
Why it matters: LLaMA became a pivotal project for research on efficient and openly accessible foundation models and strongly influenced the open-weight ecosystem.
LLM
A large language model, or LLM, is a neural language model trained at scale on large text or multimodal corpora and capable of performing many language-related tasks through prompting, adaptation, retrieval, or tools.
Why it matters: The term is descriptive rather than a precise size threshold. LLMs vary in architecture, parameter count, training data, modality, alignment, context length, and deployment design.
LLM-as-a-judge
LLM-as-a-judge uses a language model to grade, compare, critique, or score outputs from another model or system.
Why it matters: It can make evaluation cheaper and more scalable, but judge models have their own biases, positional preferences, calibration errors, and susceptibility to prompt manipulation.
Logits
Logits are the unnormalized scores a model produces for candidate next tokens before the softmax function converts them into probabilities.
Why it matters: Temperature, penalties, token masking, and sampling algorithms operate on or transform these scores during decoding.
Long context
Long-context modeling refers to architectures, training methods, attention mechanisms, retrieval systems, and evaluation techniques designed to let models use very large input sequences.
Why it matters: Long context can reduce the need for aggressive summarization or retrieval, but cost, distraction, positional generalization, and effective use of distant information remain challenges.
Long Ouyang
Long Ouyang is an AI researcher and first author of the InstructGPT paper describing a pipeline using demonstrations, preference comparisons, reward modeling, and PPO to improve instruction following.
Why it matters: The work became one of the most influential practical references for RLHF-based assistant post-training.
LoRA
LoRA, or Low-Rank Adaptation, freezes pretrained model weights and learns small low-rank matrices that modify selected layers during fine-tuning.
Why it matters: LoRA sharply reduces the number of trainable parameters and made task- or domain-specific adaptation of large models much cheaper.
Lost in the middle
Lost in the middle describes the tendency observed in some long-context language models to use information less reliably when relevant evidence appears in the middle of a long input rather than near the beginning or end.
Why it matters: The phenomenon shows why context-window size is not the same thing as uniform ability to use every token inside that window.
Mamba
Mamba is a selective state-space sequence-model architecture introduced by Albert Gu and Tri Dao as an alternative to attention-based Transformers for long sequences.
Why it matters: Mamba is important because it explores whether foundation models can achieve strong sequence modeling with linear scaling in sequence length rather than standard quadratic attention.
Masked language model
A masked language model is trained to reconstruct hidden or corrupted tokens using surrounding context from both directions.
Why it matters: BERT popularized masked-language-model pretraining for encoder representations rather than open-ended autoregressive generation.
Memorization
Memorization occurs when a model retains specific training examples or distinctive fragments strongly enough that they can affect or sometimes be reproduced in outputs.
Why it matters: Memorization matters for privacy, copyright, benchmark contamination, data governance, and understanding the difference between generalization and recall.
Mixed precision
Mixed-precision training uses lower-precision numeric formats for much of computation while retaining higher precision where needed for stability.
Why it matters: Formats such as bfloat16 and float16 make large-model training faster and more memory efficient on modern accelerators.
Mixture of experts
A mixture-of-experts model contains multiple specialized parameter blocks and routes each token to only a subset of them, creating sparse activation.
Why it matters: MoE can increase total parameter capacity without proportionally increasing compute per token, but introduces routing, balancing, communication, and serving complexity.
MMLU
MMLU, or Massive Multitask Language Understanding, is a benchmark containing multiple-choice questions across many academic and professional subjects.
Why it matters: MMLU became a widely reported general-capability score, though like any benchmark it is vulnerable to contamination, saturation, formatting effects, and mismatch with real deployment.
Model card
A model card is documentation describing a model's intended use, training or evaluation context, known limitations, metrics, risk considerations, and other deployment-relevant information.
Why it matters: Model cards help turn model release into a governance artifact rather than only a weight file or benchmark table.
Model collapse
Model collapse describes degradation that can occur when models are repeatedly trained on generated data that poorly represents the original data distribution or amplifies previous model errors.
Why it matters: Synthetic data can be useful, but uncontrolled feedback loops can reduce diversity and distort the information available to future models.
Model Context Protocol
Model Context Protocol, or MCP, is an open protocol for connecting AI applications to external tools and data sources through standardized interfaces.
Why it matters: Protocols for tool and data connectivity move agent design away from one-off integrations, but they also make permissions, trust boundaries, and tool security more important.
Model extraction
Model extraction is the attempt to infer, imitate, or reproduce capabilities or information from a model through queries, outputs, logits, or other exposed interfaces.
Why it matters: Risks range from copying a model's behavior to recovering sensitive memorized information or proprietary system characteristics.
Model merging
Model merging combines parameters or parameter deltas from multiple trained models into a new model without a full retraining run.
Why it matters: It can blend specialized behaviors cheaply, though merged models may exhibit interference or unexpected capability tradeoffs.
Model parallelism
Model parallelism distributes one model across multiple accelerators because its parameters, activations, or computation exceed the capacity of one device.
Why it matters: Tensor, pipeline, and expert parallelism are common forms used in large-model training and serving.
Multi-head attention
Multi-head attention runs several attention operations in parallel using different learned projections, then combines their outputs.
Why it matters: Different heads can learn different relationships or subspaces, increasing representational flexibility.
Multi-query attention
Multi-query attention, or MQA, uses multiple query heads but shares a single key and value head.
Why it matters: It reduces KV-cache size and memory bandwidth requirements during autoregressive inference.
Multi-token prediction
Multi-token prediction trains a model to predict more than one future token from a shared representation rather than optimizing only the immediate next token.
Why it matters: The approach is researched as a way to improve data efficiency, representation quality, or inference possibilities beyond standard next-token objectives.
Needle-in-a-haystack evaluation
A needle-in-a-haystack evaluation places a small target fact inside a long context and tests whether the model can retrieve and use it at different positions and context lengths.
Why it matters: It is a useful stress test for retrieval from long context, but it is much simpler than real document reasoning and should not be treated as a complete measure of long-context intelligence.
Next-token prediction
Next-token prediction trains a model to estimate the probability distribution of the next token given prior context.
Why it matters: The objective is simple and scalable, but predicting text well is not identical to following instructions, being truthful, or acting safely.
Noam Shazeer
Noam Shazeer is an AI researcher who co-authored Attention Is All You Need and has been a major contributor to mixture-of-experts language models and large-scale Transformer research.
Why it matters: His work connects the core Transformer architecture with sparse expert routing and large-model scaling.
Nucleus sampling
Nucleus sampling selects the next token from the smallest set of tokens whose cumulative probability exceeds a threshold p.
Why it matters: Also called top-p sampling, it adapts the candidate set to the model's confidence and is widely used for open-ended generation.
Open-weight model
An open-weight model is a model whose trained parameter weights are made available for others to run, inspect experimentally, fine-tune, or redistribute under the applicable license.
Why it matters: Open weights are not the same as fully open-source AI because training data, code, evaluation details, or commercial rights may still be restricted.
Overoptimization
Overoptimization occurs when continued optimization against a proxy reward degrades the qualities the proxy was intended to represent.
Why it matters: In language-model alignment, pushing too hard on a learned reward model can produce unnatural, repetitive, evasive, or strategically score-seeking behavior.
PagedAttention
PagedAttention is a memory-management approach for KV caches introduced with vLLM that divides cache memory into blocks so serving systems can allocate and share memory more efficiently.
Why it matters: It addresses memory fragmentation and enables higher-throughput serving of variable-length LLM requests.
Pairwise evaluation
Pairwise evaluation asks an evaluator to choose which of two candidate outputs is better under specified criteria.
Why it matters: Pairwise comparisons are common in human preference collection, reward-model training, DPO datasets, and model leaderboards.
PaLM
PaLM, or Pathways Language Model, was a 540-billion-parameter dense Transformer introduced by Google in 2022 and trained across TPU pods using the Pathways system.
Why it matters: PaLM was influential in research on scaling, few-shot learning, multilingual capabilities, code generation, and emergent behavior claims.
Parameter
A parameter is a learned numerical value in a model, such as a weight or bias, adjusted during training.
Why it matters: Parameter count is an imperfect proxy for capacity because architecture, sparsity, data, training compute, context, and post-training all affect performance.
Parameter-efficient fine-tuning
Parameter-efficient fine-tuning, or PEFT, adapts a model by training a small subset of parameters or additional lightweight components rather than updating the entire model.
Why it matters: PEFT methods such as LoRA and adapters reduce GPU memory, storage, and operational cost for specialized models.
Pass@k
Pass@k is a code-generation metric estimating the probability that at least one of k generated program samples passes a test suite.
Why it matters: The metric captures the practical value of sampling multiple candidate solutions rather than evaluating only the first generation.
Patrick Lewis
Patrick Lewis is a machine-learning researcher and first author of the 2020 Retrieval-Augmented Generation paper, which combined a pretrained generator with dense retrieval over an external corpus.
Why it matters: The work gave the modern RAG pattern its name and formalized a way to combine parametric model memory with explicit retrieved knowledge.
Paul Christiano
Paul Christiano is an AI alignment researcher whose work helped develop reinforcement learning from human preferences and influenced later RLHF methods used for language models.
Why it matters: His research connected human preference learning with scalable supervision and practical post-training of generative models.
Percy Liang
Percy Liang is a computer scientist whose work spans natural language processing, foundation models, evaluation, and the Stanford Center for Research on Foundation Models.
Why it matters: He is closely associated with the foundation-model framing and with HELM, a multidimensional approach to language-model evaluation.
Perplexity
Perplexity is an exponentiated form of average token-level cross-entropy that measures how surprised a language model is by a sequence. Lower perplexity generally indicates better prediction under the same tokenization and evaluation setup.
Why it matters: Perplexity is useful for language modeling but does not directly measure instruction following, factuality, reasoning, safety, or application usefulness.
Pipeline parallelism
Pipeline parallelism splits sequential layers or stages of a large model across multiple devices and streams microbatches through them.
Why it matters: It allows models that do not fit on one device to train or run across several accelerators, but creates scheduling and communication overhead.
Positional encoding
Positional encoding supplies information about token order because basic attention does not inherently distinguish position.
Why it matters: Methods include sinusoidal encodings, learned embeddings, rotary position embeddings, and attention biases such as ALiBi.
PPO
Proximal Policy Optimization, or PPO, is a reinforcement-learning algorithm that became widely used in RLHF pipelines for updating a language-model policy against a learned reward model while limiting excessively large policy changes.
Why it matters: PPO is historically important to InstructGPT-style RLHF, though preference-optimization alternatives such as DPO can avoid an explicit RL step.
Prefill
Prefill is the stage in LLM inference where the model processes the full input prompt and populates attention state before autoregressive generation begins.
Why it matters: Prefill is highly parallel and compute-intensive, while subsequent decode steps are more serial and memory-bandwidth sensitive.
Prefix caching
Prefix caching reuses model computation for prompt prefixes that recur across requests, such as common system instructions or shared documents.
Why it matters: It can reduce prefill cost in applications where many users share long, identical context.
Prefix tuning
Prefix tuning learns trainable continuous vectors that are inserted as virtual context into a frozen pretrained model.
Why it matters: It is an early parameter-efficient adaptation method that changes behavior without updating the full model.
Pretraining
Pretraining is the large-scale initial training stage that teaches a language model statistical structure, representations, and broad capabilities from large corpora before task- or behavior-specific post-training.
Why it matters: Pretraining usually consumes the majority of foundation-model compute and strongly shapes the model's underlying knowledge and capabilities.
Prompt
A prompt is the input context supplied to a language model, including instructions, examples, retrieved evidence, conversation history, data, tool results, and formatting.
Why it matters: Prompt design can strongly influence model behavior, but prompts do not change the underlying trained parameters.
Prompt injection
Prompt injection is an attack or failure mode in which untrusted content is interpreted as an instruction that conflicts with the application's intended instructions or control hierarchy.
Why it matters: It is especially important in RAG and agent systems because retrieved webpages, documents, emails, or tool outputs can contain hostile text.
Prompt leakage
Prompt leakage occurs when hidden system instructions, internal context, private retrieved data, or other non-user-facing prompt material is exposed through model output.
Why it matters: Applications should treat hidden prompts as instructions, not as a security boundary for secrets.
Prompt tuning
Prompt tuning learns a small set of continuous prompt embeddings while leaving the underlying model weights frozen.
Why it matters: It is a parameter-efficient way to specialize a model, though learned soft prompts are not usually human-readable.
Pruning
Pruning removes weights, neurons, attention heads, experts, or other model components judged to contribute little to performance.
Why it matters: Pruning can reduce compute and memory, but aggressive removal may damage capabilities that are not represented well by the pruning metric.
QLoRA
QLoRA is a fine-tuning method that backpropagates through a frozen 4-bit quantized base model into LoRA adapters, sharply reducing memory requirements.
Why it matters: The 2023 QLoRA work made high-quality adaptation of large open models practical on much smaller hardware budgets.
Quantization
Quantization represents model weights or activations with lower-precision numeric formats to reduce memory usage, bandwidth, and often inference cost.
Why it matters: Quantization enables larger models to run on less hardware, but aggressive compression can reduce quality or create implementation-specific tradeoffs.
Rafael Rafailov
Rafael Rafailov is a machine-learning researcher and first author of the 2023 Direct Preference Optimization paper.
Why it matters: DPO provided a simpler alternative to reward-model-plus-PPO pipelines for fitting language models to preference pairs.
RAG
Retrieval-augmented generation, or RAG, combines a language model with a retrieval system that fetches external information and places selected evidence into the generation context.
Why it matters: RAG can provide fresher, proprietary, or auditable knowledge without retraining the model, but performance depends on indexing, retrieval, ranking, chunking, context use, and source quality.
ReAct
ReAct is a prompting and agent pattern introduced by Shunyu Yao and colleagues that interleaves language-model reasoning traces with actions in an external environment or tool interface.
Why it matters: The work helped establish a practical bridge between chain-of-thought-style reasoning and tool-using agents.
Reasoning model
Reasoning model is an informal product and research term for a model or inference setup optimized to spend more computation on multi-step problem solving before returning a final answer.
Why it matters: The term does not imply a single architecture. Improvements can come from training data, reinforcement learning, verifiers, search, longer inference, tools, or combinations of these.
Red teaming
Red teaming is adversarial evaluation intended to discover failure modes, unsafe behaviors, exploitable instructions, hidden capabilities, or application vulnerabilities before or during deployment.
Why it matters: Effective red teaming examines the whole system, including tools, retrieval, permissions, interfaces, and humans, not only the base model.
Refusal
A refusal is a model response that declines to provide some requested assistance, often because of safety policies, uncertainty, missing authorization, or capability limitations.
Why it matters: Refusal behavior is a product of both model post-training and runtime policy, and must be balanced against unnecessary over-refusal.
Repetition penalty
A repetition penalty modifies token scores during decoding to discourage the model from repeating tokens or phrases too aggressively.
Why it matters: It is a generation heuristic and can improve some outputs, though excessive penalties can distort grammar, names, or legitimate repetition.
Reranker
A reranker takes a smaller set of retrieved candidates and applies a more expensive relevance model to reorder them before context is passed to the generator.
Why it matters: Reranking often improves RAG quality because first-stage retrieval prioritizes speed while the second stage can use richer query-document interactions.
Residual connection
A residual connection adds a layer's input back to its transformed output so information and gradients can flow through deep networks more easily.
Why it matters: Residual pathways are fundamental to modern Transformers and deep neural networks.
Residual stream
Residual stream is an interpretability-oriented term for the vector pathway that carries and accumulates information through the residual connections of a Transformer.
Why it matters: Thinking in terms of the residual stream helps researchers describe how attention and feed-forward blocks read from and write to a shared representation.
Retrieval-augmented generation
Retrieval-augmented generation is the full phrase behind RAG: a system architecture that retrieves external evidence at inference time and conditions generation on the retrieved material.
Why it matters: RAG separates part of the system's knowledge from model parameters, making it possible to update documents independently of model retraining.
Retriever
A retriever selects documents, passages, records, or other items likely to be relevant to a query before generation or downstream processing.
Why it matters: Retrieval quality sets an upper bound on many RAG systems because a generator cannot faithfully use evidence it never receives.
Reward hacking
Reward hacking occurs when optimization finds behavior that scores well under a reward model or preference proxy without satisfying the underlying human objective.
Why it matters: It is a general alignment problem because model optimization can exploit imperfections in the evaluator.
Reward model
A reward model is trained to predict which outputs people or another evaluator would prefer and produces a scalar or comparative signal used during model optimization.
Why it matters: Reward models compress complex preference judgments into an optimization target, creating the possibility of both useful alignment and reward-model exploitation.
RLAIF
Reinforcement learning from AI feedback, or RLAIF, uses AI-generated preference or critique signals in place of or alongside human feedback during post-training.
Why it matters: RLAIF can scale supervision but shifts part of the alignment problem into the quality and biases of the evaluator model.
RLHF
Reinforcement learning from human feedback, or RLHF, is a family of methods that use human demonstrations or preference judgments to train reward signals and optimize model behavior beyond the pretraining objective.
Why it matters: RLHF became central to modern assistant training because next-token prediction alone does not directly teach helpful instruction following or conversational behavior.
RMSNorm
RMSNorm is a normalization method that scales activations using their root mean square without subtracting the mean.
Why it matters: It is used in many modern LLM architectures because it is simple and computationally efficient.
RoPE
Rotary positional embedding, or RoPE, injects relative position information by rotating query and key representations as a function of token position.
Why it matters: RoPE is widely used in decoder-only LLMs and has become central to long-context extension techniques.
Rotary positional embedding
Rotary positional embedding applies position-dependent rotations to attention query and key vectors so relative position information emerges naturally in their dot products.
Why it matters: It is commonly abbreviated RoPE and is widely used in decoder-only LLMs.
Safety tuning
Safety tuning is post-training intended to reduce harmful, policy-violating, deceptive, privacy-invasive, or otherwise undesirable model behavior.
Why it matters: It may use supervised examples, preference data, reinforcement learning, constitutions, red-team findings, classifiers, or runtime policies.
Sampling
Sampling generates tokens probabilistically from the model's output distribution rather than always choosing the single highest-probability token.
Why it matters: Sampling introduces diversity and can improve open-ended generation, but randomness makes evaluation and reproducibility more complex.
Scaling laws
Scaling laws are empirical relationships showing how language-model loss or performance changes with model size, training data, and compute under specified conditions.
Why it matters: The 2020 OpenAI scaling-law work and later Chinchilla research influenced how large-model training budgets are allocated.
Scaling Laws for Neural Language Models
Scaling Laws for Neural Language Models is a 2020 research paper by Jared Kaplan and colleagues that quantified empirical power-law relationships among model performance, parameter count, dataset size, and compute.
Why it matters: The work influenced the economics and planning of large-model training and helped establish scale as a measurable engineering variable.
Self-consistency
Self-consistency samples multiple reasoning paths for the same problem and selects an answer based on agreement among the paths rather than relying on one chain of thought.
Why it matters: It is an example of using additional inference-time compute to improve reasoning reliability.
Self-Instruct
Self-Instruct is a framework by Yizhong Wang and colleagues that has a language model generate candidate instructions and responses, filters them, and uses the resulting synthetic instruction data for further fine-tuning.
Why it matters: The project demonstrated how models can help bootstrap instruction-tuning datasets with relatively little manual annotation.
SentencePiece
SentencePiece is a language-independent tokenizer framework by Taku Kudo and John Richardson that can train subword tokenizers directly from raw Unicode text rather than requiring language-specific pretokenization.
Why it matters: It became widely used in multilingual and foundation-model pipelines because it supports reversible tokenization and multiple subword algorithms.
Sequence packing
Sequence packing combines multiple shorter training examples into full model-length sequences so fewer padding tokens consume compute.
Why it matters: Efficient packing can substantially improve training utilization, but boundaries and masking must be handled correctly to avoid unintended information leakage between examples.
Shunyu Yao
Shunyu Yao is an AI researcher and first author of the ReAct paper, which combined language-model reasoning traces with actions in external environments.
Why it matters: ReAct helped shape modern LLM agent design by treating reasoning and tool use as an interleaved loop.
Sliding-window attention
Sliding-window attention limits each token's attention to a local region rather than every token in the full sequence.
Why it matters: It reduces attention cost for long contexts and can be combined with occasional global or recurrent mechanisms.
Softmax
Softmax converts a vector of logits into a normalized probability distribution over candidate tokens or classes.
Why it matters: During generation, temperature and token filtering are commonly applied around the softmax distribution before sampling.
Sparse activation
Sparse activation means only a subset of a model's total parameters are used for a given token or input.
Why it matters: Mixture-of-experts architectures use sparse activation to increase total capacity without using every parameter in every forward pass.
Sparse retrieval
Sparse retrieval represents documents and queries primarily through lexical signals such as term frequencies rather than dense learned vectors.
Why it matters: BM25 is a common sparse method, and hybrid retrieval often combines lexical precision with dense semantic matching.
Speculative decoding
Speculative decoding uses a smaller or faster model to propose several tokens and a larger target model to verify them in parallel, accepting proposals that preserve the target model's output distribution.
Why it matters: It can reduce autoregressive latency without retraining the target model or sacrificing exact sampling behavior under the algorithm's assumptions.
Stop sequence
A stop sequence is a configured string or token pattern that causes generation to terminate when encountered.
Why it matters: Stop conditions are application-level controls and should not be confused with the model's learned EOS token.
Structured output
Structured output constrains or guides an LLM to emit data that conforms to a schema such as JSON, a typed object, or a formal grammar.
Why it matters: It makes model outputs easier for software to validate and consume, though semantic correctness still requires checking beyond syntax.
Supervised fine-tuning
Supervised fine-tuning, or SFT, trains a pretrained model on curated input-output examples using ordinary supervised learning.
Why it matters: SFT is a core stage in instruction-following model development and often precedes preference optimization.
Sycophancy
Sycophancy is the tendency of a language model to agree with a user's stated belief, preference, or premise even when doing so reduces truthfulness or quality.
Why it matters: It can emerge from preference optimization if evaluators disproportionately reward agreeable responses.
Synthetic data
Synthetic data are examples generated by models, simulators, programs, or transformation pipelines rather than collected directly from naturally occurring human data.
Why it matters: Synthetic data can expand coverage and cheaply generate demonstrations, but quality control matters because model errors and biases can be amplified recursively.
System prompt
A system prompt is a high-priority instruction layer supplied by an application to define role, behavior, constraints, tool rules, style, or policies before user input is processed.
Why it matters: System prompts influence runtime behavior but are not a substitute for model training, application security, or permissions.
T5
T5, the Text-to-Text Transfer Transformer, reframed a wide range of NLP tasks as text-to-text problems and systematically studied pretraining objectives, architectures, datasets, and transfer methods.
Why it matters: T5 influenced encoder-decoder foundation models, instruction tuning, C4, and the practice of unifying tasks through natural-language input and output.
Temperature
Temperature rescales logits before sampling. Lower temperatures concentrate probability on high-scoring tokens, while higher temperatures flatten the distribution and increase randomness.
Why it matters: Temperature changes diversity and unpredictability but does not directly measure creativity, factuality, or intelligence.
Tensor parallelism
Tensor parallelism splits large matrix operations or model tensors across multiple accelerators so a single layer can be computed cooperatively.
Why it matters: It is widely used to train and serve models whose individual layers are too large or too computationally expensive for one device.
Test-time compute
Test-time compute is computation spent on a particular inference problem after training, including longer reasoning, multiple candidates, search, verification, or tool use.
Why it matters: It has become an important scaling axis alongside model parameters, training data, and pretraining compute.
The Pile
The Pile is an 825 GiB English-language dataset assembled by EleutherAI from 22 diverse sources for training and evaluating large language models.
Why it matters: It became an influential open corpus and helped make large-model data composition more inspectable than many proprietary training datasets.
Throughput
Throughput measures how much inference work a serving system completes over time, commonly in tokens per second, requests per second, or generated tokens per accelerator.
Why it matters: High throughput can conflict with low per-user latency, so production systems balance batching, queueing, model size, precision, and service-level goals.
Tim Dettmers
Tim Dettmers is an AI researcher known for work on memory-efficient deep learning, quantization, and QLoRA.
Why it matters: QLoRA made it practical to fine-tune much larger models on modest hardware by combining 4-bit quantization with LoRA adapters.
Time to first token
Time to first token, or TTFT, measures the delay between submitting a request and receiving the first generated token.
Why it matters: TTFT is strongly affected by queueing and prompt prefill and is often a better measure of perceived responsiveness than average generation speed.
Timo Schick
Timo Schick is an AI researcher and first author of Toolformer, work showing how a language model could learn when and how to call external tools from a small number of demonstrations.
Why it matters: Toolformer became an influential research reference for self-supervised tool use by language models.
Token
A token is a discrete unit processed by a language model after text or other data are converted by a tokenizer. A token may correspond to a word, part of a word, punctuation, whitespace pattern, byte sequence, or special symbol.
Why it matters: Token counts determine context usage, cost, latency, and how text is represented to the model, so tokens should not be assumed to equal words.
Tokenization
Tokenization is the process of segmenting or encoding raw text into the discrete tokens consumed by a language model.
Why it matters: Different tokenizers can produce very different token counts and representations for the same string, which affects training efficiency and inference behavior.
Tokenizer
A tokenizer converts raw text into token IDs from a fixed vocabulary and converts generated IDs back into text.
Why it matters: Tokenizer design affects sequence length, multilingual performance, code representation, rare words, numerical text, context efficiency, and compatibility with model weights.
Tokens per second
Tokens per second is a common measure of generation throughput or speed, usually referring to the rate at which output tokens are produced after prefill.
Why it matters: The metric is useful but incomplete because user experience also depends on time to first token, queueing, prompt size, batching, and tool latency.
Tool use
Tool use is the ability of a language-model system to invoke external functions such as search, calculators, databases, code execution, browsers, APIs, or enterprise applications.
Why it matters: Tools allow models to access current data and perform actions, but they also create security, authorization, observability, and failure-recovery requirements.
Toolformer
Toolformer is a Meta AI research project that trained a language model to decide when to call external APIs, what arguments to send, and how to incorporate the returned results into future token prediction.
Why it matters: It is an important bridge between pure language modeling and models that augment themselves with calculators, search, translation, and other tools.
Top-k sampling
Top-k sampling restricts the next-token distribution to the k highest-probability tokens before sampling.
Why it matters: It gives a fixed candidate-set size, unlike top-p sampling where the number of eligible tokens changes with the shape of the distribution.
Top-p sampling
Top-p sampling chooses from the smallest set of next-token candidates whose cumulative probability reaches a threshold p.
Why it matters: Also known as nucleus sampling, it adapts the size of the candidate set to model confidence.
Training Compute-Optimal Large Language Models
Training Compute-Optimal Large Language Models is the 2022 DeepMind paper commonly associated with Chinchilla. It argued that, under a fixed compute budget, model size and training-token count should be balanced differently than many earlier scaling practices.
Why it matters: The paper shifted attention from parameter count alone to the joint allocation of parameters, data, and compute.
Training corpus
A training corpus is the collection of text, code, documents, conversations, or multimodal examples used during model training.
Why it matters: Corpus composition influences language coverage, knowledge, style, bias, memorization, domain competence, legal risk, and benchmark contamination.
Transformer
A Transformer is a neural architecture built around attention, position information, feed-forward layers, residual connections, and normalization. It was introduced in 2017 for sequence transduction and became the dominant architecture for modern language models.
Why it matters: Transformers scale well on accelerators because training can process sequence positions in parallel, unlike strictly recurrent architectures.
Tri Dao
Tri Dao is an AI systems researcher known for FlashAttention and for co-authoring the Mamba selective state-space architecture.
Why it matters: His work focuses on the interaction between model architecture and the hardware realities of memory movement and efficient sequence processing.
Vector database
A vector database or vector index stores embeddings and supports nearest-neighbor search over those vectors.
Why it matters: It is commonly used in RAG, semantic search, recommendation, and memory systems, though a full RAG stack also needs ingestion, chunking, metadata, ranking, access control, and evaluation.
vLLM
vLLM is an open-source LLM serving system known for PagedAttention and continuous batching to improve memory utilization and throughput.
Why it matters: It became influential in open-model serving because memory management is often as important as raw model math for efficient inference.
Vocabulary
A tokenizer vocabulary is the fixed set of token IDs and token pieces that a model can directly represent.
Why it matters: Vocabulary design trades off model embedding size, sequence length, multilingual coverage, and how efficiently common patterns are encoded.
Weight
A weight is a learned numerical parameter that controls how signals are transformed inside a neural network.
Why it matters: When people refer to releasing model weights, they generally mean distributing the trained parameter tensors needed to run the model architecture.
WordPiece
WordPiece is a subword tokenization method used in models including BERT. It represents words as combinations of frequent learned pieces rather than requiring a token for every complete word.
Why it matters: Subword tokenization balances vocabulary size against sequence length and handles rare or novel words through decomposition.
Zero-shot prompting
Zero-shot prompting asks a pretrained or instruction-tuned model to perform a task from instructions alone without examples in the current prompt.
Why it matters: Zero-shot behavior is a major reason instruction-following models can serve many tasks through one general interface.
The model is only one dependency in the system the business now owns.
Once an LLM is connected to company data, internal applications, customer workflows, tools, or autonomous actions, architecture, observability, ownership, security, maintenance, and continuity matter alongside model quality.