Course 6 of 7 · Intermediate

Deep Learningfrom one hidden layer to a deployed network.

Every architecture is a loss, a function and an optimiser, and every network is scored against a model from the Machine Learning track on the same split.

Lessons in this course are being published. The syllabus below lists every module and lesson.

See the syllabus
11modules
49lessons planned

Who Deep Learning is for and what you will learn

This track is for you if

  • You have trained classical models and want to know how neural networks learn, not only call them.
  • You want to work with images, text or audio, where the features are not in the columns.
  • You want plain PyTorch, the code you will see at work, with nothing hidden behind a wrapper.

By the end you can

  • Take a real image, text or table problem from data to a deployed network.
  • Compute backpropagation by hand, and write the PyTorch training loop yourself.
  • Find why a network will not train, with a fixed order of checks.
  • Fine-tune pretrained networks for images and text, and know when a classical model still wins.
  • Explain attention and the transformer, and train one on real text.
  • Make a network small and fast, then serve and monitor it.

Before you start

Machine Learning up to Stage 6 of the learning path, Linear classifiers: gradient descent, the test set and classification metrics, the perceptron, logistic regression and softmax. PyTorch itself is taught in Module 2, and each lesson re-establishes what it uses from earlier tracks.

Each lesson is free to read once it opens. As in every track, the opening modules are a free sample: a free account opens all of their material. Pro adds it for the rest of the course.

The syllabus11 modules, each ending in its own finish line.

