PyTorch入门一：卷积神经网络实现MNIST手写数字识别_设计一个卷积神经网络,输入为两张mnist手写体数字图片,如果两张图片为同一个数字(

先给出几个入门PyTorch的好的资料：

• PyTorch官方教程（中文版）：http://pytorch123.com
• 《动手学深度学习》PyTorch版：https://github.com/ShusenTang/Dive-into-DL-PyTorch
  

1. PyTorch介绍

PyTorch是Torch7团队开发的，与Torch的不同之处在于PyTorch使用了Python作为开发语言，同样说明它是一个以Python优先的深度学习框架，它不仅能够实现强大的GPU加速，同时还支持动态神经网络，这是TensorFlow等很多主流框架不支持的。而且PyTorch可以轻松扩展，近两年有赶超TensorFlow的势头。

2. 卷积神经网络（CNN）

卷积神经网络（CNN——Convolutional Neural Network）是一种前馈神经网络。长期以来是图像识别领域的核心算法之一

这是一张卷及神经网络机构示意图，让我们理解下各部分：

• 输入层（Input Layer）：对于我们人来说输入的是一张图片，但是对于电脑来说输入的是一个矩阵类型的数据，这些数据代表着这张图片的像素值
• 卷积层（Convolution Layer）：对输入的数据进行特征提取，每个卷积核每次从一个小区域提取到一个特征值，所有的特征值组合起来就得到了一个特征图，当用多个卷积核对输入数据进行特征提取时，就得到了多个特征图。这个卷积核我们称为（kernel）
• 激活函数（Activation Function）：在人工神经网络的神经元上运行的函数，负责将神经元的输入映射到输出端，引入激活函数是为了增加神经网络模型的非线性
• 池化层（Pooling Layer）：在不影响特征质量的情况下对图片进行压缩，以减少参数，池化主要有两种，一种是MaxPooling，一种是AvePooling。假设池化的内核是一个2*2的矩阵，采用MaxPooling则是输出其中的最大值，采用AvePooling则输出所有数据的平均值
• 全连接层（Fully Connected Layer，简称FC）：在整个卷积神经网络中起到“分类器”的作用。如果说卷积层、池化层和激活函数层等操作是将原始数据映射到隐层特征空间的话，全连接层则起到将学到的“分布式特征表示”映射到样本标记空间的作用
• 输出层（Output Layer）：卷积神经网络中输出层的上游通常是全连接层，因此其结构和工作原理与传统前馈神经网络中的输出层相同。对于图像分类问题，输出层使用逻辑函数或归一化指数函数（softmax function）输出分类标签 。在物体识别（object detection）问题中，输出层可设计为输出物体的中心坐标、大小和分类 。在图像语义分割中，输出层直接输出每个像素的分类结果

理解完卷积神经网络后，让我们来看下PyTorch中的卷积神经网络

3. PyTorch中的卷积神经网络

3.1 卷积层：nn.Conv2d()

其参数如下：

• in_channels : 输入信号的通道数.
• out_channels : 卷积后输出结果的通道数.
• kernel_size : 卷积核的形状。例如kernel_size=(3, 2)表示3X2的卷积核，如果宽和高相同，可以只用一个数字表示
• stride : 卷积每次移动的步长, 默认为1.
• padding : 处理边界时填充0的数量, 默认为0(不填充).
• dilation : 采样间隔数量, 默认为1, 无间隔采样
• groups : 输入与输出通道的分组数量. 当不为1时, 默认为1(全连接)
• bias 为 True 时，添加偏置.

3.2 池化层：nn.MaxPool2d()

其参数如下：

• kernel_size : 最大池化操作时的窗口大小
• stride : 最大池化操作时窗口移动的步长, 默认值是 kernel_size
• padding : 输入的每条边隐式补0的数量
• dilation : 用于控制窗口中元素的步长的参数
• return_indices : 如果等于 True, 在返回 max pooling 结果的同时返回最大值的索引 这在之后的 Unpooling 时很有用
• ceil_mode : 如果等于 True, 在计算输出大小时,将采用向上取整来代替默认的向下取整的方式

4. 实现MNIST手写数字识别

下面就使用 pytorch 来动手搭建一个卷积神经网络来训练和识别手写数字。

4.1 引入库函数

import torch.nn as nn  # pytorch中最重要的模块，封装了神经网络相关的函数
import torch.nn.functional as F  # 提供了一些常用的函数，如softmax
import torch.optim as optim  # 优化模块，封装了求解模型的一些优化器，如Adam SGD
from torch.optim import lr_scheduler  # 学习率调整器，在训练过程中合理变动学习率
from torchvision import transforms  # pytorch 视觉库中提供了一些数据变换的接口
from torchvision import datasets  # pytorch 视觉库提供了加载数据集的接口
1
2
3
4
5
6

4.2 设置超参数

# 预设网络超参数 （所谓超参数就是可以人为设定的参数
 
BATCH_SIZE = 64  # 由于使用批量训练的方法，需要定义每批的训练的样本数目
 
EPOCHS = 3  # 总共训练迭代的次数
 
# 让torch判断是否使用GPU，建议使用GPU环境，因为会快很多
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
learning_rate = 0.001  # 设定初始的学习率
1
2
3
4
5
6
7
8
9
10

4.3 加载数据集

这里我们使用dataloader迭代器来加载数据集

# 加载训练集
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize(mean=(0.5,), std=(0.5,))  # 数据规范化到正态分布
                   ])),
    batch_size=BATCH_SIZE, shuffle=True)  # 指明批量大小，打乱，这是处于后续训练的需要。
 
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('data', train=False, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,))
    ])),
    batch_size=BATCH_SIZE, shuffle=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上述代码的作用是：

