使用 PyTorch C++ 前端

PyTorch C++ 前端是 PyTorch 机器学习框架的纯 C++ 接口。 虽然 PyTorch 的主要接口是 Python，但 Python API 位于大量 C++ 代码库之上，提供基础数据结构和功能，例如张量和自动微分。 C++ 前端公开了一个纯 C++11 API，它使用机器学习训练和推理所需的工具扩展了这个底层 C++ 代码库。 这包括用于神经网络建模的内置通用组件集合； 使用自定义模块扩展此集合的 API； 流行的优化算法库，例如随机梯度下降； 一个带有 API 的并行数据加载器来定义和加载数据集； 序列化例程等等。

本教程将引导您完成使用 C++ 前端训练模型的端到端示例。 具体来说，我们将训练 DCGAN（一种生成模型）来生成 MNIST 数字图像。 虽然从概念上讲是一个简单的示例，但它应该足以让您快速了解 PyTorch C++ 前端，并满足您对训练更复杂模型的兴趣。 我们将从一些激励性的词开始，说明您为什么想要使用 C++ 前端，然后直接深入定义和训练我们的模型。

• 观看 this lightning talk from CppCon 2018 以快速（幽默）地介绍 C++ 前端。

• 这篇笔记 全面概述了 C++ 前端的组件和设计理念。

• PyTorch C++ 生态系统的文档可从 https://pytorch.org/cppdocs 获得。在那里您可以找到高级描述以及 API 级文档。

一、为什么要使用PyTorch 的 C++ 前端

---

在我们开始激动人心的 GAN 和 MNIST 数字之旅之前，让我们退后一步，讨论一下为什么要使用 C++ 前端而不是 Python 前端。我们（PyTorch 团队）创建了 C++ 前端，以便在无法使用 Python 或根本不适合这项工作的工具的环境中进行研究。此类环境的示例包括：

• 低延迟系统：您可能希望在具有高每秒帧数和低延迟要求的纯 C++ 游戏引擎中进行强化学习研究。使用纯 C++ 库比 Python 库更适合这种环境。由于 Python 解释器的缓慢，Python 可能根本不易于处理。
• 高度多线程环境：由于全局解释器锁 (GIL)，Python 一次不能运行多个系统线程。多处理是一种替代方案，但不具有可扩展性，并且具有明显的缺点。 C++ 没有这样的约束，线程易于使用和创建。需要大量并行化的模型，如深度神经进化中使用的模型，可以从中受益。
• 现有 C++ 代码库：您可能是现有 C++ 应用程序的所有者，从后端服务器中的网页服务到在照片编辑软件中渲染 3D 图形，您可能是现有 C++ 应用程序的所有者，并且希望将机器学习方法集成到您的系统中。 C++ 前端允许您继续使用 C++，免去在 Python 和 C++ 之间来回绑定的麻烦，同时保留传统 PyTorch (Python) 体验的大部分灵活性和直观性。

C++ 前端不打算与 Python 前端竞争。它旨在补充它。我们知道研究人员和工程师都喜欢 PyTorch，因为它的简单性、灵活性和直观的 API。我们的目标是确保您可以在所有可能的环境中利用这些核心设计原则，包括上述环境。如果这些场景之一很好地描述了您的用例，或者如果您只是感兴趣或好奇，请跟随我们在以下段落中详细探索 C++ 前端。

• C++ 前端试图提供一个尽可能接近 Python 前端的 API。 如果您对 Python 前端有经验并且曾经问过自己“我如何用 C++ 前端做 X？”，请按照您在 Python 中的方式编写代码，并且通常相同的函数和方法将在 C++ 中可用 就像在 Python 中一样（记住用双冒号替换点）。

二、编写基本应用程序

---

让我们从编写一个最小的 C++ 应用程序开始，以验证我们在设置和构建环境方面是否处于同一页面上。首先，您需要获取 LibTorch 发行版的副本——我们现成的 zip 存档，其中包含使用 C++ 前端所需的所有相关头文件、库和 CMake 构建文件。LibTorch 发行版可在适用于 Linux、MacOS 和 Windows 的 PyTorch 网站上下载。本教程的其余部分将假设一个基本的 Ubuntu Linux 环境，但是您也可以在 MacOS 或 Windows 上自由学习。

• 关于安装 PyTorch 的 C++ 发行版的说明更详细地描述了以下步骤。

• 在 Windows 上，调试和发布版本与 ABI 不兼容。如果您打算在调试模式下构建您的项目，请尝试使用 LibTorch 的调试版本。另外，请确保在 cmake --build 中指定正确的配置。

第一步是通过从 PyTorch 网站检索到的链接在本地下载 LibTorch 发行版。 对于 vanilla Ubuntu Linux 环境，这意味着运行：

# If you need e.g. CUDA 9.0 support, please replace "cpu" with "cu90" in the URL below.
wget https://download.pytorch.org/libtorch/nightly/cpu/libtorch-shared-with-deps-latest.zip
unzip libtorch-shared-with-deps-latest.zip

接下来，让我们编写一个名为 dcgan.cpp 的小 C++ 文件，其中包含 torch/torch.h，现在只需打印出一个三乘三的单位矩阵：

#include <torch/torch.h>
#include <iostream>

int main()
{
    torch::Tensor tensor = torch::eye(3);
    std::cout << tensor << std::endl;
}

为了构建这个微型应用程序以及我们稍后完善的训练脚本，我们将使用这个 CMakeLists.txt 文件：

cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
project(dcgan)

find_package(Torch REQUIRED)

add_executable(dcgan dcgan.cpp)
target_link_libraries(dcgan "${TORCH_LIBRARIES}")
set_property(TARGET dcgan PROPERTY CXX_STANDARD 14)

• 虽然 CMake 是 LibTorch 的推荐构建系统，但它并不是硬性要求。您还可以使用 Visual Studio 项目文件、QMake、普通 Makefile 或任何其他您觉得合适的构建环境。但是，我们不为此提供开箱即用的支持。

记下上述 CMake 文件中的第 4 行：find_package(Torch REQUIRED)。这会指示 CMake 查找 LibTorch 库的构建配置。为了让 CMake 知道在哪里可以找到这些文件，我们必须在调用 cmake 时设置 CMAKE_PREFIX_PATH。在我们这样做之前，让我们就 dcgan 应用程序的以下目录结构达成一致：

