PyTorch 教程：如何使用 Python 开发深度学习模型

作者： Jason Brownlee 于 2023 年 5 月 1 日在 Deep Learning with PyTorch 130

使用深度学习进行预测建模是现代开发人员需要掌握的一项技能。

PyTorch 是由 Facebook 开发和维护的领先的开源深度学习框架。

PyTorch 的核心是一个数学库，它允许您对基于图的模型进行高效计算和自动微分。直接实现这一点具有挑战性，但幸运的是，现代 PyTorch API 提供了允许您轻松开发一套深度学习模型的类和惯用法。

在本教程中，您将发现一个逐步指南，了解如何在 PyTorch 中开发深度学习模型。

完成本教程后，您将了解：

Torch 和 PyTorch 之间的区别以及如何安装和确认 PyTorch 正在工作。
PyTorch 模型的五步生命周期以及如何定义、拟合和评估模型。
如何为回归、分类和预测建模任务开发 PyTorch 深度学习模型。

通过我的《用PyTorch进行深度学习》一书来启动你的项目。它提供了包含可用代码的自学教程。

让我们开始吧。

PyTorch Tutorial - How to Develop Deep Learning Models

PyTorch 教程 – 如何开发深度学习模型
照片由 Dimitry B. 提供，保留部分权利。

PyTorch 教程概述

本教程的重点是使用 PyTorch API 进行常见的深度学习模型开发任务；我们不会深入探讨深度学习的数学和理论。为此，我建议从这本优秀的图书开始。

在 Python 中学习深度学习的最佳方式是动手实践。深入研究。您以后可以回来学习更多理论。

我将每个代码示例设计为使用最佳实践并具有独立性，以便您可以直接将其复制粘贴到您的项目中并根据您的特定需求进行调整。这将使您在尝试仅通过官方文档了解 API 方面获得巨大的领先优势。

这是一个大型教程，因此，它分为三个部分；它们是

如何安装 PyTorch
1. 什么是 Torch 和 PyTorch？
2. 如何安装 PyTorch
3. 如何确认 PyTorch 已安装
PyTorch 深度学习模型生命周期
1. 第 1 步：准备数据
2. 第 2 步：定义模型
3. 第 3 步：训练模型
4. 第 4 步：评估模型
5. 第 5 步：进行预测
如何开发 PyTorch 深度学习模型
1. 如何开发用于二元分类的 MLP
2. 如何开发用于多类分类的 MLP
3. 如何开发用于回归的 MLP
4. 如何开发用于图像分类的 CNN

您可以在 Python 中进行深度学习！

完成本教程。最多需要 60 分钟！

您不需要理解所有内容（至少现在不需要）。您的目标是端到端地运行教程并获得结果。您不需要在第一次通过时就理解所有内容。在您进行过程中记下您的问题。大量使用 API 文档来了解您正在使用的所有函数。

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

您不需要了解算法的工作原理。了解深度学习算法的局限性以及如何配置它们非常重要。但学习算法可以放在以后。您需要长时间缓慢地积累这种算法知识。今天，从熟悉平台开始。

您不需要是一名 Python 程序员。如果您是新手，Python 语言的语法可能很直观。就像其他语言一样，重点关注函数调用（例如 function()）和赋值（例如 a = “b”）。这将使您完成大部分工作。您是一名开发人员；您知道如何非常快速地掌握一门语言的基础知识。只需开始并稍后深入了解细节。

您不需要是深度学习专家。您可以在以后了解各种算法的优点和局限性，并且有许多教程可以阅读以复习深度学习项目的步骤。

1. 如何安装 PyTorch

在本节中，您将了解什么是 PyTorch、如何安装它以及如何确认它已正确安装。

1.1. 什么是 Torch 和 PyTorch？

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

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

Torch (Torch7) 是一个用 C 编写的开源深度学习项目，通常通过 Lua 接口使用。它是 PyTorch 的前身项目，不再积极开发。PyTorch 的名称中包含“Torch”，以承认之前的 torch 库，并带有“Py”前缀，表示新项目专注于 Python。

PyTorch API 简单灵活，使其成为学术界和研究人员开发新深度学习模型和应用程序的最爱。广泛使用导致了许多针对特定应用程序（如文本、计算机视觉和音频数据）的扩展，以及许多可以直接使用的预训练模型。因此，它可能是学术界使用最广泛的库。

PyTorch 的灵活性是以易用性为代价的，特别是对于初学者而言，与 Keras 等更简单的接口相比。选择使用 PyTorch 而不是 Keras 会牺牲一些易用性，学习曲线更陡峭一些，代码更多，但灵活性更高，并且可能拥有更活跃的学术社区。

1.2. 如何安装 PyTorch

在安装 PyTorch 之前，请确保您已安装 Python，例如 Python 3.6 或更高版本。

如果您没有安装 Python，可以使用 Anaconda 安装。本教程将向您展示如何操作

如何使用 Anaconda 配置您的 Python 机器学习环境

有许多方法可以安装 PyTorch 开源深度学习库。

在您的工作站上安装 PyTorch 最常见、也许最简单的方法是使用 pip。

例如，在命令行中，您可以输入

sudo pip install torch

1	sudo pip install torch

深度学习最流行的应用可能是计算机视觉，PyTorch 计算机视觉包名为“torchvision”。

强烈建议安装 torchvision，它可以通过以下方式安装

sudo pip install torchvision

1	sudo pip install torchvision

如果您更喜欢使用特定于您的平台或包管理器的安装方法，您可以在此处查看完整的安装说明列表

PyTorch 安装指南

现在无需设置 GPU。

本教程中的所有示例都可以在现代 CPU 上正常运行。如果您想为您的 GPU 配置 PyTorch，您可以在完成本教程后进行。不要分心！

1.3. 如何确认 PyTorch 已安装

安装 PyTorch 后，务必确认库已成功安装并且您可以开始使用它。

不要跳过此步骤。

如果 PyTorch 未正确安装或在此步骤中引发错误，您将无法稍后运行示例。

创建一个名为 versions.py 的新文件，并将以下代码复制粘贴到该文件中。

# check pytorch version
import torch
print(torch.__version__)

# 检查 pytorch 版本

import torch

print(torch.__version__)

保存文件，然后打开命令行并更改目录到您保存文件的位置。

然后输入

python versions.py

1	python versions.py

然后您应该会看到以下输出

1.3.1

1.3.1

这证实 PyTorch 已正确安装，并且我们都使用相同的版本。

这还向您展示了如何从命令行运行 Python 脚本。我建议以这种方式从命令行运行所有代码，而不是从笔记本或 IDE 运行。

2. PyTorch 深度学习模型生命周期

在本节中，您将了解深度学习模型的生命周期以及可用于定义模型的 PyTorch API。

模型有一个生命周期，这个非常简单的知识为建模数据集和理解 PyTorch API 提供了骨干。

生命周期中的五个步骤如下

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

让我们依次仔细研究每个步骤。

注意：使用 PyTorch API 有多种方法可以完成这些步骤中的每一个，但我旨在向您展示最简单、最常见或最符合惯用法的。

如果您发现更好的方法，请在下面的评论中告诉我。

第 1 步：准备数据

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

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

您可以使用标准 Python 库加载和准备表格数据，例如 CSV 文件。例如，Pandas 可用于加载您的 CSV 文件，scikit-learn 中的工具可用于编码分类数据，例如类标签。

PyTorch 提供了 Dataset 类，您可以扩展和自定义它来加载您的数据集。

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

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

下面提供了一个自定义 Dataset 类的骨架。

