SwanLab入门深度学习：PyTorch MNIST手写体识别

最新推荐文章于 2024-06-17 21:08:24 发布
最新推荐文章于 2024-06-17 21:08:24 发布
阅读量608 收藏 23
点赞数 16
文章标签： 深度学习 pytorch 人工智能 开源软件 机器学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SoulmateY/article/details/139027857
版权

MNIST手写体识别是深度学习、CV的“Hello World”，无数人从这个任务入门，进入深度学习的世界～

进阶请看：PyTorch猫狗分类

这篇文章我将带大家使用SwanLab（训练可视化）、PyTorch（深度学习框架）这两个开源工具，完成从数据集准备、代码编写、到模型训练的全过程。
[图片]

代码同时适用于纯CPU、英伟达GPU或Apple M1训练。

完整代码请直接跳转到2.9节。

实验过程：SwanLab - MNIST手写体识别
数据集：百度云 提取码: 89y2
两个开源库：SwanLab、pytorch

1. 准备部分

在此之前，你需要确保你已经安装了Python。

1.1 什么是MNIST手写体识别

MNIST手写体识别任务是一个经典的计算机视觉问题，属于图像分类任务，目标是输入一个手写数字图像，AI模型可以正确预测数字是多少。
MNIST数据集包含70,000个手写数字图像，每个图像大小为28x28像素。这些图像分为两部分：60,000个训练集和10,000个测试集。
[图片]

1.2 安装Python库

需要安装下面这4个库：

torch
torchvision
swanlab>=0.3.2

安装命令：

pip install torch torchvision swanlab

1.3 创建文件目录

需要包含两个文件：

  1. train.py，它的作用训练模型
  2. MNIST文件夹，存放数据集。

MNIST数据集的下载有两种方式：一种是通过2.1中的代码下载（推荐），如果下载存在网络问题的话，则可以用我提供的百度云链接下载：百度云，提取码: 89y2。

[图片]

2. 训练部分

如果想直接看完整代码和效果，可直接跳转到第2.9。

2.1 载入MNIST数据集

训练部分的代码全部写在train.py中。
载入MNIST数据集分为三步：

  1. 下载MNIST数据集
  2. 将数据集分为训练集和验证集
  3. 封装到PyTorch DataLoader中，以供训练使用

下面的代码演示了这一过程：

from torchvision.datasets import MNIST

# 下载MNIST训练集
dataset = MNIST(os.getcwd(), train=True, download=True, transform=ToTensor())

# 随机分为训练集和验证集, 训练集55000张，验证集5000张
train_dataset, val_dataset = utils.data.random_split(dataset, [55000, 5000])

# 写入Pytorch数据载入器中
train_loader = utils.data.DataLoader(train_dataset, batch_size=256, shuffle=True)
val_loader = utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False)

ps：如果下载速度不给力的话，可以用我提供的百度云链接下载：百度云 提取码: 89y2。

目录结构是 根目录/MNIST/raw/...(下图所示的文件)。
在这里插入图片描述

2.2 载入ResNet18模型

模型我们直接选用经典的ResNet18，模型的具体原理本文不细说，重点放在工程实现上。
我们使用torchvision来创建1个resnet50模型，并载入预训练权重：

import torchvision
from torchvision.models import ResNet18_Weights

model = torchvision.models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)

因为MNIST是个1维图像和10分类任务（即输入一张图片，分类它是0～9这10个数字中的哪一个），而torchvision提供的resnet18默认是适配3维图像与1000分类，所以我们需要把模型的第一个卷积层的输入维度替换为1，全连接层的输出维度替换为10：\

import torchvision
from torchvision.models import ResNet18_Weights
import torch

model = torchvision.models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)

# 将模型的输入维度改为1，全连接层替换为10
model.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
in_features = model.fc.in_features
model.fc = torch.nn.Linear(in_features, 10)

2.3 设置cuda/mps/cpu

如果你的电脑是英伟达显卡，那么cuda可以极大加速你的训练；
如果你的电脑是Macbook Apple Sillicon（M系列芯片），那么mps同样可以极大加速你的训练；
如果都不是，那就选用cpu：

#检测是否支持mps
try:
    use_mps = torch.backends.mps.is_available()
except AttributeError:
    use_mps = False

