Crear matriz numpy llena de NaN

Tengo el siguiente código:

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

Crea una width x height x 9matriz llena de ceros. En cambio, me gustaría saber si hay una función o forma de inicializarlos en lugar de hacerlo NaNde una manera fácil.

Raramente necesita bucles para operaciones vectoriales en numpy. Puede crear una matriz no inicializada y asignarla a todas las entradas a la vez:

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

He cronometrado las alternativas a[:] = numpy.nanaquí y a.fill(numpy.nan)según lo publicado por 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

Los tiempos muestran una preferencia ndarray.fill(..)como la alternativa más rápida. OTOH, me gusta la implementación de conveniencia de numpy donde puede asignar valores a segmentos enteros en ese momento, la intención del código es muy clara.

Tenga en cuenta que ndarray.fillrealiza su operación en el lugar, por numpy.empty((3,3,)).fill(numpy.nan)lo que en su lugar regresará None.

Otra opción es usar numpy.full, una opción disponible en NumPy 1.8+

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

Esto es bastante flexible y puede llenarlo con cualquier otro número que desee.

Comparé las alternativas sugeridas para la velocidad y descubrí que, para vectores / matrices lo suficientemente grandes como para llenar, todas las alternativas excepto val * onesy array(n * [val])son igualmente rápidas.

Código para reproducir 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)",
)

¿Estás familiarizado con numpy.nan?

Puede crear su propio método, como:

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

Luego

nans([3,4])

saldría

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

Encontré este código en un hilo de la lista de correo .

Siempre puede usar la multiplicación si no recuerda inmediatamente los métodos .emptyo .full:

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

Por supuesto, también funciona con cualquier otro valor numérico:

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

Pero el @ u0b34a0f6ae's respuesta aceptada de es 3 veces más rápida (ciclos de CPU, no ciclos cerebrales para recordar sintaxis 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

Otra alternativa es numpy.broadcast_to(val,n) que regresa en tiempo constante sin importar el tamaño y también es la memoria más eficiente (devuelve una vista del elemento repetido). La advertencia es que el valor devuelto es de solo lectura.

A continuación se muestra una comparación de las actuaciones de todos los otros métodos que se han propuesto utilizando el mismo punto de referencia que en la respuesta de Nico Schlömer .

Como se dijo, numpy.empty () es el camino a seguir. Sin embargo, para los objetos, fill () podría no hacer exactamente lo que cree que hace:

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)

Una forma de evitarlo puede ser, por ejemplo:

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)

Otra posibilidad aún no mencionada aquí es usar el mosaico NumPy:

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

También da

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

No sé sobre la comparación de velocidad.