dcgan/
    CMakeLists.txt
    dcgan.cpp

此外，我将解压后的 LibTorch 发行版的路径称为 /path/to/libtorch。请注意，这必须是绝对路径。特别是将 CMAKE_PREFIX_PATH 设置为 …/…/libtorch 之类的内容会以意想不到的方式中断。而是写 $PWD/…/…/libtorch 来获取对应的绝对路径。现在我们已准备好构建我们的应用程序：

root@fa350df05ecf:/home# mkdir build
root@fa350df05ecf:/home# cd build
root@fa350df05ecf:/home/build# cmake -DCMAKE_PREFIX_PATH=/path/to/libtorch ..
-- The C compiler identification is GNU 5.4.0
-- The CXX compiler identification is GNU 5.4.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Looking for pthread.h
-- Looking for pthread.h - found
-- Looking for pthread_create
-- Looking for pthread_create - not found
-- Looking for pthread_create in pthreads
-- Looking for pthread_create in pthreads - not found
-- Looking for pthread_create in pthread
-- Looking for pthread_create in pthread - found
-- Found Threads: TRUE
-- Found torch: /path/to/libtorch/lib/libtorch.so
-- Configuring done
-- Generating done
-- Build files have been written to: /home/build
root@fa350df05ecf:/home/build# cmake --build . --config Release
Scanning dependencies of target dcgan
[ 50%] Building CXX object CMakeFiles/dcgan.dir/dcgan.cpp.o
[100%] Linking CXX executable dcgan
[100%] Built target dcgan

上面，我们首先在我们的 dcgan 目录中创建了一个 build 文件夹，进入这个文件夹，运行 cmake 命令来生成必要的 build (Make) 文件，最后通过运行 cmake --build 成功编译项目。 --config 发布。 我们现在已经准备好执行我们的最小二进制文件并完成有关基本项目配置的这一部分：

root@fa350df05ecf:/home/build# ./dcgan
1  0  0
0  1  0
0  0  1
[ Variable[CPUFloatType]{3,3} ]

看起来像一个单位矩阵！

三、定义神经网络模型

---

现在我们已经配置了基本环境，我们可以深入了解本教程中更有趣的部分。首先我们将讨论如何在 C++ 前端定义模块并与模块交互。我们将从基本的小规模示例模块开始，然后使用 C++ 前端提供的大量内置模块库来实现一个成熟的 GAN。

模块 API 基础

与 Python 接口一致，基于 C++ 前端的神经网络由称为模块的可重用构建块组成。有一个基模块类，所有其他模块都从它派生而来。在 Python 中，这个类是 torch.nn.Module，而在 C++ 中，它是 torch::nn::Module。除了实现模块封装的算法的 forward() 方法外，模块通常包含三种子对象中的任何一种：参数、缓冲区和子模块。

参数和缓冲区以张量的形式存储状态。参数记录梯度，而缓冲区不记录。参数通常是神经网络的可训练权重。缓冲区的示例包括批量标准化的均值和方差。为了重用特定的逻辑和状态块，PyTorch API 允许嵌套模块。嵌套模块称为子模块。

参数、缓冲区和子模块必须显式注册。注册后，parameters() 或 buffers() 等方法可用于检索整个（嵌套）模块层次结构中所有参数的容器。类似地，像 to(…) 这样的方法，例如to(torch::kCUDA) 将所有参数和缓冲区从 CPU 移动到 CUDA 内存，在整个模块层次结构上工作。

3.1 定义模块和注册参数

为了将这些词写入代码，让我们考虑用 Python 接口编写的这个简单模块：

import torch

class Net(torch.nn.Module):
    def __init__(self, N, M):
        super(Net, self).__init__()
        self.W = torch.nn.Parameter(torch.randn(N, M))
        self.b = torch.nn.Parameter(torch.randn(M))

    def forward(self, input):
        return torch.addmm(self.b, input, self.W)

在C++中，应该这样编写:

#include <torch/torch.h>

struct Net : torch::nn::Module
{
    Net(int64_t N, int64_t M)
    {
        W = register_parameter("W", torch::randn({N, M}));
        b = register_parameter("b", torch::randn(M));
    }
    torch::Tensor forward(torch::Tensor input)
    {
        return torch::addmm(b, input, W);
    }
    torch::Tensor W, b;
};

就像在 Python 中一样，我们定义了一个名为 Net 的类（为了简单起见，这里使用结构而不是类）并从模块基类派生它。在构造函数中，我们使用 torch::randn 创建张量，就像我们在 Python 中使用 torch.randn 一样。一个有趣的区别是我们如何注册参数。在 Python 中，我们使用 torch.nn.Parameter 类包装张量，而在 C++ 中，我们必须通过 register_parameter 方法来传递张量。这样做的原因是 Python API 可以检测到某个属性的类型为 torch.nn.Parameter 并自动注册此类张量。在 C++ 中，反射非常有限，因此提供了一种更传统（也更不神奇）的方法。

3.2 注册子模块并遍历模块层次结构

以同样的方式我们可以注册参数，我们也可以注册子模块。在 Python 中，子模块在被分配为模块的属性时会被自动检测和注册：

class Net(torch.nn.Module):
    def __init__(self, N, M):
        super(Net, self).__init__()
        # Registered as a submodule behind the scenes
        self.linear = torch.nn.Linear(N, M)
        self.another_bias = torch.nn.Parameter(torch.rand(M))

    def forward(self, input):
        return self.linear(input) + self.another_bias

例如，这允许使用 parameters() 方法递归访问我们模块层次结构中的所有参数：

>>> net = Net(4, 5)
>>> print(list(net.parameters()))
[Parameter containing:
tensor([0.0808, 0.8613, 0.2017, 0.5206, 0.5353], requires_grad=True), Parameter containing:
tensor([[-0.3740, -0.0976, -0.4786, -0.4928],
        [-0.1434,  0.4713,  0.1735, -0.3293],
        [-0.3467, -0.3858,  0.1980,  0.1986],
        [-0.1975,  0.4278, -0.1831, -0.2709],
        [ 0.3730,  0.4307,  0.3236, -0.0629]], requires_grad=True), Parameter containing:
tensor([ 0.2038,  0.4638, -0.2023,  0.1230, -0.0516], requires_grad=True)]

要在 C++ 中注册子模块，请使用恰当命名的 register_module() 方法来注册像 torch::nn::Linear 这样的模块：

