Bohrium
robot
新建

空间站广场

论文
Notebooks
比赛
课程
Apps
我的主页
我的Notebooks
我的论文库
我的足迹

我的工作空间

任务
节点
文件
数据集
镜像
项目
数据库
公开
快速开始 PyTorch|使用 Python 建立深度学习模型
PyTorch
Tutorial
Machine Learning
PyTorchTutorialMachine Learning
MileAway
发布于 2023-06-09
推荐镜像 :Basic Image:bohrium-notebook:2023-04-07
推荐机型 :c4_m16_cpu
赞 76
86
78
快速开始 PyTorch|使用 Python 建立深度学习模型
目标
目录
背景
实践
1 认识 PyTorch
1.1 什么是 PyTorch [1]
1.2 安装 Pytorch
1.3 验证 PyTorch 安装并查看版本
2 PyTorch 深度学习模型的建立范式
2.1 准备数据
2.2 定义模型
2.3 训练模型
2.4 评估模型
2.5 做出预测
3 为预测任务建立 PyTorch 深度学习模型
3.1 建立二分类任务的多层感知机模型
3.2 建立多分类任务的多层感知机模型
3.3 建立回归任务的多层感知机模型
3.4 建立图像分类的卷积神经网络模型
总结
进一步阅读
参考

快速开始 PyTorch|使用 Python 建立深度学习模型

代码
文本

Open In Bohrium

代码
文本

🎯 本教程旨在快速掌握使用 PyTorch 建立深度学习模型的范式周期。

  • 一键运行,你可以快速在实践中检验你的想法。

  • 丰富完善的注释,对于入门者友好。

代码
文本

Bohrium Notebook 界面,你可以点击界面上方蓝色按钮 开始连接,选择 bohrium-notebook 镜像及任何一款节点配置,稍等片刻即可运行。

代码
文本

目标

掌握使用 PyTorch 建立深度学习模型的范式周期,并跟随完整案例学习如何应用于预测任务。

在学习本教程后,你将能够:

  • 初识 PyTorch,安装 PyTorch 并验证其运行。
  • 通过五个步骤了解建立、拟合和验证 PyTorch 模型的范式周期。
  • 掌握如何为回归、分类预测任务建立 PyTorch 深度学习模型。

阅读该教程【最多】约需 60 分钟,让我们开始吧!

代码
文本

背景

你不需要理解所有的事(至少目前是)。 你的目标是从头到尾完成本教程并获得结果。你不需要在第一次尝试时就了解所有内容。边学习边写下你的问题。使用丰富的 API 文档来了解你正在使用的所有功能。

你不需要精通数学原理。 数学是描述算法如何工作的基本方式,特别是线性代数、概率和微积分的工具。这些并不是你可以用来了解算法如何工作的唯一工具。你还可以通过使用代码并探索具有不同输入和输出的算法行为来增进了解。了解数学不会告诉你选择哪种算法或如何最好地配置它。你只能通过精心控制的实验来发现这一点。

你不需要知道算法是如何工作的。 了解限制以及如何配置深度学习算法非常重要。但是学习算法可以稍后进行。你需要在很长一段时间内慢慢建立这种算法知识。今天,首先要熟悉这个平台。

你不需要精通 Python。 如果你不熟悉 Python 语言,不要担心,Python 的语法是直观的。就像其他语言一样,你只需要专注于函数调用(例如 function())和赋值(例如 a = “b”)(这已包括了大部分使用场景)。只需开始,稍后再深入了解详细信息。

你不需要成为深度学习专家。 你可以稍后了解各种算法的优点和局限性,并且你可以阅读大量教程来复习深度学习项目的步骤。

你需要提前了解以下基础知识:

代码
文本

实践

代码
文本

1 认识 PyTorch

在这一部分,你会了解什么是 PyTorch,在 Bohrium 中使用 PyTorch,验证并查看版本。

代码
文本

1.1 什么是 PyTorch [1]

PyTorch 是由 Facebook 开发和维护的用于深度学习的开源 Python 库。

该项目于 2016 年启动,并迅速成为开发人员和研究人员中流行的框架。

Torch (Torch7) 是一个用 C 编写的用于深度学习的开源项目,通常通过 Lua 接口使用。它是 PyTorch 的前身项目,不再积极开发。 PyTorch 在名称中包含 “Torch” 以感谢先前的 torch 库,使用 "Py" 作为前缀以表明聚焦于 Python。

PyTorch API 简单灵活,使其成为学术界和研究人员开发新的深度学习模型和应用程序的最爱之一。同时,广泛的应用衍生了许多针对特定应用(例如文本、计算机视觉和音频数据)的扩展,并且可作为预训练模型直接使用。因此,它可能是学术界使用最多的库。

Keras 等更简单的界面相比,PyTorch 的灵活性是以易用性为代价的,尤其是对于初学者而言。选择 PyTorch 而不是 Keras 的意味着放弃了一些易用性、需要面对更陡峭的学习曲线、以及使用更多的代码以获得更大的灵活性,也许还有一个更有活力的学术社区。

代码
文本

1.2 安装 Pytorch

本教程是一个 Bohrium Notebook。Python 程序可直接在浏览器中运行,Bohrium 已安装 PyTorch。这是学习和使用 PyTorch 的好方法。

要按照本教程进行操作,请点击本页顶部的按钮,在 Bohrium Notebook 中运行本笔记本。

  1. 你可以点击界面上方蓝色按钮 开始连接,选择 bohrium-notebook 镜像及任何一款计算机型,稍等片刻即可运行。

  2. 若要运行笔记本中的所有代码,请点击左上角“ 运行全部单元格 ”。若要一次运行一个代码单元,请选择需要运行的单元格,然后点击左上角 “运行选中的单元格” 图标。

如果你的 Bohrium 镜像尚未安装 PyTorch, 也可快速通过 pip 安装 torch:

代码
文本
[1]
! pip install torch
Requirement already satisfied: torch in /opt/anaconda3/envs/ML_env/lib/python3.9/site-packages (1.13.1)
Requirement already satisfied: typing-extensions in /opt/anaconda3/envs/ML_env/lib/python3.9/site-packages (from torch) (4.4.0)
代码
文本

