Preparar datos: limpieza, variables y pipelines

1. Por el propio valor: los que faltan son justamente los ingresos altos. Rellenar con la mediana los convierte en ingresos normales y el promedio de la encuesta queda más bajo que el real. Ningún relleno lo arregla del todo; al menos conviene marcar con una columna aparte (add_indicator=True) que el dato faltaba, porque eso ya es información.
2. Al azar: que falte no dice nada del estudiante. Rellenar con la mediana es razonable; solo hace la columna un poco más «picuda».
3. Por algo que sí vemos: depende de la hora de llegada. Si los pacientes de la noche son distintos (por ejemplo, llegan más graves), rellenar con la mediana de todos los hace parecer más sanos. Una mejora es rellenar con la mediana de los pacientes de su mismo turno, siempre calculada solo con el entrenamiento.

• Media: (3000 + 3200 + 3500 + 3800 + 4000 + 45 000) / 6 = 62 500 / 6 ≈ 10 417 Bs.
• Mediana: con seis valores ordenados, el promedio de los dos del medio, (3500 + 3800) / 2 = 3650 Bs.

Rellenaría con la mediana. El sueldo de 45 000 (quizás el del jefe) arrastra la media hasta casi el triple de lo que gana cualquiera de los otros cinco: la media no describe a nadie de la oficina.

sueldos = pd.DataFrame(
    {"sueldo": [3000, 3200, 3500, 3800, 4000, 45000, np.nan]})
for estrategia in ["mean", "median"]:
    imp = SimpleImputer(strategy=estrategia).fit(sueldos)
    relleno = imp.transform(sueldos)[-1, 0]
    print(f"{estrategia:6}: rellena con {relleno:.0f}")

mean  : rellena con 10417
median: rellena con 3650

SimpleImputer ignora el faltante al calcular, como hiciste a mano.

1. One-hot: los departamentos no tienen orden. Numerarlos de 1 a 9 diría, por ejemplo, que Pando está «más lejos» de La Paz que Oruro solo por el número que les tocó. Son 9 columnas nuevas.
2. Número: S, M, L y XL tienen un orden claro (variable ordinal), así que 1, 2, 3 y 4 respetan algo real. One-hot también funcionaría, pero perdería ese orden.
3. One-hot: nominal, sin orden.
4. Número: es ordinal y además los pasos son parejos (de un curso al siguiente hay un año), así que 1 a 6 funciona muy bien.

1. Media = 50 / 5 = 10. Las diferencias con la media son −8, −6, −4, −2 y 20; sus cuadrados suman 64 + 36 + 16 + 4 + 400 = 520, la varianza es 520 / 5 = 104 y la desviación √104 ≈ 10,2. Estandarizados: −0,78, −0,59, −0,39, −0,20 y 1,96.
2. Mínimo 2 y máximo 30, así que se divide por 28: 0, 0,07, 0,14, 0,21 y 1.
3. Con la normalización, los cuatro primeros quedan apretados entre 0 y 0,21: el 30, un atípico, se queda con casi todo el rango. Con la estandarización también quedan juntos, pero al menos centrados cerca de 0 y sin un techo fijo.

v = np.array([[2], [4], [6], [8], [30]])
print("Estandarizados:", StandardScaler().fit_transform(v).ravel().round(2))
print("Normalizados:  ", MinMaxScaler().fit_transform(v).ravel().round(2))

Estandarizados: [-0.78 -0.59 -0.39 -0.2   1.96]
Normalizados:   [0.   0.07 0.14 0.21 1.  ]

La mediana con que rellena y la media y la desviación con que estandariza se calculan con todos los pasajeros, incluidos los de prueba, y recién después divide. La prueba influyó en la preparación. La corrección es dividir primero y meter la preparación en un pipeline, que la ajusta solo con el entrenamiento:

columnas_num = ["pclass", "age", "sibsp", "parch", "fare"]
knn_bien = Pipeline([
    ("imputar", SimpleImputer(strategy="median")),
    ("escalar", StandardScaler()),
    ("modelo", KNeighborsClassifier(n_neighbors=5))])
knn_bien.fit(X_ent[columnas_num], y_ent)
exactitud = knn_bien.score(X_prueba[columnas_num], y_prueba)
print(f"Exactitud: {exactitud:.3f}")

Exactitud: 0.709

Esta vez la diferencia es chica (y hasta a favor de la versión correcta), como viste en la teoría: con 891 pasajeros, una mediana y una media casi no cambian. Pero la primera versión no es confiable por cómo está hecha, no por el número que dio, y el mismo hábito con un paso que mira la respuesta infla el puntaje muchísimo.

La columna alive es la respuesta escrita con palabras: vale "yes" exactamente cuando survived vale 1. El modelo no aprendió nada del Titanic, solo a leer la respuesta en otra columna. Se comprueba en una línea:

