torch

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 上。
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.Tensor。

tensor	通过复制 data，构造一个没有自动求导历史记录的张量（也称为“叶张量”，请参阅 Autograd 机制）。
sparse_coo_tensor	使用给定 indices 处的指定值，构造一个 COO(rdinate) 格式的稀疏张量。
sparse_csr_tensor	使用给定 crow_indices 和 col_indices 处的指定值，构造一个 CSR (压缩稀疏行) 格式的稀疏张量。
sparse_csc_tensor	使用给定 ccol_indices 和 row_indices 处的指定值，构造一个 CSC (压缩稀疏列) 格式的稀疏张量。
sparse_bsr_tensor	使用给定 crow_indices 和 col_indices 处的指定 2 维块，构造一个 BSR (块压缩稀疏行) 格式的稀疏张量。
sparse_bsc_tensor	使用给定 ccol_indices 和 row_indices 处的指定 2 维块，构造一个 BSC (块压缩稀疏列) 格式的稀疏张量。
asarray	将 obj 转换为张量。
as_tensor	将 data 转换为张量，如果可能，共享数据并保留自动求导历史记录。
as_strided	使用指定的 size、stride 和 storage_offset，创建现有 torch.Tensor input 的视图。
from_file	创建一个由内存映射文件支持的存储的 CPU 张量。
from_numpy	从 numpy.ndarray 创建一个 Tensor。
from_dlpack	将来自外部库的张量转换为 torch.Tensor。
frombuffer	从实现 Python 缓冲区协议的对象创建一个 1 维 Tensor。
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$ 的 1 维张量，其值来自区间 [start, end)，以公差 step 从 start 开始取值。
range	返回一个大小为 $\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor + 1$ 的 1 维张量，其值从 start 到 end，步长为 step。
linspace	创建一个大小为 steps 的一维张量，其值从 start 到 end（包括端点）均匀间隔。
logspace	创建一个大小为 steps 的一维张量，其值在对数刻度上从 ${{\text{{base}}}}^{{\text{{start}}}}$ 到 ${{\text{{base}}}}^{{\text{{end}}}}$（包括端点）均匀间隔，底数为 base。
eye	返回一个在对角线上为 1，其他位置为 0 的 2 维张量。
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 阶跃函数。

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

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

加速器

在 PyTorch 代码库中，我们将“加速器”定义为与 CPU 一起使用的 torch.device，用于加速计算。这些设备使用异步执行方案，使用 torch.Stream 和 torch.Event 作为执行同步的主要方式。我们还假设在给定主机上一次只能使用一个这样的加速器。这允许我们将当前加速器用作相关概念 (例如，pinned memory, Stream device_type, FSDP 等) 的默认设备。

截至今天，加速器设备包括（排名不分先后）“CUDA”、“MTIA”、“XPU” 和 PrivateUse1（许多设备不在 PyTorch 代码库本身中）。

Stream	一个按顺序执行的队列，以先进先出 (FIFO) 的顺序异步执行相应的任务。
Event	查询和记录 Stream 状态，以识别或控制跨 Stream 的依赖关系并测量时间。

生成器

Generator

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

随机采样

seed	在所有设备上，将生成随机数的种子设置为非确定性随机数。
manual_seed	在所有设备上，设置生成随机数的种子。
initial_seed	以 Python long 类型返回生成随机数的初始种子。
get_rng_state	以 torch.ByteTensor 形式返回随机数生成器状态。
set_rng_state	设置随机数生成器状态。

torch.default_generator 返回 默认的 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 的整数的随机排列。

原地随机采样

在张量上还定义了一些原地随机采样函数。点击链接查看其文档

