python - linalg - Binarización de matrices numpy usando solo una expresión

numpy python 3

Question

Estoy buscando una forma de binarizar una matriz Nd numpy basada en el umbral usando solo una expresión. Así que tengo algo como esto:

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

a es ahora:

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

Ahora puedo disparar estas 2 expresiones:

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

y lograr lo que quiero:

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

¿Pero hay una manera de hacer esto con una sola expresión?

Answer 1

Numpy trata cada matriz 1d como un vector, matriz 2d como secuencia de vectores (matriz) y la matriz 3d + como un tensor genérico. Esto significa que cuando realizamos operaciones, estamos realizando matemática vectorial. Así que solo puedes hacer:

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

Por ejemplo:

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

Lo que sucede aquí es que estás iterando automáticamente a través de cada elemento de cada fila en la matriz 4x4 y aplicando una comparación booleana a cada elemento.

Si> 0.5 devuelve True, si no devuelve False.

Luego, al llamar al método .astype y pasar np.int_ como argumento, le está diciendo a numpy que reemplace todos los valores booleanos con su representación de enteros, en efecto binarizando la matriz según su valor de comparación.

Answer 2

Podemos considerar np.where :

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 3

Puede escribir la expresión directamente, esto devolverá una matriz booleana, y se puede usar simplemente como una matriz de entero sin signo de 1 byte ("uint8") para otros cálculos:

print a > 0.5

salida

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

En una línea y con valores superiores / inferiores personalizados, puede escribir, por ejemplo:

upper = 10
lower = 3
treshold = 0.5

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

Answer 4

Un método más corto es simplemente multiplicar la matriz booleana de la condición por 1 o 1.0, según el tipo que desee.

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