基于pytorch的MNIST数字识别实验

最新推荐文章于 2024-07-24 15:22:35 发布

irving#11

最新推荐文章于 2024-07-24 15:22:35 发布

阅读量749

点赞数 29

文章标签： pytorch 人工智能 python

本文链接：https://blog.csdn.net/weixin_43690449/article/details/138683200

版权

基于pytorch的MNIST数字识别实验

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

$Ⅰ$ Introduction：

本文为机器学习经典案例：基于mnist数据集的手写数字识别分类实验的学习记录。
实验目标：
- 了解什么是深度学习及其基本框架与流程
- 了解pytorch及其部分常用的接口
- 动手完成分类任务，学会将结果打印输出

$Ⅱ$ Experiment：

数据准备与任务分析：

本次实验是通过计算机视觉对手写数字进行分类，目标是尽可能的准确识别每一个数字图形
为此，本次实验搭建CNN网络作为主要分类器，尽可能好的训练这个分类器是本次实验的主要目标之一。

数据准备：
本次实验选用数据mnist手写数字，通过torchvision中的dataset下载：

train_ds = torchvision.datasets.MNIST('data',
                                    train=True,
                                    transform=torchvision.transforms.ToTensor(),
                                    download=True)

test_ds  = torchvision.datasets.MNIST('data',
                                    train=False,
                                    transform=torchvision.transforms.ToTensor(),
                                    download=True)

通过torch.utils.data.DataLoader来载入数据：

batch_size = 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)

至此，前期的准备工作已完成。

配置环境：

实验环境：
- 语言环境：python 3.8
- 编译器: pycharm
- 深度学习环境：
  - torch==2.11
  - cuda12.1
  - torchvision==0.15.2a0

构建网络：

对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。

网络代码：

   import torch.nn.functional as F
   import torch
   import torch.nn as nn

   num_classes = 10


   class Model(nn.Module):
      def __init__(self):
         super().__init__()
         self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
         self.pool1 = nn.MaxPool2d(2)
         self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
         self.pool2 = nn.MaxPool2d(2)

         self.fc1 = nn.Linear(1600, 64)
         self.fc2 = nn.Linear(64, num_classes)

      def forward(self, x):
         x = self.pool1(F.relu(self.conv1(x)))
         x = self.pool2(F.relu(self.conv2(x)))

         x = torch.flatten(x, start_dim=1)

         x = F.relu(self.fc1(x))
         x = self.fc2(x)

         return x

nn.Conv2d为卷积层，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小

nn.MaxPool2d为池化层，进行下采样，用更高层的抽象表示图像特征，传入参数为池化核大小

nn.ReLU为激活函数，使模型可以拟合非线性数据

nn.Linear为全连接层，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）

nn.Sequential可以按构造顺序连接网络，在初始化阶段就设定好网络结构，不需要在前向传播中重新写一遍

加载并打印模型:

>>>
from torchinfo import summary
model = Model().to(device)
summary(model)

>>>
=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            320
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            18,496
├─MaxPool2d: 1-4                         --
├─Linear: 1-5                            102,464
├─Linear: 1-6                            650
=================================================================
Total params: 121,930
Trainable params: 121,930
Non-trainable params: 0
=================================================================

训练模型：

首先需要设置超参数：

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)

然后编写训练函数，使用反向传播计算梯度，再通过优化器更新

def train(dataloader, model, loss_fn, optimizer, learn_rate=1e-2):
    """train model"""
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    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()

        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

测试模型：

测试函数与训练函数大致相同，去掉优化器与梯度传播即可：

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    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

实验结果及可视化：
目标是尽可能提高在测试集上分类的准确率，即test_acc:

for epoch in range(epochs):
    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)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    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('Done')

经过5轮训练，得到结果如下：

Epoch: 1, Train_acc:78.4%, Train_loss:0.751, Test_acc:93.5%，Test_loss:0.210
Epoch: 2, Train_acc:94.7%, Train_loss:0.174, Test_acc:96.1%，Test_loss:0.128
Epoch: 3, Train_acc:96.4%, Train_loss:0.116, Test_acc:97.5%，Test_loss:0.085
Epoch: 4, Train_acc:97.2%, Train_loss:0.092, Test_acc:97.9%，Test_loss:0.067
Epoch: 5, Train_acc:97.6%, Train_loss:0.078, Test_acc:98.2%，Test_loss:0.059
Done

通过以下代码对结果进行图绘：

plt.rcParams['font.sans-serif']    = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.rcParams['figure.dpi']         = 100

epochs_range = range(epochs)

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()

在这里插入图片描述

$Ⅲ$ Conclusion：

知识点归纳：

a. torch.utils.data.DataLoader详解

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

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device='')

参数说明：

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 互斥。
num_workers (int,optional) ：用于数据加载的子进程数。 0 表示数据将在主进程中加载（默认值：0）。
pin_memory (bool,optional) : 如果为 True，数据加载器将在返回之前将张量复制到设备/CUDA 固定内存中。如果数据元素是自定义类型，或者collate_fn返回一个自定义类型的批次。
drop_last (bool,optional) : 如果数据集大小不能被批次大小整除，则设置为 True 以删除最后一个不完整的批次。如果 False 并且数据集的大小不能被批大小整除，则最后一批将保留。（默认值：False）
timeout (numeric,optional) : 设置数据读取的超时时间，超过这个时间还没读取到数据的话就会报错。（默认值：0）
worker_init_fn (callable,optional) ：如果不是 None，这将在步长之后和数据加载之前在每个工作子进程上调用，并使用工作 id（[0，num_workers - 1] 中的一个 int）的顺序逐个导入。（默认：None）

b. 一个神经网络程序可以用下图概括：
在这里插入图片描述

收获与总结：

在这次实验中，我使用了卷积神经网络（CNN）对 MNIST 手写数字数据集进行了分类。在测试集上，我获得了 98.1% 的准确率，而在训练集上的准确率为 97.7%。以下是我在这次实验中所获得的收获和总结：

了解卷积神经网络：
通过实验，我加深了对卷积神经网络的理解。我了解了卷积层、池化层和全连接层等基本组件，以及它们如何协同工作来提取特征并进行分类。
数据预处理的重要性：
在实验过程中，虽然本次实验没有过多的预处理，但我了解到对数据进行归一化、平衡和处理缺失值等操作，可以提高模型的性能和稳定性。
超参数调优：
不同的模型架构、学习率、批量大小等超参数的组合，对模型性能的影响是至关重要的。我发现对于不同的任务，合适的超参数组合可能有所不同，因此进行参数调优是非常重要的。
模型评估：
了解如何评估模型的性能，通过使用准确率、精确度、召回率等指标，能够更好地了解模型的优劣势，并找出改进的空间。

irving#11

关注

29
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
基于pytorch的MNIST数字识别实验

nn.Linear为全连接层，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。nn.Conv2d为卷积层，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小。
复制链接

扫一扫