Como criar um modelo de regressão quantílica em Machine Learning

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

A regressão quantílica permite prever percentis da distribuição condicional da variável alvo, em vez de apenas a média. Isto é especialmente útil quando a dispersão da variável depende de X (heterocedasticidade) ou quando se pretende avaliar riscos e intervalos de confiança condicionais — por exemplo, estimar custos mínimos, medianos e máximos para uma operação. Neste exemplo mostramos como treinar vários modelos de regressão quantílica em Python usando scikit-learn, porque fornece uma solução direta e eficiente para obter quantis como 0.1, 0.5 e 0.9, e por que isso melhora decisões em cenários com incerteza.

Pré-requisitos

Python 3.8+ com pip instalado
Bibliotecas: scikit-learn, numpy, pandas, matplotlib
Noções básicas de regressão linear, treino/teste e manipulação de dados com pandas

Passo 1: Por que usar regressão quantílica

A regressão quantílica estima um quantil q (por exemplo 0.1, 0.5, 0.9) da distribuição condicional de y dado X. Ao contrário da regressão por mínimos quadrados, que minimiza o erro quadrático e fornece a esperança condicional E[y|X], a regressão quantílica modela diretamente as caudas e a mediana. Isto é valioso quando a decisão depende da variabilidade — por exemplo, um gestor de risco pode querer saber o quantil 0.95 de perdas potenciais; um planeador orçamental pode comparar custos estimados para os quantis 0.1 e 0.9 para preparar contingências.

Exemplo concreto: se a variância de y cresce com X, a regressão da média tende a "ficar no meio" e subestima os extremos. A regressão quantílica mostra como os intervalos se alargam com X e permite medir cobertura empírica (proporção de observações que caem entre dois quantis). Para quantis 0.1–0.9 o alvo teórico de cobertura é 0.8 (80%).

Passo 2: Instalar dependências

Instala as bibliotecas necessárias. No terminal, executa:

pip install scikit-learn numpy pandas matplotlib

scikit-learn inclui QuantileRegressor desde a versão 1.0; confirma a versão com pip show scikit-learn se necessário. Em grandes conjuntos de dados poderás preferir solvers e opções de regularização diferentes para otimizar o desempenho.

Passo 3: Preparar dados de exemplo

Para evidenciar heterocedasticidade criamos um conjunto sintético com 500 observações; a amplitude do ruído cresce com X. Isto torna visível por que quantis divergem da média.

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)

A amostra de treino terá 400 pontos e de teste 100 pontos. Este é um tamanho suficiente para demonstrar o comportamento dos quantis sem exigir muita capacidade computacional.

Passo 4: Treinar regressão quantílica com scikit-learn

scikit-learn oferece QuantileRegressor (desde v1.0). Treinamos modelos separados para os quantis 0.1, 0.5 e 0.9. O parâmetro alpha controla a regularização L2: valores como 0.0–1.0 são comuns; 0.0 significa sem regularização. O solver 'highs' é estável e rápido para problemas lineares.

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 um workflow mais robusto inclui normalização das features e validação de alpha via cross-validation se tiveres múltiplas features.

Passo 5: Fazer previsões e construir intervalo condicional

Usa os modelos para prever os quantis no conjunto de teste; a diferença entre o quantil 0.9 e o 0.1 aproxima um intervalo condicional robusto. Isto dá estimativas da largura do intervalo dependente 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 exemplo, para X=10 o intervalo (0.1–0.9) pode ser significativamente mais largo do que para X=0; isto reflete o aumento de incerteza com X.

Passo 6: Visualizar resultados (exemplo)

Uma visualização ajuda a verificar se os quantis capturam a heterocedasticidade. Um gráfico típico mostra pontos observados e as três curvas dos quantis. Se o modelo estiver correto, os pontos deverão ficar densos dentro da banda (0.1–0.9) e a banda deverá alargar com X.

import matplotlib.pyplot as plt

plt.scatter(X_test, y_test, s=10, alpha=0.6, label='observado')
# Ordenar para linha
order = np.argsort(X_test.values.ravel())
xx = X_test.values.ravel()[order]
plt.plot(xx, lower_pred[order], color='red', label='quantil 0.1')
plt.plot(xx, median_pred[order], color='green', label='quantil 0.5')
plt.plot(xx, upper_pred[order], color='red', linestyle='--', label='quantil 0.9')
plt.legend()
plt.xlabel('X')
plt.ylabel('y')
plt.title('Regressão quantílica: intervalos condicionais')
plt.show()

Passo 7: Avaliar o desempenho dos quantis

Para avaliar usamos a perda de quantil (pinball loss) e a cobertura empírica do intervalo. A pinball loss é assimétrica e penaliza de forma adequada desvios para cada lado do quantil.

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 orientação, para o nosso exemplo sintético a cobertura empírica deve ficar perto de 0.8 (por exemplo entre 0.75 e 0.85). Valores muito fora desta gama indicam sub ou sobreajuste ou problemas de modelagem.

Verificar o resultado

Confirma que os gráficos mostram dispersão crescente com X e que a cobertura empírica do intervalo 0.1–0.9 está próxima de 0.8. Evita erros comuns: usar uma única regressão da média quando precisas de intervalos, não validar alpha (sobre-regularização pode achatar quantis) ou esquecer de transformar/normalizar features quando tens múltiplas colunas com escalas diferentes.

Conclusão

A regressão quantílica em Machine Learning permite estimar intervalos condicionais e gerir incerteza de forma prática e interpretável. Próximos passos recomendados: experimentar com múltiplas features, escolher alpha via cross-validation, testar modelos não lineares (ex.: GradientBoostingQuantile ou modelos baseados em quantile loss) e validar a calibração dos quantis em dados reais. Dica prática: valida sempre a cobertura empírica para garantir que os quantis estão bem calibrados antes de usar as previsões em decisões operacionais.