Every lesson is listed, including the ones still in production, so you can see where the track goes. Open lessons have their parts and key terms free to read, and their quiz free with an account.

  1. Module 0 · 1 lesson · planned

    The Result First

    1. 0.1What Deep Learning Is ForSee a pretrained network fine-tuned on real photos beat every classical model on the same split, and say which problems need deep learning and which still run on the ML track's models.
      What it will cover
      • The problem: 37 pet breeds from photos; logistic regression on raw pixels as the baseline, with its accuracy
      • A pretrained network fine-tuned on the same training images, scored on the same test images; a prediction on a new photo
      • Why pixels defeat classical models: the features are not in the columns
      • Where deep learning is the default (images, audio, text, video) and where gradient boosting still wins (most tables), with ML 9.4 named
      • What a GPU is for, measured: one matrix multiplication timed on CPU and GPU
      • What the track opens, in order: every step of what just ran
      Planned
  2. Module 1 · 4 lessons · planned

    From Logistic Regression to a Neural Network

    1. 1.1The Multilayer PerceptronBuild a network with one hidden layer from softmax regression, train it, and explain why the hidden layer needs a nonlinearity.
      What it will cover
      • The problem: classify clothing images; softmax regression (ML 7.4) as the baseline
      • A hidden layer: h = ReLU(XW₁ + b₁), ŷ = softmax(hW₂ + b₂), with every shape printed
      • Two linear layers without a nonlinearity collapse into one, computed on screen
      • The decision boundary on constructed moons: softmax regression's line against the network's curve
      • Parameters counted layer by layer; cross-entropy as the objective; mini-batch SGD as the learning
      • Failure modes previewed: overfitting with width, slow training, a stuck loss
      • Code: NumPy forward and backward, then the same network in PyTorch
      Planned
    2. 1.2Activation FunctionsChoose the activation for each layer and the output, and see what saturation does to the gradient.
      What it will cover
      • Sigmoid, tanh, ReLU, GELU and SiLU, each with its derivative plotted
      • Saturation: the gradient through ten sigmoid layers, measured
      • Dead ReLUs: the fraction of units that never fire, counted during training
      • The output layer by task: none for regression, sigmoid for binary, softmax for many classes, each with its loss
      • Common mistake: softmax before CrossEntropyLoss, which applies it again
      Planned
    3. 1.3BackpropagationCompute every gradient of a small network by hand with the chain rule, and see why one backward pass costs about as much as the forward pass.
      What it will cover
      • The computation graph of a 2-2-1 network, with numbers on every node
      • The backward pass node by node: each local derivative, multiplied along the path, closing on screen
      • Reuse: why reverse mode computes all gradients in one pass
      • One layer vectorised: dW = Xᵀ dZ, with the shapes
      • Gradient checking by finite differences, and the relative error that says it is right
      • Common mistake: forgetting the gradient sums over the mini-batch
      Planned
    4. 1.4Depth and WidthMeasure what extra layers and extra units buy at the same parameter count.
      What it will cover
      • One wide hidden layer can fit any curve on the constructed spiral, at a cost in units
      • Depth against width at equal parameter counts, trained and scored
      • Capacity and the bias–variance hyperparameter: training against validation loss as width grows (ML 4.6)
      • Why depth is hard to train, previewed for Module 3
      Planned
  3. Module 2 · 4 lessons · planned

    PyTorch

    1. 2.1Tensors and the GPUCreate, reshape and move tensors, and predict where an operation runs and in what precision.
      What it will cover
      • Tensors against NumPy arrays: the same shapes, dtypes and broadcasting rules (Tools 1.2–1.4)
      • device: moving a tensor to the GPU, and the error when two tensors live on different devices
      • float32, float16 and bfloat16: range and precision printed (Maths 5.1)
      • Timing a matrix multiplication on CPU and GPU, with synchronisation (common mistake: timing without it)
      • Views against copies; reshape, permute, unsqueeze
      Planned
    2. 2.2AutogradLet PyTorch compute DL 1.3's gradients, and predict what `.backward()` does to `.grad`.
      What it will cover
      • requires_grad, the graph recorded during the forward pass, .backward()
      • The hand gradients of DL 1.3 matched to the last digit
      • Gradients accumulate: the bug when zero_grad is missing, shown
      • torch.no_grad() and .detach() for evaluation and for values that must not be trained
      Planned
    3. 2.3Modules, Datasets and DataLoadersWrite a network as an `nn.Module` and feed it shuffled mini-batches from a `Dataset`.
      What it will cover
      • nn.Module, nn.Linear, nn.Sequential; parameters() listed and counted (Python Module 6)
      • Dataset.__getitem__ and __len__; DataLoader batching and shuffling
      • Transforms: converting and normalising an image on load
      • Common mistake: normalising with statistics computed on the test set (ML 8.5)
      Planned
    4. 2.4The Training LoopWrite the training loop once, completely, and reuse it for every network in the track.
      What it will cover
      • Forward, loss, backward, step, zero: each line and what it changes
      • model.train() against model.eval(), and the validation loop
      • Logging the loss per step and per epoch; reading the curve
      • Saving and loading a checkpoint: weights, optimiser state, epoch
      • The overfit-one-batch check: a correct loop drives one batch's loss to near zero
      • The DL 1.1 network trained with it, matching the NumPy result
      Planned
  4. Module 3 · 9 lessons · planned

    Training Deep Networks

    1. 3.1InitialisationSee activations vanish or explode through depth, and choose the initial scale that keeps them steady.
      What it will cover
      • A 20-layer network: the standard deviation of each layer's activations, plotted at three initial scales
      • Xavier and Kaiming initialisation derived from keeping the variance constant
      • What PyTorch does by default, and when to change it
      • Common mistake: all weights equal, so every unit learns the same thing
      Planned
    2. 3.2Optimisers: Momentum, RMSProp, Adam and AdamWWatch each optimiser cross the same ill-conditioned loss, and know why AdamW is the default.
      What it will cover
      • SGD on the constructed ravine loss: the zig-zag from ML 3.5's conditioning
      • Momentum as a running average of gradients; RMSProp as a per-parameter scale; Adam as both, with bias correction
      • The same four on the clothes network: loss curves on one chart
      • Weight decay inside Adam against AdamW's decoupled weight decay, measured
      • The defaults, and which hyperparameter matters most (the learning rate)
      Planned
    3. 3.3The Learning Rate: Range Test, Warmup and SchedulesChoose a learning rate from a range test and a schedule from the loss curve.
      What it will cover
      • The learning-rate range test: loss against a rising rate, and where to read it
      • Constant, step, cosine and one-cycle schedules; warmup and why it helps early training
      • Batch size and learning rate together
      • Common mistake: a schedule that steps per epoch when it was written per batch
      Planned
    4. 3.4Normalisation: Batch Norm and Layer NormNormalise activations inside the network, and know which normalisation fits which architecture.
      What it will cover
      • Batch norm: per-feature mean and variance over the mini-batch, then a learned scale and shift
      • Its two modes: batch statistics in training, running averages in evaluation; the bug when eval() is forgotten, shown
      • Layer norm: statistics over the features of one example, independent of batch size
      • The depth a network can train to, with and without normalisation, measured
      Planned
    5. 3.5Regularising a NetworkClose the gap between training and validation loss with weight decay, dropout and early stopping, and measure what each does.
      What it will cover
      • The overfitting network: training loss falling while validation loss rises (ML 4.6)
      • Weight decay as ML 4.8's penalty on every weight
      • Dropout: units zeroed in training, scaled in evaluation
      • Early stopping on validation loss, with the checkpoint kept
      • Label smoothing named; data augmentation previewed for DL 4.3
      • All of them on one table: validation accuracy and the train–validation gap
      Planned
    6. 3.6Residual ConnectionsSee a deeper plain network train worse than a shallow one, and fix it with a skip connection.
      What it will cover
      • The degradation problem: training loss of plain networks at 8, 20 and 50 layers
      • The residual block x + F(x), and the gradient path it adds
      • The same depths with residual blocks, trained and compared
      • Why the residual block is the unit of ResNets and of transformers
      Planned
    7. 3.7Debugging a Network That Won't TrainFind why a training run fails, with a fixed order of checks.
      What it will cover
      • The loss at initialisation should be log C; reading what it means when it is not
      • Overfit one batch (DL 2.4); gradient norms per layer; activation histograms
      • NaN and infinite losses: their causes (learning rate, log(0), overflow in float16) (Maths 5.1)
      • Data-pipeline bugs: shuffled labels, unnormalised inputs, a wrong channel order
      • A broken run fixed step by step, each check run live
      Planned
    8. 3.8Hyperparameter Tuning for NetworksTune a network's hyperparameters in the order that matters, within a fixed budget.
      What it will cover
      • What to tune first: learning rate, then weight decay and batch size, then architecture
      • Random search against grid search on a log scale (ML 4.5)
      • Pruning poor trials early with Optuna (ML 4.5 owns it); the best trial re-run with three seeds
      • Common mistake: choosing on the test set, or on one seed
      Planned
    9. 3.9Mixed Precision and Training FasterTrain in half precision without losing accuracy, and measure the memory and time saved.
      What it will cover
      • float16 against bfloat16: range and the underflow of small gradients
      • autocast and gradient scaling in PyTorch
      • Gradient accumulation: a large effective batch on a small GPU
      • Memory and throughput measured with and without each
      Planned
  5. Module 4 · 7 lessons · planned

    Computer Vision

    1. 4.1Convolutional Neural NetworksCompute a convolution by hand, build a CNN from convolution and pooling layers, and see why it beats the MLP on images with fewer parameters.
      What it will cover
      • The problem: classify small colour photos; the DL 1.1 MLP as the baseline, with its parameter count
      • A 3 × 3 kernel slid over a 5 × 5 image, every product and sum on screen
      • Padding, stride, channels and pooling; the output shape computed before it is printed
      • Parameter sharing: the CNN's count against the MLP's
      • Real feature maps from the trained network, layer by layer
      • Failure modes: translation is handled, rotation and scale are not
      • Code: one convolution in NumPy, then nn.Conv2d
      Planned
    2. 4.2CNN Architectures: From LeNet to ResNetRead a CNN architecture diagram, and measure what each design step adds.
      What it will cover
      • The receptive field growing with depth, computed
      • The VGG pattern: stacks of 3 × 3 convolutions; ResNet's residual blocks (DL 3.6); global average pooling
      • Parameters against accuracy for each, trained on the same data
      • Current architectures named in the learner pack, not the narration
      Planned
    3. 4.3Data AugmentationEnlarge the training set with transformations that keep the label, and measure the gain.
      What it will cover
      • Flips, crops, colour changes and rotations, each shown on one image
      • Which transformations keep the label and which do not (a flipped 6 is not a 9, a flipped chest X-ray changes the side)
      • Validation accuracy with and without augmentation
      • Augmentation applied to training data only; test-time augmentation named
      • Mixup and CutMix named
      Planned
    4. 4.4Transfer Learning and Fine-TuningStart from a network pretrained on millions of images, adapt it to a few thousand, and know when to freeze and when to fine-tune.
      What it will cover
      • What a pretrained network has learned: its early and late feature maps on the viewer's images
      • Feature extraction (frozen backbone, new head) against fine-tuning (all layers, a lower learning rate)
      • From scratch against pretrained on the same small training set, measured
      • Discriminative learning rates; unfreezing in stages
      • Common mistake: forgetting the pretrained network's input normalisation
      • torchvision and timm for pretrained weights; licences of pretrained weights checked
      Planned
    5. 4.5Object DetectionPredict where objects are as boxes, score a detector, and fine-tune a pretrained one.
      What it will cover
      • The problem: find each pet's head; a box as four numbers
      • Intersection over union, computed for two boxes on screen
      • A detector's output: many scored boxes; non-maximum suppression run step by step
      • Precision and recall at an IoU threshold, then mean average precision (ML 5.3)
      • Two-stage and one-stage detectors named; a pretrained detector fine-tuned
      • Failure modes: small objects, crowded scenes, boxes cut off at the edge
      Planned
    6. 4.6Image Segmentation and the U-NetClassify every pixel with an encoder–decoder network, and score a segmentation.
      What it will cover
      • The problem: separate each pet from its background; a mask as one label per pixel
      • The U-Net: a downsampling encoder, an upsampling decoder, and the skip connections between them
      • Upsampling: transposed convolution and interpolation, each computed on a small grid
      • Pixel accuracy misleads when the background dominates (ML 5.4); Dice and IoU computed
      • Failure modes: thin structures, boundaries, label noise in the masks
      Planned
    7. 4.7Seeing What a CNN UsesShow which pixels a prediction depends on, and catch a network that learned the background instead of the object.
      What it will cover
      • Saliency maps from the gradient of the class score
      • Grad-CAM: weighting the last feature maps by their gradients
      • A constructed shortcut: a network trained where one class always has the same background, then tested where it does not
      • What these maps can and cannot claim (ML 10.1)
      Planned
  6. Module 5 · 4 lessons · planned

    Representation Learning

    1. 5.1EmbeddingsTurn a category or an image into a learned vector, and find similar items by the distance between vectors.
      What it will cover
      • An embedding layer is a one-hot vector times a matrix (ML 8.2), computed both ways
      • The penultimate layer of DL 4.4's network as an image embedding
      • Cosine similarity (ML 4.1): the nearest pets to a query photo, retrieved
      • A 2-D projection of the embeddings (ML 11.3), breeds clustering
      • Vector search named; the Generative AI track uses it for retrieval
      Planned
    2. 5.2AutoencodersTrain a network to reconstruct its input through a narrow layer, and compare what it keeps with PCA.
      What it will cover
      • The problem: compress images to a few numbers; PCA (ML 11.1) as the baseline at the same size
      • Encoder, bottleneck, decoder; reconstruction loss
      • Reconstructions side by side at 2, 8 and 32 dimensions, with error measured against PCA's
      • The denoising autoencoder: noise in, clean out
      • Failure modes: a bottleneck too wide copies the input; blurry reconstructions under squared error
      • The variational autoencoder named; the Generative AI track uses it in latent diffusion
      Planned
    3. 5.3Autoencoders for Anomaly DetectionFlag rare transactions by their reconstruction error, and measure it honestly against isolation forest.
      What it will cover
      • Train on normal transactions only; reconstruction error as the anomaly score
      • The threshold from the precision–recall curve (ML 5.3)
      • Against isolation forest (ML 13.2) on the same sealed set, with the result as measured
      Planned
    4. 5.4Self-Supervised and Contrastive LearningLearn useful features from unlabelled images, and measure them with a linear probe.
      What it will cover
      • Labels are expensive; unlabelled images are not (ML 16.1 named)
      • Two augmented views of one image; the contrastive loss as a softmax cross-entropy over pairs (ML 7.4)
      • The linear probe: logistic regression on frozen features, the standard measure of a representation
      • Self-supervised features against supervised features on a small labelled subset
      • Why the pretrained backbones of DL 4.4 exist; text–image contrastive models named for the Generative AI track
      Planned
  7. Module 6 · 6 lessons · planned

    Sequences and the Transformer

    1. 6.1Recurrent Neural NetworksProcess a sequence one token at a time with a hidden state, and see why long sequences make it fail.
      What it will cover
      • The problem: review sentiment from 50,000 reviews; TF-IDF with logistic regression (ML 6.1, 7.2) as the baseline, with its score
      • Tokens to integer IDs to embeddings (DL 5.1)
      • The recurrence hₜ = tanh(W hₜ₋₁ + U xₜ + b), unrolled over a five-token sentence
      • Backpropagation through time; vanishing and exploding gradients measured over sequence length; gradient clipping
      • LSTM and GRU gates named as the fix, with the measured gain
      • The result as measured, including if TF-IDF still wins
      Planned
    2. 6.2AttentionCompute self-attention by hand on a four-token sentence, and say what each query, key and value does.
      What it will cover
      • The limit of one hidden state for a long sequence
      • Queries, keys and values as three linear projections of each token
      • Dot products, scaling by √d, softmax over each row, the weighted sum of values, every number closing on screen
      • The causal mask for prediction from the left only
      • Multi-head attention: several projections in parallel, concatenated
      • The cost: quadratic in sequence length, counted
      Planned
    3. 6.3The TransformerAssemble attention, a feed-forward layer, residual connections and layer norm into a transformer block, and train a small transformer on real text.
      What it will cover
      • The problem: the same reviews; the RNN of DL 6.1 as the baseline
      • Position encodings: why attention alone ignores order, shown by shuffling tokens
      • The block: attention, add and norm, feed-forward, add and norm (DL 3.4, 3.6)
      • Encoder against decoder: the mask is the difference
      • A small encoder trained from scratch, against the RNN and TF-IDF
      • Failure modes: data hunger from scratch, cost at long sequences
      • Code: one block in NumPy for the explanation tier, then nn.TransformerEncoderLayer
      Planned
    4. 6.4Fine-Tuning a Pretrained Text ModelFine-tune a pretrained transformer encoder for text classification, and beat a TF-IDF baseline on a small labelled set.
      What it will cover
      • Subword tokenisation shown on real sentences (the Generative AI track teaches tokenisers fully)
      • A pretrained encoder plus a classification head; the learning rate for fine-tuning
      • On ML 7.9's 3,000 sentences: TF-IDF's score still on the board, then the fine-tuned model's
      • Sentence embeddings (ML 6.1) as the frozen-encoder alternative, measured
      • Hugging Face transformers and its Trainer against DL 2.4's loop
      • Common mistake: truncating long texts without checking how many were cut
      Planned
    5. 6.5Token Classification: Named-Entity RecognitionLabel every token of a sentence, and score entities rather than tokens.
      What it will cover
      • BIO tags on a real sentence
      • Subword tokens against word labels: the alignment, and the common mistake of labelling every piece
      • Token accuracy against entity-level precision, recall and F1 (ML 5.1)
      • A pretrained encoder fine-tuned, with its errors read by entity type
      Planned
    6. 6.6Transformers for ImagesTreat an image as a sequence of patches, and compare a vision transformer with a CNN on the same data.
      What it will cover
      • Patches as tokens, a learned position embedding, a class token
      • Pretrained vision transformer against pretrained CNN, fine-tuned on pets with the same budget
      • From scratch on small data, where the CNN's built-in assumptions help, measured
      Planned
  8. Module 7 · 3 lessons · planned

    Tables, Recommendations and Time Series

    1. 7.1Neural Networks on Tabular DataBuild a network for a table with numerical and categorical columns, and measure it against gradient boosting.
      What it will cover
      • Scaled numerical columns and entity embeddings for categorical columns (DL 5.1)
      • The network against ML 9.4's gradient boosting on the same split
      • Where networks help on tables: very large data, text or images beside the columns, several targets at once
      • The decision rule for a new tabular problem
      Planned
    2. 7.2Neural Collaborative FilteringWrite matrix factorisation as a network with two embedding tables, and extend it.
      What it will cover
      • ML 14.2's factorisation as user embedding dot item embedding, plus biases
      • Replacing the dot product with an MLP; error and ranking measured against ML 14.2
      • The two-tower retrieval model named for large catalogues
      Planned
    3. 7.3Forecasting with Neural NetworksForecast a series with a network, validated walk-forward, against the ML track's lag-feature model.
      What it will cover
      • Windows of past values as input; the walk-forward split from ML 15.1
      • An MLP and a 1-D convolution on hourly bike counts against ML 15.2's gradient boosting on lag features
      • Pretrained forecasting models named in the learner pack
      • The result as measured
      Planned
  9. Module 8 · 1 lesson · planned

    Audio · (optional)

    1. 8.1Audio Classification (optional)Turn a waveform into a spectrogram, classify it with a CNN, and fine-tune a pretrained audio model.
      What it will cover
      • The problem: recognise spoken command words; a waveform as samples at a sampling rate
      • The short-time Fourier transform and the mel spectrogram, built on screen from one clip
      • A CNN on spectrograms (DL 4.1); masking time and frequency as augmentation
      • A pretrained audio encoder fine-tuned, against the CNN
      • Failure modes: background noise, other speakers, other microphones
      Planned
  10. Module 9 · 7 lessons · planned

    Deep Learning in Practice

    1. 9.1Structuring a Deep Learning ProjectDecide what to work on next from an error analysis, instead of from guesses.
      What it will cover
      • Error analysis: 100 validation errors sorted into categories, and the ceiling each fix could reach
      • Human-level performance as the estimate of the best possible error; avoidable bias against variance (ML 4.3)
      • Train and serving data from different distributions: the train–dev set that separates variance from mismatch
      • The decision table: bigger network, more data, more regularisation, or different data
      Planned
    2. 9.2Building and Cleaning an Image DatasetAssemble a labelled dataset, and use a trained model to find its labelling errors.
      What it will cover
      • Collecting and labelling: sources, licences, and the label guide
      • The model's highest-loss training images as candidates for label errors, reviewed
      • Near-duplicate images across train and test found by embedding similarity (DL 5.1, ML 8.5)
      • Class balance and what to do about it (ML 5.4)
      Planned
    3. 9.3Reproducible Training and Experiment TrackingMake a training run repeatable and every result traceable to its code, data and configuration.
      What it will cover
      • Seeds, deterministic kernels, and what still varies across GPUs (measured over five seeds)
      • Configuration files and the checkpoint as the record of a run
      • Tracking runs with MLflow (ML 17.6 owns it)
      • Reporting a mean and spread over seeds, not one run
      Planned
    4. 9.4Making a Model Small and FastMeet a latency and memory budget, and measure what each technique costs in accuracy.
      What it will cover
      • Latency and throughput measured: batch size, CPU against GPU
      • Exporting the model: ONNX and torch.export; torch.compile
      • Post-training quantisation to 8-bit integers; pruning named
      • Knowledge distillation: a small student trained on a large teacher's probabilities (Stats 7.2)
      • One table: accuracy, size, latency for each
      Planned
    5. 9.5Serving a Deep Learning ModelPut a trained network behind an interface, with preprocessing identical to training, and monitor it.
      What it will cover
      • The preprocessing saved with the model; train/serve skew shown when it is not (ML 17.3)
      • A Gradio demo and an HTTP endpoint for the same model
      • Batching requests; GPU against CPU serving costs
      • Monitoring inputs that change: image brightness, size and class mix drifting (ML 17.5)
      Planned
    6. 9.6Calibration and Robustness of NetworksMeasure how overconfident a network is and how it fails under changed inputs, and correct its confidence.
      What it will cover
      • Reliability diagram of a network's probabilities (ML 17.1 owns calibration); temperature scaling as the network fix
      • Accuracy under corruptions: blur, noise, brightness
      • An adversarial example made with one gradient step, shown and measured
      • Out-of-distribution inputs: a car photo given to the pet classifier
      Planned
    7. 9.7Training on More Than One GPU (optional)Know when one GPU is not enough, and how data-parallel training splits the work.
      What it will cover
      • Memory per GPU: parameters, gradients, optimiser state and activations, counted
      • Data parallelism: each GPU on its own batch, gradients averaged
      • Distributed data parallel in PyTorch; sharding the optimiser state named
      Planned
  11. Module 10 · 3 lessons · planned

    Case Studies

    1. 10.1Case Study: Pneumonia from Chest X-RaysTake a medical-imaging problem from framing to a deployed model, choosing the metric for the clinical decision.
      What it will cover
      • The decision: which X-rays a radiologist reads first; recall as the constraint (ML 5.3)
      • The split by patient, and the leakage a split by image causes (ML 8.5)
      • A ladder of models: logistic regression, a CNN from scratch, a fine-tuned pretrained network
      • Error analysis (DL 9.1), Grad-CAM checks for shortcuts (DL 4.7), calibration (DL 9.6)
      • A deployed demo and what monitoring it would need
      Planned
    2. 10.2Case Study: Routing Consumer ComplaintsClassify written complaints by product, and decide whether a fine-tuned transformer is worth its cost over TF-IDF.
      What it will cover
      • The decision: which team receives each complaint; the cost of a misroute
      • Classes imbalanced and changing over time; a split by date (ML 15.1)
      • A ladder: TF-IDF with logistic regression, sentence embeddings with logistic regression, a fine-tuned encoder
      • Accuracy, macro F1 and latency in one table; the choice justified by all three
      • Distillation or quantisation to meet the latency (DL 9.4)
      Planned
    3. 10.3Case Study: Land Use from Satellite Images (optional)Fine-tune a network pretrained on everyday photos for satellite images, and deploy a small model that runs on a CPU.
      What it will cover
      • The decision: mapping land use across a region at a fixed compute budget
      • Pretrained on a different domain: how much transfer still helps, measured
      • Augmentations that keep the label for overhead images (rotations do)
      • A quantised model served on a CPU, with accuracy and latency reported
      Planned

