Geek asks and answers

Reorder sparse arrays by replacing rows and columns

I have large but rare arrays, and I want to change them by replacing rows with columns. What is a good way to do this in scipy.sparse?

Some problems

  • I do not think that permutation matrices are well suited for this task, since they randomly change the structure of sparseness. And the manipulation will always “propagate” all columns or rows, even if only a few swaps are required.

  • What is the best allowed matrix representation in scipy.sparsefor this task?

  • Implementation suggestions are very welcome.

I also noted this with Matlab, as this question may find an answer that does not necessarily matter scipy.

+5
source share
2 answers

The CSC format stores a list of row indexes of all nonzero entries, the CSR format stores a list of column indices of all nonzero entries. I think you can take advantage of this to exchange things as follows, and I think there should be no side effects:

def swap_rows(mat, a, b) :
    mat_csc = scipy.sparse.csc_matrix(mat)
    a_idx = np.where(mat_csc.indices == a)
    b_idx = np.where(mat_csc.indices == b)
    mat_csc.indices[a_idx] = b
    mat_csc.indices[b_idx] = a
    return mat_csc.asformat(mat.format)

def swap_cols(mat, a, b) :
    mat_csr = scipy.sparse.csr_matrix(mat)
    a_idx = np.where(mat_csr.indices == a)
    b_idx = np.where(mat_csr.indices == b)
    mat_csr.indices[a_idx] = b
    mat_csr.indices[b_idx] = a
    return mat_csr.asformat(mat.format)

Now you can do something like this:

>>> mat = np.zeros((5,5))
>>> mat[[1, 2, 3, 3], [0, 2, 2, 4]] = 1
>>> mat = scipy.sparse.lil_matrix(mat)
>>> mat.todense()
matrix([[ 0.,  0.,  0.,  0.,  0.],
        [ 1.,  0.,  0.,  0.,  0.],
        [ 0.,  0.,  1.,  0.,  0.],
        [ 0.,  0.,  1.,  0.,  1.],
        [ 0.,  0.,  0.,  0.,  0.]])
>>> swap_rows(mat, 1, 3)
<5x5 sparse matrix of type '<type 'numpy.float64'>'
    with 4 stored elements in LInked List format>
>>> swap_rows(mat, 1, 3).todense()
matrix([[ 0.,  0.,  0.,  0.,  0.],
        [ 0.,  0.,  1.,  0.,  1.],
        [ 0.,  0.,  1.,  0.,  0.],
        [ 1.,  0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.,  0.]])
>>> swap_cols(mat, 0, 4)
<5x5 sparse matrix of type '<type 'numpy.float64'>'
    with 4 stored elements in LInked List format>
>>> swap_cols(mat, 0, 4).todense()
matrix([[ 0.,  0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.,  1.],
        [ 0.,  0.,  1.,  0.,  0.],
        [ 1.,  0.,  1.,  0.,  0.],
        [ 0.,  0.,  0.,  0.,  0.]])

I used the LIL matrix to show how you can save the type of your output. In your application, you probably want it to be in CSC or CSR format already, and choose whether to first change the rows or columns on it to minimize conversions.

+4
source

In Matlab, you can simply index columns and rows as you like:

Matrix = speye(10);
mycolumnorder = [1 2 3 4 5 6 10 9 8 7];
myroworder = [4 3 2 1 5 6 7 8 9 10];
Myorderedmatrix = Matrix(myroworder,mycolumnorder);

I think that this remains limited ... I do not know what scipy is, though ...

0
source

More articles:


All Articles