Segmentation de monnaies grecques avec le regroupement spectral

Introduction

Dans ce laboratoire, nous utiliserons le regroupement spectral pour segmenter une image de monnaies grecques en plusieurs régions partiellement homogènes. Le regroupement spectral est une technique puissante qui peut être utilisée pour identifier les groupes dans un ensemble de données sur la base de la similarité entre leurs caractéristiques. Dans ce laboratoire, nous utiliserons le regroupement spectral pour segmenter une image en créant un graphe à partir des différences entre voxels sur une image puis en divisant l'image en plusieurs régions partiellement homogènes.

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églerons rapidement le problème pour vous.

Charger et prétraiter l'image

Nous commencerons par charger l'image de monnaies grecques et la prétraiter pour la rendre plus facile à manipuler. Nous allons redimensionner l'image à 20% de sa taille d'origine et appliquer un filtre Gaussien pour le lissage avant la réduction d'échelle pour réduire les artefacts d'aliasing.

## charger les monnaies sous forme d'un tableau numpy
orig_coins = coins()

## Redimensionnez-la à 20% de sa taille d'origine pour accélérer le traitement
## Appliquer un filtre Gaussien pour le lissage avant la réduction d'échelle
## réduit les artefacts d'aliasing.
smoothened_coins = gaussian_filter(orig_coins, sigma=2)
rescaled_coins = rescale(smoothened_coins, 0.2, mode="reflect", anti_aliasing=False)

Convertir l'image en un graphe avec la valeur du gradient sur les arêtes

Nous allons convertir l'image en un graphe avec la valeur du gradient sur les arêtes. Plus beta est petit, plus la segmentation est indépendante de l'image réelle. Pour beta = 1, la segmentation est proche d'un diagramme de Voronoi.

## Convertir l'image en un graphe avec la valeur du gradient sur les
## arêtes.
graph = image.img_to_graph(rescaled_coins)

## Prendre une fonction décroissante du gradient : une exponentielle
beta = 10
eps = 1e-6
graph.data = np.exp(-beta * graph.data / graph.data.std()) + eps

Appliquer le regroupement spectral

Nous allons appliquer le regroupement spectral en utilisant le solveur d'eigenvaleur par défaut eigen_solver='arpack'. N'importe quel solveur implémenté peut être utilisé : eigen_solver='arpack', 'lobpcg' ou 'amg'. Choisir eigen_solver='amg' nécessite un package supplémentaire appelé 'pyamg'. La qualité de la segmentation et la vitesse des calculs sont principalement déterminées par le choix du solveur et la valeur de la tolérance eigen_tol.

## Appliquer le regroupement spectral en utilisant le solveur d'eigenvaleur par défaut `eigen_solver='arpack'`.
## N'importe quel solveur implémenté peut être utilisé : `eigen_solver='arpack'`, `'lobpcg'` ou `'amg'`.
## Choisir `eigen_solver='amg'` nécessite un package supplémentaire appelé `'pyamg'`.
## La qualité de la segmentation et la vitesse des calculs sont principalement déterminées
## par le choix du solveur et la valeur de la tolérance `eigen_tol`.
n_regions = 26
n_regions_plus = 3
for assign_labels in ("kmeans", "discretize", "cluster_qr"):
    t0 = time.time()
    labels = spectral_clustering(
        graph,
        n_clusters=(n_regions + n_regions_plus),
        eigen_tol=1e-7,
        assign_labels=assign_labels,
        random_state=42,
    )
    t1 = time.time()
    labels = labels.reshape(rescaled_coins.shape)

Visualiser la segmentation

Nous allons visualiser les régions résultantes en traçant l'image d'origine et en superposant les contours des régions segmentées.

plt.figure(figsize=(5, 5))
plt.imshow(rescaled_coins, cmap=plt.cm.gray)
plt.xticks(())
plt.yticks(())
title = "Regroupement spectral : %s, %.2fs" % (assign_labels, (t1 - t0))
print(title)
plt.title(title)
for l in range(n_regions):
    colors = [plt.cm.nipy_spectral((l + 4) / float(n_regions + 4))]
    plt.contour(labels == l, colors=colors)
plt.show()

Sommaire

Dans ce laboratoire, nous avons utilisé le regroupement spectral pour segmenter une image de monnaies grecques en de multiples régions partiellement homogènes. Nous avons prétraité l'image, la convertie en un graphe avec la valeur du gradient sur les arêtes, appliqué le regroupement spectral et visualisé les régions résultantes. Le regroupement spectral est une technique puissante qui peut être utilisée pour identifier des groupes dans un ensemble de données en fonction de la similarité entre leurs caractéristiques.