Pytorch For Deep Learning In 2023: Zero To Mastery

Learn PyTorch. Become a Deep Learning Engineer. Get Hired.

What you'll learn
Everything from getting started with using PyTorch to building your own real-world models
Understand how to integrate Deep Learning into tools and applications
Build and deploy your own custom trained PyTorch neural network accessible to the public
Master deep learning and become a top candidate for recruiters seeking Deep Learning Engineers
The skills you need to become a Deep Learning Engineer and get hired with a chance of making US$100,000+ / year
Why PyTorch is a fantastic way to start working in machine learning
Create and utilize machine learning algorithms just like you would write a Python program
How to take data, build a ML algorithm to find patterns, and then use that algorithm as an AI to enhance your applications
To expand your Machine Learning and Deep Learning skills and toolkit
Requirements
A computer (Linux/Windows/Mac) with an internet connection is required
Basic Python knowledge is required
Previous Machine Learning knowledge is recommended, but not required (we provide sufficient supplementary resources to get you up to speed!)
Description
What is PyTorch and why should I learn it?PyTorch is a machine learning and deep learning framework written in Python.PyTorch enables you to craft new and use existing state-of-the-art deep learning algorithms like neural networks powering much of today’s Artificial Intelligence (AI) applications.Plus it's so hot right now, so there's lots of jobs available!PyTorch is used by companies like:Tesla to build the computer vision systems for their self-driving carsMeta to power the curation and understanding systems for their content timelinesApple to create computationally enhanced photography.Want to know what's even cooler?Much of the latest machine learning research is done and published using PyTorch code so knowing how it works means you’ll be at the cutting edge of this highly in-demand field.And you'll be learning PyTorch in good company.Graduates of Zero To Mastery are now working at Google, Tesla, Amazon, Apple, IBM, Uber, Meta, Shopify + other top tech companies at the forefront of machine learning and deep learning.This can be you.By enrolling today, you’ll also get to join our exclusive live online community classroom to learn alongside thousands of students, alumni, mentors, TAs and Instructors.Most importantly, you will be learning PyTorch from a professional machine learning engineer, with real-world experience, and who is one of the best teachers around!What will this PyTorch course be like?This PyTorch course is very hands-on and project based. You won't just be staring at your screen. We'll leave that for other PyTorch tutorials and courses.In this course you'll actually be:Running experimentsCompleting exercises to test your skillsBuilding real-world deep learning models and projects to mimic real life scenariosBy the end of it all, you'll have the skillset needed to identify and develop modern deep learning solutions that Big Tech companies encounter.⚠ Fair warning: this course is very comprehensive. But don't be intimidated, Daniel will teach you everything from scratch and step-by-step!Here's what you'll learn in this PyTorch course:1. PyTorch Fundamentals — We start with the barebone fundamentals, so even if you're a beginner you'll get up to speed.In machine learning, data gets represented as a tensor (a collection of numbers). Learning how to craft tensors with PyTorch is paramount to building machine learning algorithms. In PyTorch Fundamentals we cover the PyTorch tensor datatype in-depth.2. PyTorch Workflow — Okay, you’ve got the fundamentals down, and you've made some tensors to represent data, but what now?With PyTorch Workflow you’ll learn the steps to go from data -> tensors -> trained neural network model. You’ll see and use these steps wherever you encounter PyTorch code as well as for the rest of the course.3. PyTorch Neural Network Classification — Classification is one of the most common machine learning problems.Is something one thing or another?Is an email spam or not spam?Is credit card transaction fraud or not fraud?With PyTorch Neural Network Classification you’ll learn how to code a neural network classification model using PyTorch so that you can classify things and answer these questions.4. PyTorch Computer Vision — Neural networks have changed the game of computer vision forever. And now PyTorch drives many of the latest advancements in computer vision algorithms.For example, Tesla use PyTorch to build the computer vision algorithms for their self-driving software.With PyTorch Computer Vision you’ll build a PyTorch neural network capable of seeing patterns in images of and classifying them into different categories.5. PyTorch Custom Datasets — The magic of machine learning is building algorithms to find patterns in your own custom data. There are plenty of existing datasets out there, but how do you load your own custom dataset into PyTorch?This is exactly what you'll learn with the PyTorch Custom Datasets section of this course.You’ll learn how to load an image dataset for FoodVision Mini: a PyTorch computer vision model capable of classifying images of pizza, steak and sushi (am I making you hungry to learn yet?!).We’ll be building upon FoodVision Mini for the rest of the course.6. PyTorch Going Modular — The whole point of PyTorch is to be able to write Pythonic machine learning code.There are two main tools for writing machine learning code with Python:A Jupyter/Google Colab notebook (great for experimenting)Python scripts (great for reproducibility and modularity)In the PyTorch Going Modular section of this course, you’ll learn how to take your most useful Jupyter/Google Colab Notebook code and turn it reusable Python scripts. This is often how you’ll find PyTorch code shared in the wild.7. PyTorch Transfer Learning — What if you could take what one model has learned and leverage it for your own problems? That’s what PyTorch Transfer Learning covers.You’ll learn about the power of transfer learning and how it enables you to take a machine learning model trained on millions of images, modify it slightly, and enhance the performance of FoodVision Mini, saving you time and resources.8. PyTorch Experiment Tracking — Now we're going to start cooking with heat by starting Part 1 of our Milestone Project of the course!At this point you’ll have built plenty of PyTorch models. But how do you keep track of which model performs the best?That’s where PyTorch Experiment Tracking comes in.Following the machine learning practitioner’s motto of experiment, experiment, experiment! you’ll setup a system to keep track of various FoodVision Mini experiment results and then compare them to find the best.9. PyTorch Paper Replicating — The field of machine learning advances quickly. New research papers get published every day. Being able to read and understand these papers takes time and practice.So that’s what PyTorch Paper Replicating covers. You’ll learn how to go through a machine learning research paper and replicate it with PyTorch code.At this point you'll also undertake Part 2 of our Milestone Project, where you’ll replicate the groundbreaking Vision Transformer architecture!10. PyTorch Model Deployment — By this stage your FoodVision model will be performing quite well. But up until now, you’ve been the only one with access to it.How do you get your PyTorch models in the hands of others?That’s what PyTorch Model Deployment covers. In Part 3 of your Milestone Project, you’ll learn how to take the best performing FoodVision Mini model and deploy it to the web so other people can access it and try it out with their own food images.What's the bottom line?Machine learning's growth and adoption is exploding, and deep learning is how you take your machine learning knowledge to the next level. More and more job openings are looking for this specialized knowledge.Companies like Tesla, Microsoft, OpenAI, Meta (Facebook + Instagram), Airbnb and many others are currently powered by PyTorch.And this is the most comprehensive online bootcamp to learn PyTorch and kickstart your career as a Deep Learning Engineer.So why wait? Advance your career and earn a higher salary by mastering PyTorch and adding deep learning to your toolkit?

