Learning Roadmap - From Beginner to Expert¶

A structured path through the collection's papers, essays and explainers, chosen by your background and goals.

Each path is a curated subset, not the whole library - the point is an order that builds on itself. When you finish one, BROWSE.md and INDEX.md have everything else, and READING_GUIDE.md says which of it is still worth your time.

Choose Your Path¶

Path 1: Complete Beginner (No ML Background)¶

Goal: Understand what modern AI is and how it works Time: 20-30 hours Prerequisites: None

Path 2: Software Engineer¶

Goal: Build AI applications Time: 15-20 hours Prerequisites: Programming experience

Path 3: ML Student/Researcher¶

Goal: Deep technical understanding Time: 30-40 hours Prerequisites: Linear algebra, calculus, basic ML

Path 4: AI Product Manager¶

Goal: Understand capabilities and trade-offs Time: 10-15 hours Prerequisites: None

Path 5: Reasoning & Agents (2024-2026)¶

Goal: Catch up on everything that happened after the "essential papers" lists were written Time: 12-18 hours Prerequisites: Path 2, or comfort with Transformers, RLHF and Chain-of-Thought

Path 6: The Big Picture (no maths, no code)¶

Goal: Hold an informed opinion about where AI is, who is building it, and what is unresolved Time: 8-12 hours Prerequisites: None

Path 1: Complete Beginner¶

Week 1: Foundations¶

Goal: Understand the basic architecture that powers everything

Day 1-2: Start with Transformers - Read: Transformers summary - Focus on: "Why This Matters" and "Core Innovation" sections - Skip: Mathematical formulas on first read - Watch: "The Illustrated Transformer" (linked in summary) - Key takeaway: Self-attention lets models process all words at once

Day 3: Understanding Language Models - Read: GPT-3 summary - Focus on: Few-shot learning, in-context learning - Try: Experiment with ChatGPT using few-shot examples - Key takeaway: Large models can learn from examples in prompts

Day 4-5: Why Training Matters - Read: Scaling Laws summary - Focus on: The three scaling laws (simple version) - Read: LLaMA summary - Key takeaway: Training longer on more data > just making bigger models

Day 6-7: Review and Explore - Re-read any confusing sections - Check Glossary for terms you don't understand - Watch related YouTube videos (Two Minute Papers, etc.)

Week 2: Image Generation¶

Goal: Understand how AI creates images

Day 8-9: Basic Image Generation - Read: GANs summary - Focus on: Generator vs discriminator game - Key takeaway: Two models competing makes both better

Day 10-11: Modern Image Generation - Read: Diffusion Models summary - Focus on: Iterative denoising process - Read: Stable Diffusion summary - Try: Generate images with Stable Diffusion online demo - Key takeaway: Modern models denoise step-by-step

Day 12-13: Connecting Text and Images - Read: CLIP summary - Focus on: How models learn image-text relationships - Key takeaway: Contrastive learning aligns vision and language

Day 14: Review Week 2 - Use Quick Reference to compare approaches - Try different text-to-image tools to see concepts in action

Week 3: Making AI Helpful¶

Goal: Understand alignment and practical techniques

Day 15-16: Making AI Follow Instructions - Read: InstructGPT summary - Focus on: RLHF process (simplified) - Key takeaway: Human feedback shapes model behavior

Day 17-18: Practical Improvements - Read: Chain-of-Thought summary - Try: Use "let's think step by step" in ChatGPT - Read: RAG summary - Key takeaway: Techniques that make models more useful

Day 19-20: Efficient Adaptation - Read: LoRA summary - Focus on "Why This Matters" - Key takeaway: Can customize models without retraining everything

Day 21: Final Review - Read Comparisons - "When to Use Which" - Reflect on how all pieces fit together

Path 2: Software Engineer¶

Sprint 1: Architecture (3-5 days)¶

Goal: Understand the underlying architectures

1. Transformers - The foundation
2. Focus on: Architecture details, code examples
3. Implement: Basic attention mechanism

4. Resources: Hugging Face tutorial

5. Vision Transformer - Extending to images

6. Focus on: How patches work, unified architecture
7. Implement: Patch embedding

8. Key: Same architecture works for text and images

