torch

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

它有一个CUDA版本，使您能够在NVIDIA GPU上运行张量计算，前提是该GPU的计算能力>=3.0。

张量


`is_tensor`	如果 obj 是一个 PyTorch 张量，则返回 True。
`is_storage`	如果 obj 是一个 PyTorch 存储对象，则返回 True。
`is_complex`	如果数据类型为`input`是一个复杂的数据类型，即`torch.complex64`, 以及`torch.complex128`
`is_conj`	如果`input`is a conjugated tensor, 即其共轭位设置为True。
`is_floating_point`	如果数据类型为`input`是一个浮点数据类型，即`torch.float64`,`torch.float32`,`torch.float16`, 以及`torch.bfloat16`
`is_nonzero`	如果`input`is a single element tensor which is not equal to zero after type conversions.
`set_default_dtype`	设置默认的浮点数数据类型为`d`
`get_default_dtype`	获取当前默认浮点数`torch.dtype`
`set_default_device`	设置默认值`torch.Tensor`要分配在`device`
`get_default_device`	获取默认值`torch.Tensor`要分配在`device`
`set_default_tensor_type`
`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.Tensors。


`tensor`	构造一个没有自动求导历史的张量（也称为“叶子张量”，请参见自动微分机制）通过复制`data`
`sparse_coo_tensor`	构造稀疏张量（COO 格式）指定值在给定的位置`indices`
`sparse_csr_tensor`	构造稀疏张量在CSR（压缩行_sparse）中指定值在给定的位置`crow_indices`和`col_indices`
`sparse_csc_tensor`	构造稀疏张量在CSC（压缩稀疏列）格式中指定值在给定的位置`ccol_indices`和`row_indices`
`sparse_bsr_tensor`	构造稀疏张量在BSR（分块压缩行_sparse）中with指定的二维块在给定的位置`crow_indices`和`col_indices`
`sparse_bsc_tensor`	构造稀疏张量在BSC（块压缩列 sparse）格式中with指定的二维块在给定的位置`ccol_indices`和`row_indices`
`asarray`	转换`obj`转为张量。
`as_tensor`	转换`data`转换为张量，共享数据并在可能的情况下保留自动求导历史。
`as_strided`	创建一个现有 torch.Tensor 的视图`input`with 指定的`size`,`stride`和`storage_offset`
`from_file`	创建一个由内存映射文件支持的CPU张量。
`from_numpy`	创建一个`Tensor`from a`numpy.ndarray`
`from_dlpack`	将外部库中的张量转换为`torch.Tensor`
`frombuffer`	创建一个一维`Tensor`来自实现Python缓冲协议的对象。
`zeros`	返回一个填满标量值 0 的张量，其形状由变量参数定义`size`
`zeros_like`	返回一个填满标量值 0 的张量，大小与`input`
`ones`	返回一个填满标量值1的张量，其形状由变量参数定义`size`
`ones_like`	返回一个填满标量值1的张量，大小与`input`
`arange`	返回一个大小为$\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil$的一维张量，其中包含区间内的值`[start, end)`taken with 公共差异`step`从开始处
`range`	返回一个大小为$\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor + 1$的一维张量，其值从`start`to`end`with步长`step`
`linspace`	创建一个大小为一维张量`steps`其值均匀间隔`start`to`end`, 包括在内。
`logspace`	创建一个大小为一维张量`steps`其值在以${{\text{{base}}}}^{{\text{{start}}}}$到${{\text{{base}}}}^{{\text{{end}}}}$（包括两端）为范围的对数尺度上均匀分布，底数为`base`
`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`and its imaginary part equal to`imag`
`polar`	构造一个复数张量，其元素是对应于极坐标绝对值的笛卡尔坐标`abs`和角度`angle`
`heaviside`	计算每个元素的海维赛德阶梯函数`input`

索引、切片、连接、变异操作


`adjoint`	返回张量共轭视图，且最后两个维度转置。
`argwhere`	返回一个张量，其中包含所有非零元素的索引。`input`
`cat`	连接给定的序列`seq`张量在给定维度中。
`concat`	别名`torch.cat()`
`concatenate`	别名`torch.cat()`
`conj`	返回一个视图`input`带有共轭位翻转的。
`chunk`	尝试将张量分成指定数量的部分。
`dsplit`	分割`input`, 一个具有三个或更多维度的张量，根据深度分成多个张量。`indices_or_sections`
`column_stack`	通过水平堆叠张量创建一个新的张量`tensors`
`dstack`	按深度顺序堆叠张量（沿第三个轴）。
`gather`	沿着由dim指定的轴收集值。
`hsplit`	分割`input`，一个具有一个或多个维度的张量，根据水平方向分割成多个张块。`indices_or_sections`
`hstack`	按列顺序水平堆叠张量。
`index_add`	参见`index_add_()`用于函数描述。
`index_copy`	参见`index_add_()`用于函数描述。
`index_reduce`	参见`index_reduce_()`用于函数描述。
`index_select`	返回一个新的张量，该张量通过索引得到`input`沿着维度张量`dim`使用条目中的内容`index`这是一个LongTensor。
`masked_select`	返回一个新的 1-D 张量，该张量通过索引`input`根据布尔掩码调整张量`mask`这是一个BoolTensor。
`movedim`	移动维度`input`在位置(s)处`source`到位置（s）中`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`沿着对角线元素`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维张量，并交换第0和第1维。
`take`	返回一个新张量，其中包含元素`input`在给定的索引处。
`take_along_dim`	选择值从`input`在1维索引处`indices`沿着给定的`dim`
`tensor_split`	将张量分割为多个子张量，所有子张量均为原张量的视图。`input`, 沿着维度`dim`根据指定的索引或节的数量`indices_or_sections`
`tile`	通过重复元素来构建张量`input`
`transpose`	返回一个转置版本的张量`input`
`unbind`	移除张量维度。
`unravel_index`	将一个扁平索引张量转换为一组坐标张量，这些张量用于根据指定形状访问任意张量。
`unsqueeze`	返回一个在指定位置插入大小为一的新维度的张量。
`vsplit`	分割`input`, 将一个具有两个或更多维度的张量垂直分成多个张块`indices_or_sections`
`vstack`	按行顺序垂直堆叠张量。
`where`	返回一个元素从以下任选其一组成的张量`input`or`other`, 根据`condition`

