WEBINAR - PRINCÍPIOS DE SÉRIES TEMPORAIS

Pacotes

Tire o “#” para instalar os pacotes abaixo.

#install.packages("forecast")
#install.packages("fpp2")
#install.packages("tseries")
#install.packages("patchwork")

library(forecast)
library(fpp2)
library(tseries)
library(patchwork)

Introdução

Criando uma série do zero

Crie um vetor numérico com c() e use ts() para mudar o formato para time-series.

serie <- c(5, 8, 12, 8)
serie <- ts(serie)
serie
autoplot(serie)

Definindo começo e frequência

start=quando a série começa

end=quando a série termina

frequency=número de unidades por período 

serie2 <- c(4, 8, 7, 9, 5, 12, 8, 6, 8, 10, 16, 22)
serie2 <- ts(serie2, start = 2020, frequency = 12)
serie2
autoplot(serie2)

Usando séries do R

Exemplos de séries do próprio R.

airmiles
AirPassengers
Seatbelts

Usando séries do R (pacote fpp2)

Pacote com uma grande coleção de séries temporais.

fpp2::a10
fpp2::ausbeer
fpp2::goog200

Decomposição

Uma série pode ser decomposta em três partes: tendência, sazonalidade e aleatoriedade. Em outras abordagens, também é considerado o componente do ciclo.

Modelo aditivo

SÉRIE = TENDÊNCIA + SAZONALIDADE + ALEATÓRIO

Deve ser escolhido quando a sazonalidade é constante ao longo do tempo.

autoplot(milk)
dec.add <- decompose(milk)
autoplot(dec.add)

Modelo multiplicativo

SÉRIE = TENDÊNCIA x SAZONALIDADE x ALEATÓRIO

Deve ser escolhido quando a sazonalidade aumenta ao longo do tempo.

autoplot(a10)
dec.mult <- decompose(a10, type = "multiplicative")
autoplot(dec.mult)

Conceitos

Autocorrelação

A autocorrelação é a correlação da série com ela mesma. Em séries temporais, será a correlação entre a série e uma lag sua.

a10
lag(a10, -1)
lag(a10, -2)
acf(a10)
pacf(a10)
ggtsdisplay(a10)

Estacionariedade

Uma série estacionária é uma série cujas características não mudam ao longo do tempo.

# Ruído branco
rb <- ts(rnorm(500))
autoplot(rb)

Normalidade

Uma distribuição normal tem forma de sino, com os dados distribuídos simetricamente ao redor da média.

# Histograma e qqplot da a10
hist(a10)
qqnorm(a10)
qqline(a10, col = "red")

Transformações

Diferenciação

Usada para tornar a série estacionária. Diferenciação é a mudança da série, a diferença entre o valor e um valor anterior.

a10.diff <- diff(a10, 1)
autoplot(a10.diff)
a10.diff2 <- diff(a10, 2)
autoplot(a10.diff2)
ndiffs(a10)

BoxCox

Se a diferenciação não for o bastante, pode ser usada a transformação de BoxCox.

lambda <- BoxCox.lambda(a10)
a10.bc <- BoxCox(a10, lambda = lambda)
hist(a10.bc)
autoplot(a10.bc)
ap1 <- autoplot(a10)
ap2 <- autoplot(a10.bc)
ap1 + ap2

serie.final <- diff(a10.bc, 1)
autoplot(serie.final)
adf.test(serie.final)

Modelagem e Forecast

Hora de prever o futuro com séries temporais!

Métodos simples

Método da média

Os valores previstos serão a média da série.

prev.media <- meanf(a10, h = 12)
autoplot(prev.media)

Método naive

Os valores previstos serão o mesmo que último valor registrado.

prev.naive <- naive(a10, h = 12)
autoplot(prev.naive)

Método naive sazonal

Os valores previstos serão o último valor registrado no mesmo período sazonal anterior.

prev.snaive <- snaive(a10, h = 12)
autoplot(prev.snaive)

Arima

Definições:

Modelos:

Passo a passo do Arima:

  1. Plotar a série e examiná-la;
  2. Diferenciar a série até ficar estacionária e fazer transformações, se necessário;
  3. Usar séries diferenciadas para definir p e q;
  4. Implementar o Arima nos dados originais;
  5. Checar se é um bom modelo;
  6. Usar o modelo para fazer previsões.

