How to use this roadmap
Do not measure progress by videos watched or certificates completed. Measure it by models implemented, experiments run, papers reproduced, hypotheses tested, and systems shipped.
20%
Learn
Courses, books, papers and lecture notes. Use video for intuition, not passive consumption.
50%
Implement + experiment
Write algorithms yourself, train models, break them intentionally, inspect gradients and compare baselines.
20%
Research
Read papers, reproduce results, design ablations and write conclusions.
Core rule: every major concept should pass through this loop: understand → derive → implement → train → debug → measure → explain.
12-month map
The Claude roadmap had excellent first-principles projects and research habits, but six months is too compressed for your stated goal. This version gives model training, post-training, research methodology and production systems their own space.
Months 1–2Math + classical ML
Months 3–4Deep learning + PyTorch
Months 5–6NLP + Transformers
Months 7–8LLM training + post-training
Months 9–10Research + paper reproduction
Month 11Agentic AI depth + evaluation
Month 12Distributed training + production ML
OngoingPaper reading + research portfolio
The curriculum
Each phase has a purpose, primary resources, implementation work, a flagship project and a checkpoint before you move on.
PHASE 0
Environment + experiment discipline
Learn
PyTorch tensors, devices, reproducibility, environments, notebooks vs packages, experiment configs, Git discipline.
Resources
Projects
Tensor sanity labManually calculate derivatives for a tiny tensor graph and verify against autograd.
Experiment template repoConfig-driven training script, logging, seeds, checkpoints, metrics, README and reproducible environment.
Move on when
You can run an experiment twice with the same seed, explain every tensor shape, and recover a run from a checkpoint.
PHASE 1
Mathematics for ML
Master
Vectors, matrix multiplication, basis, rank, eigendecomposition, SVD, derivatives, partial derivatives, gradients, Jacobians, chain rule, probability, expectation, variance, covariance, MLE, entropy, cross-entropy, KL divergence.
Projects
Gradient checkerFinite-difference gradients vs analytical gradients for several functions.
PCA from scratchCovariance matrix → eigenvectors → projection; compare with sklearn.
Linear regression from first principlesClosed-form and gradient descent; derive MSE gradient by hand.
Skip / de-prioritize
Do not spend excessive time implementing Gauss-Jordan inversion or Strassen multiplication. Understand them conceptually; your highest-value work is gradients, matrix operations, optimization and statistics.
Move on when
You can derive gradient descent for linear regression and explain cross-entropy, MLE and PCA without memorized scripts.
PHASE 2
Classical machine learning
Resources
Learn
Linear/logistic regression, regularization, bias/variance, SVM intuition, trees, random forests, boosting, clustering, GMM/EM, PCA, model selection, calibration, data leakage, imbalanced classification.
Projects
ml-from-scratch packageLinear regression, logistic regression, k-means, PCA and one decision tree implemented with NumPy.
Model diagnostics studyTake a real tabular dataset; intentionally introduce leakage, imbalance and overfitting, then diagnose each failure.
Research habit
For each model, write: assumptions, objective function, optimization method, failure cases and a baseline comparison.
Move on when
You can explain why a model failed, not just whether its accuracy is high.
PHASE 3
Backpropagation + deep learning + PyTorch
Resources
Learn
Computation graphs, backprop, initialization, activations, normalization, optimizers, schedulers, regularization, CNNs, residual connections, mixed precision basics, training/validation behavior.
Projects
Micrograd cloneScalar Value class, graph construction and backward pass. Build an MLP on top.
Raw-tensor MLPMNIST network with manual forward/backward math before using nn.Module.
CIFAR-10 CNN → mini-ResNetTrack training curves, parameter counts, throughput and failure modes.
Manual BatchNorm + DropoutImplement the training/inference behaviors yourself and compare to PyTorch modules.
Required experiments
learning rate sweep
batch-size sweep
activation comparison
with/without weight decay
with/without BatchNorm
gradient-norm tracking
intentional overfit on tiny batch
Move on when
If loss stops moving, you have a systematic debugging checklist rather than random guesses.
PHASE 4
NLP foundations → Transformers
Resources
Learn
Tokenization, embeddings, Word2Vec intuition, RNN/LSTM history, seq2seq, attention, Q/K/V, causal masks, multi-head attention, position encodings/RoPE, residuals, LayerNorm/RMSNorm, encoder vs decoder architectures.
Projects
BPE tokenizer from scratchMerge statistics, vocabulary, encode/decode, compression behavior and unknown-text tests.
Character RNN/LSTMShort historical exercise to understand recurrence and long-range limitations.
Attention from scratchMasked self-attention and multi-head attention; annotate every tensor dimension.
Mini GPTDecoder-only Transformer trained on Tiny Shakespeare or another small corpus.
Required derivation
Q: [B,H,T,Dh]
K: [B,H,T,Dh]
Q @ Kᵀ -> [B,H,T,T]
softmax(scores / sqrt(Dh))
weights @ V -> [B,H,T,Dh]
Move on when
You can implement causal self-attention without copying a library implementation and explain why every dimension exists.
PHASE 5
LLM pretraining + training dynamics
Learn
Causal LM objective, dataset packing, token budgets, AdamW, warmup, cosine decay, gradient clipping, mixed precision, gradient accumulation, checkpointing, validation perplexity, scaling intuition, data quality.
Resources
Flagship project
Train your own small language model10M–100M parameter range depending on compute. Build data pipeline, tokenizer, training loop, checkpoints, metrics and evaluation.
Required experiments
LR: 3e-4 vs 1e-3
context length: short vs longer
model depth: baseline vs deeper
weight decay: 0 vs tuned
data quality: raw vs cleaned
batch size / grad accumulation
with/without gradient clipping
Deliverable
Write a training report with curves, compute budget, tokens seen, tokens/sec, best checkpoint, failure cases and conclusions.
Move on when
You understand why a run diverged or plateaued and can compare training configurations scientifically.
PHASE 6
Fine-tuning + post-training + evaluation
Learn
Full fine-tuning, LoRA, QLoRA, SFT, preference data, DPO, quantization, eval-set design, contamination, exact-match vs model-graded evaluation, calibration and error analysis.
Projects
Toy LoRA implementationImplement low-rank A/B adapters yourself before using PEFT.
Controlled fine-tuning studySame dataset and model: compare full FT vs LoRA vs QLoRA where feasible.
Evaluation harnessDeterministic task set, metrics, failure categories and regression tracking.
Move on when
You can explain why a fine-tune improved one behavior while degrading another, using evidence rather than anecdotes.
PHASE 7
Research apprenticeship
Paper order
Word2Vec → Seq2Seq → Bahdanau Attention → Attention Is All You Need → BERT → GPT-2 → Scaling Laws → Chinchilla → LoRA → QLoRA → FlashAttention → LLaMA → DPO → selected current papers.
Read in 3 passes
PASS 1: abstract, intro, figures, conclusion
PASS 2: method, architecture, experiments
PASS 3: equations, implementation details, appendix
Research projects
Paper reproduction #1Reproduce a manageable result from a landmark paper on a smaller dataset.
Ablation studyRemove or alter one component, run multiple seeds when feasible, report mean/variance.
Paper reproduction #2Choose a more modern topic: LoRA, attention variant, retrieval, evaluation or agent behavior.
Research write-upProblem → hypothesis → method → baseline → experiments → ablations → results → limitations → next hypothesis.
Weekly target
1–2 serious papers/week, one reproduction every ~6–8 weeks. Quality beats reading 50 abstracts.
Move on when
You can read a paper and identify its baseline, independent variable, evaluation setup, likely confounders and an experiment you would run next.
PHASE 8
Agentic AI — model behavior, not framework tourism
Resources
Learn
Tool calling, planning, structured generation, context engineering, state, retrieval, long-horizon failure, retries, reflection, model/tool boundaries, agent evaluation and cost/latency trade-offs.
Projects
Raw ReAct agentNo LangChain/LangGraph. Your own loop, state and tool executor.
Tool-use evaluation benchmarkExpected tool + expected arguments + execution success + latency + cost.
Memory experimentCompare no-memory vs vector retrieval vs summarized memory on a controlled benchmark.
Optional multi-agent studyOnly after a strong single-agent baseline. Compare whether multiple agents actually improve measured performance.
Metrics
task success rate
tool-selection accuracy
argument accuracy
unnecessary tool calls
recovery rate
latency
token cost
hallucinated actions
Move on when
You can show whether your agent architecture is better than a simpler baseline using a reproducible evaluation set.
PHASE 9
Distributed training + production ML
Learn
Single GPU profiling → AMP → gradient accumulation → DDP → FSDP → multi-node basics; data/model versioning, registry, deployment, continuous evaluation, drift, retraining, rollbacks, online/batch inference.
Serving
vLLM, continuous batching, KV cache, prefix caching, quantization, time-to-first-token, tokens/sec, GPU utilization, autoscaling and backpressure.
Capstone projects
Continuous training pipelineDagster/Airflow: ingest → validate → train → evaluate vs baseline → register if improved → deploy.
Distributed training labMove a working single-GPU training job to DDP, measure scaling efficiency, then try FSDP if compute allows.
High-throughput LLM servingServe a trained/fine-tuned model with vLLM. Load test concurrency, TTFT, throughput and GPU memory.
Move on when
You can train, register, deploy, observe and roll back a model with reproducible artifacts and measured performance.
Your final portfolio
You do not need 30 toy repositories. Aim for 6–8 projects that show increasing depth.
| Project | What it proves | Required artifact |
|---|---|---|
| ML from Scratch | Math + algorithms | Library + tests + derivations |
| Micrograd + MLP | Backprop understanding | Autograd engine + notebook explanation |
| ResNet/CIFAR study | Training/debugging skill | Experiment report + curves |
| BPE + Mini GPT | Transformer internals | Tokenizer + model + samples |
| Small LM pretraining | Actual model training | Training report + checkpoints |
| LoRA/QLoRA study | Post-training | Controlled comparison + eval harness |
| Paper reproduction | Research skill | Reimplementation + ablation + write-up |
| Production ML capstone | End-to-end ML engineering | Training → registry → serving → monitoring |
What to deliberately deprioritize
Certificates
Useful only as structure. They are not your evidence of research ability.
Framework collecting
Don't learn five agent frameworks. Build one raw system, then learn abstractions.
Huge-model obsession
A 30M parameter experiment you fully understand is more educational than renting a giant model and copying a script.
Notebook-only work
Exploration in notebooks is fine; mature projects should become packages, reproducible scripts and documented experiments.
Weekly operating system
A realistic schedule alongside a full-time engineering job.
| Day | Focus | Output |
|---|---|---|
| Mon · 1.5h | Theory / lecture | Notes + unanswered questions |
| Tue · 1.5h | Math / derivation | One derivation worked by hand |
| Wed · 2h | Implementation | Concept coded from scratch |
| Thu · 2h | Experiment | One controlled run logged |
| Fri · 1h | Paper | Research note |
| Sat · 4h | Main project | Meaningful project milestone |
| Sun · 2h | Analysis / review | Plots, conclusions, next hypothesis |
Use AI carefully while learning: use it as a tutor, reviewer and debugging partner, but for first-principles exercises, derive and write the first implementation yourself before asking for help. The point is to build your own internal model of how the system works.
Research note template
Paper note
Problem:
Previous approach:
Core idea:
Key equation:
Dataset:
Baseline:
Main result:
Limitations:
What I don't understand:
Reproduction plan:
Ablation I would run:
My next hypothesis:
Experiment note
Hypothesis:
Baseline:
Independent variable:
Controlled variables:
Seeds:
Metrics:
Result:
Unexpected behavior:
Failure analysis:
Conclusion:
Next experiment:
North-star skill checklist
- Derive gradient descent and backprop
- Implement ML algorithms with NumPy
- Debug PyTorch training loops
- Implement attention and Transformers
- Write a BPE tokenizer
- Train a small language model
- Run controlled hyperparameter studies
- Fine-tune with LoRA/QLoRA
- Design reliable evaluations
- Read and critique ML papers
- Reproduce a paper result
- Run ablation studies
- Build an agent without frameworks
- Evaluate tool-use reliability
- Use DDP/FSDP conceptually and practically
- Serve LLMs with performance metrics
- Build model registry + deployment flow
- Write research-quality reports