Швидка перевірка наявності NaN в NumPy

Я шукаю найшвидший спосіб перевірити наявність NaN ( np.nan) в масиві NumPy X. np.isnan(X)не виникає сумніву, оскільки він будує булевий масив форм X.shape, який потенційно є гігантським.

Я намагався np.nan in X, але це, здається, не виходить, тому що np.nan != np.nan. Чи існує швидкий та ефективний для пам'яті спосіб зробити це взагалі?

(Тим, хто запитав "як гігантські": я не можу сказати. Це перевірка вводу для бібліотечного коду.)

Рішення Рея добре. Однак, на моїй машині це близько 2.5x швидше використовувати numpy.sumзамість 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

На відміну від цього min, sumне потрібно розгалуження, що на сучасному апаратному забезпеченні, як правило, досить дорого. Це, мабуть, причина, чому sumшвидше.

редагування Вищевказаний тест проводили з одним NaN праворуч посеред масиву.

Цікаво відзначити, що minповільніше у присутності NaN, ніж у їх відсутності. Це також здається повільніше, коли NaN наближаються до початку масиву. З іншого боку, sumпропускна здатність здається постійною незалежно від того, є NaN та де вони знаходяться:

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.isnan(np.min(X))слід робити те, що ти хочеш.

Навіть існує прийнята відповідь, я хотів би продемонструвати наступне (з Python 2.7.2 та Numpy 1.6.0 на 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

Таким чином, дійсно ефективний спосіб може сильно залежати від операційної системи. У будь-якому випадку, dot(.)здається, вона є найбільш стабільною.

Тут є два загальних підходи:

• Перевірте кожен елемент масиву nanта знайдіть його any.
• Застосуйте деяку сукупну операцію, яка зберігає nans (як sum), і перевірте її результат.

Хоча перший підхід, безумовно, найчистіший, важка оптимізація деяких кумулятивних операцій (особливо тих, які виконуються в BLAS, як dot) може зробити їх досить швидкими. Зауважте, що dot, як і деякі інші операції BLAS, є багатопоточним за певних умов. Це пояснює різницю швидкості між різними машинами.

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)",
)

1. використовувати .any ()

   if numpy.isnan(myarray).any()

2. numpy.isfinite може бути кращим, ніж isnan для перевірки

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

Якщо вам комфортно numba це дозволяє створити швидке коротке замикання (зупиняється, як тільки знайдеться NaN):

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

Якщо немає NaNфункції, то насправді це може бути повільніше np.min, я думаю, це тому, що np.minвикористовує багатопроцесорну обробку для великих масивів:

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

Але якщо в масиві є NaN, особливо якщо його положення знаходиться на низьких показниках, то це набагато швидше:

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

Подібні результати можуть бути досягнуті з Cython або розширенням C, вони трохи складніші (або легко доступні як bottleneck.anynan), але ультиматично виконують те саме, що і моя anynanфункція.

З цим пов'язано питання, як знайти перше виникнення NaN. Це найшвидший спосіб впоратися з тим, що я знаю:

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