Numpy-Matrix-Binärisierung mit nur einem Ausdruck

Question

Ich bin auf der Suche nach einer Möglichkeit, numpy N-d-Array basierend auf dem Schwellenwert mit nur einem Ausdruck binarisieren. Also ich habe so etwas wie dies:

np.random.seed(0) 
np.set_printoptions(precision=3) 
a = np.random.rand(4, 4) 
threshold, upper, lower = 0.5, 1, 0 

a ist jetzt:

array([[ 0.02 , 0.833, 0.778, 0.87 ], 
     [ 0.979, 0.799, 0.461, 0.781], 
     [ 0.118, 0.64 , 0.143, 0.945], 
     [ 0.522, 0.415, 0.265, 0.774]]) 

Jetzt kann ich diese 2 Ausdrücke Feuer:

a[a>threshold] = upper 
a[a<=threshold] = lower 

und erreichen, was ich will:

array([[ 0., 1., 1., 1.], 
     [ 1., 1., 0., 1.], 
     [ 0., 1., 0., 1.], 
     [ 1., 0., 0., 1.]]) 

Aber gibt es einen Weg, dies mit nur zu tun e Ausdruck?

Answer 1

Wir können np.where betrachten:

np.where(a>threshold, upper, lower) 
Out[6]: 
array([[0, 1, 1, 1], 
     [1, 1, 0, 1], 
     [0, 1, 0, 1], 
     [1, 0, 0, 1]]) 

Answer 2

Sie Ausdruck direkt schreiben kann, wird dies eine boolean Array zurück, und es kann zur weiteren einfach als 1-Byte unsigned integer ("uint8") Array verwendet werden Berechnungen:

print a > 0.5 

Ausgang

[[False True True True] 
[ True True False True] 
[False True False True] 
[ True False False True]] 

in einer Zeile und mit benutzerdefinierten obere/untere Werten kann man so beispielsweise schreiben:

upper = 10 
lower = 3 
treshold = 0.5 

print lower + (a>treshold) * (upper-lower) 

Answer 3

Numpy behandelt jeden 1D-Array als ein Vektor, 2D-Array als Folge von Vektoren (Matrix) und 3D + Array als generic Tensor. Das bedeutet, wenn wir Operationen ausführen, führen wir Vektormathematik aus. So können Sie einfach tun:

>>> a = (a > 0.5).astype(np.int_) 

Zum Beispiel:

>>> np.random.seed(0) 
>>> np.set_printoptions(precision=3) 

>>> a = np.random.rand(4, 4) 

>>> a 
>>> array([[ 0.549, 0.715, 0.603, 0.545], 
     [ 0.424, 0.646, 0.438, 0.892], 
     [ 0.964, 0.383, 0.792, 0.529], 
     [ 0.568, 0.926, 0.071, 0.087]]) 

>>> a = (a > 0.5).astype(np.int_) # Where the numpy magic happens. 

>>> array([[1, 1, 1, 1], 
      [0, 1, 0, 1], 
      [1, 0, 1, 1], 
      [1, 1, 0, 0]]) 

Was hier los ist, dass Sie automatisch in der 4x4-Matrix durch jedes Element jeder Zeile iterieren und einen boolean Vergleich zu jeder Anwendung Element.

Wenn> 0,5 gibt True zurück, sonst gibt False zurück.

dann durch die .astype Methode aufrufen und np.int_ als Argument übergeben, sind Sie numpy sagen alle Boolesche Werte mit ihren Integer-Darstellung zu ersetzen, in der Tat Digitalisieren des Matrix auf Vergleichswert basiert.

Answer 4

Eine kürzere Methode besteht darin, die boolesche Matrix einfach von der Bedingung um 1 oder 1.0 zu multiplizieren, je nach dem gewünschten Typ.

>>> a = np.random.rand(4,4) 
>>> a 
array([[ 0.63227032, 0.18262573, 0.21241511, 0.95181594], 
     [ 0.79215808, 0.63868395, 0.41706148, 0.9153959 ], 
     [ 0.41812268, 0.70905987, 0.54946947, 0.51690887], 
     [ 0.83693151, 0.10929998, 0.19219377, 0.82919761]]) 
>>> (a>0.5)*1 
array([[1, 0, 0, 1], 
     [1, 1, 0, 1], 
     [0, 1, 1, 1], 
     [1, 0, 0, 1]]) 
>>> (a>0.5)*1.0 
array([[ 1., 0., 0., 1.], 
     [ 1., 1., 0., 1.], 
     [ 0., 1., 1., 1.], 
     [ 1., 0., 0., 1.]])