1 PyTorch for Deep Learning Demo
03:34 2 Course Welcome and What Is Deep Learning
05:54 3 Why Use Machine Learning or Deep Learning
03:34 4 The Number 1 Rule of Machine Learning and What Is Deep Learning Good For
05:40 5 Machine Learning vs. Deep Learning
06:07 6 Anatomy of Neural Networks
09:22 7 Different Types of Learning Paradigms
04:31 8 What Can Deep Learning Be Used For
06:22 9 What Is and Why PyTorch
10:13 10 What Are Tensors
04:16 11 What We Are Going To Cover With PyTorch
06:06 12 How To and How Not To Approach This Course
05:10 13 Important Resources For This Course
05:22 14 Getting Setup to Write PyTorch Code
07:40 15 Introduction to PyTorch Tensors
13:26 16 Creating Random Tensors in PyTorch
09:59 17 Creating Tensors With Zeros and Ones in PyTorch
03:09 18 Creating a Tensor Range and Tensors Like Other Tensors
05:18 19 Dealing With Tensor Data Types
09:25 20 Getting Tensor Attributes
08:23 21 Manipulating Tensors (Tensor Operations)
06:00 22 Matrix Multiplication (Part 1)
09:35 23 Matrix Multiplication (Part 2): The Two Main Rules of Matrix Multiplication
07:52 24 Matrix Multiplication (Part 3): Dealing With Tensor Shape Errors
12:58 25 Finding the Min Max Mean and Sum of Tensors (Tensor Aggregation)
06:10 26 Finding The Positional Min and Max of Tensors
03:17 27 Reshaping, Viewing and Stacking Tensors
13:41 28 Squeezing, Unsqueezing and Permuting Tensors
11:56 29 Selecting Data From Tensors (Indexing)
09:32 30 PyTorch Tensors and NumPy
09:09 31 PyTorch Reproducibility (Taking the Random Out of Random)
10:47 32 Different Ways of Accessing a GPU in PyTorch
11:51 33 Setting up Device Agnostic Code and Putting Tensors On and Off the GPU
07:44 34 PyTorch Fundamentals: Exercises and Extra-Curriculum
04:50 35 Introduction and Where You Can Get Help
02:46 36 Getting Setup and What We Are Covering
07:15 37 Creating a Simple Dataset Using the Linear Regression Formula
09:42 38 Splitting Our Data Into Training and Test Sets
08:21 39 Building a function to Visualize Our Data
07:46 40 Creating Our First PyTorch Model for Linear Regression
14:10 41 Breaking Down What's Happening in Our PyTorch Linear regression Model
06:11 42 Discussing Some of the Most Important PyTorch Model Building Classes
06:27 43 Checking Out the Internals of Our PyTorch Model
09:51 44 Making Predictions With Our Random Model Using Inference Mode
11:13 45 Training a Model Intuition (The Things We Need)
08:15 46 Setting Up an Optimizer and a Loss Function
12:52 47 PyTorch Training Loop Steps and Intuition
13:54 48 Writing Code for a PyTorch Training Loop
08:47 49 Reviewing the Steps in a Training Loop Step by Step
14:58 50 Running Our Training Loop Epoch by Epoch and Seeing What Happens
09:26 51 Writing Testing Loop Code and Discussing What's Happening Step by Step
11:38 52 Reviewing What Happens in a Testing Loop Step by Step
14:43 53 Writing Code to Save a PyTorch Model
13:46 54 Writing Code to Load a PyTorch Model
08:45 55 Setting Up to Practice Everything We Have Done Using Device-Agnostic Code
06:03 56 Putting Everything Together (Part 1): Data
06:09 57 Putting Everything Together (Part 2): Building a Model
10:08 58 Putting Everything Together (Part 3): Training a Model
12:41 59 Putting Everything Together (Part 4): Making Predictions With a Trained Model
05:18 60 Putting Everything Together (Part 5): Saving and Loading a Trained Model
09:11 61 Exercise: Imposter Syndrome
02:57 62 PyTorch Workflow: Exercises and Extra-Curriculum
03:58 63 Introduction to Machine Learning Classification With PyTorch
09:42 64 Classification Problem Example: Input and Output Shapes
09:08 65 Typical Architecture of a Classification Neural Network (Overview)
06:32 66 Making a Toy Classification Dataset
12:19 67 Turning Our Data into Tensors and Making a Training and Test Split
11:56 68 Laying Out Steps for Modelling and Setting Up Device-Agnostic Code
04:20 69 Coding a Small Neural Network to Handle Our Classification Data
10:58 70 Making Our Neural Network Visual
06:58 71 Recreating and Exploring the Insides of Our Model Using nn.Sequential
13:18 72 Setting Up a Loss Function Optimizer and Evaluation Function for Our Classification Network
14:51 73 Going from Model Logits to Prediction Probabilities to Prediction Labels
16:08 74 Coding a Training and Testing Optimization Loop for Our Classification Model
15:27 75 Writing Code to Download a Helper Function to Visualize Our Models Predictions
14:14 76 Discussing Options to Improve a Model
08:03 77 Creating a New Model with More Layers and Hidden Units
09:07 78 Writing Training and Testing Code to See if Our New and Upgraded Model Performs Better
12:46 79 Creating a Straight Line Dataset to See if Our Model is Learning Anything
08:08 80 Building and Training a Model to Fit on Straight Line Data
10:02 81 Evaluating Our Models Predictions on Straight Line Data
05:24 82 Introducing the Missing Piece for Our Classification Model Non-Linearity
10:01 83 Building Our First Neural Network with Non-Linearity
10:26 84 Writing Training and Testing Code for Our First Non-Linear Model
15:13 85 Making Predictions with and Evaluating Our First Non-Linear Model
05:48 86 Replicating Non-Linear Activation Functions with Pure PyTorch
09:35 87 Putting It All Together (Part 1): Building a Multiclass Dataset
11:25 88 Creating a Multi-Class Classification Model with PyTorch
12:28 89 Setting Up a Loss Function and Optimizer for Our Multi-Class Model
06:41 90 Going from Logits to Prediction Probabilities to Prediction Labels with a Multi-Class Model
11:03 91 Training a Multi-Class Classification Model and Troubleshooting Code on the Fly
16:18 92 Making Predictions with and Evaluating Our Multi-Class Classification Model
08:00 93 Discussing a Few More Classification Metrics
09:18 94 PyTorch Classification: Exercises and Extra-Curriculum
02:59 95 What Is a Computer Vision Problem and What We Are Going to Cover
11:48 96 Computer Vision Input and Output Shapes
10:09 97 What Is a Convolutional Neural Network (CNN)
05:03 98 Discussing and Importing the Base Computer Vision Libraries in PyTorch
09:20 99 Getting a Computer Vision Dataset and Checking Out Its- Input and Output Shapes
14:31 100 Visualizing Random Samples of Data
09:52 101 DataLoader Overview Understanding Mini-Batch
07:18 102 Turning Our Datasets Into DataLoaders
12:24 103 Model 0: Creating a Baseline Model with Two Linear Layers
14:39 104 Creating a Loss Function: an Optimizer for Model 0
10:30 105 Creating a Function to Time Our Modelling Code
05:35 106 Writing Training and Testing Loops for Our Batched Data
21:26 107 Writing an Evaluation Function to Get Our Models Results
12:59 108 Setup Device-Agnostic Code for Running Experiments on the GPU
03:47 109 Model 1: Creating a Model with Non-Linear Functions
09:04 110 Mode 1: Creating a Loss Function and Optimizer
03:05 111 Turing Our Training Loop into a Function
08:29 112 Turing Our Testing Loop into a Function
06:36 113 Training and Testing Model 1 with Our Training and Testing Functions
11:53 114 Getting a Results Dictionary for Model 1
04:09 115 Model 2: Convolutional Neural Networks High Level Overview
08:25 116 Model 2: Coding Our First Convolutional Neural Network with PyTorch
19:49 117 Model 2: Breaking Down Conv2D Step by Step
15:00 118 Model 2: Breaking Down MaxPool2D Step by Step
15:49 119 Mode 2: Using a Trick to Find the Input and Output Shapes of Each of Our Layers
13:46 120 Model 2: Setting Up a Loss Function and Optimizer
02:39 121 Model 2: Training Our First CNN and Evaluating Its Results
07:55 122 Comparing the Results of Our Modelling Experiments
07:24 123 Making Predictions on Random Test Samples with the Best Trained Model
11:40 124 Plotting Our Best Model Predictions on Random Test Samples and Evaluating Them
08:11 125 Making Predictions Across the Whole Test Dataset and Importing Libraries to Plot a Confusion Matrix
15:21 126 Evaluating Our Best Models Predictions with a Confusion Matrix
06:55 127 Saving and Loading Our Best Performing Model
11:28 128 Recapping What We Have Covered Plus Exercises and Extra-Curriculum
06:02 129 What Is a Custom Dataset and What We Are Going to Cover
09:54 130 Importing PyTorch and Setting Up Device-Agnostic Code
05:55 131 Downloading a Custom Dataset of Pizza, Steak and Sushi Images
14:05 132 Becoming One With the Data (Part 1): Exploring the Data Format
08:42 133 Becoming One With the Data (Part 2): Visualizing a Random Image
11:41 134 Becoming One With the Data (Part 3): Visualizing a Random Image with Matplotlib
04:48 135 Transforming Data (Part 1): Turning Images Into Tensors
08:54 136 Transforming Data (Part 2): Visualizing Transformed Images
11:31 137 Loading All of Our Images and Turning Them Into Tensors With ImageFolder
09:19 138 Visualizing a Loaded Image From the Train Dataset
07:19 139 Turning Our Image Datasets into PyTorch DataLoaders
09:04 140 Creating a Custom Dataset Class in PyTorch High Level Overview
08:01 141 Creating a Helper Function to Get Class Names From a Directory
09:07 142 Writing a PyTorch Custom Dataset Class from Scratch to Load Our Images
17:47 143 Compare Our Custom Dataset Class to the Original ImageFolder Class
07:14 144 Writing a Helper Function to Visualize Random Images from Our Custom Dataset
14:19 145 Turning Our Custom Datasets Into DataLoaders
07:00 146 Exploring State of the Art Data Augmentation With Torchvision Transforms
14:24 147 Building a Baseline Model (Part 1): Loading and Transforming Data
08:16 148 Building a Baseline Model (Part 2): Replicating Tiny VGG from Scratch
11:25 149 Building a Baseline Model (Part 3): Doing a Forward Pass to Test Our Model Shapes
08:10 150 Using the Torchinfo Package to Get a Summary of Our Model
06:39 151 Creating Training and Testing loop Functions
13:04 152 Creating a Train Function to Train and Evaluate Our Models
10:15 153 Training and Evaluating Model 0 With Our Training Functions
09:54 154 Plotting the Loss Curves of Model 0
09:03 155 Discussing the Balance Between Overfitting and Underfitting and How to Deal With Each
14:14 156 Creating Augmented Training Datasets and DataLoaders for Model 1
11:04 157 Constructing and Training Model 1
07:11 158 Plotting the Loss Curves of Model 1
03:23 159 Plotting the Loss Curves of All of Our Models Against Each Other
10:56 160 Predicting on Custom Data (Part 1): Downloading an Image
05:33 161 Predicting on Custom Data (Part2): Loading In a Custom Image With PyTorch
07:01 162 Predicting on Custom Data (Part 3): Getting Our Custom Image Into the Right Format
14:08 163 Predicting on Custom Data (Part 4): Turning Our Models Raw Outputs Into Prediction Labels
04:25 164 Predicting on Custom Data (Part 5): Putting It All Together
12:48 165 Summary of What We Have Covered Plus Exercises and Extra-Curriculum
06:05 166 What Is Going Modular and What We Are Going to Cover
11:35 167 Going Modular Notebook (Part 1): Running It End to End
07:41 168 Downloading a Dataset
04:51 169 Writing the Outline for Our First Python Script to Setup the Data
13:51 170 Creating a Python Script to Create Our PyTorch DataLoaders
10:36 171 Turning Our Model Building Code into a Python Script
09:19 172 Turning Our Model Training Code into a Python Script
06:17 173 Turning Our Utility Function to Save a Model into a Python Script
06:08 174 Creating a Training Script to Train Our Model in One Line of Code
15:47 175 Going Modular: Summary, Exercises and Extra-Curriculum
06:00 176 Introduction: What is Transfer Learning and Why Use It
10:06 177 Where Can You Find Pretrained Models and What We Are Going to Cover
05:13 178 Installing the Latest Versions of Torch and Torchvision
08:06 179 Downloading Our Previously Written Code from Going Modular
06:42 180 Downloading Pizza, Steak, Sushi Image Data from Github
08:01 181 Turning Our Data into DataLoaders with Manually Created Transforms
14:41 182 Turning Our Data into DataLoaders with Automatic Created Transforms
13:07 183 Which Pretrained Model Should You Use
12:16 184 Setting Up a Pretrained Model with Torchvision
10:57 185 Different Kinds of Transfer Learning
07:12 186 Getting a Summary of the Different Layers of Our Model
06:50 187 Freezing the Base Layers of Our Model and Updating the Classifier Head
13:27 188 Training Our First Transfer Learning Feature Extractor Model
07:55 189 Plotting the Loss Curves of Our Transfer Learning Model
06:27 190 Outlining the Steps to Make Predictions on the Test Images
07:58 191 Creating a Function Predict On and Plot Images
10:01 192 Making and Plotting Predictions on Test Images
07:24 193 Making a Prediction on a Custom Image
06:22 194 Main Takeaways, Exercises and Extra Curriculum
03:22 195 What Is Experiment Tracking and Why Track Experiments
07:07 196 Getting Setup by Importing Torch Libraries and Going Modular Code
08:14 197 Creating a Function to Download Data
10:24 198 Turning Our Data into DataLoaders Using Manual Transforms
08:31 199 Turning Our Data into DataLoaders Using Automatic Transforms
07:48 200 Preparing a Pretrained Model for Our Own Problem
10:29 201 Setting Up a Way to Track a Single Model Experiment with TensorBoard
13:36 202 Training a Single Model and Saving the Results to TensorBoard
04:39 203 Exploring Our Single Models Results with TensorBoard
10:18 204 Creating a Function to Create SummaryWriter Instances
10:45 205 Adapting Our Train Function to Be Able to Track Multiple Experiments
04:58 206 What Experiments Should You Try
06:00 207 Discussing the Experiments We Are Going to Try
06:02 208 Downloading Datasets for Our Modelling Experiments
06:32 209 Turning Our Datasets into DataLoaders Ready for Experimentation
08:29 210 Creating Functions to Prepare Our Feature Extractor Models
15:55 211 Coding Out the Steps to Run a Series of Modelling Experiments
14:28 212 Running Eight Different Modelling Experiments in 5 Minutes
03:51 213 Viewing Our Modelling Experiments in TensorBoard
13:39 214 Loading In the Best Model and Making Predictions on Random Images from the Test Set
10:33 215 Making a Prediction on Our Own Custom Image with the Best Model
03:45 216 Main Takeaways, Exercises and Extra Curriculum
03:57 217 What Is a Machine Learning Research Paper?
07:35 218 Why Replicate a Machine Learning Research Paper?
03:14 219 Where Can You Find Machine Learning Research Papers and Code?
08:19 220 What We Are Going to Cover
08:22 221 Getting Setup for Coding in Google Colab
08:22 222 Downloading Data for Food Vision Mini
04:03 223 Turning Our Food Vision Mini Images into PyTorch DataLoaders
09:48 224 Visualizing a Single Image
03:46 225 Replicating a Vision Transformer - High Level Overview
09:54 226 Breaking Down Figure 1 of the ViT Paper
11:13 227 Breaking Down the Four Equations Overview and a Trick for Reading Papers
10:56 228 Breaking Down Equation 1
08:15 229 Breaking Down Equations 2 and 3
10:04 230 Breaking Down Equation 4
07:28 231 Breaking Down Table 1
11:06 232 Calculating the Input and Output Shape of the Embedding Layer by Hand
15:42 233 Turning a Single Image into Patches (Part 1: Patching the Top Row)
15:04 234 Turning a Single Image into Patches (Part 2: Patching the Entire Image)
12:34 235 Creating Patch Embeddings with a Convolutional Layer
13:34 236 Exploring the Outputs of Our Convolutional Patch Embedding Layer
12:55 237 Flattening Our Convolutional Feature Maps into a Sequence of Patch Embeddings
10:00 238 Visualizing a Single Sequence Vector of Patch Embeddings
05:04 239 Creating the Patch Embedding Layer with PyTorch
17:02 240 Creating the Class Token Embedding
13:25 241 Creating the Class Token Embedding - Less Birds
13:25 242 Creating the Position Embedding
11:26 243 Equation 1: Putting it All Together
13:26 244 Equation 2: Multihead Attention Overview
14:31 245 Equation 2: Layernorm Overview
09:04 246 Turning Equation 2 into Code
14:34 247 Checking the Inputs and Outputs of Equation
05:41 248 Equation 3: Replication Overview
09:12 249 Turning Equation 3 into Code
11:26 250 Transformer Encoder Overview
08:51 251 Combining Equation 2 and 3 to Create the Transformer Encoder
09:17 252 Creating a Transformer Encoder Layer with In-Built PyTorch Layer
15:55 253 Bringing Our Own Vision Transformer to Life - Part 1: Gathering the Pieces of the Puzzle
18:20 254 Bringing Our Own Vision Transformer to Life - Part 2: Putting Together the Forward Method
10:42 255 Getting a Visual Summary of Our Custom Vision Transformer
07:14 256 Creating a Loss Function and Optimizer from the ViT Paper
11:27 257 Training our Custom ViT on Food Vision Mini
04:30 258 Discussing what Our Training Setup Is Missing
09:09 259 Plotting a Loss Curve for Our ViT Model
06:14 260 Getting a Pretrained Vision Transformer from Torchvision and Setting it Up
14:38 261 Preparing Data to Be Used with a Pretrained ViT
05:54 262 Training a Pretrained ViT Feature Extractor Model for Food Vision Mini
07:16 263 Saving Our Pretrained ViT Model to File and Inspecting Its Size
05:14 264 Discussing the Trade-Offs Between Using a Larger Model for Deployments
03:47 265 Making Predictions on a Custom Image with Our Pretrained ViT
03:31 266 PyTorch Paper Replicating: Main Takeaways, Exercises and Extra-Curriculum
06:51 267 What is Machine Learning Model Deployment and Why Deploy a Machine Learning Model
09:36 268 Three Questions to Ask for Machine Learning Model Deployment
07:14 269 Where Is My Model Going to Go?
13:35 270 How Is My Model Going to Function?
08:00 271 Some Tools and Places to Deploy Machine Learning Models
05:50 272 What We Are Going to Cover
04:02 273 Getting Setup to Code
06:16 274 Downloading a Dataset for Food Vision Mini
03:24 275 Outlining Our Food Vision Mini Deployment Goals and Modelling Experiments
08:00 276 Creating an EffNetB2 Feature Extractor Model
09:46 277 Create a Function to Make an EffNetB2 Feature Extractor Model and Transforms
06:30 278 Creating DataLoaders for EffNetB2
03:32 279 Training Our EffNetB2 Feature Extractor and Inspecting the Loss Curves
09:16 280 Saving Our EffNetB2 Model to File
03:25 281 Getting the Size of Our EffNetB2 Model in Megabytes
05:52 282 Collecting Important Statistics and Performance Metrics for Our EffNetB2 Model
06:35 283 Creating a Vision Transformer Feature Extractor Model
07:52 284 Creating DataLoaders for Our ViT Feature Extractor Model
02:31 285 Training Our ViT Feature Extractor Model and Inspecting Its Loss Curves
06:20 286 Saving Our ViT Feature Extractor and Inspecting Its Size
05:09 287 Collecting Stats About Our ViT Feature Extractor
05:52 288 Outlining the Steps for Making and Timing Predictions for Our Models
11:16 289 Creating a Function to Make and Time Predictions with Our Models
16:21 290 Making and Timing Predictions with EffNetB2
10:44 291 Making and Timing Predictions with ViT
07:35 292 Comparing EffNetB2 and ViT Model Statistics
11:32 293 Visualizing the Performance vs Speed Trade-off
15:55 294 Gradio Overview and Installation
08:40 295 Gradio Function Outline
08:50 296 Creating a Predict Function to Map Our Food Vision Mini Inputs to Outputs
09:52 297 Creating a List of Examples to Pass to Our Gradio Demo
05:27 298 Bringing Food Vision Mini to Life in a Live Web Application
12:13 299 Getting Ready to Deploy Our App Hugging Face Spaces Overview
06:27 300 Outlining the File Structure of Our Deployed App
08:12 301 Creating a Food Vision Mini Demo Directory to House Our App Files
04:12 302 Creating an Examples Directory with Example Food Vision Mini Images
09:14 303 Writing Code to Move Our Saved EffNetB2 Model File
07:43 304 Turning Our EffNetB2 Model Creation Function Into a Python Script
04:02 305 Turning Our Food Vision Mini Demo App Into a Python Script
13:28 306 Creating a Requirements File for Our Food Vision Mini App
04:12 307 Downloading Our Food Vision Mini App Files from Google Colab
11:31 308 Uploading Our Food Vision Mini App to Hugging Face Spaces Programmatically
13:37 309 Running Food Vision Mini on Hugging Face Spaces and Trying it Out
07:45 310 Food Vision Big Project Outline
04:18 311 Preparing an EffNetB2 Feature Extractor Model for Food Vision Big
09:39 312 Downloading the Food 101 Dataset
07:46 313 Creating a Function to Split Our Food 101 Dataset into Smaller Portions
13:37 314 Turning Our Food 101 Datasets into DataLoaders
07:24 315 Training Food Vision Big: Our Biggest Model Yet!
20:16 316 Outlining the File Structure for Our Food Vision Big
05:49 317 Downloading an Example Image and Moving Our Food Vision Big Model File
03:34 318 Saving Food 101 Class Names to a Text File and Reading them Back In
06:57 319 Turning Our EffNetB2 Feature Extractor Creation Function into a Python Script
02:21 320 Creating an App Script for Our Food Vision Big Model Gradio Demo
10:42 321 Zipping and Downloading Our Food Vision Big App Files
03:46 322 Deploying Food Vision Big to Hugging Face Spaces
13:35 323 PyTorch Mode Deployment: Main Takeaways, Extra-Curriculum and Exercises
06:14 324 Introduction to PyTorch 2.0
06:02 325 What We Are Going to Cover and PyTorch 2 Reference Materials
01:22 326 Getting Started with PyTorch 2.0 in Google Colab
04:20 327 PyTorch 2.0 - 30 Second Intro
03:21 328 Getting Setup for PyTorch 2.0
02:23 329 Getting Info from Our GPUs and Seeing if They're Capable of Using PyTorch 2.0
06:50 330 Setting the Default Device in PyTorch 2.0
09:41 331 Discussing the Experiments We Are Going to Run for PyTorch 2.0
06:43 332 Creating a Function to Setup Our Model and Transforms
10:18 333 Discussing How to Get Better Relative Speedups for Training Models
08:24 334 Setting the Batch Size and Data Size Programmatically
07:16 335 Getting More Speedups with TensorFloat-32
09:54 336 Downloading the CIFAR10 Dataset
07:01 337 Creating Training and Test DataLoaders
07:39 338 Preparing Training and Testing Loops with Timing Steps
04:59 339 Experiment 1 - Single Run without Torch Compile
08:23 340 Experiment 2 - Single Run with Torch Compile
10:39 341 Comparing the Results of Experiments 1 and 2
11:20 342 Saving the Results of Experiments 1 and 2
04:40 343 Preparing Functions for Experiments 3 and 4
12:42 344 Experiment 3 - Training a Non-Compiled Model for Multiple Runs
12:45 345 Experiment 4 - Training a Compiled Model for Multiple Runs
09:58 346 Comparing the Results of Experiments 3 and 4
05:24 347 Potential Extensions and Resources to Learn More
05:51 348 Thank You!
01:18 
