Machine Learning Roadmap for Beginners in 2026

A machine learning roadmap is narrower and deeper than a data science one. Data science spans questions, SQL, analysis and communication; machine learning is about the models themselves: how they learn, why they fail, and how to make them generalise. If you want the broader path, start with the data science roadmap. This one assumes you want to understand and build models well.

Each stage below ends with a self-test. Move on when you can pass it, not when a course says you are done.

Stage 0: Python and NumPy

You need to be comfortable in Python and, above all, to think in arrays. Machine learning code is mostly matrix operations; writing loops over rows where NumPy would do it in one expression is slow and hides the maths. Learn indexing, broadcasting, vectorised arithmetic and matrix multiplication with the @ operator, plus enough pandas to load and inspect a dataset.

Self-test: implement k-nearest neighbours classification in NumPy without loops over the test points, and check it gives the same predictions as scikit-learn's KNeighborsClassifier.

Stage 1: The maths, in the order ML uses it

You do not need a mathematics degree, but you do need three areas, and each has a clear use:

• Linear algebra: vectors, dot products, matrix multiplication, and later eigenvectors and the singular value decomposition. Every model's prediction is built from these, and PCA is an application of them.
• Calculus: derivatives, partial derivatives, gradients and the chain rule. Training is minimising a loss, and backpropagation is the chain rule applied layer by layer.
• Probability and statistics: distributions, expectation, conditional probability, Bayes' rule and likelihood. Loss functions such as log loss come from likelihood, and evaluation relies on sampling and uncertainty.

Mathematics for Machine Learning, a free book by Deisenroth, Faisal and Ong, covers exactly these foundations and then applies them to machine learning problems (Mathematics for Machine Learning). Learn each topic when a model needs it rather than all of it up front.

Self-test: derive the gradient of a model's loss by hand and check it numerically. For logistic regression, the gradient of the mean log loss is Xᵀ(p − y)/n. Comparing it with a finite-difference estimate is also the standard way to catch bugs in hand-written gradients:

import numpy as np

rng = np.random.default_rng(0)
X = rng.normal(size=(100, 3))
y = (X @ np.array([1.5, -2.0, 0.5]) + rng.normal(size=100) > 0).astype(float)

def loss(w):
    p = 1 / (1 + np.exp(-X @ w))
    return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))

def gradient(w):                       # derived by hand: X^T (p - y) / n
    p = 1 / (1 + np.exp(-X @ w))
    return X.T @ (p - y) / len(y)

w = rng.normal(size=3)
eps = 1e-6
numeric = np.array([(loss(w + eps * e) - loss(w - eps * e)) / (2 * eps) for e in np.eye(3)])
print("analytic:", gradient(w).round(6))
print("numeric: ", numeric.round(6))
print("max difference:", f"{np.abs(gradient(w) - numeric).max():.1e}")

analytic: [-0.33359   0.37742  -0.266279]
numeric:  [-0.33359   0.37742  -0.266279]
max difference: 2.1e-10

If you can derive a gradient like this and make the check pass, the calculus you need is in place. Gradient descent explained then shows how such gradients train a model.

Stage 2: Core supervised learning, with honest evaluation

This is the heart of the roadmap, and where most practical machine learning still happens:

• Linear and logistic regression, including regularisation (ridge, lasso). Implement each from scratch once, then use the library.
• Decision trees and why they overfit.
• Ensembles: random forests and gradient boosting, the usual winners on tabular data. Bagging, boosting and stacking measures what each adds.
• k-nearest neighbours and support vector machines, for their ideas of distance and margins.

Learn evaluation alongside the models, not after: train, validation and test splits, cross-validation, and metrics matched to the problem. Evaluation metrics explained covers the choice. Understand overfitting through the bias-variance trade-off. The scikit-learn user guide is the best single reference for this stage, with an explanation of every model it implements (scikit-learn: user guide); Google's free Machine Learning Crash Course is a gentle companion (Google: Machine Learning Crash Course).

Self-test: on a new tabular dataset, beat a sensible baseline with cross-validation, explain why your chosen metric fits the problem, and explain from a learning curve whether more data or a more flexible model would help.

Stage 3: Unsupervised learning

Learn clustering (k-means, hierarchical, DBSCAN), dimensionality reduction (PCA, and t-SNE or UMAP for visualisation) and the basics of anomaly detection. The hard part here is evaluation without labels: judging whether clusters are meaningful requires domain knowledge as much as scores.

Self-test: cluster a dataset, then explain in plain language what distinguishes each cluster and whether the grouping would be useful to someone.

Stage 4: Deep learning foundations

Start once the earlier stages feel solid. Learn how a network is built from layers and activations, how backpropagation computes gradients, and how optimisers, batches and regularisation such as dropout affect training. Then learn one framework well; PyTorch is widely used in research and industry. After that, convolutional networks for images and sequence models, including the attention mechanism behind transformers. Deep learning explained builds a network from scratch as a starting point, and the free Deep Learning textbook covers the theory in depth (Deep Learning book).

Self-test: train a small network on an image dataset, diagnose a training run that is not improving (learning rate, scaling, overfitting), and fine-tune a pre-trained model for a new task.

Stage 5: Choose one specialisation

Machine learning branches into areas with their own methods and tools. Pick one for depth, based on the work you want:

The NLP roadmap goes deeper on the language track.

Projects that prove each stage

Build one project per stage rather than many tutorials. A good set: a from-scratch implementation of linear or logistic regression; a tabular project with honest cross-validation and error analysis; a clustering analysis with a written interpretation; a neural network trained and fine-tuned on images or text; and one project in your specialisation, deployed or at least packaged so someone else can run it.

What to leave for later

• Advanced theory such as measure-theoretic probability or learning theory proofs. Valuable for research, not needed to start.
• Reinforcement learning, unless it is your target field; it has its own large set of prerequisites.
• Chasing every new model release. The fundamentals above change slowly; the newest architecture is easier to learn once they are solid.

Python, statistics, the core supervised and unsupervised algorithms, evaluation and deep learning are covered in sequence in the Data Science course.

Sources

• Mathematics for Machine Learning — Cambridge University Press, 2020
• scikit-learn User Guide — scikit-learn documentation
• Machine Learning Crash Course (Google) — Google for Developers
• Deep Learning (Goodfellow, Bengio and Courville) — MIT Press, free online edition