• 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	设置用于操作间并行性的线程数 (例如

局部禁用梯度计算

上下文管理器 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	如果当前启用了 grad 模式，则返回 True。
autograd.grad_mode.inference_mode	启用或禁用推理模式的上下文管理器。
is_inference_mode_enabled	如果当前启用了推理模式，则返回 True。

数学运算

常量

inf	浮点正无穷大。是 math.inf 的别名。
nan	浮点“非数字”值。此值不是合法的数字。是 math.nan 的别名。

逐元素操作

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	逐元素计算 $\text{input}_{i} / \text{other}_{i}$ 的反正切值，并考虑象限。
arctan2	是 torch.atan2() 的别名。
bitwise_not	计算给定输入张量的按位 NOT。
bitwise_and	计算 input 和 other 的按位 AND。
bitwise_or	计算 input 和 other 的按位 OR。
bitwise_xor	计算 input 和 other 的按位 XOR。
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	返回一个新的张量，其中 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}$ 的梯度。
imag	返回一个包含 self 张量的虚数值的新张量。
ldexp	将 input 乘以 2 ** other。
lerp	对两个张量 start (由 input 给定) 和 end 基于标量或张量 weight 进行线性插值，并返回结果张量 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、正无穷和负无穷值在 input 中替换为由 nan、posinf 和 neginf 分别指定的值。
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 的模运算。
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	别名，指向 torch.div()，其中 rounding_mode=None。
trunc	返回一个新张量，其中包含 input 元素的截断整数值。
xlogy	别名，指向 torch.special.xlogy()。

归约运算

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	返回给定维度 dim 中 input 张量每行求和指数的对数。
mean
nanmean	计算指定维度上所有 非 NaN 元素的均值。
median	返回 input 中值的中位数。
nanmedian	返回 input 中值的中位数，忽略 NaN 值。
mode	返回一个 namedtuple (values, indices)，其中 values 是给定维度 dim 中 input 张量每行的众数值，即在该行中最常出现的值，而 indices 是找到的每个众数值的索引位置。
norm	返回给定张量的矩阵范数或向量范数。
nansum	返回所有元素的总和，并将非数字 (NaN) 视为零。
prod	返回 input 张量中所有元素的乘积。
quantile	计算维度 dim 上 input 张量每行的 q-th 分位数。
nanquantile	这是 torch.quantile() 的变体，它“忽略” NaN 值，计算分位数 q，就好像 input 中的 NaN 值不存在一样。
std	计算由 dim 指定的维度上的标准差。
std_mean	计算由 dim 指定的维度上的标准差和均值。
sum	返回 input 张量中所有元素的总和。
unique	返回输入张量的唯一元素。
unique_consecutive	从每个连续的等效元素组中消除除第一个元素之外的所有元素。
var	计算由 dim 指定的维度上的方差。
var_mean	计算由 dim 指定的维度上的方差和均值。
count_nonzero	计算给定 dim 沿线的张量 input 中非零值的数量。

比较运算

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 的每个元素是否“接近” other 的对应元素。
isfinite	返回一个新张量，其中包含布尔元素，表示每个元素是否为 有限的。
isin	测试 elements 的每个元素是否在 test_elements 中。
isinf	测试 input 的每个元素是否为无穷大（正无穷大或负无穷大）。
isposinf	测试 input 的每个元素是否为正无穷大。
isneginf	测试 input 的每个元素是否为负无穷大。
isnan	返回一个新张量，其中包含布尔元素，表示 input 的每个元素是否为 NaN。
isreal	返回一个新张量，其中包含布尔元素，表示 input 的每个元素是否为实数值。
kthvalue	返回一个 namedtuple (values, indices)，其中 values 是给定维度 dim 中 input 张量每行的第 k 个最小元素。
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	返回给定维度上 input 张量的 k 个最大元素。
msort	沿第一个维度按值升序对 input 张量的元素进行排序。

频谱运算

stft	短时傅里叶变换 (STFT)。
istft	逆短时傅里叶变换。
bartlett_window	Bartlett 窗函数。
blackman_window	Blackman 窗函数。
hamming_window	Hamming 窗函数。
hann_window	Hann 窗函数。
kaiser_window	计算窗口长度为 window_length 和形状参数为 beta 的 Kaiser 窗。

