Crea matrice intorpidita riempita con NaNs

Ho il codice seguente:

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

Crea una width x height x 9matrice piena di zeri. Invece, vorrei sapere se esiste una funzione o un modo per inizializzarli invece che NaNin modo semplice.

Raramente sono necessari loop per operazioni vettoriali in numpy. È possibile creare un array non inizializzato e assegnarlo a tutte le voci contemporaneamente:

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

Ho cronometrato le alternative a[:] = numpy.nanqui e a.fill(numpy.nan)come pubblicato da 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

I tempi mostrano una preferenza ndarray.fill(..)come alternativa più veloce. OTOH, mi piace l'implementazione della comodità di numpy in cui è possibile assegnare valori a intere porzioni in quel momento, l'intenzione del codice è molto chiara.

Si noti che ndarray.fillesegue l'operazione sul posto, quindi numpy.empty((3,3,)).fill(numpy.nan)tornerà invece None.

Un'altra opzione è usare numpy.full, un'opzione disponibile in NumPy 1.8+

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

Questo è abbastanza flessibile e puoi riempirlo con qualsiasi altro numero che desideri.

Ho confrontato le alternative suggerite per la velocità e ho scoperto che, per vettori / matrici abbastanza grandi da riempire, tutte le alternative tranne val * onese array(n * [val])sono ugualmente veloci.

Codice per riprodurre la trama:

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

Hai familiarità con numpy.nan?

Puoi creare il tuo metodo come:

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

Poi

nans([3,4])

sarebbe uscita

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

Ho trovato questo codice in un thread della mailing list .

Puoi sempre usare la moltiplicazione se non ricordi immediatamente i metodi .emptyo .full:

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

Ovviamente funziona anche con qualsiasi altro valore numerico:

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

Ma la risposta accettata da @u0b34a0f6ae è 3 volte più veloce (cicli CPU, non cicli cerebrali per ricordare la sintassi intorpidita;):

$ 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

Un'altra alternativa è quella numpy.broadcast_to(val,n)che ritorna in tempo costante indipendentemente dalle dimensioni ed è anche la memoria più efficiente (restituisce una vista dell'elemento ripetuto). L'avvertenza è che il valore restituito è di sola lettura.

Di seguito è riportato un confronto delle prestazioni di tutti gli altri metodi che sono stati proposti utilizzando lo stesso benchmark della risposta di Nico Schlömer .

Come detto, numpy.empty () è la strada da percorrere. Tuttavia, per gli oggetti, fill () potrebbe non fare esattamente quello che pensi che faccia:

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)

Un modo per aggirare può essere ad esempio:

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)

Ancora un'altra possibilità non ancora menzionata qui è di usare il riquadro NumPy:

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

Dà anche

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

Non conosco il confronto di velocità.