Remplacer tous les éléments de Python Tableau NumPy qui sont supérieures à la valeur

J'ai un 2D tableau NumPy et à remplacer toutes les valeurs supérieures ou égales à un seuil T avec 255.0. À ma connaissance, le moyen le plus fondamental serait:

shape = arr.shape
result = np.zeros(shape)
for x in range(0, shape[0]):
    for y in range(0, shape[1]):
        if arr[x, y] >= T:
            result[x, y] = 255

Ce qui est le plus concis et pythonic façon de le faire?
Est-il plus rapide (peut-être moins, concis et/ou moins pythonic) façon de le faire?

Ce sera une partie d'une fenêtre de réglage du niveau de sous-routine pour les examens par IRM de la tête humaine. La 2D tableau numpy est le pixel de l'image des données.

Pour plus d'informations, jetez un coup d'oeil à cette intro à l'indexation.

InformationsquelleAutor NLi10Me | 2013-10-29

264

Je pense qu'à la fois la plus rapide et la plus concise façon de le faire est d'utiliser NumPy intégré dans la Fantaisie de l'indexation. Si vous avez un ndarray nommé arr, vous pouvez remplacer tous les éléments >255 avec une valeur x comme suit:
```
arr[arr > 255] = x
```
J'ai couru ce sur ma machine avec un 500 x 500 matrice aléatoire, le remplacement de toutes les valeurs >de 0,5 à 5, et il a fallu une moyenne de 7.59 ms.
```
In [1]: import numpy as np
In [2]: A = np.random.rand(500, 500)
In [3]: timeit A[A > 0.5] = 5
100 loops, best of 3: 7.59 ms per loop
```
- passons sur le fait qu'il fonctionne très bien avec de multiples dimensions
- Notez que cela modifie le tableau existant arr, au lieu de créer un result tableau comme dans l'OP.
- Est-il un moyen de faire ça en ne modifiant A mais la création d'un nouveau tableau?
- Que ferions-nous, si nous voulions changer les valeurs des indices qui sont des multiples de n, comme un[2], [4],un[6], [8]..... pour n=2?
- 100 boucles, best of 3: 2.22 ms par boucle
- REMARQUE: cela ne fonctionne pas si les données sont dans une liste python, il doit être dans un tableau numpy (np.array([1,2,3])
- np.place de la méthode la plus rapide que cela. timeit Une[A>0.5] = 5 :- 1.79 ms ± 6.63 µs par boucle (moyenne ± std. dev. de 7 pistes, 1000 boucles de chaque) et timeit np.lieu de(A, A>0, 5) :- 732 µs ± 5.89 µs par boucle (moyenne ± std. dev. de 7 pistes, 1000 boucles de chaque)
InformationsquelleAutor mdml
40

Puisque vous voulez vraiment un autre tableau qui est arr où arr < 255, et 255 sinon, cela peut être fait simplement:
```
result = np.minimum(arr, 255)
```
Plus généralement, pour l'une inférieure et/ou supérieure lié:
```
result = np.clip(arr, 0, 255)
```
Si vous voulez juste pour accéder aux valeurs supérieures à 255, ou quelque chose de plus compliqué, @mtitan8 la réponse est plus général, mais np.clip et np.minimum (ou np.maximum) sont plus agréable et beaucoup plus rapide pour votre cas:
```
In [292]: timeit np.minimum(a, 255)
100000 loops, best of 3: 19.6 µs per loop

In [293]: %%timeit
   .....: c = np.copy(a)
   .....: c[a>255] = 255
   .....: 
10000 loops, best of 3: 86.6 µs per loop
```
Si vous voulez le faire sur place (c'est à dire, de modifier arr au lieu de créer result), vous pouvez utiliser le out paramètre de np.minimum:
```
np.minimum(arr, 255, out=arr)
```
ou
```
np.clip(arr, 0, 255, arr)
```
(le out= nom est facultatif puisque les arguments dans le même ordre que la définition de la fonction.)

En cours de modification, le booléen indexation des vitesses beaucoup (sans avoir à faire, puis modifier la copie séparément), mais n'est pas encore aussi rapide que minimum:
```
In [328]: %%timeit
   .....: a = np.random.randint(0, 300, (100,100))
   .....: np.minimum(a, 255, a)
   .....: 
100000 loops, best of 3: 303 µs per loop

In [329]: %%timeit
   .....: a = np.random.randint(0, 300, (100,100))
   .....: a[a>255] = 255
   .....: 
100000 loops, best of 3: 356 µs per loop
```
À des fins de comparaison, si vous souhaitez limiter vos valeurs avec un minimum ainsi qu'un maximum, sans clip vous devez le faire deux fois, avec quelque chose comme
```
np.minimum(a, 255, a)
np.maximum(a, 0, a)
```
ou,
```
a[a>255] = 255
a[a<0] = 0
```
- Merci beaucoup pour votre commentaire, cependant np.clip et np.minimum ne semble pas être ce dont j'ai besoin dans ce cas, dans l'OP, vous voyez que le seuil T et la valeur de remplacement (255) ne sont pas nécessairement le même nombre. Cependant je continue de vous a donné un vote pour la perfection. Merci encore.
- Que ferions-nous, si nous voulions changer les valeurs des indices qui sont des multiples de n, comme un[2], [4],un[6], [8]..... pour n=2?
- pour ce faire, vous pouvez utiliser la troisième partie de la tranche, qui est généralement négligé: a[start:stop:step] vous donne les éléments de la matrice de start à stop, mais à la place de chaque élément, il faut que tous les step (si elle est négligée, il est 1 par défaut). Afin de définir toutes les evens à zéro, vous pourriez faire a[::2] = 0
- Merci, j'ai besoin de quelque chose, comme ça, même si je le savais pour les listes simples, mais je ne sais pas si, ou comment il fonctionne pour numpy.tableau.
InformationsquelleAutor askewchan
10

Je pense que vous pouvez réaliser cela le plus rapidement à l'aide de la where fonction:

Par exemple à la recherche pour les articles de plus de 0,2 dans un tableau numpy et le remplacement de ceux qui ont 0:
```
import numpy as np

nums = np.random.rand(4,3)

print np.where(nums > 0.2, 0, nums)
```
InformationsquelleAutor Amir F

Vous pouvez envisager d'utiliser des numpy.putmask:

np.putmask(arr, arr>=T, 255.0)

Voici une comparaison de performances avec le Numpy est builtin indexation:

In [1]: import numpy as np
In [2]: A = np.random.rand(500, 500)

In [3]: timeit np.putmask(A, A>0.5, 5)
1000 loops, best of 3: 1.34 ms per loop

In [4]: timeit A[A > 0.5] = 5
1000 loops, best of 3: 1.82 ms per loop

Ne fonctionne pas si vous avez ndarray de taille >=3.

InformationsquelleAutor lev

8

Une autre façon est d'utiliser des np.place qui fait à l'endroit de remplacement et travaille avec multidimentional tableaux:
```
import numpy as np

arr = np.arange(6).reshape(2, 3)
np.place(arr, arr == 0, -10)
```
- C'est la solution que j'ai utilisé, car il a été le premier je suis venu à travers. Je me demande si il y a une grande différence entre ça et la réponse sélectionnée ci-dessus. Qu'en pensez-vous?
- Dans ma très limité des tests, mon code ci-dessus avec np.le lieu est en cours d'exécution 2X plus lent que accepté de réponse de la méthode d'indexation directe. C'est surprenant parce que j'aurais pensé np.place serait plus optimisé, mais je suppose qu'ils ont sans doute mis plus de travail sur l'indexation directe.
InformationsquelleAutor Shital Shah
2

Vous pouvez également utiliser &, | (et/ou) pour plus de flexibilité:

des valeurs entre 5 et 10: A[(A>5)&(A<10)]

des valeurs supérieures à 10 ou plus petit que 5: A[(A<5)|(A>10)]

InformationsquelleAutor Mahdi Shahbaba

Vous devez vous connecter pour publier un commentaire.