torch.Tensor¶

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

数据类型¶

Torch 定义了 10 种具有 CPU 和 GPU 变体的张量类型，如下所示：

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

1: 有时称为 binary16：使用 1 个符号、5 个指数和 10 significand 位。当精度很重要但以牺牲范围为代价时很有用。
2: 有时称为大脑浮点：使用 1 个符号、8 个指数和 7 significand 位。当 range 很重要时很有用，因为它具有相同的指数位数为float32
3: 量化的 4 位整数存储为 8 位有符号整数。目前，它仅在 EmbeddingBag 运算符中受支持。

torch.Tensor是默认张量类型（）的别名。torch.FloatTensor

初始化和基本作¶

可以从 Python 构造张量list或使用torch.tensor()构造函数：

>>> torch.tensor([[1., -1.], [1., -1.]])
tensor([[ 1.0000, -1.0000],
        [ 1.0000, -1.0000]])
>>> torch.tensor(np.array([[1, 2, 3], [4, 5, 6]]))
tensor([[ 1,  2,  3],
        [ 4,  5,  6]])

警告

torch.tensor()始终复制 .如果你有一个 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 version`torch.Tensor.index_add_()`.
`Tensor.index_copy_`	复制的元素`tensor`通过按照中给定的顺序选择索引，将其放入张量中。`selfindex`
`Tensor.index_copy`	的 Out-of-place version`torch.Tensor.index_copy_()`.
`Tensor.index_fill_`	通过按照中给出的顺序选择索引，用 value 填充张量的元素。`selfvalueindex`
`Tensor.index_fill`	的 Out-of-place version`torch.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 version`torch.Tensor.masked_scatter_()`
`Tensor.masked_fill_`	用 where 为 True 填充 tensor 的元素。`selfvaluemask`
`Tensor.masked_fill`	的 Out-of-place version`torch.Tensor.masked_fill_()`
`Tensor.masked_select`	看`torch.masked_select()`
`Tensor.matmul`	看`torch.matmul()`
`Tensor.matrix_power`	注意 `matrix_power()`已弃用，请使用`torch.linalg.matrix_power()`相反。
`Tensor.matrix_exp`	看`torch.matrix_exp()`
`Tensor.max`	看`torch.max()`
`Tensor.maximum`	看`torch.maximum()`
`Tensor.mean`	看`torch.mean()`
`Tensor.nanmean`	看`torch.nanmean()`
`Tensor.median`	看`torch.median()`
`Tensor.nanmedian`	看`torch.nanmedian()`
`Tensor.min`	看`torch.min()`
`Tensor.minimum`	看`torch.minimum()`
`Tensor.mm`	看`torch.mm()`
`Tensor.smm`	看`torch.smm()`
`Tensor.mode`	看`torch.mode()`
`Tensor.movedim`	看`torch.movedim()`
`Tensor.moveaxis`	看`torch.moveaxis()`
`Tensor.msort`	看`torch.msort()`
`Tensor.mul`	看`torch.mul()`.
`Tensor.mul_`	的就地版本`mul()`.
`Tensor.multiply`	看`torch.multiply()`.
`Tensor.multiply_`	的就地版本`multiply()`.
`Tensor.multinomial`	看`torch.multinomial()`
`Tensor.mv`	看`torch.mv()`
`Tensor.mvlgamma`	看`torch.mvlgamma()`
`Tensor.mvlgamma_`	的就地版本`mvlgamma()`
`Tensor.nansum`	看`torch.nansum()`
`Tensor.narrow`	看`torch.narrow()`.
`Tensor.narrow_copy`	看`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 version`torch.Tensor.scatter_()`
`Tensor.scatter_`	将张量中的所有值写入张量中指定的索引处。`srcselfindex`
`Tensor.scatter_add_`	将张量中的所有值添加到张量中指定的索引处，其方式与`srcselfindexscatter_()`.
`Tensor.scatter_add`	的 Out-of-place version`torch.Tensor.scatter_add_()`
`Tensor.scatter_reduce_`	使用通过参数（、）定义的应用缩减，将张量中的所有值减少到张量中张量中指定的索引。`srcindexselfreduce"sum""prod""mean""amax""amin"`
`Tensor.scatter_reduce`	的 Out-of-place version`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`	返回一个新的稀疏张量，其中包含由 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`

torch.Tensor¶

数据类型¶

初始化和基本作¶

Tensor 类参考¶

文档

教程

资源