torch.Tensor

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

数据类型

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

数据类型	dtype
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 Floating Point：使用 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')

有关构建张量的更多信息，请参阅 Creation Ops

可以使用 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

有关索引的更多信息，请参阅 Indexing, Slicing, Joining, Mutating Ops

可以使用 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，它保存其数据。 张量类还提供存储的多维、strided 视图，并定义其上的数值运算。

注意

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

注意

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

注意

修改张量的方法用下划线后缀标记。 例如，torch.FloatTensor.abs_() 在原地计算绝对值并返回修改后的张量，而 torch.FloatTensor.abs() 在新张量中计算结果。

注意

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

警告

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

张量类参考

class torch.Tensor

有几种主要方法可以创建张量，具体取决于您的用例。

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

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

• 若要创建与另一个张量具有相同大小（以及类似类型）的张量，请使用 torch.*_like 张量创建操作（请参阅 Creation Ops）。

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

• 有一个遗留构造函数 torch.Tensor，不建议使用。 请改用 torch.tensor()。

Tensor.__init__(self, data)

此构造函数已弃用，建议改用 torch.tensor()。 此构造函数的作用取决于 data 的类型。

• 如果 data 是一个 Tensor，则返回对原始 Tensor 的别名。 与 torch.tensor() 不同，它跟踪 autograd 并将梯度传播到原始 Tensor。 device 关键字参数不支持此 data 类型。

• 如果 data 是一个序列或嵌套序列，则创建一个默认 dtype（通常为 torch.float32）的张量，其数据是序列中的值，并在必要时执行强制转换。 值得注意的是，这与 torch.tensor() 不同，因为此构造函数始终会构造一个浮点张量，即使输入都是整数。

• 如果 data 是一个 torch.Size，则返回一个大小为该大小的空张量。

此构造函数不支持显式指定返回张量的 dtype 或 device。 我们建议使用 torch.tensor()，它提供了此功能。

参数

data (array_like): 要从中构建的张量。

关键字参数

device (torch.device，可选)：返回张量的所需设备。

默认值：如果为 None，则与该张量相同的 torch.device。

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	返回一个新的张量，其 data 作为张量数据。
Tensor.new_full	返回一个大小为 size 的张量，并用 fill_value 填充。
Tensor.new_empty	返回一个大小为 size 的张量，并用未初始化的数据填充。
Tensor.new_ones	返回一个大小为 size 的张量，并用 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.ndim	它是 dim() 的别名。
Tensor.real	对于复数输入张量，返回一个新的张量，其中包含 self 张量的实数值。
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
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_	通过按 index 中给出的顺序选择索引，将 tensor 的元素复制到 self 张量中。
Tensor.index_copy	torch.Tensor.index_copy_() 的非就地版本。
Tensor.index_fill_	通过按 index 中给出的顺序选择索引，用值 value 填充 self 张量的元素。
Tensor.index_fill	torch.Tensor.index_fill_() 的非就地版本。
Tensor.index_put_	使用在 indices（它是一个张量元组）中指定的索引，将来自张量 values 的值放入张量 self 中。
Tensor.index_put	index_put_() 的非就地版本。
Tensor.index_reduce_	通过使用 reduce 参数给出的缩减，按 index 中给出的顺序累加到索引，将 source 的元素累加到 self 张量中。
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
Tensor.less_	的原地版本 less().
Tensor.lu	参见 torch.lu()
Tensor.lu_solve	参见 torch.lu_solve()
Tensor.as_subclass	使用与 self 相同的数据指针创建 cls 实例。
Tensor.map_	将 callable 应用于 self 张量中的每个元素和给定的 tensor，并将结果存储在 self 张量中。
Tensor.masked_scatter_	将 source 中的元素复制到 self 张量中 mask 为 True 的位置。
Tensor.masked_scatter	的非原地版本 torch.Tensor.masked_scatter_()
Tensor.masked_fill_	用 value 填充 self 张量中 mask 为 True 的元素。
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	定义如何在将 other 加载到 self 中时转换它，在 load_state_dict() 中使用。
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_	用由 mean 和 std 参数化的正态分布的元素样本填充 self 张量。
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	给定一个通过线性（仿射）量化量化的张量，返回底层量化器() 的零点。
Tensor.q_per_channel_scales	给定一个通过线性（仿射）逐通道量化量化的张量，返回一个包含底层量化器比例的张量。
Tensor.q_per_channel_zero_points	给定一个通过线性（仿射）逐通道量化量化的张量，返回一个包含底层量化器零点的张量。
Tensor.q_per_channel_axis	给定一个通过线性（仿射）逐通道量化量化的张量，返回应用逐通道量化的维度的索引。
Tensor.rad2deg	参见 torch.rad2deg()
Tensor.random_	用从 [from, to - 1] 范围内离散均匀分布中采样的数字填充 self 张量。
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_	使用通过 reduce 参数（"sum"、"prod"、"mean"、"amax"、"amin"）定义的应用减少，将 src 张量中的所有值减少到 index 张量在 self 张量中指定的索引。
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	执行张量 dtype 和/或设备转换。
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	返回原始张量的视图，其中包含来自 self 张量的维数 dimension 中所有大小为 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 张量具有相同的数据，但具有不同的 shape。
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.xpu	返回此对象在 XPU 内存中的副本。
Tensor.zero_	用零填充 self 张量。