#检测是否支持cuda
if torch.cuda.is_available():
    device = "cuda"
elif use_mps:
    device = "mps"
else:
    device = "cpu"

将模型加载到对应的device中：

model.to(torch.device(device))

2.4 初始化SwanLab

在训练中我们使用swanlab库作为实验管理与指标可视化工具。
SwanLab是一个类似Wandb（Weights and Biases）的在线开源训练可视化工具，能够在远程、在网页上看指标。除了能记录指标，还能自动记录训练的logging、硬件环境、Python环境、训练时间等信息。
如何入门SwanLab可以看这个文档：🚀快速开始 - SwanLab，也可以跟着本文往下走。

初始化并设置超参数
swanlab库使用swanlab.init记录超参数、实验名、实验介绍：

import swanlab
# 初始化swanlab
run = swanlab.init(
    project="MNIST-example",
    experiment_name="ResNet18",
    config={
        "model": "ResNet18",
        "optim": "Adam",
        "lr": 1e-4,
        "batch_size": 256,
        "num_epochs": 10,
        "device": device,
    }

这里我们设置的超参数分别是：模型使用resnet18，学习率lr为1e-4，批大小batch_size为256，轮数epoch为20，分类数为10，设备为2.3检测到的设备值。
这里swanlab干了三件事：

  1. 创建了1个名为MNIST的项目
  2. 创建了1个名为ResNet18的实验，项目和实验是类似文件夹和文件的关系，每次训练都会产生一个新的实验
  3. 将超参数上传到实验中，被记录下来

跟踪训练指标
在训练MNIST的过程中，我们最关心的指标就是训练集的损失值loss和验证集的准确率acc，我们用SwanLab在记录这些指标，生成可视化的折线图。
下面是一个简单的记录loss的常见用法，具体的使用案例见2.6和2.7。

for data in train_dataloader:
    ...
    swanlab.log({"loss": loss})

2.5 设置优化器和损失函数

设置损失函数为交叉熵损失，优化器为Adam。

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=run.config.lr)

交叉熵损失是常用于图像分类任务的损失函数，Adam是一种经典的优化器。

2.6 定义训练函数train

我们定义1个训练函数train：

def train(model, device, train_dataloader, optimizer, criterion, epoch, num_epochs):
    model.train()
    # 1. 循环调用train_dataloader，每次取出1个batch_size的图像和标签
    for iter, (inputs, labels) in enumerate(train_dataloader):
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        # 2. 传入到resnet18模型中得到预测结果
        outputs = model(inputs)
        # 3. 将结果和标签传入损失函数中计算交叉熵损失
        loss = criterion(outputs, labels)
        # 4. 根据损失计算反向传播
        loss.backward()
        # 5. 优化器执行模型参数更新
        optimizer.step()
        print('Epoch [{}/{}], Iteration [{}/{}], Loss: {:.4f}'.format(epoch, num_epochs, iter + 1, len(train_dataloader),
                                                                      loss.item()))
        # 6. 每20次迭代，用SwanLab记录一下loss的变化
        if iter % 20 == 0:
            swanlab.log({"train/loss": loss.item()})

训练的逻辑很简单：我们循环调用train_dataloader，每次取出1个batch_size的图像和标签，传入到resnet18模型中得到预测结果，将结果和标签传入损失函数中计算交叉熵损失，最后根据损失计算反向传播，Adam优化器执行模型参数更新，循环往复。
在训练中我们最关心的指标是损失值loss，所以我们用swanlab.log跟踪它的变化。

2.7 定义测试函数test

我们定义1个测试函数test：

def test(model, device, val_dataloader, epoch):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        # 1. 循环调用val_dataloader，每次取出1个batch_size的图像和标签
        for inputs, labels in val_dataloader:
            inputs, labels = inputs.to(device), labels.to(device)
            # 2. 传入到resnet18模型中得到预测结果
            outputs = model(inputs)
            # 3. 获得预测的数字
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            # 4. 计算与标签一致的预测结果的数量
            correct += (predicted == labels).sum().item()
    
        # 5. 得到最终的测试准确率
        accuracy = correct / total
        # 6. 用SwanLab记录一下准确率的变化
        swanlab.log({"val/accuracy": accuracy}, step=epoch)

