手写数字识别：使用PyTorch构建MNIST分类器

在这篇文章中，我将引导你通过使用PyTorch框架构建一个简单的神经网络模型，用于识别MNIST数据集中的手写数字。MNIST数据集是一个经典的机器学习数据集，包含了60,000张训练图像和10,000张测试图像，每张图像都是28x28像素的灰度手写数字。

环境准备

首先，确保你的环境中安装了PyTorch和torchvision。可以通过以下命令安装：

pip install torch torchvision

数据加载与预处理

我们首先加载MNIST数据集，并将图像转换为PyTorch张量格式，以便模型可以处理。

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

'''下载训练数据集(包含训练图片+标签)'''
training_data = datasets.MNIST( #跳转到函数的内部源代码,pycharm 按下ctrl+鼠标点击 training_data:Dataset
    root="data",#表示下载的手写数字 到哪个路径。60000
    train=True, #读取下载后的数据 中的 训练集
    download=True,#如果你之前已经下载过了，就不用再下载
    transform=ToTensor(), #张量，图片是不能直接传入神经网络模型
)   #对于pytorch库能够识别的数据一般是tensor张量。


'''下载测试数据集(包含训练图片+标签)'''
test_data = datasets.MNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()
)
print(len(training_data))

数据可视化

为了更好地理解数据，我们可以展示一些手写数字图像。

''展示手写字图片，把训练数据集中的前59000张图片展示一下'''

from matplotlib import pyplot as plt
figure = plt.figure()
for i in range(9):
    img, label = training_data[i+59000] #提取第59000张图片

    figure.add_subplot(3, 3, i+1) #图像窗口中创建多个小窗口，小窗口用于显示图片
    plt.title(label)
    plt.axis("off") # plt.show(I)#是示矢量,
    plt.imshow(img.squeeze(), cmap="gray")
    a = img.squeeze()
plt.show()

创建DataLoader

为了高效地加载数据，我们使用DataLoader来批量加载数据。

# '"创建数据DataLoader(数据加载器)开'
#  'batch_size:将数据集分成多份，每一份为batch_size个数据'
#  '优点:可以减少内存的使用，提高训练速度。

train_dataloader = DataLoader(training_data, batch_size=64) #64张图片为一个包,train_dataloader:<torch
test_dataloader = DataLoader(test_data, batch_size=64)

模型定义

接下来，我们定义一个简单的神经网络模型，包含两个隐藏层和一个输出层。

'''定义神经网络类的继承这种方式'''
class NeuralNetwork(nn.Module):  #通过调用类的形式来使用神经网络，神经网络的模型，nn.module
    def __init__(self): #python基础关于类,self类自已本身
        super().__init__() #继承的父类初始化
        self.flatten = nn.Flatten() #展开,创建一个展开对象flatten
        self.hidden1 = nn.Linear(28*28, 128 ) #第1个参数:有多少个神经元传入进来，第2个参数:有多少个数据传出
        self.hidden2 = nn.Linear(128, 256)
        self.out = nn.Linear(256, 10)
    def forward(self, x):
        x = self.flatten(x) #图像进行展开
        x = self.hidden1(x)
        x = torch.relu(x) #激活函数，torch使用的relu函数 relu，tanh
        x = self.hidden2(x)
        x = torch.relu(x)
        x = self.out(x)
        return x

model = NeuralNetwork().to(device) #把刚刚创建的模型传入到Gpu
print(model)

训练与测试

我们定义训练和测试函数，使用交叉熵损失函数和随机梯度下降优化器。

def train(dataloader, model, loss_fn, optimizer):
    model.train() #告诉模型，我要开始训练，模型中w进行随机化操作，已经更新w。在训练过程中，w会被修改的
# #pytorch提供2种方式来切换训练和测试的模式，分别是:model.train()和 model.eval()。
 # 一般用法是:在训练开始之前写上model.trian()，在测试时写上 model.eval()

    batch_size_num = 1
    for X, y in dataloader: #其中batch为每一个数据的编号
        X, y = X.to(device), y.to(device) #把训练数据集和标签传入cpu或GPU
        pred = model.forward(X) #.forward可以被省略，父类中已经对次功能进行了设置。自动初始化w
        loss= loss_fn(pred, y) #通过交叉熵损失函数计算损失值loss
        # Backpropagation 进来一个batch的数据，计算一次梯度，更新一次网络
        optimizer.zero_grad() #梯度值清零
        loss.backward() #反向传播计算得到每个参数的梯度值w
        optimizer.step() #根据梯度更新网络w参数

        loss_value = loss.item() #从tensor数据中提取数据出来，tensor获取损失值
        if batch_size_num % 100 ==0:
            print(f"loss: {loss_value:>7f} [number:{batch_size_num}]")
        batch_size_num += 1


def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset) #10000
    num_batches = len(dataloader) #打包的数量
    model.eval() #测试，w就不能再更新。
    test_loss, correct = 0, 0
    with torch.no_grad(): #一个上下文管理器，关闭梯度计算。当你确认不会调用Tensor.backward()的时候。这
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model.forward(X)
            test_loss += loss_fn(pred, y).item()  #test_loss是会自动累加每一个批次的损失值
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            a = (pred.argmax(1) == y)   #dim=1表示每一行中的最大值对应的索引号，dim=0表示每一列中的最大值
            b = (pred.argmax(1) == y).type(torch.float)
    test_loss /= num_batches #能来衡量模型测试的好坏。
    correct /= size #平均的正确率

    print(f"Test result: \n Accuracy: {(100*correct)}%, Avg loss: {test_loss}")

训练模型

最后，我们训练模型并测试其性能。

loss_fn = nn.CrossEntropyLoss() #创建交叉熵损失函数对象，因为手写字识别中一共有10个数字，输出会有10个结果

optimizer = torch.optim.SGD(model.parameters(), lr=0.01) #创建一个优化器，SGD为随机梯度下降算法
# #params:要训练的参数，一般我们传入的都是model.parameters()# #lr:learning_rate学习率，也就是步长

#loss表示模型训练后的输出结果与,样本标签的差距。如果差距越小，就表示模型训练越好，越逼近干真实的模型。

# train(train_dataloader, model, loss_fn, optimizer)
# test(test_dataloader, model, loss_fn)

epochs = 30
for t in range(epochs):
    print(f"Epoch {t+1}\n")
    train(train_dataloader, model, loss_fn, optimizer)
print("Done!")
test(test_dataloader, model, loss_fn)

运行结果

结论

通过这篇文章，我们成功构建了一个简单的神经网络模型来识别MNIST数据集中的手写数字。这个模型展示了如何使用PyTorch进行数据处理、模型定义、训练和测试。希望这能帮助你开始自己的深度学习项目！