How to learn machine learning in 2026: an updated roadmap

In September 2022, we published a seven-step plan for learning machine learning from scratch. It has since been watched more than 775,000 times, which tells you something about how many people are still standing at the start of this path looking for a straight line through it.

It also predates ChatGPT by two months.

That's the awkward thing about roadmaps. The 2022 plan was good advice, and most of its bones are still correct — you still need Python, you still need enough math to not be scared of a gradient, you still learn more from one finished project than from four abandoned courses. But a roadmap written before the LLM era sends you to the wrong finish line. It ends at "train a scikit-learn model and enter a Kaggle competition." In 2026, a large share of applied machine learning work is fine-tuning, retrieval, evaluation, and gluing models into products that already work.

So this is the roadmap rewritten for 2026. Every resource below was checked and is live as of August 2026. Where the original recommendation has gone stale, we say so and say what replaced it.

What actually changed since 2022

Before the steps, the honest diff. This matters more than the step order, because it's what determines whether you're learning the field as it exists or as it existed.

One more change worth naming: the tooling got dramatically friendlier. In 2022, "getting hands-on" meant wiring up a training loop. In 2026 you can call a production model with an API key and spend your attention on the part that's actually hard — the data, the evaluation, and the product.

The roadmap at a glance

Step 1: Get just enough math, then move on

The 2022 version made an argument that has aged well: the frameworks abstract the math away, plenty of working ML engineers never touch it, and yet knowing it gives you a better foundation and makes debugging less mysterious. That's still right. There's also a genuine pleasure in understanding why the thing learns, and that pleasure is a real asset when you're 40 hours into a course.

What's changed is the emphasis. You need less calculus than the old roadmap implied and more probability and statistics, because so much of modern practice is measurement — is this model better than that one, and how confident are you.

What to actually do:

• Khan Academy: Linear Algebra — vectors, matrices, dot products. The one that matters most.
• Khan Academy: Statistics and Probability — distributions, Bayes, variance. Promoted from "nice to have" to essential.
• Khan Academy: Multivariable Calculus — enough to understand gradients and backpropagation. You do not need all of it.
• 3Blue1Brown: Essence of Linear Algebra — still the best visual intuition for matrices anywhere, and free.

Dropped from the 2022 list: Khan Academy's Differential Equations course. It's still live, it's still excellent mathematics, and it's not on the critical path to machine learning. Skip it unless you're heading toward physics-informed models or neural ODEs.

Use the original video's advice on sequencing: take the basics, then move on. When a course later hits you with something you don't understand, come back and learn exactly that. Studying math on spec is how people spend six months not doing machine learning.

Step 2: Learn Python properly

Python is still the language. Every major framework is built on it, every serious course uses it for exercises, and it remains a genuinely good first language. Nothing about the LLM era changed this — if anything it entrenched it.

The two courses the original roadmap recommended are both still online and both still hold up:

• Learn Python — Full Course for Beginners (freeCodeCamp, 4h27m). Published in 2018 with 49 million views. The editor setup in the intro is dated; the Python isn't.
• Intermediate Python Programming Course (freeCodeCamp, 5h56m). Decorators, generators, context managers, threading versus multiprocessing. This is the "slightly more than beginner" level the original video was pointing at.

Two things to add that weren't in the 2022 plan, because in 2026 they're table stakes rather than nice-to-haves: Git and GitHub, and type hints. Every current roadmap on the first page of Google now lists version control in the foundations phase. Your portfolio lives on GitHub, so learn it before you need it.

Step 3: The data stack

Three libraries, in this order, and only the basics of each: NumPy (the numerical base everything else sits on), pandas (data handling), Matplotlib (visualization). The original roadmap called this step "a bit optional" because a good ML course teaches these along the way. That's fair. But going in cold means learning two hard things at once.

Here's where we've changed the recommendation. The 2022 list pointed at three one-hour YouTube crash courses. They still exist, but library APIs drift, and the official documentation now has beginner tracks that are maintained against the current release. Use those instead:

• NumPy: the absolute basics for beginners — arrays, shapes, broadcasting, indexing.
• pandas: getting started tutorials — ten short tutorials, from reading a CSV to reshaping and time series.
• Matplotlib quick start guide — figures, axes, and why the object-oriented style is worth learning first.
• Kaggle Learn: Pandas — if you'd rather learn by solving short hands-on challenges.

