Aprendizaje Supervisado

El aprendizaje supervisado mapea características de entrada a etiquetas conocidas. La regresión predice valores continuos; la clasificación asigna categorías discretas. sklearn proporciona una API coherente entre algoritmos.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

from sklearn.linear_model import Ridge, LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingRegressor
 
# Clasificación
clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)
 
# Regresión
reg = Ridge(alpha=1.0)
reg.fit(X_train, y_train)

Cuándo usar esto:

• Predicción de un resultado numérico (precio, demanda, latencia) - regresión.
• Asignación de categorías (abandono, fraude, sentimiento) - clasificación.
• Datos tabulares con ejemplos de entrenamiento etiquetados.
• Modelado de línea base antes de la optimización de deep learning o gradient boosting.

Ejemplo de Trabajo

"""supervised_learning.py - regresión y clasificación con sklearn."""
from __future__ import annotations
 
import pandas as pd
from sklearn.datasets import fetch_california_housing, load_breast_cancer
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.linear_model import LogisticRegression, Ridge
from sklearn.metrics import mean_absolute_error, roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
 
# --- Clasificación ---
cancer = load_breast_cancer(as_frame=True)
Xc, yc = cancer.data, cancer.target
Xc_train, Xc_test, yc_train, yc_test = train_test_split(Xc, yc, test_size=0.2, random_state=42)
 
clf_pipe = Pipeline([
    ("scale", StandardScaler()),
    ("clf", LogisticRegression(max_iter=1000, random_state=42)),
])
clf_pipe.fit(Xc_train, yc_train)
proba = clf_pipe.predict_proba(Xc_test)[:, 1]
print("AUC de clasificación:", roc_auc_score(yc_test, proba))
 
# --- Regresión ---
housing = fetch_california_housing(as_frame=True)
Xr, yr = housing.data, housing.target
Xr_train, Xr_test, yr_train, yr_test = train_test_split(Xr, yr, test_size=0.2, random_state=42)
 
reg = RandomForestRegressor(n_estimators=200, random_state=42, n_jobs=-1)
reg.fit(Xr_train, yr_train)
print("MAE de regresión:", mean_absolute_error(yr_test, reg.predict(Xr_test)))

Lo que esto demuestra:

• Misma API fit/predict para regresión y clasificación.
• Escalado antes de la regresión logística; los modelos de árbol omiten el escalado.
• Salidas de probabilidad para métricas de clasificación de ranking.
• MAE como métrica de regresión interpretable (dólares, unidades).

Inmersión Profunda

Cómo Funciona

• Entrenamiento minimiza una función de pérdida sobre ejemplos etiquetados (pérdida logarítmica, MSE, pérdida de bisagra).
• Los modelos lineales aprenden sumas ponderadas de características; rápidos e interpretables.
• Los conjuntos de árboles particionan el espacio de características con divisiones alineadas con los ejes; capturan interacciones no lineales.
• La regularización (L1/L2) penaliza los pesos grandes para reducir el sobreajuste.
• La complejidad del límite de decisión crece con la capacidad del modelo: equilibra con métricas de validación.

Selección de Algoritmos

Notas de Python

from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
 
# SVM: potente con características escaladas, más lento en datos grandes
svm = Pipeline([("scale", StandardScaler()), ("clf", SVC(probability=True))])
 
# k-NN: aprendiz perezoso, sensible a la escala y dimensionalidad
knn = Pipeline([("scale", StandardScaler()), ("clf", KNeighborsClassifier(n_neighbors=5))])

Trampas

• Usar métricas de clasificación para regresión - la precisión en objetivos continuos no tiene sentido. Solución: MAE, RMSE, R-cuadrado para regresión.
• No escalar para SVM/k-NN/regresión logística - los métodos de distancia y gradiente fallan en características no escaladas. Solución: StandardScaler en un pipeline.
• Ignorar el desequilibrio de clases - la precisión parece buena mientras el modelo predice la clase mayoritaria. Solución: F1, ROC-AUC o remuestreo.
• Sobreajuste con árboles profundos - max_depth=None memoriza ruido en datos pequeños. Solución: limitar la profundidad, aumentar min_samples_leaf, usar CV.
• Multicolinealidad en regresión lineal - coeficientes inestables con características correlacionadas. Solución: regresión Ridge o selección de características.
• Predecir sin predict_proba - algunos modelos necesitan probability=True (SVC) para salidas de probabilidad. Solución: verificar el soporte del estimador antes de usar proba.

Alternativas

Preguntas Frecuentes

LogisticRegression(multi_class="multinomial", max_iter=1000)
# o
RandomForestClassifier()  # maneja multiclase de forma nativa

for name, imp in zip(feature_names, reg.feature_importances_):
    print(f"{name}: {imp:.3f}")

Relacionados

• Evaluación de Modelos - elegir las métricas correctas
• Ingeniería de Características - preprocesamiento por algoritmo
• Gradient Boosting - XGBoost y LightGBM
• Optimización de Hiperparámetros - optimizar parámetros del modelo
• Datos Desequilibrados - peso de clase y remuestreo

Versiones de la pila: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.