Overview
Core Machine Learning and AI Knowledge carries ten official objectives and the heaviest weight on the exam. They span three layers. The first is theory: machine learning fundamentals such as feature engineering, model comparison and cross validation, plus the research that produced modern LLMs, starting with the Transformer and its self-attention mechanism. The second is language tooling: tokenization, text embeddings, spaCy, NumPy, Keras and vector databases. The third is application building: prompt engineering, curating and embedding content for retrieval-augmented generation, and assembling RAG systems, chatbots and summarizers.
Two objectives reach into operations, asking you to help evaluate a deployed model's scalability, performance and reliability and to recognize how insights are mined from large datasets. NVIDIA repeats several of these bullets under Data Analysis and Software Development, so this domain works as the conceptual base those later domains apply.
How it's tested
Questions in this domain are short scenarios or definitions at an associate level. They describe an LLM behavior, an application requirement or a training curve and ask which concept, technique or tool explains it. Expect vocabulary checks on transformer internals mixed with practical choices about RAG, embeddings and prompts.
-
Pick the application pattern
A business need is described and you decide between prompting alone, retrieval-augmented generation, or fine-tuning the model.
-
Explain the architecture
A model property such as bidirectional context or next-token prediction is described and you name the architecture or component behind it.
-
Fix the prompt
A prompt produces poorly formatted or illogical output, and you choose the prompting technique or sampling setting that corrects it.
A legal team wants answers drawn from its contracts, which are updated weekly, with each answer citing a clause. Fine-tuning would bake in facts that soon go stale and cannot cite sources. A longer prompt cannot hold every contract. Retrieval-augmented generation embeds the contracts, retrieves the relevant chunks per question and passes them to the model, so answers stay current and traceable. The clues are frequent updates and citations.
Objectives 10
Official objectives from the NVIDIA outline, in outline order.
1.1 Assist in deployment and evaluation of model scalability, performance, and reliability under the supervision of senior team members.Measuring latency, throughput and reliability of a deployed LLM.
- What it means
- Associates support the engineers who own a deployment by measuring whether the model holds up under load. The core metrics are time to first token, per-token latency, throughput in tokens or requests per second, GPU memory use and error rate.
- What to understand
- Bigger batches usually raise throughput but can lengthen the wait for each individual request. The KV cache grows with context length and the number of concurrent sequences, and it often caps how many users a GPU can serve. Reliability means stable uptime and consistent responses, checked with load tests and health probes on servers such as Triton Inference Server or NVIDIA NIM.
- How it shows up
- A serving metric is described and you identify what it measures or which change would improve it.
- Common confusion
- Treating throughput and latency as one metric; a server can push many tokens per second while each user still waits.
1.2 Awareness of the process of extracting insights from large datasets using data mining, data visualization, and similar techniques.Data mining and exploration as groundwork for LLM projects.
- What it means
- You should recognize how teams turn large raw corpora into usable knowledge through profiling, clustering, frequency counts, topic modeling and charts, before any model is trained or prompted.
- What to understand
- In LLM projects this exploration reveals document length distributions, duplicate rates, language mix and topic coverage. Those findings shape decisions such as what to filter, how big chunks should be, and which subjects need more examples. GPU libraries in NVIDIA RAPIDS, such as cuDF and cuML, make the analysis practical on very large datasets.
- How it shows up
- You choose the exploratory technique that reveals a described property of a large corpus.
- Common confusion
- Thinking data mining means training the production model; it is exploratory work that informs modeling.
1.3 Build LLM use cases such as retrieval-augmented generation (RAG), chatbots, and summarizers.Common LLM application patterns and their building blocks.
- What it means
- This objective covers assembling the typical LLM applications. RAG retrieves relevant passages and inserts them into the prompt, a chatbot manages conversation history across turns, and a summarizer condenses long input.
- What to understand
- RAG grounds answers in private or current data without retraining, reduces hallucination and allows citations. Its pipeline is ingest, chunk, embed, index, retrieve the top matches, optionally rerank, then generate. Chatbots must keep history inside the context window, often by truncating or summarizing older turns. Documents longer than the window need chunked map-reduce summarization. NVIDIA NeMo Retriever and NIM microservices supply retrieval and generation pieces.
- How it shows up
- A requirement is described and you choose RAG, fine-tuning or prompting as the most suitable design.
- Common confusion
- Assuming fine-tuning is the way to add new facts; retrieval is cheaper and stays current.
1.4 Curate and embed content datasets for RAGs.Cleaning, chunking and embedding documents for retrieval.
- What it means
- Retrieval only works if the source content is prepared first: cleaned of boilerplate, split into chunks, tagged with metadata and converted into vectors stored in an index.
- What to understand
- Chunk size is a trade-off. Small chunks match precisely but lose surrounding context, while large chunks keep context but dilute relevance and consume prompt tokens. Overlap keeps sentences that straddle a boundary retrievable. Metadata such as source, date and access level supports filtering. Documents and queries must be embedded with the same model, and switching models means re-embedding the whole corpus.
- How it shows up
- Retrieval returns irrelevant passages and you identify the curation step responsible.
- Common confusion
- Embedding queries and documents with different models, which places them in incompatible vector spaces.
1.5 Familiarity with the fundamentals of machine learning (e.g., feature engineering, model comparison, cross validation).Classic machine learning ideas that still apply to LLM work.
- What it means
- The exam expects general machine learning literacy: supervised and unsupervised learning, features, train, validation and test splits, overfitting, and k-fold cross validation for fair model comparison.
- What to understand
- Feature engineering converts raw data into informative inputs, such as TF-IDF vectors for text. Overfitting appears as falling training loss with rising validation loss, and regularization, dropout, more data or early stopping help. Cross validation rotates the held-out fold so every sample is evaluated once, giving a steadier estimate. Neural network basics also appear: activation functions, backpropagation, gradient descent and the learning rate.
- How it shows up
- Training and validation curves are described and you diagnose overfitting, underfitting or a bad learning rate.
- Common confusion
- Tuning hyperparameters against the test set, which leaks information and inflates the final score.
1.6 Familiarity with the capabilities of Python natural language packages (spaCy, NumPy, vector databases, etc.).What common Python NLP and vector tools are for.
- What it means
- You need to know the job of each common tool: spaCy for tokenization, lemmatization, part-of-speech tagging and named entity recognition, NumPy for fast array math, and vector databases for similarity search over embeddings.
- What to understand
- spaCy runs configurable linguistic pipelines and quickly extracts entities, sentences or noun phrases. NumPy powers numeric work such as computing cosine similarity between vectors. Vector databases such as Milvus, or libraries such as FAISS, store embeddings and answer approximate nearest-neighbor queries using indexes like HNSW or IVF, with GPU acceleration available through NVIDIA cuVS.
- How it shows up
- A text-processing job is described and you pick the package designed for it.
- Common confusion
- Expecting a vector database to write answers; it stores vectors and returns the closest matches.
1.7 Read research papers (articles, conference papers, etc.) to identify emerging LLM trends and technologies.The landmark papers behind modern LLMs.
- What it means
- NVIDIA's study guide points to papers such as Attention Is All You Need, BERT and LoRA. You should recognize each paper's main contribution and link it to current tools and practice.
- What to understand
- The Transformer replaced recurrence with self-attention, enabling parallel training over long sequences, with multi-head attention and positional encoding as key parts. BERT is an encoder trained by masked language modeling, suited to classification and extraction. GPT-style decoders are autoregressive and predict the next token. LoRA freezes base weights and trains small low-rank matrices. Scaling-law studies show loss falling predictably as parameters, data and compute grow.
- How it shows up
- A paper's idea is summarized and you name the architecture or technique it introduced.
- Common confusion
- Mixing up BERT and GPT; BERT reads context in both directions, GPT generates left to right.
1.8 Select and use models to create text embeddings.Choosing and applying embedding models.
- What it means
- Text embeddings are dense vectors whose distance reflects meaning. This objective covers choosing a suitable embedding model and using it to encode text for search, clustering or classification.
- What to understand
- Selection factors include domain fit, language coverage, maximum input length, vector dimension, which affects storage and speed, and benchmark results such as MTEB retrieval scores. Cosine similarity on normalized vectors is the usual comparison. NVIDIA packages embedding models as NeMo Retriever NIM microservices, and some models expect distinct input types for queries and passages.
- How it shows up
- You choose the embedding model or similarity measure that satisfies a stated retrieval need.
- Common confusion
- Assuming the largest generative LLM gives the best embeddings; purpose-trained embedding models usually retrieve better.
1.9 Use prompt engineering principles to create prompts to achieve desired results.Instructions, examples and structure that steer LLM output.
- What it means
- Prompt engineering shapes the input so the output meets the goal without changing model weights. It covers clear instructions, system prompts, roles, delimiters, output format requirements and examples.
- What to understand
- Zero-shot prompts give only the instruction. Few-shot prompts add worked examples that set format and style. Chain-of-thought prompting asks for step-by-step reasoning and helps multi-step problems. Sampling settings matter: low temperature makes output more deterministic, while top-p and top-k limit the candidate tokens. Mixing untrusted user text with instructions creates prompt injection risk.
- How it shows up
- A prompt gives inconsistent format or weak reasoning and you choose the technique that fixes it.
- Common confusion
- Raising temperature to improve accuracy; it adds randomness, not correctness.
1.10 Use Python packages (spaCy, NumPy, Keras, etc.) to implement specific traditional machine learning analyses.Building classic machine learning and NLP baselines in Python.
- What it means
- This objective covers hands-on use of Python libraries for conventional analyses such as text classification, clustering or regression, often as a baseline before an LLM is considered.
- What to understand
- A typical pipeline tokenizes and lemmatizes with spaCy, vectorizes with bag-of-words or TF-IDF, then trains a classifier in scikit-learn or a small Keras network, with NumPy holding the arrays. RAPIDS cuML offers scikit-learn-style APIs on GPUs. A cheap baseline shows whether a large model justifies its cost.
- How it shows up
- You pick the library or step that completes a described classic machine learning pipeline.
- Common confusion
- Skipping the baseline and assuming an LLM always beats simpler models on narrow classification.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Self-attention
Every token weighs every other token in the sequence to build its contextual representation.
- Remember
- Compute grows roughly with the square of sequence length.
- Tested as
- Transformer architecture questions.
- Trap
- Describing attention as recurrent processing.
-
Positional encoding
Injects token order, because attention by itself treats input as an unordered set.
- Remember
- Without it, word order is invisible to the model.
- Tested as
- Transformer component questions.
- Trap
- Assuming attention captures order on its own.
-
Subword tokenization
Methods such as BPE, WordPiece and SentencePiece split text into subword units.
- Remember
- Context limits and usage costs are counted in tokens, not words.
- Tested as
- Context window and cost questions.
- Trap
- Treating one token as one word.
-
Context window
The maximum number of tokens a model can attend to across prompt and output.
- Remember
- Generated tokens share the same budget as the prompt.
- Tested as
- Chatbot and RAG design questions.
- Trap
- Forgetting that output length eats into the window.
-
Encoder vs. decoder
Encoders like BERT read both directions; decoders like GPT generate the next token.
- Remember
- Generation tasks use decoders or encoder-decoder models.
- Tested as
- Architecture selection questions.
- Trap
- Picking BERT for open-ended text generation.
-
Retrieval-augmented generation
Retrieves relevant passages and adds them to the prompt before generation.
- Remember
- It grounds answers in current data without retraining.
- Tested as
- Use-case design questions.
- Trap
- Choosing fine-tuning for facts that change often.
-
Chunking and overlap
Splitting documents into retrievable pieces, with overlap so boundary text is not lost.
- Remember
- Chunk size trades precision against context.
- Tested as
- RAG curation questions.
- Trap
- Using one huge chunk per document.
-
Cosine similarity
Measures the angle between two vectors, ignoring their length.
- Remember
- It is the default way to compare text embeddings.
- Tested as
- Embedding and retrieval questions.
- Trap
- Confusing high similarity with factual correctness.
-
Few-shot prompting
Including worked input-output examples in the prompt.
- Remember
- It sets format and style without training.
- Tested as
- Prompt engineering questions.
- Trap
- Calling it fine-tuning.
-
Chain-of-thought
Prompting the model to reason step by step before answering.
- Remember
- It helps arithmetic and multi-step logic.
- Tested as
- Prompt engineering questions.
- Trap
- Using it where a simple lookup needs no reasoning.
-
Temperature
Scales the token probability distribution before sampling.
- Remember
- Low values give focused, repeatable output; high values give variety.
- Tested as
- Sampling parameter questions.
- Trap
- Believing higher temperature means more accurate output.
-
Overfitting
The model memorizes training data and generalizes poorly.
- Remember
- Training loss falls while validation loss rises.
- Tested as
- Learning curve questions.
- Trap
- Reading low training loss alone as success.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Prompting vs. RAG vs. fine-tuning
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Prompt engineering | Shape instructions and examples at inference time | No training, fastest to try | Expecting it to add knowledge the model lacks |
| Retrieval-augmented generation | Fetch external passages into the prompt | Adds current or private facts with citations | Ignoring retrieval quality as the main failure point |
| Fine-tuning | Update model weights on new examples | Changes behavior, style or task skill | Using it to keep fast-changing facts current |
Transformer model families
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Encoder-only (BERT) | Bidirectional context, masked language modeling | Strong for classification and extraction | Using it for free-form generation |
| Decoder-only (GPT, Llama, Nemotron) | Left-to-right next-token prediction | Built for open-ended generation | Assuming it sees future tokens |
| Encoder-decoder (T5) | Encoder reads input, decoder writes output | Suited to translation and summarization | Treating it as decoder-only |
Prompting techniques
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Zero-shot | Instruction only, no examples | Lowest prompt cost | Expecting a precise custom format from it |
| Few-shot | Instruction plus worked examples | Teaches format through demonstration | Confusing it with training |
| Chain-of-thought | Ask for intermediate reasoning steps | Improves multi-step answers | Applying it to simple factual lookups |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Fine-tune for fresh facts
- What candidates pick
- Retrain the model every time the knowledge base changes.
- Why it looks right
- Training sounds like the thorough option.
- Why it's wrong
- Retraining is slow and costly and cannot cite sources; retrieval adds current facts at query time.
Clue to watch for The scenario mentions frequently updated documents or a need for citations.
-
Temperature fixes accuracy
- What candidates pick
- Raise temperature so the model finds better answers.
- Why it looks right
- More exploration sounds like more chances to be right.
- Why it's wrong
- Temperature only changes randomness; factual quality comes from grounding, prompting or better models.
Clue to watch for The goal is consistent, factual output.
-
BERT for generation
- What candidates pick
- Select an encoder-only model to write long answers.
- Why it looks right
- BERT is a famous transformer.
- Why it's wrong
- Encoders produce representations, not fluent open-ended text; decoders generate.
Clue to watch for The task is free-form text generation.
-
Tokens equal words
- What candidates pick
- Estimate context use by counting words.
- Why it looks right
- Words are the natural unit people count.
- Why it's wrong
- Subword tokenizers often produce more tokens than words, so limits and costs are higher than a word count implies.
Clue to watch for The question asks whether text fits the context window.
-
Bigger chunks are safer
- What candidates pick
- Index each document as one large chunk.
- Why it looks right
- It seems to keep all context together.
- Why it's wrong
- Huge chunks dilute similarity scores and crowd the prompt, so relevant details get missed.
Clue to watch for Retrieval returns broad but unhelpful passages.
-
Test-set tuning
- What candidates pick
- Pick hyperparameters by checking the test score repeatedly.
- Why it looks right
- It maximizes the reported number.
- Why it's wrong
- The test set then leaks into model selection and no longer gives an unbiased estimate.
Clue to watch for The scenario describes repeated adjustments against held-out data.
Answer framework
Use these steps for any Domain 1 scenario about LLM concepts or applications.
- Decide whether the question is about theory, tooling, prompting or application design, because each draws on a different vocabulary set.
- For architecture questions, identify whether the behavior points to attention, positional encoding, an encoder or a decoder, and note that GPT-style generators are decoder-only while BERT-style models are encoder-only.
- For application questions, ask whether the model needs new knowledge, new behavior or just clearer instructions, then map those to RAG, fine-tuning or prompting.
- For retrieval questions, trace the pipeline from chunking through embedding and search to locate the failing stage, checking chunk size and whether queries and documents use the same embedding model.
- For prompting questions, choose the least costly fix first, such as clearer instructions or examples, before changing sampling settings or models.
Practice question
Want more like this? The NCA-GENL practice test has questions for every domain.
Checklist
0 of 14
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Give this domain the largest block of your study time, since it carries the most weight and underpins everything else. Begin with the Transformer: read a plain-language walkthrough of Attention Is All You Need, then make sure you can explain self-attention, multi-head attention, positional encoding and the difference between encoder and decoder stacks. Add tokenization and context windows next, because they explain many practical limits.
Then move to applications. Build a tiny RAG prototype in Python: chunk a few documents, embed them, store them in a vector index and query it through an LLM endpoint such as a NIM microservice or a hosted API. Changing chunk size and watching results shift teaches more than reading. Practice prompts side by side with zero-shot, few-shot and chain-of-thought variants and different temperatures.
Finally, refresh classic machine learning: overfitting, cross validation, feature engineering, and a quick TF-IDF classifier with spaCy and scikit-learn or Keras. Skim the LoRA and BERT abstracts so paper-based questions feel familiar. Close with timed practice questions and sort your misses into theory, tooling or application gaps.
FAQ
How much of NCA-GENL is Domain 1?
Core Machine Learning and AI Knowledge is 30% of the exam, the largest share, which works out to roughly 15 to 18 of the 50 to 60 questions.
Is NCA-GENL being retired or replaced?
No retirement or new version has been announced on NVIDIA's exam page as of October 2026. Several recommended DLI courses did close to new enrollment in mid-2026, so confirm current training options.
Do I need to code for this domain?
You need to read and reason about simple Python using spaCy, NumPy, Keras and vector database clients. The exam is multiple choice, so you will not write code, but hands-on practice makes questions easier.
When should I choose RAG over fine-tuning?
Choose RAG when the model needs facts that change or are private and when answers should cite sources. Fine-tuning suits changing tone, format or task behavior.
Which research papers should I know?
NVIDIA's study guide lists Attention Is All You Need, BERT and LoRA among its readings, along with articles on foundation models, autoregressive models and backpropagation.
What does temperature do?
It rescales the probability distribution over next tokens. Lower values make output more predictable; higher values make it more varied but not more accurate.
Why are some objectives listed in more than one domain?
NVIDIA's blueprint repeats several bullets, such as Python packages and RAG use cases, across domains. This page covers the concepts; Data Analysis and Software Development cover the applied side.
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 1 knowledge
You have covered transformers, tokenization, embeddings, prompting and RAG design. Check whether you can pick the right concept or pattern for a scenario under time pressure.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the NCA-GENL AI tutor Get any concept explained your way