【超详细】深度学习的Hello World：使用pytroch训练一个自定义的手写体数字识别模型完整流程【附数据集与完整源码】

2024-09-01 17:52
文章标签 数据 源码 流程 学习 使用 训练 自定义 深度 模型 详细 识别 数字 hello world 完整 手写体 pytroch

本文主要是介绍【超详细】深度学习的Hello World：使用pytroch训练一个自定义的手写体数字识别模型完整流程【附数据集与完整源码】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《博主简介》

小伙伴们好，我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。
👍感谢小伙伴们点赞、关注！

《------往期经典推荐------》

一、AI应用软件开发实战专栏【链接】

项目名称项目名称
1.【人脸识别与管理系统开发】2.【车牌识别与自动收费管理系统开发】
3.【手势识别系统开发】4.【人脸面部活体检测系统开发】
5.【图片风格快速迁移软件开发】6.【人脸表表情识别系统】
7.【YOLOv8多目标识别与自动标注软件开发】8.【基于YOLOv8深度学习的行人跌倒检测系统】
9.【基于YOLOv8深度学习的PCB板缺陷检测系统】10.【基于YOLOv8深度学习的生活垃圾分类目标检测系统】
11.【基于YOLOv8深度学习的安全帽目标检测系统】12.【基于YOLOv8深度学习的120种犬类检测与识别系统】
13.【基于YOLOv8深度学习的路面坑洞检测系统】14.【基于YOLOv8深度学习的火焰烟雾检测系统】
15.【基于YOLOv8深度学习的钢材表面缺陷检测系统】16.【基于YOLOv8深度学习的舰船目标分类检测系统】
17.【基于YOLOv8深度学习的西红柿成熟度检测系统】18.【基于YOLOv8深度学习的血细胞检测与计数系统】
19.【基于YOLOv8深度学习的吸烟/抽烟行为检测系统】20.【基于YOLOv8深度学习的水稻害虫检测与识别系统】
21.【基于YOLOv8深度学习的高精度车辆行人检测与计数系统】22.【基于YOLOv8深度学习的路面标志线检测与识别系统】
23.【基于YOLOv8深度学习的智能小麦害虫检测识别系统】24.【基于YOLOv8深度学习的智能玉米害虫检测识别系统】
25.【基于YOLOv8深度学习的200种鸟类智能检测与识别系统】26.【基于YOLOv8深度学习的45种交通标志智能检测与识别系统】
27.【基于YOLOv8深度学习的人脸面部表情识别系统】28.【基于YOLOv8深度学习的苹果叶片病害智能诊断系统】
29.【基于YOLOv8深度学习的智能肺炎诊断系统】30.【基于YOLOv8深度学习的葡萄簇目标检测系统】
31.【基于YOLOv8深度学习的100种中草药智能识别系统】32.【基于YOLOv8深度学习的102种花卉智能识别系统】
33.【基于YOLOv8深度学习的100种蝴蝶智能识别系统】34.【基于YOLOv8深度学习的水稻叶片病害智能诊断系统】
35.【基于YOLOv8与ByteTrack的车辆行人多目标检测与追踪系统】36.【基于YOLOv8深度学习的智能草莓病害检测与分割系统】
37.【基于YOLOv8深度学习的复杂场景下船舶目标检测系统】38.【基于YOLOv8深度学习的农作物幼苗与杂草检测系统】
39.【基于YOLOv8深度学习的智能道路裂缝检测与分析系统】40.【基于YOLOv8深度学习的葡萄病害智能诊断与防治系统】
41.【基于YOLOv8深度学习的遥感地理空间物体检测系统】42.【基于YOLOv8深度学习的无人机视角地面物体检测系统】
43.【基于YOLOv8深度学习的木薯病害智能诊断与防治系统】44.【基于YOLOv8深度学习的野外火焰烟雾检测系统】
45.【基于YOLOv8深度学习的脑肿瘤智能检测系统】46.【基于YOLOv8深度学习的玉米叶片病害智能诊断与防治系统】
47.【基于YOLOv8深度学习的橙子病害智能诊断与防治系统】48.【车辆检测追踪与流量计数系统】
49.【行人检测追踪与双向流量计数系统】50.【基于YOLOv8深度学习的反光衣检测与预警系统】
51.【危险区域人员闯入检测与报警系统】52.【高密度人脸智能检测与统计系统】
53.【CT扫描图像肾结石智能检测系统】54.【水果智能检测系统】
55.【水果质量好坏智能检测系统】56.【蔬菜目标检测与识别系统】
57.【非机动车驾驶员头盔检测系统】58.【太阳能电池板检测与分析系统】
59.【工业螺栓螺母检测】60.【金属焊缝缺陷检测系统】
61.【链条缺陷检测与识别系统】62.【交通信号灯检测识别】

