Comparando Classificação por Vizinhos Mais Próximos com e sem NCA

Introdução

Este laboratório mostrará como comparar a classificação de vizinhos mais próximos com e sem Análise de Componentes de Vizinhança (NCA). Iremos plotar os limites de decisão de classe dados por um classificador de Vizinhos Mais Próximos quando se utiliza a distância euclidiana nas características originais, versus a utilização da distância euclidiana após a transformação aprendida pela Análise de Componentes de Vizinhança. Este último visa encontrar uma transformação linear que maximize a precisão (estocástica) da classificação de vizinhos mais próximos no conjunto de treino. Usaremos o conjunto de dados Iris, que contém 3 classes de 50 instâncias cada.

Dicas da Máquina Virtual

Após o arranque da VM, 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 o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Importar Bibliotecas

Começaremos importando as bibliotecas necessárias. Usaremos o scikit-learn para realizar a classificação de vizinhos mais próximos e a NCA. Usaremos o matplotlib para plotar os limites de decisão de classe.

import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier, NeighborhoodComponentsAnalysis
from sklearn.pipeline import Pipeline
from sklearn.inspection import DecisionBoundaryDisplay

Carregar e Preparar os Dados

Em seguida, carregaremos e prepararemos os dados. Carregaremos o conjunto de dados Iris usando o scikit-learn e selecionaremos apenas duas características. Em seguida, dividiremos os dados em um conjunto de treino e um conjunto de teste.

n_neighbors = 1

dataset = datasets.load_iris()
X, y = dataset.data, dataset.target

## apenas duas características são selecionadas. Poderíamos evitar este corte feio usando um conjunto de dados bidimensional
X = X[:, [0, 2]]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, stratify=y, test_size=0.7, random_state=42
)

Criar Mapas de Cores

Agora criaremos mapas de cores para plotar os limites de decisão das classes. Usaremos cores claras para o fundo e cores fortes para as cores das classes.

h = 0.05  ## tamanho do passo na malha

## Criar mapas de cores
cmap_light = ListedColormap(["#FFAAAA", "#AAFFAA", "#AAAAFF"])
cmap_bold = ListedColormap(["#FF0000", "#00FF00", "#0000FF"])

Definir Classificadores

Definiremos dois classificadores: um usando KNN e outro usando NCA e KNN. Usaremos pipelines para escalar os dados e aplicar os classificadores.

names = ["KNN", "NCA, KNN"]

classifiers = [
    Pipeline(
        [
            ("scaler", StandardScaler()),
            ("knn", KNeighborsClassifier(n_neighbors=n_neighbors)),
        ]
    ),
    Pipeline(
        [
            ("scaler", StandardScaler()),
            ("nca", NeighborhoodComponentsAnalysis()),
            ("knn", KNeighborsClassifier(n_neighbors=n_neighbors)),
        ]
    ),
]

Treinar e Testar Classificadores

Agora, treinaremos e testaremos os classificadores. Itera-se sobre os classificadores e ajusta-os aos dados de treino. Em seguida, plotaremos os limites de decisão das classes e calcularemos a pontuação nos dados de teste.

for name, clf in zip(names, classifiers):
    clf.fit(X_train, y_train)
    score = clf.score(X_test, y_test)

    _, ax = plt.subplots()
    DecisionBoundaryDisplay.from_estimator(
        clf,
        X,
        cmap=cmap_light,
        alpha=0.8,
        ax=ax,
        response_method="predict",
        plot_method="pcolormesh",
        shading="auto",
    )

    ## Plot também os pontos de treino e teste
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold, edgecolor="k", s=20)
    plt.title("{} (k = {})".format(name, n_neighbors))
    plt.text(
        0.9,
        0.1,
        "{:.2f}".format(score),
        size=15,
        ha="center",
        va="center",
        transform=plt.gca().transAxes,
    )

plt.show()

Resumo

Neste laboratório, comparamos a classificação por vizinhos mais próximos com e sem a Análise de Componentes de Vizinhança (NCA). Usamos o conjunto de dados Iris para plotar os limites de decisão das classes dados por um classificador de Vizinhos Mais Próximos quando se utiliza a distância euclidiana nas características originais, versus a utilização da distância euclidiana após a transformação aprendida pela NCA. Usamos o scikit-learn para realizar a classificação por vizinhos mais próximos e a NCA. Também usamos o matplotlib para plotar os limites de decisão das classes. Concluímos que a NCA melhorou a precisão da classificação.

Plotar Classificação com NCA