Using the TensorDataset class

In practice, loading your data into a PyTorch dataset will be one of the first steps you take in order to create and train a neural network with PyTorch.

The TensorDataset class is very helpful when your dataset can be loaded directly as a NumPy array. Recall that TensorDataset() can take one or more NumPy arrays as input.

In this exercise, you'll practice creating a PyTorch dataset using the TensorDataset class.

torch and numpy have already been imported for you, along with the TensorDataset class.

This is a part of the course

“Introduction to Deep Learning with PyTorch”

Exercise instructions

Create a TensorDataset using the torch_features and the torch_target tensors provided (in this order).
Return the last element of the dataset.

Hands-on interactive exercise

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

import numpy as np
import torch
from torch.utils.data import TensorDataset

np_features = np.array(np.random.rand(12, 8))
np_target = np.array(np.random.rand(12, 1))

torch_features = torch.tensor(np_features)
torch_target = torch.tensor(np_target)

# Create a TensorDataset from two tensors
dataset = ____

# Return the last element of this dataset
print(____)

Edit and Run Code

This exercise is part of the course

Introduction to Deep Learning with PyTorch

IntermediateSkill Level

4.2+

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