scipy.sparse.

csr_array#

class scipy.sparse.csr_array(arg1, shape=None, dtype=None, copy=False, *, maxprint=None)[Quelle]#

Compressed Sparse Row array.

Dies kann auf verschiedene Arten instanziiert werden
csr_array(D)

wobei D ein 2-D ndarray ist

csr_array(S)

mit einem anderen dünnbesetzten Array oder einer dünnbesetzten Matrix S (entspricht S.tocsr())

csr_array((M, N), [dtype])

zum Erstellen eines leeren Arrays mit der Form (M, N). dtype ist optional und hat standardmäßig dtype=’d’.

csr_array((data, (row_ind, col_ind)), [shape=(M, N)])

wobei data, row_ind und col_ind die Beziehung a[row_ind[k], col_ind[k]] = data[k] erfüllen.

csr_array((data, indices, indptr), [shape=(M, N)])

ist die Standard-CSR-Darstellung, bei der die Spaltenindizes für Zeile i in indices[indptr[i]:indptr[i+1]] gespeichert sind und ihre entsprechenden Werte in data[indptr[i]:indptr[i+1]] gespeichert sind. Wenn der shape-Parameter nicht angegeben wird, werden die Array-Dimensionen aus den Index-Arrays abgeleitet.

Attribute:
dtypedtype

Datentyp des Arrays

shape2-tuple

Form des Arrays

ndimint

Anzahl der Dimensionen (dies ist immer 2)

nnz

Anzahl der gespeicherten Werte, einschließlich expliziter Nullen.

size

Anzahl der gespeicherten Werte.

data

CSR-Format-Datenarray des Arrays

indices

CSR-Format-Indexarray des Arrays

indptr

CSR-Format-Indexzeigerarray des Arrays

has_sorted_indices

Ob die Indizes sortiert sind

has_canonical_format

Ob das Array/die Matrix sortierte Indizes und keine Duplikate hat

T

Transponierte.

Methoden

__len__()

arcsin()

Elementweise Arcussinus.

arcsinh()

Elementweise Arcusshinus.

arctan()

Elementweise Arctangens.

arctanh()

Elementweise Arcustangens.

argmax([axis, out, explicit])

Gibt die Indizes der maximalen Elemente entlang einer Achse zurück.

argmin([axis, out, explicit])

Gibt die Indizes der minimalen Elemente entlang einer Achse zurück.

asformat(format[, copy])

Gibt dieses Array/diese Matrix im übergebenen Format zurück.

astype(dtype[, casting, copy])

Gibt die Elemente des Arrays/der Matrix in einem angegebenen Typ aus.

ceil()

Elementweise Aufrundung.

check_format([full_check])

Prüft, ob das Array/die Matrix das CSR- oder CSC-Format einhält.

conj([copy])

Elementweise komplexe Konjugation.

conjugate([copy])

Elementweise komplexe Konjugation.

copy()

Gibt eine Kopie dieses Arrays/dieser Matrix zurück.

count_nonzero([axis])

Anzahl der Nicht-Null-Einträge, äquivalent zu

deg2rad()

Elementweise Umrechnung von Grad in Radiant.

diagonal([k])

Gibt die k-te Diagonale des Arrays/der Matrix zurück.

dot(other)

Gewöhnliches Skalarprodukt

eliminate_zeros()

Entfernt Nulleinträge aus dem Array/der Matrix

expm1()

Elementweise expm1.

floor()

Elementweise Abrundung.

log1p()

Elementweise log1p.

max([axis, out, explicit])

Gibt das Maximum des Arrays/der Matrix oder das Maximum entlang einer Achse zurück.

maximum(other)

Elementweises Maximum zwischen diesem und einem anderen Array/einer anderen Matrix.

mean([axis, dtype, out])

Berechnet das arithmetische Mittel entlang der angegebenen Achse.

min([axis, out, explicit])

Gibt das Minimum des Arrays/der Matrix oder das Maximum entlang einer Achse zurück.

minimum(other)

Elementweises Minimum zwischen diesem und einem anderen Array/einer anderen Matrix.

multiply(other)

Elementweise Multiplikation mit einem anderen Array/einer anderen Matrix.

nanmax([axis, out, explicit])

Gibt das Maximum zurück und ignoriert alle NaNs entlang einer Achse.

nanmin([axis, out, explicit])

Gibt das Minimum zurück und ignoriert alle NaNs entlang einer Achse.

nonzero()

Nicht-Null-Indizes des Arrays/der Matrix.

power(n[, dtype])

Diese Funktion führt elementweise Potenzierung durch.

prune()

Entfernt leeren Speicherplatz nach allen Nicht-Null-Elementen.

rad2deg()

Elementweise Umrechnung von Radiant in Grad.

reshape(self, shape[, order, copy])

