👋 Sobre el autor

Wilder Ramírez Delgado convierte datos en decisiones. Científico de Datos, Arquitecto de IA y asesor tecnológico con más de 20 años de experiencia en analítica avanzada, machine learning, Big Data e IoT. Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), asesora a entidades gubernamentales y empresas privadas en Colombia y es referente en analítica y normatividad para los sectores postal y logístico del país. Una serie pensada para ir de la teoría a la práctica, con ejemplos concretos en cada paso.

📌 Parte de la serie Análisis Avanzado de Datos.

De varianza e independencia a vecindad y estructura

En el artículo anterior viste ICA: una alternativa a PCA que busca componentes estadísticamente independientes en vez de solo no correlacionados. PCA e ICA comparten algo importante: las dos son transformaciones lineales — el nuevo sistema de coordenadas es una combinación lineal (una rotación o un cizallamiento) de las variables originales.

Ese supuesto de linealidad es también su límite. Cuando la estructura real de los datos vive sobre una superficie curva — una variedad (manifold) de menor dimensión, enredada dentro del espacio original —, ninguna rotación lineal la desenreda bien. Este artículo cierra la serie de reducción de dimensionalidad mirando qué pasa cuando se abandona la linealidad, y qué se gana y qué se pierde al hacerlo.

Objetivos de aprendizaje

Al terminar este artículo vas a ser capaz de:

• explicar qué es la maldición de la dimensionalidad y por qué distorsiona las distancias;
• distinguir selección de variables de proyección de variables;
• describir la intuición de MDS, t-SNE y UMAP, y qué tipo de estructura preserva cada uno;
• elegir entre reducir para visualizar y reducir para predecir;
• reconocer los riesgos de sobre-interpretar una proyección no lineal.

Preparación del entorno

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine
from sklearn.decomposition import PCA
from sklearn.manifold import MDS, TSNE
from sklearn.preprocessing import StandardScaler
import umap

SEMILLA = 2026
COLORES = ['#2A6F97', '#D97706', '#2D6A4F']
plt.rcParams.update({
    'figure.figsize': (9, 5),
    'axes.spines.top': False,
    'axes.spines.right': False,
    'axes.titleweight': 'bold',
})

C:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages\tqdm\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

La maldición de la dimensionalidad

A medida que agregamos variables, el espacio donde viven los datos crece mucho más rápido de lo que crecen los datos mismos. Dos consecuencias prácticas de esto:

• Los datos se vuelven ralos. Para cubrir un espacio de dimensiones con la misma densidad que lográs en 2 dimensiones, necesitás un número de observaciones que crece exponencialmente con .
• Las distancias dejan de discriminar. En dimensión alta, la distancia entre el punto más cercano y el más lejano a un punto de referencia tiende a volverse casi igual — todos los puntos terminan “igual de lejos”. Esto es un problema serio para cualquier método (como vecinos más cercanos, o el propio t-SNE que vas a ver más abajo) que depende de distinguir “cerca” de “lejos”.

rng = np.random.default_rng(SEMILLA)
dimensiones = [2, 5, 10, 20, 50, 100, 300]
n_puntos = 500

contraste = []
for d in dimensiones:
    puntos = rng.uniform(size=(n_puntos, d))
    referencia = puntos[0]
    distancias = np.linalg.norm(puntos[1:] - referencia, axis=1)
    contraste.append({
        'dimension': d,
        'distancia_min': distancias.min(),
        'distancia_max': distancias.max(),
        'contraste_relativo': (distancias.max() - distancias.min()) / distancias.min(),
    })

tabla_contraste = pd.DataFrame(contraste)
display(tabla_contraste.round(4))

Los datos: los mismos trece vinos del capítulo anterior

Para que las comparaciones de este artículo sean justas, usamos el mismo conjunto de datos que en PCA e ICA: 178 vinos italianos de tres cultivos distintos, descritos por 13 mediciones químicas. Volvemos a cargarlo y a estandarizarlo exactamente igual que antes.

wine = load_wine(as_frame=True)
X = wine.data.copy()
y = wine.target.copy()
nombres_clase = wine.target_names

escalador = StandardScaler()
X_std = escalador.fit_transform(X)

print(f'Observaciones: {X.shape[0]}')
print(f'Variables numéricas: {X.shape[1]}')
print('Observaciones por clase:', y.value_counts().sort_index().to_dict())

Observaciones: 178
Variables numéricas: 13
Observaciones por clase: {0: 59, 1: 71, 2: 48}

Punto de partida: la proyección lineal que ya conocés

Antes de ver métodos no lineales, proyectamos los mismos datos con PCA a 2 dimensiones, igual que en el capítulo anterior. Esta proyección queda como referencia para comparar visualmente contra MDS, t-SNE y UMAP más abajo — no es una repetición del análisis completo de PCA, que ya hiciste a fondo.

pca_2d = PCA(n_components=2, random_state=SEMILLA)
proy_pca = pca_2d.fit_transform(X_std)
varianza_2d = pca_2d.explained_variance_ratio_.sum()

fig, ax = plt.subplots(figsize=(7, 6))
for clase, color in zip(range(3), COLORES):
    mascara = y == clase
    ax.scatter(proy_pca[mascara, 0], proy_pca[mascara, 1], c=color, label=nombres_clase[clase], alpha=0.8)
ax.set_xlabel('PC1')
ax.set_ylabel('PC2')
ax.set_title(f'PCA (2 componentes, {varianza_2d:.1%} de varianza explicada)')
ax.legend()
plt.show()

Selección de variables frente a proyección de variables

Reducir dimensiones no siempre significa proyectar. Hay dos familias de estrategias y conviene no confundirlas:

• Selección de variables: te quedás con un subconjunto de las columnas originales (por ejemplo, las 4 más correlacionadas con la variable objetivo) y descartás el resto. El resultado sigue siendo interpretable en las unidades originales — “alcohol” sigue siendo “alcohol” — pero podés perder información que solo aparecía combinada entre variables descartadas.
• Proyección de variables: construís nuevas variables como función de todas las originales (PCA, ICA, MDS, t-SNE, UMAP entran acá). Usás toda la información disponible, pero el resultado — “componente 1”, “dimensión UMAP 2” — ya no tiene una unidad ni un significado directo.

Este artículo trata exclusivamente de proyección. Si tu objetivo es mantener variables interpretables para alguien que va a actuar sobre ellas (un médico, un auditor, un regulador), selección de variables puede ser preferible aunque “explique menos varianza” en el papel.

Métodos no lineales: la idea general

PCA busca una rotación que maximice varianza global. Los métodos de esta sección, en cambio, parten de las distancias o las vecindades entre observaciones y buscan una representación en pocas dimensiones que las reproduzca lo mejor posible — sin exigir que la transformación sea una combinación lineal de las variables originales. Eso les da más flexibilidad para seguir curvas y superficies, pero a cambio pierden varias propiedades cómodas de PCA: no hay una fórmula cerrada única, el resultado depende de un proceso de optimización (y por lo tanto de la semilla), y — salvo UMAP, como vas a ver — no siempre hay una forma clara de aplicar la misma transformación a una observación nueva.

MDS: preservar distancias globales

El escalamiento multidimensional (multidimensional scaling, MDS) parte de todas las distancias por pares entre observaciones en el espacio original y busca coordenadas en 2 dimensiones que reproduzcan esas distancias lo más fielmente posible. Formalmente, minimiza una función de “estrés”:

donde es la distancia original entre las observaciones y , y es la distancia entre sus proyecciones en 2D. A diferencia de PCA, MDS no pasa por una matriz de covarianza ni por componentes ortogonales: trabaja directamente sobre la matriz de distancias, lo que le permite —en principio— capturar relaciones no lineales si se usa una noción de distancia no euclidiana. En su versión más simple (la que usamos acá), con distancia euclidiana, MDS clásico da un resultado muy cercano a PCA; su verdadero valor aparece con otras métricas de distancia o con datos ya dados como una matriz de disimilitud.

mds = MDS(n_components=2, random_state=SEMILLA, normalized_stress='auto', n_init=4)
proy_mds = mds.fit_transform(X_std)

fig, ax = plt.subplots(figsize=(7, 6))
for clase, color in zip(range(3), COLORES):
    mascara = y == clase
    ax.scatter(proy_mds[mascara, 0], proy_mds[mascara, 1], c=color, label=nombres_clase[clase], alpha=0.8)
ax.set_xlabel('Dimensión 1')
ax.set_ylabel('Dimensión 2')
ax.set_title(f'MDS (estrés final: {mds.stress_:.1f})')
ax.legend()
plt.show()

C:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages\sklearn\manifold\_mds.py:735: FutureWarning: The default value of `init` will change from 'random' to 'classical_mds' in 1.10. To suppress this warning, provide some value of `init`.
  warnings.warn(

t-SNE: preservar vecindades locales

t-SNE (t-distributed Stochastic Neighbor Embedding) cambia el objetivo: en vez de intentar reproducir todas las distancias por igual, se concentra en preservar quién es vecino de quién. Para cada observación, construye una distribución de probabilidad sobre “cuáles son sus vecinos cercanos” en el espacio original, y busca una configuración en 2D donde esa misma distribución de vecindad se mantenga lo más parecida posible.

El hiperparámetro central es la perplejidad, que fija de manera aproximada cuántos vecinos efectivos considera cada punto — perplejidades bajas priorizan estructura muy local (grupos pequeños), perplejidades altas priorizan estructura más amplia. t-SNE no tiene una solución única: el proceso de optimización es no convexo, así que el resultado cambia con la semilla y con la perplejidad, y no existe una forma de aplicar la misma transformación a una observación nueva — solo sabe proyectar el conjunto completo con el que fue ajustado. Esto importa más adelante, en el notebook aplicado, cuando comparemos qué tan útil es cada método para un modelo de producción.

tsne = TSNE(n_components=2, perplexity=30, random_state=SEMILLA, init='pca', learning_rate='auto')
proy_tsne = tsne.fit_transform(X_std)

fig, ax = plt.subplots(figsize=(7, 6))
for clase, color in zip(range(3), COLORES):
    mascara = y == clase
    ax.scatter(proy_tsne[mascara, 0], proy_tsne[mascara, 1], c=color, label=nombres_clase[clase], alpha=0.8)
ax.set_xlabel('Dimensión 1 (t-SNE)')
ax.set_ylabel('Dimensión 2 (t-SNE)')
ax.set_title('t-SNE (perplejidad = 30)')
ax.legend()
plt.show()

UMAP: vecindades locales con más estructura global

UMAP (Uniform Manifold Approximation and Projection) persigue un objetivo parecido al de t-SNE — preservar vecindades locales —, pero parte de una formulación distinta, basada en topología de variedades, que en la práctica tiende a conservar algo más de la estructura global (la posición relativa entre grupos lejanos) que t-SNE, además de ser considerablemente más rápido en datasets grandes.

Sus dos hiperparámetros principales son n_neighbors (cuántos vecinos considera al construir el grafo de vecindad local — el equivalente aproximado a la perplejidad de t-SNE) y min_dist (qué tan apretados deja los puntos dentro de un mismo grupo en la proyección final). A diferencia de t-SNE, UMAP sí aprende una función de proyección reutilizable: una vez ajustado, se puede llamar .transform() sobre observaciones nuevas sin tener que reajustar todo el modelo. Esa diferencia técnica, aparentemente pequeña, es la que determina si un método sirve solo para explorar datos o también para un pipeline de producción.

modelo_umap = umap.UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=SEMILLA)
proy_umap = modelo_umap.fit_transform(X_std)

fig, ax = plt.subplots(figsize=(7, 6))
for clase, color in zip(range(3), COLORES):
    mascara = y == clase
    ax.scatter(proy_umap[mascara, 0], proy_umap[mascara, 1], c=color, label=nombres_clase[clase], alpha=0.8)
ax.set_xlabel('Dimensión 1 (UMAP)')
ax.set_ylabel('Dimensión 2 (UMAP)')
ax.set_title('UMAP (n_neighbors=15, min_dist=0.1)')
ax.legend()
plt.show()

C:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages\umap\umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.
  warn(

Las cuatro proyecciones, lado a lado

proyecciones = [
    ('PCA', proy_pca),
    ('MDS', proy_mds),
    ('t-SNE', proy_tsne),
    ('UMAP', proy_umap),
]

fig, ejes = plt.subplots(2, 2, figsize=(11, 10))
for ax, (nombre, proy) in zip(ejes.ravel(), proyecciones):
    for clase, color in zip(range(3), COLORES):
        mascara = y == clase
        ax.scatter(proy[mascara, 0], proy[mascara, 1], c=color, alpha=0.8, s=20)
    ax.set_title(nombre)
    ax.set_xticks([])
    ax.set_yticks([])
fig.suptitle('Mismo dataset, cuatro formas de aplastarlo a 2 dimensiones')
plt.tight_layout()
plt.show()

Reducir para visualizar frente a reducir para predecir

Esta distinción organiza todo lo que viste hasta acá:

• Reducir para visualizar: el objetivo es que una persona entienda la estructura de los datos de un vistazo. Acá t-SNE y UMAP suelen ganar — producen imágenes más legibles, con grupos más definidos — siempre que quien las lea conozca sus límites (distancias y tamaños no literales).
• Reducir para predecir: el objetivo es alimentar un modelo supervisado con menos columnas sin perder poder predictivo, dentro de un pipeline reproducible que después va a recibir datos nuevos. Acá importan otras dos cosas que visualizar no exige: que el método tenga una forma honesta de transformar observaciones nuevas (ver la advertencia sobre t-SNE más arriba), y que exista algún criterio objetivo — como la varianza explicada de PCA — para decidir cuántas dimensiones retener, en vez de fijar 2 solo porque es lo que cabe en una pantalla.

El notebook aplicado de este artículo retoma exactamente esta distinción con números concretos.

Riesgos: distorsión e inestabilidad

Tres riesgos concretos a tener presentes antes de usar cualquiera de estos métodos para sacar una conclusión:

• Distorsión de distancias. Ya lo viste: en t-SNE y UMAP, ni el tamaño de un grupo ni la distancia entre grupos son literales. Tratarlos como si lo fueran — “el grupo A está más lejos del B que del C, entonces A y B son más distintos” — es sobre-interpretar la imagen.
• Inestabilidad frente a hiperparámetros. La forma de la proyección de t-SNE y UMAP cambia con la perplejidad o n_neighbors. Un cambio de hiperparámetro puede hacer aparecer o desaparecer grupos que no reflejan ninguna estructura real adicional en los datos — solo un ajuste distinto del algoritmo.

fig, ejes = plt.subplots(1, 3, figsize=(15, 5))
perplejidades = [5, 30, 100]
for ax, perp in zip(ejes, perplejidades):
    tsne_prueba = TSNE(n_components=2, perplexity=perp, random_state=SEMILLA, init='pca', learning_rate='auto')
    proy_prueba = tsne_prueba.fit_transform(X_std)
    for clase, color in zip(range(3), COLORES):
        mascara = y == clase
        ax.scatter(proy_prueba[mascara, 0], proy_prueba[mascara, 1], c=color, alpha=0.8, s=20)
    ax.set_title(f'perplejidad = {perp}')
    ax.set_xticks([])
    ax.set_yticks([])
fig.suptitle('Mismos datos, misma semilla, solo cambia la perplejidad')
plt.tight_layout()
plt.show()

Qué hace y qué no hace cada método

Ningún método de esta tabla “gana” en todos los criterios. La elección depende de la pregunta: si necesitás entender visualmente cómo se agrupan tus datos, t-SNE o UMAP suelen ser más informativos; si necesitás una transformación reproducible dentro de un pipeline predictivo, PCA o UMAP son las opciones honestas; MDS rinde más cuando el punto de partida ya es una matriz de distancias (no necesariamente euclidianas) en vez de variables numéricas crudas.

Qué sigue

Hasta acá, toda la serie trabajó con observaciones que podían reordenarse libremente — filas intercambiables de una tabla. El siguiente artículo cambia esa premisa: entran los datos donde el orden sí importa, porque cada observación depende de las anteriores en el tiempo.

👋 Sobre el autor

Wilder Ramírez Delgado convierte datos en decisiones. Científico de Datos, Arquitecto de IA y asesor tecnológico con más de 20 años de experiencia en analítica avanzada, machine learning, Big Data e IoT. Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), asesora a entidades gubernamentales y empresas privadas en Colombia y es referente en analítica y normatividad para los sectores postal y logístico del país. Una serie pensada para ir de la teoría a la práctica, con ejemplos concretos en cada paso.

