Introduction
L'apprentissage à variété est un sous-domaine de l'apprentissage automatique qui traite de l'apprentissage de la structure sous-jacente des données à haute dimension. Dans ce laboratoire, nous allons appliquer différentes techniques d'apprentissage à variété sur un ensemble de données sphériques. Nous utiliserons la réduction de la dimensionalité pour acquérir quelques intuitions sur les méthodes d'apprentissage à variété.
Conseils sur la VM
Une fois le démarrage de la VM 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églerons rapidement le problème pour vous.
Importation des bibliothèques
Nous allons commencer par importer les bibliothèques nécessaires. Nous utiliserons scikit - learn, matplotlib et numpy.
from time import time
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import NullFormatter
from sklearn import manifold
from sklearn.utils import check_random_state
import mpl_toolkits.mplot3d
Création d'un ensemble de données sphérique
Ensuite, nous allons créer un ensemble de données sphérique. Nous allons créer une sphère, couper les pôles et une tranche mince le long de son côté. Cela permettra aux techniques d'apprentissage à variété de "l'étendre" tout en la projetant sur deux dimensions.
n_neighbors = 10
n_samples = 1000
random_state = check_random_state(0)
p = random_state.rand(n_samples) * (2 * np.pi - 0.55)
t = random_state.rand(n_samples) * np.pi
indices = (t < (np.pi - (np.pi / 8))) & (t > ((np.pi / 8)))
colors = p[indices]
x, y, z = (
np.sin(t[indices]) * np.cos(p[indices]),
np.sin(t[indices]) * np.sin(p[indices]),
np.cos(t[indices]),
)
fig = plt.figure(figsize=(15, 8))
plt.suptitle(
"Manifold Learning with %i points, %i neighbors" % (1000, n_neighbors), fontsize=14
)
ax = fig.add_subplot(251, projection="3d")
ax.scatter(x, y, z, c=p[indices], cmap=plt.cm.rainbow)
ax.view_init(40, -10)
sphere_data = np.array([x, y, z]).T
Effectuer l'apprentissage à variété par Embedding Linéaire Local
Nous allons maintenant effectuer l'apprentissage à variété par Embedding Linéaire Local (LLE). LLE est une technique puissante qui peut déplier des variétés complexes avec un nombre réduit d'échantillons. Nous utiliserons quatre variantes de LLE et comparerons leurs résultats.
methods = ["standard", "ltsa", "hessian", "modified"]
labels = ["LLE", "LTSA", "Hessian LLE", "Modified LLE"]
for i, method in enumerate(methods):
t0 = time()
trans_data = (
manifold.LocallyLinearEmbedding(
n_neighbors=n_neighbors, n_components=2, method=method
)
.fit_transform(sphere_data).T
)
t1 = time()
print("%s: %.2g sec" % (methods[i], t1 - t0))
ax = fig.add_subplot(252 + i)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("%s (%.2g sec)" % (labels[i], t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")
Effectuer l'apprentissage à variété par Isomap
Ensuite, nous allons effectuer l'apprentissage à variété par Isomap. Isomap est une technique de réduction de la dimensionalité non linéaire qui cherche une projection en dimension réduite des données qui conserve les distances géodésiques entre tous les couples de points.
t0 = time()
trans_data = (
manifold.Isomap(n_neighbors=n_neighbors, n_components=2)
.fit_transform(sphere_data).T
)
t1 = time()
print("%s: %.2g sec" % ("ISO", t1 - t0))
ax = fig.add_subplot(257)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("%s (%.2g sec)" % ("Isomap", t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")
Effectuer l'échelle multidimensionnelle (MDS)
Nous allons maintenant effectuer l'apprentissage à variété par échelle multidimensionnelle (MDS). MDS est une technique qui cherche une représentation en dimension réduite des données dans laquelle les distances entre les points respectent les distances dans l'espace original de haute dimension.
t0 = time()
mds = manifold.MDS(2, max_iter=100, n_init=1, normalized_stress="auto")
trans_data = mds.fit_transform(sphere_data).T
t1 = time()
print("MDS: %.2g sec" % (t1 - t0))
ax = fig.add_subplot(258)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("MDS (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")
Effectuer l'imbrication spectrale
Ensuite, nous allons effectuer l'apprentissage à variété par imbrication spectrale. L'imbrication spectrale est une technique qui cherche une représentation en dimension réduite des données qui conserve les distances entre les paires de points.
t0 = time()
se = manifold.SpectralEmbedding(n_components=2, n_neighbors=n_neighbors)
trans_data = se.fit_transform(sphere_data).T
t1 = time()
print("Spectral Embedding: %.2g sec" % (t1 - t0))
ax = fig.add_subplot(259)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("Spectral Embedding (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")
Effectuer l'imbrication stochastique voisine t-distribuée (t-SNE)
Enfin, nous allons effectuer l'apprentissage à variété par imbrication stochastique voisine t-distribuée (t-SNE). t-SNE est une technique qui cherche une représentation en dimension réduite des données qui conserve les distances locales entre les points.
t0 = time()
tsne = manifold.TSNE(n_components=2, random_state=0)
trans_data = tsne.fit_transform(sphere_data).T
t1 = time()
print("t-SNE: %.2g sec" % (t1 - t0))
ax = fig.add_subplot(2, 5, 10)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("t-SNE (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")
plt.show()
Sommaire
Dans ce laboratoire, nous avons appliqué différentes techniques d'apprentissage à variété sur un ensemble de données sphériques. Nous avons utilisé l'imbrication linéaire locale (Locally Linear Embedding - LLE), Isomap, l'échelle multidimensionnelle (Multi-dimensional Scaling - MDS), l'imbrication spectrale et l'imbrication stochastique voisine t-distribuée (t-SNE) pour acquérir quelques intuitions sur les méthodes d'apprentissage à variété. Ces techniques sont utiles pour l'analyse et la visualisation de données de haute dimension.