Creating one-hot encoded labels

One-hot encoding is a technique that turns a single integer label into a vector of N elements, where N is the number of classes in your dataset. This vector only contains zeros and ones. In this exercise, you'll create the one-hot encoded vector of the label y provided.

You'll practice doing this manually, and then make your life easier by leveraging the help of PyTorch! Your dataset contains three classes, and the class labels range from 0 to 2 (e.g., 0, 1, 2).

NumPy is already imported as np, and torch.nn.functional as F. The torch package is also imported.

This is a part of the course

“Introduction to Deep Learning with PyTorch”

Exercise instructions

Manually create a one-hot encoded vector of the ground truth label y by filling in the NumPy array provided.
Create a one-hot encoded vector of the ground truth label y using PyTorch.

Hands-on interactive exercise

Have a go at this exercise by completing this sample code.

y = 1
num_classes = 3

# Create the one-hot encoded vector using NumPy
one_hot_numpy = np.array([____, ____, ____])

# Create the one-hot encoded vector using PyTorch
one_hot_pytorch = ____

Edit and Run Code

This exercise is part of the course

Introduction to Deep Learning with PyTorch

IntermediateSkill Level

4.2+

Learn how to build your first neural network, adjust hyperparameters, and tackle classification and regression problems in PyTorch.

Start Course for Free

Self-driving cars, smartphones, search engines... Deep learning is now everywhere. Before you begin building complex models, you will become familiar with PyTorch, a deep learning framework. You will learn how to manipulate tensors, create PyTorch data structures, and build your first neural network in PyTorch.

Exercise 1: Introduction to deep learning with PyTorch Exercise 2: Getting started with PyTorch tensors Exercise 3: Checking and adding tensors Exercise 4: Creating our first neural network Exercise 5: Your first neural network Exercise 6: Stacking linear layers Exercise 7: Discovering activation functions Exercise 8: Activate your understanding!Exercise 9: The sigmoid and softmax functions

To train a neural network in PyTorch, you will first need to understand the job of a loss function. You will then realize that training a network requires minimizing that loss function, which is done by calculating gradients. You will learn how to use these gradients to update your model's parameters, and finally, you will write your first training loop.

Exercise 1: Running a forward pass Exercise 2: Building a binary classifier in PyTorch Exercise 3: From regression to multi-class classification Exercise 4: Using loss functions to assess model predictions Exercise 5: Creating one-hot encoded labels

Exercise 6: Calculating cross entropy loss Exercise 7: Using derivatives to update model parameters Exercise 8: Accessing the model parameters Exercise 9: Updating the weights manually Exercise 10: Using the PyTorch optimizer Exercise 11: Writing our first training loop Exercise 12: Using the MSELoss Exercise 13: Writing a training loop

Hyperparameters are parameters, often chosen by the user, that control model training. The type of activation function, the number of layers in the model, and the learning rate are all hyperparameters of neural network training. Together, we will discover the most critical hyperparameters of a neural network and how to modify them.

Exercise 1: Discovering activation functions between layers Exercise 2: Implementing ReLU Exercise 3: Implementing leaky ReLU Exercise 4: Understanding activation functions Exercise 5: A deeper dive into neural network architecture Exercise 6: Counting the number of parameters Exercise 7: Manipulating the capacity of a network Exercise 8: Learning rate and momentum Exercise 9: Experimenting with learning rate Exercise 10: Experimenting with momentum Exercise 11: Layer initialization and transfer learning Exercise 12: Fine-tuning process Exercise 13: Freeze layers of a model Exercise 14: Layer initialization

Training a deep learning model is an art, and to make sure our model is trained correctly, we need to keep track of certain metrics during training, such as the loss or the accuracy. We will learn how to calculate such metrics and how to reduce overfitting using an image dataset as an example.

Exercise 1: A deeper dive into loading data Exercise 2: Using the TensorDataset class Exercise 3: From data loading to running a forward pass Exercise 4: Evaluating model performance Exercise 5: Writing the evaluation loop Exercise 6: Calculating accuracy using torchmetrics Exercise 7: Fighting overfitting Exercise 8: Experimenting with dropout Exercise 9: Understanding overfitting Exercise 10: Improving model performance Exercise 11: Implementing random search Exercise 12: Wrap-up video