📌 Parte de la serie Análisis Avanzado de Datos.

De la intuición a los números

El artículo anterior mostró, de forma visual, cómo PCA, MDS, t-SNE y UMAP proyectan el mismo conjunto de vinos a 2 dimensiones, y advirtió que las distancias en t-SNE y UMAP no son literales. Este caso aplicado reemplaza esa intuición visual por dos métricas concretas de qué tanta estructura conserva cada método, y usa esas métricas para responder una pregunta de producción: si el objetivo es alimentar un modelo predictivo en vez de solo mirar un gráfico, ¿cuál conviene usar?

Objetivos de este caso

Al terminar vas a ser capaz de:

• calcular y leer el trustworthiness de una proyección, una métrica de preservación local;
• comparar la preservación global de distancias entre métodos mediante correlación de rangos;
• explicar por qué t-SNE y MDS clásico no son aptos para un pipeline que debe transformar datos nuevos;
• decidir, con una comparación numérica, si conviene proyectar a 2D para un modelo predictivo o no.

Preparación del entorno

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.spatial.distance import pdist
from scipy.stats import spearmanr
from sklearn.datasets import load_wine
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.manifold import TSNE, trustworthiness
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
import umap

SEMILLA = 2026
COLORES = ['#2A6F97', '#D97706', '#2D6A4F']
plt.rcParams.update({
    'figure.figsize': (9, 5),
    'axes.spines.top': False,
    'axes.spines.right': False,
    'axes.titleweight': 'bold',
})

C:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages\tqdm\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

Los datos

Mismo conjunto que en el artículo conceptual: 178 vinos, 13 variables químicas, 3 clases. Igual que siempre, estandarizamos antes de proyectar.

wine = load_wine(as_frame=True)
X = wine.data.copy()
y = wine.target.copy()

escalador = StandardScaler()
X_std = escalador.fit_transform(X)

print(f'Observaciones: {X.shape[0]}, variables: {X.shape[1]}')

Observaciones: 178, variables: 13

Métrica 1: trustworthiness (preservación local)

El trustworthiness mide si los vecinos más cercanos de un punto en la proyección también eran sus vecinos más cercanos en el espacio original. Va de 0 a 1: 1 significa que la vecindad local se preservó perfectamente; valores bajos indican que la proyección “inventó” vecinos que no lo eran. Es la métrica natural para evaluar t-SNE y UMAP, porque es justo lo que esos métodos intentan optimizar — a diferencia del estrés de MDS o la varianza explicada de PCA, que miden preservación global.

proyecciones = {
    'PCA': PCA(n_components=2, random_state=SEMILLA).fit_transform(X_std),
    't-SNE': TSNE(n_components=2, perplexity=30, random_state=SEMILLA, init='pca', learning_rate='auto').fit_transform(X_std),
    'UMAP': umap.UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=SEMILLA).fit_transform(X_std),
}

filas_confianza = []
for nombre, proy in proyecciones.items():
    for k in (5, 10):
        t = trustworthiness(X_std, proy, n_neighbors=k)
        filas_confianza.append({'metodo': nombre, 'k_vecinos': k, 'trustworthiness': t})

tabla_confianza = pd.DataFrame(filas_confianza).pivot(index='metodo', columns='k_vecinos', values='trustworthiness')
display(tabla_confianza.round(3))

C:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages\umap\umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.
  warn(

Métrica 2: correlación de distancias (preservación global)

Trustworthiness mide vecindad local; para preservación global comparamos directamente las distancias por pares. Tomamos todas las distancias euclidianas entre pares de observaciones en el espacio original de 13 variables, las mismas distancias entre pares en cada proyección 2D, y calculamos la correlación de Spearman entre ambas listas: si vale 1, el orden de “quién está más lejos de quién” se preservó exactamente; si vale 0, no hay relación.

distancias_originales = pdist(X_std)

filas_correlacion = []
for nombre, proy in proyecciones.items():
    distancias_proyectadas = pdist(proy)
    rho, _ = spearmanr(distancias_originales, distancias_proyectadas)
    filas_correlacion.append({'metodo': nombre, 'correlacion_spearman': rho})

tabla_correlacion = pd.DataFrame(filas_correlacion).set_index('metodo')
display(tabla_correlacion.round(3))

La pregunta que de verdad separa “visualizar” de “predecir”

Las dos métricas anteriores comparan qué tan fiel es cada proyección. Pero para usar una proyección dentro de un modelo predictivo hace falta algo más básico: poder aplicarle la misma transformación ya aprendida a observaciones nuevas, sin tener que volver a ajustar el método desde cero cada vez que llega un dato. Esto es justamente lo que distingue a fit_transform de fit + transform por separado:

• PCA: aprende una matriz de proyección fija; .transform() sobre datos nuevos es directo.
• UMAP: también aprende una función reutilizable; soporta .transform() sobre datos nuevos (con alguna pérdida de fidelidad frente a reajustar todo, pero es una operación válida y rápida).
• MDS clásico y t-SNE: no aprenden una función reutilizable. Solo saben proyectar el conjunto exacto con el que fueron ajustados; no hay .transform() para datos nuevos sin reajustar todo el modelo con los datos viejos y nuevos juntos.

Por esta razón, en la comparación predictiva que sigue solo entran PCA y UMAP — son los dos métodos de este artículo que se pueden meter dentro de un Pipeline de scikit-learn sin incurrir en fuga de información ni en tener que reajustar sobre el conjunto de prueba.

Comparación predictiva: PCA(2D) frente a UMAP(2D) frente a las 13 variables originales

Partimos los datos en entrenamiento y prueba, igual que en el capítulo de PCA, y comparamos tres pipelines de clasificación. Fijamos 2 componentes en los tres casos a propósito — no es un valor optimizado por validación cruzada, es el mismo número de dimensiones que usamos para graficar arriba, para que la comparación sea justa contra esas imágenes.

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=SEMILLA, stratify=y
)

modelo_completo = Pipeline([
    ('escalador', StandardScaler()),
    ('clasificador', LogisticRegression(max_iter=2000)),
])
modelo_pca = Pipeline([
    ('escalador', StandardScaler()),
    ('pca', PCA(n_components=2, random_state=SEMILLA)),
    ('clasificador', LogisticRegression(max_iter=2000)),
])
modelo_umap = Pipeline([
    ('escalador', StandardScaler()),
    ('umap', umap.UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=SEMILLA)),
    ('clasificador', LogisticRegression(max_iter=2000)),
])

resultados = []
for nombre, modelo in [('13 variables', modelo_completo), ('PCA (2D)', modelo_pca), ('UMAP (2D)', modelo_umap)]:
    modelo.fit(X_train, y_train)
    exactitud = accuracy_score(y_test, modelo.predict(X_test))
    resultados.append({'modelo': nombre, 'dimensiones': 13 if nombre == '13 variables' else 2, 'exactitud_test': exactitud})

tabla_resultados = pd.DataFrame(resultados)
display(tabla_resultados.style.format({'exactitud_test': '{:.2%}'}))

C:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages\umap\umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.
  warn(

Decisión práctica: ¿cuántas dimensiones retener?

En el capítulo de PCA, la pregunta “¿cuántas dimensiones?” tenía una respuesta basada en un número objetivo: la curva de varianza explicada acumulada. UMAP no ofrece un equivalente directo — no existe una noción de “varianza explicada por componente” para n_neighbors o min_dist, porque UMAP no está optimizando varianza, está optimizando preservación de vecindad. Esto tiene una consecuencia práctica importante: si tu objetivo final es predecir, PCA te da una forma principiada de decidir cuántos componentes retener (como en el capítulo anterior); si tu objetivo es visualizar, fijar 2 o 3 dimensiones en UMAP o t-SNE es razonable porque ahí el número lo impone la pantalla, no un criterio estadístico. Usar UMAP o t-SNE como paso de reducción dentro de un pipeline predictivo es posible — y UMAP, a diferencia de t-SNE, lo permite técnicamente — pero conviene tratarlo como una decisión de ingeniería a validar con la métrica final del modelo (como hicimos arriba), no como una optimización de varianza.

Qué te llevás de este caso

Si tenés que elegir uno solo para explorar datos nuevos sin mucho contexto previo, UMAP suele ser el mejor punto de partida: combina vecindad local razonable, rapidez y la posibilidad — poco común entre los métodos no lineales — de aplicarse a datos nuevos.

👋 Sobre el autor

Wilder Ramírez Delgado convierte datos en decisiones. Científico de Datos, Arquitecto de IA y asesor tecnológico con más de 20 años de experiencia en analítica avanzada, machine learning, Big Data e IoT. Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), asesora a entidades gubernamentales y empresas privadas en Colombia y es referente en analítica y normatividad para los sectores postal y logístico del país. Una serie pensada para ir de la teoría a la práctica, con ejemplos concretos en cada paso.

📌 Parte de la serie Análisis Avanzado de Datos.

Del knot a la ventana

En el artículo anterior de la serie construiste splines: elegías dónde poner los nodos (knots) y ajustabas polinomios por tramos que se conectan suavemente. Funciona muy bien, pero exige decidir una estructura. Ahora tomamos otro camino, todavía dentro de la suavización, con una idea más directa: estimar el comportamiento en cada punto a partir de los datos que están cerca, sin construir ninguna base polinómica ni colocar knots.

Esa idea sencilla —una ventana alrededor de cada punto y un peso que decae con la distancia— da lugar a dos herramientas: la estimación de densidades (¿cómo se distribuyen mis datos?) y la regresión por kernel (¿qué valor de espero para cada ?). Y esa misma idea trae de vuelta, con otro nombre, el compromiso sesgo-varianza que ya conoces.

Objetivos de aprendizaje

Al terminar este notebook vas a entender cómo funcionan los métodos de suavización por kernel y cuándo conviene usarlos. En concreto, vas a ser capaz de:

• Definir formalmente una densidad de probabilidad, un kernel y el estimador de densidad por kernel (KDE), y reconocer los tipos más usados (gaussiano, Epanechnikov, uniforme).
• Explicar las limitaciones del histograma y estimar una densidad con el método de kernel (KDE), entendiendo su fórmula.
• Aplicar la regresión por kernel (estimador de Nadaraya–Watson) para suavizar una relación no lineal.
• Interpretar el papel del ancho de banda como el parámetro que regula el compromiso sesgo-varianza, y seleccionarlo por validación.
• Reconocer el sesgo de frontera y otras limitaciones prácticas, y comparar el suavizado por kernel con el spline y la recta.

Preparación del entorno

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import gaussian_kde
from sklearn.neighbors import KernelDensity
from sklearn.preprocessing import SplineTransformer
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split, GridSearchCV, KFold
from sklearn.metrics import r2_score, mean_squared_error
from statsmodels.nonparametric.smoothers_lowess import lowess

SEMILLA = 2026
plt.rcParams['figure.figsize'] = (8, 4)
print("Librerías cargadas")

Librerías cargadas

Parte A — Estimación de densidades

Antes de suavizar una relación entre variables, empecemos por suavizar algo más básico: la forma en que se distribuye una sola variable. Es el terreno donde la idea del kernel se ve con más claridad.

Qué es una densidad (definición formal)

Cuando la variable es continua —aquí, la desviación en horas—, un valor exacto tiene probabilidad cero: . Lo que sí tiene sentido es la probabilidad de un intervalo.

La función de densidad es una función no negativa que convierte el área bajo la curva en probabilidad:

El número no es una probabilidad. Es cuánta probabilidad se concentra por unidad de alrededor de ese punto (en este ejemplo, por hora). Por eso, en las figuras, los puntos negros van sobre el eje: marcan dónde cayeron los datos. La altura de la curva es densidad, no un observado.

Un histograma de conteos responde «¿cuántos cayeron en este intervalo?». El mismo histograma con el eje en densidad —y, más adelante, el estimador por kernel— responde «¿qué tan concentrada está la probabilidad ahí?». El objetivo de esta parte es estimar a partir de una muestra, sin suponer de antemano que sea una gaussiana.

El histograma engaña más de lo que crees

El histograma es la primera herramienta para ver una distribución, pero su forma depende de decisiones arbitrarias: el ancho de los intervalos (bins) y dónde empiezan. La misma variable puede contar historias distintas.

Generemos una variable con dos grupos. Piensa, por ejemplo, en la desviación (en horas) frente a la hora prometida de entrega para envíos de dos rutas mezclados: los valores negativos son entregas que llegaron antes; los positivos, entregas tardías. Vamos a dibujarla dos veces con el mismo ancho de bin, cambiando solo el punto donde empiezan los intervalos.

rng = np.random.default_rng(SEMILLA)
n = 600
comp = rng.random(n) < 0.5
datos = np.where(comp, rng.normal(-2, 0.6, n), rng.normal(2.5, 1.0, n))

ancho = 2.5
bordes_a = np.arange(-4.5, 8.0, ancho)      # intervalos que empiezan en -4.5
bordes_b = bordes_a + ancho / 4             # mismos intervalos, corridos 0.625

fig, ax = plt.subplots(1, 2, figsize=(11, 4), sharey=True)
conteos_a, _, _ = ax[0].hist(datos, bins=bordes_a, color='steelblue', edgecolor='white')
conteos_b, _, _ = ax[1].hist(datos, bins=bordes_b, color='steelblue', edgecolor='white')
ax[0].set_title(f'Ancho {ancho}, bordes desde {bordes_a[0]}')
ax[1].set_title(f'Ancho {ancho}, bordes desde {bordes_b[0]}')
for a in ax: a.set_xlabel('desviación frente a la hora prometida (horas)')
ax[0].set_ylabel('frecuencia')
plt.tight_layout(); plt.show()

print('Conteos, bordes desde -4.5  :', conteos_a.astype(int))
print('Conteos, bordes desde -3.875:', conteos_b.astype(int))
print('Media global:', round(datos.mean(), 2))

Conteos, bordes desde -4.5  : [153 149 210  88]
Conteos, bordes desde -3.875: [261  57 244  38]
Media global: 0.25

def flujo_verdadero(hora):
    """Vehículos por minuto según la hora. La misma curva del artículo anterior."""
    ritmo_base = 24 + 7 * np.sin((hora - 5) * np.pi / 12)
    pico_manana = 80 * np.exp(-0.5 * ((hora - 8.0) / 0.95) ** 2)
    pico_tarde = 92 * np.exp(-0.5 * ((hora - 18.2) / 1.15) ** 2)
    return ritmo_base + pico_manana + pico_tarde


rng = np.random.default_rng(SEMILLA)
minutos = np.linspace(0, 24, 24 * 60, endpoint=False)
peso = np.clip(flujo_verdadero(minutos), 0, None)
peso = peso / peso.sum()
n_vehiculos = 12000
hora_paso = rng.choice(minutos, size=n_vehiculos, p=peso)

t = np.linspace(0, 24, 1000)
flujo = np.clip(flujo_verdadero(t), 0, None)
curva = n_vehiculos * flujo / np.trapezoid(flujo, t)

ancho = 4
inicios_a = list(range(0, 24, ancho))          # bordes en 0, 4, 8, 12, 16, 20
inicios_b = list(range(-2, 24, ancho))         # los mismos intervalos, corridos 2 horas

fig, ejes = plt.subplots(1, 2, figsize=(11, 4.2), sharey=True)
paneles = (
    (ejes[0], inicios_a, 'Ancho 4 h, bordes desde las 0'),
    (ejes[1], inicios_b, 'Ancho 4 h, bordes desde las 2'),
)
tasas = []
for eje, inicios, titulo in paneles:
    tasas_panel = []
    for inicio in inicios:
        lo = max(inicio, 0)
        hi = min(inicio + ancho, 24)
        if hi <= lo:
            continue
        conteo = np.sum((hora_paso >= lo) & (hora_paso < hi))
        tasa = conteo / (hi - lo)
        tasas_panel.append(round(tasa))
        eje.bar(
            lo, tasa, width=hi - lo, align='edge',
            color='steelblue', edgecolor='white', zorder=2,
        )
    eje.plot(t, curva, color='firebrick', lw=0.4, ls='-', zorder=3)
    eje.axvline(8.0, color='0.35', ls='--', lw=1, zorder=1)
    eje.axvline(18.2, color='0.35', ls='--', lw=1, zorder=1)
    eje.set_xlim(0, 24)
    eje.set_xticks(range(0, 25, 2))
    eje.set_title(titulo)
    eje.set_xlabel('hora del día')
    tasas.append(tasas_panel)

