Dataset class (custom datasets) in PyTorch

Introduction

We use custom Dataset classes to organize and load our own data easily for training machine learning models.

When you have images stored in folders and want to load them with labels.

When your data is in a CSV file and you want to feed it to a model.

When you want to apply transformations like resizing or normalization on the fly.

When you want to load data in batches efficiently during training.

When you want to combine multiple data sources into one dataset.

Syntax

PyTorch

from torch.utils.data import Dataset

class CustomDataset(Dataset):
    def __init__(self, data, labels, transform=None):
        self.data = data
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        sample = self.data[idx]
        label = self.labels[idx]
        if self.transform:
            sample = self.transform(sample)
        return sample, label

The __init__ method sets up your data and any transforms.

The __len__ method returns how many samples you have.

The __getitem__ method returns one sample and label by index.

Examples

A simple dataset with only data, no labels.

PyTorch

class MyDataset(Dataset):
    def __init__(self, data):
        self.data = data

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

Dataset for images with optional transformations.

PyTorch

from torchvision.io import read_image

class ImageDataset(Dataset):
    def __init__(self, image_paths, labels, transform=None):
        self.image_paths = image_paths
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        image = read_image(self.image_paths[idx])
        label = self.labels[idx]
        if self.transform:
            image = self.transform(image)
        return image, label

Sample Model

This program creates a simple dataset with features and labels, then loads it in batches of 2 using DataLoader. It prints each batch's data and labels.

PyTorch

import torch
from torch.utils.data import Dataset, DataLoader

class SimpleDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

# Sample data
features = torch.tensor([[1, 2], [3, 4], [5, 6], [7, 8]])
labels = torch.tensor([0, 1, 0, 1])

# Create dataset
dataset = SimpleDataset(features, labels)

# Create DataLoader to load data in batches
loader = DataLoader(dataset, batch_size=2, shuffle=False)

for batch_idx, (data, target) in enumerate(loader):
    print(f"Batch {batch_idx+1} data:", data)
    print(f"Batch {batch_idx+1} labels:", target)

Important Notes

Always return data and label as a tuple in __getitem__.

Use transforms to preprocess data inside the dataset.

DataLoader helps to load data in batches and shuffle if needed.

Summary

Custom Dataset classes help organize your data for PyTorch models.

Implement __init__, __len__, and __getitem__ methods.

Use DataLoader to load data in batches during training.

Practice

1. What is the main purpose of creating a custom Dataset class in PyTorch?

easy

A. To organize and provide access to your data for training models

B. To define the neural network architecture

C. To perform data visualization

D. To optimize the training speed automatically

Solution

1. Step 1: Understand Dataset role

   A custom Dataset class is designed to organize data and provide easy access to samples and labels.

2. Step 2: Differentiate from other components

   Neural network architecture and visualization are separate tasks, not handled by Dataset classes.

3. Final Answer:

   To organize and provide access to your data for training models -> Option A

4. Quick Check:

   Dataset class = data organization [OK]

Hint: Dataset class organizes data for model input [OK]

Common Mistakes:

• Confusing Dataset with model definition
• Thinking Dataset handles visualization
• Assuming Dataset optimizes training speed

2. Which method must be implemented in a PyTorch custom Dataset class to return the number of samples?

easy

A. __getitem__

B. __init__

C. __len__

D. load_data

Solution

1. Step 1: Recall Dataset methods

   __len__ returns the total number of samples in the dataset.

2. Step 2: Differentiate from other methods

   __getitem__ fetches a sample, __init__ initializes the dataset, load_data is not a standard method.

3. Final Answer:

   __len__ -> Option C

4. Quick Check:

   Count samples = __len__ [OK]

Hint: Use __len__ to get dataset size [OK]

Common Mistakes:

• Using __getitem__ to get length
• Confusing __init__ with length method
• Assuming load_data is required

3. What will be the output of this code snippet?

import torch
from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self):
        self.data = [10, 20, 30]
    def __len__(self):
        return len(self.data)
    def __getitem__(self, idx):
        return self.data[idx] * 2

dataset = MyDataset()
print(len(dataset))
print(dataset[1])

medium

A. 3 and 40

B. 3 and 20

C. Error due to missing DataLoader

D. 3 and 30

Solution

1. Step 1: Calculate length of dataset

   len(dataset) calls __len__, which returns length of self.data = 3.

2. Step 2: Calculate dataset[1]

   dataset[1] calls __getitem__ with idx=1, returns self.data[1]*2 = 20*2 = 40.

3. Final Answer:

   3 and 40 -> Option A

4. Quick Check:

   Length=3, item*2=40 [OK]

Hint: Remember __getitem__ transforms data on access [OK]

Common Mistakes:

• Confusing index values
• Expecting error without DataLoader
• Forgetting the multiplication by 2

4. Identify the error in this custom Dataset class:

from torch.utils.data import Dataset

class SampleDataset(Dataset):
    def __init__(self, data):
        self.data = data
    def __len__(self):
        return self.data
    def __getitem__(self, idx):
        return self.data[idx]

medium

A. __getitem__ should return the index, not data element

B. __len__ should return an integer, not the data list

C. Missing __init__ method

D. Dataset class should inherit from torch.nn.Module

Solution

1. Step 1: Check __len__ method

   __len__ returns self.data, which is a list, but it must return an integer length.

2. Step 2: Verify other methods

   __getitem__ correctly returns data element; __init__ is present; Dataset inheritance is correct.

3. Final Answer:

   __len__ should return an integer, not the data list -> Option B

4. Quick Check:

   __len__ must return length integer [OK]

Hint: __len__ must return integer length [OK]

Common Mistakes:

• Returning list instead of length in __len__
• Confusing Dataset with nn.Module
• Omitting __init__ method

5. You want to create a custom Dataset that loads images and their labels from a folder. Which of these is the best approach to implement the __getitem__ method?

hard

A. Load all images in __init__ and return preloaded images in __getitem__

B. Return the file path as a string without loading the image

C. Only return labels in __getitem__, ignore images

D. Load the image file from disk, apply transformations, and return the image and label

Solution

1. Step 1: Understand __getitem__ role

   __getitem__ should load and return the actual data sample and label when requested.

2. Step 2: Evaluate options

   Loading image on demand with transformations is efficient and standard. Returning file path or only labels is incomplete. Loading all images in __init__ can use too much memory.

3. Final Answer:

   Load the image file from disk, apply transformations, and return the image and label -> Option D

4. Quick Check:

   __getitem__ loads and returns data [OK]

Hint: Load and transform data inside __getitem__ [OK]

Common Mistakes:

• Loading all data in __init__ causing memory issues
• Returning file paths instead of data
• Ignoring images and returning only labels