struct Net : torch::nn::Module
{
    Net(int64_t N, int64_t M) : linear(register_module("linear", torch::nn::Linear(N, M)))
    {
        another_bias = register_parameter("b", torch::randn(M));
    }
    torch::Tensor forward(torch::Tensor input)
    {
        return linear(input) + another_bias;
    }

    torch::nn::Linear linear;
    torch::Tensor another_bias;
};

• 您可以在此处的torch::nn 命名空间的文档中找到可用内置模块的完整列表，例如 torch::nn::Linear、torch::nn::Dropout 或 torch::nn::Conv2d。

上述代码的一个微妙之处在于为什么子模块是在构造函数的初始化列表中创建的，而参数是在构造函数体内创建的。这有一个很好的理由，我们将在下面关于 C++ 前端所有权模型的部分中讨论这一点。然而最终结果是我们可以像在 Python 中一样递归访问模块树的参数。调用 parameters() 返回一个std::vector<torch::Tensor>，我们可以迭代它：

int main()
{
    Net net(4, 5);
    for(const auto& p : net.parameters())
    {
        std::cout << p << std::endl;
    }
}

上述代码将会打印：

root@fa350df05ecf:/home/build# ./dcgan
0.0345
1.4456
-0.6313
-0.3585
-0.4008
[ Variable[CPUFloatType]{5} ]
-0.1647  0.2891  0.0527 -0.0354
0.3084  0.2025  0.0343  0.1824
-0.4630 -0.2862  0.2500 -0.0420
0.3679 -0.1482 -0.0460  0.1967
0.2132 -0.1992  0.4257  0.0739
[ Variable[CPUFloatType]{5,4} ]
0.01 *
3.6861
-10.1166
-45.0333
7.9983
-20.0705
[ Variable[CPUFloatType]{5} ]

就像在 Python 中一样带有三个参数。为了同时查看这些参数的名称，C++ API 提供了一个 named_parameters() 方法，该方法返回一个 OrderedDict，就像在 Python 中一样：

Net net(4, 5);
for(const auto& pair : net.named_parameters())
{
    std::cout << pair.key() << ": " << pair.value() << std::endl;
}

再次执行可以看到如下输出:

root@fa350df05ecf:/home/build# make && ./dcgan                                                                                                                                            11:13:48
Scanning dependencies of target dcgan
[ 50%] Building CXX object CMakeFiles/dcgan.dir/dcgan.cpp.o
[100%] Linking CXX executable dcgan
[100%] Built target dcgan
b: -0.1863
-0.8611
-0.1228
1.3269
0.9858
[ Variable[CPUFloatType]{5} ]
linear.weight:  0.0339  0.2484  0.2035 -0.2103
-0.0715 -0.2975 -0.4350 -0.1878
-0.3616  0.1050 -0.4982  0.0335
-0.1605  0.4963  0.4099 -0.2883
0.1818 -0.3447 -0.1501 -0.0215
[ Variable[CPUFloatType]{5,4} ]
linear.bias: -0.0250
0.0408
0.3756
-0.2149
-0.3636
[ Variable[CPUFloatType]{5} ]

• torch::nn::Module 的文档包含对模块层次结构进行操作的完整方法列表。

3.3 以转发模式运行网络

要在 C++ 中执行网络，我们只需调用我们自己定义的 forward() 方法：

int main()
{
    Net net(4, 5);
    std::cout << net.forward(torch::ones({2, 4})) << std::endl;
}

它打印出类似的东西：

root@fa350df05ecf:/home/build# ./dcgan
0.8559  1.1572  2.1069 -0.1247  0.8060
0.8559  1.1572  2.1069 -0.1247  0.8060
[ Variable[CPUFloatType]{2,5} ]

3.4 模块所有权

至此，我们知道如何在 C++ 中定义模块，注册参数，注册子模块，通过 parameters() 等方法遍历模块层次结构，最后运行模块的 forward() 方法。虽然在 C++ API 中有更多的方法、类和主题可供阅读，推荐您阅读说明文档。当我们在一秒钟内实现 DCGAN 模型和端到端训练管道时，我们还将涉及更多概念。在我们这样做之前，让我简要介绍一下 C++ 前端为 torch::nn::Module 的子类提供的所有权模型。

在本次讨论中，所有权模型指的是模块的存储和传递方式——它决定了谁拥有特定模块实例。在 Python 中，对象总是动态分配（在堆上）并具有引用语义。这很容易使用且易于理解。事实上，在 Python 中，您可以在很大程度上忘记对象的位置以及它们如何被引用，而专注于完成工作。

C++ 作为一种低级语言，在这个领域提供了更多的选择。这会增加复杂性并严重影响 C++ 前端的设计和人体工程学。特别是，对于 C++ 前端的模块，我们可以选择使用值语义或引用语义。第一种情况是最简单的，并在迄今为止的示例中显示：模块对象在堆栈上分配，当传递给函数时，可以复制、移动（使用 std::move）或通过引用或指针获取：

struct Net : torch::nn::Module { };

void a(Net net) { }
void b(Net& net) { }
void c(Net* net) { }

int main()
{
    Net net;
    a(net);
    a(std::move(net));
    b(net);
    c(&net);
}

对于第二种情况——引用语义——我们可以使用 std::shared_ptr。 引用语义的优点是，就像在 Python 中一样，它减少了思考模块必须如何传递给函数以及参数必须如何声明（假设您在任何地方都使用 shared_ptr）的认知开销。

struct Net : torch::nn::Module {};

void a(std::shared_ptr<Net> net) { }

int main()
{
    auto net = std::make_shared<Net>();
    a(net);
}

根据我们的经验，来自动态语言的研究人员更喜欢引用语义而不是值语义，即使后者对 C++ 更“原生”。同样重要的是要注意，torch::nn::Module 的设计，为了接近 Python API 的人体工程学，依赖于共享所有权。例如，以我们之前（这里简写）的 Net 定义为例：

struct Net : torch::nn::Module
{
    Net(int64_t N, int64_t M) : linear(register_module("linear", torch::nn::Linear(N, M)))
    {
        ;
    }

    torch::nn::Linear linear;
};

为了使用 linear 子模块，我们希望将它直接存储在我们的类中。但是我们也希望模块基类知道并访问这个子模块。为此它必须存储对此子模块的引用。在这一点上，我们已经达到了共享所有权的需要。torch::nn::Module 类和具体的 Net 类都需要对子模块的引用。出于这个原因，基类将模块存储为 shared_ptrs，因此具体类也必须如此。