如果你需要使用更特定于你的平台或包管理器的安装方法,你可以在这里查看更完整的安装说明。

代码
文本

1.3 验证 PyTorch 安装并查看版本

安装 PyTorch 后,确认库已成功安装并且你可以开始使用它。

不要跳过此步骤。

如果 PyTorch 未正确安装或在此步骤中引发错误,则将无法运行之后的示例。

代码
文本
[2]
import torch
print(torch.__version__) # torch.__version__ 返回安装的 PyTorch 的版本号
1.13.1
代码
文本

2 PyTorch 深度学习模型的建立范式

在本节中,你将了解深度学习模型的建立范式以及可用于定义模型的 PyTorch API。

建立模型有一个范式,这个非常简单的知识为数据建模和理解 PyTorch API 提供了支撑。

模型建立范式中的五个步骤如下:

  1. 准备数据。
  2. 定义模型。
  3. 训练模型。
  4. 评估模型。
  5. 做出预测。

注意:使用 PyTorch API 有很多方法可以实现这些步骤,我们的目标是向你展示最简单、最常见或最惯用的方法。

如果你发现更好的方法,请通过邮箱告诉我。

接下来让我们依次仔细看看每个步骤。

在本节中,我们将以 基于鸢尾花数据集的多分类感知机 为例进行介绍。

这个问题涉及在给定花的测量值的情况下预测鸢尾花的种类。

数据集将使用 Pandas 自动下载,但您可以在此处了解更多信息:

代码
文本

2.1 准备数据

第一步是加载和准备数据。

神经网络模型需要输入数据和输出数据。

你可以使用标准 Python 库来加载和准备多维数据,例如 CSV 文件。

Pandas 可用于加载你的 CSV 文件,Scikit-Learn 中的工具可用于编码分类数据,例如对标签分类。

PyTorch 提供了 Dataset 类,你可以扩展和自定义该类以加载你的数据集。

例如,数据集对象的构造函数可以加载你的数据文件(例如 CSV 文件)。然后,你可以覆盖可用于获取数据集长度(行数或样本数)的 __len__() 函数,以及用于按索引获取特定样本的 __getitem__() 函数。

加载数据集时,你还可以执行任何所需的转换,例如缩放或编码。

下面提供了自定义数据集类的框架。

代码
文本
[3]
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from torch.utils.data import Dataset
from torch.utils.data import random_split

# 定义数据集
class CSVDataset(Dataset):
# 导入数据集
def __init__(self, path):
# 导入传入路径的数据集为 Pandas DataFrame 格式
df = pd.read_csv(path, header=None)
# 设置神经网络的输入与输出
self.X = df.values[:, :-1] # 根据你的数据集定义输入属性
self.y = df.values[:, -1] # 根据你的数据集定义输出属性
# 确保输入的数据是浮点型
self.X = self.X.astype('float32')
# 使用浮点型标签编码原输出
self.y = LabelEncoder().fit_transform(self.y)
# 定义获得数据集长度的方法
def __len__(self):
return len(self.X)
# 定义获得某一行数据的方法
def __getitem__(self, idx):
return [self.X[idx], self.y[idx]]
# 在类内部定义划分训练集和测试集的方法,在本例中,训练集比例为 0.67,测试集比例为 0.33
def get_splits(self, n_test=0.33):
# 确定训练集和测试集的尺寸
test_size = round(n_test * len(self.X))
train_size = len(self.X) - test_size
# 根据尺寸划分训练集和测试集并返回
return random_split(self, [train_size, test_size])
代码
文本

让我们运行一下定义的 CSVDataset() 类中的各方法以加深理解

代码
文本
[4]
# 定义数据集路径(在本例中,数据集需为 csv 文件)
data_path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv'
# 实例化数据集
dataset = CSVDataset(data_path)
print(f'输入矩阵的形状是:{dataset.X.shape}')
# dataset.X # 查看输入矩阵 dataset.X
输入矩阵的形状是:(150, 4)
代码
文本
[5]
print(f'输出矩阵的形状是:{dataset.y.shape}')
# dataset.y # 查看输出矩阵
输出矩阵的形状是:(150,)
代码
文本
[6]
# len() 方法本质上是调用类内部的 __len__() 方法,所以以下方法是等效的。
print(len(dataset))
print(dataset.__len__())
150
150
代码
文本
[7]
# dataset[] 方法本质上是调用类内部的 __getitem__ 方法,所以以下方法是等效的。
print(dataset[149])
print(dataset.__getitem__(149))
[array([5.9, 3. , 5.1, 1.8], dtype=float32), 2]
[array([5.9, 3. , 5.1, 1.8], dtype=float32), 2]
代码
文本

加载后,PyTorch 提供 DataLoader 类,用于在模型训练和评估期间导航数据集实例。

可以为训练数据集、测试数据集甚至验证数据集创建 DataLoader 实例。

random_split() 函数可用于将数据集拆分为训练集和测试集。

拆分后,将数据集中 batch 及其 size 提供给 DataLoader,并可选择是否应在每个 epoch 对数据进行随机排序。

了解什么是 epoch 和 batch,推荐阅读:训练神经网络中最基本的三个概念:Epoch, Batch, Iteration

代码
文本
[8]
from torch.utils.data import DataLoader
from torch.utils.data import random_split

...
# 确定训练集和测试集的尺寸
n_test = 0.33 # 在本例中,训练集比例为 0.67,测试集比例为 0.33
test_size = round(n_test * len(dataset.X))
train_size = len(dataset.X) - test_size

# 根据尺寸划分训练集和测试集并返回
train, test = random_split(dataset, [train_size, test_size])

# 让我们查看一下创建的训练集的类型和长度
print(f'划分的训练集的数据类型是:{type(train)}')
print(f'划分的训练集长度是:{len(train)}')
划分的训练集的数据类型是:<class 'torch.utils.data.dataset.Subset'>
划分的训练集长度是:100
代码
文本
[9]
# list(train) # 查看一下划分的训练集

# 你可以用同样的方法查看一下划分得到的测试集
代码
文本

