MemoryMappedTensor

class tensordict.MemoryMappedTensor(source, *, dtype=None, shape=None, index=None, device=None, handler=None, filename=None)

内存映射张量。

支持文件名或文件句柄。

MemoryMappedTensor 的主要优势在于它的序列化方法，可以确保张量在没有任何复制的情况下通过队列或 RPC 远程调用传递。

注意

在 RPC 设置中使用时，文件路径应可被两个节点访问。如果不可访问，从一个工作节点传递 MemoryMappedTensor 到另一个工作节点的行为是未定义的。

MemoryMappedTensor 支持多种构造方法。

示例

>>> # from an existing tensor
>>> tensor = torch.randn(3)
>>> with tempfile.NamedTemporaryFile() as file:
...     memmap_tensor = MemoryMappedTensor.from_tensor(tensor, filename=file.name)
...     assert memmap_tensor.filename is not None
>>> # if no filename is passed, a handler is used
>>> tensor = torch.randn(3)
>>> memmap_tensor = MemoryMappedTensor.from_tensor(tensor, filename=file.name)
>>> assert memmap_tensor.filename is None
>>> # one can create an empty tensor too
>>> with tempfile.NamedTemporaryFile() as file:
...     memmap_tensor_empty = MemoryMappedTensor.empty_like(tensor, filename=file.name)
>>> with tempfile.NamedTemporaryFile() as file:
...     memmap_tensor_zero = MemoryMappedTensor.zeros_like(tensor, filename=file.name)
>>> with tempfile.NamedTemporaryFile() as file:
...     memmap_tensor = MemoryMappedTensor.ones_like(tensor, filename=file.name)

H

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

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

另请参阅

mH: 一个同样适用于矩阵批量的属性。

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)) 来反转张量的维度。

abs() → Tensor

请参见 torch.abs()

abs_() → Tensor

abs() 的就地版本

absolute() → Tensor

abs() 的别名

absolute_() → Tensor

absolute() 的就地版本 abs_() 的别名

acos() → Tensor

请参见 torch.acos()

acos_() → Tensor

acos() 的就地版本

acosh() → Tensor

请参见 torch.acosh()

acosh_() → Tensor

acosh() 的就地版本

add(other, *, alpha=1) → Tensor

将标量或张量添加到 self 张量。如果同时指定了 alpha 和 other，则在使用 other 的每个元素之前，将其乘以 alpha。

当 other 为张量时，other 的形状必须与底层张量的形状 广播兼容。

请参见 torch.add()

add_(other, *, alpha=1) → Tensor

add()

addbmm(batch1, batch2, *, beta=1, alpha=1) → Tensor

torch.addbmm()

addbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor

addbmm()

addcdiv(tensor1, tensor2, *, value=1) → Tensor

torch.addcdiv()

addcdiv_(tensor1, tensor2, *, value=1) → Tensor

addcdiv()

addcmul(tensor1, tensor2, *, value=1) → Tensor

torch.addcmul()

addcmul_(tensor1, tensor2, *, value=1) → Tensor

addcmul()

addmm(mat1, mat2, *, beta=1, alpha=1) → Tensor

torch.addmm()

addmm_(mat1, mat2, *, beta=1, alpha=1) → Tensor

addmm()

addmv(mat, vec, *, beta=1, alpha=1) → Tensor

torch.addmv()

addmv_(mat, vec, *, beta=1, alpha=1) → Tensor

addmv()

addr(vec1, vec2, *, beta=1, alpha=1) → Tensor

torch.addr()

addr_(vec1, vec2, *, beta=1, alpha=1) → Tensor

addr()

adjoint() → Tensor

adjoint()

align_as(other) → Tensor

self other other self.names other.names align_to()

self.names self.names

align_to()

示例

# Example 1: Applying a mask
>>> mask = torch.randint(2, [127, 128], dtype=torch.bool).refine_names('W', 'H')
>>> imgs = torch.randn(32, 128, 127, 3, names=('N', 'H', 'W', 'C'))
>>> imgs.masked_fill_(mask.align_as(imgs), 0)


# Example 2: Applying a per-channel-scale
>>> def scale_channels(input, scale):
>>>    scale = scale.refine_names('C')
>>>    return input * scale.align_as(input)

>>> num_channels = 3
>>> scale = torch.randn(num_channels, names=('C',))
>>> imgs = torch.rand(32, 128, 128, num_channels, names=('N', 'H', 'W', 'C'))
>>> more_imgs = torch.rand(32, num_channels, 128, 128, names=('N', 'C', 'H', 'W'))
>>> videos = torch.randn(3, num_channels, 128, 128, 128, names=('N', 'C', 'H', 'W', 'D'))

# scale_channels is agnostic to the dimension order of the input
>>> scale_channels(imgs, scale)
>>> scale_channels(more_imgs, scale)
>>> scale_channels(videos, scale)

警告

align_to(*names)

self names

self 的所有维度名称都必须出现在 names 中。 names 可能包含 self.names 中没有的额外名称；输出张量对于每个新名称都有一个大小为一的维度。

names 最多可以包含一个省略号 (...)。省略号被扩展为等于 self 的所有未在 names 中提到的维度名称，它们按照在 self 中出现的顺序排列。

Python 2 不支持省略号，但可以使用字符串字面量代替 ('...')。

参数:

names (可迭代的 str) – 输出张量的所需维度排序。最多可以包含一个省略号，该省略号被扩展为 self 的所有未提及的维度名称。

示例

>>> tensor = torch.randn(2, 2, 2, 2, 2, 2)
>>> named_tensor = tensor.refine_names('A', 'B', 'C', 'D', 'E', 'F')

# Move the F and E dims to the front while keeping the rest in order
>>> named_tensor.align_to('F', 'E', ...)

警告

all(dim=None, keepdim=False) → Tensor

参见 torch.all()

allclose(other, rtol=1e-05, atol=1e-08, equal_nan=False) → Tensor

参见 torch.allclose()

amax(dim=None, keepdim=False) → Tensor

参见 torch.amax()

amin(dim=None, keepdim=False) → Tensor

参见 torch.amin()

aminmax(*, dim=None, keepdim=False) -> (Tensor min, Tensor max)

参见 torch.aminmax()

angle() → Tensor

参见 torch.angle()

any(dim=None, keepdim=False) → Tensor

参见 torch.any()

apply_(callable) → Tensor

将函数 callable 应用于张量中的每个元素，用 callable 返回的值替换每个元素。

注意

此函数仅适用于 CPU 张量，不应在需要高性能的代码部分使用。

arccos() → Tensor

参见 torch.arccos()

arccos_() → Tensor

arccos() 的就地版本

arccosh()

acosh() -> Tensor

参见 torch.arccosh()

arccosh_()

acosh_() -> Tensor

arccosh() 的就地版本

arcsin() → Tensor

参见 torch.arcsin()

arcsin_() → Tensor

arcsin() 的就地版本

arcsinh() → Tensor

参见 torch.arcsinh()

arcsinh_() → Tensor

arcsinh() 的就地版本

arctan() → Tensor

参见 torch.arctan()

arctan2(other) → Tensor

参见 torch.arctan2()

arctan2_()

atan2_(other) -> Tensor

arctan2() 的就地版本

arctan_() → Tensor

arctan() 的就地版本

arctanh() → Tensor

参见 torch.arctanh()

arctanh_(other) → Tensor

arctanh() 的就地版本

argmax(dim=None, keepdim=False) → LongTensor

参见 torch.argmax()

argmin(dim=None, keepdim=False) → LongTensor

参见 torch.argmin()

argsort(dim=- 1, descending=False) → LongTensor

参见 torch.argsort()

argwhere() → Tensor

参见 torch.argwhere()

as_strided(size, stride, storage_offset=None) → Tensor

参见 torch.as_strided()

as_strided_(size, stride, storage_offset=None) → Tensor

as_strided() 的就地版本

as_strided_scatter(src, size, stride, storage_offset=None) → Tensor

参见 torch.as_strided_scatter()

as_subclass(cls) → Tensor

使用与 self 相同的数据指针创建一个 cls 实例。输出中的更改会反映在 self 中，并且输出保持连接到自动梯度图。 cls 必须是 Tensor 的子类。

asin() → Tensor

参见 torch.asin()

asin_() → Tensor

asin() 的就地版本

asinh() → Tensor

参见 torch.asinh()

asinh_() → Tensor

asinh() 的就地版本

atan() → Tensor

参见 torch.atan()

atan2(other) → Tensor

参见 torch.atan2()

atan2_(other) → Tensor

atan2() 的就地版本

atan_() → Tensor

atan() 的就地版本

atanh() → Tensor

参见 torch.atanh()

atanh_(other) → Tensor

atanh() 的就地版本

backward(gradient=None, retain_graph=None, create_graph=False, inputs=None)

计算当前张量相对于图叶的梯度。

使用链式法则对图进行微分。如果张量是非标量（即其数据有多个元素）并且需要梯度，则该函数还需要指定一个 gradient。它应该是一个具有匹配类型和形状的张量，表示微分函数相对于 self 的梯度。

此函数在叶节点中累积梯度 - 你可能需要在调用它之前将 .grad 属性清零或将其设置为 None。有关累积梯度的内存布局的详细信息，请参见 默认梯度布局。

注意

如果你在用户指定的 CUDA 流上下文中运行任何正向操作、创建 gradient 或调用 backward，请参见 反向传播的流语义。

注意

当提供 inputs 并且给定输入不是叶节点时，当前实现将调用其 grad_fn（尽管严格来说不需要获得这些梯度）。这是一个实现细节，用户不应该依赖。有关更多详细信息，请参见 https://github.com/pytorch/pytorch/pull/60521#issuecomment-867061780。

参数:

• gradient (Tensor, optional) – 微分函数相对于 self 的梯度。如果 self 是标量，则可以省略此参数。

• retain_graph (bool, 可选) – 如果 False，用于计算梯度的图将被释放。请注意，在几乎所有情况下，将此选项设置为 True 都是不需要的，并且通常可以用更有效的方式解决。默认为 create_graph 的值。

• create_graph (bool, 可选) – 如果 True，将构建导数图，允许计算更高阶导数乘积。默认为 False。

• inputs (张量序列, 可选) – 要累积梯度的输入。所有其他张量将被忽略。如果没有提供，则梯度将累积到所有用于计算 tensors 的叶张量中。

baddbmm(batch1, batch2, *, beta=1, alpha=1) → Tensor

参见 torch.baddbmm()

baddbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor

baddbmm() 的就地版本。

bernoulli(*, generator=None) → Tensor

返回一个结果张量，其中每个 \(\texttt{result[i]}\) 独立地从 \(\text{Bernoulli}(\texttt{self[i]})\) 中采样。 self 必须具有浮点 dtype，结果将具有相同的 dtype。

参见 torch.bernoulli()

bernoulli_(p=0.5, *, generator=None) → Tensor

用从 \(\text{Bernoulli}(\texttt{p})\) 中独立采样的值填充 self 的每个位置。 self 可以具有整数 dtype。

p 应该是一个标量或包含用于绘制二元随机数的概率的张量。

如果它是一个张量，则 self 张量的 \(\text{i}^{th}\) 个元素将被设置为从 \(\text{Bernoulli}(\texttt{p\_tensor[i]})\) 中采样的值。在这种情况下，p 必须具有浮点 dtype。

另请参见 bernoulli() 和 torch.bernoulli()

bfloat16(memory_format=torch.preserve_format) → Tensor

self.bfloat16() 等效于 self.to(torch.bfloat16)。参见 to()。

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

bincount(weights=None, minlength=0) → Tensor

参见 torch.bincount()

bitwise_and() → Tensor

参见 torch.bitwise_and()

bitwise_and_() → Tensor

bitwise_and() 的就地版本。

bitwise_left_shift(other) → Tensor

参见 torch.bitwise_left_shift()

bitwise_left_shift_(other) → Tensor

bitwise_left_shift() 的就地版本。

bitwise_not() → Tensor

参见 torch.bitwise_not()

bitwise_not_() → Tensor

bitwise_not() 的就地版本。

bitwise_or() → Tensor

参见 torch.bitwise_or()

bitwise_or_() → Tensor

bitwise_or() 的就地版本。

bitwise_right_shift(other) → Tensor

参见 torch.bitwise_right_shift()

bitwise_right_shift_(other) → Tensor

bitwise_right_shift() 的就地版本。

bitwise_xor() → Tensor

参见 torch.bitwise_xor()

bitwise_xor_() → Tensor

bitwise_xor() 的就地版本。

bmm(batch2) → Tensor

参见 torch.bmm()

bool(memory_format=torch.preserve_format) → Tensor

self.bool() 等同于 self.to(torch.bool)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

broadcast_to(shape) → Tensor

参见 torch.broadcast_to().

byte(memory_format=torch.preserve_format) → Tensor

self.byte() 等同于 self.to(torch.uint8)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

cauchy_(median=0, sigma=1, *, generator=None) → Tensor

用从柯西分布中抽取的数字填充张量

\[f(x) = \dfrac{1}{\pi} \dfrac{\sigma}{(x - \text{median})^2 + \sigma^2}\]

注意

Sigma (\(\sigma\)) 用于表示柯西分布中的尺度参数。

cdouble(memory_format=torch.preserve_format) → Tensor

self.cdouble() 等同于 self.to(torch.complex128)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

ceil() → Tensor

参见 torch.ceil()

ceil_() → Tensor

ceil() 的就地版本

cfloat(memory_format=torch.preserve_format) → Tensor

self.cfloat() 等同于 self.to(torch.complex64)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

chalf(memory_format=torch.preserve_format) → Tensor

self.chalf() 等同于 self.to(torch.complex32)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

char(memory_format=torch.preserve_format) → Tensor

self.char() 等同于 self.to(torch.int8)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

cholesky(upper=False) → Tensor

参见 torch.cholesky()

cholesky_inverse(upper=False) → Tensor

参见 torch.cholesky_inverse()

cholesky_solve(input2, upper=False) → Tensor

参见 torch.cholesky_solve()

chunk(chunks, dim=0) → List of Tensors

参见 torch.chunk()

clamp(min=None, max=None) → Tensor

参见 torch.clamp()

clamp_(min=None, max=None) → Tensor

clamp() 的就地版本

clip(min=None, max=None) → Tensor

clamp() 的别名。

clip_(min=None, max=None) → Tensor

clamp_() 的别名。

clone(*, memory_format=torch.preserve_format) → Tensor

参见 torch.clone()

coalesce() → Tensor

如果 self 是一个 未合并张量，则返回 self 的合并副本。

如果 self 是一个合并张量，则返回 self。

警告

如果 self 不是一个稀疏 COO 张量，则抛出错误。

col_indices() → IntTensor

当 self 是一个布局为 sparse_csr 的稀疏 CSR 张量时，返回包含 self 张量的列索引的张量。 col_indices 张量的形状严格为 (self.nnz())，类型为 int32 或 int64。当使用 MKL 例程（例如稀疏矩阵乘法）时，需要使用 int32 索引以避免向下转换并可能丢失信息。

示例：

>>> csr = torch.eye(5,5).to_sparse_csr()
>>> csr.col_indices()
tensor([0, 1, 2, 3, 4], dtype=torch.int32)

conj() → Tensor

见 torch.conj()

conj_physical() → Tensor

见 torch.conj_physical()

conj_physical_() → Tensor

conj_physical() 的就地版本

contiguous(memory_format=torch.contiguous_format) → Tensor

返回一个在内存中连续的张量，它包含与 self 张量相同的数据。如果 self 张量已经处于指定的内存格式，则此函数返回 self 张量。

