关于Dataset和DataLoader的概念

Posted 2023-04-11 python算法工程师

关于Dataset和DataLoader的概念

在机器学习中，Dataset和DataLoader是两个很重要的概念，它们通常用于训练和测试模型时的数据处理。
Dataset是指用于存储和管理数据的类。在深度学习中，通常将数据存储在Dataset中，并使用Dataset提供的方法读取和处理数据。Dataset可以是各种类型的数据，例如图像、文本、音频、视频等。在PyTorch中，torch.utils.data.Dataset是一个抽象类，可以用于创建自定义的Dataset类。在自定义Dataset类中，我们需要实现__len__方法和__getitem__方法，用于返回数据集的大小和每个数据样本。例如，我们可以创建一个图像分类的Dataset类，其中每个数据样本是一张图像及其对应的标签。
DataLoader是指用于从Dataset中读取数据的类。在深度学习中，通常将Dataset传递给DataLoader，然后使用DataLoader提供的方法对数据进行批量读取和处理。DataLoader可以实现多线程读取数据、数据打乱、数据增强等功能。在PyTorch中，torch.utils.data.DataLoader是一个类，可以用于创建DataLoader对象。在创建DataLoader对象时，我们可以指定批量大小、是否打乱数据、是否使用多线程读取数据等参数。例如，我们可以创建一个DataLoader对象，用于从图像分类的Dataset中读取数据，并每次读取32个数据样本。
通过使用Dataset和DataLoader，我们可以方便地读取和处理数据，并将其传递给模型进行训练和测试。这种数据处理方式可以大大简化代码，提高代码的可读性和可维护性

如何创建自定义的Dataset类？

在PyTorch中，我们可以通过创建自定义的Dataset类来处理自己的数据。下面是一个示例，说明如何创建自定义的Dataset类：

import torch
from torch.utils.data import Dataset

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

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

    def __getitem__(self, index):
        x = self.data[index]
        y = self.labels[index]
        return x, y

在上述代码中，我们创建了一个名为MyDataset的自定义Dataset类。该类接受两个参数：data和labels，分别表示数据和标签。在类的初始化方法__init__中，我们将传入的数据和标签存储为类的成员变量，以便在后续的方法中使用。

该类实现了__len__方法和__getitem__方法，用于返回数据集的大小和每个数据样本。__len__方法返回数据集的大小，即数据的数量。__getitem__方法接受一个索引index作为参数，并返回该索引对应的数据样本。在该方法中，我们首先获取数据和标签的索引，然后将它们打包成一个元组返回。在实际使用时，我们可以通过调用该类的实例对象的__getitem__方法，以便获取数据集中的数据。

例如，我们可以使用以下代码创建MyDataset的实例对象，然后通过调用该实例对象的__getitem__方法来获取数据集中的数据：

data = torch.randn(100, 3, 32, 32)
labels = torch.randint(0, 10, (100,))
dataset = MyDataset(data, labels)
x, y = dataset[0]
print(x.shape, y)

在上述代码中，我们首先创建了一个随机的数据张量data和标签张量labels，然后使用它们创建了一个MyDataset的实例对象dataset。最后，我们通过调用dataset的__getitem__方法来获取数据集中的第一个数据样本，并输出该数据样本的形状和标签。

通过创建自定义的Dataset类，我们可以方便地处理各种类型的数据，并将其传递给DataLoader对象进行批量读取和处理。

如何使用 DataLoader 从我的自定义数据集中加载数据？

在PyTorch中，我们可以使用DataLoader从自定义的数据集中加载数据。下面是一个示例，说明如何使用DataLoader从自定义的数据集中加载数据：

import torch
from torch.utils.data import DataLoader

# 假设我们创建了一个名为MyDataset的自定义数据集
dataset = MyDataset(data, labels)

# 创建一个批量大小为32且打乱数据的DataLoader对象
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 使用for循环遍历DataLoader对象，以批量的形式加载数据
for batch in dataloader:
    # batch是一个元组，包含一批数据和标签
    x, y = batch
    # 对一批数据和标签进行操作
    ...

