Séries Temporais com ML — ARIMA, LSTM, Prophet e Transformers

Séries temporais são sequências de observações ordenadas no tempo. Previsão de séries temporais é uma das aplicações mais antigas e mais demandadas de machine learning — de previsão de demanda em varejo a cotações financeiras, de consumo de energia a métricas de produtos.

Papers de referência: arXiv cs.LG | stat.ML — seção time series

Conceitos fundamentais

Decomposição de séries temporais

Qualquer série pode ser decomposta em componentes:

Y(t) = Tendência(t) + Sazonalidade(t) + Resíduo(t)
     ou
Y(t) = Tendência(t) × Sazonalidade(t) × Resíduo(t)  [multiplicativo]

• Tendência: direção de longo prazo (crescimento, declínio)
• Sazonalidade: padrões cíclicos regulares (diário, semanal, anual)
• Resíduo: variação aleatória não explicada pelos componentes acima

Estacionariedade

Uma série é estacionária quando suas propriedades estatísticas (média, variância, autocovariância) não mudam ao longo do tempo.

Por que importa: a maioria dos modelos clássicos assume estacionariedade. Séries não-estacionárias (preços de ações, PIB) precisam ser transformadas.

Transformações comuns:

• Diferenciação: Δy_t = y_t - y_{t-1}
• Log-transformação: reduz heteroscedasticidade multiplicativa
• Remoção de tendência: subtrair tendência estimada

Teste ADF (Augmented Dickey-Fuller): testa presença de raiz unitária (não-estacionariedade). H₀: série tem raiz unitária. Rejeitar H₀ → série estacionária.

Modelos Clássicos

ARIMA — AutoRegressive Integrated Moving Average

O modelo estatístico padrão para séries temporais univariadas.

ARIMA(p, d, q):

• p (AR): order autoregressiva — valor atual depende de p valores passados
• d (I): grau de diferenciação para tornar série estacionária
• q (MA): order de média móvel — valor atual depende de q erros passados

ARIMA(1,1,1):
Δy_t = c + φ₁Δy_{t-1} + θ₁ε_{t-1} + ε_t

Onde:
- Δy_t = y_t - y_{t-1} (primeira diferença)
- φ₁: coeficiente autoregressivo
- θ₁: coeficiente de média móvel
- ε_t: ruído branco (erro)

SARIMA: extensão com componente sazonal SARIMA(p,d,q)(P,D,Q)[m] onde m é o período sazonal.

from statsmodels.tsa.arima.model import ARIMA

model = ARIMA(y_train, order=(1, 1, 1))
result = model.fit()
forecast = result.forecast(steps=30)

GARCH — Volatilidade condicional

Detalhe completo em Econometria. Essencial para finanças: modela períodos de alta e baixa volatilidade.

Facebook/Meta Prophet

Prophet (2017) é um modelo de séries temporais desenvolvido pelo time de Data Science do Facebook, projetado para analistas que não são especialistas em séries temporais.

Modelo interno:

y(t) = g(t) + s(t) + h(t) + ε_t

- g(t): tendência (linear ou logística com pontos de mudança)
- s(t): sazonalidade (Fourier series)
- h(t): feriados e eventos especiais
- ε_t: ruído

Vantagens:

• Lida automaticamente com sazonalidades múltiplas (diária, semanal, anual)
• Robusto a dados faltantes e outliers
• Detecta automaticamente changepoints na tendência
• Interface simples

from prophet import Prophet
import pandas as pd

df = pd.DataFrame({"ds": datas, "y": valores})

model = Prophet(
    seasonality_mode="multiplicative",
    yearly_seasonality=True,
    weekly_seasonality=True
)
model.fit(df)

future = model.make_future_dataframe(periods=365)
forecast = model.predict(future)
model.plot(forecast)

Deep Learning para séries temporais

LSTMs

Long Short-Term Memory networks (detalhes em Redes Neurais Profundas) são a primeira abordagem de deep learning a funcionar bem para séries temporais.

