Quantification de couleur à l'aide de K-Means

Introduction

La quantification de couleurs est un processus consistant à réduire le nombre de couleurs distinctes utilisées dans une image tout en préservant son aspect global. Cela se fait en regroupant les couleurs similaires et en les représentant avec une seule valeur de couleur. Dans ce laboratoire, nous utiliserons l'algorithme de clustering K-Means pour effectuer la quantification de couleurs sur une image du Palais d'été en Chine.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Charger et afficher l'image d'origine

Nous allons commencer par charger et afficher l'image d'origine du Palais d'été.

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

## Charger la photo du Palais d'été
china = load_sample_image("china.jpg")

## Afficher l'image d'origine
plt.figure()
plt.axis("off")
plt.title("Image d'origine")
plt.imshow(china)
plt.show()

Convertir l'image en flottants et redimensionner

Nous allons convertir l'image en flottants et la redimensionner en un tableau numpy 2D afin qu'elle puisse être traitée par l'algorithme K-Means.

## Convertir en flottants au lieu du codage entier par défaut de 8 bits.
china = np.array(china, dtype=np.float64) / 255

## Obtenir les dimensions de l'image
w, h, d = original_shape = tuple(china.shape)
assert d == 3

## Redimensionner l'image en un tableau numpy 2D
image_array = np.reshape(china, (w * h, d))

Ajuster le modèle K-Means

Nous allons ajuster le modèle K-Means sur un petit sous-échantillonnage des données d'image, et l'utiliser pour prédire les indices de couleur sur l'image complète.

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

n_colors = 64

## Ajuster le modèle K-Means sur un petit sous-échantillonnage des données
print("Ajustement du modèle sur un petit sous-échantillonnage des données")
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"terminé en {time() - t0:0.3f}s.")

## Obtenir les étiquettes pour tous les points
print("Prédiction des indices de couleur sur l'image complète (k-means)")
t0 = time()
labels = kmeans.predict(image_array)
print(f"terminé en {time() - t0:0.3f}s.")

Prédire les indices de couleur à l'aide d'un livre de codes aléatoire

Nous allons prédire les indices de couleur sur l'image complète à l'aide d'un livre de codes aléatoire.

## Obtenir un livre de codes aléatoire
codebook_random = shuffle(image_array, random_state=0, n_samples=n_colors)

## Prédire les indices de couleur sur l'image complète à l'aide du livre de codes aléatoire
print("Prédiction des indices de couleur sur l'image complète (aléatoire)")
t0 = time()
labels_random = pairwise_distances_argmin(codebook_random, image_array, axis=0)
print(f"terminé en {time() - t0:0.3f}s.")

Recréer l'image

Nous allons recréer l'image compressée à l'aide du livre de codes et des étiquettes obtenus à partir du modèle K-Means et du livre de codes aléatoire.

def recreate_image(codebook, labels, w, h):
    """Recréer l'image (compressée) à partir du livre de codes & des étiquettes"""
    return codebook[labels].reshape(w, h, -1)

## Afficher l'image d'origine côte à côte avec les images quantisées
plt.figure()
plt.clf()
plt.axis("off")
plt.title("Image d'origine (96 615 couleurs)")
plt.imshow(china)

plt.figure()
plt.clf()
plt.axis("off")
plt.title(f"Image quantisée ({n_colors} couleurs, K-Means)")
plt.imshow(recreate_image(kmeans.cluster_centers_, labels, w, h))

plt.figure()
plt.clf()
plt.axis("off")
plt.title(f"Image quantisée ({n_colors} couleurs, Aléatoire)")
plt.imshow(recreate_image(codebook_random, labels_random, w, h))

plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à utiliser l'algorithme de regroupement K-Means pour effectuer une quantification de couleur sur une image. Nous avons chargé et affiché l'image d'origine, la convertie en flottants et la redimensionnée en un tableau numpy 2D. Nous avons ajusté le modèle K-Means sur un sous-échantillonnage des données d'image et l'avons utilisé pour prédire les indices de couleur sur l'image complète. Nous avons également prédit les indices de couleur sur l'image complète à l'aide d'un livre de codes aléatoire. Enfin, nous avons recréé l'image compressée à l'aide du livre de codes et des étiquettes obtenus à partir du modèle K-Means et du livre de codes aléatoire, et affiché l'image d'origine côte à côte avec les images quantisées.