Quantification vectorielle avec KBinsDiscretizer

Introduction

Ce laboratoire montre comment utiliser KBinsDiscretizer de la bibliothèque Scikit-learn pour effectuer une quantification vectorielle sur une image d'échantillon du visage d'un raton laveur. La quantification vectorielle est une technique pour réduire le nombre de niveaux de gris utilisés pour représenter une image. Nous utiliserons KBinsDiscretizer pour effectuer une quantification vectorielle sur l'image du visage du raton laveur. Nous utiliserons 8 niveaux de gris pour représenter l'image, ce qui peut être compressé pour n'utiliser que 3 bits par pixel. Nous comparerons les stratégies d'échantillonnage uniforme et de regroupement k-moyennes pour mapper les valeurs de pixel aux 8 niveaux de gris.

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 Notebook pour accéder à Jupyter Notebook pour la pratique.

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

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

Skills Graph

Charger et afficher l'image originale

Nous commencerons par charger l'image du visage de raton laveur à partir de Scipy. Nous afficherons l'image et vérifierons sa forme, son type de données et son utilisation mémoire.

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

raccoon_face = face(gray=True)

print(f"La dimension de l'image est {raccoon_face.shape}")
print(f"Les données utilisées pour encoder l'image sont de type {raccoon_face.dtype}")
print(f"Le nombre d'octets occupés en RAM est {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("Image originale")
ax[1].hist(raccoon_face.ravel(), bins=256)
ax[1].set_xlabel("Valeur du pixel")
ax[1].set_ylabel("Nombre de pixels")
ax[1].set_title("Distribution des valeurs des pixels")
_ = fig.suptitle("Image originale du visage d'un raton laveur")

Quantification vectorielle à l'aide de KBinsDiscretizer

Nous allons maintenant utiliser KBinsDiscretizer pour effectuer une quantification vectorielle sur l'image du visage de raton laveur. Nous utiliserons 8 niveaux de gris pour représenter l'image, ce qui peut être compressé pour n'utiliser que 3 bits par pixel. Nous utiliserons les stratégies d'échantillonnage uniforme et de regroupement k-moyennes pour mapper les valeurs de pixel aux 8 niveaux de gris.

Stratégie d'échantillonnage uniforme

Nous utiliserons tout d'abord la stratégie d'échantillonnage uniforme pour mapper les valeurs de pixel aux 8 niveaux 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("Echantillonnage uniforme")
ax[1].hist(compressed_raccoon_uniform.ravel(), bins=256)
ax[1].set_xlabel("Valeur du pixel")
ax[1].set_ylabel("Nombre de pixels")
ax[1].set_title("Distribution des valeurs des pixels")
_ = fig.suptitle("Visage de raton laveur compressé avec 3 bits et une stratégie uniforme")

Stratégie de regroupement k-moyennes

Nous allons maintenant utiliser la stratégie de regroupement k-moyennes pour mapper les valeurs de pixel aux 8 niveaux 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("Regroupement k-moyennes")
ax[1].hist(compressed_raccoon_kmeans.ravel(), bins=256)
ax[1].set_xlabel("Valeur du pixel")
ax[1].set_ylabel("Nombre de pixels")
ax[1].set_title("Distribution des valeurs des pixels")
_ = fig.suptitle("Visage de raton laveur compressé avec 3 bits et une stratégie k-moyennes")

Emprise mémoire

Nous allons maintenant vérifier l'utilisation mémoire des images compressées. Nous nous attendons à ce que l'image compressée prenne 8 fois moins de mémoire que l'image originale.

print(f"Le nombre d'octets occupés en RAM est {compressed_raccoon_kmeans.nbytes}")
print(f"Taux de compression : {compressed_raccoon_kmeans.nbytes / raccoon_face.nbytes}")

Résumé

Dans ce laboratoire, nous avons utilisé KBinsDiscretizer de Scikit-learn pour effectuer une quantification vectorielle sur une image d'échantillon du visage d'un raton laveur. Nous avons utilisé 8 niveaux de gris pour représenter l'image, ce qui peut être compressé pour n'utiliser que 3 bits par pixel. Nous avons comparé les stratégies d'échantillonnage uniforme et de regroupement k-moyennes pour mapper les valeurs de pixel aux 8 niveaux de gris. Nous avons constaté que la stratégie de regroupement k-moyennes offrait une distribution plus équilibrée des valeurs de pixel. Nous avons également vérifié l'utilisation mémoire des images compressées et avons découvert que l'image compressée occupait 8 fois plus de mémoire que l'image originale en raison de l'utilisation d'une représentation à virgule flottante 64 bits pour l'image compressée.

Résumé

Félicitations ! Vous avez terminé le laboratoire sur la quantification vectorielle avec KBinsDiscretizer. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.