可是等等！在上面的代码中没有看到任何提及 shared_ptr 的内容！这是为什么？好吧，因为 std::shared_ptr<MyModule> 需要输入很多东西。为了让我们的研究人员保持高效，我们想出了一个精心设计的方案来隐藏 shared_ptr 的提及——一个通常保留给值语义的好处——同时保留引用语义。要了解这是如何工作的，我们可以看一下核心库中 torch::nn::Linear 模块的简化定义（完整定义在这里）：

struct LinearImpl : torch::nn::Module
{
    LinearImpl(int64_t in, int64_t out);

    Tensor forward(const Tensor& input);

    Tensor weight, bias;
};

TORCH_MODULE(Linear);

简而言之：模块不叫Linear，而是LinearImpl。然后，宏 TORCH_MODULE 定义了实际的 Linear 类。这个“生成的”类实际上是 std::shared_ptr<LinearImpl> 的包装器。它是一个包装器而不是一个简单的 typedef，因此构造函数仍然可以按预期工作，即您仍然可以编写 torch::nn::Linear(3, 4) 而不是 std::make_shared<LinearImpl>(3, 4)。我们将宏创建的类称为模块持有者。与（共享）指针一样，您可以使用箭头运算符（如 model->forward(…)）访问底层对象。最终结果是一个与 Python API 非常相似的所有权模型。引用语义成为默认，但没有 std::shared_ptr 或 std::make_shared 的额外类型。对于我们的网络，使用模块持有人 API 如下所示：

struct NetImpl : torch::nn::Module {};
TORCH_MODULE(Net);

void a(Net net) { }

int main()
{
    Net net;
    a(net);
}

这里有一个微妙的问题值得一提。默认构造的 std::shared_ptr 为“空”，即包含空指针。什么是默认构造的 Linear 或 Net？嗯，这是一个棘手的选择。我们可以说它应该是一个空的 (null) std::shared_ptr<LinearImpl>。但是，请记住 Linear(3, 4) 与 std::make_shared<LinearImpl>(3, 4) 相同。这意味着如果我们决定Linear linear；应该是一个空指针，那么就无法构造一个不接受任何构造函数参数或默认所有参数的模块。出于这个原因，在当前的 API 中，默认构造的模块持有者（如 Linear()）调用底层模块的默认构造函数 (LinearImpl())。如果底层模块没有默认构造函数，则会出现编译器错误。要代替构造空持有者，您可以将 nullptr 传递给持有者的构造函数。

实际上，这意味着您可以使用子模块，如前面所示，其中模块在初始化列表中注册和构造：

struct Net : torch::nn::Module
{
    Net(int64_t N, int64_t M) : linear(register_module("linear", torch::nn::Linear(N, M)))
    {
        ;
    }
    torch::nn::Linear linear;
};

或者您可以首先使用空指针构造持有者，然后在构造函数中分配给它（Pythonistas 更熟悉）：

struct Net : torch::nn::Module
{
    Net(int64_t N, int64_t M)
    {
        linear = register_module("linear", torch::nn::Linear(N, M));
    }
    torch::nn::Linear linear{nullptr}; // construct an empty holder
};

总而言之，您应该使用哪种所有权模型——哪种语义？ C++ 前端的 API 最好地支持模块持有者提供的所有权模型。这种机制的唯一缺点是在模块声明下方多出了一行样板。也就是说，最简单的模型仍然是 C++ 模块介绍中显示的值语义模型。对于小而简单的脚本，您也可能会侥幸逃脱。但是您迟早会发现，由于技术原因，它并不总是受支持。例如，序列化 API（torch::save 和 torch::load）仅支持模块持有者（或普通的 shared_ptr）。因此，模块持有者 API 是使用 C++ 前端定义模块的推荐方式，我们将在本教程中使用此 API。

四、定义 DCGAN 模块

---

我们现在有了必要的背景知识和介绍来定义我们想要在这篇文章中解决的机器学习任务的模块。总结一下：我们的任务是从 MNIST数据集 生成数字图像。 我们想使用生成对抗网络（GAN）来解决这个任务。 特别是，我们将使用 DCGAN 架构——同类中第一个也是最简单的架构之一，但足以完成这项任务。

• 您可以在此存储库中找到本教程中提供的完整源代码。

什么是 GAN aGAN？

GAN 由两个不同的神经网络模型组成：生成器和鉴别器。生成器从噪声分布中接收样本，其目的是将每个噪声样本转换为类似于目标分布的图像——在我们的例子中是 MNIST 数据集。鉴别器依次接收来自 MNIST 数据集的真实图像或来自生成器的假图像。它被要求发出一个概率来判断特定图像的真实性（接近于 1）或虚假（接近于 0）。来自鉴别器的关于生成器生成的图像的真实性的反馈用于训练生成器。使用关于鉴别器真实性的反馈来优化鉴别器。理论上，生成器和判别器之间的微妙平衡使它们协同改进，导致生成器生成与目标分布无法区分的图像，欺骗判别器（那时）出色的眼睛，为真假图像发出 0.5 的概率.对我们来说，最终结果是一台接收噪声作为输入并生成数字的逼真图像作为其输出的机器。

4.1 DCGAN 生成器模块

我们首先定义生成器模块，它由一系列转置的 2D 卷积、批量归一化和 ReLU 激活单元组成。我们在我们自己定义的模块的 forward() 方法中显式地在模块之间传递输入（以 functional 方式）：

struct DCGANGeneratorImpl : nn::Module
{
    DCGANGeneratorImpl(int kNoiseSize) : conv1(nn::ConvTranspose2dOptions(kNoiseSize, 256, 4).bias(false)),
                                         batch_norm1(256),
                                         conv2(nn::ConvTranspose2dOptions(256, 128, 3).stride(2).padding(1).bias(false)),
                                         batch_norm2(128),
                                         conv3(nn::ConvTranspose2dOptions(128, 64, 4).stride(2).padding(1).bias(false)),
                                         batch_norm3(64),
                                         conv4(nn::ConvTranspose2dOptions(64, 1, 4).stride(2).padding(1).bias(false))
    {
        // register_module() is needed if we want to use the parameters() method later on
        register_module("conv1", conv1);
        register_module("conv2", conv2);
        register_module("conv3", conv3);
        register_module("conv4", conv4);
        register_module("batch_norm1", batch_norm1);
        register_module("batch_norm2", batch_norm2);
        register_module("batch_norm3", batch_norm3);
    }