ejes[0].set_ylabel('vehículos por hora')
fig.legend(['flujo real'], loc='upper right', frameon=False, bbox_to_anchor=(0.99, 0.98))
fig.suptitle('Misma avenida, mismos vehículos: solo se corren los bordes 2 horas', y=1.03)
plt.tight_layout()
plt.show()

print('Bordes desde las 0:', tasas[0])
print('Bordes desde las 2:', tasas[1])

Bordes desde las 0: [206, 574, 642, 351, 958, 271]
Bordes desde las 2: [194, 261, 867, 361, 637, 673, 208]

Qué es un kernel (definición formal)

Un kernel es una función de ponderación: asigna a cada punto un peso según su distancia. En este artículo trabajaremos con kernels de suavización no negativos, normalizados y simétricos. Estas son las propiedades de los tres ejemplos siguientes; no son una definición universal para todos los métodos que usan la palabra kernel:

• No negatividad: para todo .
• Integra uno: (su área vale 1, como una densidad de probabilidad).
• Simetría: (pesa igual a izquierda y derecha).

Hay muchos kernels válidos. Los tres más comunes:

• Gaussiano: . Suave, con soporte infinito (todo punto recibe algún peso).
• Epanechnikov: para . Tiene soporte finito y es óptimo en un sentido teórico preciso: entre los kernels no negativos y simétricos, y usando para cada uno su ancho de banda óptimo, minimiza el error integrado cuadrático medio asintótico (AMISE) en el marco habitual de estimación de densidades de segundo orden. Es un resultado asintótico bajo condiciones de regularidad, no una garantía de menor error en cualquier muestra.
• Uniforme: para . Una caja: todos los vecinos dentro de la ventana pesan igual.

u = np.linspace(-3, 3, 400)
gauss = np.exp(-u**2 / 2) / np.sqrt(2 * np.pi)
epan = np.where(np.abs(u) <= 1, 0.75 * (1 - u**2), 0)
unif = np.where(np.abs(u) <= 1, 0.5, 0)

plt.plot(u, gauss, label='Gaussiano', linewidth=2)
plt.plot(u, epan, label='Epanechnikov', linewidth=2)
plt.plot(u, unif, label='Uniforme', linewidth=2)
plt.xlabel('u'); plt.ylabel('K(u)'); plt.legend()
plt.title('Tres kernels válidos'); plt.show()

Qué es el KDE (definición formal)

La densidad de la población no la observas. Observas una muestra . El estimador de densidad por kernel (KDE, kernel density estimator) es una curva que estima esa desconocida:

En palabras: colocas sobre cada dato una campana (el kernel ) de ancho , las sumas y divides por para que el área siga siendo 1. no es la densidad verdadera ni el valor de un dato: es una estimación, y cambia si cambian la muestra o el ancho de banda .

La diferencia con el histograma es que no partes el eje en intervalos fijos: cada observación lleva su propia campana centrada en ella.

Construyamos el KDE paso a paso

La muestra tiene 600 entregas. El KDE pone una campana sobre cada una, así que el estimador de verdad son 600 campanas promediadas. Si las dibujáramos todas a la vez, se fundirían y no verías el ladrillo. Por eso vamos en tres tomas, de menos a más:

1. Un dato. Una sola campana, para ver la pieza básica: el kernel centrado en un punto.
2. Ocho datos. Los primeros 8 de la muestra (datos[:8]), cada uno con su campana, sin sumarlas. Es una lupa: se distinguen los solapes y los huecos. No es el KDE todavía; es un recorte para que el ojo alcance.
3. Los 600. Ahí sí se suman y se promedian todas las campanas. Esa curva ya es el KDE, en la misma escala que el histograma.

Para dibujar, no usamos los 600 datos como eje horizontal. Evaluamos cada campana en una malla de 500 valores de entre y horas (grid = np.linspace(-6, 7, 500)). Esas 500 columnas son puntos de dibujo, no observaciones: si pusieras 200 o 1000, la curva sería la misma idea, solo más tosca o más suave al trazarla.

Empezamos por la primera toma.

def campana(x, centro, h):
    """Kernel gaussiano centrado en 'centro' con ancho h (ya normalizado)."""
    return np.exp(-0.5 * ((x - centro) / h) ** 2) / (h * np.sqrt(2 * np.pi))

grid = np.linspace(-6, 7, 500)  # malla de dibujo: 500 valores de x, no 500 datos
punto = datos[0]
h = 0.3
altura = campana(punto, punto, h)

plt.plot(grid, campana(grid, punto, h), color='firebrick', linewidth=2)
plt.vlines(punto, 0, altura, colors='0.4', linestyles='--', linewidth=1)
plt.plot([punto], [0], 'ko', markersize=8, clip_on=False, zorder=5,
         label=f'un dato (x={punto:.2f})')
plt.xlim(punto - 2, punto + 2)
plt.ylim(-0.12, altura * 1.12)
plt.xlabel('desviación (horas)'); plt.ylabel('aporte'); plt.legend()
plt.title('Una campana (kernel) sobre un solo dato'); plt.show()

# Los primeros 8 datos de la muestra de entregas.
sub = datos[:8]

# Un solo punto con etiqueta, para que la leyenda no repita «datos» ocho veces.
plt.plot([sub[0]], [0], 'ko', markersize=6, label='datos')
for xi in sub:
    # Campana centrada en xi, ancho 0.3, dividida por 8: el aporte de un dato al promedio.
    plt.plot(grid, campana(grid, xi, 0.3) / len(sub), color='steelblue', alpha=0.7)
    plt.plot([xi], [0], 'ko', markersize=6)
plt.xlabel('desviación (horas)'); plt.ylabel('aporte (escalado)'); plt.legend()
plt.title('Cada dato aporta su propia campana'); plt.show()

# h: ancho de cada campana, en horas. El mismo de las figuras anteriores.
h = 0.3

# Una fila por cada uno de los 600 datos; 500 columnas = la malla de dibujo (grid), no 500 entregas.
aportes = np.array([campana(grid, xi, h) for xi in datos])

# Promedio de las 600 filas = (1/n) * suma. Eso es el KDE, y ya integra uno.
kde_manual = aportes.mean(axis=0)

# density=True pone el histograma en la misma escala que la curva (densidad, no conteos).
plt.hist(datos, bins=40, density=True, color='lightsteelblue',
         edgecolor='white', label='histograma')
plt.plot(grid, kde_manual, color='firebrick', linewidth=2, label='suma de campanas (KDE)')
plt.xlabel('desviación (horas)'); plt.ylabel('densidad'); plt.legend()
plt.title('El KDE es la suma (promediada) de todas las campanas'); plt.show()

La fórmula del KDE, ahora en código

La definición de arriba es lo que acabas de armar a mano:

donde es el kernel, el número de datos y el ancho de banda. En la práctica no la programas a mano: scipy y scikit-learn la traen lista. Pero no hacen lo mismo con . scipy.gaussian_kde elige el ancho de banda por ti (regla de Scott por defecto, o Silverman si se lo pides con bw_method='silverman').

Las reglas de Scott y de Silverman son fórmulas cerradas para elegir sin validar. En una dimensión las dos son del tipo : miran el tamaño de muestra y la dispersión de los datos. El no es un número mágico: sale de minimizar el AMISE (asymptotic mean integrated squared error), un error teórico de toda la curva cuando es grande —promedio, a lo largo de , de —. Lo usan suponiendo que se parece a una gaussiana (referencia normal). Scott, en scipy, usa el factor (). Silverman usa un factor distinto: en scipy es ; en la versión de los libros a veces entra también el rango intercuartílico, más resistente a valores extremos. Ninguna de las dos inspecciona si hay dos grupos o un pico raro: si la forma no es gaussiana, el que entregan no es un óptimo para esa muestra, solo un atajo rápido. La fórmula del AMISE la desglosamos en la sección del compromiso sesgo-varianza.

En sklearn normalmente fijas tú, y si le pides una regla automática hay un detalle que conviene conocer. Veamos esa diferencia.

kde_scipy = gaussian_kde(datos)  # bw_method='scott' por defecto
h_scott = float(np.sqrt(np.asarray(kde_scipy.covariance).squeeze()))

kde_sk_scott = KernelDensity(bandwidth='scott').fit(datos.reshape(-1, 1))
h_sk = float(kde_sk_scott.bandwidth_)
# score_samples devuelve log-densidad; exp la pasa a la misma escala que scipy.
dens_sk = np.exp(kde_sk_scott.score_samples(grid.reshape(-1, 1)))

print('scipy.gaussian_kde elige el ancho de banda solo (regla de Scott).')
print(f'  h de scipy:                  {h_scott:.3f}')
print(f'  h de sklearn con "scott":    {h_sk:.3f}')
print(f'  desviación estándar datos:   {datos.std(ddof=1):.3f}')

plt.hist(datos, bins=40, density=True, color='lightsteelblue',
         edgecolor='white', label='histograma')
plt.plot(grid, kde_scipy(grid), color='firebrick', linewidth=2,
         label=f'scipy (Scott, h={h_scott:.2f})')
plt.plot(grid, dens_sk, color='steelblue', linewidth=2,
         label=f'sklearn (Scott, h={h_sk:.2f})')
plt.xlabel('desviación (horas)'); plt.ylabel('densidad'); plt.legend()
plt.title('El mismo nombre Scott, dos anchos distintos'); plt.show()

scipy.gaussian_kde elige el ancho de banda solo (regla de Scott).
  h de scipy:                  0.660
  h de sklearn con "scott":    0.278
  desviación estándar datos:   2.373

El ancho de banda y el compromiso sesgo-varianza

El KDE tiene un único parámetro crítico: el ancho de banda . Aquí el compromiso sesgo-varianza toma forma concreta:

• Con pequeño, cada campana es estrecha; la estimación se pega a cada dato y fluctúa mucho de una muestra a otra (varianza alta, sesgo bajo).
• Con grande, las campanas son anchas; la estimación es estable pero aplana los detalles reales (sesgo alto, varianza baja).

El error total se mide con el MISE (mean integrated squared error), . En una dimensión, para una densidad suficientemente suave y un kernel simétrico de segundo orden, con y , su aproximación asintótica es

donde y . El primer término baja cuando crece; el segundo sube. El mínimo está en un punto intermedio, , y de ahí sale el factor de la regla de Scott. Veámoslo con tres anchos.

anchos = [0.1, 0.3, 2.0]
fig, ax = plt.subplots(1, 3, figsize=(13, 4))
for a, hb in zip(ax, anchos):
    kde_h = KernelDensity(kernel='gaussian', bandwidth=hb).fit(datos.reshape(-1, 1))
    dens = np.exp(kde_h.score_samples(grid.reshape(-1, 1)))
    a.hist(datos, bins=40, density=True, color='lightsteelblue', edgecolor='white')
    a.plot(grid, dens, color='firebrick', linewidth=2)
    a.set_title(f'h = {hb}'); a.set_xlabel('desviación (horas)')
ax[0].set_ylabel('densidad')
plt.tight_layout(); plt.show()

Elegir el ancho de banda por validación (densidad)

No queremos elegir a simple vista. Como el KDE es una densidad, podemos medir qué tan bien predice datos nuevos mediante la log-verosimilitud en validación cruzada: buscamos el que hace más probables los datos que el modelo no vio. GridSearchCV lo automatiza.

La verosimilitud es «qué tan creíbles se ven estos puntos si esta curva fuera la densidad verdadera»: se evalúa en cada dato y se multiplican esos valores. Como el producto de muchos números pequeños se va a cero, se toma el logaritmo y se suman: esa es la log-verosimilitud. Más alta = la curva coloca más densidad donde sí cayeron entregas nuevas. Más baja = las puso en el lugar equivocado. En validación cruzada se calcula con puntos que no se usaron para armar el KDE, para no premiar a un que solo memoriza la muestra.

params = {'bandwidth': np.linspace(0.1, 2.0, 40)}
busqueda = GridSearchCV(KernelDensity(kernel='gaussian'), params, cv=5)
busqueda.fit(datos.reshape(-1, 1))
h_dens = busqueda.best_params_['bandwidth']
print(f'Ancho de banda óptimo por validación: {h_dens:.3f}')

Ancho de banda óptimo por validación: 0.295

Parte B — Regresión por kernel

La misma idea de “mirar lo cercano” sirve para regresión. En vez de estimar una densidad, queremos estimar la función de regresión , es decir, el valor esperado de para cada . Lo haremos promediando los de los puntos vecinos, con más peso para los más próximos.

La intuición: los pesos en un punto

Antes de la fórmula, veamos qué significa “promediar lo cercano”. Fijemos un punto y miremos cuánto pesa cada dato según su distancia, usando el kernel gaussiano. Los cercanos deben pesar mucho; los lejanos, casi nada.

rng = np.random.default_rng(SEMILLA)
n = 200
x = np.sort(rng.uniform(0, 10, n))
m_true = np.sin(x) + 0.3 * x
y = m_true + rng.normal(0, 0.5, n)

x0 = 5.0
h = 0.5
pesos = np.exp(-0.5 * ((x - x0) / h) ** 2)

plt.scatter(x, y, c=pesos, cmap='Reds', s=30, edgecolor='gray', linewidth=0.3)
plt.axvline(x0, color='black', linestyle='--', label=rf'$x_0$ = {x0:g}')
plt.colorbar(label='peso del kernel')
plt.xlabel('x'); plt.ylabel('y'); plt.legend()
plt.title(r'Peso de cada dato al predecir en $x_0$ = 5'); plt.show()

El estimador de Nadaraya–Watson

Esa idea tiene fórmula: la predicción en es el promedio de los ponderado por el kernel según la distancia a :

El numerador suma los pesados; el denominador normaliza. No hay knots ni coeficientes: solo el ancho de banda . Lo implementamos a mano.

def _entradas_kernel(x_train, y_train, x_query, h):
    """Validar datos unidimensionales y un ancho de banda positivo."""
    x_train = np.asarray(x_train, dtype=float)
    y_train = np.asarray(y_train, dtype=float)
    x_query = np.atleast_1d(np.asarray(x_query, dtype=float))
    if x_train.ndim != 1 or y_train.ndim != 1 or x_query.ndim != 1:
        raise ValueError("Usa vectores unidimensionales; x_query también puede ser escalar.")
    if x_train.size == 0 or x_train.size != y_train.size:
        raise ValueError("x_train e y_train deben tener la misma longitud no nula.")
    if not all(np.isfinite(v).all() for v in (x_train, y_train, x_query)):
        raise ValueError("Los datos y las consultas deben ser finitos.")
    h = np.asarray(h, dtype=float)
    if h.ndim != 0 or not np.isfinite(h) or h <= 0:
        raise ValueError("h debe ser un escalar finito y positivo.")
    return x_train, y_train, x_query, float(h)


def _pesos_gaussianos(x_train, xq, h):
    # Restar el mayor log-peso evita que todos los pesos se redondeen a cero.
    # El factor común se cancela al normalizar y no cambia el estimador.
    with np.errstate(over="ignore", invalid="ignore"):
        log_w = -0.5 * ((x_train - xq) / h) ** 2
    if not np.isfinite(log_w).any():
        raise ValueError("La escala de distancias es extrema: reescala X o revisa h.")
    return np.exp(log_w - np.max(log_w))


def nadaraya_watson(x_train, y_train, x_query, h):
    x_train, y_train, x_query, h = _entradas_kernel(x_train, y_train, x_query, h)
    pred = np.empty(len(x_query))
    for i, xq in enumerate(x_query):
        w = _pesos_gaussianos(x_train, xq, h)
        pred[i] = np.sum((w / w.sum()) * y_train)
    return pred

grid_x = np.linspace(0, 10, 300)
ajuste = nadaraya_watson(x, y, grid_x, h=0.5)

plt.scatter(x, y, s=15, alpha=0.5, label='datos')
plt.plot(grid_x, np.sin(grid_x) + 0.3 * grid_x, 'k--', label='relación real')
plt.plot(grid_x, ajuste, color='firebrick', linewidth=2, label='kernel (h=0.5)')
plt.xlabel('x'); plt.ylabel('y'); plt.legend()
plt.title('Regresión por kernel (Nadaraya–Watson)'); plt.show()

El ancho de banda controla la flexibilidad

Igual que en densidades, decide cuánto suaviza. Cumple el papel que tenía el número de knots en el spline, pero en sentido inverso: más knots dan una curva más flexible; un más grande da una curva más rígida.