加速器

在 PyTorch 仓库中，我们将“加速器”定义为与 CPU 配合使用的 torch.device，以加快计算速度。这些设备采用异步执行方案，主要通过 torch.Stream 和 torch.Event 来实现同步。我们还假设在给定主机上一次只能有一个加速器可用。这使我们可以将当前加速器用作相关概念（如固定内存、Stream 设备类型、FSDP 等）的默认设备。

截至今日，加速器设备包括（无特定顺序）“CUDA”、“MTIA”、“XPU”，以及PrivateUse1（许多设备不在PyTorch仓库本身中）。


`Stream`	按先进先出（FIFO）顺序异步执行相应任务的有序队列。
`Event`	查询并记录流状态，以识别或控制流之间的依赖关系，并测量时间。

生成器


`Generator`	创建并返回一个管理生成伪随机数算法状态的生成器对象。

随机采样


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

torch.default_generator 返回默认的CPU torch.Generator


`bernoulli`	从伯努利分布中绘制二进制随机数（0或1）。
`multinomial`	返回一个张量，其中每一行包含`num_samples`从多项式中抽取的索引（更严格的定义是多元的，参见)`torch.distributions.multinomial.Multinomial`对于更多细节，请参阅该张量对应行的概率分布`input`
`normal`	返回一个张量，其中包含从各自独立的正态分布中抽取的随机数，其均值和标准差由给定参数决定。
`poisson`	返回与原张量大小相同的张量`input`with each element sampled from a Poisson分布，其速率参数由对应元素给出`input`即
`rand`	返回一个填满区间$[0, 1)$均匀分布随机数的张量
`rand_like`	返回一个与原张量大小相同的张量`input`该张量由区间$[0, 1)$上的均匀分布随机数填充。
`randint`	返回一个填满在均匀分布区间内生成的随机整数张量`low`(包含在内的)和`high`(独家)
`randint_like`	返回一个与张量形状相同的张量`input`filled with random integers generated uniformly between`low`(包含在内的)和`high`(独家)
`randn`	返回一个充满均值为0，方差为1的正态分布随机数的张量（也称为标准正态分布）。
`randn_like`	返回一个与原张量大小相同的张量`input`这个张量由均值为0、方差为1的正态分布随机数填充。
`randperm`	返回从`0`to`n - 1`