例如,我们可以通过传入数据集中的选定行来定义 DataLoader

代码
文本
[10]
# 为训练集和测试集创建 DataLoader
train_dl = DataLoader(train, batch_size=32, shuffle=True)
test_dl = DataLoader(test, batch_size=1024, shuffle=False)
print(len(train_dl.dataset), len(test_dl.dataset))
100 50
代码
文本

定义后,可以循环 DataLoader,每次迭代生成一批样本。

代码
文本
[11]
# 在本例中,train_dl 的 batch_size 为 32,数据将随机排序。让我们来查看一下 train_dl
n_inputs = len(train_dl)
for i, (inputs, targets) in enumerate(train_dl):
print(f'第 {i} 个 batch 有 {len(inputs)} 个数据,其中输入矩阵的形状是 {inputs.shape},输出矩阵的形状是 {targets.shape}')
print(f'共有 {n_inputs} 个 batches')
第 0 个 batch 有 32 个数据,其中输入矩阵的形状是 torch.Size([32, 4]),输出矩阵的形状是 torch.Size([32])
第 1 个 batch 有 32 个数据,其中输入矩阵的形状是 torch.Size([32, 4]),输出矩阵的形状是 torch.Size([32])
第 2 个 batch 有 32 个数据,其中输入矩阵的形状是 torch.Size([32, 4]),输出矩阵的形状是 torch.Size([32])
第 3 个 batch 有 4 个数据,其中输入矩阵的形状是 torch.Size([4, 4]),输出矩阵的形状是 torch.Size([4])
共有 4 个 batches
代码
文本

enumerate() 函数是 Python 内置函数,用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个有索引的序列,同时列出数据和数据下标。多用在 for 循环中。

尝试在本 Notebook 中运行以下示例并理解 enumerate() 函数。

代码
文本
[12]
seasons = [('Spring', 'Green'),
('Summer', 'Red'),
('Fall', 'Yellow'),
('Winter', 'White')
]
print(list(enumerate(seasons, start=1))) # start 参数设置序列从 1 开始,不填则默认从 0 开始
print('--------')

# 再在 for 循环中看看 enumerate 函数的效果
for i, (season, color) in enumerate(seasons, start=1):
print(f'My impression {i} about {season} is {color}.')
[(1, ('Spring', 'Green')), (2, ('Summer', 'Red')), (3, ('Fall', 'Yellow')), (4, ('Winter', 'White'))]
--------
My impression 1 about Spring is Green.
My impression 2 about Summer is Red.
My impression 3 about Fall is Yellow.
My impression 4 about Winter is White.
代码
文本

2.2 定义模型

下一步是定义模型。

在 PyTorch 中定义模型的习惯用法是定义一个继承 Module 类Python class

你构造的类定义了模型的层,forward() 函数需要覆写以定义在模型层中的输入参数的前向传播。

了解什么是前向传播,推荐阅读:笔记 | 什么是Forward Propagation

许多层都可用,例如用于全连接层的 Linear,用于卷积层的 Conv2d,用于池化层的 MaxPool2d

激活函数也可以定义为层,例如 ReLU, Softmax, 和 Sigmoid.

在构造函数中定义给定层后,也可以初始化给定层的权重。

常见的例子包括 XavierHe weight 权重初始化方案。例如:xavier_uniform_(self.layer.weight)

下面是一个简单的单层 MLP 模型的示例。

代码
文本
[13]
from torch.nn import Linear
from torch.nn import ReLU
from torch.nn import Softmax
from torch.nn import Module
from torch.nn.init import kaiming_uniform_
from torch.nn.init import xavier_uniform_

# 定义模型
class MLP(Module):
# 定义模型属性
def __init__(self, n_inputs):
super(MLP, self).__init__()
# 输出层
self.hidden1 = Linear(n_inputs, 10)
kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
self.act1 = ReLU()
# 第二个隐藏层
self.hidden2 = Linear(10, 8)
kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
self.act2 = ReLU()
# 第三层
self.hidden3 = Linear(8, 3)
xavier_uniform_(self.hidden3.weight)
self.act3 = Softmax(dim=1)
# 前向传播方法
def forward(self, X):
# 输入到第一个隐藏层
X = self.hidden1(X)
X = self.act1(X)
# 第二个隐藏层
X = self.hidden2(X)
X = self.act2(X)
# 输出层
X = self.hidden3(X)
X = self.act3(X)
return X
代码
文本

2.3 训练模型

训练过程要求你定义 损失函数优化算法

常见的损失函数包括:

  • BCELoss: 用于二元分类的 二元交叉熵损失 (Binary Cross-Entropy Loss)
  • CrossEntropyLoss: 用于多元分类的 多元交叉熵损失 (Categorical Cross-Entropy Loss)
  • MSELoss: 用于回归的 均方损失 (Mean squared loss)

有关损失函数的更多信息,请参阅教程:

用于训练深度学习神经网络的损失和损失函数

使用 随机梯度下降 进行优化,标准算法由 SGD class 提供,该算法的其他版本也可用,例如 Adam

了解随机梯度下降,请参阅:如何理解随机梯度下降(stochastic gradient descent,SGD)?

代码
文本
[14]
from torch.optim import SGD
from torch.nn import CrossEntropyLoss

...
model = MLP(n_inputs=n_inputs)
# 定义优化器
criterion = CrossEntropyLoss()
optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
代码
文本

训练模型涉及枚举训练数据集的 DataLoader

首先,需要为大量的 training epochs 建立一个循环。然后,需要为每个 mini-batch 建立一个内部循环,用于随机梯度下降。

模型的每次更新都涉及相同的常规模式,包括:

  • 清除最后一个误差梯度。
  • 前向传播并计算模型输出。
  • 计算模型输出的损失。
  • 通过模型反向传播误差。
  • 更新模型以减少损失。

例如:

