¿Hay una manera eficiente de concatenar matrices scipy.sparse?

Question

Estoy trabajando con matrices dispersas bastante grandes (de 5000x5000 a 20000x20000) y necesito encontrar una forma eficiente de concatenar matrices de forma flexible para construir una matriz estocástica a partir de partes separadas.

En este momento estoy usando la siguiente forma para concatenar cuatro matrices, pero es terriblemente ineficiente. ¿Hay alguna forma mejor de hacer esto que no implique convertir a una matriz densa?

rmat[0:m1.shape[0],0:m1.shape[1]] = m1 
rmat[m1.shape[0]:rmat.shape[0],m1.shape[1]:rmat.shape[1]] = m2 
rmat[0:m1.shape[0],m1.shape[1]:rmat.shape[1]] = bridge 
rmat[m1.shape[0]:rmat.shape[0],0:m1.shape[1]] = bridge.transpose() 

Answer 1

Bien, encontré la respuesta. Usar scipy.sparse.coo_matrix es mucho más rápido que usar lil_matrix. Convertí las matrices en coo (indoloras y rápidas) y luego concatenamos los datos, filas y columnas después de agregar el relleno correcto.

data = scipy.concatenate((m1S.data,bridgeS.data,bridgeTS.data,m2S.data)) 
rows = scipy.concatenate((m1S.row,bridgeS.row,bridgeTS.row + m1S.shape[0],m2S.row + m1S.shape[0])) 
cols = scipy.concatenate((m1S.col,bridgeS.col+ m1S.shape[1],bridgeTS.col ,m2S.col + m1S.shape[1])) 

scipy.sparse.coo_matrix((data,(rows,cols)),shape=(m1S.shape[0]+m2S.shape[0],m1S.shape[1]+m2S.shape[1])) 

Answer 2

La biblioteca escaso ahora tiene hstack y vstack para concatenar respectivamente matrices horizontal y verticalmente.

Answer 3

Usar hstack, vstack o concatenar es mucho más lento que concatenar los objetos de datos internos. La razón es que hstack/vstack convierte la matriz dispersa en formato coo, que puede ser muy lenta cuando la matriz es muy grande y no está en formato coo. Aquí está el código para la concatenación de matrices csc, método similar se puede utilizar para matrices RSE:

def concatenate_csc_matrices_by_columns(matrix1, matrix2): 
    new_data = np.concatenate((matrix1.data, matrix2.data)) 
    new_indices = np.concatenate((matrix1.indices, matrix2.indices)) 
    new_ind_ptr = matrix2.indptr + len(matrix1.data) 
    new_ind_ptr = new_ind_ptr[1:] 
    new_ind_ptr = np.concatenate((matrix1.indptr, new_ind_ptr)) 

    return csc_matrix((new_data, new_indices, new_ind_ptr)) 

Answer 4

respuesta de Amos ya no es necesario. Ahora, Scipy hace algo similar a esto internamente si las matrices de entrada están en formato csr o csc y ​​el formato de salida deseado está configurado en ninguno o en el mismo formato que las matrices de entrada. Es eficiente para apilar verticalmente matrices en formato RSE, o horizontalmente matrices pila en formato csc, utilizando scipy.sparse.vstack o scipy.sparse.hstack, respectivamente.