其他运算

atleast_1d	返回每个零维输入张量的 1 维视图。
atleast_2d	返回每个零维输入张量的 2 维视图。
atleast_3d	返回每个零维输入张量的 3 维视图。
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	返回一个 namedtuple (values, indices)，其中 values 是维度 dim 中 input 元素的累积最大值。
cummin	返回一个 namedtuple (values, indices)，其中 values 是维度 dim 中 input 元素的累积最小值。
cumprod	返回维度 dim 中 input 元素的累积乘积。
cumsum	返回维度 dim 中 input 元素的累积和。
diag	如果 input 是向量（1 维张量），则返回一个 2 维方阵张量
diag_embed	创建一个张量，其某些 2D 平面（由 dim1 和 dim2 指定）的对角线由 input 填充。
diagflat	如果 input 是向量（1 维张量），则返回一个 2 维方阵张量
diagonal	返回 input 的部分视图，其相对于 dim1 和 dim2 的对角线元素作为维度附加到形状的末尾。
diff	计算沿给定维度的 n 阶前向差分。
einsum	根据基于爱因斯坦求和约定的符号，对输入 operands 沿指定维度的元素乘积求和。
flatten	通过将 input 重塑为一维张量来展平它。
flip	沿 dims 中给定的轴反转 n 维张量的顺序。
fliplr	在左右方向翻转张量，返回一个新张量。
flipud	在上下方向翻转张量，返回一个新张量。
kron	计算 input 和 other 的 Kronecker 积，表示为 $\otimes$。
rot90	在由 dims 轴指定的平面中将 n 维张量旋转 90 度。
gcd	计算 input 和 other 的逐元素最大公约数 (GCD)。
histc	计算张量的直方图。
histogram	计算张量中值的直方图。
histogramdd	计算张量中值的多维直方图。
meshgrid	创建由 attr:tensors 中的 1D 输入指定的坐标网格。
lcm	计算 input 和 other 的逐元素最小公倍数 (LCM)。
logcumsumexp	返回维度 dim 中 input 元素的指数累积和的对数。
ravel	返回一个连续的展平张量。
renorm	返回一个张量，其中沿维度 dim 的 input 的每个子张量都经过归一化，使得子张量的 p-范数低于值 maxnorm
repeat_interleave	重复张量的元素。
roll	沿给定维度滚动张量 input。
searchsorted	从 sorted_sequence 的最内层维度中查找索引，使得如果将 values 中的对应值插入到索引之前，则在排序时，将保留 sorted_sequence 中相应最内层维度的顺序。
tensordot	返回 a 和 b 在多个维度上的收缩。
trace	返回输入 2 维矩阵的对角线元素的总和。
tril	返回矩阵（2 维张量）或批量矩阵 input 的下三角部分，结果张量 out 的其他元素设置为 0。
tril_indices	返回 row x col 矩阵的下三角部分的索引，以 2xN 张量形式返回，其中第一行包含所有索引的行坐标，第二行包含列坐标。
triu	返回矩阵（2 维张量）或批量矩阵 input 的上三角部分，结果张量 out 的其他元素设置为 0。
triu_indices	返回 row x col 矩阵的上三角部分的索引，以 2xN 张量形式返回，其中第一行包含所有索引的行坐标，第二行包含列坐标。
unflatten	在多个维度上展开输入张量的维度。
vander	生成范德蒙矩阵。
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 维张量的矩阵乘积。
cholesky	计算对称正定矩阵 $A$ 或对称正定矩阵批量的 Cholesky 分解。
cholesky_inverse	计算给定 Cholesky 分解的复 Hermitian 矩阵或实对称正定矩阵的逆矩阵。
cholesky_solve	计算给定 Cholesky 分解的复 Hermitian 矩阵或实对称正定左手边 (lhs) 线性方程组的解。
dot	计算两个一维张量的点积。
geqrf	这是一个直接调用 LAPACK 的 geqrf 的底层函数。
ger	torch.outer() 的别名。
inner	计算一维张量的点积。
inverse	torch.linalg.inv() 的别名
det	torch.linalg.det() 的别名
logdet	计算方阵或方阵批量的对数行列式。
slogdet	torch.linalg.slogdet() 的别名
lu	计算矩阵或矩阵批量 A 的 LU 分解。
lu_solve	使用来自 lu_factor() 的 A 的部分主元 LU 分解，返回线性系统 $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 分解，并返回张量的 namedtuple (Q, R)，使得 $\text{input} = Q R$，其中 $Q$ 是正交矩阵或正交矩阵批量，而 $R$ 是上三角矩阵或上三角矩阵批量。
svd	计算矩阵或矩阵批量 input 的奇异值分解。
svd_lowrank	返回矩阵、矩阵批量或稀疏矩阵 $A$ 的奇异值分解 (U, S, V)，使得 $A \approx U \operatorname{diag}(S) V^{\text{H}}$。
pca_lowrank	对低秩矩阵、此类矩阵的批量或稀疏矩阵执行线性主成分分析 (PCA)。
lobpcg	使用无矩阵 LOBPCG 方法，查找对称正定广义特征值问题的 k 个最大（或最小）特征值以及相应的特征向量。
trapz	torch.trapezoid() 的别名。
trapezoid	沿 dim 计算 梯形法则。
cumulative_trapezoid	沿 dim 累积计算 梯形法则。
triangular_solve	求解具有方阵上三角或下三角可逆矩阵 $A$ 和多个右手边 $b$ 的方程组。
vdot	计算沿维度的两个一维向量的点积。