# dataset definition
class CSVDataset(Dataset):
    # load the dataset
    def __init__(self, path):
        # store the inputs and outputs
        self.X = ...
        self.y = ...

    # number of rows in the dataset
    def __len__(self):
        return len(self.X)

    # get a row at an index
    def __getitem__(self, idx):
        return [self.X[idx], self.y[idx]]

# 数据集定义

class CSVDataset(Dataset):

# 加载数据集

def __init__(self, path):

# 存储输入和输出

self.X = ...

self.y = ...

# 数据集中的行数

def __len__(self):

return len(self.X)

# 获取索引处的一行

def __getitem__(self, idx):

return [self.X[idx], self.y[idx]]

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

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

random_split() 函数可用于将数据集拆分为训练集和测试集。拆分后，可以将 Dataset 中选择的行提供给 DataLoader，以及批处理大小以及是否应在每个 epoch 洗牌数据。

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

...
# create the dataset
dataset = CSVDataset(...)
# select rows from the dataset
train, test = random_split(dataset, [[...], [...]])
# create a data loader for train and test sets
train_dl = DataLoader(train, batch_size=32, shuffle=True)
test_dl = DataLoader(test, batch_size=1024, shuffle=False)

...

# 创建数据集

dataset = CSVDataset(...)

# 从数据集中选择行

train, test = random_split(dataset, [[...], [...]])

# 为训练集和测试集创建数据加载器

train_dl = DataLoader(train, batch_size=32, shuffle=True)

test_dl = DataLoader(test, batch_size=1024, shuffle=False)

定义后，可以枚举 DataLoader，每次迭代生成一批样本。

...
# train the model
for i, (inputs, targets) in enumerate(train_dl):
	...

...

# 训练模型

for i, (inputs, targets) in enumerate(train_dl):

...

第 2 步：定义模型

下一步是定义模型。

在 PyTorch 中定义模型的惯用法涉及定义一个扩展 Module 类的类。

您的类的构造函数定义了模型的层，而 forward() 函数是定义如何通过模型定义的层向前传播输入的覆盖。

有许多层可用，例如用于全连接层的 Linear、用于卷积层的 Conv2d 和用于池化层的 MaxPool2d。

激活函数也可以定义为层，例如 ReLU、Softmax 和 Sigmoid。

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

# model definition
class MLP(Module):
    # define model elements
    def __init__(self, n_inputs):
        super(MLP, self).__init__()
        self.layer = Linear(n_inputs, 1)
        self.activation = Sigmoid()

    # forward propagate input
    def forward(self, X):
        X = self.layer(X)
        X = self.activation(X)
        return X

# 模型定义

class MLP(Module):

# 定义模型元素

def __init__(self, n_inputs):

super(MLP, self).__init__()

self.layer = Linear(n_inputs, 1)

self.activation = Sigmoid()

# 前向传播输入

def forward(self, X):

X = self.layer(X)

X = self.activation(X)

return X

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

常见的示例包括 Xavier 和 He 权重初始化方案。例如

...
xavier_uniform_(self.layer.weight)

1 2	... xavier_uniform_(self.layer.weight)

第 3 步：训练模型

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

常见的损失函数包括以下内容

BCELoss：用于二元分类的二元交叉熵损失。
CrossEntropyLoss：用于多类分类的分类交叉熵损失。
MSELoss：用于回归的均方误差损失。

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

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

随机梯度下降用于优化，标准算法由 SGD 类提供，尽管还有其他版本的算法可用，例如 Adam。

# define the optimization
criterion = MSELoss()
optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)

# 定义优化

criterion = MSELoss()

optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)

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

首先，需要一个用于训练 epoch 数量的循环。然后需要一个用于随机梯度下降的小批量的内循环。

...
# enumerate epochs
for epoch in range(100):
    # enumerate mini batches
    for i, (inputs, targets) in enumerate(train_dl):
    	...

...

# 枚举 epoch

for epoch in range(100):

# 枚举小批量

for i, (inputs, targets) in enumerate(train_dl):

...

模型的每次更新都涉及相同的通用模式，包括

清除上次的误差梯度。
输入通过模型的前向传播。
计算模型输出的损失。
通过模型反向传播误差。
更新模型以减少损失。

例如：

...
# clear the gradients
optimizer.zero_grad()
# compute the model output
yhat = model(inputs)
# calculate loss
loss = criterion(yhat, targets)
# credit assignment
loss.backward()
# update model weights
optimizer.step()

...

# 清除梯度

optimizer.zero_grad()

# 计算模型输出

yhat = model(inputs)

# 计算损失

loss = criterion(yhat, targets)

# 归属

loss.backward()

# 更新模型权重

optimizer.step()

第 4 步：评估模型

一旦模型拟合，就可以在测试数据集上进行评估。

这可以通过使用测试数据集的 DataLoader 并收集测试集的预测，然后将预测与测试集的预期值进行比较并计算性能指标来实现。

...
for i, (inputs, targets) in enumerate(test_dl):
    # evaluate the model on the test set
    yhat = model(inputs)
    ...

...

for i, (inputs, targets) in enumerate(test_dl):

# 在测试集上评估模型

yhat = model(inputs)

...

第 5 步：进行预测

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

例如，您可能有一张图像或一行数据并希望进行预测。

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

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

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

...
# convert row to data
row = Variable(Tensor([row]).float())
# make prediction
yhat = model(row)
# retrieve numpy array
yhat = yhat.detach().numpy()

...

# 将行转换为数据

row = Variable(Tensor([row]).float())

# 进行预测

yhat = model(row)

# 检索 numpy 数组

yhat = yhat.detach().numpy()

现在我们已经高层次地熟悉了 PyTorch API 和模型生命周期，接下来让我们看看如何从头开始开发一些标准的深度学习模型。

3. 如何开发 PyTorch 深度学习模型

在本节中，您将学习如何开发、评估和使用标准深度学习模型进行预测，包括多层感知器 (MLP) 和卷积神经网络 (CNN)。

多层感知器模型，简称 MLP，是一种标准的完全连接神经网络模型。

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

MLP 是一个具有一个或多个全连接层的模型。此模型适用于表格数据，即表格或电子表格中显示的数据，其中每列对应一个变量，每行对应一个变量。您可能希望使用 MLP 探索三种预测建模问题：二元分类、多类分类和回归。

让我们为每种情况拟合一个真实数据集的模型。

注意：本节中的模型是有效的，但未优化。看看您是否可以提高它们的性能。在下面的评论中发布您的发现。

3.1. 如何开发用于二元分类的 MLP

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

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

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

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

最好使用“relu”激活和“He Uniform”权重初始化。这种组合在训练深度神经网络模型时很大程度上克服了梯度消失的问题。有关 ReLU 的更多信息，请参阅教程

ReLU（修正线性单元）简介

该模型预测类别 1 的概率并使用 sigmoid 激活函数。该模型使用随机梯度下降进行优化，并寻求最小化二元交叉熵损失。

完整的示例如下所示。

# pytorch mlp for binary classification
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_

# dataset definition
class CSVDataset(Dataset):
    # load the dataset
    def __init__(self, path):
        # load the csv file as a dataframe
        df = read_csv(path, header=None)
        # store the inputs and outputs
        self.X = df.values[:, :-1]
        self.y = df.values[:, -1]
        # ensure input data is floats
        self.X = self.X.astype('float32')
        # label encode target and ensure the values are floats
        self.y = LabelEncoder().fit_transform(self.y)
        self.y = self.y.astype('float32')
        self.y = self.y.reshape((len(self.y), 1))

    # number of rows in the dataset
    def __len__(self):
        return len(self.X)

    # get a row at an index
    def __getitem__(self, idx):
        return [self.X[idx], self.y[idx]]

    # get indexes for train and test rows
    def get_splits(self, n_test=0.33):
        # determine sizes
        test_size = round(n_test * len(self.X))
        train_size = len(self.X) - test_size
        # calculate the split
        return random_split(self, [train_size, test_size])

