Optimización de hiperparámetros

La biblioteca Scikit Learn, en el lenguaje de programación Python, está orientada al Machine Learning, con el objetivo de predecir determinadas acciones a través de patrones en una base de datos. Tiene varias funciones que requieren parámetros para la perfecta ejecución del código y algunas de ellas asumen un estado por defecto (default), devolviendo un valor que, hasta ese momento, es el mejor resultado que podemos encontrar.

Pero, ¿que son realmente?

De hecho, podemos modificar los parámetros de estas funciones, llamados hiperparámetros, para mejorar el resultado. El nombre de este proceso se denomina ajuste de hiperparámetros.

En este artículo, utilizaremos una base de datos preparada que proporciona el propio sklearn, para que podamos centrarnos en la optimización de hiperparámetros. Vamos a utilizar la base de datos de wisconsin de cáncer de mama que contiene información sobre nódulos y los clasifica como benignos o malignos.

Cargando la base de datos

Primero, carguemos la base de datos.

from sklearn.datasets import load_breast_cancer 
data = load_breast_cancer()

A continuación, convirtamos esta base en un Pandas DataFrame para que los datos sean más fáciles de visualizar.

import pandas as pd 
df_feature = pd.DataFrame(data=data['data'],columns=data['feature_names']) 
df_feature.head()

Ahora vamos a crear una tabla con una sola columna, llamada Pandas Series for the Targets, que son la clasificación de los datos. Usemos el método único para visualizar que solo tendremos dos clases, la 0 y 1.

ser_targets = pd.Series(data=data['target'], name='benign') 
ser_targets.unique()

Ahora transfiramos los datos a las variables X e Y por convención.

X = df_feature 
y = ser_targets

Primer modelo

Exploremos el modelo DecisionTreeClassifier, que es un árbol de decisión que clasifica los datos, en nuestro caso, entre 0 y 1. Primero usamos sus hiperparámetros definidos por defecto.

from sklearn.tree import DecisionTreeClassifier 
modelo_arvore = DecisionTreeClassifier()

Un punto importante es que vamos a utilizar el concepto de validación cruzada, donde tratamos de minimizar los efectos que la aleatoriedad de los datos seleccionados para el entrenamiento y la prueba pueden tener en nuestro resultado. Lo que hará cross_validate es separar nuestros datos en 5 grupos y usarlos para entrenar varios modelos, en este caso 5 veces porque configuramos cv=5, variando qué datos serán para entrenamiento y cuáles para prueba.

results = cross_validate(modelo_arvore, X, y, cv=5,                                 scoring=('accuracy'),                                                return_train_score=True)

El cross_validate devolverá los resultados que contienen la información principal que calculó, centrémonos en mean_train_score y mean_test_score que son, respectivamente, la precisión promedio con los valores de entrenamiento y la precisión promedio con los valores de prueba.

print(f"mean_train_score {np.mean(results['train_score']):.2f}") print(f"mean_test_score {np.mean(results['test_score']):.2f}")

Tenemos:

mean_train_score 1.00 
mean_test_score 0.92

Tuvimos un buen resultado de Score, pero tuvimos una precisión del 100% en los datos de entrenamiento, lo que indica un sobreajuste (overfitting) cuando el modelo está especializado en los datos de entrenamiento.

Optimización de los hiperparámetros

Los hiperparámetros son características de su modelo que se pueden definir a través de parámetros. Por ejemplo, DecisionTreeClassifier tiene los parámetros max_ depth y min_samples_split que, según el valor, entregan un modelo que se adapta mejor a sus datos.

Pero eso nos lleva a una pregunta. Basta con mirar la documentación de uno de estos algoritmos para darse cuenta de la infinidad de parámetros que tenemos y, en consecuencia, de muchas posibilidades. Para este problema tenemos dos soluciones: definir los valores e hiperparámetros que vamos a explorar o explorar aleatoriamente. Estas dos estrategias se implementan en scikit-learn, GridSearchCV y RandomizedSearchCV

Comencemos con GridSearchCV. Nos permite definir un espacio que queremos explorar, por ejemplo:

from sklearn.model_selection import GridSearchCV 

espaco_de_parametros = {
  "max_depth" : [3, 5],
  "min_samples_split" : [32, 64, 128],
  "min_samples_leaf" : [32, 64, 128],
  "criterion" : ["gini", "entropy"]
}

