Curso Visualização de dados de interesse para a vigilância em saúde

Módulo 4 - Transformações e suavizações

Ao analisar séries temporais, nem sempre os padrões que queremos investigar ficam claros à primeira vista. Isso ocorre, muitas vezes, porque a série contém ruído – flutuações aleatórias que podem dificultar a identificação de tendências ou padrões sazonais. Um exemplo comum é quando os dados diários possuem muita variação, tornando difícil distinguir uma verdadeira mudança de tendência de uma simples variação aleatória.

Um exemplo frequente disso foi durante a pandemia de covid-19, quando a imprensa e as agências de saúde utilizaram a técnica da média móvel para suavizar os valores diários de casos confirmados e mortes. Essa suavização ajudou a acompanhar a evolução da pandemia de forma mais clara, destacando a tendência geral dos casos e permitindo uma visualização mais estável dos dados.

Média móvel de casos da covid-19 durante a pandemia. Fonte: https://g1.globo.com/jornal-nacional/noticia/2021/12/06/media-diaria-de-mortes-por-covid-no-brasil-fica-abaixo-de-200-pelo-terceiro-dia-seguido.ghtml

No gráfico acima, os dados diários (em cinza) mostram muitas flutuações, o que dificulta perceber imediatamente uma tendência clara. Quando olhamos apenas para um dia específico, como um valor baixo, não podemos saber se isso indica realmente uma queda nos casos ou apenas uma flutuação aleatória. Ao utilizar a média móvel (linha vermelha), conseguimos visualizar essas variações e obter uma visão mais clara da tendência geral, facilitando a interpretação dos dados.

Nas próximas seções, vamos explorar técnicas de transformações e suavizações que podem ser aplicadas para lidar com ruídos e variações indesejadas, permitindo uma análise mais precisa e confiável das séries temporais.

Funções

A aplicação de certas funções, como a função logarítmica e a transformação de Box-Cox são úteis para estabilização da variância dos dados. Por exemplo, se os casos de uma doença crescem exponencialmente, a transformação logarítmica pode “linearizar” esse crescimento, facilitando a análise. Poderemos usar isso nas técnicas de modelagem de séries temporais, mas veremos só mais à frente. Não se preocupe.

Na Figura 22A vemos uma série cuja variância não é constante, ou seja, a amplitude dos valores ao redor da tendência (média) varia ao longo do tempo. Já na Figura 22B vemos a série após a aplicação da transformação logarítmica.

Figura 22: Exemplo de transformações de séries temporais.

$Figura 22: Exemplo de transformações de séries temporais.$

Atenção

Observação: Por padrão, quando utilizamos a função log() no software R e, por consequência, aplicamos a transformação logarítmica, estamos nos referindo ao log na base natural ( $e$ ). Em outras notações pode ser conhecido como “log natural”, ou $ln$ .

Box-Cox

Box e Cox (1964) propuseram uma transformação mais versátil, chamada transformação de Box-Cox. Essa depende de um parâmetro lambda ( $\lambda$ ), que define como será a transformação. Caso $\lambda$ seja zero, a transformação logarítmica que já conhecemos é aplicada. Caso contrário, aplica-se a transformação exponencial da série à potência $\lambda$ , ou seja:

