Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/HelenDiMo/pildora-bootcamp-preprocesamiento/llms.txt

Use this file to discover all available pages before exploring further.

XGBoost (eXtreme Gradient Boosting) construye árboles de forma secuencial: cada nuevo árbol se entrena para corregir los errores residuales del ensemble acumulado hasta ese momento. A diferencia del Bagging paralelo de Random Forest, este enfoque convierte gradualmente un predictor débil en uno muy preciso, iteración a iteración. En versiones modernas, XGBClassifier acepta etiquetas de texto directamente para clasificación multi-clase, por lo que la función train_xgboost puede recibir las etiquetas originales de especie sin ninguna transformación previa.

​
Función train_xgboost

La función train_xgboost construye y ajusta un Pipeline que combina el preprocesador con un XGBClassifier configurado para clasificación multi-clase: 
from sklearn.pipeline import Pipeline
from xgboost import XGBClassifier

def train_xgboost(preprocessor, X_train, y_train):
    xgb = Pipeline([
        ('preprocessor', preprocessor),
        ('model', XGBClassifier(
            n_estimators=200,
            max_depth=4,
            learning_rate=0.1,
            random_state=42,
            eval_metric='mlogloss'
        ))
    ])
    xgb.fit(X_train, y_train)
    return xgb
Parámetros:
ParámetroTipoDescripción
preprocessorColumnTransformerObjeto construido por build_preprocessor(). Gestiona imputación y codificación de columnas numéricas y categóricas.
X_trainpd.DataFrameConjunto de entrenamiento con las columnas de características del dataset.
y_trainpd.SeriesVariable objetivo con las etiquetas de especie originales: 'Adelie', 'Chinstrap' o 'Gentoo'. XGBClassifier acepta etiquetas de texto directamente en clasificación multi-clase.
Retorna: un sklearn.pipeline.Pipeline ajustado con los pasos 'preprocessor' y 'model'.
eval_metric='mlogloss' especifica explícitamente la métrica interna de evaluación como multi-class log loss, suprimiendo el aviso de deprecación que XGBoost emite cuando la métrica se selecciona automáticamente para problemas multi-clase.

​
Uso y evaluación

Con las etiquetas de texto originales, puedes entrenar el pipeline y evaluar directamente con nombres de especie legibles: 
from sklearn.metrics import accuracy_score, classification_report, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

xgb_pipeline = train_xgboost(preprocessor, X_train, y_train)
xgb_preds = xgb_pipeline.predict(X_test)

print("Accuracy:", accuracy_score(y_test, xgb_preds))
print(classification_report(y_test, xgb_preds))

fig, ax = plt.subplots()
ConfusionMatrixDisplay.from_predictions(y_test, xgb_preds, ax=ax, cmap="plasma")
plt.show()
Dado que train_xgboost trabaja con las etiquetas originales, xgb_pipeline.predict(X_test) devuelve directamente las cadenas de texto 'Adelie', 'Chinstrap' y 'Gentoo', lo que hace que el reporte de clasificación y la matriz de confusión sean inmediatamente legibles sin ningún paso adicional de decodificación.

​
Hiperparámetros clave

ParámetroValor usadoDescripción
n_estimators200Número de árboles en el ensemble secuencial.
max_depth4Profundidad máxima de cada árbol. Limitar la profundidad previene el sobreajuste y reduce el coste computacional.
learning_rate0.1Contribución de cada árbol a la predicción acumulada. Valores más bajos mejoran la generalización a costa de requerir más árboles.
random_state42Semilla del generador de aleatoriedad para reproducibilidad.
eval_metric'mlogloss'Métrica interna de evaluación durante el entrenamiento: multi-class log loss.

​
LabelEncoder en la aplicación Streamlit

La aplicación Streamlit (Sección 6) construye su propio pipeline inline — sin llamar a train_xgboost — y sí utiliza un LabelEncoder antes de entrenar: 
from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)  # 'Adelie' -> 0, 'Chinstrap' -> 1, 'Gentoo' -> 2
y_test_enc  = le.transform(y_test)

xgb_pipeline.fit(X_train, y_train_enc)
xgb_preds = xgb_pipeline.predict(X_test)

# Decode back to species names for readable reports
preds_decoded = le.inverse_transform(xgb_preds)
Este patrón es válido y produce resultados idénticos, pero es independiente de la función train_xgboost definida en models.py. Si usas train_xgboost directamente, no necesitas codificar las etiquetas — pasa y_train con los nombres de especie originales tal como los devuelve encoding().
Si optas por el patrón con LabelEncoder, ajústalo siempre solo sobre y_train mediante fit_transform. Sobre y_test usa únicamente transform. Ajustar el codificador sobre y_test constituye una fuga de datos (data leakage) que inflaría artificialmente las métricas.

Build docs developers (and LLMs) love

Get started for freeTalk to us