Why Dataset class (custom datasets) in PyTorch? - Purpose & Use Cases

The Big Idea

What if you could stop wasting hours on loading data and start training your model faster and smarter?

The Scenario

Imagine you have hundreds of images stored in different folders, each representing a category, and you need to load them one by one to train a model.

You try to open each file manually, read it, and label it correctly before feeding it to your program.

The Problem

This manual approach is slow and tiring because you have to write repetitive code for loading and labeling each file.

It's easy to make mistakes like mixing up labels or forgetting files, and updating your code for new data becomes a headache.

The Solution

The Dataset class in PyTorch lets you create a custom way to load and organize your data automatically.

You write simple code once to tell it how to get each item and its label, and then PyTorch handles the rest efficiently.

Before vs After

✗ Before

images = []
labels = []
for file in files:
    img = open_image(file)
    label = get_label(file)
    images.append(img)
    labels.append(label)

✓ After

from torch.utils.data import Dataset

class CustomDataset(Dataset):
    def __init__(self, files):
        self.files = files
    def __len__(self):
        return len(self.files)
    def __getitem__(self, idx):
        img = open_image(self.files[idx])
        label = get_label(self.files[idx])
        return img, label

What It Enables

It makes loading, transforming, and managing large and complex datasets easy and error-free, so you can focus on building your model.

Real Life Example

For example, when training a model to recognize different types of animals from thousands of photos stored in folders, a custom Dataset class can automatically load and label each photo correctly without manual effort.

Key Takeaways

Manual data loading is slow and error-prone.

Custom Dataset class automates data handling.

Simplifies working with complex or large datasets.

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