O sktime oferece um ecossistema robusto, mas em cenarios reais frequentemente precisamos ajustar comportamentos, incorporar dados hierarquicos ou adicionar pre-processamentos especificos. Felizmente, o sktime torna relativamente simples a criacao de modelos customizados, desde que sigamos algumas regras.
+
Acredito que essa e uma das grandes vantagens da biblioteca: o foco em ser extensivel e customizavel.
+
+
11.1 O sistema de tags
+
Entre a chamada dos metodos publicos e privados existe uma camada de validacoes e conversões controlada pelas tags. Elas sinalizam ao BaseForecaster e ao BaseTransformer o que precisa ser garantido antes de executar a implementacao customizada.
+
As tags mais importantes para um forecaster podem ser definidas assim:
Cada uma delas indica o que o modelo é capaz de fazer nos seus métodos privados _fit e _predict:
+
+
capability:exogenous: Indica se o modelo suporta variáveis exógenas (X) durante o ajuste e a previsão.
+
requires-fh-in-fit: Indica se o modelo precisa do horizonte de previsão (fh) durante o ajuste. Alguns modelos precisam devido a sua implementação interna.
+
y_inner_mtype: Define os tipos de dados aceitos para a variável dependente (y) durante o ajuste e a previsão.
+
X_inner_mtype: Define os tipos de dados aceitos para as variáveis exógenas (X) durante o ajuste e a previsão.
+
+
Os machine-types (mtypes), ou tipos para máquina, são a peça mais crucial nesse sistema.
+
+
11.1.1 Machine-types disponiveis
+
Os mtypes definem qual a estrutura de dados que o modelo aceita como entrada e produz como saída. Os principais mtypes para séries temporais são:
+
+
np.ndarray
+
pd.Series
+
pd.DataFrame
+
pd-multiindex (ideia de painel)
+
pd_multiindex_hier (dados hierarquicos)
+
+
Se o modelo suporta um mtype hierárquico e passamos um dado hierárquico, o dado chegará normalmente ao método privado _fit ou _predict. Caso contrário, o sktime tentará converter o dado para um mtype suportado.
+
+
11.1.1.1 Baixando exemplos por mtype
+
Para entender melhor cada mtype, podemos baixar exemplos práticos usando a função get_examples do sktime:
+
+
from sktime.datatypes import get_examples
+
+get_examples(mtype="np.ndarray", as_scitype="Series")[0]
Agora veremos como o modelo se comporta com dados hierárquicos. Note que, nos casos onde o modelo não suporta dados hierárquicos, o sktime tentará convertê-los para um mtype suportado.
Abaixo, implementamos o CustomNaiveForecaster seguindo as regras do sktime (clique para expandir). Em seguida, explicamos passo a passo.
+
+
+Code
+
from sktime.forecasting.base import BaseForecaster
+import pandas as pd
+
+
+class CustomNaiveForecaster(BaseForecaster):
+"""
+ A simple naive forecaster
+
+ Parameters
+ ----------
+ n : int
+ Number of past values to use.
+ """
+
+ _tags = {
+"requires-fh-in-fit": False,
+"y_inner_mtype": [
+"pd.Series",
+ ],
+ }
+
+# Add hyperparameters in init!
+def__init__(self, n=1):
+# 1. Set hyper-parameters
+self.n = n
+
+# 2. Initialize parent class
+super().__init__()
+
+# 3. Check hyper-parameters
+assertself.n >0, "n must be greater than 0"
+
+def _fit(self, y, X, fh):
+"""
+ Fit necessary parameters.
+ """
+
+self.value_ = y.iloc[-self.n :].mean()
+returnself
+
+def _predict(self, fh, X):
+"""
+ Use forecasting horizon and optionally X to predict y
+ """
+
+# During fit, BaseForecaster sets
+# self.cutoff to the latest cutoff time point
+ index = fh.to_absolute_index(self.cutoff)
+ y_pred = pd.Series(
+ index=index,
+ data=[self.value_ for _ inrange(len(index))],
+ )
+ y_pred.name =self._y.name
+
+return y_pred
+
+# Veremos mais tarde como usar esse método
+@classmethod
+def get_test_params(cls, parameter_set="default"):
+return [
+ {"n": 1},
+ {"n": 2},
+ ]
+
+
+
+
11.2.1 Definindo o método __init__
+
O método __init__ possui 3 etapas:
+
+
A definição dos hiperparametros e seus atributos com mesmo nome.
+
A chamada do super().__init__() para inicializar a classe pai.
+
A validação dos hiperparâmetros.
+
+
# Add hyperparameters in init!
+def__init__(self, n=1):
+# 1. Set hyper-parameters
+self.n = n
+
+# 2. Initialize parent class
+super().__init__()
+
+# 3. Check hyper-parameters
+assertself.n >0, "n must be greater than 0"
+
No caso de algum preprocessamento dos hiperparâmetros no __init__, devemos guardar em uma variável com nome diferente do hiperparâmetro. Por exemplo, se tivéssemos interesse em ter um atributo n diferente do passado no __init__, poderíamos fazer:
+
self._n = n + 1
+
O self.n funciona como uma digital do modelo, e deve ser exatamente o que foi passado no __init__.
+
+
+
11.2.2 Definindo o método _fit
+
No método _fit, devemos implementar a lógica de ajuste do modelo. No nosso caso, calculamos a média dos últimos n valores e armazenamos em self.value_.
+
O _ após o nome do atributo indica que é um atributo aprendido durante o ajuste, e será retornado quando chamarmos get_fitted_params().
+
Note que podemos supor que y é do tipo definido na tag y_inner_mtype, ou seja, uma pd.Series.
+
+
+
11.2.3 Definindo o método _predict
+
No método _predict, implementamos a lógica de previsão. Usamos o horizonte de previsão fh para determinar os índices futuros e retornamos uma série com o valor previsto para cada ponto no horizonte.
+
O fh é um objeto do tipo ForecastingHorizon, que possui o método to_absolute_index(cutoff) para converter o horizonte relativo em índices absolutos, considerando o último ponto conhecido (self.cutoff).
+
Retornamos um pd.Series com os índices e os valores previstos.
+
+
+
11.2.4 Usando o CustomNaiveForecaster
+
Agora, já podemos usar o nosso modelo customizado para fazer previsões.
Please rerun this cell to show the HTML repr or trust the notebook.
CustomNaiveForecaster()
+
+
+
Como passamos um dado hierárquico, o sktime converteu automaticamente para pd.Series, que é o mtype suportado pelo nosso modelo. Os modelos internos, para cada série, ficam disponíveis em forecasters_.
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/extra/sktime_custom_files/figure-html/cell-20-output-1.png b/book/latest/content/pt/extra/sktime_custom_files/figure-html/cell-20-output-1.png
new file mode 100644
index 0000000..5a39fa5
Binary files /dev/null and b/book/latest/content/pt/extra/sktime_custom_files/figure-html/cell-20-output-1.png differ
diff --git a/book/latest/content/pt/extra/sktime_custom_files/figure-html/cell-24-output-1.png b/book/latest/content/pt/extra/sktime_custom_files/figure-html/cell-24-output-1.png
new file mode 100644
index 0000000..2bd74db
Binary files /dev/null and b/book/latest/content/pt/extra/sktime_custom_files/figure-html/cell-24-output-1.png differ
diff --git a/book/latest/content/pt/part1/balls1.png b/book/latest/content/pt/part1/balls1.png
new file mode 100644
index 0000000..bb8bcab
Binary files /dev/null and b/book/latest/content/pt/part1/balls1.png differ
diff --git a/book/latest/content/pt/part1/components_and_diff.html b/book/latest/content/pt/part1/components_and_diff.html
new file mode 100644
index 0000000..d81ff13
--- /dev/null
+++ b/book/latest/content/pt/part1/components_and_diff.html
@@ -0,0 +1,2761 @@
+
+
+
+
+
+
+
+
+
+3 Decomposição de séries temporais e modelos clássicos – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
3Decomposição de séries temporais e modelos clássicos
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Nesse capítulo, vamos começar a usar um dataset mais realista, com dados simulando vendas diárias de uma empresa de varejo.
+
Vamos aprender os seguintes pontos:
+
+
Definição de séries integradas, e uso de diferenciação
+
Modelos estatísticos clássicos: modelos de suavização exponencial e modelos autoregressivos (AR)
+
Como usar esses modelos com a biblioteca sktime
+
+
+
3.1 Importando dados
+
Para acessar os dados, vamos usar a classe SyntheticRetail da biblioteca tsbook, que contém dados simulados de vendas diárias de uma empresa de varejo.
Os dados são diários, e vemos que sempre positivos. Também notamos que existe alguma sazonalidade, aparentemente algo mensal e anual, que aumenta de magnitude ao longo do tempo.
+
Algo que deve chamar a atenção nesse gráfico é que a magnitude da série temporal está aumentando ao longo do tempo. Isso não deve passar desapercebido, pois é um ponto importante para entendermos o que vem a seguir.
+
+
+
3.2 Auto-correlação
+
É interessante entender o quanto de informação o passado de uma série temporal carrega sobre o seu futuro. Uma maneira de capturar essa relação (considerando variações lineares) é através da auto-correlação. A autocorrelação para um determinado lag \(k\) é definida como:
Em outras palavras, quando o valor em \(k\) observações atrás está acima (ou abaixo) da média, o valor atual também tende a estar acima (ou abaixo) da média?
+
Com plot_correlations, podemos visualizar algumas informações úteis:
+
+
No plot superior, vemos a série temporal original.
+
No canto inferior esquerdo, temos o gráfico de autocorrelação (ACF), que mostra a correlação entre a série temporal e suas versões defasadas (lags). Valores próximos de 1 ou -1 indicam uma forte correlação positiva ou negativa, respectivamente.
+
No canto inferior direito, temos o gráfico de autocorrelação parcial (PACF), que mostra a correlação entre a série temporal e suas versões defasadas, controlando para as correlações intermediárias. É útil para entender o efeito isolado de um lag.
/var/folders/_2/9y4tsvdd2n3gqjgd2zmlr1km0000gn/T/ipykernel_24222/2914460266.py:5: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown
+ fig.show()
+
+
+
+
+
+
+
+
+
+
No gráfico de autocorrelação, vemos algumas características interessantes:
+
+
Valores são extremamente altos, e decaem lentamente ao longo do tempo.
+
Existem oscilações claras, indicando padrões sazonais na série temporal.
+
+
+
+
+
+
+
+Tip
+
+
+
+
É um erro comum usar a correlação de lags de uma série para seleção de variáveis (lags). Sempre que possível, devemos eliminar a tendência antes de analisar a autocorrelação.
+
+
+
Veremos que esses padrões são indicativos de que a série temporal possui componentes importantes, e que valores passados dizem muito sobre valores futuros.
+
+
+
3.3 Componentes de séries temporais
+
Séries temporais podem ser decompostas em 3 componentes principais:
+
+
Tendência: padrão de longo prazo na série temporal
+
Sazonalidade: padrões que se repetem em intervalos regulares, como diariamente, semanalmente ou anualmente
+
Ruído: variação aleatória que não pode ser explicada pelos outros componentes
+
+
Uma série aditiva pode ser representada como:
+
\[
+Y(t) = T(t) + S(t) + R(t)
+\]
+
onde \(T(t)\) é a tendência, \(S(t)\) é a sazonalidade, e \(R(t)\) é o ruído.
+
Em séries aditivas, o impacto da sazonalidade se dá em termos absolutos, dizemos: “em janeiro, as vendas aumentam em 100 unidades com relação a média do ano”.
+
Mas também existem séries multiplicativas, onde os componentes interagem de forma diferente:
+
\[
+Y(t) = T(t) \cdot S(t) \cdot R(t)
+\]
+
Nessas séries, o impacto da sazonalidade se dá em termos relativos, dizemos: “em janeiro, as vendas aumentam em 20% com relação a média do ano”. Esse é o caso mais comum para séries não-negativas, como vendas. Isso vem por definição: se temos vendas muito baixas, por exemplo, 10 unidades, não faz sentido dizer que em janeiro as vendas diminuem em 100 unidades, pois isso levaria a vendas negativas. Já dizer que as vendas diminuem em 20% é perfeitamente razoável.
+
+
+
+
+
+
+Tip
+
+
+
+
Em alguns casos, as séries multiplicativas são definidas como:
Para fazer isso no sktime, usamos o transformador LogTransformer. Transformadores são usados para pré-processar ou pós-processar os dados antes de aplicar um modelo de previsão, e sua interface é similar a dos modelos de previsão:
+
+
__init__: define os hiperparâmetros do transformador
+
fit: aprende os parâmetros do transformador a partir dos dados
+
transform: aplica a transformação nos dados
+
inverse_transform (opcional): aplica a transformação inversa nos dados
+
+
+
from sktime.transformations.series.boxcox import LogTransformer
+log_transformer = LogTransformer()
+log_transformer.fit(y_train)
+
+
LogTransformer()
Please rerun this cell to show the HTML repr or trust the notebook.
Ainda que não esteja perfeito, essa transformação estabiliza as variações da série temporal, o que é importante para alguns modelos de previsão.
+
+
3.3.1 Decompondo a série temporal
+
Sktime fornece algumas opções para decompor séries temporais. Aqui, vamos usar o Detrender para remover a tendência, e o Deseasonalizer para remover a sazonalidade.
/var/folders/_2/9y4tsvdd2n3gqjgd2zmlr1km0000gn/T/ipykernel_24222/935228866.py:2: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown
+ fig.show()
+
+
+
+
+
+
+
+
+
+
O que indica que, ao eliminar a tendencia, a informação que o passado carrega sobre o futuro diminuiu bastante. Na verdade, a existência da tendência - um efeito de longo prazo - faz com que valores passados sejam altamente correlacionados com valores futuros, e pode dar a falsa impressão de que a série é “fácil” de modelar.
+
+
+
3.3.1.2 Sazonalidade
+
Agora, usamos o Deseasonalizer para remover a sazonalidade:
/var/folders/_2/9y4tsvdd2n3gqjgd2zmlr1km0000gn/T/ipykernel_24222/10449850.py:2: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown
+ fig.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Tip
+
+
+
+
Tente adicionar mais um deseasonalizer para remover a sazonalidade semanal.
+
+
+
+
+
+
+
3.4 Séries estacionárias
+
O conceito de estacionariedade é fundamental em séries temporais. Uma série temporal é dita estacionária se suas propriedades estatísticas, como média, variância e autocovariância, são constantes ao longo do tempo, não importando a janela e quando ela é observada.
+
+
Mais precisamente, se \(Y(t)\), onde \(t\) é o indice temporal, então dizemos que ela é estacionária se:
Claramente, a série temporal que estamos analisando não é estacionária. Basta percebermos que para valores maiores de \(t\), a média e a variância são maiores.
+
O aumento da média da série ao longo do tempo é chamado de tendência. A tendência é um padrão de longo prazo na série temporal, e um grande desafio para previsões de longo prazo.
+
Existem definições mais “suaves” de estacionariedade, como a estacionariedade fraca, que requer apenas que propriedades como média e autovariância sejam constantes ao longo do tempo.
+
No fundo, o que nos interessa mais é ter uma série temporal que seja “fácil”de modelar. Para alguns algoritmos, como Naive, é importante que ela seja o mais próxima possível de estacionária. Veja abaixo o problema geraodo quando aplicamos o modelo Naive diretamente na série temporal original.
Uma técnica simples e eficaz para lidar com séries não estacionárias é a diferenciação. Calculamos:
+
\[
+Y'(t) = Y(t) - Y(t-1)
+\]
+
e fazemos previsões em \(Y'(t)\) ao invés de \(Y(t)\). Para obter a previsão de \(Y(t)\), precisamos fazer o processo inverso: somar a previsão de \(Y'(t)\) com o valor anterior de \(Y(t-1)\).
Existem ainda alguns problemas com a diferenciação. Note que a variância da série temporal diferenciada não é constante ao longo do tempo. Aqui, podemos combinar nossa transformação logarítmica com a diferenciação.
+
Primeiro, vamos criar um transformador que combina as duas transformações:
Ele basicamente atribui o mesmo peso para todas as observações passadas. Mas, intuitivamente, faz mais sentido dar mais peso para as observações mais recentes, e menos peso para as observações mais antigas.
+
O exponential smoothing faz exatamente isso. Ele atribui pesos decrescentes para observações mais antigas. O peso da observação decresce exponencialmente segundo um fator \(0 < \alpha < 1\)(Hyndman and Athanasopoulos 2018):
Modelos autoregressivos (AR) são modelos que prevem o valor atual de uma série temporal como uma combinação dos valores passados. O modelo AR(p) usa os últimos p valores para fazer a previsão:
Um modelo auto-regressivo mais complexo é o ARIMA, que combina autoregressão (AR), média móvel (MA) e diferenciação integrada (I) para lidar com séries temporais não estacionárias. Não vamos estudar o ARIMA aqui pois envolve conceitos mais avançados, mas temos ele disponível no sktime, sktime.forecasting.arima.ARIMA.
+
+
+
4.3 STL: dividir e conquistar
+
Sabemos que séries temporais podem ser decompostas em componentes de tendência, sazonalidade e resíduos. O modelo STL (Seasonal and Trend decomposition using Loess) é uma técnica que permite fazer essa decomposição de forma robusta.
+
Temos no sktime o STLTransformer, que permite fazer a decomposição STL:
+
+
from sktime.transformations.series.detrend import STLTransformer
+
+stl = STLTransformer(sp=365)
+stl.fit(y_train)
+
+
STLTransformer(sp=365)
Please rerun this cell to show the HTML repr or trust the notebook.
/var/folders/_2/9y4tsvdd2n3gqjgd2zmlr1km0000gn/T/ipykernel_24269/1542615419.py:8: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown
+ fig.show()
+
+
+
+
+
+
+
+
+
+
Uma possibilidade, uma vez que temos os diferentes componentes, é modelar cada componente separadamente e depois combinar as previsões. O sktime tem o STLForecaster, que faz exatamente isso:
+Hyndman, Rob J, and George Athanasopoulos. 2018. Forecasting: Principles and Practice. OTexts.
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-10-output-1.png b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-10-output-1.png
new file mode 100644
index 0000000..91610b3
Binary files /dev/null and b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-10-output-1.png differ
diff --git a/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-12-output-1.png b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-12-output-1.png
new file mode 100644
index 0000000..a6d8007
Binary files /dev/null and b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-12-output-1.png differ
diff --git a/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-2-output-1.png b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-2-output-1.png
new file mode 100644
index 0000000..025abce
Binary files /dev/null and b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-2-output-1.png differ
diff --git a/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-5-output-1.png b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-5-output-1.png
new file mode 100644
index 0000000..8cca719
Binary files /dev/null and b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-5-output-1.png differ
diff --git a/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-6-output-1.png b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-6-output-1.png
new file mode 100644
index 0000000..600f315
Binary files /dev/null and b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-6-output-1.png differ
diff --git a/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-7-output-1.png b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-7-output-1.png
new file mode 100644
index 0000000..f376a3a
Binary files /dev/null and b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-7-output-1.png differ
diff --git a/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-9-output-2.png b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-9-output-2.png
new file mode 100644
index 0000000..8ad122b
Binary files /dev/null and b/book/latest/content/pt/part1/ets_and_ar_files/figure-html/cell-9-output-2.png differ
diff --git a/book/latest/content/pt/part1/index.html b/book/latest/content/pt/part1/index.html
new file mode 100644
index 0000000..41b9792
--- /dev/null
+++ b/book/latest/content/pt/part1/index.html
@@ -0,0 +1,770 @@
+
+
+
+
+
+
+
+
+
+1 Definição do problema – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1Definição do problema
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Em modelos de regressão e classificação básicos, supomos que os dados são i.i.d: variaveis aleatórias independentes e identicamente distribuidas. Ou seja, a ordem que observamos os dados não tem nenhum impacto em nossa habilidade de prever quais serão as próximas observações.
+
Vamos considerar um experimento simples: temos uma caixa com bolas pretas e vermelhas dentro. Digamos que as bolas pretas valem 1 e as bolas vermelhas valem 0. Queremos descobrir qual a quantidade de pontos vamos ter na próxima rodada.
+
+
+
+Bolas pretas e vermelhas
+
+
+
Se as bolas estão distribuidas aleatóriamente dentro da caixa, podemos esperar ver algo como a seguinte sequência de pontos:
+
\[
+\{0, 1, 1, 0, 1, 0, 0, \dots \}
+\]
+
Nesse caso, a ordem dos pontos não importa. Não importa o que vimos até então; a próxima bola que vamos tirar da caixa é independente das bolas que já tiramos.
+
Vamos supor um caso ligeiramente diferente. Agora, as bolas estão organizadas em blocos: primeiro todas as bolas pretas, depois todas as bolas vermelhas, depois todas as bolas pretas de novo, e assim por diante. Nesse caso, podemos esperar ver algo como:
+
\[
+\{1, 1, 1, 0, 0, 0, 1, 1, 1, \dots \}
+\]
+
Nesse caso, a ordem dos pontos importa. Se vimos muitas bolas pretas recentemente, é mais provável que vejamos uma bola preta na próxima rodada. A próxima bola que vamos tirar da caixa depende das bolas que já tiramos. Esse é um caso básico de aplicação de modelos de previsão de séries temporais.
+
Considerando que cada observação é indexada por uma variável temporal, podemos definir uma série temporal como uma sequência de observações ordenadas no tempo. Exemplos comuns de séries temporais incluem:
+
+
Varejo: vendas diárias, semanais ou mensais de um produto
+
Finanças: preços diários de ações, taxas de câmbio
+
Saúde: número diário de novos casos de uma doença
+
Clima: temperatura diária, precipitação mensal
+
+
Esse livro é uma introdução prática a modelos de séries temporais, com objetivo de dar contexto das ferramentas mais relevantes em 3h de leitura.
+
O conteúdo está organizado nas seguintes seções:
+
+
Introdução a séries temporais:
+
+
Modelo Naive, Modelo Naive sazonal
+
Séries integradas, diferenciação e estacionariedade
+
Modelo de Suavização Exponencial (Exponential Smoothing)
+
Modelos autoregressivos (AR)
+
Métricas de avaliação de modelos de séries temporais
+
Engenharia de features para séries temporais
+
+
Modelos avançados e caso de uso
+
+
Forecast com modelos de Machine Learning
+
Forecast com modelos fundacionais
+
Previsão de vendas totais agregadas
+
Previsão de vendas por região e modelos globais
+
Previsão hierárquica e reconciliação
+
+
Customização de modelos com sktime
+
+
Como customizar e criar modelos em sktime
+
Criando um wrapper de biblioteca externa
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part1/metricas.html b/book/latest/content/pt/part1/metricas.html
new file mode 100644
index 0000000..a3d3f92
--- /dev/null
+++ b/book/latest/content/pt/part1/metricas.html
@@ -0,0 +1,1035 @@
+
+
+
+
+
+
+
+
+
+5 Métricas e cross-validation – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
5Métricas e cross-validation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Até então, vimos como criar modelos de séries temporais e avaliamos qualitativamente seu desempenho, em apenas uma simples divisão treino-teste. Agora, vamos explorar como avaliar modelos de séries temporais de forma mais robusta, utilizando métricas específicas e técnicas de validação cruzada adaptadas para dados temporais.
+
+
5.1 Métricas
+
Primeiro vamos baixar os dados e criar um modelo simples.
Para avaliar o desempenho de modelos de séries temporais, existem diversas métricas que podem ser utilizadas.
+
Duas métricas básicas são:
+
+
Mean Absolute Error (MAE): Média dos erros absolutos entre as previsões e os valores reais. \[
+MAE = \frac{1}{h} \sum_{t=T+1}^{T+h} |y_t - \hat{y}_t|
+\]
+
+
+
from sktime.performance_metrics.forecasting import MeanAbsoluteError
+
+metric = MeanAbsoluteError()
+metric(y_true=y_test, y_pred=y_pred)
+
+
np.float64(615.0555555555555)
+
+
+
+
Mean Squared Error (MSE): Média dos erros quadráticos entre as previsões e os valores reais.
from sktime.performance_metrics.forecasting import MeanSquaredError
+
+metric = MeanSquaredError()
+metric(y_true=y_test, y_pred=y_pred)
+
+
np.float64(633773.8777777777)
+
+
+
No entanto, essas métricas não levam em consideração a escala dos dados, o que pode ser um problema ao comparar desempenho entre diferentes séries temporais, e também na comunicação dos resultados para stakeholders.
+
Em muitos meios, é comum usar métricas que eliminam o fator escala, como:
+
+
Mean Absolute Percentage Error (MAPE): Média dos erros percentuais absolutos entre as previsões e os valores reais.
Essas métricas, no entanto, apresentam seus próprios problemas. Note que os valores podem ser exageradamente alto quando o denominador é próximo de zero. Ou seja, o MAPE e sMAPE podem ser problemáticos quando a série temporal contém valores próximos de zero.
+
Outro tema é que essas métricas não consideram a dificuldade da série. Por exemplo, 5% de erro pode ser muito em uma série, e pouco em outra. Para isso, foram propostas métricas “escalas”:
+
+
Mean Absolute Scaled Error (MASE): dividimos o erro absoluto pelo erro absoluto médio de um naive nos dados de treino. Se:
Expanding window: a janela de treino começa com um tamanho mínimo, e vai aumentando ao longo do tempo, incluindo todos os dados anteriores. A cada passo, o modelo é re-treinado com todos os dados disponíveis até aquele ponto.
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part1/metricas_files/figure-html/cell-10-output-1.png b/book/latest/content/pt/part1/metricas_files/figure-html/cell-10-output-1.png
new file mode 100644
index 0000000..1ff4ee8
Binary files /dev/null and b/book/latest/content/pt/part1/metricas_files/figure-html/cell-10-output-1.png differ
diff --git a/book/latest/content/pt/part1/metricas_files/figure-html/cell-9-output-1.png b/book/latest/content/pt/part1/metricas_files/figure-html/cell-9-output-1.png
new file mode 100644
index 0000000..97c4cea
Binary files /dev/null and b/book/latest/content/pt/part1/metricas_files/figure-html/cell-9-output-1.png differ
diff --git a/book/latest/content/pt/part1/naive.html b/book/latest/content/pt/part1/naive.html
new file mode 100644
index 0000000..1cbfa49
--- /dev/null
+++ b/book/latest/content/pt/part1/naive.html
@@ -0,0 +1,1570 @@
+
+
+
+
+
+
+
+
+
+2 Primeiro passos com sktime e modelo Naive – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
2Primeiro passos com sktime e modelo Naive
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Considerando o nosso exemplo da caixa com bolas pretas e vermelhas, um modelo simples para prever a próxima bola que vamos tirar da caixa é o Modelo Naive.
+
Existem algumas versões de modelo naive:
+
+
Naive (last): a previsão para o próximo ponto é igual ao último ponto observado.
+
Naive (mean): a previsão para o próximo ponto é igual à média dos pontos observados numa janela passada.
+
Naive Sazonal: a previsão para o próximo ponto é igual ao ponto observado na mesma posição em um ciclo anterior. Por exemplo, se estamos prevendo vendas diárias e hoje é segunda-feira, a previsão para hoje é igual às vendas da última segunda-feira.
+
+
Esse modelo é simples, mas é extremamente eficaz e dificil de ser vencido em muitos casos. No cenário onde os dados não vêm organizados em nenhuma ordem específica, a melhor aposta que podemos fazer é o valor médio das bolas no histórico recente.
+
Vamos ver como fazer um forecast simples com sktime, usando o modelo Naive.
+
+
2.1 Exemplo prático com sktime
+
Aqui, baixamos o dataset simples que vem na biblioteca desse repositório.
Esse é um dataset simples com uma série temporal mensal. Vamos dividir os dados em treino e teste, usando os últimos 36 meses como teste. Para isso, devemos respeitar a ordem temporal dos dados.
+
A função temporal_train_test_split faz isso para nós.
+
+
from sktime.forecasting.model_selection import temporal_train_test_split
+y_train, y_test = temporal_train_test_split(y, test_size=36)
+
+
Também temos uma função de plotagem simples para visualizar séries temporais.
+
+
from sktime.utils.plotting import plot_series
+
+plot_series(y, labels=["Observações"])
+
+
+
+
+
+
+
+
+
+
2.1.1 Criando o modelo
+
No sktime, os modelos são usados em 3 passos:
+
+
Inicialização (__init__): aqui, definimos os hiperparâmetros do modelo. Pense nessa parte como a configuração do modelo.
+
Treinamento (fit): aqui, o modelo aprende com os dados de treino.
+
Previsão (predict): com esse método, o modelo faz previsões para os dados futuros.
+
+
Quando inicializamos o modelo em um notebook, o sktime mostra uma ilustração do modelo, o que é útil para entender o que está acontecendo “por baixo dos panos”. Em casos mais complexos com composição de modelos, isso pode ser útil para ilustrar o que estamos fazendo para outros cientistas.
+
+
from sktime.forecasting.naive import NaiveForecaster
+
+model = NaiveForecaster(strategy="last")
+model
+
+
NaiveForecaster()
Please rerun this cell to show the HTML repr or trust the notebook.
NaiveForecaster()
+
+
+
Ao treinar o modelo, passamos dados de treinamento.
+
+
model.fit(y_train)
+
+
NaiveForecaster()
Please rerun this cell to show the HTML repr or trust the notebook.
NaiveForecaster()
+
+
+
Para a previsão, temos que passar um argumento obrigatório: fh, abreviatura de “forecasting horizon” (horizonte de previsão). Tipicamente passamos um fh relativo, ou seja, no formato de uma lista
+
+
model.predict(fh=[1,2,3,4])
+
+
+
+
+
+
+
+
+
points
+
+
+
+
+
2021-03-06
+
1.0
+
+
+
2021-03-07
+
1.0
+
+
+
2021-03-08
+
1.0
+
+
+
2021-03-09
+
1.0
+
+
+
+
+
+
+
+
Onde cada número representa o número de períodos à frente que queremos prever. Também podemos passar o fh como um índice de tempo absoluto, que é o que faremos aqui. Vamos passar o índice de tempo do conjunto de teste.
Claro, como esse exemplo é muito simples, o modelo naive sazonal captura perfeitamente a sazonalidade dos dados. No entanto, vamos ver no próximo capítulo um caso de uso mais realista, com dados de varejo, e estudaremos modelos mais avançados.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part1/naive_files/figure-html/cell-10-output-1.png b/book/latest/content/pt/part1/naive_files/figure-html/cell-10-output-1.png
new file mode 100644
index 0000000..388f0f2
Binary files /dev/null and b/book/latest/content/pt/part1/naive_files/figure-html/cell-10-output-1.png differ
diff --git a/book/latest/content/pt/part1/naive_files/figure-html/cell-4-output-1.png b/book/latest/content/pt/part1/naive_files/figure-html/cell-4-output-1.png
new file mode 100644
index 0000000..163a645
Binary files /dev/null and b/book/latest/content/pt/part1/naive_files/figure-html/cell-4-output-1.png differ
diff --git a/book/latest/content/pt/part1/naive_files/figure-html/cell-8-output-1.png b/book/latest/content/pt/part1/naive_files/figure-html/cell-8-output-1.png
new file mode 100644
index 0000000..98185b8
Binary files /dev/null and b/book/latest/content/pt/part1/naive_files/figure-html/cell-8-output-1.png differ
diff --git a/book/latest/content/pt/part1/naive_files/figure-html/cell-9-output-1.png b/book/latest/content/pt/part1/naive_files/figure-html/cell-9-output-1.png
new file mode 100644
index 0000000..8080cf6
Binary files /dev/null and b/book/latest/content/pt/part1/naive_files/figure-html/cell-9-output-1.png differ
diff --git a/book/latest/content/pt/part2/deep_learning.html b/book/latest/content/pt/part2/deep_learning.html
new file mode 100644
index 0000000..1625e70
--- /dev/null
+++ b/book/latest/content/pt/part2/deep_learning.html
@@ -0,0 +1,1295 @@
+
+
+
+
+
+
+
+
+
+10 Modelos de deep learning e zero-shot forecasting – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
10Modelos de deep learning e zero-shot forecasting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Além de modelos de ML simples, também podemos usar modelos de deep learning para forecasting. Podemos com certeza usar uma rede neural simples como um regressor, assim como fizemos com os modelos de ML tradicionais. No entanto, existem alguns modelos com arquiteturas específicas para forecasting de séries temporais. Por exemplo, o N-BEATS é um modelo de deep learning que pode ser usado para forecasting.
+
+
+
+
+
+
+Tip
+
+
+
+
Importante notar que esse livro/tutorial tem o objetivo de ser curto e prático, então não entraremos em muitos detalhes sobre deep learning ou sobre todos métodos existentes.
+
+
+
+
+Code
+
import pandas as pd
+import matplotlib.pyplot as plt
+
+from sktime.utils.plotting import plot_series
N-BEATS é um modelo de séries temporais totalmente baseado em camadas densas (MLP)—nada de RNN/LSTM nem convolução. Ele pega uma janela do passado e entrega diretamente a previsão do futuro, aprendendo padrões como tendência e sazonalidade de forma pura, só com perceptrons.
+
O N-BEATS usa bases para construir sinais interpretáveis:
+
+
Base de tendência: combina funções polinomiais (captura subidas/descidas suaves).
+
Base sazonal: combina senos/cossenos (captura repetições periódicas).
+
Base genérica: aprende formas livres (sem pressupor forma analítica).
+
+
Assim, internamente, ele determina os coeficientes das funções base para modelar a série temporal, baseado no histórico observado, fazendo uma espécie de meta-aprendizado interno.
+
Os blocos são empilhados e executados de forma sucessiva. Pense numa fila de especialistas olhando a mesma janela do passado:
+
+
Cada um explica a sua parte do que viu (remove do passado o que já foi entendido = backcast), e propõe um pedaço da previsão (seu forecast).
+
O que não foi explicado segue para o próximo especialista. No final, a previsão é a soma do que cada um sugeriu.
+
+
+
+
10.1.1 Pytorch Forecasting
+
O Sktime nao é uma biblioteca especializada em deep learning, mas sim uma API uniforme que provê acesso aos mais diversos algoritmos.
+
Logo, também provemos acesso a bibliotecas especializadas em deep learning, como o Pytorch Forecasting, que implementa o N-BEATS.
+
Aqui, temos que definir os hiperparâmetros do modelo, como o número de blocos, o tamanho do contexto (janela de entrada), e o número de coeficientes para as funcões de base.
+
+
from sktime.forecasting.pytorchforecasting import PytorchForecastingNBeats
+from pytorch_forecasting.data.encoders import EncoderNormalizer
+
+CONTEXT_LENGTH =120
+nbeats = PytorchForecastingNBeats(
+ train_to_dataloader_params={"batch_size": 256},
+ trainer_params={"max_epochs": 1},
+ model_params={
+"stack_types": ["trend", "seasonality"], # One of the following values: “generic”, “seasonality” or “trend”.
+"num_blocks" : [2,2], # The number of blocks per stack.
+"context_length": CONTEXT_LENGTH, # lookback period
+"expansion_coefficient_lengths" : [2, 5],
+"learning_rate": 1e-3,
+ },
+ dataset_params={
+
+"max_encoder_length": CONTEXT_LENGTH,
+"target_normalizer": EncoderNormalizer()
+ },
+)
+
+nbeats.fit(y_train.astype(float), fh=fh)
+
+
💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.
+GPU available: True (mps), used: True
+TPU available: False, using: 0 TPU cores
+HPU available: False, using: 0 HPUs
+
+ | Name | Type | Params | Mode
+-------------------------------------------------------
+0 | loss | MASE | 0 | train
+1 | logging_metrics | ModuleList | 0 | train
+2 | net_blocks | ModuleList | 1.4 M | train
+-------------------------------------------------------
+1.4 M Trainable params
+0 Non-trainable params
+1.4 M Total params
+5.484 Total estimated model params size (MB)
+60 Modules in train mode
+0 Modules in eval mode
/Users/felipeangelim/Workspace/python_brasil_2025/.venv/lib/python3.11/site-packages/sktime/forecasting/base/adapters/_pytorchforecasting.py:655: FutureWarning: Downcasting object dtype arrays on .fillna, .ffill, .bfill is deprecated and will change in a future version. Call result.infer_objects(copy=False) instead. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`
+ _y.fillna(0, inplace=True)
+💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.
+GPU available: True (mps), used: True
+TPU available: False, using: 0 TPU cores
+HPU available: False, using: 0 HPUs
Agora, podemos visualizar o forecast para uma das séries. Vemos que, mesmo com poucas épocas de treinamento ou tuning, o N-BEATS já consegue capturar a tendência.
Zero-shot forecasting se refere ao fato de fazer previsão para uma série jamais vista pelo modeo, sem utilizar a série para treinar ou ajustar parâmetros dele.
+
Aqui, para simular esse cenário, vamos criar uma nova série temporal combinando duas séries do conjunto de treino.
+
+
new_y_train = (y_train.loc[0]**2+ y_train.loc[20]).astype(float)
+new_y_test = (y_test.loc[0]**2+ y_test.loc[20]).astype(float)
+
+# Plotting the new series
+fig, ax = plt.subplots(figsize=(10, 4))
+new_y_train["sales"].plot.line(ax=ax, label="New Train")
+new_y_test["sales"].plot.line(ax=ax, label="New Test")
+fig.show()
+
+
+
+
+
+
+
+
+
Na interface atual do sktime, usamos o argumento y do método predict para passar a nova série temporal para o modelo:
/Users/felipeangelim/Workspace/python_brasil_2025/.venv/lib/python3.11/site-packages/sktime/forecasting/base/adapters/_pytorchforecasting.py:655: FutureWarning: Downcasting object dtype arrays on .fillna, .ffill, .bfill is deprecated and will change in a future version. Call result.infer_objects(copy=False) instead. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`
+ _y.fillna(0, inplace=True)
+💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.
+GPU available: True (mps), used: True
+TPU available: False, using: 0 TPU cores
+HPU available: False, using: 0 HPUs
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-11-output-1.png b/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-11-output-1.png
new file mode 100644
index 0000000..3a69830
Binary files /dev/null and b/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-11-output-1.png differ
diff --git a/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-8-output-1.png b/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-8-output-1.png
new file mode 100644
index 0000000..1a7a253
Binary files /dev/null and b/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-8-output-1.png differ
diff --git a/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-9-output-1.png b/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-9-output-1.png
new file mode 100644
index 0000000..af73fad
Binary files /dev/null and b/book/latest/content/pt/part2/deep_learning_files/figure-html/cell-9-output-1.png differ
diff --git a/book/latest/content/pt/part2/exog_variables.html b/book/latest/content/pt/part2/exog_variables.html
new file mode 100644
index 0000000..33476d7
--- /dev/null
+++ b/book/latest/content/pt/part2/exog_variables.html
@@ -0,0 +1,2013 @@
+
+
+
+
+
+
+
+
+
+6 Variáveis Exógenas – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
6Variáveis Exógenas
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Como séries temporais possuem uma ordem temporal, a sua própria história tem poder preditivo muito forte. No entanto, em alguns casos, apenas a história não é suficiente para fazer previsões precisas.
+
Por exemplo, em vendas de varejo, fatores como promoções, feriados e eventos sazonais podem impactar significativamente as vendas.
+
Agora, vamos ver como usar variáveis exógenas em modelos de séries temporais com sktime, as famosas “features”.
+
A interface é sempre a mesma, vamos ver que a diferença é o uso do parâmetro X nos métodos fit e predict.
+
Usaremos os mesmos dados de varejo sintético dos exemplos anteriores. Agora, teremos também X_train e X_test, que são as variáveis exógenas.
Antes de prosseguirmos, vamos separar as variáveis exógenas em dois tipos:
+
+
Variáveis exógenas com valores futuros conhecidos: São variáveis cujos valores futuros já são conhecidos no momento da previsão. Variáveis indicadoras (dummies) para feriados ou eventos especiais, bem como recursos de sazonalidade, são exemplos comuns desse tipo de variável.
+
Variáveis exógenas com valores futuros desconhecidos: São variáveis cujos valores futuros não são conhecidos para o horizonte de previsão. Por exemplo, se quisermos incluir indicadores econômicos que ainda não foram divulgados, devemos tratá-los como variáveis exógenas de valor futuro desconhecido.
+
+
Nesse último cenário, para realizar a previsão, existem três opções: 1. Prever os valores futuros das variáveis exógenas usando um modelo separado (ou o mesmo modelo, se ele permitir) e usar essas previsões como entrada para o modelo principal de previsão. 2. Usar um valor de preenchimento (por exemplo, o último valor conhecido) para as variáveis exógenas de valor futuro desconhecido durante a previsão. 3. Usar valores defasados (lags) das variáveis exógenas como características (features), o que pode ser útil se o modelo conseguir aprender com os valores passados dessas variáveis.
+
+
+
6.2 Usando variáveis exógenas com sktime
+
Vamos usar AutoREG como modelo base para nosso exemplo de vairáveis exógenas. Primeiramente, vamos supor que conhecemos a variável macro_trend no futuro
plot_series(y_train, y_test, y_pred, labels=["Treino", "Teste", "Previsão com Exógenas"])
+
+
+
+
+
+
+
+
+
Fácil, no caso que conhecemos a variável exógena no futuro, basta passar X em fit e predict.
+
Antes de avançar, é importante revisar que os transformadores com fit e transform também podem ser aplicados a variávei exógenas! Inclusive, podemos fazer pipelines compostos de várias etapas de preprocessamento de exógenas. Isso será importante para os próximos exemplos.
+
+
+
6.3 Variável observada, mas desconhecida no futuro
+
Vamos eliminar a variável macro_trend do conjunto de teste, para simular o cenário onde não conhecemos o valor futuro dessa variável.
Agora, vamos supor que não sabemos o valor futuro de macro_trend. Nesse caso, podemos criar um modelo separado para prever macro_trend e usar essa previsão como entrada para o modelo principal.
+
Sktime possui uma funcionalidade pronta para isso: um forecaster chamado ForecastX. Ele é composto de dois modelos, um para a variável exógena, e outro para o alvo principal.
+
Aqui, o forecaster necessita que o horizonte de previsão (fh) seja passado já na etapa de fit.
+
+
from sktime.forecasting.compose import ForecastX
+
+model = ForecastX(
+ forecaster_y=AutoREG(lags=30),
+ forecaster_X=AutoREG(lags=30),
+)
+
+fh = [i for i inrange(1, len(y_test) +1)]
+model.fit(y_train, X=X_train, fh=fh)
+
+y_pred_case1 = model.predict(X=X_test_missing)
+
+
+
plot_series(y_train, y_test, y_pred_case1, labels=["Treino", "Teste", "Previsão com Exógenas Previstas"])
+
+
+
+
+
+
+
+
+
+
+
6.3.2 Solução 2: Usar valor de preenchimento (imputação)
+
Para essa solução, vamos usar transformadores para preencher os valores faltantes na variável exógena. Aqui, usaremos o Imputer do sktime, que suporta variáveis exógenas.
Nossa previsão não ficou boa. Claro! A variável exógena possui uma tendência - que naturalmente faz com que a imputação do ultimo valor ou a média não funcione bem. A solução ótima varia de caso para caso.
+
+
+
+
+
+
+Tip
+
+
+
+
Dica: Podemos também usar o operador ** como atalho para criar pipelines de variáveis exógenas.
+
model = Imputer(method="mean") ** AutoREG(lags=30)
+
Note a diferença do que aprendemos para criar pipelines com transformações na variável target, que usam * como operador. Claramente, podemos fazer composições mais complexas, como:
+
model = Imputer(method="mean") ** (Differencer() * AutoREG())
+
+
+
+
+
6.3.3 Solução 3: Usar valores defasados (lags) da variável exógena
+
Outra opção é criar versões defasadas das variáveis exógenas e usá-las como features.
+
Para isso, podemos usar o transformador Lag do sktime. Ao utilizar defasagens (lags), surgem dois desafios principais:
+
+
O aparecimento de valores NaN, que muitos modelos de previsão não conseguem tratar.
+
O número de variáveis exógenas pode aumentar significativamente, o que pode levar a overfitting ou, no caso do nosso conjunto de dados, a um número de features maior que o número de amostras — o que pode gerar erros no processo de ajuste (fitting).
+
+
Para lidar com isso, no exemplo abaixo utilizamos um TransformerPipeline que realiza as seguintes etapas:
+
+
Seleção de variáveis: executa uma seleção das variáveis exógenas, mantendo apenas as mais relevantes.
+
Defasagem: aplica o transformador Lag para criar versões defasadas das variáveis exógenas.
+
Imputação: usa o transformador Imputer para preencher os valores NaN criados pelo processo de defasagem. Neste caso, é usado o método backfill (preenchimento a partir de valores posteriores).
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-10-output-1.png b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-10-output-1.png
new file mode 100644
index 0000000..22fe4e2
Binary files /dev/null and b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-10-output-1.png differ
diff --git a/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-13-output-1.png b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-13-output-1.png
new file mode 100644
index 0000000..b21b266
Binary files /dev/null and b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-13-output-1.png differ
diff --git a/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-17-output-1.png b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-17-output-1.png
new file mode 100644
index 0000000..416c24e
Binary files /dev/null and b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-17-output-1.png differ
diff --git a/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-3-output-1.png b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-3-output-1.png
new file mode 100644
index 0000000..2a10f4d
Binary files /dev/null and b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-3-output-1.png differ
diff --git a/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-4-output-1.png b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-4-output-1.png
new file mode 100644
index 0000000..1e9d5f8
Binary files /dev/null and b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-4-output-1.png differ
diff --git a/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-7-output-1.png b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-7-output-1.png
new file mode 100644
index 0000000..dd2d9c3
Binary files /dev/null and b/book/latest/content/pt/part2/exog_variables_files/figure-html/cell-7-output-1.png differ
diff --git a/book/latest/content/pt/part2/hierarchical_forecasting.html b/book/latest/content/pt/part2/hierarchical_forecasting.html
new file mode 100644
index 0000000..92e35cc
--- /dev/null
+++ b/book/latest/content/pt/part2/hierarchical_forecasting.html
@@ -0,0 +1,1395 @@
+
+
+
+
+
+
+
+
+
+9 Forecasting Hierárquico – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
9Forecasting Hierárquico
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Muitas vezes, não apenas temos múltiplas séries temporais, mas essas séries também estão organizadas em uma hierarquia. Por exemplo, vendas de produtos podem ser organizadas por SKU, categoria, departamento e total da loja.
+
Vamos usar o mesmo dataset sintético, mas agora com uma hierarquia de produtos.
Ao mesmo tempo que dados hierarárquicos são interessantes pois nos trazem mais informação, eles também trazem desafios adicionais. Imagine que queremos prever as vendas futuras de cada produto. Se fizermos previsões independetes para cada produto, não há garantia que a soma das previsões dos produtos será igual à previsão do total da loja. Isso é chamado de incoerência nas previsões hierárquicas. O processo de ajustar as previsões para garantir coerência é chamado de reconciliação.
+
+
9.1 Carregando dados
+
Vamos usar os dados sintéticos, agora com sua versao hierárquica.
Agora, os dataframes possuem mais de 2 ou mais índices, representando a hierarquia.
+
+
y_train
+
+
+
+
+
+
+
+
+
+
+
sales
+
+
+
group_id
+
sku_id
+
date
+
+
+
+
+
+
-1
+
20
+
2020-01-01
+
0
+
+
+
2020-01-02
+
0
+
+
+
2020-01-03
+
0
+
+
+
2020-01-04
+
0
+
+
+
2020-01-05
+
2
+
+
+
...
+
...
+
...
+
...
+
+
+
__total
+
__total
+
2024-07-01
+
2000
+
+
+
2024-07-02
+
1616
+
+
+
2024-07-03
+
1917
+
+
+
2024-07-04
+
2384
+
+
+
2024-07-05
+
2462
+
+
+
+
+
51088 rows × 1 columns
+
+
+
+
Para obter o número de pontos de série únicos (séries temporais individuais), podemos fazer o seguinte:
+
+
y_train.index.droplevel(-1).nunique()
+
+
31
+
+
+
Note que existem algumas séries com um identificador __total. Esse identificador representa o total para aquele nível da hierarquia. Por exemplo, se o id completo é (-1, "__total"), isso representa o total do grupo -1.
+
+
y_train.loc[(-1, "__total")].head()
+
+
+
+
+
+
+
+
+
sales
+
+
+
date
+
+
+
+
+
+
2020-01-01
+
4
+
+
+
2020-01-02
+
2
+
+
+
2020-01-03
+
3
+
+
+
2020-01-04
+
14
+
+
+
2020-01-05
+
16
+
+
+
+
+
+
+
+
O total de todas as séries é representado por ("__total", "__total").
+
+
y_train.loc[("__total", "__total")]
+
+
+
+
+
+
+
+
+
sales
+
+
+
date
+
+
+
+
+
+
2020-01-01
+
24
+
+
+
2020-01-02
+
19
+
+
+
2020-01-03
+
14
+
+
+
2020-01-04
+
23
+
+
+
2020-01-05
+
23
+
+
+
...
+
...
+
+
+
2024-07-01
+
2000
+
+
+
2024-07-02
+
1616
+
+
+
2024-07-03
+
1917
+
+
+
2024-07-04
+
2384
+
+
+
2024-07-05
+
2462
+
+
+
+
+
1648 rows × 1 columns
+
+
+
+
Para contabilizar o número de séries temporais individuais, podemos fazer o seguinte:
+
+
y_train.index.droplevel(-1).nunique()
+
+
31
+
+
+
+
+
9.3 Previsão sem reconciliação
+
Vamos fazer uma previsão e entender o problema da incoerência.
Para somar as previsões de baixo para cima, podemos usar o transformador Aggregator. Vamos ver que, quando somarmos as previsões das séries filhas, o resultado não é igual à previsão da série total.
+
+
from sktime.transformations.hierarchical.aggregate import Aggregator
+
+Aggregator().fit_transform(y_pred) - y_pred
+
+
+
+
+
+
+
+
+
+
+
sales
+
+
+
group_id
+
sku_id
+
date
+
+
+
+
+
+
-1
+
20
+
2024-07-06
+
0.000000
+
+
+
2024-07-07
+
0.000000
+
+
+
2024-07-08
+
0.000000
+
+
+
2024-07-09
+
0.000000
+
+
+
2024-07-10
+
0.000000
+
+
+
...
+
...
+
...
+
...
+
+
+
__total
+
__total
+
2024-12-28
+
-195.866868
+
+
+
2024-12-29
+
-113.260571
+
+
+
2024-12-30
+
-294.224862
+
+
+
2024-12-31
+
-311.490070
+
+
+
2025-01-01
+
-256.487505
+
+
+
+
+
5580 rows × 1 columns
+
+
+
+
Existe uma diferença… ou seja, os valores não batem. Imagine o impacto de levar previsões incoerentes para a tomada de decisão em uma empresa? A raiz do problema é que temos mais modelos que graus de liberdade. Para ilustrar, suponha que temos 3 séries: \(A\), \(B\) e \(C\), onde:
+
\[
+C(t) = A(t) + B(t)
+\]
+
Aqui, temos 3 séries, mas apenas 2 graus de liberdade, pois \(C\) é completamente determinado por \(A\) e \(B\). Se fizermos previsões independentes para \(A\), \(B\) e \(C\), não há garantia de que a relação acima será mantida nas previsões.
+
+
+
9.4 Reconciliação de previsões hierárquicas
+
+
Existem diferentes métodos para reconciliar previsões em séries temporais hierárquicas. Não existe uma solução única, e o melhor método depende dos dados e do contexto.
+
+
+
9.5 Bottom-up
+
A maneira mais simples de reconcialiar previsões hierárquicas é a abordagem bottom-up. Nessa abordagem, fazemos previsões apenas para as séries mais baixas na hierarquia (as séries filhas) e depois somamos essas previsões para obter as previsões das séries superiores (as séries pais).
+
+
Lados positivos:
+
+
Simplicidade: fácil de entender e implementar.
+
Coerência garantida: a soma das previsões das séries filhas sempre será igual à previsão da série pai.
+
Sérias filhas podem capturar detalhes específicos que podem ser perdidos em níveis superiores.
+
+
No entanto, essa abordagem também tem desvantagens: é sucetível ao ruído nas séries filhas, e se as séries filhas tiverem pouca informação, as previsões podem ser ruins. Por exemplo, muitos zeros nas séries de níveis baixos pode levar a previsões ruins a niveis agregados.
Outra abordagem é a top-down. Nessa abordagem, fazemos previsões apenas para as séries superiores na hierarquia (as séries pais) e depois distribuímos essas previsões para as séries filhas com base em proporções previstas.
+
Suponha que temos a seguinte hierarquia \(C(t) = A(t) + B(t)\). Considere \(\hat{C}(t)\), \(\hat{A}(t)\) e \(\hat{B}(t)\) como as previsões para \(C\), \(A\) e \(B\), respectivamente. Na abordagem top-down, faríamos o seguinte:
+
+
Prever \(\hat{C}(t)\), \(\hat{A}(t)\) e \(\hat{B}(t)\) independentemente.
+
Calcular as proporções previstas para os níveis mais baixos: \[
+p_A(t) = \frac{\hat{A}(t)}{\hat{A}(t) + \hat{B}(t)}
+\]
Distribuir a previsão de \(C\) para \(A\) e \(B\) usando essas proporções: \[
+\tilde{A}(t) = p_A(t) \cdot \hat{C}(t)
+\]
+
+
\[
+\tilde{B}(t) = p_B(t) \cdot \hat{C}(t)
+\]
+
Essa abordagem é capaz de usufruir da qualidade do forecast total, e ainda consegue distribuir para as séries filhas baseadas no histórico.
+
+
O que chamam de “Proporções históricas” é equivalente a esse método, mas com um modelo Naive para prever as proporções.
+
Esse método pode ser bom quando o forecast total é de boa qualidade. No entanto, dependemos profundamente da qualidade do forecast total e das proporções.
Existe uma abordagem mais sofisticada, com uma intuição geométrica interessante. A ideia é ajustar as previsões iniciais para que elas satisfaçam as restrições de soma da hierarquia. Por exemplo, para a hierarquia \(C(t) = A(t) + B(t)\), queremos garantir que:
+
\[
+\hat{C}(t) = \hat{A}(t) + \hat{B}(t)
+\]
+
Se consideramos nosso espaço 3D de observações \((\hat{A}, \hat{B}, \hat{C})\), a condição acima é satisfeita para um plano 2D nesse universo.
+
+
Podemos então projetar nossas previsões iniciais nesse plano para obter previsões coerentes. Essa projeção pode ser feita de várias maneiras, levando a diferentes métodos de reconciliação ótima. Os métodos levam o nome “OLS” pois a projeção é feita minimizando o erro quadrático (Ordinary Least Squares).
+
+
OLS : projetar ortogonalmente todas as previsões base na espaço de reconciliação, tratando todas as séries igualmente.
+
Weighted OLS: projetar obliquamente, ou seja, considerando pesos diferentes para cada série, permitindo dar mais importância a certas séries na reconciliação. A projeção não faz mais uma perpendicular, mas sim uma oblíqua.
+
Minimum trace (MinT): use a matriz de covariância do erro para encontrar as previsões reconciliadas ótimas. Chamado de “ótimo”.
+
+
Para a reconciliação ótima com OLS, podemos usar o OptimalReconciler do sktime:
from sktime.utils.plotting import plot_series
+import matplotlib.pyplot as plt
+import pandas as pd
+
+
+idx = y_train.index.droplevel(-1).unique()[10]
+
+plot_series(
+ y_train.loc[idx,],
+ y_test.loc[idx,],
+ y_pred.loc[idx,],
+ y_pred_optimal.loc[idx,],
+ labels=["Train", "Test", "Predicted (sem reconciliação)", "Predicted (ótimo)"],
+)
+plt.xlim(pd.to_datetime("2024-05-01"), None)
+plt.show()
+
+
+
+
+
+
+
+
+
+
Para reconciliações ótimas (que usam a covariância do erro), podemos usar o ReconcilerForecaster do sktime, que internamente já faz o cálculo da covariância do erro:
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part2/hierarchical_forecasting_files/figure-html/cell-16-output-1.png b/book/latest/content/pt/part2/hierarchical_forecasting_files/figure-html/cell-16-output-1.png
new file mode 100644
index 0000000..6a96af6
Binary files /dev/null and b/book/latest/content/pt/part2/hierarchical_forecasting_files/figure-html/cell-16-output-1.png differ
diff --git a/book/latest/content/pt/part2/img/coherent_plane.png b/book/latest/content/pt/part2/img/coherent_plane.png
new file mode 100644
index 0000000..836d394
Binary files /dev/null and b/book/latest/content/pt/part2/img/coherent_plane.png differ
diff --git a/book/latest/content/pt/part2/img/global_reduction.png b/book/latest/content/pt/part2/img/global_reduction.png
new file mode 100644
index 0000000..7fbe4c6
Binary files /dev/null and b/book/latest/content/pt/part2/img/global_reduction.png differ
diff --git a/book/latest/content/pt/part2/img/hierarchical_bottomup.png b/book/latest/content/pt/part2/img/hierarchical_bottomup.png
new file mode 100644
index 0000000..472dc40
Binary files /dev/null and b/book/latest/content/pt/part2/img/hierarchical_bottomup.png differ
diff --git a/book/latest/content/pt/part2/img/hierarchical_reconciled_vs_not.png b/book/latest/content/pt/part2/img/hierarchical_reconciled_vs_not.png
new file mode 100644
index 0000000..4723676
Binary files /dev/null and b/book/latest/content/pt/part2/img/hierarchical_reconciled_vs_not.png differ
diff --git a/book/latest/content/pt/part2/img/hierarchical_td_fcst.png b/book/latest/content/pt/part2/img/hierarchical_td_fcst.png
new file mode 100644
index 0000000..60f44fb
Binary files /dev/null and b/book/latest/content/pt/part2/img/hierarchical_td_fcst.png differ
diff --git a/book/latest/content/pt/part2/img/nbeats_simplified.png b/book/latest/content/pt/part2/img/nbeats_simplified.png
new file mode 100644
index 0000000..aeac0a4
Binary files /dev/null and b/book/latest/content/pt/part2/img/nbeats_simplified.png differ
diff --git a/book/latest/content/pt/part2/img/reduction.png b/book/latest/content/pt/part2/img/reduction.png
new file mode 100644
index 0000000..d672f20
Binary files /dev/null and b/book/latest/content/pt/part2/img/reduction.png differ
diff --git a/book/latest/content/pt/part2/ml_models.html b/book/latest/content/pt/part2/ml_models.html
new file mode 100644
index 0000000..012d88d
--- /dev/null
+++ b/book/latest/content/pt/part2/ml_models.html
@@ -0,0 +1,1726 @@
+
+
+
+
+
+
+
+
+
+7 Modelos de Machine Learning – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
7Modelos de Machine Learning
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Nesse capítulo vamos ver as maneiras de usar modelos de Machine Learning para forecasting. Aqui é onde mais acontecem erros de novos praticantes, pois muitas vezes tentam aplicar modelos de ML diretamente na série temporal.
+
Para usar um modelo de ML, precisamos transformar a série temporal em um problema de regressão tradicional. Isso é feito criando janelas deslizantes (sliding windows) da série temporal, onde cada janela é usada como uma amostra de treinamento para o modelo de ML.
+
Ou seja, se temos uma série temporal \((y_t)\), podemos criar janelas de tamanho \(n\) e usar os valores \(y_{t-n}, y_{t-n+1}, \ldots, y_{t-1}\) como características (features) para prever o valor \(y_t\).
+
+
+
+img/reduction.png
+
+
+
Para prever mais de um passo à frente, existem duas abordagens:
+
+
Previsão recursive: se queremos prever \(h\) passos à frente, podemos usar o modelo para prever \(y_{t+1}\), depois usar essa previsão para prever \(y_{t+2}\), e assim por diante, até \(y_{t+h}\). Isso pode levar a erros acumulados, pois cada previsão depende das previsões anteriores.
+
Previsão direta: em vez de prever um passo de cada vez, podemos treinar o modelo para prever todos os \(h\) passos à frente de uma vez. Isso pode ser feito usando um modelo para cada \(h\) ou usando um modelo que prevê um vetor de \(h\) valores.
+
+
A verdade é que as duas abordagens podem ser vistas como uma: a previsão recursiva pode ser vista como uma previsão direta para \(h=1\).
A tendência em séries temporais é como um constante problema de data drift:
+
+
+Code
+
_X = [y_train.iloc[i : i +7] for i inrange(0, 700)]
+
+_X_test = [y_train.iloc[i : i +7] for i inrange(700, 800)]
+
+
+def set_index(x):
+ x.index =range(len(x))
+return x
+
+
+_X = [set_index(x) for x in _X]
+_X_test = [set_index(x) for x in _X_test]
+
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots()
+for x in _X:
+ ax.plot(x, color="gray", alpha=0.3)
+for x in _X_test:
+ ax.plot(x, color="red", alpha=0.3)
+
+# Add legend, with 1 red line for test and 1 gray for train
+from matplotlib.lines import Line2D
+
+legend_handles = [
+ Line2D([0], [0], color="gray", alpha=0.3, lw=2, label="Treino"),
+ Line2D([0], [0], color="red", alpha=0.3, lw=2, label="Teste"),
+]
+ax.legend(handles=legend_handles, loc="best")
+ax.set_title("Série original - Magnitudes diferentes para cada janela")
+fig.show()
+
+
+
+
+
+
+
+
+
+
Quando criamos nossas janelas e olhamos treine e teste, esse problema fica claro. A informação de uma série em treino não é util para prever a série de teste, pois elas estão em magnitudes diferentes.
+
Uma possível solução para isso é normalizar cada janela, dividindo pelo valor médio da janela. Assim, todas as janelas ficam na mesma escala:
+
+
+Code
+
_X = [x / x.mean() for x in _X]
+_X_test = [x / x.mean() for x in _X_test]
+
+fig, ax = plt.subplots()
+for x in _X:
+ ax.plot(x, color="gray", alpha=0.3)
+for x in _X_test:
+ ax.plot(x, color="red", alpha=0.3)
+
+ax.legend(handles=legend_handles, loc="best")
+ax.set_title("Série normalizada")
+fig.show()
+
+
+
+
+
+
+
+
+
+
e podemos prever sem problemas.
+
Outra possibilidade é a diferenciação, como já vimos em capítulos anteriores. A diferenciação remove a tendência da série, tornando-a estacionária.
+
+
+
7.2 Usando modelos de ML com sktime
+
Primeiro, vamos import ReductionForecaster, que é a classe que implementa a abordagem de janelas deslizantes para usar modelos de ML em séries temporais. Vamos testar um primeiro caso sem nenhum tipo de preprocessamento, apenas criando as janelas:
y_pred_diff = model.predict(fh=y_test.index, X=X_test)
+
+plot_series(
+ y_train, y_test, y_pred_diff, labels=["Treino", "Teste", "Previsão com ML + Diferença"]
+)
+plt.show()
+
+
+
+
+
+
+
+
+
Aqui, já vemos uma melhora significativa. Mas tem algo que podemos melhorar para realizar a diferenciação? Sim. Lembre que essa série tem um padrão multiplicativo. Então, antes de aplicar a diferenciação, podemos aplicar uma transformação logarítmica para estabilizar a variância:
+
+
from sktime.transformations.series.boxcox import LogTransformer
+
+model_log = LogTransformer() * model
+
+model_log.fit(y_train, X=X_train)
+y_pred_log_diff = model_log.predict(fh=y_test.index, X=X_test)
+plot_series(
+ y_train,
+ y_test,
+ y_pred_log_diff,
+ labels=["Treino", "Teste", "Previsão com ML + Log + Diferença"],
+)
+
+
+
+
+
+
+
+
+
+
+
7.2.2 Solução 2: Normalização por janela
+
A diferenciação aumenta o ruído da série, o que pode dificultar o trabalho do modelo de ML. Outra opção é normalizar em cada janela. A classe ReductionForecaster tem um parâmetro chamado normalization_strategy, que pode ser usado para determinar a estratégia de normalização. Vamos usar a estratégia divide_mean, que divide cada janela pelo seu valor médio.
Podemos fazer um conjunto de modelos, um para cada passo à frente. Abaixo, definimos steps_ahead=12, o que significa que o modelo vai prever 12 passos à frente diretamente.
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part2/ml_models_files/figure-html/cell-10-output-1.png b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-10-output-1.png
new file mode 100644
index 0000000..5d88936
Binary files /dev/null and b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-10-output-1.png differ
diff --git a/book/latest/content/pt/part2/ml_models_files/figure-html/cell-11-output-1.png b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-11-output-1.png
new file mode 100644
index 0000000..99512cf
Binary files /dev/null and b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-11-output-1.png differ
diff --git a/book/latest/content/pt/part2/ml_models_files/figure-html/cell-13-output-1.png b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-13-output-1.png
new file mode 100644
index 0000000..f3d43ad
Binary files /dev/null and b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-13-output-1.png differ
diff --git a/book/latest/content/pt/part2/ml_models_files/figure-html/cell-4-output-1.png b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-4-output-1.png
new file mode 100644
index 0000000..3e5a4ef
Binary files /dev/null and b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-4-output-1.png differ
diff --git a/book/latest/content/pt/part2/ml_models_files/figure-html/cell-5-output-1.png b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-5-output-1.png
new file mode 100644
index 0000000..ef048ea
Binary files /dev/null and b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-5-output-1.png differ
diff --git a/book/latest/content/pt/part2/ml_models_files/figure-html/cell-7-output-1.png b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-7-output-1.png
new file mode 100644
index 0000000..c1ccada
Binary files /dev/null and b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-7-output-1.png differ
diff --git a/book/latest/content/pt/part2/ml_models_files/figure-html/cell-9-output-1.png b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-9-output-1.png
new file mode 100644
index 0000000..4ab8615
Binary files /dev/null and b/book/latest/content/pt/part2/ml_models_files/figure-html/cell-9-output-1.png differ
diff --git a/book/latest/content/pt/part2/panel_data.html b/book/latest/content/pt/part2/panel_data.html
new file mode 100644
index 0000000..3099e92
--- /dev/null
+++ b/book/latest/content/pt/part2/panel_data.html
@@ -0,0 +1,3569 @@
+
+
+
+
+
+
+
+
+
+8 Dados em painel (multi-series) – Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
8Dados em painel (multi-series)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Em muitas aplicações, não temos acesso a uma única série temporal, mas sim a um conjunto de séries temporais relacionadas. Isso é comum em cenários como vendas de produtos em diferentes lojas, consumo de energia em diferentes regiões, etc. Esses dados são chamados de dados em painel.
+
Uma ideia poderosa é aproveitar a similaridade entre as séries para melhorar as previsões. Chamamos de modelos globais os modelos capazes de aprender padrões comuns entre as séries, ao contrário dos modelos locais que aprendem apenas com uma única série.
+
A maioria dos modelos clássicos de séries temporais são locais. Modelos globais são, em geral, baseados em modelos tabulares de ML ou deep learning. Segundo competições de séries temporais, como a M5, em forecasts de painel os modelos globais são os que apresentam melhor desempenho (Makridakis, Spiliotis, and Assimakopoulos 2022).
+
+
8.1 Acessando os dados
+
Aqui, vamos usar o dataset sintético que vimos antes, mas agora teremos acesso às várias séries temporais que compõe o total.
+
Esse dataset é feito para simular um caso de varejo, onde temos vendas diárias de vários produtos:
+
+
+Code
+
import pandas as pd
+import matplotlib.pyplot as plt
+
+from sktime.utils.plotting import plot_series
Nem todos modelos suportam nativamente dados em painel. Por exemplo, exponential smoothing. Aqui, temos uma boa notícia: sem linhas extras necessárias. O sktime faz upcasting automático para dados em painel ao usar estimadores do sktime.
Internamente, o sktime cria um clone do estimador para cada série nos dados em painel. Em seguida, cada clone é treinado com a série correspondente. Isso é feito de forma transparente para usuário, mas sem exigir esforço.
+
O atributo forecasters_ armazena um DataFrame com os estimatores de cada série.
+
+
naive_forecaster.forecasters_.head()
+
+
+
+
+
+
+
+
+
forecasters
+
+
+
+
+
0
+
NaiveForecaster(window_length=1)
+
+
+
1
+
NaiveForecaster(window_length=1)
+
+
+
2
+
NaiveForecaster(window_length=1)
+
+
+
3
+
NaiveForecaster(window_length=1)
+
+
+
4
+
NaiveForecaster(window_length=1)
+
+
+
+
+
+
+
+
É dificil explicar o quanto isso é extremamente útil para código limpo e prototipagem rápida. Foi um dos motivos que me levaram a usar o sktime.
+
+
+
8.3 Métricas
+
Agora que temos várias séries, precisamos explicar como calcular métricas de avaliação. O sktime oferece duas opções para isso, como argumentos na criação da métrica:
+
+
multilevel="uniform_average_time" para calcular a média das séries temporais no painel.
+
multilevel="raw_values" para obter o erro por série.
+
+
+
from sktime.performance_metrics.forecasting import MeanSquaredScaledError
+
+metric = MeanSquaredScaledError(multilevel="uniform_average_time")
Na prática, as métricas que a sua aplicação exige podem ser diferentes. Por exemplo, as séries temporais podem ter diferentes importâncias, e você pode querer ponderar as métricas de acordo.
+
Para isso, é possível criar uma métrica customizada no sktime, mas não entraremos nesse mérito aqui.
+
+
+
8.4 Modelos globais de Machine Learning
+
Quando vimos como usar modelos de Machine Learning para forecasting, já mencionamos como é necessário traduzir o problema de séries temporais para um problema de regressão tradicional.
+
No caso de dados em painel, também podemos usar essa abordagem, mas agora aproveitando todas as séries temporais para treinar um único modelo global.
+
+
Abaixo, vamos comparar um LightGBM global com um local. Veremos o seguinte: o modelo local é melhor que o modelo global, se não processarmos os dados corretamente para o modelo global aproveitar as similaridades entre as séries!
Para forçar que um modelo global funcione como um modelo local, podemos usar ForecastByLevel, que cria um modelo separado para cada série temporal, mesmo quando o estimador suporta dados em painel.
Sabemos como preprocessar séries temporais univariadas para melhorar o desempenho dos modelos de ML. Aplicamos da mesma maneira que fizemos anteriormente o Differencer, com objetivo de remover tendências.
Note como já superamos o modelo global incial, e o modelo local. Isso é para destacar que é essencial realizar um bom preprocessamento e engenharia de features para que modelos de Machine Learning tenham bom desempenho em dados em painel.
+
+
8.5.1 Normalização por janela
+
Agora, vamos usar a normalização por janela, que é especialmente útil em dados em painel, onde as séries podem ter diferentes escalas.
Uma técnica muito adotada é fazer modelos globais por clusters de séries temporais similares.
+
Uma maneira de categorizar é usando ADI (Average Demand Interval) e CV² (squared Coefficient of Variation). O componente ADI é calculado como o percentual de períodos com demanda (y>0), e \(CV^2\) é o quadrado do coeficiente de variação das demandas positivas.
+
+
+
+
+
+
+
+
+
+
+
Categoria
+
ADI
+
CV²
+
Padrão típico
+
Exemplos
+
+
+
+
+
Suave (Smooth)
+
≤ 1,32
+
≤ 0,49
+
Demanda contínua e estável
+
Itens de consumo diário, alimentos
+
+
+
Errática (Erratic)
+
≤ 1,32
+
> 0,49
+
Demanda contínua, porém muito variável
+
Moda, eletrônicos
+
+
+
Intermitente (Intermittent)
+
> 1,32
+
≤ 0,49
+
Muitos períodos sem venda, mas valores estáveis quando ocorre
+
Peças de reposição, ferramentas
+
+
+
Irregular (Lumpy)
+
> 1,32
+
> 0,49
+
Muitos períodos com zero e valores muito variáveis quando há demanda
Although it did not perform better than the best global model in this synthetic example, in real-world scenarios this approach can be very effective, particularly when there are large samples for each category, allowing the model to learn specific patterns for each group of series.
+
In addition, this can be useful when there are computation constraints, as training multiple smaller models for each cluster can be more efficient than training a single large global model.
+
+
+
8.7 Resumo
+
Aqui, vimos como trabalhar com dados em painel (multi-series) usando o sktime. Vimos, especialmente, como criar modelos globais de Machine Learning que aproveitam as similaridades entre as séries para melhorar o desempenho das previsões. Também destacamos a importância do preprocessamento e da engenharia de features para obter bons resultados com esses modelos.
+
Para uma análise mais aprofundada, recomendo o artigo de (Montero-Manso and Hyndman 2021), que discute princípios para forecasting em dados em painel usando modelos globais de Machine Learning.
+
+
+
+
+Makridakis, Spyros, Evangelos Spiliotis, and Vassilios Assimakopoulos. 2022. “M5 Accuracy Competition: Results, Findings, and Conclusions.”International Journal of Forecasting 38 (4): 1346–64.
+
+
+Montero-Manso, Pablo, and Rob J Hyndman. 2021. “Principles and Algorithms for Forecasting Groups of Time Series: Locality and Globality.”International Journal of Forecasting 37 (4): 1632–53.
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/book/latest/content/pt/part2/panel_data_files/figure-html/cell-19-output-1.png b/book/latest/content/pt/part2/panel_data_files/figure-html/cell-19-output-1.png
new file mode 100644
index 0000000..ee6ed22
Binary files /dev/null and b/book/latest/content/pt/part2/panel_data_files/figure-html/cell-19-output-1.png differ
diff --git a/book/latest/content/pt/part2/panel_data_files/figure-html/cell-30-output-1.png b/book/latest/content/pt/part2/panel_data_files/figure-html/cell-30-output-1.png
new file mode 100644
index 0000000..1e28f31
Binary files /dev/null and b/book/latest/content/pt/part2/panel_data_files/figure-html/cell-30-output-1.png differ
diff --git a/book/latest/content/pt/part2/panel_data_files/figure-html/cell-6-output-1.png b/book/latest/content/pt/part2/panel_data_files/figure-html/cell-6-output-1.png
new file mode 100644
index 0000000..9fc9874
Binary files /dev/null and b/book/latest/content/pt/part2/panel_data_files/figure-html/cell-6-output-1.png differ
diff --git a/book/latest/index.html b/book/latest/index.html
new file mode 100644
index 0000000..23e92d6
--- /dev/null
+++ b/book/latest/index.html
@@ -0,0 +1,713 @@
+
+
+
+
+
+
+
+
+
+
+
+Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Previsão de Séries temporais com Python: um pequeno guia
+
+
+
+
+
+
+
+
Author
+
+
Felipe Angelim
+
+
+
+
+
Published
+
+
October 11, 2025
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Prefácio
+
Esse é um pequeno livro feito para o workshop de sktime na Python Brasil 2025. O objetivo é apresentar os conceitos básicos de séries temporais e como usar o sktime para modelagem e previsão.
+
Esse livro é raso em diversos aspectos, mas pode ser útil como ponto de partida para quem quer aprender mais sobre séries temporais em Python.