# model definition
class MLP(Module):
    # define model elements
    def __init__(self, n_inputs):
        super(MLP, self).__init__()
        # input to first hidden layer
        self.hidden1 = Linear(n_inputs, 10)
        kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
        self.act1 = ReLU()
        # second hidden layer
        self.hidden2 = Linear(10, 8)
        kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
        self.act2 = ReLU()
        # third hidden layer and output
        self.hidden3 = Linear(8, 1)
        xavier_uniform_(self.hidden3.weight)
        self.act3 = Sigmoid()

    # forward propagate input
    def forward(self, X):
        # input to first hidden layer
        X = self.hidden1(X)
        X = self.act1(X)
         # second hidden layer
        X = self.hidden2(X)
        X = self.act2(X)
        # third hidden layer and output
        X = self.hidden3(X)
        X = self.act3(X)
        return X

# prepare the dataset
def prepare_data(path):
    # load the dataset
    dataset = CSVDataset(path)
    # calculate split
    train, test = dataset.get_splits()
    # prepare data loaders
    train_dl = DataLoader(train, batch_size=32, shuffle=True)
    test_dl = DataLoader(test, batch_size=1024, shuffle=False)
    return train_dl, test_dl

# train the model
def train_model(train_dl, model):
    # define the optimization
    criterion = BCELoss()
    optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
    # enumerate epochs
    for epoch in range(100):
        # enumerate mini batches
        for i, (inputs, targets) in enumerate(train_dl):
            # clear the gradients
            optimizer.zero_grad()
            # compute the model output
            yhat = model(inputs)
            # calculate loss
            loss = criterion(yhat, targets)
            # credit assignment
            loss.backward()
            # update model weights
            optimizer.step()

# evaluate the model
def evaluate_model(test_dl, model):
    predictions, actuals = list(), list()
    for i, (inputs, targets) in enumerate(test_dl):
        # evaluate the model on the test set
        yhat = model(inputs)
        # retrieve numpy array
        yhat = yhat.detach().numpy()
        actual = targets.numpy()
        actual = actual.reshape((len(actual), 1))
        # round to class values
        yhat = yhat.round()
        # store
        predictions.append(yhat)
        actuals.append(actual)
    predictions, actuals = vstack(predictions), vstack(actuals)
    # calculate accuracy
    acc = accuracy_score(actuals, predictions)
    return acc

# make a class prediction for one row of data
def predict(row, model):
    # convert row to data
    row = Tensor([row])
    # make prediction
    yhat = model(row)
    # retrieve numpy array
    yhat = yhat.detach().numpy()
    return yhat

# prepare the data
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))
# define the network
model = MLP(34)
# train the model
train_model(train_dl, model)
# evaluate the model
acc = evaluate_model(test_dl, model)
print('Accuracy: %.3f' % acc)
# make a single prediction (expect class=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()))

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

# 用于二元分类的 pytorch mlp

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):

# 将 csv 文件加载为数据框

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]]

# 获取训练和测试行的索引

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__()

# 输入到第一个隐藏层

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, 1)

xavier_uniform_(self.hidden3.weight)

self.act3 = Sigmoid()

# 前向传播输入

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

# 准备数据

def prepare_data(path):

# 加载数据集

dataset = CSVDataset(path)

# 计算拆分

train, test = dataset.get_splits()

# 准备数据加载器

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)

# 枚举 epoch

for epoch in range(100):

# 枚举小批量

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()))

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

注意：由于算法或评估过程的随机性，或数值精度的差异，您的结果可能会有所不同。建议运行该示例几次并比较平均结果。

进一步阅读

如果您想深入了解，本节提供了更多关于该主题的资源。

书籍

PyTorch项目

API

总结

在本教程中，您学习了在 PyTorch 中开发深度学习模型的分步指南。

具体来说，你学到了：

Torch 和 PyTorch 之间的区别以及如何安装和确认 PyTorch 正在工作。
PyTorch 模型的五步生命周期以及如何定义、拟合和评估模型。
如何为回归、分类和预测建模任务开发 PyTorch 深度学习模型。

你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。

关于此主题的更多信息

使用 PyTorch 进行深度学习（9 日迷你课程）

PyTorch 中的激活函数

对 PyTorch 教程：如何使用 Python 开发深度学习模型的 130 条回复

Kashif 2020年3月23日 5:39 am #

不错的教程。请问您是否正在从Keras迁移到Pytorch，以及这样做的任何可靠理由？我知道它是研究界的最爱，但还有什么呢？

回复
- Jason Brownlee 2020年3月23日 6:16 am #
  
  目前没有计划迁移到pytorch，我只是展示如何入门。
  
  回复
  - Hoson 2020年3月27日 6:40 pm #
    
    Keras API 仍然看起来比 PyTorch API 简单，但 TensorFlow 的版本 2 比 PyTorch 相对更强大且更适合生产。创建本教程背后有什么原因，或者有没有计划/原因切换到 PyTorch？
    
    一年多以前我评估过 Pytorch，但最终没有切换。另一个是 Julia，但直到现在，尤其是在有了版本 2 的 Eager 模式之后，我仍然坚持使用 TF 和 Keras。
    
    回复
    - Jason Brownlee 2020年3月28日 6:15 am #
      
      应要求制作。
      
      同意，Keras API 对初学者来说好很多。没有计划切换。
      
      回复
匿名 2020年3月24日 3:10 am #

先生，我正在用pytorch运行一个简单的DNN二分类程序。pytorch论坛上也有一个讨论，但尚未解决。您能帮忙吗？我会把链接发出来。

回复
- Jason Brownlee 2020年3月24日 6:09 am #
  
  请参阅上面关于“使用pytorch的DNN”的MLP示例。
  
  回复
Vince 2020年3月24日 8:27 am #

感谢您的教程。它非常好。但是，您有类似这样的 TensorFlow 教程吗？或者来自其他来源（书籍、网络……）？
谢谢！

回复
- Jason Brownlee 2020年3月24日 8:31 am #
  
  是的，就在这里。
  https://machinelearning.org.cn/tensorflow-tutorial-deep-learning-with-tf-keras/
  
  回复
Vince 2020年3月24日 9:33 am #

我的意思是：您有没有仅使用 TensorFlow 而不使用 Keras 的类似教程？
此外，我非常喜欢您的PyTorch教程中的“准备数据集”部分，因为我可以轻松定制我的数据集。然而，本教程不是这样的。它使用的是库中的函数，难以定制。您能解释一下为什么您这样做吗？
谢谢！

回复
- Jason Brownlee 2020年3月24日 1:43 pm #
  
  是的，这里有许多例子。
  https://machinelearning.org.cn/start-here/#deeplearning
  
  也许从这里开始
  https://machinelearning.org.cn/tutorial-first-neural-network-python-keras/
  
  在本教程中，我采用了 PyTorch 的最佳实践，这就是原因。
  
  回复
Benjamin 2020年3月25日 2:51 am #

很棒的教程。

我希望您能继续这个系列，并在 Pytorch 中涵盖更多示例。

回复
- Jason Brownlee 2020年3月25日 6:36 am #
  
  感谢您的建议。
  
  目前没有计划。
  
  回复
ZCoder 2020年3月25日 7:28 am #

Jason，

