Free NVIDIA-Certified Professional: Generative AI LLMs (NCP-GENL) Practice Questions

Sample NCP-GENL Practice Questions

Browse all 20 free NVIDIA-Certified Professional: Generative AI LLMs practice questions below.

1. Your team is training a 175B parameter model across 64 DGX A100 nodes (512 GPUs total). The current configuration uses only data parallelism, but you're experiencing suboptimal GPU utilization and high communication overhead. Which parallelism strategy would best optimize training throughput?

   • Keep pure data parallelism but enable ZeRO-3 sharding so optimizer, gradient, and parameter state split across all 512 GPUs
   • Adopt PTD-P: tensor parallelism within each DGX node over NVLink, pipeline across nodes, and data parallelism to scale
   • Add sequence parallelism with activation checkpointing on top of the data-parallel setup to cut per-GPU activation memory pressure
   • Use pipeline parallelism across all 64 nodes with an interleaved 1F1B schedule to shrink pipeline bubble overhead

2. When deploying a 70B parameter LLM for production inference with strict latency requirements (<100ms) and limited GPU memory, which TensorRT-LLM optimization technique provides the best balance of speed and model quality?

   • Apply INT8 SmoothQuant calibration to the weights and activations
   • Shard the unquantized FP16 model with tensor parallelism over more GPUs
   • Pair FP8 weight quantization with speculative decoding to cut latency
   • Enable in-flight batching with a paged KV cache for higher throughput

3. Your data preparation pipeline for training a domain-specific LLM processes 500GB of raw text. The current CPU-based tokenization is taking 36 hours. Which NVIDIA technologies would most effectively accelerate this preprocessing step? (Select TWO)

   • Use NVIDIA DALI to build a GPU data-loading pipeline that tokenizes the text batches
   • Use RAPIDS cuDF to run the string operations and tokenization as GPU dataframe kernels
   • Apply tensor parallelism across GPUs to split the tokenization workload over multiple devices
   • Use NeMo Curator to run the curation and tokenization stages on GPUs via its Dask backend
   • Compile the tokenizer with TensorRT-LLM so the encode step runs as an optimized GPU engine

4. You're implementing few-shot learning for a classification task and getting inconsistent results across multiple runs with the same prompt. The model uses greedy decoding (temperature=0). Which prompt engineering technique would most effectively improve output consistency?

   • Pin the model's random seed and stop tokens so greedy decoding becomes fully reproducible per run
   • Add chain-of-thought reasoning to each few-shot example so the model derives the label deterministically
   • Apply self-consistency: sample several outputs at temperature > 0 and return the majority-vote answer
   • Lower the top-p nucleus sampling threshold so the decoder only weighs the highest-probability tokens

5. A long-context application processes 32K token sequences but faces GPU memory constraints during inference. Profiling shows KV cache consuming 80% of available memory. Which optimization technique provides the best memory reduction while maintaining accuracy?

   • Apply Multi-Head Latent Attention (MLA), projecting the keys and values into a shared low-rank latent space before caching them
   • Deploy Grouped Query Attention (GQA) so multiple query heads share a single key-value head, shrinking the per-token cache footprint
   • Apply INT8 post-training weight quantization so the model parameter tensors occupy far less GPU memory during inference runs
   • Enable FlashAttention so the attention scores are tiled in SRAM, removing the large intermediate score matrix from device memory

6. Your team is deploying a 70B parameter LLM on a multi-GPU DGX system and needs to minimize inference latency for real-time applications. Which quantization technique in TensorRT-LLM would provide the best balance of speed and accuracy for small batch sizes?

   • FP8 quantization applied to both the model weights and the layer activations
   • INT8 weight-only quantization paired with an FP16 KV cache for the decoder
   • INT8 SmoothQuant quantizing both weights and the smoothed activation outliers
   • INT4 GPTQ weight-only quantization with calibrated per-group scales

7. When using TensorRT-LLM's Model Optimizer for post-training quantization (PTQ), which approaches are specifically suited to addressing activation outliers that can degrade quantization quality? (Select TWO)

   • Apply GPTQ, which uses second-order Hessian information to quantize weights one column at a time with low error
   • Run AutoQuantize to search each layer for the quant format that minimizes accuracy loss under a compression target
   • Calibrate on a representative dataset to compute per-channel activation scales so outlier channels keep their own range
   • Use SmoothQuant to apply a per-channel scaling transform that migrates activation outlier magnitude into the weights
   • Use AWQ to scale and protect the small fraction of salient weight channels identified from activation magnitude statistics

8. Your latency-sensitive production LLM deployment uses TensorRT-LLM on Hopper GPUs and experiences high memory pressure with long context lengths. What is the recommended approach for KV cache optimization?

   • Apply INT8 KV cache quantization to maximize the compression ratio per token
   • Enable FP8 KV cache quantization to exploit the Hopper FP8 tensor cores
   • Offload the KV cache to host memory to free up GPU device memory
   • Turn on KV cache block reuse so shared prompt prefixes are not recomputed

9. A model optimization engineer is comparing quantization strategies for a 175B parameter model deployed on Blackwell architecture GPUs. Which quantization format provides specialized kernel support and high compression for this architecture?

   • INT4 AWQ activation-aware weight quantization
   • INT8 SmoothQuant with per-channel scaling
   • NVFP4 with Blackwell-native FP4 kernels
   • FP8 (E4M3) calibrated with TensorRT-LLM

10. When deploying models quantized with TensorRT-LLM's Model Optimizer PTQ framework, which inference frameworks are natively supported for deployment?

    • Triton Inference Server alone, via its deprecated FasterTransformer backend
    • TensorRT-LLM, vLLM, and the DeepSpeed-Inference serving engine
    • TensorRT-LLM, vLLM, and the stock Hugging Face Transformers eager runtime
    • TensorRT-LLM, vLLM, and SGLang from a unified exported checkpoint

