Crear matriz numpy llena de NaN

Tengo el siguiente código:

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

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

Rara vez 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.nan aquí 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 por ndarray.fill(..) como la alternativa más rápida. OTOH, me gusta la implementación conveniente de numpy donde puede asignar valores a segmentos completos en ese momento, la intención del código es muy clara.

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

Otra opción es usar numpy.fulluna 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 encontré que, para vectores/matrices suficientemente grandes para llenar, todas las alternativas excepto val * ones y array(n * [val]) son igualmente rápidos.

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])


b = perfplot.bench(
    setup=lambda n: n,
    kernels=[fill, colon, full, ones_times, list],
    n_range=[2 ** k for k in range(20)],
    xlabel="len(a)",
)
b.save("out.png")

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

Después

nans([3,4])

daría salida

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 puedes usar la multiplicación si no recuerdas inmediatamente el .empty o .full métodos:

>>> 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 la respuesta aceptada de @ u0b34a0f6ae es 3 veces más rápida (ciclos de CPU, no ciclos cerebrales para recordar la 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)[email protected]:~/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

Como se dijo, numpy.empty() es el camino a seguir. Sin embargo, para los objetos, fill() podría no hacer exactamente lo que crees 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é acerca de la comparación de velocidad.