测试的逻辑同样很简单：我们循环调用test_dataloader，将验证集的图像传入到当前训练的resnet18模型中得到预测结果，与标签进行对比，计算整体的准确率。
在测试中我们最关心的指标是准确率accuracy，所以我们用swanlab.log跟踪它的变化。

2.8 保存模型权重文件

我们使用train.save进行模型的权重保存，保存到checkpoint文件夹下。

# 如果不存在checkpoint文件夹，则自动创建一个
if not os.path.exists("checkpoint"):
    os.makedirs("checkpoint")
torch.save(model.state_dict(), 'checkpoint/latest_checkpoint.pth')

至此，我们完成已完成了绝大多数的代码，现在是时候将它们组合起来，开始训练！

2.9 完整训练代码

我们一共训练10轮，每2轮进行测试，并在最后保存权重文件：

import os
import torch
from torch import nn, optim, utils
import torch.nn.functional as F
import torchvision
from torchvision.datasets import MNIST
from torchvision.transforms import ToTensor
from torchvision.models import ResNet18_Weights
import swanlab

def train(model, device, train_dataloader, optimizer, criterion, epoch, num_epochs):
    model.train()
    # 1. 循环调用train_dataloader，每次取出1个batch_size的图像和标签
    for iter, (inputs, labels) in enumerate(train_dataloader):
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        # 2. 传入到resnet18模型中得到预测结果
        outputs = model(inputs)
        # 3. 将结果和标签传入损失函数中计算交叉熵损失
        loss = criterion(outputs, labels)
        # 4. 根据损失计算反向传播
        loss.backward()
        # 5. 优化器执行模型参数更新
        optimizer.step()
        print('Epoch [{}/{}], Iteration [{}/{}], Loss: {:.4f}'.format(epoch, num_epochs, iter + 1, len(train_dataloader),
                                                                      loss.item()))
        # 6. 每20次迭代，用SwanLab记录一下loss的变化
        if iter % 20 == 0:
            swanlab.log({"train/loss": loss.item()})

def test(model, device, val_dataloader, epoch):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        # 1. 循环调用val_dataloader，每次取出1个batch_size的图像和标签
        for inputs, labels in val_dataloader:
            inputs, labels = inputs.to(device), labels.to(device)
            # 2. 传入到resnet18模型中得到预测结果
            outputs = model(inputs)
            # 3. 获得预测的数字
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            # 4. 计算与标签一致的预测结果的数量
            correct += (predicted == labels).sum().item()
    
        # 5. 得到最终的测试准确率
        accuracy = correct / total
        # 6. 用SwanLab记录一下准确率的变化
        swanlab.log({"val/accuracy": accuracy}, step=epoch)
    

if __name__ == "__main__":

    #检测是否支持mps
    try:
        use_mps = torch.backends.mps.is_available()
    except AttributeError:
        use_mps = False

    #检测是否支持cuda
    if torch.cuda.is_available():
        device = "cuda"
    elif use_mps:
        device = "mps"
    else:
        device = "cpu"

    # 初始化swanlab
    run = swanlab.init(
        project="MNIST-example",
        experiment_name="ResNet18",
        config={
            "model": "ResNet18",
            "optim": "Adam",
            "lr": 1e-4,
            "batch_size": 256,
            "num_epochs": 10,
            "device": device,
        },
    )

    # 设置MNIST训练集和验证集
    dataset = MNIST(os.getcwd(), train=True, download=True, transform=ToTensor())
    train_dataset, val_dataset = utils.data.random_split(dataset, [55000, 5000])

    train_dataloader = utils.data.DataLoader(train_dataset, batch_size=run.config.batch_size, shuffle=True)
    val_dataloader = utils.data.DataLoader(val_dataset, batch_size=8, shuffle=False)

    # 初始化模型
    model =torchvision.models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)
    # 让模型适配MNIST数据集
    model.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    in_features = model.fc.in_features
    model.fc = torch.nn.Linear(in_features, 10)
    model.to(torch.device(device))

    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=run.config.lr)

    # 开始训练和测试循环
    for epoch in range(1, run.config.num_epochs+1):
        swanlab.log({"train/epoch": epoch}, step=epoch)
        train(model, device, train_dataloader, optimizer, criterion, epoch, run.config.num_epochs)
        if epoch % 2 == 0: 
            test(model, device, val_dataloader, epoch)

    # 保存模型
    # 如果不存在checkpoint文件夹，则自动创建一个
    if not os.path.exists("checkpoint"):
        os.makedirs("checkpoint")
    torch.save(model.state_dict(), 'checkpoint/latest_checkpoint.pth')

