NCA-GENL Practice Test 22 — 15 Questions

Question 1

A developer is tuning a TensorRT-LLM deployment of a long-context chat model and observes that GPU memory is exhausted under concurrent requests, causing requests to be rejected. They want to reduce KV cache memory pressure without retraining the model. (Choose two.)

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Enable paged KV cache so cache blocks are allocated dynamically instead of reserving a contiguous buffer per sequence.. KV cache memory dominates long-context serving, so the effective levers are how cache memory is allocated and how many bytes each cached token consumes. Paged KV cache removes fragmentation by allocating blocks on demand, and KV cache quantization reduces per-token storage precision. Both are runtime or build-time configuration changes that need no retraining, unlike architectural pruning, and both increase the number of concurrent sequences the GPU can hold.

Answer

Reduce the model's hidden dimension by pruning attention heads and rebuild the engine from the pruned checkpoint.

Answer

Disable continuous batching so each request is processed to completion before the next one begins.

Answer

Increase the maximum number of batched tokens so more requests are processed simultaneously in a single forward pass.

Question 2

A developer is deploying a large language model using NVIDIA TensorRT-LLM and wants to optimize inference for a production environment with limited GPU memory. Which two techniques can be used to reduce memory footprint while maintaining acceptable performance? (Choose two.)

Accepted Answer

Enabling paged KV cache and tuning the maximum sequence length to a realistic value.. Quantization and paged KV cache with tuned sequence length are effective techniques to reduce GPU memory footprint in TensorRT-LLM. Quantization lowers precision of weights, and paged KV cache optimizes memory allocation for key-value pairs. Both help fit larger models on limited GPUs while preserving performance. Other options either increase memory usage or introduce latency, making them unsuitable for the scenario.

Answer

Using a larger batch size to amortize memory overhead across more requests.

Answer

Increasing the tensor parallelism degree to spread the model across more GPUs.

Answer

Storing the model weights on CPU and offloading them to GPU on demand.

Question 3

A developer is containerizing an inference service built with TensorRT-LLM and NVIDIA NIM for a Kubernetes cluster. They want the deployment to start reliably and use the GPU efficiently. Which two practices should they follow? (Choose two.)

Accepted Answer

Request nvidia.com/gpu resources in the pod spec and ensure the NVIDIA GPU Operator or device plugin is installed so the scheduler can allocate the device.. Reliable GPU-backed startup requires that Kubernetes can schedule the device through the NVIDIA device plugin or GPU Operator, and that the heavy engine artifacts are already present locally rather than downloaded at boot. Restart loops, bypassing the NVIDIA container runtime, and CPU-only emulation all prevent the engine from loading or waste resources instead of improving reliability and GPU efficiency.

Answer

Disable the NVIDIA container runtime so the pod uses the host's default runtime and accesses the GPU through /dev/nvidia devices directly.

Answer

Set the pod's restartPolicy to Always and rely on CrashLoopBackOff to warm the GPU driver on each restart.

Answer

Pin the pod to a CPU-only node pool and use CUDA emulation to run the TensorRT-LLM engine.

Question 4

A team is building a RAG assistant and wants to reduce hallucinated citations. They plan to have the LLM return structured output that names the source document chunk used for each claim. Which implementation strategy most directly improves the reliability of that structured output?

Accepted Answer

Pass the retrieved chunks with stable identifiers in the prompt and constrain generation to a JSON schema that references those identifiers.. Reliable attribution comes from making the citation a constrained choice among known identifiers. Supplying stable chunk IDs in context and enforcing a JSON schema means the model selects from real evidence instead of generating citation text. The application can then validate each returned identifier against the retrieved set, converting an unverifiable prose claim into a programmatically checkable reference.

Answer

Retrieve more chunks and place them all in the prompt without identifiers.

Answer

Increase the model temperature so the model explores more citation candidates.

Answer

Ask the model to cite sources in a free-text bibliography appended after the answer.

Question 5

A developer has a working TensorRT-LLM engine and wants to expose it through NVIDIA Triton Inference Server so that multiple client applications can call it over HTTP and gRPC with a stable interface. Which Triton feature should they configure to serve the TensorRT-LLM engine as a backend?

Accepted Answer

The TensorRT-LLM backend, declaring the engine in the model repository with a config.pbtxt that sets the backend and engine directory.. Triton's TensorRT-LLM backend is designed specifically to load TensorRT-LLM engines from the model repository and serve them over the standard HTTP and gRPC endpoints. Declaring the engine directory and backend in config.pbtxt gives clients a stable interface while retaining optimized in-flight batching and KV cache management. Custom backends and ensembles add complexity without providing the required serving capability.