Overview

Section 1: Introduction

Lecture 1 PyTorch for Deep Learning

Lecture 2 Course Welcome and What Is Deep Learning

Lecture 3 Join Our Online Classroom!

Lecture 4 Exercise: Meet Your Classmates + Instructor

Lecture 5 Course Companion Book + Code + More

Lecture 6 Machine Learning + Python Monthly Newsletters

Section 2: PyTorch Fundamentals

Lecture 7 Why Use Machine Learning or Deep Learning

Lecture 8 The Number 1 Rule of Machine Learning and What Is Deep Learning Good For

Lecture 9 Machine Learning vs. Deep Learning

Lecture 10 Anatomy of Neural Networks

Lecture 11 Different Types of Learning Paradigms

Lecture 12 What Can Deep Learning Be Used For

Lecture 13 What Is and Why PyTorch

Lecture 14 What Are Tensors

Lecture 15 What We Are Going To Cover With PyTorch

Lecture 16 How To and How Not To Approach This Course

Lecture 17 Important Resources For This Course

Lecture 18 Getting Setup to Write PyTorch Code

Lecture 19 Introduction to PyTorch Tensors

Lecture 20 Creating Random Tensors in PyTorch

Lecture 21 Creating Tensors With Zeros and Ones in PyTorch

Lecture 22 Creating a Tensor Range and Tensors Like Other Tensors

