Sparse arrays (scipy.sparse)

SciPy 2-D Sparse-Array-Paket für numerische Daten.

Hinweis

Dieses Paket stellt von der älteren Matrix-Schnittstelle auf eine Array-Schnittstelle um, die mit NumPy-Arrays kompatibel ist. Wir empfehlen, für alle neuen Arbeiten die Array-Objekte (bsr_array, coo_array usw.) zu verwenden.

Bei Verwendung der Array-Schnittstelle beachten Sie bitte, dass

• x * y nicht mehr die Matrixmultiplikation, sondern die elementweise Multiplikation durchführt (genau wie bei NumPy-Arrays). Um Code zu schreiben, der sowohl mit Arrays als auch mit Matrizen funktioniert, verwenden Sie x @ y für die Matrixmultiplikation.

• Operationen wie sum, die früher dichte Matrizen erzeugten, erzeugen nun Arrays, deren Multiplikationsverhalten ähnlich unterschiedlich ist.

• Sparse-Arrays verwenden Array-basierte *Slicing*-Operationen, die Skalare, 1D- oder 2D-Sparse-Arrays zurückgeben. Wenn Sie 2D-Ergebnisse benötigen, verwenden Sie einen entsprechenden Index. Z. B. A[:, i, None] oder A[:, [i]].

• Alle Index-Arrays für ein gegebenes Sparse-Array sollten denselben dtype haben. Zum Beispiel sollten für das CSR-Format indices und indptr denselben dtype haben. Für COO sollte jedes Array in coords denselben dtype haben.

Die Konstruktionshilfsprogramme (eye, kron, random, diags usw.) haben entsprechende Ersetzungen (siehe Erstellung von Sparse-Arrays).

Weitere Informationen finden Sie unter Migration von spmatrix zu sparray.

Submodule

csgraph	Komprimierte Sparse-Graph-Routinen (scipy.sparse.csgraph)
linalg	Sparse lineare Algebra (scipy.sparse.linalg)

Sparse-Array-Klassen

bsr_array(arg1[, shape, dtype, copy, ...])	Block Sparse Row-Format Sparse-Array.
coo_array(arg1[, shape, dtype, copy, maxprint])	Ein Sparse-Array im COOrdinate-Format.
csc_array(arg1[, shape, dtype, copy, maxprint])	Compressed Sparse Column Array.
csr_array(arg1[, shape, dtype, copy, maxprint])	Compressed Sparse Row Array.
dia_array(arg1[, shape, dtype, copy, maxprint])	Sparse-Array mit DIAgonaler Speicherung.
dok_array(arg1[, shape, dtype, copy, maxprint])	Dictionary Of Keys-basiertes Sparse-Array.
lil_array(arg1[, shape, dtype, copy, maxprint])	Reihenbasierte LIst of Lists Sparse-Array.
sparray()	Diese Klasse stellt eine Basisklasse für alle Sparse-Arrays dar.

Erstellung von Sparse-Arrays

diags_array(diagonals, /, *[, offsets, ...])	Konstruiere ein Sparse-Array aus Diagonalen.
eye_array(m[, n, k, dtype, format])	Sparse-Array gewählter Form mit Einsen auf der k-ten Diagonale und Nullen ansonsten.
random_array(shape, *[, density, format, ...])	Gibt ein Sparse-Array mit gleichmäßig zufälligen Zahlen in [0, 1) zurück.
block_array(blocks, *[, format, dtype])	Erstelle ein Sparse-Array aus Sparse-Subblöcken.

Kombinieren von Arrays

kron(A, B[, format])	Kronecker-Produkt der Sparse-Matrizen A und B.
kronsum(A, B[, format])	Kronecker-Summe von quadratischen Sparse-Matrizen A und B.
block_diag(mats[, format, dtype])	Erstellt eine blockdiagonale Sparse-Matrix oder ein Sparse-Array aus den bereitgestellten Matrizen.
tril(A[, k, format])	Gibt den unteren Dreiecksteil eines Sparse-Arrays oder einer Sparse-Matrix zurück.
triu(A[, k, format])	Gibt den oberen Dreiecksteil eines Sparse-Arrays oder einer Sparse-Matrix zurück.
hstack(blocks[, format, dtype])	Stapelt Sparse-Matrizen horizontal (spaltenweise).
vstack(blocks[, format, dtype])	Stapelt Sparse-Arrays vertikal (zeilenweise).