参数:

memory_format (torch.memory_format，可选) - 返回张量的所需内存格式。默认值：torch.contiguous_format。

copy_(src, non_blocking=False) → Tensor

将元素从 src 复制到 self 张量中并返回 self。

src 张量必须与 self 张量 可广播。它可以是不同的数据类型或驻留在不同的设备上。

参数:

• src (Tensor) - 要从中复制的源张量

• non_blocking (bool) - 如果为 True 并且此复制在 CPU 和 GPU 之间，则复制可能与主机异步发生。对于其他情况，此参数没有影响。

copysign(other) → Tensor

见 torch.copysign()

copysign_(other) → Tensor

copysign() 的就地版本

corrcoef() → Tensor

见 torch.corrcoef()

cos() → Tensor

见 torch.cos()

cos_() → Tensor

cos() 的就地版本

cosh() → Tensor

见 torch.cosh()

cosh_() → Tensor

cosh() 的就地版本

count_nonzero(dim=None) → Tensor

见 torch.count_nonzero()

cov(*, correction=1, fweights=None, aweights=None) → Tensor

见 torch.cov()

cpu(memory_format=torch.preserve_format) → Tensor

返回此对象在 CPU 内存中的副本。

如果此对象已经位于 CPU 内存中并且在正确的设备上，则不会执行复制操作，并且将返回原始对象。

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

cross(other, dim=None) → Tensor

见 torch.cross()

crow_indices() → IntTensor

当 self 是一个布局为 sparse_csr 的稀疏 CSR 张量时，返回包含 self 张量的压缩行索引的张量。 crow_indices 张量的形状严格为 (self.size(0) + 1)，类型为 int32 或 int64。当使用 MKL 例程（例如稀疏矩阵乘法）时，需要使用 int32 索引以避免向下转换并可能丢失信息。

示例：

>>> csr = torch.eye(5,5).to_sparse_csr()
>>> csr.crow_indices()
tensor([0, 1, 2, 3, 4, 5], dtype=torch.int32)

cuda(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

返回此对象在 CUDA 内存中的副本。

如果此对象已在 CUDA 内存中且在正确的设备上，则不执行任何复制操作，并返回原始对象。

参数:

• device (torch.device) – 目标 GPU 设备。默认为当前 CUDA 设备。

• non_blocking (bool) – 如果为 True 且源在固定内存中，则复制将相对于主机是异步的。否则，参数无效。默认值：False。

• memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

cummax(dim)

请参见 torch.cummax()

cummin(dim)

请参见 torch.cummin()

cumprod(dim, dtype=None) → Tensor

请参见 torch.cumprod()

cumprod_(dim, dtype=None) → Tensor

cumprod() 的就地版本

cumsum(dim, dtype=None) → Tensor

请参见 torch.cumsum()

cumsum_(dim, dtype=None) → Tensor

cumsum() 的就地版本

data_ptr() → int

返回 self 张量第一个元素的地址。

deg2rad() → Tensor

请参见 torch.deg2rad()

deg2rad_() → Tensor

deg2rad() 的就地版本

dense_dim() → int

返回 稀疏张量 self 中密集维度的数量。

注意

如果 self 不是稀疏张量，则返回 len(self.shape)。

另请参见 Tensor.sparse_dim() 和 混合张量。

dequantize() → Tensor

给定一个量化张量，对其进行反量化并返回反量化后的浮点张量。

det() → Tensor

请参见 torch.det()

detach()

返回一个新的张量，与当前图分离。

结果将永远不需要梯度。

此方法还会影响前向模式 AD 梯度，结果将永远不会具有前向模式 AD 梯度。

注意

返回的张量与原始张量共享相同的存储。对两者中的任何一个进行就地修改都将被看到，并且可能会触发正确性检查中的错误。

detach_()

将张量与其创建它的图分离，使其成为叶子。视图无法就地分离。

此方法还会影响前向模式 AD 梯度，结果将永远不会具有前向模式 AD 梯度。

device

是 torch.device，其中此张量位于。

diag(diagonal=0) → Tensor

请参见 torch.diag()

diag_embed(offset=0, dim1=- 2, dim2=- 1) → Tensor

请参见 torch.diag_embed()

diagflat(offset=0) → Tensor

请参见 torch.diagflat()

diagonal(offset=0, dim1=0, dim2=1) → Tensor

请参见 torch.diagonal()

diagonal_scatter(src, offset=0, dim1=0, dim2=1) → Tensor

请参见 torch.diagonal_scatter()

diff(n=1, dim=- 1, prepend=None, append=None) → Tensor

参见 torch.diff()

digamma() → Tensor

参见 torch.digamma()

digamma_() → Tensor

digamma() 的就地版本

dim() → int

返回 self 张量的维度数量。

dim_order() → tuple

返回一个包含 int 的元组，描述 self 的维度顺序或物理布局。

参数:

None –

维度顺序表示维度在内存中的排列方式，从最外层维度到最内层维度。

示例：

>>> torch.empty((2, 3, 5, 7)).dim_order()
(0, 1, 2, 3)
>>> torch.empty((2, 3, 5, 7), memory_format=torch.channels_last).dim_order()
(0, 2, 3, 1)

警告

dim_order 张量 API 处于实验阶段，可能会发生变化。

dist(other, p=2) → Tensor

参见 torch.dist()

div(value, *, rounding_mode=None) → Tensor

参见 torch.div()

div_(value, *, rounding_mode=None) → Tensor

div() 的就地版本

divide(value, *, rounding_mode=None) → Tensor

参见 torch.divide()

divide_(value, *, rounding_mode=None) → Tensor

divide() 的就地版本

dot(other) → Tensor

参见 torch.dot()

double(memory_format=torch.preserve_format) → Tensor

self.double() 等效于 self.to(torch.float64)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

dsplit(split_size_or_sections) → List of Tensors

参见 torch.dsplit()

element_size() → int

返回单个元素的大小（以字节为单位）。

示例

>>> torch.tensor([]).element_size()
4
>>> torch.tensor([], dtype=torch.uint8).element_size()
1

classmethod empty(*size, dtype=None, device=None, filename=None)

classmethod empty(shape, *, dtype=None, device=None, filename=None)

创建一个具有空内容、特定形状、数据类型和文件名的张量。

参数:

shape (整数 或 torch.Size) – 张量的形状。

关键字参数：

• dtype (torch.dtype) – 张量的类型。

• device (torch.device) – 张量的设备。仅接受 None 和 “cpu”，任何其他设备都会引发异常。

• filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

• existsok (bool, 可选) – 是否允许覆盖现有文件。默认为 False。

classmethod empty_like(input, *, filename=None)

创建一个没有内容但与输入张量具有相同形状和数据类型的张量。

参数:

input (torch.Tensor) – 用作示例的张量。

关键字参数：

filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

classmethod empty_nested(*args, **kwargs)

创建一个具有空内容、特定形状、数据类型和文件名的张量。

参数:

shape (nested_shape) – 张量的形状。

关键字参数：

• dtype (torch.dtype) – 张量的类型。

• device (torch.device) – 张量的设备。仅接受 None 和 “cpu”，任何其他设备都会引发异常。

• filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

• existsok (bool, 可选) – 是否允许覆盖现有文件。默认为 False。

eq(other) → Tensor

参见 torch.eq()

eq_(other) → Tensor

eq() 的就地版本

equal(other) → bool

参见 torch.equal()

erf() → Tensor

参见 torch.erf()

erf_() → Tensor

erf() 的就地版本

erfc() → Tensor

参见 torch.erfc()

erfc_() → Tensor

erfc() 的就地版本

erfinv() → Tensor

参见 torch.erfinv()

erfinv_() → Tensor

erfinv() 的就地版本

exp() → Tensor

参见 torch.exp()

exp2() → Tensor

参见 torch.exp2()

exp2_() → Tensor

exp2() 的就地版本

exp_() → Tensor

exp() 的就地版本

expand(*sizes) → Tensor

返回 self 张量的新视图，其中单例维度扩展到更大的大小。

将 -1 作为维度的尺寸表示不改变该维度的尺寸。

张量也可以扩展到更多维，新维将附加在前面。对于新维度，尺寸不能设置为 -1。

扩展张量不会分配新的内存，而只是在现有张量上创建一个新视图，其中尺寸为 1 的维度通过将 stride 设置为 0 扩展到更大的尺寸。任何尺寸为 1 的维度都可以扩展到任意值而无需分配新的内存。

参数:

*sizes (torch.Size 或 int...) – 想要的扩展尺寸

警告

扩展张量的多个元素可能引用同一个内存位置。因此，就地操作（尤其是矢量化的操作）可能会导致不正确的行为。如果您需要写入张量，请先克隆它们。

示例

>>> x = torch.tensor([[1], [2], [3]])
>>> x.size()
torch.Size([3, 1])
>>> x.expand(3, 4)
tensor([[ 1,  1,  1,  1],
        [ 2,  2,  2,  2],
        [ 3,  3,  3,  3]])
>>> x.expand(-1, 4)   # -1 means not changing the size of that dimension
tensor([[ 1,  1,  1,  1],
        [ 2,  2,  2,  2],
        [ 3,  3,  3,  3]])

expand_as(other) → Tensor

将此张量扩展到与 other 相同的大小。self.expand_as(other) 等同于 self.expand(other.size())。

请参见 expand() 了解有关 expand 的更多信息。

参数:

other (torch.Tensor) – 结果张量的大小与 other 相同。

expm1() → Tensor

参见 torch.expm1()

expm1_() → Tensor

expm1() 的就地版本

exponential_(lambd=1, *, generator=None) → Tensor

用从 PDF（概率密度函数）中抽取的元素填充 self 张量

\[f(x) = \lambda e^{-\lambda x}, x > 0\]

注意

在概率论中，指数分布在区间 [0, \(\inf\))（即 \(x >= 0\)）上得到支持，这意味着可以从指数分布中采样零。但是，torch.Tensor.exponential_() 不会采样零，这意味着它实际支持的区间是 (0, \(\inf\)）。

注意，torch.distributions.exponential.Exponential() 在区间 [0, \(\inf\)) 上得到支持，并且可以采样零。

property filename

张量的文件名，如果它有的话。

否则会引发异常。

fill_(value) → Tensor

用指定的值填充 self 张量。

fill_diagonal_(fill_value, wrap=False) → Tensor

填充至少具有 2 维的张量的对角线。当 dims>2 时，输入的所有维度都必须具有相同的长度。此函数会就地修改输入张量，并返回输入张量。

参数:

• fill_value (Scalar) – 填充值

• wrap (bool) – 高矩阵的 N 列之后的对角线“环绕”。

示例

>>> a = torch.zeros(3, 3)
>>> a.fill_diagonal_(5)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.]])
>>> b = torch.zeros(7, 3)
>>> b.fill_diagonal_(5)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
>>> c = torch.zeros(7, 3)
>>> c.fill_diagonal_(5, wrap=True)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.],
        [0., 0., 0.],
        [5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.]])

fix() → Tensor

参见 torch.fix().

fix_() → Tensor

fix() 的就地版本

flatten(start_dim=0, end_dim=- 1) → Tensor

参见 torch.flatten()

flip(dims) → Tensor

参见 torch.flip()

fliplr() → Tensor

参见 torch.fliplr()

flipud() → Tensor

参见 torch.flipud()

float(memory_format=torch.preserve_format) → Tensor

self.float() 等效于 self.to(torch.float32)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

float_power(exponent) → Tensor

参见 torch.float_power()

float_power_(exponent) → Tensor

float_power() 的就地版本。

floor() → Tensor

参见 torch.floor()

floor_() → Tensor

floor() 的就地版本。

floor_divide(value) → Tensor

参见 torch.floor_divide()

floor_divide_(value) → Tensor

floor_divide() 的就地版本。

fmax(other) → Tensor

参见 torch.fmax()

fmin(other) → Tensor

参见 torch.fmin()

fmod(divisor) → Tensor

参见 torch.fmod()

fmod_(divisor) → Tensor

fmod() 的就地版本。

frac() → Tensor

参见 torch.frac()

frac_() → Tensor

frac() 的就地版本。

frexp(input) -> (Tensor mantissa, Tensor exponent)

参见 torch.frexp()

classmethod from_filename(filename, dtype, shape, index=None)

从给定的文件名加载 MemoryMappedTensor。

参数:

• filename (路径 或 等效项) – 文件的路径。

• dtype (torch.dtype) – 张量的类型。

• shape (torch.Size 或 torch.Tensor) – 矩阵的形状。如果提供了一个张量，则假定该张量是一个 nested_tensor 实例。

• index (与 torch 兼容的索引类型) – 用于构建矩阵的索引。

classmethod from_handler(handler, dtype, shape, index=None)

从给定的句柄加载 MemoryMappedTensor。

参数:

• handler (兼容的文件句柄) – 矩阵的句柄。

• dtype (torch.dtype) – 张量的类型。

• shape (torch.Size 或 torch.Tensor) – 矩阵的形状。如果提供了一个张量，则假定该张量是一个 nested_tensor 实例。

• index (与 torch 兼容的索引类型, 可选) – 用于构建矩阵的索引。

classmethod from_tensor(input, *, filename=None, existsok=False, copy_existing=False, copy_data=True, shape=None)

使用与另一个矩阵相同的内容创建 MemoryMappedTensor。

如果张量已经是 MemoryMappedTensor，如果 filename 参数为 None 或两个路径匹配，则返回原始张量。在所有其他情况下，将生成一个新的 MemoryMappedTensor。

参数:

• input (torch.Tensor) – 必须将内容复制到 MemoryMappedTensor 的张量。

• filename (文件路径) – 张量应存储到的文件的路径。如果没有提供，则使用文件句柄。

• existsok (bool, 可选) – 如果为 True，则该文件将覆盖现有文件。默认为 False。

• copy_existing (bool, 可选) – 如果为 True 并且提供的输入是带有关联文件名的 MemoryMappedTensor，则允许将内容复制到新位置。否则，将引发异常。这种行为是为了防止无意中复制磁盘上的数据。

• copy_data (bool, 可选) – 如果为 True，则张量的内容将被复制到存储区。默认为 True。

• shape (torch.Size 或 torch.Tensor) – 用于覆盖张量形状的形状。如果传递了张量，则它必须表示嵌套张量的嵌套形状。

classmethod full(*size, fill_value, dtype=None, device=None, filename=None)

classmethod full(shape, *, fill_value, dtype=None, device=None, filename=None)

使用由 fill_value 指定的单个内容创建张量，指定形状、dtype 和文件名。

参数:

shape (整数 或 torch.Size) – 张量的形状。

关键字参数：

• fill_value (float 或 等效值) – 张量的内容。

• dtype (torch.dtype) – 张量的类型。

• device (torch.device) – 张量的设备。仅接受 None 和 “cpu”，任何其他设备都会引发异常。

• filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

• existsok (bool, 可选) – 是否允许覆盖现有文件。默认为 False。

classmethod full_like(input, fill_value, *, filename=None)

使用由 fill_value 参数指示的单个内容创建张量，但形状和 dtype 与输入张量相同。

参数:

• input (torch.Tensor) – 用作示例的张量。

• fill_value (float 或 等效值) – 张量的内容。

关键字参数：

filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

gather(dim, index) → Tensor

参见 torch.gather()

gcd(other) → Tensor

参见 torch.gcd()

gcd_(other) → Tensor

gcd() 的就地版本。

ge(other) → Tensor

参见 torch.ge()。

ge_(other) → Tensor

ge() 的就地版本。