就地随机采样

还有几个在张量上定义的原地随机采样函数。点击查阅它们的文档：

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`	The`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`	设置用于互操作并行的线程数量（例如

局部禁用梯度计算

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

示例：

>>> 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`	启用梯度计算的上下文管理器。
`autograd.grad_mode.set_grad_enabled`	上下文管理器，用于设置梯度计算的开启或关闭。
`is_grad_enabled`	如果当前启用梯度模式，则返回 True。
`autograd.grad_mode.inference_mode`	上下文管理器，用于启用或禁用推理模式。
`is_inference_mode_enabled`	如果当前启用了推理模式，则返回 True。

数学运算

点态运算


`abs`	计算每个元素的绝对值`input`
`absolute`	别名用于`torch.abs()`
`acos`	计算每个元素的反余弦值`input`
`arccos`	别名用于`torch.acos()`
`acosh`	返回一个新张量，其中包含元素的反双曲余弦值。`input`
`arccosh`	别名用于`torch.acosh()`
`add`	添加了`other`, 按比例缩放`alpha`, 到`input`
`addcdiv`	执行元素的除法`tensor1`by`tensor2`, 将结果乘以标量`value`并将其添加到`input`
`addcmul`	执行元素乘法`tensor1`by`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`	逐元素反正切$\text{input}{i} / \text{other}{i}$，考虑象限。
`arctan2`	别名用于`torch.atan2()`
`bitwise_not`	计算给定输入张量的按位非运算。
`bitwise_and`	计算按位与`input`和`other`
`bitwise_or`	计算按位或`input`和`other`
`bitwise_xor`	计算按位异或`input`和`other`
`bitwise_left_shift`	计算左算术移位`input`by`other`位。
`bitwise_right_shift`	计算正确的算术右移`input`by`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`	返回一个新张量，其中包含数据`input`使用伪量化逐通道`scale`,`zero_point`,`quant_min`和`quant_max`, 指定通道`axis`
`fake_quantize_per_tensor_affine`	返回一个新张量，其中包含数据`input`使用假量化`scale`,`zero_point`,`quant_min`和`quant_max`
`fix`	别名用于`torch.trunc()`
`float_power`	`input`到… 的幂`exponent`, 元素级，双精度。
`floor`	返回一个新张量，其中包含元素的地板值`input`, 每个元素不大于的最大整数。
`floor_divide`
`fmod`	应用C++的std::fmod逐项。
`frac`	计算每个元素的小数部分`input`
`frexp`	分解`input`将张量分解为尾数和指数张量，使得$\text{input} = \text{mantissa} \times 2^{\text{exponent}}$。
`gradient`	估计函数$g : \mathbb{R}^n \rightarrow \mathbb{R}$在1个或多个维度中的梯度二阶精度中心差分方法并且在边界处要么是一阶估计，要么是二阶估计。
`imag`	返回一个新的张量，其中包含虚数部分。`self`张量。
`ldexp`	乘法`input`by 2 **`other`
`lerp`	两个张量的线性插值是否正确`start`(由`input`) 和`end`基于标量或张量`weight`并返回结果`out`张量。
`lgamma`	计算绝对值的自然对数伽马函数`input`
`log`	返回一个新张量，其中包含元素的自然对数。`input`
`log10`	返回一个新张量，其中包含元素的以10为底的对数。`input`
`log1p`	返回一个新的张量，其中包含（1加`input`
`log2`	返回一个新张量，其中包含元素的以2为底的对数。`input`
`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`by`other`
`multiply`	别名用于`torch.mul()`
`mvlgamma`	别名用于`torch.special.multigammaln()`
`nan_to_num`	替换`NaN`, 正无穷大，和负无穷大值在`input`with the values specified by`nan`,`posinf`, 以及`neginf`, 分别。
`neg`	返回一个新张量，其中包含原元素的负数`input`
`negative`	别名用于`torch.neg()`
`nextafter`	返回下一个浮点数`input`向`other`, 元素级。
`polygamma`	别名用于`torch.special.polygamma()`
`positive`	返回`input`
`pow`	取每个元素的幂`input`with`exponent`并返回一个包含结果的张量。
`quantized_batch_norm`	在4D（NCHW）量化张量上应用批归一化。
`quantized_max_pool1d`	对一个由多个输入平面组成的定量输入张量应用一维最大池化。
`quantized_max_pool2d`	对一个由多个输入平面组成的量化输入张量应用二维最大池化。
`rad2deg`	返回一个新张量，其中包含每个元素。`input`转换为度数，从弧度表示的角度转换而来。
`real`	返回一个新的张量，其中包含实数值`self`张量。
`reciprocal`	返回一个新张量，其中包含元素的倒数`input`
`remainder`	计算Python 的取模运算逐项。
`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`	减去`other`, 按比例缩放`alpha`, 从`input`
`subtract`	别名用于`torch.sub()`
`tan`	返回一个新张量，其中包含元素的正切值。`input`
`tanh`	返回一个新张量，其中包含元素的双曲正切值。`input`
`true_divide`	别名用于`torch.div()`with`rounding_mode=None`
`trunc`	返回一个新张量，其中包含元素的截断整数值。`input`
`xlogy`	别名用于`torch.special.xlogy()`

