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

NCA-GENL practice questions are the quickest way to learn whether your transformer, prompt-engineering, and NVIDIA-tooling knowledge holds up under exam-style pressure. This article gives you 20 fresh scenario questions for the NVIDIA-Certified Associate: Generative AI with LLMs (NCA-GENL) exam, spread across all five domains in proportion to their weights, each followed by the answer and a full explanation of why the right choice wins and why every wrong choice loses. You also get a self-check rubric to interpret your score and a domain-by-domain map of what to read next. Work through the set with a timer at about one minute per question, which is the pace the real 60-minute exam demands.

How NCA-GENL questions are built

The exam has 50 to 60 questions in 60 minutes, remotely proctored, with a passing score that NVIDIA does not publish. Most items are single-answer multiple choice; some are multiple response, and the stem states how many options to pick. At associate depth the stems are short (a two- or three-sentence situation) and the difficulty lives in the options: every distractor is a true statement about a neighboring concept, and your job is to match the concept to this situation. A question about attention scaling will offer dropout and learning rate as options, both real training tools and both wrong for the symptom described. The 20 questions below follow the official domain weights, so the mix mirrors what you will face.

Score yourself honestly (a Select TWO counts only when both picks are right) and read the result with this rubric:

Core Machine Learning and AI Knowledge (30%)

Question 1

Domain: Core Machine Learning and AI Knowledge (30%)

A team trains a small transformer (a neural network built from stacked attention layers) for intent classification and drops the positional encoding step to simplify the code. Training accuracy is fine, but the model treats "cancel my order then confirm" and "confirm my order then cancel" as identical. Which component should they restore first?

• A. Positional encodings added to the token embeddings before the first layer
• B. A wider feed-forward network inside each of the transformer blocks
• C. Layer normalization applied before every attention sublayer in the stack
• D. Additional attention heads in each of the multi-head attention layers

Answer: A

Self-attention mixes all token vectors with learned weights, and the result is identical no matter what order the tokens arrive in (permutation invariance). Without positional information the two sentences are the same bag of tokens. Positional encodings (sinusoidal or learned vectors added to the embeddings) inject order. A wider feed-forward network adds capacity per position and still sees no order, layer normalization only stabilizes training, and extra heads are exactly as order-blind as the first one.

Question 2

Domain: Core Machine Learning and AI Knowledge (30%)

A support team has 20,000 labeled tickets and wants a model that assigns one of five categories with a probability per class, runs on a small GPU with low latency, and can be fine-tuned on their labels. Which architecture is the best fit?

• A. An encoder-only model with a classification head on the pooled output
• B. A decoder-only model prompted to write the category name as free text
• C. An encoder-decoder model trained to translate tickets into label strings
• D. A decoder-only model with a much longer context window than the default

Answer: A

Encoder-only models (BERT-style, reading the whole input with bidirectional attention) produce one fixed representation, so a classification head outputs calibrated class probabilities directly; they are small, fast, and fine-tuning on 20,000 labels is routine. A prompted decoder-only model can name a label but gives no clean per-class probability, costs more per request, and wastes the labeled data. Encoder-decoder models exist for sequence-to-sequence output such as translation, heavier than the task needs. A longer context window fixes input length, which was never the constraint.

Question 3

Domain: Core Machine Learning and AI Knowledge (30%)

An engineer implements attention from scratch for a model with key dimension 512. Training stalls almost immediately: the attention weights collapse to near one-hot distributions and gradients through the softmax are tiny. She has not divided the query-key dot products by anything. What is the correct fix?

• A. Scale the dot products by the square root of the key dimension before the softmax
• B. Increase the learning rate by a large factor so the optimizer escapes the flat region
• C. Replace the softmax with a sigmoid applied to each attention score independently
• D. Apply dropout to the attention weights immediately after the softmax has been computed

Answer: A

