Hey Friends, I found a list of ordered videos for this course, hope this helps someone.
- PyTorch for Deep Learning
- Course Welcome and What Is Deep Learning
- Why Use Machine Learning or Deep Learning
- The Number 1 Rule of Machine Learning and What Is Deep Learning Good For
- Machine Learning vs. Deep Learning
- Anatomy of Neural Networks
- Different Types of Learning Paradigms
- What Can Deep Learning Be Used For
- What Is and Why PyTorch
- What Are Tensors
- What We Are Going To Cover With PyTorch
- How To and How Not To Approach This Course
- Important Resources For This Course
- Getting Setup to Write PyTorch Code
- Introduction to PyTorch Tensors
- Creating Random Tensors in PyTorch
- Creating Tensors With Zeros and Ones in PyTorch
- Creating a Tensor Range and Tensors Like Other Tensors
- Dealing With Tensor Data Types
- Getting Tensor Attributes
- Manipulating Tensors (Tensor Operations)
- Matrix Multiplication (Part 1)
- Matrix Multiplication (Part 2): The Two Main Rules of Matrix Multiplication
- Matrix Multiplication (Part 3): Dealing With Tensor Shape Errors
- Finding the Min Max Mean and Sum of Tensors (Tensor Aggregation)
- Finding The Positional Min and Max of Tensors
- Reshaping, Viewing and Stacking Tensors
- Squeezing, Unsqueezing and Permuting Tensors
- Selecting Data From Tensors (Indexing)
- PyTorch Tensors and NumPy
- PyTorch Reproducibility (Taking the Random Out of Random)
- Different Ways of Accessing a GPU in PyTorch
- Setting up Device Agnostic Code and Putting Tensors On and Off the GPU
- PyTorch Fundamentals: Exercises and Extra-Curriculum
- Introduction and Where You Can Get Help
- Getting Setup and What We Are Covering
- Creating a Simple Dataset Using the Linear Regression Formula
- Splitting Our Data Into Training and Test Sets
- Building a function to Visualize Our Data
- Creating Our First PyTorch Model for Linear Regression
- Breaking Down What's Happening in Our PyTorch Linear regression Model
- Discussing Some of the Most Important PyTorch Model Building Classes
- Checking Out the Internals of Our PyTorch Model
- Making Predictions With Our Random Model Using Inference Mode
- Training a Model Intuition (The Things We Need)
- Setting Up an Optimizer and a Loss Function
- PyTorch Training Loop Steps and Intuition
- Writing Code for a PyTorch Training Loop
- Reviewing the Steps in a Training Loop Step by Step
- Running Our Training Loop Epoch by Epoch and Seeing What Happens
- Writing Testing Loop Code and Discussing What's Happening Step by Step
- Reviewing What Happens in a Testing Loop Step by Step
- Writing Code to Save a PyTorch Model
- Writing Code to Load a PyTorch Model
- Setting Up to Practice Everything We Have Done Using Device-Agnostic Code
- Putting Everything Together (Part 1): Data
- Putting Everything Together (Part 2): Building a Model
- Putting Everything Together (Part 3): Training a Model
- Putting Everything Together (Part 4): Making Predictions With a Trained Model
- Putting Everything Together (Part 5): Saving and Loading a Trained Model
- Exercise: Imposter Syndrome
- PyTorch Workflow Exercises: Extra-Curriculum
- Introduction to Machine Learning Classification With PyTorch
- Classification Problem Example: Input and Output Shapes
- Typical Architecture of a Classification Neural Network (Overview)
- Making a Toy Classification Dataset
- Turning Our Data into Tensors and Making a Training and Test Split
- Laying Out Steps for Modelling and Setting Up Device-Agnostic Code
- Coding a Small Neural Network to Handle Our Classification Data
- Making Our Neural Network Visual
- Setting Up a Loss Function Optimizer and Evaluation Function for Our Classification Network
- Going from Model Logits to Prediction Probabilities to Prediction Labels
- Coding a Training and Testing Optimization Loop for Our Classification Model
- Writing Code to Download a Helper Function to Visualize Our Models Predictions
- Discussing Options to Improve a Model
- Creating a New Model with More Layers and Hidden Units
- Writing Training and Testing Code to See if Our New and Upgraded Model Performs Better
- Creating a Straight Line Dataset to See if Our Model is Learning Anything
- Building and Training a Model to Fit on Straight Line Data
- Evaluating Our Models Predictions on Straight Line Data
- Introducing the Missing Piece for Our Classification Model Non-Linearity
- Building Our First Neural Network with Non-Linearity
- Writing Training and Testing Code for Our First Non-Linear Model
- Making Predictions with and Evaluating Our First Non-Linear Model
- Replicating Non-Linear Activation Functions with Pure PyTorch
- Putting It All Together (Part 1): Building a Multiclass Dataset
- Creating a Multi-Class Classification Model with PyTorch
- Setting Up a Loss Function and Optimizer for Our Multi-Class Model
- Going from Logits to Prediction Probabilities to Prediction Labels with a Multi-Class Model
- Making Predictions with and Evaluating Our Multi-Class Classification Model
- Discussing a Few More Classification Metrics
- PyTorch Classification Exercises and Extra-Curriculum
- What Is a Computer Vision Problem and What We Are Going to Cover
- Computer Vision Input and Output Shapes (
- What Is a Convolutional Neural Network (CNN)
- Discussing and Importing the Base Computer Vision Libraries in PyTorch
- Getting a Computer Vision Dataset and Checking Out Its- Input and Output Shapes
- Visualizing Random Samples of Data
- DataLoader Overview Understanding Mini-Batch
- Turning Our Datasets Into DataLoaders
- Model 0: Creating a Baseline Model with Two Linear Layers
- Creating a Loss Function: an Optimizer for Model 0
- Creating a Function to Time Our Modelling Code
- Writing Training and Testing Loops for Our Batched Data
- Writing an Evaluation Function to Get Our Models Results
- Setup Device-Agnostic Code for Running Experiments on the GPU
- Model 1: Creating a Model with Non-Linear Functions
- Mode 1: Creating a Loss Function and Optimizer
- Turing Our Training Loop into a Function
- Turing Our Testing Loop into a Function
- Training and Testing Model 1 with Our Training and Testing Functions
- Getting a Results Dictionary for Model 1
- Model 2: Convolutional Neural Networks High Level Overview
- Model 2: Coding Our First Convolutional Neural Network with PyTorch
- Model 2: Breaking Down Conv2D Step by Step
- Model 2: Breaking Down MaxPool2D Step by Step
- Mode 2: Using a Trick to Find the Input and Output Shapes of Each of Our Layers
- Model 2: Setting Up a Loss Function and Optimizer
- Model 2: Training Our First CNN and Evaluating Its Results
- Comparing the Results of Our Modelling Experiments
- Making Predictions on Random Test Samples with the Best Trained Model
- Plotting Our Best Model Predictions on Random Test Samples and Evaluating Them
- Making Predictions Across the Whole Test Dataset and Importing Libraries to Plot a Confusion Matrix
- Evaluating Our Best Models Predictions with a Confusion Matrix
- Saving and Loading Our Best Performing Model
- Recapping What We Have Covered and Exercises and Extra-Curriculum
- What Is a Custom Dataset and What We Are Going to Cover
- Importing PyTorch and Setting Up Device-Agnostic Code
- Downloading a Custom Dataset of Pizza, Steak and Sushi Images
- Becoming One With the Data (Part 1): Exploring the Data Format
- Becoming One With the Data (Part 2): Visualizing a Random Image
- Becoming One With the Data (Part 3): Visualizing a Random Image with Matplotlib
- Transforming Data (Part 1): Turning Images Into Tensors
- Transforming Data (Part 2): Visualizing Transformed Images
- Loading All of Our Images and Turning Them Into Tensors With ImageFolder
- Visualizing a Loaded Image From the Train Dataset
- Turning Our Image Datasets into PyTorch DataLoaders
- Creating a Custom Dataset Class in PyTorch High Level Overview
- Creating a Helper Function to Get Class Names From a Directory
- Writing a PyTorch Custom Dataset Class from Scratch to Load Our Images
- Compare Our Custom Dataset Class to the Original ImageFolder Class
- Writing a Helper Function to Visualize Random Images from Our Custom Dataset
- Turning Our Custom Datasets Into DataLoaders
- Exploring State of the Art Data Augmentation With Torchvision Transforms
- Building a Baseline Model (Part 1): Loading and Transforming Data
- Building a Baseline Model (Part 2): Replicating Tiny VGG from Scratch
- Building a Baseline Model (Part 3): Doing a Forward Pass to Test Our Model Shapes
- Using the Torchinfo Package to Get a Summary of Our Model
- Creating Training and Testing loop Functions
- Creating a Train Function to Train and Evaluate Our Models
- Training and Evaluating Model 0 With Our Training Functions
- Plotting the Loss Curves of Model 0
- Discussing the Balance Between Overfitting and Underfitting and How to Deal With Each
- Creating Augmented Training Datasets and DataLoaders for Model 1
- Constructing and Training Model 1
- Plotting the Loss Curves of Model 1
- Plotting the Loss Curves of All of Our Models Against Each Other
- Predicting on Custom Data (Part 1): Downloading an Image
- Predicting on Custom Data (Part2): Loading In a Custom Image With PyTorch
- Predicting on Custom Data (Part 3): Getting Our Custom Image Into the Right Format
- Predicting on Custom Data (Part 4): Turning Our Models Raw Outputs Into Prediction Labels
- Predicting on Custom Data (Part 5): Putting It All Together
- Summary of What We Have Covered Plus Exercises and Extra-Curriculum
- What Is Going Modular and What We Are Going to Cover
- Going Modular Notebook (Part 1): Running It End to End
- Downloading a Dataset
- Writing the Outline for Our First Python Script to Setup the Data
- Creating a Python Script to Create Our PyTorch DataLoaders
- Turning Our Model Building Code into a Python Script
- Turning Our Model Training Code into a Python Script
- Turning Our Utility Function to Save a Model into a Python Script
- Creating a Training Script to Train Our Model in One Line of Code
- Going Modular Summary Exercises and Extra-Curriculum
- Thank You!
