Programming

PyTorch: Deep Learning with PyTorch

Master modern deep learning and neural network engineering with PyTorch. From tensor fundamentals, automatic differentiation with Autograd, torch.nn modules, custom datasets and DataLoaders to Convolutional Neural Networks (CNNs), Recurrent Neural Networks (LSTM/GRU), transfer learning, CUDA GPU acceleration with mixed precision …

40 hours Duration
15 Modules
Free Access

Course fee Free enrollment

Login to enroll and access modules, quizzes, and AI tutoring.

Login to Enroll

Learning path

Course Modules

Work through each module and pass quizzes to unlock the next step in your journey.

Module 1 Locked

Introduction to PyTorch

Embark on your deep learning journey with PyTorch, the leading Python framework for AI research and production. Understand what PyTorch is, its dynamic execution model (define-by-run), architectural advantages, and thriving ecosystem (torchvision, torchaudio, torchtext). Install …

Enroll in this course to access modules.

Learning objectives

• Understand what PyTorch is and why it dominates modern deep learning
• Compare dynamic computational graphs (define-by-run) with static graph engines
• Explore key features of PyTorch: imperative execution, Pythonic syntax, and GPU acceleration
• Understand the internal architecture of PyTorch
• Navigate the PyTorch ecosystem (torchvision, torchaudio, TorchServe)
• Install PyTorch and configure your development environment
• Verify CUDA GPU support and execute your first PyTorch script

Module 2 Locked

Tensors

Master Tensors, the foundational data structure of PyTorch. Create tensors from primitives and NumPy, explore tensor data types (float32, int64), dimensions, and shapes. Perform mathematical operations, indexing, slicing, reshaping with view() and reshape(), understand broadcasting …

Enroll in this course to access modules.

Learning objectives

• Understand the mathematical and computational properties of PyTorch Tensors
• Create tensors using torch.tensor(), torch.zeros(), torch.ones(), and torch.randn()
• Inspect tensor rank, shape, dimension, and datatype
• Perform element-wise operations and matrix multiplications
• Index and slice multi-dimensional tensors like NumPy
• Reshape tensors using view(), reshape(), squeeze(), and unsqueeze()
• Convert seamlessly between NumPy arrays and PyTorch tensors with shared memory

Module 3 Locked

Autograd

Uncover PyTorch's automatic differentiation engine: Autograd. Understand dynamic computational graphs, the requires_grad attribute, gradient tracking and calculation via backward(), detaching tensors, gradient accumulation, gradient clipping, and disabling gradient calculation with torch.no_grad().

Enroll in this course to access modules.

Learning objectives

• Understand how Autograd tracks tensor operations to compute vector-Jacobian products
• Configure requires_grad=True to flag tensors for automatic differentiation
• Execute backward() to compute gradients of scalar loss expressions
• Access computed partial derivatives through the .grad attribute
• Detach tensors from computation graphs using .detach()
• Implement gradient accumulation across mini-batches
• Disable gradient tracking with torch.no_grad() and torch.inference_mode() to save memory

Module 4 Locked

PyTorch Modules

Build reusable neural network components using torch.nn. Explore the nn.Module class, built-in layers (Linear, Conv, Embedding), activation functions (ReLU, Sigmoid, GELU), loss functions (CrossEntropyLoss, MSELoss), optimizers (Adam, SGD), weight initialization techniques, and regularization with Dropout …

Enroll in this course to access modules.

Learning objectives

• Understand the torch.nn package and the core nn.Module abstraction
• Instantiate and configure standard layers like nn.Linear and nn.Embedding
• Choose appropriate activation functions for hidden and output representations
• Select and configure loss functions for regression and classification tasks
• Instantiate optimizers from torch.optim (Adam, AdamW, SGD) with learning rates
• Apply weight initialization schemes using torch.nn.init (Xavier, Kaiming/He)
• Add Dropout and BatchNorm layers to regularize and stabilize training

Module 5 Locked

Building Neural Networks

Construct end-to-end deep neural network architectures with PyTorch. Master the nn.Module forward() method, manage model parameters, build linear pipelines with nn.Sequential, construct multi-branch custom models, configure hidden and output layers, inspect architectures with model summaries, …

Enroll in this course to access modules.

Learning objectives