Dot products between random vectors grow in magnitude with dimension, so at d_k = 512 the raw scores are large, the softmax (which turns scores into a probability distribution) saturates toward one-hot outputs, and its gradient vanishes. Scaled dot-product attention divides by sqrt(d_k) to keep scores in a range where the softmax stays soft. A higher learning rate does not undo saturation and often destabilizes training. A per-score sigmoid removes the normalization across positions that attention relies on. Dropout regularizes weights that were already computed and leaves the input scale untouched.

Question 4

Domain: Core Machine Learning and AI Knowledge (30%)

A colleague proposes replacing the eight 64-dimensional heads in an attention layer with a single 512-dimensional head, arguing that the parameter count is the same and the code is simpler. What capability does the model most directly lose with this change?

• A. Attending to several different relationships in parallel from separate subspaces
• B. Encoding the relative order of tokens within the input sequence it processes
• C. Processing input sequences that are longer than the context length it was trained with
• D. Reducing the total number of trainable parameters inside the attention layer

Answer: A

Multi-head attention splits the representation into subspaces and lets each head learn its own pattern, so one head can track syntax while another tracks which pronoun refers to which noun, all in one layer. A single wide head averages these into one distribution per position. Token order comes from the positional encodings, so head count has no effect on it. Context length depends on the positional scheme and memory. And the colleague is right that the parameter count is roughly equal, so nothing changes there.

Question 5

Domain: Core Machine Learning and AI Knowledge (30%)

A team fine-tunes a small decoder-only language model on 3,000 internal documents. Training loss keeps falling across epochs, but validation loss bottoms out after epoch two and then rises. Which TWO actions most directly address this behavior? (Select TWO)

• A. Add dropout or weight decay and stop training at the best validation loss
• B. Increase the learning rate by an order of magnitude so training converges faster
• C. Add more diverse training examples so the model sees broader coverage
• D. Remove layer normalization so the model has more expressive freedom to fit

Answer: A and C

Falling training loss with rising validation loss is overfitting: the model memorizes the small dataset instead of learning patterns that generalize. Regularization (dropout randomly zeroes activations, weight decay penalizes large weights) and early stopping limit memorization, and more varied data gives the model something general to learn. A larger learning rate speeds up whatever the model is doing, including memorization, and risks divergence. Removing layer normalization destabilizes optimization and adds no generalization benefit.

Question 6

Domain: Core Machine Learning and AI Knowledge (30%)

A startup downloads a pretrained base model that produces fluent continuations of any text but ignores instructions, rambles past the question, and never declines harmful requests. They want a helpful chat assistant. Which stage of the LLM training pipeline is missing?

• A. Supervised instruction tuning followed by preference-based alignment
• B. Additional pretraining on a much larger crawl of general web text
• C. Increasing the number of layers and attention heads in the network
• D. Attaching a document retrieval component in front of the base model

Answer: A

Pretraining teaches next-token prediction, which yields a fluent completer, and the base model behaves exactly like one. Supervised fine-tuning on instruction-response pairs teaches the format of following requests, and alignment methods (RLHF, reinforcement learning from human feedback, or DPO, direct preference optimization, both trained on human preference data) shape helpfulness, conciseness, and refusals. More pretraining produces a better completer, extra layers add capacity without changing behavior, and retrieval supplies facts without teaching instruction following.

Software Development (24%)

Question 7

Domain: Software Development (24%)

A three-person team must serve an open-weight Llama-family model inside their own Kubernetes cluster behind an OpenAI-compatible chat endpoint. Nobody on the team has inference-optimization experience, and they need production-grade throughput within a week. Which approach best fits?

• A. Deploy the model with an NVIDIA NIM container pulled from NGC
• B. Wrap a Hugging Face pipeline() call in a small Flask web service
• C. Compile a TensorRT engine and write a custom HTTP server around it
• D. Train the model from scratch with the NeMo Framework and serve it

Answer: A

