Tutorial de modelos en conjunto: explora técnicas de aprendizaje en conjunto

Los modelos de aprendizaje automático no son como el software tradicional. Estos modelos necesitan actualizaciones constantes a medida que hay nuevos datos disponibles para ofrecer predicciones precisas y fiables. En escenarios complejos o sensibles, depender de un único modelo puede no ser suficiente para obtener el mejor resultado, y aquí es donde entran en juego los modelos en conjunto. 

Este tutorial conceptual explica qué es el aprendizaje en conjunto (ensemble) en machine learning y cómo puede mejorar el rendimiento global de tus modelos. Después, veremos un resumen de varios métodos de ensemble antes de ilustrar un caso real con una implementación paso a paso en Python.

Nuestro tutorial Ensemble learning en R con SuperLearner explica cómo impulsar tus resultados de machine learning basados en el enfoque de aprendizaje en conjunto usando el paquete SuperLearner en R.

Modelos en conjunto en aprendizaje automático

Imagina a un director musical que participa en un concurso internacional. Tiene a su disposición una gran variedad de músicos con diferentes especialidades: 

• Músicos clásicos con capacidad para componer piezas tradicionales.
• Músicos electrónicos expertos en instrumentos electrónicos.
• Músicos de jazz con gran sentido de la improvisación.
• Solistas capaces de interpretar solos complejos y destacar por su técnica.

Dada la diversidad de perfiles y habilidades, el director puede combinarlos para crear una actuación única y memorable.

Piensa en los modelos en conjunto como en una orquesta: cada persona domina un instrumento específico, como piano, trompeta o percusión. La combinación de esas habilidades crea una melodía armoniosa. 

El aprendizaje en conjunto sigue la misma lógica: 

Combina varios algoritmos para lograr un rendimiento predictivo mejor que el de un único modelo. No hay un número predeterminado de modelos; según el objetivo de negocio, podrían hacer falta más o menos.

Error del modelo y cómo reducirlo con conjuntos

El error que surge en cualquier modelo puede descomponerse matemáticamente en tres componentes:

Sesgo + Varianza + Error irreducible

¿Por qué es importante aquí? Para entender qué ocurre dentro de un modelo en conjunto, primero necesitas saber qué causa el error en un modelo. 

Veamos estos errores: 

Error de sesgo 

Sirve para cuantificar cuánto se desvían, de media, los valores predichos respecto al valor real. Un sesgo alto indica un modelo poco eficaz que pasa por alto tendencias esenciales.

Varianza

Por otro lado, la varianza cuantifica cuánto difieren entre sí las predicciones hechas sobre la misma observación. Un modelo con alta varianza se ajustará en exceso a los datos de entrenamiento y tendrá mal desempeño en observaciones fuera de ese conjunto. El siguiente diagrama lo aclara (supón que el punto rojo es el valor real y los puntos azules, las predicciones): 

Normalmente, al aumentar la complejidad del modelo, disminuye el error debido a un menor sesgo. Sin embargo, esto solo ocurre hasta cierto punto. Si sigues haciendo el modelo más complejo, acabarás sobreajustándolo y el modelo empezará a sufrir por la alta varianza.

Ahora que ya conoces lo básico del aprendizaje en conjunto, veamos distintas técnicas:

Tipos de métodos en conjunto

Existen varios tipos de métodos de ensemble, cada uno con sus ventajas e inconvenientes. En esta sección los revisamos para ayudarte a elegir el más adecuado para tus casos de uso. 

Antes de entrar en cada método, aclaremos qué son los meta learners y los base learners para entender mejor los conceptos que vienen. 

• Base learners: son el primer nivel de una arquitectura en conjunto y se entrenan para hacer predicciones individuales. 
• Meta learners: están en el segundo nivel y se entrenan con la salida de los base learners. 

Bagging

Bagging también se conoce como agregación bootstrap. Esta técnica es similar a random forest, pero usa todos los predictores, mientras que random forest usa solo un subconjunto en cada árbol.  

