Pytorch实现mnist模拟手写数字识别_pycharm实现手写数字识别-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_56988539/article/details/144010134

● 🍨 本文为🔗365天深度学习训练营中的学习记录博客
● 🍖 原作者：K同学啊

环境

语言环境：python3.8 编译器：pycharm

深度学习环境：torchvision==0.20.0+cuda12.6 torch==2.4.1

一、前期准备

1、设置GPU

如果设备支持GPU则使用GPU，不支持则使用CPU

# 设置硬件设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print (device)   #输出为cuda则表明使用GPU运行程序

2、导入数据

使用dataset下载MNIST数据集，并划分好训练集和测试集

使用dataloader加载数据集，并设置好参数（batch_size）

torchvision.datasets.MNIST

torchvision.datasets是pytorch自带的数据库，可以实现在代码中在线下载数据库（前提是可供下载）

函数原型：

torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False）

参数说明：

● root (string) ：下载的数据集保存的地址
● train (string) ：True-训练集，False-测试集
● download (bool,optional) : 如果为True，从互联网上下载数据集，并把数据集放在root目录下。
● transform (callable, optional )：这里的参数选择一个你想要的数据转化函数，直接完成数据转化
● target_transform (callable,optional) ：接受目标并对其进行转换的函数/转换。

# 导入数据
train_ds = torchvision.datasets.MNIST('data_mnist', train = True,
transform=torchvision.transforms.ToTensor(),  # 将数据类型转化为tensor数据类型
download=True)
test_ds = torchvision.datasets.MNIST('data_mnist', train = False,
transform=torchvision.transforms.ToTensor(),  # 将数据类型转化为tensor数据类型
download=True)

数据集下载后如下图所示（数据集保存在data_mnist文件夹中）

torch.utils.data.DataLoader：pytorch自带的一个数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集

参数说明：（只介绍常用参数）

● dataset (string) ：加载的数据集
● batch_size (int,optional) ：每批加载的样本大小（默认值：1）
● shuffle (bool,optional) : 如果为True，每个epoch重新排列数据。
● sampler (Sampler or iterable, optional) ：定义从数据集中抽取样本的策略。可以是任何实现了 __len__ 的 Iterable。如果指定，则不得指定 shuffle 。
● batch_sampler (Sampler or iterable, optional) ：类似于sampler，但一次返回一批索引。与 batch_size、shuffle、sampler 和 drop_last 互斥。
● drop_last (bool,optional) : 如果数据集大小不能被批次大小整除，则设置为 True 以删除最后一个不完整的批次。如果 False 并且数据集的大小不能被批大小整除，则最后一批将保留。（默认值：False）

# 设置数据格式
batch_size = 32   # 每批数据加载的数据大小为32
train_dl = torch.utils.data.DataLoader(train_ds, # 训练数据集
                                       batch_size = batch_size, # 指定大小
                                       shuffle = True # 重新排列数组
                                       )
test_dl = torch.utils.data.DataLoader(test_ds, batch_size = batch_size)

# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
imgs, labels = next(iter(train_dl))
print(imgs.shape)    # 输出为torch.Size([32, 1, 28, 28])

代码解释：

1. train_dl 是一个 PyTorch 数据加载器（DataLoader），用于加载训练数据集。通常情况下，数据加载器会将数据集分成小批量（batches）进行处理。
2. iter(train_dl) 将数据加载器转换为一个迭代器（iterator），使得我们可以使用 Python 的 next() 函数来逐个访问数据加载器中的元素。
3. next() 函数用于获取迭代器中的下一个元素。在这里，它被用来获取 train_dl 中的下一个批量数据。
4. imgs, labels = ... 这行代码是 Python 的解构赋值语法。它将从 next() 函数返回的元素中提取出两个变量：imgs 和 labels。
5. imgs 变量将包含一个批量的图像数据，而 labels 变量将包含相应的标签数据。这些图像和标签是从训练数据集中提取的。

3、数据可视化

squeeze()函数的功能是从矩阵shape中，去掉维度为1的。例如一个矩阵是的shape是（5, 1），使用过这个函数后，结果为（5, ）。

