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?

  • Kopiere / Migration alter Zookeeper znode / Daten zum neuen Zookeeper
  • Suche nach Dateisystem mit Python
  • Installierte Pakete mit Pip sind nicht in Pip-Freeze gezeigt?
  • WxPython: Wie die Optionsfelder sich an meine Wahl erinnern können, wenn ich den Rahmen schließe
  • Wie man eine Byte-String in separate Bytes in Python aufteilt
  • Bodenabteilung mit negativer Zahl
  • Im Moment benutze ich folgendes:

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

    oder

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

  • Mehrfach- / Split-Klasse-Assoziationen in sqlalchemy
  • Wie füttere ich einen Platzhalter?
  • Wie programmgesteuert man Textdateien mit potenziellen Konflikten (ala git oder svn, etc) zusammenführt?
  • Datetime.datetime.strptime nicht in Python 2.4.1 vorhanden
  • Django: Ändern von Daten mit Benutzereingabe durch benutzerdefinierte Template-Tag?
  • Wie benutzt man g.user global im Kolben
  • 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.