Fundamentos de ML

Aprender, en ML, es ajustar los parámetros de una función para que cometa menos errores sobre datos que no ha visto. Todo el proceso se reduce a cuatro piezas: datos, modelo, pérdida y optimizador.

Las cuatro piezas

El problema de aprendizaje, formalmente

Sea $\mathcal{H}$ el espacio de hipótesis (todas las funciones que nuestro modelo puede representar). Buscamos:

Esta distinción es el corazón del ML: minimizar el error de entrenamiento es fácil (basta memorizar); lo difícil es generalizar. Todo el Módulo 3 gira alrededor de esa tensión.

El bucle de entrenamiento

# Pseudocódigo del bucle universal de entrenamiento
for epoca in range(num_epocas):
    for batch in data_loader:
        X, y = batch
        y_pred = modelo(X)                 # forward pass
        loss = perdida(y, y_pred)          # calcular error
        gradientes = calcular_gradiente(loss, parametros)  # backprop
        parametros -= learning_rate * gradientes           # actualizar
    validar(modelo, validacion)            # medir generalización

Este esqueleto es el mismo para una regresión logística, una CNN o un Transformer. Cambian el modelo, la pérdida y el optimizador; el ciclo es idéntico.

Una analogía útil: el tiro con arco

El modelo es el arco; los parámetros, la tensión y el ángulo; la pérdida, la distancia al centro; el optimizador, el ajuste tras cada flecha. Con una sola flecha no puedes calibrar; con muchas, corriges. Pero si solo practicas a una distancia fija, fallarás en otra: eso es overfitting.

Tipos de aprendizaje, otra vez

Un dataset es una tabla (o colección de archivos) donde cada fila es un ejemplo, cada columna una característica y, en aprendizaje supervisado, una columna especial es la etiqueta que queremos predecir.

Tipos de variables

Datasets públicos que usaremos

Calidad de datos: lo que mata proyectos

• Valores faltantes: ¿faltan al azar o sistemáticamente? Si faltan más en un grupo, imputar la media puede introducir sesgo.
• Duplicados: inflan el rendimiento si caen en train y test. Elimínalos antes de dividir.
• Outliers: pueden ser errores o señal. Investiga antes de recortar.
• Etiquetas ruidosas: un 5% de etiquetas mal puestas limita el techo de cualquier modelo.
• Desbalance: si una clase es el 1%, accuracy no sirve como métrica.
• Sesgo de selección: los datos reflejan cómo se recogieron, no necesariamente la población objetivo.

Cargar y dividir con Scikit-learn

from sklearn.datasets import load_iris, fetch_california_housing
from sklearn.model_selection import train_test_split

iris = load_iris(as_frame=True)
X, y = iris.data, iris.target
print(X.shape, y.shape)
print(iris.target_names)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
print("train:", X_train.shape, "test:", X_test.shape)

# Regresión: sin estratificar
housing = fetch_california_housing(as_frame=True)
Xh, yh = housing.data, housing.target
Xtr, Xte, ytr, yte = train_test_split(Xh, yh, test_size=0.2, random_state=42)

No puedes evaluar un modelo con los mismos datos con los que lo entrenaste. La separación de conjuntos es la garantía mínima de que estás midiendo generalización y no memorización.

Los tres conjuntos

Si el dataset es pequeño, la validación cruzada ($k$-fold) use el train completo para estimar el rendimiento y reserva el test para el final. Lo veremos en el Módulo 6.

Fuga de información (data leakage)

Ocurre cuando información del conjunto de validación o test se filtra al entrenamiento. Es la causa más común de resultados «demasiado buenos» que se desmoronan en producción.

Divisiones especiales

from sklearn.model_selection import (
    train_test_split, StratifiedKFold, TimeSeriesSplit, GroupKFold
)

# 1) Split estratificado (clasificación desbalanceada)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 2) Validación cruzada estratificada
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for fold, (tr_idx, va_idx) in enumerate(skf.split(X, y), 1):
    print(f"fold {fold}: train={len(tr_idx)}, val={len(va_idx)}")

# 3) Serie temporal: nunca mezclar pasado y futuro
tscv = TimeSeriesSplit(n_splits=5)

# 4) Por grupo (mismo paciente no se reparte entre splits)
# gkf = GroupKFold(n_splits=5)
# for tr, va in gkf.split(X, y, groups=patient_id):
#     ...