Aquí definimos un diccionario donde la clave es el nombre del parámetro que queremos optimizar y el valor es una lista de valores que queremos que explore. Entonces, en este caso, entrena el árbol usando una profundidad máxima, max_depth, 3 y 5.

Para usar GridSearchCV repetiremos algunos parámetros que usamos en cross_validate. Lo nuevo es que no vamos a enviar x e y, y vamos a usar el parámetro param_grid, que será nuestro diccionario.

modelo_arbol = DecisionTreeClassifier()

clf = GridSearchCV(modelo_arbol, espacio_de_parametros, cv=5, return_train_score=True, scoring = 'accuracy')
search = clf.fit(X, y)
results_GridSearchCV = search.cv_results_
indice_mejores_parametros = search.best_index_

Otra diferencia es que tendremos más de un modelo, por lo que debemos seleccionar el que mejor se desempeñó. Accedemos a search.bestindex y luego lo seleccionamos dentro de nuestros resultados.

print(f"mean_train_score {results_GridSearchCV['mean_train_score'][indice_melhores_parametros]:.2f}") print(f"mean_test_score {results_GridSearchCV['mean_test_score'][indice_melhores_parametros]:.2f}")

Resultado:

mean_train_score 0.94 

mean_test_score 0.92

Para recuperar los parámetros que tuvieron el mejor rendimiento, usemos la llave params:

results_GridSearchCV['params'][indice_melhores_parametros]

Resultado:

{'criterion': 'gini',
 'max_depth': 3,
 'min_samples_leaf': 32,
 'min_samples_split': 32}

Con esto, logramos descubrir el mejor modelo entre el grupo de parámetros que definimos, pero esto puede ser un problema, porque el espacio de posibilidades es mucho más grande. Entonces, la mejor combinación de parámetros podría estar en otro lugar de ese espacio. Con eso en mente, tenemos la segunda solución, RandomizedSearchCV. En él definimos el espacio que queremos explorar y probará aleatoriamente las combinaciones de hiperparámetros, además de probar la cantidad que determinará el parámetro n_iter, que es el número de interacciones.

from sklearn.model_selection import RandomizedSearchCV

Primero definamos este espacio. Tenga en cuenta que ahora podemos incluir una gran cantidad de posibilidades, ya que no todas estarán probadas. Por ejemplo, en min_samples_split probamos números aleatorios entre 32 y 129.

from scipy.stats import randint

espacio_de_parametros = {
    "max_depth" : randint(1, 10),
    "min_samples_split" : randint(32, 129),
    "min_samples_leaf" : randint(32, 129),
    "criterion" : ["gini", "entropy"]
}

Con el espacio definido, podemos pasar a usar RandomizedSearchCV. Fíjate que lo vamos a utilizar de forma similar a GridSearchCV, pero con un parámetro más, n_iter, que es el número de combinaciones que intentará.

modelo_arbol = DecisionTreeClassifier()

clf = RandomizedSearchCV(modelo_arbol, espacio_de_parametros, random_state=SEED, cv=5, return_train_score=True, n_iter=100, scoring='accuracy')
search = clf.fit(X, y)
results_RandomizedSearchCV = search.cv_results_
indice_mejores_parametros = search.best_index_

Para poder comparar los resultados, modifiqué la función presentada anteriormente para usar estos optimizadores de hiperparámetros:

print(f"mean_train_score {results_RandomizedSearchCV['mean_train_score'][indice_mejores_parametros]:.2f}")
print(f"mean_test_score {results_RandomizedSearchCV['mean_test_score'][indice_mejores_parametros]:.2f}")

Resultado:

mean_train_score 0.92
mean_test_score 0.91

Para recuperar los parámetros que tuvieron el mejor rendimiento, usemos la llave params:

results_RandomizedSearchCV['params'][indice_melhores_parametros]

Resultado:

{'criterion': 'gini',
 'max_depth': 4,
 'min_samples_leaf': 34,
 'min_samples_split': 105}

Con esto podemos ver que podemos explorar más los algoritmos. Recomiendo explorar la documentación de los algoritmos con los que está trabajando. Busque hiperparámetros para explorar y encontrar los mejores para sus datos y propósito.

En este notebook encontrarás el código completo del proyecto.

Igor Nascimento Alves

Soy licenciado en Informática. Trabajo como instructor de Data Science y Machine Learning en Grupo Alura, teniendo como principales intereses en tecnología: creación de modelos y análisis de datos. En mi tiempo libre veo y analizo datos de baloncesto y me encanta escuchar podcasts de humor como Nerdcast y Jujubacast.