anchos = [0.1, 0.5, 2.5]
plt.scatter(x, y, s=15, alpha=0.4, label='datos')
plt.plot(grid_x, np.sin(grid_x) + 0.3 * grid_x, 'k--', label='relación real')
colores = ['seagreen', 'firebrick', 'darkorange']
for hb, c in zip(anchos, colores):
    plt.plot(grid_x, nadaraya_watson(x, y, grid_x, hb), color=c, linewidth=2, label=f'h={hb}')
plt.xlabel('x'); plt.ylabel('y'); plt.legend()
plt.title('Efecto del ancho de banda'); plt.show()

El sesgo de frontera (boundary bias)

Nadaraya–Watson tiene una debilidad conocida en los extremos del rango. En el interior, cada punto tiene vecinos a ambos lados y el promedio queda centrado. Pero en la frontera (el primer y el último tramo de ) solo hay vecinos de un lado. Si la relación tiene pendiente, esos vecinos están todos más arriba (o más abajo) y el promedio se sesga hacia el interior: la curva se “dobla”.

La solución clásica es cambiar el promedio local por una recta local. Nadaraya–Watson es una regresión polinómica local de grado 0: en cada punto ajusta una constante (el promedio ponderado). La regresión lineal local es de grado 1: en cada punto ajusta una recta por mínimos cuadrados ponderados con el mismo kernel, y usa su valor en ese punto como predicción.

Para que la comparación sea justa, usemos una relación lineal, más ruido, y el mismo kernel gaussiano con el mismo en ambos métodos.

def lineal_local(x_train, y_train, x_query, h):
    x_train, y_train, x_query, h = _entradas_kernel(x_train, y_train, x_query, h)
    pred = np.empty(len(x_query))
    for i, xq in enumerate(x_query):
        w = _pesos_gaussianos(x_train, xq, h)  # mismo kernel gaussiano estabilizado
        # recta ponderada centrada en xq: el intercepto es la predicción en xq
        if np.unique(x_train[w > 0]).size < 2:
            raise ValueError("La recta local necesita dos valores distintos de X con peso positivo.")
        pendiente, intercepto = np.polyfit(x_train - xq, y_train, deg=1, w=np.sqrt(w))
        pred[i] = intercepto
    return pred

rng2 = np.random.default_rng(SEMILLA)
xb = np.sort(rng2.uniform(0, 10, 200))
mb = 0.5 * xb
yb = mb + rng2.normal(0, 0.6, 200)

gx = np.linspace(0, 10, 300)
fit_nw = nadaraya_watson(xb, yb, gx, h=1.0)
fit_ll = lineal_local(xb, yb, gx, h=1.0)

plt.scatter(xb, yb, s=12, alpha=0.35, label='datos')
plt.plot(gx, 0.5 * gx, 'k--', label='relación real (recta)')
plt.plot(gx, fit_nw, color='firebrick', linewidth=2,
         label='Nadaraya–Watson (grado 0)')
plt.plot(gx, fit_ll, color='seagreen', linewidth=2,
         label='lineal local (grado 1)')
plt.xlabel('x'); plt.ylabel('y'); plt.legend()
plt.title('Sesgo de frontera: promedio local vs recta local (mismo h)'); plt.show()

fit_low = lowess(yb, xb, frac=0.3, it=1, return_sorted=True)
fit_low_grid = np.interp(gx, fit_low[:, 0], fit_low[:, 1])

borde = (gx < 1) | (gx > 9)
m_grid = 0.5 * gx
ajustes = {'Nadaraya–Watson': fit_nw,
           'Lineal local':    fit_ll,
           'LOWESS':          fit_low_grid}

print('RMSE frente a la relación real')
print(f'{"método":<17}{"bordes":>8}{"interior":>10}')
for nombre, f in ajustes.items():
    rmse_borde = np.sqrt(np.mean((f[borde] - m_grid[borde]) ** 2))
    rmse_int = np.sqrt(np.mean((f[~borde] - m_grid[~borde]) ** 2))
    print(f'{nombre:<17}{rmse_borde:>8.3f}{rmse_int:>10.3f}')

RMSE frente a la relación real
método             bordes  interior
Nadaraya–Watson     0.283     0.091
Lineal local        0.020     0.038
LOWESS              0.058     0.065

Elegir el ancho de banda por validación (regresión)

No queremos elegir mirando el conjunto de prueba: dejaría de ser una medida honesta, porque habría participado en la decisión (una fuga de información). Reservamos los datos de prueba y elegimos por validación cruzada (CV, por cross-validation) solo sobre el entrenamiento: el entrenamiento se divide en 5 partes (folds); cada una se usa por turnos para validar mientras las otras cuatro ajustan el modelo, y se promedia el error cuadrático medio (MSE). El conjunto de prueba solo se usa al final, para reportar.

X = x.reshape(-1, 1)
Xtr, Xte, ytr, yte, xtr, xte = train_test_split(
    X, y, x, test_size=0.3, random_state=SEMILLA
)

# K-Fold SOLO sobre el entrenamiento: el conjunto de prueba no entra a elegir h
kf = KFold(n_splits=5, shuffle=True, random_state=SEMILLA)
hs = np.linspace(0.05, 2.5, 50)
errores_cv = []
for h in hs:
    mse_folds = []
    for tr, va in kf.split(xtr):
        pred = nadaraya_watson(xtr[tr], ytr[tr], xtr[va], h)
        mse_folds.append(mean_squared_error(ytr[va], pred))
    errores_cv.append(np.mean(mse_folds))

h_opt = hs[int(np.argmin(errores_cv))]

plt.plot(hs, errores_cv, marker='o', color='steelblue')
plt.axvline(h_opt, color='firebrick', linestyle='--',
            label=f'h óptimo = {h_opt:.2f}')
plt.xlabel('ancho de banda h')
plt.ylabel('MSE de validación (K-Fold)')
plt.legend()
plt.title('Selección de h por CV (solo entrenamiento)')
plt.show()

print(f'h óptimo (CV en entrenamiento): {h_opt:.2f} | MSE de validación: {min(errores_cv):.3f}')

h óptimo (CV en entrenamiento): 0.30 | MSE de validación: 0.254

Comparación: recta, spline y kernel

Cerremos poniendo a competir los tres enfoques sobre los mismos datos de prueba, que no se usaron para elegir nada. El spline elige su número de knots por el mismo K-Fold sobre el entrenamiento; el kernel ya trajo su . Primero la gráfica; después el en prueba.

candidatos_k = list(range(4, 16))
errores_k = []
for k in candidatos_k:
    mse_folds = []
    for tr, va in kf.split(Xtr):
        modelo_k = make_pipeline(
            SplineTransformer(n_knots=k, degree=3, include_bias=False),
            LinearRegression(),
        ).fit(Xtr[tr], ytr[tr])
        mse_folds.append(mean_squared_error(ytr[va], modelo_k.predict(Xtr[va])))
    errores_k.append(np.mean(mse_folds))
k_opt = candidatos_k[int(np.argmin(errores_k))]

recta = LinearRegression().fit(Xtr, ytr)
spline = make_pipeline(
    SplineTransformer(n_knots=k_opt, degree=3, include_bias=False),
    LinearRegression(),
).fit(Xtr, ytr)

r2_lineal = r2_score(yte, recta.predict(Xte))
r2_spline = r2_score(yte, spline.predict(Xte))
r2_kernel = r2_score(yte, nadaraya_watson(xtr, ytr, xte, h_opt))

plt.scatter(xte, yte, s=18, alpha=0.45, label='datos de prueba')
plt.plot(grid_x, recta.predict(grid_x.reshape(-1, 1)),
         color='gray', linewidth=2, label='recta')
plt.plot(grid_x, spline.predict(grid_x.reshape(-1, 1)),
         color='seagreen', linewidth=2, label=f'spline (k={k_opt})')
plt.plot(grid_x, nadaraya_watson(xtr, ytr, grid_x, h_opt),
         color='firebrick', linewidth=2, label=f'kernel (h={h_opt:.2f})')
plt.xlabel('x'); plt.ylabel('y'); plt.legend()
plt.title('Tres formas de ajustar la misma relación')
plt.show()

print(f'n_knots óptimo (CV en entrenamiento): {k_opt}')
print('R2 en prueba (no usado para elegir h ni knots)')
print(f'  Recta (lineal):     {r2_lineal:.3f}')
print(f'  Spline cúbico:      {r2_spline:.3f}')
print(f'  Kernel (NW, h opt): {r2_kernel:.3f}')

n_knots óptimo (CV en entrenamiento): 11
R2 en prueba (no usado para elegir h ni knots)
  Recta (lineal):     0.474
  Spline cúbico:      0.783
  Kernel (NW, h opt): 0.780

Errores comunes al trabajar con kernels

Síntoma	Causa probable	Solución
La densidad se ve llena de picos	ancho de banda demasiado pequeño	súbelo; elígelo por validación
Se pierde una moda o la asimetría	ancho de banda demasiado grande	bájalo; desconfía de las reglas automáticas con datos multimodales
La curva se dobla en los extremos	sesgo de frontera	usa regresión lineal local (LOWESS); interpreta los bordes con cautela
La curva se vuelve errática o queda indefinida donde hay pocos datos	ventana sin vecinos suficientes; con soporte finito puede aparecer 0/0 y con un gaussiano los pesos pueden redondearse a cero	limita el rango de predicción; estabiliza los pesos gaussianos y revisa mediante validación
Resultados raros con varias variables en escalas distintas	el kernel usa distancias	estandariza las variables antes
bandwidth='scott' en sklearn da un muy distinto al de scipy	sklearn no reescala por la dispersión	estandariza antes o fija bandwidth y valídalo
Muy lento con muchos datos	el promedio recorre todos los puntos	usa implementaciones optimizadas (árboles, FFT)

Lo que debes llevarte de este artículo

• Los kernels de suavización usados aquí son funciones de ponderación no negativas, normalizadas y simétricas que favorecen la proximidad; hay varios (gaussiano, Epanechnikov, uniforme) y la elección importa poco frente al ancho de banda.
• El KDE estima una densidad sumando una campana por dato; el estimador de Nadaraya–Watson estima una regresión promediando los vecinos.
• El ancho de banda es el parámetro que controla el compromiso sesgo-varianza y se elige por validación, igual que el número de knots del spline (pero en sentido inverso: más , menos flexibilidad).
• El promedio local sufre sesgo de frontera; la recta local (lineal local, LOWESS) lo reduce. Interpreta los extremos con cautela.
• Spline y regresión por kernel abordan la estimación de una relación no lineal por caminos distintos. En este ejemplo rinden de forma similar; en otros datos el resultado debe comprobarse mediante evaluación.

¿Qué sigue?

Con esto cierras el tema de suavización: splines y kernels, dos formas de modelar relaciones no lineales sin imponer de antemano una forma funcional. La pregunta del próximo tema abre un frente nuevo:

¿Y si la variable que quieres predecir no es un número continuo, sino una categoría (sí/no) o un conteo?

Ahí entran los modelos lineales generalizados (GLM) —regresión logística, Poisson— y su extensión, los modelos aditivos (GAM), que combinan el GLM con suavizadores como los splines que ya conoces (y, en su versión clásica, también con suavizadores locales como los de este artículo). Todo lo que aprendiste sobre suavización reaparece ahí.

Referencias para profundizar

• Henderson, Elements of Nonparametric Statistics, capítulo 12: regresión por kernel y regresión local.
• SciPy: gaussian_kde: reglas de ancho de banda, limitaciones y bibliografía de estimación de densidades.
• scikit-learn: KernelDensity: ancho de banda y evaluación por log-verosimilitud.
• statsmodels: LOWESS: ventana de vecinos, kernel tricúbico e iteraciones robustas.
• NumPy: polyfit: convención de pesos usada para mínimos cuadrados ponderados.

👋 Sobre el autor

Wilder Ramírez Delgado convierte datos en decisiones. Científico de Datos, Arquitecto de IA y asesor tecnológico con más de 20 años de experiencia en analítica avanzada, machine learning, Big Data e IoT. Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), asesora a entidades gubernamentales y empresas privadas en Colombia y es referente en analítica y normatividad para los sectores postal y logístico del país. Una serie pensada para ir de la teoría a la práctica, con ejemplos concretos en cada paso.

📌 Parte de la serie Análisis Avanzado de Datos.

El problema: no todos los barrios entregan igual

Una empresa de mensajería tiene miles de entregas registradas, cada una con su ubicación (latitud, longitud) y el tiempo que tardó. La pregunta operativa es sencilla y valiosa: dada una dirección cualquiera de la ciudad, ¿cuánto tardará una entrega ahí? La respuesta es un mapa de calor: zonas rápidas y zonas lentas.

Este es un problema donde la variable de entrada tiene dos dimensiones (la posición en el mapa), y donde —como veremos— las técnicas que sirvieron en una dimensión fracasan, mientras que el suavizado por kernel resuelve el problema de forma natural. La razón es intuitiva: para saber cuánto tarda una entrega en un punto, lo más sensato es mirar las entregas cercanas en el mapa. Eso es exactamente lo que hace un kernel.

Objetivos

Al terminar este caso vas a ser capaz de:

• Reconocer cuándo un problema tiene estructura espacial (dos dimensiones) y por qué eso rompe a los modelos globales.
• Aplicar la regresión por kernel en dos dimensiones para construir un mapa de calor de predicción.
• Comparar de forma justa el kernel con la regresión lineal, el polinomio bidimensional y los k-vecinos, con validación, sin fuga de información y repitiendo el reparto de los datos con varias semillas.
• Interpretar el ancho de banda como el radio de influencia en el mapa y elegirlo por validación.

Preparación del entorno

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, KFold
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import r2_score, mean_squared_error

SEMILLA = 2026
rng = np.random.default_rng(SEMILLA)
plt.rcParams['figure.figsize'] = (7, 6)
print("librerias cargadas")

librerias cargadas

Los datos: entregas en la ciudad

Simulamos una ciudad en una cuadrícula de 10×10. Cada entrega ocurre en una posición (lon, lat) y tarda un tiempo que depende de la zona: hay un centro congestionado (lento) y otra zona lenta al noroeste; el resto es más rápido. Añadimos ruido para simular la variabilidad real (un día con más tráfico, un repartidor más ágil, etc.). En la práctica no conocemos la fórmula: solo tenemos los puntos.

n = 600
lon = rng.uniform(0, 10, n)
lat = rng.uniform(0, 10, n)

def tiempo_real(lon, lat):
    base = 12
    centro = 35 * np.exp(-0.5 * (((lon - 5) / 1.6) ** 2 + ((lat - 5) / 1.6) ** 2))
    zona_lenta = 22 * np.exp(-0.5 * (((lon - 2.5) / 1.1) ** 2 + ((lat - 7.5) / 1.1) ** 2))
    return base + centro + zona_lenta

tiempo = tiempo_real(lon, lat) + rng.normal(0, 3, n)
X = np.column_stack([lon, lat])
y = tiempo

plt.scatter(lon, lat, c=y, cmap='RdYlGn_r', s=25, edgecolor='gray', linewidth=0.3)
plt.colorbar(label='tiempo de entrega (min)')
plt.xlabel('longitud'); plt.ylabel('latitud')
plt.title('Cada punto es una entrega, coloreada por su tiempo'); plt.show()

print(f'{n} entregas | tiempo medio: {y.mean():.1f} min | rango: {y.min():.1f}-{y.max():.1f} min')

600 entregas | tiempo medio: 19.2 min | rango: 3.5-49.9 min

Preparación para evaluar

Separamos entrenamiento y prueba, y definimos una malla que cubre toda la ciudad para dibujar los mapas de calor de cada modelo. El conjunto de prueba no se usará para elegir ningún parámetro: solo para medir, al final, qué modelo generaliza mejor.

Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=SEMILLA)

# Malla para pintar los mapas de calor
gx = np.linspace(0, 10, 60)
gy = np.linspace(0, 10, 60)
GX, GY = np.meshgrid(gx, gy)
malla = np.column_stack([GX.ravel(), GY.ravel()])

def mapa(valores, titulo):
    plt.contourf(GX, GY, valores.reshape(GX.shape), levels=20, cmap='RdYlGn_r')
    plt.colorbar(label='tiempo estimado (min)')
    plt.scatter(Xtr[:, 0], Xtr[:, 1], c='black', s=4, alpha=0.25)
    plt.xlabel('longitud'); plt.ylabel('latitud'); plt.title(titulo); plt.show()

Intento 1: regresión lineal

Empecemos por lo más simple, lo que ya conoces: una regresión lineal. En dos dimensiones, ajusta un plano — el tiempo sube de forma constante en alguna dirección. ¿Podrá un plano representar una ciudad con un centro lento rodeado de zonas rápidas?

