Learn the fundamentals of generative AI for real-world applications - AWS x DeepLearning.AI

Delivers a sequenced learning path covering prompt engineering, fine-tuning, retrieval-augmented generation (RAG), and agent design through video lectures paired with Jupyter notebook labs. Uses a progressive complexity model starting with basic prompting techniques, advancing through parameter-efficient fine-tuning (LoRA, QLoRA), and culminating in multi-step reasoning architectures. Labs are pre-configured with AWS SageMaker integration points and pre-loaded datasets to minimize setup friction.

Provides a Jupyter-based environment where learners can write prompts, test them against multiple LLM backends (e.g., Claude, GPT, open-source models via SageMaker), and compare outputs side-by-side with configurable temperature, max_tokens, and system prompts. The sandbox logs all interactions, enabling learners to build intuition about how prompt variations affect model behavior without writing boilerplate API code.

Teaches and provides pre-configured code for fine-tuning large language models using Low-Rank Adaptation (LoRA) and Quantized LoRA (QLoRA), enabling learners to adapt 7B-70B parameter models on a single GPU with <24GB VRAM. The labs use Hugging Face Transformers, PEFT library, and bitsandbytes for quantization, with step-by-step walkthroughs of adapter configuration, training loops, and inference-time merging of adapters back into the base model.

Teaches the architecture and implementation of RAG systems through a modular curriculum covering document chunking strategies, embedding models, vector database indexing (using FAISS or similar), retrieval ranking, and prompt augmentation. Labs walk through building a complete RAG pipeline: ingesting documents, creating embeddings, storing in a vector index, retrieving relevant chunks for a query, and augmenting an LLM prompt with retrieved context. Includes evaluation metrics (BLEU, ROUGE, retrieval precision/recall) to measure RAG quality.

Teaches the architecture of agentic systems where an LLM iteratively reasons about a task, decides which tools to call (e.g., calculator, web search, database query), executes those tools, and incorporates results into the next reasoning step. Labs implement agents using function-calling APIs (OpenAI's tool_choice, Anthropic's tool_use), with explicit handling of tool selection logic, error recovery, and termination conditions. Covers both simple ReAct-style agents and more complex multi-step planning architectures.

Teaches systematic evaluation of LLM outputs using both automated metrics (BLEU, ROUGE, METEOR, BERTScore) and human evaluation frameworks. Labs implement evaluation pipelines that compare model outputs against reference answers, measure semantic similarity, and assess task-specific quality (e.g., code correctness, factual accuracy). Includes guidance on designing evaluation datasets, setting up human annotation workflows, and interpreting evaluation results to guide model selection and fine-tuning decisions.

Teaches strategies for reducing the cost and latency of LLM applications through model selection, quantization, caching, batching, and infrastructure choices. Labs compare the cost/quality trade-offs of different models (GPT-4 vs GPT-3.5 vs open-source), demonstrate quantization techniques (INT8, INT4) that reduce model size and inference latency, and show how to implement prompt caching and request batching to amortize API costs. Includes calculators to estimate total cost of ownership for different deployment architectures.

Teaches systematic approaches to prompt engineering beyond trial-and-error, including prompt structure templates (chain-of-thought, few-shot examples, role-playing), prompt optimization techniques (iterative refinement, A/B testing), and anti-patterns to avoid. Labs provide frameworks for documenting prompts, tracking versions, and measuring the impact of prompt changes on model outputs. Includes guidance on when prompt engineering is sufficient vs when fine-tuning or RAG is needed.

Covers safety, bias, and ethical considerations when building LLM applications, including techniques for detecting and mitigating bias, implementing content filtering and guardrails, and evaluating fairness across demographic groups. Labs include bias detection workflows, prompt injection attack simulations, and guidelines for responsible deployment (e.g., transparency about AI use, handling sensitive data). Emphasizes the importance of human oversight and the limitations of automated safety measures.