深度学习笔记:基于PyTorch的MNIST手写数字识别实战

案例背景

MNIST手写数字识别是深度学习领域的经典入门项目，被誉为深度学习的"Hello World"。本案例使用全连接神经网络实现对0-9手写数字的分类识别。

本文是基于pytorch对深度学习一些案例的代码实现

MNIST手写数字识别案例

这个案例的目的是，训练神经网络能够识别手写数字，该案例原本是cnn的经典案例，但是还没写rnn的笔记并且该数据比较简单，直接就用Linear来代替卷积层了。

模块导入

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

第一个就不多说了

nn是神经网络核心模块，提供网络层实现

optim是优化器（包含SGD，Adam等优化器）

torchveision计算机视觉工具包，提供常用数据集

DataLoader是用来把Dataset数据集装换成一个可以迭代的数据加载器

plt就是画图用的。

数据准备

# 管道，处理数据，先把数据变成张量，然后在标准化
transform=transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
# 下载数据到指定目录并且利用管道处理后的张量转换成一个Dataset数据集
# 训练数据集
train_dataset=torchvision.datasets.MNIST('./data',
                               train=True,
                               transform=transform)
# 测试数据集
test_dataset=torchvision.datasets.MNIST('./data',
                               train=False,
                               transform=transform)
#训练数据加载器
train_loader=DataLoader(train_dataset,batch_size=68,shuffle=True) #batch_size代表每个epoch中的每轮是68个数据，shuffle代表打乱数据集
#测试数据加载器
test_loader=DataLoader(test_dataset,batch_size=68,shuffle=False)

数据的准备通常就是把正常的数据变成张量，然后是数据集，然后就是数据加载器。

神经网络搭建

class net(nn.Module):
    def __init__(self):
        super(net,self).__init__()
        # 为了方便直接全部用线性层代替
        self.linear1=nn.Linear(28*28,128)
        self.linear2=nn.Linear(128,64)
        self.linear3=nn.Linear(64,10)
        # 激活层
        self.relu=nn.ReLU()
        # 归一化层
        self.dropout=nn.Dropout(0.2)

    # 向前传播，在使用时自动会进行该操作
    def forward(self,x):
        # 先把28*28的矩阵张量，展开成1,28*28的张量
        x=x.view(-1,28*28)
        # 输入先第一层加权求和，然后归一化，最后激活
        x=self.relu(self.dropout(self.linear1(x)))
        x=self.relu(self.dropout(self.linear2(x)))
        #最后一层是输出层，直接输出
        x=self.linear3(x)
        return x

继承nn.Module模块，__init__()里初始化神经网络的网络层，forward()是向前传播的方法，在使用模型时会自动调用该方法。

思考

可以在初始化的时候加入参数的初始化，比如kaiming和xavier初始化。

模型训练

#设置epoch轮数
epochs=5
#挂载的设备，gpu还是cpu
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
#实体化模型到指定设备上
model = net().to(device)
#实体损失函数
criterion = nn.CrossEntropyLoss()
#实体优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
#开启训练模式
model.train()
#总损失，做统计用
total_loss=0
#开始训练
for epoch in range(epochs):
    totol_loss=0
    #每轮次遍历迭代器，每次迭代68个
    for batch_idx, (data, target) in enumerate(train_loader):
        #梯度归零，防止累加
        optimizer.zero_grad()
        #模型预测
        y_pred=model(data)
        #求损失
        loss=criterion(y_pred,target)
        #反向传播求梯度
        loss.backward()
        #梯度更新
        optimizer.step()
        #累加损失
        total_loss += loss.item()
        #输出当前批次的损失
        if batch_idx % 100 == 0:
            print(f'Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)}] Loss: {loss.item():.6f}')
    #输出平均损失
    print(f'Epoch {epoch} Average Loss: {total_loss/len(train_loader):.6f}')

对于神经网络的训练，都有梯度归零，模型预测，损失函数，反向传播，梯度更新这五步骤，基本是固定的。

思考

训练过程中可以采用学习率衰减策略，优化器的选择是否有其他更好的。

测试模型

def test_model():
    #模型测评模式
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            outputs = model(data)
            _, predicted = torch.max(outputs.data, 1)
            total += target.size(0)
            correct += (predicted == target).sum().item()
    
    accuracy = 100 * correct / total
    print(f'测试集准确率: {accuracy:.2f}%')
    return accuracy
test_model()


def predict_single_image():
    model.eval()
    # 获取一张测试图片
    data_iter = iter(test_loader)
    images, labels = next(data_iter)
    image, label = images[0], labels[0]
    
    with torch.no_grad():
        output = model(image.unsqueeze(0).to(device))
        _, predicted = torch.max(output, 1)
        
    print(f'真实标签: {label.item()}, 预测结果: {predicted.item()}')
    
    # 显示图片
    plt.imshow(image.squeeze(), cmap='gray')
    plt.title(f'True: {label}, Pred: {predicted.item()}')
    plt.show()

predict_single_image()

和上面类似就不多做赘述了。

效果展示

最后想看cnn实现方案的可以看这篇文章

https://nextjournal.com/gkoehler/pytorch-mnist