torch.Tensor

一个 torch.Tensor 是一个包含单一数据类型元素的多维矩阵。

数据类型

Torch 使用以下数据类型定义张量类型：

数据类型	数据类型
32位浮点数	torch.float32 或 torch.float
64位浮点数	torch.float64 或 torch.double
16位浮点数 1	torch.float16 或 torch.half
16位浮点数 2	torch.bfloat16
32位复数	torch.complex32 或 torch.chalf
64位复数	torch.complex64 或 torch.cfloat
128位复数	torch.complex128 或 torch.cdouble
8位无符号整数	torch.uint8
16位整数（无符号）	torch.uint16（有限支持）4
32位整数（无符号）	torch.uint32（有限支持）4
64位整数（无符号）	torch.uint64（有限支持）4
8位整数（有符号）	torch.int8
16位整数（有符号）	torch.int16 或 torch.short
32位整数（有符号）	torch.int32 或 torch.int
64位整数（有符号）	torch.int64 或 torch.long
布尔值	torch.bool
量化 8 位整数（无符号）	torch.quint8
量化 8 位整数（有符号）	torch.qint8
量化 32 位整数（有符号）	torch.qint32
量化 4 位整数（无符号）3	torch.quint4x2
8位浮点数，e4m3 5	torch.float8_e4m3fn（有限支持）
8位浮点数，e5m2 5	torch.float8_e5m2（有限支持）

1

有时被称为binary16：使用1个符号位、5个指数位和10个有效位。在精度比范围更重要时非常有用。

2

有时被称为Brain浮点数：使用1个符号位、8个指数位和7个有效位。当范围重要时很有用，因为它具有与float32相同的指数位数。

3

量化的4位整数存储为8位有符号整数。目前仅在EmbeddingBag运算符中支持。

4(1,2,3)

除了 uint8 之外的无符号类型目前计划仅在急切模式下提供有限支持（它们主要存在以协助使用 torch.compile）；如果您需要急切支持且不需要额外的范围，我们建议改用它们的有符号变体。更多详情请参见 https://github.com/pytorch/pytorch/issues/58734。

5(1,2)

torch.float8_e4m3fn 和 torch.float8_e5m2 实现了来自 https://arxiv.org/abs/2209.05433 的 8 位浮点类型的规范。操作支持非常有限。

为了向后兼容，我们支持以下数据类型的备用类名：

数据类型	CPU 张量	GPU 张量
32位浮点数	torch.FloatTensor	torch.cuda.FloatTensor
64位浮点数	torch.DoubleTensor	torch.cuda.DoubleTensor
16位浮点数	torch.HalfTensor	torch.cuda.HalfTensor
16位浮点数	torch.BFloat16Tensor	torch.cuda.BFloat16Tensor
8位无符号整数	torch.ByteTensor	torch.cuda.ByteTensor
8位整数（有符号）	torch.CharTensor	torch.cuda.CharTensor
16位整数（有符号）	torch.ShortTensor	torch.cuda.ShortTensor
32位整数（有符号）	torch.IntTensor	torch.cuda.IntTensor
64位整数（有符号）	torch.LongTensor	torch.cuda.LongTensor
布尔值	torch.BoolTensor	torch.cuda.BoolTensor

然而，为了构建张量，我们建议使用工厂函数，例如 torch.empty() 并使用 dtype 参数。 torch.Tensor 构造函数是默认张量类型 (torch.FloatTensor) 的别名。

初始化和基本操作

可以使用 torch.tensor() 构造函数从 Python list 或序列构建张量：

>>> torch.tensor([[1., -1.], [1., -1.]])
tensor([[ 1.0000, -1.0000],
        [ 1.0000, -1.0000]])
>>> torch.tensor(np.array([[1, 2, 3], [4, 5, 6]]))
tensor([[ 1,  2,  3],
        [ 4,  5,  6]])

警告

torch.tensor() 总是复制 data。如果你有一个 Tensor data 并且只想改变它的 requires_grad 标志，使用 requires_grad_() 或 detach() 以避免复制。 如果你有一个 numpy 数组并且想避免复制，使用 torch.as_tensor()。

可以通过传递一个 torch.dtype 和/或一个 torch.device 给构造函数或张量创建操作来构造特定数据类型的张量：

>>> torch.zeros([2, 4], dtype=torch.int32)
tensor([[ 0,  0,  0,  0],
        [ 0,  0,  0,  0]], dtype=torch.int32)
>>> cuda0 = torch.device('cuda:0')
>>> torch.ones([2, 4], dtype=torch.float64, device=cuda0)
tensor([[ 1.0000,  1.0000,  1.0000,  1.0000],
        [ 1.0000,  1.0000,  1.0000,  1.0000]], dtype=torch.float64, device='cuda:0')

有关构建张量的更多信息，请参阅创建操作

可以使用Python的索引和切片表示法来访问和修改张量的内容：

>>> x = torch.tensor([[1, 2, 3], [4, 5, 6]])
>>> print(x[1][2])
tensor(6)
>>> x[0][1] = 8
>>> print(x)
tensor([[ 1,  8,  3],
        [ 4,  5,  6]])

