用pytorch中的resnet18实现mnist手写数字识别

工作大纲

• 在本项目中，我修改了resnet18的输出，使其符合mnist数据集
• 学习使用残差结构

手写数字识别常用的网络

手写数字识别常用的网络包括以下5种：

1. 卷积神经网络（Convolutional Neural Network,CNN）：CNN是一种专门用于图像识别和分类的神经网络结构，由于其对图像特征的提取能力而在手写数字识别中得到广泛应用。
2. 循环神经网络（Recurrent Neural Network, RNN）：RNN可以用于处理序列数据，对于手写数字的笔画轨迹进行识别和理解有一定的作用。
3. 长短期记忆网络（Long Short-Term Memory, LSTM）：LSTM 是 RNN 的一种特殊形式，能够更好地捕捉长距离依赖关系，适用于处理手写数字的连续笔画。
4. 支持向量机（Support Vector Machine, SVM）：SVM 可以用于分类问题，也可以用于手写数字的识别和分类。
5. K近邻算法（K-Nearest Neighbors, KNN）：KNN 是一种简单有效的分类算法，也可以用于手写数字的识别。

这些神经网络和算法在手写数字识别中被广泛应用，并且在实践中取得了良好的效果。

那种效果最好？

在手写数字识别任务中，卷积神经网络（CNN）通常被认为是效果最好的网络之一。CNN 在图像识别领域有着卓越的表现，其结构能够有效提取图像的特征，并且对于手写数字的识别具有较高的准确率和鲁棒性。许多经典的手写数字识别模型，如LeNet、AlexNet、VGG、ResNet等，都是基于CNN结构构建的。因此，CNN 在手写数字识别中通常能够取得最好的效果。

LeNet（1998）、AlexNet（2012）、VGG（2014）、ResNet（2015），（）内指该网络是哪一年出现的。ResNet使用了残差结构，解决了模型深度越来越深的同时梯度消失的问题，这值得学习一下。因此，本文使用ResNet实现手写数字识别任务。

使用ResNet实现手写数字识别

1. 准备数据集：首先要准备手写数字的数据集，例如MNIST数据集，包括训练集和测试集。
2. 构建ResNet模型：可以使用TensorFlow或PyTorch中的预定义ResNet模型，也可以根据自己的需求构建ResNet模型。
3. 数据预处理：对数据集进行预处理，包括归一化、reshape等操作，使其适合ResNet模型的输入要求。
4. 训练模型：使用训练集对ResNet模型进行训练，可以使用交叉熵损失函数和随机梯度下降（SGD）等优化算法。
5. 评估模型：使用测试集对训练好的ResNet模型进行评估，计算准确率等指标。
6. 预测：使用训练好的ResNet模型对新的手写数字图像进行预测。

• ok 上面6步，一步一步走

1.准备数据集

import torch
import torchvision
import torchvision.transforms as transforms


# 数据导入
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, ), (0.5, ))
])
BatchSize = 64
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=False, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=BatchSize, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=BatchSize, shuffle=False)

• 文件结构是这个样子

• 我觉得不好看，比较难懂，于是转为图片的形式

import torchvision.transforms as transforms
from torchvision.datasets import MNIST
import os

# 定义数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),  # 将图片转换为Tensor
])

# 加载MNIST测试集
dataset = MNIST(root='./data', train=False, download=True)

# dataset = MNIST(root='./data', train=True, download=True)
# save_dir = 'mnist_train_images'

# 创建保存图片的文件夹
save_dir = 'mnist_test_images'

if not os.path.exists(save_dir):
    os.makedirs(save_dir)

# 将MNIST测试集中的图片保存为文件
for i in range(len(dataset)):
    image, label = dataset[i]
    image = transform(image)  # 使用数据预处理步骤
    image = transforms.ToPILImage()(image)  # 将Tensor转换为PIL图片
    image.save(os.path.join(save_dir, f'{i:05d}.jpg'))

• 结果是：

训练集图片

测试集图片

• 上面两个数据集我也上传了，免积分下载，还在审核当中，审核好了我会把连接更新过来

2.构建ResNet模型

• 主要就是修改了输入和输出，不改运行不了。这里写成了类，方便导入到其他文件中，这个文件是 MyNet.py

import torch
from torchvision.models import resnet18
import torch.nn as nn
import torchvision.models as models