En bagging, se selecciona con reemplazo una muestra aleatoria del conjunto de entrenamiento, lo que permite que haya instancias duplicadas. Estos son los pasos principales: 

• Generar múltiples remuestras bootstrap.
• Ejecutar un algoritmo sobre cada remuestra para obtener predicciones.
• Combinar las predicciones promediándolas o tomando la clase mayoritaria (en clasificación).

Bagging presenta varias ventajas e inconvenientes clave tanto en clasificación como en regresión.

Ventajas

• El proceso de modelado es sencillo, no requiere conceptos matemáticos complejos y puede manejar valores perdidos.
• El paquete scikit-learn facilita implementar la lógica subyacente. Incluye módulos para combinar las predicciones de cada modelo (los base learners). 
• Reduce significativamente la varianza en clasificadores de alta varianza. Esto ayuda con datos de alta dimensionalidad, evitando que el modelo generalice mal en datos nuevos. 
• Proporciona una estimación no sesgada del error out-of-bag, que corresponde al error/pérdida medio que arrojan todos esos clasificadores.

Inconvenientes

• Es computacionalmente costoso al usar varios modelos.
• El promedio de predicciones dificulta interpretar el resultado final.

Boosting

Boosting adopta un enfoque secuencial: la predicción del modelo actual se transfiere al siguiente. Cada modelo centra su atención de forma iterativa en las observaciones mal clasificadas por sus predecesores. El proceso general es el siguiente: 

Ventajas

• Al igual que bagging, boosting es fácil de entender e implementar. No requiere preprocesado y puede manejar valores perdidos.
• Reduce el sesgo de forma eficiente. 
• Durante el entrenamiento, los algoritmos de boosting priorizan las características que más aumentan la precisión. Esto reduce la dimensionalidad y, por tanto, el tiempo de cómputo. 

Inconvenientes

• El enfoque secuencial hace que los modelos siguientes corrijan errores del anterior, lo que vuelve al modelo global más vulnerable a valores atípicos.
• Por la misma razón (secuencialidad), boosting no escala bien.

Stacking

Stacking es bastante similar a boosting. Las predicciones de los base learners se apilan y se usan como entrada para entrenar el meta learner y producir predicciones más robustas. El meta learner se usa luego para predecir en último término. Bagging y boosting suelen usar base learners homogéneos, mientras que stacking tiende a incluirlos heterogéneos. 

Ventajas

• Aprovecha las fortalezas de varios modelos de alto rendimiento tanto en clasificación como en regresión.
• Como otros modelos en conjunto, ayuda a construir un modelo más preciso que los modelos individuales por separado.

Inconvenientes

• Usar modelos base complejos puede aumentar el riesgo de sobreajuste.
• Los distintos niveles de entrenamiento pueden hacer que la arquitectura de stacking sea compleja de implementar.

Blending 

Blending es similar a stacking. En blending, la estructura de los datos se divide en entrenamiento, validación (hold-out) y prueba. Los meta learners se entrenan con los datos de entrenamiento. Después, sus predicciones se combinan con los datos de validación para construir el meta modelo final, que usa los datos de prueba para las predicciones finales.

Ventajas

• Como stacking y otros métodos de ensemble, blending puede mejorar el rendimiento del modelo final en muchos casos. 
• Su uso ha sido clave para ganar muchas competiciones. 

Inconvenientes

• Dividir los datos según la arquitectura de blending puede limitar los datos disponibles para entrenar los modelos base y provocar peor desempeño.
• Como en otros ensembles, la interpretabilidad del modelo final se reduce por la mayor complejidad, dificultando extraer insights de negocio.

Voting

En voting, se entrenan varios modelos de forma independiente y sus predicciones se combinan para obtener la predicción final mediante voto duro, voto blando o voto ponderado:

• En el voto duro, la predicción final es la clase más frecuente entre todos los modelos.  
• En el voto blando, cada modelo genera una distribución de probabilidades en lugar de una predicción binaria. Se predice la clase con mayor probabilidad. 
• En el voto ponderado, se asume que algunos modelos son más competentes que otros y se les asigna mayor peso al combinar predicciones.

