pytorch整理（五）

.new:创建一个新的Tensor，该Tensor的type和device都和原有Tensor一致，且无内容。

C++拓展

C++ 扩展有两种形式：可以使用 setuptools “提前”构建，也可以通过 torch.utils.cpp_extension.load() “即时”构建。

使用 setuptools 进行构建

为了实现“提前”构建，我们编写一个 setup.py 脚本来构建 C++ 扩展，其使用 setuptools 来编译我们的 C++ 代码。脚本十分简单，如下所示：

from setuptools import setup, Extension
from torch.utils import cpp_extension

setup(name='lltm_cpp',
      ext_modules=[cpp_extension.CppExtension('lltm_cpp', ['lltm.cpp'])],
      cmdclass={'build_ext': cpp_extension.BuildExtension})

在这部分代码中，CppExtension 是 setuptools.Extension 的一个便利的包装器(wrapper），它传递正确的引用路径，并且将扩展包语言设置为 c++。等效的泛化版 setuptools 简单代码如下所示：

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

C++编写

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

torch::Tensor d_sigmoid(torch::Tensor z) {
  auto s = torch::sigmoid(z);
  return (1 - s) * s;
}

<torch / extension.h> 是一站式(one-stop）头文件，其中包括编写 C++ 扩展所有必需的 PyTorch 扩展。 这包括：
ATen 库，它是我们张量计算的主要 API，
pybind11，用于实现我们的 C++ 代码的 Python 衔接方法，
其他管理 ATen 和 pybind11 交互细节的头文件。

d_sigmoid() 的实现展示了如何使用 ATen API。PyTorch 的张量和变量接口是由 ATen 库自动生成的，因此我们可以或多或少地实现将 Python 以 1：1 的形式转换为 C++。我们用于所有计算的主要数据类型将是 torch::Tensor。它的完整 API 可以在这里查到。注意，我们可以包含 或任何其他 C 或 C++ 头文件 – 我们可以使用 C++11 的全部功能。

C++ 扩展 API 当前不提供为我们自动生成后向传播函数的方法。因此，我们必须要自己实现 后向传播，其将计算每个前向传播的输入的导数。

衔接python

一旦您用 C++ 和 ATen 编写了计算，可以使用 pybind11 以非常简单的方式将 C++ 函数或类衔接到 Python 中。

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

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

使用拓展

目录结构

pytorch/
  lltm-extension/
    lltm.cpp
    setup.py

运行 python setup.py install 安装你的扩展
关于编译器的一个小注意事项：由于 ABI 版本问题，用于构建 C++ 扩展的编译器必须与 ABI 兼容，并且这里的编译器是必须是与构建 PyTorch 时采用的编译器一样的。实际上，这意味着您必须在 Linux 上使用 GCC 4.9 及更高版本。 对于 Ubuntu 16.04 和其他较新的 Linux 发行版，这应该已经是默认的编译器。 在最坏的情况下，您可以使用编译器从源代码构建 PyTorch ，然后使用相同的编译器构建扩展。
使用

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

由于我们现在能够从 Python 中调用我们的 C++ 函数，我们可以使用 torch.autograd.Function和 torch.nn.Module 来包装(warp）它们，使它们成为 PyTorch 中的最顶层的类(first class citizens，关键的一部分）：

import math
import torch

# Our module!
import lltm_cpp

class LLTMFunction(torch.autograd.Function):
    @staticmethod
    def forward(ctx, input, weights, bias, old_h, old_cell):
        outputs = lltm_cpp.forward(input, weights, bias, old_h, old_cell)
        new_h, new_cell = outputs[:2]
        variables = outputs[1:] + [weights]
        ctx.save_for_backward(*variables)

        return new_h, new_cell

    @staticmethod
    def backward(ctx, grad_h, grad_cell):
        outputs = lltm_cpp.backward(
            grad_h.contiguous(), grad_cell.contiguous(), *ctx.saved_variables)
        d_old_h, d_input, d_weights, d_bias, d_old_cell = outputs
        return d_input, d_weights, d_bias, d_old_h, d_old_cell


class LLTM(torch.nn.Module):
    def __init__(self, input_features, state_size):
        super(LLTM, self).__init__()
        self.input_features = input_features
        self.state_size = state_size
        self.weights = torch.nn.Parameter(
            torch.empty(3 * state_size, input_features + state_size))
        self.bias = torch.nn.Parameter(torch.empty(3 * state_size))
        self.reset_parameters()

    def reset_parameters(self):
        stdv = 1.0 / math.sqrt(self.state_size)
        for weight in self.parameters():
            weight.data.uniform_(-stdv, +stdv)

    def forward(self, input, state):
        return LLTMFunction.apply(input, self.weights, self.bias, *state)

移到GPU

无需更改实现，我们只需要将张量在 Python 中加入 GPU 内存，即可在开始时添加 device = cuda_device 参数，或者在创建后使用 .to(cuda_device)。

JIT 编译扩展

JIT 编译机制通过调用 PyTorch API 中一个称为 torch.utils.cpp_extension.load() 的简单函数，为您提供了一种动态编译和加载扩展的方式。

from torch.utils.cpp_extension import load

lltm_cpp = load(name="lltm_cpp", sources=["lltm.cpp"])

作用同之前的setup.py
其实包含操作：
创建一个临时目录 /tmp/torch_extensions/lltm，
将 Ninja 构建文件发送到该临时目录中，
将您的源文件编译到共享库中，
将此共享库导入为 Python 模块。
如果将变量 verbose = True 传递给 cpp_extension.load()，该进程会在运行过程中会显式过程

C++，CUDA混合拓展

cuda内核

编写 CUDA 扩展的一般策略是先编写一个 C++ 文件，该文件定义将从 Python 调用的函数，然后使用 pybind11 将这些函数衔接到 Python。此外，此文件还将声明在CUDA(.cu）文件中定义的函数。然后，C++ 函数将进行一些检查，并最终将其调用转发给 CUDA 函数。在 CUDA 文件中，我们编写实际的 CUDA 内核。
然后，cpp_extension 包将负责使用 gcc 之类的 C++ 编译器来编译 C++ 源代码，并使用 NVIDIA 的 nvcc 编译器来编译 CUDA 源代码。这样可以确保每个编译器都编译地它最了解的文件。最终，它们将被链接到一个共享库中，该库可以从 Python 代码中获得。
NVCC 可以聪明地编译 C++11，因此我们仍然可以使用 ATen 和 C++ 标准库(但不提供 torch.h）。请注意， setuptools 无法处理具有相同名称但扩展名不同的文件，因此，如果您使用 setup.py 方法而不是 JIT 方法，则必须为 CUDA 文件指定与 C++ 文件不同的名称(对于 JIT 方法则可以正常区分 lltm.cpp 和 lltm.cu）。

模型并行

手动将网络不同部分和数据放在不同GPU，backward()和torch.optim将自动处理梯度，就像模型在一个GPU上一样。你只需确保调用损失函数时标签与输出在同一设备上。
模型并行实现的执行时间比现有的单GPU实现长4.02 / 3.75-1 = 7％。因此，我们可以得出结论，在GPU之间来回复制张量大约有7％的开销。
这里有改进的空间，因为我们知道两个GPU之一在整个执行过程中处于空闲状态。一种选择是将每个批次进一步划分为拆分流水线，以便当一个拆分到达第二子网络时，可以将下一个拆分投入第一子网络。这样，两个连续的拆分可以在两个GPU上同时运行。

用流水线输入加速

为了使您的环境获得最佳性能，一种正确的方法是首先生成曲线以找出最佳split_size，然后将该split_size用于流水线输入。

数据并行

DistributedDataParallel可以与模型并行化一起工作；DataParallel此时不工作。
DataParallel是单进程、多线程的，并且只在一台机器上工作；而DistributedDataParallel是多进程的，可用于单机和多机训练。因此，即使对于单机训练，数据足够小，可以放在一台机器上，DistributedDataParallel也会比DataParallel更快。DistributedDataParallel还可以预先复制模型，而不是在每次迭代时复制模型，从而可以避免全局解释器锁定。
https://blog.csdn.net/qq_35446336/article/details/105017394，结合之前的博客

一些原理

requires_grad

只要有单个输入进行梯度计算操作，则其输出也需要梯度计算。相反，只有当所有输入都不需要计算梯度时，输出才不需要梯度计算。如果其中所有的张量都不需要进行梯度计算，后向计算不会在子图中执行。

x = torch.randn(5, 5)  # requires_grad=False by default

而初始化网络层时参数requires_grad=True by default

in-place

除非在巨大的内存压力下运行，否则你可能永远不需要使用它
In-place正确性检查
每一个张量都有一个版本计算器，每次在任何操作中标记都会递增。 当Function保存任何用于后向传播的张量时，也会保存包含张量的版本计数器。一旦访问self.saved_tensors后，它将被检查，如果它大于保存的值，则会引发错误。这可以确保如果您使用in-place函数而没有看到任何错误，则可以确保计算出的梯度是正确的。

广播

如果遵守以下规则，则两个张量是“可广播的”：
每个张量至少有一个维度；
遍历张量维度大小时，从末尾随开始遍历，两个张量的维度满足以下条件之一：大小必须相等、它们其中一个为1、他们其中一个不存在。
如果x,y两个张量是可以广播的，则通过计算得到的张量大小遵循以下原则：
如果x和y的维数不相等，则在维度较小的张量的前面增加1个维度，使它们的长度相等。
然后,生成新张量维度的大小是x和y在每个维度上的最大值。
一个复杂因素是in-place操作不允许in-place张量像广播那样改变形状。

PyTorch的早期版本允许某些逐点函数在具有不同形状的张量上执行，只要每个张量中的元素数量相等即可。 然后通过将每个张量视为1维来执行逐点运算。PyTorch现在支持广播，并且“1维”逐点行为被认为已弃用，并且在张量不可广播但具有相同数量的元素的情况下将生成Python警告。
注意，在两个张量不具有相同形状但是可广播并且具有相同数量元素的情况下，广播的引入可能导致向后不兼容。例如：

>>> torch.add(torch.ones(4,1), torch.randn(4))

以前可能会产生一个torch.Size([4,1]）的Tensor，但现在会产生一个torch.Size([4,4]）这样的Tensor。 为了帮助识别代码中可能存在广播引起的向后不兼容性的情况，您可以设置torch.utils.backcompat.broadcast_warning.enabled 为 True，在这种情况下会产生python警告。

cuda

您可以通过设置环境变量强制进行同步计算 CUDA_LAUNCH_BLOCKING=1。这在 GPU 上发生错误时非常方便。(使用异步执行时，直到实际执行操作后才会报告此类错误，因此堆栈跟踪不会显示请求的位置。）
异步计算的结果是没有同步的时间测量是不精确的。要获得精确的测量结果，应该在测量之前调用torch.cuda.synchronize()，或者使用torch.cuda.Event记录时间如下：

start_event = torch.cuda.Event(enable_timing=True)
end_event = torch.cuda.Event(enable_timing=True)
start_event.record()

# 在这里执行一些操作

end_event.record()
torch.cuda.synchronize()  # Wait for the events to be recorded!
elapsed_time_ms = start_event.elapsed_time(end_event)

内存管理

PyTorch 使用缓存内存分配器来加速内存分配。这允许在没有设备同步的情况下快速释放内存。但是，分配器管理的未使用内存仍将显示为使用 nvidia-smi。您可以使用 memory_allocated() 和 max_memory_allocated() 监视张量占用的内存，并使用 memory_cached() 和 max_memory_cached() 监视缓存分配器管理的内存。调用 empty_cache() 可以从 PyTorch 释放所有 unused 的缓存内存，以便其他 GPU 应用程序可以使用它们。但是，tensor 占用的 GPU 内存不会被释放，因此无法增加 PyTorch 可用的 GPU 内存量。

#设备当前占用内存和历史最大内存
torch.cuda.memory_allocated(device=None)
torch.cuda.max_memory_allocated(device=None)
#查看特定设备上缓存分配器当前占用内存和历史最大内存
torch.cuda.memory_cached(device=None)
torch.cuda.max_memory_cached(device=None)
#释放缓存分配器当前所管理的所有未使用的缓存
torch.cuda.empty_cache()

测试时记得，torch.no_grad()

常见问题

total_loss += loss，会保存历史记录，改为total_loss + = float(loss）
不用的张量del
不要在太大的序列上运行RNN
不要使用太大的线性图层
如果在Python退出后你的GPU内存仍旧没有被释放，那么很可能是一些Python子进程仍处于活动状态。你可以通过ps -elf |grep python找到它们并用kill -9 [pid]手动结束这些进程。
torch.multiprocessing 是 Python 的 multiprocessing 的直接替代模块。它支持完全相同的操作，但进行了扩展，这样所有的张量就可以通过一个 multiprocessing.Queue 进行传递，将数据移动到共享内存并只将句柄传递到另一个进程。

重复性

PyTorch中涉及两个伪随机数生成器，您需要手动播种以使运行可重现。此外，您应该确保您的代码依赖于使用随机数的所有其他库也使用固定种子。

import torch
torch.manual_seed(0)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
#确定性模式可能会对性能产生影响，具体取决于您的型号。
import numpy as np
np.random.seed(0)