Pemeriksaan cepat untuk NaN di NumPy

Saya mencari cara tercepat untuk memeriksa terjadinya NaN ( np.nan) dalam array NumPy X. np.isnan(X)tidak mungkin, karena ia membangun larik bentuk boolean X.shape, yang berpotensi sangat besar.

Saya mencoba np.nan in X, tetapi tampaknya tidak berhasil karena np.nan != np.nan. Apakah ada cara yang cepat dan hemat memori untuk melakukan ini sama sekali?

(Untuk mereka yang bertanya "seberapa besar": Saya tidak tahu. Ini adalah validasi input untuk kode perpustakaan.)

Solusi Ray bagus. Namun, di komputer saya, ini sekitar 2,5x lebih cepat untuk digunakan numpy.sumsebagai pengganti 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

Berbeda dengan min, sumtidak memerlukan percabangan, yang pada perangkat keras modern cenderung cukup mahal. Ini mungkin alasan mengapa sumlebih cepat.

sunting Tes di atas dilakukan dengan satu NaN tepat di tengah-tengah array.

Menarik untuk dicatat bahwa minkeberadaan NaN lebih lambat dibandingkan saat tidak ada. Tampaknya juga menjadi lebih lambat karena NaN semakin mendekati awal larik. Di sisi lain, sumthroughput tampak konstan terlepas dari apakah ada NaN dan di mana lokasinya:

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

Saya pikir np.isnan(np.min(X))harus melakukan apa yang Anda inginkan.

Bahkan ada jawaban yang diterima, saya ingin menunjukkan yang berikut (dengan Python 2.7.2 dan Numpy 1.6.0 di 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

Jadi, cara yang sangat efisien mungkin sangat bergantung pada sistem operasi. Pokoknya dot(.)berbasis tampaknya yang paling stabil.

Ada dua pendekatan umum di sini:

• Periksa setiap item array untuk nandan ambil any.
• Terapkan beberapa operasi kumulatif yang mempertahankan nans (suka sum) dan periksa hasilnya.

Meskipun pendekatan pertama tentu yang paling bersih, pengoptimalan yang berat dari beberapa operasi kumulatif (terutama yang dijalankan di BLAS, seperti dot) dapat membuatnya cukup cepat. Perhatikan bahwa dot, seperti beberapa operasi BLAS lainnya, multithread dalam kondisi tertentu. Ini menjelaskan perbedaan kecepatan antara mesin yang berbeda.

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. gunakan .any ()

   if numpy.isnan(myarray).any()

2. numpy.isfinite mungkin lebih baik daripada isnan untuk diperiksa

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

Jika Anda merasa nyaman dengan numba memungkinkan untuk membuat korsleting cepat (berhenti segera setelah NaN ditemukan) fungsi:

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

Jika tidak ada NaNfungsi yang sebenarnya mungkin lebih lambat dari np.min, saya pikir itu karena np.minmenggunakan multiprocessing untuk array besar:

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

Tetapi jika ada NaN dalam array, terutama jika posisinya berada pada indeks rendah, maka akan lebih cepat:

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

Hasil serupa dapat dicapai dengan Cython atau ekstensi C, ini sedikit lebih rumit (atau mudah tersedia bottleneck.anynan) tetapi pada umumnya melakukan hal yang sama seperti anynanfungsi saya .

Terkait dengan ini adalah pertanyaan bagaimana menemukan kemunculan pertama NaN. Ini adalah cara tercepat untuk menangani yang saya tahu:

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