Lecture 23 Dealing With Tensor Data Types

Lecture 24 Getting Tensor Attributes

Lecture 25 Manipulating Tensors (Tensor Operations)

Lecture 26 Matrix Multiplication (Part 1)

Lecture 27 Matrix Multiplication (Part 2): The Two Main Rules of Matrix Multiplication

Lecture 28 Matrix Multiplication (Part 3): Dealing With Tensor Shape Errors

Lecture 29 Finding the Min Max Mean and Sum of Tensors (Tensor Aggregation)

Lecture 30 Finding The Positional Min and Max of Tensors

Lecture 31 Reshaping, Viewing and Stacking Tensors

Lecture 32 Squeezing, Unsqueezing and Permuting Tensors

Lecture 33 Selecting Data From Tensors (Indexing)

Lecture 34 PyTorch Tensors and NumPy

Lecture 35 PyTorch Reproducibility (Taking the Random Out of Random)

Lecture 36 Different Ways of Accessing a GPU in PyTorch

Lecture 37 Setting up Device-Agnostic Code and Putting Tensors On and Off the GPU

Lecture 38 PyTorch Fundamentals: Exercises and Extra-Curriculum

Lecture 39 Unlimited Updates

Section 3: PyTorch Workflow

Lecture 40 Introduction and Where You Can Get Help

Lecture 41 Getting Setup and What We Are Covering

Lecture 42 Creating a Simple Dataset Using the Linear Regression Formula

Lecture 43 Splitting Our Data Into Training and Test Sets

Lecture 44 Building a function to Visualize Our Data

Lecture 45 Creating Our First PyTorch Model for Linear Regression

Lecture 46 Breaking Down What's Happening in Our PyTorch Linear regression Model

Lecture 47 Discussing Some of the Most Important PyTorch Model Building Classes

Lecture 48 Checking Out the Internals of Our PyTorch Model

Lecture 49 Making Predictions With Our Random Model Using Inference Mode

Lecture 50 Training a Model Intuition (The Things We Need)

Lecture 51 Setting Up an Optimizer and a Loss Function

Lecture 52 PyTorch Training Loop Steps and Intuition

Lecture 53 Writing Code for a PyTorch Training Loop

Lecture 54 Reviewing the Steps in a Training Loop Step by Step

Lecture 55 Running Our Training Loop Epoch by Epoch and Seeing What Happens

Lecture 56 Writing Testing Loop Code and Discussing What's Happening Step by Step

Lecture 57 Reviewing What Happens in a Testing Loop Step by Step

Lecture 58 Writing Code to Save a PyTorch Model

Lecture 59 Writing Code to Load a PyTorch Model

Lecture 60 Setting Up to Practice Everything We Have Done Using Device Agnostic code

Lecture 61 Putting Everything Together (Part 1): Data

Lecture 62 Putting Everything Together (Part 2): Building a Model

Lecture 63 Putting Everything Together (Part 3): Training a Model

Lecture 64 Putting Everything Together (Part 4): Making Predictions With a Trained Model

Lecture 65 Putting Everything Together (Part 5): Saving and Loading a Trained Model

Lecture 66 Exercise: Imposter Syndrome

Lecture 67 PyTorch Workflow: Exercises and Extra-Curriculum

Section 4: PyTorch Neural Network Classification

Lecture 68 Introduction to Machine Learning Classification With PyTorch

Lecture 69 Classification Problem Example: Input and Output Shapes

Lecture 70 Typical Architecture of a Classification Neural Network (Overview)

Lecture 71 Making a Toy Classification Dataset

Lecture 72 Turning Our Data into Tensors and Making a Training and Test Split

Lecture 73 Laying Out Steps for Modelling and Setting Up Device-Agnostic Code