二、机器学习实战专栏【链接】，已更新31期，欢迎关注，持续更新中~~
三、深度学习【Pytorch】专栏【链接】
四、【Stable Diffusion绘画系列】专栏【链接】
五、YOLOv8改进专栏【链接】，持续更新中~~
六、YOLO性能对比专栏【链接】，持续更新中~

《------正文------》

目录

  • 引言
    • 安装PyTorch
    • MNIST 数据集介绍
    • 自定义模型与训练步骤
      • 步骤 1：导入必要的库
      • 步骤2：加载MNIST数据集
      • 步骤 3：构建自己的分类模型
        • 使用GPU 与 CPU
        • 查看模型结构
      • 步骤 4：定义损失函数和优化器
      • 步骤 5：训练模型
      • 步骤 6：绘制训练和验证曲线以检查过度拟合或欠拟合
      • 步骤 7：模型评估
    • 总结

引言

深度学习是一种强大而灵活的方法，框架，它提供了一种在 Python 中构建、训练和评估神经网络的无缝方法。在本文中，我们将详细介绍使用 PyTorch 自定义一个深度学习模型框架、并训练深度学习模型的步骤以及一个示例。

神经网络是一种机器学习模型，其灵感来自人脑的结构和功能。它由多层相互连接的节点（称为神经元）组成，用于处理和传输信息。神经网络特别适合图像和语音识别、自然语言处理以及基于大量数据进行预测等任务。

下面是神经网络的基本结构：包含输入层、隐藏层与输出层。

神经网络 -Geeksforgeeks

安装PyTorch

要安装 PyTorch，您需要在计算机上安装 Python 和 pip（Python 的包管理器）。

您可以通过在命令提示符或终端中运行以下命令来安装 PyTorch 和必要的库：

pip install torch
pip install torchvision
pip install torchsummary

MNIST 数据集介绍

MNIST 数据集是手写数字的数据集，由 60,000 个训练示例和 10,000 个测试示例组成。每个示例都是一个 28×28 的手写数字灰度图像，值范围从 0（白色）到 255（黑色）。每个示例的标签是图像所代表的数字，值范围从 0 到 9。

img

它是常用于训练和评估图像分类模型的数据集，尤其是在计算机视觉领域。它被认为是深度学习的“Hello World”数据集，因为它很小且相对简单，但仍需要大量的预处理和模型架构设计才能实现良好的性能。

自定义模型与训练步骤

步骤 1：导入必要的库

import torch 
import torchvision 
import torch.nn as nn 
import torch.optim as optim 
from torchsummary import summary 
import torch.nn.functional as F

步骤2：加载MNIST数据集

首先，我们需要导入必要的库并加载数据集。我们将使用 PyTorch 中的内置 MNIST 数据集，可以使用 torchvision 库轻松加载该数据集。

注:pytorch内置了Mnist数据集，可以通过以下代码直接下载，也可以直接使用我提供的数据集。

# Load the MNIST dataset 
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=torchvision.transforms.ToTensor(), download=True) 
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=torchvision.transforms.ToTensor(), download=True)

在上面的代码中，torchvision.datasets.MNIST 函数用于加载数据集，它接受几个参数，例如：

  • root：数据集将保存的目录
  • train：一个布尔标志，指示是否加载训练集还是测试集。
  • transform：应用于数据的变换，变为张量
  • download：一个布尔标志，指示如果在根目录中找不到数据集是否下载。

步骤 3：构建自己的分类模型

