Enregistrement rapide pour NaN dans NumPy

Je suis à la recherche de la façon la plus rapide pour vérifier l'apparition de NaN (np.nan) dans un tableau NumPy X. np.isnan(X) est hors de question, car elle construit un booléen tableau de forme X.shape, qui est potentiellement gigantesque.

J'ai essayé np.nan in X, mais qui ne semble pas fonctionner, car np.nan != np.nan. Est-il rapide et efficace de la mémoire manière de faire tout cela?

(Pour ceux qui se demandent "comment gigantesque": je ne peux pas dire. C'est la validation d'entrée pour le code de bibliothèque.)

ne la validation de la saisie de l'utilisateur ne fonctionnent pas dans ce scénario? Comme dans vérifier NaN avant de l'insérer
non, la bibliothèque prend des tableaux NumPy ou scipy.sparse de matrices d'entrée.
Si vous êtes en train de faire beaucoup, j'ai entendu de bonnes choses au sujet de Goulot d'étranglement (pypi.python.org/pypi/Bottleneck)

InformationsquelleAutor Fred Foo | 2011-07-18

142

Ray solution est bonne. Cependant, sur ma machine, il est d'environ 2,5 x plus rapide à utiliser numpy.somme en place de numpy.min:
```
In [13]: %timeit np.isnan(np.min(x))
1000 loops, best of 3: 244 us per loop

In [14]: %timeit np.isnan(np.sum(x))
10000 loops, best of 3: 97.3 us per loop
```
Contrairement à min, sum ne nécessite pas de branchement, qui sur le matériel moderne a tendance à être assez cher. C'est probablement la raison pour laquelle sum est plus rapide.

modifier Le test ci-dessus a été réalisée avec un seul NaN droit dans le milieu du tableau.

Il est intéressant de noter que min est plus lente en présence de NaNs qu'en leur absence. Il semble également obtenir plus lent que NaNs obtenir plus près du début du tableau. D'autre part, sum's le débit semble constant, indépendamment de savoir si il y a des NaNs et où ils sont situés:
```
In [40]: x = np.random.rand(100000)

In [41]: %timeit np.isnan(np.min(x))
10000 loops, best of 3: 153 us per loop

In [42]: %timeit np.isnan(np.sum(x))
10000 loops, best of 3: 95.9 us per loop

In [43]: x[50000] = np.nan

In [44]: %timeit np.isnan(np.min(x))
1000 loops, best of 3: 239 us per loop

In [45]: %timeit np.isnan(np.sum(x))
10000 loops, best of 3: 95.8 us per loop

In [46]: x[0] = np.nan

In [47]: %timeit np.isnan(np.min(x))
1000 loops, best of 3: 326 us per loop

In [48]: %timeit np.isnan(np.sum(x))
10000 loops, best of 3: 95.9 us per loop
```
- np.min est plus rapide lorsque le tableau contient pas de NaNs, qui est ma contribution qui est attendue. Mais j'ai décidé d'accepter celle-ci de toute façon, parce qu'il attrape inf et neginf ainsi.
- Cela ne les captures inf ou -inf si l'entrée contient à la fois, et il a des problèmes si l'entrée contient un grand mais fini valeurs de dépassement lorsqu'on les additionne.
- min et max n'a pas besoin de la branche pour les données à virgule flottante sur l'ess capable puces x86. Afin de numpy 1,8 min ne sera pas plus lent que la somme, sur mon amd phenom son même 20% plus vite.
- Sur mon Intel Core i5, avec numpy 1.9.2 sur OSX, np.sum est encore d'environ 30% plus rapide que np.min.
- np.isnan(x).any(0) est légèrement plus rapide que np.sum et np.min sur ma machine, même s'il pourrait être non désirés de la mise en cache.
- Ou vous pouvez utiliser sum() au lieu de np.somme , qui peut être beaucoup beaucoup plus rapide. (dans mon cas, 1/10ème)
- Informations supplémentaires pour les gens qui se demandent pourquoi sum() est plus rapide: stackoverflow.com/q/22392185/974555
InformationsquelleAutor NPE
24

Je pense que np.isnan(np.min(X)) devrait faire ce que vous voulez.
- Hmmm... c'est toujours en O(n) quand est-ce pourrait être O(1) (pour certains tableaux).
InformationsquelleAutor Ray
17

