Free NCA-GENL practice questions

In a transformer encoder, what is the primary purpose of the multi-head attention mechanism compared to single-head attention?

• AIt allows the model to attend to information from different representation subspaces at different positions simultaneously.check_circle Correct
• BIt reduces the total number of parameters by splitting the attention matrix into independent segments.
• CIt replaces positional encoding by encoding token order directly through each attention head.
• DIt applies a recurrent connection across heads so that the output of one head is fed as input to the next head sequentially.

Why A is correct: This is the defining benefit: each head learns a distinct linear projection of queries, keys, and values, enabling the model to capture different types of relationships (syntactic, semantic, coreference) in parallel across the sequence.

Why B is wrong: Tempting because 'splitting' sounds like compression, but multi-head attention does not reduce parameters - it uses separate learned projection matrices for each head, which typically keeps or increases the parameter count relative to a single wide attention layer.

Why C is wrong: Tempting because attention heads do process position-sensitive information, but positional encoding is a separate, additive signal injected into the embeddings before attention is computed - attention heads do not replace it.

Why D is wrong: Tempting for candidates who conflate multi-head attention with sequential processing, but the heads in multi-head attention operate in parallel and independently; their outputs are concatenated, not chained recurrently.

A researcher notices that a transformer language model produces identical output regardless of the order in which tokens appear in the input sequence. Which component is most likely missing or misconfigured?

• AThe feed-forward sublayer within each encoder block.
• BThe positional encoding added to the token embeddings before the attention layers.check_circle Correct
• CThe layer normalisation applied after each sublayer.
• DThe residual connections that bypass each sublayer.

Why A is wrong: Tempting because the feed-forward sublayer processes each position, but it operates identically on each position independently and does not encode order information - its absence would degrade quality but would not cause order-invariance on its own.

Why B is correct: Without positional encoding, the self-attention mechanism treats the input as a set rather than a sequence - the attention scores depend only on token identity, not position, so permuting tokens produces the same output. Positional encodings inject order information into the embeddings to break this symmetry.

Why C is wrong: Layer normalisation stabilises training and affects output magnitudes, but it contains no positional information and its removal would not cause the model to treat token order as irrelevant.

Why D is wrong: Residual connections carry gradient flow and preserve earlier representations, but they do not encode sequence order. Removing them would harm gradient propagation, not make the model order-invariant.

When comparing a transformer-based language model to a recurrent neural network (RNN) for processing long text sequences, which characteristic most directly explains why transformers generally handle long-range dependencies more effectively?

• ATransformers use gating mechanisms similar to LSTM cells that selectively retain information across many time steps.
• BTransformers process sequences left-to-right one token at a time, which gives them better gradient flow than bidirectional RNNs.
• CTransformers process all tokens in direct pairwise attention in a single pass, giving any two tokens a constant path length between them.check_circle Correct
• DTransformers replace embeddings with one-hot vectors at each layer, avoiding the compression that causes RNNs to forget early tokens.

Why A is wrong: LSTM-style gating is an RNN mechanism, not a transformer one. Transformers do not use gates; they use attention weights to route information. Attributing LSTM gating to transformers conflates two separate architectures.

Why B is wrong: Transformers do not process tokens sequentially left-to-right; they process the entire sequence in parallel. Claiming they are sequential conflates transformer inference with autoregressive generation - and bidirectional RNNs already improve over unidirectional ones for gradient flow.

Why C is correct: The scaled dot-product attention computes relationships between every pair of positions simultaneously, so the path length between any two tokens is O(1) regardless of sequence length. In an RNN, the signal from an early token must pass through every intermediate hidden state, creating O(n) path length and vanishing-gradient risk.

Why D is wrong: Transformers use dense learned embeddings, not one-hot vectors, at their input layer. One-hot representations are extremely high-dimensional and sparse; replacing embeddings with them would not improve memory of long-range dependencies.

A team is training a convolutional neural network (CNN) on a dataset of greyscale medical images. Each image is 256x256 pixels, stored in channels-last (NHWC) format. Which tensor shape correctly represents a single training batch of 32 images when fed into the first convolutional layer?

• A(32, 3, 256, 256) - batch size, channels, height, width
• B(32, 256, 256, 1) - batch size, height, width, channelscheck_circle Correct
• C(32, 256, 256) - batch size, height, width only
• D(1, 32, 256, 256) - channels, batch size, height, width

Why A is wrong: Tempting because NCHW format is valid in some frameworks such as PyTorch, and 3 is the channel count for RGB images. However, greyscale images have 1 channel, not 3, making this shape doubly wrong for this task.