geometric_(p, *, generator=None) → Tensor

使用从几何分布中抽取的元素填充 self 张量。

\[P(X=k) = (1 - p)^{k - 1} p, k = 1, 2, ...\]

注意

torch.Tensor.geometric_() k 次试验是第一次成功，因此在 \(\{1, 2, \ldots\}\) 中抽取样本，而 torch.distributions.geometric.Geometric() \((k+1)\) 次试验是第一次成功，因此在 \(\{0, 1, \ldots\}\) 中抽取样本。

geqrf()

参见 torch.geqrf()

ger(vec2) → Tensor

参见 torch.ger()

get_device() -> Device ordinal (Integer)

对于 CUDA 张量，此函数返回张量所在的 GPU 的设备序数。对于 CPU 张量，此函数返回 -1。

示例

>>> x = torch.randn(3, 4, 5, device='cuda:0')
>>> x.get_device()
0
>>> x.cpu().get_device()
-1

grad

此属性默认情况下为 None，并且在第一次调用 backward() 为 self 计算梯度时变为张量。然后该属性将包含计算的梯度，对 backward() 的未来调用将在其中累积（添加）梯度。

greater(other) → Tensor

参见 torch.greater()。

greater_(other) → Tensor

greater() 的就地版本。

greater_equal(other) → Tensor

参见 torch.greater_equal()。

greater_equal_(other) → Tensor

greater_equal() 的就地版本。

gt(other) → Tensor

请参见 torch.gt()。

gt_(other) → Tensor

gt() 的就地版本。

half(memory_format=torch.preserve_format) → Tensor

self.half() 等效于 self.to(torch.float16)。请参见 to()。

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

hardshrink(lambd=0.5) → Tensor

请参见 torch.nn.functional.hardshrink()

has_names()

如果此张量的任何维度都有命名，则为 True。否则，为 False。

heaviside(values) → Tensor

请参见 torch.heaviside()

heaviside_(values) → Tensor

heaviside() 的就地版本

histc(bins=100, min=0, max=0) → Tensor

请参见 torch.histc()

histogram(input, bins, *, range=None, weight=None, density=False)

请参见 torch.histogram()

hsplit(split_size_or_sections) → List of Tensors

请参见 torch.hsplit()

hypot(other) → Tensor

请参见 torch.hypot()

hypot_(other) → Tensor

hypot() 的就地版本

i0() → Tensor

请参见 torch.i0()

i0_() → Tensor

i0() 的就地版本

igamma(other) → Tensor

请参见 torch.igamma()

igamma_(other) → Tensor

igamma() 的就地版本

igammac(other) → Tensor

请参见 torch.igammac()

igammac_(other) → Tensor

igammac() 的就地版本

imag

返回一个包含 self 张量虚部的新张量。返回的张量和 self 共享相同的底层存储。

警告

imag() 仅支持具有复数数据类型的张量。

示例：

>>> x=torch.randn(4, dtype=torch.cfloat)
>>> x
tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
>>> x.imag
tensor([ 0.3553, -0.7896, -0.0633, -0.8119])

index_add(dim, index, source, *, alpha=1) → Tensor

torch.Tensor.index_add_() 的非就地版本。

index_add_(dim, index, source, *, alpha=1) → Tensor

将 alpha 倍的 source 张量的元素累加到 self 张量中，按照 index 中给定的顺序添加到索引。例如，如果 dim == 0，index[i] == j 且 alpha=-1，那么 source 的第 i 行将从 self 的第 j 行中减去。

source 的第 dim 维必须与 index 的长度（必须是向量）相同，所有其他维度必须与 self 相匹配，否则会引发错误。

对于 3 维张量，输出如下所示

self[index[i], :, :] += alpha * src[i, :, :]  # if dim == 0
self[:, index[i], :] += alpha * src[:, i, :]  # if dim == 1
self[:, :, index[i]] += alpha * src[:, :, i]  # if dim == 2

注意

当在 CUDA 设备上给出张量时，此操作可能会表现出不确定性。有关更多信息，请参阅 /notes/randomness。

参数:

• dim (int) – 要索引的维度

• index (Tensor) – 要从中选择的 source 的索引，数据类型应为 torch.int64 或 torch.int32

• source (Tensor) – 包含要添加的值的张量

关键字参数：

alpha (Number) – source 的标量乘数

示例

>>> x = torch.ones(5, 3)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2])
>>> x.index_add_(0, index, t)
tensor([[  2.,   3.,   4.],
        [  1.,   1.,   1.],
        [  8.,   9.,  10.],
        [  1.,   1.,   1.],
        [  5.,   6.,   7.]])
>>> x.index_add_(0, index, t, alpha=-1)
tensor([[  1.,   1.,   1.],
        [  1.,   1.,   1.],
        [  1.,   1.,   1.],
        [  1.,   1.,   1.],
        [  1.,   1.,   1.]])

index_copy(dim, index, tensor2) → Tensor

torch.Tensor.index_copy_() 的非就地版本。

index_copy_(dim, index, tensor) → Tensor

通过按照 index 中给定的顺序选择索引，将 tensor 的元素复制到 self 张量中。例如，如果 dim == 0 且 index[i] == j，那么 tensor 的第 i 行将被复制到 self 的第 j 行。

tensor 的第 dim 维必须与 index 的长度（必须是向量）相同，所有其他维度必须与 self 相匹配，否则会引发错误。

注意

如果 index 包含重复项，则来自 tensor 的多个元素将被复制到 self 的相同索引。结果是不确定的，因为它取决于哪个副本最后发生。

参数:

• dim (int) – 要索引的维度

• index (LongTensor) – 要从中选择的 tensor 的索引

• tensor (Tensor) – 包含要复制的值的张量

示例

>>> x = torch.zeros(5, 3)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2])
>>> x.index_copy_(0, index, t)
tensor([[ 1.,  2.,  3.],
        [ 0.,  0.,  0.],
        [ 7.,  8.,  9.],
        [ 0.,  0.,  0.],
        [ 4.,  5.,  6.]])

index_fill(dim, index, value) → Tensor

torch.Tensor.index_fill_() 的非就地版本。

index_fill_(dim, index, value) → Tensor

通过按照 index 中给定的顺序选择索引，用值 value 填充 self 张量的元素。

参数:

• dim (int) – 要索引的维度

• index (LongTensor) – 要填充的 self 张量的索引

• value (float) – 要填充的值

示例：

>>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 2])
>>> x.index_fill_(1, index, -1)
tensor([[-1.,  2., -1.],
        [-1.,  5., -1.],
        [-1.,  8., -1.]])

index_put(indices, values, accumulate=False) → Tensor

index_put_() 的非就地版本。

index_put_(indices, values, accumulate=False) → Tensor

使用 indices（它是张量元组）中指定的索引，将来自张量 values 的值放入张量 self 中。表达式 tensor.index_put_(indices, values) 等效于 tensor[indices] = values。返回 self。

如果 accumulate 为 True，则 values 中的元素将添加到 self 中。如果 accumulate 为 False，则如果 indices 包含重复元素，则行为未定义。

参数:

• indices (tuple of LongTensor) – 用于索引到 self 的张量。

• values (Tensor) – 与 self 数据类型相同的张量。

• accumulate (bool) – 是否累加到 self 中

index_reduce_(dim, index, source, reduce, *, include_self=True) → Tensor

使用 reduce 参数给出的约简，通过将 source 的元素累加到按照 index 中给定的顺序累加到的索引，将 source 的元素累加到 self 张量中。例如，如果 dim == 0，index[i] == j，reduce == prod 且 include_self == True，那么 source 的第 i 行将乘以 self 的第 j 行。如果 include_self="True"，则 self 张量中的值将包含在约简中，否则，累加到的 self 张量中的行将被视为填充了约简标识。

source 的第 dim 维必须与 index 的长度（必须是向量）相同，所有其他维度必须与 self 相匹配，否则会引发错误。

对于 3 维张量，使用 reduce="prod" 和 include_self=True，输出如下所示

self[index[i], :, :] *= src[i, :, :]  # if dim == 0
self[:, index[i], :] *= src[:, i, :]  # if dim == 1
self[:, :, index[i]] *= src[:, :, i]  # if dim == 2

注意

当在 CUDA 设备上给出张量时，此操作可能会表现出不确定性。有关更多信息，请参阅 /notes/randomness。

注意

此函数仅支持浮点张量。

警告

此函数处于测试阶段，在不久的将来可能会发生变化。

参数:

• dim (int) – 要索引的维度

• index (Tensor) – 要从中选择的 source 的索引，数据类型应为 torch.int64 或 torch.int32

• source (FloatTensor) – 包含要累加的值的张量

• reduce (str) – 要应用的缩减操作 ("prod", "mean", "amax", "amin")

关键字参数：

include_self (bool) – self 张量中的元素是否包含在缩减中

示例

>>> x = torch.empty(5, 3).fill_(2)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2, 0])
>>> x.index_reduce_(0, index, t, 'prod')
tensor([[20., 44., 72.],
        [ 2.,  2.,  2.],
        [14., 16., 18.],
        [ 2.,  2.,  2.],
        [ 8., 10., 12.]])
>>> x = torch.empty(5, 3).fill_(2)
>>> x.index_reduce_(0, index, t, 'prod', include_self=False)
tensor([[10., 22., 36.],
        [ 2.,  2.,  2.],
        [ 7.,  8.,  9.],
        [ 2.,  2.,  2.],
        [ 4.,  5.,  6.]])

index_select(dim, index) → Tensor

参见 torch.index_select()

indices() → Tensor

返回 稀疏 COO 张量 的索引张量。

警告

如果 self 不是一个稀疏 COO 张量，则抛出错误。

另见 Tensor.values()。

注意

此方法只能在合并的稀疏张量上调用。有关详细信息，请参见 Tensor.coalesce()。

inner(other) → Tensor

参见 torch.inner().

int(memory_format=torch.preserve_format) → Tensor

self.int() 等效于 self.to(torch.int32)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

int_repr() → Tensor

给定一个量化张量，self.int_repr() 返回一个 CPU 张量，其数据类型为 uint8_t，存储给定张量的底层 uint8_t 值。

inverse() → Tensor

参见 torch.inverse()