# 数据可视化
plt.figure(figsize=(20, 5))  # 指定图片大小（20宽5高的绘图）单位：英寸inch
for i, imgs in enumerate(imgs[:20]):  # 遍历图像：遍历imgs中的前20张图像，enumerate可以同时获取索引i和对应图像数据imgs
    # 维度缩减
    npimg = np.squeeze(imgs.numpy())
    # 将整个figure分成2行10列，绘制第i+1个子图
    plt.subplot(2, 10, i+1)
    plt.imshow(npimg, cmap = plt.cm.binary)  #显示图像：使用灰度色彩（binary）来显示图像
    plt.axis('off')  # 隐藏坐标轴，是图像更干净
plt.show()  # 显示绘制好的所有图像

二、构建简单CNN网络

一般CNN网络：通常由特征提取网络和分类网络构成，其中特征提取网络用于提取图像特征，分类网络用于图像分类

● nn.Conv2d为卷积层，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小
● nn.MaxPool2d为池化层，进行下采样，用更高层的抽象表示图像特征，传入参数为池化核大小
● nn.ReLU为激活函数，使模型可以拟合非线性数据
● nn.Linear为全连接层，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）
● nn.Sequential可以按构造顺序连接网络，在初始化阶段就设定好网络结构，不需要在前向传播中重新写一遍

根据上图可编写网络：

import torch.nn.functional as F
num_class = 10  # 图片的类别数
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        # 提取特征网络
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        # 分类网络
        self.fc1 = nn.Linear(1600, 64)  # 全连接层，输入特征数为1600，输出为64
        self.fc2 = nn.Linear(64, num_class)    # 输出10个类别
    # 前向传播
    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x))) # 第一卷积层 + ReLU 激活 + 最大池化
        x = self.pool2(F.relu(self.conv2(x))) # 第二卷积层 + ReLU 激活 + 最大池化
        x = torch.flatten(x, start_dim=1) # 展平张量，从而形成输入全连接层的样式，start_dim=1：表明第一个维度（通常是批处理大小）保持不变，其他维度将合并为一个。
        x = F.relu(self.fc1(x)) # 第一全连接层 + ReLU 激活
        x = self.fc2(x) # 第二全连接层，输出结果
        return x
# 加载并打印模型
# 让模型在GPU中运行
model = Model().to(device)
summary(model)

三、训练模型

1、设置超参数

loss_fn = nn.CrossEntropyLoss()  # 创建损失函数（CrossEntropyLoss常用于多类分类任务）
learn_rate = 1e-2  # 学习速率（0.01）
opt = torch.optim.SGD(model.parameters(), lr = learn_rate) # 定义优化器，torch.optim.SGD：表示随机梯度下降（SGD）作为优化器，model.parameters()：获取模型中所有可学习的参数，优化器在训练过程中将更新参数

2、编写训练函数

1.optimizer.zero_grad()

函数会遍历模型中所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设置为0，即上一次的梯度记录被清空。

2.loss.backward()

PyTorch的反向传播(即tensor.backward())是通过autograd包来实现的，autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。
具体来说，torch.tensor是autograd包的基础类，如果你设置tensor的requires_grads为True，就会开始跟踪这个tensor上面的所有运算，如果你做完运算后使用tensor.backward()，所有的梯度就会自动运算，tensor的梯度将会累加到它的.grad属性里面去。
更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用loss.backward()后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。
如果没有进行tensor.backward()的话，梯度值将会是None，因此loss.backward()要写在optimizer.step()之前。

3. optimizer.step()
step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。

注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。

"""
该函数用于训练一个深度学习模型，接收数据加载器、模型、损失函数和优化器作为输入，并返回训练期间的准确率和损失值。
"""
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 获取训练集大小：60000
    num_batches = len(dataloader)  # 计算每个epoch中的batch数量，这个数量由数据集大小和batch_size决定。例如，数据集大小为60000，batch_size为64，则该数量为60000/64=937,这表示在训练中会有937次迭代。
    train_loss, train_acc = 0, 0
    for X, y in dataloader:
        X, y = X.to(device), y.to(device)

        # 计算预测误差
        pred = model(X) # 前向传播，计算预测值
        loss = loss_fn(pred, y) # 计算损失

        # 反向传播
        optimizer.zero_grad() # 清除先前的梯度
        loss.backward() # 反向传播以重新计算当前梯度
        optimizer.step() # 更新模型参数

        # 记录acc  loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()
        # 计算整体训练准确率和损失
    train_acc /= size
    train_loss /= num_batches
    return train_acc, train_loss