NIM (NVIDIA Inference Microservices) packages a supported model with a pre-optimized inference engine (TensorRT-LLM or vLLM under the hood), health checks, and an OpenAI-compatible API in one container, which is exactly the "production in a week without optimization expertise" case. A pipeline() in Flask is fine for a demo but runs unoptimized eager inference one request at a time. Building a TensorRT engine plus a custom server is the work NIM already did. NeMo Framework is for training and customizing models, and nothing here calls for training.

Question 8

Domain: Software Development (24%)

A platform team hosts a PyTorch text classifier, an ONNX embedding model, and a TensorRT engine on the same GPU nodes. They want one serving layer that batches concurrent requests automatically and runs all three formats. Which TWO Triton Inference Server capabilities meet these needs? (Select TWO)

• A. Dynamic batching, which groups incoming requests on the server
• B. Multiple framework backends served from one model repository
• C. Model ensembles that chain several models into a single pipeline
• D. Sequence batching for stateful models that need ordered requests

Answer: A and B

Dynamic batching lets Triton combine individual inference requests into larger batches on the fly, which raises GPU utilization without client changes. Triton's backend system loads PyTorch (LibTorch), ONNX Runtime, TensorRT, Python, and other model types side by side from a single model repository, so one server covers all three formats. Ensembles are a real Triton feature, but they chain models into a pipeline and answer neither the batching nor the multi-framework requirement. Sequence batching targets stateful models such as streaming speech, a different workload.

Question 9

Domain: Software Development (24%)

A developer builds a document Q&A feature with LangChain. Every request follows the same steps in the same order: retrieve chunks, build a prompt, call the LLM, parse the answer into a schema. There is no branching and no tool selection. Which abstraction fits best?

• A. A sequential chain composed with the LangChain Expression Language
• B. A ReAct agent that decides which tool to call at each step of the run
• C. A LangGraph graph with cycles and conditional edges between nodes
• D. A conversation memory module attached to the chat model object

Answer: A

A fixed, linear pipeline is what chains are for: LCEL (LangChain Expression Language, the pipe-style syntax for composing components) joins retriever, prompt, model, and output parser into one runnable with streaming and batching included. A ReAct agent adds an LLM-driven loop that reasons and picks tools, unnecessary overhead when the steps never change. LangGraph shines when the workflow needs cycles, branching, or persistent state across steps, none of which appear here. Memory stores prior turns for multi-turn chat and does not define the pipeline.

Question 10

Domain: Software Development (24%)

A developer wants to sanity-check a Hub-hosted sentiment model on a few sentences in under five lines of Python, without writing tokenization or post-processing code. Which Hugging Face transformers approach is the right one?

• A. Call pipeline() with the task name and the Hub model id
• B. Load AutoModelForCausalLM and decode the output logits by hand
• C. Instantiate AutoTokenizer alone and inspect the token ids
• D. Configure the Trainer class and run one training epoch first

Answer: A

pipeline("sentiment-analysis", model=...) downloads the tokenizer and model, applies preprocessing, runs inference, and returns labels with scores, which is the intended quick-test path. AutoModelForCausalLM is the wrong head for classification (AutoModelForSequenceClassification would be needed) and still requires a manual softmax and label mapping. A tokenizer by itself only converts text to ids and never produces a prediction. Trainer is for fine-tuning, and a pretrained sentiment model needs no training before it can be tested.

Question 11

Domain: Software Development (24%)

A vision-language service runs a fixed PyTorch model in eager mode on NVIDIA GPUs and misses its latency target. The architecture will not change, and the team wants the largest inference speedup with the least code. What should they do?

• A. Export the model and build a TensorRT engine at FP16 or INT8 precision
• B. Rewrite the training loop to use mixed precision and then retrain the model
• C. Reduce the inference batch size to one and disable CUDA graphs on the server
• D. Add more CPU worker processes to the data loader in front of the model

Answer: A

