《深度学习》卷积神经网络CNN 实现手写数字识别
目录
一、卷积神经网络CNN
1、什么是CNN
2、核心
3、构造
二、案例实现
1、下载训练集、测试集
代码实现如下：
2、展示部分图片
运行结果：
3、图片打包
运行结果：
4、判断当前使用的CPU还是GPU
5、定义卷积神经网络
运行结果：
6、训练、测试模型
运行结果：
以下代码类似于前面所说的神经网络实现手写数字识别，可参考下列博客。
《深度学习》PyTorch 手写数字识别 案例解析及实现 ＜下＞
https://blog.csdn.net/qq_64603703/article/details/142282105?fromshare=blogdetail&sharetype=blogdetail&sharerId=142282105&sharerefer=PC&sharesource=qq_64603703&sharefrom=from_link
一、卷积神经网络CNN
1、什么是CNN
卷积神经网络是一种深度学习模型，主要应用于图像和视频处理任务。它的设计灵感来源于生物视觉系统的工作原理。
2、核心
核心是卷积层，这是一种通过在输入数据上应用滤波器（也称为卷积核）来提取特征的操作。卷积层的输出是一系列的特征图，每个特征图表示一种特定的图像特征，例如边缘、纹理等。这种特征提取的方式可以捕捉到图像中的局部模式，并且在不同位置共享参数，从而提高了模型的效率和泛化能力。
3、构造
CNN还包括池化层，用于减小特征图的尺寸，降低计算复杂度，增加模型的平移不变性。
卷积神经网络还可以包含多个卷积层和池化层的堆叠，以及全连接层（Fully Connected Layer）用于进行分类或回归等任务。
二、案例实现
1、下载训练集、测试集
通过现有的库调用其用法直接去下载现成的手写数字的数据集，这些手写数字集共有70000张图片，这些图片都有其对应的标签，大小为28*28，灰度图，数字居中，直接使用即可。
将这70000张图片，60000张当做训练集，10000张当做测试集。
代码实现如下：
import torch
print(torch.__version__)
"""MNIST包含70,000张手写数字图像:60,000张用于训练，10,000张用于测试。
图像是灰度的，28x28像素的，并且居中的，以减少预处理和加快运行。"""
from torch import nn # 导入神经网络模块
from torch.utils.data import DataLoader # 数据包管理工具，打包数据,
from torchvision import datasets # 封装了很多与图像相关的模型，数据集
from torchvision.transforms import ToTensor # 数据转换，张量，将其他类型的数据转换为tensor张量,numpy arrgy,
"""下载训练数据集，图片+标签"""
training_data = datasets.MNIST( # 跳转到函数的内部源代码，pycharm 按下ctrl +鼠标点击
root='data', # 表述下载的数据存放的根目录
train=True, # 表示下载的是训练数据集，如果要下载测试集，更改为False即可
download=True, # 表示如果根目录有该数据，则不再下载，如果没有则下载
transform=ToTensor() # 张量，图片是不能直接传入神经网络模型
# 表示制定一个数据转换操作，将下载的图片转换为pytorch张量，因为pytorch只能处理张量tensor类型的数据
)
test_data = datasets.MNIST(
root='data',
train=False,
download=True,
transform=ToTensor() # Tensor是在深度学习中提出并广泛应用的数据类型，它与深度学习框架(如 PyTorch、TensorFlo
) # NumPy 数组只能在CPU上运行。Tensor可以在GPU上运行，这在深度学习应用中可以显著提高计算速度。
print(len(training_data))
print(len(test_data))实现结果就是当前代码的目录多出了一个data文件，里面存放的就是下载好的手写数字的图片，打印内容为下载的图片个数。
2、展示部分图片
取出9张图片，将其展示在画布上
from matplotlib import pyplot as plt # 导入绘图库
figure = plt.figure() # 设置一个空白画布
for i in range(9):
img,label = training_data[i+59000] # 提取第59000张图片开始，共9张，返回图片及其对应的标签值
figure.add_subplot(3,3,i+1) # 在画布创建3行3列的小窗口，通过遍历的值i来确定每个画布展示的图片
plt.title(label) # 设置每个窗口的标题，设置标签为上述返回的标签值
plt.axis('off') # 取消画布中的坐标轴的图像
plt.imshow(img.squeeze(),cmap='gray') # plt.imshow()将NumPy数组data中的数据显示为图像，并在图形窗口中,
a = img.squeeze() # img.squeeze()从张量img中去掉维度为1的。如果该维度的大小不为1,则张量不会改变。
plt.show()运行结果：
3、图片打包
因为图片的数量太多，将其一张一张的放入GPU进行计算太耗费时间，而且还浪费资源，所以将64张图片打包成一份，将这一整个数据包传入GPU使其计算，这样大大增加了运行的效率。
train_dataloader = DataLoader(training_data,batch_size=64) # 调用上述定义的DataLoader打包库，将训练集的图片和标签，64张图片为一个包，
test_dataloader = DataLoader(test_data,batch_size=64) # 将测试集的图片和标签，每64张打包成一份
for x,y in test_dataloader:
# x是表示打包好的每一个数据包,其形状为[64,1,28,28],64表示批次大小，1表示通道数为1，即灰度图，28表示图像的宽高像素值
# y表示每个图片标签
print(f"shape of x[N,C,H,W]:{x.shape}") # 打印图片形状
print(f"shape of y:{y.shape}{y.dtype}") # 打印标签的形状和数据类型
break # 跳出并终止循环，表示只遍历一个包的数据情况运行结果：
4、判断当前使用的CPU还是GPU
"""判断当前设备是否支持GPU，其中mps是苹果m系列芯片的GPU""" # 返回cuda，mps，cpu， m1，m2集显CPU+GPU RTX3060
device = "cuda" if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device") # 字符串的格式化。CUDA驱动软件的功能:pytorch能够去执行cuda的命令，cuda通过GPU指令集
# 神经网络的模型也需要传入到GPU，1个batchsize的数据集也需要传入到GPU，才可以进行训练。5、定义卷积神经网络
"""定义神经网络"""
class CNN(nn.Module): # 继承nn算法中的Module
def __init__(self): # 这里输入大小为(1,28,28)
super(CNN,self).__init__()
self.conv1 = nn.Sequential( # 第一层卷积， 将多个层组合成一起。
nn.Conv2d( # 二维卷积成，2d一般用于图像，3d用于视频数据(多一个时间维度)，1d一般用于结构化的序列数据
in_channels=1, # 输入图像通道个数，1表示灰度图(确定了卷积核 组中的个数)，
out_channels=16, # 输出多少个特征图，也可表示卷积核的个数
kernel_size=5, # 卷积核大小，5*5
stride=1, # 卷积核移动的步长
padding=2, # 边缘填充层数
), # 输出的特征图为(16*28*28)
nn.ReLU(), # 设置激活层，引入非线性，增强表达能力，relu层，不会改变特征图的大小(16*28*28)
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(), # relu层(32*14*14)
nn.Conv2d(32,32,5,1,2), # 输出(32*14*14)
nn.ReLU(), # (32，14，14)
nn.MaxPool2d(2), # 最大池化，输出(32*7*7)
)
self.conv3 = nn.Sequential( # 输入(32*7*7)
nn.Conv2d(32, 64, 5, 1, 2), # (64*7*7)
nn.ReLU(), # 输出(64*7*7)
)
self.out = nn.Linear(64*7*7,10) # 全连接层得到的结果
def forward(self, x): # 定义前向传播
x = self.conv1(x) # 对传入模型的图片数据进行第一层卷积处理
x = self.conv2(x)
x = self.conv3(x) # 输出(64,64，7，7)
x = x.view(x.size(0),-1) # 重新调整张量的形状，即flatten操作，结果为:(batch_size，64*7*7)
# x.size(0)表示获取第一个维度的大小，-1表示自动计算维度大小
# x.view(x.size(0),-1)将张量x重新调整为两维张量，其中第一维的大小保持不变（即x.size(0)），而第二维的大小是自动计算的，以确保总元素数量与原始张量相同。
output = self.out(x)
return output
model = CNN().to(device) # 将模型传入GPU
print(model) # 打印模型的结构运行结果：
6、训练、测试模型
def train(dataloader,model,loss_fn,optimizer): # 导入参数，dataloader表示打包，数据加载器，model导入上述定义的神经网络模型，loss_fn表示损失值，optimizer表示优化器
model.train() # 模型设置为训练模式
# 告诉模型，我要开始训练，模型中权重w进行随机化操作，已经更新w。在训练过程中，w会被修改的
# #pytorch提供2种方式来切换训练和测试的模式，分别是:model.train()和 model.eval()。
# 一般用法是:在训练开始之前写上model.train()，在测试时写上model.eval()。
batch_size_num = 1
for x,y in dataloader: # 遍历打包的图片的每一个包中的每一张图片及其对应的标签，其中batch为每一个数据的编号
x,y = x.to(device),y.to(device) # 把训练数据集和标签传入cpu或GPU
pred = model.forward(x) # 模型进行前向传播，输入图片信息后得到预测结果，forward可以被省略，父类中已经对次功能进行了设置。自动初始化w权值
loss = loss_fn(pred,y) # 调用交叉熵损失函数计算损失值loss，输入参数为预测结果和真实结果，
# Backpropaqation 进来一个batch的数据，计算一次梯度，更新一次网络
optimizer.zero_grad() # 梯度值清零，在反向传播之前先清除之前的梯度
loss.backward() # 反向传播，计算得到每个参数的梯度值w
optimizer.step() # 根据梯度更新权重w参数
loss_value = loss.item() # 从tensor数据中提取数据出来，tensor获取损失值
if batch_size_num % 200 == 0: # 判断遍历包的个数是否整除于200，用于将训练到的包的个数打印出来，整除200目的是节省资源
print(f"loss:{loss_value:>7f} [number: {batch_size_num}]") # 打印损失值及其对应的值,损失值最大宽度为7，右对齐
batch_size_num += 1 # 每遍历一个包增加一次，以达到显示出来遍历的包的个数
def test(dataloader,model,loss_fn): # 输入参数打包的图片、训练好的模型、以及损失值
size = len(dataloader.dataset) # 返回测试数据集的样本总数
num_batches = len(dataloader) # 返回当前dataloader配置下的批次数
model.eval() # 表示此为模型测试，w就不能再更新。
test_loss,correct = 0, 0 # 设置总损失值初始化为0，正确预测结果初始化为0
with torch.no_grad(): # 一个上下文管理器，关闭梯度计算。当你确认不会调用Tensor.backward()的时候。这可以减少计算
for x,y in dataloader: # 遍历测试集中的每个包的每个图片及其对应的标签
x,y = x.to(device),y.to(device) # 将其传入gpu
pred = model.forward(x) # 图片数据进行前向传播
test_loss += loss_fn(pred,y).item() # test_loss是会自动累加每一个批次的损失值
correct += (pred.argmax(1) == y).type(torch.float).sum().item() # pred.argmax(1) == y用于判断预测结果最大值对用的标签是否与真实值相同,然后将判断结果的bool值转变为浮点数并求和
a = (pred.argmax(1) == y) # dim=1表示每一行中的最大值对应的索引号，dim=0表示每一列中的最大值对应的索引号
b = (pred.argmax(1) == y).type(torch.float)
test_loss /= num_batches # 总损失值除以打包的批次数，返回测试的每一个包的损失值的均值，能来衡量模型测试的好坏。
correct /= size # 平均的正确率
print(f"Test result: \n Accuracy:{(100 * correct)}%, Avg loss:{test_loss}") # 打印测试集测试结果
loss_fn = nn.CrossEntropyLoss() # 创建交叉熵损失函数对象，因为手写字识别中一共有10个数字，输出会有10个结果
optimizer = torch.optim.Adam(model.parameters(),lr=0.001) # 创建一个优化器，SGD为随机梯度下降算法，学习率或者叫步长为0.0045
epochs = 8 # 设置训练的轮数为8轮，因为模型中设置了权重值的更新，所以重复训练会更新模型的权值
for i in range(epochs):
print(f"Epoch {i+1}\n--------------------")
train(train_dataloader,model,loss_fn,optimizer)
print('Done!!')
test(test_dataloader,model,loss_fn) # 导入测试集进行测试运行结果：