Lecture 74 Coding a Small Neural Network to Handle Our Classification Data

Lecture 75 Making Our Neural Network Visual

Lecture 76 Recreating and Exploring the Insides of Our Model Using nn.Sequential

Lecture 77 Loss Function Optimizer and Evaluation Function for Our Classification Network

Lecture 78 Going from Model Logits to Prediction Probabilities to Prediction Labels

Lecture 79 Coding a Training and Testing Optimization Loop for Our Classification Model

Lecture 80 Writing Code to Download a Helper Function to Visualize Our Models Predictions

Lecture 81 Discussing Options to Improve a Model

Lecture 82 Creating a New Model with More Layers and Hidden Units

Lecture 83 Writing Training and Testing Code to See if Our Upgraded Model Performs Better

Lecture 84 Creating a Straight Line Dataset to See if Our Model is Learning Anything

Lecture 85 Building and Training a Model to Fit on Straight Line Data

Lecture 86 Evaluating Our Models Predictions on Straight Line Data

Lecture 87 Introducing the Missing Piece for Our Classification Model Non-Linearity

Lecture 88 Building Our First Neural Network with Non-Linearity

Lecture 89 Writing Training and Testing Code for Our First Non-Linear Model

Lecture 90 Making Predictions with and Evaluating Our First Non-Linear Model

Lecture 91 Replicating Non-Linear Activation Functions with Pure PyTorch

Lecture 92 Putting It All Together (Part 1): Building a Multiclass Dataset

Lecture 93 Creating a Multi-Class Classification Model with PyTorch

Lecture 94 Setting Up a Loss Function and Optimizer for Our Multi-Class Model

Lecture 95 Logits to Prediction Probabilities to Prediction Labels with a Multi-Class Model

Lecture 96 Training a Multi-Class Classification Model and Troubleshooting Code on the Fly

Lecture 97 Making Predictions with and Evaluating Our Multi-Class Classification Model

Lecture 98 Discussing a Few More Classification Metrics

Lecture 99 PyTorch Classification: Exercises and Extra-Curriculum

Section 5: PyTorch Computer Vision

Lecture 100 What Is a Computer Vision Problem and What We Are Going to Cover

Lecture 101 Computer Vision Input and Output Shapes

Lecture 102 What Is a Convolutional Neural Network (CNN)

Lecture 103 Discussing and Importing the Base Computer Vision Libraries in PyTorch

Lecture 104 Getting a Computer Vision Dataset and Checking Out Its- Input and Output Shapes

Lecture 105 Visualizing Random Samples of Data

Lecture 106 DataLoader Overview Understanding Mini-Batches

Lecture 107 Turning Our Datasets Into DataLoaders

Lecture 108 Model 0: Creating a Baseline Model with Two Linear Layers

Lecture 109 Creating a Loss Function: an Optimizer for Model 0

Lecture 110 Creating a Function to Time Our Modelling Code

Lecture 111 Writing Training and Testing Loops for Our Batched Data

Lecture 112 Writing an Evaluation Function to Get Our Models Results

Lecture 113 Setup Device-Agnostic Code for Running Experiments on the GPU

Lecture 114 Model 1: Creating a Model with Non-Linear Functions

Lecture 115 Mode 1: Creating a Loss Function and Optimizer

Lecture 116 Turing Our Training Loop into a Function

Lecture 117 Turing Our Testing Loop into a Function

Lecture 118 Training and Testing Model 1 with Our Training and Testing Functions

Lecture 119 Getting a Results Dictionary for Model 1

Lecture 120 Model 2: Convolutional Neural Networks High Level Overview

Lecture 121 Model 2: Coding Our First Convolutional Neural Network with PyTorch

Lecture 122 Model 2: Breaking Down Conv2D Step by Step

Lecture 123 Model 2: Breaking Down MaxPool2D Step by Step

Lecture 124 Mode 2: Using a Trick to Find the Input and Output Shapes of Each of Our Layers

Lecture 125 Model 2: Setting Up a Loss Function and Optimizer