TensorRT takes a trained model, fuses layers, selects tuned kernels for the target GPU, and can run in reduced precision (FP16, or INT8 with calibration), which typically gives the largest inference speedup for a fixed architecture. Mixed-precision training speeds up training and does not by itself change the deployed graph. Batch size one with CUDA graphs disabled lowers throughput and adds launch overhead. More data-loader workers help only when preprocessing is the bottleneck, and the scenario points at model latency.

Experimentation (22%)

Question 12

Domain: Experimentation (22%)

A team wants a 7B model to adopt their legal summarization style using 5,000 examples. They have one 24 GB GPU, and full fine-tuning runs out of memory before the first optimizer step. Which approach should they use?

• A. Apply LoRA adapters to the attention projections and train only those
• B. Freeze the embedding layer and fully fine-tune all of the remaining layers
• C. Continue pretraining the whole model on legal text at a lower learning rate
• D. Distill the model into a smaller student and then fully fine-tune the student

Answer: A

LoRA (low-rank adaptation, a PEFT or parameter-efficient fine-tuning method) freezes the base weights and trains small low-rank matrices injected into chosen layers, so gradients and optimizer states exist only for a tiny fraction of parameters and the job fits on a single 24 GB GPU; QLoRA (4-bit base weights plus LoRA) shrinks memory further. Freezing embeddings still leaves billions of trainable parameters with full optimizer state. Continued pretraining is full-parameter training with the same memory problem and the wrong objective. Distillation is a separate multi-week project and sacrifices capability.

Question 13

Domain: Experimentation (22%)

An extraction prompt turns invoices into JSON, but across calls the model changes key names, sometimes wraps the output in prose, and drops fields. The team cannot fine-tune and needs consistent output this week. What is the best next step?

• A. Add two or three worked examples showing the exact JSON schema in the prompt
• B. Ask the model to reason step by step before it writes the final answer
• C. Raise the temperature so the model explores alternative output formats
• D. Split each invoice into sentences and call the model once per sentence

Answer: A

Few-shot examples anchor the output format: showing the exact keys and shape (with an explicit "return only JSON" instruction) is the standard fix for inconsistent structure. Chain-of-thought prompting helps multi-step reasoning and tends to add prose, the opposite of what is wanted. A higher temperature (the sampling setting that controls randomness) increases variance and therefore inconsistency. Sentence-level calls destroy the document context needed to link fields, multiply cost, and still leave the format unspecified.

Question 14

Domain: Experimentation (22%)

A team has 200 human-written reference summaries and two candidate summarization prompts. Before spending budget on human review, they need one automated metric to indicate which prompt produces summaries closer to the references. Which metric should they choose?

• A. ROUGE, measuring n-gram and subsequence overlap with the reference texts
• B. BLEU, the precision-oriented score designed for machine translation output
• C. Perplexity of the model computed on the set of reference summaries
• D. Token-level F1 as used for named-entity recognition and tagging tasks

Answer: A

ROUGE was designed for summarization: it is recall-oriented, rewarding candidates that cover the content of the reference, and ROUGE-1, ROUGE-2, and ROUGE-L are the standard reported numbers. BLEU is precision-oriented and penalizes paraphrase and shorter outputs, a poor fit for summaries. Perplexity measures how well a language model predicts text; it compares no generated summary to a reference and cannot separate two prompts on the same model. Token-level F1 assumes a token-tagging task, which summarization is not.

Question 15

Domain: Experimentation (22%)

A team compares a new system prompt to the current one by running both on five hand-picked examples; the new one "looks better." Before shipping it, which TWO experiment-design practices would make the conclusion trustworthy? (Select TWO)

• A. Evaluate both prompts on the same held-out set of several hundred examples
• B. Fix decoding settings such as temperature and seed so only the prompt varies
• C. Rerun the same five hand-picked examples ten times each and average the scores
• D. Reuse the examples that inspired the new prompt as the official evaluation test set

