Die effizienteste Art des Zugriffs auf Werte ungleich Null in Zeile / Spalte in scipy.sparse Matrix

Was ist die schnellste oder, die fehlgeschlagene, am wenigsten wortreiche Art, auf alle Nicht-Null-Werte in einer scipy.sparse oder Spalte col einer scipy.sparse Matrix A im CSR Format scipy.sparse ?

Wäre es in einem anderen Format (sagen wir, COO ) effizienter?

  • Generiere zufällige UTF-8 String in Python
  • Gibt es eine Möglichkeit, den Linienwinkel bei der Erstellung von Graphen mit pyDot zu steuern
  • Stapeldatenstruktur in Python
  • Ist pythons sortierte () -Funktion garantiert stabil?
  • Ist es möglich, den Inhalt einer S3-Datei zu laden, ohne sie mit boto3 herunterzuladen?
  • Alle Methoden standardmäßig verknüpfen
  • Im Moment benutze ich folgendes:

     A[row, A[row, :].nonzero()[1]] 

    oder

     A[A[:, col].nonzero()[0], col] 

  • Dynamic Button mit ScrollBar in tkinter - Python
  • Reverse Mapping Class Attribute zu Klassen in Python
  • Wie ersetze ich alle Interpunktion in meinem String mit "" in Python?
  • Es gibt Fehler "Ungültige Locator-Werte übergeben", falls wir find_element anstelle von find_element_by verwenden
  • Python - Verbinden Sie mehrere Threads mit Timeout
  • Django {% if forloop.first%} Frage
  • One Solution collect form web for “Die effizienteste Art des Zugriffs auf Werte ungleich Null in Zeile / Spalte in scipy.sparse Matrix”

    Für ein Problem wie dies ist zahlt, um die zugrunde liegenden Datenstrukturen für die verschiedenen Formate zu verstehen:

     In [672]: A=sparse.csr_matrix(np.arange(24).reshape(4,6)) In [673]: A.data Out[673]: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], dtype=int32) In [674]: A.indices Out[674]: array([1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5], dtype=int32) In [675]: A.indptr Out[675]: array([ 0, 5, 11, 17, 23], dtype=int32) 

    Die Datenwerte für eine Zeile sind eine Scheibe innerhalb von A.data , aber die Identifizierung dieser Scheibe erfordert einige Kenntnisse der A.indptr (siehe unten)

    Für den coo .

     In [676]: Ac=A.tocoo() In [677]: Ac.data Out[677]: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], dtype=int32) In [678]: Ac.row Out[678]: array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3], dtype=int32) In [679]: Ac.col Out[679]: array([1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5], dtype=int32) 

    Beachten Sie, dass A.nonzeros() in coo konvertiert und die row und A.nonzeros() zurückgibt (mehr oder weniger – den Code ansehen).

    Für das lil Format; Daten werden in Listen in Listen gespeichert:

     In [680]: Al=A.tolil() In [681]: Al.data Out[681]: array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]], dtype=object) In [682]: Al.rows Out[682]: array([[1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=object) 

    ===============

    Die Auswahl einer Reihe von A funktioniert, obwohl in meiner Erfahrung, die dazu neigt, ein bisschen langsam, zum Teil, weil es eine neue csr Matrix zu schaffen csr . Auch dein Ausdruck scheint wortler als nötig

    Ich betrachte meine erste Reihe, die ein 0-Element hat (die anderen sind zu dicht):

     In [691]: A[0, A[0,:].nonzero()[1]].A Out[691]: array([[1, 2, 3, 4, 5]], dtype=int32) 

    Die ganze Reihe, ausgedrückt als dichtes Array, ist:

     In [692]: A[0,:].A Out[692]: array([[0, 1, 2, 3, 4, 5]], dtype=int32) 

    Aber das Datenattribut dieser Zeile ist das gleiche wie Ihre Auswahl

     In [693]: A[0,:].data Out[693]: array([1, 2, 3, 4, 5], dtype=int32) 

    Und mit dem lil Format

     In [694]: Al.data[0] Out[694]: [1, 2, 3, 4, 5] 

    A[0,:].tocoo() fügt nichts hinzu.

    Direkter Zugriff auf Attribute von csr und lil ist nicht so gut bei der Auswahl von Spalten. Für diese csc ist besser, oder lil der transpose.

    Direkter Zugriff auf die csr data , mit Hilfe von indptr , wäre:

     In [697]: i=0; A.data[A.indptr[i]:A.indptr[i+1]] Out[697]: array([1, 2, 3, 4, 5], dtype=int32) 

    Berechnungen, die das csr Format verwenden, routinemäßig durch indptr , wobei die Werte jeder Zeile erhalten werden – aber das macht sie im kompilierten Code.

    Ein aktuelles Thema, das das Produkt von ungleichen Elementen nach Zeile sucht: Multiplizieren von Spaltenelementen mit spärlicher Matrix

    Dort fand ich den reduceat mit indptr war ziemlich schnell.

    Ein anderes Werkzeug beim Umgang mit spärlichen Matrizen ist die Multiplikation

     In [708]: (sparse.csr_matrix(np.array([1,0,0,0])[None,:])*A) Out[708]: <1x6 sparse matrix of type '<class 'numpy.int32'>' with 5 stored elements in Compressed Sparse Row format> 

    csr tatsächlich sum mit dieser Art von Multiplikation. Und wenn mein Gedächtnis richtig ist, führt es tatsächlich A[0,:] diese Weise

    Sparse Matrix Slicing mit der Liste der int

    Python ist die beste Programmiersprache der Welt.