Ventajas

• La arquitectura de voting es más simple de implementar que stacking o blending. Además, no requiere un ajuste fino complejo. 
• Al usar múltiples base learners, es menos susceptible a la influencia de modelos individuales, lo que aporta predicciones más estables y fiables.

Inconvenientes

• Puede ser difícil resolver los conflictos entre predicciones de modelos, complicando la decisión final.
• Añadir más modelos al ensemble de voting no mejora necesariamente el rendimiento.

Cascading 

Cascading usa un enfoque tipo stacking pero con un solo modelo por capa. El primer modelo se entrena con todos los datos de entrenamiento y el siguiente se entrena con la salida del anterior. El objetivo es aprender patrones complejos y así mejorar las predicciones.   

Ventajas

• El siguiente modelo se especializa en la salida del previo, lo que reduce el ruido.
• Más robusto al sobreajuste y buen desempeño en datos del mundo real.

Inconvenientes

• Implementarlo puede ser complejo, ya que implica entrenar cada modelo de la secuencia.  
• Encontrar la arquitectura óptima puede requerir mucha experimentación y ajuste fino.

Resumen de algoritmos en conjunto

Ya vimos los diferentes tipos de modelos en conjunto. Ahora, hagamos un repaso breve de algunos modelos populares. 

Random forest

Random forest es un modelo muy utilizado que resuelve problemas de clasificación y regresión. Se compone de muchos árboles de decisión entrenados con bagging. Su resultado se obtiene promediando las predicciones de los árboles individuales. 

El tamaño de nodo, el número de árboles y el número de características muestreadas son los tres hiperparámetros principales que hay que fijar antes del entrenamiento. 

¿Y la aleatoriedad en un random forest?

El muestreo aleatorio de características (feature bagging) crea una muestra aleatoria de variables para asegurar baja correlación entre árboles. Esto diferencia a los random forests de los árboles de decisión, que consideran todas las divisiones posibles, mientras que los random forests consideran solo un subconjunto. Lee más en nuestro tutorial de clasificación con random forest. 

XGBoost

Extreme Gradient Boosting, o XGBoost, se usa tanto para clasificación como para regresión. Está diseñado para ser escalable y muy eficiente, e implementa el marco de gradient boosting con árboles de decisión. 

Es adecuado para conjuntos de datos de gran escala y es compatible con entornos distribuidos como Hadoop, MPI (Message Passing Inference) y SGI (Sun Grid Engine). Puedes saber más en nuestro tutorial de XGBoost. 

AdaBoost

Adaptive Boosting, o AdaBoost, es uno de los primeros clasificadores de boosting exitosos para clasificación binaria. Es adaptativo porque reasigna pesos a cada instancia, otorgando más peso a las mal clasificadas. Lee más sobre AdaBoost classification en Python en nuestro tutorial aparte. 

Implementación paso a paso de modelos en conjunto 

Ahora que ya entiendes la idea principal del modelado en conjunto y cómo funcionan algunos modelos, pasamos a la implementación técnica en Python. 

Preparar el entorno 

Para empezar, necesitas tener Python instalado en tu equipo, junto con estas librerías:

• pandas para cargar el data frame. 
• scikit-learn para usar algoritmos de machine learning existentes.
• seaborn y matplotlib para visualización.

Puedes instalarlas con pip, el gestor de paquetes de Python, así:

pip install scikit-learn
pip install pandas
pip install matplotlib seaborn

Para ilustrar el caso de uso, utilizaremos los datos de préstamos (Loan Data) disponibles en DataLab. El código de este tutorial también está en DataLab en este workbook; puedes crear tu propia copia, editar y ejecutar el código en el navegador sin instalar nada en tu ordenador.

Entender los datos

El conjunto de datos contiene 9.500 préstamos con información sobre la estructura del préstamo, la persona solicitante y si se devolvió íntegramente, representado por la columna not.fully.paid. Las cinco primeras observaciones se muestran a continuación: 

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()