print(pd.crosstab(titanic["alive"], titanic["survived"]))

survived    0    1
alive             
no        549    0
yes         0  342

Esta es la fuga por la respuesta (en inglés, target leakage): una columna que en la vida real no conocerías al momento de predecir, porque se anota después o es una copia de lo que quieres predecir. Pasa también con columnas menos obvias, como «días de internación» para predecir si un paciente se enfermará. Un resultado demasiado bueno para ser cierto casi siempre es una fuga. La corrección es sacar alive de las columnas.

El pipeline está bien armado, pero el conjunto de prueba se usó para elegir k: se probaron siete modelos y se quedó el que mejor salió en la prueba. Parte de esa ventaja es suerte con esos 223 pasajeros, así que el 0,816 es optimista. Es la fuga del tema 7: la prueba se usa una sola vez, al final. La corrección es elegir k con validación cruzada sobre el entrenamiento y recién después mirar la prueba:

buscar_k = GridSearchCV(
    crear_pipeline_titanic(KNeighborsClassifier()),
    {"modelo__n_neighbors": [1, 3, 5, 9, 15, 25, 41]}, cv=pliegues)
buscar_k.fit(X_ent, y_ent)
print("k elegido con validación:", buscar_k.best_params_)
print(f"Validación: {buscar_k.best_score_:.3f}"
      f"   prueba: {buscar_k.score(X_prueba, y_prueba):.3f}")

k elegido con validación: {'modelo__n_neighbors': 25}
Validación: 0.814   prueba: 0.794

La validación elige otro k, y la prueba, usada una sola vez, da un número honesto. Que el número honesto sea más bajo no es un error: es la verdad que el primer código escondía.

X_deck = agregar_variables(titanic)[
    ["pclass", "sex", "age", "sibsp", "parch", "fare", "embarked",
     "deck"]]
# Las mismas filas de entrenamiento que en la teoría
Xd_ent = X_deck.loc[X_ent.index]
# deck es de tipo categoría; como texto, admite el relleno nuevo
Xd_ent = Xd_ent.astype({"deck": "object"})

mi_prep = ColumnTransformer([
    ("edad", Pipeline([
        ("imputar", SimpleImputer(strategy="median",
                                  add_indicator=True)),
        ("escalar", StandardScaler())]), ["age"]),
    ("num", Pipeline([
        ("imputar", SimpleImputer(strategy="median")),
        ("escalar", StandardScaler())]),
     ["pclass", "sibsp", "parch", "fare"]),
    ("cubierta", Pipeline([
        ("imputar", SimpleImputer(strategy="constant",
                                  fill_value="sin dato")),
        ("onehot", OneHotEncoder(handle_unknown="ignore"))]), ["deck"]),
    ("cat", Pipeline([
        ("imputar", SimpleImputer(strategy="most_frequent")),
        ("onehot", OneHotEncoder(handle_unknown="ignore"))]),
     ["sex", "embarked"])])
mi_pipe = Pipeline([("preparar", mi_prep),
                    ("modelo", LogisticRegression(max_iter=1000))])

mio = cross_val_score(mi_pipe, Xd_ent, y_ent, cv=pliegues)
tema = cross_val_score(
    crear_pipeline_titanic(LogisticRegression(max_iter=1000)),
    X_ent, y_ent, cv=pliegues)
print(f"Con deck e indicador: {mio.mean():.3f} ± {mio.std():.3f}")
print(f"Pipeline del tema:    {tema.mean():.3f} ± {tema.std():.3f}")
print(mi_pipe.fit(Xd_ent, y_ent).named_steps["preparar"]
      .get_feature_names_out()[:4])

Con deck e indicador: 0.807 ± 0.033
Pipeline del tema:    0.823 ± 0.032
['edad__age' 'edad__missingindicator_age' 'num__pclass' 'num__sibsp']

Fíjate en tres cosas: el indicador aparece como una columna más (edad__missingindicator_age); strategy="constant" convierte el faltante en una categoría más, que one-hot trata como cualquier otra; y la cubierta no mejoró la validación. Con la clase del pasaje ya en el modelo, saber si falta la cubierta agrega poco: los dos datos cuentan casi la misma historia.

from scipy.stats import kurtosis

modelo_l = Pipeline([
    ("escalar", StandardScaler()),
    ("modelo", LogisticRegression(max_iter=1000))])

crudas = cross_val_score(modelo_l, lecturas, falla, cv=pliegues)

momentos = np.column_stack([
    lecturas.mean(axis=1),
    lecturas.std(axis=1),
    np.abs(lecturas).max(axis=1),
    kurtosis(lecturas, axis=1)])
resumidas = cross_val_score(modelo_l, momentos, falla, cv=pliegues)
print(f"50 lecturas crudas:    {crudas.mean():.3f}")
print(f"4 momentos por fila:   {resumidas.mean():.3f}")

