《PyTorch深度学习实践》学习笔记:加载数据集

文章目录

  • 前言
  • 一、Mini-batch基础概念
  • 二、DataLoader使用
  • 三、模型准备、损失函数、优化器
  • 四、完整代码
  • 五、Pytorch内置数据集
  • 六、课后练习
    • 1.准备数据集
    • 2.定义模型
    • 3.优化器和损失函数
    • 4.训练模型
    • 5.测试模型
  • 总结


前言

在前面的内容中,在训练的时候我们使用的都是全部的数据进行训练,这种在时间上比较好,但是性能上会遇到一些问题,比如鞍点;此外,我们还知道一种随机梯度下降,这种训练是每次取一个数据去计算梯度,这种方法能够有效的解决鞍点的问题,而且性能相对较好,但是每次一个点时间消耗多,而且不能利用CPU/GPU的并行计算能力;把全部的梯度下降和随机梯度下降进行一个折中(时间和性能进行折中),得出了批量梯度下降,也就是Mini-batch梯度下降,也就是每次训练时去一小批数据进行训练。


一、Mini-batch基础概念

当我们使用Mini-batch进行训练的时候,我们就需要通过两层循环还进行:

for epoch in range(trainging_epochs):  # 外层代表训练轮数
	for i in range(total_batchs):      # 内存对batch进行迭代
  • Epoch:1次epoch表示把所有的训练样本都进行了一次前馈和反馈的训练;

  • Batch_Size:表示一次前馈和反馈所使用的样本数量;

  • Iteration:将样本一共分成了几个Mini-Batch。

例:10000个样本,其中Batch_size=1000,则Iteration=10000/1000=10。

采用Mini-Batch的方法来训练数据时,需要使用Dataset和DataLoader两个工具类:

Dataset:用来构造数据集,使数据集可以通过索引快速取出

DataLoader:取出一个Mini-Batch,一组数据


二、DataLoader使用

使用DataLoader时需要两个基本参数:

  1. shuffle :是否打乱数据顺序,打乱的话每次epoch的Mini-Batch数据都是随机的
  2. batch-size:每个Mini-Batch需要的数据量

dataset提供了索引和长度,这样的话dataloader就可以根据dataset进行小批量的数据集的生成。
《PyTorch深度学习实践》学习笔记:加载数据集_第1张图片
上图batch_size = 2,dataloader的工作先通过shuffle将数据样本打乱,打乱之后进行分组,按照每batch_size为一组,之后在迭代的过程中就是按照每组进行Mini-batch取数据。

在代码层面实现dataset和dataloader:

pytorch的utils.data里面提供Dataset和Dataloader。Dataset是抽象类,而抽象类是不能够实例化的,他只能被其他的子类进行继承,所以我们只能通过继承的方式来自定义我们自己的类。Dataloader是一个类帮助我们来加载数据,可以shuffle以及batch_size,因此我们可以实例化一个Dataloader。

接下来定义我们自己数据集的类:

class DiabetesDataset(Dataset):
    def __init__(self):
        pass
    def __getitem__(self, index):
        pass
    def __len__(self):
        pass

getitem(): 实现数据集的索引,dataset[index]

len(): 返回数据集的长度

在构造数据集的时候需要注意有两点:

  1. 我们把所有的数据都通过init()加载到内存当中,然后我们通过getitem()把构造好的数据集的第i个样本给传出去,这种方法适合于本身的数据集不大,但是对于打的数据集比如图像数据集,init()把数据都读到内存是不可能的,对于图像有时候会把它变成一个一个的文件,有时候会把它放到一个package文件里,所以在init()里面只是做一些初始化,或者说都是读写的,定义一些列表,然后数据集里面的每一条数据的文件名放到相应的列表里面,相应的标签可以读到内存里(比较简单的标签),但是一些数据集的标签也很复杂,例如输入一张图像,输出是图像的每一个像素是属于背景还是前景,这就使得输出的结果也很大,所以对于简单的输出标签,可以选择加载到内存;对于复杂的输出,就可以把它的文件名放到列表里面,等到getitem()可以读取列表里面的第i个文件,然后输入X和输出Y再从文件里读出来,然后再进行返回,这样才能保证内存的高效使用。
  2. 如果数据比较小,就直接读到内存;如果数据集比较大,我们应该考虑是否可以把它直接加载到内存。

关于Dataloader的参数,我们常使用的有四个:

train_loader = DataLoader(dataset=dataset,   # 数据集对象
                          batch_size=32,     # 小批量的样本数量
                          shuffle=True,      # 数据是否打乱
                          num_workers=2)     # 读数据的是否需要多线程(并行化)

