Final Projects: Build a Reproducible Generative-Model Experiment | CMU 10-423 Topic Guide
Design controlled comparisons, retain paired outcomes, and distinguish replication from working code in a generative-model project.
#cmu
174 postsAutodiff in Practice: From Hand Gradients to a Training Loop | CMU 10-423 Assignment 0
Knowing that backpropagation uses the chain rule is different from implementing a correct training loop.
Paper Reports: Turn a Model Summary into a Testable Argument | CMU 10-423 Assignment 623
Separate paper claims, empirical support, and your own interpretation through a role-based report and a controlled-comparison example.
Causal Attention: From Q, K, and V to the Next Token | CMU 10-423 Lecture 2
An RNN compresses the prefix into a state.
Training and Decoding: Why the Same Logits Produce Different Sequences | CMU 10-423 Lecture 3
Learning a next-token distribution and choosing a token from that distribution are consecutive but distinct operations.
Diffusion Training and Sampling: Random Timesteps and Reverse Chains | CMU 10-423 Lecture 8
Lecture 7 constructed noisy inputs and noise targets.
VAEs: Reconstruction, KL, and Reparameterization | CMU 10-423 Lecture 9
A conventional autoencoder compresses an input into a vector and reconstructs it.
ICL, SFT, and RLHF: From Changing Inputs to Changing Weights | CMU 10-423 Lecture 11
Separate what ICL, SFT, reward models, and RLHF each change, with worked examples and answered variations.
DPO and Latent Diffusion: Updating on Preferences, Conditioning the Denoiser | CMU 10-423 Lecture 12
Derive the DPO loss with a recomputable example, then trace shapes and conditioning paths in latent diffusion.
Vision-Language Models: Turning Images into Language-Model Inputs | CMU 10-423 Lecture 13
A complete worked example and answered variations for Vision-Language Models: Turning Images into Language-Model Inputs.
Cross-Attention and DiT: How Conditions Enter a Denoiser | CMU 10-423 Lecture 14
A complete worked example and answered variations for Cross-Attention and DiT: How Conditions Enter a Denoiser.
Q-Former and Scaling Laws: Bridging Frozen Models, Allocating a Fixed Budget | CMU 10-423 Lecture 15
Trace Q-Former queries and two-stage training, then compute a model/data split under a fixed compute budget.
Mixture of Experts: Separating Capacity from Active Computation | CMU 10-423 Lecture 16
A complete worked example and answered variations for Mixture of Experts: Separating Capacity from Active Computation.
Distributed Training: Splitting Data, Models, and Optimizer State | CMU 10-423 Lecture 17
A complete worked example and answered variations for Distributed Training: Splitting Data, Models, and Optimizer State.
Efficient Inference: FlashAttention, KV Caches, and Speculative Decoding | CMU 10-423 Lecture 18
A complete worked example and answered variations for Efficient Inference: FlashAttention, KV Caches, and Speculative Decoding.
Long Context: Fitting Input Is Not Reliable Retrieval | CMU 10-423 Lecture 19
Long Context: Fitting Input Is Not Reliable Retrieval | CMU 10-423 Lecture 19
State Space Models: From Recurrence to Convolution | CMU 10-423 Lecture 21
State Space Models: From Recurrence to Convolution | CMU 10-423 Lecture 21
Generative AI Risks: Turning Failures into Tests | CMU 10-423 Lecture 22
Generative AI Risks: Turning Failures into Tests | CMU 10-423 Lecture 22
Audio Understanding and Generation: Samples to Text, Tokens Back to Sound | CMU 10-423 Lecture 24
Compute frames, mel bins, and WER, then account for codec tokens and contrast diffusion sampling.
Video Generation: Modeling the Time Axis | CMU 10-423 Lecture 25
Video Generation: Modeling the Time Axis | CMU 10-423 Lecture 25
World Models and Alignment Theory: Action Interventions and Corrigibility Assumptions | CMU 10-423 Lecture 26
Separate three world representations and evidence of action control, then examine consensus costs and corrigibility theorem conditions.
LoRA: What Changes When Most Weights Stay Frozen | CMU 10-423 Lecture 10
A complete worked example and answered variations for LoRA: What Changes When Most Weights Stay Frozen.
Practice Exam: Diagnose Conceptual Gaps | CMU 10-423 Topic Guide
Use the public practice exam to diagnose assumptions, data flow, and evaluation errors through a worked probability example.
Reinforcement Learning Systems: Connecting Inference and Training | CMU 11-768 Lecture 12
An RL system samples with an inference engine, assigns rewards through verification, recomputes logprobs and gradients in a trainer, then synchronizes new weights back to inference. Walk through these five stages in an invented example before examining caching, preserved histories, and asynchronous updates.
Agent Safety — Four Threat Models and Three Limits: Sandboxes, Credential Brokering, Monitoring | CMU 11-768 Lecture 13
Lecture 13 is about limiting what agents can access and do. The slides open with five real incidents, sort them into four threat models (malicious user, prompt injection, agent error, improper means), then give four layers of defense: red teaming and safety training, sandboxes and credential brokering, monitoring, and safety evaluation. The easiest point to miss: hiding the API key does not stop an agent from misusing the access behind it.
OpenHands — A Coding-Agent Framework That Went from Research Prototype to Thousands of Automated Runs | CMU 11-768 Lecture 14
Graham Neubig uses OpenHands, which he leads, to explain framework design: how coding agents evolved from HumanEval, SWE-bench and Devin to 2026's long-running, interruptible, parallel work; the parts of the Software Agent SDK (LLM, tools, conversation, condenser, workspace, confirmation policy); the single- vs. multi-agent trade-off; local vs. cloud and four interfaces (IDE, GUI, CLI, integrations); automations wired to issues and PRs; and revising skills from past trajectories.
Audio, Video, and World Models: A Reading Map | CMU 10-423 Topic Guide
Audio representation, temporal relationships in video, and action-conditioned world transitions are different learning tasks. The earlier combined guide checked only audio at the end. This URL now serves as a reading map to one full guide each for Lectures 24–26; the Lecture 26 guide also covers the separate alignment deck.
CNNs and ViT: Turning an Image into Model Inputs | CMU 10-423 Lecture 5
Text models convert text into tokens; image models also need a computational representation of pixels.
Code Generation and Agents: A Reliable Test–Repair Loop | CMU 10-423 Lecture 23
Code Generation and Agents: A Reliable Test–Repair Loop | CMU 10-423 Lecture 23
Condition Injection: The Roles of Attention, DiT, and Q-Former | CMU 10-423 Topic Guide
Cross-attention reads another representation, DiT is a diffusion-backbone choice, and Q-Former uses learned queries to extract or bridge information. They can coexist rather than being three competing products. The Lecture 14 lesson handles Prompt-to-Prompt and classifier-free guidance in detail.
Diffusion Models: Why Adding Noise Creates a Training Task | CMU 10-423 Lecture 7
A GAN learns from a discriminator.
Distributed Training and Efficient Inference: Locate the Cost | CMU 10-423 Topic Guide
A model that does not fit on one GPU has a different problem from a model that fits but decodes slowly. Distributed strategies partition data, parameters, and states. FlashAttention improves attention memory traffic; KV caching avoids recomputing historical keys and values during decoding.
Exams, Papers, and Projects: Three Forms of Learning Evidence | CMU 10-423 Topic Guide
An exam tests reasoning under a fixed question. A paper report tests your judgment of someone else’s evidence. A project tests your ability to produce reproducible evidence. These are distinct learning tasks, now taught separately while this URL remains an assessment map.
GANs: What the Generator and Discriminator Learn | CMU 10-423 Lecture 6
A classifier asks which class an image belongs to.
A Generative AI Learning Path: Reading the 35 Core Guides | CMU 10-423 Course Overview
This series uses the public Spring 2026 materials for CMU 10-423/623/723 Generative AI.
Testing minGPT Changes: Shapes, Masks, and Positions | CMU 10-423 Assignment 1
Assignment 1 brings sequence modeling and modern attention into code.
Testing DDPM: Matching Timestep Coefficients to a Batch | CMU 10-423 Assignment 2
Copying a noising equation is not enough to implement diffusion correctly.
Testing LoRA Fine-Tuning: Gradients, Data, and Evaluation | CMU 10-423 Assignment 3
Use an original numerical test to check gradients, data, and evaluation alongside the original assignment specification.
Testing Q-Former Text-to-Image: Gradients through Frozen Backbones | CMU 10-423 Assignment 4
Use an original numerical test to check gradients, data, and evaluation alongside the original assignment specification.
SFT, RLHF, and DPO: Separate Their Training Signals | CMU 10-423 Topic Guide
A prompt with one demonstrated answer is not the same data as a prompt with a preferred and rejected response. SFT learns demonstrated tokens. A typical RLHF pipeline learns reward and then updates a constrained policy. DPO forms a loss directly from preference pairs and reference-relative ratios.
Long Context and SSMs: Different Ways to Retain History | CMU 10-423 Topic Guide
Long-context evaluation asks whether a model can process, retrieve, and use distant information. An SSM specifies sequence processing through state updates. SSM efficiency does not establish reliable document retrieval, and a large attention window does not guarantee relevant evidence is used.
Modern Transformers: What Position Rotation and KV Sharing Change | CMU 10-423 Lecture 4
Attention needs both order information and a manageable memory footprint during generation.
PEFT and ICL: Change Parameters or Change the Input | CMU 10-423 Topic Guide
Adapting without retraining every weight can mean two different things. LoRA-style PEFT still trains some parameters. ICL supplies examples in context without updating parameters during that inference. The source spans the end of Lecture 9, Lecture 10, and the ICL material in Lecture 11.
Reasoning Models: Spending Compute on Verifiable Answers | CMU 10-423 Lecture 20
Reasoning Models: Spending Compute on Verifiable Answers | CMU 10-423 Lecture 20
Operational Risks and Alignment Theory: Tests and Assumptions | CMU 10-423 Topic Guide
Hallucination, leakage, and prompt injection are observable operational risks. Alignment theory asks which guarantees hold under specific formal assumptions. They require different evidence. Lectures 22 and 26 therefore have separate teaching guides, without turning one theorem into a universal impossibility claim.
RNN Language Models: Sequence Probabilities and Gradient Paths | CMU 10-423 Lecture 1
A sequence such as “I like cats” is not a bag of independent words.
Scaling and MoE: Compute Budgets and Conditional Computation | CMU 10-423 Topic Guide
Scaling laws study model and data allocation under a budget. MoE increases expert capacity while activating selected experts. The former concerns allocation and empirical models; the latter concerns architecture and routing. Both deserve separate checks.
Text-to-Image and VLMs: Generating Images versus Reading Them | CMU 10-423 Topic Guide
“Text plus images” does not specify the task. Text-to-image generation produces an image conditioned on text; a VLM may consume an image and produce an answer. Direction, output objective, and evaluation differ even when both use Transformers.
Transformer, Training, and Decoding: Three Different Questions | CMU 10-423 Topic Guide
How the model reads a history, learns from targets, and chooses its next token are different questions. Attention mixes information; the training objective updates parameters; decoding selects output under a fixed model. Keeping them distinct prevents confusing a sampling change with a model update.
Diffusion and VAEs: Related Objectives, Different Generation Paths | CMU 10-423 Topic Guide
Diffusion and VAEs share probabilistic ideas without sharing the same generation procedure. Diffusion chains noise steps; a VAE approximates a latent posterior with an encoder and reconstructs through a decoder. This guide connects those ideas while directing each mechanism to its own lesson.
Accelerating Transformers on GPUs, and Where LightSeq Finds the Time | CMU 11-868 Lecture 10
Lecture 10 of 11-868 uses Lei Li's own LightSeq and LightSeq2 as the case study and breaks them into four techniques: fuse every small operation outside matrix multiplication into one kernel, rewrite the LayerNorm and Softmax formulas to cut thread synchronizations, store parameters and gradients in FP16 but compute updates in FP32, and reuse memory based on backward-pass dependencies. The slides report 1.4-3.5x training speedups on WMT14 English-German. The official syllabus lists no public recording link; this guide works from slide page numbers and the two papers.
Distributed Training and Data Parallelism, and Where Gradient Sync Costs Come From | CMU 11-868 Lectures 14–15
Lectures 14 and 15 of 11-868 go from the parameter server to PyTorch DDP. They use NCCL's five collectives (Broadcast, Reduce, AllReduce, ReduceScatter, AllGather) as building blocks, show why a ring makes broadcast time nearly independent of GPU count, and split AllReduce into ReduceScatter plus AllGather. The second lecture takes apart DDP's two key designs: bucketing gradients (25 MB by default) and starting synchronization before the backward pass finishes. The official syllabus lists no public recording link; this guide works from slide page numbers and the VLDB 2020 paper.
How a Deep Learning Framework Computes Gradients from a Computation Graph | CMU 11-868 Lecture 5
L05 follows a small sentiment classification network throughout. It expresses computation as a graph, evaluates it in topological order, sends gradients back with the chain rule and vector-Jacobian products, and then takes apart TensorFlow v1's placeholder, variable, operation, and session. One slide is labeled "important for HW2".
FlashAttention: Attention Is Slow Because of Data Movement, Not Math — Tri Dao from FA1 to FA4 | CMU 11-868 Lecture 21
Standard attention writes the N×N score matrix out to HBM and reads it back, and most of its time goes to that traffic. FlashAttention uses tiling plus softmax rescaling so each block finishes inside SRAM, and the backward pass recomputes instead of storing. Tri Dao's guest slides for 11-868 give one set of numbers: the backward pass does 13% more FLOPs, 9x less HBM traffic, and runs 6x faster. FA3 and FA4 follow the same theme: when the hardware changes, the bottleneck moves, and the algorithm has to move with it.
GPU Programming and Acceleration: Threads, Blocks, the Memory Hierarchy, and Tiling | CMU 11-868 Lectures 2–4
CMU 11-868's three GPU lectures answer one question: why does a correct CUDA matmul use only 2.48% of an A100's FP32 compute? L02 covers SMs, warps, and the grid/block/thread hierarchy. L03 covers cudaMalloc, cudaMemcpy, and kernel indexing. L04 uses tiling, coalesced access, and bank-conflict avoidance to bring data closer than global memory, which sits about 500 cycles away.
Writing MiniTorch's map, zip, reduce, and matmul in CUDA | CMU 11-868 Assignment 1
The first 11-868 assignment has you write four CUDA kernels in src/combine.cu (map 15, zip 25, reduce 25, matmul 30 points), wire them into MiniTorch's Python backend, and finish with a 5-point integration test. Shared-memory optimizations for reduce and matmul are marked Optional. The assignment page says plainly that you need a GPU, and grading uses private test cases.
Implementing Autodiff in MiniTorch and Training a Sentiment Classifier | CMU 11-868 Assignment 2
The second 11-868 assignment has three parts: autodiff's topological_sort and backpropagate (40 points), a Linear layer and MLP network (30), and binary cross entropy plus the training loop (30). You then train a sentiment classifier on SST-2 with GloVe embeddings and must reach 75% validation accuracy. The default backend is the CUDA kernels from Assignment 1, and the repo merged small Fall 2026 fixes on 2026-09-02.
Build GPT-2 in Your Own MiniTorch and Make It Translate German | CMU 11-868 Assignment 3
HW3 has you add softmax loss, Dropout, LayerNorm, and Embedding to the MiniTorch you built in HW1 and HW2, assemble a pre-LN GPT-2 decoder, and train it on IWSLT14 German-English translation. Points: tensor functions 20, basic modules 20, decoder LM 40, translation pipeline 20. Full marks require passing the private tests and a BLEU of about 20±2. The assignment page warns that training alone takes at least 10 hours: one epoch is about an hour on a PSC V100, and you need 10. In Spring 2026 it went out Feb 4 and was due Feb 18.
Writing Softmax and LayerNorm as Fused CUDA Kernels | CMU 11-868 Assignment 4
The fourth 11-868 assignment has you follow LightSeq and hand-write CUDA kernels for attention softmax and LayerNorm (forward and backward), bind them into your own MiniTorch, then swap them into your HW3 Transformer and train for one epoch. Points: Softmax 40, LayerNorm 40, integration 20. The assignment page expects individual kernels to be 3.7x to 15.8x faster, but end-to-end training only about 1.1x faster, because of Amdahl's law. You need an NVIDIA GPU, and the repo has already been changed for Fall 2026.
Writing Data Parallelism and Pipeline Parallelism Yourself on Two GPUs | CMU 11-868 Assignment 5
CMU 11-868's fifth assignment switches to PyTorch and Hugging Face GPT-2. Using only torch.distributed and torch.multiprocessing, you write data parallelism (partition the data, set up a process group, average gradients; 50 points), then a GPipe-style pipeline (split the model, generate a clock schedule, run micro-batches on worker threads; 50 points). Both parts need benchmarks and plots on at least two GPUs: data parallelism must reach at least 1.5x speedup on 2 GPUs, and the pipeline must beat plain model parallelism. The Spring 2026 deadline was 3/25.
Training Llama-2-7B with DeepSpeed ZeRO + LoRA, Serving with SGLang | CMU 11-868 Assignment 6
The sixth 11-868 assignment is the first to set aside your homemade MiniTorch and use industry frameworks. Two problems, 50 points each. Problem 1: edit a DeepSpeed training script to turn on LoRA so Llama-2-7B can train on two 16GB V100s. Problem 2: fill in the TODOs of an SGLang inference script and tune parameters to make generation faster. The two problems want conflicting GPUs: SGLang doesn't support V100, so you need an L40S, A6000, or A100. The spring due date was April 13, and the assignment page publishes no grading tests.
A VERL-Style Pipeline with a Reward Model, GAE, and PPO | CMU 11-868 Assignment 7
11-868's RL systems lecture has no slides; the Syllabus lists just one paper, ReaLHF. Assignment 7, on the other hand, is fully public. You train a DistilBERT reward model on Anthropic's HH-RLHF data (40 points), fill in GAE, the PPO loss, and entropy in a VERL-style trainer to fine-tune GPT-2 (40 points), and compare reward distributions before and after RLHF (20 points). The starter trainer never imports the verl package. What you learn is the RLHF dataflow, not VERL's distributed engine.
Why LLMs Need Systems — the Scale Curve, Low-Level Operators, and Three Layers of Abstraction | CMU 11-868 Lecture 1
CMU 11-868's first lecture spends 51 slides on one argument: the LLM bottleneck isn't only the model, it's computing larger LLMs on bigger datasets with fewer GPUs, less memory, and less power, faster. It breaks a Transformer into four low-level operators (matrix multiply, reduction, map, memory movement), sorts the hard problems into kernel, framework, and distributed-system layers, and warns that fast computation isn't enough because moving data takes time too.
LLM Serving: Scheduling, RadixAttention, and PagedAttention | CMU 11-868 Lecture 22 / Lecture 24
11-868 spends two lectures on one question: how does an inference server handle many requests at once without wasting KV cache on the GPU? Lecture 22 (Lei Li) starts from SGLang's scheduling loop: ORCA's continuous batching, RadixAttention's radix tree for KV, sorting and routing by prefix hit rate, and hiding CPU scheduling behind GPU compute. Lecture 24 is given by vLLM author Woosuk Kwon: PagedAttention cuts KV cache into fixed-size blocks and virtualizes them with a block table, taking the batch on one A100 from 8 to 40. The second half covers how vLLM cuts CPU overhead, uses piecewise CUDA graphs, splits models across GPUs, and manages memory for hybrid architectures.
LLM Systems: A Learning Path through Training, Inference, and Deployment | CMU 11-868 Course Overview
CMU 11-868 is Lei Li's graduate course on LLM systems: it goes from CUDA kernels and your own MiniTorch framework to distributed training, SGLang serving, and RLHF. All 28 Spring 2026 slide decks, 7 assignment pages, and 7 starter-code repos are public, which rates it A3. What's missing: videos, GPUs and a PSC account, the quizzes, and any official statement of which two assignments are optional.
When a Model Won't Fit on One GPU — Split Layers, Matrices, or Experts | CMU 11-868 Lectures 16–17
CMU 11-868 (Spring 2026) spends two lectures on models too big for one GPU. L16 covers pipeline parallelism, which splits layers (GPipe micro-batches, 1F1B, interleaved stages), and tensor parallelism, which splits matrices (Megatron-LM's cuts for FFN, attention, and embeddings). The rule of thumb: TP inside a node, PP across nodes, DP on top. L17 treats MoE as a third way to split: each GPU holds different experts and replicates everything else. The price is all-to-all communication and load balancing, shown through GShard, DeepSpeed-MoE, and DeepSeek-V3.
Model Quantization: GPTQ Saves Memory, and the Speedup Comes Along for the Ride | CMU 11-868 Lectures 19–20
11-868 spends two lectures on quantization. L19 goes from BF16 and absmax/zero-point quantization to AdaQuant, ZeroQuant, and LLM.int8(). L20 is all GPTQ. GPTQ quantizes weights only: after each column is quantized, it uses second-order information to adjust the weights not yet quantized, and lazy batch updates plus a Cholesky trick let it scale to 175B. What it mainly saves is memory. Inference gets faster because single-batch decoding was already bottlenecked on reading weights; the amount of arithmetic does not shrink.
Efficient Fine-Tuning for Large Models: LoRA, CIAT, and QLoRA | CMU 11-868 Lecture 23
Lecture 23 of 11-868 treats fine-tuning as a memory problem. Full-parameter half-precision fine-tuning of LLaMA-8B needs about 80GB. LoRA brings that to about 33GB, and QLoRA, which stores the frozen weights in 4 bits, gets it to about 9.2GB. The lecture moves in three steps: train only two small low-rank matrices A and B (the slides credit CIAT as the first to do this); squeeze frozen weights to about 0.52 bytes per parameter with an NF4 lookup table and double quantization; and use a paged optimizer to push optimizer state to the CPU when the GPU is about to run out.
Prefill/Decode Disaggregation, KV Cache, and Heterogeneous Hardware | CMU 11-868 Topic Guide
11-868 closes with five serving decks: Hao Zhang on DistServe, Vikram Mailthody on NVIDIA Dynamo, Junchen Jiang on LMCache, Mingxing Zhang on Mooncake and KTransformers, and Lei Li's map of serving frameworks. They share one question: once serving grows from one machine to a data center, where do the compute and the KV cache go? The argument runs in three steps. Measure goodput under latency SLOs instead of raw throughput. Put prefill and decode on separate GPUs. Let the KV cache spill from GPU memory into CPU memory, SSDs, and remote storage.
Choosing a Vocabulary, Emitting Tokens, and Why Speculative Decoding Is Fast | CMU 11-868 Lectures 8–9
L08 goes from BPE to VOLT, a method co-authored by the lecturer Lei Li: vocabulary size has both a cost and a value, and VOLT finds the sweet spot by asking how much normalized entropy each added token removes, then solves it as an optimal transport problem. The second half covers LLaMA 3 growing its vocabulary from 32k to 128k and the cost of byte-level BPE splitting one Chinese character into three tokens. L09 moves from greedy decoding, sampling, and beam search to speculative decoding: a small model guesses N tokens and the big model checks them in one forward pass, because checking is cheaper than generating. It ends with EAGLE, which predicts final-layer features instead of tokens.
TPU, JAX, and Pallas: One Attention Kernel on TPU, from XLA Fusions to Splash Attention | CMU 11-868 Lectures 12–13
Across two lectures and more than 200 slides, Google's Srinath Mandalapu traces one attention computation from Python down to TPU VLIW instructions. L12 covers the JAX ecosystem, the memory and compute units of TPU Ironwood, and how XLA compiles attention into three fused kernels. L13 covers what XLA cannot do: using Pallas to control movement between HBM and VMEM yourself, writing FlashAttention, then adding block sparsity to get Splash Attention. The ideas match the GPU version. The difference is that on TPU the compiler does most of the scheduling, and Pallas is how you take loops and block sizes back into your own hands.
Reading Transformers, T5, LLaMA, and GPT-3 Like a Systems Engineer | CMU 11-868 Lectures 6–7
11-868 spends only two lectures on the model itself. L06 breaks the Transformer into embeddings, multi-head attention, FFN, LayerNorm, and residuals; L07 uses T5, LLaMA, and GPT-3 to show what modern LLMs changed. For a systems engineer the point is to remember the shapes: GPT-3 175B has 96 layers, d_model 12288, a 2048-token context, and trained on 300B tokens; LLaMA 65B has 80 layers, d_model 8192, and trained on 1.4T tokens. Those numbers set the workload for every acceleration, parallelism, and serving lecture that follows.
How ZeRO Cuts Data-Parallel Memory — Optimizer State, Gradients, Then Parameters | CMU 11-868 Lecture 18
Data parallelism keeps a full copy of parameters, gradients, and optimizer state on every GPU. With Adam and mixed precision that is about 20 bytes per parameter, 16 of them optimizer-related, so LLaMA-3 8B already needs 160GB. CMU 11-868 L18 builds on the ZeRO paper and animates its three stages frame by frame: ZeRO-1 partitions optimizer state, ZeRO-2 also partitions gradients, and ZeRO-3 partitions parameters too. The slides conclude that the first two stages add no communication and save up to 8x memory; stage 3 makes per-GPU memory shrink with GPU count, at what the slides estimate as about 3x the communication.
Build an Agent Harness by Hand — One ReAct Loop to Fix Bugs, Compact Context, and Play Chess | CMU 11-768 Assignment 1
CMU 11-768's first assignment starts from an empty ReAct loop: a bash-only CodeAgent fixes a bug in a chess app, context compaction is added to solve a SWE-bench task, and the same loop becomes a ChessAgent that runs a two-ply search with simulate_move, run_python, and a skill. All 100 points are graded by replaying submitted patches and trajectories offline.
Writing a Validator for a Data-Visualization Agent — Four Error Families, MCC, and Harbor Verifiers | CMU 11-768 Assignment 2
11-768's Assignment 2 has students use one fixed judge, Qwen3-VL-30B-A3B, to flag four error families in every run of a data-visualization agent, graded by the mean MCC across families on a private set (30% of the assignment). The second half packages students' own tasks as Harbor environments, with one wrong solution the verifier rejects and one that fools it. The theme: the grader you write becomes the RL reward later.
An Agents Course You Can't Take Without Having Trained a Language Model, With Three Assignments From Harness to Eval to RL | CMU 11-768 Course Overview
CMU 11-768 is a new Fall 2026 graduate course on agents taught by Graham Neubig and Daniel Fried. The prerequisite — prior experience training language models — is strictly enforced. Its 23 lectures run from tool calling, context, memory, and planning through SFT, RL, sandboxing, and human-agent interaction. Three individual assignments in the first half build a harness, an evaluation, and a training pipeline; the second half is a team research project. Slides and the first ten lecture videos are public.
An Agent Is a Model in a Loop — the Hard Part Is Making It Work | CMU 11-768 Lecture 1
Lecture 1 of 11-768 strips an agent to its minimum: tool definitions and tool calls are just tokens, the harness parses, executes, and feeds results back into context, and running a ReAct loop makes it an agent. Neubig then lists six capabilities a good agent needs, each of which can be built through training or through the harness, and argues that an agent is a system of harness, sandbox, inference, training, and monitoring — not just a model.
How Tool Use Turns Tokens into Actions — Schemas, Constrained Decoding, MCP, and Parallel Calls | CMU 11-768 Lecture 2
Neubig splits tool use into five layers: capabilities, mechanics, constraints, interfaces, and systems. A tool call is just tokens the model emits; the harness parses, validates, and matches results back by call ID. Constrained decoding guarantees form, not correctness. MCP's real value is credential brokering. And the same model served by different providers can swing from roughly 15% tool-call errors to under 0.1%.
How Long-Context Agents Manage Memory — Hybrid Attention, RoPE Extension, Prompt Caching, and Compaction | CMU 11-768 Lecture 3
An agent resends its whole history on every call, so five calls already add up to 80K input tokens; 1,500 OpenHands sessions averaged 78K tokens, 37% of them tool results. Neubig works on two layers: at the model layer, hybrid attention (many local layers, one global) plus length curricula make million-token context possible; at the harness layer, stable prefixes earn cache reads roughly ten times cheaper, and compaction that keeps anchors and externalizes evidence gets past the limit — evaluated by how the agent continues afterwards.
Skills and Memory — How Agents Stop Starting Over | CMU 11-768 Lecture 4
Lecture 4 of CMU 11-768 sorts cross-task experience into episodes, facts, and skills, stored as external artifacts rather than in context or weights. Human-written skills load through SKILL.md and progressive disclosure, lifting the average SkillsBench pass rate from 33.9% to 50.5%. Skills an agent induces itself can be tested before admission when written as code, but break easily on a new website. The hard part is the lifecycle: imperfect judges, over-retrieval, and bloated skill libraries each eat into the gains.
Planning — When an Agent Should Think It Through, and When It Should Revise as It Goes | CMU 11-768 Lecture 5
Lecture 5 of CMU 11-768 defines an agent's plan as an explicit, inspectable, revisable representation of intended behavior for this task, and gives four reasons to add planning structure: modularity, environment feedback, long horizons, and control. Fried's own MACU has a manager decompose tasks into a DAG and dispatch parallel sub-agents, raising Odysseys success from 8.5% to 34.0%; on an OSWorld subset, no planning scores 25.0%, an initial DAG with no revisions scores 27.8%, and allowing 10 revisions reaches 58.3%.
Coding Agents — From Completing a Line to Fixing a Whole Repo | CMU 11-768 Lecture 6
Neubig's L6 splits coding agents into three layers: train a model that can code (pre-training, mid-training, infilling, RL from test rewards), wrap it in a localize–edit–verify loop with the right editing tools so it can change a repo, then evaluate and train it in SWE-bench-style executable environments. Fixing bugs is only about 15% of a developer's day; the next frontier is tests, CI, and maintenance in the outer loop.
How Computer Use Agents See the Screen, Get Graded, and Get Trained | CMU 11-768 Lecture 7
JY Koh breaks computer use agents into three questions: evaluation has moved from single clicks (ScreenSpot-Pro, Mind2Web) to programmatic end-state checks (WebArena, OSWorld), VLM judges, and long-horizon rubrics (Odysseys, OSWorld 2.0); the model is a VLM reading interleaved screenshots and actions; training runs pre-training for grounding → SFT on human and synthetic trajectories → RL in resettable simulated environments.
How to Do SFT for Agents — Loss Masks, Trajectory Selection, Data Formats, and the Handoff to RL | CMU 11-768 Lecture 8
Yueqi Song breaks agent SFT into six decisions: compute loss on assistant tokens only (including the stop token); choose trajectories carefully (runs that pass tests can still teach bad habits, and switching teachers or adding new tasks beats sampling more); unify formats with the Agent Data Protocol; watch packing and template drift during training; evaluate in the real harness; and pick the SFT checkpoint for the RL that follows, not for its own best score.
RL Basics — a Policy Gradient Is Just an SFT Loss Times a Weight | CMU 11-768 Lecture 9
Using a guess-a-number-from-1-to-16 game, Daniel Fried frames RL as an extension of SFT: he names SFT's three gaps (task mismatch, no learning from failures, never seeing its own mistakes), then derives ReST, REINFORCE, baselines, and GRPO/DrGRPO in turn. All four compute log-probabilities of the tokens the agent itself generated; they differ only in the weight each token gets.
How to Evaluate, Train, and Retrieve for Deep Research Agents | CMU 11-768 Lecture 10
Akari Asai's L10 splits deep research agents into three problems: evaluation has to cover four gaps (search difficulty, domain expertise, long-form answer quality, citation support); training runs mid-training → SFT → RL, with DR Tulu's evolving rubrics as the reward for long-form reports; retrieval should let the retriever see the agent's reasoning, which gets AgentIR-4B to 68% on BrowseComp-Plus with Tongyi-DR.
Advanced RL Algorithms — Credit Assignment, Stable Updates, Reward Hacking, and Distillation | CMU 11-768 Lecture 11
Using a bug-fix coding task, Graham Neubig takes Lecture 9's policy gradient into practice: a critic, GAE, or a PRM to credit individual turns; importance ratios and clipping to handle stale data in async RL; and PPO, GRPO, CISPO, GSPO, and DAPO side by side in one table. The largest share goes to the reward itself — verifier errors, reward hacking, and exploration collapse — before closing with on-policy distillation.
Logic and the Hybrid Wumpus Agent, Logical Inference Plus A* Planning | CMU 07-380 Assignment 1
The HW1 programming assignment turns Lec2's entailment into a Pacman take on the Wumpus agent. Q1–Q2 warm up with Expr and pycosat. Q3–Q5 write the PKE percept rule, build the KB, and use two SAT calls to decide SAFE, NOT_SAFE or UNSURE. Q6–Q7 use the provided A* helpers to build an exploration agent and a three-tier hybrid agent. The starter code and local autograder are public; the Gradescope online questions are CMU-only. No solutions here.
Classical and Motion Planning, from Robot-Cook PDDL to RRT* to Graphing LPs | CMU 07-380 Assignment 2
07-380 HW2 has three parts. The programming assignment has you write PDDL for a pancake-cooking robot, solve it optimally with unified-planning and Fast Downward, then implement RRT and RRT* in rrt.py (Q2–Q7). The written part covers GraphPlan, one LP modeling problem, and two LP graphing problems. A Gradescope online component is CMU-only. This guide covers structure, prerequisites, and running the local autograder; it contains no solutions.
Optimization, Writing Your Own LP Solver and Branch and Bound, With PCA and MAP on Paper | CMU 07-380 Assignment 3
HW3 has three parts. The programming part has you build an LP solver by vertex enumeration, stack branch and bound on top of it for integer programs, and formulate three word problems. The written part covers integer programming by hand, the ethics of Amazon's delivery routing, PCA via SVD, and a proof that a Laplace prior equals L1. It is due 10/1, so this guide explains structure and concepts only, with no solutions.
Introduction, and What AI & ML II Adds After 07-280 | CMU 07-380 Lecture 1
07-380 Lec1 has no algorithms. It sets up three things: the working definition that intelligence means doing well on a task under uncertainty, a bubble diagram that color-codes 07-280 topics against the new 07-380 topics, and a grading scheme with quizzes at 55%, no final exam, and a final project. Off-campus readers can use it to place the other 25 lectures.
Logical Agents, Proving a Square Safe with Model Checking, DPLL and Forward Chaining | CMU 07-380 Lecture 2
Lec2 turns 'is this square safe?' in Minesweeper and Wumpus World into an entailment question: KB ⊨ α exactly when KB ∧ ¬α is unsatisfiable. Three ways to answer it: TT-ENTAILS, which enumerates every model; DPLL, which adds early termination, pure symbols and unit clauses to backtracking; and forward chaining, which accepts only definite clauses and runs in linear time. Resolution sits in the appendix, marked out of scope.
Classical Planning, PDDL, State-Space Search, and Relaxation Heuristics | CMU 07-380 Lecture 3
07-380 Lec3 replaces propositional successor-state axioms with STRIPS actions (pre/add/del sets), which turns planning back into state-space search. When that search is too large, GraphPlan lets actions run in parallel and never deletes facts, and delete relaxation drops delete effects entirely, yielding the heuristics behind FF and Fast Downward.
Motion Planning, RRT Samples Its Way Through Continuous Space | CMU 07-380 Lecture 4
The second half of 07-380 Lec4 moves planning into continuous configuration space. States can no longer be enumerated, so RRT samples a random point, extends the nearest tree node a short step toward it, and checks the whole segment for collisions. RRT is probabilistically complete but not optimal; RRT* uses tree path costs to pick a better parent and rewire neighbors, so the path converges to optimal as samples grow.
Linear Programming, and Why the Optimum Sits at a Vertex of the Feasible Region | CMU 07-380 Lecture 5
07-380 Lec5 turns the Diet Problem from words into min cᵀx s.t. Ax ⪯ b, then draws it: each constraint is a half-plane, the cost is a direction, and cost contours are perpendicular to c. Push a contour in the −c direction until it last touches the feasible region and you always hit a vertex, so solvers only need the intersections of constraint boundaries. Vertex enumeration checks them all; simplex walks greedily from one vertex to a better neighbor.
Integer Programming, Relax to an LP and Branch and Bound | CMU 07-380 Lecture 6
07-380 Lec6 adds one constraint to an LP, x ∈ ℤᴺ, and the vertex solution may no longer be an integer. Searching the integer points near the LP solution is not guaranteed to work either. The fix: drop the integer constraint (relaxation) to get an LP lower bound, split on a fractional coordinate into xᵢ ≤ floor and xᵢ ≥ ceil, and keep every subproblem in a priority queue ordered by LP objective. The first all-integer solution popped is optimal.
Low Rank Optimization, PCA's Reconstruction Error, Projected Variance, and LoRA | CMU 07-380 Lecture 7
07-380 Lec7 frames PCA as low-rank optimization: approximate the data with a matrix of rank at most r. For a unit vector v, each point's reconstruction error equals ‖x‖² minus the squared projection length, so minimizing reconstruction error and maximizing projected variance are the same problem. Lagrange multipliers show the answer is an eigenvector of the covariance matrix, which you can also read straight off the V in the SVD. The site lists the LoRA paper as reading; its ΔW = BA applies the same low-rank idea to weight updates.
MAP, How Priors Enter Estimation and Why That Equals Regularization | CMU 07-380 Lecture 8
Lecture 8 swaps MLE's argmax p(D|θ) for argmax p(θ|D). The prior p(θ) multiplies the likelihood, and after taking the negative log it becomes an extra term in the objective. A trick coin shows data overwhelming the prior, a Beta prior estimates a click rate, and Gaussian and Laplace priors on linear-regression weights turn into L2 and L1 regularization.
Probabilistic Generative Models, Naive Bayes and Gaussian Discriminant Analysis | CMU 07-380 Lecture 9
Lecture 9 stops learning p(y|x) directly. Instead it learns the class prior p(y) and the class-conditional p(x|y), then inverts them with Bayes rule. The price is stronger assumptions; the payoff is the ability to generate new data and more stability with little data. Naive Bayes uses conditional independence to make the parameters estimable, GDA uses multivariate Gaussians for continuous features, and whether the covariances match decides a linear or a curved boundary.
Bayes Nets Break a Joint Distribution into Conditional Probability Tables | CMU 07-380 Lecture 10
The Lec10 slides are not on the 07-380 course site yet, so this guide uses only the PR6 Bayes Nets pre-reading and the 15-281 Bayes Net Demo. A joint distribution can answer any query, but nobody hands it to you and it is too big to store; a Bayes net writes it as a product of 'node given parents' tables, and every missing edge is an independence assumption.
Stage Recap: From Reasoning Under Certainty and Optimization to Uncertainty | CMU 07-380 Topic Guide
The course site's schedule splits 07-380's first ten lectures into Reasoning Under Certainty, Optimization and Reasoning Under Uncertainty: prove things with logic and plan with search, then write problems as constrained objectives, and finally let a prior in with MAP and turn to probabilistic models. HW1 tests logic plus search, HW2 planning plus LP graphing, HW3 writing solvers plus PCA and MAP derivations.
Completing CMU 07-280: What You Know, What Is Missing, and What Comes Next | CMU 07-280 Course Map
Finishing 07-280 means more than reading 24 guides: produce a search engine, supervised-model comparison, CNN/GPT-2 experiments, and a small RL-plus-MCTS system before choosing 07-380, 10-301, or a specialist course.
Why Search, GPT-2, and AlphaZero Belong in One Course | CMU 07-280 Course Overview
07-280 is CMU's new Spring 2026 AI+ML core: 24 lectures and 12 main assignments move from heuristic search and CSPs to AlexNet, GPT-2, and AlphaZero. Its public material supports self-study, but the official schedule lists no complete recordings, and Canvas checkpoints, Gradescope, and staff feedback remain unavailable.
The Shared Problem Behind AI, ML, and Representation Learning | CMU 07-280 Lecture 1
Lecture 1 uses an alien autoencoder, the scope of AI and ML, and AI history to establish the course's coordinate system: an intelligent system turns inputs into representations and decisions under uncertainty.
Heuristic Search from UCS and Greedy to A* | CMU 07-280 Lecture 2
Lecture 2 decomposes search into a problem, frontier, and priority: UCS uses paid cost, Greedy uses estimated remaining cost, and A* combines them as `f=g+h`; tree and graph search require different optimality conditions.
Minimax, Alpha-Beta, and Expectimax | CMU 07-280 Lecture 3
Lecture 3 turns a single path into a contingent plan: minimax faces an optimal opponent, alpha-beta skips branches without changing the root value, and expectimax replaces worst-case choice with probability.
CSPs, AC-3, and Search Order | CMU 07-280 Lecture 4
Lecture 4 exposes structure through variables, domains, and constraints, then upgrades DFS with backtracking, forward checking, AC-3, MRV, and LCV; the goal is to prove failure earlier.
Defining Machine Learning with Loss, Risk, and ERM | CMU 07-280 Lecture 5
Lecture 5 formulates machine learning through `X → Y`, loss, risk, and empirical risk minimization: a training set only gives average observed loss, while the real objective remains generalization over an unknown distribution.
How Decision Trees Split Data with Mutual Information | CMU 07-280 Lecture 6
Lecture 6 recursively grows a tree from decision stumps, measures label uncertainty with entropy, and selects splits by `I(Y;W)=H(Y)-H(Y|W)`; this is computationally practical greedy ERM, not a global optimal-tree guarantee.
Linear Regression and the Normal Equation | CMU 07-280 Lecture 7
Lecture 7 applies ERM to linear functions and squared loss, moves from a one-dimensional slope to `argmin ||y-Xθ||²`, and derives the normal equation when `XᵀX` is invertible.
Gradient Descent, SGD, and Learning Rate | CMU 07-280 Lecture 8
Lecture 8 moves from a one-dimensional parabola to vector gradients and compares batch GD, SGD, and mini-batches; the learning rate determines whether updates converge, oscillate, or diverge.
Logistic Regression as Probability Estimation | CMU 07-280 Lecture 9
Lecture 9 models P(y=1|x) with a sigmoid instead of directly predicting 0 or 1, learns parameters with cross-entropy and convex optimization, and extends naturally to softmax regression.
Trading Expressiveness for Stability with Features and Regularization | CMU 07-280 Lecture 10
Lecture 10 uses φ(x) to let linear models express nonlinear functions, then controls the resulting overfitting with train/validation/test separation, L1/L2 regularization, and model selection.
Building a Neural Network from Logistic Regression | CMU 07-280 Lecture 11
Lecture 11 expands a logistic unit into a multilayer network: linear layers produce z, activations produce a, and multiple neurons jointly learn a feature transform trained through a final loss.
How Backpropagation Reuses the Chain Rule | CMU 07-280 Lecture 12
Lecture 12 treats a network as a computation graph: the forward pass stores intermediates, the backward pass propagates upstream gradients, and local linear, activation, and softmax rules compute every parameter gradient efficiently.
From Reward Hacking to Auditable AI Scientists | CMU 07-280 Lecture 13
Lecture 13 separates alignment into specification, distribution shift, oversight, and corrigibility, then uses benchmark selection, leakage, and post-hoc selection experiments to show why a final paper cannot audit an autonomous research workflow.
Encoding Image Structure with Convolutional Networks | CMU 07-280 Lecture 14
Lecture 14 replaces dense image models with local connectivity and parameter sharing, moving from convolution, stride, padding, and pooling to AlexNet, GPU data parallelism, ResNet skip connections, and BatchNorm.
Separating Pretraining, Transfer Learning, and Fine-Tuning | CMU 07-280 Lecture 15
Lecture 15 splits a pretrained model into representation g and task head h: freeze g and train only the head, or fine-tune some or all parameters at a smaller learning rate depending on data volume and source-target distance.
Unifying Logistic and Linear Regression with Maximum Likelihood | CMU 07-280 Lecture 16
Lecture 16 starts from likelihood p(D|θ), uses i.i.d. to factor the joint probability and logs to turn products into sums; Bernoulli MLE yields sample proportions, conditional Bernoulli yields logistic cross-entropy, and Gaussian noise yields squared error.
From Tokenization to N-gram Language Models | CMU 07-280 Lecture 17
Lecture 17 first decides how text becomes tokens, then uses N-grams to turn sequence probability into conditional probabilities estimated from corpus counts. Tokenization is the first design decision about what a model can see.
How N-grams Train, Sample, and Fail | CMU 07-280 Lecture 18
Lecture 18 truncates the chain rule with an N-gram Markov assumption, estimates probabilities from corpus counts, and contrasts greedy, categorical, and temperature sampling. The real bottlenecks are zero probability for unseen contexts and a fixed window.
Turning Next-token Prediction into Geometry | CMU 07-280 Lecture 19
Lecture 19 builds a minimal next-token model from two embedding matrices, dot-product similarity, softmax, and cross-entropy. Shared vector parameters replace the isolated count cells of an N-gram table.
From Position Encoding to Causal Self-Attention | CMU 07-280 Lecture 20
Lecture 20 expands one-token embeddings into sequences, adds positional information, derives Q/K/V scaled dot-product attention and causal masking, and assembles multi-head blocks into a GPT-2 skeleton.
How Bellman Equations Solve Markov Decision Processes | CMU 07-280 Lecture 21
Lecture 21 formulates stochastic sequential decisions as an MDP with known dynamics, defines value and Q-values through Bellman backups, and solves for an optimal policy with value or policy iteration.
Q-learning When Dynamics Are Unknown | CMU 07-280 Lecture 22
Lecture 22 keeps the MDP structure but removes known transitions and rewards. TD learning updates value from one sample, and Q-learning uses an off-policy target to learn optimal action values directly.
From Approximate Q-learning to DQN | CMU 07-280 Lecture 23
Lecture 23 replaces a huge Q-table with Qθ(s,a): first derive a gradient update for linear features from squared TD error, then add replay data and a fixed target network to form DQN.
How Monte Carlo Tree Search Connects to AlphaZero | CMU 07-280 Lecture 24
Spring 2026 Lecture 24 is MCTS, not Fall 2026 LLM post-training. It allocates simulations through selection, expansion, rollout, backup, and UCB, then connects policy/value heads and self-play to AlphaZero.
Stage Review I: From Search Problems to Supervised Learning | CMU 07-280 Topic Guide
Lectures 1–12 form one decision pipeline: define states, moves, and objectives, then use heuristics, losses, regularization, and backpropagation to control an otherwise intractable search space.
Stage Review II: Building AlexNet and GPT-2 as Working Systems | CMU 07-280 Topic Guide
Stage II uses HW8 and HW11 to test whether representation, computation graphs, training, transfer, and generation actually connect, rather than treating CNNs and Transformers as diagrams to memorize.
Stage Review III: From MDPs and Q-learning to AlphaZero | CMU 07-280 Topic Guide
Stage III connects value, policy, bootstrapping, function approximation, and MCTS into AlphaZero: a network supplies priors and estimates, search improves decisions, and self-play creates the next training set.
Introduction | CMU 11-785 Lecture 1
Spring 2026 Lecture 1 focuses on neurons, perceptrons, connectionism, and the problem framing of deep learning. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Neural Nets as Universal Approximators | CMU 11-785 Lecture 2
Spring 2026 Lecture 2 focuses on Boolean functions, how network depth and width affect representational capacity (including a multi-input XOR example), and the hand-off at the end to the next lecture's training problem. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Training I: Learning and Empirical Risk Minimization | CMU 11-785 Lecture 3
Spring 2026 Lecture 3 focuses on how the learning problem is set up (representing inputs and outputs as numbers), the perceptron learning rule and why it does not carry over to multi-layer networks, differentiable divergences, and empirical risk minimization (the loss). This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Training II: Gradient Descent | CMU 11-785 Lecture 4
Spring 2026 Lecture 4 focuses on the definitions of derivative and gradient, extrema and second derivatives, gradient descent as repeated steps against the gradient, and the network, input/output representations, and divergence that must be defined before training. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Training III: Backpropagation | CMU 11-785 Lecture 5
Spring 2026 Lecture 5 focuses on layered-network notation, the forward pass, the chain rule and Jacobians (including vector activations), and how the backward pass computes weight and bias derivatives layer by layer. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Training IV: Convergence, Loss Surfaces, and Momentum | CMU 11-785 Lecture 6
Spring 2026 Lecture 6 focuses on convergence of gradient descent (step-size choice on convex and quadratic functions, differences between dimensions), local minima and saddle points, decaying or adaptive learning rates, R-prop, and momentum with Nesterov accelerated gradient. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Training V: SGD and Second-order Methods | CMU 11-785 Lecture 7
Spring 2026 Lecture 7 focuses on incremental SGD and mini-batch updates and trend-based updates such as RMSprop and momentum (second-order methods are only in the slides, not in the recording). This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Training VI: Optimizers and Regularization | CMU 11-785 Lecture 8
Spring 2026 Lecture 8 focuses on the choice of divergence (loss), BatchNorm, dropout and other regularization methods, and training tricks such as early stopping (AdaGrad and Adam are not in this recording). This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
CNNs I | CMU 11-785 Lecture 9
Spring 2026 Lecture 9 focuses on why we scan the input, distributing the scan over several layers, handling deformation with max pooling, and the CNN / time delay neural network structure. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
CNNs II | CMU 11-785 Lecture 10
Spring 2026 Lecture 10 focuses on where the CNN comes from (Hubel and Wiesel, Fukushima's Neocognitron), the operations of convolution and pooling layers, and design choices such as filter size, stride and number of channels. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
CNNs III | CMU 11-785 Lecture 11
Spring 2026 Lecture 11 focuses on a recap of CNNs and backpropagation through convolution and pooling layers. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
CNNs IV | CMU 11-785 Lecture 12
Spring 2026 Lecture 12 focuses on additional backpropagation rules (strides, upsampling and downsampling), invariance to transformations other than shifts, and a quick history of CNNs with the major architectures. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
RNNs I | CMU 11-785 Lecture 13
Spring 2026 Lecture 13 focuses on why sequences need their own models, state and memory, Jordan/Elman-style recurrent networks, backpropagation through time, and bidirectional networks. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
RNNs II | CMU 11-785 Lecture 14
Spring 2026 Lecture 14 focuses on backpropagation through time, gradient stability, and LSTM-style gated memory. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Seq2Seq and Connectionist Temporal Classification | CMU 11-785 Lecture 15
Spring 2026 Lecture 15 focuses on the alignment problem when training sequence models (training with explicit or re-estimated alignments, and the risk of local optima); CTC is only introduced at the very end, with details left to the next lecture. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
CTC Blanks and Beam Search | CMU 11-785 Lecture 16
Spring 2026 Lecture 16 focuses on blank symbols and the merging of adjacent repeated symbols, CTC's forward (alpha) probability computation, and pruned approximate decoding (beam search is described only briefly near the end). This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Language Models and Translation | CMU 11-785 Lecture 17
Spring 2026 Lecture 17 focuses on next-word-prediction language models, conditional translation models, and beam-search decoding. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Attention and Transformers | CMU 11-785 Lecture 18
Spring 2026 Lecture 18 focuses on sequence-to-sequence attention (queries, keys, values, and softmax-weighted averaging), a mention of multi-head attention, and a brief introduction to the Transformer. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Transformers and Newer Architectures | CMU 11-785 Lecture 19
Spring 2026 Lecture 19 focuses on encoder/decoder structures, masks, residual paths, and architecture variants. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Large Language Models | CMU 11-785 Lecture 20
Spring 2026 Lecture 20 focuses on scaled autoregressive models, pre-training and scaling laws, and post-training (including improving the model from its own sampled answers and feedback). This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Representations and Autoencoders | CMU 11-785 Lecture 21
Spring 2026 Lecture 21 focuses on what neural networks actually represent, the reconstruction objective (autoencoders), and the link to PCA (dimensionality reduction). This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Variational Autoencoders | CMU 11-785 Lecture 22
Spring 2026 Lecture 22 focuses on latent variables, the ELBO, the KL term, and the reparameterization trick. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Diffusion Models | CMU 11-785 Lecture 23
Spring 2026 Lecture 23 focuses on forward noising, reverse denoising, score or noise prediction, and sampling. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Generative Adversarial Networks | CMU 11-785 Lecture 24
Spring 2026 Lecture 24 focuses on the generator, discriminator, minimax objective, and training instability. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Graph Neural Networks | CMU 11-785 Lecture 25
Spring 2026 Lecture 25 focuses on message passing, aggregation, node representations, and permutation symmetry. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Reinforcement Learning | CMU 11-785 Lecture 26
Spring 2026 Lecture 26 focuses on states, actions, rewards, returns, values, and policy learning. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Hopfield Networks | CMU 11-785 Lecture 27
Spring 2026 Lecture 27 focuses on associative memory, energy functions, fixed points, and pattern retrieval. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
Boltzmann Machines | CMU 11-785 Lecture 28
Spring 2026 Lecture 28 focuses on energy-based probability models (the Gibbs distribution and its normalizing constant Z), stochastic neurons, and how to train such probabilistic networks. This guide follows the official slides and recording and adds a small self-check that does not depend on the enrolled-course grader.
A Learning Path from Neural Network Foundations to Sequence Models | CMU 11-785 Course Overview
CMU 11-785 Spring 2026 publishes official slides and YouTube recordings for all 28 content lectures, plus extensive bootcamps and recitations. Its HW1–HW4 specifications, starters, and evaluation still depend on Autolab, Piazza, and Kaggle.
Advanced AI and Machine Learning: From Logical Planning to Generative Models | CMU 07-380 Course Overview
07-380 Fall 2026 is the first offering of CMU's new AI II: 26 lectures from logic, planning and optimization to probabilistic graphs and generative systems. As of the 2026-09-29 course site, the Lec1–9 slides, PR1–6 notes, Rec1–5 (with solutions) and HW1–3 are public, and this site now has 14 lecture-by-lecture guides for them. Slides after Lec10, HW4–7 and the final project are not out yet, so the course as a whole is still A2.
Find ML Foundation Gaps with Mathematics and Python | CMU 10-301 Assignment 1
HW1 is written and programming work: mathematical and CS foundations followed by a majority-vote classifier.
From Information Calculations to a Complete Decision Tree | CMU 10-301 Assignment 2
HW2 moves from hand-calculated entropy and mutual information to an end-to-end tree learner, predictor, and evaluator.
Compare K-NN, Perceptron, and Linear Regression | CMU 10-301 Assignment 3
HW3 is written work: a decision-tree review followed by K-NN, Perceptron, and Linear Regression through inductive bias, errors, and model selection.
Turn Logistic Regression Likelihood into a Classifier | CMU 10-301 Assignment 4
HW4 joins probabilistic interpretation, cross-entropy gradients, and implementation into one traceable training pipeline.
Expose Neural Networks and Backpropagation with NumPy | CMU 10-301 Assignment 5
HW5 avoids automatic differentiation so learners must track forward shapes, caches, and backward gradients themselves.
Learning Theory, MLE/MAP, and Fairness Metrics | CMU 10-301 Assignment 6
HW6 combines generalization, MLE/MAP, probabilistic learning, fairness metrics, and social impact in one written assignment about assumptions and tradeoffs.
Move from Basic Neural Networks to Deep Learning | CMU 10-301 Assignment 7
HW7 builds on HW5 backpropagation to address deep-model architecture and training failures, emphasizing diagnosis over merely adding layers.
From MDPs to Reinforcement-Learning Updates | CMU 10-301 Assignment 8
HW8 connects states, actions, rewards, transitions, and value updates while separating environment dynamics, policy, and estimation error.
Close the Course with Ensembles, k-Means, PCA, and Recommenders | CMU 10-301 Assignment 9
The final written assignment combines ensembles, clustering, representation, and recommendation to test whether you can choose a learning paradigm from problem structure.
Learn Machine Learning Through Nine Assignments | CMU 10-301 Course Overview
Spring 2026 publishes material for 27 lectures and nine homework bundles; outsiders can do the core work but cannot access Panopto, Piazza, Gradescope, or official homework solutions.
CMU's AI Core Redesign: From 15-281 + 10-315 to 07-280 + 07-380
In 2026, CMU recombined its separate general-AI and SCS machine-learning introductions into the 07-280 → 07-380 sequence. This is a redistribution of content and prerequisites, not a pair of simple course renames.
The Pacman AI Project Lineage: How Berkeley CS188 and CMU 15-281 Restructure the Same Material
CMU 15-281's Search and Games explicitly credits Berkeley's Pacman AI projects. The official course site separately lists a zero-point P0 tutorial and five programming assignments, P1–P5.
CMU's AI Degrees: The First U.S. AI Bachelor's Turned 'What Should AI Students Learn?' into Graduation Requirements
Stanford has no AI degree; AI is a track inside CS. CMU launched the first U.S. B.S. in Artificial Intelligence in 2018, divided AI into four clusters, required one course from each, and made ethics a graduation requirement. At the master's level, MSAII sits not in CS but in the Language Technologies Institute; 84 of its 195 units cover an innovation process ending in a fundable capstone. Two official-page conflicts emerged during verification: whether the AI Core has two or three courses, and whether MSAII totals 192 or 195 units.
CMU AI/ML Course Guide: The New 07-280 Core and a Public Self-Study Route | Global AI/CS Course Map
CMU's current BSAI now runs through 07-280 and 07-380 before branching into an NLP/vision core and four AI clusters. 07-380 debuted in Fall 2026, and the same semester launched a graduate-level 11-768 AI Agents course. The residual Spring 2026 materials for 07-280 and the complete 10-301/601 site already support self-study; retired 15-281 remains a useful legacy route.