利用PyTorch实现基于MIST数据集的手写数字识别

2025-07-27 15:09:11

利用PyTorch实现基于MIST数据集的手写数字识别利用PyTorch实现基于MIST数据集的手写数字识别简介：如何使用PyTorch实现基于MIST数据集的手写数字识别。手写数字识别是计算机视觉领域的经典问题之一，旨在将手写数字图像转换为对应的数字标签。数据集简介MIST数据集是一个经典的手写数字数据集，包含了张训练图像和张测试图像。每张图像的大小为28x28

利用PyTorch实现基于MIST数据集的手写数字识别

简介：如何使用PyTorch实现基于MIST数据集的手写数字识别。手写数字识别是计算机视觉领域的经典问题之一，旨在将手写数字图像转换为对应的数字标签。

数据集简介

MIST数据集是一个经典的手写数字数据集，包含了60000张训练图像和10000张测试图像。每张图像的大小为28x28像素，图像内容为0到9的手写数字。我们将使用这个数据集来训练和测试我们的模型。

代码实现

代码语言：javascript代码运行次数：0运行复制

# 导入所需的库
import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import  as nn
import  as optim

# 设置随机种子，以确保结果的可重复性
_seed(0)

# 定义数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),  # 将图像转换为张量
    ((0.107,), (0.081,))  # 标准化图像
])

# 加载MIST数据集
train_dataset = datasets.MIST('data', train=True, download=True, transform=transform)  # 训练数据集
test_dataset = datasets.MIST('data', train=False, download=True, transform=transform)  # 测试数据集

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)  # 训练数据加载器
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)  # 测试数据加载器

# 定义神经网络模型（Leet）
class et(nn.Module):
    def __init__(self):
        super(et, self).__init__()
         = nn.Conv2d(1, 20, 5, 1)
         = nn.Conv2d(20, 50, 5, 1)
        self.fc1 = nn.Linear(4*4*50, 500)
        self.fc2 = nn.Linear(500, 10)

    def forward(self, x):
        x = nn.functional.relu((x))
        x = nn._pool2d(x, 2, 2)
        x = nn.functional.relu((x))
        x = nn._pool2d(x, 2, 2)
        x = x.view(-1, 4*4*50)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return nn.functional.log_softmax(x, dim=1)

# 创建神经网络模型实例
model = et()

# 定义优化器和损失函数
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
criterion = nn.CrossEntropyLoss()

