pytorch之使用MNIST数据集构建CNN

MNIST数据集构建卷积神经网络

我们的MNIST数据是黑白的，分测试集和训练集，我在上一篇文章 pytorch学习之mnist 手写数字识别：https://mp.youkuaiyun.com/editor/html/116197866*有打印**

step1 导入需要的各种库

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
%matplotlib inline

torchvision.datasets使用参考：https://pytorch-cn.readthedocs.io/zh/latest/torchvision/torchvision-datasets/
pytorch torchvision transform使用参考：https://pytorch-cn.readthedocs.io/zh/latest/torchvision/torchvision-transform/

step2.读取数据

1. 分别构建训练集和测试集（验证集）
2. DataLoader来迭代取数据

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

#训练集
train_dataset = datasets.MNIST(root='.\data',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

#测试集
test_dataset = datasets.MNIST(root='.\data',
                             train=False,
                             transform=transforms.ToTensor())

#构建batch数据
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)

下面是我从官网截取的datasets.MNIST（）参数说明，直接看就好咯

transfroms.Totensor() #转化成Tensor()形，

把上面官网的例子执行一下：

torch.utils.data.DataLoader的分析链接放在这里：https://www.cnblogs.com/ranjiewen/p/10128046.html 本文的参数很简单，不做说明

step3.卷积网络模块构建

#一般卷积层，relu层，池化层可以写成一个套餐
#注意卷积的最后结果是一个特征图，需要把图转换成向量才能做分类或回归任务

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(  # 输入大小（1,28,28）conv1是指第一个卷积模块
            nn.Conv2d(
                in_channels=1,  # 灰度图，当前输入特征图个数
                out_channels=16,  # 输出特征图的个数
                kernel_size=5,  # 卷积核大小
                stride=1,  # 步长
                padding=2,  # 如果希望卷积后大小跟原来一样，需要设置padding=(kernel_size-1)/2 if tride=1
            ),
            nn.ReLU(),  # relu层
            nn.MaxPool2d(kernel_size=2),  # 进行池化操作（2*2区域），输出结果为：（16,14,14）
        )
        self.conv2 = nn.Sequential(  # 输入（16,14,14）
            nn.Conv2d(16, 32, 5, 1, 2),  # 输出（32,14,14）
            nn.ReLU(),
            nn.MaxPool2d(2),  # 输出（32,7,7）
        )
        self.out = nn.Linear(32 * 7 * 7, 10)  # 最终输出层，我们需要得到一个10分类的结果


    def forward(self, x):
            # 前向传播
            x = self.conv1(x)
            x = self.conv2(x)
            x = x.view(x.size(0), -1)  # reshape操作，把当前结果转换为一个全部向量的形式。结果为：（batch_size,32*7*7)
            output = self.out(x)
            return output

nn.Sequential:一个有顺序的容器，将特定神经网络模块按照在传入构造器的顺序依次被添加到计算图中 ，大概就是调用nn.Module，实现__call__通过for循环遍历参数，将所有的子模块添加到现有模块中，然后forward函数中依次调用添加到现有模块中的子模块，最后输出经过所有神经网络层的结果。
源码分析，可以看一下这位博主的博客：https://blog.youkuaiyun.com/dss_dssssd/article/details/82980222

view(x.size(0), -1) 是指将前面多维度的tensor展平成一维

step4 训练网络模型

#准确率作为评估标准：
def accuracy(predictions,labels):
    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)
        print(right)
        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批次的整数倍才会打印
                100. *batch_idx / len(train_loader),
                loss.data,
                100. * train_r[0].numpy() / train_r[1],
                100. * val_r[0].numpy() / val_r[1],
            ))

torch.max()使用参考：https://zhuanlan.zhihu.com/p/89465622，
或者https://www.jianshu.com/p/3ed11362b54f
view及view_as使用参考：https://blog.youkuaiyun.com/qq_37385726/article/details/81738518

step5.执行结果：