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 位无符号整型	`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 个尾数位。当精度很重要但范围可以牺牲时很有用。
2: 有时称为 Brain Floating Point：使用 1 个符号位、8 个指数位和 7 个尾数位。当范围很重要时很有用，因为它具有与 float32 相同的指数位数
3: 量化 4 位整数存储为 8 位有符号整数。目前仅在 EmbeddingBag 算子中支持。
4(1,2,3): 除了 uint8 之外的无符号类型目前计划仅在 eager 模式下提供有限支持（它们主要用于协助与 torch.compile 的使用）；如果您需要 eager 支持且不需要额外的范围，我们建议使用其有符号变体代替。更多详细信息请参阅 https://github.com/pytorch/pytorch/issues/58734。
5(1,2): torch.float8_e4m3fn 和 torch.float8_e5m2 实现了 https://arxiv.org/abs/2209.05433 中 8 位浮点类型的规范。算子支持非常有限。

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

数据类型	CPU 张量	GPU 张量
32 位浮点型	`torch.FloatTensor`	`torch.cuda.FloatTensor`
64 位浮点型	`torch.DoubleTensor`	`torch.cuda.DoubleTensor`
16 位浮点型	`torch.HalfTensor`	`torch.cuda.HalfTensor`
16 位浮点型	`torch.BFloat16Tensor`	`torch.cuda.BFloat16Tensor`
8 位无符号整型	`torch.ByteTensor`	`torch.cuda.ByteTensor`
8 位有符号整型	`torch.CharTensor`	`torch.cuda.CharTensor`
16 位有符号整型	`torch.ShortTensor`	`torch.cuda.ShortTensor`
32 位有符号整型	`torch.IntTensor`	`torch.cuda.IntTensor`
64 位有符号整型	`torch.LongTensor`	`torch.cuda.LongTensor`
布尔型	`torch.BoolTensor`	`torch.cuda.BoolTensor`

然而，要构造张量，我们建议使用如 torch.empty() 这样的工厂函数，并指定 dtype 参数。 torch.Tensor 构造函数是默认张量类型 (torch.FloatTensor) 的别名。

初始化和基本操作¶

可以使用 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')

有关构建张量的更多信息，请参阅创建操作 (Creation Ops)

可以使用 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

有关索引的更多信息，请参阅索引、切片、连接、变动操作 (Indexing, Slicing, Joining, Mutating Ops)

可以创建一个张量并设置 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 Views)。

注意

有关 torch.dtype, torch.device 和 torch.layout 这三个 torch.Tensor 属性的更多信息，请参阅张量属性 (Tensor Attributes)。

注意

修改张量的方法通常带有下划线后缀。例如，torch.FloatTensor.abs_() 就地计算绝对值并返回修改后的张量，而 torch.FloatTensor.abs() 则在一个新张量中计算结果。

注意

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

警告

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

Tensor 类参考¶

class torch.Tensor¶

根据您的用例，有几种主要方法可以创建张量。

要使用现有数据创建张量，请使用 torch.tensor()。
要创建具有特定大小的张量，请使用 torch.* 张量创建操作（参阅创建操作 (Creation Ops)）。
要创建与另一个张量具有相同大小（和相似类型）的张量，请使用 torch.*_like 张量创建操作（参阅创建操作 (Creation Ops)）。
要创建与另一个张量类型相似但大小不同的张量，请使用 tensor.new_* 创建操作。
有一个不推荐使用的旧版构造函数 torch.Tensor。建议改用 torch.tensor()。

Tensor.__init__(self, data)¶

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

如果 data 是一个 Tensor，则返回原始 Tensor 的别名。与 torch.tensor() 不同，这会跟踪 autograd 并将梯度传播到原始 Tensor。device kwarg 不支持此 data 类型。
如果 data 是序列或嵌套序列，则创建一个默认 dtype（通常为 torch.float32）的张量，其数据是序列中的值，必要时执行强制类型转换。值得注意的是，这与 torch.tensor() 不同，此构造函数将始终构造一个浮点张量，即使输入全部是整数。
如果 data 是一个 torch.Size，则返回该大小的空张量。

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

参数

data (array_like): 用于构造张量的数据。

关键字参数

device (torch.device, optional)：返回张量的期望设备。: 默认值：如果为 None，则与此张量使用相同的 torch.device。

Tensor.T¶

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

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

警告

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

Tensor.H¶

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

对于复数矩阵，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`	返回一个新 Tensor，其张量数据为 `data`。
`Tensor.new_full`	返回一个大小为 `size` 并填充 `fill_value` 的 Tensor。
`Tensor.new_empty`	返回一个大小为 `size` 并填充未初始化数据的 Tensor。
`Tensor.new_ones`	返回一个大小为 `size` 并填充 `1` 的 Tensor。
`Tensor.new_zeros`	返回一个大小为 `size` 并填充 `0` 的 Tensor。
`Tensor.is_cuda`	如果 Tensor 存储在 GPU 上，则为 `True`，否则为 `False`。
`Tensor.is_quantized`	如果 Tensor 已量化，则为 `True`，否则为 `False`。
`Tensor.is_meta`	如果 Tensor 是 meta 张量，则为 `True`，否则为 `False`。
`Tensor.device`	此 Tensor 所在的 `torch.device`。
`Tensor.grad`	此属性默认为 `None`，并在第一次调用 `backward()` 计算 `self` 的梯度时变为一个 Tensor。
`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`	将标量或张量添加到 `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_`	将 `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_`	使用 `reduce` 参数指定的归约方法，将 `source` 的元素按 `index` 中给定的顺序累加到 `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()` 返回一个数据类型为 uint8_t 的 CPU 张量，它存储给定张量的底层 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`	创建一个与 `self` 具有相同数据指针的 `cls` 实例。
`Tensor.map_`	对 `self` 张量和给定的 `tensor` 中的每个元素应用 `callable`，并将结果存储到 `self` 张量中。
`Tensor.masked_scatter_`	将 `source` 中的元素复制到 `self` 张量中 `mask` 为 True 的位置。
`Tensor.masked_scatter`	`torch.Tensor.masked_scatter_()` 的非原地版本
`Tensor.masked_fill_`	用值 `value` 填充 `self` 张量中 `mask` 为 True 的元素。
`Tensor.masked_fill`	`torch.Tensor.masked_fill_()` 的非原地版本
`Tensor.masked_select`	请参阅 `torch.masked_select()`
`Tensor.matmul`	请参阅 `torch.matmul()`
`Tensor.matrix_power`	注意 `matrix_power()` 已弃用，请改用 `torch.linalg.matrix_power()`。
`Tensor.matrix_exp`	请参阅 `torch.matrix_exp()`
`Tensor.max`	请参阅 `torch.max()`
`Tensor.maximum`	请参阅 `torch.maximum()`
`Tensor.mean`	请参阅 `torch.mean()`
`Tensor.module_load`	定义在 `load_state_dict()` 中将 `other` 加载到 `self` 时如何转换 `other`。
`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`	给定通过线性(仿射)逐通道量化量化的张量，返回底层量化器的尺度张量。
`Tensor.q_per_channel_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_`	更改自动微分是否应该记录此张量上的操作：原地设置此张量的 `requires_grad` 属性。
`Tensor.reshape`	返回一个与 `self` 具有相同数据和元素数量但具有指定形状的张量。
`Tensor.reshape_as`	返回此张量，其形状与 `other` 相同。
`Tensor.resize_`	将 `self` 张量的大小调整为指定大小。
`Tensor.resize_as_`	将 `self` 张量的大小调整为与指定的 `tensor` 大小相同。
`Tensor.retain_grad`	启用此张量在 `backward()` 期间填充其 `grad`。
`Tensor.retains_grad`	如果此张量是非叶子张量且其 `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_`	以类似于 `scatter_()` 的方式，将张量 `src` 中的所有值添加到 `self` 张量中由 `index` 张量指定的索引位置。
`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`	执行张量 dtype 和/或设备的转换。
`Tensor.to_mkldnn`	返回张量在 `torch.mkldnn` 布局中的副本。
`Tensor.take`	参阅 `torch.take()`
`Tensor.take_along_dim`	参阅 `torch.take_along_dim()`
`Tensor.tan`	参阅 `torch.tan()`
`Tensor.tan_`	`tan()` 的原地版本。
`Tensor.tanh`	参阅 `torch.tanh()`
`Tensor.tanh_`	`tanh()` 的原地版本。
`Tensor.atanh`	参阅 `torch.atanh()`
`Tensor.atanh_`	`atanh()` 的原地版本。
`Tensor.arctanh`	参阅 `torch.arctanh()`
`Tensor.arctanh_`	`arctanh()` 的原地版本。
`Tensor.tolist`	将张量作为（嵌套）列表返回。
`Tensor.topk`	参阅 `torch.topk()`
`Tensor.to_dense`	如果 `self` 不是跨步张量，则创建其跨步副本，否则返回 `self`。
`Tensor.to_sparse`	返回张量的稀疏副本。
`Tensor.to_sparse_csr`	将张量转换为压缩行存储格式 (CSR)。
`Tensor.to_sparse_csc`	将张量转换为压缩列存储格式 (CSC)。
`Tensor.to_sparse_bsr`	将张量转换为给定块大小的块稀疏行 (BSR) 存储格式。
`Tensor.to_sparse_bsc`	将张量转换为给定块大小的块稀疏列 (BSC) 存储格式。
`Tensor.trace`	参阅 `torch.trace()`
`Tensor.transpose`	参阅 `torch.transpose()`
`Tensor.transpose_`	`transpose()` 的原地版本。
`Tensor.triangular_solve`	参阅 `torch.triangular_solve()`
`Tensor.tril`	参阅 `torch.tril()`
`Tensor.tril_`	`tril()` 的原地版本。
`Tensor.triu`	参阅 `torch.triu()`
`Tensor.triu_`	`triu()` 的原地版本。
`Tensor.true_divide`	参阅 `torch.true_divide()`
`Tensor.true_divide_`	`true_divide_()` 的原地版本。
`Tensor.trunc`	参阅 `torch.trunc()`
`Tensor.trunc_`	`trunc()` 的原地版本。
`Tensor.type`	如果未提供 dtype，则返回类型；否则将此对象转换为指定类型。
`Tensor.type_as`	返回转换为给定张量类型的此张量。
`Tensor.unbind`	参阅 `torch.unbind()`
`Tensor.unflatten`	参阅 `torch.unflatten()`。
`Tensor.unfold`	返回原始张量的一个视图，该视图包含 `self` 张量在维度 `dimension` 中所有大小为 `size` 的切片。
`Tensor.uniform_`	使用从连续均匀分布中采样的数字填充 `self` 张量。
`Tensor.unique`	返回输入张量的唯一元素。
`Tensor.unique_consecutive`	消除每个连续等效元素组中除第一个元素外的所有元素。
`Tensor.unsqueeze`	参阅 `torch.unsqueeze()`
`Tensor.unsqueeze_`	`unsqueeze()` 的原地版本。
`Tensor.values`	返回稀疏 COO 张量的值张量。
`Tensor.var`	参阅 `torch.var()`
`Tensor.vdot`	参阅 `torch.vdot()`
`Tensor.view`	返回一个新张量，其数据与 `self` 张量相同，但形状 `shape` 不同。
`Tensor.view_as`	将此张量视为与 `other` 大小相同。
`Tensor.vsplit`	参见 `torch.vsplit()`
`Tensor.where`	`self.where(condition, y)` 等效于 `torch.where(condition, self, y)`。
`Tensor.xlogy`	参见 `torch.xlogy()`
`Tensor.xlogy_`	`xlogy()` 的就地版本
`Tensor.xpu`	返回此对象在 XPU 内存中的副本。
`Tensor.zero_`	用零填充 `self` 张量。

torch.Tensor¶

数据类型¶

初始化和基本操作¶

Tensor 类参考¶

文档

教程

资源