Enroll in Generative AI and LLMs

What Is Generative AI

Explore the definition of generative AI and how it differs from traditional predictive AI. Review real products that use it every day.

History and Evolution of Generative Models

Trace the path from rule-based systems and Markov chains to GANs, transformers and modern large language models.

Types of Generative Models

Compare text, image, audio, video and code generation models at a conceptual level. Understand where each type fits.

Industry Applications of Generative AI

Study how healthcare, marketing, education, finance and software teams use generative AI to create value.

Setting Up Python and Jupyter Notebooks

Install Python, create virtual environments and run code in Jupyter and Google Colab.

Variables Data Types and Operators

Work with numbers, strings, booleans and operators to write simple programs and expressions.

Control Flow with Conditions and Loops

Use if statements, for loops and while loops to control how programs make decisions and repeat tasks.

Functions and Modules

Write reusable functions, use parameters and return values, and import standard and third party modules.

Lists and Tuples

Create, slice and modify lists and tuples, and choose between them for different tasks.

Dictionaries and Sets

Store key value data in dictionaries and remove duplicates with sets. Practice lookups and updates.

Comprehensions and Iterators

Write concise list and dictionary comprehensions and understand iterators and generators.

Classes and Objects

Define classes, attributes and methods, and understand inheritance and encapsulation through small examples.

NumPy Arrays and Vectorized Operations

Create arrays, apply vectorized math and understand shapes and broadcasting for fast numerical computing.

Linear Algebra Essentials with NumPy

Practice vectors, matrices, dot products and matrix multiplication, which are the building blocks of neural networks.

Pandas Series and DataFrames

Load data from CSV files, inspect it and select rows and columns using Pandas.

Data Cleaning and Transformation

Handle missing values, fix data types, filter records, group data and merge datasets.

Introduction to Machine Learning

Learn the differences between supervised, unsupervised and reinforcement learning along with the standard ML workflow.

Probability and Statistics for AI

Review distributions, mean, variance and conditional probability, and see why they matter for generative models.

Regression and Classification with Scikit-learn

Train linear regression and logistic regression models and make predictions on real datasets.

Model Evaluation and Overfitting

Split data into train and test sets, use metrics such as accuracy and RMSE, and recognize overfitting and underfitting.

Neurons Layers and Activation Functions

Understand how artificial neurons combine inputs and how activation functions add non linearity.

Loss Functions and Gradient Descent

See how models measure error and improve through gradient descent and learning rates.

Backpropagation Explained

Follow the intuition behind backpropagation and how gradients flow through a network during training.

Building Models with PyTorch

Use tensors, datasets and training loops in PyTorch to build and train a simple neural network.

Tokenization Fundamentals

Explore how text is split into tokens using word, character, and subword approaches. Practice tokenizing sentences and inspecting the results.

Byte Pair Encoding and Vocabulary Building

Learn how BPE merges frequent symbol pairs to build a subword vocabulary. Train a small tokenizer on a sample corpus.

Word Embeddings Explained

Understand how words are mapped to dense vectors that capture meaning. Compare Word2Vec and GloVe style embeddings on example words.

Measuring Similarity in Embedding Space

Use cosine similarity and nearest neighbor search to compare vectors. Visualize embeddings with dimensionality reduction.

Recurrent Neural Networks Basics

Learn how RNNs process sequences step by step with a hidden state. Implement a simple character-level RNN.

LSTMs and GRUs

Study gating mechanisms that help models remember long-range information. Compare LSTM and GRU performance on a small task.

Vanishing Gradients and Long-Range Dependencies

Understand why recurrent models forget distant context. Observe gradient behavior through simple experiments.

Encoder-Decoder Models and Seq2Seq

Explore how encoder-decoder designs handle translation and summarization. Identify the bottleneck of a single context vector.

Self-Attention with Queries Keys and Values

Break down how queries, keys, and values produce context-aware representations. Compute attention by hand on a short sentence.

Scaled Dot-Product and Multi-Head Attention

Understand scaling, softmax, and why multiple heads capture different relationships. Implement multi-head attention in code.

Positional Encoding

Learn how transformers inject word order using sinusoidal and learned positions. Compare absolute and rotary approaches.

Feed-Forward Layers Residuals and Layer Normalization

Examine the supporting blocks that stabilize and deepen transformer training. See how they combine into a full layer.

Encoder-Only Models and BERT

Understand masked language modeling and bidirectional context. Use BERT for classification and embeddings.

Decoder-Only Models and the GPT Family

Learn autoregressive generation and causal masking. Trace how GPT models predict one token at a time.

Encoder-Decoder Models like T5 and BART

Explore text-to-text frameworks for translation and summarization. Compare their strengths with decoder-only models.