Answer

An ensemble model that chains a preprocessing model, the TensorRT-LLM engine, and a postprocessing model.

Answer

A Python backend model that loads the engine and implements the inference logic in a custom script.

Answer

A custom C++ backend compiled against the TensorRT-LLM libraries and registered with Triton at startup.

Question 6

A developer is writing an application that calls an NVIDIA-hosted LLM endpoint and needs to keep multi-turn context across several user messages. Which payload structure should the application send to the chat completions API?

Accepted Answer

A 'messages' array of objects, each with a 'role' and 'content', ordered from system to user and assistant turns.. Chat completions APIs from NVIDIA expect an ordered messages array with role and content fields, preserving system, user, and assistant turns. This structure gives the model the turn boundaries it needs for coherent multi-turn dialogue, unlike a flat prompt string or incomplete history.

Answer

A 'context' object mapping user IDs to their previous messages.

Answer

A 'history' array containing only the assistant's prior responses.

Answer

A single 'prompt' string containing all previous turns concatenated.

Question 7

A financial services company is deploying an LLM-based assistant that must answer questions about internal compliance documents. The documents are updated weekly, and the company cannot retrain the model every week. The assistant must cite the exact source passage for each answer. Which architecture best satisfies these requirements?

Accepted Answer

Use retrieval-augmented generation (RAG) with a vector index over the compliance documents and return retrieved passages with the answer. RAG separates knowledge from model weights: documents are indexed in a vector store, relevant passages are retrieved at query time, and the LLM generates an answer grounded in those passages with citations. Weekly document updates require only re-indexing, not retraining. Fine-tuning, stuffing all documents into the prompt, or static FAQ routing either conflicts with the update frequency, does not scale, or cannot provide reliable source citations.

Answer

Train a separate classifier to route questions to static FAQ answers written by the compliance team

Answer

Fine-tune the LLM weekly on the updated documents and rely on its parametric memory to answer

Answer

Increase the model's context window and paste all compliance documents into every prompt

Question 8

A developer needs to serve a quantized Llama model on an NVIDIA GPU and wants the runtime to automatically select the fastest available execution kernels for the detected GPU architecture. Which approach aligns with the NVIDIA inference stack for this requirement?

Accepted Answer

Compile the model with TensorRT-LLM to produce an engine that contains architecture-tuned kernels and let the runtime pick the best ones for the GPU present.. TensorRT-LLM compiles model graphs into engines containing kernels tuned for specific GPU architectures, and at runtime it selects from the available tactics for the hardware present. Building the engine for the deployment GPU ensures the fastest kernels are candidates. This gives the developer optimized execution without hand-authoring CUDA code or losing performance to eager framework dispatch.

Answer

Write custom CUDA kernels for each target GPU and dispatch them manually at runtime.

Answer

Convert the model to ONNX and rely on the default CPU execution provider.

Answer

Run the model in eager execution mode on PyTorch without any compilation step.

Question 9

A developer is tuning a retrieval-augmented generation pipeline that uses NVIDIA NIM embeddings and a NIM LLM. Latency is dominated by embedding thousands of document chunks at query time because the team re-embeds the whole corpus on every request. Which change most directly fixes the architecture?

Accepted Answer

Precompute and persist chunk embeddings in a vector index once, then embed only the incoming query and retrieve nearest neighbors at request time.. When latency is driven by re-embedding static documents per request, the correct remedy is to embed the corpus once, store the vectors in an index, and embed only the query at serving time. Larger embedding models, longer generation, and answer caches do not remove the redundant full-corpus embedding work and can even increase cost or staleness.

Answer

Cache the final LLM answers in memory and serve repeats, leaving the per-request embedding of the corpus unchanged.

Answer

Switch the embedding NIM to a larger model with higher dimensionality so fewer chunks are needed to cover the corpus.

Answer

Increase the LLM's max_tokens so it can summarize the raw documents directly instead of retrieving chunks.

Question 10

A developer is packaging a generative AI application that must run inference on-premises with NVIDIA GPUs and also expose an OpenAI-compatible HTTP API so existing client code works unchanged. Which two components should the developer use together to meet these requirements? (Choose two.)

Accepted Answer

NVIDIA Triton Inference Server as the serving runtime hosting the NIM model artifacts.. The requirement pairs an on-premises GPU deployment with OpenAI-compatible APIs. NIM supplies optimized model microservices with those compatible endpoints, while Triton Inference Server provides the runtime that executes the model artifacts and manages batching and GPU resources. Together they deliver both the API contract and the execution environment without changes to existing client code.

