自定义 C ++和 CUDA 扩展

原文： https://pytorch.org/tutorials/advanced/cpp_extension.html

作者： Peter Goldsborough

PyTorch 提供了与神经网络，任意张量代数，数据整理和其他目的有关的大量操作。 但是，您仍然可能会发现自己需要更多的自定义操作。 例如，您可能想使用论文中发现的新颖的激活功能，或者实现您在研究过程中开发的操作。

在 PyTorch 中集成这样的自定义操作的最简单方法是通过扩展此处概述的Function和Module在 Python 中编写它。 这为您提供了自动区分的全部功能(使您不必编写派生函数）以及 Python 的通常表达能力。 但是，有时您的操作可以用 C ++更好地实现。 例如，您的代码可能需要确实快速，因为在模型中它经常被调用，或者即使很少调用也很昂贵。 另一个合理的原因是它依赖于其他 C 或 C ++库或与之交互。 为了解决这种情况，PyTorch 提供了一种非常简单的方式来编写自定义 C ++扩展。

C ++扩展是我们开发的一种机制，允许用户(您）创建源外定义的 PyTorch 运算符，即，即与 PyTorch 后端分开。 该方法与与不同于本机 PyTorch 操作的实现方式。 C ++扩展旨在为您节省大量与将操作与 PyTorch 后端集成在一起相关的样板，同时为基于 PyTorch 的项目提供高度的灵活性。 但是，一旦您将操作定义为 C ++扩展，将其转换为本地 PyTorch 函数在很大程度上取决于代码组织，如果您决定在上游进行操作，则可以解决此问题。

动机与榜样

本说明的其余部分将逐步介绍编写和使用 C ++(和 CUDA）扩展的实际示例。 如果您被追捕，或者在一天结束前仍未完成该操作，就会有人开除您，则可以跳过本节，直接进入下一部分的实施细节。

假设您想出了一种新型的循环装置，发现与现有技术相比，它具有更好的性能。 该循环单元类似于 LSTM，但不同之处在于它缺少遗忘门，并使用指数线性单元(ELU）作为其内部激活功能。 由于此设备永远不会忘记，因此我们将其称为 LLTM 或长期内存单元。

LLTM 与普通 LSTM 的两种区别非常重要，以至于我们无法为自己的目的配置 PyTorch 的LSTMCell，因此我们必须创建一个自定义单元。 这样做的第一个也是最简单的方法，并且在所有情况下都可能是一个好的第一步，是使用 Python 在纯 PyTorch 中实现我们所需的功能。 为此，我们需要继承torch.nn.Module，并实现 LLTM 的前向传递。 看起来像这样：

  1. class LLTM(torch.nn.Module):
  2.     def __init__(self, input_features, state_size):
  3.         super(LLTM, self).__init__()
  4.         self.input_features = input_features
  5.         self.state_size = state_size
  6.         # 3 * state_size for input gate, output gate and candidate cell gate.
  7.         # input_features + state_size because we will multiply with [input, h].
  8.         self.weights = torch.nn.Parameter(
  9.             torch.empty(3 * state_size, input_features + state_size))
  10.         self.bias = torch.nn.Parameter(torch.empty(3 * state_size))
  11.         self.reset_parameters()
  13.     def reset_parameters(self):
  14.         stdv = 1.0 / math.sqrt(self.state_size)
  15.         for weight in self.parameters():
  16.             weight.data.uniform_(-stdv, +stdv)
  18.     def forward(self, input, state):
  19.         old_h, old_cell = state
  20.         X = torch.cat([old_h, input], dim=1)
  22.         # Compute the input, output and candidate cell gates with one MM.
  23.         gate_weights = F.linear(X, self.weights, self.bias)
  24.         # Split the combined gate weight matrix into its components.
  25.         gates = gate_weights.chunk(3, dim=1)
  27.         input_gate = torch.sigmoid(gates[0])
  28.         output_gate = torch.sigmoid(gates[1])
  29.         # Here we use an ELU instead of the usual tanh.
  30.         candidate_cell = F.elu(gates[2])
  32.         # Compute the new cell state.
  33.         new_cell = old_cell + candidate_cell * input_gate
  34.         # Compute the new hidden state and output.
  35.         new_h = torch.tanh(new_cell) * output_gate
  37.         return new_h, new_cell

然后我们可以按预期使用：

  1. import torch
  3. X = torch.randn(batch_size, input_features)
  4. h = torch.randn(batch_size, state_size)
  5. C = torch.randn(batch_size, state_size)
  7. rnn = LLTM(input_features, state_size)
  9. new_h, new_C = rnn(X, (h, C))

自然，如果可能的话，您应该使用这种方法扩展 PyTorch。 由于 PyTorch 对 CPU 和 GPU 的操作进行了高度优化的实现，并由 NVIDIA cuDNN ， Intel MKL 或 NNPACK 等库提供支持 ，上面的 PyTorch 代码通常会足够快。 但是，我们还可以看到为什么在某些情况下还有进一步改进性能的空间。 最明显的原因是 PyTorch 不了解您要实现的算法。 它仅知道您用于组成算法的单个操作。 因此，PyTorch 必须一个接一个地执行您的操作。 由于对操作的实现(或内核）的每个单独调用(可能涉及 CUDA 内核的启动）都具有一定的开销，因此该开销在许多函数调用中可能变得很重要。 此外，运行我们的代码的 Python 解释器本身可能会使我们的程序变慢。

因此，一种确定的加速方法是用 C ++(或 CUDA）和熔断特定操作组来重写零件。 融合意味着将许多功能的实现组合到一个功能中，这可以从更少的内核启动以及我们可以通过提高全局数据流可见性而执行的其他优化中获利。

让我们看看如何使用 C ++扩展来实现 LLTM 的融合版本。 首先，我们使用 ATen 库以普通的 C ++语言编写代码，该库为 PyTorch 的许多后端提供了强大的支持，并了解它使我们轻松转换 Python 代码的方式。 然后，我们将模型的某些部分移至 CUDA 内核，以从 GPU 提供的大量并行处理中受益，从而进一步加快处理速度。

编写 C ++扩展

C ++扩展有两种形式：它们可以使用setuptools提前构建，也可以通过torch.utils.cpp_extension.load()适时构建。 我们将从第一种方法开始，稍后再讨论后者。

使用setuptools构建

为了“提前”，我们通过编写一个setup.py脚本来构建 C ++扩展，该脚本使用 setuptools 编译我们的 C ++代码。 对于 LLTM，它看起来像这样简单：

  1. from setuptools import setup, Extension
  2. from torch.utils import cpp_extension
  4. setup(name='lltm_cpp',
  5.       ext_modules=[cpp_extension.CppExtension('lltm_cpp', ['lltm.cpp'])],
  6.       cmdclass={'build_ext': cpp_extension.BuildExtension})

在此代码中，CppExtension是setuptools.Extension的便利包装，它传递正确的包含路径并将扩展语言设置为 C ++。 等效的原始setuptools代码将是：

  1. Extension(
  2.    name='lltm_cpp',
  3.    sources=['lltm.cpp'],
  4.    include_dirs=cpp_extension.include_paths(),
  5.    language='c++')

BuildExtension执行许多必需的配置步骤，并检查和管理混合 C ++ / CUDA 扩展的混合编译。 这就是我们现在真正需要了解的有关构建 C ++扩展的全部信息！ 现在让我们看一下lltm.cpp中 C ++扩展的实现。

编写 C ++ Op

让我们开始以 C ++实现 LLTM！ 我们需要向后传递的一项功能是 S 形导数。 这是一小段代码，用于讨论编写 C ++扩展时可供我们使用的总体环境：

  1. #include <torch/extension.h>
  3. #include <iostream>
  5. torch::Tensor d_sigmoid(torch::Tensor z) {
  6.   auto s = torch::sigmoid(z);
  7.   return (1 - s) * s;
  8. }

&lt;torch/extension.h&gt;是一站式标头，其中包含编写 C ++扩展所需的所有必需的 PyTorch 位。 这包括：

  • ATen 库，这是我们用于张量计算的主要 API，
  • pybind11 ，这是我们为 C ++代码创建 Python 绑定的方式，
  • 标头，用于管理 ATen 与 pybind11 之间的交互的详细信息。

d_sigmoid()的实现显示了如何使用 ATen API。 PyTorch 的张量和变量接口是从 ATen 库自动生成的，因此我们可以将 Python 实现 1：1 或多或少地转换为 C ++。 我们用于所有计算的主要数据类型将为torch::Tensor。 可以在中检查其完整的 API。 还要注意，我们可以包括&lt;iostream&gt;或任何其他 C 或 C ++头文件 –我们拥有 C ++ 11 的全部功能。

前进通行证

接下来，我们可以将整个正向传递到 C ++：

  1. #include <vector>
  3. std::vector<at::Tensor> lltm_forward(
  4.     torch::Tensor input,
  5.     torch::Tensor weights,
  6.     torch::Tensor bias,
  7.     torch::Tensor old_h,
  8.     torch::Tensor old_cell) {
  9.   auto X = torch::cat({old_h, input}, /*dim=*/1);
  11.   auto gate_weights = torch::addmm(bias, X, weights.transpose(0, 1));
  12.   auto gates = gate_weights.chunk(3, /*dim=*/1);
  14.   auto input_gate = torch::sigmoid(gates[0]);
  15.   auto output_gate = torch::sigmoid(gates[1]);
  16.   auto candidate_cell = torch::elu(gates[2], /*alpha=*/1.0);
  18.   auto new_cell = old_cell + candidate_cell * input_gate;
  19.   auto new_h = torch::tanh(new_cell) * output_gate;
  21.   return {new_h,
  22.           new_cell,
  23.           input_gate,
  24.           output_gate,
  25.           candidate_cell,
  26.           X,
  27.           gate_weights};
  28. }

后退通行证

C ++扩展 API 当前不提供为我们自动生成向后函数的方法。 因此，我们还必须实现 LLTM 的后向传递，它计算相对于前向传递的每个输入的损耗导数。 最终，我们将前进和后退功能放入torch.autograd.Function中，以创建一个不错的 Python 绑定。 向后函数的功能稍微复杂一些，因此我们将不深入研究代码(如果您有兴趣，请阅读 Alex Graves 的论文，以获取有关此方面的更多信息）：

  1. // tanh'(z) = 1 - tanh^2(z)
  2. torch::Tensor d_tanh(torch::Tensor z) {
  3.   return 1 - z.tanh().pow(2);
  4. }
  6. // elu'(z) = relu'(z) + { alpha * exp(z) if (alpha * (exp(z) - 1)) < 0, else 0}
  7. torch::Tensor d_elu(torch::Tensor z, torch::Scalar alpha = 1.0) {
  8.   auto e = z.exp();
  9.   auto mask = (alpha * (e - 1)) < 0;
  10.   return (z > 0).type_as(z) + mask.type_as(z) * (alpha * e);
  11. }
  13. std::vector<torch::Tensor> lltm_backward(
  14.     torch::Tensor grad_h,
  15.     torch::Tensor grad_cell,
  16.     torch::Tensor new_cell,
  17.     torch::Tensor input_gate,
  18.     torch::Tensor output_gate,
  19.     torch::Tensor candidate_cell,
  20.     torch::Tensor X,
  21.     torch::Tensor gate_weights,
  22.     torch::Tensor weights) {
  23.   auto d_output_gate = torch::tanh(new_cell) * grad_h;
  24.   auto d_tanh_new_cell = output_gate * grad_h;
  25.   auto d_new_cell = d_tanh(new_cell) * d_tanh_new_cell + grad_cell;
  27.   auto d_old_cell = d_new_cell;
  28.   auto d_candidate_cell = input_gate * d_new_cell;
  29.   auto d_input_gate = candidate_cell * d_new_cell;
  31.   auto gates = gate_weights.chunk(3, /*dim=*/1);
  32.   d_input_gate *= d_sigmoid(gates[0]);
  33.   d_output_gate *= d_sigmoid(gates[1]);
  34.   d_candidate_cell *= d_elu(gates[2]);
  36.   auto d_gates =
  37.       torch::cat({d_input_gate, d_output_gate, d_candidate_cell}, /*dim=*/1);
  39.   auto d_weights = d_gates.t().mm(X);
  40.   auto d_bias = d_gates.sum(/*dim=*/0, /*keepdim=*/true);
  42.   auto d_X = d_gates.mm(weights);
  43.   const auto state_size = grad_h.size(1);
  44.   auto d_old_h = d_X.slice(/*dim=*/1, 0, state_size);
  45.   auto d_input = d_X.slice(/*dim=*/1, state_size);
  47.   return {d_old_h, d_input, d_weights, d_bias, d_old_cell};
  48. }

绑定到 Python

一旦用 C ++和 ATen 编写了操作，就可以使用 pybind11 以非常简单的方式将 C ++函数或类绑定到 Python 中。 您对 PyTorch C ++扩展部分的疑问或问题将在 pybind11 文档中得到解决。

对于我们的扩展，必要的绑定代码仅跨越四行：

  1. PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
  2.   m.def("forward", &lltm_forward, "LLTM forward");
  3.   m.def("backward", &lltm_backward, "LLTM backward");
  4. }

这里要注意的一点是宏TORCH_EXTENSION_NAME。 torch扩展程序构建会将其定义为您在setup.py脚本中为扩展程序指定的名称。 在这种情况下，TORCH_EXTENSION_NAME的值为“ lltm”。 这是为了避免必须在两个位置(构建脚本和 C ++代码）维护扩展名，因为两者之间的不匹配会导致令人讨厌且难以跟踪的问题。

使用扩展

现在，我们准备将扩展名导入 PyTorch 中。 此时，目录结构可能如下所示：

  1. pytorch/
  2.   lltm-extension/
  3.     lltm.cpp
  4.     setup.py

现在，运行python setup.py install来构建和安装扩展程序。 看起来应该像这样：

  1. running install
  2. running bdist_egg
  3. running egg_info
  4. creating lltm_cpp.egg-info
  5. writing lltm_cpp.egg-info/PKG-INFO
  6. writing dependency_links to lltm_cpp.egg-info/dependency_links.txt
  7. writing top-level names to lltm_cpp.egg-info/top_level.txt
  8. writing manifest file 'lltm_cpp.egg-info/SOURCES.txt'
  9. reading manifest file 'lltm_cpp.egg-info/SOURCES.txt'
  10. writing manifest file 'lltm_cpp.egg-info/SOURCES.txt'
  11. installing library code to build/bdist.linux-x86_64/egg
  12. running install_lib
  13. running build_ext
  14. building 'lltm_cpp' extension
  15. creating build
  16. creating build/temp.linux-x86_64-3.7
  17. gcc -pthread -B ~/local/miniconda/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I~/local/miniconda/lib/python3.7/site-packages/torch/include -I~/local/miniconda/lib/python3.7/site-packages/torch/include/torch/csrc/api/include -I~/local/miniconda/lib/python3.7/site-packages/torch/include/TH -I~/local/miniconda/lib/python3.7/site-packages/torch/include/THC -I~/local/miniconda/include/python3.7m -c lltm.cpp -o build/temp.linux-x86_64-3.7/lltm.o -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=lltm_cpp -D_GLIBCXX_USE_CXX11_ABI=1 -std=c++11
  18. cc1plus: warning: command line option '-Wstrict-prototypes' is valid for C/ObjC but not for C++
  19. creating build/lib.linux-x86_64-3.7
  20. g++ -pthread -shared -B ~/local/miniconda/compiler_compat -L~/local/miniconda/lib -Wl,-rpath=~/local/miniconda/lib -Wl,--no-as-needed -Wl,--sysroot=/ build/temp.linux-x86_64-3.7/lltm.o -o build/lib.linux-x86_64-3.7/lltm_cpp.cpython-37m-x86_64-linux-gnu.so
  21. creating build/bdist.linux-x86_64
  22. creating build/bdist.linux-x86_64/egg
  23. copying build/lib.linux-x86_64-3.7/lltm_cpp.cpython-37m-x86_64-linux-gnu.so -> build/bdist.linux-x86_64/egg
  24. creating stub loader for lltm_cpp.cpython-37m-x86_64-linux-gnu.so
  25. byte-compiling build/bdist.linux-x86_64/egg/lltm_cpp.py to lltm_cpp.cpython-37.pyc
  26. creating build/bdist.linux-x86_64/egg/EGG-INFO
  27. copying lltm_cpp.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
  28. copying lltm_cpp.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
  29. copying lltm_cpp.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
  30. copying lltm_cpp.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
  31. writing build/bdist.linux-x86_64/egg/EGG-INFO/native_libs.txt
  32. zip_safe flag not set; analyzing archive contents...
  33. __pycache__.lltm_cpp.cpython-37: module references __file__
  34. creating 'dist/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg' and adding 'build/bdist.linux-x86_64/egg' to it
  35. removing 'build/bdist.linux-x86_64/egg' (and everything under it)
  36. Processing lltm_cpp-0.0.0-py3.7-linux-x86_64.egg
  37. removing '~/local/miniconda/lib/python3.7/site-packages/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg' (and everything under it)
  38. creating ~/local/miniconda/lib/python3.7/site-packages/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg
  39. Extracting lltm_cpp-0.0.0-py3.7-linux-x86_64.egg to ~/local/miniconda/lib/python3.7/site-packages
  40. lltm-cpp 0.0.0 is already the active version in easy-install.pth
  42. Installed ~/local/miniconda/lib/python3.7/site-packages/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg
  43. Processing dependencies for lltm-cpp==0.0.0
  44. Finished processing dependencies for lltm-cpp==0.0.0

关于编译器的小注释：由于 ABI 版本问题，用于构建 C ++扩展的编译器必须为，并且 PyTorch 编译器是与 ABI 兼容的。 实际上，这意味着您必须在 Linux 上使用 GCC 4.9 及更高版本。 对于 Ubuntu 16.04 和其他较新的 Linux 发行版，这应该已经是默认编译器。 在 MacOS 上，您必须使用 clang(它没有任何 ABI 版本控制问题）。 在最坏的情况下，您可以使用编译器从源代码构建 PyTorch，然后使用相同的编译器构建扩展。

扩展程序构建完成后，您可以使用在setup.py脚本中指定的名称，简单地将其导入 Python。 只需确保先import torch，因为这将解决动态链接器必须看到的一些符号：

  1. In [1]: import torch
  2. In [2]: import lltm_cpp
  3. In [3]: lltm_cpp.forward
  4. Out[3]: <function lltm.PyCapsule.forward>

如果在函数或模块上调用help()，则可以看到其签名与我们的 C ++代码匹配：

  1. In[4] help(lltm_cpp.forward)
  2. forward(...) method of builtins.PyCapsule instance
  3.     forward(arg0: torch::Tensor, arg1: torch::Tensor, arg2: torch::Tensor, arg3: torch::Tensor, arg4: torch::Tensor) -> List[torch::Tensor]
  5.     LLTM forward

由于我们现在可以从 Python 调用 C ++函数，因此可以将它们包装为torch.autograd.Function和torch.nn.Module以使其成为 PyTorch 的一等公民：

  1. import math
  2. import torch
  4. # Our module!
  5. import lltm_cpp
  7. class LLTMFunction(torch.autograd.Function):
  8.     @staticmethod
  9.     def forward(ctx, input, weights, bias, old_h, old_cell):
  10.         outputs = lltm_cpp.forward(input, weights, bias, old_h, old_cell)
  11.         new_h, new_cell = outputs[:2]
  12.         variables = outputs[1:] + [weights]
  13.         ctx.save_for_backward(*variables)
  15.         return new_h, new_cell
  17.     @staticmethod
  18.     def backward(ctx, grad_h, grad_cell):
  19.         outputs = lltm_cpp.backward(
  20.             grad_h.contiguous(), grad_cell.contiguous(), *ctx.saved_variables)
  21.         d_old_h, d_input, d_weights, d_bias, d_old_cell = outputs
  22.         return d_input, d_weights, d_bias, d_old_h, d_old_cell
  24. class LLTM(torch.nn.Module):
  25.     def __init__(self, input_features, state_size):
  26.         super(LLTM, self).__init__()
  27.         self.input_features = input_features
  28.         self.state_size = state_size
  29.         self.weights = torch.nn.Parameter(
  30.             torch.empty(3 * state_size, input_features + state_size))
  31.         self.bias = torch.nn.Parameter(torch.empty(3 * state_size))
  32.         self.reset_parameters()
  34.     def reset_parameters(self):
  35.         stdv = 1.0 / math.sqrt(self.state_size)
  36.         for weight in self.parameters():
  37.             weight.data.uniform_(-stdv, +stdv)
  39.     def forward(self, input, state):
  40.         return LLTMFunction.apply(input, self.weights, self.bias, *state)

性能比较

既然我们已经能够使用和调用 PyTorch 的 C ++代码，我们就可以运行一个小型基准测试，以查看通过用 C ++重写 op 获得的性能。 我们将向前和向后运行 LLTM 几次，并测量持续时间：

  1. import time
  3. import torch
  5. batch_size = 16
  6. input_features = 32
  7. state_size = 128
  9. X = torch.randn(batch_size, input_features)
  10. h = torch.randn(batch_size, state_size)
  11. C = torch.randn(batch_size, state_size)
  13. rnn = LLTM(input_features, state_size)
  15. forward = 0
  16. backward = 0
  17. for _ in range(100000):
  18.     start = time.time()
  19.     new_h, new_C = rnn(X, (h, C))
  20.     forward += time.time() - start
  22.     start = time.time()
  23.     (new_h.sum() + new_C.sum()).backward()
  24.     backward += time.time() - start
  26. print('Forward: {:.3f} us | Backward {:.3f} us'.format(forward * 1e6/1e5, backward * 1e6/1e5))

如果我们使用本文开头用纯 Python 编写的原始 LLTM 来运行此代码，则会得到以下数字(在我的机器上）：

  1. Forward: 506.480 us | Backward 444.694 us

以及我们的新 C ++版本：

  1. Forward: 349.335 us | Backward 443.523 us

我们已经可以看到前进功能的显着提速(超过 30％）。 对于后退功能，可以看到加速，尽管不是主要的。 我在上面编写的后向通行证没有特别优化，并且肯定可以改进。 而且，PyTorch 的自动微分引擎可以自动并行化计算图，可以整体上使用更高效的操作流程，并且也可以用 C ++实现，因此有望实现更快的速度。 尽管如此，这是一个良好的开始。

GPU 设备上的性能

关于 PyTorch 的 ATen 后端的一个奇妙事实是，它抽象了您正在运行的计算设备。 这意味着我们为 CPU 编写的相同代码可以也可以在 GPU 上运行，并且各个操作将相应地分派到 GPU 优化的实现。 对于某些运算，例如矩阵乘法(例如mm或addmm），这是一个很大的胜利。 让我们看一下使用 CUDA 张量运行 C ++代码所获得的性能。 无需更改实现，只需将张量从 Python 放到 GPU 内存中，在创建时添加device=cuda_device参数，或者在创建后使用.to(cuda_device)：

  1. import torch
  3. assert torch.cuda.is_available()
  4. cuda_device = torch.device("cuda")  # device object representing GPU
  6. batch_size = 16
  7. input_features = 32
  8. state_size = 128
  10. # Note the device=cuda_device arguments here
  11. X = torch.randn(batch_size, input_features, device=cuda_device)
  12. h = torch.randn(batch_size, state_size, device=cuda_device)
  13. C = torch.randn(batch_size, state_size, device=cuda_device)
  15. rnn = LLTM(input_features, state_size).to(cuda_device)
  17. forward = 0
  18. backward = 0
  19. for _ in range(100000):
  20.     start = time.time()
  21.     new_h, new_C = rnn(X, (h, C))
  22.     torch.cuda.synchronize()
  23.     forward += time.time() - start
  25.     start = time.time()
  26.     (new_h.sum() + new_C.sum()).backward()
  27.     torch.cuda.synchronize()
  28.     backward += time.time() - start
  30. print('Forward: {:.3f} us | Backward {:.3f} us'.format(forward * 1e6/1e5, backward * 1e6/1e5))

再次将普通的 PyTorch 代码与 C ++版本(现在都在 CUDA 设备上运行）进行比较，我们再次看到了性能提升。 对于 Python / PyTorch：

  1. Forward: 187.719 us | Backward 410.815 us

和 C ++ / ATen：

  1. Forward: 149.802 us | Backward 393.458 us

与非 CUDA 代码相比，这可以大大提高整体速度。 但是，通过编写自定义 CUDA 内核，我们可以从 C ++代码中获得更多性能，我们将很快深入其中。 在此之前，让我们讨论构建 C ++扩展的另一种方法。

JIT 编译扩展

之前，我提到过有两种构建 C ++扩展的方法：使用setuptools或即时(JIT）。 在介绍了前者之后，让我们详细介绍后者。 JIT 编译机制通过调用 PyTorch API 中称为torch.utils.cpp_extension.load()的简单函数，为您动态编译和加载扩展程序。 对于 LLTM，这看起来像这样简单：

  1. from torch.utils.cpp_extension import load
  3. lltm_cpp = load(name="lltm_cpp", sources=["lltm.cpp"])

在此，我们为函数提供与setuptools相同的信息。 在后台，这将执行以下操作：

  1. 创建一个临时目录/tmp/torch_extensions/lltm，
  2. 将 Ninja 构建文件发送到该临时目录中，
  3. 将您的源文件编译到共享库中，
  4. 将此共享库导入为 Python 模块。

实际上，如果将verbose=True传递给cpp_extension.load()，则会通知您有关过程：

  1. Using /tmp/torch_extensions as PyTorch extensions root...
  2. Emitting ninja build file /tmp/torch_extensions/lltm_cpp/build.ninja...
  3. Building extension module lltm_cpp...
  4. Loading extension module lltm_cpp...

生成的 Python 模块将与 setuptools 生成的模块完全相同，但是消除了必须维护单独的setup.py构建文件的要求。 如果您的设置更加复杂，并且确实需要setuptools的全部功能，则可以编写自己的setup.py –但是在许多情况下，这种 JIT 技术就可以了。 第一次运行此行时，将需要一些时间，因为扩展程序是在后台编译的。 由于我们使用 Ninja 构建系统来构建您的源代码，因此重新编译是增量的，因此在您第二次运行 Python 模块时重新加载扩展程序非常快捷，而且如果您不更改扩展程序的源文件，则开销很低。

编写混合的 C ++ / CUDA 扩展

为了将实现真正提升到一个新的水平，我们可以使用自定义 CUDA 内核来手写前进和后退传递的部分内容。 对于 LLTM，这具有特别有效的前景，因为有大量按顺序进行的逐点操作，这些操作都可以在单个 CUDA 内核中融合和并行化。 让我们看看如何编写这种 CUDA 内核，并使用此扩展机制将其与 PyTorch 集成。

编写 CUDA 扩展的一般策略是首先编写一个 C ++文件，该文件定义将从 Python 调用的函数，然后使用 pybind11 将这些函数绑定到 Python。 此外，此文件还将声明在 CUDA(.cu）文件中定义的函数。 然后，C ++函数将进行一些检查，并最终将其调用转发给 CUDA 函数。 在 CUDA 文件中，我们编写了实际的 CUDA 内核。 然后cpp_extension包将负责使用gcc等 C ++编译器来编译 C ++源代码，并使用 NVIDIA 的nvcc编译器来编译 CUDA 源。 这样可以确保每个编译器都照顾最了解要编译的文件。 最终，它们将被链接到一个共享库中，该库可以从 Python 代码中获得。

我们将从 C ++文件开始，我们将其称为lltm_cuda.cpp，例如：

  1. #include <torch/extension.h>
  3. #include <vector>
  5. // CUDA forward declarations
  7. std::vector<torch::Tensor> lltm_cuda_forward(
  8.     torch::Tensor input,
  9.     torch::Tensor weights,
  10.     torch::Tensor bias,
  11.     torch::Tensor old_h,
  12.     torch::Tensor old_cell);
  14. std::vector<torch::Tensor> lltm_cuda_backward(
  15.     torch::Tensor grad_h,
  16.     torch::Tensor grad_cell,
  17.     torch::Tensor new_cell,
  18.     torch::Tensor input_gate,
  19.     torch::Tensor output_gate,
  20.     torch::Tensor candidate_cell,
  21.     torch::Tensor X,
  22.     torch::Tensor gate_weights,
  23.     torch::Tensor weights);
  25. // C++ interface
  27. #define CHECK_CUDA(x) TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor")
  28. #define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
  29. #define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x)
  31. std::vector<torch::Tensor> lltm_forward(
  32.     torch::Tensor input,
  33.     torch::Tensor weights,
  34.     torch::Tensor bias,
  35.     torch::Tensor old_h,
  36.     torch::Tensor old_cell) {
  37.   CHECK_INPUT(input);
  38.   CHECK_INPUT(weights);
  39.   CHECK_INPUT(bias);
  40.   CHECK_INPUT(old_h);
  41.   CHECK_INPUT(old_cell);
  43.   return lltm_cuda_forward(input, weights, bias, old_h, old_cell);
  44. }
  46. std::vector<torch::Tensor> lltm_backward(
  47.     torch::Tensor grad_h,
  48.     torch::Tensor grad_cell,
  49.     torch::Tensor new_cell,
  50.     torch::Tensor input_gate,
  51.     torch::Tensor output_gate,
  52.     torch::Tensor candidate_cell,
  53.     torch::Tensor X,
  54.     torch::Tensor gate_weights,
  55.     torch::Tensor weights) {
  56.   CHECK_INPUT(grad_h);
  57.   CHECK_INPUT(grad_cell);
  58.   CHECK_INPUT(input_gate);
  59.   CHECK_INPUT(output_gate);
  60.   CHECK_INPUT(candidate_cell);
  61.   CHECK_INPUT(X);
  62.   CHECK_INPUT(gate_weights);
  63.   CHECK_INPUT(weights);
  65.   return lltm_cuda_backward(
  66.       grad_h,
  67.       grad_cell,
  68.       new_cell,
  69.       input_gate,
  70.       output_gate,
  71.       candidate_cell,
  72.       X,
  73.       gate_weights,
  74.       weights);
  75. }
  77. PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
  78.   m.def("forward", &lltm_forward, "LLTM forward (CUDA)");
  79.   m.def("backward", &lltm_backward, "LLTM backward (CUDA)");
  80. }

如您所见，它主要是样板文件，检查并转发到我们将在 CUDA 文件中定义的功能。 我们将此文件命名为lltm_cuda_kernel.cu(请注意.cu扩展名！）。 NVCC 可以合理地编译 C ++ 11，因此我们仍然可以使用 ATen 和 C ++标准库(但不能使用torch.h）。 请注意，setuptools无法处理具有相同名称但扩展名不同的文件，因此，如果您使用setup.py方法而不是 JIT 方法，则必须给 CUDA 文件指定一个与 C ++文件不同的名称(对于 JIT 方法， lltm.cpp和lltm.cu可以正常工作）。 让我们看一下该文件的外观：

  1. #include <torch/extension.h>
  3. #include <cuda.h>
  4. #include <cuda_runtime.h>
  6. #include <vector>
  8. template <typename scalar_t>
  9. __device__ __forceinline__ scalar_t sigmoid(scalar_t z) {
  10.   return 1.0 / (1.0 + exp(-z));
  11. }

在这里，我们看到了我刚刚描述的标头，以及我们正在使用特定于 CUDA 的声明(例如__device__和__forceinline__）以及函数(例如exp）的事实。 让我们继续一些我们需要的辅助功​​能：

  1. template <typename scalar_t>
  2. __device__ __forceinline__ scalar_t d_sigmoid(scalar_t z) {
  3.   const auto s = sigmoid(z);
  4.   return (1.0 - s) * s;
  5. }
  7. template <typename scalar_t>
  8. __device__ __forceinline__ scalar_t d_tanh(scalar_t z) {
  9.   const auto t = tanh(z);
  10.   return 1 - (t * t);
  11. }
  13. template <typename scalar_t>
  14. __device__ __forceinline__ scalar_t elu(scalar_t z, scalar_t alpha = 1.0) {
  15.   return fmax(0.0, z) + fmin(0.0, alpha * (exp(z) - 1.0));
  16. }
  18. template <typename scalar_t>
  19. __device__ __forceinline__ scalar_t d_elu(scalar_t z, scalar_t alpha = 1.0) {
  20.   const auto e = exp(z);
  21.   const auto d_relu = z < 0.0 ? 0.0 : 1.0;
  22.   return d_relu + (((alpha * (e - 1.0)) < 0.0) ? (alpha * e) : 0.0);
  23. }

现在要真正实现一个函数，我们将再次需要两件事：一个函数执行我们不希望手工编写并调用 CUDA 内核的操作，然后是要加速的部分的实际 CUDA 内核。 。 对于前向传递，第一个函数应如下所示：

  1. std::vector<torch::Tensor> lltm_cuda_forward(
  2.     torch::Tensor input,
  3.     torch::Tensor weights,
  4.     torch::Tensor bias,
  5.     torch::Tensor old_h,
  6.     torch::Tensor old_cell) {
  7.   auto X = torch::cat({old_h, input}, /*dim=*/1);
  8.   auto gates = torch::addmm(bias, X, weights.transpose(0, 1));
  10.   const auto batch_size = old_cell.size(0);
  11.   const auto state_size = old_cell.size(1);
  13.   auto new_h = torch::zeros_like(old_cell);
  14.   auto new_cell = torch::zeros_like(old_cell);
  15.   auto input_gate = torch::zeros_like(old_cell);
  16.   auto output_gate = torch::zeros_like(old_cell);
  17.   auto candidate_cell = torch::zeros_like(old_cell);
  19.   const int threads = 1024;
  20.   const dim3 blocks((state_size + threads - 1) / threads, batch_size);
  22.   AT_DISPATCH_FLOATING_TYPES(gates.type(), "lltm_forward_cuda", ([&] {
  23.     lltm_cuda_forward_kernel<scalar_t><<<blocks, threads>>>(
  24.         gates.data<scalar_t>(),
  25.         old_cell.data<scalar_t>(),
  26.         new_h.data<scalar_t>(),
  27.         new_cell.data<scalar_t>(),
  28.         input_gate.data<scalar_t>(),
  29.         output_gate.data<scalar_t>(),
  30.         candidate_cell.data<scalar_t>(),
  31.         state_size);
  32.   }));
  34.   return {new_h, new_cell, input_gate, output_gate, candidate_cell, X, gates};
  35. }

这里的主要关注点是AT_DISPATCH_FLOATING_TYPES宏和内核启动(由&lt;&lt;&lt;...&gt;&gt;&gt;指示）。 尽管 ATen 提取了我们处理过的张量的设备和数据类型，但张量在运行时仍将由具体设备上具体类型的内存支持。 因此，我们需要一种在运行时确定张量是什么类型，然后有选择地调用具有相应正确类型签名的函数的方法。 手动完成后，(在概念上）将如下所示：

  1. switch (tensor.type().scalarType()) {
  2.   case torch::ScalarType::Double:
  3.     return function<double>(tensor.data<double>());
  4.   case torch::ScalarType::Float:
  5.     return function<float>(tensor.data<float>());
  6.   ...
  7. }

AT_DISPATCH_FLOATING_TYPES的目的是为我们处理此调度。 它需要一个类型(在我们的示例中为gates.type()），一个名称(用于错误消息）和一个 lambda 函数。 在此 lambda 函数中，类型别名scalar_t可用，并且定义为该上下文中张量实际上在运行时的类型。 这样，如果我们有一个模板函数(CUDA 内核将使用它），则可以使用此scalar_t别名实例化它，然后将调用正确的函数。 在这种情况下，我们还希望检索张量的数据指针作为scalar_t类型的指针。 如果您想分派所有类型而不仅仅是浮点类型(Float和Double），则可以使用AT_DISPATCH_ALL_TYPES。

请注意，我们使用普通的 ATen 执行一些操作。 这些操作仍将在 GPU 上运行，但使用 ATen 的默认实现。 这是有道理的，因为 ATen 会针对矩阵乘法(例如addmm）或卷积使用高度优化的例程，而这将很难实现和改善。

至于内核启动本身，我们在这里指定每个 CUDA 块将具有 1024 个线程，并且将整个 GPU 网格分为所需的1 x 1024线程块，以便用每个组件一个线程填充矩阵。 例如，如果我们的状态大小为 2048，批处理大小为 4，则我们将以每 1024 个线程总共启动4 x 2 = 8块。 如果您以前从未听说过 CUDA 的“障碍”或“网格”，那么简介 CUDA 可能会有所帮助。

实际的 CUDA 内核非常简单(如果您曾经编程过 GPU）：

  1. template <typename scalar_t>
  2. __global__ void lltm_cuda_forward_kernel(
  3.     const scalar_t* __restrict__ gates,
  4.     const scalar_t* __restrict__ old_cell,
  5.     scalar_t* __restrict__ new_h,
  6.     scalar_t* __restrict__ new_cell,
  7.     scalar_t* __restrict__ input_gate,
  8.     scalar_t* __restrict__ output_gate,
  9.     scalar_t* __restrict__ candidate_cell,
  10.     size_t state_size) {
  11.   const int column = blockIdx.x * blockDim.x + threadIdx.x;
  12.   const int index = blockIdx.y * state_size + column;
  13.   const int gates_row = blockIdx.y * (state_size * 3);
  14.   if (column < state_size) {
  15.     input_gate[index] = sigmoid(gates[gates_row + column]);
  16.     output_gate[index] = sigmoid(gates[gates_row + state_size + column]);
  17.     candidate_cell[index] = elu(gates[gates_row + 2 * state_size + column]);
  18.     new_cell[index] =
  19.         old_cell[index] + candidate_cell[index] * input_gate[index];
  20.     new_h[index] = tanh(new_cell[index]) * output_gate[index];
  21.   }
  22. }

这里最有趣的是，我们能够为门矩阵中的每个单独的组件完全并行地计算所有这些逐点运算。 如果您想象必须用一个串行的百万个元素的for巨型循环来执行此操作，那么您会明白为什么这样做会快得多。

使用访问器

您可以在 CUDA 内核中看到，我们直接处理正确类型的指针。 确实，直接在 cuda 内核中使用高级类型不可知张量会非常低效。

但是，这是以易于使用和可读性为代价的，尤其是对于高维数据。 在我们的示例中，例如，我们知道连续的gates张量具有 3 个维度：

  1. 批次，batch_size的大小和3*state_size的步幅
  2. 3的行，大小和state_size的步幅
  3. 指数，state_size的大小和1的步幅

那么我们如何访问内核中的元素gates[n][row][column]？ 事实证明，您需要通过一些简单的算法就可以大步访问元素。

  1. gates.data<scalar_t>()[n*3*state_size + row*state_size + column]

除了冗长之外，该表达式还需要跨步才能被明确地知道，并因此在其参数中传递给内核函数。 您会看到，在内核函数接受具有不同大小的多个张量的情况下，您将得到很长的参数列表。

对我们来说幸运的是，ATen 提供了通过动态检查 Tensor 是尺寸的类型和数量而创建的访问器。 然后，访问器公开一个 API，可以有效地访问 Tensor 元素，而不必转换为单个指针：

  1. torch::Tensor foo = torch::rand({12, 12});
  3. // assert foo is 2-dimensional and holds floats.
  4. auto foo_a = foo.accessor<float,2>();
  5. float trace = 0;
  7. for(int i = 0; i < foo_a.size(0); i++) {
  8.   // use the accessor foo_a to get tensor data.
  9.   trace += foo_a[i][i];
  10. }

访问器对象具有较高级别的接口，具有.size()和.stride()方法以及多维索引。 .accessor&lt;&gt;接口旨在在 CPU 张量上有效访问数据。 cuda 张量的等效项是packed_accessor64&lt;&gt;和packed_accessor32&lt;&gt;，它们产生具有 64 位或 32 位整数索引的压缩访问器。

与 Accessor 的根本区别在于，打包的 Accessor 在其结构内部复制大小和跨度数据，而不是指向它。 它允许我们将其传递给 CUDA 内核函数并在其中使用其接口。

我们可以设计一个使用压缩访问器而不是指针的函数。

  1. __global__ void lltm_cuda_forward_kernel(
  2.     const torch::PackedTensorAccessor32<scalar_t,3,torch::RestrictPtrTraits> gates,
  3.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> old_cell,
  4.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> new_h,
  5.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> new_cell,
  6.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> input_gate,
  7.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> output_gate,
  8.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> candidate_cell)

让我们分解一下这里使用的模板。 前两个参数scalar_t和2与常规访问器相同。 参数torch::RestrictPtrTraits指示必须使用__restrict__关键字。 另请注意，我们使用了PackedAccessor32变体，将变体和步幅存储在int32_t中。 这很重要，因为使用 64 位变体(PackedAccessor64）会使内核变慢。

函数声明变为

  1. template <typename scalar_t>
  2. __global__ void lltm_cuda_forward_kernel(
  3.     const torch::PackedTensorAccessor32<scalar_t,3,torch::RestrictPtrTraits> gates,
  4.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> old_cell,
  5.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> new_h,
  6.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> new_cell,
  7.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> input_gate,
  8.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> output_gate,
  9.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> candidate_cell) {
  10.   //batch index
  11.   const int n = blockIdx.y;
  12.   // column index
  13.   const int c = blockIdx.x * blockDim.x + threadIdx.x;
  14.   if (c < gates.size(2)){
  15.     input_gate[n][c] = sigmoid(gates[n][0][c]);
  16.     output_gate[n][c] = sigmoid(gates[n][1][c]);
  17.     candidate_cell[n][c] = elu(gates[n][2][c]);
  18.     new_cell[n][c] =
  19.         old_cell[n][c] + candidate_cell[n][c] * input_gate[n][c];
  20.     new_h[n][c] = tanh(new_cell[n][c]) * output_gate[n][c];
  21.   }
  22. }

该实现更具可读性！ 然后，通过在主机函数内使用.packed_accessor32&lt;&gt;方法创建压缩访问器来调用此函数。

  1. std::vector<torch::Tensor> lltm_cuda_forward(
  2.     torch::Tensor input,
  3.     torch::Tensor weights,
  4.     torch::Tensor bias,
  5.     torch::Tensor old_h,
  6.     torch::Tensor old_cell) {
  7.   auto X = torch::cat({old_h, input}, /*dim=*/1);
  8.   auto gate_weights = torch::addmm(bias, X, weights.transpose(0, 1));
  10.   const auto batch_size = old_cell.size(0);
  11.   const auto state_size = old_cell.size(1);
  13.   auto gates = gate_weights.reshape({batch_size, 3, state_size});
  14.   auto new_h = torch::zeros_like(old_cell);
  15.   auto new_cell = torch::zeros_like(old_cell);
  16.   auto input_gate = torch::zeros_like(old_cell);
  17.   auto output_gate = torch::zeros_like(old_cell);
  18.   auto candidate_cell = torch::zeros_like(old_cell);
  20.   const int threads = 1024;
  21.   const dim3 blocks((state_size + threads - 1) / threads, batch_size);
  23.   AT_DISPATCH_FLOATING_TYPES(gates.type(), "lltm_forward_cuda", ([&] {
  24.     lltm_cuda_forward_kernel<scalar_t><<<blocks, threads>>>(
  25.         gates.packed_accessor32<scalar_t,3,torch::RestrictPtrTraits>(),
  26.         old_cell.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  27.         new_h.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  28.         new_cell.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  29.         input_gate.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  30.         output_gate.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  31.         candidate_cell.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>());
  32.   }));
  34.   return {new_h, new_cell, input_gate, output_gate, candidate_cell, X, gates};
  35. }

向后传递遵循相同的模式，在此我不再赘述：

  1. template <typename scalar_t>
  2. __global__ void lltm_cuda_backward_kernel(
  3.     torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> d_old_cell,
  4.     torch::PackedTensorAccessor32<scalar_t,3,torch::RestrictPtrTraits> d_gates,
  5.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> grad_h,
  6.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> grad_cell,
  7.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> new_cell,
  8.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> input_gate,
  9.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> output_gate,
  10.     const torch::PackedTensorAccessor32<scalar_t,2,torch::RestrictPtrTraits> candidate_cell,
  11.     const torch::PackedTensorAccessor32<scalar_t,3,torch::RestrictPtrTraits> gate_weights) {
  12.   //batch index
  13.   const int n = blockIdx.y;
  14.   // column index
  15.   const int c = blockIdx.x * blockDim.x + threadIdx.x;
  16.   if (c < d_gates.size(2)){
  17.     const auto d_output_gate = tanh(new_cell[n][c]) * grad_h[n][c];
  18.     const auto d_tanh_new_cell = output_gate[n][c] * grad_h[n][c];
  19.     const auto d_new_cell =
  20.         d_tanh(new_cell[n][c]) * d_tanh_new_cell + grad_cell[n][c];
  22.     d_old_cell[n][c] = d_new_cell;
  23.     const auto d_candidate_cell = input_gate[n][c] * d_new_cell;
  24.     const auto d_input_gate = candidate_cell[n][c] * d_new_cell;
  26.     d_gates[n][0][c] =
  27.         d_input_gate * d_sigmoid(gate_weights[n][0][c]);
  28.     d_gates[n][1][c] =
  29.         d_output_gate * d_sigmoid(gate_weights[n][1][c]);
  30.     d_gates[n][2][c] =
  31.         d_candidate_cell * d_elu(gate_weights[n][2][c]);
  32.   }
  33. }
  35. std::vector<torch::Tensor> lltm_cuda_backward(
  36.     torch::Tensor grad_h,
  37.     torch::Tensor grad_cell,
  38.     torch::Tensor new_cell,
  39.     torch::Tensor input_gate,
  40.     torch::Tensor output_gate,
  41.     torch::Tensor candidate_cell,
  42.     torch::Tensor X,
  43.     torch::Tensor gates,
  44.     torch::Tensor weights) {
  45.   auto d_old_cell = torch::zeros_like(new_cell);
  46.   auto d_gates = torch::zeros_like(gates);
  48.   const auto batch_size = new_cell.size(0);
  49.   const auto state_size = new_cell.size(1);
  51.   const int threads = 1024;
  52.   const dim3 blocks((state_size + threads - 1) / threads, batch_size);
  54.   AT_DISPATCH_FLOATING_TYPES(X.type(), "lltm_forward_cuda", ([&] {
  55.     lltm_cuda_backward_kernel<scalar_t><<<blocks, threads>>>(
  56.         d_old_cell.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  57.         d_gates.packed_accessor32<scalar_t,3,torch::RestrictPtrTraits>(),
  58.         grad_h.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  59.         grad_cell.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  60.         new_cell.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  61.         input_gate.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  62.         output_gate.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  63.         candidate_cell.packed_accessor32<scalar_t,2,torch::RestrictPtrTraits>(),
  64.         gates.packed_accessor32<scalar_t,3,torch::RestrictPtrTraits>());
  65.   }));
  67.   auto d_gate_weights = d_gates.reshape({batch_size, 3*state_size});
  68.   auto d_weights = d_gate_weights.t().mm(X);
  69.   auto d_bias = d_gate_weights.sum(/*dim=*/0, /*keepdim=*/true);
  71.   auto d_X = d_gate_weights.mm(weights);
  72.   auto d_old_h = d_X.slice(/*dim=*/1, 0, state_size);
  73.   auto d_input = d_X.slice(/*dim=*/1, state_size);
  75.   return {d_old_h, d_input, d_weights, d_bias, d_old_cell, d_gates};
  76. }

将 C ++ / CUDA 操作与 PyTorch 集成

同样，将支持 CUDA 的 op 与 PyTorch 集成非常简单。 如果要编写setup.py脚本，它可能如下所示：

  1. from setuptools import setup
  2. from torch.utils.cpp_extension import BuildExtension, CUDAExtension
  4. setup(
  5.     name='lltm',
  6.     ext_modules=[
  7.         CUDAExtension('lltm_cuda', [
  8.             'lltm_cuda.cpp',
  9.             'lltm_cuda_kernel.cu',
  10.         ])
  11.     ],
  12.     cmdclass={
  13.         'build_ext': BuildExtension
  14.     })

现在，我们使用CUDAExtension()代替CppExtension()。 我们只需要指定.cu文件和.cpp文件即可–该库将为您解决所有麻烦。 JIT 机制甚至更简单：

  1. from torch.utils.cpp_extension import load
  3. lltm = load(name='lltm', sources=['lltm_cuda.cpp', 'lltm_cuda_kernel.cu'])

Performance Comparison

我们的希望是，将我们的代码的逐点操作与 CUDA 并行化和融合，将改善 LLTM 的性能。 让我们看看这是否成立。 我们可以运行前面列出的代码来运行基准测试。 我们之前最快的版本是基于 CUDA 的 C ++代码：

  1. Forward: 149.802 us | Backward 393.458 us

现在使用我们的自定义 CUDA 内核：

  1. Forward: 129.431 us | Backward 304.641 us

更多性能提升！

结论

现在，您应该已经对 PyTorch 的 C ++扩展机制有了很好的了解，并有使用它们的动机。 您可以在此处找到本说明中显示的代码示例。 如有疑问，请使用论坛。 如果您遇到任何问题，也请务必查看我们的常见问题解答。