1. 将mnist训练集和测试集下载到文件夹data中
2. 对数据进行变化，包括转为tensor数据类型，以及为了保证训练集测试集的独立同分布，数据规范化到正态分布
3. 数据分批量存储，顺序打乱，方便后续训练。

4.4 设计网络结构

一个简单的卷积神经网络的结构，一般包括：

• 卷积层Conv：通过卷积核提取图像特征，得到feature map
• 池化层Pool：利用卷积核对feature map 降采样，减少尺寸。最大池化层就是取滑动窗口内最大的像素，而平均池化层就是取滑动窗口内平均像素结果。
• 全连接层：多个linear model + 激活函数 eg：ReLU。这样就构成了一个基本的CNN了，但是我们出于爱学习的心态呢，我们最好还要了解一些深度学习训练过程中的一些tricks，以提高模型的泛化能力。
• batch normalization：简单来说就是将上一层的加权求和的所有输出结果再批量归一化（标准正态分布），然后输入一个线性模型，然后再连接到激活函数。
• DropOut：在全连接层中，我们通过设定概率随机的让这一层的某些权重为0，相当于神经元无效。

 
# 设计模型
class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        # 提取特征层
        self.features = nn.Sequential(
            # 卷积层
            # 输入图像通道为 1，因为我们使用的是黑白图，单通道的
            # 输出通道为32（代表使用32个卷积核），一个卷积核产生一个单通道的特征图
            # 卷积核kernel_size的尺寸为 3 * 3，stride 代表每次卷积核的移动像素个数为1
            # padding 填充，为1代表在图像长宽都多了两个像素
            nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1),# ((28-3+2*1)/1)+1=28  28*28*1  》 28*28*32
 
            # 批量归一化，跟上一层的out_channels大小相等，以下的通道规律也是必须要对应好的
            nn.BatchNorm2d(num_features=32),   #28*28*32  》 28*28*32
 
            # 激活函数，inplace=true代表直接进行运算
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1),   #  ((28-3+2*1)/1)+1=28     28*28*32 》 28*28*32
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
 
            # 最大池化层
            # kernel_size 为2 * 2的滑动窗口
            # stride为2，表示每次滑动距离为2个像素
            # 经过这一步，图像的大小变为1/4，即 28 * 28 -》 7 * 7
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # 分类层
        self.classifier = nn.Sequential(
            # Dropout层
            # p = 0.5 代表该层的每个权重有0.5的可能性为0
            nn.Dropout(p=0.5),
            # 这里是通道数64 * 图像大小7 * 7，然后输入到512个神经元中
            nn.Linear(64 * 7 * 7, 512),
            nn.BatchNorm1d(512),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(512, 512),
            nn.BatchNorm1d(512),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(512, 10),
        )
    # 前向传递函数    
    def forward(self, x):
        # 经过特征提取层
        x = self.features(x)
        # 输出结果必须展平成一维向量
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

4.5 训练前准备

# 初始化模型 将网络操作移动到GPU或者CPU
 