Z_{t} (λ) = {\begin{array}{rc} Z_{t}^{λ}, & se λ \neq 0, \\ l n (Z_{t}), & se λ = 0. \end{array}

$Z_{t}(\lambda) = \left\{ \begin{array}{rc} Z_t^{\lambda}, &\mbox{se} \quad \lambda \neq 0, \\ ln(Z_t) , &\mbox{se} \quad \lambda = 0. \end{array}\right.$

A transformação de Box-Cox também é útil para estabilização da variância e pode funcionar melhor em mais situações, além de aproximar a distribuição dos dados à distribuição normal para melhorar o ajuste de modelos de séries temporais, como o modelo ARIMA.

Podemos testar, portanto, vários valores de $lambda$ . Acompanhe na Figura 23 um exemplo de uso de vários $lambda$ diferentes:

Figura 23: Exemplo de uso de $lambda$ para transformar séries temporais.

É possível trabalhar com um valor de $\lambda$ escolhido automaticamente, que nesse caso foi o de $\lambda =$ -0.4. O método automático foi proposto por Guerrero (1993) e busca a escolha de um valor de $\lambda$ que minimiza o coeficiente de variação para a série.

Diferenciação

Uma vez que verificamos que a série é não estacionária (ou seja, possui tendência), podemos trabalhar para remover essa tendência da visualização. Novamente, essa operação pode ser necessária para aplicação de modelos que pressupõem estacionariedade da série, como veremos mais a frente. Uma das formas de atingir esse objetivo é por meio da diferenciação.

O processo de diferenciação de primeira ordem é simples e se dá, para cada valor da série, pela subtração do valor anterior. Ou seja, em uma série $Z_t$ , o valor em cada momento da série se dá por:

Z_{t}^{'} = Z_{t} - Z_{t - 1}

$Z'_t = Z_t - Z_{t-1}$

Onde:

$Z'_t$ representa os valores da série já diferenciada.

Vamos aplicar a diferenciação sobre a mesma série usada anteriormente.

Figura 24: Exemplo de uso de diferenciação em séries temporais.

Vemos que agora a tendência foi removida, e temos uma série centrada no valor zero. Podemos combinar as duas transformações vistas para obter uma série estacionária e com variância estabilizada:

Figura 25: Exemplo de série temporal após remoção da tendência e estabilização da variância.

Médias móveis

Assim como vimos no exemplo da covid-19, a média móvel é uma técnica para suavizar a série temporal, destacando sua tendência e tirando a influência do ruído aleatório. A técnica, como o nome diz, consiste em uma média aritmética das observações. Neste caso, são várias médias: para cada ponto na série, calcula-se a média dele mesmo com as $h$ observações mais próximas. Esse valor de $h$ define a ordem da média móvel. Por exemplo, uma média móvel de ordem 3 se refere a média do próprio ponto e seus dois pontos próximos, podendo ser à esquerda, à direita ou em ambas direções.

Figura 26: Média móvel de ordem h=5, alinhada à esquerda, à direita e centrada.

Dessa forma, temos que:

M_{t} = \frac{Z_{t} + Z_{t - 1} + \dots + Z_{t - (h - 1)}}{h}

$M_t = \frac{Z_t + Z_{t-1} + \ldots + Z_{t-(h-1)}}{h}$

Para representar uma média móvel à direita (onde olhamos para os $h-1$ valores passados, como era o exemplo da covid-19), vamos aplicar uma média móvel centrada com $h=5$ e $h=12$ para a série semanal de dengue no Maranhão nos anos de 2023 e 2024 (Figura 27).

Figura 27: Casos prováveis de dengue, São Luís-MA, 2023 e 2024.

Ao analisarmos a Figura 27 podemos perceber que, à medida que aumentamos o valor de $h$ , a série temporal se torna mais suavizada. No entanto, também observamos que as séries suavizadas acabam perdendo parte de sua extensão. Mas por que isso acontece?

A razão para essa perda está na forma como a média móvel é calculada. Para cada ponto da série, a média é calculada com base em $h$ valores próximos. Por exemplo, se $h$ = 5, podemos usar os 2 valores anteriores e os 2 valores seguintes, ou algum outro arranjo próximo, dependendo da posição. Porém, em alguns pontos da série, especialmente no início e no final, não existem vizinhos suficientes para calcular a média. Isso resulta em uma perda de valores nas extremidades da série.

Veja, por exemplo, o que acontece ao calcular a média móvel de ordem 5:

Figura 28: Série original (primeiros valores).

Figura 29: Série suavizada com média móvel de ordem 5 (primeiros valores).

Nesse caso, podemos ver que os primeiros valores da série original não podem ser suavizados, pois não há vizinhos suficientes para calcular a média. Isso também ocorrerá com os últimos valores da série.

Kernel

Outra possível técnica de suavização de uma série temporal é a suavização por Kernel. Essa técnica está inclusa em métodos mais avançados que ajustam curvas suaves aos dados, levando em conta as vizinhanças locais. Essas técnicas são mais flexíveis e são particularmente úteis quando a série tem padrões complexos.

Um Kernel é uma função ponderada que é aplicada sobre cada ponto de uma série temporal e seus vizinhos. Essa função atribui mais peso ao ponto de interesse e menores pesos aos pontos mais distantes, suavizando a série. O formato da função de suavização (Kernel) e o tamanho da janela utilizada, chamado de largura de banda, determinam o tipo e a intensidade da suavização. Diferentes tipos de Kernel podem ser usados, como o Gaussiano, Retangular, Triangular, Cosseno, ou Epanechnikov, cada um proporcionando uma forma diferente de suavização.

A escolha da função Kernel e da largura de banda tem impacto direto na forma como a suavização ocorre. Repare na Figura 30 como o comportamento de suavização pode variar conforme a função escolhida:

Figura 30: Casos prováveis de dengue, São Luís-MA, 2023 e 2024.

O parâmetro de largura de banda (Bandwidth - BW) é o que define a quantidade de suavização aplicada ao kernel. Vamos visualizar, na Figura 31, a aplicação de variações desse parâmetro à série de casos prováveis de dengue no Maranhão:

Figura 31: Variações da largura de banda: Casos prováveis de dengue, São Luís-MA, 2023 e 2024.

Percebe-se que uma largura de banda maior implica numa maior suavização. A curva verde, com BW = 20, se aproxima das variações de médio termo da série, enquanto as suavizações de BW = 50 ou BW = 100 reproduzem uma tendência de mais longo termo.

Loess

Loess (Locally Estimated Scatterplot Smoothing) e Lowess (Locally Weighted Scatterplot Smoothing) são métodos de suavização semelhantes ao Kernel, mas, em vez de usar médias ponderadas, esses métodos fazem regressões locais para estimar os valores suavizados.

No caso do Loess, para cada ponto da série, um polinômio é ajustado a um subconjunto de dados utilizando o método dos mínimos quadrados, resultando em uma curva suave. Já no Lowess, uma reta é ajustada, mas utilizando mínimos quadrados ponderados, dando mais peso aos pontos mais próximos e menos peso aos mais distantes.

O subconjunto de dados usado em cada estimativa é chamado de janela ou largura de banda (também conhecido como parâmetro de suavização). Esse parâmetro controla a flexibilidade da função de regressão. Se a janela for muito ampla (muitos dados considerados se igualando ao total de pontos, por exemplo), o alisamento será maior; se a janela for menor, a suavização será mais limitada. Quanto maior a janela, maior o alisamento da série.

A largura da janela é expressa como uma fração dos dados, variando de 0 a 1. Por exemplo, uma janela de 0,1 indica que 10% dos dados no eixo horizontal estão sendo usados para estimar o valor suavizado em cada ponto.

Outro aspecto importante é o grau do polinômio utilizado nas regressões locais:

Polinômio de grau 0: é equivalente a uma média móvel simples.
Polinômio de grau 1: resulta em uma regressão linear local.
Polinômio de grau 2: resulta em uma regressão quadrática local.

Se a janela incluir 100% dos pontos, o resultado será equivalente a calcular a média simples de toda a série.

Vantagens:

Simples e eficaz: Loess e Lowess são ótimos para análise exploratória, fornecendo uma curva suave e flexível.
Menos sensível às bordas: Essas técnicas lidam bem com pontos próximos às extremidades da série, onde pode ser mais impreciso.

Desvantagens: - Sensibilidade a valores extremos: O método pode ser influenciado por outliers, o que pode distorcer a suavização.

Splines

Os Splines são um conjunto de funções polinomiais que têm diversos usos na análise de dados. No nosso caso, os splines são utilizados como uma técnica de suavização, permitindo que diferentes segmentos da série temporal sejam ajustados de forma suave e contínua. Eles são particularmente úteis porque permitem unir diferentes pontos, chamados de nós, de forma suave, mantendo propriedades matemáticas ideais.

A mais usada para suavização é a spline cúbica natural. Trata-se de uma forma de regressão penalizada, em que os nós estão posicionados em diferentes valores de $x_i$ . A suavização entre esses nós ocorre por meio de funções polinomiais cúbicas, que garantem uma transição suave entre os segmentos da série.

A escolha do parâmetro de suavização (ou seja, quão “suave” a curva deve ser) pode ser feita de maneira visual, observando o gráfico, ou de forma mais formal, utilizando métodos que minimizam o erro quadrático médio ou através de técnicas de validação cruzada.

Na regressão penalizada, o objetivo é encontrar a função $\hat{f}(x)$ que minimize o seguinte:

\sum {[y_{i} - f (x_{i})]}^{2} + τ \int f^{″} (x)]^{2} d x

$\sum\left[y_i - f(x_i) \right]^2 + \tau \int f''(x)]^2 dx$

Sendo $\tau$ o parâmetro de alisamento:

Se $\tau = 0 \Rightarrow \hat{f}(x)$ é interpolação pontual (conecta os pontos);
Se $\tau = 1 \Rightarrow \hat{f}(x)$ é interpolação linear simples;
Se $\tau$ é muito grande $\Rightarrow \hat{f}(x)$ será tal que $f''(x)$ seja zero em todos os pontos, ou seja, mínimos quadrados.

Splines vs Loess/Lowess

No spline se minimiza uma função-objetivo explícita, é mais elegante matematicamente que loess/lowess.
O ajuste dos dois é muito semelhante para o mesmo número de graus de liberdade.
Pode-se ajustar essas funções para diversos preditores.
Existe uma forma mais complexa de spline mais complexo para splines (thin plate splines) que pode ser usada em modelos GAM.

Prática em `R`: Transformações e suavizações

Vamos continuar com nossa série de SRAG no Paraná:

# Visualizando a série temporal

plot(srag_pr_ts, ylab = "Casos de SRAG", xlab = "Tempo")

O comando plot(srag_pr_ts, ylab = "Casos de SRAG") gera um gráfico de linha da série temporal srag_pr_ts, com o eixo Y rotulado como “Casos de SRAG”.

Vamos aplicar as transformações vistas à série: transformação logarítmica, Box-Cox e diferenciação.

Para a transformação logarítmica podemos usar a própria função log() do R:

srag_pr_log<- log(srag_pr_ts)

plot(srag_pr_log, ylab = "Log(Casos)", xlab = "Tempo", 



main = "Casos de SRAG no PR\nTransformação: Log")

Este código aplica uma transformação logarítmica aos dados da série temporal srag_pr_ts e exibe o gráfico da série transformada.

srag_pr_log <- log(srag_pr_ts): Cria uma nova série, srag_pr_log, contendo os logaritmos dos valores de srag_pr_ts, suavizando variações extremas e tornando os dados mais adequados para análises de tendência e sazonalidade.
plot(srag_pr_log, ylab = "Log(Casos)", main = "Casos de SRAG no PR\nTransformação: Log"): Plota a série transformada com o rótulo do eixo Y como “Log(Casos)” e o título “Casos de SRAG no PR Transformação: Log”. O “ $\backslash$ n” é utilizado para quebrar a linha do título.

Vemos como a diferença entre os picos mais altos e dos mais baixos já não é mais tão grande, ou seja, há uma redução na amplitude de variação nos dados. Agora, vamos verificar como a série fica após a transformação de Box-Cox, e para isso usaremos o pacote forecast.

Atenção

De agora em diante, usaremos de forma intensiva o pacote forecast, que contém um conjunto de funções e utilidades na tarefa de análise de séries temporais. Caso ele não esteja instalado em seu ambiente R, basta executar o código abaixo. Acompanhe:

install.packages("forecast")

# Carregando o pacote

library(forecast)



# Aplicando a transformação de Box-Cox

srag_pr_bc1 <- BoxCox(srag_pr_ts, lambda = 0.1)



# Visualizando a série transformada

plot(srag_pr_bc1,

     ylab = "Casos (transformado)",

     main = "Casos de SRAG no PR\nTransformação: BoxCox, lambda = 0.1")

Este código aplica uma transformação de Box-Cox na série temporal srag_pr_ts para estabilizar a variância e facilitar a modelagem.

library(forecast): Carrega o pacote forecast, que contém a função BoxCox.
BoxCox(srag_pr_ts, lambda = 0.1): Aplica a transformação de Box-Cox com parâmetro lambda = 0.1 na série srag_pr_ts, criando uma versão transformada, srag_pr_bc1.
plot(): Exibe a série transformada com rótulo “Casos (transformado)” e título indicando a transformação.

Conforme vimos anteriormente, a transformação de Box-Cox requer o parâmetro lambda, que determina a forma da transformação. No exemplo acima usamos lambda = 0.1. Podemos testar diferentes valores do parâmetro e comparar os resultados. Podemos testar também, conforme visto anteriormente, o lambda automático, através do comando BoxCox.lambda():

# Aplicando a transformação de Box-Cox

lambda_auto <- BoxCox.lambda(srag_pr_ts)



srag_pr_bc2 <- BoxCox(srag_pr_ts, lambda = lambda_auto)



# Visualizando a série transformada

plot(srag_pr_bc2,

     ylab = "Casos (transformado)",

     main = paste0(

       "Casos de SRAG no PR\nTransformação: BoxCox, lambda = ",

       round(lambda_auto, 2)

     )

)

Esse código aplica a transformação de Box-Cox na série temporal srag_pr_ts para estabilizar a variância:

lambda_auto <- BoxCox.lambda(srag_pr_ts): Calcula o parâmetro lambda ideal para a transformação de Box-Cox, armazenando-o em lambda_auto.
srag_pr_bc2 <- BoxCox(srag_pr_ts, lambda = lambda_auto): Aplica a transformação de Box-Cox usando o lambda calculado para criar srag_pr_bc2, a série transformada.
plot(): Plota a série transformada com um título que exibe o valor de lambda arredondado.

Vemos que a diferença de amplitude entre as curvas diminui, aproximando-as. Como visto anteriormente, tais técnicas de transformação podem ser úteis nas etapas de modelagem da série temporal.

Podemos aplicar a última transformação vista: a diferenciação. Vimos que a diferenciação é útil para remoção da tendência da série, contudo já percebemos durante a última prática que a série não possui tendência relevante. Assim, esperamos uma série parecida ao diferenciá-la. Vamos testar por meio do comando diff():

par(mfrow = c(2,1))



# Diferenciação da série original

srag_pr_diff <- diff(srag_pr_ts)





plot(

  srag_pr_diff,

  ylab = "Diferença de casos",

  main = "a. Casos de SRAG no PR\nTransformação: Diferenciação"

  )



# Diferenciação da série já transformada

srag_pr_bc_diff <- diff(srag_pr_bc2)



plot(

  srag_pr_bc_diff,

  ylab = "Diferença de casos (transformado)",

  main = "b. Casos de SRAG no PR\nTransformação: Box-Cox e Diferenciação"

  )

Esse código cria um painel com dois gráficos para comparar transformações de diferenciação na série temporal de casos de SRAG:

par(mfrow = c(2,1)): Define a disposição dos gráficos em duas linhas e uma coluna, permitindo a visualização dos dois gráficos um sobre o outro.
srag_pr_diff <- diff(srag_pr_ts): Calcula a primeira diferenciação da série srag_pr_ts, capturando mudanças entre períodos consecutivos.
plot(): Plota a série diferenciada, mostrando as diferenças nos casos de SRAG e destacando variações temporais.
srag_pr_bc_diff <- diff(srag_pr_bc2): Calcula a primeira diferenciação da série transformada por Box-Cox srag_pr_bc2, uma técnica que ajusta a distribuição antes da diferenciação.
plot(): Plota a série diferenciada transformada, mostrando as diferenças após ambas as transformações.

Vemos que a diferenciação traz a média dos casos para zero e de uma forma constante, sem qualquer tendência (a). Contudo, somente esta transformação mantém a diferença na amplitude entre as curvas. Buscando estabilizar isso, transformamos também a série transformada por meio do método Box-Cox (b).

Suavizações

Podemos comparar também, diferentes estratégias vistas para obter uma suavização da série.

Médias móveis

Podemos obter a série suavizada por médias móveis por meio da função ma(), também do pacote forecast.

plot(

  srag_pr_ts,

  ylab = "",

  main = "Média Móvel Centrada"

  )

lines(ma(srag_pr_ts, order = 10), col = 2, lty = 1, lwd = 2)

lines(ma(srag_pr_ts, order = 4), col = 4, lty = 2, lwd = 2)

legend("topright",

       legend = c("Casos mensais", "Média Móvel 4", "Média Móvel 10"),

       col = c("black", "blue", "red"),

       lty = c(1, 2, 1),

       cex = 1)

Esse código gera um gráfico da série temporal srag_pr_ts com médias móveis centradas para suavizar e destacar tendências de curto e longo prazo.

plot(srag_pr_ts, ylab = "", main = "Média Móvel Centrada"): Plota a série temporal srag_pr_ts com o título “Média Móvel Centrada”.
lines(ma(srag_pr_ts, order = 10), col = 2, lty = 1, lwd = 2): Adiciona uma linha de média móvel de ordem 10 (longa) em vermelho (col = 2), linha contínua (lty = 1) e espessura 2 (lwd = 2).
lines(ma(srag_pr_ts, order = 4), col = 4, lty = 2, lwd = 2): Adiciona uma linha de média móvel de ordem 4 (curta) em azul (col = 4), linha tracejada (lty = 2) e espessura 2.
legend(): Adiciona uma legenda no canto superior direito que identifica a série original, a média móvel de ordem 4 e a de ordem 10.

Vemos que a média móvel de ordem $h=4$ captura bem as variações importantes e suaviza a série de forma satisfatória, enquanto a média de ordem $h=10$ realiza uma suavização mais intensa, de forma a perder algumas flutuações relevantes na série. Note que o período que perdemos ao aumentar o valor de $h$ é maior, de forma que a série em vermelho se inicia em meados de 2013 e vai até meados de 2017.

Também vimos que podemos alinhar as médias móveis à esquerda ou à direita, conforme o que for mais adequado. No R, podemos trocar esse alinhamento com a função rollmean(), do pacote zoo. Ela também é uma função para médias móveis, porém com mais parâmetros:

library(zoo)

plot(srag_pr_ts, ylab = "", main = "Média Móvel Alinhada")

lines(rollmean(srag_pr_ts, k = 4, align = 'left'), col = "orange", lwd = 2)

lines(rollmean(srag_pr_ts, k = 4, align = 'right'), col = "purple", lwd = 2)

legend("topright", legend = c("Casos mensais", "Alinhada à esquerda", "Alinhada à direita"),

       col = c("black", "orange", "purple"), lty = c(1, 1, 1), cex = 1)

Esse código utiliza o pacote zoo para plotar a série temporal srag_pr_ts com médias móveis alinhadas à esquerda e à direita, destacando variações suavizadas na série.

plot(srag_pr_ts, ylab = "", main = "Média Móvel Alinhada"): Plota a série temporal com o título “Média Móvel Alinhada”.
lines(rollmean(srag_pr_ts, k = 4, align = 'left'), col = "orange", lwd = 2): Adiciona uma linha de média móvel de 4 períodos alinhada à esquerda, em laranja e espessura de 2.
lines(rollmean(srag_pr_ts, k = 4, align = 'right'), col = "purple", lwd = 2): Adiciona uma linha de média móvel de 4 períodos alinhada à direita, em roxo e espessura de 2.
legend(): Adiciona uma legenda no canto superior direito para identificar as linhas.

Kernel

Vimos que outra possibilidade para obter uma suavização da série é a utilização de uma função de kernel. Há inúmeras possibilidades de realizar essa operação em R, sendo a mais simples por meio da utilização da função ksmooth(). Nela, passamos os valores de x e y da relação que queremos suavizar. Como estamos tratando de uma série temporal, nosso valor de x representa o momento da série temporal (podemos obtê-lo com a função time()), e y é o próprio valor da série. Dessa forma, podemos implementar uma suavização por kernel, variando os valores da largura de banda, que determina a quantidade de suavização:

kernel1 <- ksmooth(time(srag_pr_ts), srag_pr_ts, kernel = "normal", bandwidth = 0.3)

kernel2 <- ksmooth(time(srag_pr_ts), srag_pr_ts, kernel = "normal", bandwidth = 0.5)

kernel3 <- ksmooth(time(srag_pr_ts), srag_pr_ts, kernel = "normal", bandwidth = 1)



plot(

  x = srag_pr_ts,

  ylab="",

  main="Suavização por Kernel"

  )

lines(kernel1$x, kernel1$y, col = 3)

lines(kernel2$x, kernel2$y, col = 2)

lines(kernel3$x, kernel3$y, col = 4)



legend("topright",c("0,3 meses","0,5 meses","1 mês"),fill=c(3,2,4), title="Janela",bty="n")

Esse código aplica a suavização por kernel à série temporal srag_pr_ts com diferentes larguras de banda para analisar tendências:

ksmooth(): Suaviza a série temporal usando o kernel “normal” com três larguras de banda distintas (0.3, 0.5 e 1). Larguras de banda menores captam mais detalhes, enquanto maiores produzem uma suavização mais geral.
plot(): Plota a série original.
lines(): Adiciona as linhas suavizadas de kernel1, kernel2 e kernel3 com cores diferentes.
legend(): Adiciona uma legenda no canto superior direito, indicando as diferentes larguras de banda e suas respectivas cores.

Vemos que, conforme aumentamos a largura de banda, a suavização aplicada é maior. O kernel com largura de 1 mês, por exemplo, captura apenas as variações mais longas da série.

Lowess

A suavização por meio do método lowess se dá de forma parecida em R, com a função lowess(). Neste caso, apenas temos que escrever nossos parâmetros na forma de uma fórmula, ou seja: y ~ x. Veja abaixo:

lowess1 <- lowess(srag_pr_ts ~ time(srag_pr_ts), f = 0.1)

lowess2 <- lowess(srag_pr_ts ~ time(srag_pr_ts), f = 0.4)





plot(srag_pr_ts, ylab = "", main = "Suavização por Lowess")

lines(lowess1$x, lowess1$y, col = 4)

lines(lowess2$x, lowess2$y, col = 2)

legend(

  "topright",

  c("f=0.1", "f=0.4"),

  col = c(4, 2),

  title = "",

  bty = "n",

  lty = c(1, 1)

)

Esse código aplica a suavização Lowess na série temporal srag_pr_ts usando duas intensidades de suavização diferentes (f = 0.1 e f = 0.4), e plota os resultados para comparação.

lowess1 e lowess2: Guardam as suavizações de srag_pr_ts com os parâmetros f = 0.1 (mais sensível às variações) e f = 0.4 (mais suave), onde f controla a fração dos dados usada em cada ponto de suavização.
plot(): Plota a série temporal original com o título “Suavização por Lowess”.
lines(lowess1$x, lowess1$y, col = 4) e lines(lowess2$x, lowess2$y, col = 2): Adicionam as linhas de suavização para lowess1 (em azul) e lowess2 (em vermelho).
legend(): Coloca uma legenda no canto superior direito (topright), indicando os valores de f usados para cada linha.

De forma similar ao aumentarmos o parâmetro f, que determina a janela de suavização, temos uma suavização mais expressiva. Ao utilizarmos um valor menor, como f = 0.1, vemos que alguns pontos ainda mantêm uma variação brusca.

Splines

A função utilizada para ajustar splines é a smooth.spline. Tentemos comparar alguns cenários com diferentes graus de liberdade (df):

spline1 <- smooth.spline(time(srag_pr_ts), srag_pr_ts, df = 10)

spline2 <- smooth.spline(time(srag_pr_ts), srag_pr_ts, df = 50)

spline3 <- smooth.spline(time(srag_pr_ts), srag_pr_ts, df = 5)



plot(srag_pr_ts, ylab = "", main = "Suavização por Spline")

lines(spline1$x, spline1$y, col = 3)

lines(spline2$x, spline2$y, col = 4)

lines(spline3$x, spline3$y, col = 2)

legend(

  "topright",

  c("df=10", "df=50", "df=2"),

  col = c(3, 4, 2),

  lty = c(1, 1, 1),

  title = "Janela",

  bty = "n"

)

Esse código aplica suavizações por splines com diferentes graus de liberdade (df) na série temporal srag_pr_ts, e plota as linhas suavizadas no gráfico para comparação.

spline1, spline2, spline3: Criam três suavizações por splines usando smooth.spline, com graus de liberdade de 10, 50 e 5, respectivamente, ajustando diferentes níveis de suavidade.
plot(srag_pr_ts, ylab = "", main = "Suavização por Spline"): Plota a série temporal original sem rótulo no eixo Y e com o título “Suavização por Spline”.
lines(): Adiciona ao gráfico as três curvas suavizadas (verde, azul e vermelha) usando os resultados de spline1, spline2 e spline3.
legend(): Adiciona uma legenda no canto superior direito, especificando os diferentes graus de liberdade (10, 50 e 5) e suas cores.

Vemos que as splines produzem curvas suaves e contínuas, que se ajustam aos padrões dos dados. Diferentemente das outras abordagens, vemos que ao aumentar os graus de liberdade (df), temos curvas menos suaves e mais ajustadas aos dados, enquanto poucos graus mostram uma tendência mais geral dos dados.

Pronto! Agora você já sabe tudo sobre os componentes de uma série temporal, como transformá-la para reduzir sua variação ou remover sua tendência, e estratégias de suavização para obter padrões mais claros. No próximo módulo, vamos aprender a modelar as séries temporais para ajudar a descrevê-la, testar associações e realizar previsões.

<
1
2
3
4
5
6
7
8
Conclusão
>

Funções

Box-Cox

Diferenciação

Médias móveis

Kernel

Loess

Splines

Prática em R: Transformações e suavizações

Suavizações

Médias móveis

Kernel

Lowess

Splines

Prática em `R`: Transformações e suavizações