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.

La etapa final del pipeline de preprocesamiento prepara los datos en el formato exacto que requieren los algoritmos de scikit-learn y XGBoost. Antes de entrenar cualquier modelo es necesario completar tres pasos: separar las features de la variable objetivo, construir el ColumnTransformer que imputa nulos y codifica variables categóricas, y dividir el dataset en conjuntos de entrenamiento y test preservando la proporción de clases. Las tres funciones de app/logic/preprocessing.py encapsulan estas responsabilidades de forma modular y reproducible.

​
Función encoding

encoding separa el dataframe en la matriz de features X y el vector objetivo y, y define explícitamente las listas de columnas numéricas y categóricas que el preprocesador necesita conocer: 
def encoding(df):
    num_cols = ['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm', 'body_mass_g', 'bill_ratio']
    cat_cols = ['island', 'sex']

    X = df[num_cols + cat_cols]
    y = df['species']

    return X, y, num_cols, cat_cols
Firma: encoding(df) → tuple[pd.DataFrame, pd.Series, list, list]
ParámetroTipoDescripción
dfpd.DataFrameDataframe con las 8 columnas (incluyendo bill_ratio)
Valores de retorno:
VariableTipoDescripción
Xpd.DataFrame7 columnas de features (5 numéricas + 2 categóricas)
ypd.SeriesVariable objetivo: species (Adelie / Chinstrap / Gentoo)
num_colslist[str]Lista de nombres de columnas numéricas
cat_colslist[str]Lista de nombres de columnas categóricas

​
Función split_train_test

split_train_test divide los datos en conjuntos de entrenamiento y test usando los parámetros canónicos del módulo: 
def split_train_test(X, y):
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42, stratify=y
    )
    return X_train, X_test, y_train, y_test
Firma: split_train_test(X, y) → tuple[pd.DataFrame, pd.DataFrame, pd.Series, pd.Series] Los parámetros clave de train_test_split son:
  • test_size=0.2: el 20 % de los datos (≈69 filas) se reservan para test; el 80 % (≈275 filas) se usan para entrenamiento.
  • random_state=42: fija la semilla aleatoria para garantizar reproducibilidad — la misma división en cada ejecución.
  • stratify=y: asegura que la proporción de cada clase (Adelie, Chinstrap, Gentoo) sea idéntica en train y en test. Sin este parámetro, una división aleatoria podría sobrerrepresentar o infrarrepresentar a Chinstrap (la clase minoritaria con solo 68 ejemplares).

​
Función build_preprocessor

build_preprocessor construye el ColumnTransformer de scikit-learn que agrupa las transformaciones de las columnas numéricas y categóricas en un único objeto: 
def build_preprocessor(num_cols, cat_cols):
    preprocessor = ColumnTransformer([
        ('num', SimpleImputer(strategy='median'), num_cols),
        ('cat', Pipeline([
            ('imputer', SimpleImputer(strategy='most_frequent')),
            ('onehot', OneHotEncoder(handle_unknown='ignore'))
        ]), cat_cols)
    ])
    return preprocessor
Firma: build_preprocessor(num_cols, cat_cols) → ColumnTransformer El ColumnTransformer aplica dos sub-pipelines en paralelo: Pipeline numérico ('num') SimpleImputer(strategy='median') sustituye los valores nulos de las 5 columnas numéricas con la mediana de cada columna calculada sobre el conjunto de entrenamiento. La mediana es preferible a la media porque es robusta frente a outliers: en columnas como bill_length_mm, un valor extremo no desplazará el valor de imputación. Pipeline categórico ('cat') Se ejecutan dos pasos en secuencia:
  1. SimpleImputer(strategy='most_frequent'): rellena los 11 nulos de la columna sex con el valor más frecuente (la moda) calculado sobre el conjunto de entrenamiento.
  2. OneHotEncoder(handle_unknown='ignore'): codifica island (3 categorías → 3 columnas binarias) y sex (2 categorías → 2 columnas binarias) como variables dummy. El parámetro handle_unknown='ignore' hace que las categorías no vistas durante el entrenamiento se codifiquen como un vector de ceros en lugar de lanzar un error.

​
Uso conjunto

El flujo completo de las tres funciones se encadena de la siguiente forma: 
from app.logic.preprocessing import encoding, split_train_test, build_preprocessor

X, y, num_cols, cat_cols = encoding(df)
X_train, X_test, y_train, y_test = split_train_test(X, y)
preprocessor = build_preprocessor(num_cols, cat_cols)

print('Train:', X_train.shape)  # (275, 7)
print('Test:', X_test.shape)    # (69, 7)
El preprocessor resultante se integra como primer paso en un Pipeline de scikit-learn junto con el clasificador: 
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier

pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(random_state=42))
])

pipeline.fit(X_train, y_train)
score = pipeline.score(X_test, y_test)
print(f"Accuracy: {score:.4f}")
build_preprocessor devuelve un ColumnTransformer que todavía no ha sido ajustado. Las estadísticas de imputación (mediana de cada columna numérica, moda de sex) se calculan únicamente cuando se llama a pipeline.fit(X_train, y_train). El preprocesador aprende esos valores exclusivamente del conjunto de entrenamiento para evitar data leakage desde el test set.
El parámetro handle_unknown='ignore' en OneHotEncoder es crítico. Sin él, si el conjunto de test contiene una categoría no vista durante el entrenamiento (por ejemplo, si una combinación de sex queda fuera del train en una partición aleatoria), scikit-learn lanzará un ValueError en tiempo de predicción. En datasets pequeños como Palmer Penguins, este escenario es perfectamente posible con la columna sex y divisiones aleatorias de diferente semilla.

Build docs developers (and LLMs) love

Get started for freeTalk to us