9. Scaling Laws - Planning resources

10. Focus on: Practical implications
11. Use this: When choosing model size for your project

Sprint 2: Practical Techniques (5-7 days)¶

Goal: Learn tools for building applications

1. RAG - Most important for applications
2. Focus on: Implementation guide, code examples
3. Implement: Basic RAG with LangChain
4. Try: LlamaIndex tutorials

5. This is crucial: 80% of production LLM apps use RAG

6. LoRA - Efficient fine-tuning

7. Focus on: Implementation, when to use
8. Implement: Fine-tune a small model with LoRA

9. Resources: PEFT library examples

10. Chain-of-Thought - Better prompting

11. Focus on: Prompt engineering techniques
12. Implement: CoT prompts in your app
13. Quick win: Improves reasoning immediately

Sprint 3: Deployment Decisions (2-3 days)¶

Goal: Choose the right approach for your use case

1. LLaMA - Open-source options
2. Focus on: Model sizes, deployment costs
3. Compare: LLaMA vs GPT API for your use case

4. Resources: llama.cpp for local deployment

5. InstructGPT vs Constitutional AI - Alignment

6. Focus on: Which alignment approach fits your needs

7. Read: Comparisons - Alignment section

8. Review Quick Reference

9. Section: "When to Use Which Paper's Techniques"
10. Build: Decision tree for your projects

Sprint 4: What Production Actually Runs On (4-6 days)¶

Goal: The layer between "it works in a notebook" and "it serves users"

1. Dense Retrieval - the retriever under your RAG
2. Focus on: why pure vector search misses IDs, error codes and proper nouns
3. Build: hybrid BM25 + dense retrieval with rank fusion

4. This is the single most common RAG bug

5. PagedAttention / vLLM - serving

6. Focus on: KV-cache waste, continuous batching

7. Try: serve a model with vLLM, compare throughput to raw Transformers

8. GPTQ & AWQ - fitting the model

9. Focus on: what 4-bit costs you in quality

10. Try: run a 70B quantised model locally

11. MCP - tool integration

12. Focus on: the M x N problem it removes

13. Build: a small MCP server exposing one of your own tools

14. LLM-as-a-Judge - knowing if it works

15. Focus on: position bias, verbosity bias, self-preference
16. Build: an eval set for your own app before you need one

Hands-On Project Ideas¶

• RAG chatbot: company docs + hybrid retrieval + a local model, served with vLLM
• Fine-tuned classifier: LoRA or QLoRA on domain-specific data
• Text-to-image app: Stable Diffusion with ControlNet for layout and a subject LoRA
• Coding agent: ReAct loop + MCP tools, scored against a slice of SWE-bench
• Reasoning assistant: Chain-of-Thought with self-consistency, measured against a single pass

Path 3: ML Student/Researcher¶

Phase 1: Theoretical Foundations (1-2 weeks)¶

Goal: Deep understanding of core innovations

1. Transformers - Study in depth
2. Read: Full paper + summary
3. Implement: Full Transformer from scratch
4. Understand: All mathematical details

5. Study: Attention visualization, positional encodings

6. Scaling Laws - Mathematical foundations

7. Read: Full paper
8. Understand: Power law derivations
9. Study: Chinchilla revisions

10. Apply: Predict performance for your compute budget

11. Vision Transformer - Architecture generalization

12. Read: Full paper + summary
13. Compare: CNN inductive biases vs Transformer learned patterns
14. Implement: Patch embedding, position interpolation
15. Study: Attention patterns in different layers

Phase 2: Training Methods (2 weeks)¶

Goal: Understand different training paradigms

1. BERT - Masked language modeling
2. Implement: MLM from scratch
3. Understand: Bidirectional training

4. Compare: vs autoregressive (GPT)

5. GPT-3 - Autoregressive scaling

6. Read: Full paper (especially Broader Impacts section)
7. Understand: Few-shot learning emergence

8. Study: In-context learning mechanisms (active research area)

9. LLaMA - Compute-optimal training

10. Read: Full paper
11. Understand: How they applied Chinchilla laws
12. Study: Training optimizations (Flash Attention, etc.)
13. Compare: Data mixtures, preprocessing