Working with Hugging Face Transformers

Load pretrained models and tokenizers using the Hugging Face library. Run inference pipelines for several tasks.

Pretraining Objectives and Data Sources

Learn how next-token prediction on massive corpora builds general language ability. Discuss data quality, filtering, and bias.

Scaling Laws and Compute

Understand how model size, data, and compute relate to performance. Interpret scaling curves from published research.

Distributed Training and Optimization

Get an overview of GPUs, data and model parallelism, and optimizers like Adam. Learn why mixed precision matters.

Instruction Tuning and Supervised Fine-Tuning

See how models are adapted to follow instructions using curated examples. Prepare a small instruction dataset.

Decoding Strategies

Compare greedy search, beam search, top-k, and nucleus sampling. Generate text and observe how each strategy changes output.

Temperature and Generation Parameters

Experiment with temperature, repetition penalties, and max length. Learn how to tune for creativity versus accuracy.

Context Windows and the KV Cache

Understand context length limits and how caching speeds up inference. Discuss memory and latency trade-offs.

Hallucinations and Failure Modes

Identify why LLMs produce confident but wrong answers. Practice spotting and testing for common failure patterns.

Anatomy of an Effective Prompt

Explore the components of a prompt including role, task, context, constraints and output format. Practice rewriting vague prompts into precise ones.

Roles, System Messages and Personas

Learn how system, user and assistant messages steer tone and behavior. Design personas for support, tutoring and analysis use cases.

Context and Constraint Setting

Supply background information and limits such as length, style and audience to control responses. Compare outputs with and without constraints.

Controlling Output Format

Request tables, lists, markdown and structured text reliably. Use delimiters and templates to keep formats consistent.

Zero-Shot and Few-Shot Prompting

Decide when to give examples and how to select them. Measure how example quality and order change results.

Chain-of-Thought Reasoning

Elicit step-by-step reasoning for math, logic and planning problems. Understand when explicit reasoning helps and when it adds noise.

Self-Consistency and Prompt Chaining

Break big tasks into linked prompts and aggregate multiple samples for better answers.

Reflection and Self-Critique Prompts

Ask models to review and improve their own drafts. Build critique-and-revise loops for writing and code.

API Basics and Authentication

Understand REST endpoints, API keys and secure secret handling. Make a first chat completion request from Python.

Chat Completion Requests and Responses

Build message lists, read response objects and manage multi-turn conversation history.

Streaming Responses and Async Calls

Stream tokens for responsive interfaces and use asynchronous calls to run many requests efficiently.

Error Handling, Retries and Rate Limits

Handle timeouts, rate limit errors and malformed responses with exponential backoff and logging.

Generating JSON Reliably

Prompt for strict JSON and apply JSON mode. Parse and repair outputs in Python.

Schema Validation with Pydantic

Define data schemas and validate model outputs automatically. Retry on validation failure.

Function Calling and Tool Use

Describe functions to the model and execute the calls it requests. Return results to complete the conversation loop.

Information Extraction and Classification

Build pipelines that extract entities and classify text such as resumes, reviews and tickets.

Hugging Face Hub and Model Cards

Navigate the Hub, read model cards and licenses, and pick suitable models for a task.

Text Generation with Transformers Library

Load a pretrained model and generate text using pipelines and generate settings.

Running Models Locally with Ollama

Install and serve quantized models locally and call them through a local API.

Prompt Formats and Chat Templates

Learn how different model families expect instructions and apply chat templates correctly.

Building Prompt Test Sets

Create representative test cases and expected outputs to measure prompt performance objectively.

Automated Evaluation and LLM-as-Judge

Score outputs using metrics and model-based graders, and understand their biases and limits.

Prompt Injection and Jailbreak Defense

Recognize injection attacks and apply input filtering, instruction hierarchy and output checks.

Reducing Hallucinations and Bias

Ground answers in provided sources, request citations and test for biased or unsafe outputs.

From Words to Vectors

Trace the evolution from one-hot encoding and bag of words to dense representations. Understand why vector space captures semantic meaning.

Word and Sentence Embeddings

Compare Word2Vec and GloVe with modern sentence-level embedding models. Generate embeddings for sample text in Python.

Embedding Models from Providers

Use hosted embedding APIs and open-source models from Hugging Face. Compare dimensions, context limits, cost and quality.

Similarity Metrics

Learn cosine similarity, dot product and Euclidean distance and when each one fits. Compute and compare them with NumPy.

Exact Versus Approximate Search

Understand brute-force nearest neighbor search and why it fails at scale. Explore the speed and recall trade-off of approximate methods.

Indexing with HNSW