    torch::Tensor forward(torch::Tensor x)
    {
        x = torch::relu(batch_norm1(conv1(x)));
        x = torch::relu(batch_norm2(conv2(x)));
        x = torch::relu(batch_norm3(conv3(x)));
        x = torch::tanh(conv4(x));
        return x;
    }

    nn::ConvTranspose2d conv1, conv2, conv3, conv4;
    nn::BatchNorm2d batch_norm1, batch_norm2, batch_norm3;
};

TORCH_MODULE(DCGANGenerator);
DCGANGenerator generator(kNoiseSize);

我们现在可以调用 DCGANGgenerator 上的 forward() 将噪声样本映射到图像。

选择的特定模块，如 nn::ConvTranspose2d 和 nn::BatchNorm2d，遵循前面概述的结构。kNoiseSize 常数确定输入噪声向量的大小，并设置为 100。当然，超参数是通过梯度下降学到的。

• No grad students were harmed in the discovery of hyperparameters. They were fed Soylent regularly.
• 关于将选项传递给 C++ 前端中的 Conv2d 等内置模块的方式的简要说明：每个模块都有一些必需的选项，例如 BatchNorm2d 的特征数量。如果您只需要配置所需的选项，您可以将它们直接传递给模块的构造函数，例如 BatchNorm2d(128) 或 Dropout(0.5) 或 Conv2d(8, 4, 2)（用于输入通道数、输出通道数和 kernel大小）。但是，如果您需要修改其他通常默认的选项，例如 Conv2d 的偏差，则需要构造并传递选项对象。C++ 前端中的每个模块都有一个关联的选项结构，称为 ModuleOptions，其中 Module 是模块的名称，就像 Linear 的 LinearOptions。这就是我们为上面的 Conv2d 模块所做的。

4.2 DCGAN 鉴别器模块

鉴别器同样是一系列卷积、批量归一化和激活。然而，卷积现在是常规的而不是转置的，我们使用 alpha 值为 0.2 的 leaky ReLU 而不是 vanilla ReLU。 此外，最终激活变成了一个 Sigmoid，它将值压缩到 0 到 1 之间的范围内。然后我们可以将这些压缩值解释为鉴别器分配给真实图像的概率。

为了构建鉴别器，我们将尝试不同的东西：Sequential 模块。 就像在 Python 中一样，这里的 PyTorch 提供了两个用于模型定义的 API：一个是函数式的，其中输入通过连续的函数传递（例如生成器模块示例），以及一个更面向对象的 API，其中我们构建了一个包含整个模型作为子模块的 Sequential 模块 . 使用 Sequential，鉴别器看起来像：

nn::Sequential discriminator(
    // Layer 1
    nn::Conv2d(
        nn::Conv2dOptions(1, 64, 4).stride(2).padding(1).bias(false)),
    nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
    // Layer 2
    nn::Conv2d(
        nn::Conv2dOptions(64, 128, 4).stride(2).padding(1).bias(false)),
    nn::BatchNorm2d(128),
    nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
    // Layer 3
    nn::Conv2d(
        nn::Conv2dOptions(128, 256, 4).stride(2).padding(1).bias(false)),
    nn::BatchNorm2d(256),
    nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
    // Layer 4
    nn::Conv2d(
        nn::Conv2dOptions(256, 1, 3).stride(1).padding(0).bias(false)),
    nn::Sigmoid());

• Sequential 模块只是执行功能组合。 第一个子模块的输出成为第二个子模块的输入，第三个子模块的输出成为第四个子模块的输入，依此类推。

五、加载数据

---

现在我们已经定义了生成器和鉴别器模型，我们需要一些数据来训练这些模型。C++ 前端，就像 Python 前端一样，带有一个强大的并行数据加载器。该数据加载器可以从数据集（您可以自己定义）中读取批量数据并提供许多可选配置。

• 虽然 Python 数据加载器使用多进程，但 C++ 数据加载器是真正的多线程并且不会启动任何新进程。

数据加载器是 C++ 前端数据 api 的一部分，包含在 torch::data:: 命名空间中。这个 API 由几个不同的组件组成：

• 数据加载器类，
• 用于定义数据集的 API，
• 用于定义转换的 API，可应用于数据集，
• 用于定义采样器的 API，它生成索引数据集的索引，
• 已存在数据集、转换器和采样器的库。

对于本教程，我们可以使用 C++ 前端附带的 MNIST 数据集。 让我们为此实例化一个 torch::data::datasets::MNIST，并应用两个转换：首先，我们对图像进行标准化，使它们在 -1 到 +1 的范围内（从原始范围 0 到 1） . 其次，我们应用 Stack 排序规则，它采用一批张量并将它们沿第一维堆叠成一个张量：

auto dataset = torch::data::datasets::MNIST("./mnist")
    .map(torch::data::transforms::Normalize<>(0.5, 0.5))
    .map(torch::data::transforms::Stack<>());

请注意，MNIST 数据集应位于相对于执行训练二进制文件的位置的 ./mnist 目录中。 您可以使用此脚本下载 MNIST 数据集。

接下来，我们创建一个数据加载器并将此数据集传递给它。 为了创建一个新的数据加载器，我们使用 torch::data::make_data_loader，它返回一个正确类型的 std::unique_ptr（这取决于数据集的类型、采样器的类型和其他一些实现细节）：

auto data_loader = torch::data::make_data_loader(std::move(dataset));

数据加载器确实有很多选项。您可以在此处查看详细设置。例如，为了加快数据加载，我们可以增加 worker 的数量。默认数字为零，这意味着将使用主线程。如果我们将 worker 设置为 2，将产生两个并发加载数据的线程。我们还应该将批大小从其默认值 1 增加到更合理的值，例如 64（kBatchSize 的值）。让我们创建一个 DataLoaderOptions 对象并设置适当的属性：

auto data_loader = torch::data::make_data_loader(
    std::move(dataset),
    torch::data::DataLoaderOptions().batch_size(kBatchSize).workers(2));

我们现在可以编写一个循环来加载批量数据，我们现在只将其打印到控制台：

