Introdução
Neste laboratório, exploraremos diversas técnicas de incorporação de variedades de dados no conjunto de dados de dígitos. Usaremos diferentes técnicas para incorporar o conjunto de dados de dígitos, plotar a projeção dos dados originais em cada incorporação e comparar os resultados obtidos com diferentes métodos de incorporação.
Dicas da Máquina Virtual
Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.
Por vezes, pode ser necessário esperar 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 tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.
Carregar o Conjunto de Dados de Dígitos
Carregaremos o conjunto de dados de dígitos e usaremos apenas seis das dez classes disponíveis. Também plotaremos os cem primeiros dígitos deste conjunto de dados.
## Carregar o conjunto de dados 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
## Plotar os cem primeiros 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("Uma seleção do conjunto de dados de dígitos 64-dimensionais", fontsize=16)
Função de Plotagem de Incorporação
Definiremos uma função auxiliar para plotar a incorporação. A função recebe os dados de incorporação e o título do gráfico como entrada. A função plotará cada dígito na incorporação e mostrará uma caixa de anotação para um 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]]) ## apenas algo grande
for i in range(X.shape[0]):
## plotar cada dígito na incorporação
## mostrar uma caixa de anotação para um grupo de dígitos
dist = np.sum((X[i] - shown_images) ** 2, 1)
if np.min(dist) < 4e-3:
## não mostrar pontos muito próximos
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 Incorporação
Vamos comparar diferentes técnicas de incorporação usando diferentes métodos. Armazenaremos os dados projetados, bem como o tempo de computação necessário para realizar cada projeção.
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 ## Tornar X invertível
else:
data = X
print(f"Computando {name}...")
start_time = time()
projections[name] = transformer.fit_transform(data, y)
timing[name] = time() - start_time
Plotar Resultados
Vamos plotar a projeção resultante de cada método.
for name in timing:
title = f"{name} (tempo {timing[name]:.3f}s)"
plot_embedding(projections[name], title)
plt.show()
Resumo
Neste laboratório, exploramos várias técnicas de incorporação de variedades no conjunto de dados de dígitos. Utilizamos diferentes técnicas para incorporar o conjunto de dados de dígitos, plotamos a projeção dos dados originais em cada incorporação e comparamos os resultados obtidos com diferentes métodos de incorporação. Os resultados fornecem insights sobre a eficácia de cada método de incorporação em agrupar dígitos semelhantes no espaço de incorporação.