减少操作


`argmax`	返回所有元素中的最大值的索引`input`张量。
`argmin`	返回展平张量或某个维度中最小值的索引
`amax`	返回每个切片的最大值`input`在给定维度中的张量`dim`
`amin`	返回每个切片的最小值`input`在给定维度中的张量`dim`
`aminmax`	计算张量的最小值和最大值`input`张量。
`all`	Tests if all elements in`input`评估为True。
`any`	测试是否有任何元素在`input`评估为真。
`max`	返回所有元素的最大值`input`张量。
`min`	返回所有元素中的最小值`input`张量。
`dist`	返回 ( 的 p-范数`input`-`other`
`logsumexp`	返回每行指数和的对数`input`在给定维度中的张量`dim`
`mean`	返回所有元素的平均值`input`张量。
`nanmean`	计算指定维度上所有非NaN元素的平均值。
`median`	返回值中数值的中位数`input`
`nanmedian`	返回值中数值的中位数`input`,忽略`NaN`values.
`mode`	返回一个命名元组`(values, indices)`where`values`是每行的模式值`input`在给定维度中的张量`dim`, 即该行中出现次数最多的值，`indices`是每个模式值找到的位置索引。
`norm`	返回给定张量的矩阵范数或向量范数。
`nansum`	返回所有元素的总和，将“不是数字”（NaN）视为零。
`prod`	返回所有元素的乘积`input`张量。
`quantile`	计算每个行的q分位数`input`沿着维度张量`dim`
`nanquantile`	这是`torch.quantile()`that "忽略"`NaN`计算分位数的值`q`好像`NaN`values in`input`不存在。
`std`	计算在指定维度上的标准差`dim`
`std_mean`	在指定维度上计算标准差和均值`dim`
`sum`	返回所有元素的总和`input`张量。
`unique`	返回输入张量中的唯一元素。
`unique_consecutive`	消除所有连续相同元素组中除第一个之外的所有元素。
`var`	计算沿着指定维度的方差`dim`
`var_mean`	根据指定维度计算方差和均值`dim`
`count_nonzero`	统计张量中非零值的数量`input`沿着给定的`dim`

比较操作


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

光谱操作


`stft`	短时傅里叶变换（STFT）。
`istft`	逆短时傅里叶变换。
`bartlett_window`	巴特利特窗口函数。
`blackman_window`	布莱克曼窗函数。
`hamming_window`	汉明窗函数。
`hann_window`	汉宁窗函数。
`kaiser_window`	计算带有窗口长度的凯撒窗`window_length`和形状参数`beta`

其他操作


`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`矩阵，其中行是变量，列是观测值。
`cov`	估计给定变量的协方差矩阵`input`矩阵，其中行是变量，列是观测值。
`cross`	返回向量在维度中的叉乘`dim`of`input`和`other`
`cummax`	返回一个命名元组`(values, indices)`where`values`是元素的累积最大值`input`在该维度中`dim`
`cummin`	返回一个命名元组`(values, indices)`where`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`with the its diagonal elements with respect to`dim1`和`dim2`附加为形状末尾的一个维度。
`diff`	计算沿指定维度的第n个前向差分。
`einsum`	将输入元素的乘积求和`operands`沿基于爱因斯坦求和约定的指定维度。
`flatten`	展平`input`通过将其重塑为一维张量。
`flip`	沿给定轴在dims中反转n维张量的顺序。
`fliplr`	将张量从左向右翻转，返回一个新的张量。
`flipud`	将张量沿上/下方向翻转，返回一个新的张量。
`kron`	计算克罗内克积，表示为$\otimes$，`input`和`other`
`rot90`	将一个n维张量在由dims轴指定的平面中旋转90度。
`gcd`	计算元素的最大公约数（GCD）`input`和`other`
`histc`	计算张量的直方图。
`histogram`	计算张量中值的直方图。
`histogramdd`	计算张量中值的多维直方图。
`meshgrid`	创建由attr:tensors中的一维输入指定的坐标网格。
`lcm`	计算元素的最小公倍数（LCM）`input`和`other`
`logcumsumexp`	返回指数元素累积求和的对数`input`在该维度中`dim`
`ravel`	返回一个连续展平的张量。
`renorm`	返回一个张量，其中每个子张量`input`沿维度`dim`is normalized such that the p-norm of the sub-tensor is lower than the value`maxnorm`
`repeat_interleave`	重复张量中的元素。
`roll`	滚动张量`input`沿给定维度（或多个维度）。
`searchsorted`	从内部维度`sorted_sequence`such that, if the corresponding values in`values`当按排序顺序插入索引之前，相应项的顺序内部维度内部`sorted_sequence`将被保留。
`tensordot`	返回a和b在多个维度上的约简。
`trace`	返回输入二维矩阵对角线元素之和。
`tril`	返回矩阵（二维张量）或一批矩阵的下三角部分`input`, 结果张量的其他元素`out`设置为0。
`tril_indices`	返回矩阵的下三角部分的索引`row`*by-`col`将索引表示为一个2×N张量，其中第一行包含所有索引的行坐标，第二行包含所有索引的列坐标。
`triu`	返回矩阵（二维张量）或一批矩阵的上三角部分`input`, 结果张量的其他元素`out`设置为0。
`triu_indices`	返回矩阵上三角部分的索引`row`by`col`将索引表示为一个2×N张量，其中第一行包含所有索引的行坐标，第二行包含所有索引的列坐标。
`unflatten`	扩展输入张量的一个维度到多个维度。
`vander`	生成范德蒙矩阵。
`view_as_real`	返回一个视图`input`作为真正的张量。
`view_as_complex`	返回一个视图`input`作为一个复杂的张量。
`resolve_conj`	返回一个带有实现实共轭的新张量`input`'s 共轭位设置为 True，否则返回`input`
`resolve_neg`	返回一个带有实际否定的新张量如果`input`'s 负数位设置为 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$的Cholesky分解，或对一批对称正定矩阵进行Cholesky分解。
`cholesky_inverse`	计算给定其Cholesky分解的复厄米特或实对称正定矩阵的逆。
`cholesky_solve`	计算具有其Cholesky分解的复Hermitian或实对称正定系数矩阵的线性方程组的解。
`dot`	计算两个1D张量的点积。
`geqrf`	这是一个调用LAPACK的geqrf函数的低级方法。
`ger`	别名`torch.outer()`
`inner`	计算一维张量的点积。
`inverse`	别名用于`torch.linalg.inv()`
`det`	别名用于`torch.linalg.det()`
`logdet`	计算正方形矩阵或一批正方形矩阵的对数行列式。
`slogdet`	别名用于`torch.linalg.slogdet()`
`lu`	计算矩阵或矩阵批次的LU分解`A`
`lu_solve`	返回线性系统 $Ax = b$ 的 LU 解，该解使用矩阵 A 的部分选主元 LU 分解得到。`lu_factor()`
`lu_unpack`	分解由`lu_factor()`分解为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`	计算矩阵或矩阵批次的QR分解`input`并返回一个命名元组（Q，R），其中包含张量，使得$\text{input} = Q R$，其中$Q$是一个正交矩阵或一批正交矩阵，而$R$是一个上三角矩阵或一批上三角矩阵。
`svd`	计算矩阵或矩阵批次的奇异值分解`input`
`svd_lowrank`	返回奇异值分解`(U, S, V)`矩阵、矩阵批次或稀疏矩阵 $A$，使得 $A \approx U \operatorname{diag}(S) V^{\text{H}}$。
`pca_lowrank`	执行线性主成分分析（PCA）在低秩矩阵、此类矩阵的批处理或稀疏矩阵上。
`lobpcg`	使用矩阵无LOBPCG方法求解对称正定广义特征值问题中k个最大（或最小）的特征值及其对应的特征向量。
`trapz`	别名用于`torch.trapezoid()`
`trapezoid`	计算梯形法则along`dim`
`cumulative_trapezoid`	逐步计算梯形法则along`dim`
`triangular_solve`	求解一个方程组，该方程组具有平方上三角或下三角可逆矩阵$A$和多个右侧向量$b$。
`vdot`	计算两个1D向量沿某一维的点积。

遍历操作

警告

此API处于测试阶段，可能会在未来发生变化。前向模式自动微分尚未得到支持。


`_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()`将每个张量输入列表中的每个张量

工具


`compiled_with_cxx11_abi`	返回PyTorch是否使用_GLIBCXX_USE_CXX11_ABI=1构建
`result_type`	返回`torch.dtype`执行算术运算后将得到的结果输入张量。
`can_cast`	根据PyTorch类型提升中描述的类型转换规则，确定是否允许进行类型转换。文档
`promote_types`	返回`torch.dtype`使用最小的大小和标量种类，该种类既不小于也不低于类型1或类型2的大小和标量种类。
`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的一些警告可能每个进程只会显示一次。
`get_device_module`	返回与给定设备关联的模块（例如，torch.device('cuda')、"mtia:0"、"xpu" 等）。
`is_warn_always_enabled`	如果全局 warn_always 标志已打开，则返回 True。
`vmap`	vmap 是向量化映射；`vmap(func)`返回一个新的函数，该函数用于映射`func`在输入的某个维度上
`_assert`	围绕Python的断言创建的一个包装器，该包装器可以被符号化跟踪。

符号数字

class torch.SymInt(node)[source]

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

as_integer_ratio()[source]

将此整数表示为精确的整数比例

返回类型

元组[SymInt, 整数]

class torch.SymFloat(node)[source]

就像一个浮点数（包括魔术方法），但将所有操作重定向到包装的节点上。这在符号记录符号形.workflow中的操作中特别有用。

as_integer_ratio()[source]

将此浮点数表示为精确整数比例

返回类型

元组[整数, 整数]

is_integer()[source]

如果浮点数是整数，则返回 True。

class torch.SymBool(node)[source]

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

与常规布尔值不同，常规的布尔运算符会强制执行额外的保护措施，而不是进行符号评估。为了处理这种情况，请改用按位操作符。


`sym_float`	浮点数转换的符号整数感知工具。
`sym_int`	整数类型感知工具用于整数转换。
`sym_max`	带符号整数感知的最大值实用工具，避免在a < b上进行分支。
`sym_min`	支持最小整数类型的辅助工具用于获取最小值。
`sym_not`	符号感知整数逻辑非工具。
`sym_ite`

导出路径

警告

此功能是预览版本，未来可能会有破坏兼容性的更改。

export generated/exportdb/index

控制流

警告

此功能是预览版本，未来可能会有破坏兼容性的更改。


`cond`	条件性地应用true_fn或false_fn。

优化


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

torch.compile 文档

操作符标签

class torch.Tag

成员：

核心

data_dependent_output

dynamic_output_shape

flexible_layout

生成

inplace_view

needs_fixed_stride_order

non_deterministic_bitwise

非确定性种子

逐点

pt2_compliant_tag

[处理结果)view_copy

属性名称