利用MNIST-FASHION进行简单神经网络训练流程

简单神经网络训练流程

1）设置步长lr，动量值gamma，迭代次数epochs，batch_size等信息，（如果需要）设置初始权重w0；
2）导入数据，将数据切分成batches；
3）定义神经网络框架；
4）定义损失函数L(w)，如果需要，将损失函数调整成凸函数，以便求解最小值；
5）定义所使用的优化算法；
6）开始在epoches和batch上循环，执行优化算法：
6.1）调整数据结构，确定数据能够在神经网络、损失函数和优化算法中顺利运行；
6.2）完成向前传播，
6.3）计算初始损失；
6.3）反向传播，在损失函数L(w)上对每一个w求偏导数；
6.4）迭代当前权重；
6.5）清空本轮梯度；
6.6）完成模型进度与监控效果；
7）输出结果

1 导库，设置各种初始值

import torch
from torch import nn as nn
from torch import optim
from torch.nn import functional as F 
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
import torchvision
import torchvision.transforms as transforms
# torchvision：包含数据的模块
# transforms：处理数据的模块
# DataLoader、TensorDataset——对数据的结构、归纳方式进行变化
# torchvison.transforms ——对数据集的数字本身进行修改

# 确定数据、确定优先需要设置的值
lr = 0.15
gamma = 0 
epochs = 10
bs = 128

2 导入数据，分割小批量

mnist = torchvision.datasets.FashionMNIST(
      root = r'E:\MINST-FASHION数据集\MINST-FASHION数据集\FashionMNIST'
      , train = True
      , download = True
      , transform = transforms.ToTensor())

重要方法与属性

len(mnist)   # >60000    查看数据集样本数
mnist.data   #     查看特征张量，这个张量结构看起来非常常规，可惜的是它与我们要输入到模型的数据结构有差异
mnist.targets    # 查看标签
mnist.classes    # 查看类别，也就是不同标签类别解释

# 分割batch
batchdata = DataLoader(mnist,batch_size=bs,shuffle=True)

# 总共有多少个batch
len(batchdata)         # 469

# 查看会放入进入迭代的数据结构
for x,y in batchdata:
    print(x.shape)             # torch.Size([128, 1, 28, 28])
    print(y.shape)             # torch.Size([128])
    break 

input_ = mnist.data[0].numel()     # 784 特征的数目，一般是第一维之外的所有维度相乘的数，输入层神经元个数
output_ = len(mnist.targets.unique())   # 10 分类的数目，输出层神经元个数

##########################简洁代码##########################

import torchvision
import torchvision.transforms as transforms

mnist = torchvision.datasets.FashionMNIST(
      root = r'E:\MINST-FASHION数据集\MINST-FASHION数据集\FashionMNIST'
      , train = True
      , download = True
      , transform = transforms.ToTensor())

batchdata = DataLoader(mnist,batch_size=bs,shuffle=True)

input_ = mnist.data[0].numel() 
output_ = len(mnist.targets.unique()) 

3 定义神经网络的架构

class Model(nn.Module):
    def __init__(self, in_features=10,out_featurs=2):
        super().__init__()
        self.linear1 = nn.Linear(in_features,128,bias=False)  # 一个隐藏层
        self.output = nn.Linear(128,out_featurs,bias=False)   # 一个输出层
        
    def forward(self,x):
        x = x.view(-1,28*28)         # x(128,1,28,28)，后面的维度要拉平           
        # 需要对数据的结构进行一个改变，这里的“-1”代表，我不想算，请pytorch帮我计算
        sigma1 = torch.relu(self.linear1(x))
        z2 = self.output(sigma1)
        sigma2 = F.log_softmax(z2,dim=1)      # 为后面计算准确率使用
        return sigma2

4 定义训练函数

def fit(net,batchdata,lr=0.01,epochs=5,gamma=0):   # net：网络结构，batchdata：数据    batch_size不需要放进去
    criterion = nn.NLLLoss()    # 定义损失函数
    opt = optim.SGD(net.parameters(), lr=lr, momentum=gamma)  # 定义优化算法
    correct = 0
    samples = 0            # 已经查看的数据个数
    for epoch in range(epochs):
        for batch_idx, (x,y) in enumerate(batchdata):
            y = y.view(x.shape[0])   # x:[128,1,28,28]  y=128
            sigma = net.forward(x)   # x是特征张量
            loss = criterion(sigma,y)
            loss.backward()
            opt.step()
            opt.zero_grad()
            
            # 求解准确率
            yhat = torch.max(sigma,1)[1]    # torch.max返回的是【values，indices】
            correct += torch.sum(yhat == y)
            samples += x.shape[0]           # 已经完成一个batch的训练，一个批量为128
            
            # 定义一个规定，打印训练信息
            if(batch_idx+1) % 125 == 0 or batch_idx == len(batchdata)-1:   # batchdata=469,一共有多少个batch，or后面表示每训练一个epoch打印训练信息
                print('Epoch{}:[{}/{}({:.0f}%)]\tLoss:{:.6f}\t Accuracy:{:.3f}'.format(
                                                                                           epoch+1
                                                                                            ,samples
                                                                                            ,len(batchdata.dataset)*epochs
                                                                                            ,100*samples/(len(batchdata.dataset)*epochs)
                                                                                            ,loss.data.item()
                                                                                            ,float(correct*100)/samples))

5 进行训练与评估

# 实例化神经网络，调用优化算法需要的参数
torch.manual_seed(420)
net = Model(in_features=input_, out_featurs=output_)
fit(net,batchdata,lr=lr,epochs=epochs,gamma=gamma)