Cómo crear un modelo de regresión cuantílica en Machine Learning

João Barros 29 de September de 2026 5 min de lectura

La regresión cuantílica permite predecir percentiles de la distribución condicional de la variable objetivo, en lugar de solo la media. Esto es especialmente útil cuando la dispersión de la variable depende de X (heterocedasticidad) o cuando se pretende evaluar riesgos e intervalos de confianza condicionales — por ejemplo, estimar costes mínimos, medianos y máximos para una operación. En este ejemplo mostramos cómo entrenar varios modelos de regresión cuantílica en Python usando scikit-learn, por qué proporciona una solución directa y eficiente para obtener cuantiles como 0.1, 0.5 y 0.9, y por qué esto mejora la toma de decisiones en escenarios con incertidumbre.

Requisitos previos

Python 3.8+ con pip instalado
Bibliotecas: scikit-learn, numpy, pandas, matplotlib
Noociones básicas de regresión lineal, entrenamiento/prueba y manipulación de datos con pandas

Paso 1: Por qué usar regresión cuantílica

La regresión cuantílica estima un cuantíl q (por ejemplo 0.1, 0.5, 0.9) de la distribución condicional de y dado X. A diferencia de la regresión por mínimos cuadrados, que minimiza el error cuadrático y proporciona la esperanza condicional E[y|X], la regresión cuantílica modela directamente las colas y la mediana. Esto es valioso cuando la decisión depende de la variabilidad — por ejemplo, un gestor de riesgo puede querer conocer el cuantíl 0.95 de pérdidas potenciales; un planificador presupuestario puede comparar costes estimados para los cuantiles 0.1 y 0.9 para preparar contingencias.

Ejemplo concreto: si la varianza de y aumenta con X, la regresión de la media tiende a "quedarse en el medio" y subestima los extremos. La regresión cuantílica muestra cómo los intervalos se ensanchan con X y permite medir la cobertura empírica (proporción de observaciones que caen entre dos cuantiles). Para cuantiles 0.1–0.9 el objetivo teórico de cobertura es 0.8 (80%).

Paso 2: Instalar dependencias

Instala las bibliotecas necesarias. En la terminal, ejecuta:

pip install scikit-learn numpy pandas matplotlib

scikit-learn incluye QuantileRegressor desde la versión 1.0; confirma la versión con pip show scikit-learn si es necesario. En conjuntos de datos grandes podrías preferir solvers y opciones de regularización diferentes para optimizar el rendimiento.

Paso 3: Preparar datos de ejemplo

Para evidenciar heterocedasticidad creamos un conjunto sintético con 500 observaciones; la amplitud del ruido crece con X. Esto hace visible por qué los cuantiles divergen de la media.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

np.random.seed(0)
X = np.linspace(0, 10, 500)
noise = np.random.randn(500) * (0.5 + 0.5 * X)
y = 2.0 + 0.5 * X + noise

df = pd.DataFrame({'X': X, 'y': y})
X = df[['X']]
y = df['y']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

La muestra de entrenamiento tendrá 400 puntos y la de prueba 100 puntos. Este es un tamaño suficiente para demostrar el comportamiento de los cuantiles sin exigir mucha capacidad computacional.

Paso 4: Entrenar regresión cuantílica con scikit-learn

scikit-learn ofrece QuantileRegressor (desde v1.0). Entrenamos modelos separados para los cuantiles 0.1, 0.5 y 0.9. El parámetro alpha controla la regularización L2: valores como 0.0–1.0 son comunes; 0.0 significa sin regularización. El solver 'highs' es estable y rápido para problemas lineales.

from sklearn.linear_model import QuantileRegressor

quantiles = [0.1, 0.5, 0.9]
models = {}
for q in quantiles:
    qr = QuantileRegressor(quantile=q, alpha=0.0, solver='highs')
    qr.fit(X_train, y_train)
    models[q] = qr

Observa que un flujo de trabajo más robusto incluye normalización de las features y validación de alpha vía cross-validation si tienes múltiples features.

Paso 5: Hacer predicciones y construir intervalo condicional

Usa los modelos para predecir los cuantiles en el conjunto de prueba; la diferencia entre el cuantíl 0.9 y el 0.1 aproxima un intervalo condicional robusto. Esto proporciona estimaciones del ancho del intervalo dependiente de X.

import numpy as np

preds = {q: models[q].predict(X_test) for q in quantiles}
median_pred = preds[0.5]
lower_pred = preds[0.1]
upper_pred = preds[0.9]

Por ejemplo, para X=10 el intervalo (0.1–0.9) puede ser significativamente más ancho que para X=0; esto refleja el aumento de incertidumbre con X.

Paso 6: Visualizar resultados (ejemplo)

Una visualización ayuda a verificar si los cuantiles capturan la heterocedasticidad. Un gráfico típico muestra puntos observados y las tres curvas de los cuantiles. Si el modelo es correcto, los puntos deberían concentrarse dentro de la banda (0.1–0.9) y la banda debería ensancharse con X.

import matplotlib.pyplot as plt

plt.scatter(X_test, y_test, s=10, alpha=0.6, label='observado')
# Ordenar para línea
order = np.argsort(X_test.values.ravel())
xx = X_test.values.ravel()[order]
plt.plot(xx, lower_pred[order], color='red', label='cuantil 0.1')
plt.plot(xx, median_pred[order], color='green', label='cuantil 0.5')
plt.plot(xx, upper_pred[order], color='red', linestyle='--', label='cuantil 0.9')
plt.legend()
plt.xlabel('X')
plt.ylabel('y')
plt.title('Regresión cuantílica: intervalos condicionales')
plt.show()

Paso 7: Evaluar el rendimiento de los cuantiles

Para evaluar usamos la pérdida de cuantíl (pinball loss) y la cobertura empírica del intervalo. La pinball loss es asimétrica y penaliza de forma adecuada las desviaciones a cada lado del cuantíl.

def pinball_loss(y_true, y_pred, q):
    err = y_true - y_pred
    return np.mean(np.maximum(q * err, (q - 1) * err))

for q in quantiles:
    loss = pinball_loss(y_test.values, preds[q], q)
    print(f'Quantile {q}: pinball loss = {loss:.4f}')

coverage = np.mean((y_test.values >= lower_pred) & (y_test.values <= upper_pred))
print(f'Cobertura entre 0.1 e 0.9: {coverage:.3f}')

Como referencia, para nuestro ejemplo sintético la cobertura empírica debería situarse cerca de 0.8 (por ejemplo entre 0.75 y 0.85). Valores muy fuera de este rango indican subajuste o sobreajuste o problemas de modelado.

Verificar el resultado

Confirma que los gráficos muestran dispersión creciente con X y que la cobertura empírica del intervalo 0.1–0.9 está próxima a 0.8. Evita errores comunes: usar una única regresión de la media cuando necesitas intervalos, no validar alpha (la sobre-regularización puede aplanar los cuantiles) u olvidar transformar/normalizar features cuando tienes múltiples columnas con escalas diferentes.

Conclusión

La regresión cuantílica en Machine Learning permite estimar intervalos condicionales y gestionar la incertidumbre de forma práctica e interpretable. Próximos pasos recomendados: experimentar con múltiples features, elegir alpha vía cross-validation, probar modelos no lineales (p. ej.: GradientBoostingQuantile o modelos basados en quantile loss) y validar la calibración de los cuantiles en datos reales. Consejo práctico: valida siempre la cobertura empírica para garantizar que los cuantiles están bien calibrados antes de usar las predicciones en decisiones operativas.