NVIDIA NCA-GENM Practice Exam Questions & Answers

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.

Reviewer note: Marked answer (C) is factually incorrect --- ReLU is well suited to deep networks and specifically helps mitigate vanishing gradients. The genuine, well-established disadvantage is the 'dying ReLU' problem (D).

I need to flag this one as well: the marked answer (C) does not hold up, and stating otherwise would misrepresent a fairly foundational deep learning fact. ReLU (Rectified Linear Unit, f(x) = max(0, x)) is, if anything, particularly well suited to deep neural networks --- it was widely adopted specifically *because* it mitigates the vanishing gradient problem that plagued earlier activation functions like sigmoid and tanh in deep architectures: ReLU's gradient is a constant 1 for all positive inputs, rather than the saturating, near-zero gradients that sigmoid/tanh produce for large-magnitude inputs, which allows gradients to propagate more effectively through many layers.

The genuine, well-documented disadvantage of ReLU is option D: the 'dying ReLU' problem. Because ReLU's gradient is exactly zero for any negative input, a neuron whose weighted input becomes consistently negative --- often due to a large negative gradient update or an unfavorable initialization --- will always output zero and will never receive a gradient large enough to recover, effectively 'dying' and no longer contributing to learning. This is a real, practically significant issue that motivated variants like Leaky ReLU, Parametric ReLU (PReLU), and ELU, which allow a small non-zero gradient for negative inputs specifically to prevent neurons from dying.

Options A and B are also factually incorrect characterizations of ReLU --- it is computationally cheap (a simple thresholding operation, part of its original appeal over sigmoid/tanh) and it specifically helps *avoid* vanishing gradients rather than causing them.

In a denoising diffusion probabilistic model (DDPM), the U-Net serves as the noise-prediction network at the core of the iterative generation process: at each reverse-diffusion timestep, the U-Net takes the current noisy image (and typically a timestep embedding, plus conditioning information like a CLIP text embedding in text-to-image models) as input and predicts the noise component present at that step. Subtracting this predicted noise incrementally, over many timesteps starting from pure Gaussian noise, progressively denoises the input into a coherent image --- the mechanism by which DDPMs generate new images from pure noise. U-Net's architecture --- a contracting encoder path paired with an expanding decoder path, connected by skip connections at matching resolutions --- is well suited to this role because the skip connections preserve fine-grained spatial detail that would otherwise be lost through the network's downsampling bottleneck, which matters for producing sharp, high-fidelity denoised output at each step.

Options B, C, and D describe discriminative tasks --- classification, detection, and segmentation --- that describe *other* legitimate applications of U-Net-style architectures (originally developed for biomedical image segmentation) but do not describe its function specifically *within* the diffusion generative process. Within a DDPM pipeline specifically, U-Net's role is generative noise prediction supporting image synthesis from noise, not classification or detection of any kind.

Encoder-only transformer architectures (BERT and its derivatives being the canonical examples) process an entire input sequence bidirectionally, attending to both left and right context simultaneously, and output contextualized representations for each token --- well suited to understanding tasks that require a rich representation of input meaning without generating new sequential output. Semantic analysis --- including sentiment classification, named entity recognition, semantic similarity, and text classification more broadly --- is a natural fit, typically implemented by taking the encoder's output representation (often a special [CLS] token embedding) and feeding it to a lightweight classification head.

The other options require architectures the encoder-only design is not built for: generating code (B) and open-ended text generation generally require autoregressive, causal (decoder-only or encoder-decoder) architectures that predict tokens sequentially, since encoder-only models produce a fixed set of contextualized representations rather than generating novel token sequences left-to-right. Image generation (C) requires an entirely different model family (diffusion models, GANs, or autoregressive image models), unrelated to text-encoder architectures. Speech recognition (D) requires an audio-processing pipeline --- typically a CTC-based or encoder-decoder acoustic model operating on spectrogram or waveform input --- not a text-only transformer encoder.

Within Trustworthy AI frameworks, 'Certification' is best understood as the formal verification process confirming that an AI system meets defined standards of fitness-for-purpose --- whether those standards are set by regulatory bodies, industry consortia, or internal governance frameworks --- for the specific context in which the system will be deployed. This is distinct from, though related to, the broader Trustworthy AI principles of ethics (option A), transparency (option B), and legal compliance (option C): certification is the *verification mechanism* that attests a system satisfies applicable standards, rather than being one of those underlying values itself.

The distinction between C and D is subtle and worth being precise about: C describes compliance as an obligation ('must follow laws and regulations'), while D describes certification as a verification activity ('confirming fitness according to standards') --- certification is the audit/attestation process, and compliance is one of the things that process may confirm. A system can be legally compliant without having undergone formal certification, and certification processes often assess criteria broader than legal compliance alone, including performance benchmarks, robustness testing, and domain-appropriate validation (e.g., clinical validation standards for a medical imaging model).

In practice, certification connects Trustworthy AI to concrete deployment gates: a healthcare AI model, for instance, may require certification against medical device standards before clinical use --- the verification step, not merely the legal requirement, is the 'Certification' principle's substance.

A/B testing in an ML engineering context is a controlled experimental methodology where two (or more) model variants --- for example, a current production model (A) and a candidate replacement (B) --- are deployed simultaneously to randomly assigned, statistically comparable segments of live traffic, and their real-world performance is compared on business or task-relevant metrics (conversion rate, click-through rate, task accuracy, latency-adjusted engagement). This provides causal evidence of which model performs better under actual production conditions, which offline evaluation on static held-out datasets cannot fully capture, since production data distributions shift and downstream user behavior interacts with model outputs in ways offline metrics miss.

Option A narrows A/B testing incorrectly to UI changes alone; while A/B testing originated in and remains common for UI/UX experimentation, its application in ML engineering explicitly extends to comparing model versions, algorithms, and feature sets --- not just interface elements. Option B misattributes a distinct methodology (systematic hyperparameter search, covered in the previous question) to A/B testing, which evaluates already-trained model variants rather than searching a hyperparameter space. Option C is simply incorrect --- A/B testing is a cornerstone of responsible ML deployment and MLOps practice, gating rollout decisions before full production release.

In the context described --- comparing the performance of different AI models against each other --- the purpose of evaluation is to systematically measure each candidate model's performance on relevant metrics (accuracy, F1, WER, BLEU, latency, or task-specific measures) using held-out data, in order to determine which architecture, configuration, or training approach performs best for the target task. This is the immediate, operational purpose of the evaluation experiment being described: comparative performance measurement that informs model-selection decisions.

The other options describe legitimate but distinct concerns that belong to different domains within a full AI development lifecycle rather than to the 'evaluate performance of different models' activity specifically described in the question: ethical implications

(B) fall under Trustworthy AI governance --- fairness audits, bias assessments, and impact reviews --- conducted alongside, not as a substitute for, performance evaluation. Studying impact on human behavior (C) belongs to human-computer interaction or longitudinal deployment studies, a separate research activity from a controlled model-comparison experiment. Cost-effectiveness analysis (D) is a business/engineering consideration weighing performance gains against compute, infrastructure, and development cost --- relevant to deployment decisions, but not what 'evaluating model performance' itself measures.

Rigorous evaluation in this context requires a held-out test set the models were not trained or tuned on, appropriate metric selection for the task, and often statistical significance testing when comparing close results.