Lecture 126 Model 2: Training Our First CNN and Evaluating Its Results

Lecture 127 Comparing the Results of Our Modelling Experiments

Lecture 128 Making Predictions on Random Test Samples with the Best Trained Model

Lecture 129 Plotting Our Best Model Predictions on Random Test Samples and Evaluating Them

Lecture 130 Making Predictions and Importing Libraries to Plot a Confusion Matrix

Lecture 131 Evaluating Our Best Models Predictions with a Confusion Matrix

Lecture 132 Saving and Loading Our Best Performing Model

Lecture 133 Recapping What We Have Covered Plus Exercises and Extra-Curriculum

Section 6: PyTorch Custom Datasets

Lecture 134 What Is a Custom Dataset and What We Are Going to Cover

Lecture 135 Importing PyTorch and Setting Up Device Agnostic Code

Lecture 136 Downloading a Custom Dataset of Pizza, Steak and Sushi Images

Lecture 137 Becoming One With the Data (Part 1): Exploring the Data Format

Lecture 138 Becoming One With the Data (Part 2): Visualizing a Random Image

Lecture 139 Becoming One With the Data (Part 3): Visualizing a Random Image with Matplotlib

Lecture 140 Transforming Data (Part 1): Turning Images Into Tensors

Lecture 141 Transforming Data (Part 2): Visualizing Transformed Images

Lecture 142 Loading All of Our Images and Turning Them Into Tensors With ImageFolder

Lecture 143 Visualizing a Loaded Image From the Train Dataset

Lecture 144 Turning Our Image Datasets into PyTorch Dataloaders

Lecture 145 Creating a Custom Dataset Class in PyTorch High Level Overview

Lecture 146 Creating a Helper Function to Get Class Names From a Directory

Lecture 147 Writing a PyTorch Custom Dataset Class from Scratch to Load Our Images

Lecture 148 Compare Our Custom Dataset Class. to the Original Imagefolder Class

Lecture 149 Writing a Helper Function to Visualize Random Images from Our Custom Dataset

Lecture 150 Turning Our Custom Datasets Into DataLoaders

Lecture 151 Exploring State of the Art Data Augmentation With Torchvision Transforms

Lecture 152 Building a Baseline Model (Part 1): Loading and Transforming Data

Lecture 153 Building a Baseline Model (Part 2): Replicating Tiny VGG from Scratch

Lecture 154 Building a Baseline Model (Part 3):Doing a Forward Pass to Test Our Model Shapes

Lecture 155 Using the Torchinfo Package to Get a Summary of Our Model

Lecture 156 Creating Training and Testing loop Functions

Lecture 157 Creating a Train Function to Train and Evaluate Our Models

Lecture 158 Training and Evaluating Model 0 With Our Training Functions

Lecture 159 Plotting the Loss Curves of Model 0

Lecture 160 The Balance Between Overfitting and Underfitting and How to Deal With Each

Lecture 161 Creating Augmented Training Datasets and DataLoaders for Model 1

Lecture 162 Constructing and Training Model 1

Lecture 163 Plotting the Loss Curves of Model 1

Lecture 164 Plotting the Loss Curves of All of Our Models Against Each Other

Lecture 165 Predicting on Custom Data (Part 1): Downloading an Image

Lecture 166 Predicting on Custom Data (Part 2): Loading In a Custom Image With PyTorch

Lecture 167 Predicting on Custom Data (Part3):Getting Our Custom Image Into the Right Format

Lecture 168 Predicting on Custom Data (Part4):Turning Our Models Raw Outputs Into Prediction

Lecture 169 Predicting on Custom Data (Part 5): Putting It All Together

Lecture 170 Summary of What We Have Covered Plus Exercises and Extra-Curriculum

Section 7: PyTorch Going Modular

Lecture 171 What Is Going Modular and What We Are Going to Cover

Lecture 172 Going Modular Notebook (Part 1): Running It End to End

Lecture 173 Downloading a Dataset

Lecture 174 Writing the Outline for Our First Python Script to Setup the Data

