Mastery of Embodied AI

Below is the complete, lesson-by-lesson curriculum index. It expands the five-phase architecture into delivered lessons, labs, and assessments, sequenced so that every concept is primed, implemented, and then independently applied before the next layer is introduced. The structure draws on established course designs from PKU, Cornell, CUHK, ETH Zürich, JHU, and open-source embodied AI curricula, adapting their sequencing into a unified mastery progression.

📖 Complete Curriculum Index: Mastery of Embodied AI

Phase 0 — The Bridge (Weeks 1–4)

From Python to PyTorch and Robotic Mathematics

Module 0.1 — PyTorch from First Principles

Lesson 0.1.1 Tensors as the substrate of robot learning: shapes, broadcasting, and device management (CPU/GPU).
Lesson 0.1.2 Autograd and the computational graph: what .backward() actually does, and why memory management (.detach(), torch.no_grad()) matters for control loops.
Lesson 0.1.3 nn.Module, optim, and DataLoader: the anatomy of a training pipeline.
Lesson 0.1.4 Train vs. eval mode: batch normalization, dropout, and the silent bugs they cause in deployment.
Lab 0.1.A Implement a multi-layer perceptron entirely from tensor operations (no nn.Linear), then replicate it with the PyTorch API and verify numerical equivalence.
Lab 0.1.B Profile memory and compute: measure the cost of a forward pass with and without torch.no_grad().

Module 0.2 — Linear Algebra and Geometry for Robotics

Lesson 0.2.1 Homogeneous transformations and SE(3): why robotics uses 4×4 matrices.
Lesson 0.2.2 Rotation representations: rotation matrices, Euler angles, axis–angle, and quaternions. The gimbal-lock problem and why quaternions are the default.
Lesson 0.2.3 The exponential map and screw theory: connecting Lie algebra to joint motion.
Lesson 0.2.4 Active vs. passive transformations: the most common source of sign errors in robotics code.
Lab 0.2.A Build a Transform class in PyTorch that composes, inverts, and interpolates SE(3) poses; animate a 2D arm in Matplotlib.
Lab 0.2.B Convert a rotation matrix to a quaternion and back; verify that interpolation stays on the unit sphere.

Module 0.3 — Probability and Estimation

Lesson 0.3.1 Bayes’ rule and Gaussian distributions: the foundation of state estimation.
Lesson 0.3.2 Maximum likelihood and maximum a posteriori estimation.
Lesson 0.3.3 Filtering vs. smoothing: why recursive estimation is necessary in real time.
Lesson 0.3.4 The Kalman filter as linear-Gaussian belief propagation; the extended Kalman filter (EKF) and linearization.
Lab 0.3.A Implement a 1D Kalman filter for a robot with noisy odometry and GPS; compare filtering and smoothing trajectories.
Lab 0.3.B Implement an EKF for a 2D unicycle model and visualize uncertainty ellipses over time.
Assessment 0 “Math-to-Code” quiz: translate a written description of a spatial transformation and a Bayesian update into working PyTorch functions.

Phase 1 — Foundations of Physical Intelligence (Weeks 5–12)

Robot modeling, simulation, and the first learning algorithms

Module 1.1 — Robot Modeling and Classical Control

Lesson 1.1.1 Forward kinematics: the product-of-exponentials formula and Denavit–Hartenberg conventions.
Lesson 1.1.2 Inverse kinematics: analytical vs. numerical methods, Jacobian pseudoinverse, and singularities.
Lesson 1.1.3 PID control: proportional, integral, and derivative action; windup and saturation.
Lesson 1.1.4 Trajectory generation: minimum-jerk profiles, polynomial splines, and time-optimal parameterization.
Lesson 1.1.5 Joint-space vs. task-space control: when each is appropriate and why compliant interaction demands more than PID.
Lab 1.1.A (Guided) Control a simulated 2-DOF arm in MuJoCo to reach target positions with PD control.
Lab 1.1.B (Independent) Implement numerical inverse kinematics for a 6-DOF arm and compare convergence across Jacobian update rules.

Module 1.2 — Simulation Environments and Sensor Models

