Vérification rapide des NaN dans NumPy

Question

Je cherche le moyen le plus rapide de vérifier l'occurrence de NaN ( np.nan ) dans un tableau NumPy X . np.isnan(X) est hors de question, puisqu'il construit un tableau booléen de forme X.shape ce qui est potentiellement gigantesque.

J'ai essayé np.nan in X mais cela ne semble pas fonctionner car np.nan != np.nan . Existe-t-il un moyen rapide et peu gourmand en mémoire d'effectuer cette opération ?

(Pour ceux qui demanderaient "à quel point c'est gigantesque" : Je ne peux pas le dire. Il s'agit d'une validation d'entrée pour le code de la bibliothèque).

Answer 1

La solution de Ray est bonne. Cependant, sur ma machine, il est environ 2,5 fois plus rapide d'utiliser numpy.sum à la 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, ce qui, sur le matériel moderne, tend à être assez coûteux. C'est probablement la raison pour laquelle sum est plus rapide.

éditer Le test ci-dessus a été effectué avec un seul NaN au milieu du tableau.

Il est intéressant de noter que min est plus lente en présence de NaNs qu'en leur absence. Elle semble également plus lente lorsque les NaN se rapprochent du début du tableau. D'autre part, sum semble constant, qu'il y ait ou non des NaN et quel que soit l'endroit où ils se trouvent :

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

Answer 2

Je pense que np.isnan(np.min(X)) doit faire ce que vous voulez.

Answer 3

Il existe deux approches générales :

• Vérifier chaque élément du tableau pour nan et prendre any .
• Appliquer une opération cumulative qui préserve nan (comme les sum ) et vérifier son résultat.

Bien que la première approche soit certainement la plus propre, l'optimisation lourde de certaines des opérations cumulatives (en particulier celles qui sont exécutées en BLAS, comme le dot ) peut les fabriquer assez rapidement. Notez que les dot comme d'autres opérations BLAS, sont multithreadées sous certaines conditions. Cela explique la différence de vitesse entre différentes machines.

import numpy as np
import perfplot

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

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

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

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

def einsum(a):
    return np.isnan(np.einsum("i->", a))

b = perfplot.bench(
    setup=np.random.rand,
    kernels=[min, sum, dot, any, einsum],
    n_range=[2 ** k for k in range(25)],
    xlabel="len(a)",
)
b.save("out.png")
b.show()

Answer 4

Même s'il existe une réponse acceptée, j'aimerais démontrer ce qui suit (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 méthode la plus efficace peut dépendre fortement du système d'exploitation. Quoi qu'il en soit dot(.) semble être la plus stable.

Answer 5

Si vous êtes à l'aise avec numba elle permet de créer une fonction de court-circuit rapide (qui s'arrête dès qu'un NaN est trouvé) :

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

S'il n'y a pas de NaN la fonction pourrait en fait être plus lente que np.min Je pense que c'est parce que np.min utilise le multiprocessing pour les 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 sa position est à des indices faibles, 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 une extension C, qui sont un peu plus compliqués (ou facilement disponibles en tant que bottleneck.anynan ) mais en fin de compte faire la même chose que mon anynan fonction.