Dataset class (custom datasets) in PyTorch - Model Metrics & Evaluation

Metrics & Evaluation - Dataset class (custom datasets)

Which metric matters for Dataset class (custom datasets) and WHY

When working with custom datasets in PyTorch, the key metric is data loading correctness and efficiency. This means your dataset class must correctly load and return the right data samples and labels without errors. While this is not a model metric like accuracy, it is critical because bad data loading leads to wrong training and poor model results. Efficiency matters too, so training is not slowed down.

Confusion matrix or equivalent visualization

For dataset classes, we don't have a confusion matrix. Instead, we check data integrity by verifying the number of samples matches expectations and that each sample-label pair is correct. For example:

    Dataset size: 1000 samples
    Sample 0: image shape (3, 224, 224), label: 5
    Sample 999: image shape (3, 224, 224), label: 2
    

This ensures the dataset class correctly loads all data.

Tradeoff: Correctness vs Efficiency in Dataset class

There is a tradeoff between loading data correctly and loading it fast. If you load all data into memory at once, loading is fast but uses lots of RAM. If you load data on the fly, it uses less memory but can slow training. The goal is to balance correctness (no errors, right labels) with efficiency (fast enough to keep training smooth).

What "good" vs "bad" looks like for Dataset class

Good: Dataset returns correct samples and labels, length matches dataset size, no crashes during training, data shapes are consistent, and loading speed keeps up with training.

Bad: Dataset returns wrong labels, crashes on some indexes, length is wrong, data shapes vary unexpectedly, or loading is too slow causing training delays.

Common pitfalls in Dataset class metrics

• Mixing up labels and data order causing wrong training signals.
• Not implementing __len__ or __getitem__ correctly.
• Loading all data into memory causing crashes on large datasets.
• Slow data loading blocking GPU training.
• Data leakage by accidentally including test data in training dataset.

Self-check question

Your custom dataset class returns 1000 samples but during training, the model gets random results and loss does not improve. What could be wrong?

Answer: The dataset might be returning wrong labels or mismatched data-label pairs. Check your __getitem__ method to ensure correct data loading.

Key Result

For custom datasets, correctness of data loading and label matching is the key metric to ensure valid 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