I am experimenting/learning with using the torch.utils.data.Dataset feature with a common data set, MNIST, in its CSV format. When I use this same code, involving more complex operations on an NLP data set, it works wonderfully fast and as expected. When I tried to port my code over to another data set, MNIST in CSV format, I am stunned at how slow it emits data from the DataLoader when I compare it to PyTorch’s datasets.MNIST.
Consider the following:
import time
from torchvision import datasets
from torchvision import transforms
from torch.utils.data import Dataset, Subset
from torch.utils.data import random_split, DataLoader, RandomSampler


# Create Dataset
class CSVDataset(Dataset):
    """MNIST dataset."""

    def __init__(self, csv_file, target, transform=None):
        """
        Args:
            csv_file (string): Path to the csv file with annotations.
            features (string): column(s) containing feature data.
            target (string): column containing the dependent variable.
            transform (callable, optional): Optional transform to be applied
                on a sample.
        """
        # initialize
        self.data_frame = pd.read_csv(csv_file)
        self.features = [x for x in self.data_frame.columns if x != str(target)]
        self.target = target
        self.transform = transform
        return None

        # get length of df
    def __len__(self):
        return len(self.data_frame)

        # get target
    def __get_target__(self):
        return self.data_frame[self.target]

        # get df filtered by indices
    def __get_values__(self, indices):
        return self.data_frame.iloc[indices]

    def __getitem__(self, idx):
        if torch.is_tensor(idx):
            idx = idx.tolist()

        # pull a sample of data
        features = self.data_frame.iloc[idx][self.features]
        target = self.data_frame.iloc[idx][self.target]

        # hold sample in a dict
        sample = {'features': torch.tensor(features),
                  'target': torch.tensor(target),
                  'idx': torch.tensor(idx)}

        if self.transform:
            sample = self.transform(sample)

        return sample

# instantiate the lazy data set
csv_dataset = CSVDataset(csv_file='https://datahub.io/machine-learning/mnist_784/r/mnist_784.csv',
                         target='class',
                         transform=None)

# set train, valid, and test size
train_size = int(0.8 * len(csv_dataset))
valid_size = int(0.1 * len(csv_dataset))

# use random split to create three data sets; 
train_ds, valid_ds, test_ds = torch.utils.data.random_split(csv_dataset, [train_size, valid_size, valid_size])


train_csv_loader = DataLoader(dataset=train_ds,
                          batch_size=100,
                          shuffle=True)
# check the output
start = time.time()
for i, batch in enumerate(train_csv_loader):
    if i == 50:
        break
end = time.time()
print(end - start) # 71.06

And for comparison, PyTorch’s version emits data to the DataLoader over 100x faster.
# and officially from PyTorch
train_dataset = datasets.MNIST(root='data',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

train_loader = DataLoader(dataset=train_dataset,
                          batch_size=100,
                          shuffle=True)

# check the output
start = time.time()
for i, batch in enumerate(train_loader):
    if i == 50:
        break
end = time.time() 
print(end - start)   # 0.52

I am confused as to what is causing such a slowdown when I am using nearly the same strategy (the Dataset class), with more operations for NLP (also from a CSV file), and it works very fast.
Thanks for your consideration and time!