Matriz dispersa en Python

1. ¿Qué es una matriz dispersa en Python?
2. Cómo crear matrices dispersas en Python
3. Convierta una matriz normal en una matriz dispersa usando el módulo SciPy en Python
4. Matriz de columna dispersa comprimida en Python
5. Matriz dispersa en formato de coordenadas en Python
6. Diccionario de matriz dispersa basada en claves en Python
7. Conclusión

Al implementar algoritmos de aprendizaje automático en Python, a menudo necesitamos representar los datos de entrada en un formato que requiere menos memoria.

Normalmente, los datos de entrada proporcionados a los algoritmos de aprendizaje automático se representan en forma de matriz. Este artículo discutirá el uso de la matriz dispersa para almacenar datos en Python.

Para ello, aprenderemos diferentes representaciones de la matriz dispersa en Python. También veremos cómo convertir una matriz simple a una representación dispersa usando las funciones definidas en el módulo scipy en Python.

¿Qué es una matriz dispersa en Python?

Una matriz dispersa es una matriz cuyos elementos en su mayoría son 0. Es decir, la matriz contiene datos solo en algunas ubicaciones.

Un ejemplo de matriz dispersa es el siguiente.

[[16, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 5], [0, 0, 0, 0]]

Aquí puede ver que la mayoría de los elementos de la matriz son 0.

Las matrices dispersas se utilizan ampliamente en el procesamiento del lenguaje natural y la codificación de datos. Si la mayoría de los elementos de la matriz son 0, almacenar todos los elementos de la matriz se vuelve costoso en términos de almacenamiento.

Esto se debe a que solo tenemos unos pocos puntos de datos y la mayor parte del almacenamiento está ocupado por ceros redundantes.

Cómo crear matrices dispersas en Python

Para evitar el uso de memoria para los ceros redundantes en cualquier matriz dada, podemos convertir una matriz normal en una matriz dispersa.

Puede pensar en una matriz dispersa como una lista que contiene tres elementos. La lista interna de la lista almacena el número de fila, el número de columna y el valor de los elementos distintos de cero de la matriz de entrada dada. Esto representa la matriz dispersa.

Por ejemplo, considere la siguiente matriz de entrada.

[[16, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 5], [0, 0, 0, 0]]

Esta matriz tiene elementos distintos de cero en solo dos ubicaciones: (0,0) y (2,3).

Para convertir esta matriz en una matriz dispersa, crearemos una lista que represente la matriz dispersa. La lista contendrá listas que contienen el número de fila, el número de columna y el valor de los elementos distintos de cero.

Entonces, tenemos dos listas internas en la matriz dispersa: [0,0,16] y [2,3,5]. La matriz dispersa final será la siguiente.

[[0, 0, 16], [2, 3, 5]]

Aquí,

• El primer elemento de las listas internas representa el número de fila de los elementos distintos de cero de la matriz de entrada.
• El segundo elemento de las listas internas representa el número de columna de los elementos distintos de cero de la matriz de entrada.
• Finalmente, el tercer elemento de la lista interna contiene el valor real de los elementos distintos de cero.

Para crear la matriz dispersa a partir de una matriz dada, primero crearemos una lista matriz_dispersa que represente la matriz dispersa. Después de eso, recorreremos la matriz de entrada usando un bucle for.

Mientras recorremos, si encontramos un elemento distinto de cero en la matriz, crearemos una lista que contiene el triplete del número de fila, el número de columna y el valor del elemento. Después de eso, agregaremos la lista a sparse_matrix usando el método append().

Después de ejecutar el bucle for, tendremos la matriz dispersa en la lista matriz_dispersa. Puedes observar esto en el siguiente ejemplo.

import numpy as np

input_matrix = np.array([[16, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 5], [0, 0, 0, 0]])
print("The input matrix is:")
print(input_matrix)
sparse_matrix = []
rows, cols = input_matrix.shape
for i in range(rows):
    for j in range(cols):
        if input_matrix[i][j] != 0:
            triplet = [i, j, input_matrix[i][j]]
            sparse_matrix.append(triplet)
print("The sparse matrix is:")
print(sparse_matrix)

Producción :

The input matrix is:
[[16  0  0  0]
 [ 0  0  0  0]
 [ 0  0  0  5]
 [ 0  0  0  0]]
The sparse matrix is:
[[0, 0, 16], [2, 3, 5]]

Puede observar que la matriz dispersa tiene muy pocos elementos en comparación con la matriz de entrada.

El uso de la matriz dispersa se vuelve muy útil cuando la matriz de entrada tiene un tamaño de 1024x1024 o más, como en las aplicaciones de aprendizaje automático del mundo real. El tamaño de la matriz dispersa se vuelve significativamente bajo en comparación con la matriz de entrada.

Recuerde que si el número de elementos distintos de cero en una matriz es mayor que un tercio del total de elementos en la matriz, crear y usar una matriz dispersa se vuelve más costoso que usar la matriz original. Si una matriz tiene n elementos distintos de cero, la matriz dispersa contiene 3*n elementos.

Convierta una matriz normal en una matriz dispersa usando el módulo SciPy en Python

También podemos convertir una matriz normal en una matriz dispersa utilizando el módulo scipy. El módulo scipy proporciona varios métodos para convertir una matriz normal en una matriz dispersa.

