小白学Pytorch使用（3）：Mnist手写数字集分类---卷积

任务背景

使用Pytorch框架搭建神经网络进行Mnist手写数字集分类。数据可以自行下载进行本地链接，也可直接通过代码下载。
mnist数据集下载链接

一、导入库

# pytorch框架
import torch
import torch.nn as nn
# 优化器
import torch.optim as optim
import torch.nn.functional as F
# datasets处理数据集并存在内置数据集；transforms数据预处理
from torchvision import datasets, transforms
# 画图展示库
import matplotlib.pyplot as plt
# 矩阵计算库
import numpy as np

二、参数定义及数据集导入

# 定义超参数
# 输入图像尺寸28*28
input_size = 28  
# 分类标签数，即标签的种类数
num_classes = 10  
# 循环周期，循环三轮
num_epochs = 3 
# 单次训练（验证）批次大小：64张图一个batch_size
batch_size = 64  

# 导入训练集
# datasets中内置MNIST数据集。root：下载路径根目录；train：是否是训练集；transform：转变为tensor格式；download：是否下载数据集（本地有就不用下载，False）
train_dataset = datasets.MNIST(root='./data',
                            train=True,
                            # tensor格式
                            transform=transforms.ToTensor(),
                            download=False)

# 导入测试集
#train：是否是训练集，False即测试集
test_dataset = datasets.MNIST(root='./data',
                           train=False,
                           # tensor格式
                           transform=transforms.ToTensor())

# 构建batch数据
# 数据集打乱划分batch。dataset：数据集；batch_size：单个batch数据大小；shuffle：是否打乱数据。
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

三、卷积模块构建

# 类名随意定义，这里使用CNN
class CNN(nn.Module):
    # 构造函数
    def __init__(self):
        super(CNN, self).__init__()
        # 卷积层1
        # 输入大小 (1, 28, 28)————部分工具包是（28，28，1）的，如果存在格式不符的话需要转换
        # nn.Sequential顺序执行内部层级
        self.conv1 = nn.Sequential(  
            # 2D卷积Conv2d——图像数据；3D卷积Conv3d——视频数据（比2D多了时间维度）；1D卷积Conv1d——结构化数据（一般使用全连接）
            nn.Conv2d(
                # 输入图像通道数，如灰度图1通道，rgb图3通道
                in_channels=1,
                # 输出个数，即卷积核个数，卷积结束输出特征图个数       计算卷积后特征图尺寸公式（H-FH+2P）/S + 1——————H输入图高（宽），FH卷积核高（宽），P即padding，S即stride，除法向下取整
                out_channels=16,
                # 卷积核大小，如3*3卷积核，这里使用5*5卷积核
                kernel_size=5,
                # 步长，卷积核单次移动一格
                stride=1,
                # padding是几就在输入图边缘填充几圈0。如果希望卷积后大小跟原来一样，需要设置padding=(kernel_size-1)/2 if stride=1
                padding=2,
            ),  # 输出的特征图为 (16, 28, 28)
            # 非线性映射，激活函数relu
            nn.ReLU(),
            # 进行池化操作（2x2 区域）, 输出结果为： (16, 14, 14)————池化不改变特征图个数，只改变特征图尺寸
            nn.MaxPool2d(kernel_size=2),
        )
        # 卷积层2
        # 输入 (16, 14, 14)
        self.conv2 = nn.Sequential(  
            nn.Conv2d(16, 32, 5, 1, 2),  # 输出 (32, 14, 14)
            nn.ReLU(),  # relu层
            # 输入(32, 14, 14)
            nn.Conv2d(32, 32, 5, 1, 2),	# 输出（32， 14， 14）
            nn.ReLU(),
            nn.MaxPool2d(2),  # 输出 (32, 7, 7)
        )
		# 卷积层3
		# 输入 (32, 7, 7)
        self.conv3 = nn.Sequential(  
            nn.Conv2d(32, 64, 5, 1, 2),  # 输出 (64, 7, 7)
            nn.ReLU(),  
        )
		# 全连接层
		# 将特征矩阵拉长
        self.out = nn.Linear(64 * 7 * 7, 10)  

    # 前向传播
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        # 特征图转换为2维矩阵，才能输入全连接层进行计算
        # x.view等价于x.reshape操作：x为(batch,c,h,w)类型，flatten操作后为(batch, c*h*w)即(batch_size, 32 * 7 * 7)
        x = x.view(x.size(0), -1)
        output = self.out(x)
        # print(output)
        # 10分类每种类别对应的概率[-8.1265e-02, -2.8372e-02, -3.3683e-01,  1.3532e-01,  1.5830e-01, 8.1468e-02,  2.2857e-03, -7.4673e-02,  3.8515e-02,  4.5618e-02]
        return output

四、准确率统计

# 准确率统计函数
def accuracy(predictions, labels):
    # torch.max返回最大值和最大值索引，取索引值。预测类别为0-9，因此返回概率最高的那个索引值即为预测类别
    pred = torch.max(predictions.data, 1)[1]
    # 统计预测值和实际值相同的个数
    rights = pred.eq(labels.data.view_as(pred)).sum()
    # 返回预测正确的个数、标签总长度即数据总数
    return rights, len(labels)

五、网络训练

# 实例化网络
net = CNN()
# 损失函数
criterion = nn.CrossEntropyLoss()
# 优化器，普通的随机梯度下降算法
optimizer = optim.Adam(net.parameters(), lr=0.001)  

# 开始训练循环
for epoch in range(num_epochs):
    # 当前epoch的结果保存下来
    train_rights = []
	# 针对容器中的每一个批进行循环
    for batch_idx, (data, target) in enumerate(train_loader):  
        # 训练
        net.train()
        # 输出训练结果
        output = net(data)
        # 计算损失
        loss = criterion(output, target)
        # 梯度归零
        optimizer.zero_grad()
        # 反向传播
        loss.backward()
        # 参数更新
        optimizer.step()
        # 预测正确个数统计
        right = accuracy(output, target)
        # 预测结果储存
        train_rights.append(right)

        # 每100个batch size进行一次验证
        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)

            # 准确率计算		前者为预测正确数目求和，后者为每个batch_size中标签数目求和
            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]))

训练结果展示：

五层CNN神经网络训练3轮，准确率在98.75%。