Aprendizado de Variedades em Dados Esféricos

Introdução

O aprendizado de variedades é um subcampo do aprendizado de máquina que lida com o aprendizado da estrutura subjacente de dados de alta dimensionalidade. Neste laboratório, aplicaremos diferentes técnicas de aprendizado de variedades a um conjunto de dados esférico. Usaremos a redução de dimensionalidade para obter alguma intuição sobre os métodos de aprendizado de variedades.

Dicas da Máquina Virtual

Após o início da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para você.

Importar Bibliotecas

Começaremos importando as bibliotecas necessárias. Usaremos scikit-learn, matplotlib e 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

Criar Conjunto de Dados Esférico

Em seguida, criaremos um conjunto de dados esférico. Criaremos uma esfera, separando os pólos e uma fatia fina ao longo de seu lado. Isso permitirá que as técnicas de aprendizado de variedades "a abram" ao projetá-la em duas dimensões.

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(
    "Aprendizado de Variedades com %i pontos, %i vizinhos" % (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

Executar Aprendizado de Variedade por Inclusão Linear Local

Agora, executaremos o aprendizado de variedade por Inclusão Linear Local (LLE). O LLE é uma técnica poderosa que pode desdobrar variedades complexas com um pequeno número de amostras. Usaremos quatro variações do LLE e compararemos seus 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")

Executar Aprendizado de Variedade por Isomap

Em seguida, executaremos o aprendizado de variedade por Isomap. Isomap é uma técnica de redução não linear de dimensionalidade que busca uma incorporação em dimensão inferior dos dados que mantém as distâncias geodésicas entre todos os pares de pontos.

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

Executar Aprendizado de Variedade por Escalonamento Multidimensional (MDS)

Agora, executaremos o aprendizado de variedade por Escalonamento Multidimensional (MDS). MDS é uma técnica que busca uma representação de baixa dimensão dos dados na qual as distâncias entre os pontos respeitam as distâncias no espaço original de alta dimensão.

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

Executar Inclusão Espectral

Em seguida, executaremos o aprendizado de variedade por Inclusão Espectral. A Inclusão Espectral é uma técnica que busca uma representação de baixa dimensão dos dados que preserva as distâncias entre pares de pontos.

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

Executar t-distributed Stochastic Neighbor Embedding (t-SNE)

Finalmente, executaremos o aprendizado de variedade por t-distributed Stochastic Neighbor Embedding (t-SNE). O t-SNE é uma técnica que busca uma representação de baixa dimensão dos dados que preserva as distâncias locais entre os pontos.

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

Resumo

Neste laboratório, aplicamos diferentes técnicas de aprendizado de variedades em um conjunto de dados esférico. Utilizamos o Embedding Linear Local (LLE), Isomap, Escalonamento Multidimensional (MDS), Inclusão Espectral e o t-distributed Stochastic Neighbor Embedding (t-SNE) para obter alguma intuição sobre os métodos de aprendizado de variedades. Essas técnicas são úteis para analisar e visualizar dados de alta dimensão.