Discutamos todos los métodos uno por uno.

Matriz de filas dispersas comprimida en Python

Las matrices de filas dispersas comprimidas (CSR) son matrices dispersas que podemos usar en operaciones aritméticas.

Las matrices CSR admiten sumas, restas, multiplicaciones, divisiones y cálculos de matrices de potencia. Puede convertir una matriz normal en una matriz de filas dispersas comprimida utilizando el método csr_matrix() definido en el módulo scipy de Python.

Como se muestra a continuación, el método csr_matrix() toma una matriz normal como entrada y devuelve una matriz dispersa.

import numpy as np
from scipy import sparse

input_matrix = np.array([[16, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 5], [0, 0, 0, 0]])
print("The input matrix is:")
print(input_matrix)
sparse_matrix = sparse.csr_matrix(input_matrix)
print("The sparse matrix is:")
print(sparse_matrix)

Producción :

The input matrix is:
[[16  0  0  0]
 [ 0  0  0  0]
 [ 0  0  0  5]
 [ 0  0  0  0]]
The sparse matrix is:
  (0, 0)	16
  (2, 3)	5

Las matrices de filas dispersas comprimidas facilitan el corte eficiente de filas y productos de vector de matriz rápidos. Sin embargo, las operaciones de división de columnas son lentas en las matrices CSR.

Matriz de columna dispersa comprimida en Python

Podemos usar una matriz de columna dispersa comprimida (CSC) en lugar de las matrices CSR en los programas que necesitan corte de columna.

Puede crear una matriz CSC en Python utilizando el método csc_matrix() definido en el módulo scipy. El método csc_matrix() acepta una matriz normal como argumento de entrada y devuelve una matriz dispersa a continuación.

import numpy as np
from scipy import sparse

input_matrix = np.array([[16, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 5], [0, 0, 0, 0]])
print("The input matrix is:")
print(input_matrix)
sparse_matrix = sparse.csc_matrix(input_matrix)
print("The sparse matrix is:")
print(sparse_matrix)

Producción :

The input matrix is:
[[16  0  0  0]
 [ 0  0  0  0]
 [ 0  0  0  5]
 [ 0  0  0  0]]
The sparse matrix is:
  (0, 0)	16
  (2, 3)	5

Las matrices de columnas dispersas comprimidas facilitan un corte de columnas más rápido y un corte de filas lento en comparación con las matrices de filas dispersas comprimidas.

Matriz dispersa en formato de coordenadas en Python

El formato de coordenadas es una forma más rápida de crear matrices dispersas. Puede crear una matriz dispersa en el formato de coordenadas utilizando el método coo_matrix() definido en el módulo scipy.

El coo_matrix() acepta una matriz normal como argumento de entrada y devuelve una matriz dispersa en el formato de coordenadas, como se muestra a continuación.

import numpy as np
from scipy import sparse

input_matrix = np.array([[16, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 5], [0, 0, 0, 0]])
print("The input matrix is:")
print(input_matrix)
sparse_matrix = sparse.coo_matrix(input_matrix)
print("The sparse matrix is:")
print(sparse_matrix)

Producción :

The input matrix is:
[[16  0  0  0]
 [ 0  0  0  0]
 [ 0  0  0  5]
 [ 0  0  0  0]]
The sparse matrix is:
  (0, 0)	16
  (2, 3)	5

Si necesita convertir una matriz normal en una matriz CSR o CSC, primero debe convertir la matriz normal en una matriz dispersa en formato de coordenadas. Después de eso, puede convertir la matriz dispersa al formato deseado.

Una matriz dispersa en formato de coordenadas se usa principalmente para interconectar matrices de un formato a otro. No admite operaciones aritméticas ni cortes.

Diccionario de matriz dispersa basada en claves en Python

La matriz dispersa basada en el diccionario de claves (DOK) proporciona acceso O(1) a los elementos de la matriz.

Además, las matrices basadas en DOK no contienen valores duplicados. Puede crear un diccionario de matriz dispersa basada en claves usando el método dok_sparse() definido en el módulo scipy.

Como se muestra a continuación, el método dok_sparse() toma una matriz normal y devuelve una matriz dispersa.

import numpy as np
from scipy import sparse

input_matrix = np.array([[16, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 5], [0, 0, 0, 0]])
print("The input matrix is:")
print(input_matrix)
sparse_matrix = sparse.dok_matrix(input_matrix)
print("The sparse matrix is:")
print(sparse_matrix)

Producción :

The input matrix is:
[[16  0  0  0]
 [ 0  0  0  0]
 [ 0  0  0  5]
 [ 0  0  0  0]]
The sparse matrix is:
  (0, 0)	16
  (2, 3)	5

Conclusión

En este artículo, hemos discutido matrices dispersas y su implementación en Python. También vimos diferentes formas de convertir una matriz normal en una matriz dispersa en Python.

Al crear una matriz dispersa, debe conocer el uso previsto de la matriz. Si hay muchas operaciones de división de columnas, debe crear una matriz CSC.

Para las operaciones de corte de filas, debe crear una matriz CSR. Si la matriz de entrada es grande, primero debe convertirla a matriz dispersa en formato de coordenadas. Después de eso, puede obtener la matriz dispersa deseada.