Control rápido para NaN en NumPy

Creo que np.isnan(np.min(X)) debería hacer lo que quiera.

Incluso existe una respuesta aceptada, me gustaría demostrar lo siguiente (con Python 2.7.2 y Numpy 1.6.0 en 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

Por lo tanto, la forma realmente eficiente podría depender en gran medida del sistema operativo. De todos modos dot(.) basado parece ser el más estable.

Hay dos enfoques generales aquí:

• Compruebe cada elemento de matriz para nan y tome any.
• Aplique alguna operación acumulativa que preserve nan s (como sum) y verifique su resultado.

Si bien el primer enfoque es ciertamente el más limpio, la optimización pesada de algunas de las operaciones acumulativas (particularmente las que se ejecutan en BLAS, como dot) puede hacer que sean bastante rápidas. Tenga en cuenta que dot, al igual que algunas otras operaciones BLAS, son multihilo bajo ciertas condiciones. Esto explica la diferencia de velocidad entre las diferentes máquinas.

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)'
    )

Si te sientes cómodo con numba permite crear un cortocircuito rápido (se detiene tan pronto como se encuentra una NaN) función:

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 no hay NaN la función podría ser en realidad más lenta que np.min, creo que eso es porque np.min usa multiprocesamiento para arreglos grandes:

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

Pero en caso de que haya una NaN en la matriz, especialmente si su posición está en índices bajos, entonces es mucho más rápido:

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

Se pueden lograr resultados similares con Cython o a C extensión, estos son un poco más complicado (o fácilmente disponible como bottleneck.anynan) pero en última instancia hacer lo mismo que mi función anynan.

Relacionado con esto está la cuestión de cómo encontrar la primera aparición de NaN. Esta es la manera más rápida de manejar eso que yo sepa:

index = next((i for (i,n) in enumerate(iterable) if n!=n), None)

enter code here

1. uso .any()

if numpy.isnan(myarray).any()

1. numpy.isfinite tal vez mejor que isnan para comprobar

if not np.isfinite(prop).all()