...
# 梯度清除
optimizer.zero_grad()
# 计算模型输出
yhat = model(inputs)
# 计算损失
loss = criterion(yhat, targets)
# 贡献度分配
loss.backward()
# 升级模型权重
optimizer.step()
代码
文本
[15]
...
# 枚举 epochs
for epoch in range(500):
# 枚举 mini-batches
for i, (inputs, targets) in enumerate(train_dl):
# 梯度清除
optimizer.zero_grad()
# 计算模型输出
yhat = model(inputs)
# 计算损失
loss = criterion(yhat, targets)
# 贡献度分配
loss.backward()
# 升级模型权重
optimizer.step()
代码
文本

2.4 评估模型

模型拟合后,可以在测试数据集上对其进行评估。

可以通过使用测试集的 DataLoader 收集测试集的预测值,然后比较模型预测值与测试集的预期值并计算评价指标。

代码
文本
[16]
from numpy import vstack
from numpy import argmax
from sklearn.metrics import accuracy_score

predictions, actuals = list(), list() # 实例化预测值列表和预期值列表
for i, (inputs, targets) in enumerate(test_dl):
# 在测试集上评估模型
yhat = model(inputs)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
actual = targets.numpy()
# 转换为类标签
yhat = argmax(yhat, axis=1)
# 为 stack reshape 矩阵
actual = actual.reshape((len(actual), 1))
yhat = yhat.reshape((len(yhat), 1))
# 保存数据
predictions.append(yhat)
actuals.append(actual)

predictions, actuals = vstack(predictions), vstack(actuals)
# 计算准确度
acc = accuracy_score(actuals, predictions)
print(acc)
0.58
代码
文本

2.5 做出预测

拟合模型可用于对新数据进行预测。

例如,您可能有单个图像或一行数据,并且想要进行预测。

这需要您将数据包装在 PyTorch Tensor 数据结构中。

Tensor 只是用于保存 NumPy 数组类型的数据的 PyTorch 版本。它还允许您在模型图中执行自动微分任务,例如在训练模型时调用 backward()

预测也将是一个 Tensor,尽管您可以通过在自动微分图中分离张量并调用 NumPy 函数来检索 NumPy 数组。

代码
文本
[17]
from torch import Tensor

...
row = [5.1,3.5,1.4,0.2]
# 将数据转化为 Tensor
row = Tensor([row])
# 做出预测
yhat = model(row)
# 重写为 Numpy Array 格式
yhat = yhat.detach().numpy()

print(f'各标签可能的概率: {yhat} (最可能的种类:class={argmax(yhat)})')
各标签可能的概率: [[9.9997008e-01 2.9798704e-05 1.6202495e-07]] (最可能的种类:class=0)
代码
文本

现在我们已经充分熟悉了 PyTorch API 和模型建立范式,让我们看看如何从头开始开发一些标准的深度学习模型。

有关该节示例的连续代码,请见 3.2 建立多分类任务的多层感知机模型

代码
文本

3 为预测任务建立 PyTorch 深度学习模型

在本节中,你将了解如何使用标准深度学习模型(包括多层感知器 (Multi Layer Perceptrons, MLP) 和卷积神经网络 (Convolutional Neural Networks, CNN))进行开发、评估和预测。

多层感知机模型(MLP)是一种标准的全连接神经网络模型。

它由节点层组成,其中每个节点连接到前一层的所有输出,每个节点的输出连接到下一层节点的所有输入。

MLP 是具有一个或多个完全连接层的模型。此模型适用于表格类型的数据。你可能想使用 MLP 探索三个预测建模问题;它们是二元分类、多类分类和回归。让我们在真实数据集上为每种情况拟合一个模型。

注意:本节中的模型有效,但未优化。看看你是否可以提高他们的表现。不要犹豫,试试直接在 Bohrium Notebook 中实现你的想法。

代码
文本

3.1 建立二分类任务的多层感知机模型

我们将使用电离层二分类数据集来演示用于二分类的 MLP。

该数据集涉及预测大气中是否存在给定雷达回波的结构。

数据集将使用 Pandas 自动下载,但你可以在此处了解更多信息:

我们将使用 LabelEncoder 将字符串标签编码为整数值 0 和 1。该模型将适合 67% 的数据,其余 33% 将用于评估,使用 train_test_split() function 函数进行拆分。

使用带有 “He Uniform” 权重初始化的 “relu” 激活函数是一个很好的做法。这种组合对于克服训练深度神经网络模型时梯度消失 的问题大有帮助。有关 ReLU 的更多信息,请参阅教程:

该模型使用随机梯度下降进行优化,并力求最小化二元交叉熵损失。 下面列出了完整的示例。