lin = LinearRegression().fit(Xtr, ytr)
r2_lin = r2_score(yte, lin.predict(Xte))
mapa(lin.predict(malla), f'Regresión lineal — R2 = {r2_lin:.3f}')
print(f'R2 en prueba (lineal): {r2_lin:.3f}')

R2 en prueba (lineal): 0.030

Intento 2: polinomio bidimensional

Si un plano no basta, subamos la flexibilidad con un polinomio en dos variables (términos como , , , etc.). Elegimos el grado por validación cruzada para no hacer trampa.

grados = list(range(1, 11))
kf = KFold(5, shuffle=True, random_state=SEMILLA)

# Para cada grado candidato, medimos el error de validación en cada fold
cv_g = []
for g in grados:
    errores_folds = []
    for idx_tr, idx_va in kf.split(Xtr):
        modelo_g = make_pipeline(PolynomialFeatures(g), LinearRegression())
        modelo_g.fit(Xtr[idx_tr], ytr[idx_tr])
        pred_va = modelo_g.predict(Xtr[idx_va])
        errores_folds.append(mean_squared_error(ytr[idx_va], pred_va))
    cv_g.append(np.mean(errores_folds))

g_opt = grados[int(np.argmin(cv_g))]
print('MSE de validación por grado:')
for g, e in zip(grados, cv_g):
    print(f'  grado {g:2d}: {e:10.2f}')

poli = make_pipeline(PolynomialFeatures(g_opt), LinearRegression()).fit(Xtr, ytr)
r2_pol = r2_score(yte, poli.predict(Xte))
mapa(poli.predict(malla), f'Polinomio 2D grado {g_opt} — R2 = {r2_pol:.3f}')
print(f'Grado óptimo: {g_opt} | R2 en prueba (polinomio): {r2_pol:.3f}')

MSE de validación por grado:
  grado  1:      91.26
  grado  2:      48.56
  grado  3:      45.90
  grado  4:      22.94
  grado  5:      21.65
  grado  6:      15.95
  grado  7:      17.81
  grado  8:      14.02
  grado  9:      12.07
  grado 10:      16.15

Grado óptimo: 9 | R2 en prueba (polinomio): 0.851

La idea local: kernel en dos dimensiones

Volvamos a la intuición del problema: para estimar el tiempo en un punto del mapa, lo natural es promediar las entregas cercanas, dándoles más peso cuanto más cerca estén. Eso es la regresión por kernel, ahora con la distancia medida en el plano:

donde es la distancia entre dos puntos del mapa y es el radio de influencia (el ancho de banda). No hay que decidir estructuras ni grados: solo ese radio.

def kernel_2d(Xtr, ytr, Xq, h):
    out = np.empty(len(Xq))
    for i, q in enumerate(Xq):
        d2 = np.sum((Xtr - q) ** 2, axis=1)     # distancia al cuadrado en el mapa
        w = np.exp(-0.5 * d2 / h ** 2)          # peso: decae con la distancia
        s = w.sum()
        out[i] = (w * ytr).sum() / s if s > 0 else np.nan
    return out

mapa_kernel = kernel_2d(Xtr, ytr, malla, h=0.45)
mapa(mapa_kernel, 'Kernel 2D (h=0.45)')

El ancho de banda es el radio de influencia

En dos dimensiones, tiene una lectura muy física: cuán lejos alcanza la vecindad que se promedia para cada punto. Comparemos tres radios; el del medio, 0.45, es el que la validación elegirá un poco más adelante.

fig, ax = plt.subplots(1, 3, figsize=(16, 5))
for a, h in zip(ax, [0.15, 0.45, 3.0]):
    val = kernel_2d(Xtr, ytr, malla, h).reshape(GX.shape)
    cf = a.contourf(GX, GY, val, levels=20, cmap='RdYlGn_r')
    a.set_title(f'h = {h}'); a.set_xlabel('longitud')
ax[0].set_ylabel('latitud')
plt.tight_layout(); plt.show()

Elegir el radio por validación

Como siempre, no elegimos a simple vista: probamos varios por validación cruzada sobre el entrenamiento y nos quedamos con el que mejor generaliza.

hs = np.linspace(0.3, 4.0, 25)

# Para cada radio candidato, medimos el error de validación en cada fold
cv_h = []
for h in hs:
    errores_folds = []
    for idx_tr, idx_va in kf.split(Xtr):
        pred_va = kernel_2d(Xtr[idx_tr], ytr[idx_tr], Xtr[idx_va], h)
        errores_folds.append(mean_squared_error(ytr[idx_va], pred_va))
    cv_h.append(np.mean(errores_folds))

h_opt = hs[int(np.argmin(cv_h))]

plt.figure(figsize=(8, 4))
plt.plot(hs, cv_h, marker='o', color='steelblue')
plt.axvline(h_opt, color='firebrick', linestyle='--', label=f'h óptimo = {h_opt:.2f}')
plt.xlabel('radio h'); plt.ylabel('MSE de validación'); plt.legend()
plt.title('Selección del radio de influencia'); plt.show()

print(f'h óptimo (validación cruzada): {h_opt:.2f} | MSE de validación: {min(cv_h):.2f}')

h óptimo (validación cruzada): 0.45 | MSE de validación: 11.89

Comparación final: los cuatro modelos, lado a lado

Ponemos a competir los cuatro enfoques sobre datos de prueba que no se usaron para elegir nada. Añadimos los k-vecinos (kNN), otro método local, para una comparación completa. Primero miramos los cuatro mapas de un mismo reparto de datos; después repetimos todo con varios repartos para ver cuánto de lo que observamos es real y cuánto es azar.

ks = list(range(3, 31))

# Para cada número de vecinos k, medimos el error de validación en cada fold
cv_k = []
for k in ks:
    errores_folds = []
    for idx_tr, idx_va in kf.split(Xtr):
        modelo_k = KNeighborsRegressor(n_neighbors=k)
        modelo_k.fit(Xtr[idx_tr], ytr[idx_tr])
        pred_va = modelo_k.predict(Xtr[idx_va])
        errores_folds.append(mean_squared_error(ytr[idx_va], pred_va))
    cv_k.append(np.mean(errores_folds))

k_opt = ks[int(np.argmin(cv_k))]
knn = KNeighborsRegressor(n_neighbors=k_opt).fit(Xtr, ytr)

r2_knn = r2_score(yte, knn.predict(Xte))
r2_ker = r2_score(yte, kernel_2d(Xtr, ytr, Xte, h_opt))

modelos = {
    f'Lineal (R2={r2_lin:.3f})': lin.predict(malla),
    f'Polinomio g{g_opt} (R2={r2_pol:.3f})': poli.predict(malla),
    f'kNN k{k_opt} (R2={r2_knn:.3f})': knn.predict(malla),
    f'Kernel h{h_opt:.2f} (R2={r2_ker:.3f})': kernel_2d(Xtr, ytr, malla, h_opt),
}
fig, ax = plt.subplots(2, 2, figsize=(13, 11))
for a, (titulo, val) in zip(ax.ravel(), modelos.items()):
    a.contourf(GX, GY, val.reshape(GX.shape), levels=20, cmap='RdYlGn_r')
    a.set_title(titulo); a.set_xlabel('longitud'); a.set_ylabel('latitud')
plt.tight_layout(); plt.show()

print(f'R2 en prueba, split con semilla {SEMILLA} (no usado para elegir parámetros)')
print(f'  Lineal:          {r2_lin:.3f}')
print(f'  Polinomio 2D:    {r2_pol:.3f}')
print(f'  kNN:             {r2_knn:.3f}')
print(f'  Kernel 2D:       {r2_ker:.3f}')

R2 en prueba, split con semilla 2026 (no usado para elegir parámetros)
  Lineal:          0.030
  Polinomio 2D:    0.851
  kNN:             0.855
  Kernel 2D:       0.867

¿Y si cambia el reparto? La comparación con varias semillas

Los R² de arriba salen de un solo reparto entrenamiento/prueba. Si otra semilla mandara otros puntos al conjunto de prueba, ¿el orden de los modelos seguiría igual? Diferencias de un centésimo pueden ser puro azar del reparto.

Para saberlo, repetimos todo el protocolo con 10 semillas distintas. En cada una: separamos, elegimos , y por validación cruzada solo con el entrenamiento de esa semilla, y medimos el R² en su prueba. Al final reportamos el promedio y la desviación de cada modelo. Para que no tarde demasiado, aquí usamos rejillas de hiperparámetros algo más gruesas que en las secciones anteriores.

semillas = list(range(10))
grados_m = list(range(1, 11))
ks_m = list(range(3, 31, 3))
hs_m = np.linspace(0.3, 2.0, 10)

r2_por_modelo = {'Lineal': [], 'Polinomio 2D': [], 'kNN': [], 'Kernel 2D': []}

for semilla in semillas:
    Xtr_s, Xte_s, ytr_s, yte_s = train_test_split(X, y, test_size=0.3, random_state=semilla)
    kf_s = KFold(5, shuffle=True, random_state=semilla)

    # Lineal: no tiene hiperparámetros
    lin_s = LinearRegression().fit(Xtr_s, ytr_s)
    r2_por_modelo['Lineal'].append(r2_score(yte_s, lin_s.predict(Xte_s)))

    # Polinomio: elegir el grado por validación cruzada
    cv_grados = []
    for g in grados_m:
        errores = []
        for i_tr, i_va in kf_s.split(Xtr_s):
            m = make_pipeline(PolynomialFeatures(g), LinearRegression())
            m.fit(Xtr_s[i_tr], ytr_s[i_tr])
            errores.append(mean_squared_error(ytr_s[i_va], m.predict(Xtr_s[i_va])))
        cv_grados.append(np.mean(errores))
    g_s = grados_m[int(np.argmin(cv_grados))]
    poli_s = make_pipeline(PolynomialFeatures(g_s), LinearRegression()).fit(Xtr_s, ytr_s)
    r2_por_modelo['Polinomio 2D'].append(r2_score(yte_s, poli_s.predict(Xte_s)))

    # kNN: elegir k por validación cruzada
    cv_ks = []
    for k in ks_m:
        errores = []
        for i_tr, i_va in kf_s.split(Xtr_s):
            m = KNeighborsRegressor(n_neighbors=k).fit(Xtr_s[i_tr], ytr_s[i_tr])
            errores.append(mean_squared_error(ytr_s[i_va], m.predict(Xtr_s[i_va])))
        cv_ks.append(np.mean(errores))
    k_s = ks_m[int(np.argmin(cv_ks))]
    knn_s = KNeighborsRegressor(n_neighbors=k_s).fit(Xtr_s, ytr_s)
    r2_por_modelo['kNN'].append(r2_score(yte_s, knn_s.predict(Xte_s)))

    # Kernel: elegir el radio h por validación cruzada
    cv_hs = []
    for h in hs_m:
        errores = []
        for i_tr, i_va in kf_s.split(Xtr_s):
            pred = kernel_2d(Xtr_s[i_tr], ytr_s[i_tr], Xtr_s[i_va], h)
            errores.append(mean_squared_error(ytr_s[i_va], pred))
        cv_hs.append(np.mean(errores))
    h_s = hs_m[int(np.argmin(cv_hs))]
    r2_por_modelo['Kernel 2D'].append(r2_score(yte_s, kernel_2d(Xtr_s, ytr_s, Xte_s, h_s)))

print(f'R2 en prueba con {len(semillas)} semillas (promedio ± desviación)')
for nombre, valores in r2_por_modelo.items():
    print(f'  {nombre:<14s} {np.mean(valores):.3f} ± {np.std(valores, ddof=1):.3f}')

# Diferencia kernel - kNN, semilla por semilla (mismo reparto para ambos)
dif = np.array(r2_por_modelo['Kernel 2D']) - np.array(r2_por_modelo['kNN'])
print(f'\nKernel - kNN: {dif.mean():+.3f} ± {dif.std(ddof=1):.3f} '
      f'| el kernel gana en {int((dif > 0).sum())} de {len(semillas)} semillas')
dif_pol = np.array(r2_por_modelo['Kernel 2D']) - np.array(r2_por_modelo['Polinomio 2D'])
print(f'Kernel - Polinomio: {dif_pol.mean():+.3f} ± {dif_pol.std(ddof=1):.3f} '
      f'| el kernel gana en {int((dif_pol > 0).sum())} de {len(semillas)} semillas')

plt.figure(figsize=(8, 4))
plt.boxplot(list(r2_por_modelo.values()))
plt.xticks(range(1, 5), list(r2_por_modelo.keys()))
plt.ylabel('R2 en prueba')
plt.title(f'R2 en prueba con {len(semillas)} repartos distintos')
plt.show()

R2 en prueba con 10 semillas (promedio ± desviación)
  Lineal         0.030 ± 0.018
  Polinomio 2D   0.843 ± 0.031
  kNN            0.871 ± 0.011
  Kernel 2D      0.876 ± 0.012

Kernel - kNN: +0.005 ± 0.005 | el kernel gana en 8 de 10 semillas
Kernel - Polinomio: +0.034 ± 0.035 | el kernel gana en 8 de 10 semillas

Por qué el 2D cambió el resultado

En una sola dimensión, un spline bien afinado suele igualar al kernel; no hay un ganador claro. Pero al pasar a dos dimensiones la balanza se inclina: los métodos globales (polinomios) se vuelven inestables y necesitan muchísimos términos, y los splines requieren productos entre dimensiones que se complican rápido. El suavizado por kernel, en cambio, apenas cambia: sigue siendo “promedia lo cercano”, solo que ahora la cercanía se mide en el plano. Esa simplicidad que no se degrada al subir de dimensión es su gran fortaleza — y por eso los métodos de kernel son un pilar en problemas espaciales, de imágenes y de datos de alta dimensión.

Errores comunes en problemas espaciales con kernels

Lo que debes llevarte de este caso

• Cuando el problema tiene estructura espacial (dos o más variables de entrada), los modelos globales —recta, polinomio— fracasan o se vuelven inestables.
• El suavizado por kernel resuelve el problema con la misma idea de siempre (promediar lo cercano), y su simplicidad no se degrada al subir de dimensión.
• El ancho de banda es, literalmente, el radio de influencia en el mapa, y se elige por validación.
• Los métodos locales (kernel, kNN) superan con claridad a la recta y con margen moderado al polinomio, que además es el más inestable. Entre kernel y kNN el R² no decide (diferencia de 0.005 con 10 semillas); el kernel gana por dar el mapa más suave.
• Antes de declarar un ganador, repite la comparación con varias semillas: una diferencia de un centésimo en un solo reparto puede ser puro azar.

¿Qué sigue?

Has visto la suavización por kernel llevar un problema real de una y dos dimensiones a un mapa útil para decidir. El siguiente tema cambia de pregunta: ¿y si lo que quieres predecir no es un número, sino una categoría (entrega a tiempo sí/no) o un conteo (número de incidencias)? Ahí entran los modelos lineales generalizados (GLM) y su extensión, los modelos aditivos (GAM), que combinan estas ideas con la regresión.

👋 Sobre el autor

Wilder Ramírez Delgado convierte datos en decisiones. Científico de Datos, Arquitecto de IA y asesor tecnológico con más de 20 años de experiencia en analítica avanzada, machine learning, Big Data e IoT. Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), asesora a entidades gubernamentales y empresas privadas en Colombia y es referente en analítica y normatividad para los sectores postal y logístico del país. Una serie pensada para ir de la teoría a la práctica, con ejemplos concretos en cada paso.

📌 Parte de la serie Análisis Avanzado de Datos.

Cuando la respuesta es sí o no

Hasta ahora, de la regresión lineal a los splines y los kernels, predijiste números continuos: un tiempo, un flujo, un costo. Pero muchas de las preguntas más importantes tienen respuesta binaria: ¿esta entrega llegará a tiempo o no? ¿este cliente se irá o se quedará? ¿esta transacción es fraude o no? Para eso, la regresión lineal no sirve: podría predecir una “probabilidad” de 1.4 o de −0.3, que no significan nada.

La regresión logística resuelve esto. Es el primer paso hacia los modelos lineales generalizados (GLM): en vez de predecir el valor directamente, predice la probabilidad de que ocurra el sí, garantizando que quede siempre entre 0 y 1. En este artículo la construimos sobre un caso de logística de entregas con datos simulados, la pregunta que dejó planteada el caso aplicado de entregas: predecir si una entrega llegará a tiempo.

Objetivos de aprendizaje

Al terminar este notebook vas a ser capaz de:

