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 位整数 （unsigned）	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 significand 位。当精度很重要但以牺牲范围为代价时很有用。

2

有时称为大脑浮点：使用 1 个符号、8 个指数和 7 significand 位。当 range 很重要时很有用，因为它具有相同的 指数位数为float32

3

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

4（1,2,3）

除 之外的 unsigned types 目前计划只具有 在 EAGER 模式下的支持有限（它们主要用于帮助使用 torch.compile 的 Package）;如果您需要热切的支持并且不需要额外的范围， 我们建议改用他们的 signed variants。有关详细信息，请参阅 https://github.com/pytorch/pytorch/issues/58734。uint8

5（1,2）

torch.float8_e4m3fn并实现 8 位的规范 https://arxiv.org/abs/2209.05433 浮点类型。op 支持 非常有限。torch.float8_e5m2

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

数据类型	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()替换为参数。这dtypetorch.Tensorconstructor 是默认张量类型的别名 ().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()始终复制 .如果你有一个 Tensor 并且只想更改它的标志，请使用datadatarequires_gradrequires_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')

有关构建 Tensor 的更多信息，请参阅创建作

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

>>> 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()从包含 单个值：

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

有关索引的更多信息，请参阅索引、切片、联接、更改运算

可以使用 创建 Tensor，以便requires_grad=Truetorch.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]])

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

注意

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

注意

有关torch.dtype,torch.device和torch.layout的属性torch.Tensor，请参阅 Tensor Attributes。

注意

改变张量的方法标有下划线后缀。 例如，计算 absolute 值 就地返回修改后的张量，同时在新张量中计算结果。torch.FloatTensor.abs_()torch.FloatTensor.abs()

注意

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

警告

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

Tensor 类参考

类 Torch 的 Torch 类张肌

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

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

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

• 要创建与另一个张量大小相同（和类似类型）的张量，请执行以下作： 使用 Tensor Creation Ops （参见 Creation Ops）。torch.*_like

• 要创建与另一个张量类型相似但大小不同的张量，请执行以下作： 使用 Creation Ops。tensor.new_*

张肌。吨

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

如果 是 中的维度数，则 等效于 。nxx.Tx.permute(n-1, n-2, ..., 0)

警告

的使用Tensor.T()在 2 维以外的张量上反转其形状 已弃用，它将在未来发行版中引发错误。考虑mT转置矩阵批次，或 x.permute（*torch.arange（x.ndim - 1， -1， -1）） 反向 张量的维度。

张肌。H

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

x.H等效于 对于复矩阵和对于实矩阵。x.transpose(0, 1).conj()x.transpose(0, 1)

另请参阅

mH：也适用于矩阵批次的属性。

张肌。兆吨

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

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

张肌。mH

访问此属性等效于调用adjoint().

