【深度学习】用pytorch实现数字识别

已于 2024-09-11 17:04:06 修改
阅读量860 收藏 19
点赞数 12
文章标签： 机器学习 pytorch 人工智能
于 2024-09-11 17:02:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z87726848/article/details/142128411
版权

1.背景介绍


      1.1 数据集来源

      本文使用的是MNIST数据集,里面包含了0到9十种数字的28*28像素规格的灰度图片,总共包含6万张训练数据集和1万张的测试数据集 由Yann LeCun、Corinna Cortes和Christopher Burges他们在1998年发布，用于手写数字的图像识别任务.

2.引入包导入数据集

     2.1 引入外部包 

     首先先导入我们本次需要使用的所有外部的的


import torch
from torch import nn
from torch.nn import functional as F
from torch import optim

import torchvision
from   util import plot_curve,plot_image,one_hot

    util类的代码如下 自行编写并引入或者直接去除util类的导入直接把引入的方法写在当前类里

import torch
from matplotlib import pyplot as plt


def plot_curve(data):
    """
    下降曲线的绘制
    :param data: 损失值列表
    :return: None
    """
    fig = plt.figure()
    plt.plot(range(len(data)), data, color='blue')  # 绘制损失值曲线
    plt.legend(['value'], loc='upper right')  # 图例
    plt.xlabel('step')  # x轴标签
    plt.ylabel('value')  # y轴标签
    plt.show()  # 显示图形



def plot_image(img, label, name):
    """
    可视化识别结果
    :param img: 图像张量
    :param label: 标签张量
    :param name: 图像标题
    :return: None
    """
    fig = plt.figure()
    for i in range(6):  # 显示前 6 张图像
        plt.subplot(2, 3, i + 1)  # 创建 2 行 3 列的子图
        plt.tight_layout()  # 调整子图布局
        plt.imshow(img[i][0] * 0.3081 + 0.1307, cmap='gray', interpolation='none')  # 显示图像
        plt.title("{}: {}".format(name, label[i].item()))  # 设置标题
        plt.xticks([])  # 不显示 x 轴刻度
        plt.yticks([])  # 不显示 y 轴刻度
    plt.show()  # 显示图形



def one_hot(labels, depth=10):
    """
    将标签转换为 one-hot 编码
    :param labels: 标签张量
    :param depth: 类别数（即 one-hot 编码的长度）
    :return: one-hot 编码张量
    """
    # 确保标签是 Long 类型
    labels = labels.long()

    # 创建一个全零的张量
    out = torch.zeros(labels.size(0), depth)

    # 将标签索引变为一列的张量
    idx = labels.view(-1, 1)

    # 使用 scatter 操作将值设为 1
    out.scatter_(dim=1, index=idx, value=1)

    return out


#plot_curve 用于绘制损失曲线，监控训练过程。
#plot_image 用于展示图像和预测结果，帮助检查模型的输出。
#one_hot 用于将标签转换为 one-hot 编码，是分类任务中常见的预处理步骤。
   2.2 加载MNIST数据集
# 第一步加载数据集
def load_dataset():
    #一次性处理数据集图片的数量(根据电脑性能自行调整)
    batch_size = 512

    #加载mnist训练数据集
    train_loader = torch.utils.data.DataLoader(
         
        torchvision.datasets.MNIST('mnist_data', train=True, download=True,
                                   transform=torchvision.transforms.Compose([
                                       torchvision.transforms.ToTensor(),
                                       torchvision.transforms.Normalize(
                                           (0.1307,), (0.3081,))
                                   ])),
        batch_size=batch_size, shuffle=True)

    #加载mnist测试数据集
    test_loader = torch.utils.data.DataLoader(
        torchvision.datasets.MNIST('mnist_data/', train=False, download=True,
                                   transform=torchvision.transforms.Compose([
                                       torchvision.transforms.ToTensor(),
                                       torchvision.transforms.Normalize(
                                           (0.1307,), (0.3081,))
                                   ])),
        batch_size=batch_size, shuffle=False)

         为了让大家有更好的理解我在这里大致阐述一下每个参数是用来做什么的
  从 torch.utils.data.DataLoader 这个函数开始