在上述代码中，我们首先创建了一个自定义的数据集MyDataset，并将数据和标签作为参数传递进去。然后，我们使用DataLoader创建了一个批量大小为32且打乱数据的DataLoader对象。在使用for循环遍历DataLoader对象时，每个batch返回一个元组，其中包含一批数据和标签。我们可以对每个batch进行操作，例如将其传递给模型进行训练或评估。

需要注意的是，批量大小应该根据可用内存和数据大小进行选择。较大的批量大小可以加速训练，但可能需要更多的内存。打乱数据的参数应该在训练数据中设置为True，在验证和测试数据中设置为False。

my_dataset.py

# import random
# list1 = [1,2,3,4,5,6,7]   # 所有的数据 ,  dataset
#
#
# batch_size =  2          #
# epoch =  2              # 轮次
# shuffle = True
#
# for e in range(epoch):
#     if shuffle:
#         random.shuffle(list1)
#     for i in range(0,len(list1),batch_size): # 数据加载的过程, dataloader
#         batch_data = list1[i:i+batch_size]
#         print(batch_data)

import random
class MyDataset:
    def __init__(self,all_datas,batch_size,shuffle=True):
        self.all_datas = all_datas
        self.batch_size = batch_size
        self.shuffle = shuffle
        self.cursor = 0

    # python魔术方法:某种场景自动触发的方法

    #
    def __iter__(self):  # 返回一个具有__next__的对象
        if self.shuffle:
            random.shuffle(self.all_datas)
        self.cursor = 0
        return self



    def __next__(self):
        if self.cursor >= len(self.all_datas):
            raise StopIteration

        batch_data = self.all_datas[self.cursor:self.cursor+self.batch_size]
        self.cursor += self.batch_size
        return batch_data


if __name__ == "__main__":

    all_datas = [1,2,3,4,5,6,7]
    batch_size = 2
    shuffle = True
    epoch = 2

    dataset = MyDataset(all_datas,batch_size,shuffle)

    for e in range(epoch):
        for batch_data in dataset:  # 把一个对象放在for上时, 会自动调用这个对象的__iter__,
            print(batch_data)

[3, 1]
[5, 7]
[6, 4]
[2]
[5, 3]
[2, 7]
[4, 1]
[6]

my_dataset_dataloader.py

import random
import numpy as np
class MyDataset:
    def __init__(self,all_datas,batch_size,shuffle=True):
        self.all_datas = all_datas
        self.batch_size = batch_size
        self.shuffle = shuffle


    # python魔术方法:某种场景自动触发的方法

    #
    def __iter__(self):  # 返回一个具有__next__的对象
        # if self.shuffle:
        #     random.shuffle(self.all_datas)
        # self.cursor = 0
        # return self
        return DataLoader(self)

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


    # def __next__(self):
    #     if self.cursor >= len(self.all_datas):
    #         raise StopIteration
    #
    #     batch_data = self.all_datas[self.cursor:self.cursor+self.batch_size]
    #     self.cursor += self.batch_size
    #     return batch_data


class DataLoader:
    def __init__(self,dataset):
        self.dataset = dataset
        self.indexs = [i for i in range(len(self.dataset))]
        if self.dataset.shuffle == True:
            np.random.shuffle(self.indexs)
        self.cursor = 0

    def __next__(self):
        if self.cursor >= len(self.dataset.all_datas):
            raise StopIteration

        index = self.indexs[self.cursor:self.cursor + self.dataset.batch_size]

        batch_data = self.dataset.all_datas[index]
        self.cursor += self.dataset.batch_size
        return batch_data



if __name__ == "__main__":

    all_datas = np.array([1,2,3,4,5,6,7])
    batch_size = 2
    shuffle = True
    epoch = 2

    dataset = MyDataset(all_datas,batch_size,shuffle)

    for e in range(epoch):
        for batch_data in dataset:  # 把一个对象放在for上时, 会自动调用这个对象的__iter__,
            print(batch_data)

