Brain Bank

Search Brain Bank

Search is available on the built site (npm run build).

Section 8 of 9

AI Learning Roadmaps

Seven zero-prerequisite roadmaps: ML, Deep Learning, NLP, GenAI, LLMs, RAG, and Agentic AI.

Roadmap 1 — Machine Learning (classical) · ~3–4 months

  1. Math minimum: linear algebra (vectors, matrices, dot products), basic calculus (derivatives, gradients), probability/statistics (distributions, Bayes, mean/variance). Resource: 3Blue1Brown “Essence of Linear Algebra” + “Essence of Calculus” (YouTube); Khan Academy statistics.
  2. Core concepts: supervised vs unsupervised; train/validation/test split; overfitting/underfitting; bias-variance; cross-validation; metrics (accuracy, precision/recall, F1, ROC-AUC, RMSE).
  3. Algorithms: linear/logistic regression, decision trees, random forests, gradient boosting (XGBoost/LightGBM), k-means, PCA, kNN, SVM (conceptual).
  4. Tooling: scikit-learn end-to-end pipelines, pandas feature engineering, matplotlib evaluation plots.
  5. Practice: Kaggle “Titanic” then a tabular competition; one end-to-end project (data → cleaned features → model → evaluation → simple API serving via FastAPI). Canonical free courses: Andrew Ng “Machine Learning Specialization” (Coursera — free to audit); Kaggle Learn “Intro to ML” + “Intermediate ML”; StatQuest (Josh Starmer) YouTube for metric/algorithm intuition.

Roadmap 2 — Deep Learning · ~3–4 months (after Roadmap 1 basics, or in parallel)

  1. Neural net fundamentals: perceptron, activation functions, loss functions, backpropagation, gradient descent variants (SGD, Adam).
  2. Framework: PyTorch (industry default) — tensors, autograd, nn.Module, DataLoaders, training loops.
  3. Architectures: MLPs → CNNs (vision) → RNNs/LSTMs (conceptual, mostly historical now) → Transformers (the one that matters).
  4. Training craft: regularization (dropout, weight decay), batch norm, learning-rate schedules, GPU usage (Colab free tier), experiment tracking (Weights & Biases free tier).
  5. Practice: MNIST/CIFAR-10 classifier from scratch; fine-tune a pretrained ResNet; reimplement a tiny transformer. Canonical free courses: Andrej Karpathy “Neural Networks: Zero to Hero” (YouTube — builds backprop and GPT from scratch, widely considered the best single free DL resource); fast.ai “Practical Deep Learning for Coders”; 3Blue1Brown “Neural networks” series.

Roadmap 3 — NLP · ~2 months (after DL basics)

  1. Classical NLP (1 week, context only): tokenization, stemming/lemmatization, TF-IDF, bag-of-words.
  2. Embeddings: word2vec/GloVe concept → contextual embeddings → sentence embeddings (SBERT).
  3. Transformers for NLP: attention mechanism, BERT (encoder) vs GPT (decoder) families; fine-tuning for classification/NER.
  4. Tooling: Hugging Face transformers, datasets, tokenizers; the Hugging Face Hub.
  5. Practice: sentiment classifier by fine-tuning DistilBERT; semantic-search demo with sentence-transformers. Canonical free courses: Hugging Face “LLM Course” (hf.co/learn — free, hands-on); Stanford CS224N lectures (YouTube); Jay Alammar “The Illustrated Transformer” (blog).

Roadmap 4 — Generative AI (broad) · ~1–2 months · CAN START EARLY

  1. Landscape: what generative models do — text (LLMs), images (diffusion: Stable Diffusion, Midjourney), audio, video; closed APIs vs open-weights models.
  2. Prompt engineering: zero/few-shot, chain-of-thought, system prompts, structured output (JSON mode), prompt evaluation.
  3. API fluency: OpenAI + Anthropic SDKs — chat completions/messages, streaming, function/tool calling, vision inputs, token counting + cost control.
  4. Safety/limits: hallucination, jailbreaks, data privacy, rate limits.
  5. Practice: build 3 small tools — summarizer CLI, structured-data extractor (invoice → JSON), simple chatbot UI (your Angular skills: chat frontend + Node or FastAPI proxy backend). Canonical free courses: DeepLearning.AI short courses (“ChatGPT Prompt Engineering for Developers”, “Building Systems with the ChatGPT API” — free); Anthropic docs + cookbook (github.com/anthropics/anthropic-cookbook); Microsoft “Generative AI for Beginners” (GitHub, free).

