torch.Tensor

创建于：2016年12月23日 | 最后更新于：2025年6月27日

一个 torch.Tensor 是一个多维矩阵，包含单一数据类型的元素。有关 dtype 的支持详情，请参阅 torch.dtype。

初始化和基本操作

可以使用 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，其中包含其数据。Tensor 类还提供了存储的多维、跨步（strided）视图，并定义了其上的数值操作。

注意

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

注意

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

注意

更改张量的（mutate）方法以一个下划线后缀标记。例如，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 是一个 Tensor，则返回原始 Tensor 的一个别名。与 torch.tensor() 不同，此构造函数会跟踪 autograd 并将梯度传播到原始 Tensor。device 关键字参数不支持此 data 类型。

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

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

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

参数 (Args)

data (array_like): 要从中构造张量的数据。

关键字参数

device (torch.device, optional): 返回张量的所需设备。

默认值：如果为 None，则与此张量相同。 (torch.device)

Tensor.T

返回此张量的一个视图，其维度反转。

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

警告

对维度不为 2 的张量使用 Tensor.T() 来反转其形状已被弃用，并且在将来的版本中将引发错误。请考虑使用 mT 来转置矩阵批次，或使用 x.permute(*torch.arange(x.ndim - 1, -1, -1)) 来反转张量的维度。

Tensor.H

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

对于复数矩阵，x.H 等同于 x.transpose(0, 1).conj()；对于实数矩阵，x.H 等同于 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_	将 self 的每个位置填充为从 $\text{Bernoulli}(\texttt{p})$ 中采样的独立样本。
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 的元素，按照 index 中给出的顺序累加到 self 张量中。
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_	按照 index 中给出的顺序，使用 reduce 参数给定的归约操作，将 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() 返回一个 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，则返回 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
Tensor.less_	less() 的原地版本。
Tensor.lu	参阅 torch.lu()
Tensor.lu_solve	参阅 torch.lu_solve()
Tensor.as_subclass	创建一个 cls 实例，该实例具有与 self 相同的数据指针。
Tensor.map_	将 callable 应用于 self 张量中的每个元素以及给定的 tensor，并将结果存储在 self 张量中。
Tensor.masked_scatter_	在 mask 为 True 的位置，将 source 的元素复制到 self 张量中。
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_	使用均值 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	对于通过逐通道线性（仿射）量化获得的张量，返回底层量化器的 scales 张量。
Tensor.q_per_channel_zero_points	对于通过逐通道线性（仿射）量化获得的张量，返回底层量化器的 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_	更改 autograd 是否记录此张量的操作：原地修改此张量的 requires_grad 属性。
Tensor.reshape	返回一个具有与 self 相同数据和元素数量，但具有指定形状的新张量。
Tensor.reshape_as	将此张量重塑为与 other 相同的形状。
Tensor.resize_	将 self 张量的大小调整为指定的尺寸。
Tensor.resize_as_	将 self 张量的大小调整为与指定的 tensor 相同。
Tensor.retain_grad	使此张量能够在其 grad 在 backward() 期间被填充。
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	返回一个由稀疏张量 mask 的索引过滤的、来自 strided 张量 self 的值的新的 稀疏张量。
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	返回原始张量的视图，该视图包含 self 张量在 dimension 维度上长度为 size 的所有切片。
Tensor.uniform_	使用连续均匀分布采样的数字填充 self 张量。
Tensor.unique	返回输入张量的唯一元素。
Tensor.unique_consecutive	从每个连续的等效元素组中删除除第一个元素之外的所有元素。
Tensor.unsqueeze	参见 torch.unsqueeze()
Tensor.unsqueeze_	原地版本的 unsqueeze()
Tensor.values	返回 稀疏 COO 张量 的 values 张量。
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 张量。