You don't need scikit-learn, PyTorch, or TensorFlow yet. Those come bundled into the next step.

Step 4: Take one real machine learning course, and finish it

The original recommendation was Andrew Ng's Machine Learning Specialization on Coursera, and it's still the right answer. Three courses, taught by Ng with Eddy Shyu, Aarti Bagul, and Geoff Ladwig, offered by Stanford Online and DeepLearning.AI. Roughly two months at ten hours a week. It uses Python with NumPy, scikit-learn, and TensorFlow, so you get the concepts and the hands-on library experience in one pass. More than 826,000 people are enrolled. It's free to audit.

The 2022 video called it "revamped a few months ago." Four years later that revamp is the version everyone is still taking, which is a decent signal.

Two additions worth knowing about:

• Google's Machine Learning Crash Course — refreshed since 2022 with new modules on AutoML and an introduction to large language models, covering tokens through transformers. Much shorter than the specialization, and a good primer if you want to sanity-check your interest before committing two months.
• Practical Deep Learning for Coders (fast.ai) — Jeremy Howard's top-down course, nine lessons of about 90 minutes, built on PyTorch with fastai, Hugging Face Transformers, and Gradio. Note the honest caveat: the current recorded edition is from 2022. The pedagogy is excellent and the deployment sections are dated.

If you want the concepts in written form as you go, our own machine learning concepts for beginners course covers the same ground in short explainers, including supervised learning, unsupervised learning, and backpropagation.

Step 5: Implement a few algorithms from scratch

This step was optional in 2022 and it's still optional. It's also still the single highest-leverage optional thing on the list. Writing linear regression, k-nearest neighbours, and a decision tree in pure Python and NumPy converts "I watched a lecture about this" into "I know what this does."

Small piece of good news for anyone who watched the original video: it promised an updated ML From Scratch course on the AssemblyAI channel, and that course shipped. The Machine Learning From Scratch playlist is 11 videos covering 10 algorithms — KNN, linear and logistic regression, decision trees, naive Bayes, perceptron, SVM, k-means, and more. It's free.

There's also a Python for AI Developers playlist on the same channel if you want the environment-setup-to-trained-model path with pandas and scikit-learn.

Step 6: The part the 2022 roadmap didn't have

This is the new step, and if you only add one thing to the old plan, add this one.

Classical ML is the foundation. But the work that hiring managers are describing in job posts right now is mostly downstream of pretrained transformer models: adapting them, retrieving the right context for them, evaluating their output, and chaining them into systems that do something. You can be excellent at gradient boosting and still not be able to read a 2026 job description.

Learn it in this order:

Transformers and attention

Understand attention before you use anything built on it. Neural Networks: Zero to Hero by Andrej Karpathy is eight lectures that build from backpropagation through a working GPT and a tokenizer, all in code. It is the best thing in this category and it's free.

Working with LLMs

The Hugging Face LLM Course is 12 chapters, free, no ads. Chapters 1–4 cover transformer concepts, 5–8 cover datasets and tokenizers with classic NLP tasks, and 10–12 get into fine-tuning, curating high-quality datasets, and reasoning models. This is the closest thing to a canonical free curriculum for the current era.

Retrieval and agents

Two things every applied ML person is now expected to have opinions about:

• Retrieval-augmented generation. DeepLearning.AI runs a substantial RAG course covering architecture through deployment and evaluation, plus shorter courses on advanced retrieval and multimodal RAG.
• Agents. The Hugging Face Agents Course is free including certification, running from agent fundamentals through frameworks (smolagents, LangGraph, LlamaIndex) to real-world use cases and a final project, with bonus units on fine-tuning and observability.

Frameworks

PyTorch has won the research mindshare and most new tutorials assume it. TensorFlow is still deployed widely in production. Learn PyTorch first; if you want the long version of that argument, we wrote PyTorch vs TensorFlow. Reinforcement learning has become newly relevant through post-training, and our deep Q-learning explainer is a reasonable entry point.

Evaluation