• Reconocer cuándo una variable respuesta es binaria y por qué una regresión lineal no respeta su distribución.
• Describir las tres piezas de un GLM logístico: respuesta Bernoulli, predictor lineal y función de enlace logit.
• Distinguir probabilidad, odds y log-odds, y convertir coeficientes en odds ratios.
• Ajustar una regresión logística y obtener probabilidades para observaciones nuevas.
• Explicar cómo un umbral convierte probabilidades en clases y cómo afecta los tipos de error.
• Evaluar el modelo con matriz de confusión, exactitud y área bajo la curva ROC (AUC).
• Distinguir el uso de scikit-learn para predicción y de statsmodels para inferencia.

Preparación del entorno

Cargamos las librerías y fijamos una semilla global, SEMILLA = 2026, de la que salen la simulación de los datos y la partición en entrenamiento y prueba.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix, roc_curve
import statsmodels.api as sm

SEMILLA = 2026
rng = np.random.default_rng(SEMILLA)
plt.rcParams['figure.figsize'] = (8, 4)

Los datos: ¿la entrega llega a tiempo?

Simulamos 800 entregas. De cada una conocemos la distancia (km) y si se hizo en hora pico, y queremos predecir si llegó a tiempo (1) o no (0). Por construcción, la probabilidad de llegar a tiempo baja con la distancia y baja también en hora pico. En la práctica no conocemos esa regla: la inferimos de los datos.

n = 800
distancia = rng.uniform(1, 25, n)          # km
hora_pico = rng.integers(0, 2, n)          # 1 = hora pico

# Regla oculta (log-odds de llegar a tiempo): baja con distancia y en hora pico
logit = 3.2 - 0.18 * distancia - 1.1 * hora_pico
prob = 1 / (1 + np.exp(-logit))
a_tiempo = rng.binomial(1, prob)

X = np.column_stack([distancia, hora_pico])
y = a_tiempo
print(f'{n} entregas | llegaron a tiempo: {y.mean():.1%}')
pd.DataFrame({'distancia': distancia[:5], 'hora_pico': hora_pico[:5], 'a_tiempo': y[:5]})

800 entregas | llegaron a tiempo: 56.4%

Por qué la regresión lineal no sirve aquí

Antes de buscar una solución, veamos el fracaso de la herramienta conocida. Para aislar el problema, usaremos únicamente las entregas realizadas fuera de hora pico y ajustaremos una regresión lineal de a_tiempo contra distancia. Así, la demostración es univariada y la forma del gráfico no mezcla el efecto de la segunda variable.

mascara_normal = hora_pico == 0
distancia_normal = distancia[mascara_normal]
y_normal = y[mascara_normal]

lin = LinearRegression().fit(distancia_normal.reshape(-1, 1), y_normal)
grid_lineal = np.linspace(0, 40, 250).reshape(-1, 1)
pred_grid_lineal = lin.predict(grid_lineal)

plt.scatter(distancia_normal, y_normal, s=12, alpha=0.3, label='entregas fuera de hora pico')
plt.plot(grid_lineal, pred_grid_lineal, color='firebrick', linewidth=2, label='regresión lineal')
plt.axhline(0, color='gray', ls=':'); plt.axhline(1, color='gray', ls=':')
plt.axvline(distancia_normal.max(), color='gray', ls='--', alpha=0.6, label='máximo observado')
plt.xlabel('distancia (km)'); plt.ylabel('¿llegó a tiempo?'); plt.legend(loc='center right')
plt.title('La recta produce "probabilidades" fuera de [0, 1]'); plt.show()

for km in [0, 30, 40]:
    print(f'Predicción de la recta a {km:>2} km: {lin.predict([[km]])[0]:.2f}')

print(f'Distancias observadas: {distancia_normal.min():.1f} a {distancia_normal.max():.1f} km')
print(f'La recta cruza 1 a {(1 - lin.intercept_) / lin.coef_[0]:.1f} km y 0 a {-lin.intercept_ / lin.coef_[0]:.1f} km')

Predicción de la recta a  0 km: 1.10
Predicción de la recta a 30 km: 0.14
Predicción de la recta a 40 km: -0.17
Distancias observadas: 1.0 a 24.9 km
La recta cruza 1 a 3.0 km y 0 a 34.5 km

La arquitectura formal del GLM logístico

Una regresión logística combina tres piezas:

1. Distribución de la respuesta: cada entrega es un ensayo Bernoulli.
2. Predictor lineal: las variables se combinan en una cantidad sin restricciones.
3. Función de enlace: el logit conecta la media de la respuesta con el predictor.

Pieza	Regresión logística
Respuesta	Bernoulli
Media
Predictor lineal
Enlace	logit
Función inversa	sigmoide

La parte lineal sigue ahí, pero ya no intenta predecir directamente un cero o un uno. Predice en la escala logit y después regresa a una probabilidad. Construyamos esa transformación paso a paso.

Paso 1: de la probabilidad a las odds

Las odds (en español, momios) expresan cuántas veces esperamos el evento por cada no evento:

Si , las odds son 1: uno a uno. Si , las odds son 4: cuatro entregas puntuales por cada entrega tardía. Mientras vive entre 0 y 1, las odds van de 0 a infinito.

probs = np.array([0.1, 0.25, 0.5, 0.75, 0.9])
odds_ejemplo = probs / (1 - probs)
pd.DataFrame({
    'probabilidad': probs,
    'odds = p/(1-p)': odds_ejemplo,
}).round(3)

Paso 2: de las odds a los log-odds

El logaritmo de las odds se llama log-odds o logit. Aplicar el logaritmo transforma en toda la recta real:

Así, corresponde a log-odds 0; probabilidades mayores producen valores positivos y probabilidades menores, negativos. Esta es la escala donde el modelo puede usar una combinación lineal sin restricciones.

grid_p = np.linspace(0.001, 0.999, 300)
fig, ax = plt.subplots(1, 2, figsize=(12, 4))
ax[0].plot(grid_p, grid_p / (1 - grid_p), color='steelblue', linewidth=2)
ax[0].set(title='Odds (eje cortado en 20)', xlabel='probabilidad', ylabel='p/(1-p)', ylim=(0, 20))
ax[1].plot(grid_p, np.log(grid_p / (1 - grid_p)), color='seagreen', linewidth=2)
ax[1].axhline(0, color='gray', ls=':')
ax[1].set(title='Log-odds o logit', xlabel='probabilidad', ylabel='log(p/(1-p))')
plt.tight_layout()
plt.show()

Paso 3: volver a la probabilidad con la sigmoide

La inversa del logit es la función logística:

Esta transformación toma cualquier valor real de y lo devuelve al intervalo abierto : se acerca a 0 y a 1 sin alcanzarlos. Esa es la curva en forma de S que reemplaza a la recta fallida del inicio.

z = np.linspace(-8, 8, 200)
plt.plot(z, 1 / (1 + np.exp(-z)), color='steelblue', linewidth=2)
plt.axhline(0, color='gray', ls=':'); plt.axhline(1, color='gray', ls=':')
plt.axhline(0.5, color='firebrick', ls='--', alpha=0.6)
plt.xlabel('η = combinación lineal'); plt.ylabel('probabilidad')
plt.title('La función logística (sigmoide): siempre entre 0 y 1'); plt.show()

eta_ejemplo = np.array([-2.0, 0.0, 2.0])
p_ejemplo = 1 / (1 + np.exp(-eta_ejemplo))
tabla_escalas = pd.DataFrame({
    'η = log-odds': eta_ejemplo,
    'odds = exp(η)': np.exp(eta_ejemplo),
    'probabilidad': p_ejemplo,
})
tabla_escalas.round(3)

Cómo leer este resultado

La curva en forma de S nunca sale del intervalo . Cuando , las odds son : el evento y el no evento tienen la misma posibilidad, por lo que . Cuando , las odds son aproximadamente 7.39 a 1 y la probabilidad es cercana a 0.881. Cuando , las odds son aproximadamente 0.135 y la probabilidad baja a 0.119.

Las tres escalas expresan la misma predicción, pero responden preguntas distintas:

Escala	Expresión	Lectura
Probabilidad		proporción esperada de eventos
Odds		eventos esperados por cada no evento
Log-odds		escala lineal donde actúan los coeficientes

La probabilidad es la escala más natural para comunicar una predicción. Las odds y los log-odds son las escalas que permiten formular e interpretar el modelo.

z_param = np.linspace(-6, 6, 300)
fig, ax = plt.subplots(1, 2, figsize=(12, 4))

for beta_1 in [0.5, 1.0, 3.0]:
    ax[0].plot(z_param, 1 / (1 + np.exp(-(beta_1 * z_param))), label=rf'$\beta_1={beta_1}$')
ax[0].set(title='La pendiente controla la transición', xlabel='x', ylabel='probabilidad')
ax[0].legend()

for beta_0 in [-3.0, 0.0, 3.0]:
    ax[1].plot(z_param, 1 / (1 + np.exp(-(z_param + beta_0))), label=rf'$\beta_0={beta_0}$')
ax[1].set(title='El intercepto desplaza el punto medio', xlabel='x', ylabel='probabilidad')
ax[1].legend()

plt.tight_layout()
plt.show()

Ajustar el modelo predictivo

Separamos entrenamiento y prueba con estratificación para conservar aproximadamente la proporción de entregas puntuales en ambos conjuntos.

El modelo de scikit-learn tendrá un propósito predictivo: aprende únicamente con entrenamiento y se evalúa con probabilidades y decisiones sobre prueba. LogisticRegression aplica por defecto una penalización L2 (la misma de Ridge) con C=1.0, donde C es el inverso de la fuerza de la penalización; eso ayuda a estabilizar los coeficientes. Aquí no ajustamos C por validación cruzada porque el objetivo es ilustrar el modelo, no optimizarlo. Más adelante ajustaremos statsmodels sobre el mismo entrenamiento, pero con un propósito inferencial.

X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=SEMILLA, stratify=y
)

modelo_predictivo = LogisticRegression().fit(X_tr, y_tr)
prob_te = modelo_predictivo.predict_proba(X_te)[:, 1]
UMBRAL = 0.5
pred_te = (prob_te >= UMBRAL).astype(int)

print('Coeficientes predictivos (distancia, hora_pico):', modelo_predictivo.coef_[0].round(3))
print('Intercepto predictivo:', round(modelo_predictivo.intercept_[0], 3))
print(f'Probabilidades en prueba: {prob_te.min():.3f} a {prob_te.max():.3f}')

Coeficientes predictivos (distancia, hora_pico): [-0.171 -1.045]
Intercepto predictivo: 3.228
Probabilidades en prueba: 0.109 a 0.944

Visualizar el ajuste

Antes de interpretar los odds ratios, dibujemos la probabilidad estimada según la distancia para una entrega fuera de hora pico y para una entrega en hora pico. Las dos curvas proceden del mismo modelo; solo cambia el indicador hora_pico.

distancia_grid = np.linspace(0, 30, 300)
for indicador_pico, color, etiqueta in [
    (0, 'seagreen', 'fuera de hora pico'),
    (1, 'firebrick', 'hora pico'),
]:
    X_grid = np.column_stack([distancia_grid, np.full_like(distancia_grid, indicador_pico)])
    plt.plot(
        distancia_grid,
        modelo_predictivo.predict_proba(X_grid)[:, 1],
        color=color, linewidth=2, label=etiqueta,
    )

plt.axhline(0.5, color='gray', ls='--', alpha=0.6)
plt.xlabel('distancia (km)')
plt.ylabel('probabilidad de llegar a tiempo')
plt.title('Probabilidad estimada según distancia y hora pico')
plt.legend()
plt.show()

Modelo inferencial y odds ratios

Ahora ajustamos statsmodels sobre el mismo conjunto de entrenamiento. Su propósito es inferencial: obtener coeficientes, odds ratios y p-valores.

LogisticRegression usa regularización L2 por defecto; sm.Logit no regulariza. Por eso sus coeficientes pueden diferir aunque vean las mismas observaciones. Si necesitas coeficientes comparables, ajusta scikit-learn sin penalización con LogisticRegression(C=np.inf): desde la versión 1.8 el parámetro penalty está obsoleto (emite un aviso y se eliminará en la 1.10).

Para una variable , es el odds ratio (razón de odds): el factor por el que se multiplican las odds cuando aumenta una unidad, manteniendo constantes las demás variables. Para un cambio de unidades, el factor acumulado es .

X_tr_sm = sm.add_constant(X_tr)
modelo_inferencial = sm.Logit(y_tr, X_tr_sm).fit(disp=0)

nombres = ['intercepto', 'distancia', 'hora_pico']
coeficientes = pd.Series(modelo_inferencial.params, index=nombres)
odds_ratios = np.exp(coeficientes)
p_valores = pd.Series(modelo_inferencial.pvalues, index=nombres)

ic_or = np.exp(modelo_inferencial.conf_int())   # IC 95% en escala de odds ratio

tabla_inferencia = pd.DataFrame({
    'coeficiente': coeficientes.round(4),
    'odds ratio': odds_ratios.round(4),
    'OR IC95% inf': ic_or[:, 0].round(3),
    'OR IC95% sup': ic_or[:, 1].round(3),
    'p-valor': p_valores.map(lambda v: f'{v:.1e}'),
})
display(tabla_inferencia)

or_distancia_10km = odds_ratios['distancia'] ** 10
print(f"OR acumulado para 10 km adicionales: {or_distancia_10km:.3f}")

perfiles = pd.DataFrame({
    'distancia_km': [5, 5, 15, 15, 25, 25],
    'hora_pico': [0, 1, 0, 1, 0, 1],
})
X_perfiles = perfiles[['distancia_km', 'hora_pico']].to_numpy()
perfiles['probabilidad_llegar_a_tiempo'] = modelo_predictivo.predict_proba(X_perfiles)[:, 1]
display(perfiles.round(3))

OR acumulado para 10 km adicionales: 0.178

De la probabilidad a la decisión

El modelo estima la probabilidad de que la entrega llegue a tiempo. Para convertirla en una decisión usamos un umbral: con 0.5, declaramos “llega a tiempo” cuando .

• Falso positivo: prometimos “llega a tiempo”, pero llegó tarde. Es una falsa promesa.
• Falso negativo: predijimos “no llega a tiempo”, pero sí llegó. Es una alerta innecesaria.

Un umbral alto exige más evidencia antes de prometer puntualidad: reduce falsas promesas, pero genera más alertas innecesarias. Un umbral bajo declara más entregas como puntuales: aumenta la cobertura de los casos que sí llegan, pero puede producir más falsas promesas.

Primero compararemos la exactitud (proporción de entregas clasificadas correctamente) con una línea base (baseline): la regla ingenua que siempre predice la clase mayoritaria. Después observaremos cómo cambian los errores al mover el umbral y usaremos el AUC (área bajo la curva ROC) para evaluar la capacidad de ordenar casos sin fijar un único corte.

acc = accuracy_score(y_te, pred_te)
auc = roc_auc_score(y_te, prob_te)
accuracy_base = max(y_te.mean(), 1 - y_te.mean())

cm = confusion_matrix(y_te, pred_te)
print(f'Matriz de confusión con umbral = {UMBRAL:.2f}:')
display(pd.DataFrame(cm, index=['real: no', 'real: sí'], columns=['pred: no', 'pred: sí']))
print(f'Exactitud del modelo: {acc:.3f}')
print(f'Línea base (siempre la clase mayoritaria): {accuracy_base:.3f}')
print(f'Mejora absoluta sobre la línea base: {acc - accuracy_base:.3f}')
print(f'AUC: {auc:.3f}')

filas_umbral = []
for umbral in [0.3, 0.5, 0.7]:
    pred_umbral = (prob_te >= umbral).astype(int)
    tn, fp, fn, tp = confusion_matrix(y_te, pred_umbral).ravel()
    filas_umbral.append({
        'umbral': umbral,
        '% declarado puntual': pred_umbral.mean(),
        'falsas promesas (FP)': fp,
        'alertas innecesarias (FN)': fn,
        'exactitud': accuracy_score(y_te, pred_umbral),
    })

tabla_umbrales = pd.DataFrame(filas_umbral)
display(tabla_umbrales.round(3))

Matriz de confusión con umbral = 0.50:

Exactitud del modelo: 0.708
Línea base (siempre la clase mayoritaria): 0.562
Mejora absoluta sobre la línea base: 0.146
AUC: 0.800

Evaluar sin fijar un único umbral: ROC y AUC

