AI Expert Roadmap — Companion Learning Material¶

Learn what the AI Expert Roadmap asks of you, in depth. The roadmap tells you what to build each week and why; this companion tells you how to learn what you need — with sources, sequencing, math, code skeletons, and an explanation of how each piece earns its place in the journey.

2026 hardening update: a new deep-dives directory contains 14 self-contained reference chapters (~131,000 words). These chapters let the reader master each topic from the document alone-without depending on the YouTube videos, blog posts, or paper PDFs that the sequences link to (and which will rot over years). The sequences and weeks remain the how to learn cadence; the deep dives are the primary technical reference. See the deep dives index for the index, and AUDIT.md for the durability analysis behind the addition.

Restructured for 3 deep-dive sessions per week¶

The folder was originally organized as a Mon–Fri daily checklist. It is now organized as 3 deep-dive sessions per week, because deep blocks beat fragmented daily ticks for absorbing technical material. The new shape:

Total per week: ~9–11 hours of focused work. If your real availability is closer to 6 hours, run the year over 18 months instead of 12-same plan, halved velocity. Pretending otherwise is the most common failure mode.

Why three sessions, not five days¶

Five short daily blocks fragment context. You re-load every morning and ship nothing in any single sitting. Three long sessions let you re-derive a proof from foundations to its application in attention, all in one block. Material sticks because it's connected. Code shipped because there was uninterrupted time to debug. The week's narrative arc-read → build → ship-happens in one weekend, not over a week of partial attention.

Inside each session: foundations → intermediate → advanced¶

Each session is internally structured as a mini-curriculum: - Part 1-Foundations (~30–60 min): the simplest version of the idea, with worked examples. - Part 2-Build-up (~45–90 min): the intermediate concepts that connect foundations to application. - Part 3-Advanced (the level the journey requires) (~45–90 min): the form in which you'll actually use the idea later-in attention, in evaluation, in fine-tuning.

This mirrors how the best textbooks teach: spiral from a concrete simple case to the general advanced formulation, with the connection always visible.

Two kinds of documents¶

1. `sequences/ - topic deep-dives¶

Each file takes one topic (linear algebra, transformers, RAG, evals, etc.) and walks from basics to the required advanced level, explaining at each rung why this rung matters for the AI-engineer journey. Use these when: - You need to learn a topic without skipping prerequisites - You're stuck on something and want to know what's underneath it - You're preparing for a quarter (read the relevant sequence in advance)

2. `DEEP_DIVES/ - self-contained reference chapters (14 files)¶

Each chapter is the durable primary source for one topic-math derivations, algorithm proofs, design patterns, runnable code, and worked exercises. Authored to be readable across years even as external links rot. See the deep dives index for the curriculum-pairing index.

Topics: - the Math for ML deep dive - applied LA/calc/probability with full derivations. - the PyTorch Fluency deep dive - user-side PyTorch (complement to AI_SYSTEMS internals). - the Classical ML Rigor deep dive - the foundations skipped at your peril. - the Deep Learning Fundamentals deep dive - backprop derived; AdamW; norms; init. - the LLM Application Patterns deep dive - daily-work engineering (structured outputs, tool use, caching, retry, orchestration). - the Retrieval & RAG deep dive - BM25 to RRF to RAGAS, fully derived. - the Agent Reliability Engineering deep dive - distributed-systems lens applied (the bridge chapter). - the Evaluation Systems deep dive - the user's specialty: golden sets, judges, kappa, power, A/B. - the LLM Observability deep dive - the user's unique moat: OTel GenAI conventions, SLOs, dashboards. - the Fine-tuning (SFT to RLHF) deep dive - LoRA, QLoRA, DPO derived end-to-end. - the Multimodal Foundations deep dive - ViT, CLIP, LLaVA, Whisper, diffusion (gap-fill). - the AI Safety & Red Teaming deep dive - production defense engineering (gap-fill). - the AI for SRE deep dive - the unique-moat lift that the curriculum had underweighted. - the Future-proofing & Audit deep dive - the durability framework + refresh cadence.

3. `weeks/ - week-by-week training plans (3 sessions each)¶

One file per week of the 12-month plan (48 files: Month 1, Week 1 through Month 12, Week 4). Each file contains: - The week's goal and artifact - Prerequisites (what you must know coming in) - Three sessions with: arc, parts, math derivations or code skeletons, resources with links, self-check questions, common pitfalls, output committed at end of session - End-of-week artifact and self-assessment - Common failure modes for the week

How to use a weekly file¶

1. Pre-week (Sunday, 30 min): read the file end-to-end. Queue up the videos / paper / chapter for Session A. Confirm you have the prerequisites.
2. Session A (~3 h): do the theory block in a single sitting. Take notes. Do all self-checks before stopping.
3. Session B (~3–4 h): open Session A's notes for reference. Build. Don't context-switch out.
4. Session C (~2–3 h): finish artifact, run evals if applicable, push code, write blog post if due.
5. End of week: mark the file's checkboxes. Carry slipped items into next week's Session A as a "warmup recap."

Index¶

Deep Dives (the primary technical reference)¶

• the deep dives index-the index with curriculum pairing
• See the 14 chapters listed above

Curriculum hardening artifacts¶

• AUDIT.md-durability audit and findings
• CROSS_REFERENCES.md-bridges to sibling curricula (AI_SYSTEMS_PLAN, LINUX, KUBERNETES, etc.)

Sequences¶

• 00-How to use this folder
• 01-Linear Algebra
• 02-Calculus
• 03-Probability & Statistics
• 04-Python for ML
• 05-PyTorch
• 06-Classical ML
• 07-Deep Learning
• 08-Transformers
• 09-LLM Application Engineering
• 10-Retrieval & RAG
• 11-Agents
• 12-Evaluation Systems
• 13-LLM Observability
• 14-Inference & Serving
• 15-Fine-tuning
• 16-Distributed Training

Weeks¶

• Q1-Foundations: Month 1, Week 1 … Month 3, Week 4
• Q2-Applied AI Engineering: Month 4, Week 1 … Month 6, Week 4
• Q3-Specialization + Infra: Month 7, Week 1 … Month 9, Week 4
• Q4-Synthesis + Public Portfolio: Month 10, Week 1 … Month 12, Week 4

Conventions¶

• Math: rendered inline using ‖a‖, θ, etc. (plain Unicode, readable in any markdown viewer). Where derivations span multiple lines, code blocks are used.
• Code: Python skeletons are runnable; copy and extend, don't paste-and-pray.
• Links: durable sources (arXiv IDs, official docs, well-known author blogs). When a URL is uncertain, the doc names the resource so you can search for it.
• Self-check questions: answerable from the session content. If you can't answer, redo the part.
• Output of session: always a concrete artifact-notebook cell, repo commit, hand derivation photographed, blog draft. No session ends with "I read about X."
• Free-first. Where a paid course is recommended, a free alternative is also listed.
• Three sessions, not five. Block them in your calendar Sunday evening.

On the cadence and life¶

If you miss a session, don't panic-double-up. Skip it and continue. Three sessions/week sustained over 48 weeks beats four sessions/week for 12 weeks followed by burnout. The goal is compounding. Compounding requires consistency more than intensity.

If life forces a 4-week pause (vacation, illness, family), restart with the next session, not the missed one. The plan accommodates ~4 lost weeks/year by design.