Comparaison de l'apprentissage sur variété

Introduction

Dans ce laboratoire, nous allons comparer différents algorithmes de Manifold Learning pour effectuer une réduction de dimensionnalité non linéaire. Le but de ceci est de réduire la dimensionnalité de l'ensemble de données tout en conservant les caractéristiques essentielles des données originales.

Nous utiliserons l'ensemble de données S-curve, qui est un ensemble de données couramment utilisé pour la réduction de dimensionnalité. Nous utiliserons des algorithmes tels que les Embeddings Linéaires Locaux, l'Embeding Isomap, l'Echelle Multidimensionnelle, l'Embeding Spectral et l'Embeding T-distribué de Voisins Stochastiques.

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

Préparation de l'ensemble de données

Nous commençons par générer l'ensemble de données S-curve.

import matplotlib.pyplot as plt
from matplotlib import ticker

## unused but required import for doing 3d projections with matplotlib < 3.2
import mpl_toolkits.mplot3d  ## noqa: F401

from sklearn import manifold, datasets

n_samples = 1500
S_points, S_color = datasets.make_s_curve(n_samples, random_state=0)

Embeddings Linéaires Locaux

L'Embedding Linéaire Local (Locally Linear Embedding - LLE) est une série d'Analyses en Composantes Principales locales qui sont comparées globalement pour trouver la meilleure non-linéaire embedding. Nous utiliserons quatre méthodes différentes de LLE, soit la Standard, l'Ajustement de l'espace tangent local, la Carte d'eigenvaleur de Hessian et l'Embedding Linéaire Local Modifié.

params = {
    "n_neighbors": n_neighbors,
    "n_components": n_components,
    "eigen_solver": "auto",
    "random_state": 0,
}

lle_standard = manifold.LocallyLinearEmbedding(method="standard", **params)
S_standard = lle_standard.fit_transform(S_points)

lle_ltsa = manifold.LocallyLinearEmbedding(method="ltsa", **params)
S_ltsa = lle_ltsa.fit_transform(S_points)

lle_hessian = manifold.LocallyLinearEmbedding(method="hessian", **params)
S_hessian = lle_hessian.fit_transform(S_points)

lle_mod = manifold.LocallyLinearEmbedding(method="modified", **params)
S_mod = lle_mod.fit_transform(S_points)

Embeding Isomap

Isomap cherche un emmbeding à basse dimension qui conserve les distances géodésiques entre tous les points.

isomap = manifold.Isomap(n_neighbors=n_neighbors, n_components=n_components, p=1)
S_isomap = isomap.fit_transform(S_points)

Echelle Multidimensionnelle

L'Echelle Multidimensionnelle (Multidimensional Scaling - MDS) cherche une représentation à basse dimension des données dans laquelle les distances respectent bien les distances dans l'espace original à haute dimension.

md_scaling = manifold.MDS(
    n_components=n_components,
    max_iter=50,
    n_init=4,
    random_state=0,
    normalized_stress=False,
)
S_scaling = md_scaling.fit_transform(S_points)

Embedding Spectral pour la réduction de dimension non linéaire

Cette implémentation utilise les Cartes d'eigenvaleur de Laplacien, qui trouve une représentation à basse dimension des données en utilisant une décomposition spectrale du Laplacien du graphe.

spectral = manifold.SpectralEmbedding(
    n_components=n_components, n_neighbors=n_neighbors
)
S_spectral = spectral.fit_transform(S_points)

Embedding aléatoire voisin T-distribué

Il convertit les similitudes entre les points de données en probabilités conjointes et essaie de minimiser la divergence de Kullback-Leibler entre les probabilités conjointes de l'embedding à basse dimension et les données à haute dimension.

t_sne = manifold.TSNE(
    n_components=n_components,
    perplexity=30,
    init="random",
    n_iter=250,
    random_state=0,
)
S_t_sne = t_sne.fit_transform(S_points)

Sommaire

L'apprentissage sur variété est une approche pour la réduction de dimension non linéaire. Dans ce laboratoire, nous avons comparé différents algorithmes d'apprentissage sur variété tels que les plongements linéaires locaux, l'embedding Isomap, l'échelle multidimensionnelle, l'embedding spectral et l'embedding aléatoire voisin T-distribué pour effectuer une réduction de dimension non linéaire sur l'ensemble de données en forme de S.