PyTorch for Deep Learning Bootcamp
Learn PyTorch. Become a Deep Learning Engineer. Get Hired.
Lo que serás capaz de hacer
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 cars Meta to power the curation and understanding systems for their content timelines Apple 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 experiments Completing exercises to test your skills Building real-world deep learning models and projects to mimic real life scenarios By 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?
- 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
Temario
UNIDAD 1 - Introduction · 7 leccionesUNIDAD 1 - Introduction
UNIDAD 1 - Introduction
- PyTorch for Deep Learning
- Course Welcome and What Is Deep Learning
- Join Our Online Classroom!
- Exercise: Meet Your Classmates + Instructor
- Free Course Book + Code Resources + Asking Questions + Getting Help
- ZTM Resources
- AI & Machine Learning Monthly Newsletters
UNIDAD 2 - PyTorch Fundamentals · 32 leccionesUNIDAD 2 - PyTorch Fundamentals
UNIDAD 2 - PyTorch Fundamentals
- 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
UNIDAD 3 - PyTorch Workflow · 28 leccionesUNIDAD 3 - PyTorch Workflow
UNIDAD 3 - PyTorch Workflow
- 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 and Extra-Curriculum
UNIDAD 4 - PyTorch Neural Network Classification · 32 leccionesUNIDAD 4 - PyTorch Neural Network Classification
UNIDAD 4 - PyTorch Neural Network Classification
- 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
- Recreating and Exploring the Insides of Our Model Using nn.Sequential
- 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 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
- Logits to Prediction Probabilities to Prediction Labels with a Multi-Class Model
- Training a Multi-Class Classification Model and Troubleshooting Code on the Fly
- Making Predictions with and Evaluating Our Multi-Class Classification Model
- Discussing a Few More Classification Metrics
- PyTorch Classification: Exercises and Extra-Curriculum
UNIDAD 5 - PyTorch Computer Vision · 34 leccionesUNIDAD 5 - PyTorch Computer Vision
UNIDAD 5 - PyTorch Computer Vision
- 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-Batches
- 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 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 Plus Exercises and Extra-Curriculum
UNIDAD 6 - PyTorch Custom Datasets · 37 leccionesUNIDAD 6 - PyTorch Custom Datasets
UNIDAD 6 - PyTorch Custom Datasets
- 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
- 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 (Part 2): Loading In a Custom Image With PyTorch
- Predicting on Custom Data (Part3):Getting Our Custom Image Into the Right Format
- Predicting on Custom Data (Part4):Turning Our Models Raw Outputs Into Prediction
- Predicting on Custom Data (Part 5): Putting It All Together
- Summary of What We Have Covered Plus Exercises and Extra-Curriculum
UNIDAD 7 - PyTorch Going Modular · 10 leccionesUNIDAD 7 - PyTorch Going Modular
UNIDAD 7 - PyTorch Going Modular
- 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
UNIDAD 8 - PyTorch Transfer Learning · 19 leccionesUNIDAD 8 - PyTorch Transfer Learning
UNIDAD 8 - PyTorch Transfer Learning
- Introduction: What is Transfer Learning and Why Use It
- Where Can You Find Pretrained Models and What We Are Going to Cover
- Installing the Latest Versions of Torch and Torchvision
- Downloading Our Previously Written Code from Going Modular
- Downloading Pizza, Steak, Sushi Image Data from Github
- Turning Our Data into DataLoaders with Manually Created Transforms
- Turning Our Data into DataLoaders with Automatic Created Transforms
- Which Pretrained Model Should You Use
- Setting Up a Pretrained Model with Torchvision
- Different Kinds of Transfer Learning
- Getting a Summary of the Different Layers of Our Model
- Freezing the Base Layers of Our Model and Updating the Classifier Head
- Training Our First Transfer Learning Feature Extractor Model
- Plotting the Loss curves of Our Transfer Learning Model
- Outlining the Steps to Make Predictions on the Test Images
- Creating a Function Predict On and Plot Images
- Making and Plotting Predictions on Test Images
- Making a Prediction on a Custom Image
- Main Takeaways, Exercises and Extra- Curriculum
UNIDAD 9 - PyTorch Experiment Tracking · 22 leccionesUNIDAD 9 - PyTorch Experiment Tracking
UNIDAD 9 - PyTorch Experiment Tracking
- What Is Experiment Tracking and Why Track Experiments
- Getting Setup by Importing Torch Libraries and Going Modular Code
- Creating a Function to Download Data
- Turning Our Data into DataLoaders Using Manual Transforms
- Turning Our Data into DataLoaders Using Automatic Transforms
- Preparing a Pretrained Model for Our Own Problem
- Setting Up a Way to Track a Single Model Experiment with TensorBoard
- Training a Single Model and Saving the Results to TensorBoard
- Exploring Our Single Models Results with TensorBoard
- Creating a Function to Create SummaryWriter Instances
- Adapting Our Train Function to Be Able to Track Multiple Experiments
- What Experiments Should You Try
- Discussing the Experiments We Are Going to Try
- Downloading Datasets for Our Modelling Experiments
- Turning Our Datasets into DataLoaders Ready for Experimentation
- Creating Functions to Prepare Our Feature Extractor Models
- Coding Out the Steps to Run a Series of Modelling Experiments
- Running Eight Different Modelling Experiments in 5 Minutes
- Viewing Our Modelling Experiments in TensorBoard
- Loading the Best Model and Making Predictions on Random Images from the Test Set
- Making a Prediction on Our Own Custom Image with the Best Model
- Main Takeaways, Exercises and Extra- Curriculum
UNIDAD 10 - PyTorch Paper Replicating · 50 leccionesUNIDAD 10 - PyTorch Paper Replicating
UNIDAD 10 - PyTorch Paper Replicating
- What Is a Machine Learning Research Paper?
- Why Replicate a Machine Learning Research Paper?
- Where Can You Find Machine Learning Research Papers and Code?
- What We Are Going to Cover
- Getting Setup for Coding in Google Colab
- Downloading Data for Food Vision Mini
- Turning Our Food Vision Mini Images into PyTorch DataLoaders
- Visualizing a Single Image
- Replicating a Vision Transformer - High Level Overview
- Breaking Down Figure 1 of the ViT Paper
- Breaking Down the Four Equations Overview and a Trick for Reading Papers
- Breaking Down Equation 1
- Breaking Down Equation 2 and 3
- Breaking Down Equation 4
- Breaking Down Table 1
- Calculating the Input and Output Shape of the Embedding Layer by Hand
- Turning a Single Image into Patches (Part 1: Patching the Top Row)
- Turning a Single Image into Patches (Part 2: Patching the Entire Image)
- Creating Patch Embeddings with a Convolutional Layer
- Exploring the Outputs of Our Convolutional Patch Embedding Layer
- Flattening Our Convolutional Feature Maps into a Sequence of Patch Embeddings
- Visualizing a Single Sequence Vector of Patch Embeddings
- Creating the Patch Embedding Layer with PyTorch
- Creating the Class Token Embedding
- Creating the Class Token Embedding - Less Birds
- Creating the Position Embedding
- Equation 1: Putting it All Together
- Equation 2: Multihead Attention Overview
- Equation 2: Layernorm Overview
- Turning Equation 2 into Code
- Checking the Inputs and Outputs of Equation
- Equation 3: Replication Overview
- Turning Equation 3 into Code
- Transformer Encoder Overview
- Combining equation 2 and 3 to Create the Transformer Encoder
- Creating a Transformer Encoder Layer with In-Built PyTorch Layer
- Bringing Our Own Vision Transformer to Life - Part 1: Gathering the Pieces
- Bringing Our Own Vision Transformer to Life - Part 2: The Forward Method
- Getting a Visual Summary of Our Custom Vision Transformer
- Creating a Loss Function and Optimizer from the ViT Paper
- Training our Custom ViT on Food Vision Mini
- Discussing what Our Training Setup Is Missing
- Plotting a Loss Curve for Our ViT Model
- Getting a Pretrained Vision Transformer from Torchvision and Setting it Up
- Preparing Data to Be Used with a Pretrained ViT
- Training a Pretrained ViT Feature Extractor Model for Food Vision Mini
- Saving Our Pretrained ViT Model to File and Inspecting Its Size
- Discussing the Trade-Offs Between Using a Larger Model for Deployments
- Making Predictions on a Custom Image with Our Pretrained ViT
- PyTorch Paper Replicating: Main Takeaways, Exercises and Extra-Curriculum
UNIDAD 11 - PyTorch Model Deployment · 57 leccionesUNIDAD 11 - PyTorch Model Deployment
UNIDAD 11 - PyTorch Model Deployment
- What is Machine Learning Model Deployment - Why Deploy a Machine Learning Model
- Three Questions to Ask for Machine Learning Model Deployment
- Where Is My Model Going to Go?
- How Is My Model Going to Function?
- Some Tools and Places to Deploy Machine Learning Models
- What We Are Going to Cover
- Getting Setup to Code
- Downloading a Dataset for Food Vision Mini
- Outlining Our Food Vision Mini Deployment Goals and Modelling Experiments
- Creating an EffNetB2 Feature Extractor Model
- Create a Function to Make an EffNetB2 Feature Extractor Model and Transforms
- Creating DataLoaders for EffNetB2
- Training Our EffNetB2 Feature Extractor and Inspecting the Loss Curves
- Saving Our EffNetB2 Model to File
- Getting the Size of Our EffNetB2 Model in Megabytes
- Collecting Important Statistics and Performance Metrics for Our EffNetB2 Model
- Creating a Vision Transformer Feature Extractor Model
- Creating DataLoaders for Our ViT Feature Extractor Model
- Training Our ViT Feature Extractor Model and Inspecting Its Loss Curves
- Saving Our ViT Feature Extractor and Inspecting Its Size
- Collecting Stats About Our-ViT Feature Extractor
- Outlining the Steps for Making and Timing Predictions for Our Models
- Creating a Function to Make and Time Predictions with Our Models
- Making and Timing Predictions with EffNetB2
- Making and Timing Predictions with ViT
- Comparing EffNetB2 and ViT Model Statistics
- Visualizing the Performance vs Speed Trade-off
- Gradio Overview and Installation
- Gradio Function Outline
- Creating a Predict Function to Map Our Food Vision Mini Inputs to Outputs
- Creating a List of Examples to Pass to Our Gradio Demo
- Bringing Food Vision Mini to Life in a Live Web Application
- Getting Ready to Deploy Our App Hugging Face Spaces Overview
- Outlining the File Structure of Our Deployed App
- Creating a Food Vision Mini Demo Directory to House Our App Files
- Creating an Examples Directory with Example Food Vision Mini Images
- Writing Code to Move Our Saved EffNetB2 Model File
- Turning Our EffNetB2 Model Creation Function Into a Python Script
- Turning Our Food Vision Mini Demo App Into a Python Script
- Creating a Requirements File for Our Food Vision Mini App
- Downloading Our Food Vision Mini App Files from Google Colab
- Uploading Our Food Vision Mini App to Hugging Face Spaces Programmatically
- Running Food Vision Mini on Hugging Face Spaces and Trying it Out
- Food Vision Big Project Outline
- Preparing an EffNetB2 Feature Extractor Model for Food Vision Big
- Downloading the Food 101 Dataset
- Creating a Function to Split Our Food 101 Dataset into Smaller Portions
- Turning Our Food 101 Datasets into DataLoaders
- Training Food Vision Big: Our Biggest Model Yet!
- Outlining the File Structure for Our Food Vision Big
- Downloading an Example Image and Moving Our Food Vision Big Model File
- Saving Food 101 Class Names to a Text File and Reading them Back In
- Turning Our EffNetB2 Feature Extractor Creation Function into a Python Script
- Creating an App Script for Our Food Vision Big Model Gradio Demo
- Zipping and Downloading Our Food Vision Big App Files
- Deploying Food Vision Big to Hugging Face Spaces
- PyTorch Mode Deployment: Main Takeaways, Extra-Curriculum and Exercises
UNIDAD 12 - Introduction to PyTorch 2.0 and torch.compile · 25 leccionesUNIDAD 12 - Introduction to PyTorch 2.0 and torch.compile
UNIDAD 12 - Introduction to PyTorch 2.0 and torch.compile
- Introduction to PyTorch 2.0
- What We Are Going to Cover and PyTorch 2 Reference Materials
- Getting Started with PyTorch 2 in Google Colab
- PyTorch 2.0 - 30 Second Intro
- Getting Setup for PyTorch 2
- Getting Info from Our GPUs and Seeing if They're Capable of Using PyTorch 2
- Setting the Default Device in PyTorch 2
- Discussing the Experiments We Are Going to Run for PyTorch 2
- Introduction to PyTorch 2
- Creating a Function to Setup Our Model and Transforms
- Discussing How to Get Better Relative Speedups for Training Models
- Setting the Batch Size and Data Size Programmatically
- Getting More Potential Speedups with TensorFloat-32
- Downloading the CIFAR10 Dataset
- Creating Training and Test DataLoaders
- Preparing Training and Testing Loops with Timing Steps for PyTorch 2.0 timing
- Experiment 1 - Single Run without torch.compile
- Experiment 2 - Single Run with torch.compile
- Comparing the Results of Experiment 1 and 2
- Saving the Results of Experiment 1 and 2
- Preparing Functions for Experiment 3 and 4
- Experiment 3 - Training a Non-Compiled Model for Multiple Runs
- Experiment 4 - Training a Compiled Model for Multiple Runs
- Comparing the Results of Experiment 3 and 4
- Potential Extensions and Resources to Learn More
UNIDAD 13 - Bonus Section · 1 leccionesUNIDAD 13 - Bonus Section
UNIDAD 13 - Bonus Section
- Special Bonus Lecture
UNIDAD 14 - Where To Go From Here? · 4 leccionesUNIDAD 14 - Where To Go From Here?
UNIDAD 14 - Where To Go From Here?
- Thank You!
- Become An Alumni
- Endorsements on LinkedIn
- Learning Guideline
Tu certificado lo emite la SEP, no solo una plataforma
Al demostrar la competencia recibes un certificado emitido por la Secretaría de Educación Pública a través del Gobierno del Estado de México: un documento oficial que puedes presentar con confianza ante cualquier empleador o institución.
Tu certificado con INEC
- Lo emite la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México
- Documento oficial con folio verificable en línea
- Lo otorga la Universidad Tecnológica Fidel Velázquez
Otras plataformas en línea
- Constancia privada emitida por la misma plataforma
- Solo acredita horas cursadas o asistencia
- Sin respaldo de una autoridad educativa
Tu itinerario, de la inscripción al certificado
- 1
Inscripción con pago único
Pagas $2,800 MXN una sola vez y entras de inmediato al curso.
- 2
Estudias a tu ritmo
14 unidades con videos, lecturas y actividades, disponibles 24/7 durante 12 meses.
- 3
Cuestionarios por unidad
Cuestionarios para comprobar lo aprendido.
- 4
Certificado
Emitido por la SEP a través del Gobierno del Estado de México, con folio verificable.
Un certificado oficial de la SEP
Muestra · verificable por folio y QR
- Emitido por la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México. No es una constancia privada: es un documento oficial, y ese respaldo marca la diferencia frente a otras plataformas en línea.
- Contenido impartido por Andrei Neagoie.
- Folio y QR verificables para compartirlo con quien te contrate.
Empieza hoy, a tu ritmo
Un solo pago y acceso inmediato al curso completo durante 12 meses.
- 14 unidades · 358 lecciones · 60 h
- 12 meses de acceso
- Certificado emitido por la SEP (Gob. del Estado de México) con folio verificable
Sobre tu inscripción
¿Cómo es el pago?
Un solo pago de $2,800 MXN. No hay mensualidades ni cargos recurrentes.
¿Cuánto tiempo tengo acceso?
12 meses desde tu inscripción, 24/7, para avanzar a tu ritmo.
¿Quién imparte el contenido?
El curso es impartido por Andrei Neagoie; INEC gestiona tu inscripción, evaluación y certificado.
¿Qué pasa cuando vence mi acceso?
Puedes renovar tu cuenta tú mismo desde la plataforma, sin trámites ni esperas.