11. When preparing a large web-scraped dataset for LLM pre-training, which quality filtering step is most critical to prevent memorization and improve generalization?

    • Heuristic and perplexity-based quality classification to drop low-quality documents
    • PII redaction to remove names, emails, and identifiers from training documents
    • Language identification to keep only documents in the target training languages
    • Exact and near-duplicate detection and removal across the corpus

12. What is the primary advantage of using SentencePiece for tokenization compared to word-level tokenization?

    • It treats whitespace as a reserved symbol so detokenization is reversible across any language
    • It applies the unigram language-model objective to prune the most frequent whole words first
    • It handles many languages and rare words through language-agnostic subword segmentation
    • It guarantees a fixed token count per input regardless of the configured vocabulary size

13. When using NVIDIA RAPIDS cuDF for LLM data preprocessing, what is the primary performance benefit?

    • It deduplicates documents semantically by clustering text embeddings to remove near-duplicate samples
    • GPU-accelerated dataframe operations that deliver roughly 10-100x speedup over CPU-based pandas at scale
    • It streams datasets larger than GPU memory by transparently spilling partitions to host RAM and disk
    • It tokenizes text and packs sequences directly into GPU tensors for the training dataloader

14. What is the purpose of vocabulary size in tokenization, and what tradeoff does it represent? (Select TWO)

    • It sets the model's maximum context window, trading off how much text fits per forward pass against attention memory cost
    • A larger vocabulary encodes text in fewer tokens but inflates the embedding and output-projection tables, increasing memory
    • It defines the embedding dimensionality (hidden size), trading representational capacity against per-token compute cost
    • Its purpose is to eliminate out-of-vocabulary tokens, since subword tokenizers only avoid the <UNK> token at large vocab sizes
    • A larger vocabulary improves rare-word coverage but risks sparse, under-trained embeddings for infrequent tokens

15. In the context of LLM training data, what does perplexity measure when used as a data quality filter?

    • The fraction of n-gram overlap a document shares with the rest of the corpus, flagging near-duplicate content
    • The document’s token count measured against the minimum and maximum length thresholds set in the curation pipeline
    • A quality classifier’s predicted probability that a document closely resembles a curated high-quality reference set
    • The model’s surprise at the text, where high-perplexity passages are often low quality or out-of-distribution

16. Your team is building a customer service chatbot that needs to follow a specific troubleshooting workflow. The LLM sometimes skips steps or hallucinates solutions. Which prompt engineering technique would most effectively ensure the model follows the required step-by-step reasoning process?

    • Add a retrieval-augmented generation layer so each answer is grounded in the troubleshooting knowledge base of articles
    • Apply self-consistency decoding by sampling several independent reasoning chains and majority-voting the result
    • Switch to greedy decoding at low temperature so the model returns one deterministic, repeatable response
    • Use few-shot Chain-of-Thought prompts that demonstrate the full troubleshooting workflow as worked examples

17. You're deploying a NVIDIA NIM-based API that must return customer data in strict JSON format with specific field validation (e.g., phone numbers matching regex patterns, dates in ISO format). Which structured generation approach provides the most reliable output formatting?

    • Enable NIM's JSON mode via response_format={"type":"json_object"} so the model is forced to emit valid JSON
    • Fine-tune the model with LoRA on formatted JSON examples so it learns the required field patterns and types
    • Use NIM's guided_json parameter to constrain decoding against a JSON schema with field type and pattern rules
    • Provide the JSON schema in a few-shot system prompt and set a low temperature to boost output format adherence

18. Your ReAct agent built with NVIDIA NeMo Agent Toolkit is performing poorly on complex multi-step tasks, often choosing wrong tools or getting stuck in loops. What is the most effective optimization strategy?

    • Refine the prompt with clearer tool descriptions and few-shot examples of correct thought-action-observation flow
    • Wrap each tool call in tenacity-style retries plus a hard step-count cap that forcibly breaks the agent out of loops
    • Fine-tune the base model with LoRA on logged traces of past successful agent runs to embed the reasoning behavior
    • Lower the sampling temperature toward zero so the agent tool selection becomes fully deterministic and stable

19. You're using NVIDIA's MIPROv2 to optimize prompts for a classification task. After several iterations, the optimizer suggests adding 8 few-shot examples, but this pushes your prompt to 3,500 tokens. What's the best approach to balance performance and cost? (Select TWO)

    • Migrate the eight demonstrations into a LoRA fine-tune so the classification behavior lives in the model weights, not the prompt
    • Test a reduced set of three to four strategically chosen examples and measure whether the accuracy drop is acceptable
    • Quantize the deployed model to INT4 with TensorRT-LLM so serving the longer 3,500-token prompt costs noticeably less
    • Move all eight examples into a retrieval store and fetch only the two or three most relevant demonstrations per query
    • Keep the demonstration block static and reuse its cached prefix so the few-shot tokens are not re-billed on each call

20. Your application needs to generate SQL queries from natural language. The LLM occasionally produces syntactically invalid SQL or uses wrong table names. Which combination of techniques provides the most robust solution?

    • Fine-tune the model with LoRA on a labeled text-to-SQL corpus so it internalizes valid syntax and the warehouse table names
    • Use constrained decoding with a SQL grammar, add Chain-of-Thought query planning, and inject the table schema into the prompt
    • Retrieve semantically similar prior queries via RAG and pass them as few-shot exemplars alongside the user request and schema text
    • Validate every generated query with a SQL parser library and re-prompt the model on each parsing failure until it passes