代码
文本
[18]
# PyTorch|建立二分类任务的多层感知机模型
from numpy import vstack
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch.utils.data import random_split
from torch import Tensor
from torch.nn import Linear
from torch.nn import ReLU
from torch.nn import Sigmoid
from torch.nn import Module
from torch.optim import SGD
from torch.nn import BCELoss
from torch.nn.init import kaiming_uniform_
from torch.nn.init import xavier_uniform_
# 数据集定义
class CSVDataset(Dataset):
# 导入数据
def __init__(self, path):
# 导入传入路径的数据集为 Pandas DataFrame 格式
df = read_csv(path, header=None)
# 设置神经网络的输入与输出
self.X = df.values[:, :-1]
self.y = df.values[:, -1]
# 确保输入数据是浮点数
self.X = self.X.astype('float32')
# 使用浮点型标签编码原输出
self.y = LabelEncoder().fit_transform(self.y)
self.y = self.y.astype('float32')
self.y = self.y.reshape((len(self.y), 1))
# 定义获得数据集长度的方法
def __len__(self):
return len(self.X)
# 定义获得某一行数据的方法
def __getitem__(self, idx):
return [self.X[idx], self.y[idx]]
# 在类内部定义划分训练集和测试集的方法,在本例中,训练集比例为 0.67,测试集比例为 0.33
def get_splits(self, n_test=0.33):
# 确定训练集和测试集的尺寸
test_size = round(n_test * len(self.X))
train_size = len(self.X) - test_size
# 根据尺寸划分训练集和测试集并返回
return random_split(self, [train_size, test_size])
# 模型定义
class MLP(Module):
# 定义模型输入
def __init__(self, n_inputs):
super(MLP, self).__init__()
# 输入到隐层 1
self.hidden1 = Linear(n_inputs, 10)
kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
self.act1 = ReLU()
# 隐层 2
self.hidden2 = Linear(10, 8)
kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
self.act2 = ReLU()
# 隐层 3 和输出
self.hidden3 = Linear(8, 1)
xavier_uniform_(self.hidden3.weight)
self.act3 = Sigmoid()
# 前向传播
def forward(self, X):
# 输入到隐层 1
X = self.hidden1(X)
X = self.act1(X)
# 隐层 2
X = self.hidden2(X)
X = self.act2(X)
# 隐层 3 和输出
X = self.hidden3(X)
X = self.act3(X)
return X
# 准备数据集
def prepare_data(path):
# 导入数据集
dataset = CSVDataset(path)
# 划分训练集和测试集并返回
train, test = dataset.get_splits()
# 为训练集和测试集创建 DataLoader
train_dl = DataLoader(train, batch_size=32, shuffle=True)
test_dl = DataLoader(test, batch_size=1024, shuffle=False)
return train_dl, test_dl
# 训练模型
def train_model(train_dl, model):
# 定义优化器
criterion = BCELoss()
optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
# 枚举 epochs
for epoch in range(100):
# 枚举 mini batches
for i, (inputs, targets) in enumerate(train_dl):
# 梯度清除
optimizer.zero_grad()
# 计算模型输出
yhat = model(inputs)
# 计算损失
loss = criterion(yhat, targets)
# 贡献度分配
loss.backward()
# 升级模型权重
optimizer.step()
# 评估模型
def evaluate_model(test_dl, model):
predictions, actuals = list(), list()
for i, (inputs, targets) in enumerate(test_dl):
# 在测试集上评估模型
yhat = model(inputs)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
actual = targets.numpy()
actual = actual.reshape((len(actual), 1))
# 转化为类值
yhat = yhat.round()
# 保存
predictions.append(yhat)
actuals.append(actual)
predictions, actuals = vstack(predictions), vstack(actuals)
# 计算准确度
acc = accuracy_score(actuals, predictions)
return acc
# 对一行数据进行类预测
def predict(row, model):
# 转换源数据
row = Tensor([row])
# 做出预测
yhat = model(row)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
return yhat
# 准备数据
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/ionosphere.csv'
train_dl, test_dl = prepare_data(path)
print(len(train_dl.dataset), len(test_dl.dataset))
# 定义网络
model = MLP(34)
# 训练模型
train_model(train_dl, model)
# 评估模型
acc = evaluate_model(test_dl, model)
print('Accuracy: %.3f' % acc)
# 进行单个预测(预期类=1)
row = [1,0,0.99539,-0.05889,0.85243,0.02306,0.83398,-0.37708,1,0.03760,0.85243,-0.17755,0.59755,-0.44945,0.60536,-0.38223,0.84356,-0.38542,0.58212,-0.32192,0.56971,-0.29674,0.36946,-0.47357,0.56811,-0.51171,0.41078,-0.46168,0.21266,-0.34090,0.42267,-0.54487,0.18641,-0.45300]
yhat = predict(row, model)
print('Predicted: %.3f (class=%d)' % (yhat, yhat.round()))
235 116
Accuracy: 0.931
Predicted: 0.999 (class=1)
代码
文本

运行示例后,首先报告训练数据集和测试数据集的长度,然后拟合模型并在测试数据集上对其进行评估。最后,对单行数据进行预测。

注意:根据算法或评估过程的随机性质或数值精度的差异,你的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

你得到了什么结果?

你能改变模型做得更好吗?

你可以试着修改代码以直接输出平均结果吗?

不要犹豫,试试直接在 Bohrium Notebook 中实现你的想法。

在本例中,我们可以看到该模型实现了大约 94% 的分类准确率,然后预测某行数据属于类 1 的概率为 0.99。

代码
文本

3.2 建立多分类任务的多层感知机模型

我们将使用鸢尾花多元分类数据集来演示用于多元分类的 MLP。

这个问题涉及在给定花的测量值的情况下预测鸢尾花的种类。

数据集将使用 Pandas 自动下载,但您可以在此处了解更多信息:

鉴于它是一个多类分类,模型必须为输出层中的每个类提供一个节点,并使用softmax激活函数。损失函数是交叉熵,它适用于整数编码的类标签(例如,0 表示一个类,1 表示下一个类,等等)。

下面列出了在鸢尾花数据集上拟合和评估 MLP 的完整示例。

