NVIDIA Updated NCA-GENM Exam Questions and Answers by margo

The attention mechanism computes a set of weights over the tokens in the input (or context) sequence for each step of processing, reflecting how relevant each input token is to the computation currently being performed — for instance, how relevant each word in a source sentence is to correctly translating a given target word, or how relevant each prior token is to predicting the next one in an autoregressive model. Mechanically, this is computed via query, key, and value projections: a query (representing the current focus) is compared against keys (representing each input token) to produce attention scores, which are normalized (typically via softmax) into weights and used to compute a weighted sum over the corresponding values — allowing the model to dynamically focus more on relevant tokens and less on irrelevant ones, rather than treating all input tokens with equal importance.

Option D describes positional encoding's role (covered directly in an earlier question in this set) — capturing token order — which is a distinct mechanism from attention; attention operates on token *content and relevance*, while positional encoding separately supplies *order* information as an input feature, since self-attention itself is permutation-invariant without it. Option A misdirects the weighting toward the output sequence specifically, when attention weights are computed primarily over the input/context tokens being attended to. Option C describes the decoding/generation procedure (autoregressive sampling), not attention's mechanism.

Zero-shot learning describes a model's capacity to correctly perform a task it was never explicitly trained or fine-tuned on, relying instead on knowledge and generalization ability acquired during broader pretraining. For LLMs, this typically means the model is given only a natural-language instruction or prompt describing the task — with no task-specific labeled examples provided in the prompt at all — and is expected to produce a reasonable response by generalizing from its pretraining. This is directly analogous to CLIP's zero-shot image classification (covered elsewhere in this set): a model trained broadly can be applied to a new, specific task purely through how the task is described to it, without additional task-specific training.

Option A is a subtly incorrect paraphrase: zero-shot learning is not about the model "learning from zero examples" during a training process — it's about applying a model that was never trained for the specific task at all, at inference time. The model isn't learning in the zero-shot moment; it's generalizing from prior training. Option B misapplies "zero" to training time rather than to task-specific examples — an unrelated concept. Option C directly contradicts the definition; zero-shot specifically refers to performance *without* task-specific training, not performance *after* extensive training on that task.

Zero-shot is typically contrasted with few-shot learning, where a small number of task-specific examples are included in the prompt to guide the model's response without updating its weights.

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.

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.