Comparação entre Busca em Grade e Halving Sucessivo

Introdução

Este laboratório compara dois algoritmos populares de busca de parâmetros em aprendizado de máquina: Busca em Grade (Grid Search) e Successive Halving. Usaremos a biblioteca scikit-learn em Python para realizar a comparação. Estes algoritmos são usados para encontrar os melhores hiperparâmetros para um determinado modelo de aprendizado de máquina.

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 das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

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

Importar as bibliotecas e o conjunto de dados necessários

Primeiro, importamos as bibliotecas e o conjunto de dados necessários para este laboratório. Usaremos a biblioteca scikit-learn para gerar um conjunto de dados sintético e realizar a busca de parâmetros.

from time import time
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.svm import SVC
from sklearn import datasets
from sklearn.model_selection import GridSearchCV
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV

rng = np.random.RandomState(0)
X, y = datasets.make_classification(n_samples=1000, random_state=rng)

gammas = [1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7]
Cs = [1, 10, 100, 1e3, 1e4, 1e5]
param_grid = {"gamma": gammas, "C": Cs}

clf = SVC(random_state=rng)

Executar Busca em Grade

Usaremos a Busca em Grade para realizar a busca de parâmetros no modelo SVC. Usaremos o conjunto de dados sintético gerado e a grade de parâmetros gerada na Etapa 1.

tic = time()
gs = GridSearchCV(estimator=clf, param_grid=param_grid)
gs.fit(X, y)
gs_time = time() - tic

Executar Halving Sucessivo

Agora, realizaremos a busca de parâmetros usando Halving Sucessivo no mesmo modelo SVC e conjunto de dados usados na Etapa 2.

tic = time()
gsh = HalvingGridSearchCV(
    estimator=clf, param_grid=param_grid, factor=2, random_state=rng
)
gsh.fit(X, y)
gsh_time = time() - tic

Visualize the Results

We will now visualize the results of the parameter search algorithms using heatmaps. The heatmaps show the mean test score of the parameter combinations for the SVC instance. The Successive Halving heatmap also shows the iteration at which the combinations were last used.

def make_heatmap(ax, gs, is_sh=False, make_cbar=False):
    """Helper to make a heatmap."""
    results = pd.DataFrame(gs.cv_results_)
    results[["param_C", "param_gamma"]] = results[["param_C", "param_gamma"]].astype(
        np.float64
    )
    if is_sh:
        ## SH dataframe: get mean_test_score values for the highest iter
        scores_matrix = results.sort_values("iter").pivot_table(
            index="param_gamma",
            columns="param_C",
            values="mean_test_score",
            aggfunc="last",
        )
    else:
        scores_matrix = results.pivot(
            index="param_gamma", columns="param_C", values="mean_test_score"
        )

    im = ax.imshow(scores_matrix)

    ax.set_xticks(np.arange(len(Cs)))
    ax.set_xticklabels(["{:.0E}".format(x) for x in Cs])
    ax.set_xlabel("C", fontsize=15)

    ax.set_yticks(np.arange(len(gammas)))
    ax.set_yticklabels(["{:.0E}".format(x) for x in gammas])
    ax.set_ylabel("gamma", fontsize=15)

    ## Rotate the tick labels and set their alignment.
    plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")

    if is_sh:
        iterations = results.pivot_table(
            index="param_gamma", columns="param_C", values="iter", aggfunc="max"
        ).values
        for i in range(len(gammas)):
            for j in range(len(Cs)):
                ax.text(
                    j,
                    i,
                    iterations[i, j],
                    ha="center",
                    va="center",
                    color="w",
                    fontsize=20,
                )

    if make_cbar:
        fig.subplots_adjust(right=0.8)
        cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
        fig.colorbar(im, cax=cbar_ax)
        cbar_ax.set_ylabel("mean_test_score", rotation=-90, va="bottom", fontsize=15)


fig, axes = plt.subplots(ncols=2, sharey=True)
ax1, ax2 = axes

make_heatmap(ax1, gsh, is_sh=True)
make_heatmap(ax2, gs, make_cbar=True)

ax1.set_title("Successive Halving\ntime = {:.3f}s".format(gsh_time), fontsize=15)
ax2.set_title("GridSearch\ntime = {:.3f}s".format(gs_time), fontsize=15)

plt.show()

Resumo

Comparámos dois algoritmos populares de busca de parâmetros em aprendizagem de máquina: Busca em Grade e Halving Sucessivo. Usámos a biblioteca scikit-learn em Python para realizar a comparação. Gerámos um conjunto de dados sintético e realizámos a busca de parâmetros no modelo SVC utilizando ambos os algoritmos. Em seguida, visualizámos os resultados utilizando mapas de calor. Observámos que o algoritmo Halving Sucessivo foi capaz de encontrar combinações de parâmetros tão precisas quanto a Busca em Grade, em muito menos tempo.