Machine learning con H2O y Python
Más sobre ciencia de datos: cienciadedatos.net
Introducción¶
En este documento se pretende mostrar cómo crear modelos de machine learning combinando H2O y el lenguaje de programación Python.
Aunque son muchos los pasos que preceden al entrenamiento de un modelo (exploración de los datos, transformaciones, selección de predictores, etc.), para no añadir una capa extra de complejidad, se va a asumir que los datos se encuentran prácticamente preparados para que puedan ser aceptados por los algoritmos de aprendizaje. Se puede encontrar una descripción más detallada de las etapas que forman parte el ciclo de vida del modelado en el documento Machine Learning con R y caret.
¿Qué es H2O?¶
H2O es un producto creado por la compañía H2O.ai con el objetivo de combinar los principales algoritmos de machine learning y aprendizaje estadístico con el Big Data. Gracias a su forma de comprimir y almacenar los datos, H2O es capaz de trabajar con millones de registros en un único ordenador (emplea todos sus cores) o en un cluster de muchos ordenadores. Internamente, H2O está escrito en Java y sigue el paradigma Key/Value para almacenar los datos y Map/Reduce para sus algoritmos. Gracias a sus API, es posible acceder a todas sus funciones desde R, Python o Scala, así como por una interfaz web llamada Flow.
Aunque la principal ventaja de H2O frente a otras herramientas es su escalabilidad, sus algoritmos son igualmente útiles cuando se trabaja con un volumen de datos reducido.
Comunicación entre H2O y Python¶
El manejo de H2O puede hacerse íntegramente desde Python: iniciar el cluster, carga de datos, entrenamiento de modelos, predicción de nuevas observaciones, etc. Es importante tener en cuenta que, aunque los comandos se ejecuten desde Python, los datos se encuentran en el cluster de H2O no en memoria. Solo cuando los datos se cargan en memoria, se les pueden aplicar funciones propias de Python.
Las funciones h2o.H2OFrame() y as_data_frame(use_pandas=True) permiten transferir los datos de la sesión de Python al cluster H2O y viceversa. Hay que tener especial precaución cuando el movimiento de datos se hace desde H2O a Python, ya que esto implica cargar en RAM todos los datos y, si son muchos, pueden ocupar toda la memoria. Para evitar este tipo de problemas, conviene realizar todos los pasos posibles (filtrado, agregaciones, cálculo de nuevas columnas...) con las funciones de H2O antes de transferir los datos.
Instalación¶
#!pip install requests
#!pip install tabulate
#!pip install "colorama>=0.3.8"
#!pip install future
#!pip uninstall h2o
#!pip install -f http://h2o-release.s3.amazonaws.com/h2o/latest_stable_Py.html h2o
Datos¶
Para los ejemplos de este documento se emplea el set de datos Adult Data Set disponible en UCI Machine Learning Repository. Este set de datos contiene información sobre 48842 ciudadanos de diferentes países. Para cada ciudadano, se dispone de 15 variables:
age: edad.workclass: tipo de empleo.fnlwgt: importancia relativa de cada observación.education: nivel de estudios.education-num: años de estudios.marital-status: estado civil.occupation: sector de trabajorelationship: estado familiar.race: raza.sex: género.capital-gain: ganancia de capital.capital-loss: perdidas de capital.hours-per-week: horas de trabajo semanal.native-countr: país de origen.salario: si el salario supera o no 50000 dólares anuales.
El objetivo del problema es crear un modelo capaz de predecir correctamente si un ciudadano tiene un salario superior o inferior a 50000 dólares anuales. Se trata de un problema de clasificación binaria supervisado.
Los datos se han modificado para eliminar observaciones con valores ausentes y para recodificar los niveles de algunas variables. El archivo resultante (adult_custom_python.csv) puede descargarse directamente del repositorio Github.
import warnings
warnings.filterwarnings("ignore")
# EL SIGUIENTE CÓDIGO MUESTRA COMO SE HAN PREPROCESADO LOS DATOS ORIGINALES.
# NO ES NECESARIO EJECUTARLO SI SE HA DESCARGADO EL ARCHIVO adult_custom_python.csv.
# ------------------------------------------------------------------------------
import pandas as pd
import numpy as np
# Datos de train.
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
datos_train = pd.read_csv(
filepath_or_buffer = url,
sep = ",",
skipinitialspace = True,
header = None)
datos_train.columns = ["age", "workclass", "final_weight", "education",
"education_number", "marital_status", "occupation",
"relationship", "race", "sex", "capital_gain",
"capital_loss", "hours_per_week", "native_country",
"salario"]
# Datos de test.
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"
datos_test = pd.read_csv(
filepath_or_buffer = url,
sep = ",",
skipinitialspace = True,
skiprows = 1,
header = None)
datos_test.columns = ["age", "workclass", "final_weight", "education",
"education_number", "marital_status", "occupation",
"relationship", "race", "sex", "capital_gain",
"capital_loss", "hours_per_week", "native_country",
"salario"]
# Se combinan los dos conjuntos de datos.
datos = pd.concat([datos_train, datos_test], axis=0).reset_index(drop=True)
# Se eliminan registros con missing values, que en este set de datos están
# codificados como ?.
datos = datos.replace(to_replace = '?', value=np.nan)
datos = datos.dropna().reset_index(drop=True)
# Recodificación de niveles.
dic_replace = {"Without-pay": "desempleado",
"Self-emp-inc": "autonomo",
"Self-emp-not-inc": "autonomo",
"Federal-gov": "funcionario",
"Local-gov": "funcionario",
"State-gov": "funcionario"}
datos["workclass"] = datos["workclass"] \
.map(dic_replace) \
.fillna(datos["workclass"])
dic_replace = {"Married-AF-spouse": "casado",
"Married-civ-spouse": "casado",
"Married-spouse-absent": "casado",
"Widowed": "separado",
"Never-married": "soltero",
"Separated":"separado",
"Divorced": "separado"}
datos["marital_status"] = datos["marital_status"] \
.map(dic_replace) \
.fillna(datos["marital_status"])
norte_america = ["Canada", "Cuba", "Dominican-Republic", "El-Salvador",
"Guatemala", "Haiti", "Honduras", "Jamaica", "Mexico",
"Nicaragua", "Outlying-US(Guam-USVI-etc)", "Puerto-Rico",
"Trinadad&Tobago", "United-States"]
europa = ["England", "France", "Germany", "Greece", "Holand-Netherlands",
"Hungary", "Ireland", "Italy", "Poland", "Portugal", "Scotland",
"Yugoslavia"]
asia = ["Cambodia", "China", "Hong", "India", "Iran", "Japan", "Laos",
"Philippines", "Taiwan", "Thailand", "Vietnam"]
sud_america = ["Columbia", "Ecuador", "Peru"]
otros = ["South"]
norte_america = dict.fromkeys(norte_america, "Norte America")
europa = dict.fromkeys(europa, "Europa")
asia = dict.fromkeys(asia, "Asia")
sud_america = dict.fromkeys(sud_america, "Sud America")
otros = dict.fromkeys(otros, "Otros")
dic_replace = dict(norte_america, **europa, **asia, **sud_america, **otros)
datos["native_country"] = datos["native_country"] \
.map(dic_replace) \
.fillna(datos["native_country"])
primaria = ["Preschool", "1st-4th", "5th-6th", "7th-8th", "9th", "10th","11th","12th"]
secuendaria = ["HS-grad"]
bachillerato = ["Some-college", "Assoc-acdm", "Assoc-voc"]
universidad = ["Bachelors"]
master = ["Masters", "Prof-school"]
doctorado = ["Doctorate"]
primaria = dict.fromkeys(primaria, "primaria")
secuendaria = dict.fromkeys(secuendaria, "primaria")
bachillerato = dict.fromkeys(bachillerato, "bachillerato")
universidad = dict.fromkeys(universidad, "primaria")
master = dict.fromkeys(master, "master")
doctorado = dict.fromkeys(doctorado, "primaria")
dic_replace = dict(primaria, **secuendaria, **bachillerato, **universidad,
**master, **doctorado)
datos["education"] = datos["education"] \
.map(dic_replace) \
.fillna(datos["education"])
dic_replace = {"<=50K." : "<=50K", ">50K." : ">50K"}
datos["salario"] = datos["salario"] \
.map(dic_replace) \
.fillna(datos["salario"])
# Se agrupan las observaciones cuya variable occupation == "Armed-Forces" con
# "Other-service" ya que solo hay 14 observaciones (0.03% del total).
dic_replace = {"Armed-Forces" : "Other-service"}
datos["occupation"] = datos["occupation"] \
.map(dic_replace) \
.fillna(datos["occupation"])
datos.to_csv("adult_custom_python.csv", header=True, index=False)
Librerías¶
Las librerías utilizadas en este documento son:
# Librerías
# ------------------------------------------------------------------------------
import h2o
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import os
from matplotlib import style
from tabulate import tabulate
import multiprocessing
# Configuración matplotlib
# ------------------------------------------------------------------------------
plt.rcParams['image.cmap'] = "bwr"
plt.rcParams['figure.dpi'] = "100"
plt.rcParams['savefig.bbox'] = "tight"
style.use('ggplot') or plt.style.use('ggplot')
Iniciación de H2O¶
Una vez que H2O ha sido instalado (pip install h2o), hay que iniciarlo, bien en todo el cluster o en un solo ordenador. Para este ejemplo, se emplea un único ordenador del que se utilizan todos sus cores en paralelo.
Tras iniciar el cluster (local), se muestran por pantalla sus características, entre las que están: el número de cores activados (4), la memoria total del cluster (3.56GB), el número de nodos (1 porque se está empleando un único ordenador) y el puerto con el que conectarse a la interfaz web de H2O (FLOW) (http://localhost:54321/flow/index.html).
Si se desea lanzar H2O en un cluster Hadoop ya establecido, solo es necesario especificar la dirección IP y puerto de acceso en h2o.init().
# Creación de un cluster local H2O
# ------------------------------------------------------------------------------
h2o.init(ip = "localhost",
# -1 indica que se empleen todos los cores disponibles.
nthreads = -1,
# Máxima memoria disponible para el cluster.
max_mem_size = "4g")
# Se eliminan los datos del cluster por si ya había sido iniciado.
h2o.remove_all()
Carga de datos¶
La carga de datos puede hacerse directamente al cluster H2O, o bien cargándolos primero en memoria en la sesión de Python y después transfiriéndolos. La segunda opción no es aconsejable si el volumen de datos es muy grande.
# Carga de datos en el cluster H2O desde url.
url = "https://github.com/JoaquinAmatRodrigo/Estadistica-con-R/raw/master/datos/adult_custom_python.csv"
datos_h2o = h2o.import_file(
path = url,
header = 1,
sep = ",",
destination_frame = "datos_h2o"
)
# Carga de datos en Python y transferencia a H2O.
url = "https://github.com/JoaquinAmatRodrigo/Estadistica-con-R/raw/master/datos/adult_custom_python.csv"
datos_python = pd.read_csv(
filepath_or_buffer = url,
sep = ",",
skipinitialspace = True
)
datos_h2o = h2o.H2OFrame(python_obj = datos_python, destination_frame = "datos_h2o")
# Carga de datos en el cluster H2O desde local.
datos_h2o = h2o.import_file(
path = "./adult_custom_python.csv",
header = 1,
sep = ",",
destination_frame = "datos_h2o"
)
Exploración de los datos¶
Si bien el set de datos empleado en este ejemplo es suficientemente pequeño para cargarlo todo en memoria y emplear directamente las magníficas posibilidades de análisis exploratorio que ofrece Python, para representar mejor la forma de proceder con grandes volúmenes de datos, se emplean funciones propias de H2O.
# Dimensiones del set de datos
datos_h2o.shape
# Nombre de las columnas
datos_h2o.col_names
El método .describe() es muy útil para obtener un análisis rápido que muestre el tipo de datos, la cantidad de valores ausentes, el valor mínimo, máximo, media y desviación típica. H2O emplea el nombre enum para los datos de tipo str y object.
datos_h2o.describe()
Para conocer el índice o nombre de las columnas que son de un determinado tipo, por ejemplo, numérico, se emplea la función h2o.columns_by_type().
# Índices
datos_h2o.columns_by_type(coltype='numeric')
Con el método h2o.cor() se calcula la correlación entre dos o más columnas numéricas.
indices = list(map(int,datos_h2o.columns_by_type(coltype='numeric')))
datos_h2o[indices].cor(use = "complete.obs")
Para contar el número de observaciones de cada clase en una variable categórica, como es en este caso la variable respuesta salario, se emplea el método .table().
# Se crea una tabla con el número de observaciones de cada tipo.
tabla = datos_h2o["salario"].table()
print(tabla)
# Una vez creada la tabla, se carga en el entorno de python para poder graficar.
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 3.8))
tabla = tabla.as_data_frame(use_pandas=True, header=True)
tabla.plot.barh(x="salario", y = "Count", ax = ax, legend = None)
fig.suptitle('Número de observaciones por grupo', fontsize= 'medium');
Separación de training, validación y test¶
Evaluar la capacidad predictiva de un modelo consiste en comprobar cómo de próximas son sus predicciones a los verdaderos valores de la variable respuesta. Para poder cuantificar de forma correcta este error, se necesita disponer de un conjunto de observaciones, de las que se conozca la variable respuesta, pero que el modelo no haya "visto", es decir, que no hayan participado en su ajuste. Con esta finalidad, se separan los datos disponibles en un conjunto de entrenamiento, uno de validación y uno de test. El conjunto de entrenamiento se emplea para ajustar el modelo, el de validación para encontrar los mejores hiperparámetros (model tuning) y el de test para estimar el error que comete el modelo al exponerse a nuevos datos. El tamaño adecuado de las particiones depende en gran medida de la cantidad de datos disponibles y la seguridad que se necesite en la estimación del error, 70%-15%-15% suele dar buenos resultados.
Si el número de observaciones es limitado, crear 3 particiones puede generar grupos demasiado pequeños y variables. En estos casos, es preferible dividir los datos únicamente en un conjunto de entrenamiento y otro de test, y utilizar validación cruzada (cross validation) sobre el conjunto de entrenamiento durante la optimización de los hiperparámetros del modelo. Para mostrar ambas posibilidades, en el ejemplo de modelo GLM se empleará validación cruzada, mientras que en el resto de modelos (GBM, RF y Deep Learning), se emplea un solo conjunto de validación. Es importante tener en cuenta que, la validación cruzada, requiere ajustar el modelo repetidas veces, lo que supone un coste computacional muy alto. Cuando se trabaja con big data no suele ser factible aplicar validación cruzada, además, al disponer de tantos datos, un conjunto de validación único es suficiente para obtener buenas estimaciones del comportamiento del modelo. Para una descripción más detallada de los diferentes métodos de validación, consultar el Anexo4 del documento Machine learning con R y Caret.
El método .splitFrame() realiza particiones aleatorias, pero no permite hacerlas de forma estratificada, por lo que no asegura que la distribución de clases de variable respuesta sea igual en todas particiones. Esto puede ser problemático con datos muy desbalanceados (alguno de los grupos es muy minoritario). Para obtener un reparto estratificado puede emplearse el método stratified_split().
# Separación de las observaciones en conjunto de entrenamiento y test.
# En los ejemplos de GBM y deep learning se repetirá la separación, pero en
# tres conjuntos en lugar de dos.
datos_train_h2o, datos_test_h2o = datos_h2o.split_frame(
ratios=[0.8],
destination_frames= ["datos_train_H2O",
"datos_test_H2O"],
seed = 123
)
Número de observaciones de cada clase por partición.
print(datos_train_h2o["salario"].table())
print(datos_test_h2o["salario"].table())
# En porcentaje
print(datos_train_h2o["salario"].table()["Count"]/datos_train_h2o.shape[0])
print(datos_test_h2o["salario"].table()["Count"]/datos_test_h2o.shape[0])
La proporción de los dos grupos de la variable respuesta es muy similar en ambas particiones.
Preprocesado de datos¶
H2O incorpora y automatiza muchas de las transformaciones necesarias para que los datos puedan ser ingeridos por los algoritmos de machine learning. Esto es distinto a la mayoría de librerías de machine learning de otros lenguajes como Python y R, donde las etapas de preprocesado suelen ser independientes del entrenamiento del modelo.
En concreto, H2O automatiza las siguientes transformaciones:
Variables categóricas en H2O¶
En el momento de ajustar un modelo (GBM, DRF, Deep Learning, K-Means, Aggregator, XGBoost), H2O identifica automáticamente que variables son categóricas y crea internamente las variables dummy correspondientes. Es altamente recomendable permitir que H2O realice este proceso en lugar de hacerlo externamente, ya que su implementación está muy optimizada. El comportamiento de la codificación de las variables categóricas puede controlarse con el argumento categorical_encoding, por defecto su valor es "AUTO".
Estandarización¶
Por defecto, H2O estandariza los predictores numéricos antes de ajustar los modelos para que todos tengan media cero y varianza uno. Este comportamiento se puede controlar con el argumento standardize. Es importante tener en cuenta que, para muchos modelos (lasso, ridge, Deep Learning...), es necesario realizar la estandarización de predictores.
Eliminación de variables con varianza cero¶
No se deben de incluir en un modelo predictores que contengan un único valor (varianza cero), ya que no aportan información. Los algoritmos de H2O excluyen directamente las columnas con valor constante. Este comportamiento se puede controlar mediante el argumento ignore_const_cols.
Balance de clases¶
En problemas de clasificación, puede ocurrir que los datos estén desbalanceados, es decir, que el número de observaciones pertenecientes a cada grupo sea muy dispar. Por ejemplo, que de 1000 observaciones, 800 pertenezcan a un grupo y solo 200 al otro. En estos casos, los modelos pueden tener dificultades para aprender a identificar las observaciones del grupo minoritario. Con el argumento balance_classes se puede indicar que antes de ajustar el modelo se equilibren las clases mediante undersampling u oversampling. Por defecto, este comportamiento está desactivado.
Todas las trasformaciones descritas anteriormente se aprenden a partir de los datos de entrenamiento en el momento del ajuste, y se aplican automáticamente cuando el modelo se emplea para predecir nuevas observaciones. De esta forma, se garantiza que no se viola la condición de que ninguna información procedente de las observaciones de test participe o influya en el ajuste del modelo.
H2O dispone de un listado de funciones para manipular y transformar los datos, sin embargo, con frecuencia no son suficientes para resolver todas las necesidades de preprocesado. En estos casos es necesario recurrir a Python, si el volumen de datos es limitado, o a Spark si la información no se puede cargar en memoria.
Nota: en mi experiencia propia, aunque las tecnologías distribuidas como Spark son muy útiles, antes de recurrir a ellas, recomiendo reflexionar sobre la manipulación que se tiene que realizar y analizar si es necesario que se haga sobre todos los datos a la vez. Por ejemplo, el proceso de imputación se debe aprender únicamente de los datos de entrenamiento y luego aplicarlo al resto de datos. Puede que todo el dataset no se pueda cargar en memoria, pero sí el conjunto de entrenamiento. Esto permitiría aprender la imputación y después aplicarla por separado a cada conjunto.
Modelos con H2O¶
Modelos disponibles¶
H2O incorpora los siguientes algoritmos de machine learning. Todos ellos están implementados de forma que puedan trabajar, en la medida de lo posible, de forma distribuida y/o en paralelo.
Modelos supervisados
Cox Proportional Hazards (CoxPH)
Deep Learning (Neural Networks)
Distributed Random Forest (DRF)
Generalized Linear Model (GLM)
Generalized Aditive Model (GAM)
Gradient Boosting Machine (GBM)
Naïve Bayes Classifier
Stacked Ensembles
XGBoost
Modelos no supervisados
Aggregator
Generalized Low Rank Models (GLRM)
K-Means Clustering
Isolation Forest
Principal Component Analysis (PCA)
Otros
- Word2vec
En este documento se muestran ejemplos con Generalized Linear Model (GLM), Generalized Aditive Model (GAM), Gradient Boosting Machine (GBM) y Deep Learning (Neural Networks).
Parada temprana¶
Los algoritmos de H2O están pensados para poder ser utilizados de forma eficiente con grandes volúmenes de datos. Emplear miles o millones de datos suele implicar tiempos largos de entrenamiento. H2O incorpora criterios de parada para que no se continúe mejorando un modelo si ya se ha alcanzado una solución aceptable. Dependiendo del algoritmo, el criterio de parada es distinto. En los siguientes apartados se describen con detalle.
Optimización de hiperparámetros¶
Muchos modelos contienen parámetros que no pueden aprenderse a partir de los datos de entrenamiento y que, por lo tanto, deben de ser establecidos por el analista. A estos se les conoce como hiperparámetros. Los resultados de un modelo pueden depender en gran medida del valor que tomen sus hiperparámetros, sin embargo, no se puede conocer de antemano cuál es el adecuado. Aunque con la práctica, los especialistas en machine learning ganan intuición sobre qué valores pueden funcionar mejor en cada problema, no hay reglas fijas. La forma más común de encontrar los valores óptimos es probando diferentes posibilidades, lo que comúnmente se conoce como grid search.
H2O emplea la clase H2OGridSearch para realizar la búsqueda de los mejores hiperparámetros, sus argumentos principales son: el nombre del algoritmo, los parámetros del algoritmo, un diccionario con los valores de los hiperparámetros que se quieren comparar y un diccionario opcional con criterios más abanzados como por ejemplo el tipo de búsqueda ("Cartesian" o "RandomDiscrete"). Una vez que la búsqueda ha finalizado, el objeto creado contiene todos los modelos, para acceder a ellos es necesario extraerlos.
Generalized linear models (GLMs)¶
Introducción¶
El modelo de regresión lineal (Legendre, Gauss, Galton y Pearson) considera que, dado un conjunto de observaciones, la media $\mu$ de la variable respuesta $Y$ se relaciona de forma lineal con la o las variables regresoras $X$.
$$\mu = \beta_0 + \beta_1 x_{1} + \beta_2 x_{2} + ... + \beta_p x_{p}$$o en notación matricial (incorporando $\beta_0$ en el vector $\mathbf{\beta}$:
$$\mu = \mathbf{X}^T \mathbf{\beta}$$Ajustar el modelo consiste en estimar los valores de los coeficientes de regresión $\hat{\beta}$ y la varianza $\hat{\sigma}^2$ que maximizan la verosimilitud (likelihood) de los datos, es decir, los que dan lugar al modelo que con mayor probabilidad puede haber generado los datos observados. El método empleado con más frecuencia es el ajuste por mínimos cuadrados (OLS):
$$\hat{\beta} = \underset{\beta_0,\beta}{\arg\min} (Y - \mathbf{X}^T \mathbf{\beta})^2$$$$\hat{\mu} = \mathbf{X}^T \mathbf{\hat{\beta}}$$$$\hat{\sigma}^2 = \frac{\sum^n_{i=1} \hat{\epsilon}_i^2}{n-p} = \frac{\sum^n_{i=1} (y_i - \hat{\mu})^2}{n-p}$$Para que esta aproximación sea válida, se necesita que el error se distribuya de forma normal y que la varianza sea constante. El requisito de que la variable respuesta se distribuya de forma normal hace que el modelo de regresión lineal no sea aplicable a muchos problemas reales. Los modelos GLM (John Nelder y Robert Wedderburn) permiten superar esta limitación haciendo una abstracción a un modelo más genérico, en el que la variable respuesta puede seguir cualquier distribución de la familia exponencial (Gaussian, Poisson, binomial…). Para conseguirlo, la media de la variable respuesta ya no está relacionada directamente con los predictores, sino que se hace a través de una función link $g(.)$. Por ejemplo, el modelo lineal generalizado es equivale al modelo de regresión lineal por mínimos cuadrados cuando la función link es la identidad, o a la regresión logística cuando es binomial (logit).
$$g(\mu) = \beta_0 + \beta_1 x_{1} + \beta_2 x_{2} + ... + \beta_p x_{p}$$$$g(\mu) = \mathbf{X}^T \mathbf{\beta}$$Además, el modelo lineal generalizado puede incluir regularización durante su ajuste, por lo que también incluye los modelos ridge regression, lasso y elastic net.
Cuando se emplea una función link gausiana (con o sin regularización L2), la máxima verosimilitud equivale a minimizar la suma de errores cuadrados, lo que tiene una solución analítica. Para el resto de familias o cuando se emplea la regularización L1, no existe una solución analítica con la que encontrar la máxima verosimilitud, por lo que se requiere un método de optimización iterativo como el iteratively reweighted least squares (IRLSM), L-BFGS, método de Newton o descenso de gradiente. H2O selecciona automáticamente el método apropiado en dependiendo de la función link especificada por el usuario.
Regularización¶
H2O incorpora 3 tipos de regularización para los modelos GLM con el objetivo de evitar overfitting, reducir varianza y atenuar el efecto de la correlación entre predictores. Por lo general, aplicando regularización se consigue modelos con mayor poder predictivo (generalización).
El modelo lasso es un modelo lineal por mínimos cuadrados que incorpora una regularización que penaliza la suma del valor absolutos de los coeficientes de regresión $(||\beta||_1 = \sum_{k=1} ^p |\beta_k|)$. Ha esta penalización se le conoce como l1 y tiene el efecto de forzar a que los coeficientes de los predictores tiendan a cero. Dado que un predictor con coeficiente de regresión cero no influye en el modelo, lasso consigue seleccionar los predictores más influyentes. El grado de penalización está controlado por el hiperparámetro $\lambda$. Cuando $\lambda = 0$, el resultado es equivalente al de un modelo lineal por mínimos cuadrados ordinarios. A medida que $\lambda$ aumenta, mayor es la penalización y más predictores quedan excluidos.
El modelo ridge es un modelo lineal por mínimos cuadrados que incorpora una regularización que penaliza la suma de los coeficientes elevados al cuadrado $(||\beta||^2_2 = \sum_{k=1} ^p \beta^2_k)$. Ha esta penalización se le conoce como l2 y tiene el efecto de reducir de forma proporcional el valor de todos los coeficientes del modelo pero sin que estos lleguen a cero. Al igual que lasso, el grado de penalización está controlado por el hiperparámetro $\lambda$.
La principal diferencia práctica entre lasso y ridge es que el primero consigue que algunos coeficientes sean exactamente cero, por lo que realiza selección de predictores, mientras que el segundo no llega a excluir ninguno. Esto supone una ventaja notable de lasso en escenarios donde no todos los predictores son importantes para el modelo y se desea que los menos influyentes queden excluidos. Por otro lado, cuando existen predictores altamente correlacionados (linealmente), ridge reduce la influencia de todos ellos a la vez y de forma proporcional, mientras que lasso tiende a seleccionar uno de ellos, dándole todo el peso y excluyendo al resto. En presencia de correlaciones, esta selección varía mucho con pequeñas perturbaciones (cambios en los datos de entrenamiento), por lo que, las soluciones de lasso, son muy inestables si los predictores están altamente correlacionados.
Para conseguir un equilibrio óptimo entre estas dos propiedades, se puede emplear lo que se conoce como penalización elastic net, que combina ambas estrategias.
- El modelo elastic net incluye una regularización que combina la penalización l1 y l2 $(\alpha \lambda ||\beta||_1 + \frac{1}{2}(1- \alpha)||\beta||^2_2)$. El grado en que influye cada una de las penalizaciones está controlado por el hiperparámetro $\alpha$. Su valor debe estar comprendido en el intervalo [0,1], cuando $\alpha = 0$, H2O aplica ridge regression y cuando $\alpha = 1$ aplica lasso. La combinación de ambas penalizaciones suele dar lugar a buenos resultados. Una estrategia frecuentemente utilizada es asignarle casi todo el peso a la penalización l1 ($\alpha$ muy próximo a 1) para conseguir seleccionar predictores y un poco a la l2 para dar cierta estabilidad en el caso de que algunos predictores estén correlacionados.
Encontrar el mejor modelo GLM implica identificar los valores óptimos de los hiperparámetros de regularización $\alpha$ y $\lambda$. Por defecto, H2O selecciona $\alpha = 0.5$ y, con cada uno de ellos, analiza un rango de valores $\lambda$. También es posible hacer una búsqueda del valor óptimo de $\alpha$ mediante un grid seach.
Lambda Search
La búsqueda del valor óptimo de lambda se habilita indicando lambda_search = True. Además, esta búsqueda puede ser configurada con los siguientes argumentos:
alpha: el valor de $\alpha$ que se emplea en el modelo para distribuir la penalización l1 y l2. Por defecto,alpha=0.5.validation_frame: método de validación empleado para identificar el mejor modelo, puede ser mediante un único conjunto de validación o mediante validación cruzada (cross-validation). En el segundo caso, no es necesario crear un conjunto de validación, las particiones se generan a partir del conjunto de entrenamiento.n_folds: número de particiones en la validación cruzada.lambda_min_ratioynlambdas: determinan la secuencia de valores lambda que se generan automáticamente y sobre los que se realiza la búsqueda. El rango de valores va desde el valor mínimo con el que se alcanza una penalización total (lambda_max), es decir, el valor de lambda a partir del cual el coeficiente de todos los predictores es cero (valor identificado automáticamente por H2O), hasta un valor de lambda igual a lambda_min_ratio x lambda_max. Dentro de ese rango, se generan un número de lambdas igual al valor especificado connlambdas. Por defecto, se empleannlambda=100ylambda_min_ratio=1e−4.max_active_predictors: establece el número máximo de predictores incluidos en el modelo (predictores con coeficientes de regresión distintos de cero). Esta opción es muy útil para evitar tiempos de computación excesivos cuando se trabaja con sets de datos que contienen cientos de predictores pero se sabe que solo unos pocos son importantes.
Método de ajuste¶
Todos los modelos GLM se ajustan encontrando el valor de los coeficientes $\beta$ que maximizan el likelihood. La estimación de estos coeficientes se realiza mediante métodos iterativos, ya que, a excepción de unos pocos casos, no existe una solución analítica. H2O incorpora dos métodos (solvers) distintos, cuya correcta elección, que depende del tipo de datos, puede influir notablemente en el rendimiento computacional.
Iteratively Reweighted Least Squares Method (IRLSM): funciona especialmente bien cuando el set de datos empleado tiene muchas observaciones (largo) pero un número limitado de predictores (estrecho). Los autores recomiendan utilizarlo cuando el número de predictores no es mayor de 500.
Limited-memory Broyden-Fletcher-Goldfarb-Shanno algorithm (L-BFGS): es el método recomendado cuando se dispone de muchos predictores (>500).
Las anteriores son solo recomendaciones generales, en caso de duda, la mejor forma de elegir es comparando el resultado de ambos solvers.
Criterio de parada¶
Los algoritmos de H2O están pensados para poder ser aplicados a grandes volúmenes de datos, por lo que, entre sus características, incorporan criterios de parada para que no se continúe mejorando un modelo si ya se ha alcanzado una solución aceptable. En el caso de los GLM, el criterio de parada es el número máximo de predictores permitidos, que se especifica mediante el argumento max_active_predictors.
Modelo¶
El problema que se describió en la introducción sobre predecir el salario es un problema de clasificación binaria. El principal modelo lineal empleado para clasificaciones binarias es la regresión logística, que es el resultado de emplear, en un modelo lineal generalizado, la función logit como link. Aunque la selección se puede hacer manualmente, H2O es capaz de identificar el tipo de variable respuesta (numérica o categórica) y en función de eso seleccionar automáticamente el tipo de modelo, regresión o clasificación.
# Se comprueba que la variable respuesta es de tipo factor.
datos_train_h2o["salario"] = datos_train_h2o["salario"].asfactor()
datos_test_h2o["salario"] = datos_test_h2o["salario"].asfactor()
print(datos_train_h2o["salario"].isfactor())
print(datos_train_h2o["salario"].isfactor())
# Se define la variable respuesta y los predictores.
var_respuesta = "salario"
# Para este modelo se emplean todos los predictores disponibles.
predictores = datos_h2o.columns
predictores.remove("salario")
# Ajuste del modelo y validación mediente 5-CV para estimar su error
# ------------------------------------------------------------------------------
from h2o.estimators.glm import H2OGeneralizedLinearEstimator
modelo_glm = H2OGeneralizedLinearEstimator(
family = "binomial",
link = "logit",
standardize = True,
balance_classes = False,
ignore_const_cols = True,
# Se especifica que hacer con observaciones incompletas
missing_values_handling = "Skip",
# Se hace una búsqueda del hiperparámetro lamba.
lambda_search = True,
# Selección automática del solver adecuado.
solver = "AUTO",
alpha = 1,
# Validación cruzada de 5 folds para estimar el error
seed = 123,
nfolds = 5,
# Reparto estratificado de las observaciones en la creación
# de las particiones.
fold_assignment = "Stratified",
keep_cross_validation_predictions = False,
model_id = "modelo_glm"
)
modelo_glm.train(
y = var_respuesta,
x = predictores,
training_frame = datos_train_h2o
)
Al imprimir el modelo por pantalla, se muestra toda la información disponible: tipo de modelo, coeficientes de regresión obtenidos, métricas, resultados de la validación cruzada... Esta suele ser más información de la que se necesita en un análisis convencional. Para poder acceder directamente a la información de interés, H2O incorpora una serie de métodos que extraen información concreta del modelo.
# print(modelo_glm)
Coeficientes de regresión¶
Si se especifica en la creación del modelo que se estandaricen los predictores (standardize=True), se generan dos tipos de coeficientes de regresión:
Coeficientes estandarizados: son los obtenidos directamente por el modelo al emplear los predictores estandarizados. Es importante tener en cuenta que, al estar estandarizados, su valor no está en las mismas unidades que los predictores originales, lo que dificulta su interpretación. Sin embargo, sí que son útiles (su valor absoluto) para ordenar los predictores de mayor a menor influencia en el modelo.
Coeficientes: son los coeficientes "normales" obtenidos a partir de los coeficientes estandarizados pero revirtiendo la estandarización. Sus unidades son las mismas que las de los predictores originales y pueden ser interpretados de forma normal.
Para obtener más información sobre la correcta interpretación de los coeficientes de regresión de un modelo de regresión logística consultar Regresión logística simple y múltiple en R.
# Coeficientes de regresión de cada uno de los predictores
# ------------------------------------------------------------------------------
coeficientes = modelo_glm._model_json['output']['coefficients_table'].as_data_frame()
coeficientes
Predictores incluidos en el modelo¶
Si el modelo GLM incorpora penalización L1 (lasso o elastic net), entonces, el propio ajuste del modelo realiza selección de predictores. Los predictores incluidos en el modelo son aquellos cuyo coeficiente de regresión es distinto de cero.
# Predictores seleccionados
# ------------------------------------------------------------------------------
coeficientes = modelo_glm._model_json['output']['coefficients_table'].as_data_frame()
coeficientes[coeficientes["coefficients"] != 0]
# {k: v for k, v in modelo_glm.coef().items() if v !=0}
Importancia de los predictores¶
En los modelos lineales generalizados, la importancia de los predictores puede estudiarse a partir del valor absoluto de los coeficientes de regresión estandarizados.
# Top 10 predictores más importantes
# ------------------------------------------------------------------------------
imporatancia_predictores = modelo_glm.varimp(use_pandas=True)
imporatancia_predictores.head(10)
#modelo_glm.std_coef_plot(num_of_features=10)
#modelo_glm.varimp_plot(num_of_features=10)
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 3.8))
imporatancia_predictores.head(10).plot.barh(x='variable', y='scaled_importance', ax=ax)
ax.invert_yaxis()
fig.suptitle('Importancia de los predictores (Top 10)', fontsize='large');
Métricas de entrenamiento¶
Se pueden obtener toda una serie de métricas calculadas a partir de los datos de entrenamiento. Al tratarse de métricas de entrenamiento, no son válidas como estimación del error que comete el modelo al predecir nuevos valores (son demasiado optimistas) ni tampoco para comparar modelos, para esto hay que emplear métricas de validación o de test. Sin embargo si son útiles para ver si el modelo está aprendiendo.
# Métricas de entrenamiento
# ------------------------------------------------------------------------------
# Área bajo la curva
print("auc: ", modelo_glm.auc(train=True))
# Mean Squared Error
print("Mean Squared Error: ",modelo_glm.mse(train=True))
# R2
print("R2: ",modelo_glm.r2(train=True))
# LogLoss
print("LogLoss: ",modelo_glm.logloss(train=True))
# Coeficiente de Gini
print("Gini: ",modelo_glm.gini(train=True))
# Desviance del modelo nulo
print("Desviance del modelo nulo: ",modelo_glm.null_deviance(train=True))
# Desviance del modelo final
print("Desviance del modelo final: ",modelo_glm.residual_deviance(train=True))
# AIC
print("AIC: ",modelo_glm.aic(train=True))
modelo_glm.confusion_matrix(train = True)
Se pueden obtener todas a la vez con el método .model_performance().
#performance_train = modelo_glm.model_performance(train=True)
#performance_train
Métricas de validación y validación cruzada¶
Al igual que para el entrenamiento, se pueden obtener las métricas obtenidas en el conjunto de validación (valid=True) o el promedio obtenido mediante validación cruzada (xval=True).
# Métricas de validación cruzada
# ------------------------------------------------------------------------------
print("auc: ", modelo_glm.auc(xval=True))
print("MSE: ",modelo_glm.mse(xval=True))
print("R2 : ",modelo_glm.r2(xval=True))
print("Gini: ",modelo_glm.gini(xval=True))
print("AIC: ",modelo_glm.aic(xval=True))
print("LogLoss: ",modelo_glm.logloss(xval=True))
# Métricas de validación cruzada para cada partición
# ------------------------------------------------------------------------------
modelo_glm.cross_validation_metrics_summary().as_data_frame()
Predicciones y error¶
Una vez que el modelo ha sido entrenado, puede emplearse para predecir nuevas observaciones con la el método .predict(), que recibe como argumentos un modelo y un nuevo set de datos.
predicciones = modelo_glm.predict(test_data = datos_test_h2o)
predicciones.head(5)
El resultado devuelto por .predict() para un modelo GLM logístico es una tabla con 3 columnas, una con la clase predicha y otras dos con la probabilidad de pertenecer a cada una de las clases. El orden de las filas es el mismo que el de los datos pasados al argumento test_data.
Si el nuevo set de datos incluye la variable respuesta, se pueden calcular métricas que cuantifiquen el grado de acierto.
# Cálculo de las métricas para el conjunto de test
# ------------------------------------------------------------------------------
performance_test = modelo_glm.model_performance(test_data = datos_test_h2o)
# Métricas de test
# ------------------------------------------------------------------------------
print(f"auc: {performance_test.auc()}")
print(f"MSE: {performance_test.mse()}")
print(f"R2: {performance_test.r2()}")
print(f"Gini: {performance_test.gini()}")
print(f"AIC: {performance_test.aic()}")
print(f"LogLoss: {performance_test.logloss()}")
# Gráfico ROC (Solo para clasificación binaria)
# ------------------------------------------------------------------------------
performance_test.plot(type='roc')
Grid search¶
En el modelo anterior, se ha hecho una búsqueda del valor óptimo de lambda pero no de alpha (se ha empleado un valor fijo de alpha = 0.95). A continuación, se repite el ajuste del modelo, pero esta vez, comparando también distintos valores de alpha. Para estimar la capacidad predictiva de cada modelo se emplea validación cruzada con 10 particiones.
Nota: con el número de observaciones disponible, emplear validación simple sería suficiente y los resultados se obtendrían mucho más rápido.
En primer lugar se define un diccionario con los valores de los hiperparámetros que se desea explorar y que se pasa a través del argumento hyper_params.
# Búsqueda de hiperparámetros
# ------------------------------------------------------------------------------
from h2o.grid.grid_search import H2OGridSearch
# Valores de alpha que se van a comparar.
hiperparametros = {"alpha" : [0, 0.1, 0.5, 0.95, 1]}
Por defecto, H2OGridSearch hace una búsqueda cartesiana extricta analizando todas las posibles combinaciones de hiperparámetros definidas en el diccionario. En caso de querer otro tipo de búsqueda, se puede definir con un diccionario que se pasa al argumento search_criteria. Un ejemplo es:
criteria = {"strategy": "RandomDiscrete", "max_runtime_secs": 600,
"max_models": 100, "stopping_metric": "AUTO",
"stopping_tolerance": 0.00001, "stopping_rounds": 5,
"seed": 123456}
El siguiente paso es crear el objeto H2OGridSearch en el que se especifica el tipo de modelo (con los parámetros fijdos), los hiperparámetros, la estrategia de búsqueda (por defecto cartesiana) y el id del grid creado.
glm_grid = H2OGridSearch(
model=H2OGeneralizedLinearEstimator(
family = "binomial",
link = "logit",
standardize = True,
balance_classes = False,
ignore_const_cols = True,
# Se especifica que hacer con observaciones incompletas
missing_values_handling = "Skip",
# Se hace una búsqueda del hiperparámetro lamba.
lambda_search = True,
# Selección automática del solver adecuado.
solver = "AUTO",
# Validación cruzada de 10 folds para estimar el error
# del modelo.
seed = 123,
nfolds = 10,
# Reparto estratificado de las observaciones en la creación
# de las particiones.
fold_assignment = "Stratified",
keep_cross_validation_predictions = False
),
hyper_params = hiperparametros,
search_criteria = {'strategy': "Cartesian"},
grid_id = 'glm_grid'
)
Por último se realiza el entrenamiento.
glm_grid.train(
y = var_respuesta,
x = predictores,
training_frame = datos_train_h2o,
)
Una vez entrenado el grid, con .get_grid() se muestran los resultados obtenidos con cada combinación de hiperpárametros ordenados por una métrica concreta. Para mostrar información detallada de todos los modelos probados se utiliza .summary().
# Resultados grid search
# ------------------------------------------------------------------------------
glm_grid.get_grid(sort_by="auc", decreasing=True).sorted_metric_table()
#glm_grid.get_grid(sort_by='auc',decreasing=True)
De entre los valores comparados, el mayor accuracy promedio de validación cruzada se obtiene con alpha = 0.0 (modelo ridge), aunque para este problema, la diferencia es mínima.
Para conocer con más detalle la distribución de accuracy obtenido por cada modelo en cada partición de la validación cruzada, se tiene que extraer la información de cada uno de los modelos.
# Comparación errores validacción cruzada
# ------------------------------------------------------------------------------
# Identificador de los modelos creados por validación cruzada.
id_modelos = glm_grid.model_ids
# Se crea un diccionario donde se almacenarán los resultados.
auc_xvalidacion = {}
# Metrica que se quiere estudiar
metrica = "auc"
# Se recorre cada modelo almacenado en el grid y se extraen la métrica (auc)
# obtenida en cada partición.
for id in id_modelos:
modelo = h2o.get_model(id)
metricas_xvalidacion_modelo = modelo.cross_validation_metrics_summary()\
.as_data_frame().set_index('')
auc_xvalidacion[modelo.summary()["regularization"][0]] = \
list(metricas_xvalidacion_modelo.loc[metrica][2:])
auc_xvalidacion
# Se convierte la lista en dataframe.
auc_xvalidacion = pd.DataFrame(auc_xvalidacion,dtype="float")
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 3.8))
auc_xvalidacion.boxplot(vert=False, ax = ax);
ax.tick_params(axis='both', labelsize=7)
fig.suptitle('Comparación errores validacción cruzada', fontsize= 'large');
En este caso, los resultados de los 5 modelos son prácticamente idénticos.
Una vez identificado el mejor modelo, se extrae del objeto grid y se almacena por separado.
# Mejor modelo
# ------------------------------------------------------------------------------
id_mejor_modelo = glm_grid.get_grid(sort_by="auc", decreasing=True)\
.sorted_metric_table()['model_ids'][0]
mejor_glm_final = h2o.get_model(id_mejor_modelo)
Detalles sobre todos los hiperparámetros del modelo final:
# Se emplea el formato YAML para facilitar la lectura de la info
import yaml
no_mostrar = ["model_id", "training_frame", "validation_frame"]
hyperparam = {key:val for key, val in mejor_glm_final.params.items() if key not in no_mostrar}
print(yaml.dump(hyperparam))
Gradient Boosting Machine (GBM)¶
Introducción¶
Boosting Machine (BM) es un tipo de modelo obtenido al combinar (ensembling) múltiples modelos sencillos (de regresión o clasificación), también conocidos como weak learners. Está combinación se realiza de forma secuencial, de forma que cada nuevo modelo que se incorpora al conjunto intenta corregir los errores de los anteriores modelos. Como resultado de la combinación de múltiples modelos, Boosting Machine consigue aprender relaciones no lineales entre la variable respuesta y los predictores. Si bien los modelos combinados pueden ser muy variados, H2O, al igual que la mayoría de librerías, utiliza como weak learners modelos basados en árboles.
Gradient Boosting Machine (GBM) es una generalización del modelo de Boosting Machine que permite aplicar el método de descenso de gradiente para optimizar cualquier función de coste durante el ajuste del modelo.
El valor predicho por un modelo GBM es la agregación (normalmente la moda en problemas de clasificación y la media en problemas de regresión) de las predicciones de todos los modelos individuales que forman el ensemble.
Dado que el ajuste de los weak learners que forman un GBM se hace de forma secuencial (el árbol i se ajusta a partir de los resultados del árbol i-1), las posibilidades de paralelizar el algoritmo son limitadas. H2O consigue acelerar el proceso en cierta medida paralelizando el ajuste de los árboles individuales.
Para información más detallada sobre métodos boosting consultar Gradient Boosting con Python.
Detención temprana del entrenamiento (Early Stopping)¶
Una de las características de GBM es que, con el número suficiente de weak learners, el modelo final tiende a ajustarse perfectamente a los datos de entrenamiento causando overfitting. Este comportamiento implica que el analista tiene que encontrar el número adecuado de árboles y, para ello, suele tener que entrenar el modelo con cientos o miles de árboles hasta identificar el momento en el que empieza el overfitting. Esto suele ser poco eficiente en términos de tiempo, ya que, posiblemente, se estén ajustando muchos árboles innecesarios.
De nuevo, la experiencia de los creadores de H2O queda reflejada en su herramienta, esta vez incluyendo toda una serie de estrategias para detener el proceso de ajuste de un modelo GBM a partir del momento en el que este deja de mejorar. Por defecto, la métrica empleada se calcula con los datos de validación. Cuatro argumentos controlan la estrategia de parada:
stopping_metric: métrica empleada para cuantificar cuánto mejora el modelo.score_tree_interval: número de árboles tras los que se evalúa el modelo. Por ejemplo, si el valor es 10, entonces, tras cada 10 nuevos árboles que se añaden al modelo, se calcula lastopping_metric. Si bien la evaluación del modelo puede hacerse tras cada nuevo árbol que se añade, esto puede ralentizar el entrenamiento.stopping_tolerance: porcentaje mínimo de mejora entre dos mediciones consecutivas (score_tree_interval) por debajo del cual se considera que el modelo no ha mejorado.stopping_rounds: número de mediciones consecutivas en las que no se debe superar elstopping_tolerancepara que el algoritmo se detenga.
Algunos ejemplos de criterios de parada son:
Detener el entrenamiento de un modelo cuando el error de clasificación no se reduce más de un 1% durante dos mediciones consecutivas:
stopping_rounds=1,stopping_tolerance=0.01ystopping_metric="misclassification".Detener el entrenamiento de un modelo cuando el logloss no se reduce nada durante 3 mediciones consecutivas:
stopping_rounds=3,stopping_tolerance=0ystopping_metric="logloss".Detener el entrenamiento de un modelo cuando la media de AUC no aumenta más de un 0.1% durante cinco mediciones consecutivas:
stopping_rounds=5,stopping_tolerance=0.001ystopping_metric="AUC".Para detener el modelo aunque la métrica converja, se tiene que deshabilitar este comportamiento de parada automática indicando
stopping_rounds=0. En este caso, el algoritmo se detendrá cuando se alcance otra condición de parada, por ejemplo, el número máximo de árboles que pueden formar el modelo.
También es posible detener el entrenamiento del modelo cuando se supera un tiempo máximo especificado con el argumento max_runtimesecs > 0.
En la práctica, es conveniente establecer un número máximo de árboles muy elevado (potencialmente por encima de la cantidad necesaria) y activar la parada temprana.
Comportamiento estocástico¶
Stochastic Gradient Boosting es el resultado de emplear, en el entrenamiento de cada árbol, únicamente una selección aleatoria de observaciones y predictores del conjunto de entrenamiento. Esta modificación suele reducir el overfitting del modelo y mejorar su generalización. Se puede especificar el % de datos aleatorios seleccionados en cada ajuste con los argumentos:
sample_rate: porcentaje de observaciones aleatorias empleadas para el ajuste de cada árbol del ensemble.sample_rate_per_class: cuando el set de datos con el que se trabaja está desbalanceado (el % de observaciones de cada grupo es muy distinto), al hacer una selección aleatoria de observaciones para el entrenamiento de los árboles, puede ocurrir que, en algunos árboles, la selección excluya a alguno de los grupos. Para evitarlo, con el argumentosample_rate_per_classse indica que la selección debe hacerse de forma estratificada, asegurando que todos los grupos queden representados.col_sample_rate: porcentaje de predictores (columnas) seleccionados de forma aleatoria para el ajuste de cada árbol del ensemble.
Los tres parámetros deben tener un valor entre 0 y 1. Por defecto, el valor empleado es 1, es decir, se emplean todos los datos y no hay comportamiento estocástico.
Distribución y función de coste¶
Dependiendo el tipo de modelo (regresión, clasificación binaria, clasificación múltiple...) se emplea una distribución y una función de coste distinta. Indicando la distribución con el argumento distribution, H2O selecciona automáticamente la función de coste correspondiente.
Las distribuciones disponibles son: bernoulli, quasibinomial, multinomial, poisson, laplace, tweedie, gaussian, huber, gamma y quantile. De entre todas ellas, las más empleadas suelen ser: gaussian para regresión, bernoulli para clasificación binaria y multinomial para clasificación multiclase. Aunque menos frecuentes, también pueden resultar muy útiles la distribución huber, cuando se quiere que los errores penalicen más que su valor absoluto pero menos que el cuadrado, y la distribución quantile cuando en lugar de la media se quiere predecir uno de los cuantiles, por ejemplo la mediana.
Otros hiperparámetros¶
Además de los ya descritos (criterio de parada, comportamiento estocástico, distribución), el modelo GBM de H2O incorpora muchos otros parámetros e hiperparámetros con los que se puede controlar el comportamiento del algoritmo. A continuación se describen algunos de los que tienen más influencia en el modelo final. Se puede encontrar un listado completo en la documentación.
Complejidad de los árboles
ntrees: número de árboles que forman el ensemble.max_depth: profundidad máxima que pueden tener los árboles (número máximo de nodos).min_rows: número mínimo de observaciones que debe tener cada nodo.min_split_improvement: reducción mínima en el error cuadrático que debe de conseguir la división de un nodo para que se lleve a cabo.
Velocidad de aprendizaje
learn_rate: determina cuanto influye cada árbol individual en el conjunto del ensemble. Cuanto más pequeño es el valor de learning rate, más lentamente aprende el modelo y más árboles se necesitan, sin embargo, al aprender poco a poco, se reduce el riesgo de overfitting. Suelen emplearse valores inferiores a 0.1.learn_rate_annealing: emplear un valor delearn_ratemuy pequeño puede conllevar que el modelo necesite varios miles de árboles y, por lo tanto, el entrenamiento tarde mucho tiempo. En lugar de utilizar un valor muy bajo desde el principio, se puede iniciar el proceso con un valor moderadamente alto e ir reduciéndolo tras cada nuevo árbol que se incorpora al modelo. Ellearn_rate_annealingdetermina el factor por el que se reduce ellearn_rateen cada iteración. Para N árboles, GBM empieza conlearn_ratey termina conlearn_rate*learn_rate_annealing^N. Por ejemplo, en lugar de emplearearn_rate=0.01, se puede emplear unlearn_rate=0.05y unlearn_rate_annealing=0.99. Con la segunda opción, el algoritmo converge mucho más rápido con aproximadamente la misma capacidad predictiva final.
Comportamiento monotónico
Los modelos GBM son capaces de aprender interacciones complejas entre los predictores y la variable respuesta. Esto puede convertirse en una desventaja cuando, debido al ruido de los datos, el modelo aprende comportamientos que no reflejan la realidad. Con el argumento monotone_constraints se puede forzar a que la relación de cada predictor (numérico) con la variable respuesta tenga siempre la misma dirección (positiva o negativa). Puede encontrarse una descripción más detallada en GBM monotónicos.
Para conseguir maximizar la capacidad predictiva de un modelo GBM, es imprescindible entender bien cómo influye cada uno de los parámetros e hiperparámetros. Algunos de ellos pueden encontrarse descritos con más detalle en el documento Boosting.
Modelo¶
A continuación, se ajusta un modelo GBM que prediga la variable respuesta salario. En esta ocasión, se emplea validación simple en lugar de validación cruzada, por lo que dividen de nuevo los datos, esta vez, en un conjunto de entrenamiento (60%), validación (20%) y test (20%).
# Reparto de los datos en train, validación y test
# ------------------------------------------------------------------------------
datos_train_h2o, datos_val_h2o, datos_test_h2o = datos_h2o.split_frame(
ratios=[0.6, 0.20],
destination_frames= ["datos_train_H2O", "datos_val_h2o", "datos_test_H2O"],
seed = 123
)
Se entrena un modelo inicial en el que únicamente se especifican el número máximo de árboles, la complejidad de los mismos y la estrategia de parada temprana, el resto de valores se dejan por defecto.
# Ajuste del modelo y validación mediente 5-CV para estimar su error
# ------------------------------------------------------------------------------
from h2o.estimators.gbm import H2OGradientBoostingEstimator
modelo_gbm = H2OGradientBoostingEstimator(
# Tipo de distribución (clasificación binaria)
distribution = "bernoulli",
# Número de árboles.
ntrees = 500,
# Complejidad de los árboles
max_depth = 3,
min_rows = 10,
# Aprendizaje
learn_rate = 0.01,
# Detención temprana
score_tree_interval = 5,
stopping_rounds = 3,
stopping_metric = "AUC",
stopping_tolerance = 0.001,
model_id = "modelo_gbm",
seed = 123
)
modelo_gbm.train(
# Variable respuesta y predictores.
y = var_respuesta,
x = predictores,
# Datos de entrenamiento.
training_frame = datos_train_h2o,
# Datos de validación para estimar el error.
validation_frame = datos_val_h2o
)
modelo_gbm.summary()
Métricas de validación¶
# Métricas de validación
# ------------------------------------------------------------------------------
#modelo_gbm.model_performance(valid=True)
print("auc: ", modelo_gbm.auc(valid=True))
print("MSE: ",modelo_gbm.mse(valid=True))
print("R2: ",modelo_gbm.r2(valid=True))
print("Gini: ",modelo_gbm.gini(valid=True))
print("LogLoss: ",modelo_gbm.logloss(valid=True))
Evolución del modelo¶
Tras ajustar un modelo GBM, es fundamental evaluar la como aprende el modelo a medida que se añaden nuevos árboles al ensemble. Una forma de hacerlo es representar la evolución de una métrica (en este caso el área bajo la curva roc, AUC) de entrenamiento y validación.
# H2O almacena las métricas de entrenamiento y test bajo el nombre de scoring.
# Los valores se encuentran almacenados dentro del modelo.
historial_scoring = modelo_gbm.scoring_history()
historial_scoring.head(5)
Tal y como se ha indicado en el argumento (score_tree_interval=5), cada 5 árboles se han recalculado las métricas de rendimiento en el conjunto de entrenamiento y validación. El argumento stopping_metric="AUC" indica que se emplee el área bajo la curva como criterio para decidir si el algoritmo debe detenerse de forma temprana, pero se calculan siempre todas (AUC, logloss, lift, rmse, classification_error).
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 3.8))
historial_scoring.plot(
x="number_of_trees",
y=["validation_auc","training_auc"],
kind='line',
ax = ax
)
fig.suptitle('Comparación errores train y validación', fontsize= 'large');
En el gráfico puede observarse que no se han alcanzado los 500 árboles indicados en el modelo, esto es así porque, alcanzados los 95 árboles, el valor de AUC se ha estabilizado lo suficiente como para que se ejecute la detención temprana.
Importancia de los predictores¶
En los modelos GBM de H2O, se puede estudiar la influencia de los predictores cuantificando la reducción total de error cuadrático que ha conseguido cada predictor en el conjunto de todos los árboles que forman el modelo.
# Importancia predictores
# -----------------------------------------------------------------------------
imporatancia_predictores = modelo_gbm.varimp(use_pandas=True)
imporatancia_predictores
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 3.8))
imporatancia_predictores.plot.barh(x='variable', y='scaled_importance', ax=ax)
ax.invert_yaxis()
fig.suptitle('Importancia predictores', fontsize= 'large');
Predicciones y error¶
Una vez ajustado el modelo, se puede predecir nuevas observaciones y estimar su error promedio.
predicciones = modelo_gbm.predict(test_data = datos_test_h2o)
predicciones.head(5)
# Cálculo de las métricas para el conjunto de test
# ------------------------------------------------------------------------------
performance_test = modelo_glm.model_performance(test_data = datos_test_h2o)
# Métricas de test
# ------------------------------------------------------------------------------
print(f"auc: {performance_test.auc()}")
print(f"MSE: {performance_test.mse()}")
print(f"R2: {performance_test.r2()}")
print(f"Gini: {performance_test.gini()}")
print(f"AIC: {performance_test.aic()}")
print(f"LogLoss: {performance_test.logloss()}")
Grid search¶
Empleando los valores por defecto de los hiperparámetros, se ha conseguido un AUC de test de 0.893. A continuación, se intenta encontrar los valores óptimos de los hiperparámetros con los que se consiga mejorar aún más el AUC.
Dada la gran cantidad de hiperparámetros que tiene el algoritmo GBM y, aunque todos interaccionan entre sí, no es posible explorar todo el espacio de posibles valores a la vez. Una estrategia que suele funcionar bien es establecer primero los hiperparámetros más influyentes (número de árboles, learning rate, complejidad de los árboles, % de observaciones empleadas en cada ajuste).
Número de árboles (
ntree): incorporar tantos árboles como sea necesario hasta que el error de validación se estabilice o empiece a aumentar. Dado que H2O incorpora estrategias de parada temprana, no hay problema en indicar un número elevado porque, de no ser necesario, no se ajustarán.Tasa de aprendizaje (
learning_rate): por lo general, valores pequeños (<0.01) dan lugar a en mejores modelos, pero requieren más árboles para aprender. Se recomienda reducir el valor tanto como permitan las limitaciones de tiempo/computación.Profundidad de los árboles (
max_depth): es la principal forma de controlar la complejidad de los árboles que forman el ensemble. Al tratarse de weak learners, la complejidad de los árboles debe ser baja, aunque depende mucho de los datos, el valor óptimo raramente está fuera del rango [1, 20].Comportamiento estocástico (
sample_rate,col_sample_rate): la finalidad de emplear solo un subconjunto de observaciones y/o columnas en el entrenamiento de cada árbol es conseguir mejor generalización, sin embargo, puede tener el resultado contrario cuando se dispone de muy pocos datos. El valor óptimo suele estar dentro del rango de [0.7-0.9]. En situaciones en las que la variable respuesta es cualitativa y los grupos están desbalanceados, es conveniente realizar una selección aleatoria estratificada, este comportamiento puede activarse consample_rate_per_class.
# Búsqueda de hiperparámetros
# ------------------------------------------------------------------------------
from h2o.grid.grid_search import H2OGridSearch
# Hiperparámetros que se quieren comparar.
hiperparametros = {
"learn_rate":[0.001, 0.05, 0.1],
"max_depth":[5, 10, 15, 20],
"sample_rate":[0.8, 1]
}
gbm_grid = H2OGridSearch(
model=H2OGradientBoostingEstimator(
distribution = "bernoulli",
# Número de árboles.
ntrees = 5000,
# Preprocesado.
ignore_const_cols = True,
# Validación cruzada de 10 folds para estimar el error
# del modelo.
seed = 123,
nfolds = 10,
# Reparto estratificado de las observaciones en la creación
# de las particiones.
fold_assignment = "Stratified",
keep_cross_validation_predictions = False,
# Detención temprana
score_tree_interval = 5,
stopping_rounds = 3,
stopping_metric = "AUC",
stopping_tolerance = 0.001,
),
hyper_params = hiperparametros,
search_criteria = {'strategy': "Cartesian"},
grid_id = 'gbm_grid'
)
gbm_grid.train(
y = var_respuesta,
x = predictores,
training_frame = datos_train_h2o,
)
Se muestran los modelos ordenados de mayor a menor AUC.
# Resultados grid search
# ------------------------------------------------------------------------------
gbm_grid.get_grid(sort_by="auc", decreasing=True).sorted_metric_table()
Los 3 modelos con mayor AUC de validación tienen todos un learning rate de 0.1 o 0.5 y un max depth 5, el sample rate parece no influir de forma sustancial. Teniendo en cuenta estos resultados, pude concluirse que los valores óptimos son:
learn_rate=0.1, max_depth=5 y sample_rate=0.8.
Se extrae del grid el mejor modelo.
# Mejor modelo
# ------------------------------------------------------------------------------
id_mejor_modelo = gbm_grid.get_grid(sort_by="auc", decreasing=True)\
.sorted_metric_table()['model_ids'][0]
mejor_gbm_final = h2o.get_model(id_mejor_modelo)
# Cálculo de la métrica AUC para el conjunto de test.
performance = mejor_gbm_final.model_performance(test_data = datos_test_h2o)
performance.auc()
Optimizando los hiperparámetros más influyentes, se ha conseguido mejorar el AUC de test de 0.893 a 0.927.
Por último, se intenta encontrar el valor óptimo del resto de hiperparámetros, esta vez mediante una búsqueda aleatoria.
# Hiperparámetros que se quieren optimizar mediante búsqueda aleatoria.
# Para realizar esta búsqueda se tiene que pasar un vector de posibles valores
# de cada hiperparámetro, entre los que se escoge aleatoriamente.
hiperparametros = {
"min_rows" : list(range(5,50,10)),
"nbins" : [2**x for x in range(4, 10, 1)],
"nbins_cats" : [2**x for x in range(4, 10, 1)],
"min_split_improvement" : [0, 1e-8, 1e-6, 1e-4],
"histogram_type" : ["UniformAdaptive","QuantilesGlobal","RoundRobin"]
}
# Al ser una búsqueda aleatoria, hay que indicar criterios de parada.
search_criteria = {
"strategy" : "RandomDiscrete",
# Tiempo máximo de búsqueda (5 minutos).
"max_runtime_secs" : 5*60,
# Número máximo de modelos.
"max_models" : 100,
# Reproducible.
"seed" : 1234
}
gbm_grid_2 = H2OGridSearch(
model=H2OGradientBoostingEstimator(
distribution = "bernoulli",
# Hiperparámetros fijados
ntrees = 5000,
learn_rate = 0.1,
max_depth = 5,
sample_rate = 0.8,
# Preprocesado.
ignore_const_cols = True,
# Validación cruzada de 10 folds para estimar el error
# del modelo.
seed = 123,
nfolds = 10,
# Reparto estratificado de las observaciones en la creación
# de las particiones.
fold_assignment = "Stratified",
keep_cross_validation_predictions = False,
# Detención temprana
score_tree_interval = 5,
stopping_rounds = 3,
stopping_metric = "AUC",
stopping_tolerance = 0.001,
),
# Hiperparámetros optimizados.
hyper_params = hiperparametros,
# Tipo de búsqueda.
search_criteria = search_criteria,
grid_id = "gbm_grid_2"
)
gbm_grid_2.train(
y = var_respuesta,
x = predictores,
training_frame = datos_train_h2o,
)
# Se muestran los modelos ordenados de mayor a menor AUC.
gbm_grid_2.get_grid(sort_by="auc", decreasing=True).sorted_metric_table()
id_mejor_modelo = gbm_grid_2.get_grid(sort_by="auc", decreasing=True)\
.sorted_metric_table()['model_ids'][0]
mejor_gbm_final = h2o.get_model(id_mejor_modelo)
# Cálculo de la métrica AUC para el conjunto de test.
performance = mejor_gbm_final.model_performance(test_data = datos_test_h2o)
performance.auc()
El AUC de test obtenido es prácticamente idéntico al del anterior modelo.
Deep Learning (Neural Networks)¶
Introducción¶
El término deep learning engloba a todo un conjunto de modelos basados en redes neuronales artificiales (artificial neural networks) que contienen múltiples capas intermedias (ocultas). En concreto, H2O incorpora redes neuronales de tipo Multi-layer - feedforward - neural networks. Estas redes se caracterizan por:
Pueden tener una o múltiples capas intermedias, también conocidas como capas ocultas. Son las capas de neuronas que hay entre la capa de entrada y la de salida.
La estructura es full conected, lo que significa que cada neurona está conectada con todas las neuronas de la capa siguiente.
El peso (participación de cada neurona en la red) se aprende mediante el proceso feed-forward. A grandes rasgos, la estrategia de aprendizaje consiste en un proceso iterativo. En cada iteración (época), la red predice las observaciones de entrenamiento, se calcula el error de estas predicciones comparando los resultados frente al valor real y se reajustan los pesos de las neuronas con el objetivo de minimizar el error (backpropagation y descenso de gradiente).
Estas redes son unas de las más empleadas, pero existen otros tipos, por ejemplo, las Convolutional Neural Networks (CNNs) son las que mejores resultados dan cuando se trabaja con imágenes.
Comprender los fundamentos de las redes neuronales y deep learning requiere de un estudio notable, puede encontrarse mucha de la información necesaria en el curso gratuito de Stanford Convolutional Neural Networks for Visual Recognition y en el libro Deep Learning An MIT Press book.
Flexibilidad de las redes neuronales¶
Los modelos basados en redes neuronales tienen la característica de ser potencialmente capaces de aprender cualquier función. La velocidad con la que aprenden está influenciada principalmente (aunque hay muchos otros hiperparámetros) por el número de observaciones, el número de neuronas y el número de iteraciones de aprendizaje (comúnmente llamadas epoch). A continuación, se muestra un ejemplo sencillo que ilustra este concepto.
Supóngase las siguientes observaciones generadas a partir de un modelo no lineal de espiral.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Número de observaciones por clase
N = 300
# Número de dimensiones
D = 2
# Número clases
K = 3
x_1 = np.empty(0)
x_2 = np.empty(0)
y = np.empty(0)
# Simulación de los datos
for i in np.arange(K):
np.random.seed(123)
r = np.linspace(start=0, stop=1, num=N)
t = np.linspace(start = i*4, stop = (i+1)*4, num = N) + np.random.normal(size = N) * 0.35
x_1 = np.hstack((x_1,r * np.sin(t)))
x_2 = np.hstack((x_2, r* np.cos(t)))
y = np.hstack((y, np.repeat(i, N)))
datos_espiral = pd.DataFrame({"x_1" : x_1,
"x_2" : x_2,
"y" : y})
fig, ax = plt.subplots(figsize=(4, 4))
ax.scatter(x = datos_espiral["x_1"],
y = datos_espiral["x_2"],
c = datos_espiral["y"],
cmap = "viridis"
)
ax.axis('off');
Se comparan 3 redes neuronales: 10 neuronas y 50 epochs, 10 neuronas y 1000 epochs, 2 capas de 200 neuronas neuronas y 1000 epochs.
from h2o.estimators.deeplearning import H2ODeepLearningEstimator
datos_espiral_h2o = h2o.H2OFrame(datos_espiral)
datos_espiral_h2o["y"] = datos_espiral_h2o["y"].asfactor()
modelo_dl_10 = H2ODeepLearningEstimator(
distribution = "multinomial",
standardize = True,
activation = "Rectifier",
hidden = [10],
stopping_rounds = 0,
epochs = 50,
seed = 123,
model_id = "modelo_dl_10"
)
modelo_dl_10.train(
x = ["x_1", "x_2"],
y = "y",
training_frame = datos_espiral_h2o
)
modelo_dl_10_1k = H2ODeepLearningEstimator(
distribution = "multinomial",
standardize = True,
activation = "Rectifier",
hidden = [10],
stopping_rounds = 0,
epochs = 1000,
seed = 123,
model_id = "modelo_dl_10_1k"
)
modelo_dl_10_1k.train(
x = ["x_1", "x_2"],
y = "y",
training_frame = datos_espiral_h2o
)
modelo_dl_2_200 = H2ODeepLearningEstimator(
distribution = "multinomial",
standardize = True,
activation = "Rectifier",
hidden = [200, 200],
stopping_rounds = 0,
epochs = 1000,
seed = 123,
model_id = "modelo_dl_2_200"
)
modelo_dl_2_200.train(
x = ["x_1", "x_2"],
y = "y",
training_frame = datos_espiral_h2o
)
def expand_grid(x, y):
xG, yG = np.meshgrid(x, y) # create the actual grid
xG = xG.flatten() # make the grid 1d
yG = yG.flatten() # same
return pd.DataFrame({'x':xG, 'y':yG})
grid_predicciones = expand_grid(x = np.linspace(-1,1, num = 75),
y = np.linspace(-1,1, num = 75))
grid_predicciones.columns = ["x_1", "x_2"]
grid_predicciones_h2o = h2o.H2OFrame(grid_predicciones)
Una vez entrenados los modelos, se representan sus fronteras de clasificación.
predicciones_10 = modelo_dl_10.predict(test_data = grid_predicciones_h2o)
grid_predicciones["y_10"] = predicciones_10["predict"].as_data_frame()
predicciones_10_1k = modelo_dl_10_1k.predict(test_data = grid_predicciones_h2o)
grid_predicciones["y_10_1k"] = predicciones_10_1k["predict"].as_data_frame()
predicciones_2_200 = modelo_dl_2_200.predict(test_data = grid_predicciones_h2o)
grid_predicciones["y_2_200"] = predicciones_2_200["predict"].as_data_frame()
display(grid_predicciones.head(5))
fig, axis = plt.subplots(nrows=1, ncols=3, figsize=(10.5, 3.5))
axis[0].scatter(
x = grid_predicciones["x_1"],
y = grid_predicciones["x_2"],
c = grid_predicciones["y_10"],
cmap = "viridis"
)
axis[0].set_title("1 capa oculta, 10 neuronas, 50 epochs", fontsize = 8)
axis[0].axis('off')
axis[1].scatter(
x = grid_predicciones["x_1"],
y = grid_predicciones["x_2"],
c = grid_predicciones["y_10_1k"],
cmap = "viridis"
)
axis[1].set_title("1 capa oculta, 10 neuronas, 1000 epochs", fontsize = 8)
axis[1].axis('off')
axis[2].scatter(
x = grid_predicciones["x_1"],
y = grid_predicciones["x_2"],
c = grid_predicciones["y_2_200"],
cmap = "viridis"
)
axis[2].set_title("2 capa oculta, 200 neuronas, 1000 epochs", fontsize = 8)
axis[2].axis('off');
fig.suptitle('Comparación redes neuronales', fontsize= 'large');
Este ejemplo debe servir como reflexión sobre la alta capacidad que tienen los modelos basados en redes para adaptarse a los datos de entrenamiento, por lo tanto, cuando la complejidad de los datos no es muy grande o se dispone de pocas observaciones, se debe tener muy presente el riesgo de overfitting.
Parámetros e hiperparámetros¶
Los modelos de Deep Learning ofrecidos por H2O tienen un número muy elevado de parámetros configurables (listado). Para la gran mayoría de casos, los valores por defecto dan buenos resultados, sin embargo, es conveniente conocer, al menos, los más influyentes.
Arquitectura
hidden: número de capas ocultas y número de neuronas por capa. La estructura se define mediante una lista de números enteros. Por ejemplo, una red con una única capa de 100 neuronas se crea conhidden = [100], y una red con dos capas ocultas de 10 neuronas cada una conhidden = [10, 10]. Las capas de entrada y salida se crean automáticamente. La capa de entrada tiene tantas neuronas como predictores (tras codificar las variables categóricas). La capa de salida tiene una única neurona en problemas de regresión, y tantas neuronas como clases en los problemas de clasificación.
Preprocesado
standardize: por defecto, se estandarizan los valores para que tengan media cero y varianza uno. Los modelos basados en redes no son independientes de la escala de los predictores, por lo que es fundamental estandarizarlos.missing_values_handling: las redes neuronales no aceptan observaciones con valores ausentes. H2O ofrece dos opciones: excluirlosSkipo imputarlos con la mediaMeanImputation.shuffle_training_data: mezclar aleatoriamente las observaciones antes de entrenar el modelo.
Aprendizaje
activation: función de activación de las neuronas de las capas intermedias (Tahn, Tahn with dropout, Rectifier, Rectifier with dropout, Maxout, Maxout with dropout). Las funciones Rectifier y Rectifier with dropout suelen dar buenos resultados para un abanico amplio de situaciones. La función de activación de la capa de salida se selecciona automáticamente dependiendo de si es un problema de regresión o clasificación.loss: función de coste que se intenta minimizar durante el entrenamiento de la red. Esta es la forma en que se cuantifica el error que comete la red y en función de ello aprende, por lo tanto, es importante escoger la función de coste más adecuada para el problema en cuestión (esto es así para todos los algoritmos, no solo para redes). Por ejemplo, en problemas de regresión, las dos funciones más comunes son el error absoluto y el error cuadrático. Con el primero, el modelo resultante prioriza predecir bien la mayoría de observaciones, aunque para unas pocas se equivoque por mucho. Con el segundo, como los errores se elevan al cuadrado, el modelo resultante tiende a evitar grandes errores a cambio de aumentar un poco el error en la mayoría de observaciones.epochs: número de iteraciones de aprendizaje durante el entrenamiento de la red. Encontrar el valor óptimo de épocas es muy importante ya que, si son muy pocas, la red puede no aprender lo suficiente, pero si son demasiadas, se produce overfiting. Normalmente, se puede tener una idea aproximada del valor correcto en función de la complejidad de la red (cuanto más compleja más pesos hay que aprender) y el número de observaciones de entrenamiento. Gracias al sistema de early stopping implementado en H2O, se puede indicar un número muy elevado de épocas sin riesgo de overfitting, ya que el entrenamiento se detendrá cuando la métrica de validación elegida no mejore. Aun así, siempre es recomendable representar la evolución del error de entrenamiento y validación en función del número de épocas.adaptive_rate: si se indica esta opción (activada por defecto), se emplea el algoritmo (ADADELTA) como algoritmo de aprendizaje. Con él, se consigue que el learning rate se adapte automáticamente (reduciéndose) a medida que el entrenamiento avanza. Es recomendable probar en primer lugar esta opción, ya que consigue un balance entre velocidad de aprendizaje y resultados bastante bueno. Este algoritmo está controlado por dos parámetros:rho: controla el ratio en el que se va reduciendo el learning rate en cada iteración de aprendizaje.
epsilon: corrector para evitar divisiones entre cero.
Si se desactiva el adaptive_rate, entonces, el usuario debe especificar el valor de learning rate empleado por la red.
rate: Cuanto menor sea este valor, más estable es el modelo final pero más tarda en aprender (llegar a convergencia).nesterov_accelerated_gradient: activa el método de descenso de gradiente Nesterov Accelerated Gradient.
Regularización
input_dropout_ratio: porcentaje de dropout en la capa de entrada. Este tipo de regularización controla que ningún predictor influya en exceso en la red. Se recomiendan valores de 0.1 o 0.2.hidden_dropout_ratios: porcentaje de dropout en las capas de intermedias. Solo es aplicable si se selecciona como función de activación TanhWithDropout, RectifierWithDropout, o MaxoutWithDropout. Por defecto, el valor es 0.5.l1: penalización l1. Ver apartado de regularización GLM para más información.l2: penalización l2. Ver apartado de regularización GLM para más información.
El siguiente listado contiene el valor por defecto de cada uno de los argumentos de la función h2o.deeplearning().
nfolds= 0keep_cross_validation_predictions= Falsekeep_cross_validation_fold_assignment= Falsefold_assignment= "AUTO", "Random", "Modulo", "Stratified"fold_column= NULLignore_const_cols= Truescore_each_iteration= Falseweights_column= NULLoffset_column= NULLbalance_classes= Falseclass_sampling_factors= NULLmax_after_balance_size= 5max_hit_ratio_k= 0checkpoint= NULLpretrained_autoencoder= NULLoverwrite_with_best_model= Trueuse_all_factor_levels= Truestandardize= Trueactivation= "Tanh", "TanhWithDropout", "Rectifier", "RectifierWithDropout", "Maxout", "MaxoutWithDropout"hidden= [200, 200]epochs= 10train_samples_per_iteration= -2target_ratio_comm_to_comp= 0.05seed= -1adaptive_rate= Truerho= 0.99epsilon= 1e-08rate= 0.005rate_annealing= 1e-06rate_decay= 1momentum_start= 0momentum_ramp= 1e+06momentum_stable= 0nesterov_accelerated_gradient= Trueinput_dropout_ratio= 0hidden_dropout_ratios= NULLl1= 0l2= 0max_w2= 3.4028235e+38initial_weight_distribution= "UniformAdaptive", "Uniform", "Normal"initial_weight_scale= 1initial_weights= NULLinitial_biases= NULLloss= "Automatic", "CrossEntropy", "Quadratic", "Huber", "Absolute", "Quantile"distribution= "AUTO", "bernoulli", "multinomial", "gaussian", "poisson", "gamma", "tweedie", "laplace", "quantile", "huber"quantile_alpha= 0.5tweedie_power= 1.5huber_alpha= 0.9score_interval= 5score_training_samples= 10000score_validation_samples= 0score_duty_cycle= 0.1classification_stop= 0regression_stop= 1e-06stopping_rounds= 5stopping_metric= "AUTO", "deviance", "logloss", "MSE", "RMSE", "MAE", "RMSLE", "AUC", "lift_top_group", "misclassification", "mean_per_class_error"stopping_tolerance= 0max_runtime_secs= 0score_validation_sampling= "Uniform", "Stratified"diagnostics= Truefast_mode= Trueforce_load_balance= Truevariable_importances= Truereplicate_training_data= Truesingle_node_mode= Falseshuffle_training_data= Falsemissing_values_handling= "MeanImputation", "Skip"quiet_mode= Falseautoencoder= Falsesparse= Falsecol_major= Falseaverage_activation= 0sparsity_beta= 0max_categorical_features= 2147483647reproducible= Falseexport_weights_and_biases= Falsemini_batch_size= 1categorical_encoding= "AUTO", "Enum", "OneHotInternal", "OneHotExplicit", "Binary", "Eigen", "LabelEncoder", "SortByResponse", "EnumLimited"elastic_averaging= Falseelastic_averaging_moving_rate= 0.9elastic_averaging_regularization= 0.001verbose= False
Importancia de los predictores¶
Para modelos de redes neuronales, una forma de cuantificar la importancia de los predictores es mediante el método Gedeon. Por defecto, esta opción está desactivada debido a que puede ser un proceso muy lento.
Modelo¶
from h2o.grid.grid_search import H2OGridSearch
# Hiperparámetros que se quieren comparar.
hiperparametros = {"hidden" : [[64], [128], [256], [512], [1024],
[64,64], [128,128], [256,256], [512, 512]]
}
dl_grid = H2OGridSearch(
model=H2ODeepLearningEstimator(
activation = "RectifierWithDropout",
epochs = 500,
# Preprocesado.
standardize = True,
missing_values_handling = "Skip",
# Detención temprana.
stopping_rounds = 3,
stopping_metric = "AUC",
stopping_tolerance = 0.01,
# Regularización
l1 = 1e-5,
l2 = 1e-5,
),
hyper_params = hiperparametros,
search_criteria = {'strategy': "Cartesian"},
grid_id = 'grid_dl'
)
dl_grid.train(
# Variable respuesta y predictores.
y = var_respuesta,
x = predictores,
# Datos de entrenamiento.
training_frame = datos_train_h2o,
shuffle_training_data = False,
# Datos de validación.
validation_frame = datos_val_h2o
)
hiperparametros
Se muestran los modelos ordenados de mayor a menor AUC.
dl_grid.get_grid(sort_by="auc", decreasing=True).sorted_metric_table()
El modelo que consigue mayor AUC de validación es el que tiene una arquitectura de una única capa con 128 neuronas.
id_mejor_modelo = dl_grid.get_grid(sort_by="auc", decreasing=True).sorted_metric_table()['model_ids'][0]
mejor_dl_final = h2o.get_model(id_mejor_modelo)
# Cálculo de la métrica AUC para el conjunto de test.
performance = mejor_dl_final.model_performance(test_data = datos_test_h2o)
performance.auc()
Detalles sobre todos los hiperparámetros del modelo final:
params_list = []
no_mostrar = ["model_id", "training_frame", "validation_frame"]
for key, value in mejor_dl_final.params.items():
if key not in no_mostrar:
params_list.append(str(key)+" = "+str(value['actual']))
params_list
Interpretación de modelos¶
En muchas aplicaciones reales, conocer la importancia que tiene cada predictor dentro de un modelo no es suficiente, además, se necesita entender de qué forma influye cada uno en el valor de las predicciones.
En los modelos lineales, gracias a los coeficientes de regresión, es fácil conocer en qué dirección y magnitud influyen variaciones de un predictor en el valor predicho. Sin embargo, en modelos más complejos como GBM, Random Forest o redes neuronales, no es tan inmediato. Una estrategia para estos últimos son los gráficos PDP e ICE.
Gráficos PDP¶
Los gráficos PDP muestran cómo varían en promedio las predicciones a medida que se modifica el valor de un predictor, manteniendo constantes el resto. Pueden obtenerse con la función h2o.partialPlot() pasándole como argumentos un modelo (object), las observaciones con las que se ha entrenado el modelo (data) y el nombre de los predictores para los que se quiere obtener el modelo (cols).
Véase el resultado de calcular las gráficas PDP del predictor age en el modelo GBM ajustado anteriormente.
curva_pdp = mejor_gbm_final.partial_plot(
data = datos_train_h2o,
cols = ["age"],
server=True,
plot = True,
figsize=(5, 3),
)
curva_pdp
El gráfico PDP muestra que, la relación entre la edad y la probabilidad de ganar más de 50000 dólares anuales no es constante ni monotónica. En el intervalo de los 20-40 años, a medida que aumenta la edad, mayor la probabilidad promedio de que una persona supere ese salario. En el intervalo 40-60 se estabiliza y a partir de los 60 decae.
Stacked Ensembles¶
Introducción¶
A modo general, el término model ensembling hace referencia a la combinación de las predicciones de dos o más modelos distintos con el objetivo de mejorar las predicciones finales. Esta estrategia se basa en la asunción de que, distintos modelos entrenados independientemente, emplean distintos aspectos de los datos para realizar las predicciones, es decir, cada uno es capaz de identificar parte de la “verdad” pero no toda ella. Combinando la perspectiva de cada uno de ellos, se obtiene una descripción más detallada de la verdadera estructura subyacente en los datos. A modo de analogía, imagínese un grupo de estudiantes que se enfrentan a un examen multidisciplinal. Aunque todos obtengan aproximadamente la misma nota, cada uno de ellos habrá conseguido más puntos con las preguntas que tratan sobre las disciplinas en las que destacan. Si en lugar de hacer el examen de forma individual, lo hacen en grupo, cada uno podrá contribuir en los aspectos que más domina, y el resultado final será probablemente superior a cualquiera de los resultados individuales.
La clave para que el ensembling consiga mejorar los resultados es la diversidad de los modelos. Si todos los modelos combinados son similares entre ellos, no podrán compensarse unos a otros. Por esta razón, se tiene que intentar combinar modelos que sean lo mejor posible a nivel individual y lo más diferentes entre ellos.
Las formas más simples de combinar las predicciones de varios modelos es emplear la media para problemas de regresión y la moda para problemas de clasificación. Sin embargo existen otras aproximaciones más complejas capaces de conseguir mejores resultados:
Ponderar las agregaciones dando distinto peso a cada modelo, por ejemplo, en proporción al accuracy que han obtenido de forma individual.
Super Learner (stacked regression): emplear un nuevo modelo para que decida la mejor forma de combinar las predicciones de los otros modelos.
Algoritmo Super Learner¶
La implementación de Super Learner disponible en H2O sigue el siguiente algoritmo:
Definición del ensemble
1) Definir un listado con los algoritmos base (cada uno con los hiperparámetros pertinentes).
2) Definir el algoritmo de metalearning que defina como se entrena en modelo superior. Entre los metalearners disponibles están (GLM, GBM, Random Forest y Deep Learning).
Entrenamiento del ensemble
1) Entrenar cada uno de los algoritmos base con el conjunto de entrenamiento.
2) Realizar k-fold cross-validation con cada uno de los algoritmos base y almacenar las predicciones hechas en cada una de las k particiones.
3) Combinar las predicciones del paso 2 en una única matriz NxL (N = número de observaciones en el conjunto de entrenamiento, L = número de modelos base).
4) Entrenar el metalearning con la variable respuesta y la matriz NxL como predictores.
5) El Super learner final está formado por los modelos base y el modelo metalearning.
Predecir
1) Predecir la nueva observación con cada uno de los modelos base.
2) Emplear las predicciones de los modelos base como input del metalearner para obtener la predicción final.
Modelo¶
Se entrena un super learner empleando como algoritmos base un GLM y un GBM. Cada uno de los modelos base se entrena por separado empleando como hiperparámetros los valores óptimos identificados en los grid search de los apartados anteriores.
Es importante tener en cuenta que, en el entrenamiento de los modelos base, es necesario:
Todos los modelos deben de emplear el mismo número de particiones en la validación cruzada (mismo valor en el argumento
nfolds.Deben de almacenarse las predicciones hechas durante la validación cruzada (
keep_cross_validation_predictions = True).Todos los modelos deben ser entrenados sobre el mismo conjunto de entrenamiento. Las filas deben de ser las mismas aunque cada modelo puede utilizar distintos predictores (columnas).
from h2o.estimators.glm import H2OGeneralizedLinearEstimator
from h2o.estimators.gbm import H2OGradientBoostingEstimator
from h2o.estimators.stackedensemble import H2OStackedEnsembleEstimator
# Entrenamiento del modelo GLM
modelo_glm = H2OGeneralizedLinearEstimator(
family = "binomial",
link = "logit",
standardize = True,
balance_classes = False,
ignore_const_cols = True,
# Se especifica que hacer con observaciones incompletas
missing_values_handling = "Skip",
# Se hace una búsqueda del hiperparámetro lamba.
lambda_search = True,
# Selección automática del solver adecuado.
solver = "AUTO",
alpha = 0,
# Validación cruzada de 5 folds para estimar el error
# del modelo.
seed = 123,
nfolds = 5,
# Reparto estratificado de las observaciones en la creación
# de las particiones.
fold_assignment = "Stratified",
keep_cross_validation_predictions = True,
model_id = "modelo_binomial"
)
modelo_glm.train(
y = var_respuesta,
x = predictores,
training_frame = datos_train_h2o
)
# Entrenamiento del modelo GBM
modelo_gbm = H2OGradientBoostingEstimator(
# Tipo de distribución (clasificación binaria)
distribution = "bernoulli",
# Número de árboles.
ntrees = 500,
# Complejidad de los árboles
max_depth = 5,
min_rows = 5,
# Aprendizaje
learn_rate = 0.1,
sample_rate = 1,
# Detención temprana
score_tree_interval = 5,
stopping_rounds = 3,
stopping_metric = "AUC",
stopping_tolerance = 0.001,
# Validación cruzada de 5 folds para estimar el error
# del modelo.
seed = 123,
nfolds = 5,
fold_assignment = "Stratified",
keep_cross_validation_predictions = True,
model_id = "modelo_gbm",
)
modelo_gbm.train(
# Variable respuesta y predictores.
y = var_respuesta,
x = predictores,
# Datos de entrenamiento.
training_frame = datos_train_h2o
)
# Entrenar el ensemble con los dos modelos anteriores.
modelo_superlearner = H2OStackedEnsembleEstimator(model_id="modelo_superlearner",
base_models=[modelo_glm, modelo_gbm])
modelo_superlearner.train(
x=predictores,
y=var_respuesta,
training_frame=datos_train_h2o
)
predicciones = modelo_superlearner.predict(test_data = datos_test_h2o)
predicciones.head(5)
# Cálculo de la métrica AUC para el conjunto de test.
performance = modelo_superlearner.model_performance(test_data = datos_test_h2o)
performance.auc()
Guardar-cargar un modelo H2O¶
Para guardar un modelo H2O ya entrenado se emplean la función h2o.save_model().
# Los modelos generados en un grid se almacenan por defecto con un model_id
# que identifica la posición que ocupa dentro del grid. Para almacenar el modelo
# con un nombre más descriptivo, se sobreescribe su atributo model_id.
mejor_gbm_final.model_id = "modelo_glm"
# Se guarda el modelo en el directorio actual
h2o.save_model(model=mejor_gbm_final, path=os.getcwd(), force=True)
Para cargar un modelo previamente guardado se emplea la función h2o.load_model().
modelo = h2o.load_model(os.path.join(os.getcwd(), "modelo_glm"))
Bibliografía¶
Nykodym, T., Kraljevic, T., Hussami, N., Rao, A., and Wang, A. (Nov 2017). Generalized Linear Modeling with H2O
Gradient Boosting Machine with H2O by Michal Malohlava & Arno Candel with assitance from Cliff Click, Hank Roark, & Viraj Parmar
Machine Learning with Python and H2O Pasha Stetsenko and Edited by: Angela Bartz
Dua, D. and Karra Taniskidou, E. (2017). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, School of Information and Computer Science
Practical Machine Learning with H2O by Darren Cook
[Top 10 Deep Learning Tips and Tricks - Arno Candel](https://www.youtube.com/watch?v=LM255qs8Zsk)
¿Cómo citar este documento?
Machine learning con H2O y Python por Joaquín Amat Rodrigo, disponible con licencia CC BY-NC-SA 4.0 en https://www.cienciadedatos.net/documentos/py04_machine_learning_con_h2o_y_python.html 
Este contenido, creado por Joaquín Amat Rodrigo, tiene licencia Attribution-NonCommercial-ShareAlike 4.0 International.