2

我有一个表示稀疏 3-D 矩阵的压缩格式的张量。我需要将其转换为普通矩阵（它实际代表的矩阵）。因此，就我而言，矩阵的任何二维切片的每一行都只能包含一个非零元素。那么，作为数据，我对这些行中的每一行、值和它出现的索引都有。例如，张量

inp = torch.tensor([[ 1,  2],
 [ 3,  4],
 [-1,  0],
 [45,  1]])

表示一个 4x5 矩阵（第一维来自张量的第一维，第二维来自元数据）A，其中A[0][2] = 1, A[1][4] = 3, A[2][0] = -1, A[3][1] = 45.

这只是我的矩阵的一个二维切片，我有可变数量的这些。我能够使用 sparse_coo_tensor 以下列方式对上述二维切片执行此操作：

>>> torch.sparse_coo_tensor(torch.stack([torch.arange(0, 4), inp.t()[1]]), inp.t()[0], [4,5]).to_dense()
tensor([[ 0,  0,  1,  0,  0],
        [ 0,  0,  0,  0,  3],
        [-1,  0,  0,  0,  0],
        [ 0, 45,  0,  0,  0]])

这是实现这一目标的最佳方法吗？有没有更简单、更易读的替代方案？如何在不循环的情况下将其扩展到 3-D 矩阵？对于 3-D 矩阵，您可以想象输入类似于

inp_list = torch.stack([inp, inp, inp, inp])

并且所需的输出将是上述输出堆叠 4 次。

我觉得如果我正确地创建了一个索引数组，我应该能够做一些事情，但是如果不使用某种循环，我想不出一种方法来做到这一点。

4

2 回答 2

1

好的，在对不同类型的索引进行了大量实验之后，我得到了这个工作。事实证明，答案在高级索引中。不幸的是，PyTorch 文档没有详细介绍高级索引。这是 Numpy 文档中的链接。

对于上述问题，此命令可以解决问题：

>>> k_lst = torch.zeros([4,4,5])
>>> k_lst[torch.arange(4).unsqueeze(1), torch.arange(4), inp_list[:,:,1]] = inp_list[:,:,0].float()
>>> k_lst
tensor([[[ 0.,  0.,  1.,  0.,  0.],
     [ 0.,  0.,  0.,  0.,  3.],
     [-1.,  0.,  0.,  0.,  0.],
     [ 0., 45.,  0.,  0.,  0.]],
    [[ 0.,  0.,  1.,  0.,  0.],
     [ 0.,  0.,  0.,  0.,  3.],
     [-1.,  0.,  0.,  0.,  0.],
     [ 0., 45.,  0.,  0.,  0.]],
    [[ 0.,  0.,  1.,  0.,  0.],
     [ 0.,  0.,  0.,  0.,  3.],
     [-1.,  0.,  0.,  0.,  0.],
     [ 0., 45.,  0.,  0.,  0.]],
    [[ 0.,  0.,  1.,  0.,  0.],
     [ 0.,  0.,  0.,  0.,  3.],
     [-1.,  0.,  0.,  0.,  0.],
     [ 0., 45.,  0.,  0.,  0.]]])

这正是我想要的。

我在搜索这个问题时学到了很多东西，我想与任何偶然发现这个问题的人分享。那么，为什么会这样呢？答案在于广播的工作方式。如果您查看所涉及的不同索引张量的形状，您会发现它们（必然）是可广播的。

>>> torch.arange(4).unsqueeze(1).shape, torch.arange(4).shape, inp_list[:,:,1].shape
(torch.Size([4, 1]), torch.Size([4]), torch.Size([4, 4]))

显然，要访问 3-D 张量的元素，例如此处的 k_lst，我们需要 3 个索引 - 每个维度一个。如果给[]算子提供 3 个形状相同的张量，它可以通过匹配这 3 个张量中的对应元素，得到一堆合法的索引。

如果 3 个张量具有不同的形状，但可广播（如这里的情况），它会复制缺少张量的相关行/列所需的次数，以获得具有相同形状的张量。

最终，在我的情况下，如果我们研究如何分配不同的值，这相当于做

k_lst[0,0,inp_list[0,0,1]] = inp_list[0,0,0].float()
k_lst[0,1,inp_list[0,1,1]] = inp_list[0,1,0].float()
k_lst[0,2,inp_list[0,2,1]] = inp_list[0,2,0].float()
k_lst[0,3,inp_list[0,3,1]] = inp_list[0,3,0].float()
k_lst[1,0,inp_list[1,0,1]] = inp_list[1,0,0].float()
k_lst[1,1,inp_list[1,1,1]] = inp_list[1,1,0].float()
.
.
.
k_lst[3,3,inp_list[3,3,1]] = inp_list[3,3,0].float()

这种格式让我想起了torch.Tensor.scatter()，但是如果它可以用来解决这个问题，我还没有弄清楚如何。

于 2020-07-18T21:05:42.147 回答
0

我相信你所说的是你有一个稀疏的张量并想要转换它。从tf.sparse.to_dense开始，然后使用tensorflow.Tensor.eval()

于 2020-07-17T21:52:52.397 回答