MNIST手写数字数据集分类

已于 2024-12-24 12:59:18 修改
阅读量469 收藏 3
点赞数 4
文章标签： 分类 数据挖掘 人工智能
于 2024-12-24 10:52:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_73993302/article/details/144686496
版权
  • 这段代码实现了一个基于PyTorch的深度学习模型，主要用于对MNIST手写数字数据集进行分类。代码包含了模型的定义、数据加载、训练过程以及模型评估。

  • 代码逐步解释：

  • 导入库：
  • import torch
from torch import nn,optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import datasets,transforms
  • 导入PyTorch相关的库，包括神经网络模块（nn）、优化器（optim）、自动求导（Variable）、数据加载工具（DataLoader）以及图像处理工具（datasets和transforms）。
  • 设置超参数：
  • batch_size=64
learning_rate=0.02
num_epoches=100
  • 定义批次大小（batch_size）、学习率（learning_rate）和训练轮数（num_epoches）。
  • 定义神经网络模型：
  • class Batch_Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Batch_Net,self).__init__()
        self.layer1=nn.Sequential(nn.Linear(in_dim,n_hidden_1),nn.BatchNorm1d(n_hidden_1),nn.ReLU(True))
        self.layer2=nn.Sequential(nn.Linear(n_hidden_1,n_hidden_2),nn.BatchNorm1d(n_hidden_2),nn.ReLU(True))
        self.layer3=nn.Sequential(nn.Linear(n_hidden_2,out_dim))
    def forward(self,x):
        x=self.layer1(x)
        x=self.layer2(x)
        x=self.layer3(x)
        return x
  • 定义一个名为Batch_Net的神经网络类，包含三个层：
    • 第一层：线性层 + 批归一化 + ReLU激活函数。
    • 第二层：线性层 + 批归一化 + ReLU激活函数。
    • 第三层：线性层（输出层）。
  • 数据预处理：
  • data_tf=transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5],[0.5])])
train_dataset=datasets.MNIST(root='./data',train=True,transform=data_tf,download=True)
test_dataset=datasets.MNIST(root='./data',train=False,transform=data_tf)
train_loader=DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader=DataLoader(test_dataset,batch_size=batch_size,shuffle=False)
  • 定义数据转换，包括将图像转换为张量并进行归一化。
    • 下载并加载MNIST训练集和测试集，并使用DataLoader进行批量加载。
  • 初始化模型、损失函数和优化器：
  • model=Batch_Net(28*28,300,100,10)
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=learning_rate)
  • 创建模型实例，指定输入维度、隐藏层维度和输出维度。
    • 使用交叉熵损失作为损失函数。
    • 使用随机梯度下降（SGD）作为优化器。
  • 训练模型：
  • epoch=0
for data in train_loader:
    img,label=data
    img=img.view(img.size(0),-1)
    if torch.cuda.is_available():
        img=img.cuda()
        label=label.cuda()
    else:
        img=Variable(img)
        label=Variable(label)
    out=model(img)
    loss=criterion(out,label)
    print_loss=loss.data.item()
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    epoch+=1
    if epoch%100==0:
        print('epoch: {},loss: {:.4}'.format(epoch,print_loss))
  • 遍历训练数据，进行以下步骤：
    • 将图像数据展平以适应模型输入。
    • 检查是否使用GPU，并相应地将数据转移到GPU。
    • 前向传播计算输出。
    • 计算损失。
    • 清零优化器的梯度。
    • 反向传播计算梯度。
    • 更新模型参数。
    • 每100个epoch打印一次损失。
  • 保存模型：
  • torch.save(model.state_dict(), 'batch_net_model.pth')
  • 将训练好的模型参数保存到文件中。
  • 评估模型：
  • model.eval()