● pred.argmax(1) 返回数组 pred 在第一个轴（即行）上最大值所在的索引。这通常用于多类分类问题中，其中 pred 是一个包含预测概率的二维数组，每行表示一个样本的预测概率分布。
● (pred.argmax(1) == y)是一个布尔值，其中等号是否成立代表对应样本的预测是否正确（True 表示正确，False 表示错误）。
● .type(torch.float)是将布尔数组的数据类型转换为浮点数类型，即将 True 转换为 1.0，将 False 转换为 0.0。
● .sum()是对数组中的元素求和，计算出预测正确的样本数量。
● .item()将求和结果转换为标量值，以便在 Python 中使用或打印。

● size 和 num_batches 是模型训练中非常重要的参数：

size 用于计算训练准确率和损失，确保在处理和输出指标时能正确反映整个数据集的性能。
num_batches 则用于在每个 epoch 中追踪批次数，可以帮助计算损失的平均值，以便更好地监控训练过程

(pred.argmax(1) == y).type(torch.float).sum().item()表示计算预测正确的样本数量，并将其作为一个标量值返回。这通常用于评估分类模型的准确率或计算分类问题的正确预测数量。

3、编写测试函数

测试函数和训练函数大致一样，但由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器。

# 用于评估深度学习模型在测试数据集上的表现
def test (dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 训练集大小：60000
    num_batches = len(dataloader)  # 计算在测试过程中总共有多少个 batch
    test_loss, test_acc = 0, 0

    with torch.no_grad():   # 不进行训练时，停止梯度更新，节省内存
        for imgs, target in dataloader:  # 遍历数据加载器
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)   # 获取模型预测
            loss = loss_fn(target_pred, target)  # 计算模型损失

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()

        test_acc /= size    # 计算测试平均准确率
        test_loss /= num_batches   # 计算平均损失

        return test_acc, test_loss

4、正式训练

1. model.train()
model.train()的作用是启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。

2. model.eval()
model.eval()的作用是不启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，在测试时添加model.eval()。model.eval()是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。

训练完train样本后，生成的模型model要用来测试样本。在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有BN层和Dropout所带来的的性质

# 正式训练
epochs = 5        # 定义训练的epoch数
train_loss = []   # 初始化记录训练损失的列表
train_acc = []    # 初始化记录训练准确率的列表
test_loss = []    # 初始化记录测试损失的列表
test_acc = []     # 初始化记录测试准确率的列表

for epoch in range(epochs):  # 遍历每个 epoch 
    model.train()    # 将模型设置为训练模式
# 训练阶段
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()     # 将模型设置为评估模式
# 测试阶段
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
# 记录每个 epoch 的训练和测试结果
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
# 打印输出当前 epoch 的信息
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}')
    print (template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('down')

四、结果可视化

#隐藏警告
warnings.filterwarnings("ignore")               #忽略警告信息
# 设置 Matplotlib 相关参数
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率
# 定义 epoch 的范围
epochs_range = range(epochs)
# 创建一个 12x3 的画布
plt.figure(figsize=(12, 3))
# 绘制训练和测试准确率的子图 
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label='Training Accuracy') # 训练准确率曲线
plt.plot(epochs_range, test_acc, label='Test Accuracy')   # 测试准确率曲线
plt.legend(loc='lower right')  # 图例位置
plt.title('Training and Validation Accuracy')  # 子图标题
# 绘制训练和测试损失的子图
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')   # 训练损失曲线
plt.plot(epochs_range, test_loss, label='Test Loss')        # 测试损失曲线
plt.legend(loc='upper right')  # 图例位置
plt.title('Training and Validation Loss')  # 子图标题
# 显示图像
plt.show()