Quantização de Cores Usando K-Means

Introdução

A quantização de cores é um processo de redução do número de cores distintas usadas numa imagem, preservando a sua aparência geral. Isto é feito agrupando cores semelhantes e representando-as com um único valor de cor. Neste laboratório, utilizaremos o algoritmo K-Means para realizar a quantização de cores numa imagem do Palácio de Verão na China.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Carregar e Exibir a Imagem Original

Começaremos carregando e exibindo a imagem original do Palácio de Verão.

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

## Carregar a foto do Palácio de Verão
china = load_sample_image("china.jpg")

## Exibir a imagem original
plt.figure()
plt.axis("off")
plt.title("Imagem Original")
plt.imshow(china)
plt.show()

Converter a Imagem para Floats e Reformate

Vamos converter a imagem para floats e reformá-la num array numpy 2D para que possa ser processada pelo algoritmo K-Means.

## Converter para floats em vez da codificação inteira de 8 bits padrão.
china = np.array(china, dtype=np.float64) / 255

## Obter as dimensões da imagem
w, h, d = original_shape = tuple(china.shape)
assert d == 3

## Reformate a imagem num array numpy 2D
image_array = np.reshape(china, (w * h, d))

Ajustar o Modelo K-Means

Ajustaremos o modelo K-Means a uma pequena amostra dos dados da imagem e usá-lo-emos para prever os índices de cores na imagem completa.

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

n_colors = 64

## Ajustar o modelo K-Means a uma pequena amostra dos dados
print("Ajustando o modelo a uma pequena amostra dos dados")
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"feito em {time() - t0:0.3f}s.")

## Obter rótulos para todos os pontos
print("Prevendo índices de cores na imagem completa (k-means)")
t0 = time()
labels = kmeans.predict(image_array)
print(f"feito em {time() - t0:0.3f}s.")

Prever Índices de Cores Usando um Livro de Códigos Aleatório

Preveremos os índices de cores na imagem completa usando um livro de códigos aleatório.

## Obter um livro de códigos aleatório
codebook_random = shuffle(image_array, random_state=0, n_samples=n_colors)

## Prever índices de cores na imagem completa usando o livro de códigos aleatório
print("Prevendo índices de cores na imagem completa (aleatório)")
t0 = time()
labels_random = pairwise_distances_argmin(codebook_random, image_array, axis=0)
print(f"feito em {time() - t0:0.3f}s.")

Recriar a Imagem

Recriaremos a imagem comprimida usando o livro de códigos e as etiquetas obtidas do modelo K-Means e do livro de códigos aleatório.

def recreate_image(codebook, labels, w, h):
    """Recriar a imagem (comprimida) a partir do livro de códigos e etiquetas"""
    return codebook[labels].reshape(w, h, -1)

## Exibir a imagem original juntamente com as imagens quantizadas
plt.figure()
plt.clf()
plt.axis("off")
plt.title("Imagem original (96.615 cores)")
plt.imshow(china)

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

plt.figure()
plt.clf()
plt.axis("off")
plt.title(f"Imagem quantizada ({n_colors} cores, Aleatório)")
plt.imshow(recreate_image(codebook_random, labels_random, w, h))

plt.show()

Resumo

Neste laboratório, aprendemos como usar o algoritmo de agrupamento K-Means para realizar quantização de cores numa imagem. Carregámos e exibimos a imagem original, convertendo-a para valores em ponto flutuante e remodelando-a num array numpy 2D. Ajustámos o modelo K-Means a uma subamostra dos dados da imagem e utilizámo-lo para prever os índices de cores na imagem completa. Também previmos os índices de cores na imagem completa usando um livro de códigos aleatório. Finalmente, recriámos a imagem comprimida usando o livro de códigos e as etiquetas obtidas do modelo K-Means e do livro de códigos aleatório, exibindo a imagem original juntamente com as imagens quantizadas.