Answer: A and B

A sound comparison needs a large, representative, held-out evaluation set (ideally scored blind by humans or by a rubric-based judge) so the result reflects real traffic. Holding decoding parameters constant ensures the prompt is the only variable that changed. Repeating five cherry-picked examples reduces sampling noise but leaves selection bias intact. Testing on the examples used to design the prompt is data leakage, and it flatters the new prompt.

Data Analysis and Visualization (14%)

Question 16

Domain: Data Analysis and Visualization (14%)

A team builds a tokenizer for a multilingual customer chatbot. Their word-level vocabulary has grown past 500,000 entries and still maps misspellings, product codes, and rare words to an unknown token, which hurts quality. Which tokenization approach should they adopt?

• A. A subword tokenizer such as BPE, WordPiece, or SentencePiece
• B. A character-level tokenizer so that no token is ever marked unknown
• C. A larger word-level vocabulary that is retrained more frequently
• D. Whitespace splitting followed by lowercasing every resulting token

Answer: A

Subword tokenizers (BPE, byte-pair encoding, and its relatives) learn a compact vocabulary of frequent pieces and represent any string, including typos and codes, as a sequence of known pieces, which is why modern LLMs use BPE or SentencePiece variants. Character-level tokenization eliminates unknowns but produces very long sequences that are expensive to attend over and weak semantically. A bigger word vocabulary still cannot cover unseen strings and bloats the embedding matrix. Whitespace splitting fails on scripts without spaces and does nothing for rare words.

Question 17

Domain: Data Analysis and Visualization (14%)

A help-center search matches keywords only. Users type "my card got declined" and find nothing, because the relevant article says "payment authorization failure." The team wants search that understands meaning across different wording. Which approach should they implement?

• A. Encode articles and queries with an embedding model and rank by cosine similarity
• B. Extend the keyword index with a hand-maintained list of synonyms for each term
• C. Fine-tune a decoder-only model to rewrite every article in plainer customer language
• D. Build TF-IDF vectors for the articles and rank them by weighted term frequency

Answer: A

Text embeddings map sentences to dense vectors where similar meanings land close together, so a nearest-neighbor search over article vectors (typically stored in a vector database) retrieves "payment authorization failure" for "card got declined." Cosine similarity, the angle between two vectors, is the usual ranking score. Synonym lists help a little and never keep up with real user language. Rewriting articles is expensive, leaves the query side untouched, and still relies on lexical matching. TF-IDF is a smarter keyword weighting but remains lexical, with the same vocabulary gap.

Question 18

Domain: Data Analysis and Visualization (14%)

A data scientist cleans several gigabytes of chat logs with pandas on a workstation that has an NVIDIA GPU. Groupby and join steps take hours, and the code is standard pandas. Which TWO changes deliver GPU acceleration with the smallest rewrite? (Select TWO)

• A. Load the data with cuDF and keep the same DataFrame-style API on the GPU
• B. Enable the cudf.pandas accelerator so existing pandas code runs on the GPU
• C. Rewrite the groupby and join logic as PyTorch tensor operations run on the GPU
• D. Run cuGraph community detection over the logs to make the joins run faster

Answer: A and B

cuDF is the RAPIDS GPU DataFrame library with a pandas-like API, so read_csv, groupby, and merge move to the GPU with near-identical code. cudf.pandas goes further: loaded as an extension or run with python -m cudf.pandas, it accelerates existing pandas scripts with zero code changes and falls back to CPU for unsupported operations. Both assume the data fits in GPU memory (Dask-cuDF scales beyond a single GPU). Rewriting tabular logic in PyTorch is a large, awkward rewrite. cuGraph is for graph analytics and does nothing to accelerate joins.

Trustworthy AI (10%)

Question 19

Domain: Trustworthy AI (10%)

A retail assistant built on an LLM sometimes states return-policy details that do not exist in the company's knowledge base, and customers act on them. Which change most directly reduces these fabricated answers?