代码
文本
[19]
# PyTorch|建立多分类任务的多层感知机模型
from numpy import vstack
from numpy import argmax
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
from torch import Tensor
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch.utils.data import random_split
from torch.nn import Linear
from torch.nn import ReLU
from torch.nn import Softmax
from torch.nn import Module
from torch.optim import SGD
from torch.nn import CrossEntropyLoss
from torch.nn.init import kaiming_uniform_
from torch.nn.init import xavier_uniform_
# 数据集定义
class CSVDataset(Dataset):
# 导入数据集
def __init__(self, path):
# 导入传入路径的数据集为 Pandas DataFrame 格式
df = read_csv(path, header=None)
# 设置神经网络的输入与输出
self.X = df.values[:, :-1]
self.y = df.values[:, -1]
# 确保输入数据是浮点型
self.X = self.X.astype('float32')
# 使用浮点型标签编码原输出
self.y = LabelEncoder().fit_transform(self.y)
# 定义获得数据集长度的方法
def __len__(self):
return len(self.X)
# 定义获得某一行数据的方法
def __getitem__(self, idx):
return [self.X[idx], self.y[idx]]
# 在类内部定义划分训练集和测试集的方法,在本例中,训练集比例为 0.67,测试集比例为 0.33
def get_splits(self, n_test=0.33):
# 确定训练集和测试集的尺寸
test_size = round(n_test * len(self.X))
train_size = len(self.X) - test_size
# 根据尺寸划分训练集和测试集并返回
return random_split(self, [train_size, test_size])
# 模型定义
class MLP(Module):
# 定义模型属性
def __init__(self, n_inputs):
super(MLP, self).__init__()
# 输入到隐层 1
self.hidden1 = Linear(n_inputs, 10)
kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
self.act1 = ReLU()
# 隐层 2
self.hidden2 = Linear(10, 8)
kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
self.act2 = ReLU()
# 隐层 3 和输出
self.hidden3 = Linear(8, 3)
xavier_uniform_(self.hidden3.weight)
self.act3 = Softmax(dim=1)
# 前向传播
def forward(self, X):
# 输入到隐层 1
X = self.hidden1(X)
X = self.act1(X)
# 隐层 2
X = self.hidden2(X)
X = self.act2(X)
# 输出层
X = self.hidden3(X)
X = self.act3(X)
return X
# 准备数据集
def prepare_data(path):
# 导入数据集
dataset = CSVDataset(path)
# 划分训练集和测试集并返回
train, test = dataset.get_splits()
# 为训练集和测试集创建 DataLoader
train_dl = DataLoader(train, batch_size=32, shuffle=True)
test_dl = DataLoader(test, batch_size=1024, shuffle=False)
return train_dl, test_dl
# 训练模型
def train_model(train_dl, model):
# 定义优化器
criterion = CrossEntropyLoss()
optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
# 枚举 epochs
for epoch in range(500):
# 枚举 mini batches
for i, (inputs, targets) in enumerate(train_dl):
# 梯度清除
optimizer.zero_grad()
# 计算模型输出
yhat = model(inputs)
# 计算损失
loss = criterion(yhat, targets)
# 贡献度分配
loss.backward()
# 升级模型权重
optimizer.step()
# 评估模型
def evaluate_model(test_dl, model):
predictions, actuals = list(), list()
for i, (inputs, targets) in enumerate(test_dl):
# 在测试集上评估模型
yhat = model(inputs)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
actual = targets.numpy()
# 转换为类标签
yhat = argmax(yhat, axis=1)
# 为 stacking reshape 矩阵
actual = actual.reshape((len(actual), 1))
yhat = yhat.reshape((len(yhat), 1))
# 保存
predictions.append(yhat)
actuals.append(actual)
predictions, actuals = vstack(predictions), vstack(actuals)
# 计算准确度
acc = accuracy_score(actuals, predictions)
return acc
# 对一行数据进行类预测
def predict(row, model):
# 转换源数据
row = Tensor([row])
# 做出预测
yhat = model(row)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
return yhat
# 准备数据
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv'
train_dl, test_dl = prepare_data(path)
print(len(train_dl.dataset), len(test_dl.dataset))
# 定义网络
model = MLP(4)
# 训练模型
train_model(train_dl, model)
# 评估模型
acc = evaluate_model(test_dl, model)
print('Accuracy: %.3f' % acc)
# 进行单个预测
row = [5.1,3.5,1.4,0.2]
yhat = predict(row, model)
print('Predicted: %s (class=%d)' % (yhat, argmax(yhat)))
100 50
Accuracy: 0.980
Predicted: [[9.9987459e-01 1.2522198e-04 1.0855692e-07]] (class=0)
代码
文本

运行示例后,首先报告训练数据集和测试数据集的长度,然后拟合模型并在测试数据集上对其进行评估。最后,对单行数据进行预测。

注意:根据算法或评估过程的随机性质或数值精度的差异,你的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

你得到了什么结果?

你能改变模型做得更好吗?

你可以试着修改代码以直接输出平均结果吗?

不要犹豫,试试直接在 Bohrium Notebook 中实现你的想法。

在本例中,我们可以看到该模型实现了大约 98% 的分类准确率,然后预测了其中一行属于某个类的概率,类 0 的概率最高。

代码
文本

3.3 建立回归任务的多层感知机模型

我们将使用波士顿房价回归数据集来演示用于回归预测建模的 MLP。

这个问题涉及根据房屋和社区的属性预测房屋价值。

数据集将使用 Pandas 自动下载,但您可以在此处了解更多信息。

这是一个回归问题,涉及预测单个数值。因此,输出层具有单个节点,并使用默认或线性激活函数(无激活函数)。通过使均方误差 (mse) 损失最小化来拟合模型。

这是回归,而不是分类;因此,我们无法计算分类准确性。有关此内容的更多信息,请参阅教程:

下面列出了在波士顿房价数据集上拟合和评估 MLP 的完整示例。