Foreach 操作

警告

此 API 处于 beta 阶段，未来可能会发生更改。不支持前向模式 AD。

_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，该类型既不小于也不低于 type1 或 type2 的类型。
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)

类似于 int（包括魔术方法），但重定向对包装节点的所有操作。这尤其用于在符号形状工作流程中以符号方式记录操作。

as_integer_ratio()

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

返回类型

Tuple[SymInt, int]

class torch.SymFloat(node)

类似于 float（包括魔术方法），但重定向对包装节点的所有操作。这尤其用于在符号形状工作流程中以符号方式记录操作。

as_integer_ratio()

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

返回类型

Tuple[int, int]

conjugate()

返回浮点数的复共轭。

返回类型

SymFloat

hex()

返回浮点数的十六进制表示形式。

返回类型

str

is_integer()

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

class torch.SymBool(node)

类似于 bool（包括魔术方法），但重定向对包装节点的所有操作。这尤其用于在符号形状工作流程中以符号方式记录操作。

与常规布尔值不同，常规布尔运算符将强制执行额外的保护，而不是符号化求值。请改用按位运算符来处理此问题。

sym_float	用于浮点数转换的 SymInt 感知实用工具。
sym_fresh_size
sym_int	用于整数转换的 SymInt 感知实用工具。
sym_max	用于 max 的 SymInt 感知实用工具，可避免在 a < b 时分支。
sym_min	用于 min() 的 SymInt 感知实用工具。
sym_not	用于逻辑否定的 SymInt 感知实用工具。
sym_ite
sym_sum	N 元加法，对于长列表，其计算速度比迭代二元加法更快。

导出路径

警告

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

export generated/exportdb/index

控制流

警告

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

cond	有条件地应用 true_fn 或 false_fn。

优化

compile

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

torch.compile 文档

运算符标签

class torch.Tag

成员

core

data_dependent_output

dynamic_output_shape

flexible_layout

generated

inplace_view

maybe_aliasing_or_mutating

needs_fixed_stride_order

nondeterministic_bitwise

nondeterministic_seeded

pointwise

pt2_compliant_tag

view_copy

property 名称