How to learn this roadmap¶
New to robotics or AI? Begin with Start here: a first-hour experiment and ten guided sessions with worked answers. Return to this page when choosing a longer route.
Use the beginner reading aid for unfamiliar notation or vocabulary. You can finish the first cart and policy experiments before learning the advanced hardware terms in the route table below.
Choose one engineering outcome, diagnose the missing prerequisites, and build a small experiment before expanding it. The phase numbers describe dependencies; they are not a requirement to finish every course. Time estimates are planning aids, not mastery tests.
The shared destination is a custom physical-AI SoC built around advanced VLA workloads: a dedicated accelerator and AI compiler, embedded Linux, wireless, and interfaces for robots and drones. Treat each course artifact as evidence for a subsystem of that platform. The SoC capstone joins the model, compiler, hardware, and application work.
Choose a route and a first deliverable¶
For a connected project across these routes, use the Physical AI Design Studio. Its nine gates reuse the same task, reference vectors, numerical contracts, and evidence from model selection through SoC integration. Use each gate to identify the specific artifact needed by the next layer.
| Route | Start | First deliverable | Then |
|---|---|---|---|
| Inference optimization | Phase 4C | CPU reference and operator benchmark; add a target profiler trace when available | Inference course, then its DeepSeek V4.1 Flash NVFP4 part |
| Robotics and robot learning | Robotics | A simulated robot with validated frames, units, reset behavior, and timing | Isaac Sim / Isaac Lab, then held-out policy evaluation |
| Embedded and edge systems | Phase 2 | A timestamped sensor-to-application pipeline with recovery from a fault | Jetson, then a thermal and latency budget |
| FPGA and accelerator design | Phase 1 | Tested RTL with a timing constraint and a waveform explaining a failure | FPGA, then chip design |
| AI compiler and runtime | Phase 4C | A reference-checked compiled subgraph with memory and execution traces | Custom accelerator backend, Linux driver, and SoC integration |
| ML and agent systems | Phase 3 | A reproducible model or agent evaluation, including failed cases | ML engineering, runtime profiling, and one deployment target |
Diagnose before reading¶
Try the entry task for your next course without following its solution. If you can produce and explain the artifact, skip the introductory reading and attempt the independent exercise. If you cannot, study the prerequisite that addresses the specific failure.
| Skill | Five-to-fifteen-minute diagnostic | Return here if stuck |
|---|---|---|
| Systems | Explain why asynchronous GPU work cannot be timed by timing only the launch | Parallel computing |
| Architecture | Estimate bytes moved and operations for a matrix-vector product; state your cache assumption | Computer architecture |
| ML | Trace tensor shapes through a forward pass and explain how to hold evaluation data out | Neural networks |
| Robotics | Draw world, base, and camera frames and distinguish physics dt from policy period | Robotics foundation |
| Measurement | Name the baseline, one variable you will change, and an outcome that would disprove your prediction | The experiment record below |
A repeatable lesson cycle¶
Use this cycle with the course's lab, integration exercise, or handoff section. For courses that already contain detailed labs, those labs remain the main assignments.
- Retrieve (5 minutes): close the notes and draw the data path or explain yesterday's failure. Mark what you cannot yet explain.
- Predict (10 minutes): estimate a result with units. Write the condition under which the estimate would fail.
- Study (20–30 minutes): read the relevant concept and one worked example. Trace a small input by hand.
- Build (45–90 minutes): reproduce the baseline, save the raw output, and change one variable.
- Debug (20 minutes): introduce a bounded fault in a test or simulator. Show that your check detects it and that the fix restores behavior.
- Explain (10 minutes): compare prediction with measurement and write the next experiment. An unchanged or slower result is useful evidence.
These are session sizes, not limits on difficult labs. Split installation, experimentation, and analysis into separate sessions when needed. After two days, answer the self-check without notes; after a week, repeat the exercise with an unfamiliar input; after a month, connect it to another course's artifact. Keep an error log of misconceptions and the evidence that corrected them.
Three levels of practice¶
| Level | Assistance | What you demonstrate |
|---|---|---|
| Worked example | Follow provided commands and explain each intermediate result | You can reproduce a result |
| Guided variation | Change input size, layout, timing, fault, or workload; predict first | You understand what controls the result |
| Independent transfer | Solve a related problem without copying the example's implementation | You can choose and defend a method |
Do not make every lab larger. Moving a correct idea to a new condition is often a stronger assessment than using a bigger model or more GPUs.
Hardware and access levels¶
| Access | Useful work | Claim you may make |
|---|---|---|
| CPU laptop | Tensor math, metadata inspection, RTL simulation, recorded-trace analysis, experiment design | Analysis or CPU result, with assumptions |
| One compatible GPU / development board | Operator profiles, small model serving, supported small simulation tasks, board bring-up | Measurements on the named device and software versions |
| RTX simulation workstation | Isaac scenes, sensors, parallel tasks, policy evaluation | Simulation results with engine, renderer, and task settings |
| Multi-GPU node | Full large checkpoints, expert parallelism, topology and load sweeps | Deployment results for the exact checkpoint/runtime/hardware tuple |
Each lab should offer a reduced exercise when possible. A CPU replay of an Isaac trace does not certify simulator performance. A metadata-only DeepSeek exercise does not certify inference. Record not run for experiments without the required hardware; complete the theory route without inventing results.
Keep an experiment record¶
Use one directory per experiment. Save the following fields with the artifact; a Markdown table, JSON document, or notebook is fine.
question and predicted outcome:
baseline and single variable changed:
source revision / checkpoint revision / asset revision:
OS, driver, runtime, compiler, device, memory, power mode:
input shape, dataset split or seed set, workload distribution:
commands and configuration:
correctness criterion fixed before optimization:
warmup, repetitions, timing boundary, sample count:
raw output and summary statistics:
failure cases and explanation:
limitations, next experiment, reproduction instructions:
execution status: measured | analytical | fixture | not run
These status words can describe different parts of one experiment. For example: “Training and evaluation executed on CPU; observations and dynamics are a synthetic fixture; the 120 ms inference delay is imposed; physical robot and GPU timing are not run.” A fixture can execute real arithmetic. Name both what ran and where its inputs came from, rather than choosing a label that hides one.
Report units and distributions. GPU kernel time, server queue time, and end-to-end latency answer different questions. Separate cold starts from steady state. For robotics, separate transitions per second, physics steps per second, and simulated time divided by wall time. Never average percentiles from separate runs and call that the combined percentile.
Completion rubric¶
Score each dimension 0 (missing), 1 (works with unexplained gaps), or 2 (reproducible and explained).
| Dimension | Evidence for 2 points |
|---|---|
| Correctness | Reference comparison, valid inputs, and a test that catches a deliberate fault |
| Reasoning | A prediction, assumptions, and an explanation of disagreement with data |
| Measurement | Raw data, units, timing boundary, repetitions, and a named hardware/software setup |
| Reproduction | Another learner can rerun the work from the recorded commands and revisions |
| Transfer | The method works on a new case, with limitations explained |
A course milestone passes at 8/10 or better, with 2 in correctness and reproduction. This is a teaching rubric, not a production certification. Hardware availability does not lower the correctness standard; it changes which milestone you can claim. Retake only the dimensions that need work.
Phase checkpoints¶
| Phase / specialization | Evidence to carry forward |
|---|---|
| 1 — Foundations | Testbench, cache/bandwidth prediction, concurrency failure and fix |
| 2 — Embedded | Interface map, boot/capture log, repeatable fault recovery |
| 3 — AI | Held-out evaluation, numerical reference, data and model versions |
| 4A — FPGA | Constraints, timing/utilization results, software-visible interface |
| 4B — Jetson | Pipeline latency distribution, sustained power/thermal behavior, deployment manifest |
| 4C — Inference | Correctness gate, operator profile, measured optimization and rejected hypothesis |
| 5A/B — Infrastructure / HPC | Topology, communication baseline, scaling curve and failure diagnosis |
| 5C — Edge | Quality/latency/memory tradeoff on the target device |
| 5D — Robotics | Task contract, reset tests, held-out seeds, closed-loop outcomes and timing |
| 5E — Autonomous systems | Replay evaluation, timing/coordinate contracts, failure analysis in simulation |
| 5F — Chip design | Workload-derived architecture, reference model, verification and PPA assumptions |
| 5G — ML systems | Pinned workload, quality gate, service-level latency and useful throughput |
| 6 — Interviews | Short design explanation backed by one of the artifacts above |
Review the authoring guide when contributing a lesson and the curriculum review for the scope and limits of the repository audit.