Aprendizaje de variedades en datos esféricos

Introducción

El aprendizaje de variedades es un subcampo del aprendizaje automático que se ocupa de aprender la estructura subyacente de datos de alta dimensión. En este laboratorio, aplicaremos diferentes técnicas de aprendizaje de variedades en un conjunto de datos esférico. Utilizaremos la reducción de dimensionalidad para obtener algunas intuiciones sobre los métodos de aprendizaje de variedades.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y le resolveremos el problema inmediatamente.

Skills Graph

Importar bibliotecas

Comenzaremos importando las bibliotecas necesarias. Utilizaremos scikit-learn, matplotlib y 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

Crear conjunto de datos esférico

A continuación, crearemos un conjunto de datos esférico. Crearemos una esfera, cortaremos los polos y una lámina delgada por su lado. Esto permitirá que las técnicas de aprendizaje de variedades 'lo abran' mientras lo proyectan en dos dimensiones.

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

Realizar el aprendizaje de variedades con Embedding Lineal Local

Ahora realizaremos el aprendizaje de variedades con Embedding Lineal Local (LLE). LLE es una técnica poderosa que puede deshacerse de variedades complicadas con un número reducido de muestras. Utilizaremos cuatro variaciones de LLE y compararemos sus resultados.

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")

Realizar el aprendizaje de variedades con Isomap

A continuación, realizaremos el aprendizaje de variedades con Isomap. Isomap es una técnica de reducción de dimensionalidad no lineal que busca una proyección de baja dimensionalidad de los datos que mantenga las distancias geodesicas entre todos los pares de puntos.

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")

Realizar escalamiento multidimensional (MDS)

Ahora realizaremos el aprendizaje de variedades con escalamiento multidimensional (MDS). MDS es una técnica que busca una representación de baja dimensionalidad de los datos en la que las distancias entre los puntos respeten las distancias en el espacio de alta dimensionalidad original.

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")

Realizar la incrustación espectral

A continuación, realizaremos el aprendizaje de variedades con incrustación espectral. La incrustación espectral es una técnica que busca una representación de baja dimensionalidad de los datos que preserva las distancias entre pares de puntos.

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")

Realizar la incrustación estocástica de vecinos con distribución t (t-SNE)

Finalmente, realizaremos el aprendizaje de variedades con la incrustación estocástica de vecinos con distribución t (t-SNE). t-SNE es una técnica que busca una representación de baja dimensionalidad de los datos que preserva las distancias locales entre los puntos.

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()

Resumen

En este laboratorio, aplicamos diferentes técnicas de aprendizaje de variedades en un conjunto de datos esféricos. Utilizamos Embedding Lineal Local (Locally Linear Embedding - LLE), Isomap, Escalamiento Multidimensional (Multi-dimensional Scaling - MDS), Embedding Espectral y Embedding Estocástico de Vecinos con Distribución t (t-distributed Stochastic Neighbor Embedding - t-SNE) para adquirir intuición sobre los métodos de aprendizaje de variedades. Estas técnicas son útiles para analizar y visualizar datos de alta dimensionalidad.