pytorch 入门（三）案例一：mnist手写数字识别

🍨 本文为🔗小白入门Pytorch中的学习记录博客

🍦 参考文章：【小白入门Pytorch】mnist手写数字识别

🍖 原作者：K同学啊

[一、前期准备](#一、前期准备)
- [1. 设置GPU](#1. 设置GPU)
- [2. 导入数据](#2. 导入数据)
- [3. 查看数据及可视化](#3. 查看数据及可视化)
- - [3.1 方式一：](#3.1 方式一：)
  - [3.1 方式二：](#3.1 方式二：)
二、构建简单的CNN网络
[三、训练模型](#三、训练模型)
- [1. 设置超参数](#1. 设置超参数)
- [2. 编写训练函数](#2. 编写训练函数)
- [3. 编写测试函数](#3. 编写测试函数)
- [4. 正式训练](#4. 正式训练)
[四、结果可视化](#四、结果可视化)
五、知识点详解

一、前期准备

python 复制代码

import torch

print(torch.__version__) # 查看pytorch版本，注意如果是使用和鲸自带的环境，需要正确选择，否则下一步导入torchvision可能会报错

1.8.1+cpu

C:\Users\chengyuanting\.conda\envs\pytorch_cpu\lib\site-packages\tqdm\auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

1. 设置GPU

如果设备上支持GPU就使用GPU,否则使用CPU

python 复制代码

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
import numpy as np
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

device

device(type='cpu')

2. 导入数据

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

使用dataloader加载数据，并设置好基本的batch_size

⭐ torchvision.datasets.MNIST详解

torchvision.datasets是Pytorch自带的一个数据库，我们可以通过代码在线下载数据，这里使用的是torchvision.datasets中的MNIST数据集。

函数原型：

python 复制代码

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) ：接受目标并对其进行转换的函数/转换。

python 复制代码

train_ds = torchvision.datasets.MNIST('data', 
                                      train=True, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

test_ds  = torchvision.datasets.MNIST('data', 
                                      train=False, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

⭐ 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）

python 复制代码

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)

3. 查看数据及可视化

3.1 方式一：

python 复制代码

# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl)) # 由于数据加载器被设置为随机打乱数据（shuffle=True），因此每次调用next函数时，都会从数据集中随机选择一个批次的数据。
imgs.shape

torch.Size([32, 1, 28, 28])

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

python 复制代码

#指定图片大小，图像大小为20宽，5高的绘图（单位为英寸inch）
plt.figure(figsize=(20,5))
for i,img in enumerate(imgs[:20]):
    # 维度缩减
    npimg = np.squeeze(img.numpy())
    plt.subplot(2,10,i+1) # 将整个figure分成2行10列，绘制第i+1个子图
    plt.imshow(npimg,cmap=plt.cm.binary)
    plt.axis('off') # 这行代码关闭了当前子图的坐标轴，使得图像没有任何坐标轴标签或刻度。

3.1 方式二：

python 复制代码

#其他方式查看数据情况
"""
说明：
这段代码的目的是从MNIST训练数据集中取前10个样本，
并在2行5列的布局中显示这些样本的图像和标签。
"""
# 查看数据的数量：
print(len(train_ds))
# 查看单个样本：
image,label = train_ds[0]
print("Label:",label)

# plt.imshow(image,cmap='gray') # 为了在matplotlib中正确显示该图像，您需要将其从(1, 28, 28)变形为(28, 28)。这可以通过使用numpy的squeeze函数来实现。
# 将图像张量转换为numpy数组并移除单通道维度
image_np = image.numpy().squeeze()
plt.imshow(image_np,cmap = 'gray')
plt.show()

# 查看图像的尺寸：
print("图像尺寸：",image.size)
print("图像尺寸(移除单通道)：",image_np.size)

# 查看多个样本：
fig,axes = plt.subplots(2,5,figsize = (10,5)) # 使用plt.subplots函数创建一个绘图窗口（figure：10英寸宽5英寸高）和一组子图（axes）。
for i,ax in enumerate(axes.ravel()):  # 这里，axes是一个2x5的数组，所以使用ravel()函数将其转变为一个长度为10的一维数组，方便遍历。
    image,label = train_ds[i] # image是一个表示图像的张量，label是图像对应的标签。
    
    # 将图像张量转换为numpy数组并移除单通道维度
    image_np = image.numpy().squeeze()
    
    ax.imshow(image_np,cmap = 'gray') # 使用子图对象ax的imshow方法显示图像。cmap='gray'指定使用灰度颜色映射。
    ax.set_title(f"Label:{label}")
    ax.axis('off')
plt.tight_layout() # 调整子图之间的间距，确保它们不会彼此重叠。
plt.show() # 显示绘图窗口和所有子图。

60000
Label: 5

图像尺寸： <built-in method size of Tensor object at 0x0000022EC1D81CC0>
图像尺寸(移除单通道)： 784

二、构建简单的CNN网络

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

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

网络结构图：

python 复制代码

import torch.nn.functional as F

num_classes = 10  # 图片的类别数

class Model(nn.Module):
     def __init__(self):
        super().__init__()
         # 特征提取网络
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # 第一层卷积,卷积核大小为3*3
        self.pool1 = nn.MaxPool2d(2)                  # 设置池化层，池化核大小为2*2
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3) # 第二层卷积,卷积核大小为3*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.view(x.size(0), -1) 展平张量

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

加载并打印模型

python 复制代码

!pip install torchinfo -i https://pypi.mirrors.ustc.edu.cn/simple/

Defaulting to user installation because normal site-packages is not writeable
Looking in indexes: https://pypi.mirrors.ustc.edu.cn/simple/
Requirement already satisfied: torchinfo in c:\users\chengyuanting\appdata\roaming\python\python39\site-packages (1.8.0)

python 复制代码

from torchinfo import summary
# 将模型转移到GPU中（我们模型运行均在GPU中进行）
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
=================================================================

python 复制代码

# 也可以直接查看模型,但是这样不显示参数数量
model

Model(
  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1))
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc1): Linear(in_features=1600, out_features=64, bias=True)
  (fc2): Linear(in_features=64, out_features=10, bias=True)
)

三、训练模型

1. 设置超参数

python 复制代码

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

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()方法产生的。

python 复制代码

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片
    num_batches = len(dataloader)   # 批次数目，1875（60000/32）

    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)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # 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 中使用或打印。

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

3. 编写测试函数

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

python 复制代码

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）
    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所带来的的性质。

python 复制代码

epochs     = 5
train_loss = []
train_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')

Epoch: 1, Train_acc:78.2%, Train_loss:0.732, Test_acc:92.3%，Test_loss:0.255
Epoch: 2, Train_acc:94.3%, Train_loss:0.191, Test_acc:96.2%，Test_loss:0.123
Epoch: 3, Train_acc:96.3%, Train_loss:0.121, Test_acc:97.4%，Test_loss:0.091
Epoch: 4, Train_acc:97.1%, Train_loss:0.094, Test_acc:98.0%，Test_loss:0.067
Epoch: 5, Train_acc:97.6%, Train_loss:0.079, Test_acc:98.1%，Test_loss:0.061
Done

四、结果可视化

python 复制代码

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
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()

五、知识点详解

本文使用的是最简单的CNN模型，如果是第一次接触深度学习的话，可以先试着把代码跑通，然后再尝试去理解其中的代码。

MNIST手写数字数据集介绍

MNIST手写数字数据集来源于是美国国家标准与技术研究所，是著名的公开数据集之一。数据集中的数字图片是由250个不同职业的人纯手写绘制，数据集获取的网址为：http://yann.lecun.com/exdb/mnist/ （下载后需解压）。我们一般会采用(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()这行代码直接调用，这样就比较简单

MNIST手写数字数据集中包含了70000张图片，其中60000张为训练数据，10000为测试数据，70000张图片均是28*28，数据集样本如下：

如果我们把每一张图片中的像素转换为向量，则得到长度为28*28=784的向量。因此我们可以把训练集看成是一个[60000,784]的张量，第一个维度表示图片的索引，第二个维度表示每张图片中的像素点。而图片里的每个像素点的值介于0-1之间。

神经网络程序说明

神经网络程序可以简单概括如下：

python 复制代码

pytorch 入门 （三）案例一：mnist手写数字识别

目录

一、 前期准备

1. 设置GPU

2. 导入数据

3. 查看数据及可视化

3.1 方式一：

3.1 方式二：

二、构建简单的CNN网络

三、 训练模型

1. 设置超参数

2. 编写训练函数

3. 编写测试函数

4. 正式训练

四、 结果可视化

五、知识点详解

pytorch 入门（三）案例一：mnist手写数字识别

一、前期准备

三、训练模型

四、结果可视化