Wirewalk Instituteof AI
mod-201 Intermediate Available

Deep Learning with PyTorch

For developers and data scientists who want to build, train, debug and export neural networks in modern PyTorch, from tensors to torch.compile.

Level
Intermediate
Study time
14 hours
Lessons
19 in 6 modules
Exam
20 questions

About this course

Most PyTorch code is copied from tutorials and only half understood, which is why it breaks the first time the data, the GPU or the model changes. This course builds the framework up from tensors, broadcasting and autograd, so that every line of a training loop has a reason. You write modules, datasets and DataLoaders, handle variable-length sequences with padding and masks, then train MLPs on synthetic data and a CNN on real data (Fashion-MNIST).

The second half is about doing it properly on a GPU: device placement, bf16 autocast, gradient accumulation and clipping, checkpointing and resuming, and speeding up with torch.compile. You learn to read loss curves, diagnose exploding gradients, NaNs and data-loader bottlenecks, track experiments, and export a trained model with torch.export or ONNX. Library features were checked against the documentation as of October 2026 (PyTorch 2.14.1); the example outputs were captured on PyTorch 2.8.0, and the course says where newer releases may print something different.

What you will be able to do

  • Manipulate tensors with correct shapes, dtypes, devices and broadcasting, and explain what autograd records
  • Build models as nn.Module subclasses with parameters, buffers and state_dict handled correctly
  • Write a Dataset and DataLoader pipeline that keeps a GPU fed, including workers, pinning and collation
  • Implement a complete training and validation loop with an optimizer, LR schedule, gradient clipping and checkpoint resume
  • Train with bf16 autocast and torch.compile and measure the speedup honestly
  • Diagnose common failures such as NaN losses, shape bugs, overfitting and data-loader stalls from logs and loss curves
  • Export a trained model with torch.export or ONNX for inference outside the training script

Syllabus

6 modules · 19 lessons · about 14 hours

Module 1: Tensors and autograd

The data structure and the automatic differentiation engine everything else is built on.
3 lessons
  1. Tensors, dtypes, devices and broadcasting rules
  2. Autograd: the computation graph, backward() and requires_grad
  3. Views, in-place operations and the bugs they cause

Module 2: Building models with nn.Module

Composing layers into models and managing their parameters and state.
3 lessons
  1. nn.Module, parameters, buffers and state_dict
  2. Layers that matter: Linear, Conv2d, Embedding, normalization and dropout
  3. Weight initialization and why it changes training

Module 3: Data pipelines

Getting data from disk to GPU fast and correctly.
3 lessons
  1. Dataset, DataLoader, samplers and collate functions
  2. Workers, pinned memory and finding a data-loading bottleneck
  3. Using Hugging Face Datasets and torchvision transforms with PyTorch

Module 4: The training loop

Loss functions, optimizers and a loop you can reason about and resume.
4 lessons
  1. Loss functions: cross-entropy, MSE and label smoothing
  2. Optimizers and schedules: SGD, AdamW, warmup and cosine decay
  3. Validation, early stopping and checkpoint save and resume
  4. Training an image classifier end to end

Module 5: Training fast on GPUs

Using the hardware well without changing the model's results.
3 lessons
  1. Mixed precision with autocast: bf16 versus fp16 and GradScaler
  2. torch.compile: graph capture, graph breaks and recompilation
  3. Gradient accumulation, clipping and a first look at multi-GPU with Accelerate

Module 6: Debugging, tracking and export

Finding what went wrong, recording what happened, and getting the model out of the notebook.
3 lessons
  1. Reading loss curves and debugging NaNs, divergence and overfitting
  2. Experiment tracking and reproducibility: seeds, determinism and logging
  3. Exporting with torch.export and ONNX for inference

Exam and certificate

The exam unlocks once you have completed every lesson. It draws 20 questions from a larger bank, spread across the modules, with the answer options shuffled for each attempt. You have 45 minutes and need 80% to pass. After a failed attempt you can try again after 24 hours, up to 3 attempts in total. Feedback is given per module, never as the answer key.

Passing earns a certificate of completion and assessment from the Wirewalk Institute of AI with a unique ID that anyone can check at institute.wirewalk.com/verify. It is not an accredited qualification or a vendor certification. How certification works.

The Wirewalk Institute of AI is independent. This course teaches publicly documented products and is not affiliated with or endorsed by PyTorch, NVIDIA CUDA, Hugging Face (Datasets, Accelerate), Weights & Biases, or ONNX. Product and company names are trademarks of their respective owners.

More in Model Development

All 16 courses in this track
mod-202 Intermediate Available

Transformers from the Ground Up

Build a decoder-only transformer piece by piece: tokenization, embeddings, scaled dot-product attention, multi-head and grouped-query attention, positional schemes such as RoPE, and the training and sampling loop, then map it onto real open-weight model architectures.

16 h · 19 lessons See price at checkout
mod-203 Intermediate Waitlist

Classical Machine Learning in Production

Gradient-boosted trees and linear models still win most tabular problems. This course covers leakage-proof pipelines, honest validation, tuning, calibration and explainability, then packaging, serving and monitoring for drift.

14 h · 19 lessons Join the waitlist
mod-204 Intermediate Waitlist

Computer Vision Models

From CNNs and vision transformers to self-supervised backbones, real-time detectors and promptable segmentation: how modern vision models work, how to fine-tune them on your own labeled data, how to measure them with mAP and IoU, and how to deploy them fast.

15 h · 18 lessons Join the waitlist