How to Actually Learn ML in 2026: The Complete Beginner's Guide

Welcome to the 64rd issue of AI Agents Simplified 🍻

Welcome back to the Agentic Reading Roadmap. Same deal as always: dense technical books are worth reading, but almost nobody finishes them, and the people who try usually stall out somewhere around the chapter where the math shows up. So instead of another summary, you get a plan, the chapters that earn their page count, the order that actually builds on itself, and explicit permission to skip the rest.

This one is different from the last book we covered though. Chip Huyen’s AI Engineering had zero code in it. This one is 800 pages of almost nothing but code. Which means the failure mode is different, and so is the reading strategy. Let’s get into it.

If you missed the previous Agentic Roadmap blog post, you can read it here:

Is This Book For You?

You cannot reason about ML systems you have never built. Géron’s bet is that you get an engineer’s intuition by shipping working models on real datasets, in order, from linear regression to diffusion models and picking up the theory on the way rather than in advance. This is the book that turns “I’ve watched a lot of YouTube about ML” into “I can build this.”

Who should read it

Software engineers who want to move into ML and are tired of tutorials that stop at model.fit(). Data scientists who can use Scikit-Learn but couldn’t tell you why their gradient boosting model is overfitting. Anyone who has been doing LLM API work for a year and is starting to feel the hole where the fundamentals should be, this is the book that fills it. Also, people who read the 3rd edition and want the PyTorch rewrite.

Who should skip it

Researchers who want mathematical rigor. The derivations here are deliberately minimal and occasionally hand-wavy; go read Murphy or Bishop. People who want to build LLM applications right now and don’t care how a transformer works, read Huyen instead, come back later. And anyone who won’t run the code. I’ll say this more than once:

this book is 40% worse if you read it like a novel, and it’s a long novel!

Prerequisites