2.10 开始训练！

实验过程可看这个SwanLab网页：SwanLab - MNIST
在开始运行时，如果你是第一次使用SwanLab，会提示你要输入SwanLab API Key。
这里的操作也非常简单，去SwanLab官网登录一下账号，在【设置】页面复制API Key，粘贴过来就可以：
[图片]
[图片]

然后，我们运行train.py：
在这里插入图片描述

这时候你会在看到在开头会给到你两个链接，我们点击第一个，里面包含了这个项目的信息和一个对比实验表格：
在这里插入图片描述

我们点开1个进行中的实验，会看到loss和acc整体的变化曲线：
在这里插入图片描述

切换到实验卡片，这里记录了实验的各种信息，包括超参数、最终的实验指标、实验状态、训练时长、Git仓库链接、主机名、操作系统、Python版本、硬件配置等等。
在这里插入图片描述

可以看到我们最终训练的准确率是98.66%，提高到99%以上应该不困难！可以把这个实验作为你的baseline，去尝试不同的trick来提高准确率～

在这里插入图片描述

至此我们完成了模型的训练和测试，得到了1个表现非常棒的猫狗分类模型，权重保存在了checkpoint目录下。
至此，我们完成了用SwanLab、PyTorch这两个开源工具训练1个猫狗分类模型的全部过程，更多想了解的可以参考相关链接或评论此文章。
如果有帮助，请点个赞和收藏吧～

