机器学习的数据处理部分 Dataset与DataLoader

关于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]