Why B is correct: A greyscale image has exactly one channel. The standard NHWC (batch, height, width, channels) format places the channel count last, giving (32, 256, 256, 1). This matches the expected input shape for most deep learning frameworks in channels-last mode.

Why C is wrong: Omitting the channel dimension is a common shorthand in data pre-processing scripts, but a CNN layer requires an explicit channel dimension. Passing a 3-D tensor without a channel axis causes a shape mismatch error at the convolution operation.

Why D is wrong: The channel count of 1 is numerically correct for greyscale, but placing it in the first axis and the batch size in the second axis inverts the standard batch-first convention, which causes incorrect layer behaviour and gradient computation.

When fine-tuning a pre-trained transformer language model, a practitioner observes that the model's self-attention mechanism scales quadratically with sequence length. Which architectural modification is specifically designed to reduce this computational complexity while preserving the model's ability to attend to distant tokens?

• AReplacing dense feed-forward layers with mixture-of-experts (MoE) blocks to activate only a subset of parameters per token
• BReducing the model's hidden dimension size so that the key and query projections operate on smaller vectors across all sequence positions
• CApplying sparse or linear attention, such as Longformer's sliding-window attention, to limit each token's attention span to a local window plus selected global tokenscheck_circle Correct
• DSwitching from multi-head attention to multi-query attention by sharing key and value projections across all heads

Why A is wrong: MoE blocks reduce the effective parameter count per forward pass by routing tokens to specialist sub-networks, which cuts feed-forward cost. However, the self-attention bottleneck is a separate mechanism; MoE does not change how attention scores are computed across the sequence length.

Why B is wrong: Shrinking the hidden dimension reduces the constant factor in attention computation and lowers memory use per token, but the number of attention score pairs still grows as O(n^2) with sequence length. It does not change the fundamental scaling behaviour that was identified as problematic.

Why C is correct: Sparse attention patterns, as used in Longformer and related architectures, replace the full O(n^2) attention matrix with local windows and a small number of global positions. This reduces complexity to O(n) or O(n log n) while still allowing long-range dependencies through the global tokens, directly addressing the quadratic scaling problem.

Why D is wrong: Multi-query attention reduces the memory footprint and inference-time KV-cache cost by using a single set of keys and values for all heads, which is a practical optimisation. However, it does not change the O(n^2) scaling of attention scores with respect to sequence length, so it does not resolve quadratic complexity.

A data engineer is building a preprocessing pipeline for a text-to-image diffusion model. The pipeline must handle floating-point pixel values, tokenised text IDs, and binary attention masks in a single batched forward pass. Which statement best describes how these three data types are typically managed within the model's input layer?

• AAll three inputs are cast to float32 at ingestion because neural network layers require a single unified numeric precision throughout the entire network.
• BPixel values and attention masks are combined into one tensor before the first layer to reduce the number of separate inputs the model graph must manage.
• CToken IDs are one-hot encoded into float vectors before embedding, because transformer attention cannot directly process integer indices.
• DPixel values use float32 or float16, token IDs use integer tensors fed into an embedding layer, and attention masks use boolean or integer tensors applied inside the attention computation.check_circle Correct

Why A is wrong: Mixed-precision training and inference is standard practice; text token IDs remain as integer tensors (int32 or int64) until they are passed through an embedding lookup that converts them to float. Casting token IDs directly to float32 before embedding is semantically incorrect and would bypass the embedding table entirely.

Why B is wrong: Merging spatially structured image data with binary mask vectors is not a valid operation because they have different shapes and semantics. Attention masks are applied multiplicatively inside attention layers, not concatenated with pixel tensors at the input stage.

Why C is wrong: One-hot encoding was used in earlier NLP systems but is computationally wasteful at large vocabulary sizes. Modern transformer implementations pass integer token IDs directly to a learnable embedding matrix (an efficient table lookup), which is both faster and more memory-efficient than materialising a full one-hot vector for each token.

Why D is correct: Each data type retains its appropriate dtype: continuous pixel intensities are represented as floating-point values, discrete token IDs are integers indexed into an embedding table to produce float vectors, and binary attention masks are boolean or 0/1 integer tensors multiplied into the attention score matrix to suppress padding positions. Using the correct dtype for each input is essential for numerical correctness and memory efficiency.

A PyTorch training pipeline loads a large image dataset. Profiling shows the GPU sits idle for several hundred milliseconds between batches. The DataLoader currently uses num_workers=0. Which configuration change will most directly reduce the inter-batch GPU idle time?

