Week1，实现MNIST手写数字识别

Week1-pytoch实现MNIST手写数字识别

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客

• 🍦 参考文章：365天深度学习训练营-第P1周：实现mnist手写数字识别
• 🍖 原作者：K同学啊 | 接辅导、项目定制
• 🚀 文章来源：K同学的学习圈子

MNIST手写数字数据集是机器学习中常用的数据集，很适合作为深度学习的入门学习内容。下面本文以MNIST数据集为例实现一个两层卷积神经网络的简单模型。
本人电脑配置
Python 3.8.0
Pytorch 1.8.1
torchvision 0.9.1 + cu10.2

前期准备

1. 设置GPU

在这里想要说明一点是，如果电脑有显卡，在装pytorch时需要安装gpu版本的，可参考网上其他博主，不能直接“pip install torch”，否则会默认安装CPU版本。

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. 导入数据

使用dataset下载MNIST数据集，并划分好训练集与测试集；使用dataloader加载数据，并设置好基本的batch_size。
下载数据到主目录的文件夹的data文件夹里

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)

加载数据，定义batch_size为32

batch_size = 32
train_d1 = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True)
test_d1 = torch.utils.data.DataLoader(test_ds, batch_size=batch_size)

3. 数据可视化

可视化部分MNIST数据集

import numpy as np
plt.figure(figsize=(20,5))
for i, imgs in enumerate(imgs[:20]):
    npimg = np.squeeze(imgs.numpy())
    plt.subplot(2,10,i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')

构建网络模型

1. 搭建模型

构建两层卷积、两层全连接的神经网络。

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

2. 可视化模型

利用torchinfo包查看模型的结构并计算模型每一层的参数量，显示出来的结果如下。

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

3. 编写训练函数

在进行前向传播后，需要把梯度清零，再进行loss回传。

def train(dataloader, model, loss_fn, optimizer):
    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

4. 编写测试函数

当不进行训练时，停止梯度更新，节省计算内存消耗。

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

5. 主函数

设置迭代epoch次数，这里设定为100，并记录训练误差、精度，测试误差、精度。

epochs     = 100
train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_d1, model, loss_fn, opt)    
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_d1, 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为62时，训练集的精度已经达到100%，而之后，测试集精度一直在99%，98.9%，98.8%左右。