SciPy：将1/0稀疏矩阵转换为0/1稀疏矩阵

Question

What is the fastest way to convert 1/0 sparse matrix to 0/1 sparse matrix without using todense() method?

Example:

Source matrix looks like:

matrix([[1, 1, 0, 0, 0, 0, 0, 0, 1, 1],
        [1, 1, 0, 0, 1, 1, 1, 1, 0, 1],
        [0, 0, 1, 1, 1, 0, 1, 0, 0, 1],
        [1, 0, 0, 1, 1, 1, 0, 1, 0, 0],
        [1, 1, 0, 0, 1, 1, 0, 0, 0, 0]])

Result matrix is:

matrix([[0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
        [0, 0, 1, 1, 0, 0, 0, 0, 1, 0],
        [1, 1, 0, 0, 0, 1, 0, 1, 1, 0],
        [0, 1, 1, 0, 0, 0, 1, 0, 1, 1],
        [0, 0, 1, 1, 0, 0, 1, 1, 1, 1]])

The source matrix is too large, so I can use only sparse representation of matrixes.

Answer 1

DSM is correct. There are many representations of sparse matrices, but if you use dictionary format, then you need 3 numbers to represent one element (row, col, value). Thus you need 3*np memory ( np is the number of nonzeros). If use a dense format, then you need n*m memory. Therefore, sparse representation is useful only when np/(n*m) < 3 for this case, which means the sparsity is less than 1/3 .

On the other hand, if you flip your 1 s and 0 s, then the sparsity will be one minus the original one. Thus, if the original matrix is sparse, then there is no way that your flipped matrix is sparse.

If you only need 1 s and 0 s in your matrix then I would recommend writing your own representation of the compressed sparse matrix. For example, you can read your matrix from top-left, row-wise, and if there are any consecutive 1 s or 0 s, then you can do something like 1 3 0 2 1 0 1 4 , which means "three consecutive 1 s, two consecutive 0 s, 1 , 0 , four consecutive 1 s". Depending on your use of your matrix, my suggestion may be useless, but it is worth thinking about it.

Answer 2

Sorry to spam, but on the second thought, if the matrix only has 1s and 0s, then you can use one int32 number to represent 32 elements (matrix needs to be dense). Then flipping 1s and 0s is just a bit manipulation and shouldn't be hard. This will make the size of matrix to 1/32 and also the operation should be roughly 32 times faster.