这是一个很棒的教程。您的端到端示例，配以非常清晰的解释，真是太棒了！非常感谢！

您网站上我最喜欢的教程是“如何将 Keras 函数式 API 用于深度学习”，特别是其第 5 部分“多输入和输出模型”。那个 Keras 教程帮助我开发了更复杂的模型。

虽然您提到目前没有计划扩展 PyTorch 教程，但如果在未来某个时候能看到一个类似的 PyTorch 教程，涵盖不同的多输入/多输出情况，那将是极好的。

谢谢！

回复
- Jason Brownlee 2020年3月25日 11:24 am #
  
  谢谢！
  
  好建议。
  
  回复
Kyla 2020年3月26日 5:48 am #

一如既往地感谢杰森！我一直期待一个好的 pytorch 教程。这个教程正合我意。

回复
- Jason Brownlee 2020年3月26日 8:02 am #
  
  谢谢！
  
  回复
Abraham 2020年3月26日 7:01 pm #

嗨，Jason，
根据我最近的经验，Pytorch 在深度学习问题上可能会比 Keras 提供更大的灵活性，也就是说，你可以深入了解模型的工作原理，并在某种程度上提升你的编码技能。我们期待新的 PyTorch 教程。

回复
- Jason Brownlee 2020年3月27日 6:08 am #
  
  谢谢。
  
  回复
Ashutosh 2020年3月27日 5:58 am #

这是一个非常棒的教程。谢谢 Jason 的分享。

回复
- Jason Brownlee 2020年3月27日 6:21 am #
  
  谢谢！
  
  回复

Anthony The Koala 2020年3月27日 1:46 pm #

尊敬的Jason博士，
我想与您分享这个。
对于那些在安装 PyTorch 时遇到困难的人，我提供另一种安装方式。

当您认为通过 pip 安装 PyTorch 及其 CUDA 和非 CUDA 版本都正常时，您可能会在安装过程中或尝试从 Python 内部导入时遇到 DLL 错误。

以下安装过程直接且未产生任何错误。

如果您在 PyTorch 安装过程中遇到困难，尤其是在安装期间出现错误，请尝试以下方法：

	Uninstall all pytorch versions including pytorch packages with *.whl 
	Goto https://pytorch.ac.cn/get-started/locally/ 
   	Select the stable version, eg, 1.4
	Select OS:Linux, Mac, Win
	Select source: conda, pip, libtorch, source
	Select language: python, c++/java
	Select cuda version: 9.1, 10.1 or none= relying on cpu
	For me: I selected stable, Win, pip, python, none.
	As a result I copied the following  for my particular choice:
	pip install torch==1.4.0+cpu torchvision==0.5.0+cpu -f https://download.pytorch.org/whl/torch_stable.html
	Opened a command window and pasted the above 
	Once installed, opened python and did this:
	import torch
	torch.__version__
	result: '1.4.0+cpu'

卸载所有 PyTorch 版本，包括带有 *.whl 的 PyTorch 软件包

前往 https://pytorch.ac.cn/get-started/locally/

选择稳定版本，例如， 1.4

选择操作系统:Linux, Mac, Win

选择源: conda, pip, libtorch, source

选择语言: python, c++/java

选择 cuda 版本: 9.1, 10.1 或无= 依赖 cpu

对我而言: 我选择了稳定版、 Win、 pip、 python、无。

因此我复制了以下内容用于我的特定选择:

pip install torch==1.4.0+cpu torchvision==0.5.0+cpu -f https://download.pytorch.org/whl/torch_stable.html

打开一个命令窗口并粘贴上述

安装完成后，打开 python 并执行以下操作:

import torch

torch.__version__

结果: '1.4.0+cpu'

谢谢你，
悉尼的Anthony

Jason Brownlee 2020年3月28日 6:09 am #

感谢分享！

回复
- Sean benhur 2020年11月2日 12:39 am #
  
  这是一个很棒的教程……请多做一些关于 Pytorch 的教程。
  
  回复
  - Jason Brownlee 2020年11月2日 6:41 am #
    
    谢谢！
    
    回复

asko 2020年4月2日 1:17 am #

非常感谢，

我仍然不明白为什么我们在创建自定义数据集类时要继承 Dataset，我知道 Dataset 是一个抽象类，但如果我们不继承它会发生什么呢？

谢谢你

回复
- Jason Brownlee 2020年4月2日 6:00 am #
  
  这是 PyTorch 库中的约定。
  
  如果你不遵守它会发生什么？你的代码可能无法工作——例如，你没有满足库的期望。
  
  回复
Sushant Gautam 2020年4月4日 3:55 am #

这是一个非常详细的解释教程。您的教程总是帮助我学到更多。谢谢 Jason 的分享。

回复
- Jason Brownlee 2020年4月4日 6:26 am #
  
  很高兴它有帮助！
  
  回复
Ando Ki 2020年4月27日 12:55 pm #

这是一个很好的教程，谢谢你。
您能告诉我如何准备新图像以提供“forward(x)”吗？
再次感谢。
安藤

回复
- Ando Ki 2020年4月27日 10:37 pm #
  
  上一个问题是关于MNIST的，问题是如何准备输入图像以从PNG或JPG图像中进行前向传播(x)。
  
  回复
  - Jason Brownlee 2020年4月28日 6:45 am #
    
    按正常方式加载图像，然后以与训练数据集相同的方式缩放像素/调整大小。
    
    回复
- Jason Brownlee 2020年4月28日 6:39 am #
  
  不客气。
  
  新图像必须以与训练数据相同的方式准备。
  
  回复
Xu Zhang 2020年4月29日 8:41 am #

非常感谢您的精彩文章。
最近，越来越多的新模型是用 Pytorch 编写的。然而，我熟悉 Keras。您有什么想法可以将 Pytorch 模型转换为 Keras 模型吗？非常感谢。

回复
- Jason Brownlee 2020年4月29日 12:05 pm #
  
  不客气。
  
  不，暂时没有，抱歉。
  
  回复
Akshay Tiwari 2020年5月10日 12:31 am #

杰森，一如既往，非常有用的教程。谢谢。
我这样假设没错吧：pytorch 对那些寻求对模型完全控制的人（即研究人员）更有用。尽管如此，keras 几乎可以完成我所有的工作。

回复
- Jason Brownlee 2020年5月10日 6:12 am #
  
  不客气。
  
  也许吧。TensorFlow 和 PyTorch 都提供了完全控制，但对于那些对控制感兴趣的人来说，PyTorch 似乎更受欢迎——例如，开发新方法的学者/研究人员，而不是解决问题的工程师。
  
  这只是我的观察，并非真理。
  
  回复
Tuan 2020年5月14日 12:35 am #

感谢这篇精彩的帖子。我只是好奇：MLP 旁边的数字是什么意思？例如 MLP(13) 和 MLP(1)。我看到您在不同的例子中使用了不同的数字。

回复
- Jason Brownlee 2020年5月14日 5:52 am #
  
  模型的输入数量。
  
  回复
Tenchu 2020年5月23日 2:06 am #

非常感谢……精彩的帖子。我学到了很多。

回复
- Jason Brownlee 2020年5月23日 6:25 am #
  
  谢谢！
  
  回复
Hoang 2020年5月26日 12:54 pm #

你好，我在我的端运行了回归代码，但我注意到对于任何一组输入，输出总是相同的。有人已经报告这个错误了吗？

例如：尝试运行
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)

row = [1,30,2.310,0,2,6.5750,80,4.0900,1,296.0,20,500,4.98]
yhat = predict(row, model)
print(‘Predicted: %.3f’ % yhat)

它们总是给出相同的答案……

