torch.Tensor

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

数据类型

Torch 定义了以下数据类型的张量类型：

数据类型	数据类型(dtype)
32位浮点数	torch.float32 or torch.float
64位浮点数	torch.float64 or torch.double
16位浮点数 1	torch.float16 or torch.half
16位浮点数 2	torch.bfloat16
32位复数	torch.complex32 or torch.chalf
64位复数	torch.complex64 or torch.cfloat
128位复数	torch.complex128 or torch.cdouble
8位整数（无符号）	torch.uint8
16位整数（无符号）	torch.uint16（有限支持） 4
32位无符号整数	torch.uint32（有限支持） 4
64位无符号整数	torch.uint64（有限支持） 4
8位整数（有符号）	torch.int8
16位整数（有符号）	torch.int16 or torch.short
32位有符号整数	torch.int32 or torch.int
64位整数（有符号）	torch.int64 or 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

有时称为二进制16：使用1位符号、5位指数和10位有效数字位。当精度比范围更重要时很有用。

2

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

3

4位量化整数以8位有符号整数的形式存储。目前它仅在EmbeddingBag操作中受支持。

4(1,2,3)

除了 uint8 之外的无符号类型目前计划仅在急切模式（eager mode）中提供有限支持（它们主要存在是为了帮助与 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)。

初始化和基本操作

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

>>> 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。如果你有一个张量 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 属性的更多信息，请参阅 张量属性。

注意

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

注意

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

警告

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

张量类参考

class torch.Tensor

根据你的使用场景，有几种主要方法可以创建张量。

• 要创建一个具有现有数据的张量，请使用 torch.tensor()。

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

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

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

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

Tensor.__init__(self, data)

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

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

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

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

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

Args:

data（类似数组）：要从中构造张量的数据。

Keyword args:

device (torch.device, optional): the desired device of returned tensor.

默认值：如果为 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

返回一个矩阵（2-D 张量）的共轭转置视图。

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	这个张量（Tensor）位于 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_	0 的原地版本 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.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.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_	用值 value 填充张量的元素，选择顺序由 index 中给出的索引决定。
Tensor.index_fill	不就地版本的 torch.Tensor.index_fill_()。
Tensor.index_put_	将张量 values 中的值根据索引 indices（一个张量的元组）放入张量 self 中。
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() 返回一个 CPU 张量，其数据类型为 uint8_t，并存储给定张量的底层 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。
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_	用从由给定的均值 $\mu$ 和标准差 $\sigma$ 参数化的对数正态分布中抽取的数字填充一个 self 维张量。
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_	对 callable 中的每个元素应用给定的 tensor 和 self 张量，并将结果存储在 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	给定一个通过线性（仿射）量化得到的张量，返回底层量化器 quantizer() 的 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	如果此张量不是叶子节点，并且在 backward()、False 期间启用了填充其 grad，则为 True，否则为 grad。
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 中的所有值写入索引由 index 张量指定的 self 中。
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 数据类型和/或设备转换。
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。
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 张量相同，但具有不同的 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 张量。