Chega de adivinhar qual modelo de série temporal usar o Ensemble da IBM faz isso por você

Por que escolher um único modelo de previsão é uma armadilha

Olha só a situação: você tem um dataset de série temporal. Testa o PatchTST — vai bem em sinais industriais suaves, mas sofre com demanda de varejo ruidosa. Testa o FlowState — melhor em horizontes sazonais longos, pior em picos de curto prazo. Testa o TTM — rápido, mas nem sempre preciso.

Escolher a arquitetura certa é metade da batalha, e a melhor escolha depende totalmente da sua série e do seu horizonte. A resposta da IBM? Pare de escolher. O Granite Timeseries Ensemble empacota quatro arquiteturas Granite complementares em um único forecaster que retorna previsões medianas e quantílicas — sem retreinar, sem pesos ajustados, sem achismo.

A ideia lembra previsão do tempo: modelos de ensemble exploram uma gama de resultados possíveis e fundem tudo numa previsão só. Com séries temporais é igual — modelos complementares enxergam padrões diferentes, e o ensemble dilui os erros individuais. Vamos lá! 🚀

Rodando em menos de 5 minutos

Instala o pacote e carrega a receita recomendada de quatro modelos direto do Hugging Face:

pip install "granite-tsfm>=0.3.11"

import pandas as pd
from tsfm_public.models.ensemble.modeling_ensemble import QuantileEnsembleForecaster

# Carrega o dataset ETTh1 (temperatura horária de transformadores elétricos)
df = pd.read_csv(
    "https://raw.githubusercontent.com/zhouhaoyi/ETDataset/main/ETT-small/ETTh1.csv",
    parse_dates=["date"],
)

# Carrega a receita padrão do ensemble (baixa 4 checkpoints em runtime)
ensemble = QuantileEnsembleForecaster.from_pretrained(
    "ibm-granite/granite-timeseries-ensemble-r1",
)

# Prevê os próximos 24 passos usando as últimas 1024 observações como contexto
result = ensemble(
    df.tail(1024),
    timestamp_column="date",
    target_columns=["OT"],
    context_length=1024,
    prediction_length=24,
)

print(result.prediction_outputs)  # previsão pontual (mediana)
print(result.quantile_outputs)    # quantis de 0.1 a 0.9

O que vem dentro da caixa

A receita padrão combina quatro modelos Granite pré-treinados com arquiteturas diferentes:

Cada arquitetura captura tendência, sazonalidade e variação local de um jeito diferente, então os erros não se alinham. A receita armazena a configuração, não os pesos fundidos — os quatro checkpoints baixam na primeira execução, então reserva um tempinho extra pra primeira chamada. 😉

Duas formas de combinar as previsões

Probabilistic Ensemble (padrão): influência igual pra cada membro, quantis fundidos no espaço de probabilidade. Sem ajuste, sem hiperparâmetros pra tunar.

IQR Ensemble (adaptativo): pondera cada membro pelo espalhamento da previsão — intervalos mais estreitos ganham mais peso. Troca com uma linha:

ensemble = QuantileEnsembleForecaster.from_pretrained(
    "ibm-granite/granite-timeseries-ensemble-r1",
    subfolder="recipes/granite-iqr",
)

Ele realmente bate os modelos individuais?

Em 97 configurações do GIFT-Eval, os dois ensembles superam os quatro membros individuais no MASE agregado:

A margem sobre o melhor modelo único é pequena — o ganho real é robustez. Você tem acurácia comparável ou melhor sem precisar saber de antemão qual arquitetura combina com seus dados.

Limitações pra ficar de olho

• Canais independentes: a receita atual prevê canais multivariados de forma independente — sem usar informação cruzada entre canais.
• Custo de latência: quatro checkpoints carregam em inferência, então memória e latência são maiores que num modelo único.
• Sem garantia de calibração: nenhum dos métodos de agregação garante calibração ou robustez sob mudança de distribuição. Monitora as previsões depois do deploy.
• Cuidado com o IQR: intervalo mais estreito não significa previsão melhor calibrada — a ponderação IQR pode favorecer um membro superconfiante. A receita expõe um parâmetro de temperatura e um limite opcional de peso se quiser experimentar.

Como avaliar pro seu caso de uso

1. Case com seu cenário. Usa janelas históricas que reflitam os dados disponíveis em cada origem de previsão, o horizonte que você precisa e as séries que espera servir.
2. Compare igual com igual. Roda Probabilistic, IQR e um membro individual forte (tipo o PatchTST-FM-r2) nas mesmas janelas.
3. Vai além do erro pontual. Avalia quantile loss junto com MASE e checa a cobertura empírica do intervalo 0.1–0.9 contra os 80% nominais.
4. Mede o custo. Registra runtime e memória pra julgar se combinar quatro modelos se justifica pra sua carga.

Pra onde ir agora

Começa pelo Probabilistic Ensemble padrão — é a linha de base sensata que não exige tuning nenhum. Se o espalhamento da previsão parecer informativo pro seu app, faz backtest do IQR Ensemble contra ele em dados representativos antes de fechar.

A interface Forecaster também aceita modelos externos compatíveis, então você troca membros ou métodos de agregação mantendo o mesmo formato de saída. Só confere compatibilidade, acurácia, calibração, latência e licenciamento pra qualquer mix novo — algumas receitas estendidas incluem checkpoints da IBM Research com termos não comerciais ou só de pesquisa.

Dica prática pra quem vai colocar em produção: trata o ensemble como baseline, não como resposta final. Ele tira a decisão de "qual modelo escolher?" do dia um, mas você ainda deve um backtest decente pro seu app. E quando estiver escalando fluxos com IA, lembra do tradeoff entre velocidade e qualidade — como discutimos em AI Doubled Our Merged PRs — Here's What Actually Broke (And What Didn't), entregar rápido sem medir é só entregar ruído mais rápido.

Pra uma visão mais ampla de como infraestrutura e IA estão convergindo na borda, dá uma olhada no nosso breakdown de Post-Quantum IPsec interoperability entre Cloudflare, Cisco e Fortinet.

Próximos passos de aprendizado:

• Lê o repositório Granite TSFM pra API completa da receita.
• Roda o notebook de getting started de ponta a ponta com seus dados.
• Faz benchmark contra o GIFT-Eval pra ver onde sua série cai.

Fonte: IBM Research — Granite Timeseries Ensemble R1