回复
- Jason Brownlee 2020年5月26日 1:23 pm #
  
  也许请仔细检查您的代码在修改后没有错误。
  
  回复
  - Hoang 2020年5月26日 9:13 pm #
    
    事实上，我从您的网站上直接复制下来，然后运行了它。如果我将预测扩展到
    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('预测值：%.3f' % yhat) # 应该接近 24.00
    
    row2 = [0.17505,0.00,5.960,0,0.4990,5.9660,30.20,3.8473,5,279.0,19.20,393.43,10.13]
    yhat2 = predict(row2, model)
    print('预测值：%.3f' % yhat2) # 应该接近 24.70
    
    row3 = [2.77974,0.00,19.580,0,0.8710,4.9030,97.80,1.3459,5,403.0,14.70,396.90,29.29]
    yhat3 = predict(row3, model)
    print('预测值：%.3f' % yhat3) # 应该接近 11.80
    
    row4 = [0.07503,33.00,2.180,0,0.4720,7.4200,71.90,3.0992,7,222.0,18.40,396.90,6.47]
    yhat4 = predict(row4, model)
    print('预测值：%.3f' % yhat4) # 应该接近 33.40
    
    我得到
    
    339 167
    MSE: 85.617，RMSE: 9.253
    预测值：22.318
    预测值：22.318
    预测值：22.318
    预测值：22.318
    
    您能在您那边重新测试一下，看看是否得到相同的结果吗？我再次使用相同的房价数据集运行了相同的代码。
    
    谢谢！
    
    回复
    - Carlos 2020年5月27日 5:20 am #
      
      SGD 优化器陷入了局部最小值，将其更改为 Adam 优化器效果更好，您会看到对不同输入有显著的响应。
      
      回复
      - Hoang 2020年5月27日 5:39 am #
        
        非常感谢 Carlos！请访问他的博客：http://cgoliver.com/blog
      - Jason Brownlee 2020年5月27日 8:04 am #
        
        很棒的博客！
      - Jason Brownlee 2020年5月27日 8:03 am #
        
        干得好！
    - Jason Brownlee 2020年5月27日 7:49 am #
      
      是的，我看到了同样的问题。
      
      也许模型对训练数据过拟合了，或许可以尝试改变模型架构或学习超参数？
      
      例如，更小的学习率或更少的训练轮数。
      
      回复
      - Carlos 2020年5月27日 9:24 am #
        
        谢谢！
        
        但问题不应该是欠拟合吗？我预计过拟合模型在推理时会有很高的方差，但我们看到的恰恰相反。
        .
      - Jason Brownlee 2020年5月27日 1:29 pm #
        
        它可能是过拟合或欠拟合。两者都可能产生类似的行为。
    - X Yang 2022年6月8日 5:37 am #
      
      我刚刚使用提供的MLP回归代码/数据进行了尝试，结果与Hoang相同：所有4个测试案例都输出相同的值。如果我绘制测试集中所有预测值与实际值，则预测的每个输出值都相同。
      
      我做了以下修改以进行健全性检查：我删除了第2层和第3层，只保留了一个带有 Xavier 均匀权重初始化的线性层，看起来我能够获得 6.5 的 RMSE，并且对 Hoang 的 4 个案例的预测与实际值相当。绘制测试集中的预测值和实际值也得到了相似的曲线。
      
      我的假设是：这仅仅意味着波士顿房价数据几乎是线性的，添加多层会导致数据过拟合？
      其他人能证实这个测试和假设吗？
      
      回复
Hoang Ngo 2020年5月27日 2:02 pm #

顺便说一下 Jason，您这个网站办得真棒，我也是一名软件工程师，刚开始学习机器学习，我非常喜欢您的内容。请继续努力，您正在为所有想进入机器学习领域的开发人员带来福音！

回复
- Jason Brownlee 2020年5月28日 6:07 am #
  
  谢谢！
  
  回复
Bruce D. Sidlinger 2020年6月6日 7:26 am #

>>> # 检查 pytorch 版本
>>> import torch
>>> print(torch.__version__)
1.5.0
>>>
(base) MacBookAir81-2:~ sidlinger$ nano bindemo.py
(base) MacBookAir81-2:~ sidlinger$ python bindemo.py
235 116
准确率：0.931
预测值：0.999 (类别=1)
(base) MacBookAir81-2:~ sidlinger$

回复
- Jason Brownlee 2020年6月6日 8:00 am #
  
  很棒的工作！
  
  回复
Hemanth V 2020年6月21日 11:07 pm #

Jason，

我绘制了回归示例的实际值与预测值，看到了一条常数线。尝试改变学习率、时期数、ReLU、隐藏层数量都没有帮助。其他数据集也是如此，不仅仅是波士顿房价数据集。看来程序中还有其他需要改变的地方，有什么想法吗？

谢谢
赫曼特

回复
- Jason Brownlee 2020年6月22日 6:14 am #
  
  很抱歉听到您遇到麻烦，这可能会有所帮助。
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
  - Hemanth V 2020年6月22日 3:40 pm #
    
    杰森，
    
    代码未修改，只是在 evaluate_model 函数中添加了一个绘图，请看下面。我的 torch 版本是 1.5.1，运行在 anaconda windows 10 上。所有代码都从命令行运行。您能否在您的系统上检查一下，看看预测是否显示为一条常数线。
    
    谢谢
    赫曼特
    
    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)
    pyplot.plot(actuals)
    pyplot.plot(predictions, color='red')
    pyplot.show()
    return mse
    
    回复
    - Jason Brownlee 2020年6月23日 6:15 am #
      
      模型可能不够熟练，需要进一步针对数据集进行调整。
      
      回复
      - Hemanth V 2020年6月23日 11:37 am #
        
        您能建议如何进一步培训吗？
      - Jason Brownlee 2020年6月23日 1:28 pm #
        
        以下是一些改进神经网络的建议
        https://machinelearning.org.cn/improve-deep-learning-performance/
SJ 2020年7月10日 4:07 am #

谢谢你，Jason。
我尝试解决纽约市出租车问题
https://www.kaggle.com/c/new-york-city-taxi-fare-prediction

即使它有分类变量，我也能解决它，但我无法创建一个“准备数据”函数，因为模型需要许多输入。

class TabularModel(nn.Module)
def __init__(self, embedding_size, num_numerical_cols, output_size, layers, p=0.4)

当有分类值和数值时，您能建议如何编写“准备数据”吗？

供您参考的示例代码 – https://stackabuse.com/introduction-to-pytorch-for-classification/

回复
- Jason Brownlee 2020年7月10日 6:07 am #
  
  抱歉，我没有 PyTorch 的数据准备教程，无法立即给出好的建议。
  
  回复
Bunga 2020年7月12日 9:27 am #

嗨
感谢这篇精彩的教程。

无论如何，我复制了mlp多类分类并在spider中运行。然而，它出现了以下错误信息。

runfile(‘E:/Exercises/master_MLPMultiClassIris.py’, wdir=’E:/Exercises’)
100 50
回溯（最近一次调用）

文件“E:\Exercises\master_MLPMultiClassIris.py”，第158行，在
train_model(train_dl, model)

文件“E:\Exercises\master_MLPMultiClassIris.py”，第113行，在 train_model
loss = criterion(yhat, targets)

文件“C:\Anaconda3\lib\site-packages\torch\nn\modules\module.py”，第477行，在 __call__
result = self.forward(*input, **kwargs)

文件“C:\Anaconda3\lib\site-packages\torch\nn\modules\loss.py”，第862行，在 forward
ignore_index=self.ignore_index, reduction=self.reduction)