# 训练模型
def train(epoch):
    ()
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print('训练 Epoch: {} [{}/{} ({:.0f}%)]\t损失: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))

# 测试模型
def test():
    ()
    test_loss = 0
    correct = 0
    with _grad():
        for data, target in test_loader:
            output = model(data)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += (target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print('\n测试集: 平均损失: {:.4f}, 准确率: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

# 进行模型训练和测试
for epoch in range(1, 11):
    train(epoch)
    test()

结果展示

代码语言：javascript代码运行次数：0运行复制

训练 Epoch: 1 [0/60000 (0%)]	损失: 2.20024
训练 Epoch: 1 [6400/60000 (11%)]	损失: 0.577842
训练 Epoch: 1 [12800/60000 (21%)]	损失: 0.4521
训练 Epoch: 1 [19200/60000 (2%)]	损失: 0.27862
训练 Epoch: 1 [25600/60000 (4%)]	损失: 0.277499
训练 Epoch: 1 [2000/60000 (5%)]	损失: 0.11560
训练 Epoch: 1 [8400/60000 (64%)]	损失: 0.148797
训练 Epoch: 1 [44800/60000 (75%)]	损失: 0.092067
训练 Epoch: 1 [51200/60000 (85%)]	损失: 0.125068
训练 Epoch: 1 [57600/60000 (96%)]	损失: 0.062419

测试集: 平均损失: 0.0014, 准确率: 972/10000 (97%)

训练 Epoch: 2 [0/60000 (0%)]	损失: 0.078582
训练 Epoch: 2 [6400/60000 (11%)]	损失: 0.172461
训练 Epoch: 2 [12800/60000 (21%)]	损失: 0.121057
训练 Epoch: 2 [19200/60000 (2%)]	损失: 0.07924
训练 Epoch: 2 [25600/60000 (4%)]	损失: 0.29202
训练 Epoch: 2 [2000/60000 (5%)]	损失: 0.022772
训练 Epoch: 2 [8400/60000 (64%)]	损失: 0.028810
训练 Epoch: 2 [44800/60000 (75%)]	损失: 0.08098
训练 Epoch: 2 [51200/60000 (85%)]	损失: 0.0244
训练 Epoch: 2 [57600/60000 (96%)]	损失: 0.08277

测试集: 平均损失: 0.0011, 准确率: 977/10000 (98%)

训练 Epoch:  [0/60000 (0%)]	损失: 0.06188
训练 Epoch:  [6400/60000 (11%)]	损失: 0.017849
训练 Epoch:  [12800/60000 (21%)]	损失: 0.009525
训练 Epoch:  [19200/60000 (2%)]	损失: 0.02097
训练 Epoch:  [25600/60000 (4%)]	损失: 0.109975
训练 Epoch:  [2000/60000 (5%)]	损失: 0.1102
训练 Epoch:  [8400/60000 (64%)]	损失: 0.0501
训练 Epoch:  [44800/60000 (75%)]	损失: 0.060158
训练 Epoch:  [51200/60000 (85%)]	损失: 0.091192
训练 Epoch:  [57600/60000 (96%)]	损失: 0.09621

测试集: 平均损失: 0.0007, 准确率: 9847/10000 (98%)

训练 Epoch: 4 [0/60000 (0%)]	损失: 0.025815
训练 Epoch: 4 [6400/60000 (11%)]	损失: 0.041258
训练 Epoch: 4 [12800/60000 (21%)]	损失: 0.020587
训练 Epoch: 4 [19200/60000 (2%)]	损失: 0.105892
训练 Epoch: 4 [25600/60000 (4%)]	损失: 0.0902
训练 Epoch: 4 [2000/60000 (5%)]	损失: 0.012649
训练 Epoch: 4 [8400/60000 (64%)]	损失: 0.0785
训练 Epoch: 4 [44800/60000 (75%)]	损失: 0.05451
训练 Epoch: 4 [51200/60000 (85%)]	损失: 0.024816
训练 Epoch: 4 [57600/60000 (96%)]	损失: 0.020467

测试集: 平均损失: 0.0007, 准确率: 984/10000 (98%)

训练 Epoch: 5 [0/60000 (0%)]	损失: 0.024172
训练 Epoch: 5 [6400/60000 (11%)]	损失: 0.09589
训练 Epoch: 5 [12800/60000 (21%)]	损失: 0.075022
训练 Epoch: 5 [19200/60000 (2%)]	损失: 0.189776
训练 Epoch: 5 [25600/60000 (4%)]	损失: 0.007984
训练 Epoch: 5 [2000/60000 (5%)]	损失: 0.01882
训练 Epoch: 5 [8400/60000 (64%)]	损失: 0.059460
训练 Epoch: 5 [44800/60000 (75%)]	损失: 0.1516
训练 Epoch: 5 [51200/60000 (85%)]	损失: 0.07755
训练 Epoch: 5 [57600/60000 (96%)]	损失: 0.0942

测试集: 平均损失: 0.0006, 准确率: 986/10000 (99%)

训练 Epoch: 6 [0/60000 (0%)]	损失: 0.02569
训练 Epoch: 6 [6400/60000 (11%)]	损失: 0.029651
训练 Epoch: 6 [12800/60000 (21%)]	损失: 0.009427
训练 Epoch: 6 [19200/60000 (2%)]	损失: 0.05245
训练 Epoch: 6 [25600/60000 (4%)]	损失: 0.05080
训练 Epoch: 6 [2000/60000 (5%)]	损失: 0.027
训练 Epoch: 6 [8400/60000 (64%)]	损失: 0.011127
训练 Epoch: 6 [44800/60000 (75%)]	损失: 0.01774
训练 Epoch: 6 [51200/60000 (85%)]	损失: 0.022161
训练 Epoch: 6 [57600/60000 (96%)]	损失: 0.02988

测试集: 平均损失: 0.0006, 准确率: 9878/10000 (99%)

训练 Epoch: 7 [0/60000 (0%)]	损失: 0.010487
训练 Epoch: 7 [6400/60000 (11%)]	损失: 0.0879
训练 Epoch: 7 [12800/60000 (21%)]	损失: 0.020085
训练 Epoch: 7 [19200/60000 (2%)]	损失: 0.017111
训练 Epoch: 7 [25600/60000 (4%)]	损失: 0.005051
训练 Epoch: 7 [2000/60000 (5%)]	损失: 0.0112
训练 Epoch: 7 [8400/60000 (64%)]	损失: 0.011859
训练 Epoch: 7 [44800/60000 (75%)]	损失: 0.09866
训练 Epoch: 7 [51200/60000 (85%)]	损失: 0.120959
训练 Epoch: 7 [57600/60000 (96%)]	损失: 0.017959

测试集: 平均损失: 0.0005, 准确率: 9884/10000 (99%)

训练 Epoch: 8 [0/60000 (0%)]	损失: 0.005525
训练 Epoch: 8 [6400/60000 (11%)]	损失: 0.006888
训练 Epoch: 8 [12800/60000 (21%)]	损失: 0.0292
训练 Epoch: 8 [19200/60000 (2%)]	损失: 0.016291
训练 Epoch: 8 [25600/60000 (4%)]	损失: 0.004896
训练 Epoch: 8 [2000/60000 (5%)]	损失: 0.09128
训练 Epoch: 8 [8400/60000 (64%)]	损失: 0.08165
训练 Epoch: 8 [44800/60000 (75%)]	损失: 0.005650
训练 Epoch: 8 [51200/60000 (85%)]	损失: 0.050541
训练 Epoch: 8 [57600/60000 (96%)]	损失: 0.017801

测试集: 平均损失: 0.0005, 准确率: 9891/10000 (99%)

训练 Epoch: 9 [0/60000 (0%)]	损失: 0.0671
训练 Epoch: 9 [6400/60000 (11%)]	损失: 0.025160
训练 Epoch: 9 [12800/60000 (21%)]	损失: 0.006145
训练 Epoch: 9 [19200/60000 (2%)]	损失: 0.026249
训练 Epoch: 9 [25600/60000 (4%)]	损失: 0.020545
训练 Epoch: 9 [2000/60000 (5%)]	损失: 0.029771
训练 Epoch: 9 [8400/60000 (64%)]	损失: 0.007581
训练 Epoch: 9 [44800/60000 (75%)]	损失: 0.02595
训练 Epoch: 9 [51200/60000 (85%)]	损失: 0.002854
训练 Epoch: 9 [57600/60000 (96%)]	损失: 0.06187

测试集: 平均损失: 0.0006, 准确率: 9870/10000 (99%)

训练 Epoch: 10 [0/60000 (0%)]	损失: 0.008528
训练 Epoch: 10 [6400/60000 (11%)]	损失: 0.014426
训练 Epoch: 10 [12800/60000 (21%)]	损失: 0.01252
训练 Epoch: 10 [19200/60000 (2%)]	损失: 0.001507
训练 Epoch: 10 [25600/60000 (4%)]	损失: 0.027995
训练 Epoch: 10 [2000/60000 (5%)]	损失: 0.026279
训练 Epoch: 10 [8400/60000 (64%)]	损失: 0.00177
训练 Epoch: 10 [44800/60000 (75%)]	损失: 0.052491
训练 Epoch: 10 [51200/60000 (85%)]	损失: 0.00997
训练 Epoch: 10 [57600/60000 (96%)]	损失: 0.020422

测试集: 平均损失: 0.0005, 准确率: 9885/10000 (99%)

et(
  (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(20, 50, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=800, out_features=500, bias=True)
  (fc2): Linear(in_features=500, out_features=10, bias=True)
)

运行结果的总结如下：

每个训练周期（Epoch）包含多个批次（Batches），每个批次大小为64。
训练周期逐渐增加，损失值逐渐减小，这表明模型在训练过程中逐渐学习到了数据的特征。
测试集的平均损失逐渐减小，准确率逐渐提高，这表明模型在训练后在测试集上表现良好。
训练周期增加到10时，测试集的准确率达到了99%左右，模型已经取得了不错的分类效果。
最后的输出展示了训练后的神经网络模型的结构，包括卷积层和全连接层的参数设置。

这个结果表明，Leet模型在MIST数据集上取得了良好的分类效果，并且模型的结构也得到了有效的训练和优化。

结果可视化

保存模型

最后，我们可以将训练好的模型保存起来，以便在需要时重新加载并使用。

代码语言：javascript代码运行次数：0运行复制

# 保存模型
torch.save(model.state_dict(), 'mnist_model.pth')

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。原始发表：2024-0-12，如有侵权请联系 cloudcommunity@tencent 删除mnist测试模型数据pytorch

#感谢您对电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格的认可，转载请说明来源于"电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格

本文地址：http://www.dnpztj.cn/biancheng/1150280.html

本站网友什么是心理健康	4分钟前发表
2 [6400/60000 (11%)] 损失
本站网友 frpp管	5分钟前发表
2) x = x.view(-1
本站网友番禺租房信息	15分钟前发表
x)
本站网友爱的100条法则	17分钟前发表
972/10000 (97%) 训练 Epoch
本站网友重庆美术培训	22分钟前发表
4 [8400/60000 (64%)] 损失
本站网友小鬼外挂	10分钟前发表
0.120959 训练 Epoch
本站网友男童误食水宝宝	5分钟前发表
7 [51200/60000 (85%)] 损失
本站网友何处春江无月明	18分钟前发表
0.09866 训练 Epoch
本站网友孕妇喝奶粉	6分钟前发表
[19200/60000 (2%)] 损失
本站网友兰州酒店	7分钟前发表
1 [19200/60000 (2%)] 损失
本站网友高成	16分钟前发表
)
本站网友俊情一点	16分钟前发表
984/10000 (98%) 训练 Epoch
本站网友鸡球大包	4分钟前发表
0.025815 训练 Epoch
本站网友亳州一中贴吧	11分钟前发表
0.0007
本站网友艾格眼科医院	13分钟前发表
代码语言：javascript代码运行次数：0运行复制# 保存模型 torch.save(model.state_dict()
本站网友手机发布会	29分钟前发表
0.1102 训练 Epoch

利用PyTorch实现基于MIST数据集的手写数字识别