# 创建自定义的ResNet-18模型类
class CustomResNet18(nn.Module):
    def __init__(self):
        super(CustomResNet18, self).__init__()
        self.resnet18 = models.resnet18(weights=None)
        self.resnet18.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)  # 修改输入通道数为1
        num_ftrs = self.resnet18.fc.in_features
        self.resnet18.fc = nn.Linear(num_ftrs, 10)  # 修改输出大小为10（适应10个类别）

    def forward(self, x):
        x = self.resnet18.conv1(x)
        x = self.resnet18.bn1(x)
        x = self.resnet18.relu(x)
        x = self.resnet18.maxpool(x)

        x = self.resnet18.layer1(x)
        x = self.resnet18.layer2(x)
        x = self.resnet18.layer3(x)
        x = self.resnet18.layer4(x)

        x = self.resnet18.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.resnet18.fc(x)

        return x
    
# # 创建自定义ResNet-18模型实例
# custom_resnet18 = CustomResNet18()

3.数据预处理

• pytorch太舒服了，在第一步：数据集的准备，就将这部分的活干完了，就那个transforms 那部分

4.训练模型

• 训练这块需要注意的是：resnet18已经算比较深的网络了，使用cpu训练太慢，我用GPU训练，显卡：英伟达3060

batch_size	64
epoch	5
耗时	3
损失函数	交叉熵损失函数
优化器	SGD与Adam
学习率	0.001

-结果： loss:0.004

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim
from MyNet import CustomResNet18


# 数据处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, ), (0.5, ))
])

trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)


# 创建自定义ResNet-18模型实例
custom_resnet18 = CustomResNet18()

# 使用GPU进行训练
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
custom_resnet18.to(device)

# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(custom_resnet18.parameters(), lr=0.001, momentum=0.9)
#Adam优化
# optimizer = torch.optim.Adam(custom_resnet18.parameters(), lr=0.001)

# 训练模型
for epoch in range(5):  # 遍历数据集多次
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data[0].to(device), data[1].to(device)
        optimizer.zero_grad()
        
        outputs = custom_resnet18(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 200 == 199:    # 每200个batch打印一次
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

# 保存训练好的模型
PATH = './mnist_resnet18.pth'
torch.save(custom_resnet18.state_dict(), PATH)

5.评估模型

• 精度98%，还可以提升，提到99.5 都可以，但是做到后面的我暂时没做

import torch
import torchvision.transforms as transforms
import torchvision
from MyNet import CustomResNet18


# 使用GPU进行训练
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)

# 创建自定义ResNet-18模型实例
custom_resnet18 = CustomResNet18().to(device)
custom_resnet18.load_state_dict(torch.load('mnist_resnet18.pth'))
custom_resnet18.eval()

# 数据处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, ), (0.5, ))
])

testset = torchvision.datasets.MNIST(root='./data', train=False, download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = custom_resnet18(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('模型准确率: %d %%' % (100 * correct / total))

6.预测

• 预测这里，我喜欢看直观的结果，就把输出的结果打印在图片上了，效果还不错

import torch
import torchvision.transforms as transforms
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
from MyNet import CustomResNet18

# 加载自定义的ResNet18模型
model = CustomResNet18()
model.load_state_dict(torch.load('mnist_resnet18.pth'))
model.eval()

# 读取前十张图片进行预测
for i in range(10):
    image_path = f'mnist_test_images\\{i:05d}.jpg'
    image = Image.open(image_path)
    image = image.convert('L')  # 转换为灰度图
    # print(image.size)
    # plt.imshow(image, cmap='gray')
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,))
    ])
    image = transform(image).unsqueeze(0)

    # 进行模型预测
    with torch.no_grad():
        output = model(image)
        _, predicted = torch.max(output, 1)

    # 在原图片右上角显示预测结果
    image = np.array(image.squeeze(0) * 0.5 + 0.5)  # 将图像数据转换为numpy数组，并反归一化
    image = np.reshape(image,(28,28))
    plt.imshow(image, cmap='gray')
    plt.text(5, 1, f'Predicted: {predicted.item()}', color='red', fontsize=16, ha='center')
    plt.axis('off')
    plt.show()

• 看下前4个的结果，表现很好
  
  

理论学习：ResNet网路结构

• “理论指导行动”，下面是相关理论知识的链接

1.ResNet网络结构分析
2.ResNet-18超详细介绍！！！！
3.ResNet-论文全文完整翻译+注解
4.原文网站：https://arxiv.org/abs/1512.03385

联系方式

QQ：1727359387
源码下载链接：请点击 数据集及源码