Cuantización vectorial con KBinsDiscretizer

Introducción

Esta práctica demuestra cómo utilizar KBinsDiscretizer de la biblioteca Scikit-learn para realizar cuantización vectorial en una imagen de muestra de la cara de un mapache. La cuantización vectorial es una técnica para reducir el número de niveles de gris utilizados para representar una imagen. Utilizaremos KBinsDiscretizer para realizar la cuantización vectorial en la imagen de la cara del mapache. Utilizaremos 8 niveles de gris para representar la imagen, lo que se puede comprimir para utilizar solo 3 bits por píxel. Compararemos las estrategias de clustering uniforme y k-medias para mapear los valores de píxeles a los 8 niveles de gris.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargar. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Cargar y mostrar la imagen original

Comenzaremos cargando la imagen de la cara de un mapache desde Scipy. Mostraremos la imagen y comprobaremos su forma, tipo de datos y uso de memoria.

from scipy.misc import face
import matplotlib.pyplot as plt

raccoon_face = face(gray=True)

print(f"La dimensión de la imagen es {raccoon_face.shape}")
print(f"Los datos utilizados para codificar la imagen son del tipo {raccoon_face.dtype}")
print(f"El número de bytes ocupados en la RAM es {raccoon_face.nbytes}")

fig, ax = plt.subplots(ncols=2, figsize=(12, 4))
ax[0].imshow(raccoon_face, cmap=plt.cm.gray)
ax[0].axis("off")
ax[0].set_title("Imagen original")
ax[1].hist(raccoon_face.ravel(), bins=256)
ax[1].set_xlabel("Valor del píxel")
ax[1].set_ylabel("Conteo de píxeles")
ax[1].set_title("Distribución de los valores de los píxeles")
_ = fig.suptitle("Imagen original de la cara de un mapache")

Cuantización vectorial utilizando KBinsDiscretizer

Ahora utilizaremos KBinsDiscretizer para realizar la cuantización vectorial en la imagen de la cara de un mapache. Utilizaremos 8 niveles de gris para representar la imagen, lo que se puede comprimir para utilizar solo 3 bits por píxel. Utilizaremos las estrategias de clustering uniforme y k-medias para mapear los valores de píxeles a los 8 niveles de gris.

Estrategia de muestreo uniforme

Primero utilizaremos la estrategia de muestreo uniforme para mapear los valores de píxeles a los 8 niveles de gris.

from sklearn.preprocessing import KBinsDiscretizer

n_bins = 8
encoder = KBinsDiscretizer(
    n_bins=n_bins, encode="ordinal", strategy="uniform", random_state=0
)
compressed_raccoon_uniform = encoder.fit_transform(raccoon_face.reshape(-1, 1)).reshape(
    raccoon_face.shape
)

fig, ax = plt.subplots(ncols=2, figsize=(12, 4))
ax[0].imshow(compressed_raccoon_uniform, cmap=plt.cm.gray)
ax[0].axis("off")
ax[0].set_title("Muestreo uniforme")
ax[1].hist(compressed_raccoon_uniform.ravel(), bins=256)
ax[1].set_xlabel("Valor del píxel")
ax[1].set_ylabel("Conteo de píxeles")
ax[1].set_title("Distribución de los valores de los píxeles")
_ = fig.suptitle("Cara de mapache comprimida utilizando 3 bits y una estrategia uniforme")

Estrategia de clustering k-medias

Ahora utilizaremos la estrategia de clustering k-medias para mapear los valores de píxeles a los 8 niveles de gris.

encoder = KBinsDiscretizer(
    n_bins=n_bins, encode="ordinal", strategy="kmeans", random_state=0
)
compressed_raccoon_kmeans = encoder.fit_transform(raccoon_face.reshape(-1, 1)).reshape(
    raccoon_face.shape
)

fig, ax = plt.subplots(ncols=2, figsize=(12, 4))
ax[0].imshow(compressed_raccoon_kmeans, cmap=plt.cm.gray)
ax[0].axis("off")
ax[0].set_title("Clustering k-medias")
ax[1].hist(compressed_raccoon_kmeans.ravel(), bins=256)
ax[1].set_xlabel("Valor del píxel")
ax[1].set_ylabel("Conteo de píxeles")
ax[1].set_title("Distribución de los valores de los píxeles")
_ = fig.suptitle("Cara de mapache comprimida utilizando 3 bits y una estrategia de k-medias")

Consumo de memoria

Ahora comprobaremos el uso de memoria de las imágenes comprimidas. Esperamos que la imagen comprimida ocupe 8 veces menos memoria que la imagen original.

print(f"El número de bytes ocupados en la RAM es {compressed_raccoon_kmeans.nbytes}")
print(f"Ratio de compresión: {compressed_raccoon_kmeans.nbytes / raccoon_face.nbytes}")

Resumen

En esta práctica, utilizamos KBinsDiscretizer de Scikit-learn para realizar cuantización vectorial en una imagen de muestra de la cara de un mapache. Utilizamos 8 niveles de gris para representar la imagen, lo que se puede comprimir para utilizar solo 3 bits por píxel. Comparamos las estrategias de clustering uniforme y k-medias para mapear los valores de píxeles a los 8 niveles de gris. Encontramos que la estrategia de clustering k-medias proporcionó una distribución más equilibrada de los valores de píxeles. También comprobamos el uso de memoria de las imágenes comprimidas y descubrimos que la imagen comprimida ocupó 8 veces más memoria que la imagen original debido al uso de una representación de punto flotante de 64 bits para la imagen comprimida.

Resumen

¡Felicidades! Has completado la práctica de Cuantización Vectorial con KBinsDiscretizer. Puedes practicar más prácticas en LabEx para mejorar tus habilidades.