参数名称用途
mnist_data下载路径,用来下载指定的数据集
train=True是否是训练数据 True 为是,说明是下载的训练数据集 False为否,说明是下载的测试数据集
download=True如果本地不存在该数据集则下载  如果download=False则反之
   transform=torchvision.transforms.Compose([
                                       torchvision.transforms.ToTensor(),
                                       torchvision.transforms.Normalize(
                                           (0.1307,), (0.3081,))
                                   ]))		用于格式化数据集使用,将图像转为张量并进行归一化。
 batch_size=batch_size一次加载多少张图片 batch_size是我们自定义的变量代码中是512
 shuffle=True为True意味着我们将这个数据集做一个随机的打散

        然后我们展开讲讲torchvision.transforms.Compose()这个函数
    

参数名称用途
 torchvision.transforms.ToTensor()把下载的数据集转为torch中的tensor格式的数据载体,用于后面的使用torch框架训练
     torchvision.transforms.Normalize((0.1307,),(0.3081,))正则化过程,这是什么意思呢？因为我们神经网络所接收的一个数据最好是在。0附近均匀的分配，但是我们的一个图片的一个像素，它是从0到1，也就是说它只在0的右侧分布，这样子的话，我们通过一个这样的减去0.1307，再除以一个0.3081标准差的一个这样过程。使得你的一个数据能够在零附近能够均匀的分布，这个就更加方便我们神经网络去优化，对于这一行可以不做。所以这一行你可以注释掉，你也可以不注释，通过测试发现，如果你注释掉的话，你的性能会稍微差一点，大概是70%的样子。

3.定义神经化网络模型
 

3.1代码展示

       本次实验我们将采用三层神经网络模型这个 Net 类定义了一个简单的前馈神经网络（也叫全连接神经网络），包括两个隐藏层和一个输出层。每个全连接层后面跟着 ReLU 激活函数，使得网络可以学习复杂的非线性关系。这个网络设计适合处理图像分类任务，如 MNIST 手写数字识别。

# 定义神经网络模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 256)  # 输入层到隐藏层1的线性变换
        self.fc2 = nn.Linear(256, 64)  # 隐藏层1到隐藏层2的线性变换
        self.fc3 = nn.Linear(64, 10)  # 隐藏层2到输出层的线性变换

    def forward(self, x):
        x = F.relu(self.fc1(x))  # 应用 ReLU 激活函数
        x = F.relu(self.fc2(x))  # 应用 ReLU 激活函数
        x = self.fc3(x)  # 输出层
        return x

net = Net()  # 实例化模型
3.2详细讲解

   

  3.2.1 nn.Linear

   nn.Linear 是一个全连接层，它的作用是对输入数据进行线性变换。在初始化 nn.Linear 时，需要指定输入和输出的特征数量。

作用：

 比如第一个self.fc1 = nn.Linear(28*28, 256)  中 第一个参数是输入特征 28*28是固定的因为输入的x是一个28*28像素的固定图像 当他从二维的图像数据展平成一维每张图像有 28x28=784 个像素值，所以这里输入特征的数量是 784。第二个参数 256 这是输出特征的数量，表示该全连接层将输入的 784 个特征变换成 256 个特征。当然这个256个特征是自己根据经验来定义的并不是死的 你也可以不用三层可以用四层或者多层但是方法都是类似的。为了让大家更加详细的理解我绘制了如下图片

       

3.2.2 F.relu()

 F.relu(self.fc1(x))：F.relu 是 PyTorch 提供的 ReLU 激活函数。ReLU（Rectified Linear Unit，线性整流单元）函数将所有负值变为 0，正值保持不变。这个操作是非线性的，帮助网络学习复杂的特征。

 ReLU 激活函数的公式：ReLU(x)=max⁡(0,x)

作用：

应用 ReLU 激活函数，使得每个特征值变为非负数。通过这种方式，网络能够引入非线性，增强表达能力。这块大家可以自行搜索资料去查看 本文主要是带大家熟悉整体的流程

4.训练模型

# 定义优化器
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)  # 使用随机梯度下降优化器，学习率为 0.001，动量为 0.9

train_loss = []  # 存储训练过程中的损失