# 5) Test final: se toca una sola vez
# metricas_finales = evaluar(modelo_final, X_te, y_te)

Parámetros vs. hiperparámetros

Capacidad del modelo

La capacidad es la complejidad de las funciones que un modelo puede representar. Un polinomio de grado 1 tiene capacidad baja; uno de grado 20, alta. Una red con millones de pesos, altísima.

Modelos paramétricos y no paramétricos

• Paramétricos: tienen un número fijo de parámetros. Regresión lineal, regresión logística, Naive Bayes. Rápidos, interpretables, pero asumen una forma funcional.
• No paramétricos: el número de parámetros crece con los datos. KNN, árboles, SVM con kernel, procesos gaussianos. Más flexibles, pero pueden ser costosos y sobreajustar.

Hiperparámetros que más importan

Un ejemplo concreto: KNN

Con $k=1$, cada punto de entrenamiento es su propio vecino: la frontera pasa por todos los puntos y el error de entrenamiento es cero, pero el de test suele ser alto. Con $k=n$, todos predicen la clase mayoritaria: underfitting extremo. El valor óptimo está en medio y se encuentra con validación cruzada.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

for k in [1, 3, 5, 11, 21, 51]:
    modelo = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(modelo, X, y, cv=5, scoring="accuracy")
    print(f"k={k:2d}  accuracy={scores.mean():.3f} ± {scores.std():.3f}")

La curva típica de accuracy vs. $k$ tiene forma de U invertida. Ese es el compromiso sesgo–varianza en acción.

La función de pérdida define qué significa equivocarse. Elegirla mal puede hacer que un modelo optimice lo que no importa. No es un detalle técnico: es una decisión de diseño.

Pérdidas para regresión

Pérdidas para clasificación

La entropía cruzada es la pérdida estándar en clasificación porque proviene de maximizar la verosimilitud de la clase correcta. Para $K$ clases, el modelo produce un vector de probabilidades que suma 1.

Otras pérdidas

• Hinge: $\max(0,1-y\,f(x))$, usada en SVM; margen y clasificación correcta.
• Focal loss: modula la entropía cruzada para enfocarse en ejemplos difíciles; común en detección de objetos.
• Triplet / contrastiva: acerca representaciones de ejemplos similares y aleja las distintas; base de embeddings.
• Dice / IoU: segmentación de imágenes, donde el desbalance píxel a píxel es extremo.

Optimización: qué significa resolver

Minimizar una pérdida es un problema de optimización. Si la función es convexa, cualquier mínimo local es global. Si no, el resultado depende de la inicialización y del optimizador. En la práctica no buscamos el mínimo global exacto: buscamos un modelo que generalice bien.

import numpy as np

def mse(y, yp):
    return np.mean((y - yp) ** 2)

def mae(y, yp):
    return np.mean(np.abs(y - yp))

def huber(y, yp, delta=1.0):
    e = y - yp
    return np.mean(np.where(np.abs(e) <= delta,
                            0.5 * e**2,
                            delta * (np.abs(e) - 0.5 * delta)))

def bce(y, p, eps=1e-12):
    p = np.clip(p, eps, 1 - eps)
    return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))

y = np.array([1, 0, 1, 1])
p = np.array([0.9, 0.2, 0.8, 0.6])
print("BCE:", bce(y, p))       # 0.288

y_real = np.array([3., -0.5, 2., 7.])
y_pred = np.array([2.5, 0.0, 2., 8.])
print("MSE:", mse(y_real, y_pred))
print("MAE:", mae(y_real, y_pred))
print("Huber:", huber(y_real, y_pred))

Un modelo generaliza si funciona bien en datos nuevos. El overfitting es memorizar el ruido del entrenamiento; el underfitting es no capturar ni la señal. Entre ambos hay un equilibrio que se gestiona con capacidad y regularización.

Descomposición sesgo–varianza

Curvas de aprendizaje

Graficar el error de entrenamiento y validación en función de:

• El tamaño del entrenamiento: si ambas curvas convergen a un error alto, hay underfitting. Si hay una brecha grande, overfitting o necesidad de más datos.
• La complejidad del modelo: a mayor complejidad, el error de train baja siempre; el de validación baja y luego sube. El mínimo de validación es el punto óptimo.
• Las épocas: en redes, la validación empeora tras cierto punto; el early stopping corta ahí.

Regularización

Regularizar es añadir una penalización a la pérdida para limitar la complejidad de los parámetros:

