AI & ML Complete
The full machine learning specialisation: build the algorithms by hand, then the advanced libraries, then real models end to end.
View course →
Stage 3 of 3 — from the maths up
Machine learning, from scratch.
You implement gradient descent and the core models by hand, you understand the maths that makes them work, and only then do you master the advanced AI and ML libraries everyone else starts with.
Built for college students and working professionals
10,000+
Students taught
15+
Countries
70+
Live courses
4.9/5
247+ reviews
The full path
Three stages from your first line of Python to building real models.
This page is the final stage. We are showing you the whole route first so you can see the depth and decide where you belong, rather than landing in the deep end by accident. Most courses sell you the destination and quietly skip the road that gets you there; we would rather you arrive ready. Read across all three stages, work out which one matches your current Python and maths, and start there. If the third stage looks too steep today, the first two are where you earn it.
Stage 1
Python From the Ground Up
Grade 6–12: about 40 classes · Grade 12+ and adults: 24 classes
Python from the roots, including the modules most courses skip, and a first honest taste of AI. This is where the language stops being mysterious and starts being a tool you reach for.
Open Stage 1 →
Stage 2
NumPy, Pandas & Matplotlib Masterclass
24 classes
Data analysis in real depth, with the maths underneath, not just method names. For teens after Stage 1, college students and professionals. This is the bridge: vectors, arrays and dataframes are the language machine learning speaks.
Open Stage 2 →
You are here
Stage 3
Machine Learning From Scratch
32 classes · college and professionals only
Build models by hand — gradient descent and the core algorithms — before you ever import a library. Then master the advanced AI and ML libraries and the current advancements, with the understanding to actually use them.
You are reading itThe full adult route runs about 80 live classes — 24 in Stage 1, 24 in Stage 2, and 32 here in Stage 3.
The one idea everything rests on
This is gradient descent. You will write it yourself.
Almost every model you train is a search for the lowest point on a loss curve. Linear regression, logistic regression, and the deep networks behind modern AI are all variations on the same move: measure the error, find which direction reduces it, and step that way. Understand this picture in code and the rest of machine learning stops being magic.
start: high loss
step = learning rate × gradient
minimum
Each dot is one update. You measure the slope of the loss, take a step downhill sized by the learning rate, and repeat until you reach the bottom. θ := θ − α · ∂J/∂θ
Stage 3 in depth
What "from scratch" actually means here.
It is not a slogan. It is the order we teach in, and it is the reason graduates of this stage can do things people who skipped it cannot.
First — you implement the core algorithms by hand
Linear regression, logistic regression, gradient descent and a neural network — written in NumPy
You start with linear regression coded from nothing: a hypothesis, a cost function, and a gradient descent loop you write line by line. You watch the loss fall update by update and you tie that movement back to the slope you computed. Then logistic regression for classification, where the sigmoid and the cross-entropy loss are derived, not handed to you. Then you build a small neural network with its own forward pass and a manual backward pass, so backpropagation is something you have implemented rather than something you have heard about — you propagate the error backwards through each layer yourself and see exactly where each weight's update comes from. No model.fit() until you have already done its job by hand.
Second — you learn the maths that makes them work
Derivatives, vectors and matrices, probability, and loss functions
We teach exactly the maths each algorithm needs, at the moment it needs it. Derivatives, because gradient descent is the derivative made practical. Vectors and matrices, because your data and your weights are arrays and the multiplications have meaning. Probability, because classification, cross-entropy loss and model confidence all rest on it. You leave able to read why a model behaves the way it does, not just what to type.
Third — then you master the advanced libraries
scikit-learn, TensorFlow and PyTorch — used by someone who knows what they hide
Now the libraries are a speed-up, not a black box. You rebuild your earlier models in scikit-learn, then move to TensorFlow and PyTorch to train deeper networks on real datasets. Because you have written the internals once, the API choices, the loss functions and the optimisers all mean something — when you reach for an optimiser you know it is gradient descent with improvements you can name, and when you set a learning rate you know precisely what you are changing. You can read the documentation and the error messages with understanding, and you can tell the difference between a bug in your setup and a genuine limit of the model.
Throughout — heavy practicals and current advancements
Real projects, plus where machine learning is going right now
Most of your time is hands-on: training models, debugging them, tuning them and measuring them honestly. You also work through current advancements — deep learning for images and text, and generative models — so you understand the systems behind today's AI tools rather than only consuming them. Every concept ends in code that runs and a result you can defend.
The toolkit, understood
The AI and ML libraries you master — and how each one works.
You do not just call these libraries. Because you have built the same ideas by hand first, you learn what each one does underneath — and you leave fluent in the tools real machine-learning and AI work actually runs on.
Classic machine learning
scikit-learn
The standard library for classic machine learning. You rebuild your hand-coded models here and learn how its estimators, pipelines, preprocessing and cross-validation work — and why the fit and predict design is shaped the way it is.
Deep learning — the one we go deepest on
PyTorch
After you have written a backward pass by hand, PyTorch's autograd finally makes sense: you trace how it records a computation graph and differentiates it for you. You build tensors, custom layers, datasets and your own training loops, and train real neural networks on real data — understanding every line, not copying a notebook.
Deep learning — production
TensorFlow and Keras
The other major framework. You learn the Keras layer API and how TensorFlow's graph execution compares to PyTorch, so you can read, debug and build in either one rather than being locked into a single ecosystem.
Modern AI — large language models
Hugging Face Transformers
What attention and a transformer block actually compute, how a tokeniser turns text into numbers, and how to load, fine-tune and run modern models — so generative AI is something you understand and shape, not just call.
Boosting and the numerical core
XGBoost, NumPy and SciPy
How gradient-boosted trees learn from each other's errors and keep winning on tabular data, all sitting on the NumPy and SciPy numerical core that every library on this list quietly stands on.
Why build it before you import it
Anyone can call a library. The engineers worth hiring are the ones who can open it up, find out why a model is failing, and make it better.
When you have implemented gradient descent yourself, an exploding loss is a clue, not a wall — you know to check the learning rate, the scaling of your features, or a sign error in the gradient. When you understand the maths of a loss function, a model that quietly underperforms is something you can diagnose rather than a verdict you have to accept. The gap between someone who builds and someone who only imports is not speed on a good day — it is what happens on a bad one, when the dataset is messy, the metric is misleading, and the tutorial does not match your problem. We deliberately put you on the building side of that gap, because that is the depth that lasts long after a particular library or model is replaced. If this philosophy resonates, you will feel at home with how we think about real coding classes across the school.
Engineers who built it from scratch
Read a strange loss curve and know where to look. Tune learning rate, regularisation and architecture on purpose. Judge whether an AI-generated model is actually correct. Improve a model instead of swapping it and hoping.
People who only ever called the API
Copy a notebook that works until it does not. Cannot tell overfitting from a data leak. Stall the moment an error is not on Stack Overflow. Trust whatever a tool returns because they have no way to check it.
Courses in this stage
The advanced courses attached to Stage 3.
These are the live, college-and-professional courses that carry the from-scratch approach into full specialisations. Look through them and pick the one that matches where you want to go. The complete catalogue lives in the course atlas.
Artificial Intelligence Complete
A broad, rigorous tour of modern AI — from the foundations through neural networks to the systems behind today's intelligent tools.
View course →
Generative AI Masterclass
How generative models actually work, built up from the maths, so you can use and shape them rather than only prompt them.
View course →
Data Science Masterclass
The end-to-end craft: clean and analyse real data, model it properly, and communicate results that hold up to scrutiny.
View course →
Data Structures & Algorithms
The reasoning underneath strong engineering — the structures and algorithms that make your machine learning code efficient and your interviews winnable.
View course →
How classes run
Live, small batch, and relentlessly practical.
This stage cannot be learned by watching. You build, you train, and a mentor watches your maths and your code while you do it.
01
Live and instructor-led
Every class is taught in real time by an instructor, online, with you typing alongside. Questions are answered the moment they come up, not left in a comment thread.
02
Small batches
Groups stay small so the instructor can see your screen, your derivations and your mistakes. At this depth, individual attention is the whole point.
03
You implement and train models
You are not watching demos. You write the gradient descent loop, you build the network, you train it on real data and you read the results yourself.
04
Your maths and your code get reviewed
A mentor reviews both the reasoning and the implementation — the derivative you wrote and the loop that uses it — so misunderstandings are caught early, while they are cheap.
Questions, answered plainly
Frequently asked questions.
Who is this stage for?
Stage 3 is for college students and working professionals only. You should already be comfortable writing Python and reasoning about data. It suits computer science and engineering students, analysts and developers moving into machine learning, and professionals who want to build and ship real models rather than only call hosted APIs.
Do I need Stage 1 and Stage 2 first?
You need their content, not necessarily the classes. Stage 1, Python From the Ground Up, gives you the language. Stage 2, the NumPy, Pandas and Matplotlib Masterclass, gives you data handling and the vector thinking that machine learning runs on. If you already have those skills you can start here. If you do not, take the earlier stages first, because we build models on top of NumPy arrays from day one.
How much maths do I need?
You need school-level algebra and a willingness to learn the rest with us. We teach the calculus, linear algebra and probability you need as we use them: derivatives for gradient descent, vectors and matrices for the data, and probability for loss functions and classification. We never wave at the maths and skip it, and we never assume a graduate background either.
What will I build?
You will implement linear regression, logistic regression and gradient descent by hand in NumPy, then code a small neural network with its own forward and backward pass. After that you rebuild the same ideas with scikit-learn, TensorFlow and PyTorch, train models on real datasets, and complete practical projects in classification, regression and a generative model. You finish with code you wrote and understand, not borrowed notebooks.
Are classes live?
Yes. Every class is live, online and instructor-led in a small batch. You write code during the session, train models with the mentor watching, and get your maths and your implementation reviewed in real time. It is not a recorded video course you watch alone.
If AI tools can build models, why learn ML from scratch?
Because from-scratch understanding is exactly what lets you use those tools well. When a model underfits, a loss curve will not move, or an AI assistant hands you confident but wrong code, the people who understand gradient descent, loss functions and the data can debug it, tune it and improve it. People who only call APIs stall the moment something breaks. As AI spreads, that depth is what makes an engineer valuable rather than replaceable.
Build the models, then master the tools.
Sit in one live class, watch how we teach machine learning from the maths up, and decide for yourself whether this is the depth you have been missing.