Même, il existe un acceptées réponse, je vais, comme pour démontrer que la suite (avec Python 2.7.2 et Numpy 1.6.0 sur Vista):
```
In []: x= rand(1e5)
In []: %timeit isnan(x.min())
10000 loops, best of 3: 200 us per loop
In []: %timeit isnan(x.sum())
10000 loops, best of 3: 169 us per loop
In []: %timeit isnan(dot(x, x))
10000 loops, best of 3: 134 us per loop

In []: x[5e4]= NaN
In []: %timeit isnan(x.min())
100 loops, best of 3: 4.47 ms per loop
In []: %timeit isnan(x.sum())
100 loops, best of 3: 6.44 ms per loop
In []: %timeit isnan(dot(x, x))
10000 loops, best of 3: 138 us per loop
```
Ainsi, la façon vraiment efficace pourrait être fortement dépendant du système d'exploitation. De toute façon dot(.) base semble être la plus stable.
- Je pense qu'elle ne dépend pas tant de l'OS, comme sur le sous-jacent BLAS de mise en œuvre et le compilateur C. Merci, mais un produit scalaire est un tout petit peu plus susceptibles de déborder lorsqu'il x contient de grandes valeurs, et je tiens également à vérifier inf.
- Eh bien, vous pouvez toujours faire le produit scalaire avec ceux et utiliser isfinite(.). Je voulais juste souligner l'énorme écart de performance. Merci
- Le même sur ma machine.
- Intelligent, non? en tant Que Fred Foo le suggère, tout gain d'efficacité du produit scalaire approche fondée sur sont presque certainement grâce à un local NumPy d'installation liés à l'encontre d'un optimisée BLAS de mise en œuvre comme ATLAS, MKL, ou OpenBLAS. C'est le cas pour Anaconda, par exemple. Étant donné que, de ce point de produit seront mises en parallèle sur tous les cœurs disponibles. Le même pas pour la min- ou sumbasée sur les approches, qui se limite à un seul noyau. Ergo, que l'écart de performances.
InformationsquelleAutor eat
8

Il existe deux approches générales ici:
- Vérifier chaque élément de tableau pour nan et prendre any.
- Appliquer certaines cumulative de fonctionnement qui préserve nans (comme sum) et vérifier son état.
Alors que la première approche est certainement le plus propre, le lourd optimisation de certains de l'ensemble des opérations (en particulier ceux qui sont exécutés dans les BLAS, comme dot) permet de le faire assez rapidement. Notez que dot, à l'instar de certains autres BLAS, sont multithread sous certaines conditions. C'est ce qui explique la différence de vitesse entre les différentes machines.
```
import numpy
import perfplot


def min(a):
    return numpy.isnan(numpy.min(a))


def sum(a):
    return numpy.isnan(numpy.sum(a))


def dot(a):
    return numpy.isnan(numpy.dot(a, a))


def any(a):
    return numpy.any(numpy.isnan(a))


def einsum(a):
    return numpy.isnan(numpy.einsum('i->', a))


perfplot.show(
    setup=lambda n: numpy.random.rand(n),
    kernels=[min, sum, dot, any, einsum],
    n_range=[2**k for k in range(20)],
    logx=True,
    logy=True,
    xlabel='len(a)'
    )
```
InformationsquelleAutor Nico Schlömer

Si vous êtes à l'aise avec numba il permet de créer un rapide court-circuit (s'arrête dès qu'on trouve un NaN) fonction:

import numba as nb
import math

@nb.njit
def anynan(array):
    array = array.ravel()
    for i in range(array.size):
        if math.isnan(array[i]):
            return True
    return False

Si il n'y a pas de NaN la fonction pourrait en fait être plus lent que np.min, je pense que c'est parce que np.min utilise le multitraitement pour de grands tableaux:

import numpy as np
array = np.random.random(2000000)

%timeit anynan(array)          # 100 loops, best of 3: 2.21 ms per loop
%timeit np.isnan(array.sum())  # 100 loops, best of 3: 4.45 ms per loop
%timeit np.isnan(array.min())  # 1000 loops, best of 3: 1.64 ms per loop

Mais dans le cas où il y a un NaN dans le tableau, surtout si c'est la position à de faibles indices, alors c'est beaucoup plus rapide:

array = np.random.random(2000000)
array[100] = np.nan

%timeit anynan(array)          # 1000000 loops, best of 3: 1.93 µs per loop
%timeit np.isnan(array.sum())  # 100 loops, best of 3: 4.57 ms per loop
%timeit np.isnan(array.min())  # 1000 loops, best of 3: 1.65 ms per loop

Des résultats similaires peuvent être obtenus avec Cython ou un C extension, ce sont un peu plus compliqué (ou facilement disponibles comme goulot d'étranglement.anynan) mais ultimatly faire la même chose que mon anynan fonction.

InformationsquelleAutor MSeifert

2
1. utilisation .tout()
  
  if numpy.isnan(myarray).any()
2. numpy.isfinite peut-être mieux que isnan pour la vérification de
  
  if not np.isfinite(prop).all()
InformationsquelleAutor woso
1

Est lié à ce que la question de la façon de trouver la première occurrence de NaN. C'est le moyen le plus rapide pour gérer ce que je connais:
```
index = next((i for (i,n) in enumerate(iterable) if n!=n), None)
```
InformationsquelleAutor vitiral

Vous devez vous connecter pour publier un commentaire.