50 lecturas crudas:    0.500
4 momentos por fila:   0.840

Con las lecturas crudas, el modelo no aprende nada (acierta como una moneda): un sacudón puede caer en cualquier columna, y para la regresión logística cada columna es una variable distinta con su propio peso. Los momentos estadísticos resumen la forma de las 50 lecturas sin importar en qué momento pasó cada sacudón, y con eso el modelo acierta el 84 %, contra el 50 % de las lecturas crudas. Calcularlos no produce fuga: cada fila usa solo sus propias lecturas.

La rejilla tiene 6 × 2 × 3 = 36 combinaciones; con 5 pliegues son 36 × 5 = 180 entrenamientos, más uno final con todo el entrenamiento y la mejor combinación (refit). La búsqueda aleatoria con n_iter=10 hace 10 × 5 = 50, más el final.

from sklearn.model_selection import ParameterGrid

rejilla_grande = {
    "modelo__C": [0.001, 0.01, 0.1, 1, 10, 100],
    "preparar__num__imputar__strategy": ["mean", "median"],
    "preparar__num__escalar": [StandardScaler(), MinMaxScaler(),
                               "passthrough"]}
combinaciones = len(ParameterGrid(rejilla_grande))
print("Combinaciones:", combinaciones,
      "  entrenamientos:", combinaciones * 5 + 1)

Combinaciones: 36   entrenamientos: 181

Cada hiperparámetro nuevo multiplica el costo de la rejilla. Por eso, cuando hay más de dos o tres, conviene la búsqueda aleatoria.

from sklearn.metrics import confusion_matrix

sns.load_dataset("penguins").to_csv("pinguinos.csv", index=False)
pinguinos = pd.read_csv("pinguinos.csv")
print(pinguinos.isna().sum().to_string())
pinguinos = pinguinos.dropna(subset=["sex"])
print("Filas con sexo:", len(pinguinos))

medidas = ["bill_length_mm", "bill_depth_mm", "flipper_length_mm",
           "body_mass_g"]
P = pinguinos[medidas + ["species", "island"]]
s = pinguinos["sex"]
P_ent, P_prueba, s_ent, s_prueba = train_test_split(
    P, s, test_size=0.25, stratify=s, random_state=0)

prep_ping = ColumnTransformer([
    ("num", prep_numericas, medidas),
    ("cat", prep_categoricas, ["species", "island"])])
candidatos = {
    "logística": (LogisticRegression(max_iter=1000),
                  {"modelo__C": [0.01, 0.1, 1, 10, 100]}),
    "vecinos": (KNeighborsClassifier(),
                {"modelo__n_neighbors": [1, 3, 5, 9, 15, 25]})}
mejores = {}
for nombre, (modelo, grilla) in candidatos.items():
    pipe = Pipeline([("preparar", prep_ping), ("modelo", modelo)])
    b = GridSearchCV(pipe, grilla, cv=pliegues).fit(P_ent, s_ent)
    mejores[nombre] = b
    print(f"{nombre:10} {b.best_params_}  validación = "
          f"{b.best_score_:.3f}")

ganador = max(mejores.values(), key=lambda b: b.best_score_)
pred = ganador.predict(P_prueba)
print(f"Prueba: {ganador.score(P_prueba, s_prueba):.3f}")
print(confusion_matrix(s_prueba, pred))
print(classification_report(s_prueba, pred))

species               0
island                0
bill_length_mm        2
bill_depth_mm         2
flipper_length_mm     2
body_mass_g           2
sex                  11
Filas con sexo: 333
logística  {'modelo__C': 10}  validación = 0.911
vecinos    {'modelo__n_neighbors': 5}  validación = 0.908
Prueba: 0.905
[[38  4]
 [ 4 38]]
              precision    recall  f1-score   support

      Female       0.90      0.90      0.90        42
        Male       0.90      0.90      0.90        42

    accuracy                           0.90        84
   macro avg       0.90      0.90      0.90        84
weighted avg       0.90      0.90      0.90        84

• Faltantes: 11 pingüinos sin sexo (se sacan: es la respuesta) y 2 sin medidas. Esos dos también tienen el sexo vacío, así que al sacar las 11 filas ya no queda ningún faltante; el imputador del pipeline igual queda listo por si llega un pingüino incompleto.
• Ganador: la regresión logística con C = 10, con 91,1 % en validación, casi empatada con los vecinos cercanos (k = 5, 90,8 %): una diferencia así no permite decir que un modelo sea mejor que el otro. En prueba acierta el 90,5 %, muy parecido a la validación, y se equivoca por igual con hembras y machos (4 de 42 en cada grupo). Con solo 84 pingüinos de prueba, cada uno vale más de un punto.
• Advertencia: el modelo vio tres especies de tres islas de la Antártida. Con otra especie, de otro tamaño, las medidas que separan machos de hembras serían otras.