卷积神经网络08(数据及加载)

Batch-Size

所有样本都参与训练称为一个epoch
每次训练用的样本数量叫做batch-size
迭代

数据及进行打乱（shuffle）



Dataset是一个抽象类，是不能直接实例化的
而DataLoader是可以直接实例化的


用到的loader函数，需要改写成，在0.4版本下会出现这样的问题



还是4步，准备数据集，设计模型，建立模型和优化，训练

例如minist数据集

import torch
from torch.utils.data import Dataset
from torch.utils.data import  DataLoader
import numpy as np
import matplotlib.pyplot as plt

class DiabetesDataset(Dataset):
    def __init__(self,filepath):
        xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32)  # delimiter分割 dtype=np.float32一般都使用32位的浮点数
        self.len = xy.shape[0]  #可以取得输入的个数
        self.x_data = torch.from_numpy(xy[:, :-1])
        self.y_data = torch.from_numpy(xy[:, [-1]])  # [-1]拿出来的是一个矩阵而不是向量，要保证在计算的时候是矩阵

    def __getitem__(self, index):   #魔方函数
        return self.x_data[index],self.y_data[index]  #返回元祖类型，分开，便于后面使用和处理

    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(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.linear1 = torch.nn.Linear(8,7)
        self.linear2 = torch.nn.Linear(7,6)
        self.linear3 = torch.nn.Linear(6,5)
        self.linear4 = torch.nn.Linear(5,4)
        self.linear5 = torch.nn.Linear(4,3)
        self.linear6 = torch.nn.Linear(3,2)
        self.linear7 = torch.nn.Linear(2,1)
        self.sigmoid = torch.nn.Sigmoid()  # nn下的sigmoid pytorch激活函数很多，可以都试试，例如：rule...torch.nn.Rule() //取值0-1
        # self.activate = torch.nn.Sigmoid()

    def forward(self,x):
        # x = self.sigmoid(self.linear1(x))
        # x = self.sigmoid(self.linear2(x))
        # x = self.sigmoid(self.linear3(x))
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        x = self.sigmoid(self.linear4(x))
        x = self.sigmoid(self.linear5(x))
        x = self.sigmoid(self.linear6(x))
        x = self.sigmoid(self.linear7(x))
        return x



model = Model()

# 损失函数和优化器
criterion = torch.nn.BCELoss(reduction='sum')

optimizer = torch.optim.SGD(model.parameters(),lr = 0.01)

epoch_l = []
loss_l = []

if __name__ == '__main__':
# data是从上面拿到的（x,y) return self.x_data[index],self.y_data[index] ,从数据集中拿出
    for epoch in range(20):
        for i,data, in enumerate(train_loader,0):  # 0是下标从0开始计数
            # 1 prepare data
            inputs, labels = data  # data是x,y元组

            # 2 Forward
            y_pred = model(inputs)
            loss = criterion(y_pred,labels)
            print(epoch,i,loss.item())

            # 3 Backward
            optimizer.zero_grad()
            loss.backward()

            # 4 updata
            optimizer.step()
        epoch_l.append(epoch)
        loss_l.append(loss.item())

    plt.plot(epoch_l,loss_l,c='r')
    plt.show()

不知道跑出来是个什么鬼，哈哈哈，你们自己试试吧，这个是在上一篇博文上扩展的一个