# 训练模型
for epoch in range(3):  # 训练 3 个 epoch
    for batch_idx, (x, y) in enumerate(train_loader):
        x = x.view(x.size(0), 28*28)  # 将每张图片展平成一维向量

        out = net(x)  # 前向传播，获取模型输出
        y_onehot = one_hot(y, 10)  # 将标签转换为 one-hot 编码
        loss = F.mse_loss(out, y_onehot)  # 计算均方误差损失

        optimizer.zero_grad()  # 清零梯度
        loss.backward()  # 反向传播计算梯度
        optimizer.step()  # 更新权重

        train_loss.append(loss.item())  # 记录损失值

        if batch_idx % 10 == 0:  # 每 10 个批次打印一次损失
            print(epoch, batch_idx, loss.item())

# 绘制训练损失曲线
plot_curve(train_loss)

5.测试模型

# 测试模型
total_correct = 0  # 记录总的正确预测数

for x, y in test_loader:
    x = x.view(x.size(0), 28*28)  # 将测试数据展平成一维向量
    out = net(x)  # 前向传播，获取模型输出
    pred = out.argmax(dim=1)  # 获取预测的类别
    correct = pred.eq(y).sum().float().item()  # 计算正确的预测数量
    total_correct += correct  # 累加正确的预测数

total_num = len(test_loader.dataset)  # 测试数据集中样本总数
acc = total_correct / total_num  # 计算准确率
print('测试的准确率:', acc)  # 打印测试准确率

# 从测试数据中取出一个批次并绘制图像
x, y = next(iter(test_loader))
out = net(x.view(x.size(0), 28*28))  # 展平图片并进行前向传播
pred = out.argmax(dim=1)  # 获取预测的类别
plot_image(x, pred, 'test')  # 绘制测试图像及预测结果

6.整体完整代码和测试结果

import torch
from torch import nn
from torch.nn import functional as F
from torch import optim
import torchvision
from matplotlib import pyplot as plt
from util import plot_curve, plot_image, one_hot

# 第一步加载数据集
batch_size = 512  # 设置每个批次的大小

# 加载 MNIST 训练数据集
train_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST('mnist_data', train=True, download=True,  # 下载并加载 MNIST 训练数据
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),  # 将图片转化为 Tensor
                                   torchvision.transforms.Normalize(
                                       (0.1307,), (0.3081,))  # 标准化处理
                               ])),
    batch_size=batch_size, shuffle=True)  # 每批次的数据大小和是否打乱顺序

# 加载 MNIST 测试数据集
test_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST('mnist_data/', train=False, download=True,  # 下载并加载 MNIST 测试数据
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),  # 将图片转化为 Tensor
                                   torchvision.transforms.Normalize(
                                       (0.1307,), (0.3081,))  # 标准化处理
                               ])),
    batch_size=batch_size, shuffle=True)  # 每批次的数据大小和是否打乱顺序

# 从测试数据加载器中获取一个批次的数据
x, y = next(iter(test_loader))
print(x.shape, y.shape, x.min(), x.max())  # 打印图片张量的形状和数值范围

# 定义神经网络模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 256)  # 输入层到隐藏层1的线性变换
        self.fc2 = nn.Linear(256, 64)  # 隐藏层1到隐藏层2的线性变换
        self.fc3 = nn.Linear(64, 10)  # 隐藏层2到输出层的线性变换

    def forward(self, x):
        x = F.relu(self.fc1(x))  # 应用 ReLU 激活函数
        x = F.relu(self.fc2(x))  # 应用 ReLU 激活函数
        x = self.fc3(x)  # 输出层
        return x

net = Net()  # 实例化模型

# 定义优化器
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)  # 使用随机梯度下降优化器，学习率为 0.001，动量为 0.9

train_loss = []  # 存储训练过程中的损失

# 训练模型
for epoch in range(3):  # 训练 3 个 epoch
    for batch_idx, (x, y) in enumerate(train_loader):
        x = x.view(x.size(0), 28*28)  # 将每张图片展平成一维向量

        out = net(x)  # 前向传播，获取模型输出
        y_onehot = one_hot(y, 10)  # 将标签转换为 one-hot 编码
        loss = F.mse_loss(out, y_onehot)  # 计算均方误差损失

        optimizer.zero_grad()  # 清零梯度
        loss.backward()  # 反向传播计算梯度
        optimizer.step()  # 更新权重

        train_loss.append(loss.item())  # 记录损失值

        if batch_idx % 10 == 0:  # 每 10 个批次打印一次损失
            print(epoch, batch_idx, loss.item())

