Réduction de la dimension Swiss Roll et Swiss-Hole

Introduction

Ce laboratoire compare deux techniques de dimensionnement non linéaires populaires, l'imbrication linéaire locale (Locally Linear Embedding - LLE) et l'imbrication stochastique voisine T-distribuée (t-SNE), sur l'ensemble de données classique de la Swiss Roll. Nous explorerons la manière dont elles gèrent toutes les deux l'ajout d'un trou dans les données.

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

Générer l'ensemble de données Swiss Roll

Nous commençons par générer l'ensemble de données Swiss Roll en utilisant la fonction make_swiss_roll() de sklearn.datasets. Cette fonction génère un ensemble de données 3D avec une forme en spirale.

import matplotlib.pyplot as plt
from sklearn import manifold, datasets

sr_points, sr_color = datasets.make_swiss_roll(n_samples=1500, random_state=0)

Visualiser l'ensemble de données Swiss Roll

Nous pouvons visualiser l'ensemble de données Swiss Roll généré en utilisant un nuage de points 3D avec des couleurs différentes représentant différents points.

fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection="3d")
fig.add_axes(ax)
ax.scatter(sr_points[:, 0], sr_points[:, 1], sr_points[:, 2], c=sr_color, s=50, alpha=0.8)
ax.set_title("Swiss Roll dans l'espace ambiant")
ax.view_init(azim=-66, elev=12)
_ = ax.text2D(0.8, 0.05, s="n_samples=1500", transform=ax.transAxes)

Calculer les plongements LLE et t-SNE de l'ensemble de données Swiss Roll

Nous calculons les plongements LLE et t-SNE de l'ensemble de données Swiss Roll en utilisant les fonctions manifold.locally_linear_embedding() et manifold.TSNE() de sklearn, respectivement.

sr_lle, sr_err = manifold.locally_linear_embedding(sr_points, n_neighbors=12, n_components=2)

sr_tsne = manifold.TSNE(n_components=2, perplexity=40, random_state=0).fit_transform(sr_points)

Visualiser les plongements LLE et t-SNE de l'ensemble de données Swiss Roll

Nous pouvons visualiser les plongements LLE et t-SNE de l'ensemble de données Swiss Roll en utilisant des nuages de points avec des couleurs différentes représentant différents points.

fig, axs = plt.subplots(figsize=(8, 8), nrows=2)
axs[0].scatter(sr_lle[:, 0], sr_lle[:, 1], c=sr_color)
axs[0].set_title("Plongement LLE de Swiss Roll")
axs[1].scatter(sr_tsne[:, 0], sr_tsne[:, 1], c=sr_color)
_ = axs[1].set_title("Plongement t-SNE de Swiss Roll")

Générer l'ensemble de données Swiss-Hole

Nous générons l'ensemble de données Swiss-Hole en ajoutant un trou à l'ensemble de données Swiss Roll en utilisant le paramètre hole=True dans la fonction make_swiss_roll().

sh_points, sh_color = datasets.make_swiss_roll(n_samples=1500, hole=True, random_state=0)

Visualiser l'ensemble de données Swiss-Hole

Nous pouvons visualiser l'ensemble de données Swiss-Hole généré en utilisant un nuage de points 3D avec des couleurs différentes représentant différents points.

fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection="3d")
fig.add_axes(ax)
ax.scatter(sh_points[:, 0], sh_points[:, 1], sh_points[:, 2], c=sh_color, s=50, alpha=0.8)
ax.set_title("Swiss-Hole dans l'espace ambiant")
ax.view_init(azim=-66, elev=12)
_ = ax.text2D(0.8, 0.05, s="n_samples=1500", transform=ax.transAxes)

Calculer les plongements LLE et t-SNE de l'ensemble de données Swiss-Hole

Nous calculons les plongements LLE et t-SNE de l'ensemble de données Swiss-Hole en utilisant les fonctions manifold.locally_linear_embedding() et manifold.TSNE() de sklearn, respectivement.

sh_lle, sh_err = manifold.locally_linear_embedding(sh_points, n_neighbors=12, n_components=2)

sh_tsne = manifold.TSNE(n_components=2, perplexity=40, init="random", random_state=0).fit_transform(sh_points)

Visualiser les plongements LLE et t-SNE de l'ensemble de données Swiss-Hole

Nous pouvons visualiser les plongements LLE et t-SNE de l'ensemble de données Swiss-Hole en utilisant des nuages de points avec des couleurs différentes représentant différents points.

fig, axs = plt.subplots(figsize=(8, 8), nrows=2)
axs[0].scatter(sh_lle[:, 0], sh_lle[:, 1], c=sh_color)
axs[0].set_title("Plongement LLE de Swiss-Hole")
axs[1].scatter(sh_tsne[:, 0], sh_tsne[:, 1], c=sh_color)
_ = axs[1].set_title("Plongement t-SNE de Swiss-Hole")

Sommaire

Dans ce laboratoire, nous avons comparé les plongements LLE et t-SNE de l'ensemble de données classique Swiss Roll et de l'ensemble de données Swiss-Hole. Nous avons visualisé les ensembles de données et leurs plongements à l'aide de nuages de points. Nous avons observé que LLE était capable de dérouler efficacement les ensembles de données Swiss Roll et Swiss-Hole, tandis que t-SNE conservait la structure générale des données mais avait tendance à regrouper des sections de points ensemble.