for(torch::data::Example<>& batch : *data_loader)
{
    std::cout << "Batch size: " << batch.data.size(0) << " | Labels: ";
    for(int64_t i = 0; i < batch.data.size(0); ++i)
    {
        std::cout << batch.target[i].item<int64_t>() << " ";
    }
    std::cout << std::endl;
}

在这种情况下，数据加载器返回的类型是 torch::data::Example。这种类型是一个简单的结构体，具有数据的数据字段和标签的目标字段。因为我们之前应用了 Stack 排序规则，数据加载器只返回一个这样的例子。如果我们没有应用排序规则，数据加载器将生成 std::vector<torch::data::Example<>> 代替，批处理中每个示例一个元素。

如果您重新构建并运行此代码，您应该会看到如下内容：

root@fa350df05ecf:/home/build# make
Scanning dependencies of target dcgan
[ 50%] Building CXX object CMakeFiles/dcgan.dir/dcgan.cpp.o
[100%] Linking CXX executable dcgan
[100%] Built target dcgan
root@fa350df05ecf:/home/build# make
[100%] Built target dcgan
root@fa350df05ecf:/home/build# ./dcgan
Batch size: 64 | Labels: 5 2 6 7 2 1 6 7 0 1 6 2 3 6 9 1 8 4 0 6 5 3 3 0 4 6 6 6 4 0 8 6 0 6 9 2 4 0 2 8 6 3 3 2 9 2 0 1 4 2 3 4 8 2 9 9 3 5 8 0 0 7 9 9
Batch size: 64 | Labels: 2 2 4 7 1 2 8 8 6 9 0 2 2 9 3 6 1 3 8 0 4 4 8 8 8 9 2 6 4 7 1 5 0 9 7 5 4 3 5 4 1 2 8 0 7 1 9 6 1 6 5 3 4 4 1 2 3 2 3 5 0 1 6 2
Batch size: 64 | Labels: 4 5 4 2 1 4 8 3 8 3 6 1 5 4 3 6 2 2 5 1 3 1 5 0 8 2 1 5 3 2 4 4 5 9 7 2 8 9 2 0 6 7 4 3 8 3 5 8 8 3 0 5 8 0 8 7 8 5 5 6 1 7 8 0
Batch size: 64 | Labels: 3 3 7 1 4 1 6 1 0 3 6 4 0 2 5 4 0 4 2 8 1 9 6 5 1 6 3 2 8 9 2 3 8 7 4 5 9 6 0 8 3 0 0 6 4 8 2 5 4 1 8 3 7 8 0 0 8 9 6 7 2 1 4 7
Batch size: 64 | Labels: 3 0 5 5 9 8 3 9 8 9 5 9 5 0 4 1 2 7 7 2 0 0 5 4 8 7 7 6 1 0 7 9 3 0 6 3 2 6 2 7 6 3 3 4 0 5 8 8 9 1 9 2 1 9 4 4 9 2 4 6 2 9 4 0
Batch size: 64 | Labels: 9 6 7 5 3 5 9 0 8 6 6 7 8 2 1 9 8 8 1 1 8 2 0 7 1 4 1 6 7 5 1 7 7 4 0 3 2 9 0 6 6 3 4 4 8 1 2 8 6 9 2 0 3 1 2 8 5 6 4 8 5 8 6 2
Batch size: 64 | Labels: 9 3 0 3 6 5 1 8 6 0 1 9 9 1 6 1 7 7 4 4 4 7 8 8 6 7 8 2 6 0 4 6 8 2 5 3 9 8 4 0 9 9 3 7 0 5 8 2 4 5 6 2 8 2 5 3 7 1 9 1 8 2 2 7
Batch size: 64 | Labels: 9 1 9 2 7 2 6 0 8 6 8 7 7 4 8 6 1 1 6 8 5 7 9 1 3 2 0 5 1 7 3 1 6 1 0 8 6 0 8 1 0 5 4 9 3 8 5 8 4 8 0 1 2 6 2 4 2 7 7 3 7 4 5 3
Batch size: 64 | Labels: 8 8 3 1 8 6 4 2 9 5 8 0 2 8 6 6 7 0 9 8 3 8 7 1 6 6 2 7 7 4 5 5 2 1 7 9 5 4 9 1 0 3 1 9 3 9 8 8 5 3 7 5 3 6 8 9 4 2 0 1 2 5 4 7
Batch size: 64 | Labels: 9 2 7 0 8 4 4 2 7 5 0 0 6 2 0 5 9 5 9 8 8 9 3 5 7 5 4 7 3 0 5 7 6 5 7 1 6 2 8 7 6 3 2 6 5 6 1 2 7 7 0 0 5 9 0 0 9 1 7 8 3 2 9 4
Batch size: 64 | Labels: 7 6 5 7 7 5 2 2 4 9 9 4 8 7 4 8 9 4 5 7 1 2 6 9 8 5 1 2 3 6 7 8 1 1 3 9 8 7 9 5 0 8 5 1 8 7 2 6 5 1 2 0 9 7 4 0 9 0 4 6 0 0 8 6
...

这意味着我们能够成功地从 MNIST 数据集中加载数据。

六、编写训练循环

---

现在让我们完成示例的算法部分，并在生成器和鉴别器之间实现微妙的舞蹈。首先，我们将创建两个优化器，一个用于生成器，一个用于鉴别器。我们使用的优化器实现了 Adam 算法：

torch::optim::Adam generator_optimizer(
    generator->parameters(), torch::optim::AdamOptions(2e-4).beta1(0.5));
torch::optim::Adam discriminator_optimizer(
    discriminator->parameters(), torch::optim::AdamOptions(5e-4).beta1(0.5));

• 在撰写本文时，PyTorch C++ 前端实现了 Adagrad、Adam、LBFGS、RMSprop 和 SGD 等优化器。此文档有相关优化器的最新的列表。

接下来，我们需要更新我们的训练循环。我们将添加一个外循环来在每个 epoch 中耗尽数据加载器，然后编写 GAN 训练代码：

