[PYTHON] Berechnungsgeschwindigkeit der Indizierung für ein numpy quadratisches Array

Erwägen Sie ein numpy quadratisches Array und indizieren Sie Zeilen und Spalten wie folgt: (In der folgenden Abbildung versuchen wir, [[9, 12], [21, 24]] aus einer quadratischen 6x6-Sequenz zu extrahieren.)

Zu diesem Zeitpunkt gab es je nach Berechnungsmethode einen erheblichen Geschwindigkeitsunterschied!

#Extrahieren Sie zufällige Zeilen- und Spaltenelemente aus einem riesigen quadratischen Array
import numpy as np

N = 10000
X = np.arange(N ** 2).reshape(N, N)

M = 100
a = np.random.choice(N, M)
b = np.random.choice(N, M)

%timeit Y1 = X[a][:, b] 
#Ausführungsbeispiel) 1.09 ms ± 243 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit Y2 = X[a[:, np.newaxis], b]
#Ausführungsbeispiel) 66.8 µs ± 1.56 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Die Berechnung von "X [a [:, np.newaxis], b]" ist überwältigend schneller als die Berechnung von "X [a] [:, b]".

Das Folgende ist ein Schlangenfuß, aber da es schwierig war, das quadratische Array wie in der obigen Abbildung gezeigt zu indizieren, werde ich die Drehungen und Wendungen bis zu diesem Punkt belassen.

Für Slice

In diesem Fall ist es einfach

import numpy as np
N = 10000
X = np.arange(N ** 2).reshape(N, N)

a = np.s_[0:100]      #Schneiden Sie über die Linie
b = np.s_[100:300]    #Schneiden Sie über die Säule
#Geschnittenes Ergebnis
Y = X[a, b]           # Y.shape = (100,200)

Kann ausgedrückt werden als. Wenn Sie jedoch versuchen, Zeilen und Spalten flexibler zu extrahieren, gibt es eine Grenze für das Schneiden.

Im Falle einer Indizierung (Fehlerbeispiel)

Wenn Sie versuchen, dasselbe wie oben zu tun, funktioniert es nicht wirklich.

import numpy as np
N = 10000
X = np.arange(N ** 2).reshape(N, N)

a = np.arange(0,100)       #Indizierung über Zeilen
b = np.arange(100, 300)    #Indizierung auf Spalten
#Indizierungsergebnis
Y = X[a, b]           #Fehler tritt auf

Bei der Indizierung eines zweidimensionalen Arrays wie oben müssen a und b Arrays gleicher Länge sein. Das folgende Array wird auch dann zurückgegeben, wenn es dieselbe Länge hat.

import numpy as np
N = 10000
X = np.arange(N ** 2).reshape(N, N)

a = np.arange(3)      #Indizierung über Zeilen
b = np.arange(3)      #Indizierung auf Spalten
#Indizierungsergebnis
Y = X[a, b]           #Ergebnis: [0, 10001, 20002]

Es ist genau wie "Y [i] = X [a [i], b [i]]".

Indizierung (Erfolgsbeispiel)

Da die obige Methode nutzlos ist, konnte ich wie erwartet durch Umschreiben wie folgt indizieren.

import numpy as np
N = 10000
X = np.arange(N ** 2).reshape(N, N)

a = np.arange(0,100)       #Indizierung über Zeilen
b = np.arange(100, 300)    #Indizierung auf Spalten
#Indizierungsergebnis
Y = X[a][:, b]           

Beim Lesen der numpy-Dokumentation fand ich jedoch die folgende Beschreibung.

So note that x[0,2] = x[0][2] though the second case is more inefficient as a new temporary array is created after the first index that is subsequently indexed by 2.

Mit anderen Worten, durch Setzen von "X [a]" wird ein temporäres Array erzeugt, das ineffizient zu sein scheint. Wie im Code am Anfang gezeigt, hat die quadratische Sequenz umso mehr Einfluss auf die Berechnungszeit, je größer sie ist.

Wiederum ist die endgültige Indizierungsmethode wie folgt.

import numpy as np
N = 10000
X = np.arange(N ** 2).reshape(N, N)

a = np.arange(0,100)       #Indizierung über Zeilen
b = np.arange(100, 300)    #Indizierung auf Spalten
#Indizierungsergebnis
Y = X[a[:, np.newaxis], b]           

Das ist alles für mich. Es ist ein Ergebnis von Versuch und Irrtum. Bitte lassen Sie mich wissen, ob es eine effizientere Methode gibt.