Criar matriz numpy preenchida com NaNs

Eu tenho o seguinte código:

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

Ele cria uma width x height x 9matriz preenchida com zeros. Em vez disso, eu gostaria de saber se existe uma função ou maneira de inicializá-los, em vez de NaNs de uma maneira fácil.

Você raramente precisa de loops para operações de vetor em numpy. Você pode criar uma matriz não inicializada e atribuir a todas as entradas de uma vez:

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

Eu cronometrei as alternativas a[:] = numpy.nanaqui e a.fill(numpy.nan)como postadas 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

Os tempos mostram uma preferência por ndarray.fill(..)como a alternativa mais rápida. OTOH, eu gosto da implementação de conveniência do numpy, onde você pode atribuir valores a fatias inteiras no momento, a intenção do código é muito clara.

Observe que ndarray.fillrealiza sua operação no local, numpy.empty((3,3,)).fill(numpy.nan)retornando None.

Outra opção é usar numpy.full, uma opção disponível no NumPy 1.8+

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

Isso é bastante flexível e você pode preenchê-lo com qualquer outro número que desejar.

Comparei as alternativas sugeridas para velocidade e descobri que, para vetores / matrizes grandes o suficiente para preencher, todas as alternativas, exceto val * onese array(n * [val])são igualmente rápidas.

Código para reproduzir o gráfico:

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

Você é familiar com numpy.nan ?

Você pode criar seu próprio método, como:

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

Então

nans([3,4])

produziria

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

Encontrei esse código em um thread de lista de discussão .

Você sempre pode usar a multiplicação se não se lembrar imediatamente dos métodos .emptyou .full:

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

Claro que também funciona com qualquer outro valor numérico:

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

Mas a resposta aceita do @ u0b34a0f6ae é 3x mais rápida (ciclos da CPU, não ciclos do cérebro para lembrar a sintaxe 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

Outra alternativa é numpy.broadcast_to(val,n) que retorna em tempo constante, independentemente do tamanho, e também é a mais eficiente em memória (retorna uma visão do elemento repetido). A ressalva é que o valor retornado é somente leitura.

Abaixo está uma comparação dos desempenhos de todos os outros métodos que foram propostos usando o mesmo benchmark da resposta de Nico Schlömer .

Como dito, numpy.empty () é o caminho a percorrer. No entanto, para objetos, fill () pode não fazer exatamente o que você pensa que faz:

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)

Uma maneira de contornar isso pode ser, por exemplo:

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)

Ainda outra possibilidade ainda não mencionada aqui é usar o bloco NumPy:

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

Também dá

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

Eu não sei sobre comparação de velocidade.