Roadmap 5 — LLMs (deeper understanding) · ~2–3 months

  1. How LLMs work: next-token prediction, tokenizers (BPE), context windows, sampling params (temperature, top-p), KV cache — Karpathy “Intro to Large Language Models” + “Let’s build GPT” videos.
  2. Training pipeline concepts: pretraining → SFT → RLHF/DPO; instruction tuning; why models hallucinate.
  3. Open-weights ecosystem: Llama/Mistral/Qwen families; running locally (Ollama, llama.cpp); quantization (GGUF, 4-bit).
  4. Fine-tuning: when to (and mostly NOT to) fine-tune; LoRA/QLoRA with Hugging Face PEFT; dataset prep.
  5. Evaluation: benchmarks (MMLU etc.) and their limits; building task-specific evals; LLM-as-judge patterns.
  6. Practice: run Llama locally via Ollama; LoRA fine-tune a small model (7B) on a custom dataset in Colab; build an eval harness for one of your Roadmap-4 tools. Canonical free resources: Karpathy “Zero to Hero” finale + “Let’s build the GPT Tokenizer”; Hugging Face LLM course; Maxime Labonne “LLM Course” (GitHub — free, popular roadmap repo).

Roadmap 6 — RAG (Retrieval-Augmented Generation) · ~1–2 months

  1. Why RAG: LLM knowledge is frozen + hallucination-prone; RAG = retrieve relevant docs, stuff into context, generate grounded answer.
  2. Pipeline anatomy: document loading → chunking strategies (size/overlap/semantic) → embedding models → vector stores (pgvector, Pinecone, Qdrant, Chroma) → similarity search → prompt assembly → generation with citations.
  3. Advanced retrieval: hybrid search (BM25 + vectors), reranking (Cohere/cross-encoders), query rewriting, metadata filtering, parent-document retrieval.
  4. Evaluation: faithfulness/answer-relevance/context-precision (RAGAS framework); golden-set testing.
  5. Production concerns: index refresh, access control on documents (your RBAC experience is directly relevant), cost/latency budgets, caching.
  6. Practice: “chat with your docs” app over your own project documentation — Angular frontend, FastAPI backend, pgvector store; add reranking + eval suite; measure improvement. Canonical free resources: DeepLearning.AI short courses on RAG/vector databases (“Building Applications with Vector Databases”, LangChain RAG courses); LangChain + LlamaIndex official docs/tutorials; pgvector README + Supabase RAG guides.

Roadmap 7 — Agentic AI / Building Agents · ~2–3 months (after 4 + 6)

  1. What an agent is: LLM in a loop with tools + memory + goal; ReAct pattern (reason → act → observe); difference from a chatbot.
  2. Tool use / function calling: define tool schemas, parse model tool calls, execute, feed results back — do this RAW (no framework) first with OpenAI/Anthropic SDKs to understand the loop.
  3. Protocols & standards: MCP (Model Context Protocol) — connecting agents to external tools/data (open standard, launched by Anthropic Nov 2024, now industry-adopted).
  4. Frameworks: LangGraph (graph-based state machines — most popular for production 2025-26), CrewAI (multi-agent teams), OpenAI Agents SDK; when NO framework beats a framework.
  5. Agent engineering: planning/decomposition, short-vs-long-term memory, human-in-the-loop gates, guardrails, sandboxing tool execution (security — your JWT/RBAC background maps to agent authZ), observability/tracing (LangSmith/Langfuse), cost control.
  6. Multi-agent patterns: orchestrator-workers, evaluator-optimizer, handoffs; Anthropic “Building Effective Agents” essay patterns.
  7. Practice: raw tool-calling agent (weather+calculator) → coding agent that reads/writes files in a sandbox → RAG-agent hybrid (“research assistant” that searches, reads, synthesizes with citations) → one MCP server for a service you know (e.g., MySQL MCP server). Canonical free resources: Anthropic “Building Effective Agents” (anthropic.com/research); Hugging Face “AI Agents Course” (free); DeepLearning.AI agent short courses (LangGraph, “AI Agents in LangGraph”, CrewAI); LangGraph docs; MCP docs (modelcontextprotocol.io).

