Torneo de selección de modelos: comparación de cinco algoritmos
Entrenará regresión logística, random forest, XGBoost, SVM y una red neuronal dentro de pipelines con validación cruzada anidada, y tabulará el rendimiento en un conjunto de prueba compartido.
Torneo de selección de modelos: comparación de cinco algoritmos es una lección gratuita de Machine Learning Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Machine Learning Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Machine Learning Academy incluye 4 lecciones en total.
¿Por qué comparar varios algoritmos?
Ningún algoritmo domina en todos los conjuntos de datos. El teorema de no hay almuerzo gratis demuestra que, promediado sobre todos los problemas posibles, el rendimiento de todos los algoritmos es igual; es decir, debe comparar empíricamente los algoritmos con sus datos específicos. Un torneo de selección de modelos entrena y evalúa sistemáticamente varios algoritmos diversos en condiciones idénticas, lo que permite determinar cuál se adapta mejor a la estructura de los datos. El ganador podrá pasar a la optimización de hiperparámetros y a la evaluación para su implementación.
Configuración de la estructura común del pipeline
Para realizar una comparación justa, todos los algoritmos deben partir de la misma matriz de características preprocesada y evaluarse con el mismo conjunto de prueba reservado. Integre cada algoritmo en un Pipeline que incluya el preprocesamiento, de modo que este se ajuste únicamente en los folds de entrenamiento. Utilice un random_state fijo en todas partes para garantizar la reproducibilidad. Mantenga el conjunto de prueba aislado: no lo consulte hasta la evaluación final y única del ganador del torneo.
import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import train_test_split, cross_val_score
# Load preprocessed data
X, y = load_features() # returns numpy arrays after EDA cleaning
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
print(f'Training set: {X_train.shape[0]} samples')
print(f'Test set (LOCKED): {X_test.shape[0]} samples')
print(f'Positive class rate (train): {y_train.mean():.3f}')Competidor 1: regresión logística
La regresión logística es la línea base lineal esencial. Es interpretable (los coeficientes muestran los efectos de las características), rápida de entrenar y funciona bien cuando el límite de decisión es aproximadamente lineal. En el torneo sirve como referencia mínima: si los modelos basados en árboles no logran superarla significativamente, es posible que el conjunto de datos carezca de patrones no lineales complejos que justifiquen el uso de modelos más complejos. Utilice class_weight='balanced' en conjuntos de datos desequilibrados.
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
lr_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(
C=1.0,
class_weight='balanced',
max_iter=1000,
random_state=42
))
])
cv_scores = cross_val_score(lr_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'Logistic Regression — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Competidor 2: Random Forest
Random Forest gestiona de forma natural las relaciones no lineales, las interacciones entre características y los tipos de datos mixtos, sin necesidad de escalar las características. Produce puntuaciones fiables de importancia de las características y es robusto frente a los valores atípicos. En las competiciones suele ser el segundo mejor algoritmo después del gradient boosting y constituye una sólida línea base para los datos tabulares. Establezca n_estimators=200 y class_weight='balanced' para obtener una configuración predeterminada sólida.
from sklearn.ensemble import RandomForestClassifier
rf_pipe = Pipeline([
('clf', RandomForestClassifier(
n_estimators=200,
max_depth=10,
class_weight='balanced',
random_state=42,
n_jobs=-1
))
])
cv_scores = cross_val_score(rf_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'Random Forest — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Competidor 3: XGBoost
XGBoost es el ganador más citado en las competiciones de ML con datos tabulares. Su boosting secuencial corrige los errores residuales en cada paso, lo que produce un rendimiento sólido con datos estructurados. Valores predeterminados clave para una ejecución del torneo: n_estimators=300, learning_rate=0.05, max_depth=6 y scale_pos_weight establecido en la proporción entre la clase negativa y la positiva para gestionar el desequilibrio. Proporcione eval_set para habilitar opcionalmente la detención temprana.
from xgboost import XGBClassifier
import numpy as np
# Compute class imbalance ratio
neg_count = (y_train == 0).sum()
pos_count = (y_train == 1).sum()
xgb_pipe = Pipeline([
('clf', XGBClassifier(
n_estimators=300,
learning_rate=0.05,
max_depth=6,
scale_pos_weight=neg_count / pos_count,
use_label_encoder=False,
eval_metric='logloss',
random_state=42,
n_jobs=-1
))
])
cv_scores = cross_val_score(xgb_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'XGBoost — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Competidor 4: máquina de vectores de soporte
La SVM con un kernel RBF destaca en conjuntos de datos con clases claramente separadas y pocas características irrelevantes. Consume mucha memoria (almacena vectores de soporte) y es lenta en conjuntos de datos grandes (tiempo de entrenamiento de O(n²) a O(n³)), pero puede superar a los modelos basados en árboles en conjuntos de datos pequeños con límites complejos. Estandarice las características antes del entrenamiento: las SVM son muy sensibles a la escala de las características. Utilice probability=True para obtener probabilidades calibradas que permitan evaluar el AUC.
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
svm_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', SVC(
C=1.0,
kernel='rbf',
gamma='scale',
class_weight='balanced',
probability=True,
random_state=42
))
])
cv_scores = cross_val_score(svm_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'SVM (RBF) — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Competidor 5: red neuronal
Un perceptrón multicapa (MLP) sencillo con 2 o 3 capas ocultas puede capturar patrones no lineales complejos, pero requiere un escalado y una regularización cuidadosos, y tarda más en entrenarse que los modelos basados en árboles con datos tabulares. Utilícelo cuando los otros cuatro algoritmos alcancen el mismo nivel de rendimiento, lo que sugiere que el límite de decisión requiere un modelado con mayor capacidad. sklearn.neural_network.MLPClassifier resulta práctico para el torneo sin necesidad de configurar PyTorch por completo.
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
mlp_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', MLPClassifier(
hidden_layer_sizes=(128, 64),
activation='relu',
alpha=0.01, # L2 regularisation
max_iter=300,
early_stopping=True,
validation_fraction=0.1,
random_state=42
))
])
cv_scores = cross_val_score(mlp_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'MLP Neural Network — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Consolidación de los resultados en una clasificación
Recopile todas las puntuaciones AUC de la validación cruzada de 5 folds en una tabla ordenada por AUC media. Registre también la desviación estándar: puede ser preferible implementar un modelo con una AUC media ligeramente inferior pero una varianza mucho menor, ya que su rendimiento es más predecible en distintas particiones de datos. Muestre los resultados en un gráfico de barras horizontales para comunicarlos a las partes interesadas.
import pandas as pd
import matplotlib.pyplot as plt
results = {
'Logistic Regression': (0.821, 0.013),
'Random Forest': (0.867, 0.009),
'XGBoost': (0.883, 0.007),
'SVM (RBF)': (0.845, 0.011),
'MLP Neural Network': (0.858, 0.010)
}
df_results = pd.DataFrame(results, index=['AUC_mean', 'AUC_std']).T
df_results = df_results.sort_values('AUC_mean', ascending=False)
print(df_results.to_string())
df_results['AUC_mean'].plot(kind='barh', xerr=df_results['AUC_std'], figsize=(8, 4))
plt.xlabel('5-fold CV AUC')
plt.title('Model Selection Tournament Results')
plt.tight_layout()
plt.savefig('tournament.png', dpi=150)Significación estadística de las diferencias
Una diferencia de 0.002 en el AUC entre dos modelos puede deberse simplemente al ruido de la partición aleatoria de los datos. Utilice una prueba t pareada o la prueba de rangos con signo de Wilcoxon sobre las puntuaciones de cada fold para determinar si la diferencia es estadísticamente significativa. Si el valor p supera 0.05, elija el modelo más sencillo: su menor complejidad facilita la depuración, la explicación y el mantenimiento en producción.
from scipy import stats
import numpy as np
# Simulated per-fold scores for XGBoost vs Random Forest
xgb_folds = np.array([0.889, 0.881, 0.875, 0.883, 0.887])
rf_folds = np.array([0.871, 0.863, 0.869, 0.865, 0.867])
# Paired t-test
t_stat, p_value = stats.ttest_rel(xgb_folds, rf_folds)
print(f'XGBoost mean: {xgb_folds.mean():.4f}')
print(f'Random Forest mean: {rf_folds.mean():.4f}')
print(f'Paired t-test: t={t_stat:.3f}, p={p_value:.4f}')
if p_value < 0.05:
print('Difference is statistically significant — prefer XGBoost.')
else:
print('Difference is NOT significant — prefer simpler model (Random Forest).')Evaluación única del conjunto de prueba
Después de seleccionar al ganador del torneo, evalúelo exactamente una vez con el conjunto de prueba reservado. Esta es la estimación de rendimiento imparcial que comunicará en la tarjeta del modelo. No optimice nunca los hiperparámetros después de consultar los resultados del conjunto de prueba, ya que hacerlo constituye una fuga de datos a través del proceso de evaluación. Si el AUC de prueba es sustancialmente inferior al AUC de la validación cruzada (más de 2 o 3 desviaciones estándar), investigue si existe sobreajuste o un cambio en la distribución entre las particiones de entrenamiento y prueba.
from sklearn.metrics import roc_auc_score, classification_report
# Fit winner on full training set
best_pipeline = xgb_pipe
best_pipeline.fit(X_train, y_train)
# One-time test evaluation
y_proba = best_pipeline.predict_proba(X_test)[:, 1]
y_pred = best_pipeline.predict(X_test)
test_auc = roc_auc_score(y_test, y_proba)
print(f'Test AUC: {test_auc:.4f}')
print('\nClassification report:')
print(classification_report(y_test, y_pred, target_names=['retained', 'churned']))Elección del ganador: más allá del AUC
El AUC no es el único criterio. Considere: la interpretabilidad (la regresión logística puede ser obligatoria para cumplir la normativa), el tiempo de entrenamiento (si se realiza un reentrenamiento semanal con 10 millones de filas, la ventaja de velocidad de XGBoost es importante), el consumo de memoria (una SVM que almacene 100 000 vectores de soporte puede superar el presupuesto de implementación) y la equidad (el modelo con mayor AUC puede presentar una peor paridad demográfica). El torneo selecciona el candidato; la preparación para la implementación es una decisión independiente basada en múltiples criterios.
# Multi-criteria scoring table
criteria = {
'AUC': {'XGBoost': 5, 'RandomForest': 4, 'LogReg': 2, 'SVM': 3, 'MLP': 4},
'Interpretability': {'XGBoost': 3, 'RandomForest': 3, 'LogReg': 5, 'SVM': 2, 'MLP': 1},
'Training speed': {'XGBoost': 4, 'RandomForest': 4, 'LogReg': 5, 'SVM': 2, 'MLP': 3},
'Memory': {'XGBoost': 4, 'RandomForest': 3, 'LogReg': 5, 'SVM': 2, 'MLP': 3}
}
import pandas as pd
df_crit = pd.DataFrame(criteria).T
df_crit.loc['Total'] = df_crit.sum()
print(df_crit)Comprobación rápida
Compruebe su comprensión de los conceptos de Machine Learning con Python de esta lección.
Resumen de la lección
En esta lección ha aprendido que: cada algoritmo debe integrarse en un Pipeline y evaluarse con folds de validación cruzada idénticos sobre el mismo conjunto de entrenamiento; la clasificación del torneo ordena los modelos por AUC media de la validación cruzada y utiliza una prueba de significación pareada para distinguir las diferencias reales del ruido; y el conjunto de prueba se utiliza exactamente una vez con el modelo ganador para producir la estimación honesta de rendimiento de la tarjeta del modelo. A continuación, empaquetaremos, documentaremos y presentaremos el modelo final para su implementación.
Aprende Python con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 30
- Lecciones
- 120
Preguntas frecuentes
¿La lección «Torneo de selección de modelos: comparación de cinco algoritmos» es gratis?
Sí — el texto completo de «Torneo de selección de modelos: comparación de cinco algoritmos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Machine Learning Academy, actualiza a CoddyKit PRO. El curso de Machine Learning Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Torneo de selección de modelos: comparación de cinco algoritmos»?
Entrenará regresión logística, random forest, XGBoost, SVM y una red neuronal dentro de pipelines con validación cruzada anidada, y tabulará el rendimiento en un conjunto de prueba compartido. Practicas Machine Learning Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Machine Learning Academy?
No se requiere experiencia previa. Machine Learning Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Torneo de selección de modelos: comparación de cinco algoritmos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Machine Learning Academy?
Sí. Cada lección de Machine Learning Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Definición del alcance del proyecto: problema y criterios de éxito
- Preparación de datos y análisis exploratorio
- Torneo de selección de modelos: comparación de cinco algoritmos
- Empaquetado, documentación y presentación del modelo final