Example Curriculum
Introduction
Available in
days
days
after you enroll
Section 00: PyTorch Fundamentals
Available in
days
days
after you enroll
- Why Use Machine Learning or Deep Learning (3:33)
- The Number 1 Rule of Machine Learning and What Is Deep Learning Good For (5:39)
- Machine Learning vs. Deep Learning (6:06)
- Anatomy of Neural Networks (9:21)
- Different Types of Learning Paradigms (4:30)
- What Can Deep Learning Be Used For (6:21)
- What Is and Why PyTorch (10:12)
- What Are Tensors (4:15)
- What We Are Going To Cover With PyTorch (6:05)
- How To and How Not To Approach This Course (5:09)
- Important Resources For This Course (5:21)
- Getting Setup to Write PyTorch Code (7:39)
- Introduction to PyTorch Tensors (13:24)
- Creating Random Tensors in PyTorch (9:58)
- Creating Tensors With Zeros and Ones in PyTorch (3:08)
- Creating a Tensor Range and Tensors Like Other Tensors (5:17)
- Dealing With Tensor Data Types (9:24)
- Getting Tensor Attributes (8:22)
- Manipulating Tensors (Tensor Operations) (5:59)
- Matrix Multiplication (Part 1) (9:34)
- Matrix Multiplication (Part 2): The Two Main Rules of Matrix Multiplication (7:51)
- Matrix Multiplication (Part 3): Dealing With Tensor Shape Errors (12:56)
- Finding the Min Max Mean and Sum of Tensors (Tensor Aggregation) (6:09)
- Finding The Positional Min and Max of Tensors (3:16)
- Reshaping, Viewing and Stacking Tensors (13:40)
- Squeezing, Unsqueezing and Permuting Tensors (11:55)
- Selecting Data From Tensors (Indexing) (9:31)
- PyTorch Tensors and NumPy (9:08)
- PyTorch Reproducibility (Taking the Random Out of Random) (10:46)
- Different Ways of Accessing a GPU in PyTorch (11:50)
- Setting up Device Agnostic Code and Putting Tensors On and Off the GPU (7:43)
- PyTorch Fundamentals: Exercises and Extra-Curriculum (4:49)
- Let's Have Some Fun (+ Free Resources)
Section 01: PyTorch Workflow
Available in
days
days
after you enroll
- Introduction and Where You Can Get Help (2:45)
- Getting Setup and What We Are Covering (7:14)
- Creating a Simple Dataset Using the Linear Regression Formula (9:40)
- Splitting Our Data Into Training and Test Sets (8:19)
- Building a function to Visualize Our Data (7:45)
- Creating Our First PyTorch Model for Linear Regression (14:09)
- Breaking Down What's Happening in Our PyTorch Linear regression Model (6:10)
- Discussing Some of the Most Important PyTorch Model Building Classes (6:26)
- Checking Out the Internals of Our PyTorch Model (9:50)
- Making Predictions With Our Random Model Using Inference Mode (11:12)
- Training a Model Intuition (The Things We Need) (8:14)
- Setting Up an Optimizer and a Loss Function (12:51)
- PyTorch Training Loop Steps and Intuition (13:53)
- Writing Code for a PyTorch Training Loop (8:46)
- Reviewing the Steps in a Training Loop Step by Step (14:57)
- Running Our Training Loop Epoch by Epoch and Seeing What Happens (9:25)
- Writing Testing Loop Code and Discussing What's Happening Step by Step (11:37)
- Reviewing What Happens in a Testing Loop Step by Step (14:42)
- Writing Code to Save a PyTorch Model (13:45)
- Writing Code to Load a PyTorch Model (8:44)
- Setting Up to Practice Everything We Have Done Using Device-Agnostic Code (6:02)
- Putting Everything Together (Part 1): Data (6:07)
- Putting Everything Together (Part 2): Building a Model (10:07)
- Putting Everything Together (Part 3): Training a Model (12:39)
- Putting Everything Together (Part 4): Making Predictions With a Trained Model (5:17)
- Putting Everything Together (Part 5): Saving and Loading a Trained Model (9:10)
- PyTorch Workflow: Exercises and Extra-Curriculum (3:57)
- Unlimited Updates
Section 02: PyTorch Neural Network Classification
Available in
days
days
after you enroll
- Introduction to Machine Learning Classification With PyTorch (9:41)
- Classification Problem Example: Input and Output Shapes (9:06)
- Typical Architecture of a Classification Neural Network (Overview) (6:30)
- Making a Toy Classification Dataset (12:18)
- Turning Our Data into Tensors and Making a Training and Test Split (11:55)
- Laying Out Steps for Modelling and Setting Up Device-Agnostic Code (4:19)
- Coding a Small Neural Network to Handle Our Classification Data (10:57)
- Making Our Neural Network Visual (6:57)
- Recreating and Exploring the Insides of Our Model Using nn.Sequential (13:17)
- Setting Up a Loss Function Optimizer and Evaluation Function for Our Classification Network (14:50)
- Going from Model Logits to Prediction Probabilities to Prediction Labels (16:06)
- Coding a Training and Testing Optimization Loop for Our Classification Model (15:26)
- Writing Code to Download a Helper Function to Visualize Our Models Predictions (14:13)
- Discussing Options to Improve a Model (8:02)
- Creating a New Model with More Layers and Hidden Units (9:06)
- Writing Training and Testing Code to See if Our New and Upgraded Model Performs Better (12:45)
- Creating a Straight Line Dataset to See if Our Model is Learning Anything (8:07)
- Building and Training a Model to Fit on Straight Line Data (10:01)
- Evaluating Our Models Predictions on Straight Line Data (5:23)
- Introducing the Missing Piece for Our Classification Model Non-Linearity (10:00)
- Building Our First Neural Network with Non-Linearity (10:25)
- Writing Training and Testing Code for Our First Non-Linear Model (15:12)
- Making Predictions with and Evaluating Our First Non-Linear Model (5:47)
- Replicating Non-Linear Activation Functions with Pure PyTorch (9:34)
- Putting It All Together (Part 1): Building a Multiclass Dataset (11:24)
- Creating a Multi-Class Classification Model with PyTorch (12:27)
- Setting Up a Loss Function and Optimizer for Our Multi-Class Model (6:39)
- Going from Logits to Prediction Probabilities to Prediction Labels with a Multi-Class Model (11:01)
- Training a Multi-Class Classification Model and Troubleshooting Code on the Fly (16:17)
- Making Predictions with and Evaluating Our Multi-Class Classification Model (7:59)
- Discussing a Few More Classification Metrics (9:17)
- PyTorch Classification: Exercises and Extra-Curriculum (2:58)
- Course Check-In
Section 03: PyTorch Computer Vision
Available in
days
days
after you enroll
- What Is a Computer Vision Problem and What We Are Going to Cover (11:47)
- Computer Vision Input and Output Shapes (10:08)
- What Is a Convolutional Neural Network (CNN) (5:02)
- Discussing and Importing the Base Computer Vision Libraries in PyTorch (9:19)
- Getting a Computer Vision Dataset and Checking Out Its- Input and Output Shapes (14:30)
- Visualizing Random Samples of Data (9:51)
- DataLoader Overview Understanding Mini-Batch (7:17)
- Turning Our Datasets Into DataLoaders (12:23)
- Model 0: Creating a Baseline Model with Two Linear Layers (14:38)
- Creating a Loss Function: an Optimizer for Model 0 (10:29)
- Creating a Function to Time Our Modelling Code (5:34)
- Writing Training and Testing Loops for Our Batched Data (21:25)
- Writing an Evaluation Function to Get Our Models Results (12:58)
- Setup Device-Agnostic Code for Running Experiments on the GPU (3:46)
- Model 1: Creating a Model with Non-Linear Functions (9:03)
- Model 1: Creating a Loss Function and Optimizer (3:04)
- Turing Our Training Loop into a Function (8:28)
- Turing Our Testing Loop into a Function (6:35)
- Training and Testing Model 1 with Our Training and Testing Functions (11:52)
- Getting a Results Dictionary for Model 1 (4:08)
- Model 2: Convolutional Neural Networks High Level Overview (8:24)
- Model 2: Coding Our First Convolutional Neural Network with PyTorch (19:48)
- Model 2: Breaking Down Conv2D Step by Step (14:59)
- Model 2: Breaking Down MaxPool2D Step by Step (15:48)
- Model 2: Using a Trick to Find the Input and Output Shapes of Each of Our Layers (13:45)
- Model 2: Setting Up a Loss Function and Optimizer (2:38)
- Model 2: Training Our First CNN and Evaluating Its Results (7:54)
- Comparing the Results of Our Modelling Experiments (7:23)
- Making Predictions on Random Test Samples with the Best Trained Model (11:39)
- Plotting Our Best Model Predictions on Random Test Samples and Evaluating Them (8:10)
- Making Predictions Across the Whole Test Dataset and Importing Libraries to Plot a Confusion Matrix (15:20)
- Evaluating Our Best Models Predictions with a Confusion Matrix (6:54)
- Saving and Loading Our Best Performing Model (11:27)
- Recapping What We Have Covered Plus Exercises and Extra-Curriculum (6:01)
- Implement a New Life System
Section 04: PyTorch Custom Datasets
Available in
days
days
after you enroll
- What Is a Custom Dataset and What We Are Going to Cover (9:53)
- Importing PyTorch and Setting Up Device-Agnostic Code (5:54)
- Downloading a Custom Dataset of Pizza, Steak and Sushi Images (14:04)
- Becoming One With the Data (Part 1): Exploring the Data Format (8:41)
- Becoming One With the Data (Part 2): Visualizing a Random Image (11:40)
- Becoming One With the Data (Part 3): Visualizing a Random Image with Matplotlib (4:47)
- Transforming Data (Part 1): Turning Images Into Tensors (8:53)
- Transforming Data (Part 2): Visualizing Transformed Images (11:30)
- Loading All of Our Images and Turning Them Into Tensors With ImageFolder (9:17)
- Visualizing a Loaded Image From the Train Dataset (7:18)
- Turning Our Image Datasets into PyTorch DataLoaders (9:03)
- Creating a Custom Dataset Class in PyTorch High Level Overview (7:59)
- Creating a Helper Function to Get Class Names From a Directory (9:06)
- Writing a PyTorch Custom Dataset Class from Scratch to Load Our Images (17:46)
- Compare Our Custom Dataset Class to the Original ImageFolder Class (7:13)
- Writing a Helper Function to Visualize Random Images from Our Custom Dataset (14:18)
- Turning Our Custom Datasets Into DataLoaders (6:58)
- Exploring State of the Art Data Augmentation With Torchvision Transforms (14:23)
- Building a Baseline Model (Part 1): Loading and Transforming Data (8:15)
- Building a Baseline Model (Part 2): Replicating Tiny VGG from Scratch (11:24)
- Building a Baseline Model (Part 3): Doing a Forward Pass to Test Our Model Shapes (8:09)
- Using the Torchinfo Package to Get a Summary of Our Model (6:38)
- Creating Training and Testing loop Functions (13:03)
- Creating a Train Function to Train and Evaluate Our Models (10:14)
- Training and Evaluating Model 0 With Our Training Functions (9:53)
- Plotting the Loss Curves of Model 0 (9:02)
- Discussing the Balance Between Overfitting and Underfitting and How to Deal With Each (14:13)
- Creating Augmented Training Datasets and DataLoaders for Model 1 (11:03)
- Constructing and Training Model 1 (7:10)
- Plotting the Loss Curves of Model 1 (3:22)
- Plotting the Loss Curves of All of Our Models Against Each Other (10:55)
- Predicting on Custom Data (Part 1): Downloading an Image (5:32)
- Predicting on Custom Data (Part2): Loading In a Custom Image With PyTorch (7:00)
- Predicting on Custom Data (Part 3): Getting Our Custom Image Into the Right Format (14:06)
- Predicting on Custom Data (Part 4): Turning Our Models Raw Outputs Into Prediction Labels (4:24)
- Predicting on Custom Data (Part 5): Putting It All Together (12:47)
- Summary of What We Have Covered Plus Exercises and Extra-Curriculum (6:04)
- Exercise: Imposter Syndrome (2:55)
Section 05: PyTorch Going Modular
Available in
days
days
after you enroll
- What Is Going Modular and What We Are Going to Cover (11:34)
- Going Modular Notebook (Part 1): Running It End to End (7:39)
- Downloading a Dataset (4:49)
- Writing the Outline for Our First Python Script to Setup the Data (13:50)
- Creating a Python Script to Create Our PyTorch DataLoaders (10:35)
- Turning Our Model Building Code into a Python Script (9:18)
- Turning Our Model Training Code into a Python Script (6:16)
- Turning Our Utility Function to Save a Model into a Python Script (6:06)
- Creating a Training Script to Train Our Model in One Line of Code (15:46)
- Going Modular: Summary, Exercises and Extra-Curriculum (5:59)
Section 06: PyTorch Transfer Learning
Available in
days
days
after you enroll
- Introduction: What is Transfer Learning and Why Use It (10:05)
- Where Can You Find Pretrained Models and What We Are Going to Cover (5:12)
- Installing the Latest Versions of Torch and Torchvision (8:05)
- Downloading Our Previously Written Code from Going Modular (6:41)
- Downloading Pizza, Steak, Sushi Image Data from Github (8:00)
- Turning Our Data into DataLoaders with Manually Created Transforms (14:40)
- Turning Our Data into DataLoaders with Automatic Created Transforms (13:06)
- Which Pretrained Model Should You Use (12:15)
- Setting Up a Pretrained Model with Torchvision (10:57)
- Different Kinds of Transfer Learning (7:11)
- Getting a Summary of the Different Layers of Our Model (6:49)
- Freezing the Base Layers of Our Model and Updating the Classifier Head (13:26)
- Training Our First Transfer Learning Feature Extractor Model (7:54)
- Plotting the Loss Curves of Our Transfer Learning Model (6:26)
- Outlining the Steps to Make Predictions on the Test Images (7:57)
- Creating a Function Predict On and Plot Images (10:00)
- Making and Plotting Predictions on Test Images (7:23)
- Making a Prediction on a Custom Image (6:21)
- Main Takeaways, Exercises and Extra Curriculum (3:21)
Section 07: PyTorch Experiment Tracking
Available in
days
days
after you enroll
- What Is Experiment Tracking and Why Track Experiments (7:06)
- Getting Setup by Importing Torch Libraries and Going Modular Code (8:13)
- Creating a Function to Download Data (10:23)
- Turning Our Data into DataLoaders Using Manual Transforms (8:30)
- Turning Our Data into DataLoaders Using Automatic Transforms (7:47)
- Preparing a Pretrained Model for Our Own Problem (10:28)
- Setting Up a Way to Track a Single Model Experiment with TensorBoard (13:35)
- Training a Single Model and Saving the Results to TensorBoard (4:38)
- Exploring Our Single Models Results with TensorBoard (10:17)
- Creating a Function to Create SummaryWriter Instances (10:45)
- Adapting Our Train Function to Be Able to Track Multiple Experiments (4:57)
- What Experiments Should You Try (5:59)
- Discussing the Experiments We Are Going to Try (6:01)
- Downloading Datasets for Our Modelling Experiments (6:31)
- Turning Our Datasets into DataLoaders Ready for Experimentation (8:28)
- Creating Functions to Prepare Our Feature Extractor Models (15:54)
- Coding Out the Steps to Run a Series of Modelling Experiments (14:27)
- Running Eight Different Modelling Experiments in 5 Minutes (3:50)
- Viewing Our Modelling Experiments in TensorBoard (13:38)
- Loading In the Best Model and Making Predictions on Random Images from the Test Set (10:32)
- Making a Prediction on Our Own Custom Image with the Best Model (3:44)
- Main Takeaways, Exercises and Extra Curriculum (3:56)
Section 08: PyTorch Paper Replicating
Available in
days
days
after you enroll
- What Is a Machine Learning Research Paper? (7:34)
- Why Replicate a Machine Learning Research Paper? (3:13)
- Where Can You Find Machine Learning Research Papers and Code? (8:18)
- What We Are Going to Cover (8:21)
- Getting Setup for Coding in Google Colab (8:21)
- Downloading Data for Food Vision Mini (4:02)
- Turning Our Food Vision Mini Images into PyTorch DataLoaders (9:47)
- Visualizing a Single Image (3:45)
- Replicating a Vision Transformer - High Level Overview (9:53)
- Breaking Down Figure 1 of the ViT Paper (11:12)
- Breaking Down the Four Equations Overview and a Trick for Reading Papers (10:55)
- Breaking Down Equation 1 (8:14)
- Breaking Down Equations 2 and 3 (10:03)
- Breaking Down Equation 4 (7:27)
- Breaking Down Table 1 (11:05)
- Calculating the Input and Output Shape of the Embedding Layer by Hand (15:41)
- Turning a Single Image into Patches (Part 1: Patching the Top Row) (15:03)
- Turning a Single Image into Patches (Part 2: Patching the Entire Image) (12:33)
- Creating Patch Embeddings with a Convolutional Layer (13:33)
- Exploring the Outputs of Our Convolutional Patch Embedding Layer (12:54)
- Flattening Our Convolutional Feature Maps into a Sequence of Patch Embeddings (9:59)
- Visualizing a Single Sequence Vector of Patch Embeddings (5:03)
- Creating the Patch Embedding Layer with PyTorch (17:01)
- Creating the Class Token Embedding (13:24)
- Creating the Class Token Embedding - Less Birds (13:24)
- Creating the Position Embedding (11:25)
- Equation 1: Putting it All Together (13:25)
- Equation 2: Multihead Attention Overview (14:30)
- Equation 2: Layernorm Overview (9:03)
- Turning Equation 2 into Code (14:33)
- Checking the Inputs and Outputs of Equation (5:40)
- Equation 3: Replication Overview (9:11)
- Turning Equation 3 into Code (11:25)
- Transformer Encoder Overview (8:50)
- Combining Equation 2 and 3 to Create the Transformer Encoder (9:16)
- Creating a Transformer Encoder Layer with In-Built PyTorch Layer (15:54)
- Bringing Our Own Vision Transformer to Life - Part 1: Gathering the Pieces of the Puzzle (18:19)
- Bringing Our Own Vision Transformer to Life - Part 2: Putting Together the Forward Method (10:41)
- Getting a Visual Summary of Our Custom Vision Transformer (7:13)
- Creating a Loss Function and Optimizer from the ViT Paper (11:26)
- Training our Custom ViT on Food Vision Mini (4:29)
- Discussing what Our Training Setup Is Missing (9:08)
- Plotting a Loss Curve for Our ViT Model (6:13)
- Getting a Pretrained Vision Transformer from Torchvision and Setting it Up (14:37)
- Preparing Data to Be Used with a Pretrained ViT (5:53)
- Training a Pretrained ViT Feature Extractor Model for Food Vision Mini (7:15)
- Saving Our Pretrained ViT Model to File and Inspecting Its Size (5:13)
- Discussing the Trade-Offs Between Using a Larger Model for Deployments (3:46)
- Making Predictions on a Custom Image with Our Pretrained ViT (3:30)
- PyTorch Paper Replicating: Main Takeaways, Exercises and Extra-Curriculum (6:50)
Section 09: PyTorch Model Deployment
Available in
days
days
after you enroll
- What is Machine Learning Model Deployment and Why Deploy a Machine Learning Model (9:35)
- Three Questions to Ask for Machine Learning Model Deployment (7:13)
- Where Is My Model Going to Go? (13:34)
- How Is My Model Going to Function? (7:59)
- Some Tools and Places to Deploy Machine Learning Models (5:49)
- What We Are Going to Cover (4:01)
- Getting Setup to Code (6:15)
- Downloading a Dataset for Food Vision Mini (3:23)
- Outlining Our Food Vision Mini Deployment Goals and Modelling Experiments (7:59)
- Creating an EffNetB2 Feature Extractor Model (9:45)
- Create a Function to Make an EffNetB2 Feature Extractor Model and Transforms (6:29)
- Creating DataLoaders for EffNetB2 (3:31)
- Training Our EffNetB2 Feature Extractor and Inspecting the Loss Curves (9:15)
- Saving Our EffNetB2 Model to File (3:24)
- Getting the Size of Our EffNetB2 Model in Megabytes (5:51)
- Collecting Important Statistics and Performance Metrics for Our EffNetB2 Model (6:34)
- Creating a Vision Transformer Feature Extractor Model (7:51)
- Creating DataLoaders for Our ViT Feature Extractor Model (2:30)
- Training Our ViT Feature Extractor Model and Inspecting Its Loss Curves (6:19)
- Saving Our ViT Feature Extractor and Inspecting Its Size (5:08)
- Collecting Stats About Our ViT Feature Extractor (5:51)
- Outlining the Steps for Making and Timing Predictions for Our Models (11:15)
- Creating a Function to Make and Time Predictions with Our Models (16:20)
- Making and Timing Predictions with EffNetB2 (10:43)
- Making and Timing Predictions with ViT (7:34)
- Comparing EffNetB2 and ViT Model Statistics (11:31)
- Visualizing the Performance vs Speed Trade-off (15:54)
- Gradio Overview and Installation (8:39)
- Gradio Function Outline (8:49)
- Creating a Predict Function to Map Our Food Vision Mini Inputs to Outputs (9:51)
- Creating a List of Examples to Pass to Our Gradio Demo (5:26)
- Bringing Food Vision Mini to Life in a Live Web Application (12:12)
- Getting Ready to Deploy Our App Hugging Face Spaces Overview (6:26)
- Outlining the File Structure of Our Deployed App (8:11)
- Creating a Food Vision Mini Demo Directory to House Our App Files (4:11)
- Creating an Examples Directory with Example Food Vision Mini Images (9:13)
- Writing Code to Move Our Saved EffNetB2 Model File (7:42)
- Turning Our EffNetB2 Model Creation Function Into a Python Script (4:01)
- Turning Our Food Vision Mini Demo App Into a Python Script (13:27)
- Creating a Requirements File for Our Food Vision Mini App (4:11)
- Downloading Our Food Vision Mini App Files from Google Colab (11:30)
- Uploading Our Food Vision Mini App to Hugging Face Spaces Programmatically (13:36)
- Running Food Vision Mini on Hugging Face Spaces and Trying it Out (7:44)
- Food Vision Big Project Outline (4:17)
- Preparing an EffNetB2 Feature Extractor Model for Food Vision Big (9:38)
- Downloading the Food 101 Dataset (7:45)
- Creating a Function to Split Our Food 101 Dataset into Smaller Portions (13:36)
- Turning Our Food 101 Datasets into DataLoaders (7:23)
- Training Food Vision Big: Our Biggest Model Yet! (20:15)
- Outlining the File Structure for Our Food Vision Big (5:48)
- Downloading an Example Image and Moving Our Food Vision Big Model File (3:33)
- Saving Food 101 Class Names to a Text File and Reading them Back In (6:56)
- Turning Our EffNetB2 Feature Extractor Creation Function into a Python Script (2:20)
- Creating an App Script for Our Food Vision Big Model Gradio Demo (10:41)
- Zipping and Downloading Our Food Vision Big App Files (3:45)
- Deploying Food Vision Big to Hugging Face Spaces (13:34)
- PyTorch Mode Deployment: Main Takeaways, Extra-Curriculum and Exercises (6:13)
Introduction to PyTorch 2.0 and torch.compile
Available in
days
days
after you enroll
- Introduction to PyTorch 2.0 (6:01)
- What We Are Going to Cover and PyTorch 2 Reference Materials (1:21)
- Getting Started with PyTorch 2.0 in Google Colab (4:19)
- PyTorch 2.0 - 30 Second Intro (3:20)
- Getting Setup for PyTorch 2.0 (2:22)
- Getting Info from Our GPUs and Seeing if They're Capable of Using PyTorch 2.0 (6:49)
- Setting the Default Device in PyTorch 2.0 (9:40)
- Discussing the Experiments We Are Going to Run for PyTorch 2.0 (6:42)
- Creating a Function to Setup Our Model and Transforms (10:17)
- Discussing How to Get Better Relative Speedups for Training Models (8:23)
- Setting the Batch Size and Data Size Programmatically (7:15)
- Getting More Speedups with TensorFloat-32 (9:53)
- Downloading the CIFAR10 Dataset (7:00)
- Creating Training and Test DataLoaders (7:38)
- Preparing Training and Testing Loops with Timing Steps (4:58)
- Experiment 1 - Single Run without Torch Compile (8:22)
- Experiment 2 - Single Run with Torch Compile (10:38)
- Comparing the Results of Experiments 1 and 2 (11:19)
- Saving the Results of Experiments 1 and 2 (4:39)
- Preparing Functions for Experiments 3 and 4 (12:41)
- Experiment 3 - Training a Non-Compiled Model for Multiple Runs (12:44)
- Experiment 4 - Training a Compiled Model for Multiple Runs (9:57)
- Comparing the Results of Experiments 3 and 4 (5:23)
- Potential Extensions and Resources to Learn More (5:50)
Where To Go From Here?
Available in
days
days
after you enroll