Phase 3: Generative Models (2 weeks)¶

Goal: Master generative modeling approaches

1. GANs - Adversarial training
2. Read: Full paper + all variants (DCGAN, StyleGAN, etc.)
3. Implement: Basic GAN, understand training dynamics

4. Study: Mode collapse, training stabilization

5. Diffusion Models (DDPM) - Denoising approach

6. Read: Full paper + mathematical derivations
7. Implement: DDPM from scratch

8. Understand: Reverse process, score matching, SDE formulation

9. Stable Diffusion - Latent diffusion

10. Read: Full paper
11. Understand: VAE compression, latent space diffusion

12. Implement: Text conditioning with cross-attention

13. CLIP - Contrastive multimodal

14. Read: Full paper
15. Implement: Contrastive loss, dual encoder
16. Study: Zero-shot capabilities, prompt engineering

Phase 4: Alignment & Efficiency (1-2 weeks)¶

Goal: Understand alignment and efficient training

1. InstructGPT (RLHF) - Human feedback
2. Read: Full paper
3. Understand: PPO for language models, reward modeling

4. Study: SFT → RM → RL pipeline

5. Constitutional AI - AI feedback

6. Read: Full paper
7. Compare: vs RLHF (trade-offs)

8. Study: Critique-revision process

9. LoRA - Parameter-efficient fine-tuning

10. Read: Full paper
11. Understand: Low-rank decomposition mathematics
12. Implement: LoRA from scratch

13. Compare: vs other PEFT methods (prefix tuning, adapters)

14. RAG - Retrieval-augmented

15. Read: Full paper
16. Understand: End-to-end training, marginalization

17. Implement: Dense retrieval + generation

18. Chain-of-Thought - Reasoning

19. Read: Full paper
20. Study: Why it works, when it emerges
21. Research: Latest CoT variants (Tree of Thoughts, etc.)

Phase 5: The Modern Frontier (2-3 weeks)¶

Goal: Reach the current research edge

1. Efficient architecture - RoPE, GQA, FlashAttention, Mixtral / MoE, Mamba, Mamba-3
2. Implement: rotary embeddings and grouped-query attention from scratch

3. Understand: why every frontier model is now sparse

4. Training systems - ZeRO & Megatron-LM

5. Understand: data, tensor, pipeline and expert parallelism, and where each breaks down

6. This is the phase most theory-first researchers skip and later regret

7. Alignment, current generation - DPO, KTO, GRPO, RLVR, Tulu 3, DAPO

8. Origins: Christiano 2017 then Stiennon 2020 are the two papers before InstructGPT
9. Derive: DPO's closed form from the RLHF objective; this is the key exercise

10. Compare: what each method removes from the PPO pipeline, and what it costs

11. Reasoning - STaR, Process Reward Models, Quiet-STaR, Test-Time Compute, DeepSeek-R1, s1

12. Understand: outcome vs process supervision, and the compute-optimal trade

13. R1 is the one to read in full: it documents what o1 did not

14. Interpretability and safety - Sparse Autoencoders, Sleeper Agents, Emergent Abilities, Circuit Tracing, Emergent Misalignment, Reasoning Models Don't Always Say What They Think

15. Implement: a sparse autoencoder on a small model's activations

16. Read Emergent Abilities with the Mirage rebuttal - it is a lesson in metric design

17. Generative modelling, current generation - DDIM, Classifier-Free Guidance, Flow Matching, DiT

18. Derive: flow matching's straight-path objective, compare to the DDPM ELBO

Research Project Ideas¶

• Reproduce results: Pick a paper, replicate key experiments
• Ablation studies: Remove components, measure impact
• Novel combinations: LoRA + Constitutional AI, etc.
• Scaling experiments: Validate scaling laws on your domain
• Analysis: Interpretability of attention patterns, emergent capabilities

Advanced Resources¶

• Read all "Further Reading" sections
• Study follow-up papers
• Join research discussions (r/MachineLearning, Twitter/X)
• Read criticism and rebuttals
• Implement from scratch (no libraries)

Path 4: AI Product Manager¶

Week 1: Understand Capabilities (6-8 hours)¶

Goal: Know what's possible and impossible