eval_loss=0
eval_acc=0
for data in test_loader:
    img,label=data
    img = img.view(img.size(0), -1)
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()
    else:
        img = Variable(img)
        label = Variable(label)
    out = model(img)
    loss = criterion(out, label)
    eval_loss+=loss.data.item()*label.size(0)
    _,pred=torch.max(out,1)
    num_correct=(pred==label).sum()
    eval_acc+=num_correct.item()
    print('Test loss: {:.6f},Acc: {:.6f}'.format(
        eval_loss/(len(test_dataset)),eval_acc/(len(test_dataset))))
  • 将模型设置为评估模式，并初始化评估损失和准确率。
    • 遍历测试数据，计算损失和准确率，并打印结果。

整体来说，这段代码实现了一个简单的神经网络模型用于MNIST数据集的分类任务，包括数据预处理、模型训练和评估。

完整代码：

import torch
from torch import nn,optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import datasets,transforms
batch_size=64
learning_rate=0.02
num_epoches=100
class Batch_Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Batch_Net,self).__init__()
        self.layer1=nn.Sequential(nn.Linear(in_dim,n_hidden_1),nn.BatchNorm1d(n_hidden_1),nn.ReLU(True))
        self.layer2=nn.Sequential(nn.Linear(n_hidden_1,n_hidden_2),nn.BatchNorm1d(n_hidden_2),nn.ReLU(True))
        self.layer3=nn.Sequential(nn.Linear(n_hidden_2,out_dim))
    def forward(self,x):
        x=self.layer1(x)
        x=self.layer2(x)
        x=self.layer3(x)
        return x
data_tf=transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5],[0.5])])
train_dataset=datasets.MNIST(root='./data',train=True,transform=data_tf,download=True)
test_dataset=datasets.MNIST(root='./data',train=False,transform=data_tf)
train_loader=DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader=DataLoader(test_dataset,batch_size=batch_size,shuffle=False)
model=Batch_Net(28*28,300,100,10)
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=learning_rate)
epoch=0
for data in train_loader:
    img,label=data
    img=img.view(img.size(0),-1)
    if torch.cuda.is_available():
        img=img.cuda()
        label=label.cuda()
    else:
        img=Variable(img)
        label=Variable(label)
    out=model(img)
    loss=criterion(out,label)
    print_loss=loss.data.item()
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    epoch+=1
    if epoch%100==0:
        print('epoch: {},loss: {:.4}'.format(epoch,print_loss))
torch.save(model.state_dict(), 'batch_net_model.pth')
model.eval()
eval_loss=0
eval_acc=0
for data in test_loader:
    img,label=data
    img = img.view(img.size(0), -1)
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()
    else:
        img = Variable(img)
        label = Variable(label)
    out = model(img)
    loss = criterion(out, label)
    eval_loss+=loss.data.item()*label.size(0)
    _,pred=torch.max(out,1)
    num_correct=(pred==label).sum()
    eval_acc+=num_correct.item()
    print('Test loss: {:.6f},Acc: {:.6f}'.format(
        eval_loss/(len(test_dataset)),eval_acc/(len(test_dataset))))

结果：

图片测试：

import torch
import cv2
import numpy as np
from torchvision import transforms
from torch import nn
# 定义Batch_Net模型结构
class Batch_Net(nn.Module):
    def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
        super(Batch_Net, self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1), nn.BatchNorm1d(n_hidden_1), nn.ReLU(True))
        self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2), nn.BatchNorm1d(n_hidden_2), nn.ReLU(True))
        self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x
# 加载图像
image = cv2.imread('1.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 预处理图像
data_tf = transforms.Compose([
    transforms.ToTensor(),                  # 转换为Tensor
    transforms.Normalize([0.5], [0.5])     # 归一化
])
# 将图像调整为28x28，并添加批次维度
gray_image = cv2.resize(gray_image, (28, 28))  # 确保图像大小为28x28
gray_image = data_tf(gray_image).view(1, -1)   # 展平并添加批次维度
# 创建模型实例并加载权重
model = Batch_Net(28 * 28, 300, 100, 10)
model.load_state_dict(torch.load('batch_net_model.pth'))
model.eval()  # 设置模型为评估模式
# 进行推理
with torch.no_grad():  # 不需要计算梯度
    output = model(gray_image)
    _, predicted = torch.max(output, 1)
    print(f'预测的数字是: {predicted.item()}')

m0_73993302
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值