Inicjowanie numpy matrycy na inną niż zero lub jeden

Question

I mają następujące oznaczenia:

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

Tworzy szerokość x wysokość x 9 matrycy wypełnione zerami. Zamiast tego chciałbym się dowiedzieć, czy istnieje funkcja lub sposób inicjowania ich zamiast NaN.

Czy są jakieś? Bez konieczności uciekania się do ręcznego robienia pętli i takich?

Dzięki

Answer 1

Rzadko potrzeba pętli do operacji wektorowych w numpy. Można utworzyć niezainicjowanej tablicę i przypisać do wszystkich wpisów na raz:

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

---

mam czasowe alternatywy a[:] = numpy.nan tutaj i a.fill(numpy.nan) jak wysłane przez 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 

Te czasy pokazują preferencja dla ndarray.fill(..) jako szybsza alternatywa. OTOH, lubię wygodną implementację numpy, w której można przypisywać wartości do całych plasterków w tym czasie, intencje kodu są bardzo jasne.

Answer 2

Czy znasz numpy.nan?

Można tworzyć własne metody, takie jak:

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

Następnie

nans([3,4]) 

byłoby wyjście

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

znalazłem ten kod w mailing list thread.

Answer 3

Inną opcją jest użycie numpy.full, opcję dostępną w NumPy 1.8+

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

To jest dość elastyczny i można wypełnić go z żadnym innym numerem, który chcesz.

Answer 4

zawsze można użyć mnożenie jeśli nie od razu przypomnieć .empty lub .full metody:

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

Oczywiście to działa w żadnej innej wartości liczbowej, a także:

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

Ale @ u0b34a0f6ae's accepted answer jest 3x szybszy (cykle procesora, a nie cykle mózgowe, aby zapamiętać zdumiewającą składnię;):

$ 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 

Answer 5

Tak jak powiedziałeś, numpy.empty() jest drogą do zrobienia.Jednak dla obiektów, wypełnić() nie może zrobić dokładnie to, co myślisz, że to robi:

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) 

Jednym ze sposobów obejścia może być np:

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) 

Answer 6

Porównałem sugerowanych alternatyw dla prędkości i stwierdził, dla wystarczająco dużych wektorów/macierzy do wypełnienia, wszystkie alternatywy z wyjątkiem val * ones i array(n * [val]) są równie szybkie.

---

Kod odtworzyć działki:

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

Answer 7

Jeszcze inna możliwość jeszcze nie wspomniano tutaj jest użycie NumPy płytki:

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

daje również

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

Nie wiem o porównaniu prędkości.