Start free, go further with Pro

Compare the plans

Free

In Deep Learning:

  • Each lesson's parts and key terms once it opens, no account
  • Quizzes and saved progress with a free account
Pro

Pricing announced soon.

  • Every course, from Python to deep learning and generative AI
  • Practice problems for every lesson, levels A to C, with values to check
  • Self-checking notebooks that mark your answers as you go
  • Module projects, cheat sheets, common mistakes and interview answers
  • A certificate for every course you complete
  • Weekly live sessions with Gaurav
  • Everything in Free

Worked articles on Deep Learning

All Deep Learning resources

Where Deep Learning is used

All AI applications

Questions about Deep Learning

Why PyTorch?

PyTorch is the default in research and in most industry code. The course uses plain PyTorch with torchvision, timm and Hugging Face transformers, and the training loop you write in Module 2 is reused for every network in the track.

Do I need my own GPU?

No. The notebooks are built to run on a free Colab or Kaggle GPU. Where a training run does not fit in one session, it is cut down, and the notebook says what was cut.

Is every network compared with a classical model?

Yes. Each network is scored against a model from the Machine Learning course on the same split. Where the classical model wins, as gradient boosting does on most tables, the lesson says so.

Does it cover large language models?

Large language models, diffusion and building applications on them are the Generative AI course, which follows this one. What it builds on is taught here: attention and the transformer, fine-tuning a pretrained transformer, embeddings, and the autoencoder and U-Net that latent diffusion is built from.

Other courses

See the machine learning path