Vantagens: capturam dependências de longo prazo, aprendem padrões não-lineares complexos. Limitações: treinamento lento, sensível à escolha de hiperparâmetros, difícil interpretabilidade.

import torch
import torch.nn as nn

class LSTMForecast(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, horizon):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, horizon)

    def forward(self, x):
        lstm_out, _ = self.lstm(x)
        return self.fc(lstm_out[:, -1, :])  # Último hidden state

Temporal Fusion Transformer (TFT)

Google AI (2020) — estado da arte em previsão interpretável de séries temporais multivariadas.

Inovações:

• Variable Selection Networks: seleciona automaticamente as features mais relevantes
• Gated Residual Networks: controla fluxo de informação
• Interpretable Multi-Head Attention: permite visualizar quais timesteps o modelo foca

from pytorch_forecasting import TemporalFusionTransformer, TimeSeriesDataSet

dataset = TimeSeriesDataSet(
    data,
    time_idx="time_idx",
    target="vendas",
    group_ids=["loja"],
    max_encoder_length=60,
    max_prediction_length=30,
    time_varying_known_reals=["preco", "promocao"],
    time_varying_unknown_reals=["vendas"],
)

tft = TemporalFusionTransformer.from_dataset(dataset, learning_rate=0.03)

N-BEATS e N-HiTS

Modelos puramente baseados em MLP sem recorrência:

• N-BEATS (Element AI, 2020): interpretável, decompõe série em tendência e sazonalidade automaticamente
• N-HiTS (2022): hierárquico, eficiente para horizontes longos

Modelos Fundacionais para Time Series

Desenvolvimentos recentes em 2023-2024:

Avaliação de modelos de previsão

Métricas de erro

Estratégias de validação

⚠️ Nunca usar k-fold padrão em séries temporais!
  O k-fold mistura dados do futuro com o passado — vaza informação.

✅ Usar Walk-forward validation (Time Series Split):

  Fold 1: treino [1..100]   teste [101..120]
  Fold 2: treino [1..120]   teste [121..140]
  Fold 3: treino [1..140]   teste [141..160]

Aplicações em finanças

Previsão de preços

import yfinance as yf
from prophet import Prophet

# Dados históricos de PETR4
ticker = yf.Ticker("PETR4.SA")
hist = ticker.history(period="5y")

df = hist[["Close"]].reset_index()
df.columns = ["ds", "y"]

# Prophet com sazonalidade semanal
model = Prophet(weekly_seasonality=True, daily_seasonality=False)
model.fit(df)

future = model.make_future_dataframe(periods=90)
forecast = model.predict(future)

Aviso: previsão de preços de ativos é notoriamente difícil. Modelos de séries temporais capturam padrões históricos, mas mercados mudam de regime. Use para gestão de risco, não como sinal de trading direto.

Previsão de volatilidade

GARCH é o padrão acadêmico; deep learning pode capturar assimetrias e saltos:

from arch import arch_model

# GARCH(1,1) para volatilidade
retornos = np.log(precos).diff().dropna() * 100

model = arch_model(retornos, vol='Garch', p=1, q=1)
result = model.fit()
vol_forecast = result.forecast(horizon=5)

Anomaly detection em transações

Séries temporais de transações financeiras — detectar padrões anômalos (fraude, manipulação de mercado):

from sklearn.ensemble import IsolationForest

# Isola anomalias em séries multivariadas
iso_forest = IsolationForest(contamination=0.01, random_state=42)
anomalias = iso_forest.fit_predict(X_series)  # -1 = anomalia

Conexões com outras seções

• Econometria — ARIMA, GARCH e VAR são modelos econométricos de séries temporais
• Inferência Bayesiana — modelos probabilísticos de séries com incerteza quantificada
• Arbitragem Estatística — séries temporais de spreads e cointegração
• Precificação de Opções — modelagem de volatilidade com GARCH e modelos estocásticos
• Redes Neurais Profundas — LSTMs e Transformers para dados sequenciais

Aviso Legal: Conteúdo educativo. Previsões de séries temporais financeiras envolvem incerteza significativa. Não constitui recomendação de investimento.