pour une matrice 2D donnée np.array ([[[[[1,1], [2,0,5]]) code> Si l'on doit calculer le max de chaque ligne dans une matrice En excluant sa propre colonne, avec l'exemple attendu retour np.array ([[[[3,1,3], [5,5,2]]) code>, quel serait le moyen le plus efficace de le faire?
Actuellement, je l'ai mis en place avec une boucle pour exclure son propre index de col: n=x.shape[0]
row_max_mat=np.zeros((n,n))
rng=np.arange(n)
for i in rng:
row_max_mat[:,i] = np.amax(s_a_array_sum[:,rng!=i],axis=1)
4 Réponses :
Vous pouvez le faire en utilisant np.accumuler. Calculez les accumulations avant et arrière des maximums le long de l'axe horizontal, puis combinez-les avec un décalage d'un: Ceci nécessitera 3x la taille de votre matrice à traiter (bien que vous puissiez prendre ce problème. jusqu'à 2x si vous voulez une mise à jour sur place). L'ajout d'une dimension 3ème et 4ème pourrait également fonctionner à l'aide d'un masque mais qui nécessitera des colonnes ^ 2 fois la taille de la matrice à traiter et sera probablement plus lente. Si nécessaire, vous pouvez appliquer la même colonne technique sage ou aux deux dimensions. (en combinant des résultats sage sur la ligne et la colonne).
a = np.array([[1,3,1],[2,0,5]]) row_max = a.max(axis=1).reshape(-1,1) b = (((a // row_max)+1)%2) c = b*row_max d = (a // row_max)*((a*b).max(axis=1).reshape(-1,1)) c+d # result
idée similaire à la vôtre (exclure des colonnes une par une), mais avec indexation: sortie:
Étant donné que, nous cherchons à obtenir Max excluant sa propre colonne, la sortie aurait essentiellement une rangée remplie de la position max, à l'exception de la position de l'élément maximum, pour laquelle nous devrons remplir avec la deuxième plus grande valeur la plus grande valeur. . En tant que tel, argpartition code> a > semble aller juste là-bas. Donc, voici une solution avec elle - In [54]: import benchit
In [55]: funcs = [max_exclude_own_col, max_accum]
In [170]: inputs = [np.random.randint(0,100,(100000,n)) for n in [10, 20, 50, 100, 200, 500]]
In [171]: T = benchit.timings(funcs, inputs, indexby='shape')
In [172]: T
Out[172]:
Functions max_exclude_own_col max_accum
Shape
100000x10 0.017721 0.014580
100000x20 0.028078 0.028124
100000x50 0.056355 0.089285
100000x100 0.103563 0.200085
100000x200 0.188760 0.407956
100000x500 0.439726 0.976510
# Speedups with max_exclude_own_col over max_accum
In [173]: T.speedups(ref_func_by_index=1)
Out[173]:
Functions max_exclude_own_col Ref:max_accum
Shape
100000x10 0.822783 1.0
100000x20 1.001660 1.0
100000x50 1.584334 1.0
100000x100 1.932017 1.0
100000x200 2.161241 1.0
100000x500 2.220725 1.0
Qu'en est-il de la méthode de Quang?
@ROGANJOSH prenait trop de temps sur ces grands tableaux. Par conséquent, ce commentaire - Autre solution de fonctionnement pour les grandes matrices .
Hein, ok. Olyball, je ne vois pas ce qui explose dans leur approche. Toute idée? (Mise à côté, merci pour Benchit - a l'air cool!)
@ROGANJOSH C'est l'œil annuel avec np.where (masque) le souffle avec des tableaux de taille 1000x1000 ou de taille plus grande. Appréciez les commentaires sur Benchit, l'accent était mis sur le travail de configuration minimale pour obtenir des horaires! :)