About Deep Learning
Deep learning is the part of machine learning behind image recognition, speech,
translation and today's large language models. Instead of writing rules by hand, you
build neural networks with many layers and let them learn the
patterns from data. This course explains how those networks work and how to build,
train and use them yourself.
It starts with Neural Network Fundamentals, then covers how
networks learn: Backpropagation & Gradient Descent,
Loss Functions & Optimizers and Overfitting &
Regularization. PyTorch Essentials then turns the ideas
into working code.
From there it moves to the main architectures. Convolutional Neural
Networks and Computer Vision & Transfer Learning cover
images, Sequence Models cover text and time series, and
Attention & Transformers introduces the design behind modern
language models. The course closes with Pretraining &
Fine-Tuning, Generative Models and Training at Scale
& Deployment.
You should be comfortable with basic Python, and some familiarity with vectors,
matrices and derivatives will help. Each module builds on the last, so work through
them in order.
Content
12 modules
01
Neural Network Fundamentals
What a neural network is: neurons and layers, weights and biases, activation functions and the forward pass, built up from a single perceptron.
Perceptron
Layers
Forward Pass
02
Backpropagation & Gradient Descent
How a network learns: measuring error, passing gradients backwards with the chain rule, and updating weights step by step in a training loop.
Backpropagation
Chain Rule
Gradient Descent
03
Loss Functions & Optimizers
Choosing a loss for the task, and the optimizers that minimize it: SGD, momentum, Adam, learning rates and schedules.
Loss Functions
Optimizers
Learning Rate
04
Overfitting & Regularization
Why a network can memorize instead of learn, and the tools that help it generalize: train/validation splits, weight decay, dropout and normalization.
Overfitting
Dropout
Normalization
05
PyTorch Essentials
Building and training models in code: tensors, autograd, modules, datasets and data loaders, and a clean training and evaluation loop.
Tensors
Autograd
Training Loops
06
Convolutional Neural Networks
How networks see images: convolution and pooling, feature maps, classic architectures and how to read what a CNN has learned.
Convolutions
Pooling
Architectures
07
Computer Vision & Transfer Learning
Putting vision models to work: image classification and detection, data augmentation, and reusing pretrained networks instead of starting from zero.
Image Classification
Augmentation
Transfer Learning
08
Sequence Models: RNNs & LSTMs
Learning from text, audio and time series: recurrent networks, hidden state, vanishing gradients, and how LSTMs and GRUs address them.
RNNs
LSTM & GRU
Sequences
09
Attention & Transformers
The architecture behind modern AI: self-attention, positional encoding, encoder and decoder blocks, and how a transformer is put together.
Self-Attention
Transformers
Positional Encoding
10
Pretraining & Fine-Tuning
How large models are trained and adapted: next-token pretraining, embeddings, fine-tuning on your own data, and lightweight methods such as LoRA.
Pretraining
Fine-Tuning
LoRA
11
Generative Models
Networks that create: autoencoders, variational autoencoders, GANs and diffusion models, and how each learns to produce new data.
Autoencoders
GANs
Diffusion
12
Training at Scale & Deployment
Making models work in practice: debugging training runs, GPUs and mixed precision, saving and serving a model, and tracking experiments.
Debugging
GPUs
Deployment
What You Can Do After This Course
By the end of the curriculum you'll understand the networks behind modern AI well
enough to build and train them, not just use them. Concretely, you'll be able to:
Explain how neural networks work: layers, weights, activations and the forward pass, and why depth lets a model learn complex patterns.
Train a network from scratch: compute a loss, backpropagate gradients and update weights with an optimizer in a clean training loop.
Spot and fix overfitting: split your data properly and use dropout, weight decay and normalization so a model generalizes.
Build models in PyTorch: work with tensors, autograd, datasets and data loaders, and write and debug your own training code.
Work with images: design and train convolutional networks, and reuse pretrained models through transfer learning.
Model sequences and language: use recurrent networks, and explain how attention and transformers process text.
Adapt large pretrained models: fine-tune a model on your own data, including lightweight methods such as LoRA.
Take a model into practice: debug training runs, use GPUs efficiently, track experiments and save a model so it can be served.