文件“C:\Anaconda3\lib\site-packages\torch\nn\functional.py”，第1550行，在 cross_entropy
return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)

文件“C:\Anaconda3\lib\site-packages\torch\nn\functional.py”，第1407行，在 nll_loss
return torch._C._nn.nll_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index)

RuntimeError: 期望对象类型为 torch.LongTensor 但找到类型 torch.IntTensor，参数 #2 'target'

回复
- Bunga 2020年7月12日 9:29 am #
  
  抱歉，我不小心按了回车键，消息还没写完。您能建议我如何解决这个问题吗？
  
  回复
- Jason Brownlee 2020年7月12日 11:29 am #
  
  很抱歉听到您遇到麻烦，我有一些建议可能会有所帮助
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
  - Bunga 2020年7月14日 7:48 pm #
    
    非常感谢，杰森……
    
    我真的很抱歉这么快就提出问题。上一个问题现在已经解决了，正在处理同一程序中的另一个问题。
    
    不过我会再检查一遍的……。
    
    回复
    - Jason Brownlee 2020年7月15日 8:15 am #
      
      不客气。
      
      回复
      - Waiming 2020年7月20日 6:47 pm #
        
        Jason，
        
        我遇到了和 Bunga 一样的错误，只针对多类代码。你能帮忙吗？
        
        RuntimeError Traceback (最近一次调用)
        in
        149 model = MLP(4)
        150 # 训练模型
        –> 151 train_model(train_dl, model)
        152 # 评估模型
        153 acc = evaluate_model(test_dl, model)
        
        在 train_model(train_dl, model)
        104 yhat = model(inputs)
        105 # 计算损失
        –> 106 loss = criterion(yhat, targets)
        107 # 归因
        108 loss.backward()
      - Jason Brownlee 2020年7月21日 5:59 am #
        
        很抱歉听到这个消息，这可能会有所帮助。
        https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
    - Waiming 2020年7月20日 5:32 pm #
      
      嗨，Bunga，
      
      我遇到了和你一样的问题。
      你是如何解决第一个问题的？
      
      回复
- Waiming 2020年7月20日 7:04 pm #
  
  Bunga，
  
  您是如何解决运行时错误的，可以和我分享一下吗？我遇到了同样的错误。
  
  回复
  - Edy 2021年3月1日 8:20 pm #
    
    嗨 Bunga 和 Waiming，
    
    问题是 targets 变量必须是 long() 类型，所以请在以下位置修改 targets 变量：
    loss = criterion(yhat, targets) 修改为 loss = criterion(yhat, targets.long())
    
    # 训练模型
    def train_model(train_dl, model)
    # 定义优化
    criterion = CrossEntropyLoss()
    optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
    # 枚举 epoch
    for epoch in range(500)
    # 枚举小批量
    for i, (inputs, targets) in enumerate(train_dl)
    # 清除梯度
    optimizer.zero_grad()
    # 计算模型输出
    yhat = model(inputs)
    # 计算损失并将 targets 转换为 long()
    loss = criterion(yhat, targets.long())
    # 归属
    loss.backward()
    # 更新模型权重
    optimizer.step()
    
    回复
    - Gaurav 2021年8月26日 11:58 pm #
      
      更改数据类型奏效了。谢谢。
      
      回复
L. Wolf 2020年7月24日 3:46 am #

不错的教程，Jason！
请问您有关于 pytorch 的电子书吗？

回复
- Jason Brownlee 2020年7月24日 6:36 am #
  
  目前还没有。
  
  回复
Haider 2020年8月24日 1:00 am #

您好，希望您一切都好。我在尝试运行您提供的 MLP 多分类问题代码时遇到了以下错误：

runfile(‘C:/Users/haide/OneDrive/바탕 화면/temp.py’, wdir=’C:/Users/haide/OneDrive/바탕 화면’)
100 50
回溯（最近一次调用）

文件“C:\Users\haide\OneDrive\바탕 화면\temp.py”，第150行，在
train_model(train_dl, model)

文件“C:\Users\haide\OneDrive\바탕 화면\temp.py”，第105行，在 train_model
loss = criterion(yhat, targets)

文件“C:\Users\haide\anaconda3\lib\site-packages\torch\nn\modules\module.py”，第532行，在 __call__
result = self.forward(*input, **kwargs)

文件“C:\Users\haide\anaconda3\lib\site-packages\torch\nn\modules\loss.py”，第915行，在 forward
return F.cross_entropy(input, target, weight=self.weight,

文件“C:\Users\haide\anaconda3\lib\site-packages\torch\nn\functional.py”，第2021行，在 cross_entropy
return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)

文件“C:\Users\haide\anaconda3\lib\site-packages\torch\nn\functional.py”，第1838行，在 nll_loss
ret = torch._C._nn.nll_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index)

RuntimeError: 期望标量类型为 Long 但找到 Int

请问有什么办法可以解决这个错误吗？

回复
- Jason Brownlee 2020年8月24日 6:28 am #
  
  我很抱歉听到这个消息。
  
  这可能会有一些有用的想法。
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
German Mandrini 2020年8月26日 4:25 am #

很棒的教程，非常清晰。我运行了用于回归的MLP，当我改变“行”的预测变量值时，我总是得到相同的输出。模型是否只预测一个值？
谢谢

回复
- German Mandrini 2020年8月26日 4:27 am #
  
  *同样是“yhat”。词典更改了它。
  
  回复
- Jason Brownlee 2020年8月26日 6:54 am #
  
  有这个可能，在这种情况下，模型可能需要进一步调整。
  
  回复
JC 2020年9月6日 5:41 pm #

嗨，Jason，

我很快就要参加公司组织的深度学习课程了，现在正在提前做一些练习，以便更好地理解感知机等逻辑。在运行您的 MLP 多分类代码时，我遇到了下面显示的错误（只是从我的 IDE 中复制粘贴）。我做错了什么？我得到了 100，50，但准确性信息被发生的错误阻止了。

回溯（最近一次调用）
文件“C:/Users/jcst/PycharmProjects/Deep_Learning_Projects/MLP_for_Multiclass_Classification.py”，第166行，在
train_model(train_dl, model)
文件“C:/Users/jcst/PycharmProjects/Deep_Learning_Projects/MLP_for_Multiclass_Classification.py”，第121行，在 train_model
loss = criterion(yhat, targets)
文件“C:\Users\jcst\PycharmProjects\Deep_Learning_Projects\venv\lib\site-packages\torch\nn\modules\module.py”，第722行，在 _call_impl
result = self.forward(*input, **kwargs)
文件“C:\Users\jcst\PycharmProjects\Deep_Learning_Projects\venv\lib\site-packages\torch\nn\modules\loss.py”，第948行，在 forward
ignore_index=self.ignore_index, reduction=self.reduction)
文件“C:\Users\jcst\PycharmProjects\Deep_Learning_Projects\venv\lib\site-packages\torch\nn\functional.py”，第2422行，在 cross_entropy
return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)
文件“C:\Users\jcst\PycharmProjects\Deep_Learning_Projects\venv\lib\site-packages\torch\nn\functional.py”，第2218行，在 nll_loss
ret = torch._C._nn.nll_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index)
RuntimeError: 期望标量类型为 Long 但找到 Int

回复
- Jason Brownlee 2020年9月7日 8:28 am #
  
  很抱歉听到这个消息，这些建议可能会有所帮助。
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  告诉我进展如何。
  
  回复
- NN 2021年5月8日 2:23 am #
  
  嗨 JC，
  您可能想在 Google Colab 上尝试一下。我在我的 Jupiter notebook 上尝试时收到了相同的消息（“RuntimeError: expected scalar type Long but found Int”），但它在 Google Colab 上运行成功。
  
  回复
