NVIDIA Generative AI LLM

Text has to become numbers before a model can use it. You clean and tokenize text with Python NLP packages, build word and sentence embeddings, and use similarity to see what an embedding captures.

• Cleaning and normalizing text
• Tokenization with Python NLP packages
• Bag-of-words and TF-IDF
• Word and sentence embeddings
• Similarity and nearest neighbors
• Visualizing an embedding space

You build A notebook that embeds a document set and finds its closest matches.

You build a working picture of an LLM without heavy math: transformers and attention, pretraining, how a model produces text one token at a time, and what limits its answers.

• From neural networks to transformers
• Attention in plain terms
• Pretraining and what a model learns
• Generating text token by token
• Context windows and their limits
• Hallucination and why it happens

You build A one-page explainer of how a prompt becomes an answer, with your own diagrams.

Prompts are the first control you have. You write clear instructions, add examples, ask for step-by-step reasoning and request structured output, then judge which changes actually help.

• Writing clear instructions
• Few-shot examples
• Asking for step-by-step reasoning
• Roles, context and formatting
• Structured output for software
• Testing prompt variants

You build A tested prompt set for summarizing, classifying and extracting from the same documents.

Numbers need a method behind them. You explore data with statistics, find trends and relationships, compare models with the right metrics, and show results in charts that others can read.

• Descriptive statistics and distributions
• Finding trends and relationships
• Choosing metrics for a task
• Comparing models statistically
• Confusion matrices and error review
• Charts that communicate

You build A short analysis report comparing two models, with charts and a recommendation.

Good results come from good experiments. You plan runs, track what changed, evaluate against benchmarks, prepare large datasets, and see how human labeling and RLHF feed back into a model.

• Designing an experiment with one variable
• Tracking runs and results
• Benchmarks and what they measure
• Preparing large datasets
• Human labeling and annotation quality
• How RLHF uses human feedback

You build An experiment log that compares three setups on one task, with a conclusion.

RAG lets a model answer from your documents. You chunk text, store embeddings in a vector database, retrieve matches for a question, and check that the answer stays grounded in what was found.

• Why retrieval helps
• Chunking documents
• Vector databases and indexing
• Retrieving and ranking passages
• Building the prompt from retrieved text
• Checking answers against sources

You build A RAG system that answers questions over a document collection, with sources shown.

You turn models into small applications. You build a chatbot that remembers the conversation, a summarizer for long text, and the tests and checks that show each one behaves as intended.

• Chat structure and conversation history
• Handling long documents
• Building a summarizer
• Wrapping a model in a Python app
• Verifying and testing outputs
• Handling errors and unusual input

You build A working chatbot and a summarizer, each with a test set.

A model that works can still do harm. You look at where bias enters, how consent and privacy apply to training data, and which habits keep a system transparent, fair and dependable.

• Where bias comes from
• Measuring fairness in outputs
• Privacy and consent in data
• Transparency and explaining a system
• Reducing bias in practice
• Responsible use and limits

You build A short trust review of an LLM application, with bias and privacy checks.

Build one small application and explain it. You analyze the data, choose and test a model, add retrieval, check bias and privacy, and present your decisions in plain language.

• Choosing a task and its data
• Selecting and testing a model
• Adding retrieval and a chat layer
• Reviewing bias and privacy
• Presenting the work

You build A documented RAG chatbot with evaluation results and a trust review.