NCP-GENL Practice Questions with Explanations: 20 Scenarios [2026]

This article gives you 20 fresh practice questions for the NVIDIA-Certified Professional: Generative AI LLMs (NCP-GENL) exam, each one a production scenario with a decision to make, four options, the answer, and an explanation that says why the winner wins and why each distractor loses. Questions are tagged by domain and distributed roughly by exam weight, so Model Optimization and GPU Acceleration get the most attention and Safety & Ethics gets one. Five questions are Select TWO, which matches the share you should expect on the real exam. Score yourself with the rubric below, then use the closing map to route your weak domains to the right deep-dive article and to the full-length practice tests on preporato.com.

How NCP-GENL questions are built

The exam is 60 to 70 questions in 120 minutes, remotely proctored, with a passing score NVIDIA does not publish and a credential valid for two years. Almost every question is a scenario: a model size, a hardware budget, a latency or accuracy constraint, and a team that has to pick one path. The options are rarely absurd. Two or three of them are real techniques that would be correct in a neighboring scenario, and the stem contains the one detail (a single 80 GB GPU, a fixed label set, an interconnect topology) that rules them out. Read for that detail first. Select TWO items say so in the stem, and both choices must be right to score.

Professional altitude means the exam expects you to reason about trade-offs the way an engineer with two to three years of production LLM work would: memory before speed, communication topology before parallelism degree, the failure mode named in the profile before the fix you happen to like.

The questions

Question 1

Domain: Model Optimization (17%)