# 绘制训练损失曲线
plot_curve(train_loss)

# 测试模型
total_correct = 0  # 记录总的正确预测数

for x, y in test_loader:
    x = x.view(x.size(0), 28*28)  # 将测试数据展平成一维向量
    out = net(x)  # 前向传播，获取模型输出
    pred = out.argmax(dim=1)  # 获取预测的类别
    correct = pred.eq(y).sum().float().item()  # 计算正确的预测数量
    total_correct += correct  # 累加正确的预测数

total_num = len(test_loader.dataset)  # 测试数据集中样本总数
acc = total_correct / total_num  # 计算准确率
print('测试的准确率:', acc)  # 打印测试准确率

# 从测试数据中取出一个批次并绘制图像
x, y = next(iter(test_loader))
out = net(x.view(x.size(0), 28*28))  # 展平图片并进行前向传播
pred = out.argmax(dim=1)  # 获取预测的类别
plot_image(x, pred, 'test')  # 绘制测试图像及预测结果

由于我电脑性能一般 3轮跑下来准确率仅有百分之60% 大家可以多跑几轮尝试一下以下为损失曲线图和结果预测图

7.总结 

       手写数字识别作为深度学习入门的一个小实验旨意在带大家了解pytorch和神经网络，中间有很多东西大家可以去自行探索包括搭建更多层的神经网络等，某些方面大家不了解的可以自行搜索资料。感谢大家的观看

