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
1
Module 1: Tensors and autograd
The data structure and the automatic differentiation engine everything else is built on.3 lessons
Tensors, dtypes, devices and broadcasting rules
Autograd: the computation graph, backward() and requires_grad
Views, in-place operations and the bugs they cause
2
Module 2: Building models with nn.Module
Composing layers into models and managing their parameters and state.3 lessons
nn.Module, parameters, buffers and state_dict
Layers that matter: Linear, Conv2d, Embedding, normalization and dropout
Weight initialization and why it changes training
3
Module 3: Data pipelines
Getting data from disk to GPU fast and correctly.3 lessons
Dataset, DataLoader, samplers and collate functions
Workers, pinned memory and finding a data-loading bottleneck
Using Hugging Face Datasets and torchvision transforms with PyTorch
4
Module 4: The training loop
Loss functions, optimizers and a loop you can reason about and resume.4 lessons
Loss functions: cross-entropy, MSE and label smoothing
Optimizers and schedules: SGD, AdamW, warmup and cosine decay
Validation, early stopping and checkpoint save and resume
Training an image classifier end to end
5
Module 5: Training fast on GPUs
Using the hardware well without changing the model's results.3 lessons
Mixed precision with autocast: bf16 versus fp16 and GradScaler
torch.compile: graph capture, graph breaks and recompilation
Gradient accumulation, clipping and a first look at multi-GPU with Accelerate
6
Module 6: Debugging, tracking and export
Finding what went wrong, recording what happened, and getting the model out of the notebook.3 lessons
Reading loss curves and debugging NaNs, divergence and overfitting
Experiment tracking and reproducibility: seeds, determinism and logging
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.
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.
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.
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.