NCA-GENM NVIDIA Generative AI Multimodal Free Practice Exam Questions (2026 Updated)

Data cleansing (or data cleaning) operates on data you already have: it identifies and resolves quality issues within an existing dataset — handling missing values (A), removing duplicate records (D), correcting formatting or type inconsistencies (B), fixing structural errors, and standardizing units or encodings. Collecting additional data (C) belongs to a conceptually earlier and separate phase of the pipeline: data acquisition or data collection, which determines what data enters the pipeline in the first place, rather than what is done to improve the quality of data already collected.

This distinction matters operationally: a cleansing step is typically deterministic and reversible against the existing dataset (you can inspect, log, and audit exactly which rows were dropped or imputed), whereas collecting more data is a scoping decision that may require new labeling budgets, new consent/privacy review, or new data-source integration — a materially different workflow with different stakeholders.

That said, insufficient data volume discovered *during* cleansing (e.g., after removing corrupted records the sample size becomes too small for the target class) can trigger a decision to go back and collect more — but that action itself is not classified as a cleansing step; it is the trigger for restarting an earlier pipeline stage.

Data fusion is the process of combining information from multiple modalities into a single, unified representation that a downstream model can act on. As covered in the early-fusion and late-fusion questions elsewhere in this set, fusion can occur at different pipeline stages — raw/feature-level (early), intermediate representation level (hybrid), or decision level (late) — but in every case the defining operation is combination, not separation.

Option A describes the inverse operation and does not correspond to any standard multimodal technique under the name "fusion." Option C describes missing-data handling or imputation, a data-quality concern that is often addressed *before* fusion (a model needs some representation for each modality, even an imputed or masked one, before combining them) but is not fusion itself. Option D describes evaluation or quality assessment, a distinct concern from the mechanical act of combining modalities into one representation.

Fusion technique choice has real architectural consequences: early fusion assumes tight temporal/spatial correspondence between modalities and is sensitive to missing streams; late fusion is more robust to missing or noisy modalities since each unimodal branch can still contribute independently; hybrid/intermediate fusion, common in modern transformer-based multimodal architectures via cross-attention, aims to capture the benefits of both while mitigating each one's weaknesses.

Before deciding *how* to handle missing data, best practice requires understanding *why* it's missing — analyzing whether missingness is Missing Completely at Random (MCAR, no systematic pattern), Missing at Random (MAR, related to other observed variables but not the missing value itself), or Missing Not at Random (MNAR, related to the missing value itself, e.g., patients with severe symptoms being less likely to complete a survey field). This diagnostic step determines which downstream handling strategy is statistically appropriate: naive row deletion under MNAR conditions can introduce systematic bias into the remaining dataset, while mean/median imputation applied blindly can distort variance and correlational structure if missingness isn't actually random.

Options B, C, and D each jump directly to a specific remedial action without first establishing whether that action is appropriate for the missingness pattern present. Removing rows (B) sacrifices sample size and can bias results if missingness correlates with the outcome of interest. Filling with a default value (C) without understanding the pattern risks introducing artificial structure that doesn't reflect the true underlying data. Removing entire columns (D) may discard genuinely informative features if missingness in that column is low or non-systematic.

Only after this initial pattern analysis should you select an appropriate strategy: listwise deletion, mean/median/mode imputation, model-based imputation (e.g., MICE, k-NN imputation), or explicit missingness indicators as additional features.

NVIDIA Triton Inference Server is an open-source model-serving platform designed to standardize production deployment across heterogeneous model formats and hardware backends. Its defining capability is multi-framework support: a single Triton instance can concurrently serve models trained in TensorFlow, PyTorch, ONNX Runtime, TensorRT, OpenVINO, and custom Python/C++ backends, exposing them through unified HTTP/REST and gRPC inference APIs. This eliminates the need for framework-specific serving stacks and lets teams standardize deployment infrastructure independent of how a given model was trained.

Option B is a common but incorrect assumption — Triton explicitly supports both GPU and CPU inference, which matters for cost-sensitive or edge deployments where GPU availability is limited. Option C confuses Triton with cuGraph, a separate RAPIDS library for GPU-accelerated graph analytics (unrelated to model serving), and option A describes a generative task (denoising diffusion), which is a *model capability*, not a Triton *server* function — Triton can host such a model, but "generating images from noise" is not what the server itself does.