Your team serves a 70B-parameter instruct model with TensorRT-LLM (NVIDIA's inference engine builder for LLMs) on H100 GPUs. Finance wants each replica to fit on one 80 GB GPU. Traffic runs at concurrency 8 to 16 with short prompts and long generations, and your held-out eval set tolerates at most one point of accuracy loss. Which quantization plan should the engine use?

• A. FP8 weights and activations with an FP8 KV cache, since Hopper Tensor Cores execute FP8 natively
• B. INT8 SmoothQuant for weights and activations, keeping the KV cache in FP16 for accuracy
• C. FP16 weights with 2:4 structured sparsity applied so the weight footprint is halved
• D. INT4 AWQ weight-only quantization with FP16 activations and an FP8 KV cache

Answer: D

Quantization (storing weights or activations in fewer bits) is judged here by memory first. At FP8 or INT8 the 70B weights alone occupy about 70 GB, leaving almost nothing for the KV cache (the per-request store of attention keys and values) at concurrency 16 with long outputs, so both the FP8 plan and the SmoothQuant plan fail the single-GPU constraint even though both are valid Hopper techniques. INT4 AWQ (activation-aware weight quantization, which protects the most salient weight channels during calibration) brings weights to roughly 35 GB, and weight-only quantization speeds up the memory-bandwidth-bound decode phase at low batch sizes, typically inside a one-point accuracy budget. 2:4 sparsity needs sparsity-aware fine-tuning to hold accuracy and targets compute throughput rather than the memory ceiling.

Question 2

Domain: Model Optimization (17%)

A support-ticket triage service uses an 8B model to assign one of 30 labels and a one-sentence justification. Volume is 20 million tickets per day, per-ticket cost must fall by roughly 4x, latency is not critical, and accuracy may drop at most two points against the current model. The GPU budget is fixed. Which optimization path fits best?

• A. Apply INT4 weight-only quantization to the 8B model and keep serving it otherwise unchanged
• B. Add speculative decoding with a small draft model in front of the 8B target model
• C. Distill the 8B teacher into a 1B-class student trained on teacher-labeled tickets, then quantize it
• D. Prune half of the attention heads with structured pruning and redeploy without further training

Answer: C

Knowledge distillation (training a smaller student model to reproduce a larger teacher's outputs) is the only option that changes the cost structure by 4x or more: a narrow, high-volume task with a fixed label set is exactly where a 1B-class student matches the teacher within a couple of points, and quantizing the student compounds the saving. INT4 quantization of the 8B model roughly doubles memory-bound decode speed but stops well short of 4x on a compute-heavy high-batch workload. Speculative decoding (a draft model proposes tokens the target verifies in one pass) cuts latency at low batch sizes and gives little throughput at saturation. Structured pruning without recovery training typically loses far more than two points.

Question 3

Domain: Model Optimization (17%)

Your Triton Inference Server deployment runs a TensorRT-LLM engine with static batching at batch size 8 and pads every request to the maximum sequence length. Requests range from 100 to 6,000 tokens. GPU utilization sits near 35 percent while a queue of waiting requests grows during peak hours. Which TWO configuration changes will raise throughput the most? (Select TWO)

• A. Raise the static batch size to 64 while keeping the current padding of every request to the maximum sequence length
• B. Enable in-flight batching so completed sequences release their slots and new requests join mid-batch
• C. Switch every request to greedy decoding to remove sampling overhead from the decode loop
• D. Enable the paged KV cache so memory is allocated in blocks as sequences grow instead of pre-reserved

Answer: B and D

In-flight batching (also called continuous batching) lets Triton's TensorRT-LLM backend add and retire requests token by token, so a 6,000-token generation no longer holds seven short requests hostage, and the paged KV cache (allocating key-value memory in fixed blocks on demand, like virtual memory pages) removes the padding waste that made batch 8 the ceiling; together they raise concurrency and utilization. Raising the static batch to 64 with padding multiplies wasted memory and would likely fail to allocate at all. Greedy decoding changes output quality and shaves only a trivial share of per-token time; the idle GPU is a scheduling problem, so sampling settings cannot fix it.

Question 4

Domain: GPU Acceleration (14%)

You are pretraining a 30B-parameter dense model on four DGX H100 nodes (32 GPUs). In BF16 the weights, gradients, and Adam optimizer state do not fit on one GPU. NVLink connects GPUs inside a node and InfiniBand connects the nodes. Which parallelism layout keeps the heaviest communication on the fastest links?

• A. Tensor parallelism of degree 32 spanning all four nodes so that every layer is split as finely as possible
• B. Tensor parallelism of 8 within each node, data parallelism of 4 across nodes, optimizer state sharded
• C. Pipeline parallelism of degree 32 with one layer group per GPU and a single micro-batch per step
• D. Data parallelism of degree 32 with ZeRO-3 sharding of parameters, gradients, and optimizer state everywhere

Answer: B

Tensor parallelism (splitting each layer's matrices across GPUs) exchanges activations with all-reduce operations several times per layer, so it belongs on NVLink inside the node; data parallelism (each replica sees different batches) synchronizes gradients once per step, which InfiniBand handles well, and sharding optimizer state across the four replicas (ZeRO stage 1) closes the memory gap. Degree-32 tensor parallelism pushes those per-layer all-reduces over the inter-node fabric and stalls every step. Degree-32 pipeline parallelism with one micro-batch leaves most GPUs idle in the pipeline bubble. ZeRO-3 across all nodes works functionally, but it all-gathers full parameters for every layer over InfiniBand, far more traffic than the intra-node tensor-parallel design.

Question 5

Domain: GPU Acceleration (14%)

A 40B-parameter model trains with tensor and data parallelism at 8K-token sequence length and already runs at micro-batch size 1. Training now fails with out-of-memory errors. An Nsight Systems profile and a memory snapshot show activations, dominated by attention, taking most of each GPU's memory, while weights and optimizer state are already sharded. Which change addresses the actual bottleneck?

• A. Enable selective activation recomputation and a fused FlashAttention kernel for the attention blocks
• B. Add ZeRO-3 parameter sharding on top of the existing setup to spread the remaining state further
• C. Increase gradient accumulation steps so each optimizer update spans more micro-batches
• D. Switch to an 8-bit Adam optimizer to shrink the per-parameter optimizer state footprint

Answer: A

The profile names activations as the problem, so the fix has to reduce activation memory. Activation recomputation (discarding intermediate activations in the forward pass and recomputing them during backward, also called activation checkpointing) trades some compute for a large memory drop, and FlashAttention (a fused kernel that never materializes the full attention score matrix) removes the term that grows with the square of sequence length. ZeRO-3 and 8-bit Adam shrink parameter and optimizer memory, which the snapshot shows is already sharded and small. More gradient accumulation only changes how many micro-batches feed one update; at micro-batch 1 it leaves peak activation memory exactly where it is.

Question 6

Domain: GPU Acceleration (14%)

Across eight DGX nodes, your data-parallel training step spends 45 percent of its time in gradient all-reduce. NCCL bandwidth tests reach only a fraction of the InfiniBand line rate, GPUDirect RDMA is not active on the hosts, and the trainer issues many tiny all-reduce calls at the end of each backward pass. Which TWO actions cut communication time? (Select TWO)

• A. Enable GPUDirect RDMA and verify NCCL selects the InfiniBand adapters with the nccl-tests bandwidth benchmark
• B. Move to tensor parallelism spanning all eight nodes so gradients no longer need a separate all-reduce
• C. Overlap communication with backward compute using larger gradient buckets that all-reduce as they fill
• D. Replace the collective all-reduce with a central parameter server that aggregates gradients per step

Answer: A and C

NCCL (NVIDIA's collective communications library) reaches line rate only when GPUs write straight to the network adapter, which GPUDirect RDMA (direct GPU-memory-to-NIC transfers that bypass host memory) provides, and nccl-tests confirms the fix, so the first action removes the bandwidth gap. Bucketed all-reduce with overlap starts transferring early gradients while later layers are still computing backward, so it hides latency instead of paying it after the pass. Cross-node tensor parallelism replaces one all-reduce per step with several per layer over the same slow path. A parameter server concentrates traffic on one host and predates the ring and tree collectives NCCL uses; it would increase the communication share.

Question 7

Domain: Prompt Engineering (13%)

An invoice-reconciliation service asks a model to compute line-item adjustments and return JSON. Zero-shot accuracy was 61 percent; adding chain-of-thought instructions raised it to 84 percent, but the reasoning text now spills into the response and breaks the JSON parser on one request in five. Which prompt design keeps the accuracy gain and fixes the parsing failures?

• A. Remove the chain-of-thought instruction and compensate with eight more few-shot input-output examples in the prompt
• B. Keep chain-of-thought and add self-consistency by sampling five reasoning paths and taking a majority vote
• C. Have the model reason inside a delimited scratchpad, then emit the final JSON in a separate block
• D. Set the temperature to zero so the model produces exactly the same, deterministic output shape for every request it serves

Answer: C

Chain-of-thought (asking the model to write intermediate reasoning before answering) is what lifted accuracy, so the fix separates the reasoning from the machine-read answer: a scratchpad section followed by a clearly delimited JSON block, ideally enforced with constrained decoding or a JSON schema, keeps both. Dropping the reasoning for more examples usually gives back part of the 23-point gain on multi-step arithmetic. Self-consistency (sampling several reasoning chains and voting) improves accuracy further and costs five calls, yet each sample still emits reasoning that breaks the parser. Temperature zero makes outputs repeatable and does nothing about where the reasoning text lands.

Question 8

Domain: Prompt Engineering (13%)

A customer-intent classifier prompts a hosted model with the same five hand-picked examples for every request across 40 intents. Accuracy on the ten rarest intents is poor, the context window cannot hold examples for every intent alongside long customer messages, and latency targets rule out multiple calls per request. What is the best way to improve rare-intent accuracy?

• A. Include one fixed example for every intent, trimming the customer messages so the whole prompt still fits
• B. Add a chain-of-thought instruction so the model reasons about the intent before labeling
• C. Raise the sampling temperature to increase output diversity across the rare intents
• D. Select few-shot examples per request by embedding similarity to the incoming message

Answer: D

In-context learning (steering the model with examples in the prompt) works best when the examples resemble the input, so dynamic few-shot selection (embedding the message, retrieving the nearest labeled examples from a pool, and inserting only those) shows rare intents exactly when they matter, within the same token budget and a single call. One example per intent forces truncating the very messages that carry the signal and still leaves each rare intent with a single, possibly unrepresentative case. Chain-of-thought adds output tokens and latency to a classification task whose weakness is coverage, and temperature raises randomness on a task that needs a stable label.

Question 9

Domain: Prompt Engineering (13%)

A logistics planner uses a model to build multi-step routing plans from constraints. Single-pass chain-of-thought answers are correct 70 percent of the time and vary between runs, and failed plans usually break one late-stage constraint. You have a latency budget for a few extra model calls per plan. Which TWO prompting changes raise reliability? (Select TWO)

• A. Sample several reasoning chains at moderate temperature and select the answer with majority agreement
• B. Set temperature to zero and issue a single call so every plan is produced deterministically
• C. Remove the reasoning instruction so the model answers directly and spends its tokens on the plan
• D. Decompose the task into sub-problems and add a verification step that checks each constraint before returning

Answer: A and D

Self-consistency (sampling multiple chain-of-thought paths and voting) converts run-to-run variance into a strength, since correct plans tend to agree while errors scatter, and the extra calls fit the stated budget. Decomposition with a verification pass (least-to-most prompting or prompt chaining, where sub-answers feed the next step and a final check tests each constraint) directly targets the late-stage constraint failures. Temperature zero removes variance but freezes in whichever reasoning error the greedy path takes; the plan is then reliably wrong 30 percent of the time. Removing reasoning entirely typically lowers accuracy on multi-step planning, since the intermediate steps are what let the model track constraints.

Question 10

Domain: Fine-Tuning (13%)

You need to fine-tune a 13B-parameter model on 40,000 domain conversations, and the only hardware available for the next month is a single NVIDIA A10 with 24 GB of memory. The team accepts somewhat slower training but wants a result close to standard LoRA quality. Which approach makes the job feasible on this GPU?

• A. Standard LoRA adapters on BF16 base weights with gradient checkpointing enabled on every layer
• B. QLoRA: base weights loaded in 4-bit NF4, LoRA adapters trained in BF16 with a paged optimizer
• C. Full fine-tuning with ZeRO-3 CPU offload so the optimizer state lives in host memory
• D. Freezing every layer except the final two transformer blocks and training those two blocks in FP32

Answer: B

LoRA (low-rank adaptation, training small rank-decomposed matrices next to frozen weights) still needs the frozen 13B base resident in memory, and 13B in BF16 is about 26 GB before activations, so standard LoRA cannot start on 24 GB. QLoRA (quantizing the frozen base to 4-bit NF4 while training BF16 adapters, with paged optimizer state to absorb memory spikes) brings the base to roughly 7 GB and matches LoRA closely on most tasks. Full fine-tuning with CPU offload needs 16 bytes per parameter of state in host memory, over 200 GB, and crawls over PCIe. Freezing all but two blocks still loads the full base and, in FP32, doubles its footprint.

Question 11

Domain: Fine-Tuning (13%)

After full fine-tuning an instruct model on 50,000 in-domain question-answer pairs, domain accuracy improved sharply, but the model now ignores formatting instructions, forgets its chat behavior, and refuses less appropriately than before. Stakeholders want the domain gains without the regression, and the training budget allows one more run. What should the next run change?

• A. Mix general instruction data into the domain set and switch to LoRA at a lower learning rate
• B. Train two more epochs on the domain data so the new behavior fully overrides the older general behavior
• C. Increase the LoRA rank to 256 so the adapters have enough capacity to hold both behaviors
• D. Start from the pretrained base checkpoint instead of the instruct checkpoint before fine-tuning again

Answer: A

The symptom is catastrophic forgetting (new training overwriting previously learned behaviors), and the remedy is to keep the old behavior in the training signal while touching fewer weights: replaying a slice of general instruction data preserves formatting and refusal behavior, and LoRA at a lower learning rate leaves the base weights intact. More epochs on domain-only data deepens the forgetting. Raising LoRA rank adds capacity, but the previous run was full fine-tuning; capacity was never the issue, and rank alone does not reintroduce the missing general data. Starting from the pretrained base discards the instruct model's chat and safety training entirely, so the regression would be worse.

Question 12

Domain: Fine-Tuning (13%)

You supervised-fine-tune a chat model with LoRA on 30,000 multi-turn conversations. The fine-tuned model sometimes continues past its answer, generating a fabricated user turn and then replying to it, and it occasionally echoes the user's question before answering. Which TWO data-preparation and training choices most directly prevent these failures? (Select TWO)

• A. Raise the LoRA alpha scaling so the adapter exerts stronger influence over the base model's outputs
• B. Render every example with the model's chat template and end each assistant turn with the end-of-turn token
• C. Compute the training loss only on assistant tokens, masking prompt and user tokens from the objective
• D. Lower the inference temperature so that the model reliably stops at the most probable end point

Answer: B and C

A model that keeps talking after its answer never learned where a turn ends: rendering the data with the chat template (the exact role tokens and separators the base model was trained on) and appending the end-of-turn token teaches it to stop and hand control back. Loss masking (computing the objective on assistant tokens only) stops the model from learning to reproduce user text, which is what causes the echoing. Alpha scaling changes how strongly the adapter perturbs the base but cannot teach turn boundaries the data omits. Temperature shapes sampling at inference; a model that assigns high probability to a fabricated user turn will still produce it.

Question 13

Domain: Data Preparation (9%)

You are assembling a continued-pretraining corpus of 200 million web documents for a domain model. A first pass showed heavy near-duplicate boilerplate and a long tail of low-quality pages. The team has a multi-node GPU cluster and a two-week deadline. Which pipeline handles the volume while removing both problems?

• A. Exact-hash deduplication in a single-node pandas job followed by manual spot checks of the output
• B. Perplexity filtering against a reference language model, keeping only the lowest-perplexity documents overall
• C. NeMo Curator running GPU exact and fuzzy MinHash deduplication, then heuristic and classifier quality filters
• D. Semantic deduplication with embedding clustering alone, skipping the exact and fuzzy dedup passes entirely

Answer: C

NeMo Curator (NVIDIA's data curation framework) runs exact and fuzzy deduplication (MinHash signatures with locality-sensitive hashing to find near-duplicates) on GPUs across the cluster, then applies heuristic filters (length, repetition, symbol ratios) and classifier-based quality scoring, which is the standard order for a corpus this size and hits the deadline. Single-node exact hashing misses near-duplicates and will not finish on 200 million documents. Perplexity filtering alone keeps bland, repetitive text (low perplexity is what boilerplate looks like) and does no deduplication. Semantic deduplication is a useful final pass but is expensive per document and, used alone, leaves exact copies that cheaper passes would have removed first.

Question 14

Domain: Data Preparation (9%)

A base model's tokenizer splits your organization's chemistry nomenclature into six to ten subword tokens per term, so sequences run about twice as long as equivalent general text and long documents no longer fit the context window. You plan a continued-pretraining phase on 30 billion domain tokens. What is the right vocabulary strategy?

• A. Train a new tokenizer from scratch on domain text and load the pretrained model weights unchanged
• B. Keep the tokenizer as it is and raise the maximum sequence length so long documents fit the window
• C. Apply BPE dropout during continued pretraining so the model learns alternative segmentations of terms
• D. Extend the vocabulary with domain tokens, resize the embedding matrix, and initialize new rows from subword pieces

Answer: D

Vocabulary extension keeps the pretrained embeddings intact for existing tokens, adds whole-term entries for the domain, and gives the new embedding rows a sensible start (the mean of the subword embeddings they replace) that continued pretraining refines; sequence length falls back toward general text. A tokenizer trained from scratch changes every token id, so the pretrained embedding matrix no longer matches and most of the pretraining is thrown away. Raising the sequence length raises attention cost and KV cache size without addressing the inefficient segmentation. BPE dropout (randomly dropping merges during training) improves robustness to segmentation but does nothing to shorten the sequences.

Question 15

Domain: Model Deployment (9%)

One model must serve two workloads: an interactive assistant with a 300 ms time-to-first-token target and 24-hour global traffic, and a nightly job that summarizes five million documents before 6 a.m. Both currently hit the same endpoint, and the nightly job pushes assistant p99 latency past its SLO. Which deployment design fixes this?

• A. Separate pools of one model: a streaming, latency-tuned assistant pool and a throughput-tuned batch pool
• B. A single endpoint with a priority queue so that assistant requests preempt batch requests whenever they arrive
• C. Run the batch job through the assistant endpoint only between 1 a.m. and 5 a.m. local time
• D. Enable token streaming for both workloads so that the batch job also returns partial results sooner

Answer: A

Batch and streaming inference have opposite tuning goals: the assistant wants small batches, token streaming (returning tokens as they are generated), and a low time-to-first-token, while the summarization job wants large batches and maximum tokens per second regardless of per-request latency. Two pools with their own scaling let each configuration win and isolate the nightly load from the SLO. A priority queue helps admission, but the batch requests already inside a batch still occupy KV cache and decode slots, so p99 keeps suffering. A time window ignores 24-hour global traffic and simply moves the collision. Streaming the batch job adds overhead and gives the job nothing it needs.

Question 16

Domain: Model Deployment (9%)

You are replacing the production model behind a public LLM API that handles about 2,000 requests per second with a newly fine-tuned version. Offline evaluation looks better, but leadership wants evidence from real traffic before full exposure and a rollback path measured in minutes. Which TWO release techniques satisfy both requirements? (Select TWO)

• A. A big-bang cutover during a scheduled maintenance window, with the old version decommissioned right afterward
• B. A blue-green switch that moves 100 percent of traffic at once while the team watches dashboards
• C. A canary release routing a small share of live traffic to the new version with side-by-side metrics
• D. Shadow traffic that mirrors requests to the new version and compares its outputs offline, never serving them

Answer: C and D

A canary release (exposing a small percentage of real users to the new version, then widening as metrics hold) provides real-traffic evidence with limited blast radius, and rollback is a routing change. Shadow traffic (mirroring production requests to the candidate and discarding its responses) gathers a full-volume real-traffic comparison at zero user risk, so it complements the canary rather than duplicating it. A big-bang cutover exposes everyone at once and, with the old version stopped, has no fast rollback. Blue-green keeps the old environment warm, which does give fast rollback, but flipping 100 percent of traffic gives up the limited-exposure evidence leadership asked for.

Question 17

Domain: Evaluation (7%)

A fine-tuned summarization model beat the base model by two ROUGE-L points on your test set, so it shipped. Two weeks later, support tickets report summaries that state figures and names absent from the source documents. You must redesign the evaluation before the next release. Which change fixes the blind spot?

• A. Replace ROUGE-L with BERTScore against the reference summaries to capture semantic rather than lexical overlap
• B. Add a faithfulness check of each summary claim against its source, plus human review of a stratified sample
• C. Report held-out perplexity of the fine-tuned model alongside ROUGE so fluency regressions are also caught
• D. Increase the ROUGE test set from 500 to 5,000 documents so the two-point gain becomes statistically robust and defensible

Answer: B

ROUGE (n-gram overlap with a reference summary) rewards summaries that look like the reference and is blind to a fabricated number that happens to sit in fluent, on-topic prose. A faithfulness or factual-consistency metric (entailment checks or a judge model verifying that every claim is supported by the source) measures exactly the failure users reported, and a stratified human sample calibrates the automatic score. BERTScore swaps lexical overlap for embedding similarity but still compares against the reference rather than the source, so hallucinated details survive. Perplexity measures fluency, which was never the problem. A larger test set only tightens the confidence interval on a metric that cannot see the error.

Question 18

Domain: Production Reliability (7%)

Your production RAG assistant shows green latency and error-rate dashboards, yet users report a sharp drop in answer quality that began the day the retrieval index was rebuilt. Nobody noticed for four days because no signal tracked answer quality. Which observability change would have caught this within hours?

• A. Add p99.9 latency and per-replica GPU utilization panels to the existing dashboards with tighter thresholds
• B. Run synthetic uptime probes against the health endpoint every 30 seconds from three geographic regions
• C. Track sampled judge scores, retrieval relevance, and thumbs-down rate as time series, alerting on post-deploy shifts
• D. Roll back the retrieval index to the previous snapshot and add a mandatory approval step for all future rebuilds

Answer: C

Latency and error rate describe whether the service answers, and this incident was about what it answered. Quality observability treats answer quality like any other production metric: an LLM judge scoring a sample of responses, retrieval relevance (whether the top chunks match the question), and explicit user feedback, plotted over time and annotated with deploys and index rebuilds, would have flagged the step change on day one. Extra latency percentiles and GPU panels sharpen a picture that was already green. Synthetic uptime probes confirm the endpoint responds, which it did. Rolling back and adding approvals is a good corrective action after detection, and it does not create the detection.

Question 19

Domain: LLM Architecture (6%)

You are specifying the attention design for a 34B-parameter model that will serve 32K-token contexts at high concurrency. Capacity planning shows the KV cache, rather than the weights, will set the maximum concurrent requests per GPU. Quality must stay close to a standard multi-head baseline. Which attention variant should the architecture use?

• A. Multi-head attention with more heads so each head attends over a narrower slice of the context
• B. Multi-query attention with a single shared key-value head to reduce the cache to its minimum
• C. Sliding-window attention only, restricting each token to a fixed local window to bound cache growth
• D. Grouped-query attention, sharing one key-value head across a group of query heads to shrink the cache

Answer: D

The KV cache stores one key and one value vector per layer for every token and every key-value head, so the number of key-value heads is the lever. Grouped-query attention (GQA) keeps many query heads but shares each key-value head among a group, cutting cache size several-fold with quality that closely tracks multi-head attention. Adding heads to multi-head attention makes the cache larger, the reverse of the goal. Multi-query attention (one key-value head for all queries) minimizes the cache but with a larger quality gap than the stem allows. Sliding-window attention bounds the cache by discarding long-range access, which defeats serving full 32K contexts.

Question 20

Domain: Safety & Ethics (5%)

A retail bank is launching a customer-facing assistant grounded on internal documents. Compliance requires that it stay on approved topics, never surface another customer's personal data that retrieval might return, and resist instructions embedded in retrieved documents. The team currently relies on a system prompt that says "do not do these things." What should the design add?

• A. A stronger system prompt that repeats the three rules at the start and end and adds refusal examples
• B. Programmable input, retrieval, and output rails (for example NeMo Guardrails) with PII checks, validated by a red-team suite
• C. Temperature zero and a lower maximum output length so that responses stay predictable, short, and consistent
• D. Fine-tuning the model on refusal examples for off-topic requests while keeping the retrieval pipeline unchanged

Answer: B

System prompt instructions are advisory; a model can be talked out of them, and prompt injection (instructions hidden in retrieved content that the model follows as if they came from the operator) is designed to do exactly that. Programmable guardrails run outside the model: input rails enforce topic scope, retrieval rails screen chunks for injected instructions, and output rails detect and redact personal data before it reaches the customer, with a red-team suite proving each rail works. A longer prompt remains a single point of failure. Temperature and length limits shape style and cannot enforce policy. Refusal fine-tuning helps topic scope but leaves injection and PII leakage unaddressed.

If you missed these, read this

Score the set, then look at which domains produced the misses. Two wrong answers inside one domain is a study signal; one wrong answer spread across domains usually means a reading error on the stem detail. Use the map below to go straight to the deep dive for each domain, then take a fresh full-length test on the NCP-GENL practice tests page or start with the free 20-question sampler.

The linked articles by slug: model optimization and quantization, GPU acceleration and distributed training, fine-tuning with LoRA, QLoRA and PEFT, exam domains complete breakdown, and how to pass NCP-GENL on the first attempt. If you want the full seven-test bank with per-domain analytics, Preporato Pro on the pricing page covers it along with the labs.

Next steps

Take the free NCP-GENL sampler under time pressure to see how the format feels at pace, then work through the seven full-length tests on the NCP-GENL practice tests page, reviewing every explanation whether you were right or wrong. When you are consistently strong across all 10 domains, use the complete guide to schedule and prepare for exam day.

Sources:

• NVIDIA-Certified Professional: Generative AI LLMs (official exam page)
• TensorRT-LLM documentation
• Triton Inference Server documentation
• NeMo Framework user guide
• NeMo Curator documentation
• NeMo Guardrails documentation