Day 1: Foundation (2 hours) - Read: Transformers - "Why This Matters" only - Read: Scaling Laws - Focus on practical implications - Key question: How does model size affect capabilities?

Day 2: Language Models (2 hours) - Read: GPT-3 - Few-shot learning section - Read: LLaMA - Comparison tables - Key question: What can current models do without fine-tuning?

Day 3: Image Generation (2 hours) - Read: Stable Diffusion - Practical applications section - Read: CLIP - Use cases section - Try: Generate some images to understand quality/speed - Key question: What's the cost/quality trade-off?

Week 2: Practical Deployment (6-8 hours)¶

Goal: Understand implementation trade-offs

Day 4: Making Models Useful (2 hours) - Read: RAG - "Why This Matters" and limitations - Read: Chain-of-Thought - When it helps - Key question: How to reduce hallucinations?

Day 5: Customization (2 hours) - Read: LoRA - Cost comparison - Read: Comparisons - RAG vs Fine-tuning section - Key question: When to fine-tune vs use RAG?

Day 6: Alignment & Safety (2 hours) - Read: InstructGPT - Why alignment matters - Read: Constitutional AI - Transparency benefits - Key question: How to ensure safe, aligned behavior?

Week 3: Decision Framework (4-6 hours)¶

Goal: Make informed product decisions

Day 7: Read Comparisons fully (2-3 hours) - Focus on: "When to Use Which", decision matrices - Output: Decision tree for your product

Day 8: Cost-Benefit Analysis (2-3 hours) - Read: Quick Reference - Cost comparisons - Compare: API vs self-hosted - Output: Cost model for your use case

Day 9: Roadmap Planning - Review: What's possible today vs future - Identify: Which papers' techniques apply to your product - Output: Technical feasibility assessment

Product Decision Cheat Sheet¶

For chatbots: - Use: InstructGPT/GPT-4 or Constitutional AI (Claude) - Add: RAG for knowledge grounding - Enhance: Chain-of-Thought for complex queries

For content generation: - Text: GPT-3/GPT-4 or LLaMA fine-tuned - Images: Stable Diffusion - Both: CLIP for text-image alignment

For classification/search: - Use: BERT-based models or CLIP (multimodal) - Customize: LoRA fine-tuning if needed

For domain-specific: - Base: LLaMA (open, cost-effective) - Customize: LoRA fine-tuning - Knowledge: RAG with domain docs

Key Metrics to Track: - Latency: RAG adds overhead, quantization helps - Cost: API vs self-hosted, model size - Quality: Accuracy, hallucination rate - Safety: Alignment approach (RLHF vs CAI)

Path 5: Reasoning & Agents (2024-2026)¶

Most "essential AI papers" lists were written before late 2024. This path covers what changed after them: models that are trained to reason rather than prompted to, alignment that shed its machinery, and agents that survive more than one turn.

Assumed: you already know Transformers, RLHF and Chain-of-Thought. If not, do Path 2 first.

Stage 1: How Reasoning Became a Training Target (4-5 hours)¶

The chain of ideas here is unusually clean - read them in order and each one answers a question the previous one raised.

1. Self-Consistency - one chain is unreliable, so sample many and vote. Raises: this is expensive.
2. STaR - keep the chains that reached the right answer and train on them. Raises: what if the right answer came from bad reasoning?
3. Process Reward Models - grade every step, not just the answer. Raises: step labels are expensive.
4. Test-Time Compute - the theory: when is thinking longer better than being bigger? This is the conceptual centre of the path.
5. OpenAI o1 - the first product built on it, with the method withheld.
6. DeepSeek-R1 - the same capability, with the method published. Read this one in full.

Stage 2: The Training Machinery (3-4 hours)¶

1. PPO - the baseline everything else is defined against (skim if you know it)
2. DPO - drop the reward model
3. KTO - drop the requirement for paired data
4. GRPO - drop the critic
5. RLVR - drop learned rewards entirely, where a verifier exists
6. Tulu 3 and DAPO - the open recipes that make it reproducible

The exercise that makes this stick: for each method, write down what it removed from the previous pipeline and what that cost. The whole line is a story of subtraction.

