Estoy trabajando con algunos de los más grandes matrices dispersas (de 5000×5000 a 20000×20000) y la necesidad de encontrar una manera eficaz para concatenar matrices de una manera flexible a fin de construir una matriz estocástica de las partes por separado.

Ahora mismo estoy usando la siguiente manera para concatenar cuatro matrices, pero es terriblemente ineficiente. ¿Hay alguna manera mejor de hacerlo que no se trata de 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()
InformationsquelleAutor jones | 2011-07-27

4 Comentarios

  1. 49

    La escasa biblioteca tiene ahora hstack y vstack para, respectivamente, la concatenación de matrices horizontalmente y verticalmente.

    • Asegúrese de utilizar scipy.dispersas.hstack en lugar de numpy.hstack
  2. 14

    Bueno, he encontrado la respuesta. El uso de scipy.dispersas.coo_matrix es mucho más rápido que el uso de lil_matrix. Me he convertido las matrices a coo (sin dolor y rápido) y, a continuación, sólo se concatenan los datos, las filas y las columnas después de añadir el margen derecho.

    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]) )
    • Gracias por visitarnos y comentar sobre cómo se hizo rápidamente. Lo necesitaba para mi PNL clase.
  3. 13

    Amos respuesta es que ya no es necesario. Scipy ahora hace algo similar a esto internamente si las matrices de entrada están en la rse o csc formato y el formato de salida está establecido en ninguno o en el mismo formato que las matrices de entrada. Es eficiente a la vertical de la pila de matrices en la rse formato, o a la horizontal de la pila de matrices en csc formato, utilizando scipy.sparse.vstack o scipy.sparse.hstack, respectivamente.

    • La versión que hace de «ahora» se refieren? ¿Tiene alguna referencia de esto?
    • El código relevante es este fragmento de código de scipy.sparse.bmat, que tanto vstack y hstack uso. Este hack fue originalmente añadido aquí en 2013. Parece que fue incluido originalmente en scipy 1.0.0.
    • Gracias! Scipy 1.0.0 es todavía en el RC etapa, aunque…
    • En realidad, yo estaba equivocado acerca de eso. Se incluyó originalmente en el 0,14.
  4. 11

    Utilizando hstack, vstack, o concatenar, es considerablemente más lento que concatenar el interior de datos de los objetos en sí mismos. La razón es que hstack/vstack convierte la matriz dispersa a coo formato que puede ser muy lenta cuando la matriz es muy grande no y no en coo formato. Aquí está el código para la concatenación de csc matrices, similar método puede ser utilizado para la rse de las matrices:

    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))
    • Estaba mirando una manera rápida de agregar nuevas filas a una de RSE de la matriz. Esto es exactamente lo que necesito. Gracias @amos.
    • Si utiliza este método, es necesario especificar la forma en ‘volver csc_matrix((new_data, new_indices, new_ind_ptr))’, es decir: el regreso de csc_matrix((new_data, new_indices, new_ind_ptr), la forma=(matrix1.de la forma[1], matrix1.de la forma[1] + matrix2.de la forma[1])’
    • Cuál sería el código para la rse de las matrices? Es el nativo de scipy aplicación mucho más rápido ahora? Porque tengo para concatenar cuatro submatrices (parte superior izquierda, superior derecha,inferior izquierda,inferior derecha) y no estoy satisfecho con el resultado. Se tarda menos tiempo para volver a calcular la matriz completa a pesar de que sería sólo tiene que calcular la parte superior derecha e inferior izquierda. Así que esta lentitud básicamente a la tabulación de la inútil en mi caso. Me molesta porque creo que solamente habría que cambiar algunos de los punteros en C si tanto la matriz y la operación eran aplicado de forma óptima.
    • Aunque no estoy seguro de si el índice de punteros se almacenan en una lista en C o en una matriz. Si se tratara de una lista que usted no sólo tiene que restablecer un puntero al final de la lista? La forma en que está ahora, el más grande de la matriz, el más largo es el apilamiento…

Dejar respuesta

Please enter your comment!
Please enter your name here