for(int64_t epoch = 1; epoch <= kNumberOfEpochs; ++epoch)
{
    int64_t batch_index = 0;
    for(torch::data::Example<>& batch : *data_loader)
    {
        // Train discriminator with real images.
        discriminator->zero_grad();
        torch::Tensor real_images = batch.data;
        torch::Tensor real_labels = torch::empty(batch.data.size(0)).uniform_(0.8, 1.0);
        torch::Tensor real_output = discriminator->forward(real_images);
        torch::Tensor d_loss_real = torch::binary_cross_entropy(real_output, real_labels);
        d_loss_real.backward();

        // Train discriminator with fake images.
        torch::Tensor noise = torch::randn({batch.data.size(0), kNoiseSize, 1, 1});
        torch::Tensor fake_images = generator->forward(noise);
        torch::Tensor fake_labels = torch::zeros(batch.data.size(0));
        torch::Tensor fake_output = discriminator->forward(fake_images.detach());
        torch::Tensor d_loss_fake = torch::binary_cross_entropy(fake_output, fake_labels);
        d_loss_fake.backward();

        torch::Tensor d_loss = d_loss_real + d_loss_fake;
        discriminator_optimizer.step();

        // Train generator.
        generator->zero_grad();
        fake_labels.fill_(1);
        fake_output = discriminator->forward(fake_images);
        torch::Tensor g_loss = torch::binary_cross_entropy(fake_output, fake_labels);
        g_loss.backward();
        generator_optimizer.step();

        std::printf(
            "\r[%2ld/%2ld][%3ld/%3ld] D_loss: %.4f | G_loss: %.4f",
            epoch,
            kNumberOfEpochs,
            ++batch_index,
            batches_per_epoch,
            d_loss.item<float>(),
            g_loss.item<float>());
    }
}

上面，我们首先在真实图像上评估鉴别器，它应该为其给出更高的概率。为此，我们使用 torch::empty(batch.data.size(0)).uniform_(0.8, 1.0) 作为目标概率。

• 我们选择均匀分布在 0.8 和 1.0 之间的随机值，而不是到处都是 1.0，以使鉴别器训练更加稳健。 这个技巧称为标签平滑。

在评估鉴别器之前，我们将其参数的梯度归零。计算损失后，我们通过调用 d_loss.backward() 来计算新的梯度，通过网络反向传播它。我们对假图像重复这个做法。我们没有使用数据集中的图像，而是让生成器通过向其提供一批随机噪声来为此创建假图像。然后我们将这些假图像转发给鉴别器。这一次，我们希望鉴别器发出低概率，理想情况下全为零。一旦我们计算了一批真实图像和一批假图像的判别器损失，我们就可以将判别器的优化器推进一步以更新其参数。

为了训练生成器，我们再次首先将其梯度归零，然后在假图像上重新评估鉴别器。然而，这一次我们希望鉴别器分配非常接近于 1 的概率，这表明生成器可以生成图像来欺骗鉴别器认为它们实际上是真实的（来自数据集）。为此，我们用所有 1 填充 fake_labels 张量。我们最终执行生成器的优化器来更新它的参数。

我们现在应该准备好在 CPU 上训练我们的模型了。我们还没有任何代码来捕获状态或示例输出，但我们稍后会添加它。现在，让我们观察我们的模型正在做某事——稍后我们将根据生成的图像验证这是否有意义。重新构建和运行应该打印如下内容：

root@3c0711f20896:/home/build# make && ./dcgan
Scanning dependencies of target dcgan
[ 50%] Building CXX object CMakeFiles/dcgan.dir/dcgan.cpp.o
[100%] Linking CXX executable dcgan
[100%] Built target dcga
[ 1/10][100/938] D_loss: 0.6876 | G_loss: 4.1304
[ 1/10][200/938] D_loss: 0.3776 | G_loss: 4.3101
[ 1/10][300/938] D_loss: 0.3652 | G_loss: 4.6626
[ 1/10][400/938] D_loss: 0.8057 | G_loss: 2.2795
[ 1/10][500/938] D_loss: 0.3531 | G_loss: 4.4452
[ 1/10][600/938] D_loss: 0.3501 | G_loss: 5.0811
[ 1/10][700/938] D_loss: 0.3581 | G_loss: 4.5623
[ 1/10][800/938] D_loss: 0.6423 | G_loss: 1.7385
[ 1/10][900/938] D_loss: 0.3592 | G_loss: 4.7333
[ 2/10][100/938] D_loss: 0.4660 | G_loss: 2.5242
[ 2/10][200/938] D_loss: 0.6364 | G_loss: 2.0886
[ 2/10][300/938] D_loss: 0.3717 | G_loss: 3.8103
[ 2/10][400/938] D_loss: 1.0201 | G_loss: 1.3544
[ 2/10][500/938] D_loss: 0.4522 | G_loss: 2.6545
...

七、转移到 GPU

---

虽然我们当前的脚本可以在 CPU 上正常运行，但我们都知道卷积在 GPU 上要快得多。让我们快速讨论如何将我们的训练转移到 GPU 上。为此，我们需要做两件事：将 GPU 设备规范传递给我们自己分配的张量，并通过 C++ 前端中所有张量和模块具有的 to() 方法将任何其他张量显式复制到 GPU 上。实现这两者的最简单方法是在我们的训练脚本的顶层创建一个 torch::Device 实例，然后将该设备传递给像 torch::zeros 这样的张量工厂函数以及 to() 方法。我们可以从一个 CPU 设备开始：

// Place this somewhere at the top of your training script.
torch::Device device(torch::kCPU);

新的张量分配，如：

torch::Tensor fake_labels = torch::zeros(batch.data.size(0));

应该更新以将 device 作为最后一个参数：

torch::Tensor fake_labels = torch::zeros(batch.data.size(0), device);

对于创建不在我们手中的张量，例如来自 MNIST 数据集的张量，我们必须插入显式的 to() 调用。这意味着

torch::Tensor real_images = batch.data;

变为

torch::Tensor real_images = batch.data.to(device);

并且我们的模型参数应该移动到正确的设备：

generator->to(device);
discriminator->to(device);

• 如果张量已经存在于提供给 to() 的设备上，则调用是空操作。 没有额外的副本。

在这一点上，我们刚刚使之前的 CPU 驻留代码更加明确。但是，现在将设备更改为 CUDA 设备也很容易：

torch::Device device(torch::kCUDA)

现在所有张量都将存在于 GPU 上，为所有操作调用快速 CUDA 内核，而我们无需更改任何下游代码。如果我们想指定一个特定的设备索引，它可以作为第二个参数传递给设备构造函数。如果我们希望不同的张量存在于不同的设备上，我们可以传递单独的设备实例（例如一个在 CUDA 设备 0 上，另一个在 CUDA 设备 1 上）。我们甚至可以动态地进行此配置，这通常有助于使我们的训练脚本更具可移植性：