Stage 3: Agents That Last More Than One Turn (3-4 hours)¶

1. ReAct - the base loop
2. Reflexion - learning from failure without touching the weights
3. Self-Refine - the critic pattern, in its simplest form
4. Generative Agents - memory, reflection and planning as an architecture
5. Voyager - skills stored as reusable code
6. MCP - how the tools get connected
7. SWE-bench - how you find out whether any of it worked
8. Measuring AI Ability to Complete Long Tasks - how long a task agents can finish, and how fast that grows

Stage 4: Knowing What You Have (2-3 hours)¶

Reasoning and agent claims are unusually easy to overstate. This stage is the antidote.

1. LLM-as-a-Judge - and the biases it brings
2. Emergent Abilities - read it together with the Mirage rebuttal
3. Sparse Autoencoders - what interpretability can actually deliver today
4. Sleeper Agents - why "we safety-tuned it" is not proof of anything

Project Ideas¶

• Reasoning eval harness: take a task you care about, and measure single-pass vs chain-of-thought vs self-consistency at N=5, 10, 40. Plot accuracy against token spend. The crossover point is the most useful number you will produce this month.
• Verifier-first pipeline: find a task in your domain with checkable answers, then build the verifier before the model. RLVR only works where this exists.
• Agent with a real scoreboard: a ReAct loop over MCP tools, scored on a held-out slice of your own issue tracker rather than a benchmark.
• Judge calibration: have an LLM judge rank outputs you have already ranked yourself, and measure the disagreement. Do this before trusting a judge anywhere.

Where to Go Next¶

The frontier is moving fastest in world models (Genie, DreamerV3) and in applying the same toolkit outside language (AlphaFold 3, ESM-2, AlphaEvolve). See docs/GAPS.md for what this collection does not cover yet.

Path 6: The Big Picture (no maths, no code)¶

For anyone who needs to talk about AI sensibly - a manager, an investor, a policymaker, a curious reader - without learning to build it. It mixes the essays that set the field's direction, the explainers on how the industry actually works, and the open questions that nobody has settled. Nothing here assumes maths.

Stage 1: The Story So Far (2-3 hours)¶

1. Timeline of AI - seventy-five years in one page. Read it once quickly, then come back to it as a map.
2. Computing Machinery and Intelligence - Turing's 1950 question, and his answers to objections people still raise.
3. The Bitter Lesson - the one-page argument that explains most of the last decade.
4. The Scaling Hypothesis - the same bet, made explicit just after GPT-3.

Stage 2: Who Builds What (2-3 hours)¶

1. The labs landscape - the organisations, and what each is known for.
2. Pick two model families and read their lineage: GPT, Claude, Gemini, Llama, DeepSeek, Qwen, Mistral.
3. Open vs closed weights - the licensing spectrum, and why the distinction matters for policy.

Stage 3: Reading the Claims (1-2 hours)¶

Every launch arrives with a benchmark table. This stage is how you read one.

1. Contamination and saturation - why scores rise faster than ability.
2. Knowledge and reasoning benchmarks and agents and computer use - what the headline numbers measure.
3. Human-preference arenas - what a leaderboard rank does and does not tell you.

Stage 4: Money, Chips and Rules (2 hours)¶

1. Cost of training and inference economics - why the frontier is expensive and why using it keeps getting cheaper.
2. The AI hardware landscape - why chips and export controls became geopolitics.
3. The EU AI Act, US AI policy and frontier safety frameworks - the rules being written, by governments and by the labs themselves.

Stage 5: The Open Questions (1-2 hours)¶

Finish with the arguments, read side by side with the essays that take a position on them.

1. Is scaling hitting a wall?
2. Do LLMs reason?
3. Synthetic data and model collapse
4. Two views of where this goes: Machines of Loving Grace and Situational Awareness. Read both, then read their criticism sections.

You are done when you can explain to a friend why a model that tops one benchmark can still disappoint in use, why training costs and API prices move in opposite directions, and what the strongest argument is on each side of one open question.

General Tips for All Paths¶

Active Learning Strategies¶

1. Take notes: Write summaries in your own words
2. Draw diagrams: Visualize architectures and processes
3. Code along: Implement concepts (even simplified versions)
4. Teach others: Explain concepts to solidify understanding
5. Ask questions: Use issues or discussions