Triton also provides dynamic batching, concurrent model execution, model ensembling (chaining pre/post-processing with inference), and metrics export — features tested elsewhere in the Software Development and Engineering and Performance Optimization domains.

CNNs remain the standard architecture for image classification tasks of this kind, for the same structural reasons covered elsewhere in this set: convolutional layers exploit spatial locality and translation invariance in image data, learning hierarchical features — edges and textures in early layers, parts and objects in deeper layers — directly from labeled pixel data, without requiring hand-engineered features. With thousands of labeled cat/dog images, a CNN (trained from scratch or, more efficiently given the modest dataset size, fine-tuned from a pretrained backbone via transfer learning) is the practical, industry-standard choice.

Decision Trees (A) can technically be applied to hand-engineered image features, but they scale poorly to raw high-dimensional pixel input and cannot learn spatial hierarchies the way convolutional architectures do — they're a reasonable choice for structured/tabular data, not raw image classification. K-Means Clustering (B) is unsupervised and would group images by similarity without using the provided labels at all, making it unsuitable for a labeled classification task where you already have ground-truth cat/dog annotations to learn from directly. Linear Regression (D) predicts continuous numeric outputs and is not designed for categorical classification; even logistic regression, its classification-oriented cousin, would struggle on raw pixels without the feature-learning capacity a CNN provides.

This mirrors a nearly identical question earlier in this set (10,000 cats/dogs/birds) — expect the exam to test this CNN-for-images association repeatedly, sometimes with different distractor combinations.

Pruning removes weights, neurons, or entire filters/channels that contribute minimally to model output — identified via magnitude-based criteria (removing near-zero weights), sensitivity analysis, or more sophisticated importance scoring — producing a smaller, sparser model that requires fewer computations and less memory at inference time while aiming to preserve accuracy through careful selection and, often, a fine-tuning step after pruning to recover any lost performance. Structured pruning (removing entire filters/channels) yields hardware-friendly speedups on standard accelerators, while unstructured pruning (removing individual weights) achieves higher sparsity ratios but requires specialized sparse-computation hardware or libraries to realize actual speed gains.

The remaining options move in the wrong direction or address a different concern: adding more convolutional filters (B) increases model capacity and parameter count, which increases computational cost, the opposite of the stated goal. Increasing batch size (D) affects training throughput and memory usage per step but does not reduce the per-sample computational cost of inference — a larger batch does more total work, not less per inference call, and batch size at inference is often constrained by latency requirements rather than optimization goals. Option C's premise — selectively replacing activation functions with simpler ones in "some neurons" — is not a standard or well-defined optimization technique; activation function choice is typically uniform within a layer and driven by training dynamics, not a piecemeal inference-cost lever.

Unlike recurrent architectures, which process tokens sequentially and thereby inherently encode order through the sequence of computation, the transformer's self-attention mechanism processes all tokens in parallel and is permutation-invariant by construction — attention scores between tokens do not inherently depend on their position in the sequence. Positional encoding solves this by injecting explicit information about each token's position into its input representation, typically by adding a positional vector (computed via fixed sinusoidal functions in the original "Attention Is All You Need" formulation, or learned as trainable embeddings in many modern variants) to the token's embedding before it enters the attention layers. Without this, "the cat sat on the mat" and "the mat sat on the cat" would be indistinguishable to the self-attention mechanism, since the same set of token embeddings would be processed identically regardless of order.

Semantic meaning (option A) is the role of the token embeddings themselves, learned separately from positional information — the two are combined (typically summed) but serve distinct purposes. Positional encoding does not remove information (C); it adds it. And while attention weights do effectively encode a learned notion of token importance relative to a query (option D), that importance-weighting mechanism is a separate, downstream function of the attention layers, not the role of positional encoding itself, which only supplies order information as an input feature.

In GPU computing, "kernel" refers to a compiled function launched on the GPU to execute a specific operation (e.g., a matrix multiplication or an activation function). Executing a sequence of such operations naively launches a separate kernel for each one, incurring per-launch overhead (kernel launch latency) and requiring intermediate results to be written to and read back from GPU global memory between each operation — both of which waste time and memory bandwidth relative to the actual compute being performed. Kernel fusion combines multiple sequential operations into a single compiled kernel, so intermediate results stay in fast on-chip registers or shared memory rather than round-tripping through global memory, and only one kernel launch is needed instead of several. This reduces both launch overhead and memory-bandwidth-bound latency, which is often the dominant bottleneck for smaller operations on modern GPUs. NVIDIA's TensorRT applies kernel fusion (alongside quantization and precision calibration) as one of its core inference-optimization techniques, commonly fusing operations like convolution + bias + activation into a single kernel.