Lecture 175 Creating a Python Script to Create Our PyTorch DataLoaders

Lecture 176 Turning Our Model Building Code into a Python Script

Lecture 177 Turning Our Model Training Code into a Python Script

Lecture 178 Turning Our Utility Function to Save a Model into a Python Script

Lecture 179 Creating a Training Script to Train Our Model in One Line of Code

Lecture 180 Going Modular: Summary, Exercises and Extra-Curriculum

Section 8: PyTorch Transfer Learning

Lecture 181 Introduction: What is Transfer Learning and Why Use It

Lecture 182 Where Can You Find Pretrained Models and What We Are Going to Cover

Lecture 183 Installing the Latest Versions of Torch and Torchvision

Lecture 184 Downloading Our Previously Written Code from Going Modular

Lecture 185 Downloading Pizza, Steak, Sushi Image Data from Github

Lecture 186 Turning Our Data into DataLoaders with Manually Created Transforms

Lecture 187 Turning Our Data into DataLoaders with Automatic Created Transforms

Lecture 188 Which Pretrained Model Should You Use

Lecture 189 Setting Up a Pretrained Model with Torchvision

Lecture 190 Different Kinds of Transfer Learning

Lecture 191 Getting a Summary of the Different Layers of Our Model

Lecture 192 Freezing the Base Layers of Our Model and Updating the Classifier Head

Lecture 193 Training Our First Transfer Learning Feature Extractor Model

Lecture 194 Plotting the Loss curves of Our Transfer Learning Model

Lecture 195 Outlining the Steps to Make Predictions on the Test Images

Lecture 196 Creating a Function Predict On and Plot Images

Lecture 197 Making and Plotting Predictions on Test Images

Lecture 198 Making a Prediction on a Custom Image

Lecture 199 Main Takeaways, Exercises and Extra- Curriculum

Section 9: PyTorch Experiment Tracking

Lecture 200 What Is Experiment Tracking and Why Track Experiments

Lecture 201 Getting Setup by Importing Torch Libraries and Going Modular Code

Lecture 202 Creating a Function to Download Data

Lecture 203 Turning Our Data into DataLoaders Using Manual Transforms

Lecture 204 Turning Our Data into DataLoaders Using Automatic Transforms

Lecture 205 Preparing a Pretrained Model for Our Own Problem

Lecture 206 Setting Up a Way to Track a Single Model Experiment with TensorBoard

Lecture 207 Training a Single Model and Saving the Results to TensorBoard

Lecture 208 Exploring Our Single Models Results with TensorBoard

Lecture 209 Creating a Function to Create SummaryWriter Instances

Lecture 210 Adapting Our Train Function to Be Able to Track Multiple Experiments

Lecture 211 What Experiments Should You Try

Lecture 212 Discussing the Experiments We Are Going to Try

Lecture 213 Downloading Datasets for Our Modelling Experiments

Lecture 214 Turning Our Datasets into DataLoaders Ready for Experimentation

Lecture 215 Creating Functions to Prepare Our Feature Extractor Models

Lecture 216 Coding Out the Steps to Run a Series of Modelling Experiments

Lecture 217 Running Eight Different Modelling Experiments in 5 Minutes

Lecture 218 Viewing Our Modelling Experiments in TensorBoard

Lecture 219 Loading the Best Model and Making Predictions on Random Images from the Test Set

Lecture 220 Making a Prediction on Our Own Custom Image with the Best Model

Lecture 221 Main Takeaways, Exercises and Extra- Curriculum

Section 10: PyTorch Paper Replicating

Lecture 222 What Is a Machine Learning Research Paper?

Lecture 223 Why Replicate a Machine Learning Research Paper?

Lecture 224 Where Can You Find Machine Learning Research Papers and Code?

Lecture 225 What We Are Going to Cover

Lecture 226 Getting Setup for Coding in Google Colab

Lecture 227 Downloading Data for Food Vision Mini

Lecture 228 Turning Our Food Vision Mini Images into PyTorch DataLoaders

Lecture 229 Visualizing a Single Image

