torch.Tensor#

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

一个 torch.Tensor 是一个包含单一数据类型元素的 N 维矩阵。有关 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 类还提供了一个存储的多维、跨步视图，并定义了在其上的数值运算。

注意

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

注意

有关 torch.Tensor 的 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 是一个 Tensor，则返回原始 Tensor 的别名。与 torch.tensor() 不同，这会跟踪 autograd 并将梯度传播到原始 Tensor。device 关键字参数不适用于此 data 类型。
如果 data 是一个序列或嵌套序列，则创建一个具有默认 dtype（通常为 torch.float32）的张量，其数据为序列中的值，并在必要时执行类型转换。特别值得注意的是，这与 torch.tensor() 不同，因为即使输入都是整数，此构造函数也总是会构造一个浮点张量。
如果 data 是一个 torch.Size，则返回一个大小为该 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#

返回一个共轭转置的矩阵（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.nbytes`	如果张量不使用稀疏存储布局，则返回张量元素“视图”所占用的字节数。
`Tensor.itemsize`	是 `element_size()` 的别名
`Tensor.abs`	请参阅 `torch.abs()`
`Tensor.abs_`	`abs()` 的就地版本
`Tensor.absolute`	是 `abs()` 的别名
`Tensor.absolute_`	是 `absolute()` 的就地版本，也是 `abs_()` 的别名。
`Tensor.acos`	请参阅 `torch.acos()`
`Tensor.acos_`	是 `acos()` 的就地版本
`Tensor.arccos`	请参阅 `torch.arccos()`
`Tensor.arccos_`	是 `arccos()` 的就地版本
`Tensor.add`	将标量或张量添加到 `self` 张量。
`Tensor.add_`	是 `add()` 的就地版本
`Tensor.addbmm`	请参阅 `torch.addbmm()`
`Tensor.addbmm_`	是 `addbmm()` 的就地版本
`Tensor.addcdiv`	请参阅 `torch.addcdiv()`
`Tensor.addcdiv_`	是 `addcdiv()` 的就地版本
`Tensor.addcmul`	请参阅 `torch.addcmul()`
`Tensor.addcmul_`	是 `addcmul()` 的就地版本
`Tensor.addmm`	请参阅 `torch.addmm()`
`Tensor.addmm_`	是 `addmm()` 的就地版本
`Tensor.sspaddmm`	请参阅 `torch.sspaddmm()`
`Tensor.addmv`	请参阅 `torch.addmv()`
`Tensor.addmv_`	是 `addmv()` 的就地版本
`Tensor.addr`	请参阅 `torch.addr()`
`Tensor.addr_`	是 `addr()` 的就地版本
`Tensor.adjoint`	是 `adjoint()` 的别名
`Tensor.allclose`	请参阅 `torch.allclose()`
`Tensor.amax`	请参阅 `torch.amax()`
`Tensor.amin`	请参阅 `torch.amin()`
`Tensor.aminmax`	请参阅 `torch.aminmax()`
`Tensor.angle`	请参阅 `torch.angle()`
`Tensor.apply_`	将 `callable` 函数应用于张量中的每个元素，并将每个元素替换为 `callable` 返回的值。
`Tensor.argmax`	请参阅 `torch.argmax()`
`Tensor.argmin`	请参阅 `torch.argmin()`
`Tensor.argsort`	请参阅 `torch.argsort()`
`Tensor.argwhere`	请参阅 `torch.argwhere()`
`Tensor.asin`	请参阅 `torch.asin()`
`Tensor.asin_`	是 `asin()` 的就地版本
`Tensor.arcsin`	请参阅 `torch.arcsin()`
`Tensor.arcsin_`	是 `arcsin()` 的就地版本
`Tensor.as_strided`	请参阅 `torch.as_strided()`
`Tensor.atan`	请参阅 `torch.atan()`
`Tensor.atan_`	是 `atan()` 的就地版本
`Tensor.arctan`	请参阅 `torch.arctan()`
`Tensor.arctan_`	是 `arctan()` 的就地版本
`Tensor.atan2`	请参阅 `torch.atan2()`
`Tensor.atan2_`	是 `atan2()` 的就地版本
`Tensor.arctan2`	请参阅 `torch.arctan2()`
`Tensor.arctan2_`	atan2_(other) -> Tensor
`Tensor.all`	请参阅 `torch.all()`
`Tensor.any`	请参阅 `torch.any()`
`Tensor.backward`	计算当前张量相对于图叶的梯度。
`Tensor.baddbmm`	请参阅 `torch.baddbmm()`
`Tensor.baddbmm_`	是 `baddbmm()` 的就地版本
`Tensor.bernoulli`	返回一个结果张量，其中每个 $\texttt{result[i]}$ 是独立地从 $\text{Bernoulli}(\texttt{self[i]})$ 中抽取的。
`Tensor.bernoulli_`	用独立抽取的 $\text{Bernoulli}(\texttt{p})$ 的样本填充 `self` 中的每个位置。
`Tensor.bfloat16`	`self.bfloat16()` 等同于 `self.to(torch.bfloat16)`。
`Tensor.bincount`	请参阅 `torch.bincount()`
`Tensor.bitwise_not`	请参阅 `torch.bitwise_not()`
`Tensor.bitwise_not_`	是 `bitwise_not()` 的就地版本
`Tensor.bitwise_and`	请参阅 `torch.bitwise_and()`
`Tensor.bitwise_and_`	是 `bitwise_and()` 的就地版本
`Tensor.bitwise_or`	请参阅 `torch.bitwise_or()`
`Tensor.bitwise_or_`	是 `bitwise_or()` 的就地版本
`Tensor.bitwise_xor`	请参阅 `torch.bitwise_xor()`
`Tensor.bitwise_xor_`	是 `bitwise_xor()` 的就地版本
`Tensor.bitwise_left_shift`	请参阅 `torch.bitwise_left_shift()`
`Tensor.bitwise_left_shift_`	是 `bitwise_left_shift()` 的就地版本
`Tensor.bitwise_right_shift`	请参阅 `torch.bitwise_right_shift()`
`Tensor.bitwise_right_shift_`	是 `bitwise_right_shift()` 的就地版本
`Tensor.bmm`	请参阅 `torch.bmm()`
`Tensor.bool`	`self.bool()` 等同于 `self.to(torch.bool)`。
`Tensor.byte`	`self.byte()` 等同于 `self.to(torch.uint8)`。
`Tensor.broadcast_to`	请参阅 `torch.broadcast_to()`。
`Tensor.cauchy_`	用从柯西分布中抽取的数字填充张量
`Tensor.ceil`	请参阅 `torch.ceil()`
`Tensor.ceil_`	是 `ceil()` 的就地版本
`Tensor.char`	`self.char()` 等同于 `self.to(torch.int8)`。
`Tensor.cholesky`	请参阅 `torch.cholesky()`
`Tensor.cholesky_inverse`	请参阅 `torch.cholesky_inverse()`
`Tensor.cholesky_solve`	请参阅 `torch.cholesky_solve()`
`Tensor.chunk`	请参阅 `torch.chunk()`
`Tensor.clamp`	请参阅 `torch.clamp()`
`Tensor.clamp_`	是 `clamp()` 的就地版本
`Tensor.clip`	是 `clamp()` 的别名。
`Tensor.clip_`	是 `clamp_()` 的别名。
`Tensor.clone`	请参阅 `torch.clone()`
`Tensor.contiguous`	返回一个在内存中连续的张量，包含与 `self` 张量相同的数据。
`Tensor.copy_`	将 `src` 的元素复制到 `self` 张量中，并返回 `self`。
`Tensor.conj`	请参阅 `torch.conj()`
`Tensor.conj_physical`	请参阅 `torch.conj_physical()`
`Tensor.conj_physical_`	是 `conj_physical()` 的就地版本
`Tensor.resolve_conj`	请参阅 `torch.resolve_conj()`
`Tensor.resolve_neg`	请参阅 `torch.resolve_neg()`
`Tensor.copysign`	请参阅 `torch.copysign()`
`Tensor.copysign_`	是 `copysign()` 的就地版本
`Tensor.cos`	请参阅 `torch.cos()`
`Tensor.cos_`	是 `cos()` 的就地版本
`Tensor.cosh`	请参阅 `torch.cosh()`
`Tensor.cosh_`	是 `cosh()` 的就地版本
`Tensor.corrcoef`	请参阅 `torch.corrcoef()`
`Tensor.count_nonzero`	请参阅 `torch.count_nonzero()`
`Tensor.cov`	请参阅 `torch.cov()`
`Tensor.acosh`	请参阅 `torch.acosh()`
`Tensor.acosh_`	是 `acosh()` 的就地版本
`Tensor.arccosh`	acosh() -> Tensor
`Tensor.arccosh_`	acosh_() -> Tensor
`Tensor.cpu`	返回此对象的 CPU 内存副本。
`Tensor.cross`	请参阅 `torch.cross()`
`Tensor.cuda`	返回此对象在 CUDA 内存中的副本。
`Tensor.logcumsumexp`	请参阅 `torch.logcumsumexp()`
`Tensor.cummax`	请参阅 `torch.cummax()`
`Tensor.cummin`	请参阅 `torch.cummin()`
`Tensor.cumprod`	请参阅 `torch.cumprod()`
`Tensor.cumprod_`	是 `cumprod()` 的就地版本
`Tensor.cumsum`	请参阅 `torch.cumsum()`
`Tensor.cumsum_`	是 `cumsum()` 的就地版本
`Tensor.chalf`	`self.chalf()` 等同于 `self.to(torch.complex32)`。
`Tensor.cfloat`	`self.cfloat()` 等同于 `self.to(torch.complex64)`。
`Tensor.cdouble`	`self.cdouble()` 等同于 `self.to(torch.complex128)`。
`Tensor.data_ptr`	返回 `self` 张量第一个元素的地址。
`Tensor.deg2rad`	请参阅 `torch.deg2rad()`
`Tensor.dequantize`	给定一个量化张量，对其进行去量化并返回去量化的浮点张量。
`Tensor.det`	请参阅 `torch.det()`
`Tensor.dense_dim`	返回稀疏张量 `self` 的密集维度数量。
`Tensor.detach`	返回一个从当前图分离的新张量。
`Tensor.detach_`	将张量与创建它的图分离，使其成为叶子节点。
`Tensor.diag`	请参阅 `torch.diag()`
`Tensor.diag_embed`	请参阅 `torch.diag_embed()`
`Tensor.diagflat`	请参阅 `torch.diagflat()`
`Tensor.diagonal`	请参阅 `torch.diagonal()`
`Tensor.diagonal_scatter`	请参阅 `torch.diagonal_scatter()`
`Tensor.fill_diagonal_`	填充至少具有 2 个维度的张量的对角线。
`Tensor.fmax`	请参阅 `torch.fmax()`
`Tensor.fmin`	请参阅 `torch.fmin()`
`Tensor.diff`	请参阅 `torch.diff()`
`Tensor.digamma`	请参阅 `torch.digamma()`
`Tensor.digamma_`	是 `digamma()` 的就地版本
`Tensor.dim`	返回 `self` 张量的维度数量。
`Tensor.dim_order`	返回描述 `self` 的维度顺序或物理布局的唯一确定的整数元组。
`Tensor.dist`	请参阅 `torch.dist()`
`Tensor.div`	请参阅 `torch.div()`
`Tensor.div_`	是 `div()` 的就地版本
`Tensor.divide`	请参阅 `torch.divide()`
`Tensor.divide_`	是 `divide()` 的就地版本
`Tensor.dot`	请参阅 `torch.dot()`
`Tensor.double`	`self.double()` 等同于 `self.to(torch.float64)`。
`Tensor.dsplit`	请参阅 `torch.dsplit()`
`Tensor.element_size`	返回单个元素的字节大小。
`Tensor.eq`	请参阅 `torch.eq()`
`Tensor.eq_`	是 `eq()` 的就地版本
`Tensor.equal`	请参阅 `torch.equal()`
`Tensor.erf`	请参阅 `torch.erf()`
`Tensor.erf_`	是 `erf()` 的就地版本
`Tensor.erfc`	请参阅 `torch.erfc()`
`Tensor.erfc_`	是 `erfc()` 的就地版本
`Tensor.erfinv`	请参阅 `torch.erfinv()`
`Tensor.erfinv_`	是 `erfinv()` 的就地版本
`Tensor.exp`	请参阅 `torch.exp()`
`Tensor.exp_`	是 `exp()` 的就地版本
`Tensor.expm1`	请参阅 `torch.expm1()`
`Tensor.expm1_`	是 `expm1()` 的就地版本
`Tensor.expand`	返回 `self` 张量的新视图，其中单例维度已扩展到更大的大小。
`Tensor.expand_as`	将此张量扩展为与 `other` 相同的大小。
`Tensor.exponential_`	用从 PDF（概率密度函数）中抽取的元素填充 `self` 张量
`Tensor.fix`	请参阅 `torch.fix()`。
`Tensor.fix_`	是 `fix()` 的就地版本
`Tensor.fill_`	用指定的值填充 `self` 张量。
`Tensor.flatten`	请参阅 `torch.flatten()`
`Tensor.flip`	请参阅 `torch.flip()`
`Tensor.fliplr`	请参阅 `torch.fliplr()`
`Tensor.flipud`	请参阅 `torch.flipud()`
`Tensor.float`	`self.float()` 等同于 `self.to(torch.float32)`。
`Tensor.float_power`	请参阅 `torch.float_power()`
`Tensor.float_power_`	是 `float_power()` 的就地版本
`Tensor.floor`	请参阅 `torch.floor()`
`Tensor.floor_`	是 `floor()` 的就地版本
`Tensor.floor_divide`	请参阅 `torch.floor_divide()`
`Tensor.floor_divide_`	是 `floor_divide()` 的就地版本
`Tensor.fmod`	请参阅 `torch.fmod()`
`Tensor.fmod_`	是 `fmod()` 的就地版本
`Tensor.frac`	请参阅 `torch.frac()`
`Tensor.frac_`	是 `frac()` 的就地版本
`Tensor.frexp`	请参阅 `torch.frexp()`
`Tensor.gather`	请参阅 `torch.gather()`
`Tensor.gcd`	请参阅 `torch.gcd()`
`Tensor.gcd_`	是 `gcd()` 的就地版本
`Tensor.ge`	请参阅 `torch.ge()`。
`Tensor.ge_`	是 `ge()` 的就地版本。
`Tensor.greater_equal`	请参阅 `torch.greater_equal()`。
`Tensor.greater_equal_`	是 `greater_equal()` 的就地版本。
`Tensor.geometric_`	用从几何分布中抽取的元素填充 `self` 张量
`Tensor.geqrf`	请参阅 `torch.geqrf()`
`Tensor.ger`	请参阅 `torch.ger()`
`Tensor.get_device`	对于 CUDA 张量，此函数返回张量所在的 GPU 的设备序号。
`Tensor.gt`	请参阅 `torch.gt()`。
`Tensor.gt_`	是 `gt()` 的就地版本。
`Tensor.greater`	请参阅 `torch.greater()`。
`Tensor.greater_`	是 `greater()` 的就地版本。
`Tensor.half`	`self.half()` 等同于 `self.to(torch.float16)`。
`Tensor.hardshrink`	请参阅 `torch.nn.functional.hardshrink()`
`Tensor.heaviside`	请参阅 `torch.heaviside()`
`Tensor.histc`	请参阅 `torch.histc()`
`Tensor.histogram`	请参阅 `torch.histogram()`
`Tensor.hsplit`	请参阅 `torch.hsplit()`
`Tensor.hypot`	请参阅 `torch.hypot()`
`Tensor.hypot_`	是 `hypot()` 的就地版本
`Tensor.i0`	请参阅 `torch.i0()`
`Tensor.i0_`	是 `i0()` 的就地版本
`Tensor.igamma`	请参阅 `torch.igamma()`
`Tensor.igamma_`	是 `igamma()` 的就地版本
`Tensor.igammac`	请参阅 `torch.igammac()`
`Tensor.igammac_`	是 `igammac()` 的就地版本
`Tensor.index_add_`	通过按 `index` 指定的顺序将 `alpha` 乘以 `source` 的元素累加到 `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_`	通过使用 `reduce` 参数指定的归约，按 `index` 指定的顺序将 `source` 的元素累加到 `self` 张量中。
`Tensor.index_reduce`
`Tensor.index_select`	请参阅 `torch.index_select()`
`Tensor.indices`	返回稀疏 COO 张量的索引张量。
`Tensor.inner`	请参阅 `torch.inner()`。
`Tensor.int`	`self.int()` 等同于 `self.to(torch.int32)`。
`Tensor.int_repr`	给定一个量化张量，`self.int_repr()` 返回一个 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_`	为 `self` 张量和给定的 `tensor` 的每个元素应用 `callable`，并将结果存储在 `self` 张量中。
`Tensor.masked_scatter_`	将 `source` 中的元素复制到 `self` 张量中 `mask` 为 True 的位置。
`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_`	使用离散均匀分布（在 `[from, to - 1]` 上）采样的数字填充 `self` 张量。
`Tensor.ravel`	参见 `torch.ravel()`
`Tensor.reciprocal`	请参阅 `torch.reciprocal()`
`Tensor.reciprocal_`	`reciprocal()` 的原地版本
`Tensor.record_stream`	将张量标记为已被此流使用。
`Tensor.register_hook`	注册一个反向钩子。
`Tensor.register_post_accumulate_grad_hook`	注册一个在梯度累积后运行的反向钩子。
`Tensor.remainder`	请参阅 `torch.remainder()`
`Tensor.remainder_`	`remainder()` 的原地版本
`Tensor.renorm`	请参阅 `torch.renorm()`
`Tensor.renorm_`	`renorm()` 的原地版本
`Tensor.repeat`	沿指定维度重复此张量。
`Tensor.repeat_interleave`	请参阅 `torch.repeat_interleave()`。
`Tensor.requires_grad`	如果需要为此张量计算梯度，则为 `True`，否则为 `False`。
`Tensor.requires_grad_`	更改 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` 张量中的所有值按照 `index` 张量指定的索引写入 `self`。
`Tensor.scatter_add_`	以类似于 `scatter_()` 的方式，将 `src` 张量中的所有值加到 `index` 张量指定的 `self` 张量中的索引处。
`Tensor.scatter_add`	`torch.Tensor.scatter_add_()` 的非原地版本
`Tensor.scatter_reduce_`	使用通过 `reduce` 参数（`"sum"`、`"prod"`、`"mean"`、`"amax"`、`"amin"`）定义的约简操作，将 `src` 张量中的所有值约简到 `self` 张量中 `index` 指定的索引。
`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.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` 张量。

torch.Tensor#

初始化和基本操作#

张量类参考#

文档

教程

资源