Aprendizaje supervisado

📐 Fundamento

Definición formal:

Dado un conjunto de entrenamiento ${(\mathbf{x}$i, y_i)}{i=1}^{n} donde:

• $\mathbf{x}_i \in \mathbb{R}^d$ es el vector de características (features)
• $y_i$ es la etiqueta (label)

El objetivo es aprender una función $f: \mathbb{R}^d \to \mathcal{Y}$ tal que $f(\mathbf{x}) \approx y$ para ejemplos nuevos.

Tipos de problemas:

El pipeline estándar:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 1. Cargar datos
df = pd.read_csv('historial_pedidos.csv')
X = df[['hora_dia', 'num_personas', 'gasto_previo', 'es_fin_semana']]
y = df['pidio_postre']  # 0 o 1

# 2. Dividir en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Escalar features (muchos modelos lo necesitan)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # aprende media/std del train
X_test_scaled = scaler.transform(X_test)        # aplica la misma escala

# 4. Entrenar modelo
# 5. Evaluar

Por qué dividir train/test:

Si evaluamos el modelo en los mismos datos con que entrenó, no sabemos si generalizó o simplemente memorizó. El test set simula datos nunca vistos — cómo se comportará en producción.

📐 Fundamento

Algoritmo KNN:

from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

# Entrenar (KNN no "aprende" — simplemente guarda los datos)
knn = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
knn.fit(X_train_scaled, y_train)

# Predecir
y_pred = knn.predict(X_test_scaled)

# Evaluar
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2%}")
print(classification_report(y_test, y_pred, target_names=['No postre', 'Sí postre']))

Distancias:

Efecto del hiperparámetro K:

Elegir K con validación cruzada:

from sklearn.model_selection import cross_val_score

for k in range(1, 21):
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, X_train_scaled, y_train, cv=5, scoring='accuracy')
    print(f"K={k:2d}: {scores.mean():.3f} ± {scores.std():.3f}")
# Elegir K con el mejor promedio

Problemas de KNN:

• Lento en predicción: Necesita calcular distancia a todos los puntos de entrenamiento → O(n·d).
• Maldición de la dimensionalidad: Con muchas features, todas las distancias se vuelven similares.
• No maneja bien features irrelevantes.

Solución: KD-Tree o Ball-Tree para acelerar la búsqueda de vecinos. Selección de features antes de KNN.

📐 Fundamento

Construcción del árbol — ID3/CART:

El árbol se construye eligiendo en cada nodo el feature que mejor separa los datos según una métrica de impureza:

Entropía (ID3):

Entropía 0 = todos los ejemplos son de la misma clase (perfecto).
Entropía 1 = mitad de cada clase (impuro).

Ganancia de información:

Se elige el feature A con mayor ganancia de información.

Índice Gini (CART — scikit-learn por defecto):

from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

# Entrenar
tree = DecisionTreeClassifier(
    max_depth=4,          # limitar profundidad para evitar overfitting
    min_samples_leaf=10,  # cada hoja tiene al menos 10 ejemplos
    random_state=42
)
tree.fit(X_train, y_train)

# Visualizar
plt.figure(figsize=(15, 8))
plot_tree(tree, feature_names=X.columns, class_names=['No', 'Sí'], filled=True)
plt.savefig('arbol_decision.png')

# Ver las reglas aprendidas
from sklearn.tree import export_text
print(export_text(tree, feature_names=list(X.columns)))

Overfitting en árboles:

Un árbol sin restricciones crece hasta memorizar cada ejemplo de entrenamiento (accuracy = 100% en train, malo en test). Técnicas de regularización:

1. Limitar max_depth — profundidad máxima.
2. Aumentar min_samples_split — mínimo de ejemplos para dividir un nodo.
3. Post-pruning — crecer el árbol completo y luego podar las ramas que no mejoran la validación.

📐 Fundamento

Diagnóstico gráfico (curva de aprendizaje):

from sklearn.model_selection import learning_curve
import numpy as np

train_sizes, train_scores, val_scores = learning_curve(
    DecisionTreeClassifier(max_depth=4),
    X_train_scaled, y_train,
    cv=5, train_sizes=np.linspace(0.1, 1.0, 10)
)

# Graficar
plt.plot(train_sizes, train_scores.mean(axis=1), label='Train')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validación')
plt.xlabel('Tamaño del training set')
plt.ylabel('Accuracy')
plt.legend()

Validación cruzada (k-fold cross validation):

from sklearn.model_selection import cross_validate

resultados = cross_validate(
    DecisionTreeClassifier(max_depth=4),
    X, y,
    cv=5,
    scoring=['accuracy', 'f1', 'roc_auc'],
    return_train_score=True
)
print(f"Val accuracy: {resultados['test_accuracy'].mean():.3f}")
print(f"Train accuracy: {resultados['train_accuracy'].mean():.3f}")

Métricas de clasificación:

                  Predicho +    Predicho -
Real +    │  TP (True Pos) │  FN (False Neg) │
Real -    │  FP (False Pos) │ TN (True Neg)  │

Accuracy  = (TP + TN) / Total
Precision = TP / (TP + FP)   — de los que predije +, ¿cuántos eran +?
Recall    = TP / (TP + FN)   — de los que son +, ¿cuántos predije +?
F1        = 2 * (Precision * Recall) / (Precision + Recall)

Cuándo usar Precision vs Recall:

• Alta Precision: cuando un FP es muy costoso (spam filter — no queremos marcar email válido como spam).
• Alto Recall: cuando un FN es muy costoso (diagnóstico de cáncer — no queremos perder un caso real).