Matrice creuse en Python

1. Qu’est-ce qu’une matrice creuse en Python
2. Comment créer des matrices creuses en Python
3. Convertir une matrice normale en matrice clairsemée à l’aide du module SciPy en Python
4. Matrice de colonnes creuses compressée en Python
5. Matrice clairsemée au format de coordonnées en Python
6. Dictionnaire de la matrice creuse basée sur les clés en Python
7. Conclusion

Lors de la mise en œuvre d’algorithmes d’apprentissage automatique en Python, nous devons souvent représenter les données d’entrée dans un format qui nécessite moins de mémoire.

Normalement, les données d’entrée fournies aux algorithmes d’apprentissage automatique sont représentées sous forme de matrice. Cet article traite de l’utilisation de la matrice creuse pour stocker des données en Python.

Pour cela, nous allons apprendre différentes représentations de la matrice creuse en Python. Nous verrons également comment convertir une matrice simple en représentation creuse en utilisant les fonctions définies dans le module scipy en Python.

Qu’est-ce qu’une matrice creuse en Python

Une matrice creuse est une matrice dont la plupart des éléments sont 0. Cela signifie que la matrice ne contient des données qu’à quelques emplacements.

Un exemple de matrice creuse est le suivant.

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

Ici, vous pouvez voir que la plupart des éléments de la matrice sont 0.

Les matrices creuses sont largement utilisées dans le traitement du langage naturel et l’encodage des données. Si la plupart des éléments de la matrice sont 0, stocker tous les éléments de la matrice devient coûteux en termes de stockage.

Il en est ainsi parce que nous n’avons que quelques points de données et que la majeure partie du stockage est occupée par des zéros redondants.

Comment créer des matrices creuses en Python

Pour éviter l’utilisation de la mémoire pour les zéros redondants dans une matrice donnée, nous pouvons convertir une matrice normale en une matrice creuse.

Vous pouvez considérer une matrice creuse comme une liste contenant trois éléments. La liste interne de la liste stocke le numéro de ligne, le numéro de colonne et la valeur des éléments non nuls de la matrice d’entrée donnée. Cela représente la matrice creuse.

Par exemple, considérez la matrice d’entrée suivante.

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

Cette matrice a des éléments non nuls à seulement deux emplacements : (0,0) et (2,3).

Pour convertir cette matrice en matrice creuse, nous allons créer une liste représentant la matrice creuse. La liste contiendra des listes contenant le numéro de ligne, le numéro de colonne et la valeur des éléments non nuls.

Ainsi, nous avons deux listes internes dans la matrice creuse : [0,0,16] et [2,3,5]. La matrice creuse finale sera la suivante.

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

Ici,

• Le premier élément des listes internes représente le numéro de ligne des éléments non nuls de la matrice d’entrée.
• Le deuxième élément des listes internes représente le numéro de colonne des éléments non nuls de la matrice d’entrée.
• Enfin, le troisième élément de la liste interne contient la valeur réelle des éléments non nuls.

Pour créer la matrice creuse à partir d’une matrice donnée, nous allons d’abord créer une liste sparse_matrix représentant la matrice creuse. Après cela, nous traverserons la matrice d’entrée à l’aide d’une boucle for.

En parcourant, si nous trouvons un élément non nul dans la matrice, nous créerons une liste contenant le triplet du numéro de ligne, du numéro de colonne et de la valeur de l’élément. Après cela, nous ajouterons la liste à sparse_matrix en utilisant la méthode append().

Après avoir exécuté la boucle for, nous aurons la matrice creuse dans la liste sparse_matrix. Vous pouvez observer cela dans l’exemple suivant.

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)

Production :

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]]

Vous pouvez observer que la matrice creuse a très peu d’éléments par rapport à la matrice d’entrée.

L’utilisation de la matrice creuse devient très utile lorsque la matrice d’entrée est de 1024x1024 ou plus comme dans les applications d’apprentissage automatique du monde réel. La taille de la matrice creuse devient significativement faible par rapport à la matrice d’entrée.

