NCA-GENM · Domain 5 of 7

NCA-GENM Domain 5: Performance Optimization

Making multimodal models faster, cheaper and more accurate: mixed precision, quantization, pruning, TensorRT, hyperparameter tuning, transfer learning and training efficiency on NVIDIA GPUs.

Exam weight
10%
Official objectives
4
Estimated questions estimate
~5
Suggested study time estimate
6–9 hrs

About 10 min read Reviewed October 2026

Overview

Domain 5 has four objectives about making models efficient and accurate. They are enhancing computational efficiency and output accuracy, optimizing performance including hyperparameter tuning, multimodal-specific transfer learning (an objective that also appears in Domain 1), and assisting with model training and training optimization.

The study guide readings set the scope: mixed precision training, quantization basics, neural network pruning, energy efficiency, and Connectionist Temporal Classification, the alignment-free loss used in speech recognition. Expect questions on FP16 and BF16 with Tensor Cores, INT8 inference and calibration, structured versus unstructured pruning, TensorRT optimization, learning rate and batch size tuning, gradient accumulation and checkpointing, and diffusion inference speedups such as fewer sampling steps.

How it's tested

Questions describe a model that is too slow, too large, too costly or not accurate enough, and ask which optimization helps. Pay attention to whether the bottleneck is training or inference, memory or compute, and whether some accuracy loss is acceptable.

  • Match the bottleneck

    A memory, latency or throughput limit is described, and you choose the optimization that targets it.

  • Tune the run

    Training behavior is described, and you choose the hyperparameter change, such as learning rate, batch size or schedule.

  • Speed up generation

    Slow diffusion or vision-language inference is described, and you pick a technique such as fewer steps, quantization or TensorRT.

Reasoning it through

A team runs out of GPU memory training a vision-language model at batch size 64, but needs that effective batch size for stable contrastive learning. Lowering the batch size changes training dynamics, and buying hardware is not an option. Gradient accumulation over four steps of 16, combined with mixed precision, keeps the effective batch at 64 while fitting in memory.

Objectives 4

Official objectives from the NVIDIA outline, in outline order.

5.1 Enhance computational efficiency and improve the accuracy of outputs in AI modelsMixed precision, quantization, pruning and distillation.
What it means
This objective covers techniques that cut compute, memory and energy while keeping, or sometimes improving, output quality.
What to understand
Mixed precision uses FP16 or BF16 on Tensor Cores with FP32 master weights and loss scaling. Quantization stores weights and activations in INT8 or FP8, using post-training calibration or quantization-aware training. Pruning removes weights; structured pruning removes whole channels and speeds up hardware more reliably. Distillation trains a small student to imitate a large teacher. TensorRT fuses layers and selects fast kernels.
How it shows up
A cost or speed problem is described, and you choose the technique and its trade-off.
Common confusion
Mixing up quantization (lower numeric precision) with pruning (removing weights).
5.2 Optimize the performance of AI models, including tuning hyperparametersLearning rate, batch size, schedules and search methods.
What it means
Hyperparameters are settings chosen before training, such as learning rate, batch size, weight decay and number of epochs. Tuning them can change accuracy more than architecture changes.
What to understand
Learning rate is usually the most sensitive setting; schedules such as warmup and cosine decay help. Larger batches often need a scaled learning rate. Search methods include grid search, random search, which is usually more efficient, and Bayesian optimization. For diffusion, inference settings such as guidance scale and step count also act as tunable parameters. Tune on validation data.
How it shows up
A training symptom or search budget is described, and you choose the tuning change or method.
Common confusion
Believing grid search is always best; random search often finds good values faster in high dimensions.
5.3 Develop content for multimodal-specific transfer learningUsing pretrained encoders to save compute and data.
What it means
From a performance view, transfer learning is the biggest efficiency win: reusing pretrained encoders avoids training multimodal models from scratch.
What to understand
Freezing a vision encoder removes its gradients and optimizer state, cutting memory and time. Parameter-efficient methods such as LoRA and adapters train a tiny fraction of weights. Fine-tuning a diffusion model for a new style with LoRA or DreamBooth needs far less compute than pretraining. Choose the smallest adaptation that meets accuracy targets.
How it shows up
A compute or data limit is described, and you choose the transfer approach that fits it.
Common confusion
Assuming transfer learning only helps accuracy; it also greatly reduces training cost.
5.4 Assist in model training and training optimization under the supervision of a senior team memberMemory and throughput tricks during training.
What it means
Associates help run training jobs efficiently: fitting models in GPU memory, keeping GPUs busy and checkpointing progress.
What to understand
Gradient accumulation simulates large batches on limited memory. Activation (gradient) checkpointing trades extra compute for lower memory. Data loading must keep up with the GPU, using parallel workers or NVIDIA DALI. Distributed data parallel spreads batches across GPUs. Early stopping saves compute. For speech models, CTC loss aligns audio frames to text without frame-level labels.
How it shows up
A training bottleneck is described, and you choose the training optimization that relieves it.
Common confusion
Treating activation checkpointing as saving model files; it recomputes activations to save memory.