Lesson 1.2.1 Physics engines: MuJoCo, Isaac Sim/Lab, Gazebo, and PyBullet—contact models, solver choices, and fidelity trade-offs.
Lesson 1.2.2 Sensors in simulation: RGB cameras, depth sensors, LiDAR, and IMUs; noise injection and latency modeling.
Lesson 1.2.3 The reality gap begins here: what simulation does not model (complex friction, soft-body deformation, actuator dynamics).
Lab 1.2.A Spawn a robot in MuJoCo, attach an RGB-D camera, and record a dataset of images and joint states during teleoperation.
Lab 1.2.B Measure the effect of physics timestep and solver iterations on contact stability.

Module 1.3 — Reinforcement Learning I: Foundations and Policy Gradients

Lesson 1.3.1 Markov Decision Processes: states, actions, rewards, transitions, and discounting.
Lesson 1.3.2 Value functions and dynamic programming: the Bellman expectation and optimality equations.
Lesson 1.3.3 Policy gradient methods: REINFORCE, baselines, and variance reduction.
Lesson 1.3.4 Actor–critic architectures and advantage estimation (A2C, GAE).
Lesson 1.3.5 Proximal Policy Optimization (PPO): trust-region intuition and clipping.
Lab 1.3.A Train PPO on CartPole and MuJoCo HalfCheetah; ablate learning rate, batch size, and GAE λ, documenting the effect on sample efficiency.
Lab 1.3.B Implement a baseline and GAE from scratch and verify variance reduction empirically.

Module 1.4 — Imitation Learning

Lesson 1.4.1 Behavior cloning (BC): supervised learning of policies from demonstrations.
Lesson 1.4.2 Covariate shift and compounding error: why BC fails when the policy drifts from the demonstration distribution.
Lesson 1.4.3 DAgger and dataset aggregation: interactive correction.
Lesson 1.4.4 Action representation choices: joint positions, end-effector poses, and action chunks.
Lab 1.4.A Collect 50 teleoperation trajectories for a reaching task; train a BC policy and evaluate success rate.
Lab 1.4.B Implement DAgger and compare success rates and data efficiency against BC.
Assessment 1 “Sim-to-Sim” transfer project: train a reaching policy in PyBullet and deploy it in MuJoCo without retraining. Write a failure-mode taxonomy.

Phase 2 — The Core Loop: Perception, Learning, and Control at Depth (Weeks 13–24)

Manipulation, navigation, and advanced learning algorithms

Module 2.1 — Robotic Perception

Lesson 2.1.1 6D object pose estimation: instance-level vs. category-level, symmetry handling, and occlusion.
Lesson 2.1.2 Point cloud processing: registration (ICP), segmentation, and PointNet++.
Lesson 2.1.3 Semantic and instance segmentation: from Mask R-CNN to SAM.
Lesson 2.1.4 Visual servoing: image-based vs. position-based control.
Lesson 2.1.5 The perception latency budget: how much time a control loop can afford.
Lab 2.1.A Given an RGB-D cluttered tabletop scene, estimate the 6D pose of a known object and command a simulated grasp.
Lab 2.1.B Benchmark pose estimation under occlusion and symmetry; quantify failure modes.

Module 2.2 — Reinforcement Learning II: Advanced Algorithms

Lesson 2.2.1 Soft Actor–Critic (SAC): maximum-entropy RL and automatic temperature tuning.
Lesson 2.2.2 TD3: twin critics, delayed policy updates, and target policy smoothing.
Lesson 2.2.3 Model-based RL: Dyna, MBPO, and Dreamer—learning a dynamics model and planning through it.
Lesson 2.2.4 Offline RL: CQL and IQL—learning from fixed datasets without online interaction.
Lesson 2.2.5 Reward shaping and domain randomization: practical techniques for real-world transfer.
Lab 2.2.A Train SAC from pixels on a door-opening task in Isaac Lab.
Lab 2.2.B Train an offline RL agent on a pre-collected dataset; compare sample efficiency and final performance against online SAC.

Module 2.3 — Grasping and Advanced Manipulation

