torch.Tensor¶

A 是一个多维矩阵，其中包含单个数据类型。

数据类型¶

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`

但是，要构造张量，我们建议改用工厂函数，例如带有参数的函数。构造函数是默认张量类型的别名 ().dtypetorch.FloatTensor

初始化和基本操作¶

可以使用构造函数从 Python 或序列构造张量：

>>> 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]])

警告

始终复制 .如果你有一个 Tensor 并且只想更改它的标志，请使用 or 以避免复制。如果您有一个 numpy 数组并希望避免复制，请使用 .datadatarequires_grad

可以通过将 and/或 a 传递给构造函数或张量创建操作：

>>> 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]])

用于从包含单个值：

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

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

注意

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

注意

有关 a 的、和属性的更多信息，请参阅张量属性。

注意

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

注意

要更改现有张量的 and/or ，请考虑对张量使用 method。

警告

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

Tensor 类参考¶

类 Torch 的 Torch 类张肌¶

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

要使用预先存在的数据创建张量，请使用。
要创建具有特定大小的张量，请使用 Tensor creation ops （请参阅创建操作）。torch.*
要创建与另一个张量大小相同（和类似类型）的张量，请执行以下操作：使用 Tensor Creation Ops （参见 Creation Ops）。torch.*_like
要创建与另一个张量类型相似但大小不同的张量，请执行以下操作：使用 Creation Ops。tensor.new_*
不鼓励使用旧版构造函数。请改用。torch.Tensor

张肌。__init__（self， data）)¶

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

如果是 Tensor，则返回原始 Tensor 的别名。与不同，这会跟踪 autograd 并将渐变传播到原始 Tensor 的 Tensor 。此类型不支持 kwarg。datadevicedata
如果是序列或嵌套序列，则创建默认 dtype（通常为），其数据是序列，必要时执行强制转换。值得注意的是，这与此构造函数将始终构造 float 的不同之处在于 tensor 的 Tensor 中，即使输入都是整数。datatorch.float32
如果是 a ，则返回该大小的空张量。data

此构造函数不支持显式指定或返回的 Tensor。我们建议使用它提供这个功能性。dtypedevice

参数：

data （array_like）：要从中构造的张量。

关键字 args：

device （可选）：返回的 Tensor 的所需设备。: 默认值：如果为 None，则与此张量相同。

张肌。吨¶

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

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

警告

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

张肌。H¶

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

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

另请参阅

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

张肌。兆吨¶

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

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

张肌。mH¶: 访问此属性等效于调用 .

`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`	是这个 Tensor 所在的位置。
`张量.grad`	默认情况下，此属性在第一次调用计算的梯度时变为 Tensor。`Nonebackward()self`
`张量.ndim`	别名
`张量.real`	返回一个新张量，其中包含复值输入张量的张量的实数值。`self`
`Tensor.imag`	返回包含张量的虚数值的新张量。`self`
`张量.nbytes`	如果 Tensor 不使用稀疏存储布局，则返回 Tensor 元素的“视图”消耗的字节数。
`Tensor.itemsize`	别名
`张量.abs`	看
`Tensor.abs_`	的就地版本
`Tensor.absolute`	别名
`Tensor.absolute_`	别名的就地版本`abs_()`
`张量.acos`	看
`Tensor.acos_`	的就地版本
`Tensor.arccos`	看
`Tensor.arccos_`	的就地版本
`张量.add`	将标量或张量添加到 tensor。`self`
`Tensor.add_`	的就地版本
`Tensor.addbmm`	看
`Tensor.addbmm_`	的就地版本
`Tensor.addcdiv`	看
`Tensor.addcdiv_`	的就地版本
`Tensor.addcmul`	看
`Tensor.addcmul_`	的就地版本
`Tensor.addmm`	看
`Tensor.addmm_`	的就地版本
`张量.sspaddmm`	看
`Tensor.addmv`	看
`Tensor.addmv_`	的就地版本
`Tensor.addr`	看
`Tensor.addr_`	的就地版本
`Tensor.adjoint`	别名
`Tensor.allclose`	看
`张量.amax`	看
`Tensor.amin`	看
`张量.aminmax`	看
`张量.angle`	看
`Tensor.apply_`	将函数应用于张量中的每个元素，将每个元素替换为返回的值。`callablecallable`
`张量.argmax`	看
`Tensor.argmin`	看
`Tensor.arg排序`	看
`Tensor.arg，其中`	看
`Tensor.asin`	看
`Tensor.asin_`	的就地版本
`Tensor.arcsin`	看
`Tensor.arcsin_`	的就地版本
`Tensor.as_strided`	看
`Tensor.atan`	看
`Tensor.atan_`	的就地版本
`Tensor.arctan`	看
`Tensor.arctan_`	的就地版本
`张量.atan2`	看
`Tensor.atan2_`	的就地版本
`张量.arctan2`	看
`Tensor.arctan2_`	atan2_（其他） -> 张量
`Tensor.all`	看
`张量.any`	看
`张量.backward`	计算当前张量 wrt 图叶子的梯度。
`Tensor.baddbmm`	看
`Tensor.baddbmm_`	的就地版本
`张量.bernoulli`	返回一个结果张量，其中每个 $\texttt{result[i]}$ 独立采样自 $\text{Bernoulli}(\texttt{self[i]})$ .
`Tensor.bernoulli_`	用独立的样品填充的每个位置`self` $\text{Bernoulli}(\texttt{p})$ .
`张量.bfloat16`	`self.bfloat16()`等效于。`self.to(torch.bfloat16)`
`Tensor.bincount`	看
`Tensor.bitwise_not`	看
`Tensor.bitwise_not_`	的就地版本
`Tensor.bitwise_and`	看
`Tensor.bitwise_and_`	的就地版本
`Tensor.bitwise_or`	看
`Tensor.bitwise_or_`	的就地版本
`Tensor.bitwise_xor`	看
`Tensor.bitwise_xor_`	的就地版本
`Tensor.bitwise_left_shift`	看
`Tensor.bitwise_left_shift_`	的就地版本
`Tensor.bitwise_right_shift`	看
`Tensor.bitwise_right_shift_`	的就地版本
`张量.bmm`	看
`Tensor.bool`	`self.bool()`等效于。`self.to(torch.bool)`
`张量.byte`	`self.byte()`等效于。`self.to(torch.uint8)`
`Tensor.broadcast_to`	请参阅。
`Tensor.cauchy_`	用从 Cauchy 分布中提取的数字填充张量：
`张量.ceil`	看
`Tensor.ceil_`	的就地版本
`张量.char`	`self.char()`等效于。`self.to(torch.int8)`
`张量.cholesky`	看
`Tensor.cholesky_inverse`	看
`Tensor.cholesky_solve`	看
`张量.chunk`	看
`Tensor.clamp`	看
`Tensor.clamp_`	的就地版本
`张量.clip`	的别名 .
`Tensor.clip_`	的别名 .
`张量.clone`	看
`Tensor.contiguous`	返回包含与 tensor 相同数据的 contiguous in memory tensor。`self`
`Tensor.copy_`	将元素从复制到 tensor 中并返回。`srcselfself`
`张量.conj`	看
`Tensor.conj_physical`	看
`Tensor.conj_physical_`	的就地版本
`Tensor.resolve_conj`	看
`Tensor.resolve_neg`	看
`Tensor.copysign`	看
`Tensor.copysign_`	的就地版本
`张量.cos`	看
`Tensor.cos_`	的就地版本
`Tensor.cosh`	看
`Tensor.cosh_`	的就地版本
`Tensor.corrcoef`	看
`Tensor.count_nonzero`	看
`张量.cov`	看
`张量.acosh`	看
`Tensor.acosh_`	的就地版本
`张量.arccosh`	acosh（） -> 张量
`Tensor.arccosh_`	acosh_（） -> 张量
`张量.cpu`	返回 CPU 内存中此对象的副本。
`张量.cross`	看
`张量.cuda`	返回 CUDA 内存中此对象的副本。
`张量.logcumsumexp`	看
`张量.cummax`	看
`张量.cummin`	看
`Tensor.cumprod`	看
`Tensor.cumprod_`	的就地版本
`张量.cumsum`	看
`Tensor.cumsum_`	的就地版本
`张量.chalf`	`self.chalf()`等效于。`self.to(torch.complex32)`
`Tensor.cfloat`	`self.cfloat()`等效于。`self.to(torch.complex64)`
`张量.cdouble`	`self.cdouble()`等效于。`self.to(torch.complex128)`
`Tensor.data_ptr`	返回 tensor 的第一个元素的地址。`self`
`张量.deg2rad`	看
`Tensor.dequantize`	给定一个量化的 Tensor，对其进行反量化并返回反量化的 float Tensor。
`张量.det`	看
`Tensor.dense_dim`	返回 sparse tensor 中的密集维度数。`self`
`Tensor.detach`	返回与当前图形分离的新 Tensor。
`Tensor.detach_`	将 Tensor 与创建它的图形分离，使其成为叶子。
`Tensor.diag`	看
`Tensor.diag_embed`	看
`Tensor.diagflat`	看
`Tensor.diagonal`	看
`Tensor.diagonal_scatter`	看
`Tensor.fill_diagonal_`	填充至少具有 2 维的张量的主对角线。
`张量.fmax`	看
`Tensor.fmin`	看
`Tensor.diff`	看
`张量.digamma`	看
`Tensor.digamma_`	的就地版本
`张量.dim`	返回 tensor 的维数。`self`
`Tensor.dim_order`	返回一个 int 元组，描述的暗序或物理布局。`self`
`Tensor.dist`	看
`张量.div`	看
`Tensor.div_`	的就地版本
`张量.divide`	看
`Tensor.divide_`	的就地版本
`张量点`	看
`Tensor.double`	`self.double()`等效于。`self.to(torch.float64)`
`Tensor.dsplit`	看
`Tensor.element_size`	返回单个元素的大小（以字节为单位）。
`张量.eq`	看
`Tensor.eq_`	的就地版本
`Tensor.equal`	看
`张量.erf`	看
`Tensor.erf_`	的就地版本
`张量.erfc`	看
`Tensor.erfc_`	的就地版本
`张量.erfinv`	看
`Tensor.erfinv_`	的就地版本
`张量.exp`	看
`Tensor.exp_`	的就地版本
`张量.expm1`	看
`Tensor.expm1_`	的就地版本
`张量.expand`	返回张量的新视图，其中单例维度扩展为更大的大小。`self`
`Tensor.expand_as`	将此张量扩展为与相同的大小。`other`
`Tensor.exponential_`	用从 PDF 中提取的元素填充张量（概率密度函数）：`self`
`张量修复`	请参阅。
`Tensor.fix_`	的就地版本
`Tensor.fill_`	用指定的值填充 tensor。`self`
`Tensor.flatten`	看
`张量.flip`	看
`张量.fliplr`	看
`张量.flipud`	看
`张量浮点`	`self.float()`等效于。`self.to(torch.float32)`
`Tensor.float_power`	看
`Tensor.float_power_`	的就地版本
`张量.floor`	看
`Tensor.floor_`	的就地版本
`Tensor.floor_divide`	看
`Tensor.floor_divide_`	的就地版本
`张量.fmod`	看
`Tensor.fmod_`	的就地版本
`张量.frac`	看
`Tensor.frac_`	的就地版本
`Tensor.frexp 函数`	看
`Tensor.gather`	看
`张量.gcd`	看
`Tensor.gcd_`	的就地版本
`Tensor.ge`	请参阅。
`Tensor.ge_`	的就地版本 .
`Tensor.greater_equal`	请参阅。
`Tensor.greater_equal_`	的就地版本 .
`Tensor.geometric_`	用从几何分布中提取的元素填充张量：`self`
`张量.geqrf`	看
`张量.ger`	看
`Tensor.get_device`	对于 CUDA 张量，此函数返回张量所在的 GPU 的设备序号。
`Tensor.gt`	请参阅。
`Tensor.gt_`	的就地版本 .
`Tensor.greater`	请参阅。
`Tensor.greater_`	的就地版本 .
`Tensor.half`	`self.half()`等效于。`self.to(torch.float16)`
`Tensor.hardshrink`	看
`张量.heaviside`	看
`张量.histc`	看
`张量.histogram`	看
`Tensor.hsplit`	看
`张量.hypot`	看
`Tensor.hypot_`	的就地版本
`张量.i0`	看
`Tensor.i0_`	的就地版本
`张量.igamma`	看
`Tensor.igamma_`	的就地版本
`张量.igammac`	看
`Tensor.igammac_`	的就地版本
`Tensor.index_add_`	按照中给出的顺序添加到索引中，将 times 的元素累积到张量中。`alphasourceselfindex`
`Tensor.index_add`	的 .
`Tensor.index_copy_`	通过按照中给定的顺序选择索引，将的元素复制到张量中。`selfindex`
`Tensor.index_copy`	的 .
`Tensor.index_fill_`	通过按照中给出的顺序选择索引，用 value 填充张量的元素。`selfvalueindex`
`Tensor.index_fill`	的 .
`Tensor.index_put_`	使用中指定的索引（这是一个 Tensor 元组）将 tensor 中的值放入 tensor 中。`valuesselfindices`
`Tensor.index_put`	的 Out-place 版本。
`Tensor.index_reduce_`	通过使用参数给出的 reduction 给出的顺序累积到索引，将的元素累积到张量中。`sourceselfindexreduce`
`Tensor.index_reduce`
`Tensor.index_select`	看
`张量.indices`	返回稀疏 COO 张量的 indices 张量。
`张量.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`	看
`Tensor.isclose`	看
`Tensor.isfinite`	看
`张量.isinf`	看
`Tensor.isposinf`	看
`Tensor.isneginf`	看
`Tensor.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`
`张量.istft`	看
`Tensor.isreal`	看
`Tensor.item`	将此张量的值作为标准 Python 数字返回。
`Tensor.kth值`	看
`张量.lcm`	看
`Tensor.lcm_`	的就地版本
`张量.ldexp`	看
`Tensor.ldexp_`	的就地版本
`张量.le`	请参阅。
`Tensor.le_`	的就地版本 .
`Tensor.less_equal`	请参阅。
`Tensor.less_equal_`	的就地版本 .
`Tensor.lerp`	看
`Tensor.lerp_`	的就地版本
`张量.lgamma`	看
`Tensor.lgamma_`	的就地版本
`Tensor.log`	看
`Tensor.log_`	的就地版本
`Tensor.logdet`	看
`张量.log10`	看
`Tensor.log10_`	的就地版本
`张量.log1p`	看
`Tensor.log1p_`	的就地版本
`张量.log2`	看
`Tensor.log2_`	的就地版本
`Tensor.log_正常_`	用来自对数正态分布的数字样本填充张量，该分布由给定均值参数化`self` $\mu$ 和标准差 $\sigma$ .
`张量.logaddexp`	看
`张量.logaddexp2`	看
`Tensor.logsumexp`	看
`Tensor.logical_and`	看
`Tensor.logical_and_`	的就地版本
`Tensor.logical_not`	看
`Tensor.logical_not_`	的就地版本
`Tensor.logical_or`	看
`Tensor.logical_or_`	的就地版本
`Tensor.logical_xor`	看
`Tensor.logical_xor_`	的就地版本
`Tensor.logit`	看
`Tensor.logit_`	的就地版本
`Tensor.long 函数`	`self.long()`等效于。`self.to(torch.int64)`
`Tensor.lt`	请参阅。
`Tensor.lt_`	的就地版本 .
`Tensor.less`	lt（other） -> 张量
`Tensor.less_`	的就地版本 .
`Tensor.lu`	看
`Tensor.lu_solve`	看
`Tensor.as_subclass`	创建具有与相同的数据指针的实例。`clsself`
`Tensor.map_`	应用于 tensor 和 given 中的每个元素，并将结果存储在 tensor 中。`callableselfself`
`Tensor.masked_scatter_`	将元素从复制到 tensor 中为 True 的位置。`sourceselfmask`
`Tensor.masked_scatter`	的 Out-of-place version
`Tensor.masked_fill_`	用 where 为 True 填充 tensor 的元素。`selfvaluemask`
`Tensor.masked_fill`	的 Out-of-place version
`Tensor.masked_select`	看
`张量.matmul`	看
`Tensor.matrix_power`	注意已弃用，请改用 USE。
`Tensor.matrix_exp`	看
`Tensor.max`	看
`Tensor.maximum`	看
`Tensor.mean`	看
`Tensor.module_load`	定义在将其加载到中时如何变换。`otherself`
`张量.nanmean`	看
`Tensor.median`	看
`Tensor.nanmedian`	看
`张量.min`	看
`Tensor.minimum`	看
`Tensor.mm`	看
`张量.smm`	看
`Tensor.mode`	看
`Tensor.movedim`	看
`Tensor.moveaxis`	看
`Tensor.msort`	看
`Tensor.mul`	请参阅。
`Tensor.mul_`	的就地版本 .
`Tensor.multiply`	请参阅。
`Tensor.multiply_`	的就地版本 .
`Tensor.multinomial （张量.多项式）`	看
`Tensor.mv`	看
`张量.mvlgamma`	看
`Tensor.mvlgamma_`	的就地版本
`张量.nansum`	看
`Tensor.窄`	请参阅。
`Tensor.narrow_copy`	请参阅。
`Tensor.ndimension`	别名
`Tensor.nan_to_num`	请参阅。
`Tensor.nan_to_num_`	的就地版本 .
`Tensor.ne`	请参阅。
`Tensor.ne_`	的就地版本 .
`Tensor.not_equal`	请参阅。
`Tensor.not_equal_`	的就地版本 .
`张量.neg`	看
`Tensor.neg_`	的就地版本
`张量.负`	看
`Tensor.negative_`	的就地版本
`Tensor.nelement`	别名
`Tensor.nextafter`	看
`Tensor.nextafter_`	的就地版本
`Tensor.nonzero`	看
`张量.范数`	看
`Tensor.normal_`	用来自正态分布的元素样本填充张量，参数化为和。`self`
`张量.numel`	看
`张量.numpy`	将张量作为 NumPy 返回。`ndarray`
`张量.orgqr`	看
`Tensor.ormqr`	看
`Tensor.outer 的`	请参阅。
`Tensor.permute`	看
`Tensor.pin_memory`	将张量复制到固定内存（如果尚未固定）。
`张量.pinverse`	看
`Tensor.polygamma`	看
`Tensor.polygamma_`	的就地版本
`Tensor.positive`	看
`张量.pow`	看
`Tensor.pow_`	的就地版本
`Tensor.prod`	看
`Tensor.put_`	将元素从复制到中指定的位置。`sourceindex`
`张量.qr`	看
`Tensor.qscheme`	返回给定 QTensor 的量化方案。
`Tensor.quantile`	看
`Tensor.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`	看
`Tensor.random_`	用从离散均匀分布中采样的数字填充张量。`self[from, to - 1]`
`张量.ravel`	看
`Tensor.倒数`	看
`Tensor.reciprocal_`	的就地版本
`Tensor.record_stream`	将张量标记为此流已使用。
`Tensor.register_hook`	注册一个向后钩子。
`Tensor.register_post_accumulate_grad_hook`	注册一个在 grad 累积后运行的 backward hook。
`Tensor.remainder`	看
`Tensor.remainder_`	的就地版本
`张量.renorm`	看
`Tensor.renorm_`	的就地版本
`张量.repeat`	沿指定维度重复此张量。
`Tensor.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_`	将张量的大小调整为与指定的 .`self`
`Tensor.retain_grad`	允许此 Tensor 在期间填充其。`gradbackward()`
`Tensor.retains_grad`	如果此 Tensor 是非叶子的，并且允许在期间填充它，否则。`Truegradbackward()False`
`张量.滚动`	看
`张量.rot90`	看
`张量.round`	看
`Tensor.round_`	的就地版本
`张量.rsqrt`	看
`Tensor.rsqrt_`	的就地版本
`张量.scatter`	的 Out-of-place version
`Tensor.scatter_`	将张量中的所有值写入张量中指定的索引处。`srcselfindex`
`Tensor.scatter_add_`	将张量中的所有值添加到张量中指定的索引中，其方式与类似。`srcselfindex`
`Tensor.scatter_add`	的 Out-of-place version
`Tensor.scatter_reduce_`	使用通过参数（、）定义的应用缩减，将张量中的所有值减少到张量中张量中指定的索引。`srcindexselfreduce"sum""prod""mean""amax""amin"`
`Tensor.scatter_reduce`	的 Out-of-place version
`Tensor.select`	看
`Tensor.select_scatter`	看
`Tensor.set_`	设置底层存储、大小和步幅。
`Tensor.share_memory_`	将底层存储移动到共享内存。
`Tensor.short`	`self.short()`等效于。`self.to(torch.int16)`
`Tensor.sigmoid`	看
`Tensor.sigmoid_`	的就地版本
`张量符号`	看
`Tensor.sign_`	的就地版本
`Tensor.signbit`	看
`张量.sgn`	看
`Tensor.sgn_`	的就地版本
`张量.sin`	看
`Tensor.sin_`	的就地版本
`张量.sinc`	看
`Tensor.sinc_`	的就地版本
`张量.sinh`	看
`Tensor.sinh_`	的就地版本
`张量.asinh`	看
`Tensor.asinh_`	的就地版本
`Tensor.arcsinh`	看
`Tensor.arcsinh_`	的就地版本
`Tensor.shape`	返回张量的大小。`self`
`Tensor.size`	返回张量的大小。`self`
`Tensor.slogdet`	看
`Tensor.slice_scatter`	看
`张量.softmax`	的别名 .
`张量.sort`	看
`Tensor.split`	看
`Tensor.sparse_mask`	返回一个新的稀疏张量，其中包含由 sparse 张量的索引过滤的跨步张量中的值。`selfmask`
`Tensor.sparse_dim`	返回稀疏张量中的稀疏维度数。`self`
`张量.sqrt`	看
`Tensor.sqrt_`	的就地版本
`张量.square`	看
`Tensor.square_`	的就地版本
`张量.squeeze`	看
`Tensor.squeeze_`	的就地版本
`张量.std`	看
`张量.stft`	看
`Tensor.storage`	返回基础 .
`Tensor.untyped_storage`	返回基础 .
`Tensor.storage_offset`	返回 tensor 在底层存储中的偏移量，以存储元素（而不是字节）的数量表示。`self`
`Tensor.storage_type`	返回底层存储的类型。
`Tensor.stride`	返回 tensor 的步幅。`self`
`张量.sub`	请参阅。
`Tensor.sub_`	的就地版本
`Tensor.subtract`	请参阅。
`Tensor.subtract_`	的就地版本 .
`张量.sum`	看
`Tensor.sum_to_size`	将张量求和为。`thissize`
`张量.svd`	看
`Tensor.swapaxes`	看
`张量.swapdims`	看
`张量.t`	看
`Tensor.t_`	的就地版本
`Tensor.tensor_split`	看
`张量.tile`	看
`Tensor.to`	执行 Tensor dtype 和/或 device 转换。
`Tensor.to_mkldnn`	返回 layout 中张量的副本。`torch.mkldnn`
`张量.take`	看
`Tensor.take_along_dim`	看
`张量.tan`	看
`Tensor.tan_`	的就地版本
`张量.tanh`	看
`Tensor.tanh_`	的就地版本
`张量.atanh`	看
`Tensor.atanh_`	的就地版本
`Tensor.arctanh`	看
`Tensor.arctanh_`	的就地版本
`Tensor.tolist`	以（嵌套）列表的形式返回张量。
`张量.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）存储格式。
`张量.trace`	看
`张量.transpose`	看
`Tensor.transpose_`	的就地版本
`Tensor.triangular_solve`	看
`Tensor.tril`	看
`Tensor.tril_`	的就地版本
`张量.triu`	看
`Tensor.triu_`	的就地版本
`Tensor.true_divide`	看
`Tensor.true_divide_`	的就地版本
`张量.trunc`	看
`Tensor.trunc_`	的就地版本
`Tensor.type`	如果未提供 dtype，则返回类型，否则将此对象强制转换为指定类型。
`Tensor.type_as`	将此张量强制转换为给定张量的类型。
`Tensor.unbind`	看
`Tensor.unflatten`	请参阅。
`张量.unfold`	返回原始张量的视图，其中包含维度中 tensor 的所有大小切片。`sizeselfdimension`
`Tensor.uniform_`	用从连续均匀分布中采样的数字填充张量：`self`
`Tensor.unique`	返回输入张量的唯一元素。
`Tensor.unique_consecutive`	从每组连续的等效元素中消除除第一个元素之外的所有元素。
`张量.unsqueeze`	看
`Tensor.unsqueeze_`	的就地版本
`Tensor.values`	返回稀疏 COO 张量的 values tensor。
`张量.var`	看
`张量.vdot`	看
`Tensor.view`	返回一个新张量，其数据与张量相同，但具有不同的。`selfshape`
`Tensor.view_as`	将此张量视为与相同的大小。`other`
`Tensor.vsplit`	看
`Tensor.where`	`self.where(condition, y)`等效于。`torch.where(condition, self, y)`
`Tensor.xlogy`	看
`Tensor.xlogy_`	的就地版本
`张量.xpu`	返回 XPU 内存中此对象的副本。
`Tensor.zero_`	用零填充 tensor。`self`

torch.Tensor¶

数据类型¶

初始化和基本操作¶

Tensor 类参考¶

文档

教程

资源