This is the full path, in order, from "I can write a little Python" to building AI agents that call tools and fix their own mistakes. It is free, it is written for students, and every session has code you can run and quick checks to test yourself.

I wrote it the way I wish someone had taught me. Each session starts from the problem the previous model could not solve, then shows the idea that was invented to get past it. So you never meet a technique without knowing why it exists.

How to use this roadmap

  • Go in order. Each session lists what it builds on. Skipping ahead works, but you will keep tripping over words that an earlier session explained.
  • Run the code. Every snippet was executed and the output shown is real. Change a number and see what happens.
  • Use the course map. On any session, the map button opens the full list so you can jump anywhere. The ticks show what you have already read, saved in your own browser only.
  • Do the quick checks. One or two questions inside each article. They take ten seconds and they are where most of the learning sticks.

The story in one minute

Linear regression draws a straight line through data. It is fast and readable, but the world is rarely a straight line. So we learned how models learn (loss functions and gradient descent), and then split into two roads to handle curves. Road A uses trees and kernels, which are brilliant on spreadsheets. Road B stacks neurons into neural networks, which win on images, sound and text.

Neural networks for sequences ran into a memory wall, which attention and the Transformer broke through in 2017. Scale a Transformer up and you get a large language model. Give that model your documents, tools and a loop to think in, and you get an agent. Each stop in that story is a session below.

Prerequisites

Nothing heavy. If you can do these, you are ready:

  • Write basic Python (variables, loops, functions).
  • Load a CSV with pandas and look at it.
  • Read a simple chart.

Session 1 revises the practical parts anyway.

Part I: Data Foundations and Linear Models

  1. 01Environment Setup and Data FundamentalsRead →Python and Jupyter setup, a real dataset, cleaning, the train/test split and the training loop in one picture.
  2. 02AI vs ML vs DL vs GenAI, and Linear RegressionRead →How the four terms nest inside each other, then your first real model: a straight line, with the maths and the code.
  3. 03Regularized Regression: Lasso and RidgeRead →Why models memorise, and how a penalty on big weights fixes it. Ridge, Lasso and ElasticNet with real output and plots.
  4. 04Model Evaluation MetricsRead →How to judge a model honestly. Regression errors, the confusion matrix, and why accuracy alone can lie to you.
  5. 05Hyperparameters and TuningRead →The dials you set before training, how epochs and learning rate change the result, and how to tune without cheating.

Part II: How Models Learn

  1. 06Loss Functions and Activation FunctionsRead →A number for "how wrong am I", and the bend that lets a network learn curves. With plots and code you can run.
  2. 07Gradient Descent FamilyRead →The algorithm that trains every neural network. The update rule, the three variants and the optimisers built on top.
  3. 08Vanishing Gradient and Learning-Rate DecayRead →Why very deep networks stall, how to spot it, and how to steady the final steps of training.
  4. 09Clustering and ANN BasicsRead →Finding groups when nobody gave you labels, then the building blocks of an artificial neural network.
  5. 10ANN Deep Dive: Forward and Backward PropagationRead →Open the box. Every number of a tiny network, computed by hand and checked, then a NumPy network that learns XOR.

Part III: Tree-Based and Kernel Models

  1. 11Decision TreeRead →The most readable model in machine learning. How a tree picks its questions, and why a single deep tree memorises.
  2. 12Random ForestRead →Why hundreds of unreliable trees voting together beat one careful tree, shown with real numbers.
  3. 13Boosting Algorithms and XGBoostRead →Trees that learn from each other's mistakes. Gradient boosting built from scratch, XGBoost with early stopping, and the vocabulary of RL.
  4. 14Support Vector Machines (SVM)Read →The model that looks for the widest street between two classes, and the trick that lets it bend.
  5. 15Ensemble Learning TechniquesRead →Combine models for stability and accuracy, with the maths of why it works, an honest benchmark and when it is not worth it.

Part IV: Deep Learning for Images and Sequences

  1. 16CNN FundamentalsRead →How a network learns to see. Filters, feature maps and pooling, then a small CNN that reads handwritten digits.
  2. 17Optional Deep Dive: YOLO for VisionRead →A CNN that tells you what is where, in a single fast pass. Run a pre-trained YOLO model and learn how its boxes are scored.
  3. 18RNN FundamentalsRead →Networks with memory for text and time series. How the hidden state works, and the experiments that show where it breaks.
  4. 19LSTMRead →The recurrent cell with a protected memory line. Every gate computed by hand, with honest tests of what it does and does not fix.

Part V: Generative AI

  1. 20Transformers and ArchitectureRead →The architecture behind every modern AI chatbot, built up from tokens to attention, with GPT-2 running real code.
  2. 21LLMs and Inference via Provider APIsRead →How a Transformer becomes an LLM, what the memory maths looks like, how quantization and LoRA work, and the shape of an API call.
  3. 22RAG and TypesRead →Give an LLM your own documents without retraining it. A complete pipeline you can run, with honest results for dense, keyword and hybrid search.
  4. 23llama.cpp: Running LLMs on CPURead →A real 1.5-billion-parameter model running on a laptop with no GPU. What the file is, how fast it goes, and why threads do not always help.
  5. 24Tool / Function CallingRead →How a model that only produces text can check the weather or query a database. A real round trip, and the ways it goes wrong.
  6. 25MCP (Model Context Protocol)Read →One open standard for plugging tools and data into any AI app. A working server, a client, and the raw messages between them.

Part VI: Frameworks and Agentic AI

  1. 26Frameworks: LangChain and LlamaIndexRead →The plumbing frameworks for LLM apps. Run a real chain and a real index on a local model, and learn when each framework earns its place.
  2. 27LangGraph and LangSmithRead →Workflows with loops, memory and crash recovery. Run a graph that retries, survives a crash, pauses for approval, and see what tracing records.
  3. 28Agentic AI: Agents, Types and OrchestrationRead →An LLM with hands, memory and a to-do list. Build the agent loop in plain Python and measure how reliable a small one really is.
  4. 29Agentic AI: ReAct, Memory and Agent CommunicationRead →How agents reason out loud, remember across sessions with simple files, and hand structured work to each other.
  5. 30Self-Correction, Planning Agents and Custom LLM TrainingRead →Agents that check their own work against real tests, plan before acting, and the last resort of training your own model, with working code.

Frequently asked questions

Is this AI and machine learning roadmap really free?

Yes. Every session is a free article on SabaqGuide with runnable code, formulas you can copy and quick-check questions. There is nothing to sign up for.

How long does it take to finish all 30 sessions?

Plan on roughly two months at a steady pace of three or four sessions a week. The first Part (five sessions) is the one that rewards slow, careful work the most.

Do I need strong maths to follow along?

You need school-level algebra and a willingness to read an equation slowly. Every formula comes with a plain-English explanation, correct notation and a copy button, and the code often shows the same thing with real numbers.

Which programming language is used?

Python, with NumPy, pandas, scikit-learn, PyTorch and, in the later Parts, libraries like Hugging Face Transformers and LangChain.

Can I start with generative AI and skip the basics?

You can read those sessions, but they lean on ideas from earlier ones (loss, gradients, attention, embeddings). The course map shows exactly which sessions each one builds on, so you can fill gaps as you meet them.