Quantização Vetorial com KBinsDiscretizer

Introdução

Este laboratório demonstra como usar o KBinsDiscretizer da biblioteca Scikit-learn para realizar quantização vetorial numa imagem de amostra de um rosto de guaxinim. A quantização vetorial é uma técnica para reduzir o número de níveis de cinza usados para representar uma imagem. Usaremos o KBinsDiscretizer para realizar a quantização vetorial na imagem do rosto do guaxinim. Usaremos 8 níveis de cinza para representar a imagem, que pode ser comprimida para usar apenas 3 bits por pixel. Compararemos as estratégias de agrupamento uniforme e k-means para mapear os valores de pixel para os 8 níveis de cinza.

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 a imagem do rosto do guaxinim a partir do Scipy. Vamos exibir a imagem e verificar as suas dimensões, tipo de dados e utilização de memória.

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

raccoon_face = face(gray=True)

print(f"As dimensões da imagem são {raccoon_face.shape}")
print(f"O tipo de dados usados para codificar a imagem é {raccoon_face.dtype}")
print(f"O número de bytes usados na RAM é {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("Imagem Original")
ax[1].hist(raccoon_face.ravel(), bins=256)
ax[1].set_xlabel("Valor do Pixel")
ax[1].set_ylabel("Contagem de Pixels")
ax[1].set_title("Distribuição dos valores dos pixels")
_ = fig.suptitle("Imagem Original de um Rosto de Guaxinim")

Quantização Vetorial usando KBinsDiscretizer

Agora usaremos o KBinsDiscretizer para realizar a quantização vetorial na imagem do rosto do guaxinim. Usaremos 8 níveis de cinza para representar a imagem, o que pode ser comprimido para usar apenas 3 bits por pixel. Usaremos as estratégias de agrupamento uniforme e k-means para mapear os valores de pixel para os 8 níveis de cinza.

Estratégia de Amostragem Uniforme

Primeiro, usaremos a estratégia de amostragem uniforme para mapear os valores de pixel para os 8 níveis de cinza.

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("Amostragem Uniforme")
ax[1].hist(compressed_raccoon_uniform.ravel(), bins=256)
ax[1].set_xlabel("Valor do Pixel")
ax[1].set_ylabel("Contagem de Pixels")
ax[1].set_title("Distribuição dos valores dos pixels")
_ = fig.suptitle("Rosto de guaxinim comprimido usando 3 bits e uma estratégia uniforme")

Estratégia de Agrupamento K-means

Agora usaremos a estratégia de agrupamento k-means para mapear os valores de pixel para os 8 níveis de cinza.

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("Agrupamento K-means")
ax[1].hist(compressed_raccoon_kmeans.ravel(), bins=256)
ax[1].set_xlabel("Valor do Pixel")
ax[1].set_ylabel("Contagem de Pixels")
ax[1].set_title("Distribuição dos valores dos pixels")
_ = fig.suptitle("Rosto de guaxinim comprimido usando 3 bits e uma estratégia K-means")

Memória Usada

Agora verificaremos o uso de memória das imagens comprimidas. Esperamos que a imagem comprimida ocupe 8 vezes menos memória que a imagem original.

print(f"O número de bytes usados na RAM é {compressed_raccoon_kmeans.nbytes}")
print(f"Razão de compressão: {compressed_raccoon_kmeans.nbytes / raccoon_face.nbytes}")

Resumo

Neste laboratório, utilizamos o KBinsDiscretizer do Scikit-learn para realizar quantização vetorial numa imagem de amostra de um rosto de guaxinim. Usamos 8 níveis de cinza para representar a imagem, que pode ser comprimida para usar apenas 3 bits por pixel. Comparámos as estratégias de agrupamento uniforme e k-means para mapear os valores de pixel para os 8 níveis de cinza. Observámos que a estratégia de agrupamento k-means proporcionou uma distribuição mais equilibrada dos valores de pixel. Também verificámos o consumo de memória das imagens comprimidas e descobrimos que a imagem comprimida utilizava 8 vezes mais memória que a imagem original devido ao uso de uma representação de ponto flutuante de 64 bits para a imagem comprimida.

Resumo

Parabéns! Você concluiu o laboratório de Quantização Vetorial com KBinsDiscretizer. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.