• AIncrease the batch size substantially so each GPU kernel runs longer, amortising the fixed per-batch data transfer overhead across more samples per step.
• BReplace the default collate function with a custom one that stacks tensors directly on the GPU, removing the explicit host-to-device copy step from inside the training loop.
• CMove the entire dataset into GPU VRAM at the start of training using a pre-loaded TensorDataset so that each batch requires no host-to-device transfer during the loop.
• DSet num_workers to a value greater than zero and enable pin_memory=True so that background worker processes prefetch batches while the GPU trains, and pinned memory enables faster asynchronous DMA transfers.check_circle Correct

Why A is wrong: A larger batch size reduces the number of host-to-device transfers per epoch but does not introduce prefetching. The root cause is that data loading is sequential and blocking, and increasing batch size does not change that. It may also cause out-of-memory errors or destabilise training.

Why B is wrong: DataLoader workers run in forked processes that cannot share CUDA contexts in the standard configuration; attempting to create GPU tensors inside a worker raises a RuntimeError. Tensors must be transferred to the GPU inside the main training loop, not during collation in the worker process.

Why C is wrong: Pre-loading a large image dataset into GPU VRAM is not feasible; VRAM capacity is far smaller than typical dataset sizes and the approach fails with an out-of-memory error. It also prevents standard CPU-side augmentation pipelines from running, limiting training data diversity.

Why D is correct: With num_workers=0, the main process blocks on each batch load before resuming the training loop, serialising CPU work and GPU computation. Setting num_workers greater than zero spawns workers that prepare the next batch in parallel. pin_memory=True allocates output tensors in page-locked host memory, enabling the CUDA DMA engine to transfer them asynchronously with higher bandwidth, further overlapping data preparation with GPU execution.

An engineer is adapting a pre-trained encoder-decoder transformer to summarise long legal documents into a single concise paragraph. The team wants a metric that captures how well the key content is retained in the summary. Which metric is most commonly used as the primary automatic evaluation measure for this task?

• AROUGE-L, which measures the longest common subsequence between candidate and reference summariescheck_circle Correct
• BPerplexity computed on a held-out portion of the source documents
• CEntity-level F1 score computed using a sequence labelling head
• DBLEU-4, which counts four-gram precision between the generated paragraph and the source document

Why A is correct: ROUGE-L computes the longest common subsequence (LCS) between a generated summary and one or more human-written reference summaries. It captures recall of key content without requiring contiguous n-gram matches, making it the dominant automatic metric for abstractive summarisation benchmarks such as CNN/DailyMail and XSum.

Why B is wrong: Perplexity measures how well a language model predicts a held-out text and reflects fluency, not content coverage. It does not compare a generated summary against a reference summary and so cannot assess whether key facts were retained.

Why C is wrong: Entity-level F1 is the standard metric for named entity recognition tasks. While entities matter in summaries, entity F1 alone does not measure overall n-gram overlap or sentence-level recall of key content across a full paragraph.

Why D is wrong: BLEU was designed for machine translation and emphasises precision of short n-grams against a reference translation, not a lengthy source document. Comparing against the source rather than a reference summary measures compression, not fidelity to human-preferred content.

A team evaluates two extractive QA models on a SQuAD-style dataset. Model A achieves an exact match (EM) of 68% and an F1 score of 81%. Model B achieves an EM of 72% and an F1 score of 74%. Which conclusion is most defensible when reporting these results?

• AModel B is strictly superior because its exact match score is higher on the held-out test set.
• BThe two metrics capture different aspects of answer quality, so the preferred model depends on whether partial credit is acceptable in the target application.check_circle Correct
• CModel A is strictly superior because its F1 score is higher on the held-out test set.
• DThe evaluation is invalid because SQuAD-style metrics cannot compare extractive models that differ in architecture.

Why A is wrong: Tempting because exact match is the stricter metric and Model B leads there. Wrong because EM penalises any token mismatch, so a model that recovers most of the answer but misses a stop-word scores zero; Model A's higher F1 shows it retrieves more answer tokens on average, making the trade-off non-trivial.

Why B is correct: Exact match requires the predicted span to match the reference exactly, while F1 measures token-level overlap and awards partial credit. Choosing between them is an application decision: high-stakes retrieval may require exact match; conversational assistants may tolerate partial matches. Reporting both and contextualising the trade-off is the defensible approach.

Why C is wrong: Tempting because F1 is often cited as the primary SQuAD metric and Model A leads there. Wrong because neither metric dominates in all use cases; the right choice depends on whether partial credit matters to the application, so a one-dimensional superiority claim based on a single metric is unjustified.

Why D is wrong: Tempting because architectural differences can affect comparability in some evaluation frameworks. Wrong because SQuAD EM and F1 are output-level metrics applied to predicted answer spans regardless of model architecture; they are specifically designed to compare any extractive QA system on a shared held-out benchmark.

