Scipy: aclaraciones básicas.

No soy indiferente la diferencia entre coo_matrix , csr_matrix y csc_matrix .

La documentación menciona que coo_matrix no es eficiente para operaciones aritméticas y debemos convertirlo a csr o csc . Estoy buscando más en la multiplicación de matrices. Y no entendí lo que está sucediendo tras bambalinas si solo tengo un coo_matrix y lo convierto a csr o csv matrix.

También si tengo algo como

 A = array([[1,2,3,0,0,5], [5,0,0,1,2,0]]) print coo_matrix(A) 

Se imprime

  (0, 0) 1 (0, 1) 2 (0, 2) 3 (0, 5) 5 

que es genial pero hay una manera, puedo ingresar directamente mi matriz como la que está impresa. Algo así como definir una matriz de COO nula y luego comenzar a definir los valores de coo_matrix como lo hacemos en matlab.

¡Gracias!

Una matriz dispersa contiene principalmente ceros. coo_matrix , csr_matrix y csc_matrix son todas clases de matriz dispersa. El coo_matrix es una lista de fila, columna, valor. Este tipo de matriz dispersa es ineficiente para la aritmética porque si tienes una matriz grande con muchos ceros, no querrás hacer cálculos matemáticos con todos esos ceros. Solo desea hacer cálculos matemáticos en los valores distintos de cero en su matriz dispersa. El csr_matrix y csc_matrix son soluciones a este problema. En lugar de enumerar todos los valores de la matriz dispersa, csr y csc son en realidad tres matrices 1-D que tienen un valor distinto de cero, un índice de columna y un puntero de fila (para csr ) que indica dónde está el valor distinto de cero Dentro de la matriz dispersa. No quiero volver a escribir el libro de texto, así que aquí hay más información y un ejemplo .

Para responder a su segunda pregunta. Quieres usar scipy.sparse.dok_matrix . Este es un diccionario de claves basadas en matriz dispersa. Puede editarlo al estilo MATLAB y luego convertirlo a csr o csc para la aritmética. Aquí hay un ejemplo simple de editar uno dinámicamente:

 >>> A = scipy.sparse.dok_matrix((5,5)) >>> A[2,3] = 7 >>> print A (2, 3) 7.0 

La terminología no está inventada por Python Scipy, pero ya existía en la ciencia de representación de matriz dispersa.

Existen varios formatos en los que se pueden representar matrices dispersas.
Los formatos se pueden dividir en dos grupos:

  1. Aquellos que admiten una modificación eficiente, como DOK (Diccionario de claves), LIL (Lista de listas) o COO (Lista de coordenadas). Estos se utilizan normalmente para construir las matrices.
  2. Aquellas que admiten operaciones de acceso y matriz eficientes, como CSR (Compressed Sparse Row) o CSC (Compressed Sparse Column).

Lista de coordenadas (COO)

COO almacena una lista de tuplas (fila, columna, valor). Idealmente, las entradas se ordenan (por índice de fila, luego por índice de columna) para mejorar los tiempos de acceso aleatorio. Este es otro formato que es bueno para la construcción de matriz incremental.

Fila dispersa comprimida (CSR)

El formato comprimido de fila dispersa (CSR) o almacenamiento comprimido de fila (CRS) representa una matriz M mediante tres matrices (unidimensionales), que respectivamente contienen valores distintos de cero, la extensión de las filas y los índices de columna. Este formato permite un acceso rápido a las filas y multiplicaciones de matrices-vector.

El formato CSR almacena una matriz M × n dispersa en forma de fila utilizando tres matrices (unidimensionales) (A, IA, JA). Sea NNZ el número de entradas distintas de cero en M. (Tenga en cuenta que los índices basados ​​en cero se usarán aquí).

La matriz A es de longitud NNZ y contiene todas las entradas distintas de cero de M en orden de izquierda a derecha de arriba a abajo (“fila-mayor”).

  1. La matriz IA es de longitud m + 1. Está definida por esta definición recursiva:
    IA [0] = 0
    IA [i] = IA [i – 1] + (número de elementos distintos de cero en la fila (i – 1) en la matriz original)

De este modo, los primeros m elementos de IA almacenan el índice en A del primer elemento distinto de cero en cada fila de M, y el último elemento IA [m] almacena NNZ, el número de elementos en A, que también puede considerarse como el índice en A del primer elemento de una fila fantasma más allá del final de la matriz M.
Los valores de la fila i-th de la matriz original se leen de los elementos A [IA [i]] a A [IA [i + 1] – 1] (inclusive en ambos extremos), es decir, desde el comienzo de una fila hasta el último índice justo antes del inicio del siguiente.

La tercera matriz, JA, contiene el índice de columna en M de cada elemento de A y, por lo tanto, también tiene una longitud NNZ.

Por ejemplo, la matriz 0 0 0 0
5 8 0 0
0 0 3 0
0 6 0 0

es una matriz de 4 × 4 con 4 elementos distintos de cero, por lo tanto

A = [5 8 3 6]
IA = [0 0 2 3 4]
JA = [0 1 2 1]

Fuente: https://en.wikipedia.org/wiki/Sparse_matrix

Creo que estás buscando algo como esto:

 row = np.array([0,0,0,0]) col = np.array([0,1,2,5]) data = np.array([1,2,3,5]) coo_matrix((data,(row,col))).todense() 

Lo que da:

 matrix([[1, 2, 3, 0, 0, 5]]) 

Aquí está el enlace de la documentación Scipy.

csr_matrix considera la primera fila y csc_matrix considera la primera columna.

Aquí hay un ejemplo simple para ilustrar eso: Tomemos una matriz,

 mat = [[1, 0, 0], [5, 0, 2], [0, -1, 0], [0, 0, 3]] 

csr_matrix da la posición del elemento distinto de cero en la fila primero, luego pasa a la segunda fila, luego a la tercera y así sucesivamente. por ejemplo, csr_matrix (mat) devuelve:

 (0, 0) 1.0 -- first row (1, 0) 5.0 -- second row (1, 2) 2.0 -- second row (2, 1) -1.0 --third row (3, 2) 3.0 -- fourth row 

De manera similar, csc_matrix da la posición de elementos distintos de cero en la primera columna, luego en la segunda columna, y así sucesivamente.

 (0, 0) 1.0 -- first column (1, 0) 5.0 -- first column (2, 1) -1.0 -- second column (1, 2) 2.0 -- third column (3, 2) 3.0 -- third column