Buat numpy matrix diisi dengan NaNs

Saya memiliki kode berikut:

r = numpy.zeros(shape = (width, height, 9))

Itu menciptakan width x height x 9matriks diisi dengan nol. Sebagai gantinya, saya ingin tahu apakah ada fungsi atau cara untuk menginisialisasi mereka alih-alih dengan NaNcara mudah.

Anda jarang membutuhkan loop untuk operasi vektor di numpy. Anda dapat membuat larik yang belum diinisialisasi dan menetapkan semua entri sekaligus:

>>> a = numpy.empty((3,3,))
>>> a[:] = numpy.nan
>>> a
array([[ NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN]])

Saya telah menghitung waktunya alternatif di a[:] = numpy.nansini dan a.fill(numpy.nan)sebagaimana diposting oleh Blaenk:

$ python -mtimeit "import numpy as np; a = np.empty((100,100));" "a.fill(np.nan)"
10000 loops, best of 3: 54.3 usec per loop
$ python -mtimeit "import numpy as np; a = np.empty((100,100));" "a[:] = np.nan" 
10000 loops, best of 3: 88.8 usec per loop

Pengaturan waktu menunjukkan preferensi untuk ndarray.fill(..) sebagai alternatif yang lebih cepat. OTOH, saya suka implementasi kenyamanan numpy di mana Anda dapat menetapkan nilai untuk seluruh irisan pada saat itu, maksud kode sangat jelas.

Perhatikan bahwa ndarray.fillmenjalankan operasinya di tempat, jadi numpy.empty((3,3,)).fill(numpy.nan)alih-alih akan kembali None.

Opsi lain adalah menggunakan numpy.full, opsi yang tersedia di NumPy 1.8+

a = np.full([height, width, 9], np.nan)

Ini cukup fleksibel dan Anda dapat mengisinya dengan nomor lain yang Anda inginkan.

Saya membandingkan alternatif kecepatan yang disarankan dan menemukan bahwa, untuk mengisi vektor / matriks yang cukup besar, semua alternatif kecuali val * onesdan array(n * [val])sama-sama cepat.

Kode untuk mereproduksi plot:

import numpy
import perfplot

val = 42.0


def fill(n):
    a = numpy.empty(n)
    a.fill(val)
    return a


def colon(n):
    a = numpy.empty(n)
    a[:] = val
    return a


def full(n):
    return numpy.full(n, val)


def ones_times(n):
    return val * numpy.ones(n)


def list(n):
    return numpy.array(n * [val])


perfplot.show(
    setup=lambda n: n,
    kernels=[fill, colon, full, ones_times, list],
    n_range=[2 ** k for k in range(20)],
    logx=True,
    logy=True,
    xlabel="len(a)",
)

Apakah Anda kenal numpy.nan?

Anda dapat membuat metode Anda sendiri seperti:

def nans(shape, dtype=float):
    a = numpy.empty(shape, dtype)
    a.fill(numpy.nan)
    return a

Kemudian

nans([3,4])

akan menghasilkan

array([[ NaN,  NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN,  NaN]])

Saya menemukan kode ini di utas milis .

Anda selalu dapat menggunakan perkalian jika Anda tidak segera mengingat metode .emptyatau .full:

>>> np.nan * np.ones(shape=(3,2))
array([[ nan,  nan],
       [ nan,  nan],
       [ nan,  nan]])

Tentu saja ia bekerja dengan nilai numerik lainnya juga:

>>> 42 * np.ones(shape=(3,2))
array([[ 42,  42],
       [ 42,  42],
       [ 42, 42]])

Tetapi jawaban yang diterima @ u0b34a0f6ae adalah 3x lebih cepat (siklus CPU, bukan siklus otak untuk mengingat sintaks numpy;):

$ python -mtimeit "import numpy as np; X = np.empty((100,100));" "X[:] = np.nan;"
100000 loops, best of 3: 8.9 usec per loop
(predict)laneh@predict:~/src/predict/predict/webapp$ master
$ python -mtimeit "import numpy as np; X = np.ones((100,100));" "X *= np.nan;"
10000 loops, best of 3: 24.9 usec per loop

Alternatif lain adalah numpy.broadcast_to(val,n) yang mengembalikan dalam waktu konstan terlepas dari ukuran dan juga yang paling efisien memori (mengembalikan tampilan elemen yang diulang). Peringatannya adalah bahwa nilai yang dikembalikan hanya baca-saja.

Di bawah ini adalah perbandingan kinerja semua metode lain yang telah diusulkan menggunakan tolok ukur yang sama seperti dalam jawaban Nico Schlömer .

Seperti yang dikatakan, numpy.empty () adalah cara untuk pergi. Namun, untuk objek, fill () mungkin tidak melakukan persis seperti yang Anda pikirkan:

In[36]: a = numpy.empty(5,dtype=object)
In[37]: a.fill([])
In[38]: a
Out[38]: array([[], [], [], [], []], dtype=object)
In[39]: a[0].append(4)
In[40]: a
Out[40]: array([[4], [4], [4], [4], [4]], dtype=object)

Salah satu jalan keluar misalnya:

In[41]: a = numpy.empty(5,dtype=object)
In[42]: a[:]= [ [] for x in range(5)]
In[43]: a[0].append(4)
In[44]: a
Out[44]: array([[4], [], [], [], []], dtype=object)

Namun kemungkinan lain yang belum disebutkan di sini adalah menggunakan ubin NumPy:

a = numpy.tile(numpy.nan, (3, 3))

Juga memberi

array([[ NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN]])

Saya tidak tahu tentang perbandingan kecepatan.