A team is fine-tuning a text classifier but has only 500 labelled training samples. Which data augmentation technique is most likely to preserve the original label while increasing the number of training examples?

• ARandomly shuffling the order of sentences within each document
• BTruncating each document to exactly half its original word count
• CTranslating documents into a different language and discarding originals
• DReplacing selected words with synonyms drawn from a lexical databasecheck_circle Correct

Why A is wrong: Shuffling sentences is tempting because it creates new document orderings, but it disrupts coherence and often changes the meaning enough to corrupt the original label, making it unreliable for classification tasks.

Why B is wrong: Truncation is tempting as a quick resize step, but removing half the content frequently drops sentiment cues or key facts, altering what the label should be and reducing information available to the model.

Why C is wrong: Translation alone changes the language domain, and discarding originals removes the source-language distribution the classifier needs; this is not standard augmentation but rather domain shift.

Why D is correct: Synonym replacement substitutes words with semantically equivalent alternatives, keeping the overall meaning and therefore the class label intact while producing a distinct token sequence the model has not seen before.

A language model trained on a small sentiment dataset performs well on training data but poorly on unseen reviews. A researcher applies back-translation augmentation before retraining. What is the primary mechanism by which this is expected to improve the model's generalisation?

• AIt exposes the model to varied paraphrases of the same meaning, reducing reliance on specific surface patternscheck_circle Correct
• BIt compresses the vocabulary so the model memorises fewer unique tokens overall
• CIt doubles the number of labels available by producing a second annotated dataset in the intermediate language
• DIt replaces rare words with high-frequency tokens, balancing the training distribution automatically

Why A is correct: Back-translation routes text through a second language and back, producing paraphrases with different word choices and syntactic structures. Training on these variants forces the model to learn meaning-level features rather than memorising particular phrasings, directly improving generalisation.

Why B is wrong: Vocabulary compression is tempting because smaller vocabularies can reduce overfitting, but back-translation does not reduce vocabulary size - it typically introduces additional paraphrases and can expand the effective vocabulary.

Why C is wrong: This is plausible because intermediate-language text is generated, but back-translation discards or does not use the intermediate-language text as a separate labelled set; the final augmented example is still in the original language.

Why D is wrong: Frequency balancing is a real concern in NLP, and back-translation might incidentally affect word frequencies, but that is not its mechanism or intended purpose; the primary benefit is paraphrase diversity, not frequency correction.

During a text augmentation pipeline, a developer uses a contextual word-substitution model to replace tokens in training sentences. After retraining, evaluation shows that some augmented examples carry incorrect labels. Which augmentation risk does this scenario best illustrate?

• ACatastrophic forgetting caused by retraining on the augmented corpus
• BLabel noise introduced when substitutions alter the meaning enough to change the correct classcheck_circle Correct
• COverfitting to augmented samples due to excessive repetition of generated examples
• DDistribution shift introduced by using a poorly calibrated translation model

Why A is wrong: Catastrophic forgetting describes a model losing previously learned knowledge when trained on new data; it is a genuine fine-tuning concern but is unrelated to the label correctness problem described in the scenario.

Why B is correct: Contextual substitution models can select replacements that shift the sentiment or intent of a sentence - for example, changing a negative word to a neutral one in a sentiment task - making the inherited label incorrect. This is the canonical label noise risk of automated text augmentation.

Why C is wrong: Overfitting from repetition is a plausible pitfall when augmentation produces near-duplicate examples, but the scenario specifically mentions incorrect labels rather than memorisation of repeated patterns, so this is not the best fit.

Why D is wrong: Distribution shift from translation is a real risk in back-translation workflows, but the scenario describes contextual word substitution, not translation; the root cause here is meaning change from substitution, not a translation model.

A financial services company is deploying a customer-facing chatbot powered by a large language model. The team wants to prevent the model from producing responses that contain account numbers, credit card details, or regulatory advice that could expose the company to liability. Which architectural approach most directly addresses both data-leakage and liability risks at the output stage?

• AApply a retrieval-augmented generation pipeline so the model draws only from pre-approved documents, removing any need for output scanning.
• BFine-tune the base model on a corpus of compliant responses so it learns to avoid sensitive outputs, replacing the need for runtime guardrails.
• CEnforce strict input validation on the user's query to block prompts that mention account numbers or financial terms before they reach the model.
• DAdd a dedicated output-validation layer that applies regex and classifier-based checks to detect and redact PII patterns and flag regulated-content categories before the response reaches the user.check_circle Correct

