About the course
This course provides a focused introduction to the fundamental concepts of Deep Learning and practical techniques for building, training, and improving simple neural networks using the PyTorch framework. Building upon basic machine learning knowledge (equivalent to completing the introductory course), it transitions from classic algorithms to the core ideas powering deep learning models, providing participants with the skills to work with modern neural network architectures.
You will dive into the PyTorch framework, learning about Tensors as the fundamental data structure, Autograd for automatic differentiation, and how to leverage GPUs for accelerated computation. The course covers the essential building blocks of neural networks using PyTorch's torch.nn module, including common layers, activation functions, and loss functions. You will master the neural network training process by implementing the training loop, understanding optimisers (torch.optim), training parameters (learning rate, batch size, epochs), and how to handle data effectively using PyTorch's Dataset and DataLoader. Techniques to combat overfitting, such as L2 regularisation and Dropout, are also covered.
Key practical skills are developed through building and training a neural network from scratch on a standard dataset (e.g., for image classification), learning how to save and load trained models in PyTorch, and understanding the power of using pretrained models and fine-tuning for new tasks. By the end of this course, you will have a solid understanding of deep learning fundamentals and the practical skills to build, train, and manage simple neural networks using PyTorch, setting the stage for exploring more advanced architectures and MLOps practices in the subsequent course.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Explain the fundamental concepts of Deep Learning and its relationship to classic ML.
- Understand the core components of the PyTorch framework, including Tensors and Autograd.
- Use PyTorch with GPUs for accelerated computation.
- Build simple neural network architectures using torch.nn layers and activation functions.
- Select appropriate loss functions and optimisers for training neural networks.
- Implement the neural network training loop in PyTorch.
- Handle data for training using PyTorch Dataset and DataLoader.
- Understand and apply techniques to combat overfitting, such as L2 regularisation and Dropout.
- Train a simple neural network from scratch using PyTorch.
- Save and load trained models in PyTorch.
- Understand and apply the concept of using pretrained models and fine-tuning.
-
This course is designed for individuals with a foundational understanding of machine learning concepts (equivalent to completing the introductory Python ML course) who want to learn the fundamentals of Deep Learning and implement them using the PyTorch framework. It is ideal for:
Data Scientists looking to transition from classic ML to deep learning.
Software Developers interested in building neural networks.
Researchers and Students working with deep learning models.
Anyone with programming experience (preferably Python) and basic ML knowledge wanting to learn PyTorch and DL fundamentals.
-
Participants should have attended our Python ML course or have equivalent experience:
Working knowledge of programming concepts, including object-oriented programming basics.
Familiarity with the Python programming language and its scientific libraries (e.g., NumPy, Pandas, Scikit-learn basics), equivalent to completing the "Introduction to Machine Learning and Classic Algorithms with Python" course.
A foundational understanding of Machine Learning concepts (e.g., supervised/unsupervised learning, training/testing, evaluation metrics basics).
A basic understanding of linear algebra and calculus concepts is beneficial for understanding the underlying mechanics but not strictly required for course completion.
No prior experience with Deep Learning concepts or PyTorch is required.
-
This Deep Learning with PyTorch course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Introduction to Deep Learning Concepts
Recap: The relationship between AI, ML, and DL (Building on the first course).
Why Deep Learning? Understanding its rise and typical use cases.
The Artificial Neuron: From biological inspiration to the Perceptron model.
From Single Neurons to Neural Networks: Layers and activation functions.
When to Consider Deep Learning vs. Classic ML (Revisiting the comparison from the first course with more depth).
Overview of the Deep Learning Workflow.
Introduction to the PyTorch Framework
What is PyTorch? Its philosophy and key advantages.
PyTorch Tensors: Understanding tensors as the fundamental data structure in PyTorch. Creating, manipulating, and performing operations on tensors.
Tensor data types and shapes.
Introduction to Autograd: PyTorch's automatic differentiation engine – the backbone of neural network training. Understanding gradients.
Using PyTorch with GPUs: Moving tensors and models to the GPU for faster computation.
Introduction to torch.nn: PyTorch's module for building neural networks.
Building Neural Networks with PyTorch
Defining Network Architectures: Using torch.nn.Module and torch.nn.Sequential to construct neural networks.
Common Layers: Understanding and using Linear (Dense) layers.
Activation Functions: Purpose and common choices (ReLU, Sigmoid, Tanh) and their implementation in PyTorch.
Loss Functions: Measuring the error of a model's predictions (torch.nn loss functions like CrossEntropyLoss for classification, MSELoss for regression).
Hands-On Labs: Working with PyTorch Tensors, performing operations on GPUs, building simple sequential neural networks using torch.nn, selecting activation and loss functions.
Training Neural Networks
The Neural Network Training Process: Understanding the steps – Forward Pass, Calculating Loss, Backward Pass (Autograd in action), Optimiser Step.
Optimisers (torch.optim): Concepts of Gradient Descent and its variants (SGD, Adam, etc.). Using optimisers in PyTorch.
Training Parameters: Understanding the role of Learning Rate, Batch Size, and Number of Epochs.
Handling Data for Training:
Introduction to torch.utils.data.Dataset: Preparing your data.
Using torch.utils.data.DataLoader: Efficiently loading and batching data for training.
Implementing the Training Loop in PyTorch.
Hands-On Labs: Setting up optimisers, implementing a basic training loop, using Dataset and DataLoader to prepare data batches for training.
Improving and Regularising Neural Networks
Understanding Overfitting and Underfitting specifically in Deep Learning.
Regularisation Techniques: Methods to prevent overfitting.
L2 Regularisation (Weight Decay) - implementation via optimisers.
Dropout Layers (torch.nn.Dropout).
(Optional/Brief) Early Stopping.
Hyperparameter Tuning for Neural Networks: Concepts and manual tuning approach.
Hands-On Labs: Implementing L2 regularisation and Dropout in a neural network, observing their effects, experimenting with hyperparameters.
Practical Application and Model Management
Training a Neural Network from Scratch: A guided, practical example covering the full workflow (e.g., Image Classification on MNIST or a similar dataset) - bringing all the pieces together.
Saving and Loading Models in PyTorch: Persisting trained models for later use.
Using Pretrained Models and Fine-tuning:
Concept of Transfer Learning.
Loading pretrained models from model hubs (e.g., torchvision.models).
Fine-tuning a pretrained model for a new task (simple example).
Hands-On Labs: Completing a full training example, saving and loading the trained model, performing a simple fine-tuning task using a pretrained model.
Summary and next steps
Review of key Deep Learning Fundamentals and PyTorch concepts covered.
Brief Introduction to Convolutional Neural Networks (CNNs) and Recurrent Neural Networks (RNNs) as common advanced architectures (as a bridge to further learning).
Connecting to the next course: MLOps and Deployment.
Q&A
-
Official PyTorch Documentation - https://pytorch.org/docs/stable/index.html
PyTorch Tutorials - https://pytorch.org/tutorials/
NumPy Documentation - https://numpy.org/doc/ (for understanding Tensor operations based on NumPy).
Trusted by
