Comparación entre Búsqueda en Cuadrícula y Mitosis Sucesiva

Introducción

Esta práctica compara dos algoritmos populares de búsqueda de parámetros en el aprendizaje automático: Búsqueda en cuadrícula y Mitosis sucesiva. Utilizaremos la biblioteca scikit-learn en Python para realizar la comparación. Estos algoritmos se utilizan para encontrar los mejores hiperparámetros para un modelo de aprendizaje automático dado.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Importar las bibliotecas y el conjunto de datos necesarios

Primero importamos las bibliotecas y el conjunto de datos necesarios para esta práctica. Utilizaremos la biblioteca scikit-learn para generar un conjunto de datos sintético y realizar la búsqueda 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)

Realizar la Búsqueda en Cuadrícula

Utilizaremos la Búsqueda en Cuadrícula para realizar la búsqueda de parámetros en el modelo SVC. Utilizaremos el conjunto de datos sintético generado y la cuadrícula de parámetros generada en el Paso 1.

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

Realizar Mitosis Sucesiva

Ahora realizaremos la búsqueda de parámetros utilizando Mitosis Sucesiva en el mismo modelo SVC y conjunto de datos utilizados en el Paso 2.

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

Visualizar los Resultados

Ahora visualizaremos los resultados de los algoritmos de búsqueda de parámetros utilizando mapas de calor. Los mapas de calor muestran la puntuación promedio de prueba de las combinaciones de parámetros para la instancia de SVC. El mapa de calor de Mitosis Sucesiva también muestra la iteración en la que se utilizó por última vez la combinación.

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("Mitosis Sucesiva\ntime = {:.3f}s".format(gsh_time), fontsize=15)
ax2.set_title("Búsqueda en Cuadrícula\ntime = {:.3f}s".format(gs_time), fontsize=15)

plt.show()

Resumen

Hemos comparado dos algoritmos populares de búsqueda de parámetros en el aprendizaje automático: Búsqueda en Cuadrícula y Mitosis Sucesiva. Utilizamos la biblioteca scikit-learn en Python para realizar la comparación. Generamos un conjunto de datos sintético y realizamos la búsqueda de parámetros en el modelo SVC utilizando ambos algoritmos. Luego visualizamos los resultados utilizando mapas de calor. Vimos que el algoritmo de Mitosis Sucesiva fue capaz de encontrar combinaciones de parámetros tan precisas como la Búsqueda en Cuadrícula, en mucho menos tiempo.