Aprendizaje de variedades en dígitos manuscritos

Introducción

En este laboratorio, exploraremos varias técnicas de incrustación de variedades en el conjunto de datos de dígitos. Utilizaremos diferentes técnicas para incrustar el conjunto de datos de dígitos, graficar la proyección de los datos originales en cada incrustación y comparar los resultados obtenidos a partir de diferentes métodos de incrustación.

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 puede automatizarse debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Cargar el conjunto de datos de dígitos

Cargaremos el conjunto de datos de dígitos y solo usaremos seis de las diez clases disponibles. También graficaremos los primeros cien dígitos de este conjunto de datos.

## Cargar el conjunto de datos de dígitos
from sklearn.datasets import load_digits

digits = load_digits(n_class=6)
X, y = digits.data, digits.target
n_samples, n_features = X.shape
n_neighbors = 30

## Graficar los primeros cien dígitos
import matplotlib.pyplot as plt

fig, axs = plt.subplots(nrows=10, ncols=10, figsize=(6, 6))
for idx, ax in enumerate(axs.ravel()):
    ax.imshow(X[idx].reshape((8, 8)), cmap=plt.cm.binary)
    ax.axis("off")
_ = fig.suptitle("Una selección del conjunto de datos de dígitos de 64 dimensiones", fontsize=16)

Graficar la función de incrustación

Definiremos una función auxiliar para graficar la incrustación. La función toma los datos de incrustación y el título para la gráfica como entrada. La función graficará cada dígito en la incrustación y mostrará una caja de anotación para un grupo de dígitos.

import numpy as np
from matplotlib import offsetbox
from sklearn.preprocessing import MinMaxScaler

def plot_embedding(X, title):
    _, ax = plt.subplots()
    X = MinMaxScaler().fit_transform(X)

    for digit in digits.target_names:
        ax.scatter(
            *X[y == digit].T,
            marker=f"${digit}$",
            s=60,
            color=plt.cm.Dark2(digit),
            alpha=0.425,
            zorder=2,
        )
    shown_images = np.array([[1.0, 1.0]])  ## solo algo grande
    for i in range(X.shape[0]):
        ## graficar cada dígito en la incrustación
        ## mostrar una caja de anotación para un grupo de dígitos
        dist = np.sum((X[i] - shown_images) ** 2, 1)
        if np.min(dist) < 4e-3:
            ## no mostrar puntos que estén demasiado cerca
            continue
        shown_images = np.concatenate([shown_images, [X[i]]], axis=0)
        imagebox = offsetbox.AnnotationBbox(
            offsetbox.OffsetImage(digits.images[i], cmap=plt.cm.gray_r), X[i]
        )
        imagebox.set(zorder=1)
        ax.add_artist(imagebox)

    ax.set_title(title)
    ax.axis("off")

Comparar técnicas de incrustación

Compararemos diferentes técnicas de incrustación utilizando diferentes métodos. Almacenaremos los datos proyectados, así como el tiempo de cómputo necesario para realizar cada proyección.

from sklearn.decomposition import TruncatedSVD
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.ensemble import RandomTreesEmbedding
from sklearn.manifold import (
    Isomap,
    LocallyLinearEmbedding,
    MDS,
    SpectralEmbedding,
    TSNE,
)
from sklearn.neighbors import NeighborhoodComponentsAnalysis
from sklearn.pipeline import make_pipeline
from sklearn.random_projection import SparseRandomProjection

embeddings = {
    "Random projection embedding": SparseRandomProjection(
        n_components=2, random_state=42
    ),
    "Truncated SVD embedding": TruncatedSVD(n_components=2),
    "Linear Discriminant Analysis embedding": LinearDiscriminantAnalysis(
        n_components=2
    ),
    "Isomap embedding": Isomap(n_neighbors=n_neighbors, n_components=2),
    "Standard LLE embedding": LocallyLinearEmbedding(
        n_neighbors=n_neighbors, n_components=2, method="standard"
    ),
    "Modified LLE embedding": LocallyLinearEmbedding(
        n_neighbors=n_neighbors, n_components=2, method="modified"
    ),
    "Hessian LLE embedding": LocallyLinearEmbedding(
        n_neighbors=n_neighbors, n_components=2, method="hessian"
    ),
    "LTSA LLE embedding": LocallyLinearEmbedding(
        n_neighbors=n_neighbors, n_components=2, method="ltsa"
    ),
    "MDS embedding": MDS(
        n_components=2, n_init=1, max_iter=120, n_jobs=2, normalized_stress="auto"
    ),
    "Random Trees embedding": make_pipeline(
        RandomTreesEmbedding(n_estimators=200, max_depth=5, random_state=0),
        TruncatedSVD(n_components=2),
    ),
    "Spectral embedding": SpectralEmbedding(
        n_components=2, random_state=0, eigen_solver="arpack"
    ),
    "t-SNE embeedding": TSNE(
        n_components=2,
        n_iter=500,
        n_iter_without_progress=150,
        n_jobs=2,
        random_state=0
    ),
    "NCA embedding": NeighborhoodComponentsAnalysis(
        n_components=2, init="pca", random_state=0
    ),
}

projections, timing = {}, {}
for name, transformer in embeddings.items():
    if name.startswith("Linear Discriminant Analysis"):
        data = X.copy()
        data.flat[:: X.shape[1] + 1] += 0.01  ## Make X invertible
    else:
        data = X

    print(f"Computing {name}...")
    start_time = time()
    projections[name] = transformer.fit_transform(data, y)
    timing[name] = time() - start_time

Graficar los resultados

Graficaremos la proyección resultante dada por cada método.

for name in timing:
    title = f"{name} (tiempo {timing[name]:.3f}s)"
    plot_embedding(projections[name], title)

plt.show()

Resumen

En este laboratorio, exploramos varias técnicas de incrustación de variedades en el conjunto de datos de dígitos. Utilizamos diferentes técnicas para incrustar el conjunto de datos de dígitos, graficamos la proyección de los datos originales en cada incrustación y comparamos los resultados obtenidos a partir de diferentes métodos de incrustación. Los resultados ofrecen una comprensión de la efectividad de cada método de incrustación para agrupar dígitos similares en el espacio de incrustación.