Why A is wrong: RAG limits the knowledge base used during generation, which reduces hallucination risk, but it does not guarantee that the model will never produce sensitive content or regulatory advice. A model can still compose harmful output from retrieved context, so RAG alone is insufficient for output-stage enforcement.

Why B is wrong: Fine-tuning on compliant examples can shift the model's distribution toward safer outputs, but it offers probabilistic rather than deterministic protection. Novel inputs can still elicit non-compliant responses, and fine-tuning alone cannot satisfy a hard policy requirement like blocking PII.

Why C is wrong: Input validation filters what enters the model, which is a useful safety layer, but it does not address output risk. The model can produce sensitive content from benign-looking prompts through indirect reasoning or retrieved context, so input-only controls leave the output stage unprotected.

Why D is correct: An output-validation layer is the correct mechanism for catching harmful content after generation and before delivery. Regex detects structured PII such as card numbers; classifiers handle semantic categories like financial advice. Together they enforce policies regardless of what the model produces.

A development team integrates a retrieval-augmented generation system to reduce hallucinations in a medical information assistant. After deployment, evaluators find that the model still occasionally produces confident-sounding claims that contradict the retrieved passages. What is the most likely root cause of this residual hallucination?

• AThe system prompt does not instruct the model to restrict its answers to the retrieved context, so the model supplements retrieved content with parametric knowledge.check_circle Correct
• BThe vector index uses cosine similarity instead of dot-product similarity, causing semantically relevant documents to rank too low for retrieval.
• CThe embedding model was not trained on medical text, so retrieved chunks have low semantic relevance to the query.
• DThe temperature setting is too high, causing the model to generate diverse responses that drift away from factual content.

Why A is correct: RAG supplies relevant passages to the context window but does not automatically prevent the model from using its parametric (trained) knowledge alongside them. Without an explicit instruction such as 'answer only from the provided documents', the model blends retrieved facts with memorised associations, producing grounded-looking but partially hallucinated outputs.

Why B is wrong: Similarity metric choice can affect retrieval quality, but cosine and dot-product similarity produce equivalent rankings for normalised embeddings and neither is a root cause of post-retrieval hallucination. This distractor targets candidates who conflate retrieval ranking with generation grounding.

Why C is wrong: A domain-mismatched embedding model can hurt retrieval precision, which may worsen hallucination indirectly. However, the scenario states that evaluators find contradictions with retrieved passages, implying relevant passages are being retrieved. The failure is in generation, not retrieval quality.

Why D is wrong: High temperature increases output variability and can contribute to hallucination, but it is a secondary factor. A well-prompted RAG system can remain grounded even at moderate temperatures. Temperature tuning treats a symptom rather than the grounding architecture gap identified in the scenario.

An AI platform team wants to enforce topic restrictions on a customer support LLM so that it refuses to discuss competitor products, regardless of how users rephrase their requests. The solution must scale across thousands of concurrent sessions without increasing per-request latency by more than 20 milliseconds. Which implementation strategy best satisfies both the enforcement and latency requirements?

• AAdd a detailed system prompt listing all competitor names and instructing the model to refuse those topics, relying on the LLM's instruction-following to enforce the policy.
• BConfigure a lightweight input-rail classifier trained specifically to detect competitor-related queries, running it as a pre-generation step before each request reaches the LLM.check_circle Correct
• CDeploy a secondary LLM as a judge that reviews every request and response pair for policy compliance before the answer is returned to the user.
• DFine-tune the production LLM on a curated dataset of refusals for competitor queries so the behaviour is baked into the model weights.

Why A is wrong: System-prompt instructions are the simplest approach but are probabilistic: a sufficiently creative rephrasing can bypass them. They also add tokens to every request, increasing both cost and latency at scale. The approach cannot provide deterministic enforcement as required.

Why B is correct: A small task-specific classifier adds only a few milliseconds of latency and can be deployed as a stateless microservice that scales horizontally. It intercepts off-topic queries before they consume LLM compute, satisfying both the latency budget and the deterministic enforcement requirement. This is the canonical NeMo Guardrails-style input-rail pattern.

Why C is wrong: An LLM-as-judge pattern provides high-quality semantic compliance checking but doubles the inference cost and adds hundreds of milliseconds of latency per request, far exceeding the 20-millisecond budget. This is a sound pattern for async audit pipelines, not real-time enforcement.

Why D is wrong: Fine-tuning can shift the model's default behaviour but requires a redeployment cycle whenever the policy changes and cannot guarantee coverage of novel phrasings. It also does not address latency; the full model still runs on every request. Fine-tuning complements guardrails but does not replace the need for a runtime enforcement mechanism.