Was ist der Schnellste Weg, um schneiden Sie ein scipy.sparse-matrix?

Verwende ich normalerweise

matrix[:, i:]

Scheint es nicht so schnell arbeiten, wie ich es erwartet habe.

  • Sinn des benchmarking ist es für uns? vielleicht sogar timeit?
InformationsquelleAutor todpole3 | 2012-12-12
  1. 13

    Wenn Sie eine sparse-matrix, die Ausgabe der Schnellste Weg, um Zeilen schneiden, ist eine csr geben, und für Spalten schneiden csc, wie hier beschrieben. In beiden Fällen müssen Sie nur das zu tun, was Sie gerade tun:

    matrix[l1:l2,c1:c2]

    Wenn Sie möchten, eine andere Art als Ausgang gibt es vielleicht schnellere Wege. In dieser anderen Antwort es erklärt viele Methoden, die für das schneiden von einer matrix und Ihrer unterschiedlichen timings im Vergleich. Zum Beispiel, wenn Sie möchten, eine ndarray als Ausgabe die Schnellste slicing:

    matrix.A[l1:l2,c1:c2]

    oder:

    matrix.toarray()[l1:l2,c1:c2]

    viel schneller als:

    matrix[l1:l2,c1:c2].A #or .toarray()
    • Aber matrix.Eine führt zu memoryError, wenn die matrix sehr groß ist.
    InformationsquelleAutor Saullo G. P. Castro
  2. 4

    Habe ich gefunden, dass das angekündigte schnelle Zeile Indizierung von scipy.sparse.csr_matrix gemacht werden kann, viel schneller, indem Sie Ihre eigenen Rollen Reihe indexer. Hier ist die Idee: 

    class SparseRowIndexer:
    def __init__(self, csr_matrix):
        data = []
        indices = []
        indptr = []

        # Iterating over the rows this way is significantly more efficient
        # than csr_matrix[row_index,:] and csr_matrix.getrow(row_index)
        for row_start, row_end in zip(csr_matrix.indptr[:-1], csr_matrix.indptr[1:]):
             data.append(csr_matrix.data[row_start:row_end])
             indices.append(csr_matrix.indices[row_start:row_end])
             indptr.append(row_end-row_start) # nnz of the row

        self.data = np.array(data)
        self.indices = np.array(indices)
        self.indptr = np.array(indptr)
        self.n_columns = csr_matrix.shape[1]

    def __getitem__(self, row_selector):
        data = np.concatenate(self.data[row_selector])
        indices = np.concatenate(self.indices[row_selector])
        indptr = np.append(0, np.cumsum(self.indptr[row_selector]))

        shape = [indptr.shape[0]-1, self.n_columns]

        return sparse.csr_matrix((data, indices, indptr), shape=shape)

    Ist, ist es möglich zu nutzen, um die schnelle Indizierung der numpy-arrays durch die Speicherung der nicht-null-Werte jeder Zeile in separate arrays (mit einer anderen Länge für jede Zeile) und Stelle alle diese Zeilen-arrays in ein Objekt-Typ-array (so dass jede Zeile eine andere Größe), die indiziert werden können, effizient. Die Spalte Indizes gespeichert werden, auf die gleiche Weise. Der Ansatz ist etwas anders als die standard CSR-Daten-Struktur, die speichert alle nicht-null-Werte in einem array erfordert look-ups, um zu sehen, wo jede Zeile beginnt und endet. Diese look-ups können verlangsamen random access, sollte aber effizient für den Abruf von zusammenhängenden Zeilen.

    Profiling-Ergebnisse

    Meine matrix mat ist eine von 1.900,000x1,250,000 csr_matrix mit 400,000,000 nicht-null-Elemente.
    ilocs ist ein array von 200.000 zufällige Zeilen-Indizes.

    >>> %timeit mat[ilocs]
2.66 s ± 233 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

    gegenüber:

    >>> row_indexer = SparseRowIndexer(mat)
>>> %timeit row_indexer[ilocs]
59.9 ms ± 4.51 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

    Den SparseRowIndexer scheint schneller zu sein als mit fancy indexing im Vergleich zu booleschen Masken.

    InformationsquelleAutor Sorig
Schreibe einen Kommentar