La curva ROC (receiver operating characteristic) recorre todos los umbrales y enfrenta dos tasas: la de verdaderos positivos, , que es la fracción de entregas puntuales que el modelo declara puntuales, y la de falsos positivos, , que es la fracción de entregas tardías que declara puntuales (las falsas promesas). Con umbral 0.5 valen 0.741 y 0.333. El AUC (área bajo esa curva) resume la capacidad del modelo para ordenar una entrega puntual por encima de una tardía según su probabilidad estimada.

fpr, tpr, _ = roc_curve(y_te, prob_te)
plt.plot(fpr, tpr, color='steelblue', linewidth=2, label=f'AUC = {auc:.3f}')
plt.plot([0, 1], [0, 1], 'k--', alpha=0.5, label='azar')
plt.xlabel('tasa de falsos positivos'); plt.ylabel('tasa de verdaderos positivos')
plt.title('Curva ROC'); plt.legend(); plt.show()

Errores comunes en regresión logística

1. Interpretar un coeficiente como cambio directo en probabilidad. cambia los log-odds y multiplica las odds.
2. Confundir la clase positiva. Aquí 1 significa “llega a tiempo”; una probabilidad alta no significa “mayor riesgo de retraso”.
3. Confundir probabilidad con decisión. El umbral convierte una estimación continua en una clase y debe responder al costo de los errores.
4. Evaluar solamente con exactitud. Compárala con una línea base y revisa qué tipos de error produce cada umbral.
5. Interpretar asociación como causalidad. Un coeficiente ajustado no demuestra que intervenir sobre la variable cause el cambio.
6. Leer un p-valor como tamaño o importancia del efecto. El p-valor y el odds ratio responden preguntas diferentes.
7. Comparar coeficientes regularizados y no regularizados como si fueran idénticos. scikit-learn y statsmodels pueden estimar valores distintos aun usando el mismo entrenamiento.
8. Confundir discriminación con calibración. Un AUC alto no garantiza probabilidades bien calibradas.

Lo que debes llevarte de este artículo

La cadena completa es:

respuesta binaria
→ distribución Bernoulli
→ predictor lineal η = Xβ
→ enlace logit
→ probabilidad mediante la sigmoide
→ umbral elegido según costos
→ decisión: llega a tiempo / no llega a tiempo

Los coeficientes viven en log-odds; sus exponenciales son odds ratios. Para comunicar una predicción concreta usamos probabilidades por perfil. Para evaluar, comparamos contra una línea base, examinamos los errores del umbral y usamos AUC para medir discriminación.

La regresión logística conserva una estructura lineal, pero adapta la distribución y la función de enlace al tipo de respuesta. Esa es la idea general que reutilizaremos en los próximos artículos de la serie (Poisson y modelos aditivos): no forzar todas las respuestas a una recta gaussiana, sino elegir una distribución y un enlace coherentes con el fenómeno. De hecho, la regresión lineal de los primeros artículos es el GLM más simple: respuesta normal y enlace identidad.

¿Qué sigue?

El paralelo que prepara el siguiente artículo es directo:

En logística preguntamos si una entrega llega a tiempo. En Poisson preguntaremos cuántos eventos ocurren. Cambian la distribución y el enlace; permanece la arquitectura GLM.

👋 Sobre el autor

Wilder Ramírez Delgado convierte datos en decisiones. Científico de Datos, Arquitecto de IA y asesor tecnológico con más de 20 años de experiencia en analítica avanzada, machine learning, Big Data e IoT. Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), asesora a entidades gubernamentales y empresas privadas en Colombia y es referente en analítica y normatividad para los sectores postal y logístico del país. Una serie pensada para ir de la teoría a la práctica, con ejemplos concretos en cada paso.

📌 Parte de la serie Análisis Avanzado de Datos.

Cuando lo que cuentas son eventos

En el artículo anterior la respuesta era sí o no. Ahora la respuesta es un conteo: ¿cuántas incidencias tuvo una ruta? ¿cuántos pedidos llegaron en una hora? ¿cuántas llamadas recibió el centro de soporte? Son números enteros, nunca negativos, y a menudo con muchos ceros.

Usar una regresión lineal para conteos es un error clásico: puede predecir −1.5 incidencias, que es imposible. La regresión de Poisson —otro modelo lineal generalizado (GLM, por sus siglas en inglés)— está hecha justo para esto: modela la tasa a la que ocurren los eventos y garantiza predicciones positivas. La construimos sobre un caso de transporte: predecir el número de incidencias por ruta.

Objetivos de aprendizaje

Al terminar este notebook vas a ser capaz de:

• Reconocer cuándo una respuesta es un conteo y por qué una regresión lineal puede producir predicciones imposibles.
• Describir las tres piezas de un GLM de Poisson: distribución, predictor lineal y enlace log.
• Explicar por qué la función exponencial garantiza una tasa esperada positiva.
• Ajustar un modelo predictivo con PoissonRegressor, elegir su regularización por validación cruzada y evaluarlo sobre datos de prueba.
• Interpretar coeficientes como cocientes de tasas de incidencia (IRR), incluidos cambios de varias unidades.
• Distinguir el propósito predictivo de scikit-learn del propósito inferencial de statsmodels.
• Comparar el modelo con un baseline de media constante mediante deviance de Poisson.
• Reconocer el supuesto de equidispersión y la señal básica de sobredispersión.

Preparación del entorno

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import poisson as poisson_dist
from sklearn.model_selection import train_test_split, GridSearchCV, KFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, PoissonRegressor
from sklearn.metrics import mean_absolute_error, mean_poisson_deviance
import statsmodels.api as sm

SEMILLA = 7
rng = np.random.default_rng(SEMILLA)
plt.rcParams['figure.figsize'] = (8, 4)
plt.rcParams['axes.spines.top'] = False
plt.rcParams['axes.spines.right'] = False

Los datos: incidencias por ruta

Simulamos 700 rutas. De cada una conocemos su longitud (km) y si tuvo clima adverso, y contamos cuántas incidencias (retrasos, fallos, novedades) ocurrieron. Por construcción, la tasa de incidencias sube con la longitud y con el mal clima.

n = 700
longitud = rng.uniform(5, 60, n)
clima_adverso = rng.integers(0, 2, n)

# Regla oculta: la tasa media crece con longitud y clima adverso.
tasa_real = np.exp(-1.0 + 0.045 * longitud + 0.6 * clima_adverso)
incidencias = rng.poisson(tasa_real)

X = np.column_stack([longitud, clima_adverso])
y = incidencias

print(f'Rutas: {n}')
print(f'Media de incidencias: {y.mean():.3f}')
print(f'Varianza de incidencias: {y.var(ddof=1):.3f}')
print(f'Máximo observado: {y.max()}')
print(f'Rutas sin incidencias: {np.mean(y == 0):.1%}')
pd.DataFrame({
    'longitud_km': longitud[:6],
    'clima_adverso': clima_adverso[:6],
    'incidencias': y[:6],
}).round(2)

Rutas: 700
Media de incidencias: 2.934
Varianza de incidencias: 7.544
Máximo observado: 19
Rutas sin incidencias: 16.1%

La forma de una variable de conteo

Un conteo no llena una recta continua: toma valores . Además, suele ser asimétrico, acumular observaciones cerca de cero y extender una cola hacia valores grandes. Veamos la distribución de incidencias antes de elegir un modelo.

valores = np.arange(y.max() + 1)
frecuencias = pd.Series(y).value_counts().reindex(valores, fill_value=0)

plt.bar(valores, frecuencias, color='steelblue', edgecolor='white')
plt.xlabel('número de incidencias')
plt.ylabel('número de rutas')
plt.title('Conteos discretos, asimétricos y con una cola a la derecha')
plt.xticks(valores)
plt.show()

print(f'Moda observada (número de incidencias): {frecuencias.idxmax()}')
print(f'Rutas con 0, 1 o 2 incidencias: {np.mean(y <= 2):.1%}')

Moda observada (número de incidencias): 1
Rutas con 0, 1 o 2 incidencias: 55.4%

La distribución de Poisson

Una variable Poisson cuenta eventos que ocurren en una unidad de exposición. Su parámetro es a la vez su media y su varianza. En un modelo de regresión, la condición se escribe dados los predictores :

Esa igualdad entre media y varianza condicionales se llama equidispersión; al final del artículo verificamos si los datos la respetan.

No significa que todos los conteos tengan la misma media. En una regresión, cada ruta recibe su propia según sus características.

k = np.arange(0, 21)
for lambda_valor, color in [(1, 'steelblue'), (4, 'seagreen'), (10, 'firebrick')]:
    plt.plot(
        k, poisson_dist.pmf(k, mu=lambda_valor),
        marker='o', linewidth=2, color=color, label=rf'$\lambda={lambda_valor}$',
    )
plt.xlabel(r'conteo $y$')
plt.ylabel(r'$P(Y=y)$')
plt.title('La forma de Poisson cambia con la tasa esperada')
plt.legend()
plt.show()

Por qué la regresión lineal falla con conteos

Dividimos los datos en entrenamiento y prueba. Después ajustamos una regresión lineal ingenua con longitud y clima. Para visualizar el problema sin mezclar grupos, dibujamos su predicción para clima normal y la comparamos con rutas de entrenamiento bajo esa misma condición.

X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=SEMILLA
)

modelo_lineal = LinearRegression().fit(X_tr, y_tr)
pred_lineal_te = modelo_lineal.predict(X_te)

longitud_grid = np.linspace(0, 65, 300)
X_grid_normal = np.column_stack([longitud_grid, np.zeros_like(longitud_grid)])
pred_lineal_grid = modelo_lineal.predict(X_grid_normal)
mascara_normal_tr = X_tr[:, 1] == 0

plt.scatter(
    X_tr[mascara_normal_tr, 0], y_tr[mascara_normal_tr],
    s=14, alpha=0.25, color='steelblue', label='rutas con clima normal',
)
plt.plot(longitud_grid, pred_lineal_grid, color='firebrick', linewidth=2, label='regresión lineal')
plt.axhline(0, color='gray', ls=':')
plt.xlabel('longitud de la ruta (km)')
plt.ylabel('incidencias')
plt.title('La recta puede predecir conteos negativos')
plt.legend()
plt.show()

print(f'Predicción lineal a 0 km, clima normal: {modelo_lineal.predict([[0, 0]])[0]:.3f}')
print(f'Predicción mínima en prueba: {pred_lineal_te.min():.3f}')
print(f'Rutas de prueba con predicción negativa: {(pred_lineal_te < 0).sum()}')

Predicción lineal a 0 km, clima normal: -1.752
Predicción mínima en prueba: -1.052
Rutas de prueba con predicción negativa: 16

La arquitectura formal del GLM de Poisson

El modelo combina las mismas tres piezas que ya viste en logística:

1. Distribución de la respuesta: cada conteo sigue una distribución Poisson condicional a sus predictores.
2. Predictor lineal: longitud y clima se combinan sin restricciones en .
3. Función de enlace: el logaritmo conecta la tasa media positiva con ese predictor.

Pieza	Regresión de Poisson
Respuesta	Poisson
Media
Predictor lineal
Enlace	log
Función inversa	exponencial

Como , la tasa esperada siempre es positiva.

Por qué modelamos el logaritmo de la tasa

La tasa no puede ser negativa, pero el predictor sí puede tomar cualquier valor real. El enlace log resuelve esa diferencia:

La exponencial es la función inversa del enlace. Convierte toda la recta real en valores estrictamente positivos y transforma cambios aditivos en en cambios multiplicativos sobre la tasa.

eta_grid = np.linspace(-3, 3, 300)
lambda_grid = np.exp(eta_grid)

plt.plot(eta_grid, lambda_grid, color='seagreen', linewidth=2)
plt.axhline(0, color='gray', ls=':')
plt.axvline(0, color='gray', ls=':')
plt.scatter([0], [1], color='firebrick', zorder=3, label=r'$e^0=1$')
plt.xlabel(r'predictor lineal $\eta=X\beta$')
plt.ylabel(r'tasa esperada $\lambda=e^\eta$')
plt.title('La exponencial transforma cualquier valor real en una tasa positiva')
plt.legend()
plt.show()

x_coef = np.linspace(0, 60, 300)
fig, ax = plt.subplots(1, 2, figsize=(12, 4))

for beta_1 in [0.02, 0.045, 0.07]:
    ax[0].plot(x_coef, np.exp(-1 + beta_1 * x_coef), label=rf'$\beta_1={beta_1}$')
ax[0].set(title='La pendiente controla el ritmo de crecimiento', xlabel='longitud', ylabel='tasa esperada')
ax[0].legend()

for beta_0, etiqueta in [(-1.6, 'nivel bajo'), (-1.0, 'nivel medio'), (-0.4, 'nivel alto')]:
    ax[1].plot(x_coef, np.exp(beta_0 + 0.045 * x_coef), label=etiqueta)
ax[1].set(title='El intercepto cambia el nivel de la tasa', xlabel='longitud', ylabel='tasa esperada')
ax[1].legend()

plt.tight_layout()
plt.show()

Ajustar el modelo predictivo

El modelo de scikit-learn tendrá un propósito predictivo: aprende únicamente con entrenamiento y se evalúa sobre prueba. PoissonRegressor incluye una penalización L2 —la misma idea de Ridge del artículo de regularización— cuya intensidad controla alpha. Su valor por defecto, alpha=1.0, no tiene nada de especial para estos datos, así que lo tratamos como cualquier hiperparámetro: lo elegimos por validación cruzada (CV) con 5 particiones (folds) solo sobre el entrenamiento, en una malla de 11 valores entre y . Antes estandarizamos los predictores, porque la penalización L2 depende de la escala: sin estandarizar, contraería mucho más el coeficiente del clima (una variable 0/1) que el de la longitud (medida en km).

Para evaluar usamos la deviance media de Poisson, que compara cada conteo observado con su tasa predicha :

con la convención cuando . Vale 0 si cada predicción coincide con su conteo y crece con la discrepancia: cuanto menor, mejor. La complementamos con el error absoluto medio (MAE), el promedio de , que se lee directamente en incidencias por ruta.

alphas = np.logspace(-4, 1, 11)
busqueda = GridSearchCV(
    make_pipeline(StandardScaler(), PoissonRegressor(max_iter=1000)),
    {'poissonregressor__alpha': alphas},
    cv=KFold(n_splits=5, shuffle=True, random_state=SEMILLA),
    scoring='neg_mean_poisson_deviance',
).fit(X_tr, y_tr)
modelo_predictivo = busqueda.best_estimator_
pred_poisson_te = modelo_predictivo.predict(X_te)

alpha_opt = busqueda.best_params_['poissonregressor__alpha']
print(f'alpha elegido por CV: {alpha_opt:.4g} (rango probado: {alphas[0]:.0e} a {alphas[-1]:.0e})')
print('¿Cae en el borde del rango?', alpha_opt in (alphas[0], alphas[-1]))
print(f'Deviance media de CV con ese alpha: {-busqueda.best_score_:.3f}')
print(f'Predicción mínima en prueba: {pred_poisson_te.min():.3f}')
print(f'Predicción máxima en prueba: {pred_poisson_te.max():.3f}')
print(f'Deviance de Poisson en prueba: {mean_poisson_deviance(y_te, pred_poisson_te):.3f}')
print(f'MAE en prueba: {mean_absolute_error(y_te, pred_poisson_te):.3f}')

alpha elegido por CV: 0.01 (rango probado: 1e-04 a 1e+01)
¿Cae en el borde del rango? False
Deviance media de CV con ese alpha: 1.052
Predicción mínima en prueba: 0.490
Predicción máxima en prueba: 10.140
Deviance de Poisson en prueba: 1.063
MAE en prueba: 1.216

Visualizar la tasa ajustada

Dibujaremos la tasa esperada según longitud para clima normal y adverso. Los puntos son conteos observados, por eso permanecen dispersos alrededor de cada curva: el modelo estima la media condicional, no pretende pasar por cada observación.

longitud_grid = np.linspace(5, 60, 300)
for indicador_clima, color, etiqueta in [
    (0, 'seagreen', 'clima normal'),
    (1, 'firebrick', 'clima adverso'),
]:
    X_grid = np.column_stack([longitud_grid, np.full_like(longitud_grid, indicador_clima)])
    tasa_grid = modelo_predictivo.predict(X_grid)
    plt.plot(longitud_grid, tasa_grid, color=color, linewidth=2.5, label=etiqueta)
    mascara = clima_adverso == indicador_clima
    plt.scatter(longitud[mascara], y[mascara], s=12, alpha=0.15, color=color)