Lecture 230 Replicating a Vision Transformer - High Level Overview

Lecture 231 Breaking Down Figure 1 of the ViT Paper

Lecture 232 Breaking Down the Four Equations Overview and a Trick for Reading Papers

Lecture 233 Breaking Down Equation 1

Lecture 234 Breaking Down Equation 2 and 3

Lecture 235 Breaking Down Equation 4

Lecture 236 Breaking Down Table 1

Lecture 237 Calculating the Input and Output Shape of the Embedding Layer by Hand

Lecture 238 Turning a Single Image into Patches (Part 1: Patching the Top Row)

Lecture 239 Turning a Single Image into Patches (Part 2: Patching the Entire Image)

Lecture 240 Creating Patch Embeddings with a Convolutional Layer

Lecture 241 Exploring the Outputs of Our Convolutional Patch Embedding Layer

Lecture 242 Flattening Our Convolutional Feature Maps into a Sequence of Patch Embeddings

Lecture 243 Visualizing a Single Sequence Vector of Patch Embeddings

Lecture 244 Creating the Patch Embedding Layer with PyTorch

Lecture 245 Creating the Class Token Embedding

Lecture 246 Creating the Class Token Embedding - Less Birds

Lecture 247 Creating the Position Embedding

Lecture 248 Equation 1: Putting it All Together

Lecture 249 Equation 2: Multihead Attention Overview

Lecture 250 Equation 2: Layernorm Overview

Lecture 251 Turning Equation 2 into Code

Lecture 252 Checking the Inputs and Outputs of Equation

Lecture 253 Equation 3: Replication Overview

Lecture 254 Turning Equation 3 into Code

Lecture 255 Transformer Encoder Overview

Lecture 256 Combining equation 2 and 3 to Create the Transformer Encoder

Lecture 257 Creating a Transformer Encoder Layer with In-Built PyTorch Layer

Lecture 258 Bringing Our Own Vision Transformer to Life - Part 1: Gathering the Pieces

Lecture 259 Bringing Our Own Vision Transformer to Life - Part 2: The Forward Method

Lecture 260 Getting a Visual Summary of Our Custom Vision Transformer

Lecture 261 Creating a Loss Function and Optimizer from the ViT Paper

Lecture 262 Training our Custom ViT on Food Vision Mini

Lecture 263 Discussing what Our Training Setup Is Missing

Lecture 264 Plotting a Loss Curve for Our ViT Model

Lecture 265 Getting a Pretrained Vision Transformer from Torchvision and Setting it Up

Lecture 266 Preparing Data to Be Used with a Pretrained ViT

Lecture 267 Training a Pretrained ViT Feature Extractor Model for Food Vision Mini

Lecture 268 Saving Our Pretrained ViT Model to File and Inspecting Its Size

Lecture 269 Discussing the Trade-Offs Between Using a Larger Model for Deployments

Lecture 270 Making Predictions on a Custom Image with Our Pretrained ViT

Lecture 271 PyTorch Paper Replicating: Main Takeaways, Exercises and Extra-Curriculum

Section 11: PyTorch Model Deployment

Lecture 272 What is Machine Learning Model Deployment - Why Deploy a Machine Learning Model

Lecture 273 Three Questions to Ask for Machine Learning Model Deployment

Lecture 274 Where Is My Model Going to Go?

Lecture 275 How Is My Model Going to Function?

Lecture 276 Some Tools and Places to Deploy Machine Learning Models

Lecture 277 What We Are Going to Cover

Lecture 278 Getting Setup to Code

Lecture 279 Downloading a Dataset for Food Vision Mini

Lecture 280 Outlining Our Food Vision Mini Deployment Goals and Modelling Experiments

Lecture 281 Creating an EffNetB2 Feature Extractor Model

Lecture 282 Create a Function to Make an EffNetB2 Feature Extractor Model and Transforms

Lecture 283 Creating DataLoaders for EffNetB2

Lecture 284 Training Our EffNetB2 Feature Extractor and Inspecting the Loss Curves

