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.