plt.xlabel('longitud de la ruta (km)')
plt.ylabel('incidencias observadas / tasa esperada')
plt.title('Tasa estimada según longitud y clima')
plt.legend()
plt.show()

Modelo inferencial y cocientes de tasas

Ajustamos con statsmodels un GLM de Poisson sobre el mismo conjunto de entrenamiento. Su propósito es inferencial: estimar coeficientes, cocientes de tasas de incidencia (IRR) y p-valores.

El modelo predictivo de scikit-learn usa una penalización L2 (pequeña, elegida por CV) sobre predictores estandarizados; este GLM de statsmodels no regulariza y trabaja con las variables en sus unidades originales. Aunque ambos reciben las mismas observaciones, sus coeficientes no son directamente comparables; lo comparable son sus predicciones. Para una variable :

Un cambio de unidades multiplica la tasa por .

X_tr_sm = sm.add_constant(X_tr)
modelo_inferencial = sm.GLM(
    y_tr, X_tr_sm, family=sm.families.Poisson()
).fit()

nombres = ['intercepto', 'longitud', 'clima_adverso']
coeficientes = pd.Series(modelo_inferencial.params, index=nombres)
irr = np.exp(coeficientes)
p_valores = pd.Series(modelo_inferencial.pvalues, index=nombres)

tabla_inferencia = pd.DataFrame({
    'coeficiente': coeficientes,
    'IRR': irr,
    'p-valor': p_valores,
})
display(tabla_inferencia.round(4))

irr_10_km = np.exp(10 * coeficientes['longitud'])
print(f'IRR acumulado para 10 km adicionales: {irr_10_km:.3f}')

IRR acumulado para 10 km adicionales: 1.585

Tasas esperadas para rutas concretas

Comparamos rutas cortas, medias y largas bajo clima normal y adverso. Esta tabla lleva los coeficientes a la escala que necesita quien toma decisiones: número esperado de incidencias por ruta.

perfiles = pd.DataFrame({
    'tipo_ruta': ['corta', 'corta', 'media', 'media', 'larga', 'larga'],
    'longitud_km': [10, 10, 30, 30, 55, 55],
    'clima': ['normal', 'adverso', 'normal', 'adverso', 'normal', 'adverso'],
    'clima_adverso': [0, 1, 0, 1, 0, 1],
})
X_perfiles = perfiles[['longitud_km', 'clima_adverso']].to_numpy()
perfiles['incidencias_esperadas'] = modelo_predictivo.predict(X_perfiles)
display(perfiles[['tipo_ruta', 'longitud_km', 'clima', 'incidencias_esperadas']].round(3))

Comparar contra un baseline

Una métrica aislada no dice si el modelo aporta valor. El baseline más simple ignora longitud y clima y predice para todas las rutas la media de conteos observada en entrenamiento. Compararemos ambos con la misma deviance de Poisson y con MAE sobre prueba.

pred_baseline = np.full(y_te.shape, y_tr.mean(), dtype=float)

deviance_modelo = mean_poisson_deviance(y_te, pred_poisson_te)
deviance_baseline = mean_poisson_deviance(y_te, pred_baseline)
mae_modelo = mean_absolute_error(y_te, pred_poisson_te)
mae_baseline = mean_absolute_error(y_te, pred_baseline)
reduccion_deviance = 1 - deviance_modelo / deviance_baseline

tabla_comparacion = pd.DataFrame({
    'modelo': ['media de entrenamiento', 'regresión de Poisson'],
    'deviance_poisson': [deviance_baseline, deviance_modelo],
    'MAE': [mae_baseline, mae_modelo],
})
display(tabla_comparacion.round(3))
print(f'Reducción relativa de deviance frente al baseline: {reduccion_deviance:.1%}')

Reducción relativa de deviance frente al baseline: 58.4%

Revisar el supuesto de dispersión

En una Poisson ideal, la varianza condicional coincide con la media condicional. Una comprobación diagnóstica habitual es la razón de dispersión de Pearson:

Valores cercanos a 1 son compatibles con la dispersión Poisson; valores claramente mayores sugieren sobredispersión y la necesidad de revisar el modelo o considerar alternativas como binomial negativa.

dispersion_pearson = modelo_inferencial.pearson_chi2 / modelo_inferencial.df_resid
ajuste_train = modelo_inferencial.fittedvalues
residuos_pearson = modelo_inferencial.resid_pearson

plt.scatter(ajuste_train, residuos_pearson, s=16, alpha=0.45, color='steelblue')
plt.axhline(0, color='firebrick', ls='--')
plt.xlabel('tasa ajustada en entrenamiento')
plt.ylabel('residuo de Pearson')
plt.title('Residuos de Pearson frente a la tasa ajustada')
plt.show()

print(f'Razón de dispersión de Pearson: {dispersion_pearson:.3f}')

Razón de dispersión de Pearson: 0.983

Errores comunes en regresión de Poisson

1. Tratar cualquier entero como conteo Poisson. Debe representar eventos no negativos observados bajo una exposición comparable.
2. Interpretar como cambio aditivo en incidencias. El efecto es multiplicativo sobre la tasa; se interpreta con .
3. Comparar IRR de variables con unidades distintas como si midieran importancia. Primero fija cambios relevantes, como 10 km frente a un cambio de clima.
4. Reportar una deviance sin modelo de referencia (baseline). El modelo debe superar una predicción trivial sobre datos de prueba.
5. Usar p-valores como prueba causal. Dependen de los supuestos y no sustituyen el tamaño ni la relevancia práctica del efecto.
6. Ignorar la sobredispersión. Si la variabilidad excede claramente lo permitido por Poisson, los errores estándar y conclusiones pueden ser inadecuados.
7. Confundir tasa esperada con conteo observado. Una predicción como 2.4 es una media para rutas comparables, no una incidencia fraccionaria.
8. Olvidar la exposición. Si unas rutas representan más tiempo o distancia de observación que otras, puede necesitarse un offset.

Lo que debes llevarte de este artículo

La cadena completa es:

respuesta de conteo
→ distribución Poisson
→ predictor lineal η = Xβ
→ enlace log
→ tasa esperada λ = exp(η)

La exponencial garantiza tasas positivas. Los coeficientes se interpretan mediante IRR, el modelo predictivo se evalúa en prueba contra un baseline y el supuesto de dispersión debe revisarse antes de confiar en la inferencia.

Cierre técnico

La regresión de Poisson conserva el predictor lineal, pero adapta la distribución y el enlace a una respuesta de conteo. El paralelo queda así:

Esa estructura común permite cambiar el tipo de respuesta sin abandonar el lenguaje de los GLM.

¿Qué sigue?

Hasta aquí, longitud y clima entran con efectos lineales en la escala log. Pero una relación real puede curvarse: quizá el riesgo crece lentamente en rutas medianas y se acelera en rutas muy largas.

Los modelos aditivos generalizados (GAM) combinan dos ideas que ya viste en la serie: la distribución y el enlace de un GLM con la flexibilidad local de los splines. El siguiente paso será permitir efectos no lineales sin perder la estructura interpretable del modelo.

👋 Sobre el autor

Wilder Ramírez Delgado convierte datos en decisiones. Científico de Datos, Arquitecto de IA y asesor tecnológico con más de 20 años de experiencia en analítica avanzada, machine learning, Big Data e IoT. Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), asesora a entidades gubernamentales y empresas privadas en Colombia y es referente en analítica y normatividad para los sectores postal y logístico del país. Una serie pensada para ir de la teoría a la práctica, con ejemplos concretos en cada paso.

📌 Parte de la serie Análisis Avanzado de Datos.

Cuando el efecto no es una recta

En los artículos anteriores el GLM te dio una arquitectura clara: eliges una distribución para , una función de enlace y un predictor lineal. Eso cubre el sí/no (logística) y los conteos (Poisson). La pieza que queda rígida es el predictor: cada variable entra con una pendiente constante. Si el efecto sube y luego baja, esa recta no tiene cómo contarlo. Es la pregunta que dejó abierta el artículo de Poisson: un riesgo que crece despacio en rutas medianas y se acelera en las muy largas.

Los splines del artículo de suavización ya resolvieron la forma flexible para una media continua. Un modelo aditivo generalizado (GAM) junta las dos ideas: conserva la distribución y el enlace del GLM, pero reemplaza el predictor lineal por una suma de funciones suaves. El resultado sigue siendo interpretable —puedes dibujar el efecto de cada variable— y ya no exige que ese efecto sea monótono.

Objetivos de aprendizaje

Al terminar este notebook vas a ser capaz de:

• Escribir un GAM como un GLM en el que el predictor lineal se reemplaza por una suma de funciones suaves.
• Reconocer un efecto no monótono en los datos y explicar por qué una logística lineal no puede capturarlo.
• Conectar el spline de la suavización con el ingrediente que le da flexibilidad al GLM.
• Elegir el número de nodos (knots) del spline por validación cruzada sobre el entrenamiento, sin usar el conjunto de prueba.
• Comparar de forma justa un GLM lineal, un GAM y un modelo de referencia trivial (baseline) sobre datos reservados.
• Leer la curva del efecto parcial: dónde sube, dónde baja y qué implica para el problema.
• Interpretar con prudencia un contraste de verosimilitud entre el predictor lineal y el suave, sin confundirlo con causalidad.

El GAM como un GLM con predictor suave

Un modelo lineal generalizado combina tres piezas: la distribución de , un predictor y una función de enlace que conecta la media con ese predictor. En el GLM clásico el predictor es lineal:

Un GAM cambia una sola pieza: cada término puede volverse una función suave , estimada con un spline:

Cada es flexible: no fijas de antemano que el efecto sea una recta ni una parábola. El spline aprende la forma a partir de los datos, con la cantidad de flexibilidad que tú controles —aquí, con el número de knots.

Lo que no cambia es el resto del GLM. Si es binaria, sigues usando Bernoulli y el enlace logit. Si es un conteo, sigues usando Poisson y el enlace log. El GAM no es una familia distinta: es el mismo esqueleto con un predictor aditivo en lugar de uno lineal.

De GLM lineal a GAM

El camino es una sola flecha:

GLM (logística, Poisson: distribución + enlace + predictor lineal) añade forma flexible (cada entra con un spline ) GAM.

Pieza	GLM lineal (logística, Poisson)	GAM
Distribución de	Bernoulli, Poisson, …	la misma
Función de enlace	logit, log, …	la misma
Predictor
Forma de cada efecto	recta en la escala del enlace	curva suave (spline)
Qué estima	probabilidad del sí (logística), tasa esperada de eventos (Poisson)	lo mismo, con forma flexible
Qué interpretas	un número (el coeficiente)	una función (el efecto parcial)

La aditividad es lo que conserva la interpretabilidad. Como las se suman, puedes dibujar contra dejando fijas las demás variables y leer el efecto de esa variable a lo largo de su rango. Una caja negra puede acertar predicciones sin mostrarte dónde el efecto sube o baja; el GAM te deja ver esa forma. Por eso es la herramienta natural cuando sospechas no linealidad y aún quieres explicar el resultado, no solo predecirlo.

En este artículo nos concentramos en una respuesta binaria y una variable continua, para que la curva se vea sin mezclas. La fórmula de arriba sigue valiendo con varias ; cada una se dibuja por separado.

Aunque cambie la respuesta, el enlace o la forma del predictor, la cadena conceptual es la misma. Ahora vamos a un caso donde esa forma flexible no es un lujo: es la diferencia entre un modelo casi inútil y uno que describe lo que ocurre.

Preparación del entorno

Cargamos scikit-learn para ajustar y comparar modelos predictivos, statsmodels para la inferencia del final y una constante global SEMILLA que fija toda la aleatoriedad del artículo.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import SplineTransformer
from sklearn.pipeline import make_pipeline
from sklearn.metrics import roc_auc_score, accuracy_score, roc_curve
import statsmodels.api as sm
from scipy.stats import chi2

SEMILLA = 2026
rng = np.random.default_rng(SEMILLA)
plt.rcParams['figure.figsize'] = (8, 4)

Los datos: conversión según la edad

Simulamos 900 clientes. De cada uno conocemos la edad y si convierte (compra: 1) o no (0). La regla oculta es deliberada: la probabilidad de conversión sube hacia las edades intermedias y baja en los extremos —un pico, no una rampa. En la práctica no conoces esa regla; la infieres de lo que observas.

Ese patrón no monótono es el escenario donde el GAM demuestra su valor. Un modelo que asuma “a más edad, siempre más (o siempre menos) conversión” va a chocar con los datos.

n = 900
edad = rng.uniform(18, 75, n)

# Regla oculta: log-odds sube y baja con la edad (pico, no rampa).
logit_real = -6 + 0.30 * edad - 0.0034 * edad**2
prob_real = 1 / (1 + np.exp(-logit_real))
convierte = rng.binomial(1, prob_real)

X = edad.reshape(-1, 1)
y = convierte

print(f'{n} clientes | tasa de conversión: {y.mean():.1%}')
print(f'Convierten: {int(y.sum())} | no convierten: {int((1 - y).sum())}')
pd.DataFrame({'edad': edad[:5], 'convierte': y[:5]}).round(3)

900 clientes | tasa de conversión: 44.4%
Convierten: 400 | no convierten: 500

La tasa observada no es monótona

Si el efecto de la edad fuera una rampa, al agrupar por tramos verías una secuencia que siempre sube o siempre baja. Calculemos la tasa de conversión en ventanas de 7 años, de 18 a 74 (los 17 clientes de 74 a 75 años quedan fuera de los tramos), y dibujémosla.

bins = np.arange(18, 81, 7)
centros = (bins[:-1] + bins[1:]) / 2
tasas = []
ns = []
for a, b in zip(bins[:-1], bins[1:]):
    mascara = (edad >= a) & (edad < b)
    ns.append(int(mascara.sum()))
    tasas.append(y[mascara].mean())

tabla_tramos = pd.DataFrame({
    'edad (centro)': centros,
    'n': ns,
    'tasa observada': tasas,
})
display(tabla_tramos.round(3))

plt.plot(centros, tasas, marker='o', color='steelblue', linewidth=2)
plt.xlabel('edad')
plt.ylabel('tasa de conversión observada')
plt.title('El efecto de la edad no es monótono: sube y baja')
plt.ylim(0, 1)
plt.show()

Entrenamiento y prueba, antes de modelar

Separamos el 30% de los clientes como conjunto de prueba y lo reservamos. Todo ajuste, toda comparación de complejidad y toda validación cruzada ocurrirán solo en entrenamiento. La prueba entra al final, una vez, para reportar.

X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=SEMILLA, stratify=y
)
edad_tr = X_tr.ravel()
edad_te = X_te.ravel()

print(f'Entrenamiento: {len(y_tr)} clientes | tasa: {y_tr.mean():.1%}')
print(f'Prueba:        {len(y_te)} clientes | tasa: {y_te.mean():.1%}')

Entrenamiento: 630 clientes | tasa: 44.4%
Prueba:        270 clientes | tasa: 44.4%

Intento 1: regresión logística lineal

Ajustamos primero el GLM que ya conoces: una logística estándar. En la escala logit, asume que el efecto de la edad es una recta —siempre en la misma dirección. En la escala de probabilidad eso produce una sigmoide monótona. Si los datos forman un pico, este modelo tiene que aplanarlo.

lineal = LogisticRegression(max_iter=1000).fit(X_tr, y_tr)

grid = np.linspace(18, 75, 300).reshape(-1, 1)
prob_lin_grid = lineal.predict_proba(grid)[:, 1]

# Tasas observadas en entrenamiento, para no mezclar con la prueba.
tasas_tr = []
for a, b in zip(bins[:-1], bins[1:]):
    mascara = (edad_tr >= a) & (edad_tr < b)
    tasas_tr.append(y_tr[mascara].mean() if mascara.sum() else np.nan)

plt.plot(centros, tasas_tr, marker='o', color='gray', alpha=0.7,
         label='tasa observada (entrenamiento)')
plt.plot(grid, prob_lin_grid, color='firebrick', linewidth=2,
         label='logística lineal')
plt.xlabel('edad')
plt.ylabel('probabilidad de conversión')
plt.title('Logística lineal: una sola dirección, una rampa suave')
plt.ylim(0, 1)
plt.legend()
plt.show()

print(f'Coeficiente de la edad: {lineal.coef_[0, 0]:.3f}')
print(f'Intercepto:             {lineal.intercept_[0]:.3f}')
print(f'Probabilidades a lo largo de la edad: {prob_lin_grid.min():.3f} a {prob_lin_grid.max():.3f}')