Question

我有一个稀疏矩阵的行信息的Python列表。每行表示为（列，值）元组的列表。称之为alist：

alist = [[(1,10), (3,-3)],
         [(2,12)]]

如何从这个列表列表中有效地构造一个scipy稀疏矩阵，得到如下矩阵：

0  10   0  -3
0   0  12   0

显而易见的方法是创建一个scipy.sparse.lil_matrix，其内部具有此“列表列表”结构。但是从scipy.sparse.lil_matrix — SciPy v0.19.0 Reference Guide我只看到了构建它们的三种方法：

从密集阵列开始
从另一个稀疏数组开始
只是构建一个空数组

因此，获取新数据的唯一方法是使用其他稀疏矩阵表示来解决此问题，或者从密集数组开始，这两者都不能解决最初的问题，而且两者似乎都可能更少此数据的有效表示形式比lil_matrix本身有效。

我想我可以制作一个空的，并使用循环来添加值，但我肯定错过了一些东西。

scipy文档在稀疏矩阵方面非常令人沮丧。

Answer 1

您的数据布局不常见。这是我第一次使用它。

In [565]: M = sparse.lil_matrix((2,4), dtype=int)
In [566]: M
Out[566]: 
<2x4 sparse matrix of type '<class 'numpy.int32'>'
    with 0 stored elements in LInked List format>
In [567]: for i,row in enumerate(alist):
     ...:     for col in row:
     ...:         M[i, col[0]] = col[1]
     ...:         
In [568]: M
Out[568]: 
<2x4 sparse matrix of type '<class 'numpy.int32'>'
    with 3 stored elements in LInked List format>
In [569]: M.A
Out[569]: 
array([[ 0, 10,  0, -3],
       [ 0,  0, 12,  0]])

是的，它是迭代的;并且lil是用于此目的的最佳格式。

或使用常见的coo输入方式：

In [580]: data,col,row = [],[],[]
In [581]: for i, rr in enumerate(alist):
     ...:     for cc in rr:
     ...:         row.append(i)
     ...:         col.append(cc[0])
     ...:         data.append(cc[1])
     ...:         
In [582]: data,col,row
Out[582]: ([10, -3, 12], [1, 3, 2], [0, 0, 1])
In [583]: M1=sparse.coo_matrix((data,(row,col)),shape=(2,4))
In [584]: M1
Out[584]: 
<2x4 sparse matrix of type '<class 'numpy.int32'>'
    with 3 stored elements in COOrdinate format>
In [585]: M1.A
Out[585]: 
array([[ 0, 10,  0, -3],
       [ 0,  0, 12,  0]])

另一种选择是创建空白lil矩阵，并直接填写其属性：

换句话说，从：

开始

In [591]: m.data
Out[591]: array([[], []], dtype=object)
In [592]: m.rows
Out[592]: array([[], []], dtype=object)

并将其更改为：

In [587]: M.data
Out[587]: array([[10, -3], [12]], dtype=object)
In [588]: M.rows
Out[588]: array([[1, 3], [2]], dtype=object)

它仍然需要在alist结构上进行2级迭代。

In [593]: for i, rr in enumerate(alist):
     ...:     for cc in rr:
     ...:         m.rows[i].append(cc[0])
     ...:         m.data[i].append(cc[1])       
In [594]: m
Out[594]: 
<2x4 sparse matrix of type '<class 'numpy.int32'>'
    with 3 stored elements in LInked List format>
In [595]: m.A
Out[595]: 
array([[ 0, 10,  0, -3],
       [ 0,  0, 12,  0]])

在另一条评论中，您提到了理解csr indptr的难度。最简单的方法是转换这些格式：

In [597]: Mr=M.tocsr()
In [598]: Mr.indptr
Out[598]: array([0, 2, 3], dtype=int32)
In [599]: Mr.data
Out[599]: array([10, -3, 12])
In [600]: Mr.indices
Out[600]: array([1, 3, 2], dtype=int32)

Answer 2

如果在创建稀疏矩阵之前拥有整个num_bins = 2 b = fromarray(a.astype(np.uint8)//num_bins) # convert to a PIL image, binned hist = {idx*num_bins:count for idx, count in enumerate(b.histogram()) if count}，则无需使用alist，因为它已针对增量更新稀疏矩阵进行了优化。

如果您想对矩阵后缀进行任何算术运算，lil_matrix可能是您的最佳选择。您可以使用csr_matrix格式直接构建csr_matrix，如下所示：

(data, (row, column))

如果效率是一个真正的问题，您可以直接创建In [40]: alist = [[(1,10), (3,-3)], ...: [(2,12)]] In [41]: i, j, data = zip(*((i, t[0], t[1]) for i, row in enumerate(alist) for t in row)) In [42]: (i, j, data) Out[42]: ((0, 0, 1), (1, 3, 2), (10, -3, 12)) In [43]: csr_matrix((data, (i, j)), shape=(2, 4)).todense() Out[43]: matrix([[ 0, 10, 0, -3], [ 0, 0, 12, 0]], dtype=int64)内部格式（使用indptr）：

csr_matrix

如果您要转换为熊猫后记，则In [57]: indptr = np.cumsum([0] + [len(row) for row in alist]) In [58]: j, data = zip(*(t for row in alist for t in row)) In [59]: csr_matrix((data, j, indptr), shape=(2, 4)).todense() Out[59]: matrix([[ 0, 10, 0, -3], [ 0, 0, 12, 0]])是可行的方法，因为熊猫还是会转换为coo_matrix：

coo_matrix

Answer 3

您可以从（列，值）元组dict的列表中创建位置和值的alist，然后使用dok_matrix构造稀疏矩阵

>>> d = {(i,j):v for i,l in enumerate(alist) for j,v in l}
>>> d
{(0, 1): 10, (0, 3): -3, (1, 2): 12}
>>> 
>>> from operator import itemgetter
>>> m = max(d.keys(), key=itemgetter(0))[0] + 1
>>> n = max(d.keys(), key=itemgetter(1))[1] + 1
>>> m,n
(2, 4)
>>>
>>> from scipy.sparse import dok_matrix
>>> S = dok_matrix((m,n), dtype=int)
>>> for pos,v in d.items():
...     S[pos] = v
... 
>>> S.todense()
matrix([[ 0, 10,  0, -3],
        [ 0,  0, 12,  0]])
>>>

Answer 4

只想使用coo_matrix发布另一个答案，这是一种构造稀疏矩阵的快速格式。

>>> alist = [[(1, 10), (3, -3)], [(2, 12)]]
>>> row, col, data = zip(*((i,j,v) for i,l in enumerate(alist) for j,v in l))
>>>
>>> from scipy.sparse import coo_matrix
>>> S = coo_matrix((data, (row, col)), (max(row)+1,max(col)+1), dtype=np.int8)
>>> S.todense()
matrix([[ 0, 10,  0, -3],
        [ 0,  0, 12,  0]], dtype=int8)
>>>

从元组列表列表构造稀疏矩阵

4 个答案: