torch.Tensor

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

数据类型

Torch 定义了 10 种张量类型，分别具有 CPU 和 GPU 版本，如下所示：

数据类型	数据类型(dtype)	CPU 张量	GPU 张量
32位浮点数	torch.float32 or torch.float	torch.FloatTensor	torch.cuda.FloatTensor
64位浮点数	torch.float64 or torch.double	torch.DoubleTensor	torch.cuda.DoubleTensor
16位浮点数 1	torch.float16 or torch.half	torch.HalfTensor	torch.cuda.HalfTensor
16位浮点数 2	torch.bfloat16	torch.BFloat16Tensor	torch.cuda.BFloat16Tensor
64位复数	torch.complex64
128位复数	torch.complex128 or torch.cdouble
8位整数（无符号）	torch.uint8	torch.ByteTensor	torch.cuda.ByteTensor
8位整数（有符号）	torch.int8	torch.CharTensor	torch.cuda.CharTensor
16位整数（有符号）	torch.int16 or torch.short	torch.ShortTensor	torch.cuda.ShortTensor
32位有符号整数	torch.int32 or torch.int	torch.IntTensor	torch.cuda.IntTensor
64位整数（有符号）	torch.int64 or torch.long	torch.LongTensor	torch.cuda.LongTensor
布尔值	torch.bool	torch.BoolTensor	torch.cuda.BoolTensor
8位量化整数（无符号）	torch.quint8	torch.ByteTensor	/
8位有符号整数量化	torch.qint8	torch.CharTensor	/
32位有符号整数（量化）	torch.qfint32	torch.IntTensor	/
量化为4位整数（无符号） 3	torch.quint4x2	torch.ByteTensor	/

1

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

2

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

3

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

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.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

返回一个矩阵（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	这是 torch.device 所在的位置。
Tensor.grad	此属性默认为 None，并在第一次调用 backward() 为 self 计算梯度时变为张量。
Tensor.ndim	别名为 dim()
Tensor.real	返回一个新张量，包含复数值输入张量的self张量的实值。
Tensor.imag	返回一个新的张量，包含self张量的虚部值。
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.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.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.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	diagonal(src, offset=0, dim1=0, dim2=1) -> Tensor
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.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.eig	查看 torch.eig()
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_	填充 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中的元素通过选择index中给定顺序的索引，复制到self张量中。
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_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	如果是使用稀疏存储布局的Tensor，则为 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.lstsq	查看 torch.lstsq()
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 中的每个元素应用在 self 张量和给定的 tensor 上，并将结果存储在 self 张量中。
Tensor.masked_scatter_	将 source 中的元素复制到 self 张量中，位置为 mask 为 True 的地方。
Tensor.masked_scatter	非原位版本的 torch.Tensor.masked_scatter_()
Tensor.masked_fill_	用 self 张量中的 value 填充元素，其中 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.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	与 Tensor.narrow() 相同，但返回的是副本而不是共享存储。
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	Returns self 张量作为 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	确保在 stream 上排队的所有当前工作完成之前，不会将张量内存重新用于其他张量。
Tensor.register_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	如果此张量是非叶节点且其True在grad期间被启用以填充，则为backward()，否则为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_	将张量 other 中的所有值按照类似于 scatter_() 的方式，添加到由 index 张量指定的索引处的 self 中。
Tensor.scatter_add	非原位版本的 torch.Tensor.scatter_add_()
Tensor.scatter_reduce	查看 torch.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.size	返回 self 张量的大小。
Tensor.slogdet	查看 torch.slogdet()
Tensor.slice_scatter	查看 torch.slice_scatter()
Tensor.solve	查看 torch.solve()
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	返回底层的存储。
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.symeig	查看 torch.symeig()
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_sparse	返回张量的稀疏副本。
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.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.zero_	填充 self 张量为零。