使用 torch.Tensor.item() 从包含单个值的张量中获取一个Python数字：

>>> x = torch.tensor([[1]])
>>> x
tensor([[ 1]])
>>> x.item()
1
>>> x = torch.tensor(2.5)
>>> x
tensor(2.5000)
>>> x.item()
2.5

有关索引的更多信息，请参阅索引、切片、连接、变异操作

可以使用 requires_grad=True 创建一个张量，以便 torch.autograd 记录对其的操作以进行自动微分。

>>> x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
>>> out = x.pow(2).sum()
>>> out.backward()
>>> x.grad
tensor([[ 2.0000, -2.0000],
        [ 2.0000,  2.0000]])

每个张量都有一个关联的 torch.Storage，用于存储其数据。 张量类还提供了多维的、跨步 存储视图，并定义了对其的数值操作。

注意

有关张量视图的更多信息，请参阅张量视图。

注意

有关 torch.dtype、torch.device 和 torch.layout 属性的更多信息，请参阅 Tensor 属性。

注意

改变张量的方法会带有下划线后缀。 例如，torch.FloatTensor.abs_() 计算绝对值 并原地返回修改后的张量，而 torch.FloatTensor.abs() 计算结果并返回一个新的张量。

注意

要更改现有张量的torch.device和/或torch.dtype，请考虑在张量上使用to()方法。

警告

当前的 torch.Tensor 实现引入了内存开销， 因此在使用许多小张量的应用程序中可能会导致意外的高内存使用。 如果这是您的情况，请考虑使用一个大的结构。

张量类参考

class torch.Tensor

有几种主要的方法可以创建一个张量，具体取决于您的使用场景。

• 要使用预先存在的数据创建张量，请使用 torch.tensor()。

• 要创建具有特定大小的张量，请使用 torch.* 张量创建操作（参见 创建操作）。

• 要创建一个与另一个张量大小相同（且类型相似）的张量，请使用 torch.*_like 张量创建操作（参见 创建操作）。

• 要创建一个与另一个张量类型相同但大小不同的张量，请使用 tensor.new_* 创建操作。

Tensor.T

返回此张量维度反转后的视图。

如果 n 是 x 的维度数量， x.T 等同于 x.permute(n-1, n-2, ..., 0)。

警告

在维度不为2的张量上使用Tensor.T()来反转其形状已被弃用，并且在未来的版本中将会抛出错误。建议使用mT来转置矩阵批次，或使用x.permute(*torch.arange(x.ndim - 1, -1, -1))来反转张量的维度。

Tensor.H

返回一个矩阵（二维张量）的共轭和转置视图。

x.H 等价于复数矩阵的 x.transpose(0, 1).conj() 和实数矩阵的 x.transpose(0, 1)。

另请参阅

mH: 一个也适用于矩阵批次的属性。

Tensor.mT

返回此张量的视图，其中最后两个维度已转置。

x.mT 等同于 x.transpose(-2, -1).

Tensor.mH

访问此属性等同于调用 adjoint()。