Joseph Kim 2020年9月11日 11:35 pm #

我总是感谢您这样有价值的文章！

只是对损失函数的一个小小的评论。
PyTorch 中的交叉熵损失（即 torch.nn.CrossEntropyLoss）将 nn.LogSoftmax() 和 nn.NLLLoss() 结合在一个类中，这意味着在多类分类问题的情况下您不需要 softmax 函数（例如，请参阅‘Oli’、‘god_sp33d’等人的评论）。实际上，许多关于多类分类的 PyTorch 教程都不使用 softmax 函数正是出于这个原因。

回复
- Jason Brownlee 2020年9月12日 6:15 am #
  
  谢谢！
  
  回复
George 2020年11月9日 5:14 pm #

嗨，Jason，
如何在 PyTorch 中对 epoch、激活函数等进行参数调优？
谢谢

回复
- Jason Brownlee 2020年11月10日 6:36 am #
  
  也许可以从一个简单的 for 循环开始，遍历你想要比较的值。
  
  回复
Nur 2020年12月27日 10:58 pm #

这是一个非常详细的解释教程。您的教程总是帮助我学到更多。我遇到了麻烦，我已将其分享到 github，您能审阅一下吗？

https://stackoverflow.com/questions/65459540/indexerror-dimension-out-of-range-expected-to-be-in-range-of-2-1-but-got?noredirect=1#comment115731790_65459540

回复
- Nur 2020年12月28日 12:13 am #
  
  数据
  
  https://stackoverflow.com/questions/65466114/transpose-on-pytorch-indexerror-dimension-out-of-range-expected-to-be-in-ran
  
  回复
- Jason Brownlee 2020年12月28日 5:58 am #
  
  谢谢！
  
  这是我在这里回答的一个常见问题
  https://machinelearning.org.cn/faq/single-faq/can-you-comment-on-my-stackoverflow-question
  
  回复
Robnald Stauffer 2021年1月12日 8:45 am #

Jason
我正在通过在线学术课程学习 PyTorch，发现您的教程（以及您的所有书籍）非常有帮助。请考虑扩展您的图书馆，增加一或多本专注于 PyTorch 的深度学习书籍。您会发现一个非常乐于接受的受众。

回复
- Jason Brownlee 2021年1月12日 10:33 am #
  
  谢谢，很高兴听到这个。
  
  好建议！
  
  回复
Tom 2021年2月3日 10:24 pm #

嗨 Jaso，

请问您能解释一下这行代码吗：for i, (inputs, targets) in enumerate(train_dl)。

此致，
汤姆

回复
- Jason Brownlee 2021年2月4日 6:18 am #
  
  当然，它是一个 for 循环，我们正在枚举“train_dl”，每次迭代我们都会获得一个用于迭代次数的临时变量 i，以及一个元组，其中包含从“train_dl”中检索到的第 i 个项目作为输入和目标。
  
  希望这能有所帮助。
  
  回复
Persian 2021年2月13日 3:38 am #

嗨，Jason，

这真是太棒了。
组织得很好，也很清晰。
对我帮助很大。

非常感谢。

回复
- Jason Brownlee 2021年2月13日 6:10 am #
  
  谢谢！
  
  回复
rosasha 2021年3月21日 5:05 pm #

极其重要的信息

回复
- Jason Brownlee 2021年3月22日 5:28 am #
  
  谢谢。
  
  回复
Peter 2021年4月11日 3:23 am #

谢谢 Jason，您似乎拥有我所寻找的一切教程，而且每个教程都比市面上的其他任何教程好十倍。

一旦找到工作，我一定会捐款，我真的欠您的。

回复
- Jason Brownlee 2021年4月11日 4:55 am #
  
  谢谢！
  
  回复
Mac 2021年5月16日 2:41 am #

杰森，我猜那些想要使用 transformer 等库的人最终应该从 keras 转向 pytorch？

或者是否可以在 keras 中使用 tensorflow transformer 库？

回复
- Jason Brownlee 2021年5月16日 5:35 am #
  
  我相信 TF 库提供了 transformers。我希望将来能写关于这个主题的文章。
  
  回复
Vijaya Yadav 2021年7月19日 3:36 pm #

你好 Jason，你能给我一些 PyTorch 函数，它们将帮助我完成机器学习项目吗？

回复
- Jason Brownlee 2021年7月20日 5:33 am #
  
  也许将来会。
  
  回复
Human 2021年8月17日 2:00 am #

为什么在二分类的 CSVDataset() 中对目标值 (y) 进行了重塑，而在多分类中却没有？

回复
- Adrian Tam 2021年8月17日 8:07 am #
  
  因为模型不同。LabelEncoder 总是输出一个值向量，但如果模型需要一个矩阵，您就需要将一个向量重塑为 Nx1 矩阵。
  
  回复
Human 2021年8月17日 5:32 pm #

如何知道模型是否需要目标值作为矩阵或向量？
这取决于损失函数吗？还是输出层输出？

回复
- Adrian Tam 2021年8月18日 2:29 am #
  
  这取决于模型的设计和所使用的库。最好查阅您所使用函数的文档。但我相信更可能的是矩阵。
  
  回复
Ale 2021年9月27日 4:36 pm #

不错，
我想在 GPU 上实现一个模型，还想在视频中检测人物。
你能帮我怎么做吗？

回复
- Adrian Tam 2021年9月28日 9:35 am #
  
  PyTorch 使用 CUDA 进行 GPU 计算。请参阅此处的示例：https://pytorch.ac.cn/docs/stable/notes/cuda.html
  
  回复
Winry 2021年10月12日 2:19 am #

__init__(self, path) 中的“path”参数是什么？

我不知道你到底在哪里导入数据。我看到了 read_csv 行，但当你只写了“path”时，Python 怎么知道要导入什么数据呢？

我之所以好奇，是因为我正在将这个教程应用到我自己的数据上，当我使用实际文件位置（C:/Users/...）导入数据时，__init__(self, path) 中的参数“path”未被使用，我很困惑它为什么会出现在那里。

我还尝试将实际文件位置放在 __init__(self, path) 中的参数“path”的位置，但它被下划线标记并显示“formal argument expected”。

谢谢！

回复
Winry 2021年10月12日 3:51 am #

哦，哇——没关系，我没有看到脚本底部的路径定义。我习惯了 MATLAB，所有东西都需要按特定顺序定义。

谢谢！

回复
- Adrian Tam 2021年10月13日 7:29 am #
  
  你找到了就好！
  
  回复
menahil javeed 2022年4月26日 6:30 am #

RuntimeError: mat1 和 mat2 形状无法相乘 (32×0 和 34×10)
尊敬的先生，您能告诉我如何解决这个错误吗？谢谢。

回复
Nawel Ben Chaabane 2022年6月7日晚上10:21 #

你好，
感谢这篇精彩的文章。
我不明白 flatten 是如何执行的
# flatten
X = X.view(-1, 4*4*50)
谢谢。
祝好

回复
- James Carmichael 2022年6月8日凌晨4:10 #
  
  嗨，Nawal……谢谢你的反馈！
  
  以下内容希望能有所帮助
  
  https://wandb.ai/ayush-thakur/dl-question-bank/reports/An-Introduction-To-The-PyTorch-View-Function–VmlldzoyMDM0Nzg
  
  回复
Alex 2022年6月21日凌晨4:25 #

不错的教程，但是我的回归模型不知为何返回以下内容

准确率：0.000
单行预测：1.000
MSE：0.000，RMSE：0.000