ipu(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

返回此对象在 IPU 内存中的副本。

如果此对象已在 IPU 内存中并且在正确的设备上，则不会执行任何复制操作，并且会返回原始对象。

参数:

• device (torch.device) – 目标 IPU 设备。默认为当前 IPU 设备。

• non_blocking (bool) – 如果为 True 且源在固定内存中，则复制将相对于主机是异步的。否则，参数无效。默认值：False。

• memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

is_coalesced() → bool

如果 self 是一个合并的 稀疏 COO 张量，则返回 True，否则返回 False。

警告

如果 self 不是一个稀疏 COO 张量，则抛出错误。

参见 coalesce() 和 未合并的张量.

is_complex() → bool

如果 self 的数据类型是复数数据类型，则返回 True。

is_conj() → bool

如果 self 的共轭位设置为 true，则返回 True。

is_contiguous(memory_format=torch.contiguous_format) → bool

如果 self 张量在内存中按内存格式指定的顺序连续，则返回 True。

参数:

memory_format (torch.memory_format, 可选) – 指定内存分配顺序。默认值：torch.contiguous_format。

is_cpu

如果张量存储在 CPU 上，则为 True，否则为 False。

is_cuda

如果张量存储在 GPU 上，则为 True，否则为 False。

is_floating_point() → bool

如果 self 的数据类型是浮点数据类型，则返回 True。

is_inference() → bool

参见 torch.is_inference()

is_ipu

如果张量存储在 IPU 上，则为 True，否则为 False。

is_leaf

所有 requires_grad 为 False 的张量根据约定都是叶张量。

对于 requires_grad 为 True 的张量，如果它们是由用户创建的，它们将是叶张量。这意味着它们不是操作的结果，因此 grad_fn 为 None。

只有叶张量会在调用 backward() 时填充其 grad。要为非叶张量填充 grad，可以使用 retain_grad().

示例

>>> a = torch.rand(10, requires_grad=True)
>>> a.is_leaf
True
>>> b = torch.rand(10, requires_grad=True).cuda()
>>> b.is_leaf
False
# b was created by the operation that cast a cpu Tensor into a cuda Tensor
>>> c = torch.rand(10, requires_grad=True) + 2
>>> c.is_leaf
False
# c was created by the addition operation
>>> d = torch.rand(10).cuda()
>>> d.is_leaf
True
# d does not require gradients and so has no operation creating it (that is tracked by the autograd engine)
>>> e = torch.rand(10).cuda().requires_grad_()
>>> e.is_leaf
True
# e requires gradients and has no operations creating it
>>> f = torch.rand(10, requires_grad=True, device="cuda")
>>> f.is_leaf
True
# f requires grad, has no operation creating it

is_meta

如果张量是元张量，则为 True，否则为 False。元张量类似于普通张量，但它们不包含任何数据。

is_mps

如果张量存储在 MPS 设备上，则为 True，否则为 False。

is_neg() → bool

如果 self 的负位设置为 true，则返回 True。

is_pinned()

如果此张量驻留在固定内存中，则返回 true。

is_quantized

如果张量被量化，则为 True，否则为 False。

is_set_to(tensor) → bool

如果两个张量都指向完全相同的内存（相同的存储、偏移量、大小和步幅），则返回 True。

is_shared()

检查张量是否在共享内存中。

对于 CUDA 张量，这始终为 True。

is_signed() → bool

如果 self 的数据类型是带符号数据类型，则返回 True。

is_sparse

如果张量使用稀疏 COO 存储布局，则为 True，否则为 False。

is_sparse_csr

如果张量使用稀疏 CSR 存储布局，则为 True，否则为 False。

is_xla

如果张量存储在 XLA 设备上，则为 True，否则为 False。

is_xpu

如果张量存储在 XPU 上，则为 True，否则为 False。

isclose(other, rtol=1e-05, atol=1e-08, equal_nan=False) → Tensor

参见 torch.isclose()

isfinite() → Tensor

参见 torch.isfinite()

isinf() → Tensor

参见 torch.isinf()

isnan() → Tensor

参见 torch.isnan()

isneginf() → Tensor

参见 torch.isneginf()

isposinf() → Tensor

参见 torch.isposinf()

isreal() → Tensor

参见 torch.isreal()

istft(n_fft: int, hop_length: Optional[int] = None, win_length: Optional[int] = None, window: Optional[Tensor] = None, center: bool = True, normalized: bool = False, onesided: Optional[bool] = None, length: Optional[int] = None, return_complex: bool = False)

请参见 torch.istft()

item() → number

将此张量的值作为标准 Python 数字返回。 这仅适用于具有一个元素的张量。 对于其他情况，请参见 tolist()。

此操作不可微分。

示例

>>> x = torch.tensor([1.0])
>>> x.item()
1.0

itemsize

是 element_size() 的别名

kron(other) → Tensor

请参见 torch.kron()

kthvalue(k, dim=None, keepdim=False)

请参见 torch.kthvalue()

lcm(other) → Tensor

请参见 torch.lcm()

lcm_(other) → Tensor

是 lcm() 的就地版本

ldexp(other) → Tensor

请参见 torch.ldexp()

ldexp_(other) → Tensor

是 ldexp() 的就地版本

le(other) → Tensor

请参见 torch.le().

le_(other) → Tensor

是 le() 的就地版本。

lerp(end, weight) → Tensor

请参见 torch.lerp()

lerp_(end, weight) → Tensor

是 lerp() 的就地版本

less()

lt(other) -> Tensor

请参见 torch.less().

less_(other) → Tensor

是 less() 的就地版本。

less_equal(other) → Tensor

请参见 torch.less_equal().

less_equal_(other) → Tensor

是 less_equal() 的就地版本。

lgamma() → Tensor

请参见 torch.lgamma()

lgamma_() → Tensor

是 lgamma() 的就地版本

log() → Tensor

参见 torch.log()

log10() → Tensor

参见 torch.log10()

log10_() → Tensor

log10() 的就地版本

log1p() → Tensor

参见 torch.log1p()

log1p_() → Tensor

log1p() 的就地版本

log2() → Tensor

参见 torch.log2()

log2_() → Tensor

log2() 的就地版本

log_() → Tensor

log() 的就地版本

log_normal_(mean=1, std=2, *, generator=None)

用给定均值 \(\mu\) 和标准差 \(\sigma\) 参数化的对数正态分布中的数字样本填充 self 张量。请注意，mean 和 std 是底层正态分布的均值和标准差，而不是返回分布的均值和标准差

\[f(x) = \dfrac{1}{x \sigma \sqrt{2\pi}}\ e^{-\frac{(\ln x - \mu)^2}{2\sigma^2}}\]

logaddexp(other) → Tensor

参见 torch.logaddexp()

logaddexp2(other) → Tensor

参见 torch.logaddexp2()

logcumsumexp(dim) → Tensor

参见 torch.logcumsumexp()

logdet() → Tensor

参见 torch.logdet()

logical_and() → Tensor

参见 torch.logical_and()

logical_and_() → Tensor

logical_and() 的就地版本

logical_not() → Tensor

参见 torch.logical_not()

logical_not_() → Tensor

logical_not() 的就地版本

logical_or() → Tensor

参见 torch.logical_or()

logical_or_() → Tensor

logical_or() 的就地版本

logical_xor() → Tensor

参见 torch.logical_xor()

logical_xor_() → Tensor

logical_xor() 的就地版本

logit() → Tensor

参见 torch.logit()

logit_() → Tensor

logit() 的就地版本

logsumexp(dim, keepdim=False) → Tensor

参见 torch.logsumexp()

long(memory_format=torch.preserve_format) → Tensor

self.long() 等效于 self.to(torch.int64)。参见 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

lt(other) → Tensor

参见 torch.lt().

lt_(other) → Tensor

lt() 的就地版本。

lu(pivot=True, get_infos=False)

见 torch.lu()

lu_solve(LU_data, LU_pivots) → Tensor

见 torch.lu_solve()

mH

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

mT

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

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

map_(tensor, callable)

对 self 张量和给定的 tensor 中的每个元素应用 callable，并将结果存储在 self 张量中。 self 张量和给定的 tensor 必须是 广播的。

callable 应该具有以下签名

def callable(a, b) -> number

masked_fill(mask, value) → Tensor

torch.Tensor.masked_fill_() 的非就地版本

masked_fill_(mask, value)

用 value 填充 self 张量中 mask 为 True 的元素。 mask 的形状必须是 广播的，与基础张量的形状相同。

参数:

• mask (BoolTensor) – 布尔掩码

• value (float) – 要填充的值

masked_scatter(mask, tensor) → Tensor

torch.Tensor.masked_scatter_() 的非就地版本

注意

输入 self 和 mask 广播。

示例

>>> self = torch.tensor([0, 0, 0, 0, 0])
>>> mask = torch.tensor([[0, 0, 0, 1, 1], [1, 1, 0, 1, 1]], dtype=torch.bool)
>>> source = torch.tensor([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
>>> self.masked_scatter(mask, source)
tensor([[0, 0, 0, 0, 1],
        [2, 3, 0, 4, 5]])

masked_scatter_(mask, source)

将 source 中的元素复制到 self 张量中 mask 为 True 的位置。 source 中的元素将复制到 self 中，从 source 的位置 0 开始，并按顺序逐个继续，对于每个 mask 为 True 的情况。 mask 的形状必须是 广播的，与基础张量的形状相同。 source 应该至少包含与 mask 中 1 的数量一样多的元素。

参数:

• mask (BoolTensor) – 布尔掩码

• source (Tensor) – 要从中复制的张量

注意

mask 对 self 张量起作用，而不是给定的 source 张量。

示例

>>> self = torch.tensor([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]])
>>> mask = torch.tensor([[0, 0, 0, 1, 1], [1, 1, 0, 1, 1]], dtype=torch.bool)
>>> source = torch.tensor([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
>>> self.masked_scatter_(mask, source)
tensor([[0, 0, 0, 0, 1],
        [2, 3, 0, 4, 5]])

masked_select(mask) → Tensor

见 torch.masked_select()

matmul(tensor2) → Tensor

见 torch.matmul()

matrix_exp() → Tensor

见 torch.matrix_exp()

matrix_power(n) → Tensor

注意

matrix_power() 已被弃用，请使用 torch.linalg.matrix_power() 代替。

torch.linalg.matrix_power() 的别名

max(dim=None, keepdim=False)

见 torch.max()

maximum(other) → Tensor

见 torch.maximum()

mean(dim=None, keepdim=False, *, dtype=None) → Tensor

参见 torch.mean()

median(dim=None, keepdim=False)

参见 torch.median()

min(dim=None, keepdim=False)

参见 torch.min()

minimum(other) → Tensor

参见 torch.minimum()

mm(mat2) → Tensor

参见 torch.mm()

mode(dim=None, keepdim=False)

参见 torch.mode()

module_load(other, assign=False)

定义将 other 加载到 self 中 load_state_dict() 的方式。

当 get_swap_module_params_on_conversion() 为 True 时使用。

预期 self 是 nn.Module 中的参数或缓冲区，而 other 是状态字典中与之对应的键的值，此方法定义如何在通过 swap_tensors() 在 load_state_dict() 中用 self 替换之前重新映射 other。

注意

此方法应始终返回一个新的对象，它不是 self 或 other。例如，默认实现返回 self.copy_(other).detach() 如果 assign 为 False 或 other.detach() 如果 assign 为 True。

参数:

• other (Tensor) – 状态字典中与 self 对应的键的值

• assign (bool) – 传递给 nn.Module.load_state_dict() 的 assign 参数

moveaxis(source, destination) → Tensor

参见 torch.moveaxis()

movedim(source, destination) → Tensor

参见 torch.movedim()

msort() → Tensor

参见 torch.msort()

mtia(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

返回此对象在 MTIA 内存中的副本。

如果此对象已在 MTIA 内存中并在正确的设备上，则不执行复制并返回原始对象。

参数:

• device (torch.device) – 目标 MTIA 设备。默认值为当前 MTIA 设备。

• non_blocking (bool) – 如果为 True 且源在固定内存中，则复制将相对于主机是异步的。否则，参数无效。默认值：False。

• memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

mul(value) → Tensor

参见 torch.mul().

mul_(value) → Tensor

mul() 的就地版本。

multinomial(num_samples, replacement=False, *, generator=None) → Tensor

参见 torch.multinomial()

multiply(value) → Tensor

参见 torch.multiply().

multiply_(value) → Tensor

multiply() 的就地版本。

mv(vec) → Tensor

参见 torch.mv()

mvlgamma(p) → Tensor

参见 torch.mvlgamma()

mvlgamma_(p) → Tensor

mvlgamma() 的就地版本

names

存储此张量每个维度的名称。

names[idx] 对应张量维度 idx 的名称。如果维度有名称，则名称为字符串；如果维度没有名称，则为 None。

维度名称可以包含字符或下划线。此外，维度名称必须是有效的 Python 变量名（即，不能以下划线开头）。

张量不能有两个同名的命名维度。

警告

nan_to_num(nan=0.0, posinf=None, neginf=None) → Tensor

参见 torch.nan_to_num()。

nan_to_num_(nan=0.0, posinf=None, neginf=None) → Tensor

nan_to_num() 的就地版本。

nanmean(dim=None, keepdim=False, *, dtype=None) → Tensor

参见 torch.nanmean()

nanmedian(dim=None, keepdim=False)

参见 torch.nanmedian()

nanquantile(q, dim=None, keepdim=False, *, interpolation='linear') → Tensor

参见 torch.nanquantile()

nansum(dim=None, keepdim=False, dtype=None) → Tensor

参见 torch.nansum()

narrow(dimension, start, length) → Tensor

参见 torch.narrow()。

narrow_copy(dimension, start, length) → Tensor

参见 torch.narrow_copy()。

nbytes

如果张量不使用稀疏存储布局，则返回张量元素“视图”所占用的字节数。定义为 numel() * element_size()

ndim

dim() 的别名

ndimension() → int

dim() 的别名

ne(other) → Tensor

参见 torch.ne()。

ne_(other) → Tensor

ne() 的就地版本。

neg() → Tensor

参见 torch.neg()

neg_() → Tensor

neg() 的就地版本

negative() → Tensor

参见 torch.negative()

negative_() → Tensor

negative() 的就地版本

nelement() → int

numel() 的别名

new_empty(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

返回一个大小为 size 的张量，其中填充了未初始化的数据。默认情况下，返回的张量具有与该张量相同的 torch.dtype 和 torch.device。

参数:

size (int...) – 定义输出张量形状的整数列表、元组或 torch.Size。

关键字参数：

• dtype (torch.dtype, 可选) – 返回张量的期望类型。默认值：如果为 None，则与该张量具有相同的 torch.dtype。

• device (torch.device, 可选) – 返回张量的期望设备。默认值：如果为 None，则与该张量具有相同的 torch.device。

• requires_grad (bool, 可选) – 是否应记录对返回张量的操作。默认值：False。

• layout (torch.layout, 可选) – 返回张量的期望布局。默认值：torch.strided。

• pin_memory (bool, 可选) – 如果设置为 True，则返回的张量将分配在固定内存中。仅适用于 CPU 张量。默认值：False。

示例

>>> tensor = torch.ones(())
>>> tensor.new_empty((2, 3))
tensor([[ 5.8182e-18,  4.5765e-41, -1.0545e+30],
        [ 3.0949e-41,  4.4842e-44,  0.0000e+00]])

new_empty_strided(size, stride, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

返回一个大小为 size 且步长为 stride 的张量，其中填充了未初始化的数据。默认情况下，返回的张量具有与该张量相同的 torch.dtype 和 torch.device。

参数:

size (int...) – 定义输出张量形状的整数列表、元组或 torch.Size。

关键字参数：

• dtype (torch.dtype, 可选) – 返回张量的期望类型。默认值：如果为 None，则与该张量具有相同的 torch.dtype。

• device (torch.device, 可选) – 返回张量的期望设备。默认值：如果为 None，则与该张量具有相同的 torch.device。

• requires_grad (bool, 可选) – 是否应记录对返回张量的操作。默认值：False。

• layout (torch.layout, 可选) – 返回张量的期望布局。默认值：torch.strided。

• pin_memory (bool, 可选) – 如果设置为 True，则返回的张量将分配在固定内存中。仅适用于 CPU 张量。默认值：False。

示例

>>> tensor = torch.ones(())
>>> tensor.new_empty_strided((2, 3), (3, 1))
tensor([[ 5.8182e-18,  4.5765e-41, -1.0545e+30],
        [ 3.0949e-41,  4.4842e-44,  0.0000e+00]])

new_full(size, fill_value, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

返回一个大小为 size 的张量，其中填充了 fill_value。默认情况下，返回的张量具有与该张量相同的 torch.dtype 和 torch.device。

参数:

fill_value (标量) – 用于填充输出张量的数字。

关键字参数：

• dtype (torch.dtype, 可选) – 返回张量的期望类型。默认值：如果为 None，则与该张量具有相同的 torch.dtype。

• device (torch.device, 可选) – 返回张量的期望设备。默认值：如果为 None，则与该张量具有相同的 torch.device。

• requires_grad (bool, 可选) – 是否应记录对返回张量的操作。默认值：False。

• layout (torch.layout, 可选) – 返回张量的期望布局。默认值：torch.strided。

• pin_memory (bool, 可选) – 如果设置为 True，则返回的张量将分配在固定内存中。仅适用于 CPU 张量。默认值：False。

示例

>>> tensor = torch.ones((2,), dtype=torch.float64)
>>> tensor.new_full((3, 4), 3.141592)
tensor([[ 3.1416,  3.1416,  3.1416,  3.1416],
        [ 3.1416,  3.1416,  3.1416,  3.1416],
        [ 3.1416,  3.1416,  3.1416,  3.1416]], dtype=torch.float64)

new_ones(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

返回一个大小为 size 的张量，其中填充了 1。默认情况下，返回的张量具有与该张量相同的 torch.dtype 和 torch.device。

参数:

size (int...) – 定义输出张量形状的整数列表、元组或 torch.Size。

关键字参数：

• dtype (torch.dtype, 可选) – 返回张量的期望类型。默认值：如果为 None，则与该张量具有相同的 torch.dtype。

• device (torch.device, 可选) – 返回张量的期望设备。默认值：如果为 None，则与该张量具有相同的 torch.device。

• requires_grad (bool, 可选) – 是否应记录对返回张量的操作。默认值：False。

• layout (torch.layout, 可选) – 返回张量的期望布局。默认值：torch.strided。

• pin_memory (bool, 可选) – 如果设置为 True，则返回的张量将分配在固定内存中。仅适用于 CPU 张量。默认值：False。

示例

>>> tensor = torch.tensor((), dtype=torch.int32)
>>> tensor.new_ones((2, 3))
tensor([[ 1,  1,  1],
        [ 1,  1,  1]], dtype=torch.int32)

new_tensor(data, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

返回一个新的张量，其中 data 作为张量数据。默认情况下，返回的张量具有与该张量相同的 torch.dtype 和 torch.device。

警告

new_tensor() 始终复制 data。如果您有一个张量 data 并且想要避免复制，请使用 torch.Tensor.requires_grad_() 或 torch.Tensor.detach()。如果您有一个 NumPy 数组并且想要避免复制，请使用 torch.from_numpy()。

警告

当数据是一个张量 x 时，new_tensor() 从传递给它的任何内容中读取“数据”，并构造一个叶变量。因此，tensor.new_tensor(x) 等效于 x.clone().detach()，而 tensor.new_tensor(x, requires_grad=True) 等效于 x.clone().detach().requires_grad_(True)。建议使用使用 clone() 和 detach() 的等效项。

参数:

data (类数组) – 返回的张量复制 data。

关键字参数：

• dtype (torch.dtype, 可选) – 返回张量的期望类型。默认值：如果为 None，则与该张量具有相同的 torch.dtype。

• device (torch.device, 可选) – 返回张量的期望设备。默认值：如果为 None，则与该张量具有相同的 torch.device。

• requires_grad (bool, 可选) – 是否应记录对返回张量的操作。默认值：False。

• layout (torch.layout, 可选) – 返回张量的期望布局。默认值：torch.strided。

• pin_memory (bool, 可选) – 如果设置为 True，则返回的张量将分配在固定内存中。仅适用于 CPU 张量。默认值：False。

示例

>>> tensor = torch.ones((2,), dtype=torch.int8)
>>> data = [[0, 1], [2, 3]]
>>> tensor.new_tensor(data)
tensor([[ 0,  1],
        [ 2,  3]], dtype=torch.int8)

new_zeros(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

返回一个大小为 size 且填充为 0 的 Tensor。默认情况下，返回的 Tensor 具有与该 Tensor 相同的 torch.dtype 和 torch.device。

参数:

size (int...) – 定义输出张量形状的整数列表、元组或 torch.Size。

关键字参数：

• dtype (torch.dtype, 可选) – 返回张量的期望类型。默认值：如果为 None，则与该张量具有相同的 torch.dtype。

• device (torch.device, 可选) – 返回张量的期望设备。默认值：如果为 None，则与该张量具有相同的 torch.device。

• requires_grad (bool, 可选) – 是否应记录对返回张量的操作。默认值：False。

• layout (torch.layout, 可选) – 返回张量的期望布局。默认值：torch.strided。

• pin_memory (bool, 可选) – 如果设置为 True，则返回的张量将分配在固定内存中。仅适用于 CPU 张量。默认值：False。

示例

>>> tensor = torch.tensor((), dtype=torch.float64)
>>> tensor.new_zeros((2, 3))
tensor([[ 0.,  0.,  0.],
        [ 0.,  0.,  0.]], dtype=torch.float64)

nextafter(other) → Tensor

参见 torch.nextafter()

nextafter_(other) → Tensor

nextafter() 的就地版本。

nonzero() → LongTensor

参见 torch.nonzero()

nonzero_static(input, *, size, fill_value=- 1) → Tensor

返回一个 2 维的张量，其中每行都是非零值的索引。返回的张量具有与 torch.nonzero() 相同的 torch.dtype。

参数:

input (Tensor) – 用于计算非零元素的输入张量。

关键字参数：

• size (int) – 预计包含在输出张量中的非零元素的大小。如果 size 大于非零元素的总数，则使用 fill_value 填充输出张量；如果 size 小于非零元素的总数，则截断输出张量。大小必须是非负整数。

• fill_value (int) – 当 size 大于非零元素的总数时，用于填充输出张量的值。默认值为 -1，表示无效索引。

示例

# 示例 1：填充 >>> input_tensor = torch.tensor([[1, 0], [3, 2]]) >>> static_size = 4 >>> t = torch.nonzero_static(input_tensor, size = static_size) tensor([[ 0, 0],

[ 1, 0], [ 1, 1], [ -1, -1]], dtype=torch.int64)

# 示例 2：截断 >>> input_tensor = torch.tensor([[1, 0], [3, 2]]) >>> static_size = 2 >>> t = torch.nonzero_static(input_tensor, size = static_size) tensor([[ 0, 0],

[ 1, 0]], dtype=torch.int64)

# 示例 3：大小为 0 >>> input_tensor = torch.tensor([10]) >>> static_size = 0 >>> t = torch.nonzero_static(input_tensor, size = static_size) tensor([], size=(0, 1), dtype=torch.int64)

# 示例 4：秩为 0 的输入 >>> input_tensor = torch.tensor(10) >>> static_size = 2 >>> t = torch.nonzero_static(input_tensor, size = static_size) tensor([], size=(2, 0), dtype=torch.int64)

norm(p: Optional[Union[float, str]] = 'fro', dim=None, keepdim=False, dtype=None)

参见 torch.norm()

normal_(mean=0, std=1, *, generator=None) → Tensor

用由 mean 和 std 参数化的正态分布中的元素样本填充 self 张量。

not_equal(other) → Tensor

参见 torch.not_equal()。

not_equal_(other) → Tensor

not_equal() 的就地版本。

numel() → int

参见 torch.numel()

numpy(*, force=False) → numpy.ndarray

将张量返回为 NumPy ndarray。

如果 force 为 False（默认值），则只有在张量位于 CPU 上、不需要梯度、没有设置其共轭位，以及数据类型和布局是 NumPy 支持的情况下才会执行转换。返回的 ndarray 和张量将共享其存储空间，因此对张量的更改将在 ndarray 中反映出来，反之亦然。

如果 force 为 True，则等效于调用 t.detach().cpu().resolve_conj().resolve_neg().numpy()。如果张量不在 CPU 上或共轭位或负位已设置，则张量将不会与其返回的 ndarray 共享其存储空间。将 force 设置为 True 可以用作有用的简写。

参数:

force (bool) – 如果为 True，则 ndarray 可能是张量的副本，而不是始终共享内存，默认为 False。

classmethod ones(*size, dtype=None, device=None, filename=None)

classmethod ones(shape, *, dtype=None, device=None, filename=None)

创建一个内容全为 1 的张量，指定其形状、数据类型和文件名。

参数:

shape (整数 或 torch.Size) – 张量的形状。

关键字参数：

• dtype (torch.dtype) – 张量的类型。

• device (torch.device) – 张量的设备。仅接受 None 和 “cpu”，任何其他设备都会引发异常。

• filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

• existsok (bool, 可选) – 是否允许覆盖现有文件。默认为 False。

classmethod ones_like(input, *, filename=None)

创建一个内容全为 1 的张量，但其形状和数据类型与输入张量相同。

参数:

input (torch.Tensor) – 用作示例的张量。

关键字参数：

filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

orgqr(input2) → Tensor

参见 torch.orgqr()

ormqr(input2, input3, left=True, transpose=False) → Tensor

参见 torch.ormqr()

outer(vec2) → Tensor

参见 torch.outer().

permute(*dims) → Tensor

参见 torch.permute()

pin_memory() → Tensor

如果张量尚未固定在内存中，则将其复制到固定内存。

pinverse() → Tensor

参见 torch.pinverse()

polygamma(n) → Tensor

参见 torch.polygamma()

polygamma_(n) → Tensor

polygamma() 的就地版本

positive() → Tensor

参见 torch.positive()

pow(exponent) → Tensor

参见 torch.pow()

pow_(exponent) → Tensor

pow() 的就地版本

prod(dim=None, keepdim=False, dtype=None) → Tensor

参见 torch.prod()

put(input, index, source, accumulate=False) → Tensor

torch.Tensor.put_() 的非就地版本。 input 对应于 torch.Tensor.put_() 中的 self。

put_(index, source, accumulate=False) → Tensor

将 source 中的元素复制到由 index 指定的位置。为了索引的目的，self 张量被视为一个一维张量。

index 和 source 需要具有相同数量的元素，但形状不必相同。

如果 accumulate 为 True，则 source 中的元素将添加到 self 中。如果 accumulate 为 False，则如果 index 包含重复元素，则行为未定义。

参数:

• index (LongTensor) – 指向 self 的索引

• source (Tensor) – 包含要复制值的张量

• accumulate (bool) – 是否累加到 self 中

示例

>>> src = torch.tensor([[4, 3, 5],
...                     [6, 7, 8]])
>>> src.put_(torch.tensor([1, 3]), torch.tensor([9, 10]))
tensor([[  4,   9,   5],
        [ 10,   7,   8]])

q_per_channel_axis() → int

对于通过线性（仿射）逐通道量化量化的张量，返回应用逐通道量化的维度索引。

q_per_channel_scales() → Tensor

对于通过线性（仿射）逐通道量化量化的张量，返回一个表示基础量化器比例的张量。它具有与张量对应维度（来自 q_per_channel_axis）匹配的元素数量。

q_per_channel_zero_points() → Tensor

给定一个通过线性（仿射）逐通道量化量化的张量，返回底层量化器的零点张量。它的元素数量与张量中相应维度（来自 q_per_channel_axis）匹配。

q_scale() → float

给定一个通过线性（仿射）量化量化的张量，返回底层量化器的比例。

q_zero_point() → int

给定一个通过线性（仿射）量化量化的张量，返回底层量化器的零点。

qr(some=True)

参见 torch.qr()

qscheme() → torch.qscheme

返回给定 QTensor 的量化方案。

quantile(q, dim=None, keepdim=False, *, interpolation='linear') → Tensor

参见 torch.quantile()

rad2deg() → Tensor

参见 torch.rad2deg()

rad2deg_() → Tensor

rad2deg() 的就地版本。

random_(from=0, to=None, *, generator=None) → Tensor

用从 [from, to - 1] 范围内的离散均匀分布中采样的数字填充 self 张量。如果未指定，则这些值通常仅受 self 张量的数据类型的限制。但是，对于浮点类型，如果未指定，则范围将为 [0, 2^mantissa]，以确保每个值都可表示。例如，torch.tensor(1, dtype=torch.double).random_() 将在 [0, 2^53] 中均匀分布。

ravel() → Tensor

参见 torch.ravel()

real

对于复数输入张量，返回一个新张量，其中包含 self 张量的实数值。返回的张量和 self 共享相同的底层存储。

如果 self 是实数值张量，则返回 self。

示例：

>>> x=torch.randn(4, dtype=torch.cfloat)
>>> x
tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
>>> x.real
tensor([ 0.3100, -0.5445, -1.6492, -0.0638])

reciprocal() → Tensor

参见 torch.reciprocal()

reciprocal_() → Tensor

reciprocal() 的就地版本。

record_stream(stream)

将张量标记为已在此流中使用。当张量被释放时，确保张量内存不会被另一个张量重用，直到在释放时排队的 stream 上的所有工作完成。

注意

缓存分配器只知道张量分配的流。由于这种意识，它已经正确地管理了仅在一个流上的张量的生命周期。但是，如果张量在与源流不同的流上使用，分配器可能会意外地重用内存。调用此方法让分配器知道哪些流使用了该张量。

警告

此方法最适合用于您提供了一个在侧流上创建张量的函数，并且希望用户能够使用该张量而无需在使用它们时仔细考虑流安全性的用例。这些安全保证会带来一些性能和可预测性的成本（类似于 GC 和手动内存管理之间的权衡），因此，如果您处于管理张量生命周期的完整情况，您可以考虑改为手动管理 CUDA 事件，因此调用此方法将不再必要。特别是，当您调用此方法时，在随后的分配中，分配器将轮询记录的流以查看所有操作是否已完成；您可能与侧流计算竞争并不可预测地重用或无法重用分配的内存。

您可以安全地在侧流上分配的张量上使用，无需 record_stream()；您必须手动确保任何非创建流对张量的使用在您释放张量之前同步回创建流。由于 CUDA 缓存分配器保证内存将只在相同的创建流中重用，这足以确保写入内存的未来重新分配将延迟，直到非创建流的使用完成。（违反直觉的是，您可能会观察到，在 CPU 端我们已经重新分配了张量，即使在旧张量上的 CUDA 内核仍在进行中。这是可以的，因为在新的张量上的 CUDA 操作将适当地等待旧的操作完成，因为它们都在同一个流上。）

具体地说，这看起来像这样

with torch.cuda.stream(s0):
    x = torch.zeros(N)

s1.wait_stream(s0)
with torch.cuda.stream(s1):
    y = some_comm_op(x)

... some compute on s0 ...

# synchronize creation stream s0 to side stream s1
# before deallocating x
s0.wait_stream(s1)
del x

请注意，在决定何时执行 s0.wait_stream(s1) 时需要一些谨慎。特别是，如果我们在 some_comm_op 之后立即等待，那么拥有侧流就没有意义；它相当于在 s0 上运行 some_comm_op。相反，同步必须放在某个适当的、较晚的时间点，您预计侧流 s1 已完成工作。这个位置通常通过分析来识别，例如，使用由 torch.autograd.profiler.profile.export_chrome_trace() 生成的 Chrome 跟踪。如果您过早地放置等待，则 s0 上的工作将阻塞，直到 s1 完成，从而阻止通信和计算的进一步重叠。如果您过晚地放置等待，您将使用比严格必要的更多的内存（因为您将 x 保持更长时间。）有关如何在实践中应用此指导的具体示例，请参阅此帖子：FSDP 和 CUDACachingAllocator.

refine_names(*names)

根据 names 改进 self 的维度名称。

改进是重命名的一个特例，它“提升”了未命名的维度。一个 None 维度可以被改进为具有任何名称；一个命名的维度只能被改进为具有相同的名称。

因为命名张量可以与未命名张量共存，所以改进名称提供了一种编写命名张量感知代码的好方法，该代码既可以与命名张量一起使用，也可以与未命名张量一起使用。

names 可以包含最多一个省略号 (...)。省略号会贪婪地扩展；它会原地扩展以填充 names 到与 self.dim() 相同的长度，使用来自 self.names 对应索引的名称。

Python 2 不支持省略号，但可以使用字符串字面量代替 ('...')。

参数:

names (字符串可迭代对象) – 输出张量的所需名称。可以包含最多一个省略号。

示例

>>> imgs = torch.randn(32, 3, 128, 128)
>>> named_imgs = imgs.refine_names('N', 'C', 'H', 'W')
>>> named_imgs.names
('N', 'C', 'H', 'W')

>>> tensor = torch.randn(2, 3, 5, 7, 11)
>>> tensor = tensor.refine_names('A', ..., 'B', 'C')
>>> tensor.names
('A', None, None, 'B', 'C')

警告

register_hook(hook)

注册一个反向钩子。

每次计算相对于张量的梯度时，都会调用该钩子。钩子应具有以下签名

hook(grad) -> Tensor or None

钩子不应修改其参数，但可以选择返回一个新的梯度，该梯度将用于替代 grad。

此函数返回一个句柄，该句柄具有一个方法 handle.remove()，用于从模块中删除钩子。

注意

有关何时执行此钩子以及其执行顺序相对于其他钩子的更多信息，请参阅 反向钩子执行。

示例

>>> v = torch.tensor([0., 0., 0.], requires_grad=True)
>>> h = v.register_hook(lambda grad: grad * 2)  # double the gradient
>>> v.backward(torch.tensor([1., 2., 3.]))
>>> v.grad

 2
 4
 6
[torch.FloatTensor of size (3,)]

>>> h.remove()  # removes the hook

register_post_accumulate_grad_hook(hook)

注册一个在梯度累积后运行的反向钩子。

该钩子将在一个张量的所有梯度累积后被调用，这意味着该张量的 .grad 字段已经更新。后累积梯度钩子仅适用于叶子张量（没有 .grad_fn 字段的张量）。在非叶子张量上注册此钩子会导致错误！

钩子应具有以下签名

hook(param: Tensor) -> None

注意，与其他 autograd 钩子不同，此钩子对需要梯度的张量而不是梯度本身进行操作。钩子可以就地修改和访问其张量参数，包括其 .grad 字段。

此函数返回一个句柄，该句柄具有一个方法 handle.remove()，用于从模块中删除钩子。

注意

有关何时执行此钩子以及其执行顺序相对于其他钩子的更多信息，请参阅 反向钩子执行。由于此钩子在反向传播期间运行，因此它将在无梯度模式下运行（除非 create_graph 为 True）。如果需要，可以使用 torch.enable_grad() 在钩子内重新启用 autograd。

示例

>>> v = torch.tensor([0., 0., 0.], requires_grad=True)
>>> lr = 0.01
>>> # simulate a simple SGD update
>>> h = v.register_post_accumulate_grad_hook(lambda p: p.add_(p.grad, alpha=-lr))
>>> v.backward(torch.tensor([1., 2., 3.]))
>>> v
tensor([-0.0100, -0.0200, -0.0300], requires_grad=True)

>>> h.remove()  # removes the hook

remainder(divisor) → Tensor

参见 torch.remainder()

remainder_(divisor) → Tensor

remainder() 的就地版本

rename(*names, **rename_map)

重命名 self 的维度名称。

主要有两种用法

self.rename(**rename_map) 返回一个张量视图，该张量视图的维度已按映射 rename_map 中指定的方式重命名。

self.rename(*names) 返回一个张量视图，使用 names 按位置重命名所有维度。使用 self.rename(None) 在张量上删除名称。

不能同时指定位置参数 names 和关键字参数 rename_map。

示例

>>> imgs = torch.rand(2, 3, 5, 7, names=('N', 'C', 'H', 'W'))
>>> renamed_imgs = imgs.rename(N='batch', C='channels')
>>> renamed_imgs.names
('batch', 'channels', 'H', 'W')

>>> renamed_imgs = imgs.rename(None)
>>> renamed_imgs.names
(None, None, None, None)

>>> renamed_imgs = imgs.rename('batch', 'channel', 'height', 'width')
>>> renamed_imgs.names
('batch', 'channel', 'height', 'width')

警告

rename_(*names, **rename_map)

rename() 的就地版本。

renorm(p, dim, maxnorm) → Tensor

参见 torch.renorm()

renorm_(p, dim, maxnorm) → Tensor

renorm() 的就地版本

repeat(*repeats) → Tensor

沿着指定维度重复此张量。

与 expand() 不同，此函数会复制张量的数据。

警告

repeat() 的行为与 numpy.repeat 不同，但更类似于 numpy.tile。对于类似于 numpy.repeat 的运算符，请参阅 torch.repeat_interleave()。

参数:

repeat (torch.Size, int..., 整数元组 或 整数列表) – 沿着每个维度重复此张量的次数

示例

>>> x = torch.tensor([1, 2, 3])
>>> x.repeat(4, 2)
tensor([[ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3]])
>>> x.repeat(4, 2, 1).size()
torch.Size([4, 2, 3])

repeat_interleave(repeats, dim=None, *, output_size=None) → Tensor

参见 torch.repeat_interleave()。

requires_grad

如果需要为此张量计算梯度，则为 True，否则为 False。

注意

需要为张量计算梯度并不意味着 grad 属性将被填充，有关更多详细信息，请参阅 is_leaf。

requires_grad_(requires_grad=True) → Tensor

更改 autograd 是否应记录对此张量的操作：就地设置此张量的 requires_grad 属性。返回此张量。

requires_grad_() 的主要用例是告诉 autograd 开始记录对张量 tensor 的操作。如果 tensor 具有 requires_grad=False（因为它来自 DataLoader，或需要预处理或初始化），则 tensor.requires_grad_() 使 autograd 开始记录对 tensor 的操作。

参数:

requires_grad (bool) – autograd 是否应记录对此张量的操作。默认值：True。

示例

>>> # Let's say we want to preprocess some saved weights and use
>>> # the result as new weights.
>>> saved_weights = [0.1, 0.2, 0.3, 0.25]
>>> loaded_weights = torch.tensor(saved_weights)
>>> weights = preprocess(loaded_weights)  # some function
>>> weights
tensor([-0.5503,  0.4926, -2.1158, -0.8303])

>>> # Now, start to record operations done to weights
>>> weights.requires_grad_()
>>> out = weights.pow(2).sum()
>>> out.backward()
>>> weights.grad
tensor([-1.1007,  0.9853, -4.2316, -1.6606])

reshape(*shape) → Tensor

返回一个与 self 具有相同数据和元素数量的张量，但具有指定的形状。如果 shape 与当前形状兼容，则此方法将返回一个视图。有关何时可以返回视图，请参见 torch.Tensor.view()。

参见 torch.reshape()

参数:

shape (整数元组 或 整数...) – 目标形状

reshape_as(other) → Tensor

返回与 other 具有相同形状的此张量。 self.reshape_as(other) 等效于 self.reshape(other.sizes())。如果 other.sizes() 与当前形状兼容，则此方法将返回一个视图。有关何时可以返回视图，请参见 torch.Tensor.view()。

有关 reshape 的更多信息，请参见 reshape()。

参数:

other (torch.Tensor) – 结果张量的形状与 other 相同。

resize_(*sizes, memory_format=torch.contiguous_format) → Tensor

将 self 张量调整为指定的大小。如果元素数量大于当前存储区大小，则底层存储区将调整大小以适合新元素数量。如果元素数量较小，则底层存储区不会更改。将保留现有元素，但任何新内存都将未初始化。

警告

这是一个低级方法。存储区被重新解释为 C 连续的，忽略当前步幅（除非目标大小等于当前大小，在这种情况下，张量将保持不变）。对于大多数用途，您应该改用 view()（它检查连续性）或 reshape()（它在必要时复制数据）。若要使用自定义步幅就地更改大小，请参见 set_()。

注意

如果 torch.use_deterministic_algorithms() 和 torch.utils.deterministic.fill_uninitialized_memory 都设置为 True，则将初始化新元素以防止使用结果作为操作的输入而导致的非确定性行为。浮点和复数被设置为 NaN，整数被设置为最大值。

参数:

• sizes (torch.Size 或 整数...) – 目标大小

• memory_format (torch.memory_format，可选) – 张量的目标内存格式。默认值：torch.contiguous_format。请注意，如果 self.size() 与 sizes 相匹配，则 self 的内存格式将不会受到影响。

示例

>>> x = torch.tensor([[1, 2], [3, 4], [5, 6]])
>>> x.resize_(2, 2)
tensor([[ 1,  2],
        [ 3,  4]])

resize_as_(tensor, memory_format=torch.contiguous_format) → Tensor

将 self 张量调整为与指定 tensor 相同的大小。这等效于 self.resize_(tensor.size())。

参数:

memory_format (torch.memory_format，可选) – 张量的目标内存格式。默认值：torch.contiguous_format。请注意，如果 self.size() 与 tensor.size() 相匹配，则 self 的内存格式将不会受到影响。

resolve_conj() → Tensor

参见 torch.resolve_conj()

resolve_neg() → Tensor

参见 torch.resolve_neg()

retain_grad() → None

使此张量能够在 backward() 期间填充其 grad。对于叶子张量，这是一个无操作。

retains_grad

如果此张量是非叶子张量并且其 grad 启用，以便在 backward() 期间填充，则为 True，否则为 False。

roll(shifts, dims) → Tensor

参见 torch.roll()

rot90(k, dims) → Tensor

参见 torch.rot90()

round(decimals=0) → Tensor

参见 torch.round()

round_(decimals=0) → Tensor

round() 的就地版本

rsqrt() → Tensor

参见 torch.rsqrt()

rsqrt_() → Tensor

rsqrt() 的就地版本

scatter(dim, index, src) → Tensor

关于 torch.Tensor.scatter_() 的非就地版本。

scatter_(dim, index, src, *, reduce=None) → Tensor

将张量 src 中的所有值写入 self 中，索引由 index 张量指定。对于 src 中的每个值，其输出索引由其在 src 中的索引（对于 dimension != dim）和 index 中对应值（对于 dimension = dim）确定。

对于一个 3 维张量，self 会被更新为：

self[index[i][j][k]][j][k] = src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] = src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] = src[i][j][k]  # if dim == 2

这是 gather() 中描述方式的反向操作。

self、index 和 src（如果它是张量）都应该具有相同数量的维度。此外，对于所有维度 d，要求 index.size(d) <= src.size(d)，并且对于所有维度 d != dim，要求 index.size(d) <= self.size(d)。注意，index 和 src 不会广播。

此外，就像 gather() 一样，index 的值必须在 0 到 self.size(dim) - 1（包含）之间。

警告

当索引不唯一时，行为是非确定性的（src 中的一个值将被任意选择），并且梯度将不正确（它将被传播到源中对应于同一索引的所有位置）!

注意

仅针对 src.shape == index.shape 实现反向传播。

此外，还接受一个可选的 reduce 参数，它允许指定可选的缩减操作，该操作将应用于张量 src 中的所有值，并将这些值写入 self 中，索引由 index 指定。对于 src 中的每个值，缩减操作将应用于 self 中的索引，该索引由其在 src 中的索引（对于 dimension != dim）和 index 中对应值（对于 dimension = dim）确定。

给定一个 3 维张量和使用乘法操作进行缩减，self 将被更新为：

self[index[i][j][k]][j][k] *= src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] *= src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] *= src[i][j][k]  # if dim == 2

使用加法操作进行缩减与使用 scatter_add_() 相同。

警告

使用张量 src 的缩减参数已弃用，将在未来的 PyTorch 版本中删除。请使用 scatter_reduce_() 来获得更多缩减选项。

参数:

• dim (int) – 索引的轴。

• index (LongTensor) – 要散布的元素的索引，可以为空或与 src 维度相同。当为空时，该操作返回 self 不变。

• src (Tensor) – 要散布的源元素。

关键字参数：

reduce (str, optional) – 要应用的缩减操作，可以是 'add' 或 'multiply'。

示例

>>> src = torch.arange(1, 11).reshape((2, 5))
>>> src
tensor([[ 1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10]])
>>> index = torch.tensor([[0, 1, 2, 0]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_(0, index, src)
tensor([[1, 0, 0, 4, 0],
        [0, 2, 0, 0, 0],
        [0, 0, 3, 0, 0]])
>>> index = torch.tensor([[0, 1, 2], [0, 1, 4]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_(1, index, src)
tensor([[1, 2, 3, 0, 0],
        [6, 7, 0, 0, 8],
        [0, 0, 0, 0, 0]])

>>> torch.full((2, 4), 2.).scatter_(1, torch.tensor([[2], [3]]),
...            1.23, reduce='multiply')
tensor([[2.0000, 2.0000, 2.4600, 2.0000],
        [2.0000, 2.0000, 2.0000, 2.4600]])
>>> torch.full((2, 4), 2.).scatter_(1, torch.tensor([[2], [3]]),
...            1.23, reduce='add')
tensor([[2.0000, 2.0000, 3.2300, 2.0000],
        [2.0000, 2.0000, 2.0000, 3.2300]])

scatter_(dim, index, value, *, reduce=None) → Tensor:

将来自 value 的值写入 self 中，索引由 index 张量指定。该操作等效于先前版本，其中 src 张量完全填充为 value。

参数:

• dim (int) – 索引的轴。

• index (LongTensor) – 要散布的元素的索引，可以为空或与 src 维度相同。当为空时，该操作返回 self 不变。

• value (Scalar) – 要散布的值。

关键字参数：

reduce (str, optional) – 要应用的缩减操作，可以是 'add' 或 'multiply'。

示例

>>> index = torch.tensor([[0, 1]])
>>> value = 2
>>> torch.zeros(3, 5).scatter_(0, index, value)
tensor([[2., 0., 0., 0., 0.],
        [0., 2., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])

scatter_add(dim, index, src) → Tensor

关于 torch.Tensor.scatter_add_() 的非就地版本。

scatter_add_(dim, index, src) → Tensor

将张量 src 中的所有值以类似于 scatter_() 的方式添加到 self 中，索引由 index 张量指定。对于 src 中的每个值，它将被添加到 self 中的索引，该索引由其在 src 中的索引（对于 dimension != dim）和 index 中对应值（对于 dimension = dim）确定。

对于一个 3 维张量，self 会被更新为：

self[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2

self、index 和 src 应该具有相同数量的维度。此外，要求对于所有维度 d，要求 index.size(d) <= src.size(d)，并且对于所有维度 d != dim，要求 index.size(d) <= self.size(d)。注意，index 和 src 不会广播。

注意

当在 CUDA 设备上给出张量时，此操作可能会表现出不确定性。有关更多信息，请参阅 /notes/randomness。

注意

仅针对 src.shape == index.shape 实现反向传播。

参数:

• dim (int) – 索引的轴。

• index (LongTensor) – 要散布和添加的元素的索引，可以为空或与 src 维度相同。当为空时，该操作返回 self 不变。

• src (Tensor) – 要散布和添加的源元素。

示例

>>> src = torch.ones((2, 5))
>>> index = torch.tensor([[0, 1, 2, 0, 0]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_add_(0, index, src)
tensor([[1., 0., 0., 1., 1.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.]])
>>> index = torch.tensor([[0, 1, 2, 0, 0], [0, 1, 2, 2, 2]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_add_(0, index, src)
tensor([[2., 0., 0., 1., 1.],
        [0., 2., 0., 0., 0.],
        [0., 0., 2., 1., 1.]])

scatter_reduce(dim, index, src, reduce, *, include_self=True) → Tensor

关于 torch.Tensor.scatter_reduce_() 的非就地版本。

scatter_reduce_(dim, index, src, reduce, *, include_self=True) → Tensor

使用 reduce 参数 ("sum", "prod", "mean", "amax", "amin") 定义的应用约简，将 src 张量中的所有值约简到 index 张量中指定的索引，位于 self 张量中。对于 src 中的每个值，它被约简到 self 中的索引，该索引由其在 src 中的索引对于 dimension != dim 和由 index 中的对应值对于 dimension = dim 指定。如果 include_self="True"，则 self 张量中的值将包含在约简中。

self、index 和 src 应该都具有相同数量的维度。还要求 index.size(d) <= src.size(d) 对于所有维度 d，并且 index.size(d) <= self.size(d) 对于所有维度 d != dim。请注意，index 和 src 不会广播。

对于具有 reduce="sum" 和 include_self=True 的 3-D 张量，输出将给出如下

self[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2

注意

当在 CUDA 设备上给出张量时，此操作可能会表现出不确定性。有关更多信息，请参阅 /notes/randomness。

注意

仅针对 src.shape == index.shape 实现反向传播。

警告

此函数处于测试阶段，在不久的将来可能会发生变化。

参数:

• dim (int) – 索引的轴。

• index (LongTensor) – 要散布和约简的元素索引。

• src (Tensor) – 要散布和约简的源元素

• reduce (str) – 要对非唯一索引应用的约简操作 ("sum", "prod", "mean", "amax", "amin")

• include_self (bool) – self 张量中的元素是否包含在约简中

示例

>>> src = torch.tensor([1., 2., 3., 4., 5., 6.])
>>> index = torch.tensor([0, 1, 0, 1, 2, 1])
>>> input = torch.tensor([1., 2., 3., 4.])
>>> input.scatter_reduce(0, index, src, reduce="sum")
tensor([5., 14., 8., 4.])
>>> input.scatter_reduce(0, index, src, reduce="sum", include_self=False)
tensor([4., 12., 5., 4.])
>>> input2 = torch.tensor([5., 4., 3., 2.])
>>> input2.scatter_reduce(0, index, src, reduce="amax")
tensor([5., 6., 5., 2.])
>>> input2.scatter_reduce(0, index, src, reduce="amax", include_self=False)
tensor([3., 6., 5., 2.])

select(dim, index) → Tensor

请参阅 torch.select()

select_scatter(src, dim, index) → Tensor

请参阅 torch.select_scatter()

set_(source=None, storage_offset=0, size=None, stride=None) → Tensor

设置底层存储、大小和步长。如果 source 是一个张量，self 张量将共享相同的存储，并且具有与 source 相同的大小和步长。对一个张量中的元素的更改将反映在另一个张量中。

如果 source 是一个 Storage，该方法将设置底层存储、偏移量、大小和步长。

参数:

• source (Tensor 或 Storage) – 要使用的张量或存储

• storage_offset (int, optional) – 存储中的偏移量

• size (torch.Size, optional) – 期望的大小。默认为源的大小。

• stride (tuple, optional) – 期望的步长。默认为 C 连续步长。

sgn() → Tensor

请参阅 torch.sgn()

sgn_() → Tensor

sgn() 的就地版本

shape

返回 self 张量的大小。是 size 的别名。

另请参阅 Tensor.size()。

示例

>>> t = torch.empty(3, 4, 5)
>>> t.size()
torch.Size([3, 4, 5])
>>> t.shape
torch.Size([3, 4, 5])

share_memory_()

将底层存储移动到共享内存。

如果底层存储已在共享内存中，以及对于 CUDA 张量，这是一个无操作。共享内存中的张量不能调整大小。

请参阅 torch.UntypedStorage.share_memory_() 以了解详细信息。

short(memory_format=torch.preserve_format) → Tensor

self.short() 等效于 self.to(torch.int16)。请参阅 to().

参数:

memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

sigmoid() → Tensor

请参阅 torch.sigmoid()

sigmoid_() → Tensor

sigmoid() 的就地版本

sign() → Tensor

请参阅 torch.sign()

sign_() → Tensor

sign() 的就地版本

signbit() → Tensor

请参阅 torch.signbit()

sin() → Tensor

参见 torch.sin()

sin_() → Tensor

sin() 的就地版本

sinc() → Tensor

参见 torch.sinc()

sinc_() → Tensor

sinc() 的就地版本

sinh() → Tensor

参见 torch.sinh()

sinh_() → Tensor

sinh() 的就地版本

size(dim=None) → torch.Size or int

返回 self 张量的尺寸。如果未指定 dim，则返回值为 torch.Size，它是 tuple 的子类。如果指定了 dim，则返回一个表示该维度尺寸的 int。

参数:

dim (int, 可选) – 要检索尺寸的维度。

示例

>>> t = torch.empty(3, 4, 5)
>>> t.size()
torch.Size([3, 4, 5])
>>> t.size(dim=1)
4

slice_scatter(src, dim=0, start=None, end=None, step=1) → Tensor

参见 torch.slice_scatter()

slogdet()

参见 torch.slogdet()

smm(mat) → Tensor

参见 torch.smm()

softmax(dim) → Tensor

torch.nn.functional.softmax() 的别名。

sort(dim=- 1, descending=False)

参见 torch.sort()

sparse_dim() → int

返回 稀疏张量 self 中稀疏维度的数量。

注意

如果 self 不是稀疏张量，则返回 0。

另请参见 Tensor.dense_dim() 和 混合张量。

sparse_mask(mask) → Tensor

返回一个新的 稀疏张量，其中包含来自步长张量 self 的值，这些值根据稀疏张量 mask 的索引进行过滤。忽略 mask 稀疏张量的值。self 和 mask 张量必须具有相同的形状。

注意

如果 mask 未合并，则返回的稀疏张量可能包含重复的值。因此，如果不需要此行为，建议传递 mask.coalesce()。

注意

返回的稀疏张量具有与稀疏张量 mask 相同的索引，即使 self 中的对应值为零。

参数:

mask (Tensor) – 索引用作过滤器的稀疏张量

示例

>>> nse = 5
>>> dims = (5, 5, 2, 2)
>>> I = torch.cat([torch.randint(0, dims[0], size=(nse,)),
...                torch.randint(0, dims[1], size=(nse,))], 0).reshape(2, nse)
>>> V = torch.randn(nse, dims[2], dims[3])
>>> S = torch.sparse_coo_tensor(I, V, dims).coalesce()
>>> D = torch.randn(dims)
>>> D.sparse_mask(S)
tensor(indices=tensor([[0, 0, 0, 2],
                       [0, 1, 4, 3]]),
       values=tensor([[[ 1.6550,  0.2397],
                       [-0.1611, -0.0779]],

                      [[ 0.2326, -1.0558],
                       [ 1.4711,  1.9678]],

                      [[-0.5138, -0.0411],
                       [ 1.9417,  0.5158]],

                      [[ 0.0793,  0.0036],
                       [-0.2569, -0.1055]]]),
       size=(5, 5, 2, 2), nnz=4, layout=torch.sparse_coo)

sparse_resize_(size, sparse_dim, dense_dim) → Tensor

将 self 稀疏张量 调整为所需的大小以及稀疏和密集维度的数量。

注意

如果 self 中指定元素的数量为零，则 size、sparse_dim 和 dense_dim 可以是任何大小和正整数，只要 len(size) == sparse_dim + dense_dim。

但是，如果 self 指定了一个或多个元素，则 size 中的每个维度都不能小于 self 的对应维度，sparse_dim 必须等于 self 中稀疏维度的数量，而 dense_dim 必须等于 self 中密集维度的数量。

警告

如果 self 不是稀疏张量，则抛出错误。

参数:

• size (torch.Size) – 目标大小。如果 self 是非空的稀疏张量，则目标大小不能小于原始大小。

• sparse_dim (int) – 稀疏维度的数量

• dense_dim (int) – 密集维度的数量

sparse_resize_and_clear_(size, sparse_dim, dense_dim) → Tensor

从 稀疏张量 self 中移除所有指定元素，并将 self 的大小调整为目标大小，以及稀疏维度和密集维度的数量。

参数:

• size (torch.Size) – 目标大小。

• sparse_dim (int) – 稀疏维度的数量

• dense_dim (int) – 密集维度的数量

sqrt() → Tensor

参见 torch.sqrt()

sqrt_() → Tensor

sqrt() 的就地版本

square() → Tensor

参见 torch.square()

square_() → Tensor

square() 的就地版本

squeeze(dim=None) → Tensor

参见 torch.squeeze()

squeeze_(dim=None) → Tensor

squeeze() 的就地版本

sspaddmm(mat1, mat2, *, beta=1, alpha=1) → Tensor

参见 torch.sspaddmm()

std(dim=None, *, correction=1, keepdim=False) → Tensor

参见 torch.std()

stft(n_fft: int, hop_length: Optional[int] = None, win_length: Optional[int] = None, window: Optional[Tensor] = None, center: bool = True, pad_mode: str = 'reflect', normalized: bool = False, onesided: Optional[bool] = None, return_complex: Optional[bool] = None)

参见 torch.stft()

警告

此函数在版本 0.4.1 中更改了签名。使用之前的签名调用可能会导致错误或返回不正确的结果。

storage() → torch.TypedStorage

返回底层的 TypedStorage。

警告

TypedStorage 已弃用。它将在将来被删除，并且 UntypedStorage 将成为唯一的存储类。要直接访问 UntypedStorage，请使用 Tensor.untyped_storage()。

storage_offset() → int

返回 self 张量的底层存储中的偏移量，以存储元素数量（而不是字节）表示。

示例

>>> x = torch.tensor([1, 2, 3, 4, 5])
>>> x.storage_offset()
0
>>> x[3:].storage_offset()
3

storage_type() → type

返回底层存储的类型。

stride(dim) → tuple or int

返回 self 张量的步长。

步长是在指定维度 dim 中从一个元素到下一个元素所需的跳跃。当不传递参数时，返回所有步长的元组。否则，返回一个整数值作为特定维度 dim 的步长。

参数:

dim (int, optional) – 所需步长的目标维度

示例

>>> x = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
>>> x.stride()
(5, 1)
>>> x.stride(0)
5
>>> x.stride(-1)
1

sub(other, *, alpha=1) → Tensor

参见 torch.sub()。

sub_(other, *, alpha=1) → Tensor

sub() 的就地版本

subtract(other, *, alpha=1) → Tensor

参见 torch.subtract()。

subtract_(other, *, alpha=1) → Tensor

subtract() 的就地版本。

sum(dim=None, keepdim=False, dtype=None) → Tensor

参见 torch.sum()

sum_to_size(*size) → Tensor

将 this 张量求和到 size。 size 必须可广播到 this 张量的尺寸。

参数:

size (int...) – 定义输出张量形状的整数序列。

svd(some=True, compute_uv=True)

参见 torch.svd()

swapaxes(axis0, axis1) → Tensor

参见 torch.swapaxes()

swapaxes_(axis0, axis1) → Tensor

swapaxes() 的就地版本

swapdims(dim0, dim1) → Tensor

参见 torch.swapdims()

swapdims_(dim0, dim1) → Tensor

swapdims() 的就地版本

t() → Tensor

参见 torch.t()

t_() → Tensor

t() 的就地版本

take(indices) → Tensor

参见 torch.take()

take_along_dim(indices, dim) → Tensor

参见 torch.take_along_dim()

tan() → Tensor

参见 torch.tan()

tan_() → Tensor

tan() 的就地版本

tanh() → Tensor

参见 torch.tanh()

tanh_() → Tensor

tanh() 的就地版本

tensor_split(indices_or_sections, dim=0) → List of Tensors

参见 torch.tensor_split()

tile(dims) → Tensor

参见 torch.tile()

to(*args, **kwargs) → Tensor

执行张量数据类型和/或设备转换。 torch.dtype 和 torch.device 是从 self.to(*args, **kwargs) 的参数推断出来的。

注意

如果 self 张量已经具有正确的数据类型和设备，则返回 self 。 否则，返回的张量是 self 的副本，具有所需的数据类型和设备。

以下是调用 to 的方法

to(dtype, non_blocking=False, copy=False, memory_format=torch.preserve_format) → Tensor

返回具有指定 dtype 的张量

参数

memory_format (torch.memory_format, 可选): 返回张量的所需内存格式。默认值: torch.preserve_format。

to(device=None, dtype=None, non_blocking=False, copy=False, memory_format=torch.preserve_format) → Tensor

返回具有指定设备和（可选）数据类型的张量。如果 dtype 为 None，则推断为 self.dtype 。当 non_blocking 为真时，尝试相对于主机异步转换（如果可能），例如，将具有固定内存的 CPU 张量转换为 CUDA 张量。当 copy 设置为真时，即使张量已经匹配所需转换，也会创建一个新张量。

参数

memory_format (torch.memory_format, 可选): 返回张量的所需内存格式。默认值: torch.preserve_format。

to(other, non_blocking=False, copy=False) → Tensor

返回与张量 other 具有相同数据类型和设备的张量。当 non_blocking 为真时，尝试相对于主机异步转换（如果可能），例如，将具有固定内存的 CPU 张量转换为 CUDA 张量。当 copy 设置为真时，即使张量已经匹配所需转换，也会创建一个新张量。

示例

>>> tensor = torch.randn(2, 2)  # Initially dtype=float32, device=cpu
>>> tensor.to(torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64)

>>> cuda0 = torch.device('cuda:0')
>>> tensor.to(cuda0)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], device='cuda:0')

>>> tensor.to(cuda0, dtype=torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')

>>> other = torch.randn((), dtype=torch.float64, device=cuda0)
>>> tensor.to(other, non_blocking=True)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')

to_dense(dtype=None, *, masked_grad=True) → Tensor

如果 self 不是步长张量，则创建一个 self 的步长副本，否则返回 self 。

关键字参数：

• {dtype} –

• masked_grad (bool, 可选) – 如果设置为 True（默认值）并且 self 具有稀疏布局，则 to_dense() 的反向传播返回 grad.sparse_mask(self) 。

示例

>>> s = torch.sparse_coo_tensor(
...        torch.tensor([[1, 1],
...                      [0, 2]]),
...        torch.tensor([9, 10]),
...        size=(3, 3))
>>> s.to_dense()
tensor([[ 0,  0,  0],
        [ 9,  0, 10],
        [ 0,  0,  0]])

to_mkldnn() → Tensor

返回张量在 torch.mkldnn 布局中的副本。

to_padded_tensor(padding, output_size=None) → Tensor

参见 to_padded_tensor()

to_sparse(sparseDims) → Tensor

返回张量的稀疏副本。PyTorch 支持以 坐标格式 表示的稀疏张量。

参数:

sparseDims (int, 可选) – 要包含在新稀疏张量中的稀疏维度数

示例

>>> d = torch.tensor([[0, 0, 0], [9, 0, 10], [0, 0, 0]])
>>> d
tensor([[ 0,  0,  0],
        [ 9,  0, 10],
        [ 0,  0,  0]])
>>> d.to_sparse()
tensor(indices=tensor([[1, 1],
                       [0, 2]]),
       values=tensor([ 9, 10]),
       size=(3, 3), nnz=2, layout=torch.sparse_coo)
>>> d.to_sparse(1)
tensor(indices=tensor([[1]]),
       values=tensor([[ 9,  0, 10]]),
       size=(3, 3), nnz=1, layout=torch.sparse_coo)

to_sparse(*, layout=None, blocksize=None, dense_dim=None) → Tensor

返回具有指定布局和块大小的稀疏张量。如果 self 是步长张量，则可以指定密集维度的数量，并且将创建一个混合稀疏张量，其中包含 dense_dim 个密集维度和 self.dim() - 2 - dense_dim 个批处理维度。

注意

如果 self 布局和块大小参数与指定的布局和块大小匹配，则返回 self 。否则，返回 self 的稀疏张量副本。

参数:

• layout (torch.layout, 可选) – 所需的稀疏布局。可以是 torch.sparse_coo 、 torch.sparse_csr 、 torch.sparse_csc 、 torch.sparse_bsr 或 torch.sparse_bsc 。默认值: 如果为 None，则为 torch.sparse_coo 。

• blocksize (列表, 元组, torch.Size, 可选) – 结果 BSR 或 BSC 张量的块大小。对于其他布局，指定非 None 的块大小会导致 RuntimeError 异常。块大小必须是长度为 2 的元组，其元素可以均匀地划分两个稀疏维度。

• dense_dim (int, 可选) – 结果 CSR、CSC、BSR 或 BSC 张量的稠密维度数量。此参数仅应在 self 为跨步张量时使用，且必须介于 0 和 self 张量维度减 2 之间。

示例

>>> x = torch.tensor([[1, 0], [0, 0], [2, 3]])
>>> x.to_sparse(layout=torch.sparse_coo)
tensor(indices=tensor([[0, 2, 2],
                       [0, 0, 1]]),
       values=tensor([1, 2, 3]),
       size=(3, 2), nnz=3, layout=torch.sparse_coo)
>>> x.to_sparse(layout=torch.sparse_bsr, blocksize=(1, 2))
tensor(crow_indices=tensor([0, 1, 1, 2]),
       col_indices=tensor([0, 0]),
       values=tensor([[[1, 0]],
                      [[2, 3]]]), size=(3, 2), nnz=2, layout=torch.sparse_bsr)
>>> x.to_sparse(layout=torch.sparse_bsr, blocksize=(2, 1))
RuntimeError: Tensor size(-2) 3 needs to be divisible by blocksize[0] 2
>>> x.to_sparse(layout=torch.sparse_csr, blocksize=(3, 1))
RuntimeError: to_sparse for Strided to SparseCsr conversion does not use specified blocksize

>>> x = torch.tensor([[[1], [0]], [[0], [0]], [[2], [3]]])
>>> x.to_sparse(layout=torch.sparse_csr, dense_dim=1)
tensor(crow_indices=tensor([0, 1, 1, 3]),
       col_indices=tensor([0, 0, 1]),
       values=tensor([[1],
                      [2],
                      [3]]), size=(3, 2, 1), nnz=3, layout=torch.sparse_csr)

to_sparse_bsc(blocksize, dense_dim) → Tensor

将张量转换为给定块大小的块稀疏列 (BSC) 存储格式。如果 self 为跨步，则可以指定稠密维度数量，并将创建一个混合 BSC 张量，包含 dense_dim 个稠密维度和 self.dim() - 2 - dense_dim 个批处理维度。

参数:

• blocksize (列表, 元组, torch.Size, 可选) – 结果 BSC 张量的块大小。块大小必须是长度为 2 的元组，其元素可以均匀地划分两个稀疏维度。

• dense_dim (int, 可选) – 结果 BSC 张量的稠密维度数量。此参数仅应在 self 为跨步张量时使用，且必须介于 0 和 self 张量维度减 2 之间。

示例

>>> dense = torch.randn(10, 10)
>>> sparse = dense.to_sparse_csr()
>>> sparse_bsc = sparse.to_sparse_bsc((5, 5))
>>> sparse_bsc.row_indices()
tensor([0, 1, 0, 1])

>>> dense = torch.zeros(4, 3, 1)
>>> dense[0:2, 0] = dense[0:2, 2] = dense[2:4, 1] = 1
>>> dense.to_sparse_bsc((2, 1), 1)
tensor(ccol_indices=tensor([0, 1, 2, 3]),
       row_indices=tensor([0, 1, 0]),
       values=tensor([[[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]]]), size=(4, 3, 1), nnz=3,
       layout=torch.sparse_bsc)

to_sparse_bsr(blocksize, dense_dim) → Tensor

将张量转换为给定块大小的块稀疏行 (BSR) 存储格式。如果 self 为跨步，则可以指定稠密维度数量，并将创建一个混合 BSR 张量，包含 dense_dim 个稠密维度和 self.dim() - 2 - dense_dim 个批处理维度。

参数:

• blocksize (列表, 元组, torch.Size, 可选) – 结果 BSR 张量的块大小。块大小必须是长度为 2 的元组，其元素可以均匀地划分两个稀疏维度。

• dense_dim (int, 可选) – 结果 BSR 张量的稠密维度数量。此参数仅应在 self 为跨步张量时使用，且必须介于 0 和 self 张量维度减 2 之间。

示例

>>> dense = torch.randn(10, 10)
>>> sparse = dense.to_sparse_csr()
>>> sparse_bsr = sparse.to_sparse_bsr((5, 5))
>>> sparse_bsr.col_indices()
tensor([0, 1, 0, 1])

>>> dense = torch.zeros(4, 3, 1)
>>> dense[0:2, 0] = dense[0:2, 2] = dense[2:4, 1] = 1
>>> dense.to_sparse_bsr((2, 1), 1)
tensor(crow_indices=tensor([0, 2, 3]),
       col_indices=tensor([0, 2, 1]),
       values=tensor([[[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]]]), size=(4, 3, 1), nnz=3,
       layout=torch.sparse_bsr)

to_sparse_coo()

将张量转换为 坐标格式.

示例

>>> dense = torch.randn(5, 5)
>>> sparse = dense.to_sparse_coo()
>>> sparse._nnz()
25

to_sparse_csc() → Tensor

将张量转换为压缩列存储 (CSC) 格式。除了跨步张量外，仅适用于 2D 张量。如果 self 为跨步，则可以指定稠密维度数量，并将创建一个混合 CSC 张量，包含 dense_dim 个稠密维度和 self.dim() - 2 - dense_dim 个批处理维度。

参数:

dense_dim (int, 可选) – 结果 CSC 张量的稠密维度数量。此参数仅应在 self 为跨步张量时使用，且必须介于 0 和 self 张量维度减 2 之间。

示例

>>> dense = torch.randn(5, 5)
>>> sparse = dense.to_sparse_csc()
>>> sparse._nnz()
25

>>> dense = torch.zeros(3, 3, 1, 1)
>>> dense[0, 0] = dense[1, 2] = dense[2, 1] = 1
>>> dense.to_sparse_csc(dense_dim=2)
tensor(ccol_indices=tensor([0, 1, 2, 3]),
       row_indices=tensor([0, 2, 1]),
       values=tensor([[[1.]],

                      [[1.]],

                      [[1.]]]), size=(3, 3, 1, 1), nnz=3,
       layout=torch.sparse_csc)

to_sparse_csr(dense_dim=None) → Tensor

将张量转换为压缩行存储格式 (CSR)。除了跨步张量外，仅适用于 2D 张量。如果 self 为跨步，则可以指定稠密维度数量，并将创建一个混合 CSR 张量，包含 dense_dim 个稠密维度和 self.dim() - 2 - dense_dim 个批处理维度。

参数:

dense_dim (int, 可选) – 结果 CSR 张量的稠密维度数量。此参数仅应在 self 为跨步张量时使用，且必须介于 0 和 self 张量维度减 2 之间。

示例

>>> dense = torch.randn(5, 5)
>>> sparse = dense.to_sparse_csr()
>>> sparse._nnz()
25

>>> dense = torch.zeros(3, 3, 1, 1)
>>> dense[0, 0] = dense[1, 2] = dense[2, 1] = 1
>>> dense.to_sparse_csr(dense_dim=2)
tensor(crow_indices=tensor([0, 1, 2, 3]),
       col_indices=tensor([0, 2, 1]),
       values=tensor([[[1.]],

                      [[1.]],

                      [[1.]]]), size=(3, 3, 1, 1), nnz=3,
       layout=torch.sparse_csr)

tolist() → list or number

将张量作为 (嵌套) 列表返回。对于标量，将返回标准 Python 数字，就像使用 item() 一样。如果必要，张量将自动移动到 CPU。

此操作不可微分。

示例

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803

topk(k, dim=None, largest=True, sorted=True)

参见 torch.topk()

trace() → Tensor

参见 torch.trace()

transpose(dim0, dim1) → Tensor

参见 torch.transpose()

transpose_(dim0, dim1) → Tensor

transpose() 的就地版本。

triangular_solve(A, upper=True, transpose=False, unitriangular=False)

参见 torch.triangular_solve()

tril(diagonal=0) → Tensor

参见 torch.tril()

tril_(diagonal=0) → Tensor

tril() 的就地版本。

triu(diagonal=0) → Tensor

参见 torch.triu()

triu_(diagonal=0) → Tensor

triu() 的就地版本。

true_divide(value) → Tensor

参见 torch.true_divide()

true_divide_(value) → Tensor

true_divide_() 的就地版本。

trunc() → Tensor

参见 torch.trunc()

trunc_() → Tensor

trunc() 的就地版本。

type(dtype=None, non_blocking=False, **kwargs) → str or Tensor

如果未提供 dtype，则返回类型，否则将此对象转换为指定类型。

如果此对象已经是正确的类型，则不会执行复制操作并返回原始对象。

参数:

• dtype (dtype 或 string) – 目标类型。

• non_blocking (bool) – 如果为 True，并且源数据在固定内存中，而目标数据在 GPU 上，反之亦然，则复制操作将异步执行，与主机无关。否则，此参数无效。

• **kwargs – 为了兼容性，可能包含键 async 来代替 non_blocking 参数。 async 参数已弃用。

type_as(tensor) → Tensor

返回将此张量转换为给定张量类型的结果。

如果张量已经是正确的类型，则这是一个无操作。这等效于 self.type(tensor.type())。

参数:

tensor (Tensor) – 具有目标类型的张量。

unbind(dim=0) → seq

参见 torch.unbind()

unflatten(dim, sizes) → Tensor

参见 torch.unflatten().

unfold(dimension, size, step) → Tensor

返回原始张量的视图，其中包含来自 self 张量的 size 大小的所有切片，位于维度 dimension 中。

两个切片之间的步长由 step 给定。

如果 sizedim 是 self 的维度 dimension 的大小，则返回张量中维度 dimension 的大小将为 (sizedim - size) / step + 1.

在返回的张量中添加了一个大小为 size 的附加维度。

参数:

• dimension (int) – 展开发生的维度。

• size (int) – 展开每个切片的大小。

• step (int) – 每个切片之间的步长。

示例

>>> x = torch.arange(1., 8)
>>> x
tensor([ 1.,  2.,  3.,  4.,  5.,  6.,  7.])
>>> x.unfold(0, 2, 1)
tensor([[ 1.,  2.],
        [ 2.,  3.],
        [ 3.,  4.],
        [ 4.,  5.],
        [ 5.,  6.],
        [ 6.,  7.]])
>>> x.unfold(0, 2, 2)
tensor([[ 1.,  2.],
        [ 3.,  4.],
        [ 5.,  6.]])

uniform_(from=0, to=1, *, generator=None) → Tensor

用从连续均匀分布中采样的数字填充 self 张量。

\[f(x) = \dfrac{1}{\text{to} - \text{from}}\]

unique(sorted=True, return_inverse=False, return_counts=False, dim=None)

返回输入张量的唯一元素。

参见 torch.unique()

unique_consecutive(return_inverse=False, return_counts=False, dim=None)

除了每个连续的等效元素组中的第一个元素之外，所有其他元素都被消除。

参见 torch.unique_consecutive()

unsafe_chunk(chunks, dim=0) → List of Tensors

参见 torch.unsafe_chunk()

unsafe_split(split_size, dim=0) → List of Tensors

参见 torch.unsafe_split()

unsqueeze(dim) → Tensor

请参阅 torch.unsqueeze()

unsqueeze_(dim) → Tensor

unsqueeze() 的就地版本

untyped_storage() → torch.UntypedStorage

返回底层的 UntypedStorage。

values() → Tensor

返回 稀疏 COO 张量 的值张量。

警告

如果 self 不是一个稀疏 COO 张量，则抛出错误。

另请参见 Tensor.indices()。

注意

此方法只能在合并的稀疏张量上调用。有关详细信息，请参见 Tensor.coalesce()。

var(dim=None, *, correction=1, keepdim=False) → Tensor

请参阅 torch.var()

vdot(other) → Tensor

请参阅 torch.vdot()

view(*shape) → Tensor

返回一个新的张量，该张量与 self 张量具有相同的数据，但具有不同的 shape。

返回的张量共享相同的数据，并且必须具有相同数量的元素，但可能具有不同的大小。对于要被视为的张量，新视图大小必须与其原始大小和步幅兼容，即每个新视图维度必须是原始维度的子空间，或者仅跨越满足以下连续性条件的原始维度 \(d, d+1, \dots, d+k\)：\(\forall i = d, \dots, d+k-1\)，

\[\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]\]

否则，将无法在不复制的情况下将 self 张量视为 shape（例如，通过 contiguous()）。当不清楚是否可以执行 view() 时，建议使用 reshape()，它在形状兼容的情况下返回视图，并在其他情况下复制（相当于调用 contiguous()）。

参数:

shape (torch.Size 或 int...) – 期望的大小

示例

>>> x = torch.randn(4, 4)
>>> x.size()
torch.Size([4, 4])
>>> y = x.view(16)
>>> y.size()
torch.Size([16])
>>> z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
>>> z.size()
torch.Size([2, 8])

>>> a = torch.randn(1, 2, 3, 4)
>>> a.size()
torch.Size([1, 2, 3, 4])
>>> b = a.transpose(1, 2)  # Swaps 2nd and 3rd dimension
>>> b.size()
torch.Size([1, 3, 2, 4])
>>> c = a.view(1, 3, 2, 4)  # Does not change tensor layout in memory
>>> c.size()
torch.Size([1, 3, 2, 4])
>>> torch.equal(b, c)
False

view(dtype) → Tensor

返回一个新的张量，该张量与 self 张量具有相同的数据，但具有不同的 dtype。

如果 dtype 的元素大小不同于 self.dtype，则输出的最后一个维度的尺寸将按比例缩放。例如，如果 dtype 的元素大小是 self.dtype 的两倍，则 self 的最后一个维度的每对元素将合并，并且输出的最后一个维度的尺寸将是 self 的一半。如果 dtype 的元素大小是 self.dtype 的一半，则 self 的最后一个维度的每个元素将被分成两个，并且输出的最后一个维度的尺寸将是 self 的两倍。为了使这成为可能，以下条件必须为真

• self.dim() 必须大于 0。

• self.stride(-1) 必须为 1。

此外，如果 dtype 的元素大小大于 self.dtype，则以下条件也必须为真

• self.size(-1) 必须可被数据类型元素大小之比整除。

• self.storage_offset() 必须可被数据类型元素大小之比整除。

• 除了最后一个维度之外，所有维度的步幅必须可被数据类型元素大小之比整除。

如果上述任何条件不满足，则会抛出错误。

警告

TorchScript 不支持此重载，在 Torchscript 程序中使用它会导致未定义的行为。

参数:

dtype (torch.dtype) – 期望的 dtype

示例

>>> x = torch.randn(4, 4)
>>> x
tensor([[ 0.9482, -0.0310,  1.4999, -0.5316],
        [-0.1520,  0.7472,  0.5617, -0.8649],
        [-2.4724, -0.0334, -0.2976, -0.8499],
        [-0.2109,  1.9913, -0.9607, -0.6123]])
>>> x.dtype
torch.float32

>>> y = x.view(torch.int32)
>>> y
tensor([[ 1064483442, -1124191867,  1069546515, -1089989247],
        [-1105482831,  1061112040,  1057999968, -1084397505],
        [-1071760287, -1123489973, -1097310419, -1084649136],
        [-1101533110,  1073668768, -1082790149, -1088634448]],
    dtype=torch.int32)
>>> y[0, 0] = 1000000000
>>> x
tensor([[ 0.0047, -0.0310,  1.4999, -0.5316],
        [-0.1520,  0.7472,  0.5617, -0.8649],
        [-2.4724, -0.0334, -0.2976, -0.8499],
        [-0.2109,  1.9913, -0.9607, -0.6123]])

>>> x.view(torch.cfloat)
tensor([[ 0.0047-0.0310j,  1.4999-0.5316j],
        [-0.1520+0.7472j,  0.5617-0.8649j],
        [-2.4724-0.0334j, -0.2976-0.8499j],
        [-0.2109+1.9913j, -0.9607-0.6123j]])
>>> x.view(torch.cfloat).size()
torch.Size([4, 2])

>>> x.view(torch.uint8)
tensor([[  0, 202, 154,  59, 182, 243, 253, 188, 185, 252, 191,  63, 240,  22,
           8, 191],
        [227, 165,  27, 190, 128,  72,  63,  63, 146, 203,  15,  63,  22, 106,
          93, 191],
        [205,  59,  30, 192, 112, 206,   8, 189,   7,  95, 152, 190,  12, 147,
          89, 191],
        [ 43, 246,  87, 190, 235, 226, 254,  63, 111, 240, 117, 191, 177, 191,
          28, 191]], dtype=torch.uint8)
>>> x.view(torch.uint8).size()
torch.Size([4, 16])

view_as(other) → Tensor

将此张量视为与 other 相同的大小。 self.view_as(other) 等效于 self.view(other.size())。

有关 view 的更多信息，请参阅 view()。

参数:

other (torch.Tensor) – 结果张量的大小与 other 相同。

vsplit(split_size_or_sections) → List of Tensors

请参阅 torch.vsplit()

where(condition, y) → Tensor

self.where(condition, y) 等效于 torch.where(condition, self, y)。请参阅 torch.where()

xlogy(other) → Tensor

请参阅 torch.xlogy()

xlogy_(other) → Tensor

xlogy() 的就地版本

xpu(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

返回此对象在 XPU 内存中的副本。

如果此对象已在 XPU 内存中并且位于正确的设备上，则不会执行任何复制操作，并且将返回原始对象。

参数:

• device (torch.device) – 目标 XPU 设备。默认为当前 XPU 设备。

• non_blocking (bool) – 如果为 True 且源在固定内存中，则复制将相对于主机是异步的。否则，参数无效。默认值：False。

• memory_format (torch.memory_format, 可选) – 返回的张量的所需内存格式。默认值：torch.preserve_format。

zero_() → Tensor

用零填充 self 数组。

classmethod zeros(*size, dtype=None, device=None, filename=None)

classmethod zeros(shape, *, dtype=None, device=None, filename=None)

创建一个内容为 0、形状、数据类型和文件名特定的数组。

参数:

shape (整数 或 torch.Size) – 张量的形状。

关键字参数：

• dtype (torch.dtype) – 张量的类型。

• device (torch.device) – 张量的设备。仅接受 None 和 “cpu”，任何其他设备都会引发异常。

• filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。

• existsok (bool, 可选) – 是否允许覆盖现有文件。默认为 False。

classmethod zeros_like(input, *, filename=None)

创建一个内容为 0、但形状和数据类型与输入数组相同的数组。

参数:

input (torch.Tensor) – 用作示例的张量。

关键字参数：

filename (路径 或 等效物) – 文件的路径（如果存在）。如果没有提供，则使用处理程序。