Real Python ( functions, classes, list comprehensions, not just scripting). NumPy and pandas at a working level (Géron links tutorials if you're rusty). Linear algebra to the level of "I know what a matrix multiplication does and why the shapes have to line up." Calculus is genuinely optional for Part I and helpful-not-required for Part II; you can understand what a gradient is doing without being able to derive one.

Time Investment

Eight to ten hours for the Fast Track with your laptop open. Forty to sixty hours for the full Practitioner’s Deep Dive, realistically spread over two to three months. If someone tells you they read this book in a week, they read the words. That’s a different activity!

What Changed From The 3rd Edition

Since roughly everyone reading this owns the previous one:

• Keras and TensorFlow are gone. It’s PyTorch now. Every deep learning chapter has been rewritten.

• Support Vector Machines got demoted. SVMs used to be Chapter 5; they’re now Appendix C and the printed table of contents only lists Appendices A and B, so C through E live online at homl.info. Read that as an honest signal about where SVMs sit in 2026.

• Chapter 17 (Speeding Up Transformers) is online-only. Two pages in the print book, a pointer, and a note that it was moved online to make room. It covers KV caching, speculative decoding, FlashAttention, MoE, and LoRA, which is to say, most of what you’d actually need to serve a model in production. Don’t miss it because it looks like a stub.

• New chapters worth the upgrade on their own: Chapter 16 (Vision and Multimodal Transformers), and a substantially expanded Chapter 15 that now walks all the way to SFT, DPO, tool calling, and the Model Context Protocol.

• New online appendices on relative positional encodings and state-space models.

Return on Time Investment (ROTI)

If you put in the hours, here’s what you walk out with:

Conceptual Upgrades:

• Bias and variance as a working diagnostic, not a phrase from an interview. By Chapter 4 you’ll be able to look at a learning curve and say “more data won’t help me, I need a bigger model”, or the reverse, instead of guessing. This single skill saves weeks per project.
  

• The understanding that your metric is your problem definition. Chapter 3 will permanently break your habit of reporting accuracy. Once you’ve watched a 99.5%-accurate classifier turn out to be useless, you start every project by asking what kind of mistake you’re willing to make.
  

• One unified story for why deep networks are hard to train. Initialization, activation functions, normalization layers, residual connections, gradient clipping, Chapter 11 presents these as five separate attacks on the same enemy. Most people learn them as five unrelated tricks. Learning them as one story is the difference between debugging a model and rerolling the dice on it.
  

• A calibrated sense of when not to reach for a neural network. Géron says it plainly in the preface and then spends Part I proving it: a gradient boosted tree ensemble beats a deep net on most tabular problems, trains in seconds, and doesn’t need a GPU.

Why Most AI Agents Fail in Production

^{Most AI agents don’t fail because of the model. They fail because they have no clear architecture for planning, verification, memory, evaluation, or stopping.}

^{If you’re building AI agents that interact with tools, write code, or automate engineering workflows, it’s time to think beyond prompts.}

^{Join Rick Hightower, Claude Certified Architect and Co-founder of Spillwave, for a live, hands-on workshop on Engineering Reliable Agentic AI Systems. Learn how System Architecture, Harness Engineering, and Loop Engineering work together to build AI agents that are reliable, observable, cost-efficient, and ready for production.}

^{Save 40% with code: AISIMPLIFIED40}

Sign Up NOW 👉

The Non-Linear Reading Algorithm

Do not read this book front to back on your first pass. It’s 19 chapters and the dependency graph is much looser than the page order suggests, Géron even prints the graph in the preface (Figure P-1) which is the most useful diagram in the front matter and almost everyone skips it.

Here’s the short version of that graph: Chapters 1–4 unlock everything. After that, Chapters 5–6 are one unit, 7–8 are one unit, and 9–12 are the deep learning on-ramp that leads to everything else. Follow this execution path instead.

The 80/20 Fast Track → If you only have a weekend

Read Chapter 2 (End-to-End ML Project) with your hands on the keyboard. Type it. Don't read it, don't copy-paste it, TYPE IT. This chapter is the whole job compressed into 60 pages: frame the problem, pick a metric, split the data, explore, clean, engineer features, pipeline it, cross-validate, tune, and only then touch the test set.

Read Chapter 4 (Training Models) analytically. This is the chapter where “the model learns” stops being a metaphor. Gradient descent, the normal equation, why batch/stochastic/mini-batch each exist, regularization, and most importantly, learning curves.

Read Chapters 10 and 11 (PyTorch, and Training Deep Neural Networks) as one unit. Chapter 10 is mechanics, tensors, autograd, the training loop, DataLoaders, saving and loading. Chapter 11 is the payoff, and it’s the best chapter in Part II.

The Practitioner's Deep Dive → Where to slow down

Chapter 3 (Classification) The most underrated chapter in the book, and the one that separates people who can ship a model from people who can ship a useful one. Precision, recall, the trade-off between them, ROC curves, and error analysis via the confusion matrix.

Chapter 6 (Ensemble Learning and Random Forests) Highest practical ROI in Part I. If your job involves tabular data, this chapter will do more for your model quality than all of Part II combined. Read Chapter 5 (Decision Trees) first, it's short and it's a hard prerequisite.

Chapter 12 (Deep Computer Vision Using CNNs) Long, dense, and worth it, but read it with a filter. The architecture tour (LeNet → AlexNet → GoogLeNet → ResNet → Xception → SENet) is genuinely educational as a history of ideas, but you are almost certainly never going to train one from scratch.

Chapter 15 (Transformers for NLP and Chatbots) The centerpiece of Part II and, at 65 pages, effectively a short book. It goes from the original encoder-decoder architecture through BERT, through the GPT lineage, all the way to SFT, DPO, tool calling, and MCP.

The Skim/Skip List → What you can safely deprioritize

Chapter 1 (The Machine Learning Landscape): Skim. The taxonomy (supervised/unsupervised, batch/online, instance-based/model-based) is worth having and the section on the main challenges is the conceptual spine of the whole book. The application examples read like a brochure. Twenty minutes, then move on.

Chapter 7 (Dimensionality Reduction): Read the PCA sections, skim the rest. PCA is genuinely useful and you should understand what “explained variance ratio” means well enough to choose a number of components deliberately. Random projection and LLE are interesting and you will probably never use them. Come back if you do.

Chapter 8 (Unsupervised Learning): Depends entirely on your work. If you’re doing customer segmentation or anomaly detection, this is a deep-dive chapter and you should treat it as one — the semi-supervised learning section (use clustering to decide which examples are worth paying a human to label) is a genuinely clever trick that saves real money. If you’re not, skim k-means and DBSCAN and move on.

Chapters 13 and 14 (RNNs, and NLP with RNNs and Attention): Read these as history, quickly, unless you work on time series, in which case Chapter 13 is a deep dive and the ARMA comparison is unusually honest about classical methods beating neural ones on small data.

Chapter 16 (Vision and Multimodal Transformers): Treat it as a reference, not a read-through. It’s a well-organized tour of ViT, Swin, DINO, CLIP, DALL·E, Perceiver, Flamingo, and BLIP-2. Read the ViT section and the CLIP section properly, CLIP in particular, because contrastive text-image pretraining is the idea underneath a surprising amount of what shipped in the last three years, and skim the rest until you need it.

Chapters 18 and 19 (Autoencoders/GANs/Diffusion, and Reinforcement Learning): These are the fun chapters and they are the last ones you should read. Both are excellent. Neither is load-bearing for most jobs. Chapter 18’s diffusion section is a rare clear explanation of an idea that sounds impossible until you see it (train a network to remove a little noise, then start from pure static and run it a few hundred times), and Chapter 19 covers the credit assignment problem well. Save them as a reward.

Appendix A (Autodiff): Skip unless you’re curious how autograd actually works. Appendix B (Mixed Precision and Quantization) is the opposite, short, practical, and directly relevant the moment you have to fit a model on constrained hardware. Read B.

Terms to Know Before You Start

• Bias/variance trade-off → bias is error from your model being too simple to capture the pattern; variance is error from it being so flexible it fits the noise. Nearly every knob in the book moves you along this axis.

• Data snooping bias → the contamination you cause by making modeling decisions after looking at data that’s supposed to be held out.

• Cross-validation → splitting the training set into k folds and training k times so you can estimate performance without touching the test set.

• Pipeline / ColumnTransformer → Scikit-Learn’s mechanism for chaining preprocessing to a model so that the same transformations are learned on train and merely applied to test. This is leak prevention as an API design.

• Bagging vs. boosting → averaging many independent strong learners (variance reduction) vs. sequentially correcting a chain of weak ones (bias reduction).

• Autograd → PyTorch’s automatic differentiation. It records every operation on a tensor into a graph, then walks the graph backward to compute gradients. You never write a derivative by hand.

• Vanishing / exploding gradients → the reason deep networks were considered untrainable until roughly 2010, and the organizing problem of Chapter 11.

• Batch norm vs. layer norm → normalizing activations across the batch vs. across the features of a single example. Batch norm dominates in CNNs; layer norm dominates in transformers, because batch statistics are unreliable with variable-length sequences.

• Transfer learning / fine-tuning → starting from a model someone else trained on far more data than you have, and adapting it. In practice this is most of applied deep learning.

• Latent representation → the compressed internal encoding a model learns. Called embeddings, codings, or features depending on which chapter you’re in.

• LoRA / PEFT → fine-tuning a huge model by training a small number of extra low-rank parameters instead of all of them. Covered in the online Chapter 17.

The Execution Protocol

This is a code book. There are notebooks for every chapter at github.com/ageron/handson-mlp, and they’re designed to run in Google Colab with zero setup. That’s the book’s biggest strength and also its biggest trap, because notebooks that already work are the easiest thing in the world to scroll past.

How to read it so it sticks:

• Type the code. Do not copy-paste it. I know! Type it anyway. Reading working code produces a very convincing illusion of understanding that evaporates the moment you face a blank file. Typing it forces you through every argument name and every shape, which is exactly where the actual learning is. This is the single highest-leverage habit for this book and it’s the one people skip.
  

• Break things on purpose. After each chapter’s main example runs, sabotage it. Remove the feature scaling and see what happens to the linear model. Set the learning rate to 10. Take the batch normalization layers out of the deep net. Train the random forest with one tree. You learn what a component does by watching what fails without it, and you’ll build the failure-mode intuition that lets you debug a model in ten minutes instead of a day.
  

• Do the exercises. Every chapter ends with them, solutions are at the end of each chapter’s notebook, and they are unusually good, the later ones are small projects rather than quiz questions. This is where the material moves from recognition to recall. If you do nothing else from this list, do the exercises for Chapters 2, 3, 4, and 11.
  

• The math sidebar trap. You will hit an equation, decide you need to fully understand it before continuing, and lose an evening. Don’t. Géron’s structure is intentional: the code always comes with or right after the math, and running the code will usually explain the equation better than staring at it. Mark it, keep going, come back at the end of the chapter. If it still doesn’t click, that’s what Khan Academy is for, but do it after you’ve seen the thing work.
  

• Budget for compute. Part I runs fine on a laptop. From Chapter 12 onward, Colab’s free tier will start disconnecting on you mid-training. Either accept that you’ll train on subsets of the data (fine, you’re learning the mechanics, not chasing benchmarks), or budget for Colab Pro for the two months you’re in Part II. Deciding this up front prevents the very common failure of quitting the book at Chapter 12 out of pure friction.

The Syntopical Map: Where It Fits

Géron is the how. It teaches you to build the machinery. It is not a book about building AI products, and if you read it expecting one you’ll be confused about why you spent a weekend on decision trees.

• Before this: if you’re not sure you want to commit 50 hours, read Burkov’s The Hundred-Page Machine Learning Book first as a map of the territory.

• Alongside this: Andrew Ng’s courses cover much of the same Part I ground with more math and less code. They complement each other well.

• After this, for depth: Murphy’s Probabilistic Machine Learning or Hastie’s Elements of Statistical Learning for the theory Géron deliberately skips. Raschka’s Build a Large Language Model (From Scratch) if Chapter 15 leaves you wanting to go all the way down.

• After this, for breadth: Huyen’s AI Engineering (the book from our last issue) picks up exactly where Géron stops. Géron teaches you how a transformer works; Huyen teaches you how to build a product on top of one and evaluate it. Read in that order, they’re close to a complete curriculum.

Next Step

Have you worked through this one or the 3rd edition? Reply and tell me whether the PyTorch rewrite justified the upgrade for you, and which chapter you stalled out on.

Let’s Collaborate

Hey there, I’m Hana, co-founder and technical writer at AI Agents Simplified. If you’re building in the AI space, have feedback on today’s post, or want to explore a collaboration, let’s chat! You can find me on LinkedIn or drop me an email. I read every message and would love to hear from you.