N’oubliez pas que si le nombre d’éléments non nuls dans une matrice est supérieur à un tiers du nombre total d’éléments dans la matrice, la création et l’utilisation d’une matrice creuse deviennent plus coûteuses que l’utilisation de la matrice d’origine. Si une matrice a n éléments non nuls, la matrice creuse contient 3*n éléments.

Convertir une matrice normale en matrice clairsemée à l’aide du module SciPy en Python

On peut aussi convertir une matrice normale en une matrice creuse en utilisant le module scipy. Le module scipy fournit diverses méthodes pour convertir une matrice normale en une matrice creuse.

Discutons de toutes les méthodes une par une.

Matrice de lignes creuses compressée en Python

Les matrices de lignes creuses compressées (CSR) sont des matrices creuses que nous pouvons utiliser dans les opérations arithmétiques.

Les matrices CSR prennent en charge l’addition, la soustraction, la multiplication, la division et le calcul de la matrice de puissance. Vous pouvez convertir une matrice normale en une matrice de lignes creuses compressée en utilisant la méthode csr_matrix() définie dans le module scipy de Python.

Comme indiqué ci-dessous, la méthode csr_matrix() prend une matrice normale en entrée et renvoie une matrice creuse.

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)

Production :

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

Les matrices de lignes creuses compressées facilitent le découpage efficace des lignes et les produits matrice-vecteur rapides. Cependant, les opérations de découpage de colonne sont lentes dans les matrices CSR.

Matrice de colonnes creuses compressée en Python

Nous pouvons utiliser une matrice de colonne creuse compressée (CSC) au lieu des matrices CSR dans les programmes nécessitant un découpage de colonne.

Vous pouvez créer une matrice CSC en Python en utilisant la méthode csc_matrix() définie dans le module scipy. La méthode csc_matrix() accepte une matrice normale comme argument d’entrée et renvoie une matrice creuse en dessous.

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)

Production :

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

Les matrices de colonnes clairsemées compressées facilitent un découpage en colonnes plus rapide et un découpage en lignes lent par rapport aux matrices de lignes clairsemées compressées.

Matrice clairsemée au format de coordonnées en Python

Le format de coordonnées est un moyen plus rapide de créer des matrices creuses. Vous pouvez créer une matrice creuse au format coordonné en utilisant la méthode coo_matrix() définie dans le module scipy.

Le coo_matrix() accepte une matrice normale comme argument d’entrée et renvoie une matrice creuse dans le format de coordonnées, comme indiqué ci-dessous.

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)

Production :

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 vous devez convertir une matrice normale en matrice CSR ou CSC, vous devez d’abord convertir la matrice normale en une matrice creuse au format de coordonnées. Après cela, vous pouvez convertir la matrice creuse dans le format souhaité.

Une matrice creuse au format de coordonnées est principalement utilisée pour interconnecter des matrices d’un format à un autre. Il ne prend pas en charge les opérations arithmétiques ou le découpage en tranches.

Dictionnaire de la matrice creuse basée sur les clés en Python

La matrice creuse basée sur le dictionnaire de clés (DOK) fournit un accès O(1) aux éléments de la matrice.

De plus, les matrices basées sur DOK ne contiennent pas de valeurs en double. Vous pouvez créer un dictionnaire de la matrice creuse basée sur les clés en utilisant la méthode dok_sparse() définie dans le module scipy.

Comme indiqué ci-dessous, la méthode dok_sparse() prend une matrice normale et renvoie une matrice creuse.

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)

Production :

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

Conclusion

Dans cet article, nous avons discuté des matrices creuses et de leur implémentation en Python. Nous avons également vu différentes manières de convertir une matrice normale en une matrice creuse en Python.

Lors de la création d’une matrice creuse, vous devez connaître l’utilisation prévue de la matrice. S’il existe de nombreuses opérations de découpage de colonne, vous devez créer une matrice CSC.

Pour les opérations de découpage de lignes, vous devez créer une matrice CSR. Si la matrice d’entrée est grande, vous devez d’abord la convertir en matrice creuse au format de coordonnées. Après cela, vous pouvez obtenir la matrice creuse souhaitée.