High-yield concepts

The terms, rules and formulas this domain turns into questions most often.

  • Mixed precision (AMP)

    Train in FP16 or BF16 with FP32 master weights.

    Remember
    Uses Tensor Cores; needs loss scaling for FP16.
    Tested as
    Training speed and memory.
    Trap
    Thinking it means training entirely in FP16.

  • BF16 vs. FP16

    BF16 keeps FP32's exponent range with less mantissa precision.

    Remember
    BF16 rarely needs loss scaling.
    Tested as
    Precision choice questions.
    Trap
    Assuming they behave identically.

  • Post-training quantization

    Convert a trained model to INT8 or FP8 using calibration data.

    Remember
    Fast to apply, small accuracy cost.
    Tested as
    Inference optimization.
    Trap
    Skipping calibration.

  • Quantization-aware training

    Simulate low precision during training.

    Remember
    Recovers accuracy lost by PTQ.
    Tested as
    Accuracy-preserving quantization.
    Trap
    Confusing it with mixed precision.

  • Structured pruning

    Removes whole channels, heads or layers.

    Remember
    Gives real speedups on standard hardware.
    Tested as
    Model compression questions.
    Trap
    Expecting unstructured sparsity to speed up automatically.

  • Knowledge distillation

    A small student learns from a large teacher.

    Remember
    Shrinks models while keeping quality.
    Tested as
    Efficiency questions.
    Trap
    Confusing it with transfer learning.

  • TensorRT

    NVIDIA SDK that optimizes trained models for inference.

    Remember
    Layer fusion, precision calibration, kernel tuning.
    Tested as
    Inference speed questions.
    Trap
    Using it to train models.

  • Gradient accumulation

    Sum gradients over micro-batches before updating.

    Remember
    Simulates a larger batch in less memory.
    Tested as
    Memory-limited training.
    Trap
    Thinking it speeds up training.

  • Activation checkpointing

    Recompute activations in the backward pass instead of storing them.

    Remember
    Saves memory, costs compute.
    Tested as
    Memory-limited training.
    Trap
    Confusing it with saving checkpoints to disk.

  • Random vs. grid search

    Random sampling of settings versus exhaustive grid.

    Remember
    Random is usually more efficient.
    Tested as
    Tuning strategy.
    Trap
    Assuming grid search is always best.

  • Fewer diffusion steps

    Faster samplers such as DDIM reduce denoising iterations.

    Remember
    Big inference speedup with modest quality cost.
    Tested as
    Generation speed questions.
    Trap
    Quantizing first when steps dominate cost.

  • CTC loss

    Aligns audio frames to text without frame labels.

    Remember
    Common in speech recognition training.
    Tested as
    Speech model training.
    Trap
    Confusing it with contrastive loss.

Side by side

Concepts candidates mix up, compared on the point that decides the answer.

Model compression techniques

ConceptMeaningKey differenceCommon trap
Quantization Lower numeric precision of weights and activations Same structure, smaller numbers Calling it pruning
Pruning Remove weights or structures Fewer parameters Expecting speedups from unstructured sparsity
Distillation Train a smaller student from a teacher New, smaller architecture Confusing it with fine-tuning

Memory-saving training techniques

ConceptMeaningKey differenceCommon trap
Mixed precision Lower-precision math with FP32 master weights Saves memory and speeds compute Forgetting loss scaling in FP16
Gradient accumulation Update after several micro-batches Larger effective batch Expecting faster training
Activation checkpointing Recompute activations on backward pass Trades compute for memory Confusing with disk checkpoints
Freezing encoders Skip gradients for pretrained parts Removes optimizer state too Freezing parts that need adaptation

Hyperparameter search

ConceptMeaningKey differenceCommon trap
Grid search Try every combination on a grid Exhaustive, expensive Wasting budget on unimportant settings
Random search Sample combinations randomly Efficient in high dimensions Assuming it is less effective
Bayesian optimization Model results to choose next trials Fewest trials for expensive runs Overhead for tiny searches

Exam traps