Lesson 2.3.1 Grasp synthesis: analytical vs. data-driven grasping; force closure and antipodal points.
Lesson 2.3.2 Motion planning: RRT, RRT*, and CHOMP—sampling vs. optimization.
Lesson 2.3.3 Task-and-motion planning (TAMP): integrating symbolic and geometric reasoning.
Lesson 2.3.4 Diffusion policies: denoising action trajectories and robustness to multimodal demonstrations.
Lesson 2.3.5 Contact-rich manipulation: impedance control and tactile feedback.
Lab 2.3.A Build a full pick-and-place pipeline: perceive a block, plan a collision-free grasp, execute a diffusion policy for the final approach, and place the block.
Lab 2.3.B Stress-test the pipeline with novel object shapes and clutter; document failure cases.

Module 2.4 — Mobile Robotics and SLAM

Lesson 2.4.1 Occupancy mapping and Bayesian fusion of sensor measurements.
Lesson 2.4.2 Visual SLAM: feature-based (ORB-SLAM) vs. direct methods; loop closure.
Lesson 2.4.3 LiDAR-based localization and mapping: scan matching and pose graphs.
Lesson 2.4.4 Navigation stacks: global planning, local planning, and recovery behaviors (Nav2).
Lesson 2.4.5 Metric vs. topological maps: when each representation is appropriate.
Lab 2.4.A Run ORB-SLAM on a simulated indoor dataset and use the map for point-goal navigation with a TurtleBot.
Lab 2.4.B Evaluate localization robustness under dynamic obstacles and lighting changes.
Assessment 2 “Perception–Action Coupling” challenge: maintain task performance when the perception system is deliberately degraded (low light, occlusion, sensor noise). Adapt either the policy or the perception pipeline.

Phase 3 — The Frontier: Foundation Models and Generalist Agents (Weeks 25–36)

VLAs, world models, LLM reasoning, and advanced sim-to-real

Module 3.1 — Vision-Language-Action (VLA) Models

Lesson 3.1.1 The VLA paradigm: a single network mapping images and language to actions.
Lesson 3.1.2 Architectures: RT-1, RT-2, OpenVLA, and the π family—design choices and trade-offs.
Lesson 3.1.3 Action tokenization: discretization, FAST tokenizers, and the effect on action smoothness.
Lesson 3.1.4 Co-fine-tuning on robot trajectories: data requirements and generalization limits.
Lesson 3.1.5 The five VLA challenges: representation, execution, generalization, safety, and data.
Lab 3.1.A Fine-tune a pre-trained VLA (e.g., OpenVLA) on a small language-conditioned pick-and-place dataset.
Lab 3.1.B Evaluate zero-shot generalization to novel object descriptions and instructions; write a failure analysis.

Module 3.2 — World Models and Model-Based Learning

Lesson 3.2.1 Latent dynamics models: learning a compressed simulator.
Lesson 3.2.2 DreamerV3: training policies entirely inside a learned world model.
Lesson 3.2.3 Video prediction models as world models: strengths and computational costs.
Lesson 3.2.4 Model exploitation: why policies find adversarial shortcuts in learned models, and how to regularize.
Lab 3.2.A Train a world model on a simple environment (e.g., a bouncing ball); use MPC in latent space and compare to model-free RL.
Lab 3.2.B Deliberately induce model exploitation and then apply a regularization technique to mitigate it.

Module 3.3 — LLMs for Embodied Reasoning and Planning

Lesson 3.3.1 LLM-based task decomposition: from abstract language to executable skill sequences.
Lesson 3.3.2 Code-as-Policies: generating robot control code from language.
Lesson 3.3.3 Grounding language to affordances: connecting words to physical possibilities.
Lesson 3.3.4 Hallucination in physical contexts: safety constraints on LLM outputs.
Lesson 3.3.5 Human–robot interaction: dialogue, clarification, and shared autonomy.
Lab 3.3.A Build a system where an LLM decomposes a natural language command (“Put the red block on the green one”) into a plan and calls pre-defined robot skills.
Lab 3.3.B Add a safety verifier that rejects physically infeasible or unsafe LLM-generated plans.

Module 3.4 — Sim-to-Real Transfer (Advanced)