a yes-man
关注
深度学习【使用PyTorch实现手写数字识别】
weixin_43923463的博客
08-23 1871
模型的构建使用了一个三层（输入层，输出层，全连接层）的神经网络，其中包括两个全连接层和一个输出层，第一个全连接层会经过激活函数的处理，将处理后的结果交给下一个全连接层，进行变换后输出结果。，黑白图片的通道数只有1，其中每个像素点的取值为[0,255],彩色图片的通道数为(R,G,B),每个通道的每个像素点的取值为[0,255]，三个通道的颜色相互叠加，形成了各种颜色。给定均值：mean，shape和图片的通道数相同(指的是每个通道的均值)，方差：std，和图片的通道数相同(指的是每个通道的方差)，将会把。.
深度学习 pytorch手写数字识别 MNIST数据集 解析+详细注释
11-01
本项目将介绍如何使用PyTorch实现手写数字识别，特别针对MNIST数据集进行解析，并提供了详细注释的源码。 MNIST数据集是深度学习入门的经典案例，由Yann LeCun等人维护，包含60,000个训练样本和10,000个测试样本的...
pytrch手写数字识别
weixin_42529756的博客
02-17 633
使用Pytorch实现手写数字识别 目标 知道如何使用Pytorch完成神经网络的构建 知道Pytorch中激活函数的使用方法 知道Pytorch中torchvision.transforms中常见图形处理函数的使用 知道如何训练模型和如何评估模型 1. 思路和流程分析 流程： 准备数据，这些需要准备DataLoader 构建模型，这里可以使用torch构造一个深层的神经网络 模型的训练 模型的保存，保存模型，后续持续使用 模型的评估，使用测试集，观察模型的好坏 2. 准备训练集和测试集 准备数据集
详解PyTorch手写数字识别(MNIST数据集)
09-18
主要介绍了详解PyTorch手写数字识别(MNIST数据集)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
PyTorch--卷积神经网络（CNN）模型实现手写数字识别
wumingzei的博客
08-14 1551
今天要介绍的这段代码是一个使用PyTorch框架实现的卷积神经网络（CNN）模型，用于对MNIST数据集进行分类的示例。MNIST数据集是手写数字识别领域的一个标准数据集，包含0到9的灰度图像。导入必要的库：导入PyTorch、PyTorch神经网络模块、torchvision（用于处理图像数据集）和transforms（用于图像预处理）。设备配置：设置模型运行的设备，优先使用GPU（如果可用），否则使用CPU。超参数设置：定义了训练迭代的轮数(num_epochs)、类别数()、批次大小(
使用pytorch实现数字识别器
weixin_57342469的博客
08-04 952
使用pytorch实现数字识别器
PyTorch——手写数字识别
原谅我这一生不羁放纵爱自由
08-29 6917
目录PyTorch 学习 —— 手写数字识别Ⅰ. 数据读取器1. 训练集2. 验证集和测试集Ⅱ. 搭建网络Ⅲ. 模型训练1. 开始训练2. 模型验证Ⅲ. 模型测试Ⅳ. 绘制图像Ⅴ. 完整代码 PyTorch 学习 —— 手写数字识别   MNIST 数据集，其包含70000 个28×28 的手写数字的数据集，其中又分为60000 个训练样本与10000 个测试样本。 Ⅰ. 数据读取器 import torch from torch import nn from torch import optim fro
深度学习速成(4)Pytorch实现数字识别
qq_45591302的博客
05-24 486
手动实现数字识别
深度学习之Python 脚本训练keras mnist 数字识别模型
03-08 2250
本脚本是训练keras 的mnist 数字识别程序 ，以前发过了 ，今天把 预测实现了，# Larger CNN for the MNIST Dataset # 2.Negative dimension size caused by subtracting 5 from 1 for 'conv2d_4/convolution' (op: 'Conv2D') with input shapes # ...
深度学习作业-基于pytorch框架python实现手写数字识别完整源码+代码注释+实验报告.zip
12-14
深度学习作业_基于pytorch框架python实现手写数字识别完整源码+代码注释+实验报告.zip 使用MNIST手写数字体数据集进行训练和预测，实现测试集准确率达到98%及以上。本实验的目的： 掌握卷积神经网络基本原理，以...
深度学习作业-基于pytorch框架python实现手写数字识别完整源码+代码注释+文档说明
最新发布
09-13
深度学习作业-基于pytorch框架python实现手写数字识别完整源码+代码注释+文档说明深度学习作业-基于pytorch框架python实现手写数字识别完整源码+代码注释+文档说明深度学习作业-基于pytorch框架python实现手写数字...
pytorch简单手写数字识别
爱听许嵩歌的博客
07-14 689
简单回归问题 只使用numpy编写，代码里有注释 import numpy as np # y = wx + b # 计算均方误差 # ???????????????? = ???????? + ???? − ???? def compute_error_for_line_given_points(b, w, points): totalError = 0 for i in range(0, len(points)): x = points[i, 0]
【机器学习入门】使用pytorch实现手写数字识别
m0_53294028的博客
03-28 2993
今天学习的内容是以手写数字识别任务为例，展示了使用PyTorch框架构建和训练一个简单的神经网络模型的完整流程。数据预处理：定义了数据转换操作，包括将图像转换为张量和归一化处理。下载并加载了MNIST数据集，分为训练集和测试集。创建了数据加载器，用于批量加载数据并在每个epoch开始时打乱数据顺序。模型定义：使用MnistNet类定义了一个神经网络模型，该类继承自nn.Module。MnistNet类中包含了两个卷积层和两个全连接层，以及前向传播逻辑。
Pytorch神经网络【手写数字识别】
早起CaiCai的学习空间
06-18 3064
利用神经网络完成对手写数字进行识别的实例。 在手写数字的识别中，我们不关心图形的颜色，所以需要的是灰度图。
Pytorch实现手写数字识别【基于全连接神经网络】
Consult_
07-18 9808
构建全连接神经网络模型，使用pytroch实现手写数字识别
PyTorch手写数字识别
MusicDancing的博客
12-11 1092
1. MNIST数据集简介 包含了6W训练样本和1W条测试样本，共10类(0-9)，每张图片都做了尺寸归一化，都是28*28大小的灰度图。 2. 模型训练 2.1 超参数定义 import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision import datasets, transforms # 超参数定义 EPOC...
PyTorch之简单手写数字识别
m0_53245772的博客
11-20 4020
所以我们要通过。
pytorch手写数字识别
qq_44918665的博客
11-28 371
结果
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值