自己实现全连接神经网络（实验篇）

一. 代码清晰 思路第一

我们将代码分成四个大模块，第一步：引包（并不是什么很重要的模块）；第二步：导入数据集；第三步：编写网络主干部分；第四部分：运行训练以及测试阶段

数据集

数据集本次实验选择的是简单常见的MNIST手写数字数据集，打印一张图片情况如下图所示：

本次任务是对该数据集进行十分类任务，将0-9十个数字进行分类处理。图片大小均为12828的单通道图片。

二.思路清晰 代码写起

2.1 导包

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import datasets,transforms
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
%matplotlib inline

2.2 导入数据

#定义超参数
input_size = 28 #图像尺寸28 * 28
num_classes = 10 #10分类
num_epochs = 3 #训练的总循环周期
batch_size = 64 #一个批次64张图片

#读取数据集
train_data = datasets.MNIST(root="./data", 
                            train=True, 
                            transform=transforms.ToTensor(), 
                            download=True)

test_data = datasets.MNIST(root="./data", 
                           train=False, 
                           transform=transforms.ToTensor(), 
                          )

train_loader = torch.utils.data.DataLoader(dataset = train_data,
                                          batch_size = batch_size,
                                          shuffle = True)
test_loader = torch.utils.data.DataLoader(dataset = test_data,
                                          batch_size = batch_size,
                                          shuffle = True)

在这个模块中我们首先定义了超参数，包括了输入图像的尺寸、类别总数、训练循环次数以及batch的大小。

数据的导入我们使用了包中自带的MNIST数据集直接进行下载，再用DataLoader进行迭代取数据

2.3 卷积网络模块构建

这里需要注意下面两点
1.卷及网络层一般为：卷积层+relu+池化层
2.卷积后的结果仍为特征图，需转换成向量后再做分类或回归任务

class CNN(nn.Module):
    def __init__(self):
        super(CNN , self).__init__()
        self.conv1 = nn.Sequential(        # 输入图像大小为（1，28，28）
            nn.Conv2d(
                in_channels = 1,           # 灰度图  channel可以理解为特征图个数
                out_channels = 16,         #共输出16个特征图
                kernel_size = 5,           #卷积核大小
                stride = 1,
                padding = 2,               #卷积后图像大小不变 padding = （kernel_size-1）/2 
            ),  
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2), #池化操作（2×2）, 输出尺寸（16，14，14）
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16 , 32 , 5 ,1 , 2), #输入channel：16 ，输出32 ，卷积核尺寸5 ， 步长 1 ， padding 2
            nn.ReLU(),
            nn.MaxPool2d(2)                #输出（32，7，7）
        )
        self.out = nn.Linear(32 * 7 * 7 , 10)  #全连接输出结果
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0) , -1)         #flatten操作，输出结果为（batch_size, 32*7*7）
        output = self.out(x)
        return output

同时在这之后我们编写计算正确率的函数：

def accuracy(prediction , labels):
    pred = torch.max(prediction , 1)[1]                #取出得分最高的分数值以及索引（类别）
    rights = pred.eq(labels.data.view_as(pred)).sum()  #判断正确的个数
    return rights,len(labels)            

2.4 运行训练以及测试阶段

损失函数：交叉熵损失函数
优化器选择adam：
Adam(Adaptive Moment Estimation)本质上是带有动量项的RMSprop，它利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。它的优点主要在于经过偏置校正后，每一次迭代学习率都有个确定范围，使得参数比较平稳。

#实例化
net = CNN()

#损失函数
criterion = nn.CrossEntropyLoss()

#优化器
optimizer = optim.Adam(net.parameters() , lr = 0.001)   #定义优化器，随机梯度下降法

#循环epoch
for epoch in range(num_epochs):
    #保存当前epoch的结果
    train_rights = []
    
    for batch_idx , (data , target) in enumerate(train_loader): #针对容器中的每一个batch进行循环
        net.train()
        output = net(data)                  #前向传播输出结果
        loss = criterion(output , target)   #计算损失
        optimizer.zero_grad()               #清空过往梯度
        loss.backward()                     #反向传播
        optimizer.step()                    #更新所有的参数 (一旦梯度被如backward()之类的函数计算好后，我们就可以调用这个函数)
        right = accuracy(output , target)
        train_rights.append(right)
        
        if batch_idx % 100 == 0:     
            net.eval()                     #网络测试
            val_rights = []                #存测试正确的结果
            
            for (data , target) in test_loader:
                output = net(data)
                right = accuracy(output , target)
                val_rights.append(right)
                
            #计算准确率
            train_r = (sum([tup[0] for tup in train_rights]) , sum([tup[1] for tup in train_rights])) #(累计正确个数，总个数)
            val_r = (sum([tup[0] for tup in val_rights]) , sum([tup[1] for tup in val_rights]))
            
            print('当前epoch：{} [{}/{} ({:.0f}%)]\t损失：{:.6f}\t训练集准确率：{:.2f}%\t测试集准确率：{:.2f}%'.format(
                epoch , batch_idx * batch_size , len(train_loader.dataset),
                100. * batch_idx / len(train_loader),
                loss.data,
                100. * train_r[0].numpy() / train_r[1],
                100. * val_r[0].numpy() / val_r[1]
            ))

运行结果