Lesson 3.4.1 The reality gap as a spectrum: visual, dynamics, and sensor discrepancies.
Lesson 3.4.2 Domain randomization: what to randomize, and why naive randomization can produce overly conservative policies.
Lesson 3.4.3 System identification: measuring real-world parameters (friction, latency, mass) to align simulation.
Lesson 3.4.4 Residual RL and teacher–student training: combining classical controllers with learned refinements.
Lesson 3.4.5 Real-to-sim adaptation: updating the simulator from real-world data.
Lab 3.4.A Train a quadruped locomotion policy in Isaac Lab with aggressive domain randomization; perform system identification to close the remaining gap.
Lab 3.4.B Compare zero-shot transfer against residual RL fine-tuning on the target platform.
Assessment 3 “VLA Generalization” benchmark: evaluate a fine-tuned VLA on held-out tasks with novel objects, instructions, and environments. Produce a detailed failure-mode taxonomy with proposed remedies.

Phase 4 — Synthesis and Mastery (Weeks 37–48)

The capstone and the master’s defense

Module 4.1 — Capstone Design and Scoping

Lesson 4.1.1 Defining a capstone that integrates perception, learning, reasoning, and safety.
Lesson 4.1.2 Choosing the embodiment: physical robot vs. high-fidelity simulation; resource and risk assessment.
Lesson 4.1.3 Evaluation design: success metrics, held-out test suites, and generalization probes.
Milestone 4.1 Capstone proposal and risk register.

Module 4.2 — Building the Full-Stack Agent

Lesson 4.2.1 Perception stack integration: real-time detection, pose estimation, and scene understanding.
Lesson 4.2.2 Policy layer: VLA, diffusion policy, or world-model-based planner—selecting and justifying the choice.
Lesson 4.2.3 Reasoning layer: LLM or learned high-level planner for abstract goal decomposition.
Lesson 4.2.4 Safety and recovery: shielding, runtime monitoring, and failure-triggered recovery behaviors.
Milestone 4.2 Mid-capstone demo: all components running in an integrated loop.

Module 4.3 — Iteration, Evaluation, and Failure Analysis

Lesson 4.3.1 Systematic experimentation: ablations, controlled baselines, and statistical rigor.
Lesson 4.3.2 Diagnosing sim-to-real failures: distinguishing perception errors from dynamics errors.
Lesson 4.3.3 Long-horizon robustness: compounding errors and recovery strategies.
Milestone 4.3 Full evaluation report with quantitative results and failure taxonomy.

Module 4.4 — The Master’s Defense

Lesson 4.4.1 Architecting the defense: justifying every design decision with theory and evidence.
Lesson 4.4.2 Proposing concrete improvements: what you would do with another six months.
Lesson 4.4.3 Communicating nuance: the unknown unknowns you discovered and how you characterized them.
Final Assessment 45-minute oral defense of the capstone, followed by open questioning on any topic from Phases 0–3.

📚 Integrated Reading Spine

The following texts are assigned progressively; each lesson points to specific chapters.

PyTorch and deep learning: Deep Learning (Goodfellow et al.) — Chapters 6–8; PyTorch official tutorials for Modules 0.1 and 1.3.
Robotics mathematics and control: Modern Robotics (Lynch & Park) — Chapters 3–6, 11; Introduction to Robotics (Craig) for intuition.
Reinforcement learning: Reinforcement Learning: An Introduction (Sutton & Barto) — Chapters 3–6, 13; Algorithms for Decision Making (Kochenderfer et al.) for modern treatments.
Probabilistic robotics: Probabilistic Robotics (Thrun et al.) — Chapters 2–4, 8.
Perception and manipulation: Robotic Manipulation (MIT course notes) and selected papers on 6D pose estimation, diffusion policies, and TAMP.
Frontier papers: The VLA survey (arXiv:2512.11362), Diffusion Policy (RSS 2023), DreamerV3 (Nature 2025), and the PKU/Cornell/ETH reading lists cited in the course schedules above.

This index delivers every topic from the five-phase architecture as a sequenced lesson stream, with labs and assessments positioned to force independent application before progression. A learner who completes every lab, every independent project, and the defense will have not only covered the syllabus but built, broken, diagnosed, and rebuilt embodied AI systems across the full stack—from a single tensor operation to a full-stack agent acting in the physical world.