Trouvez le plus petit index qui atteint le seuil de somme cumulée avec numpy

Je l'utilise beaucoup, mais je l'oublie souvent, alors prenez note

Conclusion d'abord

```Argmax () `` Cela fonctionne bien lorsqu'il est utilisé.

Chose que tu veux faire

Le titre peut être difficile à comprendre, alors expliquez ce que vous voulez faire en détail. Pour numpy.array '', vous voudrez peut-être calculer la somme cumulée ( cumsum '') et trouver le plus petit indice qui dépasse le seuil de la somme cumulée. Par exemple

In [143]: score
Out[143]: 
array([[  1.05262936e-01,   1.05262936e-01,   1.05262936e-01,
          1.05262936e-01,   1.05262936e-01,   1.57894404e-01,
          1.05262936e-01,   1.05262936e-01,   2.10525873e-06,
          1.05262936e-01],
       [  1.66664722e-01,   1.66664722e-06,   1.66664722e-01,
          2.49997083e-01,   1.66664722e-06,   2.49997083e-01,
          1.66664722e-01,   3.33329444e-06,   3.33329444e-06,
          1.66664722e-06],
       [  9.09090909e-02,   9.09090909e-02,   9.09090909e-02,
          9.09090909e-02,   9.09090909e-02,   1.21212121e-01,
          1.21212121e-01,   9.09090909e-02,   9.09090909e-02,
          1.21212121e-01]])

In [144]: score.shape
Out[144]: (3, 10)

S'il existe un «tableau» comme celui-ci, la somme cumulée de ce

In [145]: score.cumsum(1)
Out[145]: 
array([[ 0.10526294,  0.21052587,  0.31578881,  0.42105175,  0.52631468,
         0.68420909,  0.78947202,  0.89473496,  0.89473706,  1.        ],
       [ 0.16666472,  0.16666639,  0.33333111,  0.58332819,  0.58332986,
         0.83332694,  0.99999167,  0.999995  ,  0.99999833,  1.        ],
       [ 0.09090909,  0.18181818,  0.27272727,  0.36363636,  0.45454545,
         0.57575758,  0.6969697 ,  0.78787879,  0.87878788,  1.        ]])

Sont des seuils

In [149]: threshold = np.random.random((3, 1))

In [150]: threshold
Out[150]: 
array([[ 0.62732896],
       [ 0.46494853],
       [ 0.54341381]])

Je veux le plus petit index parmi les plus grands éléments. Dans cet exemple, ce sera score [0, 5], score [1, 3], score [2, 5] '', donc si vous obtenez le résultat de [5, 3, 5] '' Bien.

Donc, revenant à la première conclusion, en utilisant ```argmaxde numpy``, j'ai obtenu le résultat que je voulais pour une bonne prune de sel.

In [155]: score.cumsum(1) > threshold
Out[155]: 
array([[False, False, False, False, False,  True,  True,  True,  True,
         True],
       [False, False, False,  True,  True,  True,  True,  True,  True,
         True],
       [False, False, False, False, False,  True,  True,  True,  True,
         True]], dtype=bool)

In [156]: np.argmax(score.cumsum(1) > threshold, 1)
Out[156]: array([5, 3, 5], dtype=int64)

«Argmax» semble renvoyer le plus petit index parmi les index qui prennent la valeur maximale.

Pourtant. .. ..

Au contraire, il était impossible de trouver l'indice maximum parmi les éléments inférieurs au seuil. Je veux `` [4, 3, 4] ''

In [176]: score.cumsum(1) < threshold
Out[176]: 
array([[ True,  True,  True,  True,  True, False, False, False, False,
        False],
       [ True,  True,  True, False, False, False, False, False, False,
        False],
       [ True,  True,  True,  True,  True, False, False, False, False,
        False]], dtype=bool)

In [178]: np.argmin(score.cumsum(1) < threshold, 1)
Out[178]: array([5, 3, 5], dtype=int64)

In [179]: np.argmax(score.cumsum(1) < threshold, 1)
Out[179]: array([0, 0, 0], dtype=int64)

Ce sera comme ça.

Est-ce juste de demander quelque chose de cool comme `` np.where ''? S'il vous plaît laissez-moi savoir si quelqu'un a des conseils intéressants.

Recommended Posts

Trouvez le plus petit index qui atteint le seuil de somme cumulée avec numpy
Trouvez la position au-dessus du seuil avec NumPy
Calculer la somme des valeurs uniques par tabulation croisée des pandas
Résolution du plus petit indice numba du monde avec Numpy & Numba
[Python] Trouvez la deuxième plus petite valeur.
Trouvez la distance d'édition (distance de Levenshtein) avec python
Trouvez la broche inertielle et le moment d'inertie principal à partir du tenseur inertiel avec NumPy