Sparse-Werkzeuge

save_npz(file, matrix[, compressed])	Speichert eine Sparse-Matrix oder ein Sparse-Array mit dem .npz-Format in einer Datei.
load_npz(file)	Lädt eine Sparse-Matrix/ein Sparse-Array mit dem .npz-Format aus einer Datei.
find(A)	Gibt die Indizes und Werte der Nicht-Null-Elemente einer Matrix zurück.
get_index_dtype([arrays, maxval, check_contents])	Bestimmt basierend auf den Eingabe-(Integer-)Arrays a einen geeigneten Indexdatentyp, der die Daten in den Arrays aufnehmen kann.
safely_cast_index_arrays(A[, idx_dtype, msg])	Gibt die Indizes von Sparse-Arrays sicher nach idx_dtype um.

Identifizieren von Sparse-Arrays

issparse(x)

Ist x ein Sparse-Array oder eine Sparse-Matrix?

Sparse-Matrix-Klassen

bsr_matrix(arg1[, shape, dtype, copy, ...])	Block Sparse Row-Format Sparse-Matrix.
coo_matrix(arg1[, shape, dtype, copy, maxprint])	Eine Sparse-Matrix im COOrdinate-Format.
csc_matrix(arg1[, shape, dtype, copy, maxprint])	Compressed Sparse Column Matrix.
csr_matrix(arg1[, shape, dtype, copy, maxprint])	Compressed Sparse Row Matrix.
dia_matrix(arg1[, shape, dtype, copy, maxprint])	Sparse-Matrix mit DIAgonaler Speicherung.
dok_matrix(arg1[, shape, dtype, copy, maxprint])	Dictionary Of Keys-basierte Sparse-Matrix.
lil_matrix(arg1[, shape, dtype, copy, maxprint])	Reihenbasierte LIst of Lists Sparse-Matrix.
spmatrix()	Diese Klasse stellt eine Basisklasse für alle Sparse-Matrix-Klassen dar.

Erstellung von Sparse-Matrizen

eye(m[, n, k, dtype, format])	Sparse-Matrix gewählter Form mit Einsen auf der k-ten Diagonale und Nullen ansonsten.
identity(n[, dtype, format])	Identitätsmatrix im Sparse-Format.
diags(diagonals[, offsets, shape, format, dtype])	Konstruiere eine Sparse-Matrix aus Diagonalen.
spdiags(data, diags[, m, n, format])	Gibt eine Sparse-Matrix aus Diagonalen zurück.
bmat(blocks[, format, dtype])	Erstellt ein Sparse-Array oder eine Sparse-Matrix aus Sparse-Subblöcken.
random(m, n[, density, format, dtype, rng, ...])	Erzeuge eine Sparse-Matrix der gegebenen Form und Dichte mit zufällig verteilten Werten.
rand(m, n[, density, format, dtype, rng])	Erzeuge eine Sparse-Matrix der gegebenen Form und Dichte mit gleichmäßig verteilten Werten.

Das Kombinieren von Matrizen verwendet dieselben Funktionen wie Kombinieren von Arrays.

Identifizieren von Sparse-Matrizen

issparse(x)	Ist x ein Sparse-Array oder eine Sparse-Matrix?
isspmatrix(x)	Ist x eine Sparse-Matrix?
isspmatrix_csc(x)	Ist x vom Typ csc_matrix?
isspmatrix_csr(x)	Ist x vom Typ csr_matrix?
isspmatrix_bsr(x)	Ist x vom Typ bsr_matrix?
isspmatrix_lil(x)	Ist x vom Typ lil_matrix?
isspmatrix_dok(x)	Ist x vom Typ dok_array?
isspmatrix_coo(x)	Ist x vom Typ coo_matrix?
isspmatrix_dia(x)	Ist x vom Typ dia_matrix?

Warnungen

SparseEfficiencyWarning	Die Warnung, die ausgegeben wird, wenn die Operation für Sparse-Matrizen ineffizient ist.
SparseWarning	Allgemeine Warnung für scipy.sparse.

Verwendungsinformationen

Es gibt sieben verfügbare Sparse-Array-Typen:

1. csc_array: Compressed Sparse Column-Format

2. csr_array: Compressed Sparse Row-Format

3. bsr_array: Block Sparse Row-Format

