Learning Roadmap - From Beginner to Expert¶

A structured path through the collection's 107 papers, 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 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
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

8. Derive: DPO's closed form from the RLHF objective; this is the key exercise

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

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

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

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

13. Interpretability and safety - Sparse Autoencoders, Sleeper Agents, Emergent Abilities

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

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

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

17. 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

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

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.

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.