接下来，我们自己定义一个简单的深度学习模型结构。在这个例子中，我们将使用一个简单的前馈神经网络

  • Python3
class Classifier(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1) self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) self.pool = nn.MaxPool2d(2, 2) self.dropout1 = nn.Dropout2d(0.25) self.dropout2 = nn.Dropout2d(0.5) self.fc1 = nn.Linear(64 * 7 * 7, 128) self.fc2 = nn.Linear(128, 10) def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = self.dropout1(x) x = self.pool(F.relu(self.conv2(x))) x = self.dropout2(x) x = x.view(-1, 64 * 7 * 7) x = F.relu(self.fc1(x)) x = self.fc2(x) return x

Classifier 类继承自 PyTorch 的 nn.Module 类，并定义 CNN 的架构。创建类的实例时会调用 init 方法，并设置网络的各层。

  1. self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)：此行创建一个 2D 卷积层，该层具有 1 个输入通道、32 个输出通道、内核大小为 3、填充为 1。卷积层将一组过滤器（也称为内核）应用于输入图像以从中提取特征。
  2. self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)：此行创建另一个 2D 卷积层，具有 32 个输入通道、64 个输出通道、内核大小为 3、填充为 1。该层连接到第一个卷积层的输出，允许网络从前一层的输出中学习更复杂的特征。
  3. self.pool = nn.MaxPool2d(2, 2)：此行创建一个最大池化层，其内核大小为 2，步长为 2。最大池化是一种下采样操作，它从每个输入通道的小邻域中选择最大值。它有助于降低数据的维度，降低计算成本并有助于防止过度拟合。
  4. self.dropout1 = nn.Dropout2d(0.25)：此行创建一个概率为 0.25 的 dropout 层。Dropout 是一种正则化技术，可在训练期间随机丢弃一些神经元，有助于减少过度拟合。
  5. self.dropout2 = nn.Dropout2d(0.5)：此行创建另一个概率为 0.5 的 dropout 层
  6. self.fc1 = nn.Linear(64 * 7 * 7, 128)：此行创建一个完全连接（线性）层，具有 64 * 7 * 7 个输入特征和 128 个输出特征。完全连接层用于根据前面各层学习到的特征做出最终预测。
  7. self.fc2 = nn.Linear(128, 10)：此行创建另一个具有 128 个输入特征和 10 个输出特征的完全连接层。此层将产生具有 10 个类的网络的最终输出。forward 方法定义了

接下来是网络的前向传递方法。它接受输入 x，并应用 init 方法中各层定义的一系列操作。

  1. x = self.pool(F.relu(self.conv1(x)))：此行将 ReLU 激活函数 (F.relu) 应用于第一个卷积层 (self.conv1) 的输出，然后将最大池化 (self.pool) 应用于结果。
  2. x = self.dropout1(x)：此行将 dropout 应用于第一个池化层的输出。
  3. x = self.pool(F.relu(self.conv2(x)))：此行将 ReLU 激活函数应用于第二个卷积层（self.conv2）的输出，然后对结果应用最大池化。
  4. x = self.dropout2(x)：此行将 dropout 应用于第二个池化层的输出。
  5. x = x.view(-1, 64 * 7 * 7)：此行将张量 x 重塑为一维张量，其中 -1 表示张量中元素的数量是从其他维度推断出来的。
  6. x = F.relu(self.fc1(x))：此行将 ReLU 激活函数应用于第一个全连接层（self.fc1）的输出。
  7. x = self.fc2(x)：此行将最终的全连接层（self.fc2）应用于前一层的输出并返回结果，该结果将成为网络的最终输出。
  8. 这种 CNN 架构很简单，可以作为更复杂任务的起点。但是，可以通过添加更多层、使用不同类型的层或调整超参数来改进它，以获得更好的性能。
使用GPU 与 CPU

判断使用GPU还是CPU

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
device

输出：

device(type='cuda')

这段代码用于选择我们应该在哪个设备上运行我们的模型。如果我们在 google colab 中运行我们的代码，我们可以检查“cuda”设备是否可用，如果可用，我们可以使用它，否则我们可以使用普通 CPU。

CUDA 是针对运行 ML 模型而优化的 GPU

查看模型结构

