PyTorch入门一：卷积神经网络实现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 视觉库提供了加载数据集的接口
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 # 设定初始的学习率
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)
上述代码的作用是：
- 将mnist训练集和测试集下载到文件夹data中
- 对数据进行变化，包括转为tensor数据类型，以及为了保证训练集测试集的独立同分布，数据规范化到正态分布
- 数据分批量存储，顺序打乱，方便后续训练。
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
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
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()))
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)))
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)
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%)