# 1
autoplot(a10)
dec <- decompose(a10)
autoplot(dec)

# 2 Uma diferenciação e transformação de BoxCox
autoplot(serie.final)

# 3
pacf(serie.final)  #p=1 e 1
acf(serie.final)  #q=1 e 1
# d=1 e 1

# 4

mod.arima <- Arima(a10, order = c(1, 1, 1), seasonal = c(1, 1, 1), lambda = lambda)
summary(mod.arima)

autoplot(a10) + autolayer(mod.arima$fitted)

# 5
checkresiduals(mod.arima)

# 6
prev.arima <- forecast(mod.arima, h = 12)
autoplot(prev.arima)

Passo a passo do Auto-Arima:

  1. Executar Auto-Arima para verificar os melhores parâmetros;
  2. Implementar o Arima nos dados originais;
  3. Checar se é um bom modelo;
  4. Usar o modelo para fazer previsões.
# 1
auto.arima(a10, lambda = lambda, trace = TRUE, approximation = FALSE)  #ARIMA(3,0,0)(2,1,1)

# 2
mod.aa <- Arima(a10, order = c(3, 0, 0), seasonal = c(2, 1, 1), lambda = lambda,
    include.drift = TRUE)
# 3
checkresiduals(mod.aa)
# 4
prev.aa <- forecast(mod.aa, h = 12)

Suavização exponencial

Método Aplicação Função Parâmetros
Suavização exponencial simples Sem tendência e sazonalidade ses() α
Holt Com tendência holt() α e ß
Holt-Winters Com tendência e sazonalidade hw() α, ß e γ

SES:

Holt:

Holt-Winters: 

mod.hw <- hw(a10, seasonal = "multiplicative")
checkresiduals(mod.hw)
prev.hw <- forecast(mod.hw, h = 12)
autoplot(prev.hw)

Seleção do modelo

Holdout

Split da série

Divisão da série em treino e teste.

serie.treino <- window(a10, end = c(2006, 6))
serie.teste <- window(a10, start = c(2006, 7))

Treinamento

Treinamento dos algoritmos.

h = 24

# Média
treino.media <- meanf(serie.treino, h = h)
# Naive
treino.naive <- naive(serie.treino, h = h)
# SNaive
treino.snaive <- snaive(serie.treino, h = h)
# Arima
treino.arima.mod <- Arima(serie.treino, order = c(1, 1, 1), seasonal = c(1, 1, 1),
    lambda = lambda)
treino.arima <- forecast(treino.arima.mod, h = h)

# Auto-Arima
treino.aa.mod <- Arima(serie.treino, order = c(3, 0, 0), seasonal = c(2, 1, 1), lambda = lambda,
    include.drift = TRUE)
treino.aa <- forecast(treino.aa.mod, h = h)

# HW
treino.hw <- hw(serie.treino, h = h, seasonal = "multiplicative")

Medidas de erro

Queremos o algoritmo que erre menos as previsões.

acc.media <- accuracy(treino.media$mean, serie.teste)
acc.naive <- accuracy(treino.naive$mean, serie.teste)
acc.snaive <- accuracy(treino.snaive$mean, serie.teste)
acc.hw <- accuracy(treino.hw$mean, serie.teste)
acc.arima <- accuracy(treino.arima$mean, serie.teste)
acc.aa <- accuracy(treino.aa$mean, serie.teste)

tbl.acc <- rbind(acc.media, acc.naive, acc.snaive, acc.hw, acc.arima, acc.aa)
rownames(tbl.acc) <- c("Média", "Naive", "SNaive", "HW", "Arima", "Auto-Arima")

Forecast com o melhor método

Encontrado o melhor método, agora nós devemos aplicá-lo na série original.

mod.final <- Arima(a10, order = c(3, 0, 0), seasonal = c(2, 1, 1), lambda = lambda,
    include.drift = TRUE)
prev.final <- forecast(mod.final, h = h)
autoplot(prev.final)

Salvando o modelo final

# Salvando no diretório atual
saveRDS(mod.final, file = "modeloa10")

# Carregando o modelo depois de salvo
modelo.carregado <- readRDS("modeloa10")