Introduction détaillée au stockage clairsemé et à la conversion des matrices clairsemées Python

Cet article présente principalement Python des informations relatives au stockage et à la conversion à matrice clairsemée. Les amis dans le besoin peuvent se référer à

Sparse Matrix-sparsep

from scipy import sparse

La forme de stockage des matrices clairsemées

De nombreuses grandes matrices apparaissent souvent lors de la résolution de modèles linéaires dans les domaines de la science et de l'ingénierie. Ces matrices sont pour la plupart. les éléments sont 0, c'est ce qu'on appelle une matrice clairsemée. Utiliser le ndarray array de NumPy pour enregistrer une telle matrice gaspillera de la mémoire. En raison de la nature clairsemée de la matrice, vous pouvez économiser l'utilisation de la mémoire en enregistrant uniquement les informations pertinentes sur les éléments non nuls. De plus, écrire l'opération fonction pour cette structure particulière de la matrice peut également améliorer la vitesse de calcul de la matrice.

La bibliothèque scipy.sparse fournit plusieurs formats pour représenter des matrices clairsemées, chaque format a des utilisations différentes, parmi lesquelles dok_matrix et lil_matrix conviennent pour ajouter progressivement des éléments.

dok_matrix hérite de dict, qui utilise un dictionnaire pour sauvegarder les éléments qui ne sont pas à 0 dans la matrice : la clé du dictionnaire est un tuple qui sauvegarde l'élément (ligne, colonne) informations, et sa valeur correspondante est la valeur de l'élément situé dans (ligne, colonne) dans la matrice. Évidemment, la matrice clairsemée au format dictionnaire est très adaptée aux opérations d'addition, suppression et d'accès d'éléments uniques. Habituellement utilisé pour ajouter progressivement des éléments non nuls, puis convertir vers d'autres formats prenant en charge les opérations rapides.

a = sparse.dok_matrix((10, 5))
a[2:5, 3] = 1.0, 2.0, 3.0
print a.keys()
print a.values()

[(2, 3), (3, 3), (4, 3)]
[1.0, 2.0, 3.0]

lil_matrix utilise deux listes pour stocker des éléments non nuls. data stocke les éléments non nuls dans chaque ligne et rows stocke les colonnes dans lesquelles se trouvent les éléments non nuls. Ce format est également idéal pour ajouter des éléments un par un et récupérer rapidement les données liées aux lignes.

b = sparse.lil_matrix((10, 5))
b[2, 3] = 1.0
b[3, 4] = 2.0
b[3, 2] = 3.0
print b.data
print b.rows

[[] [] [1.0] [3.0, 2.0] [] [] [] [] [] []]
[[] [] [3] [2, 4] [] [] [] [] [] []]

coo_matrix utilise trois tableaux row, col et data pour stocker les informations des éléments non nuls. Les trois tableaux ont la même longueur, row contient la ligne d'éléments, col contient la colonne d'éléments et data contient la valeur de l'élément. coo_matrix ne prend pas en charge l'accès, l'ajout et la suppression d'éléments. Une fois créé, il est presque impossible d'effectuer des opérations ou des opérations matricielles dessus, à l'exception de sa conversion en matrice dans d'autres formats.

coo_matrix prend en charge les éléments répétés, c'est-à-dire que les mêmes coordonnées de ligne et de colonne peuvent apparaître plusieurs fois. Lorsqu'elles sont converties en matrice dans d'autres formats, plusieurs valeurs correspondant aux mêmes coordonnées de ligne et de colonne seront additionnées. Dans l'exemple ci-dessous, (2, 3) correspond à deux valeurs : 1 et 10. Lors de sa conversion en tableau ndarray, ces deux valeurs s'additionnent, donc la valeur aux coordonnées de (2, 3) dans la matrice finale est 11 .

De nombreuses données matricielles clairsemées sont enregistrées dans des fichiers dans ce format. Par exemple, un fichier CSV peut avoir trois colonnes : "ID utilisateur, ID produit, valeur d'évaluation". Après avoir lu les données à l'aide de numpy.loadtxt ou pandas.read_csv, elles peuvent être rapidement converties en une matrice clairsemée via coo_matrix : chaque ligne de la matrice correspond à un utilisateur, chaque colonne correspond à un produit et la valeur de l'élément est l'évaluation de l'utilisateur. du produit.

row = [2, 3, 3, 2]
col = [3, 4, 2, 3]
data = [1, 2, 3, 10]
c = sparse.coo_matrix((data, (row, col)), shape=(5, 6))
print c.col, c.row, c.data
print c.toarray()

[3 4 2 3] [2 3 3 2] [ 1 2 3 10]
[[ 0 0 0 0 0 0]
 [ 0 0 0 0 0 0]
 [ 0 0 0 11 0 0]
 [ 0 0 3 0 2 0]
 [ 0 0 0 0 0 0]]

Choisissez parmi les opérations personnelles, coo_matrix est choisi car il implique des opérations matricielles clairsemées, mais s'il n'est pas stocké sous d'autres formes, la complexité est trop élevée (temps et espace). Une matrice de 1000*1000 prend environ 2 heures, également fatale. Je n'avais pas d'autre choix que de penser aux triplets de format de saisie des données dans le logiciel Pajek :

J'ai donc pensé à traiter mes propres données en triplets similaires !

C'est-à-dire "matrice"—>"tuple triple"—>"sparseMatrix2tuple"—>"scipy.sparse"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!