Tensor.new_tensor	返回一个新的 Tensor 作为张量数据。data
Tensor.new_full	返回一个大小为 的 Tensor，其中填充了 。sizefill_value
Tensor.new_empty	返回一个大小为填充了未初始化数据的 Tensor。size
Tensor.new_ones	返回一个大小为 的 Tensor，其中填充了 。size1
Tensor.new_zeros	返回一个大小为 的 Tensor，其中填充了 。size0
Tensor.is_cuda	如果 Tensor 存储在 GPU 上，否则。TrueFalse
Tensor.is_quantized	如果 Tensor 被量化，否则。TrueFalse
Tensor.is_meta	如果 Tensor 是元张量，否则。TrueFalse
Tensor.device	是torch.device其中 Tensor 所在的位置。
Tensor.grad	默认情况下，此属性在第一次调用计算 的梯度时变为 Tensor。Nonebackward()self
Tensor.ndim	别名dim()
Tensor.real	返回一个新张量，其中包含复值输入张量的张量的实数值。self
Tensor.imag	返回包含张量的虚数值的新张量。self
Tensor.nbytes	如果 Tensor 不使用稀疏存储布局，则返回 Tensor 元素的“视图”消耗的字节数。
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	将标量或张量添加到 tensor。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_	将函数应用于张量中的每个元素，将每个元素替换为 返回的值。callablecallable
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_（其他） -> 张量
Tensor.all	看torch.all()
Tensor.any	看torch.any()
Tensor.backward	计算当前张量 wrt 图叶子的梯度。
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_	用从 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	返回包含与 tensor 相同数据的 contiguous in memory tensor。self
Tensor.copy_	将元素从 复制到 tensor 中并返回 。srcselfself
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	返回 tensor 的第一个元素的地址。self
Tensor.deg2rad	看torch.deg2rad()
Tensor.dequantize	给定一个量化的 Tensor，对其进行反量化并返回反量化的 float Tensor。
Tensor.det	看torch.det()
Tensor.dense_dim	返回 sparse tensor 中的密集维度数。self
Tensor.detach	返回与当前图形分离的新 Tensor。
Tensor.detach_	将 Tensor 与创建它的图形分离，使其成为叶子。
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	返回 tensor 的维数。self
Tensor.dim_order	返回一个 int 元组，描述 的暗序或物理布局。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_	用指定的值填充 tensor。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_	按照 中给出的顺序添加到索引中，将 times 的元素累积到张量中。alphasourceselfindex
Tensor.index_add	的 Out-of-place versiontorch.Tensor.index_add_().
Tensor.index_copy_	复制 的元素tensor通过按照 中给定的顺序选择索引，将其放入张量中。selfindex
Tensor.index_copy	的 Out-of-place versiontorch.Tensor.index_copy_().
Tensor.index_fill_	通过按照 中给出的顺序选择索引，用 value 填充张量的元素。selfvalueindex
Tensor.index_fill	的 Out-of-place versiontorch.Tensor.index_fill_().
Tensor.index_put_	使用 中指定的索引（这是一个 Tensor 元组）将 tensor 中的值放入 tensor 中。valuesselfindices
Tensor.index_put	的 Out-place 版本index_put_().
Tensor.index_reduce_	通过使用参数给出的 reduction 给出的顺序累积到索引，将 的元素累积到张量中。sourceselfindexreduce
Tensor.index_reduce
Tensor.index_select	看torch.index_select()
Tensor.indices	返回稀疏 COO 张量的 indices 张量。
Tensor.inner	看torch.inner().
Tensor.int	self.int()等效于 。self.to(torch.int32)
Tensor.int_repr	给定一个量化的 Tensor，返回一个数据类型为 uint8_t 的 CPU Tensor，用于存储给定 Tensor 的基础 uint8_t 值。self.int_repr()
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	如果 tensor 在内存中按内存格式指定的顺序连续，则返回 True。self
Tensor.is_complex	如果 的数据类型是复杂数据类型，则返回 True。self
Tensor.is_conj	如果共轭位 设置为 true，则返回 True。self
Tensor.is_floating_point	如果 的数据类型是浮点数据类型，则返回 True。self
Tensor.is_inference	看torch.is_inference()
Tensor.is_leaf	按照约定，所有具有 which is 的 Tensor 都将是叶 Tensor。requires_gradFalse
Tensor.is_pinned	如果此张量驻留在固定内存中，则返回 true。
Tensor.is_set_to	如果两个张量都指向完全相同的内存（相同的存储、偏移量、大小和步幅），则返回 True。
Tensor.is_shared	检查 tensor 是否在共享内存中。
Tensor.is_signed	如果 的数据类型是有符号数据类型，则返回 True。self
Tensor.is_sparse	如果 Tensor 使用稀疏 COO 存储布局，否则。TrueFalse
Tensor.istft	看torch.istft()
Tensor.isreal	看torch.isreal()
Tensor.item	将此张量的值作为标准 Python 数字返回。
Tensor.kthvalue	看torch.kthvalue()
Tensor.lcm	看torch.lcm()
Tensor.lcm_	的就地版本lcm()
Tensor.ldexp	看torch.ldexp()
Tensor.ldexp_	的就地版本ldexp()
Tensor.le	看torch.le().
Tensor.le_	的就地版本le().
Tensor.less_equal	看torch.less_equal().
Tensor.less_equal_	的就地版本less_equal().
Tensor.lerp	看torch.lerp()
Tensor.lerp_	的就地版本lerp()
Tensor.lgamma	看torch.lgamma()
Tensor.lgamma_	的就地版本lgamma()
Tensor.log	看torch.log()
Tensor.log_	的就地版本log()
Tensor.logdet	看torch.logdet()
Tensor.log10	看torch.log10()
Tensor.log10_	的就地版本log10()
Tensor.log1p	看torch.log1p()
Tensor.log1p_	的就地版本log1p()
Tensor.log2	看torch.log2()
Tensor.log2_	的就地版本log2()
Tensor.log_normal_	用来自对数正态分布的数字样本填充张量，该分布由给定均值参数化self$\mu$和标准差$\sigma$.
Tensor.logaddexp	看torch.logaddexp()
Tensor.logaddexp2	看torch.logaddexp2()
Tensor.logsumexp	看torch.logsumexp()
Tensor.logical_and	看torch.logical_and()
Tensor.logical_and_	的就地版本logical_and()
Tensor.logical_not	看torch.logical_not()
Tensor.logical_not_	的就地版本logical_not()
Tensor.logical_or	看torch.logical_or()
Tensor.logical_or_	的就地版本logical_or()
Tensor.logical_xor	看torch.logical_xor()
Tensor.logical_xor_	的就地版本logical_xor()
Tensor.logit	看torch.logit()
Tensor.logit_	的就地版本logit()
Tensor.long	self.long()等效于 。self.to(torch.int64)
Tensor.lt	看torch.lt().
Tensor.lt_	的就地版本lt().
Tensor.less	lt（other） -> 张量
Tensor.less_	的就地版本less().
Tensor.lu	看torch.lu()
Tensor.lu_solve	看torch.lu_solve()
Tensor.as_subclass	创建具有与 相同的数据指针的实例。clsself
Tensor.map_	适用于 tensor 中的每个元素和给定的callableselftensor并将结果存储在 Tensor 中。self
Tensor.masked_scatter_	将元素从 复制到 tensor 中 为 True 的位置。sourceselfmask
Tensor.masked_scatter	的 Out-of-place versiontorch.Tensor.masked_scatter_()
Tensor.masked_fill_	用 where 为 True 填充 tensor 的元素。selfvaluemask
Tensor.masked_fill	的 Out-of-place versiontorch.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	定义在将其加载到otherselfload_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_	用来自正态分布的元素样本填充张量，参数化为selfmean和std.
Tensor.numel	看torch.numel()
Tensor.numpy	将张量作为 NumPy 返回。ndarray
Tensor.orgqr	看torch.orgqr()
Tensor.ormqr	看torch.ormqr()
Tensor.outer	看torch.outer().
Tensor.permute	看torch.permute()
Tensor.pin_memory	将张量复制到固定内存（如果尚未固定）。
Tensor.pinverse	看torch.pinverse()
Tensor.polygamma	看torch.polygamma()
Tensor.polygamma_	的就地版本polygamma()
Tensor.positive	看torch.positive()
Tensor.pow	看torch.pow()
Tensor.pow_	的就地版本pow()
Tensor.prod	看torch.prod()
Tensor.put_	将元素从 复制到 中指定的位置。sourceindex
Tensor.qr	看torch.qr()
Tensor.qscheme	返回给定 QTensor 的量化方案。
Tensor.quantile	看torch.quantile()
Tensor.nanquantile	看torch.nanquantile()
Tensor.q_scale	给定一个通过线性（仿射）量化量化的 Tensor，返回底层 quantizer（） 的 scale 。
Tensor.q_zero_point	给定一个通过线性（仿射）量化量化的 Tensor，返回底层 quantizer（） 的 zero_point。
Tensor.q_per_channel_scales	给定一个通过线性（仿射）每通道量化量化的 Tensor，返回底层量化器的尺度的 Tensor。
Tensor.q_per_channel_zero_points	给定一个通过线性（仿射）每通道量化量化的 Tensor，返回底层量化器的 zero_points 张量。
Tensor.q_per_channel_axis	给定一个通过线性（仿射）每通道量化量化的 Tensor，返回应用每通道量化的维度索引。
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	注册一个在 grad 累积后运行的 backward 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	是如果需要为此 Tensor 计算梯度，否则。TrueFalse
Tensor.requires_grad_	更改 autograd 是否应该记录对此张量的作：就地设置此张量的属性。requires_grad
Tensor.reshape	返回一个张量，其数据和元素数与指定形状相同。self
Tensor.reshape_as	返回与 相同的形状的此张量。other
Tensor.resize_	将 tensor 大小调整为指定大小。self
Tensor.resize_as_	将张量大小调整为与指定大小相同的selftensor.
Tensor.retain_grad	允许此 Tensor 在 期间填充其 。gradbackward()
Tensor.retains_grad	如果此 Tensor 是非叶子的，并且允许在 期间填充它，否则。Truegradbackward()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	的 Out-of-place versiontorch.Tensor.scatter_()
Tensor.scatter_	将张量中的所有值写入张量中指定的索引处。srcselfindex
Tensor.scatter_add_	将张量中的所有值添加到张量中指定的索引处，其方式与srcselfindexscatter_().
Tensor.scatter_add	的 Out-of-place versiontorch.Tensor.scatter_add_()
Tensor.scatter_reduce_	使用通过参数 （、） 定义的应用缩减，将张量中的所有值减少到张量中张量中指定的索引。srcindexselfreduce"sum""prod""mean""amax""amin"
Tensor.scatter_reduce	的 Out-of-place versiontorch.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	返回一个新的稀疏张量，其中包含由 sparse 张量的索引过滤的跨步张量中的值。selfmask
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	返回 tensor 在底层存储中的偏移量，以存储元素（而不是字节）的数量表示。self
Tensor.storage_type	返回底层存储的类型。
Tensor.stride	返回 tensor 的步幅。self
Tensor.sub	看torch.sub().
Tensor.sub_	的就地版本sub()
Tensor.subtract	看torch.subtract().
Tensor.subtract_	的就地版本subtract().
Tensor.sum	看torch.sum()
Tensor.sum_to_size	将张量求和 为 。thissize
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 dtype 和/或 device 转换。
Tensor.to_mkldnn	返回 layout 中张量的副本。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	创建 if 不是 stribed 张量的 stribed 副本，否则返回 。selfselfself
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	返回原始张量的视图，其中包含维度中 tensor 的所有大小切片。sizeselfdimension
Tensor.uniform_	用从连续均匀分布中采样的数字填充张量：self
Tensor.unique	返回输入张量的唯一元素。
Tensor.unique_consecutive	从每组连续的等效元素中消除除第一个元素之外的所有元素。
Tensor.unsqueeze	看torch.unsqueeze()
Tensor.unsqueeze_	的就地版本unsqueeze()
Tensor.values	返回稀疏 COO 张量的 values tensor。
Tensor.var	看torch.var()
Tensor.vdot	看torch.vdot()
Tensor.view	返回一个新张量，其数据与张量相同，但具有不同的 。selfshape
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_	用零填充 tensor。self