Créer une matrice numpy remplie de NaNs

J'ai le code suivant:

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

Il crée une width x height x 9matrice remplie de zéros. Au lieu de cela, j'aimerais savoir s'il existe une fonction ou un moyen de les initialiser à la place en NaNs de manière simple.

Vous avez rarement besoin de boucles pour les opérations vectorielles dans numpy. Vous pouvez créer un tableau non initialisé et attribuer à toutes les entrées à la fois:

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

J'ai chronométré les alternatives a[:] = numpy.nanici et a.fill(numpy.nan)telles que publiées par 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

Les horaires montrent une préférence ndarray.fill(..)comme alternative plus rapide. OTOH, j'aime l'implémentation pratique de numpy où vous pouvez attribuer des valeurs à des tranches entières à l'époque, l'intention du code est très claire.

Notez que ndarray.filleffectue son opération sur place, donc numpy.empty((3,3,)).fill(numpy.nan)reviendra à la place None.

Une autre option est d'utiliser numpy.full, une option disponible dans NumPy 1.8+

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

C'est assez flexible et vous pouvez le remplir avec n'importe quel autre numéro que vous souhaitez.

J'ai comparé les alternatives suggérées pour la vitesse et constaté que, pour des vecteurs / matrices suffisamment grands à remplir, toutes les alternatives sauf val * oneset array(n * [val])sont également rapides.

Code pour reproduire l'intrigue:

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

Connaissez-vous numpy.nan?

Vous pouvez créer votre propre méthode telle que:

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

ensuite

nans([3,4])

sortirait

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

J'ai trouvé ce code dans un fil de discussion .

Vous pouvez toujours utiliser la multiplication si vous ne vous souvenez pas immédiatement des méthodes .emptyou .full:

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

Bien sûr, cela fonctionne également avec toute autre valeur numérique:

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

Mais la réponse acceptée par @ u0b34a0f6ae est 3 fois plus rapide (cycles CPU, pas cycles cérébraux pour se souvenir de la syntaxe 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

Une autre alternative est celle numpy.broadcast_to(val,n)qui retourne en temps constant quelle que soit la taille et qui est également la plus efficace en mémoire (elle retourne une vue de l'élément répété). La mise en garde est que la valeur renvoyée est en lecture seule.

Ci-dessous, une comparaison des performances de toutes les autres méthodes qui ont été proposées en utilisant le même benchmark que dans la réponse de Nico Schlömer .

Comme dit, numpy.empty () est le chemin à parcourir. Cependant, pour les objets, fill () peut ne pas faire exactement ce que vous pensez qu'il fait:

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)

Une solution peut être par exemple:

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)

Encore une autre possibilité non encore mentionnée ici est d'utiliser la tuile NumPy:

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

Donne également

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

Je ne connais pas la comparaison de vitesse.