Answer

NVIDIA NeMo Guardrails as the component that translates OpenAI API calls into model inputs.

Answer

NVIDIA TensorRT as the reverse proxy that routes client requests to model replicas.

Answer

NVIDIA CUDA Toolkit as the HTTP server exposing the compatible endpoints.

Question 11

A developer is debugging a RAG service where answers are correct in testing but degrade in production as the document corpus grows. Logs show retrieval returning chunks with high similarity scores that do not contain the answer. Which change most directly addresses the root cause?

Accepted Answer

Replace dense embedding retrieval with a hybrid approach that combines dense vectors and keyword matching, then rerank the merged candidates.. Confident but non-answering chunks point to dense retrieval optimizing topical similarity instead of matching the specific terms that carry the answer. Hybrid retrieval adds lexical matching for exact names, numbers, and rare tokens, and reranking the merged candidates pushes truly relevant chunks to the top. This improves precision where it matters, at the head of the retrieved list passed to the model.

Answer

Increase the embedding model's output dimension to improve similarity precision.

Answer

Increase the number of retrieved chunks passed to the LLM from five to twenty.

Answer

Lower the similarity threshold so fewer chunks are returned to the model.

Question 12

A developer is packaging a generative AI application for NVIDIA AI Enterprise deployment on Kubernetes. The application must run an LLM served by NVIDIA NIM, an embedding model, and a vector database, and must support rolling upgrades without dropping in-flight inference requests. Which design choice best meets these requirements?

Accepted Answer

Run each component as its own Kubernetes Deployment with readiness probes, multiple replicas, and a Service, using rolling update strategy and preStop hooks for graceful drain.. Independent Deployments per component, each with readiness probes, multiple replicas, and a stable Service, allow rolling updates that replace pods gradually while healthy capacity remains. A preStop hook combined with a termination grace period lets the NIM LLM finish in-flight generations before the process exits. This architecture also lets the LLM, embedding, and vector database tiers scale separately according to their distinct resource needs.

Answer

Use a single Deployment with a Recreate strategy so old pods are fully terminated before new ones start, guaranteeing no version mixing.

Answer

Deploy all three components in a single pod so they share a network namespace and can be upgraded together atomically.

Answer

Place the NIM LLM and embedding model behind one Service and rely on client-side retries to mask any requests lost during upgrades.

Question 13

A data scientist is training a transformer model and observes that the training loss is decreasing while the validation loss is increasing. Which technique should be prioritized to address this specific generalization challenge?

Accepted Answer

Implement L2 regularization (weight decay) on the model weights.. This scenario indicates overfitting, where the model captures noise in the training set rather than the underlying distribution. Regularization techniques like Dropout, weight decay, or early stopping are essential to improve model generalization. By limiting the model's ability to memorize the training data, these methods ensure that the weights remain small and the model learns robust patterns that perform better on unseen, held-out validation datasets.

Answer

Increase the depth of the transformer architecture layers.

Answer

Reduce the batch size to increase stochasticity during training.

Answer

Decrease the number of training epochs to save time.

Question 14

Refer to the exhibit. An engineer is monitoring a large model training job. Based on the sudden latency spike at step 502, what is the most likely cause during the experimentation phase?

Accepted Answer

A periodic checkpointing operation triggered at step 502.. The sudden latency jump suggests a periodic operation like checkpointing, data logging, or a hardware-level thermal throttling event. In LLM training, frequent checkpoints or massive synchronization steps are primary suspects for sudden, brief stalls. Identifying these spikes early allows developers to tune checkpoint frequency or optimize I/O paths, ensuring that experiments maintain consistent performance and avoid unnecessary overhead during training.

Answer

The model has reached a local minimum in the loss function.

Answer

The learning rate scheduler reduced the step size.

Answer

The model architecture was automatically reconfigured.

Question 15

Refer to the exhibit. The monitoring JSON indicates high KV cache fragmentation. Which visualization best helps developers diagnose if this is caused by heterogeneous request lengths in the workload?

Accepted Answer

A histogram of request input/output sequence lengths. KV cache fragmentation occurs when varying sequence lengths lead to non-contiguous memory allocations. By plotting a histogram of 'input sequence lengths' versus 'output sequence lengths', developers can see the variance in request sizes. High variance indicates a need for paged attention or continuous batching optimization, which allows the engine to handle variable lengths efficiently without wasting memory on fragmented cache blocks, directly addressing the performance degradation.

Answer

A line chart of GPU memory temperature

Answer

A heat map of individual GPU core activity

Answer

A scatter plot of token generation probabilities