关于num_workers在windows中使用需要注意的:
《PyTorch深度学习实践》学习笔记:加载数据集_第2张图片
如果直接使用trainloader进行训练的话,可以会报错(pytorch 0.4),报错的原因是在Linux和windows下实现多进程的方式是不同的,在windows中使用spawn替代了fork,可以会出现runtimeError。

解决问题方法:把loader迭代的训练代码封装起来,封装到if语句里面,或者是封装到函数里面,不直接写到程序的主体里面。
《PyTorch深度学习实践》学习笔记:加载数据集_第3张图片
最终实现我们自己的数据集和加载器:

class DiabetesDataset(Dataset):
    def __init__(self,filepath):
        xy = np.loadtxt(filepath,delimiter=',',dtype=np.float32)  # 糖尿病数据集,结构化表格比较小,直接全部加载到内存
        self.len = xy.shape[0]                                    # 数据集的样本数量
        self.x_data = torch.from_numpy(xy[:,:-1])                 # 输入数据
        self.y_data = torch.from_numpy((xy[:,[-1]]))              # 输出标签


    def __getitem__(self, item):
        return self.x_data[item],self.y_data[item]                # 数据索引

    def __len__(self):
        return self.len                                           # 数据集的长度

dataset = DiabetesDataset('diabetes.csv.gz')
train_loader = DataLoader(dataset=dataset,
                          batch_size=32,
                          shuffle=True,
                          num_workers=2)

三、模型准备、损失函数、优化器

# 模型
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = nn.Linear(8,6)
        self.linear2 = nn.Linear(6,4)
        self.linear3 = nn.Linear(4,1)
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return x
model = Model()
# 损失函数
creation = nn.BCELoss(reduction='mean')
# 优化器
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)

四、完整代码

import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import numpy as np
import torch.nn as nn
import matplotlib.pyplot as plt
class DiabetesDataset(Dataset):
    def __init__(self,filepath):
        xy = np.loadtxt(filepath,delimiter=',',dtype=np.float32)  # 糖尿病数据集,结构化表格比较小,直接全部加载到内存
        self.len = xy.shape[0]                                    # 数据集的样本数量
        self.x_data = torch.from_numpy(xy[:,:-1])                 # 输入数据
        self.y_data = torch.from_numpy((xy[:,[-1]]))              # 输出标签


    def __getitem__(self, item):
        return self.x_data[item],self.y_data[item]                # 数据索引

    def __len__(self):
        return self.len                                           # 数据集的长度

dataset = DiabetesDataset('diabetes.csv.gz')
train_loader = DataLoader(dataset=dataset,
                          batch_size=32,
                          shuffle=True,
                          num_workers=2)

# 模型
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = nn.Linear(8,6)
        self.linear2 = nn.Linear(6,4)
        self.linear3 = nn.Linear(4,1)
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return x
model = Model()
# 损失函数
creation = nn.BCELoss(reduction='mean')
# 优化器
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)
size = len(dataset)

if __name__ == '__main__':
    # 训练
    epoch_list = []
    loss_list = []
    for epoch in range(10): # 模型轮数
        for i,data in enumerate(train_loader,0): # 每次通过dataloader加载一个mini—batch,i代表迭代次数=数据集的大小/batchsize,i从0开始计数
            # 1.准备数据
            inputs,labels = data    # 这一句可以在for循环里面将data直接改为(inputs,labels)这样就可以省略这一步
            # 2.前馈计算
            y_pred = model(inputs)
            # 3.计算损失
            loss = creation(y_pred,labels)
            print(epoch,i,loss.item())
            # 4.梯度清0
            optimizer.zero_grad()
            # 5.反馈计算
            loss.backward()
            # 6.梯度更新
            optimizer.step()
        epoch_list.append(epoch)
        loss_list.append(loss.item())

    plt.plot(epoch_list, loss_list)
    plt.xlabel('epoch')
    plt.ylabel('loss')
    plt.show()

运行结果:
《PyTorch深度学习实践》学习笔记:加载数据集_第4张图片
《PyTorch深度学习实践》学习笔记:加载数据集_第5张图片

五、Pytorch内置数据集

《PyTorch深度学习实践》学习笔记:加载数据集_第6张图片
《PyTorch深度学习实践》学习笔记:加载数据集_第7张图片
关于直接加载MNIST数据集的一些参数:

