《深度学习》卷积神经网络CNN 实现手写数字识别

核心是卷积层 ，这是一种通过在输入数据上 应用滤波器 （也称为卷积核 ）来提取特征 的操作。卷积层的输出是一系列的特征图 ，每个特征图表示一种特定的图像特征 ，例如边缘、纹理等。这种特征提取的方式可以捕捉到图像中的局部模式，并且在不同位置共享参数，从而提高了模型的效率和泛化能力。

3、构造

CNN还包括池化层 ，用于减小特征图的尺寸 ，降低计算复杂度，增加模型的平移不变性。

卷积神经网络还可以包含多个卷积层和池化层的堆叠，以及全连接层（Fully Connected Layer）用于进行分类或回归等任务。

二、案例实现

1、下载训练集、测试集

通过现有的库调用其用法直接去下载现成的手写数字的数据集，这些手写数字集共有70000张图片，这些图片都有其对应的标签，大小为28*28，灰度图，数字居中，直接使用即可。

将这70000张图片，60000张当做训练集，10000张当做测试集。

代码实现如下：

python 复制代码

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张图片，将其展示在画布上

python 复制代码

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使其计算，这样大大增加了运行的效率。

python 复制代码

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

python 复制代码

"""判断当前设备是否支持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、定义卷积神经网络

python 复制代码

"""定义神经网络"""
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、训练、测试模型

python 复制代码

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)   # 导入测试集进行测试