[7 1]
[5 2]
[4 3]
[6]
[3 1]
[2 5]
[6 7]
[4]

深入浅出 Dataset 与 DataLoader

文章目录

• Dataset & DataLoader
• • 一、自定义Dataset
  • 二、使用 DataLoaders 为训练准备数据
  • 三、迭代数据

Dataset & DataLoader

1、官方解释(Google翻译)：
处理数据样本的代码可能会变得混乱且难以维护；理想情况下，我们希望我们的数据集代码与我们的模型训练代码分离，以获得更好的可读性和模块化。
PyTorch 提供了两个数据原语：torch.utils.data.DataLoader 和torch.utils.data.Dataset 允许我们使用预加载的数据集以及我们自己的数据。 Dataset存储样本及其对应的标签，并DataLoader在 周围包裹一个可迭代对象Dataset，以便轻松访问样本。
2、Dataset
是所有开发人员训练、测试使用的所有数据集的一个模板。
Dataset定义了数据集的内容，它相当于一个类似列表的数据结构，具有确定的长度，能够用索引获取数据集中的元素。
DataLoader定义了按batch加载数据集的方法，它是一个实现了__iter__方法的可迭代对象，每次迭代输出一个batch的数据。
3、DataLoader
DataLoader能够控制batch的大小，batch中元素的采样方法，以及将batch结果整理成模型所需输入形式的方法，并且能够使用多进程读取数据。
在绝大部分情况下，我们只需实现Dataset的 __len__方法 和 __getitem__方法 ，就可以轻松构建自己的数据集，并用默认数据管道进行加载。

一、自定义Dataset

自定义 Dataset 类需继承 pytorch官方的DataSet类 还必须实现三个函数：__init__、__len__和__getitem__。
init：初始化(一般需要传入 数据集文件路径，将文件保存到哪个路径，预处理函数)
len：返回数据集的大小
getitem：根据索引，返回样本的特征和标签。

import os.path

import pandas as pd
from torch.utils.data import Dataset
from torchvision.io import read_image


class MyImageDataset(Dataset):
    def __init__(self, annotations_file, data_dir, transform=None, target_transform=None):
        # annotations_file：文件路径
        # data_dir: 将文件保存到哪个路径
        self.data_label = pd.read_csv(annotations_file)
        self.data_dir = data_dir
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        # 返回数据集总的大小
        return len(self.data_label)

    def __getitem__(self, item):
        data_name = os.path.join(self.data_dir, self.data_label.iloc[item, 0])
        image = read_image(data_name)
        # 对特征进行预处理
        label = self.data_label.iloc[item, 1]
        if self.transform:
            image = self.transform(image)
        # 对标签进行预处理
        if self.target_transform:
            label = self.target_transform(label)
        return image, label

其实我们只需要修改的是annotations_file, data_dir, transform(特征预处理), target_transform(标签预处理) 这四个参数。
Dataset每次只处理一个样本，返回的是一个特征和该特征所对应的标签

二、使用 DataLoaders 为训练准备数据

检索我们数据集的Dataset特征并一次标记一个样本。在训练模型时，我们通常希望以“小批量”的形式传递样本，在每个 epoch (每次迭代多少次)重新洗牌以减少模型过度拟合，并使用 Pythonmultiprocessing加速数据检索。

batch_size:一次训练所选取的样本数
shuffle=True: 每个训练周期后对数据进行随机排列

from torch.utils.data import DataLoader

train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

三、迭代数据

我们已将该数据集加载到 中，DataLoader并且可以根据需要遍历数据集。下面的每次迭代都会返回一批train_features和train_labels（分别包含batch_size=64特征和标签）。
iter()方法 得到一个迭代器。
next() 方法 依次获得特征和标签。

train_features, train_labels = next(iter(train_dataloader))