林泽毅
关注
  • 16
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
pytorch实现MNIST手写体识别
09-17
在本教程中，我们将探讨如何使用PyTorch框架实现MNIST手写体识别。MNIST是一个广泛用于机器学习和深度学习研究的基准数据集，它包含60,000个训练样本和10,000个测试样本，每个样本都是28x28像素的手写数字图像。我们...
使用PyTorch实现MNIST手写体识别代码
09-18
在本教程中，我们将探讨如何使用PyTorch框架来实现MNIST手写体识别...MNIST手写体识别是一个经典的机器学习问题，通过解决这个问题，你可以掌握深度学习的基础，并为进一步探索更复杂的计算机视觉任务打下坚实的基础。
pytorch（一）：实现mnist手写数字识别
ali1174的专栏
04-21 5495
Pytorch的入门训练--CNN手写mnist识别
pytorch 入门 （三）案例一：mnist手写数字识别
qq_33489955的博客
10-20 1076
本文为内部限免文章。
pytorch应用于MNIST手写字体识别
weixin_40356612的博客
07-30 1260
手写字体MNIST数据集是一组常见的图像，其常用于测评和比较机器学习算法的性能，本文使用pytorch框架来实现对该数据集的识别，并对结果进行逐步的优化。
PyTorch实战1：实现mnist手写数字识别
weixin_64215932的博客
04-14 497
介绍如何构建一个简单的卷积神经网络（CNN），用于图像分类任务。具体来说，该网络由特征提取网络和分类网络两部分组成。特征提取网络主要包括卷积层、池化层和激活函数，用于提取图像的特征；而分类网络则包括一个或多个全连接层，用于根据提取到的特征对图像进行分类。nn.Conv2d表示卷积层，其输入参数包括输入通道数、输出通道数和池化核大小；nn.MaxPool2d表示池化层，用于下采样并提高抽象程度；nn.ReLU为激活函数，使得模型可以拟合非线性数据；
深度学习 Pytorch Mnist手写数字识别
qq_45466277的博客
06-28 632
mnist手写数字识别
PyTorch MNIST手写体识别：SwanLab可视化训练
SoulmateY的博客
06-01 706
MNIST手写体识别任务是一个经典的计算机视觉问题，属于图像分类任务，目标是输入一个手写数字图像，AI模型可以正确预测数字是多少。MNIST数据集包含70,000个手写数字图像，每个图像大小为28x28像素。这些图像分为两部分：60,000个训练集和10,000个测试集。# 1. 循环调用train_dataloader，每次取出1个batch_size的图像和标签# 2. 传入到resnet18模型中得到预测结果# 3. 将结果和标签传入损失函数中计算交叉熵损失# 4. 根据损失计算反向传播。
深度学习01-Pytorch实现mnist手写数字识别
qq_54101323的博客
04-05 472
1.动手跟着教案敲一遍代码，把代码跑通2.理解了代码各个部分的含义，补习了一些神经网络的基础知识。
Pytorch实战 | 第P1周：实现mnist手写数字识别
weixin_47272689的博客
11-18 433
Pytorch实战
pytorch——mnist手写数据识别
热门推荐
m0_51311105的博客
12-03 1万+
1、pytorch自带的数据集 pytorch中自带数据集由两个上层的API提供，分别是torchvision和torchtext。其中，torchvision提供了对照片数据处理相关的API和数据，数据所在位置：torchvision.datasets，比如torchvision.datasets.MNIST（手写数字照片数据）；torchtext提供了对文本数据处理相关的API和数据，数据所在位置：torchtext.datasets，比如torchtext.datasets.IMDB...
重磅分享：使用PyTorch实现MNIST手写体识别代码
01-20
今天小编就为大家分享一篇使用PyTorch实现MNIST手写体识别代码，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 文章目录实验环境MNIST数据集介绍导入包定义超参数数据集定义网络实例化网络定义...
rnn定义(rnn批次,核心思想理解)循环神经网络(递归)
爱学习_萌萌哒
06-17 438
当batch_first设置为False时，输入张量的形状应该是(sequence_length, batch_size, input_size)。当你创建一个nn.RNN的实例时，你实际上并没有执行前向传播，只是定义了前向传播的计算图。当你使用rnn(input, h0)这样的形式调用nn.RNN实例的forward方法时，你才真正执行了前向传播。因此，当你看到代码中出现rnn = nn.RNN(5, 6, 1)时，这行代码只是创建了一个nn.RNN的实例，并没有执行前向传播。所以true后要调整参数。
MATLAB神经网络---lstmLayer（LSTM 长短期记忆神经网络）
qq_45452617的博客
06-13 1370
描述LSTM就要先描述一下循环神经网络循环神经网络循环神经网络通过使用带自反馈的神经元，使得网络的输出不仅和当前的输入有关，还和上一时刻的输出相关，于是在处理任意长度的时序数据时，就具有短期记忆能力。如下是一个按时间展开的循环神经网络图：梯度消失和梯度爆炸是困扰RNN模型训练的关键原因之一，产生梯度消失和梯度爆炸是由于RNN的权值矩阵循环相乘导致的，相同函数的多次组合会导致极端的非线性行为。梯度消失和梯度爆炸主要存在RNN中，因为RNN中每个时间片使用相同的权值矩阵。
基于注意力机制卷积神经网络结合门控单元CNN-GRU-SAM-Attention实现柴油机故障诊断附matlab代码
算法如诗的博客
06-13 577
基于注意力机制卷积神经网络结合门控单元CNN-GRU-SAM-Attention实现柴油机故障诊断附matlab代码
pytorch - RNN参数详解
最新发布
weixin_47552266的博客
06-17 707
在使用 PyTorch 训练循环神经网络（RNN）时，需要了解相关类和方法的每个参数及其含义。
深度学习500问——Chapter11：迁移学习（4）
不要给自己设限，尝试更多可能（思所向 皆可往）
06-14 712
深度网络的finetune也许是最简单的深度网络迁移方法。Finetune，也叫微调、fine-tuning，是深度学习中的一个重要概念。简而言之，finetune就是利用别人已经训练好的网络，针对自己的任务再进行调整。从这个意思上看，我们不难理解finetune是迁移学习的一部分。为什么需要已经训练好的网络？在实际的应用中，我们通常不会针对一个新任务，就去从头开始训练一个神经网络。这样的操作显然是非常耗时的。尤其是，我们的训练数据不可能像ImageNet那么大，可以训练出泛化能力足够强的深度神经网络。
pytorch手写体数字识别mnist
08-28
对于手写体数字识别MNIST问题，您可以使用PyTorch来实现。以下是一个简单的代码示例： 首先，导入所需的库： ``` import torch import torch.nn as nn import torchvision import torchvision.transforms as ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值