定义模型后，我们可以使用该类创建模型对象并查看模型的基本结构。 summary 选项可用于打印模型的摘要，如下所示。

  • Python3
# Instantiate the model 
model = Classifier() # Move the model to the GPU if available 
model.to(device) 
summary(model, (1, 28, 28))

输出：

----------------------------------------------------------------Layer (type)               Output Shape         Param #
================================================================Conv2d-1           [-1, 32, 28, 28]             320MaxPool2d-2           [-1, 32, 14, 14]               0Dropout2d-3           [-1, 32, 14, 14]               0Conv2d-4           [-1, 64, 14, 14]          18,496MaxPool2d-5             [-1, 64, 7, 7]               0Dropout2d-6             [-1, 64, 7, 7]               0Linear-7                  [-1, 128]         401,536Linear-8                   [-1, 10]           1,290
================================================================
Total params: 421,642
Trainable params: 421,642
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.43
Params size (MB): 1.61
Estimated Total Size (MB): 2.04
----------------------------------------------------------------

步骤 4：定义损失函数和优化器

现在，我们需要定义一个[损失函数]和一个[优化器]。在这个例子中，我们将使用交叉熵损失和 ADAM 优化器。

# Define a loss function and optimizer 
criterion = nn.CrossEntropyLoss() 
optimizer = optim.Adam(model.parameters(), lr=0.001)

代码定义了神经网络的损失函数和优化器。

nn.CrossEntropyLoss() 是一个 PyTorch 函数，用于创建交叉熵损失函数的实例。交叉熵损失通常用于分类问题，因为它可以测量预测类别概率与真实类别之间的差异。它是通过对真实类别的预测类别概率取负对数来计算的。

optimizer = optim.Adam(model.parameters(), lr=0.001)：此行创建 optim.Adam 类的实例，该类是常用于深度学习的优化算法。Adam 优化器是随机梯度下降的扩展，它使用参数的移动平均值来提供梯度二阶原始矩的运行估计；术语 Adam 源自自适应矩估计。它要求将模型的参数作为第一个参数传递，并将学习率设置为 0.001。学习率是一个超参数，它控制优化器更新模型参数的步长。

优化器和损失函数分别用于训练过程中更新模型的参数和评估模型的性能。

步骤 5：训练模型

现在，我们可以使用训练数据集训练我们的模型。我们将使用 100 的批处理大小，并将训练模型 10 个epoch。下面的代码使用循环在数据集上训练神经网络，该循环迭代训练时期的数量和训练数据集中的数据。

  1. batch_size = 100 和 num_epochs = 10 定义训练过程的批大小和轮数。批大小是用于神经网络一次前向和后向传递的训练数据集样本数。时期数是整个训练数据集通过网络的次数。
  2. torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True) 为训练数据集创建一个 PyTorch DataLoader。DataLoader 将训练数据集作为输入并返回数据集上的迭代器。迭代器将在每次迭代中返回一组样本（图像和标签），其中样本数量由批次大小决定。通过设置 shuffle=True，DataLoader 将在每个时期之前随机打乱数据集。
  3. 外层循环，for epoch in range(num_epochs)，迭代训练周期数。
  4. 内部循环 for i, (images, labels) in enumerate(train_loader) 遍历 DataLoader，返回一批图像和标签。使用输出 = 模型 (images) 将图像传递给模型，以获取模型的预测。
  5. 通过将模型的预测和真实标签传递给损失函数来计算损失，使用 loss = criterion(outputs, labels)。
  6. 优化器用于在最小化损失的方向上更新模型的参数。这通过以下 3 个步骤完成：
    • optimizer.zero_grad() 清除所有可优化参数的梯度。
    • loss.backward() 计算关于模型参数的损失的梯度。
    • optimizer.step() 根据计算的梯度更新模型的参数。
  7. 每个时期结束后，代码会打印当前时期和时期结束时的损失。

在训练过程结束时，模型的参数将被更新，以最大限度地减少训练数据集的损失。

值得注意的是，在训练期间使用验证集来评估模型性能也很有用，这样我们就可以检测过度拟合并相应地调整模型。我们可以通过将训练集分为两部分来实现这一点：训练和验证。然后，使用训练集进行训练，并使用验证集在训练期间评估模型性能。