Usar la función info() genera la siguiente información relevante sobre los datos: 

• 9.578 filas (de 0 a 9577) y 14 columnas numéricas salvo purpose, que es de tipo object y describe en texto el propósito del préstamo. 
• La etiqueta non-null en cada columna indica que no hay valores perdidos en esa columna. 

loan_data.info()

Observamos un desequilibrio de clases: hay muchas más observaciones con clase 0 (8045) que con clase 1 (solo 1533).

print(loan_data['not.fully.paid'].value_counts())
loan_data['not.fully.paid'].value_counts().plot(kind='barh')

Entrenar con datos tan desbalanceados afecta al rendimiento global. 

Una forma de abordarlo es el submuestreo (undersampling): reducimos el número de observaciones de la clase mayoritaria (clase 0). En este escenario, habrá tantas observaciones de la clase 0 como de la clase 1. El proceso es:

• Primero, obtener el número de registros de la clase 1.

• Seleccionar N observaciones aleatorias de la clase 0, donde N es el tamaño del dataframe de la clase 1.

• Concatenar ambos dataframes.

loan_data_class_1 = loan_data[loan_data['not.fully.paid'] == 1]
number_class_1 = len(loan_data_class_1)
loan_data_class_0 = loan_data[loan_data['not.fully.paid'] == 0].sample(number_class_1)

final_loan_data = pd.concat([loan_data_class_1,
                         	loan_data_class_0])

print(final_loan_data.shape)

El tutorial Diving deep with imbalanced data ofrece más recursos sobre cómo tratar conjuntos desbalanceados. 

Tras el submuestreo obtenemos: 

• Un total de 3.066 observaciones y 14 columnas. 

Y la distribución final equilibrada se muestra a continuación.

Preparar los datos para el entrenamiento 

Al examinar el conjunto de datos, vemos que no todas las variables están en la misma escala, y algunos modelos como KNN son sensibles a esto. Podemos resolverlo normalizando los rangos de las variables a la misma escala con MinMaxScaler, en este caso entre 0 y 1.

Además, eliminaremos la columna purpose por simplicidad, ya que requeriría preprocesamiento adicional. 

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

# Eliminar la columna 'purpose' y obtener los datos
final_loan_data.drop('purpose', axis=1, inplace=True)
X = final_loan_data.drop('not.fully.paid', axis=1)

normalized_X = scaler.fit_transform(X)

Como en cualquier tarea predictiva, necesitamos dividir los datos en entrenamiento y prueba. En este caso, usaremos un 67% para entrenamiento y el 33% restante para prueba.  

• El parámetro random_state se fija con un valor (2023 en nuestro caso) para garantizar la reproducibilidad. 

Stratify se usa para asegurar que el valor objetivo y quede distribuido de forma equilibrada tanto en entrenamiento como en prueba.

from sklearn.model_selection import train_test_split

y = final_loan_data['not.fully.paid']
r_state = 2023
t_size = 0.33

X_train, X_test, y_train, y_test = train_test_split(normalized_X, y,
                                                	test_size=t_size,
                                                	random_state=r_state,
                                                	stratify=y)

Todos los modelos seguirán la secuencia: entrenar con los datos de entrenamiento, predecir sobre los de prueba y evaluar el rendimiento. 

Modelo de bagging 

Random forest es el modelo de bagging que usamos en esta sección. Emplearemos los parámetros por defecto para simplificar.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# Definir el modelo
random_forest_model = RandomForestClassifier()
# Ajustar el modelo a los datos
random_forest_model.fit(X_train, y_train)

Tras entrenar el modelo, obtenemos el rendimiento con la función accuracy_score así: 

# Hacer predicciones
y_pred = random_forest_model.predict(X_test)

# Obtener el rendimiento
accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy) 

La sentencia print anterior devuelve 0.6156, es decir, un 61,56%.

Ahora comparemos esta puntuación con el rendimiento de un enfoque de blending.

Modelo de blending 

