Vitesse de calcul de l'indexation pour un tableau quadratique numpy

Envisagez d'avoir un tableau quadratique numpy et d'indexer les lignes et les colonnes comme suit: (Dans la figure ci-dessous, nous essayons d'extraire [[9, 12], [21, 24]] d'une séquence quadratique 6x6.)

A cette époque, il y avait une différence de vitesse considérable selon la méthode de calcul!

#Extraire des éléments de ligne et de colonne aléatoires d'un énorme tableau quadratique
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] 
#Exemple d'exécution) 1.09 ms ± 243 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit Y2 = X[a[:, np.newaxis], b]
#Exemple d'exécution) 66.8 µs ± 1.56 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Le calcul de X [a [:, np.newaxis], b] est extrêmement plus rapide que le calcul de X [a] [:, b].

Ce qui suit est un pied de serpent, mais comme il était difficile d'indexer le tableau quadratique comme indiqué dans la figure ci-dessus, je laisserai les rebondissements jusqu'à ce point.

Pour tranche

Dans ce cas c'est facile

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

a = np.s_[0:100]      #Tranche sur la ligne
b = np.s_[100:300]    #Tranche sur la colonne
#Résultat tranché
Y = X[a, b]           # Y.shape = (100,200)

Peut être exprimé comme. Cependant, si vous essayez d'extraire les lignes et les colonnes de manière plus flexible, le découpage est limité.

En cas d'indexation (exemple d'échec)

Si vous essayez de faire la même chose que ci-dessus, cela ne fonctionne pas réellement.

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

a = np.arange(0,100)       #Indexation des lignes
b = np.arange(100, 300)    #Indexation sur les colonnes
#Résultat d'indexation
Y = X[a, b]           #Erreur se produit

Lors de l'indexation d'un tableau à deux dimensions comme ci-dessus, a et b doivent être des tableaux de même longueur. En outre, le tableau suivant est renvoyé même s'il a la même longueur.

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

a = np.arange(3)      #Indexation des lignes
b = np.arange(3)      #Indexation sur les colonnes
#Résultat d'indexation
Y = X[a, b]           #résultat: [0, 10001, 20002]

C'est juste comme Y [i] = X [a [i], b [i]].

Indexation (exemple de réussite)

Puisque la méthode ci-dessus est inutile, j'ai pu indexer comme prévu en réécrivant comme suit.

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

a = np.arange(0,100)       #Indexation des lignes
b = np.arange(100, 300)    #Indexation sur les colonnes
#Résultat d'indexation
Y = X[a][:, b]           

Cependant, quand j'ai lu la documentation numpy, j'ai trouvé la description suivante.

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.

En d'autres termes, en définissant X [a], un tableau temporaire est généré, ce qui semble inefficace. En fait, comme indiqué dans le code au début, plus la séquence quadratique est grande, plus elle affecte le temps de calcul.

Là encore, la méthode d'indexation finale est la suivante.

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

a = np.arange(0,100)       #Indexation des lignes
b = np.arange(100, 300)    #Indexation sur les colonnes
#Résultat d'indexation
Y = X[a[:, np.newaxis], b]           

C'est tout pour moi. C'est le résultat d'essais et d'erreurs, alors faites-moi savoir s'il existe une méthode plus efficace.