from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import cross_val_score

# Importante: escalar antes de regularizar
for alpha in [0.001, 0.01, 0.1, 1, 10, 100]:
    ridge = make_pipeline(StandardScaler(), Ridge(alpha=alpha))
    lasso = make_pipeline(StandardScaler(), Lasso(alpha=alpha, max_iter=10_000))
    r = cross_val_score(ridge, X, y, cv=5, scoring="r2").mean()
    l = cross_val_score(lasso, X, y, cv=5, scoring="r2").mean()
    print(f"alpha={alpha:>6}  ridge={r:.3f}  lasso={l:.3f}")

# Inspeccionar coeficientes de Lasso
lasso = make_pipeline(StandardScaler(), Lasso(alpha=0.1)).fit(X, y)
coefs = lasso[-1].coef_
print("features con peso cero:", (coefs == 0).sum(), "de", len(coefs))

Un pipeline encadena transformaciones y un modelo final en un solo objeto. Garantiza que el preprocesamiento se ajuste solo con train, evita fugas y hace que el despliegue sea reproducible.

Flujo completo

1. Definir el problema y la métrica.
2. Cargar y auditar los datos.
3. Dividir train / validación / test.
4. Explorar solo el train (estadísticas, gráficos).
5. Construir el pipeline de preprocesamiento + modelo.
6. Validar con cross-validation y buscar hiperparámetros.
7. Entrenar el modelo final con train+validación.
8. Evaluar una vez en test.
9. Analizar errores e interpretar.
10. Serializar, desplegar y monitorear.

Pipeline con columnas numéricas y categóricas

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score

# Dataset de ejemplo (reemplaza por el tuyo)
from sklearn.datasets import fetch_openml
# titanic = fetch_openml("titanic", version=1, as_frame=True).frame

# Simulamos un DataFrame con columnas mixtas
rng = np.random.default_rng(42)
n = 400
df = pd.DataFrame({
    "edad": rng.normal(38, 12, n).round(),
    "tarifa": rng.lognormal(3, 1, n).round(2),
    "clase": rng.choice(["primera", "segunda", "tercera"], n),
    "puerto": rng.choice(["S", "C", "Q"], n),
    "sobrevivio": rng.integers(0, 2, n),
})
df.loc[rng.choice(n, 30), "edad"] = np.nan

X = df.drop(columns="sobrevivio")
y = df["sobrevivio"]

num_cols = ["edad", "tarifa"]
cat_cols = ["clase", "puerto"]

preprocesador = ColumnTransformer([
    ("num", Pipeline([
        ("imputar", SimpleImputer(strategy="median")),
        ("escalar", StandardScaler()),
    ]), num_cols),
    ("cat", Pipeline([
        ("imputar", SimpleImputer(strategy="most_frequent")),
        ("onehot", OneHotEncoder(handle_unknown="ignore")),
    ]), cat_cols),
])

pipeline = Pipeline([
    ("prep", preprocesador),
    ("modelo", RandomForestClassifier(random_state=42)),
])

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

parametros = {
    "modelo__n_estimators": [100, 300],
    "modelo__max_depth": [None, 5, 10],
    "modelo__min_samples_leaf": [1, 3, 5],
}

busqueda = GridSearchCV(pipeline, parametros, cv=5, scoring="roc_auc", n_jobs=-1)
busqueda.fit(X_train, y_train)

print("mejores params:", busqueda.best_params_)
print("mejor CV AUC:", round(busqueda.best_score_, 3))

y_pred = busqueda.predict(X_test)
y_prob = busqueda.predict_proba(X_test)[:, 1]
print(classification_report(y_test, y_pred))
print("AUC test:", round(roc_auc_score(y_test, y_prob), 3))

Errores frecuentes en el pipeline

• Escalar o imputar antes de dividir.
• Incluir el ID como feature.
• Usar la etiqueta para construir una feature.
• Evaluar en test más de una vez y ajustar decisiones con esa información.
• No versionar el pipeline: el modelo serializado debe incluir el preprocesamiento.
• Entrenar con una distribución y desplegar en otra sin monitoreo.

Línea base: el modelo que debes superar

Siempre empieza con una baseline. En clasificación, predecir la clase mayoritaria; en regresión, predecir la media. Si tu modelo complejo no supera claramente la baseline, no justifica su costo. Documenta la mejora con intervalos de confianza.