Para blending, usaremos dos modelos base: un árbol de decisión y un clasificador K-Nearest Neighbors. Un modelo final de regresión logística generará las predicciones finales.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

Los datos de entrenamiento originales se dividen en un nuevo conjunto de entrenamiento y otro de validación. Los modelos base se entrenan con los datos de entrenamiento. 

X_train, X_val, y_train, y_val = train_test_split(
                                            	X_train, y_train,
                                            	test_size=t_size,
                                            	random_state=r_state)

A partir de las predicciones de esos modelos base se generan dos dataframes: 

• Primer dataframe con las predicciones sobre los datos de validación, concatenadas con los datos de validación originales.
• Segundo dataframe con las predicciones sobre los datos de prueba, concatenadas con los datos de prueba originales.

# Modelo de árbol de decisión
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_model_pred_val = dt_model.predict(X_val)
dt_model_pred_test= dt_model.predict(X_test)

dt_model_pred_val = pd.DataFrame(dt_model_pred_val)
dt_model_pred_test = pd.DataFrame(dt_model_pred_test)

# Modelo KNN
knn_model = KNeighborsClassifier()
knn_model.fit(X_train,y_train)
knn_model_pred_val = knn_model.predict(X_val)
knn_model_pred_test = knn_model.predict(X_test)

knn_model_pred_val = pd.DataFrame(knn_model_pred_val)
knn_model_pred_test = pd.DataFrame(knn_model_pred_test)

El modelo final de regresión logística se construye con los datos de validación concatenados y se evalúa con los datos de prueba concatenados. 

x_val = pd.DataFrame(X_val)
x_test = pd.DataFrame(X_test)

df_val_lr = pd.concat([x_val, knn_model_pred_val,
                    	dt_model_pred_val], axis=1)

df_test_lr = pd.concat([x_test, dt_model_pred_test,
                     	knn_model_pred_test],axis=1)

# Modelo de regresión logística
lr_model = LogisticRegression()

lr_model.fit(df_val_lr,y_val)
lr_model.score(df_test_lr,y_test)

Usar la función .score() calcula por defecto la accuracy y no necesita predicciones explícitas. 

El resultado es 0.6383, es decir, un 63,83%, aproximadamente 2% más que el random forest inicial; por tanto, el modelo de blending ofrece el mejor rendimiento.

Nuestros cursos Ensemble methods in Python y Machine learning with tree-based models in R pueden ser un gran siguiente paso para seguir tu camino en machine learning y adentrarte en el mundo de los métodos de clasificación en conjunto, en Python y R respectivamente.

Conclusión

En este artículo hemos visto distintos tipos de modelado en conjunto con sus características, ventajas e inconvenientes. También hemos repasado algunos algoritmos basados en ensembles como Random forest, Adaboost, XGBoost, Gradient boosting trees y Gradient boosting machines. 

Al construir modelos en conjunto, es importante tener presentes sus pros y contras para obtener mejores insights de negocio.

Preguntas frecuentes

¿Cuál es la diferencia entre learners homogéneos y heterogéneos?

Los learners homogéneos emplean un tipo de algoritmo y de hiperparámetros similares. Random forest puede considerarse un conjunto de learners homogéneos. 

Los heterogéneos, en cambio, combinan algoritmos e hiperparámetros diferentes. Random forest, redes neuronales y KNN pueden formar un ensemble heterogéneo.

¿Qué ventajas tienen los modelos en conjunto frente a los modelos individuales?

Usar modelos en conjunto suele ofrecer predicciones mejores que un único modelo.

¿Cuál es la principal limitación de los modelos en conjunto?

Pueden adolecer de falta de interpretabilidad: el conocimiento que aprenden no siempre es comprensible para usuarios finales.

¿Cuándo deberías evitar usar modelos en conjunto?

Conviene evitarlos cuando se requiere alta interpretabilidad, hay pocos datos, existen restricciones de tiempo real o el coste computacional es elevado.  

¿Cuáles son los distintos tipos de métodos en conjunto en machine learning?

Bagging, boosting, stacking, voting, blending y cascading son los principales.