Option A describes pruning, a distinct technique covered elsewhere in this domain — reducing parameter count, not combining kernel launches. Option C misapplies "kernel" in the CNN-filter sense rather than the GPU-execution sense the question is asking about, and layering more kernels would not describe fusion at all. Option D conflates kernel functions (as in kernel methods for SVMs) with GPU kernels — an unrelated use of the same term.

CPU-GPU data transfer over the PCIe (or NVLink) bus is frequently a throughput bottleneck in ML pipelines, particularly when small, frequent transfers dominate rather than large batched ones — each transfer incurs fixed overhead independent of data size, so many small transfers waste a disproportionate amount of time on overhead rather than useful data movement. Memory pooling techniques — pre-allocating and reusing pinned (page-locked) host memory buffers rather than repeatedly allocating and freeing memory for each transfer — reduce this overhead and enable faster, more predictable DMA transfers between host and device. Related software-level techniques include using CUDA streams to overlap data transfer with computation (so the GPU keeps computing while the next batch transfers in the background), and batching transfers to amortize fixed per-transfer overhead across more data.

Options A, B, and D each propose hardware upgrades that address a different bottleneck than the one described: increasing CPU clock speed (A) or core count (B) improves CPU-side compute throughput, not the data-transfer bandwidth or latency between CPU and GPU specifically. Upgrading the GPU (D) increases GPU compute capability but does nothing to address a PCIe/interconnect bandwidth limitation — a faster GPU sitting idle waiting for data across the same bottlenecked bus would not see meaningfully improved end-to-end throughput. The question specifically asks about *throughput between* CPU and GPU, which points to interconnect/transfer-management optimization rather than raw compute upgrades on either side.

Modality alignment is the process of establishing correspondence between semantically related elements across different data types — for example, matching a spoken word to its corresponding lip movement in video, or a caption phrase to the image region it describes. It is distinct from fusion (combining modalities into a joint representation) and from data integration (option B, which describes ingestion rather than alignment). Alignment can be explicit, as in dynamic time warping for audio-text synchronization, or implicit, learned end-to-end through attention mechanisms such as cross-attention in transformer architectures. CLIP's contrastive objective is itself a form of learned alignment: it pulls matching image-text pairs together in embedding space while pushing non-matching pairs apart, producing an aligned shared representation without explicit temporal correspondence. Alignment quality directly affects downstream fusion: poorly aligned modalities introduce noise that fusion layers cannot fully compensate for, which is why alignment is typically treated as a prerequisite step, not an afterthought.

Option A describes model reuse for custom tasks (closer to transfer learning), while C describes handling missing modality data, a separate robustness concern. Neither captures the correspondence-building nature of alignment. On the NCA-GENM exam, expect alignment questions to be paired with fusion and co-embedding concepts.

Bias evaluation for facial recognition centers on measuring whether the model's accuracy — true positive rate, false positive rate, false match rate — is consistent across demographic subgroups (race, gender, age), rather than assuming a single aggregate accuracy figure represents performance fairly for all groups. This concern is well grounded empirically: independent benchmarking, including NIST's Face Recognition Vendor Test studies, has repeatedly documented substantial accuracy disparities across demographic groups in widely deployed facial recognition systems, with error rates for some subgroups measured many times higher than for others — a direct consequence of training data underrepresentation and the representativeness-bias issue covered elsewhere in this domain.

Processing speed (A) is a performance/latency engineering concern, not a bias or fairness concern — a model could process all demographic groups at identical speed while still exhibiting severe accuracy disparities between them. Facial expression recognition capability (C) addresses a different task dimension (emotion/expression classification) than the identity-recognition bias question being asked. Operating system compatibility (D) is a software-deployment/engineering concern entirely unrelated to model fairness.

Subgroup accuracy disparities in facial recognition carry serious real-world consequences — misidentification risk in law enforcement or access-control contexts — which is why disaggregated (per-subgroup) evaluation, not just aggregate accuracy, is considered a baseline requirement under Trustworthy AI bias auditing practice.

Valid model evaluation requires measuring performance on held-out data the model has not seen during training — this is the foundational principle behind train/validation/test splits and cross-validation, and it exists specifically to estimate how the model will generalize to genuinely new data, rather than how well it memorized patterns specific to its training set. Option B correctly describes this: sampling from a portion of the dataset explicitly excluded from training and calculating accuracy on it.