Each trap is an answer that looks right. Learn the clue that should change your mind.

  1. Smaller batch fixes memory

    What candidates pick
    Cut batch size when contrastive training runs out of memory.
    Why it looks right
    It is the simplest change.
    Why it's wrong
    Contrastive learning depends on many in-batch negatives; gradient accumulation alone cannot restore them, so mixed precision and checkpointing are preferred.

    Clue to watch for The model relies on large batches, such as CLIP-style training.

  2. Unstructured pruning speeds everything

    What candidates pick
    Expect random weight pruning to cut latency directly.
    Why it looks right
    Fewer weights sounds faster.
    Why it's wrong
    Scattered zeros often run at dense speed on standard kernels; structured pruning or supported sparsity patterns are needed.

    Clue to watch for The goal is lower latency on standard GPUs.

  3. Mixed precision equals FP16 only

    What candidates pick
    Describe mixed precision as converting all weights to FP16.
    Why it looks right
    The name suggests lower precision.
    Why it's wrong
    Mixed precision keeps FP32 master weights and uses lower precision for most math, with loss scaling to avoid underflow.

    Clue to watch for The option mentions master weights or loss scaling.

  4. Grid search is thorough

    What candidates pick
    Use grid search over six hyperparameters with a small budget.
    Why it looks right
    It feels systematic.
    Why it's wrong
    Grid search grows exponentially; random or Bayesian search covers important settings with fewer trials.

    Clue to watch for Many hyperparameters and limited compute.

  5. Quantize the sampler away

    What candidates pick
    Quantize a diffusion model first to fix slow image generation.
    Why it looks right
    Quantization is a well-known speedup.
    Why it's wrong
    Diffusion latency is dominated by the number of denoising steps; a faster sampler with fewer steps often gives the largest gain.

    Clue to watch for The model runs many sampling steps per image.

Answer framework

For a Domain 5 scenario, identify the bottleneck before picking an optimization.

  1. Decide whether the problem is in training or inference, because techniques like gradient accumulation help training while TensorRT and quantization target deployment.
  2. Identify the constraint: GPU memory, compute time, latency, throughput, energy or accuracy, and note whether any accuracy loss is acceptable.
  3. For memory limits in training, consider mixed precision, freezing pretrained encoders, activation checkpointing and gradient accumulation in that rough order.
  4. For inference speed, check algorithmic waste first, such as diffusion step count, then apply TensorRT, quantization with calibration, structured pruning or distillation.
  5. For accuracy, tune learning rate and schedule first on validation data, using random or Bayesian search, and reuse pretrained weights through transfer learning.

Practice question

A team deploys a vision-language model on NVIDIA GPUs and must cut inference latency and memory use. They can accept a very small accuracy drop but cannot retrain the model. Which approach fits best?

Want more like this? The NCA-GENM practice test has questions for every domain.

Checklist

0 of 11

Tick each one you can do without notes. Your ticks stay in this browser.

Study strategy

Split this domain into two lists, training optimizations and inference optimizations, because many questions hinge on that distinction. Under training, put mixed precision, gradient accumulation, activation checkpointing, freezing, data loading and distributed training. Under inference, put TensorRT, quantization, pruning, distillation and fewer diffusion steps.

Next, for each technique write what it saves (memory, compute, latency), what it costs, and whether it needs retraining. That table answers most scenario questions directly. Read the study guide's mixed precision and quantization articles, then the pruning reading, paying attention to structured versus unstructured approaches.

Then cover hyperparameter tuning: learning rate first, then batch size and schedules, and the trade-offs among search methods. If you have GPU access, enable automatic mixed precision on a small PyTorch model and watch memory drop. Close with the CTC reading for speech training context and a set of timed practice questions. Review every miss by asking whether you confused a training technique with an inference technique.

FAQ

How many NCA-GENM questions come from Performance Optimization?

Performance Optimization is 10% of the exam, so plan for about five questions spread over four objectives.

Do I need to know TensorRT in depth?

No. Know that it optimizes trained models for inference through layer fusion, precision calibration and kernel selection, and when to use it.

What is the difference between FP16 and BF16?

Both use 16 bits. BF16 keeps FP32's exponent range, so it rarely needs loss scaling, while FP16 has more precision but a narrower range.

Why does transfer learning appear in two domains?

NVIDIA lists the same objective under Core Machine Learning and Performance Optimization. Here the emphasis is on saving compute and data.

Is CTC loss multimodal?

It is used in speech recognition to align audio frames with text, and the study guide includes it among this domain's readings.

Which hyperparameter matters most?

Learning rate is usually the most sensitive, followed by batch size and the learning-rate schedule.

Other Artificial Intelligence & Machine Learning certifications

Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.

Test your Domain 5 knowledge

You have reviewed mixed precision, quantization, pruning, TensorRT, hyperparameter tuning and training efficiency. See whether you can match each bottleneck to its fix quickly.

Take the NCA-GENM practice test Check your NCA-GENM readiness

Keep going