目录
写在开头
本文将将介绍如何使用PyTorch框架搭建卷积神经网络(CNN)模型。简易介绍卷积神经网络的原理，并实现模型的搭建、数据集加载、模型训练、测试、网络的保存等。实现机器学习领域的Hello world——手写数字识别。本文的讲解参考了B站两位up主：爆肝杰哥、炮哥带你学。有关Pytorch环境配置和CNN具体原理大家可以自行查阅资料，本文多数图片也来自于爆肝杰哥的讲解。这里也放上两位up主的视频链接：
从0开始撸代码--手把手教你搭建LeNet-5网络模型_哔哩哔哩_bilibili
Python深度学习：安装Anaconda、PyTorch（GPU版）库与PyCharm_哔哩哔哩_bilibili
本文使用的PyTorch为1.12.0版本，Numpy为1.21版本，相近的版本语法差异很小。有关数组的数据结构教程、神经网络的基本原理（前向传播/反向传播）、神经网络作为“函数模拟器”直观感受、深度神经网络的实现DNN详见本专栏的前三篇文章，链接如下：
【深度学习基础】用PyTorch从零开始搭建DNN深度神经网络_如何搭建一个深度学习神经网络dnn pytorch-CSDN博客
【深度学习基础】使用Pytorch搭建DNN深度神经网络与手写数字识别_dnn网络模型 代码-CSDN博客
基于深度神经网络DNN实现的手写数字识别，将灰度图像转换后的二维数组展平到一维，将一维的784个特征作为模型输入。在“展平”的过程中必然会失去一些图像的形状结构特征，因此基于DNN的实现方式并不能很好的利用图像的二维结构特征，而卷积神经网络CNN对于处理图像的位置信息具有一定的优势。因此卷积神经网络经常被用于图像识别/处理领域。下面我们将对CNN进行具体介绍。
一、CNN的原理
1. 概述
在上一篇博客介绍的深度神经网络DNN中，网络的每一层神经元相互直接都有链接，每一层都是全连接层，我们的目标就是训练这个全连接层的权重w和偏执b，最终得到预测效果良好的网络结构。
DNN的全连接层对应于CNN中的卷积层，而池化层（汇聚）其实与激活函数的作用类似。CNN中完整的卷积层的结构是：卷积-激活函数-池化（汇聚），其中池化层也有时可以省略。一个卷积神经网络的结构如下：
如上图所示，CNN的优势在于可以处理多为输入数据，并同样以多维数据的形式输出至下一层，保留了更多的空间信息特征。而DNN却只能将多维数据展平成一维数据，必然会损失一些空间特征。
2. 卷积层
内参数（卷积核本身）
CNN中的卷积层和DNN中的全连接层是平级关系，在DNN中，我们训练的内参数是全连接层的权重w和偏置b，CNN也类似，CNN训练的是卷积核，也就相当于包含了权重和偏置两个内部参数。下面我们首先描述什么是卷积运算。当输入数据进入卷积层后，输入数据会与卷积核进行卷积运算，运算方法如下图所示：
输入一个多维数据（上图为二维），与卷积核进行运算，即输入中与卷积核形状相同的部分，分别与卷积核进行逐个元素相乘再相加。例如计算结果中坐上角的15是根据如下过程计算得到的：
逐个元素相乘再相加，即：
1 * 2 + 2 * 0 + 3* 1 + 0 * 0 + 1 * 1 + 2 * 2 + 3 * 1 + 0 * 0 + 1 * 2 = 15
卷积核本身相当于权重，再卷积运算的过程中也可以存在偏置，如下：
卷积核（即CNN的权重和偏置）本身为内参数，（具体里面的数字）是我们通过训练得出的，我们写代码的时候只要关注一些外部设定的参数即可。下面我们将介绍一些外参数。
外参数（填充和步幅）
填充（padding）
显然，只要卷积核的大小＞1*1，必然会导致图像越卷越小，为了防止输入经过多个卷积层后变得过小，可以在发生卷积层之前，先向输入图像的外围填入固定的数据（比如0），这个步骤称之为填充，如下图：
在我们使用Pytorch搭建卷积层的时候，需要在对应的接口中添加这个padding参数，向上图中这种情况，相当于在3*3的卷积核外围添加了“一圈”，则padding = 1，卷积层的接口中就要这样写：
nn.Conv2d(in_channels=1, out_channels=6, kernel_size=3, paddding=1)
参数in_channels和out_channels是对应于这个卷积层输入和输出的通道数参数，这里我们先放一放。
步幅（stride）
步幅指的是使用卷积核的位置间隔，即输入中参与运算的那个范围每次移动的距离。前面几个示意图中的步幅均为1，即每次移动一格，如果设置stride=2，kernel_size=2，则效果如下：
此时需要在卷积层接口中添加参数stride=2。
输入与输出的尺寸关系
综上所述，结合外参数（步幅、填充）和内参数（卷积核），可以看出如下规律：
卷积核越大，输出越小。
步幅越大，输出越小。
填充越大，输出越大。
用公式表示定量关系：
如果输入和卷积核均为方阵，设输入尺寸为W*W，输出尺寸为N*N，卷积核尺寸为F*F，填充的圈数为P，步幅为S，则有关系：
这个关系大家要重点掌握，也可以自己推导一下，并不复杂。如果输入和卷积核不为方阵，设输入尺寸是H*W，输出尺寸是OH*OW，卷积核尺寸为FH*FW，填充为P，步幅为S，则输出尺寸OH*OW的计算公式是：
3. 多通道问题
多通道输入
对于手写数字识别这种灰度图像，可以视为仅有（高*长）二维的输入。然而，对于彩色图像，每一个像素点都相当于是RGB的三个值的组合，因此对于彩色的图像输入，除了高*长两个维度外，还有第三个维度——通道，即红、绿、蓝三个通道，也可以视为3个单通道的二维图像的混合叠加。
当输入数据仅为二维时，卷积层的权重往往被称作卷积核（Kernel）;
当输入数据为三维或更高时，卷积层的权重往往被称作滤波器（Filter）。
对于多通道输入，输入数据和滤波器的通道数必须保持一致。这样会导致输出结果降维成二维，如下图：
对形状进行一下抽象，则输入数据C*H*W和滤波器C*FH*FW都是长方体，结果是一个长方形1*OH*OW，注意C,H,W是固定的顺序，通道数要写在最前。
多通道输出
如果要实现多通道输出，那么就需要多个滤波器，让三维输入与多个滤波器进行卷积，就可以实现多通道输出，输出的通道数FN就是滤波器的个数FN，如下图：
和单通道一样，卷积运算后也有偏置，如果进一步追加偏置，则结果如下：每个通道都有一个单独的偏置。
4. 池化层
池化，也叫汇聚（Pooling）。池化层通常位于卷积层之后（有时也可以不设置池化层），其作用仅仅是在一定范围内提取特征值，所以并不存在要学习的内部参数。池化仅仅对图像的高H和宽W进行特征提取，并不改变通道数C。
平均汇聚
一般有平均汇聚和最大值汇聚两种。平均汇聚如下：
如上图，池化的窗口大小为2*2，对应的步幅为2，因此对于上图这种情况，对应的Pytorch接口如下：
nn.AvgPool2d(kernel_size=2, stride=2)
最大值汇聚
同理，如果使用最大值汇聚，如下图所示：
此处Pytorch函数就这么写：
nn.MaxPool2d(kernel_size=2, stride=2)
二、手写数字识别
1. 任务描述和数据集加载
此处和上一篇博客类似，详情见：
【深度学习基础】使用Pytorch搭建DNN深度神经网络与手写数字识别_dnn网络模型 代码-CSDN博客
接下来我们实现机器学习领域的Hello World——手写数字识别。使用的数据集MNIST是机器学习领域的标准数据集，其中的每一个样本都是一副二维的灰度图像，尺寸为28*28：
输入就相当于一个单通道的图像，是二维的。我们在实现的时候，要将每个样本图像转换为28*28的张量，作为输入，此处和上一篇DNN都一致。数据集则通过包torchvision中的datasets库进行下载。这里我快速给一段代码好了，详情可见上一篇博客。
import torch
from torchvision import datasets, transforms
# 设定下载参数 （数据集转换参数）,将图像转换为张量
data_transform = transforms.Compose([
transforms.ToTensor()
])
# 加载训练数据集
train_dataset = datasets.MNIST(
root='D:\\Jupyter\\dataset\\minst', # 下载路径，读者请自行设置
train=True, # 是训练集
download=True, # 如果该路径没有该数据集，则进行下载
transform=data_transform # 数据集转换参数
)
# 批次加载器,在接下来的训练中进行小批次（16批次）的载入数据，有助于提高准确度，对训练集的样本进行打乱，
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=16, shuffle=True)
# 加载测试数据集
test_dataset = datasets.MNIST(
root='D:\\Jupyter\\dataset\\minst', # 下载路径
train=False, # 是训练集
download=True, # 如果该路径没有该数据集，则进行下载
transform=data_transform # 数据集转换参数
)
test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=16, shuffle=True)2. 网络结构（LeNet-5）
本文搭建的LeNet-5起源于1998年，在手写数字识别上非常成功。其结构如下：
再列一个表格，具体结构如下：
注:输出层的激活函数目前已经被Softmax取代。
至于这些尺寸关系，我举个两例子吧：
以第一层C1的输入和输出为例。输入尺寸W是28*28，卷积核F尺寸为5*5，步幅S为1，填充P为2，那么输出N的28*28怎么来的呢？按照公式如下：
我们也可以观察到第一层的卷积核个数为6，则输出的通道数也为6。
再看一下第一个池化层S2，输入尺寸是28*28，卷积核F大小为2*2（此处的“卷积核”实际上指的是采样范围），步幅S=2，填充P为0，则输出的14*14是这么算出来的：
其他的没啥好说的，读者们可以自行计算这个尺寸关系。接下来我们给出完整的CNN网络代码，net.py如下：
import torch
from torch import nn
# 定义网络模型
class MyLeNet5(nn.Module):
# 初始化网络
def __init__(self):
super(MyLeNet5, self).__init__()
self.net = nn.Sequential(
nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2), nn.Tanh(),
nn.AvgPool2d(kernel_size=2, stride=2),
nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5), nn.Tanh(),
nn.AvgPool2d(kernel_size=2, stride=2),
nn.Conv2d(in_channels=16, out_channels=120, kernel_size=5), nn.Tanh(),
nn.Flatten(),
nn.Linear(120, 84), nn.Tanh(),
nn.Linear(84, 10)
)
# 前向传播
def forward(self, x):
y = self.net(x)
return y
# 以下为测试代码，也可不添加
if __name__ == '__main__':
x1 = torch.rand([1, 1, 28, 28])
model = MyLeNet5()
y1 = model(x1)
print(x1)
print(y1)这里我还在'__main__'添加了一些测试代码，正如表格中所示，假设我们向网络中输入一个1*1*28*28的向量，模拟批次大小为1，一个单通道28*28的灰度图输入。最终y应该是由10个数字组成的张量，结果如下：
从输出我们可以直观的看到输入经过神经网络前向传播后的结果。另外特别注意这个网络的结构中的参数，其中卷积层的搭建API有5个外参数：
in_channels：输入通道数
out_channels：输出通道数
kernel_size: 卷积核尺寸
padding: 填充，不写则默认0
stride: 步幅，不写则默认1
这个LeNet-5网络结构就长这样，我们一定要严格遵守，否则有可能出现无论怎么训练，都始终欠拟合的情况。我就曾经试过更改/添加不同的激活函数，结果无论是训练还是测试，准确率都在10%徘徊，相当于随机瞎猜的效果，因此大家一定要严格遵循这个网络结构。
3. 模型训练
网络搭建好之后，所有的内参数（即卷积核）都是随机的，下面我们要通过训练尽可能提高网络的预测能力。在训练前，我们首先要选择损失函数（这里使用交叉熵损失函数），定义优化器、进行学习率调整等，代码如下：
import torch
from torch import nn
from net import MyLeNet5
from torch.optim import lr_scheduler
# 判断是否有gpu
device = "cuda" if torch.cuda.is_available() else "cpu"
# 调用net，将模型数据转移到gpu
model = MyLeNet5().to(device)
# 选择损失函数
loss_fn = nn.CrossEntropyLoss() # 交叉熵损失函数，自带Softmax激活函数
# 定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.9)
# 学习率每隔10轮次， 变为原来的0.1
lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
然后我们可以写一个用于训练网络的函数，四个参数分别是批次加载器、模型、损失函数、优化器，代码如下：
# 定义模型训练的函数
def train(dataloader, model, loss_fn, optimizer):
loss, current, n = 0.0, 0.0, 0
for batch, (X, y) in enumerate(dataloader):
# 前向传播
X, y = X.to(device), y.to(device)
output = model(X)
cur_loss = loss_fn(output, y)
# 用_和pred分别接收输出10个元素中的最大值和对应下标位置
_, pred = torch.max(output, dim=1)
# 计算当前轮次时，训练集的精确度，将所有标签值与预测值（即下标位置）
cur_acc = torch.sum(y == pred)/output.shape[0]
# 反向传播，对内部参数（卷积核）进行优化
optimizer.zero_grad()
cur_loss.backward()
optimizer.step()
# 计算准确率和损失，这里只是为了实时显示训练集的拟合情况。也可以不写
loss += cur_loss.item()
current += cur_acc.item()
n = n + 1
print("train_loss: ", str(loss/n))
print("train_acc: ", str(current/n))只要调用这个函数，即可实现模型训练：
train(train_dataloader, model, loss_fn, optimizer)当然，我们最好是设定一个轮次epoch，我们后续会写这样一个循环，每训练一个epoch，就进行一次测试，实时显示一定轮次后训练集和测试集的拟合情况。
4. 模型测试
这里和模型训练类似，只不过我们要观察训练好的模型，在测试集的预测效果。与训练的代码相似，只是没有了反向传播优化参数的过程。用于测试的函数代码如下：
def test(dataloader, model, loss_fn):
model.eval()
loss, current, n = 0.0, 0.0, 0
# 该局部关闭梯度计算功能，提高运算效率
with torch.no_grad():
for batch, (X, y) in enumerate(dataloader):
# 前向传播
X, y = X.to(device), y.to(device)
output = model(X)
cur_loss = loss_fn(output, y)
_, pred = torch.max(output, dim=1)
# 计算当前轮次时，训练集的精确度
cur_acc = torch.sum(y == pred) / output.shape[0]
loss += cur_loss.item()
current += cur_acc.item()
n = n + 1
print("test_loss: ", str(loss / n))
print("test_acc: ", str(current / n))
return current/n # 返回精确度如上代码，将测试集的精确度作为返回值，我们在外围调用这个函数时，可以通过循环找到测试集最大的精确度。
最终我们设定一个训练轮次epochs，此处epochs=50，每经过一个epoch的训练，就进行测试，实时打印观察训练集和测试集的拟合情况。当测试集的精确度是当前的最大值时，我们就保存这个模型的参数到save_model/best_model.pth，代码如下：
import os
# 开始训练
epoch = 50
max_acc = 0
for t in range(epoch):
print(f"epoch{t+1}\n---------------")
# 训练模型
train(train_dataloader, model, loss_fn, optimizer)
# 测试模型
a = test(test_dataloader, model, loss_fn)
# 保存最好的模型参数
if a > max_acc:
folder = 'save_model'
if not os.path.exists(folder):
os.mkdir(folder)
max_acc = a
print("current best model acc = ", a)
torch.save(model.state_dict(), 'save_model/best_model.pth')
print("Done!")运行之后可以发现，测试集的精度经过1个epochs就达到了90%以上，最终经过50轮次的训练，测试集精度达到了99%左右：
模型参数也得以保存：
最后给出用于训练和测试的完整代码train.py，如下所示：
import torch
from torch import nn
from net import MyLeNet5
from torch.optim import lr_scheduler
from torchvision import datasets, transforms
import os
# 将图像转换为张量形式
data_transform = transforms.Compose([
transforms.ToTensor()
])
# 加载训练数据集
train_dataset = datasets.MNIST(
root='D:\\Jupyter\\dataset\\minst', # 下载路径
train=True, # 是训练集
download=True, # 如果该路径没有该数据集，则进行下载
transform=data_transform # 数据集转换参数
)
# 批次加载器
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=16, shuffle=True)
# 加载测试数据集
test_dataset = datasets.MNIST(
root='D:\\Jupyter\\dataset\\minst', # 下载路径
train=False, # 是训练集
download=True, # 如果该路径没有该数据集，则进行下载
transform=data_transform # 数据集转换参数
)
test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=16, shuffle=True)
# 判断是否有gpu
device = "cuda" if torch.cuda.is_available() else "cpu"
# 调用net，将模型数据转移到gpu
model = MyLeNet5().to(device)
# 选择损失函数
loss_fn = nn.CrossEntropyLoss() # 交叉熵损失函数，自带Softmax激活函数
# 定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.9)
# 学习率每隔10轮次， 变为原来的0.1
lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
# 定于训练函数
def train(dataloader, model, loss_fn, optimizer):
loss, current, n = 0.0, 0.0, 0
for batch, (X, y) in enumerate(dataloader):
# 前向传播
X, y = X.to(device), y.to(device)
output = model(X)
cur_loss = loss_fn(output, y)
_, pred = torch.max(output, dim=1)
# 计算当前轮次时，训练集的精确度
cur_acc = torch.sum(y == pred)/output.shape[0]
# 反向传播
optimizer.zero_grad()
cur_loss.backward()
optimizer.step()
loss += cur_loss.item()
current += cur_acc.item()
n = n + 1
print("train_loss: ", str(loss/n))
print("train_acc: ", str(current/n))
def test(dataloader, model, loss_fn):
model.eval()
loss, current, n = 0.0, 0.0, 0
# 该局部关闭梯度计算功能，提高运算效率
with torch.no_grad():
for batch, (X, y) in enumerate(dataloader):
# 前向传播
X, y = X.to(device), y.to(device)
output = model(X)
cur_loss = loss_fn(output, y)
_, pred = torch.max(output, dim=1)
# 计算当前轮次时，训练集的精确度
cur_acc = torch.sum(y == pred) / output.shape[0]
loss += cur_loss.item()
current += cur_acc.item()
n = n + 1
print("test_loss: ", str(loss / n))
print("test_acc: ", str(current / n))
return current/n # 返回精确度
# 开始训练
epoch = 50
max_acc = 0
for t in range(epoch):
print(f"epoch{t+1}\n---------------")
train(train_dataloader, model, loss_fn, optimizer)
a = test(test_dataloader, model, loss_fn)
# 保存最好的模型参数
if a > max_acc:
folder = 'save_model'
if not os.path.exists(folder):
os.mkdir(folder)
max_acc = a
print("current best model acc = ", a)
torch.save(model.state_dict(), 'save_model/best_model.pth')
print("Done!")
5. 直观显示预测结果
截至目前，我们已经完成了手写数字识别这个任务，但是我们好像对于数据集长什么样并不是很了解，似乎仅仅是用torchvision中的datasets库下载了一下。因此本小节，我们的目标是从数据集取出几个特定的手写数字图片，并查看我们模型对其的预测效果。
首先我们还是加载数据集，和之前的代码一样，这里省略。然后我们加载模型：
from net import MyLeNet5
# 调用net，将模型数据转移到gpu
model = MyLeNet5().to(device)
model.load_state_dict(torch.load('./save_model/best_model.pth'))我们取出测试集中的前5长图片做一个展示即可，完整代码show.py如下：
import torch
from net import MyLeNet5
from torchvision import datasets, transforms
from torchvision.transforms import ToPILImage
data_transform = transforms.Compose([
transforms.ToTensor()
])
# 加载训练数据集
train_dataset = datasets.MNIST(
root='D:\\Jupyter\\dataset\\minst', # 下载路径
train=True, # 是训练集
download=True, # 如果该路径没有该数据集，则进行下载
transform=data_transform # 数据集转换参数
)
# 加载测试数据集
test_dataset = datasets.MNIST(
root='D:\\Jupyter\\dataset\\minst', # 下载路径
train=False, # 是训练集
download=True, # 如果该路径没有该数据集，则进行下载
transform=data_transform # 数据集转换参数
)
# 判断是否有gpu
device = "cuda" if torch.cuda.is_available() else "cpu"
# 调用net，将模型数据转移到gpu
model = MyLeNet5().to(device)
model.load_state_dict(torch.load('./save_model/best_model.pth'))
# 获取结果
classes = [
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"
]
# 把tensor转化为图片，方便可视化
image = ToPILImage()
# 进入验证
for i in range(5):
X, y = test_dataset[i][0], test_dataset[i][1] # X，y对应第i张图片和标签
# image是ToPILImage的实例，将Pytorch张量转换为PIL图像，.show()方法会打开图像查看器并显示图像
image(X).show()
'''unsqueeze 方法在指定的 dim 维度上扩展张量的维度。这里 dim=0，所以它会在第0维添加一个维度.
例如，原来的 X 形状是 (1, 28, 28)，经过 unsqueeze 处理后，形状变为 (1, 1, 28, 28)。
这样做的目的是将单张图像扩展成批次大小为1的形式，这样模型可以接收单张图像作为输入。'''
X = torch.unsqueeze(X, dim=0).float().to(device)
with torch.no_grad():
# 前向传播获得预测结果pred（由10个元素组成的张量）
pred = model(X)
print(pred)
# 将预测值和标签转化为对应的数字分类结果，pred中的最大值视为预测分类
predicted, actual = classes[torch.argmax(pred[0])], classes[y]
print(f"predicted: {predicted}, actual: {actual}")
运行结果如下，我们可以看到测试集中的前五张图片分别是7，2，1，0，4，且我们的模型都能对其进行成功预测分类。
预测结果均正确，如下：
写在最后
本文介绍了如何使用PyTorch框架搭建卷积神经网络模型CNN。将CNN与DNN进行了类比。CNN中的卷积层与DNN的全连接层是平级关系。我们实现了LeNet-5的模型的搭建、模型训练、测试、网络的复用、直观查看数据集的图片预测结果等，实现了机器学习领域的Hello world——手写数字识别。在CNN原理中，读者应当重点关注输入输出的尺寸关系，并可以对照LeNet-5结构示意图写出对应Pytorch代码。至于模型训练和测试基本都是固定的代码形式。
这篇文章到这里就结束了，后续我还会继续更新深度学习的相关知识，另外近期我个人的研究方向涉及到图神经网络，回头也会更新一些相关博客。如果读者有相关建议或疑问也欢迎评论区与我共同探讨，我一定知无不言。总结不易，还请读者多多点赞关注支持！
2220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