Gibt einem Sparse Array/einer Sparse Matrix eine neue Form, ohne dessen/deren Daten zu ändern.

resize(*shape)

Ändert die Größe des Arrays/der Matrix direkt auf die durch shape gegebenen Dimensionen.

rint()

Elementweise Rundung zur nächsten ganzen Zahl.

setdiag(values[, k])

Setzt diagonale oder nicht-diagonale Elemente des Arrays/der Matrix.

sign()

Elementweises Vorzeichen.

sin()

Elementweise Sinus.

sinh()

Elementweise Sinus hyperbolicus.

sort_indices()

Sortiert die Indizes dieses Arrays/dieser Matrix *direkt*.

sorted_indices()

Gibt eine Kopie dieses Arrays/dieser Matrix mit sortierten Indizes zurück.

sqrt()

Elementweise Quadratwurzel.

sum([axis, dtype, out])

Summiert die Elemente des Arrays/der Matrix über eine gegebene Achse.

sum_duplicates()

Entfernt Duplikateinträge, indem sie addiert werden.

tan()

Elementweise Tangens.

tanh()

Elementweise Tangens hyperbolicus.

toarray([order, out])

Gibt eine dichte ndarray-Darstellung dieses Sparse Arrays/dieser Sparse Matrix zurück.

tobr([blocksize, copy])

Konvertiert dieses Array/diese Matrix in das Block Sparse Row (BSR)-Format.

tocoo([copy])

Konvertiert dieses Array/diese Matrix in das COOrdinate (COO)-Format.

tocsc([copy])

Konvertiert dieses Array/diese Matrix in das Compressed Sparse Column (CSC)-Format.

tocsr([copy])

Konvertiert dieses Array/diese Matrix in das Compressed Sparse Row (CSR)-Format.

todense([order, out])

Gibt eine dichte Darstellung dieses Sparse Arrays zurück.

todia([copy])

Konvertiert dieses Array/diese Matrix in das sparse DIAgonal-Format.

todok([copy])

Konvertiert dieses Array/diese Matrix in das Dictionary Of Keys (DOK)-Format.

tolil([copy])

Konvertiert dieses Array/diese Matrix in das List of Lists (LIL)-Format.

trace([offset])

Gibt die Summe entlang der Diagonalen des Sparse Arrays/der Sparse Matrix zurück.

transpose([axes, copy])

Kehrt die Dimensionen des Sparse Arrays/der Sparse Matrix um.

trunc()

Elementweise Trunkierung.

__getitem__

__mul__

Hinweise

Sparse Arrays können in arithmetischen Operationen verwendet werden: sie unterstützen Addition, Subtraktion, Multiplikation, Division und Matrizenpotenz.

Vorteile des CSR-Formats

  • effiziente arithmetische Operationen CSR + CSR, CSR * CSR, etc.

  • effizientes Zeilenslicing

  • schnelle Matrix-Vektor-Produkte

Nachteile des CSR-Formats

  • langsame Spaltenslicing-Operationen ( CSC in Betracht ziehen)

  • Änderungen an der Sparsity-Struktur sind teuer (erwägen Sie LIL oder DOK)

Kanonisches Format

  • Innerhalb jeder Zeile sind die Indizes nach Spalte sortiert.

  • Es gibt keine doppelten Einträge.

Beispiele

>>> import numpy as np
>>> from scipy.sparse import csr_array
>>> csr_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]], dtype=int8)

>>> row = np.array([0, 0, 1, 2, 2, 2])
>>> col = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_array((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 2],
       [0, 0, 3],
       [4, 5, 6]])

>>> indptr = np.array([0, 2, 3, 6])
>>> indices = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_array((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 2],
       [0, 0, 3],
       [4, 5, 6]])

Doppelte Einträge werden summiert.

>>> row = np.array([0, 1, 2, 0])
>>> col = np.array([0, 1, 1, 0])
>>> data = np.array([1, 2, 4, 8])
>>> csr_array((data, (row, col)), shape=(3, 3)).toarray()
array([[9, 0, 0],
       [0, 2, 0],
       [0, 4, 0]])

Als Beispiel dafür, wie ein CSR-Array inkrementell aufgebaut werden kann, baut der folgende Snippet ein Term-Dokument-Array aus Texten auf.

>>> docs = [["hello", "world", "hello"], ["goodbye", "cruel", "world"]]
>>> indptr = [0]
>>> indices = []
>>> data = []
>>> vocabulary = {}
>>> for d in docs:
...     for term in d:
...         index = vocabulary.setdefault(term, len(vocabulary))
...         indices.append(index)
...         data.append(1)
...     indptr.append(len(indices))
...
>>> csr_array((data, indices, indptr), dtype=int).toarray()
array([[2, 1, 0, 0],
       [0, 1, 1, 1]])
Auf dieser Seite