ConvModel = ConvNet().to(DEVICE)
# 定义交叉熵损失函数
criterion = nn.CrossEntropyLoss().to(DEVICE)
# 定义模型优化器：输入模型参数，定义初始学习率
optimizer = torch.optim.Adam(ConvModel.parameters(), lr=learning_rate)
# 定义学习率调度器：输入包装的模型，定义学习率衰减周期step_size，gamma为衰减的乘法因子
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=6, gamma=0.1)
# 在官网上的解释。如果初始学习率lr = 0.05，衰减周期step_size为30，衰减乘法因子gamma=0.01
# Assuming optimizer uses lr = 0.05 for all groups
# >>> # lr = 0.05     if epoch < 30
# >>> # lr = 0.005    if 30 <= epoch < 60
# >>> # lr = 0.0005   if 60 <= epoch < 90
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.6 训练

def train(num_epochs, _model, _device, _train_loader, _optimizer, _lr_scheduler):
    _model.train()  # 设置模型为训练模式
    _lr_scheduler.step() # 设置学习率调度器开始准备更新
    for epoch in range(num_epochs):
        # 从迭代器抽取图片和标签
        for i, (images, labels) in enumerate(_train_loader):
            samples = images.to(_device)
            labels = labels.to(_device)
            # 此时样本是一批图片，在CNN的输入中，我们需要将其变为四维，
            # reshape第一个-1 代表自动计算批量图片的数目n
            # 最后reshape得到的结果就是n张图片，每一张图片都是单通道的28 * 28，得到四维张量
            output = _model(samples.reshape(-1, 1, 28, 28))
            # 计算损失函数值
            loss = criterion(output, labels)
            # 优化器内部参数梯度必须变为0
            optimizer.zero_grad()
            # 损失值后向传播
            loss.backward()
            # 更新模型参数
            optimizer.step()
            if (i + 1) % 100 == 0:
                print("Epoch:{}/{}, step:{}, loss:{:.4f}".format(epoch + 1, num_epochs, i + 1, loss.item()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.7 预测

def test(_test_loader, _model, _device):
    _model.eval()  # 设置模型进入预测模式 evaluation
    loss = 0
    correct = 0
 
    with torch.no_grad():  # 如果不需要 backward更新梯度，那么就要禁用梯度计算，减少内存和计算资源浪费。
        for data, target in _test_loader:
            data, target = data.to(_device), target.to(_device)
            output = ConvModel(data.reshape(-1, 1, 28, 28))
            loss += criterion(output, target).item()  # 添加损失值
            pred = output.data.max(1, keepdim=True)[1]  # 找到概率最大的下标，为输出值
            correct += pred.eq(target.data.view_as(pred)).cpu().sum()  # .cpu()是将参数迁移到cpu上来。
 
    loss /= len(_test_loader.dataset)
 
    print('\nAverage loss: {:.4f}, Accuracy: {}/{} ({:.3f}%)\n'.format(
        loss, correct, len(_test_loader.dataset),
        100. * correct / len(_test_loader.dataset)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.8 运行

for epoch in range(1, EPOCHS + 1):
    train(epoch, ConvModel, DEVICE, train_loader, optimizer, exp_lr_scheduler)
    test(test_loader,ConvModel, DEVICE)
    test(train_loader,ConvModel, DEVICE)
1
2
3
4

5 结果

用的pytorch =0.4 用CPU跑的

Epoch:1/1, step:100, loss:0.1579
Epoch:1/1, step:200, loss:0.0809
Epoch:1/1, step:300, loss:0.0673
Epoch:1/1, step:400, loss:0.1391
Epoch:1/1, step:500, loss:0.0323
Epoch:1/1, step:600, loss:0.0870
Epoch:1/1, step:700, loss:0.0441
Epoch:1/1, step:800, loss:0.0705
Epoch:1/1, step:900, loss:0.0396
 
Average loss: 0.0006, Accuracy: 9881/10000 (98.000%)
 
Epoch:1/2, step:100, loss:0.0487
Epoch:1/2, step:200, loss:0.1519
Epoch:1/2, step:300, loss:0.0262
Epoch:1/2, step:400, loss:0.2133
Epoch:1/2, step:500, loss:0.0161
Epoch:1/2, step:600, loss:0.0805
Epoch:1/2, step:700, loss:0.0927
Epoch:1/2, step:800, loss:0.0663
Epoch:1/2, step:900, loss:0.0669
Epoch:2/2, step:100, loss:0.0124
Epoch:2/2, step:200, loss:0.0527
Epoch:2/2, step:300, loss:0.0256
Epoch:2/2, step:400, loss:0.0138
Epoch:2/2, step:500, loss:0.0894
Epoch:2/2, step:600, loss:0.1030
Epoch:2/2, step:700, loss:0.0528
Epoch:2/2, step:800, loss:0.1106
Epoch:2/2, step:900, loss:0.0044
 
Average loss: 0.0003, Accuracy: 9930/10000 (99.000%)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32