Cuantización de Colores Utilizando K-Means

Introducción

La cuantización de colores es un proceso de reducción del número de colores distintos utilizados en una imagen mientras se conserva su apariencia general. Esto se logra agrupando colores similares y representándolos con un solo valor de color. En este laboratorio, usaremos el algoritmo de agrupamiento K-Means para realizar la cuantización de colores en una imagen del Palacio de Verano en China.

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 cargarse. 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 y mostrando la imagen original del Palacio de Verano.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_sample_image

## Cargar la foto del Palacio de Verano
china = load_sample_image("china.jpg")

## Mostrar la imagen original
plt.figure()
plt.axis("off")
plt.title("Imagen Original")
plt.imshow(china)
plt.show()

Convertir la Imagen a Puntos Flotantes y Redimensionar

Convertiremos la imagen a puntos flotantes y la redimensionaremos en una matriz numpy bidimensional para que pueda ser procesada por el algoritmo K-Means.

## Convertir a puntos flotantes en lugar de la codificación entera de 8 bits por defecto.
china = np.array(china, dtype=np.float64) / 255

## Obtener las dimensiones de la imagen
w, h, d = original_shape = tuple(china.shape)
assert d == 3

## Redimensionar la imagen en una matriz numpy bidimensional
image_array = np.reshape(china, (w * h, d))

Ajustar el Modelo K-Means

Ajustaremos el modelo K-Means en una pequeña submuestra de los datos de la imagen y lo usaremos para predecir los índices de color en la imagen completa.

from sklearn.cluster import KMeans
from sklearn.utils import shuffle
from time import time

n_colors = 64

## Ajustar el modelo K-Means en una pequeña submuestra de los datos
print("Ajustando el modelo en una pequeña submuestra de los datos")
t0 = time()
image_array_sample = shuffle(image_array, random_state=0, n_samples=1000)
kmeans = KMeans(n_clusters=n_colors, n_init="auto", random_state=0).fit(
    image_array_sample
)
print(f"hecho en {time() - t0:0.3f}s.")

## Obtener etiquetas para todos los puntos
print("Predecir índices de color en la imagen completa (k-means)")
t0 = time()
labels = kmeans.predict(image_array)
print(f"hecho en {time() - t0:0.3f}s.")

Predecir Índices de Color Utilizando un Código Aleatorio

Predeciremos los índices de color en la imagen completa utilizando un código aleatorio.

## Obtener un código aleatorio
codebook_random = shuffle(image_array, random_state=0, n_samples=n_colors)

## Predecir índices de color en la imagen completa utilizando el código aleatorio
print("Predecir índices de color en la imagen completa (aleatorio)")
t0 = time()
labels_random = pairwise_distances_argmin(codebook_random, image_array, axis=0)
print(f"hecho en {time() - t0:0.3f}s.")

Recrear la Imagen

Recrearemos la imagen comprimida utilizando el código y las etiquetas obtenidas del modelo K-Means y el código aleatorio.

def recreate_image(codebook, labels, w, h):
    """Recrear la (comprimida) imagen a partir del libro de códigos & etiquetas"""
    return codebook[labels].reshape(w, h, -1)

## Mostrar la imagen original junto con las imágenes cuantizadas
plt.figure()
plt.clf()
plt.axis("off")
plt.title("Imagen original (96,615 colores)")
plt.imshow(china)

plt.figure()
plt.clf()
plt.axis("off")
plt.title(f"Imagen cuantizada ({n_colors} colores, K-Means)")
plt.imshow(recreate_image(kmeans.cluster_centers_, labels, w, h))

plt.figure()
plt.clf()
plt.axis("off")
plt.title(f"Imagen cuantizada ({n_colors} colores, Aleatoria)")
plt.imshow(recreate_image(codebook_random, labels_random, w, h))

plt.show()

Resumen

En este laboratorio, aprendimos cómo utilizar el algoritmo de agrupamiento K-Means para realizar la cuantización de colores en una imagen. Cargamos y mostramos la imagen original, la convertimos a números de punto flotante y la redimensionamos en una matriz numpy bidimensional. Ajustamos el modelo K-Means en una submuestra de los datos de la imagen y lo utilizamos para predecir los índices de color en la imagen completa. También predecimos los índices de color en la imagen completa utilizando un código aleatorio. Finalmente, recreamos la imagen comprimida utilizando el código y las etiquetas obtenidas del modelo K-Means y el código aleatorio, y mostramos la imagen original junto con las imágenes cuantizadas.