The most underrated skill on this entire roadmap. When your system is a pretrained model you didn't train, the thing you actually control is how well you measure it. We've written about why the standard metrics mislead in word error rate is broken and how to build an evaluation you can trust in how to evaluate speech recognition models. The lessons generalize past speech.

Books, if you prefer reading. The 2022 list recommended two, and both need updating. Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow by Aurélien Géron is now in its third edition (October 2022) with a chapter on attention mechanisms and the original transformer — make sure you're not buying the second edition the old list linked to. Machine Learning with PyTorch and Scikit-Learn by Sebastian Raschka, Yuxi Liu, and Vahid Mirjalili (2022) covers transformers and BERT fine-tuning in chapter 16 and is still a solid PyTorch-first companion. Add one: Raschka's Build a Large Language Model (From Scratch) (2024) walks you through implementing attention and a GPT-class model without leaning on existing LLM libraries.

Step 7: Practice on real problems

Kaggle is still the best on-ramp, and the original advice about how to use it was unusually sensible: don't chase the leaderboard. Winning requires genuine expertise and a lot of GPU budget. What you want is to tweak your solution repeatedly, learning preprocessing and hyperparameter tuning as you go, and end up with something you can point at.

Start with the free courses rather than a competition:

• Kaggle Learn: Intro to Machine Learning
• Kaggle Learn: Intermediate Machine Learning — missing values, non-numeric values, and data leakage.

Both are lightweight next to Andrew Ng's specialization and some of the material will be revision. The point is the data preparation practice and getting comfortable making submissions.

One amendment for 2026: Kaggle competitions are tabular-heavy, and much of the interesting work now isn't. Balance them with at least one project that touches a real API and real messy inputs — audio, documents, images, a scraped dataset — and that ends in something a person can use. A deployed demo with rough edges beats a notebook with a good score, because it proves you can finish.

Step 8: Pick a specialization, and write about it

The original video's closing advice was that ML engineer roles vary enormously, nobody knows everything, and the move is to read job descriptions in the area you want and specialize toward them. That's aged perfectly.

Its second piece of advice was to start a blog — "something I wish I had done earlier in my career." Write up tutorials, what you built, what broke, how you fixed it. You learn the topic more deeply by explaining it, and you end up with a portfolio artifact stronger than a line on a CV.

That advice is now worth more than it was in 2022, for a reason the original video couldn't have anticipated: writing in public is how you get read by both humans and models. If you want a starting point for who to read, our roundup of machine learning blogs still holds up.

Speech and audio as a specialization

Here's one specialization worth a closer look, partly because we're biased and mostly because it's underrated relative to how much of it is being built.

Speech went through the same transformation the rest of the field did. In 2022, doing anything with audio meant a research-grade pipeline: acoustic features, an acoustic model, a language model, and a lot of glue. Today the models are transformers, they're available behind an API, and the interesting problems have moved up the stack — accuracy on accented and noisy real-world audio, knowing who spoke when, handling code-switching mid-sentence, and evaluating any of it honestly.

It's also a modality with unusually clear product demand. Meeting notetakers, contact center analytics, medical scribing, media search, and voice agents are all built on the same foundation. Companies like Zoom, Granola, and Fireflies are shipping products where speech recognition quality is the product.

If you want to see what the current state of the art looks like from the inside, three places to start:

• The Hugging Face Audio Course — free and open-source, running from audio data fundamentals through audio transformer architectures, speech recognition, and text-to-speech, including a unit where you build a model to transcribe meeting recordings. It's the closest thing to a proper audio ML curriculum.
• The concepts, in writing: what is automatic speech recognition and our complete guide to speech to text.
• Then get your hands on a production model. Universal-3.5 Pro does native code-switching across 18 languages with no configuration, joint transcription and speaker diarization, and contextual prompting, at $0.21/hr. Reading about diarization is fine; watching a model correctly label a four-person overlapping conversation teaches you what the hard part actually is.

A project idea that punches above its weight for a portfolio: transcribe a set of real recordings, build an evaluation set by hand-correcting a sample, and measure where the model fails and why. That is a genuine applied ML project — data collection, evaluation design, error analysis — and almost nobody's portfolio has one.

Try it yourself: create a free account and run your own audio through the playground in the browser — no code required — then move to the API when you want to build with it.