• A. Ground answers in retrieved policy passages and instruct the model to use only them
• B. Increase the temperature so the model produces more diverse candidate answers per call
• C. Add a line to the system prompt telling the model to always be truthful with users
• D. Continue pretraining the model on a much larger corpus of general web text and news

Answer: A

Hallucination (a fluent answer with invented facts) here comes from the model filling gaps from its own weights. Retrieval-augmented generation (RAG) supplies the authoritative passages at request time, and an instruction to answer only from them, with citations and an explicit "I don't know" path, constrains the output to what the knowledge base actually says; an output rail that checks claims against the retrieved text, as NeMo Guardrails provides, adds a second check. Higher temperature increases variability and therefore invention. A "be truthful" line supplies none of the missing facts. More general pretraining changes nothing about company policy.

Question 20

Domain: Trustworthy AI (10%)

An analytics dashboard stores every raw prompt sent to an internal assistant, and prompts routinely include customer names, email addresses, and account numbers. Anyone in the company can open the dashboard. Which TWO changes best address the privacy risk? (Select TWO)

• A. Detect and mask personal identifiers before prompts are written to the log store
• B. Restrict dashboard access by role and set a retention limit on stored prompts
• C. Keep raw prompts indefinitely so they can serve as fine-tuning data for a later model
• D. Add a notice in the chat UI asking users to avoid entering personal data in prompts

Answer: A and B

Privacy controls for LLM systems start with data minimization: redacting or masking PII (personally identifiable information) at ingestion means the sensitive values never reach the dashboard. Role-based access and time-bounded retention limit who can see whatever remains and for how long. Keeping raw prompts indefinitely inverts minimization and turns the log into a growing liability. A UI notice is a reasonable supplement, but users will still paste account numbers, so it does not remove the exposure.

If you missed these, read this

Use your misses by domain to pick the next thing to read. Every link is a sibling article in the NCA-GENL cluster or a practice resource on preporato.com.

• Core Machine Learning and AI Knowledge (Q1 to Q6). Misses here mean the transformer diagram is not yet in your head. Read the architecture section of the exam domains breakdown, then redraw attention, positional encoding, and the encoder versus decoder split from memory.
• Software Development (Q7 to Q11). If NIM, Triton, TensorRT, and NeMo blur together, the tool table in the cheat sheet fixes that; then run one Hugging Face pipeline() call and one LCEL chain yourself so the API names stop being abstract.
• Experimentation (Q12 to Q15). These questions reward hands-on time. Weeks 3 and 4 of the 4-week study plan schedule a LoRA run and a metrics comparison; do both.
• Data Analysis and Visualization (Q16 to Q18). Know the three tokenizer families, what an embedding is, and where cuDF, cuGraph, and cuML each fit. The RAPIDS notes in the complete guide are enough at associate depth.
• Trustworthy AI (Q19 to Q20). Hallucination, bias, content filtering, and privacy: the first-attempt guide covers all four in the vocabulary the exam uses.

When every domain is solid, move to timed full-length tests. The NCA-GENL practice tests report accuracy per domain after each attempt, and the free sampler is a no-cost way to check whether one question per minute feels comfortable. All six tests are included in Preporato Pro; see pricing for current options.

Frequently asked questions

Next steps

Score this set, then read the sibling article for every domain you missed. When all five feel solid, take a full timed test at /certificates/generative-ai-llm-associate, or start with the free NCA-GENL sampler to check pacing first. If the professional exam is on your roadmap, the NCP-GENL practice questions show how the same concepts get harder.

Sources:

• NVIDIA-Certified Associate: Generative AI LLMs (official exam page)
• NVIDIA NIM for LLMs documentation
• NVIDIA Triton Inference Server user guide
• NVIDIA TensorRT documentation
• RAPIDS cudf.pandas accelerator documentation
• Hugging Face transformers pipelines reference