batch_size=100
num_epochs=10
# Split the training set into training and validation sets 
val_percent = 0.2 # percentage of the data used for validation 
val_size = int(val_percent * len(train_dataset)) 
train_size = len(train_dataset) - val_size 
train_dataset, val_dataset = torch.utils.data.random_split(train_dataset, [train_size, val_size]) # Create DataLoaders for the training and validation sets 
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, pin_memory=True) 
val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False, pin_memory=True) 
losses = [] 
accuracies = [] 
val_losses = [] 
val_accuracies = [] 
# Train the model 
for epoch in range(num_epochs): for i, (images, labels) in enumerate(train_loader): # Forward pass images=images.to(device) labels=labels.to(device) outputs = model(images) loss = criterion(outputs, labels) # Backward pass and optimization optimizer.zero_grad() loss.backward() optimizer.step() _, predicted = torch.max(outputs.data, 1) acc = (predicted == labels).sum().item() / labels.size(0) accuracies.append(acc) losses.append(loss.item()) # Evaluate the model on the validation set val_loss = 0.0val_acc = 0.0with torch.no_grad(): for images, labels in val_loader: labels=labels.to(device) images=images.to(device) outputs = model(images) loss = criterion(outputs, labels) val_loss += loss.item() _, predicted = torch.max(outputs.data, 1) total = labels.size(0) correct = (predicted == labels).sum().item() val_acc += correct / total val_accuracies.append(acc) val_losses.append(loss.item()) print('Epoch [{}/{}],Loss:{:.4f},Validation Loss:{:.4f},Accuracy:{:.2f},Validation Accuracy:{:.2f}'.format( epoch+1, num_epochs, loss.item(), val_loss, acc ,val_acc))

输出：

Epoch [1/10], Loss:0.2086, Validation Loss:14.6681, Accuracy:0.99, Validation Accuracy:0.94
Epoch [2/10], Loss:0.1703, Validation Loss:11.0446, Accuracy:0.95, Validation Accuracy:0.94
Epoch [3/10], Loss:0.1617, Validation Loss:8.9060, Accuracy:0.98, Validation Accuracy:0.97
Epoch [4/10], Loss:0.1670, Validation Loss:7.7104, Accuracy:0.98, Validation Accuracy:0.97
Epoch [5/10], Loss:0.0723, Validation Loss:7.1193, Accuracy:1.00, Validation Accuracy:0.96
Epoch [6/10], Loss:0.0970, Validation Loss:7.5116, Accuracy:1.00, Validation Accuracy:0.98
Epoch [7/10], Loss:0.1623, Validation Loss:6.8909, Accuracy:0.99, Validation Accuracy:0.96
Epoch [8/10], Loss:0.1251, Validation Loss:7.2684, Accuracy:1.00, Validation Accuracy:0.97
Epoch [9/10], Loss:0.0874, Validation Loss:6.9928, Accuracy:1.00, Validation Accuracy:0.98
Epoch [10/10], Loss:0.0405, Validation Loss:6.0112, Accuracy:0.99, Validation Accuracy:0.99

在此示例中，我们介绍了使用 PyTorch 在 MNIST 数据集上训练深度学习模型的基本步骤。可以使用更复杂的架构、数据增强和其他技术进一步改进此模型。PyTorch 是一个功能强大且灵活的库，可让您构建和训练各种模型，而此示例只是您可以使用它完成的开始。

步骤 6：绘制训练和验证曲线以检查过度拟合或欠拟合

模型训练完成后，我们可以绘制训练和验证损失和准确率曲线。这可以让我们了解模型在未知数据上的表现，以及模型是否过度拟合或欠拟合。

