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.
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.