1. Übersicht
Die Erklärung einer Sparse-Matrix besteht darin, dass eine solche Matrix als Sparse-Matrix bezeichnet wird, wenn die Matrix weit mehr Nullelemente als Nicht-Null-Elemente enthält und die Nicht-Null-Elemente keine Regeln haben ist eine dichte Matrix, in der die Anzahl der Nicht-Null-Elemente gleich der Anzahl aller Elemente ist. Das Verhältnis von wird als Dichte bezeichnet. Im Allgemeinen wird jede Dichte unter 0,05 als dünn besetzte Matrix bezeichnet.
Wir wissen, dass wir beim Komprimieren einer Datei eine große Datei in eine kleine Datei komprimieren können. Dies liegt daran, dass es viel Redundanz gibt. Wir komprimieren sie durch einen Komprimierungsalgorithmus. Da es in der Matrix viele Nullelemente gibt, haben wir ebenfalls kann auch Durch das Eliminieren kann viel Speicherplatz gespart, die Berechnungsleistung verbessert und viel Zeit gespart werden. Seine Anwendungen sind sehr breit gefächert und umfassen numerische Strömungsmechanik, statistische Physik, Schaltkreissimulation, Bildverarbeitung, Berechnung von Nanomaterialien usw.
2. Komprimieren Sie die Sparse-Matrix
Wie kann man es also komprimieren und wiederherstellen? Hier wird die Sparse-Matrix in die drei Arrays data, indptr und indices komprimiert und kann dann über diese drei Arrays auf die ursprüngliche Matrix zurückgesetzt werden.
Daten : speichert nur Nicht-Null-Elemente
indptr : speichert die kumulative Anzahl von Nicht-Null-Elementen in jeder Zeile, sodass Sie wissen können, wie viele Nicht-Null-Elemente es in jeder Zeile gibt. Natürlich, um die Anzahl zu berechnen Jede Zeile, indptr[i+1] - indptr[i], kann die Nummer der i -ten Zeile berechnen. Um die Berechnung der ersten Zeile zu erleichtern, wird das erste Element des Arrays hier auf 0 gesetzt.
Indizes : speichert den Indexwert der Spalte, in der sich das Nicht-Null-Element befindet, damit es an seiner Position in der Sparse-Matrix positioniert werden kann
Mithilfe dieser drei Arrays können wir schnell die Position jedes Elements ungleich Null ermitteln und so Matrixoperationen und -lösungen durchführen, wodurch die Berechnungszeit erheblich verkürzt wird.
Normalerweise verwenden wir eine Speichermethode namens Compressed Sparse Row (CSR) oder Compressed Sparse Matrix (CSM).
Als nächstes schauen wir uns die praktische Anwendung des Herunterladens von MXNet an.
3. Beispiel 1
3.1. Geteilte Sparse-Matrix
from mxnet import nd
import mxnet as mx
n1 = nd.array([[1,0,0,0],[4,0,2,0],[0,0,0,3],[5,1,0,0]])
/*
[[1. 0. 0. 0.]
[4. 0. 2. 0.]
[0. 0. 0. 3.]
[5. 1. 0. 0.]]
<NDArray 4x4 @cpu(0)>
*/Konvertieren Sie eine dichte Matrix in eine dünn besetzte Matrix
n1_csr = n1.tostype('csr')
<CSRNDArray 4x4 @cpu(0)>Nicht-Null-Elemente
n1_data = n1_csr.data
[1. 4. 2. 3. 5. 1.]
<NDArray 6 @cpu(0)>Kumulierte Anzahl von Elementen ungleich Null pro Zeile
n1_indptr = n1_csr.indptr
[0 1 3 4 6]
<NDArray 5 @cpu(0)>Hier können Sie die Anzahl der Nicht-Null-Elemente in welcher Zeile ermitteln. Beispielsweise befinden sich in der zweiten Zeile zwei Nicht-Null-Elemente. Wir können dies über n1_indptr[2]-n1_indptr[1] ermitteln .
die Position des Nicht-Null-Elements
n1_indices = n1_csr.indices
[0 0 2 3 0 1]
<NDArray 6 @cpu(0)>Auf diese Weise wird eine Sparse-Matrix wie n1 in drei Arrays aufgeteilt. Besonders in der Praxis trifft man häufig auf große Sparse-Matrizen. Die auf diese Weise aufgeteilten kleinen Arrays haben einen guten Komprimierungseffekt.
3.2. Sparse-Konvertierung in dicht
Der vorherige Schritt besteht darin, dichte Momente in spärliche Matrizen umzuwandeln. Natürlich können Sie auch spärliche Matrizen in dichte Matrizen umwandeln. Von den beiden Methoden ist die direkte erzwungene Typkonvertierung die einfachste:
n1_csr.asnumpy()
array([[1., 0., 0., 0.],
[4., 0., 2., 0.],
[0., 0., 0., 3.],
[5., 1., 0., 0.]], dtype=float32)Eine andere Möglichkeit besteht darin, drei geteilte Arrays zu kombinieren:
n1_o = nd.sparse.csr_matrix((n1_data, n1_indices, n1_indptr), shape = (4, 4))
n1_o.asnumpy()
array([[1., 0., 0., 0.],
[4., 0., 2., 0.],
[0., 0., 0., 3.],
[5., 1., 0., 0.]], dtype=float32)Sie können hier auch die Form angeben, um beispielsweise nur eine 3x3-Matrix abzufangen:
n1_o = nd.sparse.csr_matrix((n1_data, n1_indices, n1_indptr), shape = (3,3))
n1_o.asnumpy()
array([[1., 0., 0.],
[4., 0., 2.],
[0., 0., 0.]], dtype=float32)Sie kann auch direkt als dünn besetzte Matrix definiert werden:
src = nd.sparse.zeros('csr', (3,3))
<CSRNDArray 3x3 @cpu(0)>3.3. Vergleich verschiedener Kontexte
from mxnet import nd
import mxnet as mx
x = nd.ones((2,3)) # 默认是CPU
y = x.as_in_context(mx.cpu())
z = x.as_in_context(mx.gpu())
y is x # True
z is x # FalseAuch wenn ihre Werte gleich sind, können Werte, die nicht im gleichen Kontext stehen, nicht verglichen werden. Es ist offensichtlich, dass einer auf der CPU und der andere auf der GPU berechnet wird.
4. Beispiel 2
Schauen wir uns zur Konsolidierung ein Beispiel an. Wir werden dieses Beispiel auch verwenden, um später ein Bild zu erstellen und das Prinzip der Sparse-Matrix-Aufteilung zu verstehen.
Das heißt, im obigen Beispiel fügen Sie eine Zeile mit allen 0 Elementen hinzu, damit Sie die Bedeutung der akkumulierten Zahl indptr besser verstehen können.
from mxnet import nd
import mxnet as mx
n2 = nd.array([[1,0,0,0],[4,0,2,0],[0,0,0,0],[0,0,0,3],[5,1,0,0]])
[[1. 0. 0. 0.]
[4. 0. 2. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 3.]
[5. 1. 0. 0.]]
<NDArray 5x4 @cpu(0)>n2_csr = n2.tostype('csr')
<CSRNDArray 5x4 @cpu(0)>
n2_data = n2_csr.data
[1. 4. 2. 3. 5. 1.]
<NDArray 6 @cpu(0)>
n2_indptr = n2_csr.indptr
[0 1 3 3 4 6]
<NDArray 6 @cpu(0)>
n2_indices = n2_csr.indices
[0 0 2 3 0 1]
<NDArray 6 @cpu(0)>5. Abbildung
Mit der obigen Einführung sollte jeder mit dieser Sparse-Matrix vertraut sein. Schließlich habe ich ein Bild gezeichnet, damit ich den gesamten Prozess der Aufteilung der Sparse-Matrix in drei Arrays intuitiver erleben kann.
