PyTorch的系统学习与深度学习模型的开发应用

如何安装 PyTorch
1. 什么是 Torch 和 PyTorch？
2. 如何安装 PyTorch
3. 如何确认 PyTorch 已安装
PyTorch 深度学习模型生命周期
1. 第 1 步：准备数据
2. 第 2 步：定义模型
3. 第 3 步：训练模型
4. 第 4 步：评估模型
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 ”，以“ Py ”前缀表示先前的 Torch 库，表明新项目的 Python 重点。

PyTorch API 简单而灵活，使其成为学者和研究人员开发新的深度学习模型和应用程序的最爱。广泛的使用导致了针对特定应用（例如文本、计算机视觉和音频数据）的许多扩展，并且可能出现可以直接使用的预训练模型。因此，它可能是学者使用的最受欢迎的图书馆。PyTorch 的灵活性是以易用性为代价的，尤其是对于初学者而言。选择使用 PyTorch 而不是 Keras 会放弃一些易用性、稍微陡峭的学习曲线、更多的代码以实现更大的灵活性，或许还放弃了更有活力的学术社区。

1.2. 如何安装 PyTorch

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

如果您没有安装Python，可以使用Anaconda 安装它。

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

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

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

sudo pip install torch

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

强烈建议安装 torchvision，可以按如下方式安装：

sudo pip install torchvision

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

PyTorch 安装指南

现在无需设置 GPU。

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

1.3. 如何确认 PyTorch 已安装

安装 PyTorch 后，确认该库已成功安装并且您可以开始使用它非常重要。

不要跳过这一步。

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

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

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

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

然后输入：

python versions.py

然后您应该看到如下输出：

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

加载后，PyTorch 会提供DataLoader 类，以便在模型训练和评估期间导航数据集实例。

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

random_split () 函数可用于将数据集拆分为训练集和测试集。分割后，可以将数据集中的行选择提供给 DataLoader，以及批量大小以及是否应在每个时期对数据进行混洗。

例如，我们可以通过传入数据集中选定的行样本来定义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)

一旦定义，就可以枚举DataLoader，每次迭代都会生成一批样本。

...
# train the model
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

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

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

...
xavier_uniform_(self.layer.weight)

第 3 步：训练模型

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

常见的损失函数包括以下几种：

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

尽管也可以使用该算法的其他版本，例如Adam。

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

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

首先，需要一个循环来确定训练时期的数量。然后，小批量需要一个内循环来进行随机梯度下降。

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

第 4 步：评估模型

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

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

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

第五步：做出预测

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

使用“ relu ”激活和“ He Uniform ”权重初始化是一个很好的做法

下面列出了完整的示例。

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

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