Aprendizado de Máquina | PCA | LinearSVC | Conjunto de Dados de Dígitos

Introdução

Neste laboratório, aprenderemos a equilibrar a complexidade do modelo e a pontuação cruzada, encontrando uma precisão decente dentro de 1 desvio padrão da melhor pontuação de precisão, minimizando o número de componentes PCA. Usaremos o conjunto de dados de dígitos do scikit-learn e um pipeline composto por PCA e LinearSVC.

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 o aprendizado, 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 para este laboratório.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC

Definir Funções

Vamos definir duas funções que serão usadas mais tarde no laboratório.

def lower_bound(cv_results):
    """
    Calcula o limite inferior dentro de 1 desvio padrão
    das melhores `mean_test_scores`.

    Parâmetros
    ----------
    cv_results : dict de numpy(masked) ndarrays
        Veja o atributo cv_results_ de `GridSearchCV`

    Retorna
    -------
    float
        Limite inferior dentro de 1 desvio padrão da
        melhor `mean_test_score`.
    """
    best_score_idx = np.argmax(cv_results["mean_test_score"])

    return (
        cv_results["mean_test_score"][best_score_idx]
        - cv_results["std_test_score"][best_score_idx]
    )


def best_low_complexity(cv_results):
    """
    Equilibra a complexidade do modelo com a pontuação cruzada.

    Parâmetros
    ----------
    cv_results : dict de numpy(masked) ndarrays
        Veja o atributo cv_results_ de `GridSearchCV`.

    Retorno
    ------
    int
        Índice de um modelo que tem o menor número de componentes PCA
        enquanto tem sua pontuação de teste dentro de 1 desvio padrão da melhor
        `mean_test_score`.
    """
    threshold = lower_bound(cv_results)
    candidate_idx = np.flatnonzero(cv_results["mean_test_score"] >= threshold)
    best_idx = candidate_idx[
        cv_results["param_reduce_dim__n_components"][candidate_idx].argmin()
    ]
    return best_idx

Carregar Dados e Definir Pipeline

Vamos carregar o conjunto de dados de dígitos do scikit-learn e definir um pipeline composto por PCA e LinearSVC.

pipe = Pipeline(
    [
        ("reduce_dim", PCA(random_state=42)),
        ("classify", LinearSVC(random_state=42, C=0.01, dual="auto")),
    ]
)

X, y = load_digits(return_X_y=True)

Definir Parâmetros para GridSearchCV

Vamos definir os parâmetros para GridSearchCV.

param_grid = {"reduce_dim__n_components": [6, 8, 10, 12, 14]}

Definir o Objeto GridSearchCV

Vamos definir o objeto GridSearchCV e ajustar o modelo.

grid = GridSearchCV(
    pipe,
    cv=10,
    n_jobs=1,
    param_grid=param_grid,
    scoring="accuracy",
    refit=best_low_complexity,
)

grid.fit(X, y)

Visualizar Resultados

Vamos visualizar os resultados traçando a precisão versus o número de componentes PCA.

n_components = grid.cv_results_["param_reduce_dim__n_components"]
test_scores = grid.cv_results_["mean_test_score"]

plt.figure()
plt.bar(n_components, test_scores, width=1.3, color="b")

lower = lower_bound(grid.cv_results_)
plt.axhline(np.max(test_scores), linestyle="--", color="y", label="Melhor pontuação")
plt.axhline(lower, linestyle="--", color=".5", label="Melhor pontuação - 1 desvio padrão")

plt.title("Equilibrar a complexidade do modelo e a pontuação cruzada")
plt.xlabel("Número de componentes PCA usados")
plt.ylabel("Precisão de classificação de dígitos")
plt.xticks(n_components.tolist())
plt.ylim((0, 1.0))
plt.legend(loc="upper left")

best_index_ = grid.best_index_

print("O melhor índice é %d" % best_index_)
print("O número de componentes selecionado é %d" % n_components[best_index_])
print(
    "A pontuação de precisão correspondente é %.2f"
    % grid.cv_results_["mean_test_score"][best_index_]
)
plt.show()

Resumo

Neste laboratório, aprendemos como equilibrar a complexidade do modelo e a pontuação cruzada usando PCA e LinearSVC. Usamos GridSearchCV para encontrar o melhor número de componentes PCA, maximizando a pontuação de precisão dentro de 1 desvio padrão da melhor pontuação. Também visualizamos os resultados para melhor compreender o trade-off entre a complexidade do modelo e a precisão.

Equilibrar a Complexidade do Modelo e a Pontuação Cruzada