torch::Device device = torch::kCPU;
if (torch::cuda::is_available())
{
    std::cout << "CUDA is available! Training on GPU." << std::endl;
    device = torch::kCUDA;
}

甚至

torch::Device device(torch::cuda::is_available() ? torch::kCUDA : torch::kCPU);

八、设置 Checkpointing 和恢复 Training 状态

---

我们应该对训练脚本增加的一个操作是定期保存模型参数的状态、优化器的状态以及一些生成的图像样本。如果我们的计算机在训练过程中崩溃，前两个将允许我们恢复训练状态。对于长期持续的训练任务，这绝对是必不可少的。幸运的是，C++ 前端提供了一个 API 来序列化和反序列化模型和优化器状态，以及单个张量。

其核心 API 是 torch::save(thing,filename) 和 torch::load(thing,filename)，其中 thing 可以是 torch::nn::Module 子类或优化器实例，例如在我们的训练脚本中的 Adam 对象。接下来更新我们的训练循环，以特定时间间隔检查模型和优化器状态：

if(batch_index % kCheckpointEvery == 0)
{
    // Checkpoint the model and optimizer state.
    torch::save(generator, "generator-checkpoint.pt");
    torch::save(generator_optimizer, "generator-optimizer-checkpoint.pt");
    torch::save(discriminator, "discriminator-checkpoint.pt");
    torch::save(discriminator_optimizer, "discriminator-optimizer-checkpoint.pt");
    // Sample the generator and save the images.
    torch::Tensor samples = generator->forward(torch::randn({8, kNoiseSize, 1, 1}, device));
    torch::save((samples + 1.0) / 2.0, torch::str("dcgan-sample-", checkpoint_counter, ".pt"));
    std::cout << "\n-> checkpoint " << ++checkpoint_counter << '\n';
}

其中 kCheckpointEvery 是一个整数，设置为 100 以每 100 个批次设置 Checkpoint，而 checkpoint_counter 是每次我们创建检查点时都会碰撞的计数器。

要恢复训练状态，您可以在创建所有模型和优化器之后，在训练循环之前添加这样的行：

torch::optim::Adam generator_optimizer(
    generator->parameters(), torch::optim::AdamOptions(2e-4).beta1(0.5));
torch::optim::Adam discriminator_optimizer(
    discriminator->parameters(), torch::optim::AdamOptions(2e-4).beta1(0.5));

if(kRestoreFromCheckpoint)
{
    torch::load(generator, "generator-checkpoint.pt");
    torch::load(generator_optimizer, "generator-optimizer-checkpoint.pt");
    torch::load(discriminator, "discriminator-checkpoint.pt");
    torch::load(
        discriminator_optimizer, "discriminator-optimizer-checkpoint.pt");
}

int64_t checkpoint_counter = 0;
for(int64_t epoch = 1; epoch <= kNumberOfEpochs; ++epoch) {...}
int64_t batch_index = 0;
for(torch::data::Example<>& batch : *data_loader) {...}

九、检查生成的图像

---

我们的训练脚本现已完成。我们准备好在 CPU 或 GPU 上训练我们的 GAN。为了检查我们的训练过程的中间输出，为此我们添加了代码以定期将图像样本保存到“dcgan-sample-xxx.pt”文件中，我们可以编写一个小的 Python 脚本来加载张量并使用 matplotlib 显示它们：

from __future__ import print_function
from __future__ import unicode_literals

import argparse

import matplotlib.pyplot as plt
import torch

parser = argparse.ArgumentParser()
parser.add_argument("-i", "--sample-file", required=True)
parser.add_argument("-o", "--out-file", default="out.png")
parser.add_argument("-d", "--dimension", type=int, default=3)
options = parser.parse_args()

module = torch.jit.load(options.sample_file)
images = list(module.parameters())[0]

for index in range(options.dimension * options.dimension):
    image = images[index].detach().cpu().reshape(28, 28).mul(255).to(torch.uint8)
    array = image.numpy()
    axis = plt.subplot(options.dimension, options.dimension, 1 + index)
    plt.imshow(array, cmap="gray")
    axis.get_xaxis().set_visible(False)
    axis.get_yaxis().set_visible(False)

plt.savefig(options.out_file)
print("Saved ", options.out_file)

现在让我们训练我们的模型大约 30 个时期：

root@3c0711f20896:/home/build# make && ./dcgan
10:17:57
Scanning dependencies of target dcgan
[ 50%] Building CXX object CMakeFiles/dcgan.dir/dcgan.cpp.o
[100%] Linking CXX executable dcgan
[100%] Built target dcgan
CUDA is available! Training on GPU.
[ 1/30][200/938] D_loss: 0.4953 | G_loss: 4.0195
-> checkpoint 1
[ 1/30][400/938] D_loss: 0.3610 | G_loss: 4.8148
-> checkpoint 2
[ 1/30][600/938] D_loss: 0.4072 | G_loss: 4.36760
-> checkpoint 3
[ 1/30][800/938] D_loss: 0.4444 | G_loss: 4.0250
-> checkpoint 4
[ 2/30][200/938] D_loss: 0.3761 | G_loss: 3.8790
-> checkpoint 5
[ 2/30][400/938] D_loss: 0.3977 | G_loss: 3.3315
...
-> checkpoint 120
  [30/30][938/938] D_loss: 0.3610 | G_loss: 3.8084

并在图中显示图像：

root@3c0711f20896:/home/build# python display.py -i dcgan-sample-100.pt
Saved out.png

应该是这样的：

数字！ 万岁！ 现在以此为基础，你能改进模型让数字看起来更好吗？

总结

---

本教程希望为您提供 PyTorch C++ 前端的易懂摘要。像 PyTorch 这样的机器学习库必然具有非常广泛和广泛的 API。因此，有许多概念我们没有时间或空间在这里讨论。但是，我鼓励您尝试 API，并在遇到问题时查阅我们的文档，尤其是库 API 部分。另外，请记住，只要我们有可能，您就可以期望 C++ 前端遵循 Python 前端的设计和语义，因此您可以利用这一事实来提高学习率。

• 您可以在此存储库中找到本教程中提供的完整源代码。

与往常一样，如果您遇到任何问题或有疑问，可以使用我们的论坛或 GitHub 问题与我们联系。