NCP-GENL Concept Glossary
Every concept taught across the 52-lesson NVIDIA Certified Professional: Generative AI LLMs prep course, in one place: 52 terms, each with a plain definition and a link to the lesson that introduces it.
- Scaled dot-product attentionNCPG-C1
- Query, Key, and Value vectors combined as softmax(QKᵀ/√dₖ)·V, where dividing by √dₖ keeps dot products from growing large enough to saturate softmax.
- Multi-head attention, positional encoding, and layer normalizationNCPG-C2
- Parallel attention heads over different representation subspaces (not a parameter-reduction trick), plus the positional signal and normalization that keep a transformer trainable.
- Architecture familiesNCPG-C3
- Encoder-only (bidirectional, MLM), decoder-only (causal, CLM), and encoder-decoder families matched to the training objective and task they fit.
- Embedding extraction from encoder and decoder modelsNCPG-C4
- Extracting and comparing dense vector embeddings from both encoder and decoder models via cosine similarity, requiring query and document embeddings from the same vector space.
- Output sampling for decodersNCPG-C5
- Greedy, beam search, temperature, top-k, and top-p decoding — temperature reshapes the whole distribution while top-k/top-p truncate it; beam search maximizes likelihood, not diversity.
- In-context learningNCPG-C6
- Zero-shot, one-shot, and few-shot prompting with no gradient updates — the name "few-shot learning" invites confusion with fine-tuning despite training no weights.
- Chain-of-thought prompting and prompt templatesNCPG-C7
- Step-by-step reasoning prompts that help multi-step tasks but cost tokens and latency, making them a poor fit for simple lookup tasks.
- Causal language modeling (CLM)NCPG-C8
- The left-to-right, next-token-prediction training objective that makes autoregressive generation possible and that prompt engineering ultimately steers.
- Constrained decoding and validation wrappersNCPG-C9
- Decoding-time controls that reduce malformed and hallucinated output without touching model weights or adding knowledge — pair with RAG for the latter.
- Choosing prompting vs. RAG vs. fine-tuningNCPG-C10
- A decision rule under a stated constraint: dynamic or citable knowledge points to RAG, a new skill or style baked in permanently points to fine-tuning, and both should be exhausted first when data or compute is limited.
- Dataset cleaning and curationNCPG-C11
- Deduplication and class-imbalance handling using tools like NeMo Curator and RAPIDS cuDF, with scalers and encoders fit on the training split only.
- Dataset organization and formattingNCPG-C12
- Correct formats for a given task — JSONL for instruction data, prompt/response pairs for SFT, chunked passages for RAG — with clean, non-leaking splits.
- BPE vs. WordPiece subword tokenizationNCPG-C13
- Two subword merge rules: BPE merges the most frequent adjacent pair; WordPiece merges the pair that most increases corpus likelihood. Neither is character- or word-level.
- The vocabulary-size tradeoffNCPG-C14
- A bigger vocabulary shortens sequences but enlarges the embedding and softmax tables; because tokenization changes token counts, perplexity is only comparable across models sharing one tokenizer.
- The five-step EDA checklist before fine-tuningNCPG-C15
- Distribution, length, vocabulary, label, and quality checks that catch imbalance, leakage, and truncation risk before they quietly wreck results.
- Quantization: PTQ vs. QAT vs. GPTQNCPG-C16
- PTQ calibrates scales from observed activations with no retraining; QAT retrains with fake-quant nodes for better low-precision accuracy; GPTQ is a distinct one-shot, post-training, weight-only method using Hessian information — none of them improve accuracy, only protect it while cutting memory and latency.
- Knowledge distillation: the DistilBERT trioNCPG-C17
- DistilBERT's three measured properties — roughly 40% smaller, 60% faster, and about 97% of BERT's performance retained — distinguishing "40% smaller" from "40% of the size."
- Pruning and structured 2:4 sparsityNCPG-C18
- Unstructured pruning zeroes individual weights but may not speed up dense hardware; structured 2:4 sparsity maps directly to Tensor Core acceleration and pairs with INT8 in TensorRT.
- KV cachingNCPG-C19
- Storing per-token keys and values so decoding does not recompute attention over the whole prefix each step — the primary latency lever for autoregressive inference, spending memory to buy speed.
- Streaming attention and TensorRT runtime optimizationNCPG-C20
- Sliding-window attention bounding memory for long sequences, and TensorRT compiling, fusing kernels, and auto-tuning for a target GPU — optimization, distinct from Triton serving.
- Encoder foundation models and masked language modelingNCPG-C21
- Training encoder-based foundation models with MLM, alongside the quantization, distillation, and pruning levers that shrink them for deployment.
- Parameter-efficient fine-tuning: LoRA, adapters, P-tuningNCPG-C22
- LoRA freezing base weights and training small low-rank matrices that merge back in with no added inference latency, unlike bottleneck adapters — PEFT never shrinks the base model.
- Alignment: SFT, RLHF, DPO, and GRPONCPG-C23
- Classic RLHF trains a separate reward model and PPO critic; DPO drops the reward model and optimizes preference pairs directly; GRPO keeps a reward signal but drops the critic, using group-relative scores instead.
- Contrastive loss for embeddingsNCPG-C24
- A loss pulling similar pairs together and pushing dissimilar pairs apart in embedding space — the basis for retrieval and semantic-search models feeding RAG.
- Early stopping and fine-tuning impact assessmentNCPG-C25
- Capturing the best-generalizing checkpoint before the validation optimum is passed, and measuring impact against a stated before/after baseline.
- When to fine-tune vs. prompt or RAGNCPG-C26
- Fine-tuning for a new skill, style, or behavior baked in permanently; prompting or RAG when knowledge is dynamic, must be cited, or data and compute are limited.
- PerplexityNCPG-C27
- A metric where lower is better, undefined for masked LMs like BERT, and comparable only across models sharing the same tokenizer.
- BLEU vs. ROUGE vs. METEORNCPG-C28
- BLEU is precision-oriented (built for translation); ROUGE is recall-oriented (built for summarization); METEOR adds stem and synonym awareness beyond raw n-gram overlap.
- LLM-as-a-judge and error analysisNCPG-C29
- Combining automatic scores with judge or human review and systematic error-mode categorization to catch fluent-but-wrong answers that surface-overlap metrics miss.
- Benchmarking and scalable evaluation frameworksNCPG-C30
- Standardized metrics enabling cross-platform comparisons, with tools like NeMo Evaluator packaging benchmark harnesses, LLM-as-a-judge scoring, and RAG/agent metrics into one service.
- RAG evaluation metricsNCPG-C31
- Faithfulness (grounding), answer relevancy, context precision, and context recall — splitting quality across the retrieval/generation boundary so scoring only the final answer does not hide which stage is weak.
- The parallelism familiesNCPG-C32
- Data, tensor, pipeline, sequence, context, and expert parallelism combining to scale training from billions to trillions of parameters, each with its own precondition.
- Tensor Parallelism vs. Pipeline ParallelismNCPG-C33
- Tensor parallelism splits within a single layer (intra-layer); pipeline parallelism splits across consecutive layers (inter-layer) — the domain's most common distractor pair.
- Memory sharding: FSDP and ZeRONCPG-C34
- Sharding optimizer state — and optionally parameters and gradients — across data-parallel ranks; a memory technique layered on data parallelism, not a separate parallelism axis.
- Mixed precision and Tensor CoresNCPG-C35
- FP16/BF16 compute on Tensor Cores as the default fast path on modern GPUs, where FP16 risks gradient underflow without loss scaling and BF16's wider exponent range often avoids needing it.
- Gradient accumulation and effective batch sizeNCPG-C36
- Per-device batch size times accumulation steps, letting a large effective batch fit under a memory cap without reducing total compute.
- Profiling with NsightNCPG-C37
- Locating kernel occupancy, memory-bound versus compute-bound kernels, and CUDA memory issues before changing batch size, precision, or parallelism configuration.
- Dynamic vs. sequence batchingNCPG-C38
- Dynamic batching combines independent requests at runtime for stateless models; sequence batching routes a stateful sequence's requests to the same model instance — applying the former to the latter is the standing trap.
- NVIDIA NIM as a prepackaged microserviceNCPG-C39
- NIM LLM 2.0's "one container, one backend" design with vLLM as the inference engine, shipping validated containers with OpenAI-compatible endpoints — a higher-level microservice above the general Triton server.
- Concurrent model execution and instance groupsNCPG-C40
- Running several copies of the same model, or several different models, in parallel on one system including a single GPU — complementary to, not the same mechanism as, dynamic batching.
- Containerization, Kubernetes, and MIGNCPG-C41
- Docker packaging model plus runtime for reproducible deployment, Kubernetes scaling and health-checking it, and Multi-Instance GPU partitioning a single GPU for multi-tenant serving.
- Model-type compute tradeoffsNCPG-C42
- Decoder generation latency scaling with output length because decoding is sequential — unlike a single-pass encoder, bigger batches alone cannot fix it; KV caching is the main mitigation.
- Reliability and performance metricsNCPG-C43
- Latency percentiles (p95, p99), throughput, and error rate, chosen because reporting only average latency hides the tail problems users actually feel.
- Logging and root-cause analysisNCPG-C44
- Capturing request/response logs and alerting on latency spikes, error surges, and quality drops — turning an anomaly into a diagnosed root cause.
- Data drift and concept driftNCPG-C45
- A model that passed evaluation at launch drifting in production as real-world inputs shift away from the training distribution — launch evaluation is not a standing guarantee.
- Regression benchmarking against prior versionsNCPG-C46
- Continuously comparing a deployment against previous versions on a fixed suite, treating evaluation as ongoing rather than a one-time launch gate.
- Automated tuning, retraining, and versioningNCPG-C47
- Automated (not manual) retraining and tuning, with versioning providing traceability and safe rollback.
- NeMo Guardrails' three rail categoriesNCPG-C48
- Topical, safety/content, and security (anti-injection) rails governing both inputs and outputs — three distinct jobs, not one blanket filter.
- Measuring guardrail effectivenessNCPG-C49
- Evaluating a guardrail's coverage alongside its latency and false-positive-rate cost, not coverage alone.
- Disaggregated bias and fairness auditingNCPG-C50
- Per-group evaluation as the only way to detect disparate impact a high overall accuracy number can mask — mitigation happens at the data and training level, not inside a guardrail.
- Hallucination mitigationNCPG-C51
- RAG grounding, constrained decoding, and trustworthiness checks that reduce but do not eliminate hallucination, since a model can still misuse or ignore given context.
- Responsible-AI monitoring and complianceNCPG-C52
- Ongoing compliance monitoring for toxicity and PII leakage, extending production monitoring to ethical and regulatory signals across the whole lifecycle.
Introduced in Scaled dot-product attention: Query, Key, Value, and the √dₖ scale
Introduced in Multi-head attention, positional encoding, and layer normalization
Introduced in Architecture families: encoder-only, decoder-only, and encoder-decoder
Introduced in Embeddings: extraction from encoder and decoder models, and cosine similarity
Introduced in Output sampling for decoders: greedy, beam search, temperature, top-k, top-p
Introduced in In-context learning: zero-shot, one-shot, and few-shot prompting
Introduced in Chain-of-thought prompting and prompt templates for small or specialized data
Introduced in Causal language modeling: the training objective behind generation
Introduced in Output control: constrained decoding and validation wrappers
Introduced in Choosing prompting vs. RAG vs. fine-tuning under a stated constraint
Introduced in Cleaning and curating a dataset: dedup, imbalance, and NeMo Curator
Introduced in Organizing and formatting datasets for pretraining, fine-tuning, and RAG
Introduced in Subword tokenization: BPE vs. WordPiece
Introduced in The vocabulary-size tradeoff and why it caps perplexity comparisons
Introduced in Exploratory data analysis before fine-tuning: the five-step checklist
Introduced in Quantization: PTQ vs QAT vs GPTQ
Introduced in Knowledge distillation: the DistilBERT trio
Introduced in Pruning and structured 2:4 sparsity
Introduced in KV caching as the primary latency lever
Introduced in Streaming attention and TensorRT runtime optimization
Introduced in Encoder foundation models and masked language modeling
Introduced in Parameter-efficient fine-tuning: LoRA, adapters, and P-tuning
Introduced in Alignment: SFT, RLHF, DPO, and GRPO
Introduced in Contrastive loss for embeddings
Introduced in Early stopping and fine-tuning impact assessment
Introduced in When to fine-tune vs. prompt or RAG
Introduced in Perplexity: what it measures and where it does not apply
Introduced in BLEU vs. ROUGE vs. METEOR
Introduced in LLM-as-a-judge, human-in-the-loop review, and error analysis
Introduced in Benchmarking and scalable evaluation frameworks
Introduced in RAG evaluation: faithfulness, answer relevancy, context precision, and context recall
Introduced in The parallelism families: data, tensor, pipeline, sequence, context, and expert
Introduced in Tensor Parallelism vs Pipeline Parallelism: the #1 distractor pair
Introduced in Memory sharding: FSDP and ZeRO
Introduced in Mixed precision and Tensor Cores
Introduced in Gradient accumulation and effective batch size
Introduced in Profiling and troubleshooting with Nsight
Introduced in Dynamic batching vs. sequence batching in Dynamo-Triton
Introduced in NVIDIA NIM as an LLM-serving container: model formats and the TensorRT-LLM backend
Introduced in Concurrent model execution and instance groups
Introduced in Containerization, Kubernetes, and Multi-Instance GPU
Introduced in Model-type compute tradeoffs: encoder vs. decoder vs. encoder-decoder
Introduced in Reliability and performance metrics: latency percentiles, throughput, error rate
Introduced in Logging, anomalies, and root-cause analysis
Introduced in Drift: data drift and concept drift
Introduced in Offline eval-set regression: benchmarking a deployment against prior versions
Introduced in Automated model retraining, tuning, and versioning
Introduced in Guardrails: topical, safety/content, and security rails
Introduced in Measuring guardrail effectiveness and its latency/false-positive tradeoffs
Introduced in Bias and fairness auditing: disaggregated evaluation
Introduced in Hallucination mitigation: RAG grounding, constrained decoding, trustworthiness checks
Introduced in Responsible-AI monitoring and compliance