torch.sparse_coo_tensor

torch.sparse_coo_tensor(indices, values, size=None, *, dtype=None, device=None, pin_memory=False, requires_grad=False, check_invariants=None, is_coalesced=None)) → Tensor

在给定的 索引 处，使用指定的值构建一个COO（坐标）格式的稀疏张量。

注意

当 is_coalesced 未指定或为 None 时，此函数返回一个未合并张量。

注意

如果没有指定 device 参数，那么给定的 values 和索引张量必须具有相同的设备。如果指定了参数，则输入张量会被转换到指定的设备，并且会确定构造出来的稀疏张量的设备。

参数

indices (array_like) – 张量的初始数据，可以是列表、元组、NumPy ndarray 或标量等。内部将被转换为torch.LongTensor。这些索引表示矩阵中非零值的位置坐标，因此它们应该是二维数组，其中第一维代表张量的维度数量，第二维则表示非零值的数量。
values (array_like) – 张量的初始值，可以是列表、元组、NumPy ndarray、标量或其他类型。
size (列表、元组或torch.Size) – 稀疏张量的大小。如果没有提供，则会推断出一个最小尺寸，以确保能够容纳所有非零元素。

关键字参数

dtype (torch.dtype, 可选) – 返回的张量的数据类型。默认情况下，如果为 None，则根据 values 推断数据类型。
device (torch.device, 可选) – 返回张量所需的设备。默认情况下，如果未指定设备，则使用当前的默认张量类型设备（参见 torch.set_default_device())。对于 CPU 张量类型，默认设备为 CPU；对于 CUDA 张量类型，默认设备为当前的 CUDA 设备。
pin_memory (bool, 可选) – 如果启用，返回的张量将在固定内存中分配。仅适用于 CPU 张量。默认值： False。
requires_grad (bool, optional) – 是否启用自动求导记录返回的张量上的操作。默认值：False。
check_invariants (bool, optional) – 是否检查稀疏张量的不变性。默认值由 torch.sparse.check_sparse_tensor_invariants.is_enabled() 返回，初始为 False。
is_coalesced (bool, optional) – 当为``True``时，调用者负责提供与合并后的张量对应的张量索引。如果check_invariants标志为False，则即使不满足先决条件也不会引发错误，并且这将导致静默的错误结果。为了强制合并，请在生成的Tensor上使用coalesce()方法。默认情况下，对于平凡情况（例如nnz < 2），生成的张量is_coalesced设置为False。

示例：

>>> i = torch.tensor([[0, 1, 1],
...                   [2, 0, 2]])
>>> v = torch.tensor([3, 4, 5], dtype=torch.float32)
>>> torch.sparse_coo_tensor(i, v, [2, 4])
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3., 4., 5.]),
       size=(2, 4), nnz=3, layout=torch.sparse_coo)

>>> torch.sparse_coo_tensor(i, v)  # Shape inference
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3., 4., 5.]),
       size=(2, 3), nnz=3, layout=torch.sparse_coo)

>>> torch.sparse_coo_tensor(i, v, [2, 4],
...                         dtype=torch.float64,
...                         device=torch.device('cuda:0'))
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3., 4., 5.]),
       device='cuda:0', size=(2, 4), nnz=3, dtype=torch.float64,
       layout=torch.sparse_coo)

# Create an empty sparse tensor with the following invariants:
#   1. sparse_dim + dense_dim = len(SparseTensor.shape)
#   2. SparseTensor._indices().shape = (sparse_dim, nnz)
#   3. SparseTensor._values().shape = (nnz, SparseTensor.shape[sparse_dim:])
#
# For instance, to create an empty sparse tensor with nnz = 0, dense_dim = 0 and
# sparse_dim = 1 (hence indices is a 2D tensor of shape = (1, 0))
>>> S = torch.sparse_coo_tensor(torch.empty([1, 0]), [], [1])
tensor(indices=tensor([], size=(1, 0)),
       values=tensor([], size=(0,)),
       size=(1,), nnz=0, layout=torch.sparse_coo)

# and to create an empty sparse tensor with nnz = 0, dense_dim = 1 and
# sparse_dim = 1
>>> S = torch.sparse_coo_tensor(torch.empty([1, 0]), torch.empty([0, 2]), [1, 2])
tensor(indices=tensor([], size=(1, 0)),
       values=tensor([], size=(0, 2)),
       size=(1, 2), nnz=0, layout=torch.sparse_coo)