What we cut, and why

Being explicit about removals, since a roadmap you can't audit isn't much use:

• Khan Academy Differential Equations — still live, off the critical path.
• The three YouTube library crash courses (NumPy, pandas, Matplotlib) — still online, but the official documentation's beginner tracks are maintained against current releases. Use the docs.
• Hands-On Machine Learning, 2nd edition — the original list linked it. The 3rd edition (2022) is the one to buy; it covers attention and transformers.
• "Three months to job-ready" — replaced with a more honest range. Three months of focused work gets you building real things. Employable is usually further out, and pretending otherwise sets people up to quit at month four.

And what we kept without changes: the math-then-move-on sequencing, Python as the first language, Andrew Ng's specialization as the spine, implementing algorithms yourself, Kaggle as the practice ground, specialize-then-apply, and start a blog. Seven out of eight of the original beats survived four years of upheaval, which is a better hit rate than most technical advice from 2022.

The thing the roadmap can't give you

Every roadmap, including this one, has the same failure mode: it's a list, and lists are comfortable. You can spend a year moving through a curriculum and arrive with no evidence you can build anything.

The people who make it through aren't the ones with the best resource list. They're the ones who ship something ugly in week six. So use the steps as a map, not a queue — start a project before you feel ready, and let the gaps in it tell you which step to go read next. The roadmap changed a lot since 2022. That part didn't.

Want to build something with speech? Read the docs and try the API for free — pay-as-you-go, billed per second, with no minimums or contracts.

Frequently asked questions

What is the roadmap for machine learning in 2026?

Eight steps: enough math to follow the algorithms (linear algebra, probability, some calculus), Python, the data stack (NumPy, pandas, Matplotlib, Git), one complete core ML course such as Andrew Ng's Machine Learning Specialization, optionally implementing a few algorithms from scratch, then the modern layer — transformers, LLM fine-tuning, retrieval-augmented generation, agents, and evaluation — followed by practice on real datasets and a chosen specialization. The main difference from a 2022 roadmap is that step six exists at all.

Can you learn machine learning in 3 months?

You can get competent enough to build real projects in three months of focused study, which is roughly what the original 2022 roadmap claimed. Job-ready is usually longer — most current roadmaps put a complete beginner at 9–12 months, and someone already working as a software engineer at 6–9. Three months is a good target for finishing the foundations and your first end-to-end project, not for a job offer.

Do you need math to learn machine learning?

Less than people fear, more than the frameworks imply. Modern libraries abstract the math away and plenty of working ML engineers rarely touch it directly. But knowing the linear algebra and probability underneath makes debugging faster and model behavior less mysterious. The efficient approach is to learn the basics, start the ML course, and go back for specific topics when a lecture loses you.

Should I learn PyTorch or TensorFlow first?

PyTorch. It dominates research, most new tutorials and open models assume it, and the LLM ecosystem is built around it. TensorFlow remains widely deployed in production, so it's worth knowing eventually — Andrew Ng's specialization will introduce you to it anyway.

Is machine learning still worth learning now that LLMs exist?

Yes, but learn a different mix. Classical ML remains the foundation for the tabular problems that make up much of real business work, and you can't reason about an LLM's failure modes without understanding overfitting, evaluation, and data quality. What changed is the balance: expect to spend more of your time adapting pretrained models, designing evaluations, and building systems, and less of it training models from scratch.

How do I specialize in speech and audio machine learning?

Get the general foundations first, then take the Hugging Face Audio Course for transformer-based audio modelling, and build something with a production speech-to-text API so you learn the practical problems — accented and noisy audio, speaker diarization, code-switching, and how to measure accuracy honestly. A project that transcribes real recordings, hand-labels an evaluation set, and analyzes where the model fails demonstrates more applied skill than most tutorial projects.

Are Kaggle competitions still the best way to practice?

They're still an excellent on-ramp, and Kaggle Learn's Intro and Intermediate ML courses are among the best free hands-on material available. But Kaggle is tabular-heavy and the datasets are pre-cleaned, so pair it with at least one project involving messy real-world inputs and a real API. Don't optimize for the leaderboard — that takes serious expertise and GPU budget, and it's not what a portfolio needs.

‍