The NCA-GENM blueprint is split across 7 domains. Weights are the official share of the exam; see the official exam guide for the authoritative breakdown.
What you must be able to do. Read a generation task and name the right mechanism: the transformer step that produces text, the diffusion step that improves an image, or the embedding change that steers output.
In one sentenceThe largest domain: how transformers generate text, how diffusion refines images from noise, and how embeddings steer and are tuned for better results.
Recall check: answer these from memory first
- Walk through what a transformer does to generate text, from tokens in to the next token out, naming the role of attention.
- Describe diffusion image generation as a process: where does it start, and what does each denoising step do?
- How would you tell whether a change to your context embeddings actually improved the generated image, rather than just assuming it did?
What it tests. The largest domain. It covers how transformer-based large language models manipulate, analyse, and generate text, how denoising diffusion processes improve image quality, and how context embeddings steer image output. It also tests how you test and refine embeddings to get better results, so it spans both the text and image sides of generation at a working level.
How to study it. Spend the most time here because it carries the most marks. Get the transformer story straight end to end: tokens in, attention over context, next-token prediction out. Then learn diffusion as the mirror image: start from noise and denoise step by step towards an image. Tie embeddings to control, so you can explain how a context embedding nudges what an image generator produces and how you would test whether a change to the embeddings actually helped.
Easy to confuse
- Transformers (text generation) versus diffusion (image generation). A transformer predicts the next token over a sequence and builds text forward; diffusion starts from random noise and removes it step by step to reveal an image. If the task is sequence prediction it is the transformer; if it is denoising towards a picture it is diffusion.
- Controlling output with embeddings versus refining the embeddings themselves. Controlling output uses an existing context embedding to steer one generation; refining embeddings changes the embeddings and measures whether results improved across runs. One is steering, the other is optimisation you have to test.
- Token embeddings versus context embeddings. A token embedding represents a single unit in isolation; a context embedding represents meaning shaped by surrounding input and is what steers image output. The exam leans on the context-aware one for generation control.
Worked example from the NCA-GENM bank
lock_openFree sampleExperimentationmedium
A diffusion model is conditioned on a text prompt by injecting CLIP text embeddings at multiple layers of the U-Net denoiser. Which mechanism directly uses those embeddings to steer the spatial features of the latent during denoising?
- ACross-attention layers in the U-Net, where queries come from the spatial feature map and keys and values come from the projected text embeddingscheck_circle Correct
- BSelf-attention within the U-Net residual blocks, which relates every spatial position to every other spatial position in the same layer
- CClassifier-free guidance, which blends two separate forward passes through the denoiser at inference time to amplify prompt alignment
- DAdaptive layer normalisation, which modulates feature statistics using a global pooled representation of the text embedding
Identify the architectural mechanism by which CLIP text embeddings exert spatial control over image generation in diffusion models. In latent diffusion models such as Stable Diffusion, the U-Net denoiser contains cross-attention blocks at multiple resolutions. The spatial feature map provides queries while the CLIP text token embeddings are linearly projected to keys and values. Each spatial position can attend to whichever text tokens are most relevant, creating a direct, token-level conditioning pathway. Self-attention, adaptive normalisation, and classifier-free guidance each play distinct roles but none directly injects the token-level text representation into the spatial feature map the way cross-attention does.
Why A is correct: Cross-attention is the standard conditioning mechanism in latent diffusion models: spatial queries attend to token-level keys and values derived from the text embedding, allowing every spatial region to be guided by the relevant textual context.
Why B is wrong: Self-attention relates spatial positions to each other within the feature map, not to an external conditioning signal such as a text embedding, so it cannot directly inject the CLIP representation.
Why C is wrong: Classifier-free guidance is a sampling-time weighting strategy that scales the difference between conditional and unconditional predictions; it relies on cross-attention conditioning already being present and is not itself the mechanism that injects the embeddings.
Why D is wrong: Adaptive layer normalisation is used in some architectures such as DiT to inject timestep or class conditioning via scale and shift parameters, but it is not the primary mechanism used to inject token-level CLIP text embeddings in the U-Net backbone.
What you must be able to do. Explain the training and architecture fundamentals the rest of the exam assumes, and pick modality versus agent orchestration for a described task.
In one sentenceThe conceptual backbone: training deep learning models, transformers as the building block of LLMs, data preparation by type, and model fusion.
Recall check: answer these from memory first
- Describe one pass of a training loop and say what loss and gradients each contribute.
- Why does data preparation differ between, say, an image and a block of text before either reaches a network?
- State modality orchestration and agent orchestration in one line each, then give a task that needs each.
What it tests. The second-heaviest domain. It covers fundamental techniques for training deep learning models, how transformers act as the foundational building blocks of modern LLMs, the different data types and how neural networks are prepared for them, and model fusion, including the distinction between modality orchestration and agent orchestration.
How to study it. Treat this as the conceptual backbone the rest of the exam leans on. Be able to describe a training loop, what loss and gradients do, and why data preparation differs by data type. Nail the difference between modality orchestration, which combines signals from different inputs, and agent orchestration, which coordinates separate models or tools. That distinction is easy to confuse under time pressure and is exactly the sort of thing a distractor exploits.
Easy to confuse
- Modality orchestration versus agent orchestration. Modality orchestration combines signals from different input types into one model's reasoning; agent orchestration coordinates separate models or tools to complete a task. One fuses inputs, the other sequences systems, and the exam offers them together precisely to test the line between them.
- Loss versus gradient. Loss is the single number measuring how wrong the current prediction is; the gradient points the way the loss rises fastest for each weight, so training steps the opposite way to bring it down. Loss tells you how bad, the gradient tells you which way to move.
- Model fusion versus orchestration. Fusion combines representations or outputs inside the modelling step; orchestration is the higher-level coordination of components or modalities. Fusion is about merging signal, orchestration is about arranging the pieces around it.
Worked example from the NCA-GENM bank
lock_openFree sampleCore Machine Learning and AI Knowledgemedium
A pipeline ingests 16-bit greyscale medical images and feeds them into a convolutional network. Before training, each pixel value is divided by 65535 so the resulting tensor contains values in the range 0 to 1. What is the primary reason for this operation?
- ATo normalise input values so that large pixel magnitudes do not cause unstable gradients during back-propagation, improving training convergence.check_circle Correct
- BTo reduce the spatial resolution of the image so that fewer parameters are needed in the first convolutional layer.
- CTo convert the integer pixel values into a floating-point representation that is compatible with the network's activation functions and loss computation.
- DTo apply zero-mean standardisation so that each channel has a mean of zero and a standard deviation of one before entering the network.
Explain why pixel-value normalisation is applied to image tensors before neural-network training. Dividing raw pixel values by the maximum representable value maps all inputs to the closed interval 0 to 1. Neural networks trained on unnormalised inputs with very large magnitudes experience large activation values, which produce large loss gradients and can cause weight updates to overshoot, destabilising training. Bounded inputs keep the gradient signal well-conditioned throughout back-propagation, which is the primary purpose of this pre-processing step.
Why A is correct: Scaling inputs to a small, bounded range keeps weight gradients in a workable magnitude, preventing exploding gradients and accelerating convergence - the canonical motivation for input normalisation.
Why B is wrong: Dividing pixel values by a constant does not alter the spatial dimensions of the tensor; downsampling requires pooling or strided convolutions, not scalar division.
Why C is wrong: Casting to float is a necessary step, but the division itself is not required for the cast; the primary motivation is gradient stability from bounded inputs, not merely the numeric type.
Why D is wrong: Dividing by the maximum value scales to the unit interval but does not produce zero-mean output; standardisation requires subtracting the dataset mean and dividing by its standard deviation.
What you must be able to do. Match a cross-modal task to the right bridge or stage: CLIP for text-to-image, ASR and TTS for speech, and the correct fusion point for combining sources.
In one sentenceWorking across modalities in practice: CLIP for text-to-image, ASR and TTS for speech, conversational pipelines, and where each fusion point sits.
Recall check: answer these from memory first
- Explain why CLIP lets a text prompt drive image generation, in terms of a shared embedding space.
- Place early, late, and intermediate fusion in a pipeline by what each one combines.
- In a conversational pipeline, which model turns speech into text and which turns text into speech, and in what order do they sit?
What it tests. Working across modalities in practice: generating images from English text prompts using CLIP, customising and deploying automatic speech recognition and text-to-speech models, building end-to-end conversational AI pipelines, and applying early, late, and intermediate model fusion techniques to combine signals from more than one source.
How to study it. Learn CLIP as the bridge that lets text and images share an embedding space, which is why a text prompt can drive image generation. Map the three fusion points to where they sit in a pipeline: early fusion combines raw inputs, late fusion combines separate model outputs, and intermediate fusion combines internal representations. For speech, know what ASR and TTS each do and where they fit in a conversational pipeline.
Easy to confuse
- Early versus late versus intermediate fusion. Early fusion combines raw inputs before modelling, intermediate fusion combines internal representations partway through, and late fusion combines separate model outputs at the end. The answer hinges on what stage the signals meet, so fix each to its point in the pipeline.
- ASR versus TTS. Automatic speech recognition turns audio into text; text-to-speech turns text into audio. They run at opposite ends of a conversational pipeline, so the scenario's direction of conversion tells you which one it needs.
- CLIP versus a diffusion image generator. CLIP aligns text and images in a shared embedding space so a prompt can be matched to or guide imagery; the diffusion model is what actually synthesises the pixels. CLIP supplies the steering signal, diffusion does the drawing.
Worked example from the NCA-GENM bank
lock_openFree sampleMultimodal Datamedium
A team fine-tunes an NVIDIA Riva ASR pipeline on domain-specific vocabulary but finds the word error rate remains high on rare technical terms even after acoustic model fine-tuning. Which component should they target next to reduce errors on those terms?
- AThe vocoder, because it synthesises output waveforms and controls pronunciation fidelity for technical terms.
- BThe mel spectrogram extractor, because adjusting the filterbank resolution improves how rare phonemes are represented in the feature space.
- CThe beam-search width parameter, because widening the search ensures more candidate tokens are explored per decoding step.
- DThe language model component, because it assigns probabilities to word sequences and can be updated with a custom vocabulary or n-gram model.check_circle Correct
Distinguish the roles of acoustic and language model components in an ASR pipeline and identify the correct component for vocabulary customisation. NVIDIA Riva's ASR stack separates acoustic modelling (mapping audio features to phonemes or subword units) from language modelling (ranking word-sequence hypotheses). When the acoustic model already captures phoneme patterns correctly but rare technical terms are still misrecognised, the bottleneck is the language model's prior over word sequences. Updating the language model with a custom lexicon or domain-adapted n-gram / neural LM directly improves decoding decisions for those terms, which is reflected as a lower word error rate on the target vocabulary.
Why A is wrong: Vocoders are a TTS component that converts mel spectrograms into audio waveforms; they have no role in ASR decoding or vocabulary coverage.
Why B is wrong: Mel spectrogram extraction is a fixed pre-processing step; changing filterbank parameters affects all phonemes equally and does not address vocabulary coverage gaps.
Why C is wrong: Increasing beam width can marginally improve recall of low-probability paths, but it does not introduce domain vocabulary knowledge and has diminishing returns well before fixing a vocabulary-coverage deficit.
Why D is correct: In a hybrid ASR system the language model scores candidate transcriptions; injecting domain vocabulary and phrase probabilities directly reduces substitution errors on rare terms the acoustic model already produces as phoneme sequences.
What you must be able to do. Move from idea to something deployable: generate images from noise, use a deep learning framework, ship conversational AI with Helm, and customise an NVIDIA AI Blueprint.
In one sentenceThe build-and-ship side: image generation from noise, deep learning frameworks, deploying conversational AI with Helm, and customising NVIDIA AI Blueprints.
Recall check: answer these from memory first
- Generating an image from pure noise is which technique from the Experimentation domain, and why are they the same idea?
- What does a Helm chart package and configure, and what runs the result?
- What does an NVIDIA AI Blueprint give you as a starting point, so that your job becomes customising rather than building from scratch?
What it tests. The build-and-ship side: generating images from pure noise, working with modern deep learning frameworks, deploying production-level conversational AI with Helm charts, and customising NVIDIA AI Blueprints. It checks that you can move from a working idea to something deployable rather than only reasoning about the theory.
How to study it. Connect the image-from-noise topic back to diffusion so the two domains reinforce each other. Get a working mental model of how a deep learning framework structures a model and a training run. For deployment, know that Helm charts package and configure applications on Kubernetes, and understand what NVIDIA AI Blueprints give you as a starting point so you can reason about customising rather than building from scratch.
Easy to confuse
- Helm chart versus Kubernetes. Kubernetes is the platform that runs and orchestrates containers; a Helm chart is the package that defines and configures an application to deploy onto it. Helm describes what to deploy, Kubernetes is what runs it.
- Customising an NVIDIA AI Blueprint versus building from scratch. A Blueprint is a reference application you adapt, so the work is configuration and modification; building from scratch means assembling every part yourself. The exam favours reasoning about adapting a given starting point.
- Deep learning framework versus deployment tooling. A framework structures and trains the model; deployment tooling such as Helm and Kubernetes packages and runs it in production. One is where the model is built, the other is how it is shipped and served.
Worked example from the NCA-GENM bank
lock_openFree sampleSoftware Developmentmedium
A developer wants to swap the embedding model used in an NVIDIA AI Blueprint that implements retrieval-augmented generation. Which structural characteristic of AI Blueprints makes this kind of targeted substitution practical?
- ABlueprints are structured as reference architectures that wire together discrete NIM microservices, so the embedding NIM can be replaced or reconfigured without rewriting the surrounding pipeline.check_circle Correct
- BBlueprints package all AI logic as a single compiled binary, so the developer recompiles with a different embedding library flag.
- CBlueprints expose a single REST endpoint that proxies all model calls, so the developer redirects that endpoint to a different embedding service URL.
- DBlueprints rely on a shared CLIP backbone for all retrieval tasks, so the developer fine-tunes the CLIP model to change embedding behaviour.
Explain why the NIM microservice architecture of AI Blueprints enables component-level customisation without full pipeline rewrites. NVIDIA AI Blueprints are reference architectures that compose multiple NIM microservices into end-to-end workflows. Because each service such as an embedding model, a reranker, or a generative LLM is a discrete, independently addressable unit, a developer can substitute one NIM for another of the same role with minimal impact on the rest of the blueprint. This modular design is the core value proposition of the blueprint approach for customisation.
Why A is correct: An AI Blueprint provides a reference architecture that combines NIM microservices as modular units, meaning any single service such as an embedding model can be swapped independently while the rest of the pipeline remains intact.
Why B is wrong: Blueprints are not compiled monoliths; this misrepresents the composable microservice architecture and confuses it with traditional software packaging.
Why C is wrong: While NIM microservices do expose REST endpoints, the single-proxy description mischaracterises how blueprint components are individually addressed and replaced.
Why D is wrong: CLIP is a vision-language model relevant to multimodal retrieval but is not a universal backbone for all RAG blueprints; this conflates a specific technique with the general blueprint architecture.
What you must be able to do. Choose the right way to prepare or extract the data that feeds a generative pipeline: augmentation for more training data, LLMs for text analysis, OCR for documents.
In one sentencePreparing the data that feeds the pipeline: augmentation for more varied training data, LLM-based text analysis, and OCR to extract text from PDFs.
Recall check: answer these from memory first
- What does data augmentation give you that collecting more data does not, and name two common techniques?
- Where does OCR sit in a pipeline, and what kinds of errors does it tend to introduce downstream?
- Once a PDF has been turned into text, what is an LLM then used to do with it?
What it tests. Preparing and inspecting data: enhancing datasets through data augmentation, manipulating and analysing text-based data with LLMs, and applying PDF extraction using optical character recognition. The questions here lean towards the practical handling of data that feeds the rest of a generative pipeline.
How to study it. This is a lower-weight domain with some of the more approachable objectives, so secure it with focused practice rather than long study. Know what data augmentation buys you, which is more varied training data without collecting more of it, and the common techniques. Understand where OCR fits, turning PDFs and scanned documents into text an LLM can then analyse, and the kinds of errors OCR introduces.
Easy to confuse
- Data augmentation versus collecting more data. Augmentation transforms the examples you already have to add variety; collecting more data gathers new examples. Augmentation buys variety without new sources, which is the trade-off the exam tests.
- OCR versus general LLM text analysis. OCR turns images of text, such as scanned PDFs, into machine-readable text; LLM analysis then manipulates and reasons over text that is already digital. OCR is the extraction step, the LLM is the analysis step after it.
Worked example from the NCA-GENM bank
lock_openFree sampleData Analysis and Visualizationmedium
A data engineer needs to extract structured fields (product name, price, and availability) from thousands of unstructured product descriptions and load them into a database. Which prompting strategy most reliably produces machine-parseable output from an LLM for this pipeline?
- AZero-shot chain-of-thought prompting, asking the model to reason step-by-step before naming each field
- BEmbedding each product description and storing the vector, then using cosine similarity to retrieve the closest known structured record
- CFew-shot prompting with plain-text examples separated by delimiter lines, leaving the output format for the model to infer
- DStructured-output prompting with a JSON schema in the system prompt, constraining the model to emit a fixed key-value object per descriptioncheck_circle Correct
Identify structured-output prompting as the reliable technique for extracting machine-parseable fields from unstructured text at scale. When an LLM must feed a downstream parser, the output format must be deterministic. Structured-output prompting - declaring a JSON or similar schema inside the prompt and, where the API supports it, using response format constraints - forces the model to emit a fixed shape every time. Chain-of-thought and few-shot approaches improve reasoning or style but leave format under-constrained. Embeddings address search and clustering, not field extraction.
Why A is wrong: Chain-of-thought improves reasoning but produces verbose prose, not a consistent machine-parseable format. Downstream parsers would struggle with inconsistent output shapes across thousands of descriptions.
Why B is wrong: Embeddings plus similarity search retrieves similar items but does not extract fields from the source text. This is a search or clustering technique, not an extraction approach.
Why C is wrong: Few-shot examples guide style but do not enforce a schema. Without an explicit format constraint the model may vary its output structure across samples, breaking automated parsing.
Why D is correct: Structured-output prompting binds the model to a declared schema, guaranteeing field names and types. This is the standard approach for LLM-to-database pipelines where downstream code must parse every response identically.
What you must be able to do. Pick the lever for the constraint: transfer learning when data or compute is short, and Kubernetes scaling when a workload must grow with demand.
In one sentenceGetting more from models and infrastructure: transfer learning to reuse a pre-trained model, and Kubernetes to scale serving with demand.
Recall check: answer these from memory first
- State the cost-and-data case for transfer learning over training a model from scratch.
- How does Kubernetes let a workload grow with demand across a cluster?
- Given limited labelled data, which of the two levers applies, and why?
What it tests. Getting more from models and infrastructure: leveraging transfer learning between models so you reuse learned representations rather than training from scratch, and deploying scalable applications in Kubernetes clusters so a workload can grow with demand.
How to study it. Learn transfer learning as a cost-and-data argument: starting from a pre-trained model needs less data and less compute than training fresh, and you fine-tune from there. On the infrastructure side, understand how Kubernetes scales applications across a cluster and why that matters for serving generative models under load. This domain is small but the two ideas are concrete and worth banking.
Easy to confuse
- Transfer learning versus training from scratch. Transfer learning reuses a pre-trained model's learned representations and fine-tunes from there, needing less data and compute; training from scratch starts from random weights and needs far more of both. The exam frames this as a cost-and-data decision.
- Transfer learning versus model fusion. Transfer learning reuses one model's knowledge as a starting point for another task; fusion combines signals or outputs from more than one source. One is about reuse over time, the other about merging in the moment.
- Scaling on Kubernetes versus optimising the model itself. Kubernetes scaling adds capacity so more requests can be served in parallel; model optimisation makes a single inference cheaper or faster. One grows the infrastructure, the other improves the model, and the scenario tells you which constraint is in play.
Worked example from the NCA-GENM bank
lock_openFree samplePerformance Optimizationhard
A team is deploying a multimodal inference service on Kubernetes. Each pod requires one GPU for model execution. The NVIDIA device plugin is installed on the cluster. Which resource request configuration in the pod spec correctly reserves a single GPU for the container?
- ASet resources.requests to cpu: 0 and memory: 0, then annotate the pod with nvidia.com/gpu: 1 in the metadata section.
- BSet resources.limits to gpu: 1 using the standard Kubernetes resource name and omit the vendor prefix entirely.
- CSet resources.requests and resources.limits both to nvidia.com/gpu: 1 under the container spec.check_circle Correct
- DSet resources.requests to nvidia.com/gpu: 1 only, leaving resources.limits unset, so the pod can burst beyond one GPU when the node has capacity.
Correctly configure GPU resource requests and limits using the NVIDIA device plugin in a Kubernetes pod spec. The NVIDIA device plugin registers each GPU on a node as the extended resource nvidia.com/gpu. Kubernetes treats extended resources as integer quantities with no overcommit: the scheduler only allocates them when both resources.requests and resources.limits carry the same value. Setting both to 1 under the container spec is therefore the required pattern to reserve a single GPU for an inference container.
Why A is wrong: Kubernetes annotations are informational metadata and have no effect on resource scheduling. Extended resources like GPUs must appear in the resources block, not as annotations, to be recognised by the scheduler.
Why B is wrong: gpu is not a standard Kubernetes resource name. The NVIDIA device plugin registers GPUs under the vendor-prefixed extended resource nvidia.com/gpu; omitting the prefix means the scheduler cannot locate or allocate the device.
Why C is correct: The NVIDIA device plugin exposes GPUs as the extended resource nvidia.com/gpu. Kubernetes requires that extended resources be specified identically in both requests and limits, so setting both to 1 correctly reserves one GPU for the container.
Why D is wrong: Extended resources in Kubernetes do not support burst behaviour. The scheduler requires that limits equal requests for any extended resource; specifying only a request without a matching limit causes the pod to be rejected at admission.
What you must be able to do. Identify what establishes that media was generated and what makes a generative system trustworthy, covering provenance, authenticity, safety, and reliability.
In one sentenceThe smallest domain: content authenticity and provenance for generated media, and what makes a generative model safe, reliable, and accountable.
Recall check: answer these from memory first
- Why does content authenticity matter more as generated media gets harder to tell from real, and what establishes provenance?
- Name the concrete properties that make a generative model trustworthy, beyond saying it should be responsible.
- What is the difference between proving a piece of media was generated and making the model that generated it trustworthy?
What it tests. The smallest domain. It covers content authenticity in generated media, meaning how you tell whether media was generated and how provenance is established, and what it takes to build trustworthy generative models, covering responsible AI concerns such as safety and reliability.
How to study it. Despite the low weight these are usually clean marks once the concepts are clear, so do not skip them. Learn why content authenticity and provenance matter as generated media becomes harder to distinguish from real, and what mechanisms address it. Keep the trustworthy-model ideas concrete: what makes a generative system safe, reliable, and accountable, rather than vague principles.
Easy to confuse
- Content authenticity versus trustworthy model behaviour. Content authenticity is about the output, establishing whether a piece of media was generated and tracing its provenance; trustworthy behaviour is about the model, being safe, reliable, and accountable in how it generates. One judges the artefact, the other judges the system.
- Provenance versus detection. Provenance records where media came from and how it was made, ideally at creation; detection tries to infer after the fact whether media was generated. Provenance is proactive and attached, detection is reactive and inferred.
Worked example from the NCA-GENM bank
lock_openFree sampleTrustworthy AImedium
A media organisation wants to attach tamper-evident provenance data to every AI-generated image before publishing. Which open standard is designed specifically to carry cryptographically signed assertions about a content item's origin and editing history?
- AC2PA (Coalition for Content Provenance and Authenticity) Content Credentialscheck_circle Correct
- BEXIF metadata embedded in the image file header
- CCLIP embeddings stored alongside the image as a sidecar file
- DA perceptual hash digest appended to the filename
Identify the C2PA standard as the mechanism for attaching cryptographically signed provenance data to AI-generated content. The Coalition for Content Provenance and Authenticity (C2PA) specification defines Content Credentials: a signed manifest that binds assertions - such as generator identity, model used, and editing actions - to a content item using public-key cryptography. Because the manifest is signed, any tampering with either the content or its assertions can be detected by a verifier. This is the only option among the four that provides both tamper evidence and a portable, standardised chain of custody.
Why A is correct: C2PA defines a cryptographically signed manifest that records assertions about how content was created or modified, enabling downstream verification of origin and editing history.
Why B is wrong: EXIF stores camera and device data but carries no cryptographic signatures, so it can be stripped or forged without detection and does not constitute a provenance standard.
Why C is wrong: CLIP produces semantic similarity embeddings for retrieval and classification tasks; it has no signing mechanism and cannot provide tamper-evident provenance assertions.
Why D is wrong: Perceptual hashes measure visual similarity and can detect near-duplicates, but they carry no chain-of-custody record and are not signed, so they cannot prove origin or detect editorial changes.