代码
文本
[20]
# PyTorch|建立回归任务的多层感知机模型
from numpy import vstack
from numpy import sqrt
from pandas import read_csv
from sklearn.metrics import mean_squared_error
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch.utils.data import random_split
from torch import Tensor
from torch.nn import Linear
from torch.nn import Sigmoid
from torch.nn import Module
from torch.optim import SGD
from torch.nn import MSELoss
from torch.nn.init import xavier_uniform_
# 数据集定义
class CSVDataset(Dataset):
# 导入数据集
def __init__(self, path):
# 导入传入路径的数据集为 Pandas DataFrame 格式
df = read_csv(path, header=None)
# 设置神经网络的输入与输出
self.X = df.values[:, :-1].astype('float32')
self.y = df.values[:, -1].astype('float32')
# 确保标签有正确的 shape
self.y = self.y.reshape((len(self.y), 1))
# 定义获得数据集长度的方法
def __len__(self):
return len(self.X)
# 定义获得某一行数据的方法
def __getitem__(self, idx):
return [self.X[idx], self.y[idx]]
# 在类内部定义划分训练集和测试集的方法,在本例中,训练集比例为 0.67,测试集比例为 0.33
def get_splits(self, n_test=0.33):
# 确定训练集和测试集的尺寸
test_size = round(n_test * len(self.X))
train_size = len(self.X) - test_size
# 根据尺寸划分训练集和测试集并返回
return random_split(self, [train_size, test_size])
# 模型定义
class MLP(Module):
# 定义模型属性
def __init__(self, n_inputs):
super(MLP, self).__init__()
# 输入到隐层 1
self.hidden1 = Linear(n_inputs, 10)
xavier_uniform_(self.hidden1.weight)
self.act1 = Sigmoid()
# 隐层 2
self.hidden2 = Linear(10, 8)
xavier_uniform_(self.hidden2.weight)
self.act2 = Sigmoid()
# 隐层 3 和输出
self.hidden3 = Linear(8, 1)
xavier_uniform_(self.hidden3.weight)
# 前向传播
def forward(self, X):
# 输入到隐层 1
X = self.hidden1(X)
X = self.act1(X)
# 隐层 2
X = self.hidden2(X)
X = self.act2(X)
# 隐层 3 和输出
X = self.hidden3(X)
return X
# 准备数据集
def prepare_data(path):
# 导入数据集
dataset = CSVDataset(path)
# 划分训练集和测试集并返回
train, test = dataset.get_splits()
# 为训练集和测试集创建 DataLoader
train_dl = DataLoader(train, batch_size=32, shuffle=True)
test_dl = DataLoader(test, batch_size=1024, shuffle=False)
return train_dl, test_dl
# 训练模型
def train_model(train_dl, model):
# 定义优化器
criterion = MSELoss()
optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
# 枚举 epochs
for epoch in range(100):
# 枚举 mini batches
for i, (inputs, targets) in enumerate(train_dl):
# 梯度清除
optimizer.zero_grad()
# 计算模型输出
yhat = model(inputs)
# 计算损失
loss = criterion(yhat, targets)
# 贡献度分配
loss.backward()
# 升级模型权重
optimizer.step()
# 评估模型
def evaluate_model(test_dl, model):
predictions, actuals = list(), list()
for i, (inputs, targets) in enumerate(test_dl):
# 在测试集上评估模型
yhat = model(inputs)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
actual = targets.numpy()
actual = actual.reshape((len(actual), 1))
# 保存
predictions.append(yhat)
actuals.append(actual)
predictions, actuals = vstack(predictions), vstack(actuals)
# 计算均方损失 mse
mse = mean_squared_error(actuals, predictions)
return mse
# 对一行数据进行类预测
def predict(row, model):
# 转换源数据
row = Tensor([row])
# 做出预测
yhat = model(row)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
return yhat
# 准备数据
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
train_dl, test_dl = prepare_data(path)
print(len(train_dl.dataset), len(test_dl.dataset))
# 定义网络
model = MLP(13)
# 训练模型
train_model(train_dl, model)
# 评估模型
mse = evaluate_model(test_dl, model)
print('MSE: %.3f, RMSE: %.3f' % (mse, sqrt(mse)))
# 进行单个预测
row = [0.00632,18.00,2.310,0,0.5380,6.5750,65.20,4.0900,1,296.0,15.30,396.90,4.98]
yhat = predict(row, model)
print('Predicted: %.3f' % yhat)
339 167
MSE: 84.666, RMSE: 9.201
Predicted: 23.459
代码
文本

运行示例后,首先报告训练数据集和测试数据集的长度,然后拟合模型并在测试数据集上对其进行评估。最后,对单行数据进行预测。

注意:根据算法或评估过程的随机性质或数值精度的差异,你的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

你得到了什么结果?

你能改变模型做得更好吗?

你可以试着修改代码以直接输出平均结果吗?

不要犹豫,试试直接在 Bohrium Notebook 中实现你的想法。

在本例中,我们可以看到该模型实现了大约 103 的 MSE,即大约 10 的 RMSE(单位是千美元)。然后预测单个示例的值为 21(千美元)。

代码
文本

3.4 建立图像分类的卷积神经网络模型

卷积神经网络(简称 CNN)是一种专为图像输入而设计的网络。

它们由具有卷积层的模型组成,这些卷积层可以提取特征(称为特征图),而池化层会将特征提取到最突出的元素。

CNN最适合图像分类任务,尽管它们也可以用于将图像作为输入的各种任务。

一种流行的图像分类任务是 MNIST handwritten digit classification 手写数字分类。它涉及数以万计的手写数字,必须归类为 0 到 9 之间的数字。 torchvision API提供了一个方便的功能,可以直接下载和加载这个数据集。 下面的示例加载数据集并绘制前几个图像。

代码
文本
[21]
# 在 PyTorch 中载入 mnist 数据集
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision.transforms import Compose
from torchvision.transforms import ToTensor
from matplotlib import pyplot
# 定义保存或加载数据集的位置
path = '~/.torch/datasets/mnist'
# 定义要应用于数据的转换
trans = Compose([ToTensor()])
# 下载并定义数据集
train = MNIST(path, train=True, download=True, transform=trans)
test = MNIST(path, train=False, download=True, transform=trans)
# 定义如何枚举数据集
train_dl = DataLoader(train, batch_size=32, shuffle=True)
test_dl = DataLoader(test, batch_size=32, shuffle=True)
# 以 batch 方式获取图片
i, (inputs, targets) = next(enumerate(train_dl))
# 绘图
for i in range(25):
# 定义子图
pyplot.subplot(5, 5, i+1)
# 绘制原始像素数据
pyplot.imshow(inputs[i][0], cmap='gray')
# 展示图片
pyplot.show()
代码
文本

运行示例加载 MNIST 数据集,然后汇总默认训练和测试数据集。

上述代码创建了一个网格图,显示训练数据集中手写图像的示例。

代码
文本

我们可以训练一个CNN模型来对MNIST数据集中的图像进行分类。

请注意,图像是灰度像素数据的数组,因此,我们必须向数据添加通道维度,然后才能将图像用作模型的输入。

最好将像素值从默认范围 0-255 缩放为零平均值和标准差 1(标准正态分布)。

有关缩放像素值的详细信息,请参阅教程:

下面列出了在MNIST数据集上拟合和评估CNN模型的完整示例。

