P1周：mnist手写数字识别

● 🍨 本文为🔗365天深度学习训练营 https://mp.weixin.qq.com/s/Nb93582M_5usednAKp_Jtw中的学习记录博客
● 🍖 原作者：K同学啊 | 接辅导、项目定制 https://mtyjkh.blog.csdn.net/
● 🚀 文章来源：K同学的学习圈子 https://www.yuque.com/mingtian-fkmxf/zxwb45

环境配置：

pytorch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1 pytorch-cuda=11.7

一、前期准备

1.设置GPU

事先了解自己电脑是否支持GPU，虽然深度学习并不一定需要用GPU，但如果不使用GPU，训练模型所耗的时间会变得冗长。

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

device

2.数据集相关工作

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)

 这里使用datasets下载MNIST数据集，划分训练集与测试集，并将数据类型转化为Tensor。

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)

训练批次设为32，训练批次就是指一次训练所处理的图片数，应设置适中以确保计算资源不被浪费。然后使用DataLoader加载数据，shuffle作用是打乱数据顺序，从而达到降低过拟合风险。

3.数据可视化

import numpy as np


plt.figure(figsize=(20, 5)) #规定图片长和宽（单位inch）
for i, imgs in enumerate(imgs[:20]):
    npimg = np.squeeze(imgs.numpy())#从矩阵shape中，去掉维度为1的
    plt.subplot(2, 10, i+1)#规定figure两行十列，并第绘制i＋1个
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')

二、构建简单的CNN网络

1.CNN框架搭建

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 = F.relu(self.fc1(x))
        x = self.fc2(x)
       
        return x

nn.Conv2d为卷积层，进行卷积运算以提取图片的特征。nn.MaxPool2d为池化层，进行下采样，CNN使用的最大池化提取最显著特征，大大降低了网络模型参数和计算成本，也在一定程度上降低了网络过拟合的风险，但缺点是容易忽略细节。

nn.Linear为全连接层，可以起到特征提取器的作用。

Flatten层用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。

2.可视化

将模型的结构和每一层的参数量可视化。

from torchinfo import summary
# 将模型转移到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
=================================================================

三、训练模型

1.超参数设置

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

nn.CrossEntropyLoss()是交叉熵损失函数，运用了熵的概念先把模型转化为熵的数值然后用数值去比较模型之间的差异，常用于分类问题。损失函数的作用是量化预测值和真实值之间的差异，使得网络模型可以朝着真实值的方向预测。

学习率是调整神经网络输入权重的一种方法。如果感知机预测正确，则对应的输入权重不会变化，否则会根据Loss Function来对感知机重新调整，而这个调整的幅度大小就是Learning Rate。

2.训练函数

# 训练循环
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

大致过程为向前传播得出预测与真实差异，计算损失，梯度归零，然后根据损失来反向更新权值。

3.测试函数

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.main函数

epochs     = 20
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')

epochs为训练轮数，每一轮都打出训练损失/精度，测试损失/精度，并将它们加入属于本类的列表。

四、成果展示

训练二十轮，精度与损失曲线如下。