Learn how hierarchical navigable small world graphs organize vectors for fast lookup. Tune key parameters such as M and ef.

IVF and Product Quantization

Study inverted file indexes and vector compression to reduce memory use. Weigh accuracy loss against storage savings.

Hands-on with FAISS

Build and query indexes with the FAISS library on a real text dataset. Benchmark different index types for latency and recall.

Vector Database Landscape

Survey Chroma, Pinecone, Weaviate, Qdrant, Milvus and pgvector. Compare hosting models, features and typical use cases.

Collections, Schemas and Metadata

Design collections that store vectors alongside documents and metadata. Plan identifiers and fields for later filtering.

Ingesting and Updating Data

Batch insert, upsert and delete vectors while keeping the index consistent. Handle re-embedding when documents change.

Filtered and Namespaced Queries

Run similarity queries with metadata filters and multi-tenant namespaces. Understand how filtering affects performance.

Loading Documents from Many Sources

Extract text from PDFs, web pages, Word files and databases using document loaders. Clean noisy text and handle tables and layouts.

Chunking Strategies

Compare fixed-size, recursive, sentence and semantic chunking. Learn how chunk size and overlap affect retrieval quality.

Structure-Aware Chunking

Use headings, markdown and code structure to produce coherent chunks. Preserve context with parent-child and hierarchical chunks.

Metadata Enrichment

Attach titles, sources, dates and generated summaries to each chunk. Use this metadata to improve filtering and citations.

RAG Architecture Overview

Understand the retrieve, augment and generate flow and why RAG reduces hallucination. Compare RAG with fine-tuning and long-context prompting.

Building a Basic RAG Pipeline

Implement an end-to-end question answering app over your own documents. Use LangChain or LlamaIndex to wire the components together.

Prompting for Grounded Answers

Write prompts that force the model to use retrieved context and admit when it does not know. Return answers with source citations.

Conversational RAG with Memory

Add chat history and question rewriting so follow-up queries retrieve correctly. Manage context window limits across turns.

Query Transformation Techniques

Apply query expansion, multi-query generation and HyDE to improve recall. Decompose complex questions into sub-queries.

Reranking and Context Compression

Use cross-encoder rerankers to reorder results and compress context to the most relevant passages. Reduce token cost without losing accuracy.

Agentic and Graph-Based RAG

Explore agents that decide when and what to retrieve and knowledge graph approaches to RAG. Understand when added complexity pays off.

Evaluating RAG Quality

Measure retrieval with recall and MRR and generation with faithfulness and relevance. Use tools such as RAGAS and LLM-as-judge methods.

Prompting vs RAG vs Fine-Tuning

Learn a decision framework for choosing the right adaptation strategy based on cost, data, and task needs. Review real examples where each approach wins.

Preparing Datasets for Fine-Tuning

Collect, clean, and format instruction and chat datasets in JSONL. Cover deduplication, quality filtering, and train and validation splits.

Supervised Fine-Tuning Workflow

Walk through the full SFT pipeline from loading a base model to training and saving checkpoints. Use Hugging Face Transformers and the Trainer API.

Hyperparameters and Training Diagnostics

Tune learning rate, batch size, and epochs while reading loss curves. Recognize overfitting, underfitting, and catastrophic forgetting.

Why Parameter-Efficient Methods Matter

Explore the memory and compute limits of full fine-tuning and how adapters reduce them. Survey the PEFT landscape.

LoRA Explained and Implemented

Understand low-rank adaptation mathematically and intuitively, then apply LoRA adapters with the PEFT library. Choose rank and alpha values sensibly.

Quantization and QLoRA

Load models in 4-bit and 8-bit precision and fine-tune them with QLoRA on a single GPU. Examine the quality and speed tradeoffs.

Merging, Saving and Serving Adapters

Merge adapters into base weights, publish models to the Hub, and serve multiple adapters efficiently. Cover versioning practices.

Instruction Tuning and Chat Templates

See how raw models become helpful assistants through instruction data and chat formatting. Avoid template mismatches that degrade output.

RLHF Concepts

Learn the stages of reinforcement learning from human feedback including reward models and policy optimization. Understand its strengths and challenges.

Direct Preference Optimization

Train with chosen and rejected response pairs using DPO as a simpler alternative to RLHF. Build a small preference dataset.

Synthetic Data Generation

Use strong models to generate and filter training data for smaller models. Discuss quality control, licensing, and bias amplification.

Agent Concepts and the ReAct Pattern

Understand the reasoning and acting loop that underpins most agents. Compare agents with fixed chains and workflows.

Function Calling and Tool Use

Define tool schemas, let models choose functions, and handle results and errors. Build agents that call search, calculators, and APIs.