Tensor.new_tensor	返回一个新的 Tensor，其数据为 data。
Tensor.new_full	返回一个大小为 size 并用 fill_value 填充的张量。
Tensor.new_empty	返回一个大小为 size 的未初始化数据的张量。
Tensor.new_ones	返回一个大小为 size 的 Tensor，填充为 1。
Tensor.new_zeros	返回一个大小为 size 的填充了 0 的张量。
Tensor.is_cuda	如果张量存储在GPU上，则为True，否则为False。
Tensor.is_quantized	如果张量是量化的，则为True，否则为False。
Tensor.is_meta	如果张量是元张量，则为True，否则为False。
Tensor.device	这个张量所在的torch.device。
Tensor.grad	此属性默认情况下为None，并且在第一次调用backward()为self计算梯度时变为Tensor。
Tensor.ndim	别名用于 dim()
Tensor.real	返回一个包含复数值输入张量的实数值的新张量。
Tensor.imag	返回一个包含 self 张量虚部值的新张量。
Tensor.nbytes	返回张量元素的“视图”所占用的字节数，前提是张量不使用稀疏存储布局。
Tensor.itemsize	别名 element_size()
Tensor.abs	参见 torch.abs()
Tensor.abs_	原地版本的 abs()
Tensor.absolute	别名用于 abs()
Tensor.absolute_	原地版本的 absolute() 别名为 abs_()
Tensor.acos	参见 torch.acos()
Tensor.acos_	原地版本的 acos()
Tensor.arccos	参见 torch.arccos()
Tensor.arccos_	原地版本的 arccos()
Tensor.add	将标量或张量添加到 self 张量。
Tensor.add_	原地版本的 add()
Tensor.addbmm	参见 torch.addbmm()
Tensor.addbmm_	原地版本的 addbmm()
Tensor.addcdiv	参见 torch.addcdiv()
Tensor.addcdiv_	原地版本的 addcdiv()
Tensor.addcmul	参见 torch.addcmul()
Tensor.addcmul_	原地版本的 addcmul()
Tensor.addmm	参见 torch.addmm()
Tensor.addmm_	原地版本的 addmm()
Tensor.sspaddmm	参见 torch.sspaddmm()
Tensor.addmv	参见 torch.addmv()
Tensor.addmv_	原地版本的 addmv()
Tensor.addr	参见 torch.addr()
Tensor.addr_	原地版本的 addr()
Tensor.adjoint	别名用于 adjoint()
Tensor.allclose	参见 torch.allclose()
Tensor.amax	参见 torch.amax()
Tensor.amin	参见 torch.amin()
Tensor.aminmax	参见 torch.aminmax()
Tensor.angle	参见 torch.angle()
Tensor.apply_	将函数 callable 应用于张量中的每个元素，将每个元素替换为 callable 返回的值。
Tensor.argmax	参见 torch.argmax()
Tensor.argmin	参见 torch.argmin()
Tensor.argsort	参见 torch.argsort()
Tensor.argwhere	参见 torch.argwhere()
Tensor.asin	参见 torch.asin()
Tensor.asin_	原地版本的 asin()
Tensor.arcsin	参见 torch.arcsin()
Tensor.arcsin_	原地版本的 arcsin()
Tensor.as_strided	参见 torch.as_strided()
Tensor.atan	参见 torch.atan()
Tensor.atan_	原地版本的 atan()
Tensor.arctan	参见 torch.arctan()
Tensor.arctan_	原地版本的 arctan()
Tensor.atan2	参见 torch.atan2()
Tensor.atan2_	原地版本的 atan2()
Tensor.arctan2	参见 torch.arctan2()
Tensor.arctan2_	atan2_(other) -> Tensor
Tensor.all	参见 torch.all()
Tensor.any	参见 torch.any()
Tensor.backward	计算当前张量相对于图叶的梯度。
Tensor.baddbmm	参见 torch.baddbmm()
Tensor.baddbmm_	原地版本的 baddbmm()
Tensor.bernoulli	返回一个结果张量，其中每个 $\texttt{result[i]}$ 是从 $\text{Bernoulli}(\texttt{self[i]})$ 独立采样的。
Tensor.bernoulli_	用从 $\text{Bernoulli}(\texttt{p})$ 独立采样的样本填充 self 的每个位置。
Tensor.bfloat16	self.bfloat16() 等同于 self.to(torch.bfloat16)。
Tensor.bincount	参见 torch.bincount()
Tensor.bitwise_not	参见 torch.bitwise_not()
Tensor.bitwise_not_	原地版本的 bitwise_not()
Tensor.bitwise_and	参见 torch.bitwise_and()
Tensor.bitwise_and_	原地版本的 bitwise_and()
Tensor.bitwise_or	参见 torch.bitwise_or()
Tensor.bitwise_or_	原地版本的 bitwise_or()
Tensor.bitwise_xor	参见 torch.bitwise_xor()
Tensor.bitwise_xor_	原地版本的 bitwise_xor()
Tensor.bitwise_left_shift	参见 torch.bitwise_left_shift()
Tensor.bitwise_left_shift_	原地版本的 bitwise_left_shift()
Tensor.bitwise_right_shift	参见 torch.bitwise_right_shift()
Tensor.bitwise_right_shift_	原地版本的 bitwise_right_shift()
Tensor.bmm	参见 torch.bmm()
Tensor.bool	self.bool() 等同于 self.to(torch.bool)。
Tensor.byte	self.byte() 等同于 self.to(torch.uint8)。
Tensor.broadcast_to	参见 torch.broadcast_to()。
Tensor.cauchy_	用从柯西分布中抽取的数字填充张量：
Tensor.ceil	参见 torch.ceil()
Tensor.ceil_	原地版本的 ceil()
Tensor.char	self.char() 等同于 self.to(torch.int8)。
Tensor.cholesky	参见 torch.cholesky()
Tensor.cholesky_inverse	参见 torch.cholesky_inverse()
Tensor.cholesky_solve	参见 torch.cholesky_solve()
Tensor.chunk	参见 torch.chunk()
Tensor.clamp	参见 torch.clamp()
Tensor.clamp_	原地版本的 clamp()
Tensor.clip	别名用于 clamp()。
Tensor.clip_	别名用于 clamp_()。
Tensor.clone	参见 torch.clone()
Tensor.contiguous	返回一个内存中连续的张量，包含与 self 张量相同的数据。
Tensor.copy_	将元素从 src 复制到 self 张量并返回 self。
Tensor.conj	参见 torch.conj()
Tensor.conj_physical	参见 torch.conj_physical()
Tensor.conj_physical_	原地版本的 conj_physical()
Tensor.resolve_conj	参见 torch.resolve_conj()
Tensor.resolve_neg	参见 torch.resolve_neg()
Tensor.copysign	参见 torch.copysign()
Tensor.copysign_	原地版本的 copysign()
Tensor.cos	参见 torch.cos()
Tensor.cos_	原地版本的 cos()
Tensor.cosh	参见 torch.cosh()
Tensor.cosh_	原地版本的 cosh()
Tensor.corrcoef	参见 torch.corrcoef()
Tensor.count_nonzero	参见 torch.count_nonzero()
Tensor.cov	参见 torch.cov()
Tensor.acosh	参见 torch.acosh()
Tensor.acosh_	原地版本的 acosh()
Tensor.arccosh	acosh() -> 张量
Tensor.arccosh_	acosh_() -> Tensor
Tensor.cpu	返回此对象在CPU内存中的副本。
Tensor.cross	参见 torch.cross()
Tensor.cuda	返回此对象在CUDA内存中的副本。
Tensor.logcumsumexp	参见 torch.logcumsumexp()
Tensor.cummax	参见 torch.cummax()
Tensor.cummin	参见 torch.cummin()
Tensor.cumprod	参见 torch.cumprod()
Tensor.cumprod_	原地版本的 cumprod()
Tensor.cumsum	参见 torch.cumsum()
Tensor.cumsum_	原地版本的 cumsum()
Tensor.chalf	self.chalf() 等同于 self.to(torch.complex32)。
Tensor.cfloat	self.cfloat() 等同于 self.to(torch.complex64)。
Tensor.cdouble	self.cdouble() 等同于 self.to(torch.complex128)。
Tensor.data_ptr	返回self张量的第一个元素的地址。
Tensor.deg2rad	参见 torch.deg2rad()
Tensor.dequantize	给定一个量化的张量，对其进行反量化并返回反量化后的浮点张量。
Tensor.det	参见 torch.det()
Tensor.dense_dim	返回稀疏张量 self中的稠密维度数量。
Tensor.detach	返回一个新的张量，与当前图分离。
Tensor.detach_	将张量从创建它的图中分离，使其成为叶子节点。
Tensor.diag	参见 torch.diag()
Tensor.diag_embed	参见 torch.diag_embed()
Tensor.diagflat	参见 torch.diagflat()
Tensor.diagonal	参见 torch.diagonal()
Tensor.diagonal_scatter	参见 torch.diagonal_scatter()
Tensor.fill_diagonal_	填充至少具有2个维度的张量的主对角线。
Tensor.fmax	参见 torch.fmax()
Tensor.fmin	参见 torch.fmin()
Tensor.diff	参见 torch.diff()
Tensor.digamma	参见 torch.digamma()
Tensor.digamma_	原地版本的 digamma()
Tensor.dim	返回self张量的维度数。
Tensor.dim_order	返回一个整数元组，描述self的维度顺序或物理布局。
Tensor.dist	参见 torch.dist()
Tensor.div	参见 torch.div()
Tensor.div_	原地版本的 div()
Tensor.divide	参见 torch.divide()
Tensor.divide_	原地版本的 divide()
Tensor.dot	参见 torch.dot()
Tensor.double	self.double() 等同于 self.to(torch.float64)。
Tensor.dsplit	参见 torch.dsplit()
Tensor.element_size	返回单个元素的大小（以字节为单位）。
Tensor.eq	参见 torch.eq()
Tensor.eq_	原地版本的 eq()
Tensor.equal	参见 torch.equal()
Tensor.erf	参见 torch.erf()
Tensor.erf_	原地版本的 erf()
Tensor.erfc	参见 torch.erfc()
Tensor.erfc_	原地版本的 erfc()
Tensor.erfinv	参见 torch.erfinv()
Tensor.erfinv_	原地版本的 erfinv()
Tensor.exp	参见 torch.exp()
Tensor.exp_	原地版本的 exp()
Tensor.expm1	参见 torch.expm1()
Tensor.expm1_	原地版本的 expm1()
Tensor.expand	返回一个新的视图，其中 self 张量的单一维度扩展为更大的尺寸。
Tensor.expand_as	将此张量扩展为与 other 相同的大小。
Tensor.exponential_	用从PDF（概率密度函数）中抽取的元素填充self张量：
Tensor.fix	参见 torch.fix()。
Tensor.fix_	原地版本的 fix()
Tensor.fill_	用指定值填充 self 张量。
Tensor.flatten	参见 torch.flatten()
Tensor.flip	参见 torch.flip()
Tensor.fliplr	参见 torch.fliplr()
Tensor.flipud	参见 torch.flipud()
Tensor.float	self.float() 等同于 self.to(torch.float32)。
Tensor.float_power	参见 torch.float_power()
Tensor.float_power_	原地版本的 float_power()
Tensor.floor	参见 torch.floor()
Tensor.floor_	原地版本的 floor()
Tensor.floor_divide	参见 torch.floor_divide()
Tensor.floor_divide_	原地版本的 floor_divide()
Tensor.fmod	参见 torch.fmod()
Tensor.fmod_	原地版本的 fmod()
Tensor.frac	参见 torch.frac()
Tensor.frac_	原地版本的 frac()
Tensor.frexp	参见 torch.frexp()
Tensor.gather	参见 torch.gather()
Tensor.gcd	参见 torch.gcd()
Tensor.gcd_	原地版本的 gcd()
Tensor.ge	参见 torch.ge()。
Tensor.ge_	原地版本的 ge()。
Tensor.greater_equal	参见 torch.greater_equal()。
Tensor.greater_equal_	原地版本的 greater_equal()。
Tensor.geometric_	用从几何分布中抽取的元素填充 self 张量：
Tensor.geqrf	参见 torch.geqrf()
Tensor.ger	参见 torch.ger()
Tensor.get_device	对于CUDA张量，此函数返回张量所在的GPU的设备序号。
Tensor.gt	参见 torch.gt()。
Tensor.gt_	原地版本的 gt()。
Tensor.greater	参见 torch.greater()。
Tensor.greater_	原地版本的 greater()。
Tensor.half	self.half() 等同于 self.to(torch.float16)。
Tensor.hardshrink	参见 torch.nn.functional.hardshrink()
Tensor.heaviside	参见 torch.heaviside()
Tensor.histc	参见 torch.histc()
Tensor.histogram	参见 torch.histogram()
Tensor.hsplit	参见 torch.hsplit()
Tensor.hypot	参见 torch.hypot()
Tensor.hypot_	原地版本的 hypot()
Tensor.i0	参见 torch.i0()
Tensor.i0_	原地版本的 i0()
Tensor.igamma	参见 torch.igamma()
Tensor.igamma_	原地版本的 igamma()
Tensor.igammac	参见 torch.igammac()
Tensor.igammac_	原地版本的 igammac()
Tensor.index_add_	将 alpha 乘以 source 的元素累加到 self 张量中，按照 index 中给定的顺序添加到索引中。
Tensor.index_add	就地版本的 torch.Tensor.index_add_()。
Tensor.index_copy_	将 tensor 中的元素复制到 self 张量中，按照 index 中给定的顺序选择索引。
Tensor.index_copy	就地版本的 torch.Tensor.index_copy_()。
Tensor.index_fill_	通过按照index中给定的顺序选择索引，用value填充self张量的元素。
Tensor.index_fill	就地版本的 torch.Tensor.index_fill_()。
Tensor.index_put_	将张量 values 中的值放入张量 self 中，使用在 indices（这是一个张量的元组）中指定的索引。
Tensor.index_put	非原地版本的 index_put_()。
Tensor.index_reduce_	将 source 的元素累积到 self 张量中，累积的顺序由 index 中的索引给出，使用由 reduce 参数指定的归约方法。
Tensor.index_reduce
Tensor.index_select	参见 torch.index_select()
Tensor.indices	返回一个稀疏COO张量的索引张量。
Tensor.inner	参见 torch.inner()。
Tensor.int	self.int() 等同于 self.to(torch.int32)。
Tensor.int_repr	给定一个量化的张量，self.int_repr() 返回一个以 uint8_t 作为数据类型的 CPU 张量，该张量存储给定张量的底层 uint8_t 值。
Tensor.inverse	参见 torch.inverse()
Tensor.isclose	参见 torch.isclose()
Tensor.isfinite	参见 torch.isfinite()
Tensor.isinf	参见 torch.isinf()
Tensor.isposinf	参见 torch.isposinf()
Tensor.isneginf	参见 torch.isneginf()
Tensor.isnan	参见 torch.isnan()
Tensor.is_contiguous	如果 self 张量在内存中是连续的，并且按照内存格式指定的顺序排列，则返回 True。
Tensor.is_complex	如果 self 的数据类型是复杂数据类型，则返回 True。
Tensor.is_conj	如果 self 的共轭位被设置为 true，则返回 True。
Tensor.is_floating_point	如果 self 的数据类型是浮点型数据类型，则返回 True。
Tensor.is_inference	参见 torch.is_inference()
Tensor.is_leaf	所有requires_grad为False的张量将按惯例成为叶子张量。
Tensor.is_pinned	如果此张量驻留在固定内存中，则返回 true。
Tensor.is_set_to	如果两个张量指向完全相同的内存（相同的存储、偏移、大小和步幅），则返回True。
Tensor.is_shared	检查张量是否在共享内存中。
Tensor.is_signed	如果 self 的数据类型是有符号数据类型，则返回 True。
Tensor.is_sparse	如果张量使用稀疏COO存储布局，则为True，否则为False。
Tensor.istft	参见 torch.istft()
Tensor.isreal	参见 torch.isreal()
Tensor.item	返回此张量的标准 Python 数值。
Tensor.kthvalue	参见 torch.kthvalue()
Tensor.lcm	参见 torch.lcm()
Tensor.lcm_	原地版本的 lcm()
Tensor.ldexp	参见 torch.ldexp()
Tensor.ldexp_	原地版本的 ldexp()
Tensor.le	参见 torch.le()。
Tensor.le_	原地版本的 le()。
Tensor.less_equal	参见 torch.less_equal()。
Tensor.less_equal_	原地版本的 less_equal()。
Tensor.lerp	参见 torch.lerp()
Tensor.lerp_	原地版本的 lerp()
Tensor.lgamma	参见 torch.lgamma()
Tensor.lgamma_	原地版本的 lgamma()
Tensor.log	参见 torch.log()
Tensor.log_	原地版本的 log()
Tensor.logdet	参见 torch.logdet()
Tensor.log10	参见 torch.log10()
Tensor.log10_	原地版本的 log10()
Tensor.log1p	参见 torch.log1p()
Tensor.log1p_	原地版本的 log1p()
Tensor.log2	参见 torch.log2()
Tensor.log2_	原地版本的 log2()
Tensor.log_normal_	用从对数正态分布中抽取的数字填充 self 张量，该分布由给定的均值 $\mu$ 和标准差 $\sigma$ 参数化。
Tensor.logaddexp	参见 torch.logaddexp()
Tensor.logaddexp2	参见 torch.logaddexp2()
Tensor.logsumexp	参见 torch.logsumexp()
Tensor.logical_and	参见 torch.logical_and()
Tensor.logical_and_	原地版本的 logical_and()
Tensor.logical_not	参见 torch.logical_not()
Tensor.logical_not_	原地版本的 logical_not()
Tensor.logical_or	参见 torch.logical_or()
Tensor.logical_or_	原地版本的 logical_or()
Tensor.logical_xor	参见 torch.logical_xor()
Tensor.logical_xor_	原地版本的 logical_xor()
Tensor.logit	参见 torch.logit()
Tensor.logit_	原地版本的 logit()
Tensor.long	self.long() 等同于 self.to(torch.int64)。
Tensor.lt	参见 torch.lt()。
Tensor.lt_	原地版本的 lt()。
Tensor.less	lt(other) -> 张量
Tensor.less_	原地版本的 less()。
Tensor.lu	参见 torch.lu()
Tensor.lu_solve	参见 torch.lu_solve()
Tensor.as_subclass	创建一个与self具有相同数据指针的cls实例。
Tensor.map_	对self张量和给定的tensor中的每个元素应用callable，并将结果存储在self张量中。
Tensor.masked_scatter_	从 source 中复制元素到 self 张量中，位置在 mask 为 True 的地方。
Tensor.masked_scatter	就地版本的 torch.Tensor.masked_scatter_()
Tensor.masked_fill_	在mask为True的位置，用value填充self张量的元素。
Tensor.masked_fill	就地版本的 torch.Tensor.masked_fill_()
Tensor.masked_select	参见 torch.masked_select()
Tensor.matmul	参见 torch.matmul()
Tensor.matrix_power	注意 matrix_power() 已被弃用，请使用 torch.linalg.matrix_power() 代替。
Tensor.matrix_exp	参见 torch.matrix_exp()
Tensor.max	参见 torch.max()
Tensor.maximum	参见 torch.maximum()
Tensor.mean	参见 torch.mean()
Tensor.module_load	定义了在load_state_dict()中将other加载到self时的转换方式。
Tensor.nanmean	参见 torch.nanmean()
Tensor.median	参见 torch.median()
Tensor.nanmedian	参见 torch.nanmedian()
Tensor.min	参见 torch.min()
Tensor.minimum	参见 torch.minimum()
Tensor.mm	参见 torch.mm()
Tensor.smm	参见 torch.smm()
Tensor.mode	参见 torch.mode()
Tensor.movedim	参见 torch.movedim()
Tensor.moveaxis	参见 torch.moveaxis()
Tensor.msort	参见 torch.msort()
Tensor.mul	参见 torch.mul()。
Tensor.mul_	原地版本的 mul()。
Tensor.multiply	参见 torch.multiply()。
Tensor.multiply_	原地版本的 multiply()。
Tensor.multinomial	参见 torch.multinomial()
Tensor.mv	参见 torch.mv()
Tensor.mvlgamma	参见 torch.mvlgamma()
Tensor.mvlgamma_	原地版本的 mvlgamma()
Tensor.nansum	参见 torch.nansum()
Tensor.narrow	参见 torch.narrow()。
Tensor.narrow_copy	参见 torch.narrow_copy()。
Tensor.ndimension	别名用于 dim()
Tensor.nan_to_num	参见 torch.nan_to_num()。
Tensor.nan_to_num_	原地版本的 nan_to_num()。
Tensor.ne	参见 torch.ne()。
Tensor.ne_	原地版本的 ne()。
Tensor.not_equal	参见 torch.not_equal()。
Tensor.not_equal_	原地版本的 not_equal()。
Tensor.neg	参见 torch.neg()
Tensor.neg_	原地版本的 neg()
Tensor.negative	参见 torch.negative()
Tensor.negative_	原地版本的 negative()
Tensor.nelement	别名 numel()
Tensor.nextafter	参见 torch.nextafter()
Tensor.nextafter_	原地版本的 nextafter()
Tensor.nonzero	参见 torch.nonzero()
Tensor.norm	参见 torch.norm()
Tensor.normal_	用从正态分布中采样的元素填充 self 张量，该正态分布由 mean 和 std 参数化。
Tensor.numel	参见 torch.numel()
Tensor.numpy	返回张量作为NumPy ndarray。
Tensor.orgqr	参见 torch.orgqr()
Tensor.ormqr	参见 torch.ormqr()
Tensor.outer	参见 torch.outer()。
Tensor.permute	参见 torch.permute()
Tensor.pin_memory	如果张量尚未固定，则将其复制到固定内存中。
Tensor.pinverse	参见 torch.pinverse()
Tensor.polygamma	参见 torch.polygamma()
Tensor.polygamma_	原地版本的 polygamma()
Tensor.positive	参见 torch.positive()
Tensor.pow	参见 torch.pow()
Tensor.pow_	原地版本的 pow()
Tensor.prod	参见 torch.prod()
Tensor.put_	将元素从 source 复制到由 index 指定的位置。
Tensor.qr	参见 torch.qr()
Tensor.qscheme	返回给定 QTensor 的量化方案。
Tensor.quantile	参见 torch.quantile()
Tensor.nanquantile	参见 torch.nanquantile()
Tensor.q_scale	给定一个通过线性（仿射）量化得到的张量，返回底层量化器的比例。
Tensor.q_zero_point	给定一个通过线性（仿射）量化得到的张量，返回底层量化器的zero_point。
Tensor.q_per_channel_scales	给定一个通过线性（仿射）逐通道量化进行量化的张量，返回底层量化器的缩放比例张量。
Tensor.q_per_channel_zero_points	给定一个通过线性（仿射）逐通道量化进行量化的张量，返回底层量化器的零点张量。
Tensor.q_per_channel_axis	给定一个通过线性（仿射）逐通道量化进行量化的张量，返回逐通道量化所应用的维度的索引。
Tensor.rad2deg	参见 torch.rad2deg()
Tensor.random_	用从离散均匀分布中采样的数字填充 self 张量，范围为 [from, to - 1]。
Tensor.ravel	参见 torch.ravel()
Tensor.reciprocal	参见 torch.reciprocal()
Tensor.reciprocal_	原地版本的 reciprocal()
Tensor.record_stream	将张量标记为由该流使用过。
Tensor.register_hook	注册一个反向钩子。
Tensor.register_post_accumulate_grad_hook	注册一个在梯度累积后运行的反向钩子。
Tensor.remainder	参见 torch.remainder()
Tensor.remainder_	原地版本的 remainder()
Tensor.renorm	参见 torch.renorm()
Tensor.renorm_	原地版本的 renorm()
Tensor.repeat	沿指定维度重复此张量。
Tensor.repeat_interleave	参见 torch.repeat_interleave()。
Tensor.requires_grad	如果需要为此张量计算梯度，则为True，否则为False。
Tensor.requires_grad_	更改是否应在此张量上记录自动梯度操作：就地设置此张量的 requires_grad 属性。
Tensor.reshape	返回一个与self具有相同数据和元素数量的张量，但具有指定的形状。
Tensor.reshape_as	返回此张量，其形状与 other 相同。
Tensor.resize_	将 self 张量调整为指定大小。
Tensor.resize_as_	将 self 张量调整为与指定的 tensor 相同的大小。
Tensor.retain_grad	使这个张量能够在执行 backward() 时填充其 grad。
Tensor.retains_grad	如果此张量是非叶张量且其 grad 在 backward() 期间被启用以填充，则为 True，否则为 False。
Tensor.roll	参见 torch.roll()
Tensor.rot90	参见 torch.rot90()
Tensor.round	参见 torch.round()
Tensor.round_	原地版本的 round()
Tensor.rsqrt	参见 torch.rsqrt()
Tensor.rsqrt_	原地版本的 rsqrt()
Tensor.scatter	就地版本的 torch.Tensor.scatter_()
Tensor.scatter_	将张量 src 中的所有值写入到 self 中，索引由张量 index 指定。
Tensor.scatter_add_	将张量 src 中的所有值添加到 self 中，索引由张量 index 指定，类似于 scatter_() 的方式。
Tensor.scatter_add	就地版本的 torch.Tensor.scatter_add_()
Tensor.scatter_reduce_	将src张量中的所有值减少到self张量中index张量指定的索引处，使用通过reduce参数定义的减少操作（"sum"、"prod"、"mean"、"amax"、"amin"）。
Tensor.scatter_reduce	就地版本的 torch.Tensor.scatter_reduce_()
Tensor.select	参见 torch.select()
Tensor.select_scatter	参见 torch.select_scatter()
Tensor.set_	设置底层存储、大小和步幅。
Tensor.share_memory_	将底层存储移动到共享内存中。
Tensor.short	self.short() 等同于 self.to(torch.int16)。
Tensor.sigmoid	参见 torch.sigmoid()
Tensor.sigmoid_	原地版本的 sigmoid()
Tensor.sign	参见 torch.sign()
Tensor.sign_	原地版本的 sign()
Tensor.signbit	参见 torch.signbit()
Tensor.sgn	参见 torch.sgn()
Tensor.sgn_	原地版本的 sgn()
Tensor.sin	参见 torch.sin()
Tensor.sin_	原地版本的 sin()
Tensor.sinc	参见 torch.sinc()
Tensor.sinc_	原地版本的 sinc()
Tensor.sinh	参见 torch.sinh()
Tensor.sinh_	原地版本的 sinh()
Tensor.asinh	参见 torch.asinh()
Tensor.asinh_	原地版本的 asinh()
Tensor.arcsinh	参见 torch.arcsinh()
Tensor.arcsinh_	原地版本的 arcsinh()
Tensor.shape	返回 self 张量的大小。
Tensor.size	返回 self 张量的大小。
Tensor.slogdet	参见 torch.slogdet()
Tensor.slice_scatter	参见 torch.slice_scatter()
Tensor.softmax	别名 torch.nn.functional.softmax()。
Tensor.sort	参见 torch.sort()
Tensor.split	参见 torch.split()
Tensor.sparse_mask	返回一个新的 稀疏张量，其值来自一个步幅张量 self，通过稀疏张量 mask 的索引进行过滤。
Tensor.sparse_dim	返回稀疏张量中的稀疏维度数量 self。
Tensor.sqrt	参见 torch.sqrt()
Tensor.sqrt_	原地版本的 sqrt()
Tensor.square	参见 torch.square()
Tensor.square_	原地版本的 square()
Tensor.squeeze	参见 torch.squeeze()
Tensor.squeeze_	原地版本的 squeeze()
Tensor.std	参见 torch.std()
Tensor.stft	参见 torch.stft()
Tensor.storage	返回底层的 TypedStorage。
Tensor.untyped_storage	返回底层的 UntypedStorage。
Tensor.storage_offset	返回 self 张量在底层存储中的偏移量，以存储元素的数量（而不是字节）为单位。
Tensor.storage_type	返回底层存储的类型。
Tensor.stride	返回 self 张量的步幅。
Tensor.sub	参见 torch.sub()。
Tensor.sub_	原地版本的 sub()
Tensor.subtract	参见 torch.subtract()。
Tensor.subtract_	原地版本的 subtract()。
Tensor.sum	参见 torch.sum()
Tensor.sum_to_size	将 this 张量求和到 size。
Tensor.svd	参见 torch.svd()
Tensor.swapaxes	参见 torch.swapaxes()
Tensor.swapdims	参见 torch.swapdims()
Tensor.t	参见 torch.t()
Tensor.t_	原地版本的 t()
Tensor.tensor_split	参见 torch.tensor_split()
Tensor.tile	参见 torch.tile()
Tensor.to	执行张量的数据类型和/或设备转换。
Tensor.to_mkldnn	返回以 torch.mkldnn 布局排列的张量副本。
Tensor.take	参见 torch.take()
Tensor.take_along_dim	参见 torch.take_along_dim()
Tensor.tan	参见 torch.tan()
Tensor.tan_	原地版本的 tan()
Tensor.tanh	参见 torch.tanh()
Tensor.tanh_	原地版本的 tanh()
Tensor.atanh	参见 torch.atanh()
Tensor.atanh_	原地版本的 atanh()
Tensor.arctanh	参见 torch.arctanh()
Tensor.arctanh_	原地版本的 arctanh()
Tensor.tolist	返回张量作为一个（嵌套的）列表。
Tensor.topk	参见 torch.topk()
Tensor.to_dense	如果 self 不是跨步张量，则创建 self 的跨步副本，否则返回 self。
Tensor.to_sparse	返回张量的稀疏副本。
Tensor.to_sparse_csr	将张量转换为压缩行存储格式（CSR）。
Tensor.to_sparse_csc	将张量转换为压缩列存储（CSC）格式。
Tensor.to_sparse_bsr	将张量转换为给定块大小的块稀疏行（BSR）存储格式。
Tensor.to_sparse_bsc	将张量转换为给定块大小的块稀疏列（BSC）存储格式。
Tensor.trace	参见 torch.trace()
Tensor.transpose	参见 torch.transpose()
Tensor.transpose_	原地版本的 transpose()
Tensor.triangular_solve	参见 torch.triangular_solve()
Tensor.tril	参见 torch.tril()
Tensor.tril_	原地版本的 tril()
Tensor.triu	参见 torch.triu()
Tensor.triu_	原地版本的 triu()
Tensor.true_divide	参见 torch.true_divide()
Tensor.true_divide_	原地版本的 true_divide_()
Tensor.trunc	参见 torch.trunc()
Tensor.trunc_	原地版本的 trunc()
Tensor.type	如果未提供dtype，则返回类型，否则将此对象转换为指定类型。
Tensor.type_as	返回此张量转换为给定张量类型的结果。
Tensor.unbind	参见 torch.unbind()
Tensor.unflatten	参见 torch.unflatten()。
Tensor.unfold	返回原始张量的一个视图，该视图包含在维度 dimension 中从 self 张量获取的所有大小为 size 的切片。
Tensor.uniform_	用从连续均匀分布中抽取的数字填充 self 张量：
Tensor.unique	返回输入张量的唯一元素。
Tensor.unique_consecutive	消除每个连续的等效元素组中除第一个元素之外的所有元素。
Tensor.unsqueeze	参见 torch.unsqueeze()
Tensor.unsqueeze_	原地版本的 unsqueeze()
Tensor.values	返回一个稀疏COO张量的值张量。
Tensor.var	参见 torch.var()
Tensor.vdot	参见 torch.vdot()
Tensor.view	返回一个与 self 张量具有相同数据但形状不同的新张量。
Tensor.view_as	将此张量视为与 other 相同的大小。
Tensor.vsplit	参见 torch.vsplit()
Tensor.where	self.where(condition, y) 等同于 torch.where(condition, self, y)。
Tensor.xlogy	参见 torch.xlogy()
Tensor.xlogy_	原地版本的 xlogy()
Tensor.zero_	用零填充 self 张量。