Sequencing recommendation for a full-stack dev: 4 → 6 → 7 (application track, employable in ~4–6 months) while drip-feeding 1 → 2 → 5 fundamentals in parallel. Roadmap 3 (NLP) only if targeting NLP-specialist roles.

Seven learning paths, explained as learning to work in a restaurant industry that just invented a miracle kitchen appliance (the AI model):

  1. Machine Learning — Learn how appliances predict things by finding patterns: “houses this size usually sell for this much.” Like learning classic recipes: shows you how cooking (prediction) fundamentally works. 3–4 months.
  2. Deep Learning — How the modern miracle appliances are built inside: layers of simple parts that, stacked deep, learn to recognize faces or understand speech. Appliance-engineering school. 3–4 months.
  3. NLP (Natural Language Processing) — Teaching machines to read and write human language — the specialty behind translation apps and spam filters. 2 months.
  4. Generative AI — You don’t build the appliance; you learn to cook amazing dishes with it. Using ready-made AI (ChatGPT, Claude) through their plug sockets (“APIs” — standardized connectors programs use to talk to each other). Fastest path to something useful. 1–2 months, can start immediately.
  5. LLMs (Large Language Models) — Popping the hood of the miracle appliance: why it sometimes confidently makes things up (“hallucination”), how to run a small one on your own computer, how to fine-tune it to your taste. 2–3 months.
  6. RAG (Retrieval-Augmented Generation) — The AI’s knowledge is frozen at training time and it never read your company’s private files. RAG is giving the chef your cookbook before asking for a recipe: the AI looks up your documents first, then answers from them. This powers most “chat with our company data” products. 1–2 months.
  7. Agentic AI — Instead of one question–one answer, you give the AI a goal and tools, and it works step-by-step like an intern: reads the request, searches, uses a calculator, drafts the email, checks its work. Building and supervising these “digital interns” is the hottest new job skill. 2–3 months.

Smart order for a working developer: start with 4 (cook with the appliance), then 6 (give it your cookbook), then 7 (turn it into an intern). Learn the engineering theory (1, 2, 5) gradually on the side. Employable in AI work within about half a year of evenings, using entirely free courses — Andrew Ng’s classes, Andrej Karpathy’s YouTube series, Hugging Face’s free courses.

Diagrams

Green = application-first track (fastest to employability for full-stack devs). Dotted = helpful but not blocking.

Two-track 12-month timeline

0 1 2 3 4 5 6 7 8 9 10 11 12 Track A — Apps Track A — Apps — GenAI: 1–2 GenAI Track A — Apps — RAG: 2–4 RAG Track A — Apps — Agents: 4–7 Agents Track A — Apps — Portfolio + job apps: 7–12 Portfolio + job apps Track B — Fundamentals Track B — Fundamentals — Math + ML: 1–4 Math + ML Track B — Fundamentals — DL / Karpathy: 4–8 DL / Karpathy Track B — Fundamentals — LLM internals: 8–11 LLM internals month
Track B runs in parallel, lighter effort — Track A is the fast path to employability.
Data table
TrackPhaseStartEnd
Track A — Apps GenAI 1 2
Track A — Apps RAG 2 4
Track A — Apps Agents 4 7
Track A — Apps Portfolio + job apps 7 12
Track B — Fundamentals Math + ML 1 4
Track B — Fundamentals DL / Karpathy 4 8
Track B — Fundamentals LLM internals 8 11

Sources

  1. Andrew Ng — Machine Learning Specialization
  2. Andrej Karpathy — “Neural Networks: Zero to Hero”
  3. fast.ai — Practical Deep Learning for Coders
  4. 3Blue1Brown — Essence of Linear Algebra / Neural networks
  5. Hugging Face Learn — LLM Course, AI Agents Course
  6. DeepLearning.AI short courses
  7. Anthropic — “Building Effective Agents”
  8. Model Context Protocol docs
  9. LangGraph docs
  10. Maxime Labonne — LLM Course
  11. Microsoft — Generative AI for Beginners
  12. RAGAS docs
  13. StatQuest YouTube
  14. Stanford CS224N