When You Get Stuck¶

1. Check Glossary for unfamiliar terms
2. Re-read "Why This Matters" section
3. Watch video explanations (linked in summaries)
4. Skip math details on first read, return later
5. Ask in community forums (r/MachineLearning, Discord servers)

Maximizing Understanding¶

• First read: Focus on concepts, skip equations
• Second read: Understand architecture and flow
• Third read: Work through mathematics
• Apply: Implement or use in a project

Tracking Progress¶

• Completed Week/Sprint/Phase 1
• Implemented at least one concept
• Can explain key innovations to someone else
• Understand when to use each technique
• Built a small project applying concepts

After Completing Your Path¶

Next Steps¶

For Beginners: - Build a simple project using one concept - Take an ML course (fast.ai, Coursera) - Re-read papers with more technical depth

For Engineers: - Build production applications - Contribute to open-source projects - Experiment with latest models - Share your implementations

For Researchers: - Read latest papers (2024-2025) - Identify research gaps - Propose novel combinations - Submit to conferences

For Product Managers: - Prototype AI features - Evaluate vendor solutions - Plan AI product roadmap - Stay updated on new capabilities

Staying Current¶

Follow these resources: - ArXiv daily (cs.AI, cs.CL, cs.CV) - Papers with Code (trending) - Hugging Face blog - OpenAI, Anthropic, Google AI blogs - Twitter/X: AI researchers - YouTube: Two Minute Papers, Yannic Kilcher

New papers to watch (2024-2025): - Multimodal models (GPT-4V, Gemini) - Longer context (100k+ tokens) - Efficient training (MoE, sparse models) - Better alignment (DPO, RRHF) - Reasoning improvements (Tree of Thoughts, etc.)

Customizing Your Path¶

Mix and match based on your specific interests:

Vision - ResNet → U-Net → ViT → MAE → CLIP → SAM 2

Language models, in lineage order - Transformers → GPT-1 → GPT-2 → GPT-3 → Chinchilla → LLaMA → Mistral → Mixtral → DeepSeek-V3

Image and video generation - VAE → GANs → DDPM → DDIM → Classifier-Free Guidance → Stable Diffusion → ControlNet → DreamBooth → Flow Matching / SD3 → Sora / DiT

Alignment and safety - InstructGPT → Constitutional AI → DPO → KTO → GRPO → RLVR → Llama Guard → Sleeper Agents → Sparse Autoencoders

Reasoning - Chain-of-Thought → Self-Consistency → Tree of Thoughts → STaR → Process Reward Models → Test-Time Compute → o1 → DeepSeek-R1

Efficiency and serving - Scaling Laws → Chinchilla → LoRA → QLoRA → FlashAttention → RoPE → GQA → GPTQ & AWQ → PagedAttention → Speculative Decoding → Mixture of Experts

Retrieval and agents - RAG → Dense Retrieval → GraphRAG → ReAct → Toolformer → Reflexion → Generative Agents → Voyager → MCP

Multimodal - Transformers → ViT → CLIP → LLaVA → Whisper → GPT-4V → Gemini 3

Science and world models - AlphaZero → AlphaFold 2 → AlphaFold 3 → ESM-2 → AlphaGeometry → AlphaEvolve → DreamerV3 → Genie → CICERO

Each of these is a complete thread through the collection. TAGS.md has the generated version of the same idea, by topic tag.

Estimated Time Investment¶

Quick pass: Skim summaries, focus on key sections Thorough: Read all summaries carefully, some code Deep study: Read papers, implement, experiment

Success Criteria¶

You've succeeded when you can:

✅ Explain the key innovation of each paper to a non-expert ✅ Choose the right technique for a given problem ✅ Understand trade-offs between different approaches ✅ Read new AI papers and understand them ✅ Build or deploy an AI application ✅ Critically evaluate AI products and claims

Remember: Everyone learns differently. Adjust the pace and depth to match your needs. The goal is understanding, not speed!

Questions? Open an issue or check Contributing.

Last updated: 2026-08-20 · Paths draw on all 107 papers; see INDEX.md for the full list.