import matplotlib.pyplot as plt # Plot the training and validation loss over time 
plt.plot(range(num_epochs), losses, color='red', label='Training Loss', marker='o') 
plt.plot(range(num_epochs), val_losses, color='blue', linestyle='--', label='Validation Loss', marker='x') 
plt.xlabel('Epoch') 
plt.ylabel('Loss') 
plt.title('Training and Validation Loss') 
plt.legend() 
plt.show() # Plot the training and validation accuracy over time 
plt.plot(range(num_epochs), accuracies, label='Training Accuracy', color='red', marker='o') 
plt.plot(range(num_epochs), val_accuracies, label='Validation Accuracy', color='blue', linestyle=':', marker='x') 
plt.xlabel('Epoch') 
plt.ylabel('Accuracy') 
plt.title('Training and Validation Accuracy') 
plt.legend() 
plt.show()

输出：
训练和验证损失

训练和验证损失 -Geeksforgeeks

训练和验证准确率

训练和验证准确率 -Geeksforgeeks

注意，损失通常会随着每个时期而减少，而准确率则会提高，这是预期的情况。

步骤 7：模型评估

另一个重要方面是评估指标的选择。在此示例中，我们使用准确率作为评估指标，这对于许多问题来说都是一个很好的起点。但是，重要的是要注意，在某些情况下，准确率可能会产生误导，尤其是在类别不平衡的情况下。在这些情况下，应使用其他指标，例如准确率、召回率、F1 分数或 AUC-ROC。

训练模型后，您可以通过进行预测并将其与真实标签进行比较来评估其在测试数据集上的性能。评估分类模型性能的一种方法是使用[分类报告]，该报告是模型在所有类别中性能的摘要。

首先是在测试数据集上评估模型，并通过使用 torch.max() 函数将预测标签与真实标签进行比较来计算其整体准确性。

然后，它使用 scikit-learn 库中的 分类_report 函数生成分类报告。分类报告通过计算精度、召回率、f1 分数和支持度等多项指标，为您提供模型在所有类别中的表现摘要。

精确度 – 精确度是真阳性数量除以真阳性数量加上假阳性数量。它衡量了阳性预测中有多少是正确的。

召回率 – 召回率是真阳性数量除以真阳性数量加上假阴性数量。它衡量了实际阳性病例中有多少被正确预测。

F1 分数 – F1 分数是精确度和召回率的调和平均值。它是一个代表精确度和召回率之间平衡的数字。

支持度——支持度是测试集中属于特定类别的实例数。

值得注意的是，分类报告是基于对整个测试集的预测计算的，而不仅仅是测试集的样本。

以下是如何评估模型并生成分类报告的示例：

# Create a DataLoader for the test dataset 
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False) # Evaluate the model on the test dataset 
model.eval() with torch.no_grad(): correct = 0total = 0y_true = [] y_pred = [] for images, labels in test_loader: images = images.to(device) labels = labels.to(device) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() predicted=predicted.to('cpu') labels=labels.to('cpu') y_true.extend(labels) y_pred.extend(predicted) print('Test Accuracy: {}%'.format(100 * correct / total)) # Generate a classification report from sklearn.metrics import classification_report 
print(classification_report(y_true, y_pred))

输出：

Test Accuracy: 99.1%precision    recall  f1-score   support0       0.99      1.00      0.99       9801       1.00      1.00      1.00      11352       0.99      0.99      0.99      10323       0.99      0.99      0.99      10104       0.99      0.99      0.99       9825       0.99      0.99      0.99       8926       1.00      0.99      0.99       9587       0.98      0.99      0.99      10288       1.00      0.99      0.99       9749       0.99      0.99      0.99      1009accuracy                           0.99     10000macro avg       0.99      0.99      0.99     10000
weighted avg       0.99      0.99      0.99     10000

最后，重要的是要记住，深度学习模型需要大量数据和计算资源来训练。在大型数据集上训练模型可能需要很长时间，并且需要强大的 GPU。还有一些家云提供商提供可用于训练深度学习模型的 GPU 实例，如果您没有资源在本地训练模型，这可能是一个不错的选择。

总结

总而言之，使用 PyTorch 进行深度学习是一种强大的工具，可用于构建和训练各种模型。MNIST 数据集是学习基础知识的一个很好的起点，但重要的是要记住，在处理现实世界的数据集和问题时，还有许多其他方面需要考虑。有了正确的知识和资源，深度学习可以成为解决复杂问题和做出高精度预测的强大工具。

关于本文的数据集已经打包好了，需要的小伙伴可以自行获取学习。