4. lil_array: List of Lists-Format

5. dok_array: Dictionary of Keys-Format

6. coo_array: COOrdinate-Format (auch bekannt als IJV, Triplett-Format)

7. dia_array: DIAgonal-Format

Um ein Array effizient zu erstellen, verwenden Sie coo_array, dok_array oder lil_array. dok_array und lil_array unterstützen grundlegendes Slicing und Fancy-Indexing mit einer ähnlichen Syntax wie NumPy-Arrays. Das COO-Format unterstützt (noch) kein Indexing, kann aber auch zur effizienten Erstellung von Arrays mit Koordinaten- und Werteinformationen verwendet werden.

Trotz ihrer Ähnlichkeit mit NumPy-Arrays wird **dringend davon abgeraten**, NumPy-Funktionen direkt auf diesen Arrays zu verwenden, da NumPy sie typischerweise als generische Python-Objekte und nicht als Arrays behandelt, was zu unerwarteten (und falschen) Ergebnissen führt. Wenn Sie eine NumPy-Funktion auf diese Arrays anwenden möchten, prüfen Sie zuerst, ob SciPy eine eigene Implementierung für die gegebene Sparse-Array-Klasse hat, oder **konvertieren Sie das Sparse-Array in ein NumPy-Array** (z. B. mit der toarray-Methode der Klasse), bevor Sie die Methode anwenden.

Alle Konvertierungen zwischen den Formaten CSR, CSC und COO sind effiziente Operationen in linearer Zeit.

Um Manipulationen wie Multiplikation oder Inversion durchzuführen, konvertieren Sie das Array zuerst in das Format CSC oder CSR. Das Format lil_array ist reihenbasiert, daher ist die Konvertierung in CSR effizient, während die Konvertierung in CSC weniger effizient ist.

Matrix-Vektor-Produkt

Für ein Vektorprodukt zwischen einem 2D-Sparse-Array und einem Vektor verwenden Sie den Matmul-Operator (d. h. @), der ein Skalarprodukt durchführt (ähnlich der dot-Methode).

>>> import numpy as np
>>> from scipy.sparse import csr_array
>>> A = csr_array([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
>>> v = np.array([1, 0, -1])
>>> A @ v
array([ 1, -3, -1], dtype=int64)

Das CSR-Format eignet sich besonders gut für schnelle Matrix-Vektor-Produkte.

Beispiel 1

Konstruiere ein 1000x1000 lil_array und füge einige Werte hinzu.

>>> from scipy.sparse import lil_array
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

>>> A = lil_array((1000, 1000))
>>> A[0, :100] = rand(100)
>>> A.setdiag(rand(1000))

Konvertiere es nun in das CSR-Format und löse A x = b nach x auf.

>>> A = A.tocsr()
>>> b = rand(1000)
>>> x = spsolve(A, b)

Konvertiere es in ein dichtes Array und löse es auf, und prüfe, ob das Ergebnis dasselbe ist.

>>> x_ = solve(A.toarray(), b)

Nun können wir die Norm des Fehlers mit

>>> err = norm(x-x_)
>>> err < 1e-9
True

berechnen. Sie sollte klein sein :)

Beispiel 2

Konstruiere ein Array im COO-Format.

>>> from scipy import sparse
>>> from numpy import array
>>> I = array([0,3,1,0])
>>> J = array([0,3,1,2])
>>> V = array([4,5,7,9])
>>> A = sparse.coo_array((V,(I,J)),shape=(4,4))

Beachte, dass die Indizes nicht sortiert sein müssen.

Duplizierte (i,j)-Einträge werden beim Konvertieren nach CSR oder CSC summiert.

>>> I = array([0,0,1,3,1,0,0])
>>> J = array([0,2,1,3,1,0,0])
>>> V = array([1,1,1,1,1,1,1])
>>> B = sparse.coo_array((V,(I,J)),shape=(4,4)).tocsr()

Dies ist nützlich für die Erstellung von Steifigkeits- und Massenmatrizen für finite Elemente.

Weitere Details

CSR-Spaltenindizes sind nicht notwendigerweise sortiert. Ebenso für CSC-Zeilenindizes. Verwenden Sie die Methoden .sorted_indices() und .sort_indices(), wenn sortierte Indizes benötigt werden (z. B. beim Übergeben von Daten an andere Bibliotheken).