Options C and D both violate this principle by evaluating on the training set itself, which produces optimistically biased performance estimates: a model — particularly an overparameterized deep learning model — can achieve very high training accuracy or very low training loss simply by memorizing training examples (overfitting) without that performance transferring to new data at all. Reporting training-set accuracy (C) or training-set loss (D) as an evaluation of "performance" conflates fit-to-training-data with generalization, the central failure mode that held-out evaluation is designed to catch. Option A describes a qualitative, subjective process — interviewing developers — that provides no quantitative, reproducible performance measurement and is not a recognized model evaluation methodology.

This principle extends further in rigorous experimentation: a validation set used repeatedly for hyperparameter tuning can itself become "leaked" through repeated selection, which is why a separate, untouched test set is typically reserved for final, one-time performance reporting.

Batch size has a direct, proportional relationship with VRAM consumption during both training and inference: each sample in a batch requires its own memory allocation for input tensors, intermediate activations at every layer, and output tensors, all of which must reside in GPU memory simultaneously while the batch is being processed. Decreasing the batch size means fewer samples occupy memory concurrently, directly reducing peak VRAM consumption — this is precisely why reducing batch size is one of the first, most common remedies when a model run fails with an out-of-memory (OOM) error on a GPU with limited VRAM.

Option C states the inverse of the correct relationship and is a genuinely important misconception to correct: increasing batch size increases VRAM consumption, not decreases it — parallelism across the batch means more simultaneous memory occupancy, not less. It's true that larger batches improve GPU compute *utilization* and *throughput* (better amortizing fixed kernel-launch overhead and better exploiting parallel hardware) up to the point VRAM allows, but that throughput benefit is a separate effect from, and does not reduce, memory consumption. Options A and B both incorrectly claim batch size is memory-neutral, when it is in fact one of the most direct, easily controlled levers for managing VRAM usage — alongside model precision (quantization, mixed precision) and activation checkpointing, covered in the Performance Optimization domain elsewhere in this set.

Option D captures the general, task-agnostic definition of contrastive learning: given pairs of inputs labeled as similar (positive pairs) or dissimilar (negative pairs), the training objective pulls positive pairs' representations closer together in embedding space while pushing negative pairs' representations further apart — typically implemented via losses like InfoNCE, triplet loss, or contrastive loss with a margin. This is the mechanism underlying self-supervised representation learning broadly, not only in multimodal settings.

Option E correctly applies this general principle to the multimodal case: for the *same* object described across modalities (e.g., an image of a dog and the caption "a dog"), the model should increase representational similarity, since they refer to the same underlying entity; for *different* objects across modalities (an image of a dog paired with the caption "a cat"), the model should decrease similarity. This is exactly CLIP's training objective, tested elsewhere in this set — matching image-text pairs pulled together, mismatched pairs pushed apart.

Options B and C both invert this relationship — B increases similarity for *different* objects and decreases it for *same* objects, and C similarly reverses the correct direction — describing the opposite of what contrastive learning is designed to achieve, making both clearly incorrect distractors that test careful reading of directionality. Option A is too vague and mischaracterizes contrastive learning as a generative/manipulation technique rather than a representation-learning objective.

Late fusion trains separate, independent models for each modality — each producing its own prediction, score, or decision — and combines those outputs only at the final decision stage, typically via averaging, weighted voting, a learned meta-classifier (stacking), or simple rule-based aggregation. This is the direct counterpart to early fusion (combination at the raw/feature input level, tested elsewhere in this set) and to intermediate/hybrid fusion (combination at one or more mid-network representation levels).

Late fusion's key practical advantage is modularity and robustness: because each modality's model operates independently until the final combination step, a missing or corrupted modality at inference time degrades performance gracefully rather than catastrophically — the surviving modalities' models can still contribute a prediction. It also allows each modality-specific model to be trained, validated, and even updated independently, which simplifies engineering in production systems. Its main disadvantage is that it cannot capture fine-grained, low-level cross-modal interactions, since by the time information reaches the fusion point, each modality has already been reduced to a high-level decision.

Options C and D describe feature-level and preprocessing-level combination respectively — both inconsistent with "late" in the fusion terminology, which specifically denotes the decision/output stage. Option B describes a training-schedule concept unrelated to fusion architecture.