Wie extrahiere ich Subarrays mit einem bestimmten Schritt effizient aus einem NumPy-Array?

Effiziente Übernahme von Subarrays aus dem Numpy-Array mit gegebener Schrittweite/Schrittgröße

In der Welt der Datenanalyse müssen wir Subarrays oft mit bestimmten Schritten extrahieren Schritte oder Schrittgrößen aus einem größeren Array. Numpy, die beliebte Python-Bibliothek für numerische Operationen, bietet mehrere Methoden, um dies effizient zu erreichen.

Problemstellung:
Gegeben ein Numpy-Array, möchten wir eine Matrix von Unterarrays von extrahieren eine feste Länge mit einer bestimmten Schrittweite oder Schrittgröße. Ein Schritt ist der Abstand zwischen den Anfängen aufeinanderfolgender Subarrays.

Diskussion:

Eine einfache Möglichkeit, Subarrays zu erstellen, besteht darin, mithilfe einer for-Schleife über das ursprüngliche Array zu iterieren . Obwohl dieser Ansatz funktioniert, kann er bei großen Arrays langsam sein.

Ansatz 1: Broadcasting

Der Broadcasting-Mechanismus von NumPy ermöglicht es uns, Subarrays ohne Schleifen zu erstellen. Wir können die folgende Funktion verwenden, die das Array, die Subarray-Länge (L) und den Schritt (S) übernimmt:

def broadcasting_app(a, L, S):
    nrows = ((a.size - L) // S) + 1
    return a[S * np.arange(nrows)[:, None] + np.arange(L)]

Erklärung:
np.arange(nrows) erstellt ein Array von Indizes mit einer Schrittweite von 1. Durch Multiplikation mit S erhalten wir die Startindizes jedes Subarrays. Anschließend senden wir diese Indizes über die Zeilen von a, um die Subarrays zu erhalten.

Ansatz 2: NumPy Strides

Eine weitere effiziente Methode nutzt die Strides-Funktion von NumPy. Schritte stellen die Anzahl der Bytes zwischen aufeinanderfolgenden Elementen entlang jeder Achse dar. Wir können diese Informationen verwenden, um Subarrays zu erstellen:

def strided_app(a, L, S):
    nrows = ((a.size - L) // S) + 1
    n = a.strides[0]
    return np.lib.stride_tricks.as_strided(a, shape=(nrows, L), strides=(S * n, n))

Erklärung:
Wir verwenden np.lib.stride_tricks.as_strided, um a umzuformen, indem wir seine Schritte ausnutzen. Das resultierende Array hat die gewünschte Anzahl von Zeilen (nrows) und Subarray-Länge (L), während die Schrittweite von S beibehalten wird.

Beispielcode:

Zur Veranschaulichung Ansätze:

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

print(broadcasting_app(a, L=5, S=3))
print(strided_app(a, L=5, S=3))

Ausgabe:

[[ 1  2  3  4  5]
 [ 4  5  6  7  8]
 [ 7  8  9 10 11]]
[[ 1  2  3  4  5]
 [ 4  5  6  7  8]
 [ 7  8  9 10 11]]

Beide Ansätze generieren effizient die Matrix von Subarrays mit der gewünschten Schrittweite.

Das obige ist der detaillierte Inhalt vonWie extrahiere ich Subarrays mit einem bestimmten Schritt effizient aus einem NumPy-Array?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!