root :数据集的保存路径
train:是否下载训练集,Train代表训练集,false代表测试集
transform:代表对数据集格式的转化,比如图像数据集的格式为PIL image,通过transform的ToTensor将其转变为Tensor类型。
download:是否需要下载,已经下载好了可以设置为false。

另外一点需要注意:对于训练数据集的dataloader,一般要打乱顺序,而对于测试集的dataloader,一般不需要打乱数据,因为我们要观察测试结果咋样。

六、课后练习

  • Build DataLoader for:
    Titanic dataset: https://www.kaggle.com/c/titanic/data
  • Build a classifier using the DataLoader

官网先下载数据集:下载到自己的项目文件夹下面即可
《PyTorch深度学习实践》学习笔记:加载数据集_第8张图片

1.准备数据集

# 准备数据集
class TitanicDataset(Dataset):
    def __init__(self,filepath):
        xy = pd.read_csv(filepath)
        # 获取数据的总长度
        self.len = xy.shape[0]
        # 选取相关的数据特征
        feature = ["Pclass","Sex","SibSp","Parch","Fare"]
        # 数据变成张量
        self.x_data = torch.from_numpy(np.array(pd.get_dummies(xy[feature])))
        self.y_data = torch.from_numpy(np.array(xy["Survived"]))

    # getitem函数,可以使用索引来访问数据
    def __getitem__(self, item):
        return self.x_data[item],self.y_data[item]

    # 返回数据的条数/长度
    def __len__(self):
        return self.len

这里可以看一下选取的特征以及数据集是长什么样子的:

filepath = "D:\\Documents\\Desktop\\CHENXU\\Machine Learning\\PYTORCH_exercise\\train.csv"
xy = pd.read_csv(filepath)
# 获取数据的总长度
len = xy.shape[0]
# 选取相关的数据特征
feature = ["Pclass", "Sex", "SibSp", "Parch", "Fare"]
# 数据变成张量
a = pd.get_dummies(xy[feature])
print(a.head)
x_data = torch.from_numpy(np.array(pd.get_dummies(xy[feature])))
y_data = torch.from_numpy(np.array(xy["Survived"]))
print(x_data[0:5,:])
print(y_data[0:5])

《PyTorch深度学习实践》学习笔记:加载数据集_第9张图片
同时在这里我们可以看到训练数据x是6维的。

这里使用到了pd.get_dummies进行独热编码,可以参考这篇博文进行理解【特征提取】pd.get_dummies() 详解(One-Hot Encoding)

2.定义模型

# 模型
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = nn.Linear(6,3)
        self.linear2 = nn.Linear(3,1)
        self.sigmoid = nn.Sigmoid()
    
    def forwar(self,x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        return x
    
    # 测试模型
    def test(self,x):
        with torch.no_grad():
            x = self.sigmoid(self.linear1(x))
            x = self.sigmoid(self.linear2(x))
            y = []
            for i in x:
                if i>0.5:
                    y.append(1)
                else:
                    y.append(0)
            return y

# 实例化模型
model = Model()

3.优化器和损失函数

# 优化器和损失函数
creation = nn.BCELoss(reduction='mean')
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)

4.训练模型

if __name__ == '__main__':
    for epoch in range(100):
        for i,(x,y) in enumerate(trainloader,0):
            x = x.float()
            y = y.float()
            y_pred = model(x)
            y_pred = y_pred.squeeze(-1)   # 之前我们查看过y的数据样式是一维的,所以我们需要将预测输出的y也变为一维,这样才能计算loss
            loss = creation(y_pred,y)
            print(epoch,i,loss.item())
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

5.测试模型

# 训练完成之后进行测试
test_data = pd.read_csv('test.csv')
feature = ["Pclass","Sex","SibSp","Parch","Fare"]
test=torch.from_numpy(np.array(pd.get_dummies(test_data[feature])))
test = test.float()
y = model.test(test)

# 输出预测结果
output = pd.DataFrame({'PassengerId':test_data.PassengerId,'Survived':y})
output.to_csv('my_predict.csv',index=False)

提交测试结果到kaggle上,查看结果:
《PyTorch深度学习实践》学习笔记:加载数据集_第10张图片
《PyTorch深度学习实践》学习笔记:加载数据集_第11张图片
第一次提交0.69,然后改变了训练轮数,让多训练了会,分数到了0.73,整个模型还有很大得改变空间,以及数据处理方面应该还有更优的方法,课后还应该接着探索更优的策略。

总结

本节主要学习了pytorch数据集的加载,关键在于怎么继承Dataset父类来自定义我们的子类,从而通过Dataloader加载我们的数据集。

你可能感兴趣的:(pytorch,深度学习,pytorch,学习)