Lecture 285 Saving Our EffNetB2 Model to File

Lecture 286 Getting the Size of Our EffNetB2 Model in Megabytes

Lecture 287 Collecting Important Statistics and Performance Metrics for Our EffNetB2 Model

Lecture 288 Creating a Vision Transformer Feature Extractor Model

Lecture 289 Creating DataLoaders for Our ViT Feature Extractor Model

Lecture 290 Training Our ViT Feature Extractor Model and Inspecting Its Loss Curves

Lecture 291 Saving Our ViT Feature Extractor and Inspecting Its Size

Lecture 292 Collecting Stats About Our-ViT Feature Extractor

Lecture 293 Outlining the Steps for Making and Timing Predictions for Our Models

Lecture 294 Creating a Function to Make and Time Predictions with Our Models

Lecture 295 Making and Timing Predictions with EffNetB2

Lecture 296 Making and Timing Predictions with ViT

Lecture 297 Comparing EffNetB2 and ViT Model Statistics

Lecture 298 Visualizing the Performance vs Speed Trade-off

Lecture 299 Gradio Overview and Installation

Lecture 300 Gradio Function Outline

Lecture 301 Creating a Predict Function to Map Our Food Vision Mini Inputs to Outputs

Lecture 302 Creating a List of Examples to Pass to Our Gradio Demo

Lecture 303 Bringing Food Vision Mini to Life in a Live Web Application

Lecture 304 Getting Ready to Deploy Our App Hugging Face Spaces Overview

Lecture 305 Outlining the File Structure of Our Deployed App

Lecture 306 Creating a Food Vision Mini Demo Directory to House Our App Files

Lecture 307 Creating an Examples Directory with Example Food Vision Mini Images

Lecture 308 Writing Code to Move Our Saved EffNetB2 Model File

Lecture 309 Turning Our EffNetB2 Model Creation Function Into a Python Script

Lecture 310 Turning Our Food Vision Mini Demo App Into a Python Script

Lecture 311 Creating a Requirements File for Our Food Vision Mini App

Lecture 312 Downloading Our Food Vision Mini App Files from Google Colab

Lecture 313 Uploading Our Food Vision Mini App to Hugging Face Spaces Programmatically

Lecture 314 Running Food Vision Mini on Hugging Face Spaces and Trying it Out

Lecture 315 Food Vision Big Project Outline

Lecture 316 Preparing an EffNetB2 Feature Extractor Model for Food Vision Big

Lecture 317 Downloading the Food 101 Dataset

Lecture 318 Creating a Function to Split Our Food 101 Dataset into Smaller Portions

Lecture 319 Turning Our Food 101 Datasets into DataLoaders

Lecture 320 Training Food Vision Big: Our Biggest Model Yet!

Lecture 321 Outlining the File Structure for Our Food Vision Big

Lecture 322 Downloading an Example Image and Moving Our Food Vision Big Model File

Lecture 323 Saving Food 101 Class Names to a Text File and Reading them Back In

Lecture 324 Turning Our EffNetB2 Feature Extractor Creation Function into a Python Script

Lecture 325 Creating an App Script for Our Food Vision Big Model Gradio Demo

Lecture 326 Zipping and Downloading Our Food Vision Big App Files

Lecture 327 Deploying Food Vision Big to Hugging Face Spaces

Lecture 328 PyTorch Mode Deployment: Main Takeaways, Extra-Curriculum and Exercises

Section 12: Where To Go From Here?

Lecture 329 Thank You!

Anyone who wants a step-by-step guide to learning PyTorch and be able to get hired as a Deep Learning Engineer making over $100,000 / year,Students, developers, and data scientists who want to demonstrate practical machine learning skills by actually building and training real models using PyTorch,Anyone looking to expand their knowledge and toolkit when it comes to AI, Machine Learning and Deep Learning,Bootcamp or online PyTorch tutorial graduates that want to go beyond the basics,Students who are frustrated with their current progress with all of the beginner PyTorch tutorials out there that don't go beyond the basics and don't give you real-world practice or skills you need to actually get hired