关注下方名片GZH:【阿旭算法与机器学习】，并发送【手写体数字识别】即可获取

在这里插入图片描述

这篇关于【超详细】深度学习的Hello World：使用pytroch训练一个自定义的手写体数字识别模型完整流程【附数据集与完整源码】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1127643。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
Security OAuth2 单点登录流程

Security OAuth2 单点登录流程

单点登录（英语：Single sign-on，缩写为 SSO），又译为单一签入，一种对于许多相互关连，但是又是各自独立的软件系统，提供访问控制的属性。当拥有这项属性时，当用户登录时，就可以获取所有系统的访问权限，不用对每个单一系统都逐一登录。这项功能通常是以轻型目录访问协议（LDAP）来实现，在服务器上会将用户信息存储到LDAP数据库中。相同的，单一注销（single sign-off）就是指
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
大模型研发全揭秘：客服工单数据标注的完整攻略

大模型研发全揭秘：客服工单数据标注的完整攻略

在人工智能（AI）领域，数据标注是模型训练过程中至关重要的一步。无论你是新手还是有经验的从业者，掌握数据标注的技术细节和常见问题的解决方案都能为你的AI项目增添不少价值。在电信运营商的客服系统中，工单数据是客户问题和解决方案的重要记录。通过对这些工单数据进行有效标注，不仅能够帮助提升客服自动化系统的智能化水平，还能优化客户服务流程，提高客户满意度。本文将详细介绍如何在电信运营商客服工单的背景下进行
阅读更多...
基于MySQL Binlog的Elasticsearch数据同步实践

基于MySQL Binlog的Elasticsearch数据同步实践

一、为什么要做 随着马蜂窝的逐渐发展，我们的业务数据越来越多，单纯使用 MySQL 已经不能满足我们的数据查询需求，例如对于商品、订单等数据的多维度检索。 使用 Elasticsearch 存储业务数据可以很好的解决我们业务中的搜索需求。而数据进行异构存储后，随之而来的就是数据同步的问题。 二、现有方法及问题 对于数据同步，我们目前的解决方案是建立数据中间表。把需要检索的业务数据，统一放到一张M
阅读更多...
关于数据埋点，你需要了解这些基本知识

关于数据埋点，你需要了解这些基本知识

产品汪每天都在和数据打交道，你知道数据来自哪里吗？ 移动app端内的用户行为数据大多来自埋点，了解一些埋点知识，能和数据分析师、技术侃大山，参与到前期的数据采集，更重要是让最终的埋点数据能为我所用，否则可怜巴巴等上几个月是常有的事。   埋点类型 根据埋点方式，可以区分为： 手动埋点半自动埋点全自动埋点 秉承“任何事物都有两面性”的道理：自动程度高的，能解决通用统计，便于统一化管理，但个性化定
阅读更多...
中文分词jieba库的使用与实景应用（一）

中文分词jieba库的使用与实景应用（一）

知识星球：https://articles.zsxq.com/id_fxvgc803qmr2.html 目录 一.定义： 精确模式（默认模式）： 全模式： 搜索引擎模式： paddle 模式（基于深度学习的分词模式）： 二 自定义词典 三.文本解析   调整词出现的频率 四. 关键词提取 A. 基于TF-IDF算法的关键词提取 B. 基于TextRank算法的关键词提取
阅读更多...
使用SecondaryNameNode恢复NameNode的数据

使用SecondaryNameNode恢复NameNode的数据

1）需求： NameNode进程挂了并且存储的数据也丢失了，如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2）故障模拟 （1）kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 （2）删除NameNode存储的数据（/opt/module/hadoop-3.1.4/data/tmp/dfs/na
阅读更多...
异构存储（冷热数据分离）

异构存储（冷热数据分离）

异构存储主要解决不同的数据，存储在不同类型的硬盘中，达到最佳性能的问题。 异构存储Shell操作 （1）查看当前有哪些存储策略可以用 [lytfly@hadoop102 hadoop-3.1.4]$ hdfs storagepolicies -listPolicies （2）为指定路径（数据存储目录）设置指定的存储策略 hdfs storagepolicies -setStoragePo
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2