神经网络-MNIST数据集训练

红米煮粥

于 2024-09-17 21:17:40 发布

阅读量658

点赞数 18

文章标签：神经网络人工智能深度学习

本文链接：https://blog.csdn.net/2301_77698138/article/details/142316164

版权

文章目录

一、MNIST数据集
二、代码实现
三、总结

一、MNIST数据集

MNIST数据集是深度学习和计算机视觉领域非常经典且基础的数据集，它包含了大量的手写数字图片，通常用于训练各种图像处理系统，也被广泛用于机器学习领域的训练和测试。

1.数据集概述

来源：MNIST数据集由Yann LeCun等人于1994年创建，它是NIST（美国国家标准与技术研究所）数据集的一个子集。
内容：数据集主要包含手写数字（0~9）的图片及其对应的标签。
用途：作为深度学习和计算机视觉领域的入门级数据集，它适合初学者练习建立模型、训练和预测。

2.数据集组成

MNIST数据集总共包含两个子数据集：训练数据集和测试数据集。

训练数据集：

包含了60,000张28x28像素的灰度图像。
对应的标签文件包含了60,000个标签，每个标签对应一张图像中的手写数字。

测试数据集：

包含了10,000张28x28像素的灰度图像。
对应的标签文件包含了10,000个标签。

3.文件结构

MNIST数据集包含四个文件，分别是训练集图像、训练集标签、测试集图像和测试集标签。这些文件以gzip格式压缩，并且不是标准的图像格式，需要通过专门的编程方式读取。

训练集图像：train-images-idx3-ubyte.gz
训练集标签：train-labels-idx1-ubyte.gz）
测试集图像：t10k-images-idx3-ubyte.gz
测试集标签：t10k-labels-idx1-ubyte.gz

4.数据特点

图像大小：每张图像的大小为28x28像素，是一个灰度图像，位深度为8（灰度值范围为0~255）。
数据来源：手写数字来自250个不同的人。
数据格式：图像数据以字节的形式存储在二进制文件中，标签文件则存储了每张图像对应的数字标签。

二、代码实现

1.数据加载与预处理

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(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),  # 张量，图片是不能直接传入神经网络模型
)

"""下载测试集数据（包括训练图片和标签）"""
test_data = datasets.MNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()
)
train_dataloader = DataLoader(training_data, batch_size=64)  # 64张图片为一个包
test_dataloader = DataLoader(test_data, batch_size=64)

下载数据集：使用torchvision.datasets.MNIST下载并加载MNIST数据集。数据集分为训练集和测试集，train=True为训练集数据，train=False为测试集数据。
数据转换：数据通过transform=ToTensor()进行预处理，将图片转换为PyTorch张量（Tensor），并自动将像素值归一化到[0,1]区间。
数据封装：使用DataLoader将数据集封装成批次（batch）形式，便于后续的训练和测试过程。

2. 模型定义

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.hidden3 = nn.Linear(256, 128)
        self.out = nn.Linear(128, 10)

    def forward(self, x):  # 前向传播，告诉它，数据的流向。
        x = self.flatten(x)  # 图像进行展开
        x = self.hidden1(x)
        x = torch.sigmoid(x) 
        x = self.hidden2(x)
        x = torch.sigmoid(x)
        x = self.hidden3(x)
        x = torch.sigmoid(x)
        x = self.out(x)
        return x


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

定义类：定义了一个名为NeuralNetwork的类，该类继承自nn.Module，用于构建神经网络模型。
模型结构：模型包含输入层，输出层，隐藏层，其中隐藏层使用了Sigmoid激活函数，最后输出10个类别的得分（对应0-9的数字）
打印模型结构：打印了模型的结构，有助于理解模型的架构。
在这里插入图片描述

3. 训练和测试函数

def train(dataloader, model, loss_fn, optimizer):
    model.train()
    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
        # Backpropaqation 进来-个bqtch的数据，计算一次梯度，更新一次网络
        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)
    num_batches = len(dataloader)
    model.eval()  # 测试，w就不能再更新。
    test_loss, correct = 0, 0
    with torch.no_grad():  # 一个上下文管理器，关闭梯度计算。
        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)  # 把预测值Ture、False 转换为01
    test_loss /= num_batches  # 评判模型的好坏
    correct /= size  # 平均的准确率
    print(f"Test result:\n Accuracy:{(100 * correct)}%,Avg loss:{test_loss}")

train函数负责训练模型。它遍历训练数据集的每个批次，计算模型的预测、损失，并执行反向传播和参数更新。
test函数用于评估模型在测试集上的性能。它遍历测试数据集的每个批次，计算模型的预测和损失，但不进行反向传播或参数更新。
在训练和测试过程中，都使用了torch.no_grad()上下文管理器来关闭梯度计算，这可以节省内存和计算资源。

4.训练和测试结果

loss_fn = nn.CrossEntropyLoss()

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)  # 创建一个优化器，S6D为随机梯度下降算法

epochs = 10
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)

使用torch.optim.Adam优化器来优化模型的参数，这里的学习率设置为0.01。
定义了训练轮次（epochs），并在每个epoch中调用train函数来训练模型。
最后，使用test函数来评估模型在测试集上的性能，并打印出准确率和平均损失。

三、总结

本文为大家介绍了MNIST数据集的组成、文件结构与数据集特点，然后为大家提供了MNIST数据集训练的相关代码，通过对数据集进行处理，训练来得出准确率与损失率，为大家更好的展示。总之，MNIST数据集是深度学习和计算机视觉领域不可或缺的基础数据集之一，对于初学者来说是一个非常好的练手项目，同时也为相关领域的研究和实验提供了宝贵的数据资源。