Agent Memory and Planning

Implement short-term and long-term memory and task decomposition strategies. Explore planning and reflection techniques.

Agent Frameworks with LangGraph

Build stateful agent workflows as graphs with branching, loops, and human approval steps. Compare with other frameworks.

Evaluation Challenges and Benchmarks

Learn why evaluating generative output is hard and review benchmarks such as MMLU and HumanEval. Understand contamination and benchmark limits.

Automatic Metrics for Text Quality

Apply BLEU, ROUGE, and BERTScore and understand when they mislead. Choose metrics that fit each task.

LLM-as-a-Judge Techniques

Use models to grade outputs with rubrics and pairwise comparison. Detect and reduce judge bias.

Evaluating RAG and Agents

Measure retrieval quality, faithfulness, and answer relevance with tools like Ragas. Trace agent trajectories and tool-call accuracy.

Deploying and Serving Models

Serve models with vLLM and managed endpoints while balancing latency and throughput. Cover batching, streaming, and caching.

Observability and Tracing

Log prompts, responses, latency, and token usage using tracing tools such as LangSmith or Langfuse. Debug failures in production.

Cost and Performance Optimization

Reduce spend through model routing, prompt compression, caching, and smaller models. Set budgets and alerts.

Security, Privacy and Governance

Address prompt injection, data leakage, PII handling, and compliance requirements. Establish review and approval processes.

Building LLM Backends with FastAPI

Wrap prompts, RAG pipelines and model calls inside a clean REST API. Cover request validation, streaming responses and error handling.

Containerizing with Docker

Package an LLM service with its dependencies into a portable Docker image. Learn environment variables, secrets handling and image optimization.

Deploying to the Cloud

Deploy a containerized LLM app to a managed cloud service and expose it securely. Compare serverless, container and VM options.

Hosting Open Source Models

Serve open source models using tools such as vLLM and Ollama. Understand GPU requirements, batching and throughput tradeoffs.

Token Economics and Cost Control

Estimate and track the cost of LLM calls across providers. Apply budgets, limits and model selection strategies.

Caching and Request Batching

Use semantic caching, prompt caching and batching to cut repeated work. Measure savings against freshness requirements.

Quantization and Model Compression

Shrink models with 8-bit and 4-bit quantization and distillation ideas. Evaluate the quality and speed tradeoff.

Model Routing and Fallbacks

Route simple queries to small models and hard ones to larger models. Add retries and fallbacks for provider outages.

Introduction to LLMOps

Understand the lifecycle of an LLM product from experiment to production. Review versioning of prompts, models and datasets.

Tracing and Logging with LangSmith and Langfuse

Capture traces of chains, retrievals and tool calls to debug behavior. Inspect latency and token usage per step.

Monitoring Quality and Drift

Track output quality, user feedback and retrieval health over time. Detect drift and set up alerts.

CI/CD for LLM Applications

Automate tests, evaluations and deployments using GitHub Actions. Gate releases on evaluation scores.

LLM Threat Landscape and OWASP Top 10

Survey the main risks to LLM apps including injection, data leakage and excessive agency. Map each risk to a mitigation.

Prompt Injection and Jailbreak Defense

Practice attacking and hardening prompts and agents. Apply input isolation, output checks and least privilege for tools.

Guardrails and Content Moderation

Add input and output filters using moderation APIs and guardrail libraries. Enforce topic limits and structured output rules.

Hallucination Mitigation and Grounding

Reduce fabricated answers with grounding, citations and confidence checks. Design graceful refusal behavior.

Bias and Fairness in Generative Models

Identify sources of bias in training data and outputs. Test applications with fairness probes and mitigation methods.

Copyright, Licensing and Data Rights

Understand open model licenses, dataset provenance and content ownership questions. Learn practical steps to reduce legal exposure.

AI Regulation and Governance Frameworks

Review the EU AI Act, NIST AI RMF and organizational policy basics. Translate requirements into project checklists.

Transparency, Model Cards and Documentation

Document model behavior, limits and intended use with model cards and system cards. Communicate risk clearly to stakeholders.

Capstone Planning and Architecture

Choose a real world problem and define scope, success metrics and system design. Select models, data and tools for the build.

Capstone Build Sprint: Core Pipeline

Implement the main RAG or agent pipeline with prompts, retrieval and tool use. Receive mentor feedback on code and design.

Capstone Build Sprint: Deploy, Evaluate and Secure

Deploy the app, add evaluations, monitoring and guardrails, and fix issues found in testing. Prepare it for public demonstration.

Demo Day and Technical Presentation

Present the capstone to peers and mentors with a live demo and architecture walkthrough. Practice explaining tradeoffs and results.