代码
文本
[22]
# PyTorch|建立图像分类的卷积神经网络模型
from numpy import vstack
from numpy import argmax
from pandas import read_csv
from sklearn.metrics import accuracy_score
from torchvision.datasets import MNIST
from torchvision.transforms import Compose
from torchvision.transforms import ToTensor
from torchvision.transforms import Normalize
from torch.utils.data import DataLoader
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import Linear
from torch.nn import ReLU
from torch.nn import Softmax
from torch.nn import Module
from torch.optim import SGD
from torch.nn import CrossEntropyLoss
from torch.nn.init import kaiming_uniform_
from torch.nn.init import xavier_uniform_
# 模型定义
class CNN(Module):
# 定义模型属性
def __init__(self, n_channels):
super(CNN, self).__init__()
# 输入到隐层 1
self.hidden1 = Conv2d(n_channels, 32, (3,3))
kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
self.act1 = ReLU()
# 池化层 1
self.pool1 = MaxPool2d((2,2), stride=(2,2))
# 隐层 2
self.hidden2 = Conv2d(32, 32, (3,3))
kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
self.act2 = ReLU()
# 池化层 2
self.pool2 = MaxPool2d((2,2), stride=(2,2))
# 全连接层
self.hidden3 = Linear(5*5*32, 100)
kaiming_uniform_(self.hidden3.weight, nonlinearity='relu')
self.act3 = ReLU()
# 输出层
self.hidden4 = Linear(100, 10)
xavier_uniform_(self.hidden4.weight)
self.act4 = Softmax(dim=1)
# 前向传播
def forward(self, X):
# 输入到隐层 1
X = self.hidden1(X)
X = self.act1(X)
X = self.pool1(X)
# 隐层 2
X = self.hidden2(X)
X = self.act2(X)
X = self.pool2(X)
# 扁平化
X = X.view(-1, 4*4*50)
# 隐层 3
X = self.hidden3(X)
X = self.act3(X)
# 输出层
X = self.hidden4(X)
X = self.act4(X)
return X
# 准备数据集
def prepare_data(path):
# 定义标准化
trans = Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])
# 加载数据集
train = MNIST(path, train=True, download=True, transform=trans)
test = MNIST(path, train=False, download=True, transform=trans)
# 为训练集和测试集创建 DataLoader
train_dl = DataLoader(train, batch_size=64, shuffle=True)
test_dl = DataLoader(test, batch_size=1024, shuffle=False)
return train_dl, test_dl
# 训练模型
def train_model(train_dl, model):
# 定义优化器
criterion = CrossEntropyLoss()
optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
# 枚举 epochs
for epoch in range(10):
# 枚举 mini batches
for i, (inputs, targets) in enumerate(train_dl):
# 梯度清除
optimizer.zero_grad()
# 计算模型输出
yhat = model(inputs)
# 计算损失
loss = criterion(yhat, targets)
# 贡献度分配
loss.backward()
# 升级模型权重
optimizer.step()
# 评估模型
def evaluate_model(test_dl, model):
predictions, actuals = list(), list()
for i, (inputs, targets) in enumerate(test_dl):
# 在测试集上评估模型
yhat = model(inputs)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
actual = targets.numpy()
# 转化为类标签
yhat = argmax(yhat, axis=1)
# 为 stack 格式化数据集
actual = actual.reshape((len(actual), 1))
yhat = yhat.reshape((len(yhat), 1))
# 保存
predictions.append(yhat)
actuals.append(actual)
predictions, actuals = vstack(predictions), vstack(actuals)
# 计算准确度
acc = accuracy_score(actuals, predictions)
return acc
# 准备数据
path = '~/.torch/datasets/mnist'
train_dl, test_dl = prepare_data(path)
print(len(train_dl.dataset), len(test_dl.dataset))
# 定义网络
model = CNN(1)
# # 训练模型
train_model(train_dl, model) # 该步骤运行约需 5 分钟。
# 评估模型
acc = evaluate_model(test_dl, model)
print('Accuracy: %.3f' % acc)
60000 10000
Accuracy: 0.987
代码
文本

运行示例后,首先报告训练数据集和测试数据集的长度,然后拟合模型并在测试数据集上对其进行评估。最后,对单行数据进行预测。

注意:根据算法或评估过程的随机性质或数值精度的差异,你的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

你得到了什么结果?

你能改变模型做得更好吗?

你可以试着修改代码以直接输出平均结果吗?

不要犹豫,试试直接在 Bohrium Notebook 中实现你的想法。

在本例中,我们可以看到该模型在测试数据集上实现了大约 98% 的分类准确率。

代码
文本

总结

在本教程中,您学习了在 PyTorch 中开发深度学习模型的范式。

具体而言,您了解到:

  • Torch 和 PyTorch 之间的区别以及如何安装和确认 PyTorch 是否正常工作。
  • PyTorch 模型的建立范式以及如何定义、拟合和评估模型。
  • 如何为回归、分类和预测建模任务开发 PyTorch 深度学习模型。

你有什么问题吗? 欢迎与我们联系 bohrium@dp.tech

代码
文本

参考

  1. PyTorch Tutorial: How to Develop Deep Learning Models with Python - MachineLearningMastery.com
  2. Zhang, A.; Lipton, Z. C.; Li, M.; Smola, A. J. Dive into Deep Learning. arXiv preprint arXiv:2106.11342 2021.
代码
文本

Open In Bohrium

代码
文本

©️ Copyright 2024 @ Authors
日期:2023-05-09
共享协议:本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。

代码
文本
PyTorch
Tutorial
Machine Learning
PyTorchTutorialMachine Learning
已赞76
本文被以下合集收录
2023机器学习及其在化学中的应用
昌珺涵
更新于 2024-09-12
22 篇158 人关注
使用 Python 快速开始机器学习
MileAway
更新于 2024-07-25
7 篇25 人关注
推荐阅读
公开
快速开始 PyTorch|使用 Python 建立深度学习模型副本
PyTorchTutorialMachine Learning
PyTorchTutorialMachine Learning
CyrusZHOU
发布于 2024-03-31
公开
快速开始 PyTorch|使用 Python 建立深度学习模型副本
PyTorchTutorialMachine Learning
PyTorchTutorialMachine Learning
123
更新于 2024-07-16
1 赞
评论
 ... # 枚举 epochs for ...

bohrbb3d20

07-04 10:49
11行运行报错RuntimeError: expected scalar type Long but found Int

小洲

07-05 02:24
回复 bohrbb3d20 替换loss = criterion(yhat, targets.long())
评论
 # PyTorch|建立图像分类的卷积神...

bohrbb3d20

07-06 10:01
第40行为什么是5*5?

bohrbb3d20

07-06 10:09
第59行参数为什么是4*4*50?
评论