没有列为零的稀疏矩阵行

Question

I have a matrix like this:

A = sp.csr_matrix(np.array(
      [[1, 1, 2, 1],
       [0, 0, 2, 0],
       [1, 4, 1, 1],
       [0, 1, 0, 0]]))

I want to get all the rows where all columns are nonzero, so I can then get their sum. Either as an array:

rows = [True, False, True, False]
result = A[rows].sum()

Or as indices:

rows = [0, 2]
result = A[rows].sum()

I am stuck however at the first part, figuring out which rows to include in the sum, as most results seem to be looking for the opposite (rows where all columns are zero).

Answer 1

It is a bit easier to do for numpy arrays than for sparse ones. If you do not mind converting to numpy as an intermediate step, you can get the right rows via

(A.toarray() != 0).all(axis=1)

to produce

array([ True, False,  True, False])

and then use it in indexing A as such:

A[(A.toarray() != 0).all(axis=1),:].sum()

returns 12

Answer 2

In [35]: from scipy import sparse
In [36]: A = sparse.csr_matrix(np.array(
    ...:       [[1, 1, 2, 1],
    ...:        [0, 0, 2, 0],
    ...:        [1, 4, 1, 1],
    ...:        [0, 1, 0, 0]]))
In [37]: A
Out[37]: 
<4x4 sparse matrix of type '<class 'numpy.int64'>'
    with 10 stored elements in Compressed Sparse Row format>

Sparse doesn't do 'all/any' kinds of operations because they treat 0's as significant values.

all on the dense equivalent works nicely:

In [41]: A.A.all(axis=1)
Out[41]: array([ True, False,  True, False])

On the sparse one we can turn the dtype to boolean, and sum along the axis. And then test it for the full value:

In [42]: A.astype(bool).sum(axis=1)
Out[42]: 
matrix([[4],
        [1],
        [4],
        [1]])
In [43]: A.astype(bool).sum(axis=1).A1==4
Out[43]: array([ True, False,  True, False])

Notice that the sparse sum returns a np.matrix . I used A1 to turn that into a 1d array.

If the matrix isn't too large, working with the dense array may be faster. Sparse operations like sum are actually performed with matrix multiplication.

In [51]: A.astype(bool)@np.ones(4,int)
Out[51]: array([4, 1, 4, 1])

Or we could convert it to lil format, and look at the length of the 'rows':

In [67]: A.tolil().data
Out[67]: 
array([list([1, 1, 2, 1]), list([2]), list([1, 4, 1, 1]), list([1])],
      dtype=object)
In [68]: [len(i) for i in A.tolil().data]
Out[68]: [4, 1, 4, 1]

But wait, there's more. The indptr attribute of the csr is:

In [69]: A.indptr
Out[69]: array([ 0,  4,  5,  9, 10], dtype=int32)
In [70]: np.diff(A.indptr)
Out[70]: array([4, 1, 4, 1], dtype=int32)

I've omitted some test timings, but this last is clearly the fastest!