🎯 About this course

This course takes you from what is a tensor? to why does attention work? in six practical sessions. You derive backpropagation by hand, write your own training loop, adapt a pre-trained CNN to your own images, and learn a systematic way to debug a network that won't learn.

Every topic ends in a graded lab with automatic tests, and the course closes with a capstone: an image classifier with an honest error analysis and a usable predictor.

The course covers six core topics and closes with a guided lab. You start with tensors and automatic differentiation, learning to predict shapes and gradients by hand before you trust the framework. Next come training loops, optimisers and learning-rate schedules, then MLPs and backpropagation from scratch, where you build a small network without an autograd library. The course then moves to CNNs and transfer learning, regularisation and a systematic approach to debugging training, and ends with a first look at attention.

You leave with three things you can show: a from-scratch network (XOR), a reusable PyTorch training loop, and an image classifier with an error analysis. Along the way you practise the skills that matter when a model misbehaves: diagnosing overfitting, vanishing or exploding gradients and data leakage with a checklist rather than guesswork.

Who it is for

Learners with Python and basic machine-learning knowledge who want a real understanding of deep learning — not another tutorial to copy.

What makes it different

You never just call fit(). You see the loop, the gradients and the failure modes, and you practise diagnosing them.

By the end you will be able to

Explain tensors, broadcasting and automatic differentiation, and predict tensor shapes and gradients by hand.
Write and debug a complete PyTorch training and evaluation loop with an appropriate optimiser and learning-rate schedule.
Derive and implement backpropagation for a small network without an autograd library.
Adapt a pre-trained convolutional network to a new task using transfer learning and differential learning rates.
Diagnose overfitting, vanishing/exploding gradients and data leakage using a systematic debugging checklist.
Implement scaled dot-product self-attention with causal masking and explain why transformers use it.
Train, evaluate and package an image classifier end to end and communicate its strengths and failure modes.

Curriculum

Topics covered

Core topics 6 topics

Tensors and automatic differentiation
Tensors are the data structure of deep learning; autograd is the engine that turns a forward computation into gradients.
Training loops, optimisers and schedulers
The training loop — forward, loss, backward, step — and the optimisers and schedulers that drive it.
MLPs and backpropagation from scratch
Backpropagation is the chain rule applied layer by layer. Building it once by hand removes the mystery.
CNNs and transfer learning
Convolutions share weights across space; transfer learning reuses features learned on a large dataset.
Regularisation and debugging training
Overfitting, regularisation and a systematic way to debug a network that will not learn.
A first look at attention
Attention lets every position look at every other — the mechanism behind transformers and modern LLMs.

Course at a glance

See how this course is built

Where the time goes

Longer spokes mean more hours on that module.

Course roadmap click a step

Try a lesson0 / 3

Sample questions from this course. Your progress is kept only in your browser.

Week by week

Drag the slider, or press play, to walk through the course and see what you will have built by each week.

Week 1 of 9

Wk 1–3

Autograd and training loops

You produceAn MLP trained from scratch, then re-implemented cleanly in PyTorch

Wk 4–6

CNNs and transfer learning

You produceAn image classifier fine-tuned on a custom dataset

Wk 7–9

Debugging, regularisation and project

You produceA documented model and training report

What you'll build

A from-scratch network (XOR)

A NumPy-only multi-layer perceptron with hand-written backpropagation that solves XOR.

A reusable PyTorch training loop

A tested `fit()` with correct train/eval modes, metrics per epoch and clean structure.

Image classifier + error analysis

A transfer-learning classifier with a confusion matrix, an analysis of its most confident mistakes and a predict script.

Why take this course

Understand what your training loop is actually doing — no black boxes
A debugging checklist you will use on every model you ever train
Graded labs with automatic tests, so you know where you stand
Runs on a laptop CPU — no GPU needed

You will build

A neural network trained from scratch in NumPy that solves XOR
A reusable, correct PyTorch train/evaluate loop
A single-head self-attention layer with causal masking
An image classifier with transfer learning, a confusion matrix and a predict script

What you can do afterwards

Explain and predict gradients, shapes and training behaviour
Diagnose overfitting, exploding gradients and data leakage
Adapt a pre-trained model to your own data and package it for use

Career fit

🧭 Where this fits

Roles whose screened skills map to this course, and the skills it lets you show.

Skills you will build

Deep learning with PyTorch
Deep learning, CNNs and transformers

How to take it

💳 Delivery & fees

One course, four ways to attend. Fees are per course, in rupees excluding 18% GST (the GST-inclusive amount is shown too) with Canadian-dollar fees alongside.

Your fee includes our GPU lab infrastructure — no cloud credits to buy. See how we compare, with sources →

Deep Learning Foundations with PyTorch