doc22_031.md

# torch

> 原文：[`pytorch.org/docs/stable/torch.html`](https://pytorch.org/docs/stable/torch.html)

torch 包含用于多维张量的数据结构，并定义了这些张量上的数学操作。此外，它还提供了许多用于高效序列化张量和任意类型的工具，以及其他有用的实用程序。

它有一个 CUDA 对应项，可以让您在具有计算能力>= 3.0 的 NVIDIA GPU 上运行张量计算。

## 张量

| `is_tensor` | 如果 obj 是 PyTorch 张量，则返回 True。 |
| --- | --- |
| `is_storage` | 如果 obj 是 PyTorch 存储对象，则返回 True。 |
| `is_complex` | 如果`input`的数据类型是复数数据类型，即`torch.complex64`和`torch.complex128`之一，则返回 True。 |
| `is_conj` | 如果`input`是一个共轭张量，即其共轭位设置为 True，则返回 True。 |
| `is_floating_point` | 如果`input`的数据类型是浮点数据类型，即`torch.float64`、`torch.float32`、`torch.float16`和`torch.bfloat16`之一，则返回 True。 |
| `is_nonzero` | 如果`input`是一个经过类型转换后不等于零的单个元素张量，则返回 True。 |
| `set_default_dtype` | 将默认的浮点 dtype 设置为`d`。 |
| `get_default_dtype` | 获取当前默认的浮点`torch.dtype`。 |
| `set_default_device` | 将默认的`torch.Tensor`分配到`device`上。 |
| `set_default_tensor_type` | 将默认的`torch.Tensor`类型设置为浮点张量类型`t`。 |
| `numel` | 返回`input`张量中的总元素数。 |
| `set_printoptions` | 设置打印选项。 |
| `set_flush_denormal` | 禁用 CPU 上的非规格化浮点数。 |

### 创建操作

注意

随机抽样创建操作列在随机抽样下，包括：`torch.rand()` `torch.rand_like()` `torch.randn()` `torch.randn_like()` `torch.randint()` `torch.randint_like()` `torch.randperm()` 您还可以使用`torch.empty()`与原地随机抽样方法一起创建从更广泛的分布中抽样值的`torch.Tensor`。

| `tensor` | 通过复制`data`构建一个没有自动求导历史的张量（也称为“叶子张量”，参见自动求导机制）。 |
| --- | --- |
| `sparse_coo_tensor` | 使用给定的`indices`构建一个 COO（坐标）格式的稀疏张量。 |
| `sparse_csr_tensor` | 使用给定的`crow_indices`和`col_indices`构建一个 CSR（压缩稀疏行）格式的稀疏张量。 |
| `sparse_csc_tensor` | 使用给定的`ccol_indices`和`row_indices`构建一个 CSC（压缩稀疏列）格式的稀疏张量。 |
| `sparse_bsr_tensor` | 使用给定的`crow_indices`和`col_indices`构建一个 BSR（块压缩稀疏行）格式的稀疏张量。 |
| `sparse_bsc_tensor` | 使用给定的`ccol_indices`和`row_indices`构建一个 BSC（块压缩稀疏列）格式的稀疏张量。 |
| `asarray` | 将`obj`转换为张量。 |
| `as_tensor` | 将`data`转换为张量，如果可能的话共享数据并保留自动求导历史。 |
| `as_strided` | 使用指定的`size`、`stride`和`storage_offset`创建一个现有 torch.Tensor `input`的视图。 |
| `from_file` | 创建一个由内存映射文件支持的 CPU 张量。 |
| `from_numpy` | 从一个[`numpy.ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray)创建一个`Tensor`。 |
| `from_dlpack` | 将来自外部库的张量转换为`torch.Tensor`。 |
| `frombuffer` | 从实现 Python 缓冲区协议的对象创建一个 1 维张量。 |
| `zeros` | 返回一个填充了标量值 0 且形状由可变参数`size`定义的张量。 |
| `zeros_like` | 返回一个与`input`相同大小且填充了标量值 0 的张量。 |
| `ones` | 返回一个填充了标量值 1 且形状由可变参数`size`定义的张量。 |
| `ones_like` | 返回一个与`input`相同大小且填充了标量值 1 的张量。 |
| `arange` | 返回一个大小为$\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil$的一维张量，其值来自区间`start, end)`，以`step`为公差从`start`开始。 |
| [`range` | 返回一个大小为$\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor + 1$的一维张量，其值从`start`到`end`，步长为`step`。 |
| `linspace` | 创建一个大小为`steps`的一维张量，其值从`start`到`end`均匀间隔。 |
| `logspace` | 创建一个大小为`steps`的一维张量，其值在对数刻度上从${{\text{{base}}}}^{{\text{{start}}}}$basestart 到${{\text{{base}}}}^{{\text{{end}}}}$baseend 均匀间隔。 |
| `eye` | 返回一个对角线为 1，其他位置为 0 的二维张量。 |
| `empty` | 返回一个填充未初始化数据的张量。 |
| `empty_like` | 返回一个与`input`大小相同的未初始化张量。 |
| `empty_strided` | 创建一个指定`size`和`stride`的张量，并填充未定义数据。 |
| `full` | 创建一个大小为`size`且填充为`fill_value`的张量。 |
| `full_like` | 返回一个与`input`大小相同且填充为`fill_value`的张量。 |
| `quantize_per_tensor` | 将浮点张量转换为具有给定比例和零点的量化张量。 |
| `quantize_per_channel` | 将浮点张量转换为具有给定比例和零点的按通道量化张量。 |
| `dequantize` | 通过去量化一个量化张量返回一个 fp32 张量。 |
| `complex` | 构造一个复数张量，其实部等于`real`，虚部等于`imag`。 |
| `polar` | 构造一个复数张量，其元素是对应于绝对值`abs`和角度`angle`的极坐标。 |

| `heaviside` | 计算`input`中每个元素的 Heaviside 阶跃函数。 |  ### 索引、切片、连接、变异操作[](#indexing-slicing-joining-mutating-ops "跳转到此标题的永久链接")

| `adjoint` | 返回一个共轭并且最后两个维度转置的张量视图。 |
| --- | --- |
| `argwhere` | 返回一个包含`input`所有非零元素索引的张量。 |
| `cat` | 在给定维度上连接给定序列`seq`的张量。 |
| `concat` | `torch.cat()`的别名。 |
| `concatenate` | `torch.cat()`的别名。 |
| `conj` | 返回一个具有翻转共轭位的`input`视图。 |
| `chunk` | 尝试将张量分割成指定数量的块。 |
| `dsplit` | 根据`indices_or_sections`，将具有三个或更多维度的`input`张量沿深度方向分割成多个张量。 |
| `column_stack` | 通过水平堆叠`tensors`在`tensors`中创建一个新的张量。 |
| `dstack` | 深度顺序堆叠张量（沿第三轴）。 |
| `gather` | 沿着由 dim 指定的轴收集值。 |
| `hsplit` | 根据`indices_or_sections`，将具有一个或多个维度的`input`张量水平分割成多个张量。 |
| `hstack` | 水平顺序堆叠张量（按列）。 |
| `index_add` | 有关函数描述，请参阅`index_add_()`。 |
| `index_copy` | 有关函数描述，请参阅`index_add_()`。 |
| `index_reduce` | 有关函数描述，请参阅`index_reduce_()`。 |
| `index_select` | 返回一个新的张量，沿着维度`dim`使用`index`中的条目对`input`张量进行索引，其中`index`是一个 LongTensor。 |
| `masked_select` | 返回一个新的 1-D 张量，根据布尔掩码`mask`（BoolTensor）对`input`张量进行索引。 |
| `movedim` | 将`input`张量的维度移动到`source`中的位置到`destination`中的位置。 |
| `moveaxis` | `torch.movedim()`的别名。 |
| `narrow` | 返回一个缩小版本的`input`张量的新张量。 |
| `narrow_copy` | 与`Tensor.narrow()`相同，除了这里返回的是副本而不是共享存储。 |
| `nonzero` |  |
| `permute` | 返回原始张量`input`的维度重新排列视图。 |
| `reshape` | 返回一个与`input`具有相同数据和元素数量的张量，但具有指定的形状。 |
| `row_stack` | `torch.vstack()`的别名。 |
| `select` | 在给定索引处沿所选维度切片`input`张量。 |
| `scatter` | `torch.Tensor.scatter_()`的就地版本 |
| `diagonal_scatter` | 将`src`张量的值嵌入到`input`的对角线元素中，相对于`dim1`和`dim2`。 |
| `select_scatter` | 将`src`张量的值嵌入到给定索引的`input`中。 |
| `slice_scatter` | 将`src`张量的值嵌入到给定维度的`input`中。 |
| `scatter_add` | `torch.Tensor.scatter_add_()`的就地版本。 |
| `scatter_reduce` | `torch.Tensor.scatter_reduce_()`的就地版本。 |
| `split` | 将张量分割成多个块。 |
| `squeeze` | 返回一个去除`input`中所有指定大小为 1 的维度的张量。 |
| `stack` | 沿着新维度连接一系列张量。 |
| `swapaxes` | `torch.transpose()`的别名。 |
| `swapdims` | `torch.transpose()`的别名。 |
| `t` | 期望`input`是 <= 2-D 张量，并转置维度 0 和 1。 |
| `take` | 返回一个包含`input`在给定索引处的元素的新张量。 |
| `take_along_dim` | 在给定`dim`上沿着`indices`的一维索引从`input`中选择值。 |
| `tensor_split` | 将张量沿着维度`dim`根据`indices_or_sections`指定的索引或分段数拆分为多个子张量，所有这些子张量都是`input`的视图。 |
| `tile` | 通过重复`input`的元素构造张量。 |
| `transpose` | 返回`input`的转置版本的张量。 |
| `unbind` | 移除张量的一个维度。 |
| `unravel_index` | 将扁平索引的张量转换为索引到指定形状的任意张量的坐标张量元组。 |
| `unsqueeze` | 在指定位置插入一个大小为一的维度，返回一个新的张量。 |
| `vsplit` | 根据`indices_or_sections`将具有两个或更多维度的`input`张量垂直拆分为多个张量。 |
| `vstack` | 按行将张量依次堆叠起来。 |

| `where` | 根据`condition`从`input`或`other`中选择元素并返回张量。 |

| `Generator` | 创建并返回一个生成器对象，该对象管理产生伪随机数的算法的状态。 |  ## 随机抽样[](#random-sampling "Permalink to this heading")

| `seed` | 将生成随机数的种子设置为非确定性随机数。 |
| --- | --- |
| `manual_seed` | 设置生成随机数的种子。 |
| `initial_seed` | 将生成随机数的初始种子作为 Python 长整型返回。 |
| `get_rng_state` | 将随机数生成器状态作为 torch.ByteTensor 返回。 |
| `set_rng_state` | 设置随机数生成器状态。 |

```py
torch.default_generator Returns the default CPU torch.Generator¶
```

| `bernoulli` | 从伯努利分布中抽取二进制随机数（0 或 1）。 |
| --- | --- |
| `multinomial` | 返回一个张量，其中每行包含从多项式（更严格的定义是多变量，有关更多细节，请参考 torch.distributions.multinomial.Multinomial）概率分布中抽样的`num_samples`个索引，这些概率分布位于张量`input`相应行中。 |
| `normal` | 返回从具有给定均值和标准差的单独正态分布中抽取的随机数的张量。 |
| `poisson` | 返回与`input`相同大小的张量，其中每个元素从泊松分布中抽样，速率参数由`input`中相应元素给出。 |
| `rand` | 返回一个填充有来自区间$0, 1)$的均匀分布的随机数的张量。 |
| [`rand_like` | 返回与`input`相同大小的张量，其中填充有来自区间$0, 1)$的均匀分布的随机数。 |
| [`randint` | 返回一个填充有在`low`（包含）和`high`（不包含）之间均匀生成的随机整数的张量。 |
| `randint_like` | 返回与张量`input`形状相同的张量，其中填充有在`low`（包含）和`high`（不包含）之间均匀生成的随机整数。 |
| `randn` | 返回一个填充有来自均值为 0，方差为 1（也称为标准正态分布）的随机数的张量。 |
| `randn_like` | 返回与`input`相同大小的张量，其中填充有来自均值为 0，方差为 1 的正态分布的随机数。 |
| `randperm` | 返回从`0`到`n - 1`的整数的随机排列。 |

### 就地随机抽样[](#in-place-random-sampling "Permalink to this heading")

还有一些在张量上定义的就地随机抽样函数。点击查看它们的文档：

+   `torch.Tensor.bernoulli_()` - `torch.bernoulli()`的就地版本

+   `torch.Tensor.cauchy_()` - 从柯西分布中抽取的数字

+   `torch.Tensor.exponential_()` - 从指数分布中抽取的数字

+   `torch.Tensor.geometric_()` - 从几何分布中抽取的元素

+   `torch.Tensor.log_normal_()` - 从对数正态分布中抽样

+   `torch.Tensor.normal_()` - `torch.normal()` 的原地版本

+   `torch.Tensor.random_()` - 从离散均匀分布中抽取的数字

+   `torch.Tensor.uniform_()` - 从连续均匀分布中抽取的数字

### 准随机抽样

| `quasirandom.SobolEngine` | `torch.quasirandom.SobolEngine` 是用于生成（混淆）Sobol 序列的引擎。 |
| --- | --- |

## 序列化

| `save` | 将对象保存到磁盘文件中。 |
| --- | --- |
| `load` | 从文件中加载使用 `torch.save()` 保存的对象。 |

## 并行性

| `get_num_threads` | 返回用于并行化 CPU 操作的线程数 |
| --- | --- |
| `set_num_threads` | 设置在 CPU 上用于内部并行性的线程数。 |
| `get_num_interop_threads` | 返回在 CPU 上用于互操作并行性的线程数（例如 |
| `set_num_interop_threads` | 设置用于互操作并行性的线程数（例如 |

## 本地禁用梯度计算[](#locally-disabling-gradient-computation "Permalink to this heading")

上下文管理器 `torch.no_grad()`、`torch.enable_grad()` 和 `torch.set_grad_enabled()` 对于本地禁用和启用梯度计算非常有用。有关它们的使用详情，请参阅本地禁用梯度计算。这些上下文管理器是线程局部的，因此如果使用 `threading` 模块等将工作发送到另一个线程，则它们将无法工作。

示例：

```py
>>> x = torch.zeros(1, requires_grad=True)
>>> with torch.no_grad():
...     y = x * 2
>>> y.requires_grad
False

>>> is_train = False
>>> with torch.set_grad_enabled(is_train):
...     y = x * 2
>>> y.requires_grad
False

>>> torch.set_grad_enabled(True)  # this can also be used as a function
>>> y = x * 2
>>> y.requires_grad
True

>>> torch.set_grad_enabled(False)
>>> y = x * 2
>>> y.requires_grad
False 
```

| `no_grad` | 禁用梯度计算的上下文管理器。 |
| --- | --- |
| `enable_grad` | 启用梯度计算的上下文管理器。 |
| `set_grad_enabled` | 上下文管理器，用于打开或关闭梯度计算。 |
| `is_grad_enabled` | 如果当前启用梯度模式，则返回 True。 |
| `inference_mode` | 启用或禁用推理模式的上下文管理器。 |
| `is_inference_mode_enabled` | 如果当前启用推理模式，则返回 True。 |

## Math operations

### Pointwise Ops

| `abs` | 计算`input`中每个元素的绝对值。 |
| --- | --- |
| `absolute` | `torch.abs()`的别名。 |
| `acos` | 计算`input`中每个元素的反余弦值。 |
| `arccos` | `torch.acos()`的别名。 |
| `acosh` | 返回一个新的张量，其中包含`input`元素的反双曲余弦值。 |
| `arccosh` | `torch.acosh()`的别名。 |
| `add` | 将`other`按`alpha`缩放后加到`input`中。 |
| `addcdiv` | 对`tensor1`和`tensor2`进行逐元素除法，将结果乘以标量`value`并加到`input`中。 |
| `addcmul` | 对`tensor1`和`tensor2`进行逐元素相乘，将结果乘以标量`value`并加到`input`中。 |
| `angle` | 计算给定`input`张量的逐元素角度（弧度）。 |
| `asin` | 返回一个新的张量，其中包含`input`元素的反正弦值。 |
| `arcsin` | `torch.asin()`的别名。 |
| `asinh` | 返回一个新的张量，其中包含`input`元素的反双曲正弦值。 |
| `arcsinh` | `torch.asinh()`的别名。 |
| `atan` | 返回一个新的张量，其中包含`input`元素的反正切值。 |
| `arctan` | `torch.atan()`的别名。 |
| `atanh` | 返回一个新的张量，其中包含`input`元素的反双曲正切值。 |
| `arctanh` | `torch.atanh()`的别名。 |
| `atan2` | 考虑象限的`inputi​/otheri​`的逐元素反正切。 |
| `arctan2` | `torch.atan2()`的别名。 |
| `bitwise_not` | 计算给定输入张量的按位非。 |
| `bitwise_and` | 计算`input`和`other`的按位与。 |
| `bitwise_or` | 计算`input`和`other`的按位或。 |
| `bitwise_xor` | 计算`input`和`other`的按位异或。 |
| `bitwise_left_shift` | 计算`input`按`other`位的左算术移位。 |
| `bitwise_right_shift` | 计算`input`按`other`位的右算术移位。 |
| `ceil` | 返回一个新的张量，其中包含`input`元素的上限，即大于或等于每个元素的最小整数。 |
| `clamp` | 将`input`中的所有元素夹紧到范围`min`, `max`内。 |
| `clip` | `torch.clamp()`的别名。 |
| `conj_physical` | 计算给定`input`张量的逐元素共轭。 |
| `copysign` | 创建一个新的浮点张量，其大小为`input`，符号为`other`，逐元素。 |
| `cos` | 返回一个新的张量，其中包含`input`元素的余弦值。 |
| `cosh` | 返回一个新的张量，其中包含`input`元素的双曲余弦值。 |
| `deg2rad` | 返回一个新的张量，其中包含`input`中每个元素从角度转换为弧度。 |
| `div` | 将输入`input`的每个元素除以相应的`other`元素。 |
| `divide` | `torch.div()`的别名。 |
| `digamma` | `torch.special.digamma()`的别名。 |
| `erf` | `torch.special.erf()`的别名。 |
| `erfc` | `torch.special.erfc()`的别名。 |
| `erfinv` | `torch.special.erfinv()`的别名。 |
| `exp` | 返回一个新的张量，其中包含输入张量`input`元素的指数。 |
| `exp2` | `torch.special.exp2()`的别名。 |
| `expm1` | `torch.special.expm1()`的别名。 |
| `fake_quantize_per_channel_affine` | 返回一个新的张量，其中包含使用`scale`、`zero_point`、`quant_min`和`quant_max`对`input`进行每通道伪量化的数据，跨通道由`axis`指定。 |
| `fake_quantize_per_tensor_affine` | 使用 `scale`、`zero_point`、`quant_min` 和 `quant_max` 对 `input` 中的数据进行伪量化，并返回一个新的张量。 |
| `fix` | `torch.trunc()` 的别名 |
| `float_power` | 以双精度计算，对 `input` 的每个元素进行 `exponent` 次幂运算。 |
| `floor` | 返回一个新的张量，其元素为 `input` 的下取整，即小于或等于每个元素的最大整数。 |
| `floor_divide` |  |
| `fmod` | 对每个元素应用 C++ 的 [std::fmod](https://en.cppreference.com/w/cpp/numeric/math/fmod)。 |
| `frac` | 计算 `input` 中每个元素的小数部分。 |
| `frexp` | 将 `input` 分解为尾数和指数张量，使得 $\text{input} = \text{mantissa} \times 2^{\text{exponent}}$。 |
| `gradient` | 使用 [二阶中心差分方法](https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf) 在一个或多个维度上估计函数 $g : \mathbb{R}^n \rightarrow \mathbb{R}$g:Rn→R 的梯度，并在边界处使用一阶或二阶估计。 |
| `imag` | 返回一个包含 `self` 张量的虚部的新张量。 |
| `ldexp` | 将 `input` 乘以 2 ** `other`。 |
| `lerp` | 根据标量或张量 `weight` 对两个张量 `start`（由 `input` 给出）和 `end` 进行线性插值，并返回结果张量 `out`。 |
| `lgamma` | 计算 `input` 上伽玛函数绝对值的自然对数。 |
| `log` | 返回一个新的张量，其元素为 `input` 的自然对数。 |
| `log10` | 返回一个新的张量，其元素为 `input` 的以 10 为底的对数。 |
| `log1p` | 返回一个新的张量，其元素为 (1 + `input`) 的自然对数。 |
| `log2` | 返回一个新的张量，其元素为 `input` 的以 2 为底的对数。 |
| `logaddexp` | 对输入的指数求和的对数。 |
| `logaddexp2` | 以 2 为底对输入的指数求和的对数。 |
| `logical_and` | 计算给定输入张量的逐元素逻辑与。 |
| `logical_not` | 计算给定输入张量的逐元素逻辑非。 |
| `logical_or` | 计算给定输入张量的逐元素逻辑或。 |
| `logical_xor` | 计算给定输入张量的逐元素逻辑异或。 |
| `logit` | `torch.special.logit()` 的别名。 |
| `hypot` | 给定直角三角形的两条直角边，返回其斜边。 |
| `i0` | `torch.special.i0()` 的别名。 |
| `igamma` | `torch.special.gammainc()` 的别名。 |
| `igammac` | `torch.special.gammaincc()` 的别名。 |
| `mul` | 将 `input` 乘以 `other`。 |
| `multiply` | `torch.mul()` 的别名。 |
| `mvlgamma` | `torch.special.multigammaln()` 的别名。 |
| `nan_to_num` | 用 `nan`、`posinf` 和 `neginf` 指定的值替换 `input` 中的 `NaN`、正无穷大和负无穷大值。 |
| `neg` | 返回一个新的张量，其元素为 `input` 的负数。 |
| `negative` | `torch.neg()` 的别名。 |
| `nextafter` | 返回 `input` 向 `other` 方向的下一个浮点值，逐元素进行。 |
| `polygamma` | `torch.special.polygamma()` 的别名。 |
| `positive` | 返回 `input`。 |
| `pow` | 对 `input` 中的每个元素进行 `exponent` 次幂运算，并返回结果张量。 |
| `quantized_batch_norm` | 对 4D（NCHW）量化张量应用批量归一化。 |
| `quantized_max_pool1d` | 对由多个输入平面组成的输入量化张量应用 1D 最大池化。 |
| `quantized_max_pool2d` | 对由多个输入平面组成的输入量化张量应用 2D 最大池化。 |
| `rad2deg` | 返回一个新的张量，其中 `input` 的每个元素从弧度转换为度。 |
| `real` | 返回一个包含 `self` 张量的实数值的新张量。 |
| `reciprocal` | 返回一个新的张量，其元素为 `input` 的倒数。 |
| `remainder` | 计算逐元素的[Python 取模运算](https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations)。 |
| `round` | 将 `input` 的元素四舍五入到最接近的整数。 |
| `rsqrt` | 返回一个新的张量，其元素为 `input` 的平方根的倒数。 |
| `sigmoid` | `torch.special.expit()`的别名。 |
| `sign` | 返回具有`input`元素的符号的新张量。 |
| `sgn` | 这个函数是对复数张量的 torch.sign()的扩展。 |
| `signbit` | 检查`input`的每个元素是否设置了符号位。 |
| `sin` | 返回具有`input`元素的正弦的新张量。 |
| `sinc` | `torch.special.sinc()`的别名。 |
| `sinh` | 返回具有`input`元素的双曲正弦的新张量。 |
| `softmax` | `torch.nn.functional.softmax()`的别名。 |
| `sqrt` | 返回具有`input`元素的平方根的新张量。 |
| `square` | 返回具有`input`元素的平方的新张量。 |
| `sub` | 从`input`中减去经过`alpha`缩放的`other`。 |
| `subtract` | `torch.sub()`的别名。 |
| `tan` | 返回具有`input`元素的正切的新张量。 |
| `tanh` | 返回具有`input`元素的双曲正切的新张量。 |
| `true_divide` | 使用`rounding_mode=None`的`torch.div()`的别名。 |
| `trunc` | 返回具有`input`元素的截断整数值的新张量。 |
| `xlogy` | `torch.special.xlogy()`的别名。 |

### Reduction Ops

| `argmax` | 返回`input`张量中所有元素的最大值的索引。 |
| --- | --- |
| `argmin` | 返回扁平张量或沿着维度的最小值的索引。 |
| `amax` | 返回给定维度`dim`中`input`张量每个切片的最大值。 |
| `amin` | 返回给定维度`dim`中`input`张量每个切片的最小值。 |
| `aminmax` | 计算`input`张量的最小值和最大值。 |
| `all` | 检查`input`中是否所有元素评估为 True。 |
| `any` | 检查`input`中是否有任何元素评估为 True。 |
| `max` | 返回`input`张量中所有元素的最大值。 |
| `min` | 返回`input`张量中所有元素的最小值。 |
| `dist` | 返回(`input` - `other`)的 p-范数 |
| `logsumexp` | 返回`input`张量每行在给定维度`dim`上的对数求和指数。 |
| `mean` | 返回`input`张量中所有元素的均值。 |
| `nanmean` | 计算指定维度上所有非 NaN 元素的均值。 |
| `median` | 返回`input`中值的中位数。 |
| `nanmedian` | 返回`input`中值的中位数，忽略`NaN`值。 |
| `mode` | 返回一个命名元组`(values, indices)`，其中`values`是`input`张量每行在给定维度`dim`上的众数值，即在该行中出现最频繁的值，`indices`是找到的每个众数值的索引位置。 |
| `norm` | 返回给定张量的矩阵范数或向量范数。 |
| `nansum` | 返回所有元素的和，将非数值（NaN）视为零。 |
| `prod` | 返回`input`张量中所有元素的乘积。 |
| `quantile` | 计算`input`张量每行沿维度`dim`的 q 分位数。 |
| `nanquantile` | 这是`torch.quantile()`的一个变体，"忽略" `NaN` 值，计算`input`中的分位数`q`，就好像`input`中不存在`NaN`值一样。 |
| `std` | 计算由`dim`指定的维度上的标准差。 |
| `std_mean` | 计算由`dim`指定的维度上的标准差和均值。 |
| `sum` | 返回`input`张量中所有元素的和。 |
| `unique` | 返回输入张量的唯一元素。 |
| `unique_consecutive` | 消除每个连续等价元素组中除第一个元素之外的所有元素。 |
| `var` | 计算由`dim`指定的维度上的方差。 |
| `var_mean` | 计算由`dim`指定的维度上的方差和均值。 |
| `count_nonzero` | 计算张量`input`沿给定`dim`中的非零值的数量。 |

### Comparison Ops

| `allclose` | 此函数检查`input`和`other`是否满足条件： |
| --- | --- |
| `argsort` | 返回按值升序沿给定维度对张量进行排序的索引。 |
| `eq` | 计算逐元素相等 |
| `equal` | 如果两个张量具有相同的大小和元素，则为`True`，否则为`False`。 |
| `ge` | 计算$\text{input} \geq \text{other}$逐元素。 |
| `greater_equal` | `torch.ge()` 的别名。 |
| `gt` | 计算 $\text{input} > \text{other}$input>other 逐元素。 |
| `greater` | `torch.gt()` 的别名。 |
| `isclose` | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否与 `other` 的对应元素“接近”。 |
| `isfinite` | 返回一个新张量，其中的布尔元素表示每个元素是否为有限数。 |
| `isin` | 检查 `elements` 的每个元素是否在 `test_elements` 中。 |
| `isinf` | 检查 `input` 的每个元素是否为无穷大（正无穷大或负无穷大）。 |
| `isposinf` | 检查 `input` 的每个元素是否为正无穷大。 |
| `isneginf` | 检查 `input` 的每个元素是否为负无穷大。 |
| `isnan` | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否为 NaN。 |
| `isreal` | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否为实数或非实数。 |
| `kthvalue` | 返回一个命名元组 `(values, indices)`，其中 `values` 是 `input` 张量在给定维度 `dim` 中每行的第 `k` 小元素。 |
| `le` | 计算 $\text{input} \leq \text{other}$input≤other 逐元素。 |
| `less_equal` | `torch.le()` 的别名。 |
| `lt` | 计算 $\text{input} < \text{other}$input<other 逐元素。 |
| `less` | `torch.lt()` 的别名。 |
| `maximum` | 计算 `input` 和 `other` 的逐元素最大值。 |
| `minimum` | 计算 `input` 和 `other` 的逐元素最小值。 |
| `fmax` | 计算 `input` 和 `other` 的逐元素最大值。 |
| `fmin` | 计算 `input` 和 `other` 的逐元素最小值。 |
| `ne` | 计算 $\text{input} \neq \text{other}$input=other 逐元素。 |
| `not_equal` | `torch.ne()` 的别名。 |
| `sort` | 按值升序对 `input` 张量沿指定维度排序。 |
| `topk` | 返回给定 `input` 张量沿指定维度的前 `k` 个最大元素。 |
| `msort` | 按值升序对 `input` 张量沿其第一维排序。 |

### Spectral Ops

| `stft` | 短时傅里叶变换（STFT）。 |
| --- | --- |
| `istft` | 短时傅里叶逆变换。 |
| `bartlett_window` | Bartlett 窗口函数。 |
| `blackman_window` | Blackman 窗口函数。 |
| `hamming_window` | Hamming 窗口函数。 |
| `hann_window` | Hann 窗口函数。 |
| `kaiser_window` | 计算具有窗口长度`window_length`和形状参数`beta`的 Kaiser 窗口。 |

### 其他操作

| `atleast_1d` | 返回每个输入张量的零维视图的一维视图。 |
| --- | --- |
| `atleast_2d` | 返回每个输入张量的零维视图的二维视图。 |
| `atleast_3d` | 返回每个输入张量的零维视图的三维视图。 |
| `bincount` | 计算非负整数数组中每个值的频率。 |
| `block_diag` | 从提供的张量创建一个分块对角矩阵。 |
| `broadcast_tensors` | 根据广播语义广播给定的张量。 |
| `broadcast_to` | 将`input`广播到形状`shape`。 |
| `broadcast_shapes` | 类似于`broadcast_tensors()`，但用于形状。 |
| `bucketize` | 返回`input`中每个值所属的桶的索引，其中桶的边界由`boundaries`设置。 |
| `cartesian_prod` | 对给定的张量序列进行笛卡尔积。 |
| `cdist` | 计算两个行向量集合中每对之间的批次 p-范数距离。 |
| `clone` | 返回`input`的副本。 |
| `combinations` | 计算给定张量的长度为$r$的组合。 |
| `corrcoef` | 估计由`input`矩阵给出的变量的 Pearson 积矩相关系数矩阵，其中行是变量，列是观测。 |
| `cov` | 估计由`input`矩阵给出的变量的协方差矩阵，其中行是变量，列是观测。 |
| `cross` | 返回`input`和`other`在维度`dim`中向量的叉积。 |
| `cummax` | 返回一个命名元组`(values, indices)`，其中`values`是维度`dim`中`input`元素的累积最大值。 |
| `cummin` | 返回一个命名元组 `(values, indices)`，其中 `values` 是 `input` 在维度 `dim` 中元素的累积最小值。 |
| `cumprod` | 返回 `input` 在维度 `dim` 中元素的累积积。 |
| `cumsum` | 返回 `input` 在维度 `dim` 中元素的累积和。 |
| `diag` |

+   如果`input`是一个向量（1-D 张量），则返回一个 2-D 方形张量

|

| `diag_embed` | 创建一个张量，其中某些二维平面（由 `dim1` 和 `dim2` 指定）的对角线由 `input` 填充。 |
| --- | --- |
| `diagflat` |

+   如果`input`是一个向量（1-D 张量），则返回一个 2-D 方形张量

|

| `diagonal` | 返回 `input` 的部分视图，其对角线元素相对于 `dim1` 和 `dim2` 附加为形状末尾的维度。 |
| --- | --- |
| `diff` | 计算沿给定维度的第 n 个前向差分。 |
| `einsum` | 按照基于 Einstein 求和约定的符号，沿着指定维度对输入`operands`的元素的乘积求和。 |
| `flatten` | 通过将其重新形状为一维张量来展平 `input`。 |
| `flip` | 沿着给定轴在 dims 中反转 n-D 张量的顺序。 |
| `fliplr` | 在左/右方向上翻转张量，返回一个新的张量。 |
| `flipud` | 在上/下方向上翻转张量，返回一个新的张量。 |
| `kron` | 计算 `input` 和 `other` 的 Kronecker 积，表示为 $\otimes$⊗。 |
| `rot90` | 将 n-D 张量按 dims 轴指定的平面旋转 90 度。 |
| `gcd` | 计算 `input` 和 `other` 的逐元素最大公约数（GCD）。 |
| `histc` | 计算张量的直方图。 |
| `histogram` | 计算张量中值的直方图。 |
| `histogramdd` | 计算张量中值的多维直方图。 |
| `meshgrid` | 创建由属性`tensors`中的 1D 输入指定的坐标网格。 |
| `lcm` | 计算 `input` 和 `other` 的逐元素最小公倍数（LCM）。 |
| `logcumsumexp` | 返回 `input` 元素的指数的累积求和的对数，维度为 `dim`。 |
| `ravel` | 返回一个连续的展平张量。 |
| `renorm` | 返回一个张量，其中沿着维度`dim`的每个子张量被归一化，使得子张量的 p-范数低于值`maxnorm` |
| `repeat_interleave` | 重复张量的元素。 |
| `roll` | 沿给定维度滚动张量`input`。 |
| `searchsorted` | 找到`sorted_sequence`的*最内层*维度中的索引，使得如果将`values`中的相应值插入到这些索引之前，排序后，`sorted_sequence`中的*最内层*维度的顺序将被保留。 |
| `tensordot` | 在多个维度上返回 a 和 b 的收缩。 |
| `trace` | 返回输入 2-D 矩阵对角线元素的和。 |
| `tril` | 返回矩阵（2-D 张量）或批量矩阵`input`的下三角部分，结果张量`out`的其他元素设置为 0。 |
| `tril_indices` | 返回`row`-by-`col`矩阵的下三角部分的索引，以 2xN 张量的形式返回，其中第一行包含所有索引的行坐标，第二行包含列坐标。 |
| `triu` | 返回矩阵（2-D 张量）或批量矩阵`input`的上三角部分，结果张量`out`的其他元素设置为 0。 |
| `triu_indices` | 返回`row`乘以`col`矩阵的上三角部分的索引，以 2xN 张量的形式返回，其中第一行包含所有索引的行坐标，第二行包含列坐标。 |
| `unflatten` | 将输入张量的一个维度扩展到多个维度。 |
| `vander` | 生成 Vandermonde 矩阵。 |
| `view_as_real` | 将`input`作为实数张量返回视图。 |
| `view_as_complex` | 将`input`作为复数张量返回视图。 |
| `resolve_conj` | 如果`input`的共轭位设置为 True，则返回具有实现共轭的新张量，否则返回`input`。 |
| `resolve_neg` | 如果`input`的负位设置为 True，则返回具有实现否定的新张量，否则返回`input`。 |

### BLAS 和 LAPACK 操作

| `addbmm` | 对存储在`batch1`和`batch2`中的矩阵执行批量矩阵乘法，具有减少的加法步骤（所有矩阵乘法沿第一维度累积）。 |
| --- | --- |
| `addmm` | 执行矩阵`mat1`和`mat2`的矩阵乘法。 |
| `addmv` | 执行矩阵`mat`和向量`vec`的矩阵-向量乘积。 |
| `addr` | 执行向量`vec1`和`vec2`的外积，并将其添加到矩阵`input`中。 |
| `baddbmm` | 对`batch1`和`batch2`中的矩阵执行批量矩阵乘法。 |
| `bmm` | 对存储在`input`和`mat2`中的矩阵执行批量矩阵乘法。 |
| `chain_matmul` | 返回$N$个 2-D 张量的矩阵乘积。 |
| `cholesky` | 计算对称正定矩阵$A$A 或对称正定矩阵批次的 Cholesky 分解。 |
| `cholesky_inverse` | 计算具有 Cholesky 分解的复 Hermite 或实对称正定矩阵的逆矩阵。 |
| `cholesky_solve` | 计算具有 Cholesky 分解的复 Hermite 或实对称正定 lhs 的线性方程组的解。 |
| `dot` | 计算两个 1D 张量的点积。 |
| `geqrf` | 这是一个直接调用 LAPACK 的 geqrf 的低级函数。 |
| `ger` | `torch.outer()`的别名。 |
| `inner` | 计算 1D 张量的点积。 |
| `inverse` | `torch.linalg.inv()`的别名 |
| `det` | `torch.linalg.det()`的别名 |
| `logdet` | 计算方阵或方阵批次的对数行列式。 |
| `slogdet` | `torch.linalg.slogdet()`的别名 |
| `lu` | 计算矩阵或矩阵批次`A`的 LU 分解。 |
| `lu_solve` | 使用从`lu_factor()`得到的 A 的部分主元 LU 分解返回线性系统$Ax = b$Ax=b 的 LU 解。 |
| `lu_unpack` | 将`lu_factor()`返回的 LU 分解解包成 P、L、U 矩阵。 |
| `matmul` | 两个张量的矩阵乘积。 |
| `matrix_power` | `torch.linalg.matrix_power()`的别名 |
| `matrix_exp` | `torch.linalg.matrix_exp()`的别名。 |
| `mm` | 计算矩阵`input`和`mat2`的矩阵乘法。 |
| `mv` | 计算矩阵`input`和向量`vec`的矩阵-向量乘积。 |
| `orgqr` | `torch.linalg.householder_product()`的别名。 |
| `ormqr` | 计算 Householder 矩阵乘积与一般矩阵的矩阵-矩阵乘积。 |
| `outer` | `input` 和 `vec2` 的外积。 |
| `pinverse` | `torch.linalg.pinv()` 的别名 |
| `qr` | 计算矩阵或批量矩阵 `input` 的 QR 分解，并返回一个命名元组 (Q, R)，使得 $\text{input} = Q R$input=QR，其中 $Q$Q 是正交矩阵或批量正交矩阵，$R$R 是上三角矩阵或批量上三角矩阵。 |
| `svd` | 计算矩阵或矩阵批次 `input` 的奇异值分解。 |
| `svd_lowrank` | 返回矩阵、矩阵批次或稀疏矩阵 $A$A 的奇异值分解 `(U, S, V)`，使得 $A \approx U diag(S) V^T$A≈Udiag(S)VT。 |
| `pca_lowrank` | 对低秩矩阵、这类矩阵批次或稀疏矩阵执行线性主成分分析（PCA）。 |
| `lobpcg` | 使用无矩阵 LOBPCG 方法找到对称正定广义特征值问题的 k 个最大（或最小）特征值及其对应的特征向量。 |
| `trapz` | `torch.trapezoid()` 的别名。 |
| `trapezoid` | 计算沿着 `dim` 的 [梯形法则](https://en.wikipedia.org/wiki/Trapezoidal_rule)。 |
| `cumulative_trapezoid` | 累积计算沿着 `dim` 的 [梯形法则](https://en.wikipedia.org/wiki/Trapezoidal_rule)。 |
| `triangular_solve` | 解一个具有方形上三角或下三角可逆矩阵 $A$A 和多个右侧的方程组 $b$b。 |
| `vdot` | 计算沿着一个维度的两个 1D 向量的点积。 |

### Foreach 操作

警告

此 API 处于 beta 阶段，可能会有未来更改。不支持正向模式自动微分。

| `_foreach_abs` | 对输入列表中的每个张量应用 `torch.abs()`。 |
| --- | --- |
| `_foreach_abs_` | 对输入列表中的每个张量应用 `torch.abs()`。 |
| `_foreach_acos` | 对输入列表中的每个张量应用 `torch.acos()`。 |
| `_foreach_acos_` | 对输入列表中的每个张量应用 `torch.acos()`。 |
| `_foreach_asin` | 对输入列表中的每个张量应用 `torch.asin()`。 |
| `_foreach_asin_` | 对输入列表中的每个张量应用 `torch.asin()`。 |
| `_foreach_atan` | 对输入列表中的每个张量应用 `torch.atan()`。 |
| `_foreach_atan_` | 对输入列表中的每个张量应用 `torch.atan()`。 |
| `_foreach_ceil` | 对输入列表中的每个张量应用 `torch.ceil()`。 |
| `_foreach_ceil_` | 对输入列表中的每个张量应用 `torch.ceil()`。 |
| `_foreach_cos` | 对输入列表中的每个张量应用 `torch.cos()`。 |
| `_foreach_cos_` | 对输入列表中的每个张量应用 `torch.cos()`。 |
| `_foreach_cosh` | 对输入列表中的每个张量应用 `torch.cosh()`。 |
| `_foreach_cosh_` | 对输入列表中的每个张量应用 `torch.cosh()`。 |
| `_foreach_erf` | 对输入列表中的每个张量应用 `torch.erf()`。 |
| `_foreach_erf_` | 对输入列表中的每个张量应用 `torch.erf()`。 |
| `_foreach_erfc` | 对输入列表中的每个张量应用 `torch.erfc()`。 |
| `_foreach_erfc_` | 对输入列表中的每个张量应用 `torch.erfc()`。 |
| `_foreach_exp` | 对输入列表中的每个张量应用 `torch.exp()`。 |
| `_foreach_exp_` | 对输入列表中的每个张量应用 `torch.exp()`。 |
| `_foreach_expm1` | 对输入列表中的每个张量应用 `torch.expm1()`。 |
| `_foreach_expm1_` | 对输入列表中的每个张量应用 `torch.expm1()`。 |
| `_foreach_floor` | 对输入列表中的每个张量应用 `torch.floor()`。 |
| `_foreach_floor_` | 对输入列表中的每个张量应用 `torch.floor()`。 |
| `_foreach_log` | 对输入列表中的每个张量应用 `torch.log()`。 |
| `_foreach_log_` | 对输入列表中的每个张量应用 `torch.log()`。 |
| `_foreach_log10` | 对输入列表中的每个张量应用 `torch.log10()`。 |
| `_foreach_log10_` | 对输入列表中的每个张量应用 `torch.log10()`。 |
| `_foreach_log1p` | 对输入列表中的每个张量应用 `torch.log1p()`。 |
| `_foreach_log1p_` | 对输入列表中的每个张量应用 `torch.log1p()`。 |
| `_foreach_log2` | 对输入列表中的每个张量应用 `torch.log2()`。 |
| `_foreach_log2_` | 对输入列表中的每个张量应用 `torch.log2()`。 |
| `_foreach_neg` | 对输入列表中的每个张量应用 `torch.neg()`。 |
| `_foreach_neg_` | 对输入列表中的每个张量应用 `torch.neg()`。 |
| `_foreach_tan` | 对输入列表中的每个张量应用 `torch.tan()`。 |
| `_foreach_tan_` | 对输入列表中的每个张量应用 `torch.tan()`。 |
| `_foreach_sin` | 对输入列表中的每个张量应用 `torch.sin()`。 |
| `_foreach_sin_` | 对输入列表中的每个张量应用 `torch.sin()`。 |
| `_foreach_sinh` | 对输入列表中的每个张量应用 `torch.sinh()`。 |
| `_foreach_sinh_` | 对输入列表中的每个张量应用 `torch.sinh()`。 |
| `_foreach_round` | 对输入列表中的每个张量应用 `torch.round()`。 |
| `_foreach_round_` | 对输入列表中的每个张量应用 `torch.round()`。 |
| `_foreach_sqrt` | 对输入列表中的每个张量应用 `torch.sqrt()`。 |
| `_foreach_sqrt_` | 对输入列表中的每个张量应用 `torch.sqrt()`。 |
| `_foreach_lgamma` | 对输入列表中的每个张量应用 `torch.lgamma()`。 |
| `_foreach_lgamma_` | 对输入列表中的每个张量应用 `torch.lgamma()`。 |
| `_foreach_frac` | 对输入列表中的每个张量应用 `torch.frac()`。 |
| `_foreach_frac_` | 对输入列表中的每个张量应用 `torch.frac()`。 |
| `_foreach_reciprocal` | 对输入列表中的每个张量应用 `torch.reciprocal()`。 |
| `_foreach_reciprocal_` | 对输入列表中的每个张量应用 `torch.reciprocal()`。 |
| `_foreach_sigmoid` | 对输入列表中的每个张量应用 `torch.sigmoid()`。 |
| `_foreach_sigmoid_` | 对输入列表中的每个张量应用 `torch.sigmoid()`。 |
| `_foreach_trunc` | 对输入列表中的每个张量应用 `torch.trunc()`。 |
| `_foreach_trunc_` | 对输入列表中的每个张量应用 `torch.trunc()`。 |
| `_foreach_zero_` | 对输入列表中的每个张量应用 `torch.zero()`。 |

## Utilities

| `compiled_with_cxx11_abi` | 返回 PyTorch 是否使用 _GLIBCXX_USE_CXX11_ABI=1 构建。 |
| --- | --- |
| `result_type` | 返回在提供的输入张量上执行算术运算后将产生的 `torch.dtype`。 |
| `can_cast` | 确定在 PyTorch 类型转换规则下是否允许类型转换，规则描述在类型提升 文档中。 |
| `promote_types` | 返回具有不小于 type1 或 type2 的大小和标量类型的 `torch.dtype`。 |
| `use_deterministic_algorithms` | 设置 PyTorch 操作是否必须使用“确定性”算法。 |
| `are_deterministic_algorithms_enabled` | 如果全局确定性标志打开，则返回 True。 |
| `is_deterministic_algorithms_warn_only_enabled` | 如果全局确定性标志设置为仅警告，则返回 True。 |
| `set_deterministic_debug_mode` | 设置确定性操作的调试模式。 |
| `get_deterministic_debug_mode` | 返回确定性操作的调试模式的当前值。 |
| `set_float32_matmul_precision` | 设置 float32 矩阵乘法的内部精度。 |
| `get_float32_matmul_precision` | 返回 float32 矩阵乘法精度的当前值。 |
| `set_warn_always` | 当此标志为 False（默认）时，一些 PyTorch 警告可能只会在进程中出现一次。 |
| `is_warn_always_enabled` | 如果全局的 warn_always 标志打开，则返回 True。 |
| `vmap` | vmap 是矢量化映射；`vmap(func)`返回一个新函数，该函数将`func`映射到输入的某个维度上。 |
| `_assert` | Python 的 assert 的包装器，可进行符号跟踪。 |

## 符号数字

```py
class torch.SymInt(node)¶
```

像一个整数（包括魔术方法），但重定向包装节点上的所有操作。这特别用于在符号形状工作流程中符号记录操作。

```py
class torch.SymFloat(node)¶
```

像一个浮点数（包括魔术方法），但重定向包装节点上的所有操作。这特别用于在符号形状工作流程中符号记录操作。

```py
class torch.SymBool(node)¶
```

像一个布尔值（包括魔术方法），但重定向包装节点上的所有操作。这特别用于在符号形状工作流程中符号记录操作。

与常规布尔值不同，常规布尔运算符会强制额外的保护而不是符号化评估。请改用位运算符来处理这个问题。

| `sym_float` | 用于浮点数转换的 SymInt 感知实用程序。 |
| --- | --- |
| `sym_int` | 用于整数转换的 SymInt 感知实用程序。 |
| `sym_max` | 用于 max()的 SymInt 感知实用程序。 |
| `sym_min` | 用于 max()的 SymInt 感知实用程序。 |
| `sym_not` | 用于逻辑否定的 SymInt 感知实用程序。 |
| `sym_ite` |  |

## 导出路径

警告

此功能是一个原型，未来可能会有兼容性破坏性的更改。

导出生成的/exportdb/index

## 控制流

警告

此功能是一个原型，未来可能会有兼容性破坏性的更改。

| `cond` | 有条件地应用 true_fn 或 false_fn。 |
| --- | --- |

## 优化

| `compile` | 使用 TorchDynamo 和指定的后端优化给定的模型/函数。 |
| --- | --- |

[torch.compile 文档](https://pytorch.org/docs/main/compile/index.html)

## 操作符标签

```py
class torch.Tag¶
```

成员：

核心

数据相关输出

动态输出形状

生成的

原地视图

非确定性位运算

非确定性种子

逐点

pt2 兼容标签

视图复制

```py
property name¶
```