• Construct Artificial Neural Networks by subclassing nn.Module
• Implement the forward() computation method connecting layers
• Inspect and count model parameters with model.parameters() and named_parameters()
• Build concise architectures using nn.Sequential
• Design custom multi-branch models with skip connections
• Properly invoke models via model(inputs) to trigger internal hooks
• Generate detailed layer summaries with input/output tensor shapes

Module 6 Locked

Data Loading

Construct scalable, production-grade data pipelines using PyTorch's data primitives. Master torch.utils.data.Dataset and custom dataset implementations, harness DataLoader for batching, shuffling, and multi-processing, apply torchvision transforms and data augmentation, and handle images and tabular CSV data …

Enroll in this course to access modules.

Learning objectives

• Understand the separation between Dataset (data representation) and DataLoader (data loading/batching)
• Subclass Dataset implementing __len__() and __getitem__()
• Configure DataLoader with batch_size, shuffle, num_workers, and pin_memory
• Apply image transformations (resize, normalize, to-tensor) with torchvision.transforms
• Augment training data with random crops, flips, and rotations to combat overfitting
• Ingest and preprocess tabular CSV datasets using PyTorch and pandas
• Optimize data pipeline throughput to prevent GPU starvation

Module 7 Locked

Model Training

Master the fundamental PyTorch training loop. Understand the exact sequence of the forward pass, loss computation, backward pass with loss.backward(), and optimizer parameter updates with optimizer.step(). Tune batch size, epochs, and learning rates, log progress …

Enroll in this course to access modules.

Learning objectives

• Write clean, idiomatic PyTorch training loops from scratch
• Execute forward passes, compute loss with criterion(), and call loss.backward()
• Update model weights using optimizer.step() and reset gradients with optimizer.zero_grad()
• Tune learning rates and select appropriate batch sizes for hardware constraints
• Extract scalar metrics safely using loss.item() without leaking GPU memory
• Track and log running loss and accuracy across training steps
• Apply gradient clipping (clip_grad_norm_) to stabilize training

Module 8 Locked

Model Evaluation

Rigourously assess model generalization and diagnostic performance. Implement the evaluation loop with model.eval() and torch.no_grad(), calculate classification metrics (Accuracy, Precision, Recall, F1 Score), compute Confusion Matrices, diagnose overfitting vs underfitting, and implement performance improvements.

Enroll in this course to access modules.

Learning objectives

• Switch model to evaluation mode using model.eval() and torch.no_grad()
• Calculate classification predictions using torch.argmax() or thresholding
• Measure accuracy, precision, recall, and F1 score on validation and test sets
• Compute and visualize Confusion Matrices using scikit-learn or torchmetrics
• Diagnose overfitting (high variance) vs underfitting (high bias)
• Implement learning rate schedulers (ReduceLROnPlateau, CosineAnnealingLR)
• Systematically improve model accuracy through regularisation and architecture adjustments

Module 9 Locked

Convolutional Neural Networks (CNN)

Master computer vision with PyTorch Convolutional Neural Networks. Learn convolution layers (nn.Conv2d), pooling (nn.MaxPool2d), strides, padding, and feature map transformations. Build custom image classifiers, explore popular architectures (ResNet, VGG, EfficientNet), and implement Transfer Learning and …

Enroll in this course to access modules.

Learning objectives

• Understand how 2D convolutions extract hierarchical spatial features from images
• Configure nn.Conv2d with in_channels, out_channels, kernel_size, stride, and padding
• Reduce spatial dimensions and gain spatial invariance with nn.MaxPool2d
• Flatten feature maps using nn.Flatten() or nn.AdaptiveAvgPool2d
• Load pre-trained models from torchvision.models (ResNet, EfficientNet, MobileNet)
• Replace the final fully connected classification head for custom datasets
• Freeze backbones and fine-tune layers with differential learning rates

Module 10 Locked

Recurrent Neural Networks (RNN)

Model sequential, time series, and natural language data with PyTorch recurrent models. Understand recurrent state transitions, implement Long Short-Term Memory (nn.LSTM) and Gated Recurrent Units (nn.GRU), build sequence classifiers, forecast time series, explore Bidirectional RNNs, …

Enroll in this course to access modules.

Learning objectives

• Understand how recurrent architectures maintain sequential memory across time steps
• Overcome vanishing gradients using nn.LSTM and nn.GRU
• Configure nn.LSTM with input_size, hidden_size, num_layers, and batch_first=True
• Process text and sequential tokens using nn.Embedding and padding
• Build time series forecasting models with recurrent backbones
• Implement Bidirectional RNNs to capture future and past context
• Understand the foundations of Attention mechanisms for sequence modeling