当要求提供单行预测时。有什么帮助吗？

谢谢！

回复
- James Carmichael 2022年6月21日上午9:43 #
  
  嗨，Alex……以下资源可能有助于澄清
  
  https://stackoverflow.com/questions/58277179/accuracy-is-zero-all-the-time
  
  你可能正在处理回归问题并实现零预测误差。
  
  或者，你可能正在处理分类问题并实现 100% 的准确率。
  
  这很不寻常，原因有很多，包括：
  
  你不小心在训练集上评估了模型性能。
  你的保留数据集（训练集或验证集）太小或不具代表性。
  你的代码中引入了一个错误，它正在做一些与你预期不同的事情。
  你的预测问题很容易或微不足道，可能不需要机器学习。
  最常见的原因是你的保留数据集太小或不代表更广泛的问题。
  
  可以通过以下方法解决：
  
  使用 k 折交叉验证来估计模型性能，而不是训练/测试拆分。
  收集更多数据。
  使用不同的数据拆分进行训练和测试，例如 50/50。
  
  回复
Winry 2022年7月15日凌晨4:12 #

你好，

在调用 prepare_data 方法时，我的回归模型收到此错误。问题出在

train_dl = DataLoader(train, batch_size=32, shuffle=True)

错误是

TypeError: Instance and class checks can only be used with @runtime_checkable protocols

谢谢你

回复
Marilyn Gambone 2023年2月20日凌晨12:34 #

您在本教程中使用的是什么操作系统？Windows 还是 Linux？这是我首先要找的东西。

回复
- James Carmichael 2023年2月20日上午10:02 #
  
  嗨，Marilyn……我们不推广任何特定的操作系统或 Python 环境。您的代码运行有问题吗？我们可以提供建议吗？
  
  回复
Hafiz 2023年9月7日凌晨2:45 #

谢谢你。我想知道如何使用 PyTorch 进行深度学习来检测凹坑？

回复
- James Carmichael 2023年9月7日上午9:15 #
  
  嗨，Hafiz……请详细说明“凹坑检测”的含义，以便我们更好地帮助您。
  
  回复
Liaqat 2024年1月21日上午10:08 #

嗨，Jason，

您有关于联邦学习的博客吗？

回复
- James Carmichael 2024年1月21日上午10:29 #
  
  嗨，Liaqat……我们目前没有关于该主题的内容。以下资源可能会引起您的兴趣
  
  https://www.analyticsvidhya.com/blog/2021/05/federated-learning-a-beginners-guide/
  
  回复
Nik V. 2024年9月26日凌晨6:32 #

你好 Jason，
首先，非常感谢您这篇精彩的帖子！我喜欢您的帖子，对我帮助很大。不过，这是我第一次给您写信。

我有一个关于这行代码的问题：model = MLP(34)。我理解 34 是第一层的输入，对吗？但您是如何确定它应该是 34 的？我不明白这一点。

此外，当我尝试使用其他数字时，我得到了一个错误。例如，使用 MLP(33)，我得到以下错误：“RuntimeError: mat1 and mat2 shapes cannot be multiplied (32×34 and 33×10)”

回复
- James Carmichael 2024年9月26日上午7:24 #
  
  嗨，Nik……不客气！您说得对，model = MLP(34) 中的 34 代表多层感知器 (MLP) 第一层的输入特征数量。这个值直接来源于数据集中特征（列）的数量，不包括目标（标签）列。
  
  ### 为什么是 34？
  在您的代码中，数据集是使用以下行从 CSV 文件加载的
  
  python df = read_csv(path, header=None)
  
  这会加载 CSV 文件中的所有列，包括目标列。然后代码像这样分离特征和目标
  
  python self.X = df.values[:, :-1] # 特征（除最后一列之外的所有列） self.y = df.values[:, -1] # 目标（最后一列）
  
  – self.X 包含除最后一列之外的所有列，这意味着这些是用于模型输入的特征。
  – 在您使用的 ionosphere.csv 数据集中，总共有 35 列（根据数据结构），其中 34 列是输入特征（列），第 35 列是标签（目标）。因此，模型的输入层需要 34 个特征，所以在初始化 MLP 时需要将 34 作为参数传递给它：MLP(34)。
  
  ### 其他输入大小的错误
  当您使用不同的数字，例如 MLP(33) 时，您会收到以下错误
  
  RuntimeError: mat1 and mat2 shapes cannot be multiplied (32×34 and 33×10)
  
  此错误发生是因为网络的输入形状与数据集中特征的数量不匹配。具体来说，输入张量的第一个维度（应该与特征数量匹配）应为 34，但您传递的数字与实际特征数量不匹配。
  
  在 PyTorch 中，矩阵乘法（在正向传播期间发生）要求输入张量的列数与权重矩阵的行数匹配。如果存在不匹配，就像您传递 33 而不是 34 的情况一样，操作将失败，因为维度不一致。
  
  ### 解决方案
  您需要确保 MLP 的输入与数据集中特征的数量匹配。由于您使用的数据集有 34 个输入特征，因此 MLP 类中第一层的输入应为 34
  
  python model = MLP(34)
  
  如果您更改输入特征数量，您还需要相应地调整数据集以匹配新的特征数量。
  
  如果您需要进一步的澄清或有其他问题，请告诉我！
  
  回复
  - Nik V. 2024年10月3日上午8:20 #
    
    非常感谢您，James！我衷心感谢您详细的回答！
    再次万分感谢！
    
    回复
Oliver Ford 2025年1月29日凌晨3:41 #

很棒的教程，除了最新的 numpy，为了避免弃用警告，将最后一行更改为

print('Predicted: %.3f (class=%d)' % (yhat.item(), yhat.round().item()))

回复

导航

PyTorch 教程：如何使用 Python 开发深度学习模型

PyTorch 教程概述

您可以在 Python 中进行深度学习！

1. 如何安装 PyTorch

1.1. 什么是 Torch 和 PyTorch？

1.2. 如何安装 PyTorch

1.3. 如何确认 PyTorch 已安装

2. PyTorch 深度学习模型生命周期

第 1 步：准备数据

第 2 步：定义模型

第 3 步：训练模型

第 4 步：评估模型

第 5 步：进行预测

3. 如何开发 PyTorch 深度学习模型

3.1. 如何开发用于二元分类的 MLP

进一步阅读

书籍

PyTorch项目

API

总结

开始使用PyTorch进行深度学习！

学习如何构建深度学习模型

通过动手练习开启你的深度学习之旅

关于此主题的更多信息

对 PyTorch 教程：如何使用 Python 开发深度学习模型的 130 条回复

发表回复点击此处取消回复。

导航

PyTorch 教程概述

您可以在 Python 中进行深度学习！

1. 如何安装 PyTorch

1.1. 什么是 Torch 和 PyTorch？

1.2. 如何安装 PyTorch

1.3. 如何确认 PyTorch 已安装

2. PyTorch 深度学习模型生命周期

第 1 步：准备数据

第 2 步：定义模型

第 3 步：训练模型

第 4 步：评估模型

第 5 步：进行预测

3. 如何开发 PyTorch 深度学习模型

3.1. 如何开发用于二元分类的 MLP

进一步阅读

书籍

PyTorch项目

API

总结

开始使用PyTorch进行深度学习！

学习如何构建深度学习模型

通过动手练习开启你的深度学习之旅

关于此主题的更多信息

对 PyTorch 教程：如何使用 Python 开发深度学习模型 的 130 条回复

发表回复 点击此处取消回复。

对 PyTorch 教程：如何使用 Python 开发深度学习模型的 130 条回复

发表回复点击此处取消回复。