Otimização de Modelos de Machine Learning com Pipeline e GridSearchCV

Introdução

Este laboratório demonstra o uso de Pipeline e GridSearchCV no scikit-learn para otimizar diferentes classes de estimadores em uma única execução de validação cruzada. Usaremos um classificador de vetores de suporte para prever dígitos manuscritos do popular conjunto de dados MNIST.

Dicas da Máquina Virtual

Após o início da VM, 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 de 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 o problema rapidamente para você.

Importando bibliotecas necessárias e carregando dados

Começaremos importando as bibliotecas necessárias e carregando o conjunto de dados de dígitos do scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
from sklearn.decomposition import PCA, NMF
from sklearn.feature_selection import SelectKBest, mutual_info_classif
from sklearn.preprocessing import MinMaxScaler

X, y = load_digits(return_X_y=True)

Criar um pipeline e definir a grade de parâmetros

Criaremos um pipeline que realiza redução de dimensionalidade seguida de previsão com um classificador de vetores de suporte. Usaremos reduções de dimensionalidade não supervisionadas PCA e NMF, juntamente com seleção de recursos univariada durante a busca na grade.

pipe = Pipeline(
    [
        ("scaling", MinMaxScaler()),
        ## o estágio reduce_dim é preenchido pelo param_grid
        ("reduce_dim", "passthrough"),
        ("classify", LinearSVC(dual=False, max_iter=10000)),
    ]
)

N_FEATURES_OPTIONS = [2, 4, 8]
C_OPTIONS = [1, 10, 100, 1000]
param_grid = [
    {
        "reduce_dim": [PCA(iterated_power=7), NMF(max_iter=1_000)],
        "reduce_dim__n_components": N_FEATURES_OPTIONS,
        "classify__C": C_OPTIONS,
    },
    {
        "reduce_dim": [SelectKBest(mutual_info_classif)],
        "reduce_dim__k": N_FEATURES_OPTIONS,
        "classify__C": C_OPTIONS,
    },
]
reducer_labels = ["PCA", "NMF", "KBest(mutual_info_classif)"]

Criar um objeto GridSearchCV e ajustar os dados

Criaremos um objeto GridSearchCV usando o pipeline e a grade de parâmetros definidos na etapa anterior. Em seguida, ajustaremos os dados ao objeto.

grid = GridSearchCV(pipe, n_jobs=1, param_grid=param_grid)
grid.fit(X, y)

Plotar resultados

Plotaremos os resultados do GridSearchCV usando um gráfico de barras. Isso nos permitirá comparar a precisão de diferentes técnicas de redução de recursos.

import pandas as pd

mean_scores = np.array(grid.cv_results_["mean_test_score"])
## as pontuações estão na ordem da iteração do param_grid, que é alfabética
mean_scores = mean_scores.reshape(len(C_OPTIONS), -1, len(N_FEATURES_OPTIONS))
## seleciona a pontuação para o melhor C
mean_scores = mean_scores.max(axis=0)
## cria um DataFrame para facilitar o plot
mean_scores = pd.DataFrame(
    mean_scores.T, index=N_FEATURES_OPTIONS, columns=reducer_labels
)

ax = mean_scores.plot.bar()
ax.set_title("Comparando técnicas de redução de recursos")
ax.set_xlabel("Número reduzido de recursos")
ax.set_ylabel("Precisão de classificação de dígitos")
ax.set_ylim((0, 1))
ax.legend(loc="upper left")

plt.show()

Armazenamento em cache de transformadores dentro de um Pipeline

Agora demonstraremos como armazenar o estado de um transformador específico, já que ele pode ser reutilizado. O uso de um pipeline em GridSearchCV aciona essas situações. Portanto, usamos o argumento memory para habilitar o armazenamento em cache.

from joblib import Memory
from shutil import rmtree

## Crie uma pasta temporária para armazenar os transformadores do pipeline
location = "cachedir"
memory = Memory(location=location, verbose=10)
cached_pipe = Pipeline(
    [("reduce_dim", PCA()), ("classify", LinearSVC(dual=False, max_iter=10000))],
    memory=memory,
)

## Desta vez, um pipeline em cache será usado na busca em grade

## Exclua o cache temporário antes de sair
memory.clear(warn=False)
rmtree(location)

Resumo

Neste laboratório, utilizamos Pipeline e GridSearchCV no scikit-learn para otimizar diferentes classes de estimadores em uma única execução de validação cruzada. Também demonstramos como armazenar o estado de um transformador específico usando o argumento memory para habilitar o armazenamento em cache. Isso pode ser particularmente útil quando o ajuste de um transformador é custoso.

Redução de Dimensionalidade com Pipeline e GridSearchCV