Module 11 Locked

Model Saving and Loading

Persist, version, and restore models seamlessly. Understand state_dict dictionaries, save and load model weights (torch.save / torch.load), save entire models vs parameter dictionaries, build complete training checkpoints with optimizer state to resume training, and export …

Enroll in this course to access modules.

Learning objectives

• Understand the structure of model.state_dict() and optimizer.state_dict()
• Save and restore model weights using torch.save() and model.load_state_dict()
• Compare saving weights (state_dict) vs saving the entire serialized model object
• Construct complete checkpoints including epoch, model state, optimizer state, and loss
• Resume interrupted training jobs flawlessly from saved checkpoints
• Implement best practices for model versioning and checkpoint artifact storage

Module 12 Locked

GPU Acceleration

Accelerate deep learning workloads using NVIDIA CUDA GPUs. Learn device management (torch.device), moving models and tensors to GPU, multi-GPU training strategies (DataParallel vs DistributedDataParallel), Automatic Mixed Precision (torch.amp), GPU memory management, and debugging CUDA errors.

Enroll in this course to access modules.

Learning objectives

• Configure device-agnostic code with torch.device("cuda" if torch.cuda.is_available() else "cpu")
• Transfer models and batch tensors to GPUs using .to(device)
• Double training speed and halve VRAM with Automatic Mixed Precision (torch.amp.autocast)
• Prevent float16 underflow using torch.amp.GradScaler
• Understand multi-GPU training with DistributedDataParallel (DDP)
• Profile GPU VRAM usage and release unused memory with torch.cuda.empty_cache()
• Diagnose and troubleshoot common CUDA Out-Of-Memory (OOM) errors

Module 13 Locked

Custom Components

Extend PyTorch beyond built-in modules. Create custom layers and activation functions, implement custom loss functions, write custom optimizers, master PyTorch forward and backward hooks for feature extraction and gradient inspection, and design reusable modular architectures.

Enroll in this course to access modules.

Learning objectives

• Build custom neural layers subclassing nn.Module and defining parameter weights
• Implement custom mathematical loss functions with domain-specific penalties
• Subclass torch.autograd.Function to implement custom forward and backward gradient routines
• Attach Forward Hooks (register_forward_hook) to inspect intermediate layer activations
• Attach Backward Hooks (register_full_backward_hook) to inspect or modify gradients
• Construct custom optimization algorithms subclassing torch.optim.Optimizer
• Package custom layers into reusable, distributable PyTorch components

Module 14 Locked

Model Deployment

Transition models from research prototypes to production microservices. Master TorchScript tracing and scripting for C++ runtime execution, export models using ONNX (Open Neural Network Exchange), build high-throughput inference pipelines, integrate models with FastAPI, and implement …

Enroll in this course to access modules.

Learning objectives

• Understand the requirements and constraints of production deep learning inference
• Convert dynamic PyTorch models into static TorchScript graphs using torch.jit.trace and torch.jit.script
• Run TorchScript models in C++ environments without Python dependencies
• Export models to the open ONNX standard using torch.onnx.export
• Run high-performance inference with ONNX Runtime
• Build asynchronous inference REST API microservices using FastAPI
• Implement batching, input validation, and latency optimization for production deployment

Module 15 Locked

PyTorch Best Practices

Adopt professional software engineering, distributed scaling, and reproducibility standards for enterprise PyTorch codebases. Learn clean project organization, multi-GPU scaling with DistributedDataParallel (DDP), experiment tracking (Weights & Biases, MLflow), debugging numerical instability, and ensuring reproducibility.

Enroll in this course to access modules.

Learning objectives

• Structure production PyTorch projects with clean separation of models, datasets, configs, and training
• Ensure deterministic experiment reproducibility by setting seeds across PyTorch, NumPy, and CUDA
• Scale training across multiple nodes and GPUs with DistributedDataParallel (DDP)
• Track experiments, loss curves, and hyperparameters using Weights & Biases or TensorBoard
• Profile execution bottlenecks using PyTorch Profiler (torch.profiler)
• Diagnose common bugs: silent broadcasting errors, in-place modifications, and CUDA OOMs
• Maintain long-term PyTorch version compatibility and codebase maintainability

Techietact AI Assistant

Ask me about courses and features

Hello! 👋 I'm your Techietact AI assistant. I'd love to help you! To get started, could you please share your name, email, and contact number?