LISTA 3.1

3.1) O que é um modelo de decomposição?

Um modelo de decomposição é uma técnica de análise de séries temporais que separa a série em componentes distintos, como tendência, sazonalidade e ruído (ou erro). Esse processo facilita a compreensão da dinâmica de uma série temporal, ajudando na previsão e análise das características subjacentes.

3.2) Como a tendência se manifesta nos dados e quais são as possíveis formas de tendência que uma série temporal pode apresentar?

A tendência se manifesta como um padrão de aumento ou diminuição a longo prazo nos dados de uma série temporal. As possíveis formas de tendência incluem:

• Tendência linear: Uma mudança constante ao longo do tempo.
• Tendência não linear: Mudanças que seguem uma curva (ex.: exponencial).
• Tendência estagnada: Quando os dados não mostram aumento ou diminuição visível a longo prazo.

A tendência se manifesta como um padrão de aumento ou diminuição a longo prazo nos dados de uma série temporal. As possíveis formas de tendência incluem:

• Tendência linear: Uma mudança constante ao longo do tempo.
• Tendência não linear: Mudanças que seguem uma curva (ex.: exponencial).
• Tendência estagnada: Quando os dados não mostram aumento ou diminuição visível a longo prazo.

3.3) Considerando os métodos de remoção de tendência:

a) O método de regressão consiste em ajustar um modelo matemático (geralmente linear) aos dados para capturar a tendência subjacente. Após o ajuste, a tendência é removida subtraindo os valores ajustados da série original. Modelos lineares, polinomiais e exponenciais podem ser utilizados, dependendo da natureza da tendência.

b) O método de diferenciação envolve calcular a diferença entre valores consecutivos de uma série temporal para remover a tendência. A primeira diferença remove uma tendência linear simples, enquanto a segunda diferença é usada para remover tendências quadráticas ou de ordem superior.

c) As médias móveis suavizam uma série temporal calculando a média de um conjunto de valores ao longo do tempo. Esse método pode remover a tendência ao suavizar as flutuações de curto prazo, deixando apenas os componentes de longo prazo (tendência) isolados.

3.4) Como a sazonalidade se manifesta nos dados e quais são as possíveis formas de sazonalidade que uma série temporal pode apresentar?

A sazonalidade se manifesta como padrões repetitivos ou ciclos que ocorrem em intervalos regulares de tempo, como por mês, trimestre ou ano. As formas de sazonalidade incluem padrões anuais, mensais ou semanais, dependendo da periodicidade observada na série.

3.5) Considerando os métodos de modelagem de sazonalidade:

a) A decomposição de uma série temporal separa a série em componentes individuais, como tendência, sazonalidade e ruído. Ao subtrair a tendência e o ruído, é possível isolar a componente sazonal, permitindo uma análise mais clara dos padrões sazonais.

b) Modelo aditivo: A série temporal é expressa como a soma das componentes (tendência + sazonalidade + erro). Esse modelo é apropriado quando a amplitude da sazonalidade é constante ao longo do tempo. Modelo multiplicativo: A série é expressa como o produto das componentes (tendência × sazonalidade × erro). Esse modelo é adequado quando a amplitude da sazonalidade varia com o nível da série.

c) A suavização sazonal é uma técnica que ajusta a série para eliminar flutuações sazonais. Ela pode ser aplicada utilizando médias móveis sazonais ou outros métodos de suavização para remover a variação sazonal, permitindo a análise de tendências mais subjacentes.

3.6) O que é um periodograma e como ele pode auxiliar na análise da sazonalidade?

Um periodograma é uma representação gráfica da distribuição da potência ou variância de uma série temporal em função da frequência. Ele auxilia na identificação de padrões sazonais, mostrando quais frequências dominam o comportamento da série.

3.7) Quando uma série temporal apresenta tanto tendência quanto sazonalidade, é importante seguir uma ordem específica para análise e remoção desses componentes. Descreva os passos a serem seguidos para transformar uma série temporal em uma série estacionária. Explique por que essa ordem é importante para garantir uma análise e modelagem subsequente eficaz.

Os passos são:

1. Remover a tendência: Usar diferenciação ou regressão para estabilizar o nível médio da série.
2. Remover a sazonalidade: Aplicar médias móveis ou modelos de decomposição para isolar e remover os padrões sazonais.
3. Verificar a estacionariedade: Garantir que a série resultante tenha variância e média constantes ao longo do tempo.

Essa ordem é importante porque a presença de tendência e sazonalidade pode mascarar a verdadeira estrutura autocorrelacionada da série, impedindo uma modelagem precisa.

3.8) Explique a diferença entre a Função de Autocorrelação (ACF) e a Função de Autocorrelação Parcial (PACF). Por que é importante calcular essas funções apenas após a remoção da tendência e da sazonalidade de uma série temporal?

• Função de Autocorrelação (ACF): Mede a correlação da série temporal com seus próprios valores defasados ao longo do tempo. Em outras palavras, a ACF indica até que ponto os valores passados influenciam os valores presentes na série, sem remover o efeito dos intermediários.
• Função de Autocorrelação Parcial (PACF): Mede a correlação entre a série e os valores defasados, controlando o efeito das defasagens anteriores. Ou seja, a PACF mostra a correlação direta entre os valores após remover o efeito dos lags intermediários.
• Importância da Remoção de Tendência e Sazonalidade: A tendência e a sazonalidade introduzem padrões que podem mascarar a verdadeira estrutura autocorrelacional da série. A ACF e a PACF devem ser calculadas apenas depois de ajustar a série (removendo a tendência e a sazonalidade) para que reflitam a dependência temporal real, permitindo a escolha adequada de modelos como o ARIMA.

# Importações necessárias
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from scipy.signal import periodogram
from statsmodels.tsa.stattools import adfuller, acf, pacf
from statsmodels.stats.diagnostic import acorr_ljungbox, het_breuschpagan, het_white
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
import statsmodels.api as sm
from statsmodels.tsa.seasonal import seasonal_decompose
from scipy.signal import periodogram
import matplotlib.pyplot as plt
%matplotlib inline

Análise de Séries Temporais dos Preços do Petróleo (1986-2005)

Nesta análise, iremos examinar a série temporal dos preços do petróleo de janeiro de 1986 até dezembro de 2005. Nosso objetivo é remover a tendência e a sazonalidade da série e, posteriormente, calcular as funções de autocorrelação (ACF) e autocorrelação parcial (PACF).

Importação das Bibliotecas Necessárias

Primeiro, precisamos importar as bibliotecas necessárias para a análise.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from scipy.signal import periodogram
from statsmodels.tsa.stattools import adfuller, acf, pacf
from statsmodels.stats.diagnostic import acorr_ljungbox, het_breuschpagan, het_white
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
import statsmodels.api as sm
from statsmodels.tsa.seasonal import seasonal_decompose
%matplotlib inline

3.9) Análise da Série Temporal dos Preços do Petróleo (1986-2005)

Plote a série temporal original dos preços do petróleo e descreva visualmente se há presença de tendência, sazonalidade ou variação na estabilidade da variância (heterocedasticidade).

3.9 A)

Plote a série temporal original da produção de veículos comerciais leves e descreva visualmente se há presença de tendência, sazonalidade ou variação na estabilidade da variância (heterocedasticidade)

# Leitura dos dados do Excel
file_path = 'petroleo.xlsx'
dados_petroleo = pd.read_excel(file_path)


# Se os dados forem do tipo string, substituir vírgulas por pontos e converter para tipo numérico
if dados_petroleo['preco'].dtype == 'object':
    dados_petroleo['preco'] = dados_petroleo['preco'].str.replace(',', '.').astype(float)


# Convertendo a coluna 'tempo' para datetime
dados_petroleo['tempo'] = pd.to_datetime(dados_petroleo['tempo'], errors='coerce')


# Definindo a coluna 'tempo' como índice
dados_petroleo.set_index('tempo', inplace=True)

# Definindo a série temporal original de preços do petróleo (y1)
y1 = dados_petroleo['preco']

# Plotando a série temporal original
plt.figure(figsize=(10, 6))
plt.plot(dados_petroleo['preco'], label='Preços do Petróleo')
plt.xlabel('Tempo')
plt.ylabel('Preço em dólares')
plt.title('Série Temporal dos Preços do Petróleo')
plt.legend()
plt.show()

Análise da Série Temporal dos Preços do Petróleo (1986-2005)

Tendência

Observa-se uma clara tendência de alta nos preços do petróleo a partir da metade dos anos 1990, especialmente acentuada após o ano 2000. Antes disso, os preços parecem oscilar sem uma tendência clara, com um período de estabilização durante os anos 1990.

Sazonalidade

Não há um padrão sazonal evidente, no qual os preços sigam um ciclo regular de alta e baixa em intervalos de tempo previsíveis. A série parece ser mais influenciada por eventos específicos do mercado, como crises ou choques de oferta e demanda, que resultam em picos abruptos nos preços.

Heterocedasticidade

Há sinais de heterocedasticidade no gráfico. Nos anos mais recentes, a variância dos preços parece aumentar, com flutuações maiores na segunda metade do gráfico (2000-2005). A instabilidade dos preços aumenta conforme a série avança, com grandes picos e quedas que indicam uma maior volatilidade.

Esse comportamento sugere que os preços do petróleo são sensíveis a fatores externos e que a variabilidade dos preços se intensificou ao longo do tempo, o que pode ser indicativo de eventos globais ou mudanças estruturais no mercado de petróleo.

3.9 - C)

Aplique um teste de tendência adequado para verificar a presença de tendência nas séries. Em seguida, remova a tendência utilizando o método de sua escolha

# Teste de Tendência (Dickey-Fuller) na série original y1
adf_result = adfuller(y1)
print(f'Teste ADF para tendência: p-value = {adf_result[1]}')

# Se a tendência for detectada (p-value > 0.05), aplica-se a diferenciação
if adf_result[1] > 0.05:
    print("Tendência detectada, aplicando diferenciação.")
    y2 = np.diff(y1)  # Aplicando a diferenciação
    y2 = pd.Series(y2, index=y1.index[1:])  # Ajustando o índice da série diferenciada
else:
    y2 = y1

# Teste ADF após a diferenciação
adf_result_diff = adfuller(y2)
print(f'Teste ADF após a diferenciação: p-value = {adf_result_diff[1]}')

# Visualizar a série temporal 
plt.figure(figsize=(10, 6))
plt.plot(y2, label='Série Temporal Após Diferenciação', color='b')
plt.xlabel('Tempo')
plt.ylabel('Valor Diferenciado')
plt.title('Série Temporal dos Preços do Petróleo Após Diferenciação - Tendência')
plt.legend()
plt.show()

Teste ADF para tendência: p-value = 0.9954168801577372
Tendência detectada, aplicando diferenciação.
Teste ADF após a diferenciação: p-value = 0.007023286439870401

3.9 - D)

Verifique se há presença de sazonalidade na série. Se identificada, remova-a utilizando um método apropriado

# Inicializar y_final como None
y_final = None

# Agora começamos com y2, que já tem a tendência removida

# 1. Testar sazonalidade usando o periodograma
frequencies, Pxx = periodogram(y2)

# 2. Plotando o periodograma de y2
plt.figure(figsize=(10, 6))
plt.plot(frequencies, Pxx, label='Periodograma')
plt.xlabel('Frequência')
plt.ylabel('Densidade Espectral')
plt.title('Periodograma de y2')
plt.legend()
plt.show()

# 3. Teste de Ljung-Box para sazonalidade (com 12 defasagens)
ljung_box_result = acorr_ljungbox(y2, lags=[12], return_df=True)
print("Teste Ljung-Box:")
print(ljung_box_result)

# 4. Decisão automatizada com base no p-value do teste Ljung-Box
if ljung_box_result['lb_pvalue'].iloc[0] < 0.05:
    print("Sazonalidade detectada (p-value < 0.05). Aplicando diferenciação para remover sazonalidade.")
    
    # 5. Aplicação da diferenciação sazonal com lag de 12 (para séries mensais, por exemplo)
    y3 = y2.diff(periods=12).dropna()

    # 6. Reavaliando a série ajustada com o periodograma de y3
    frequencies_y3, Pxx_y3 = periodogram(y3)
    
    plt.figure(figsize=(10, 6))
    plt.plot(frequencies_y3, Pxx_y3, label='Periodograma após Diferenciação Sazonal')
    plt.xlabel('Frequência')
    plt.ylabel('Densidade Espectral')
    plt.title('Periodograma de y3 (após diferenciação sazonal)')
    plt.legend()
    plt.show()

    # 7. Novo teste Ljung-Box após remoção de sazonalidade em y3
    ljung_box_result_y3 = acorr_ljungbox(y3, lags=[12], return_df=True)
    print("Teste Ljung-Box após remoção de sazonalidade:")
    print(ljung_box_result_y3)

    # 8. Verificação da autocorrelação residual após remoção de sazonalidade
    if ljung_box_result_y3['lb_pvalue'].iloc[0] < 0.05:
        print("Autocorrelação significativa ainda detectada após a diferenciação sazonal.")
        y_final = y3  # Atribui y3 como a série ajustada
    else:
        print("Autocorrelação reduzida. y3 será a série final ajustada.")
        y_final = y3
else:
    print("Nenhuma sazonalidade significativa detectada. y2 será a série final ajustada.")
    y_final = y2  # Definindo y_final como y2 se não houver sazonalidade

# 9. Plotando a série final ajustada (sem tendência e sazonalidade)
plt.figure(figsize=(10, 6))
plt.plot(y_final, label='Série Ajustada Final (Sem Tendência e Sazonalidade)', color='blue')
plt.xlabel('Tempo')
plt.ylabel('Valor Ajustado')
plt.title('Série Temporal Ajustada (Sem Tendência e Sazonalidade)')
plt.legend()
plt.show()

# Confirme que o código alcançou esse ponto
print("Código executado até o final.")

Teste Ljung-Box:
      lb_stat  lb_pvalue
12  31.484838   0.001661
Sazonalidade detectada (p-value < 0.05). Aplicando diferenciação para remover sazonalidade.

Teste Ljung-Box após remoção de sazonalidade:
      lb_stat     lb_pvalue
12  75.862905  2.522970e-11
Autocorrelação significativa ainda detectada após a diferenciação sazonal.

Código executado até o final.

3.9 - B)

Verifique a estabilidade da variância ao longo do tempo (homocedasticidade). Caso observe heterocedasticidade, aplique uma transformação adequada para estabilizar a variância

# Convertendo o índice DateTime para um valor numérico
X = sm.add_constant(np.arange(len(y_final)))

# Ajustando o modelo de regressão para os dados transformados
modelo = sm.OLS(y_final, X).fit()

# Realizando o Teste de White
white_test = het_white(modelo.resid, modelo.model.exog)
labels = ['Lagrange Multiplier Statistic', 'p-value', 'f-value', 'f p-value']
resultado_white = dict(zip(labels, white_test))

print("Resultados do Teste de White:")
for label, valor in resultado_white.items():
    print(f"{label}: {valor}")

# Adicionando um offset para garantir que todos os valores sejam positivos
offset = abs(min(y_final)) + 1 if min(y_final) <= 0 else 0
y_final_adjusted = y_final + offset

# Estimativa do parâmetro lambda para Box-Cox usando máxima verossimilhança (mle)
lmbda = stats.boxcox_normmax(y_final_adjusted, method='mle')

# Aplicação da transformação de Box-Cox
y_final_2 = stats.boxcox(y_final_adjusted, lmbda)

# Converter y_final_2 para uma série temporal com o mesmo índice de y_final
y_final_2 = pd.Series(y_final_2, index=y_final.index)

# Plotando as séries temporais original e transformada (Box-Cox)
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Série temporal original (azul)
axes[0].plot(y1, label='Preços do Petróleo', color='blue')
axes[0].set_xlabel('Tempo')
axes[0].set_ylabel('Preço em dólares')
axes[0].set_title('Série Temporal dos Preços do Petróleo (Original)')
axes[0].legend()

# Série temporal transformada (após Box-Cox) (amarelo)
axes[1].plot(y_final_2, label=f'Série Temporal após Box-Cox (Offset = {offset})', color='yellow')
axes[1].set_xlabel('Tempo')
axes[1].set_ylabel('Preço Transformado')
axes[1].set_title('Série Temporal dos Preços do Petróleo com Box-Cox (Transformada)')
axes[1].legend()

plt.tight_layout()
plt.show()

# Exibindo o valor estimado de lambda para Box-Cox e o offset
print(f"Valor estimado de lambda para Box-Cox: {lmbda}")
print(f"Offset aplicado: {offset}")

# Verificando estacionariedade com o Teste ADF (Dickey-Fuller)
adf_result = adfuller(y_final_2)
print(f'Teste ADF após transformação Box-Cox: p-value = {adf_result[1]}')

if adf_result[1] > 0.05:
    print("A série ainda não é estacionária. Aplicar mais diferenciação se necessário.")
else:
    print("A série é estacionária. Pronta para modelagem.")

# Aplicar a primeira diferenciação à série transformada por Box-Cox
y_diff = y_final_2.diff().dropna()  # A primeira diferenciação remove a tendência linear

# Verificar estacionariedade com o Teste ADF (Dickey-Fuller) após a diferenciação
adf_result_diff = adfuller(y_diff)
print(f'Teste ADF após a primeira diferenciação: p-value = {adf_result_diff[1]}')



# Avaliar a estacionariedade após a diferenciação
if adf_result_diff[1] > 0.05:
    print("A série ainda não é estacionária após a primeira diferenciação.")
else:
    print("A série é estacionária após a primeira diferenciação. Pronta para modelagem.")

Resultados do Teste de White:
Lagrange Multiplier Statistic: 171.0885330527495
p-value: 7.056625815179311e-38
f-value: 113.85433866929235
f p-value: 2.423072060985118e-43

Valor estimado de lambda para Box-Cox: 1.0867379338420309
Offset aplicado: 25131.0
Teste ADF após transformação Box-Cox: p-value = 9.248287683036972e-14
A série é estacionária. Pronta para modelagem.
Teste ADF após a primeira diferenciação: p-value = 3.3936923426234893e-23
A série é estacionária após a primeira diferenciação. Pronta para modelagem.

3.9 - E & F

E) Com a série ajustada (sem tendência, sazonalidade e com variância estabilizada), calcule e plote as funções de Autocorrelação (ACF) e Autocorrelação Parcial (PACF).

F) Interprete os gráficos de ACF e PACF obtidos. Comente sobre a estrutura da autocorrelação na série ajustada e como essa informação pode ser utilizada para modelagem

# Plotando ACF e PACF para a série diferenciada
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Gráfico ACF
plot_acf(y_diff, lags=40, ax=axes[0])  # y_diff é a série diferenciada que ficou estacionária
axes[0].set_title('ACF da Série Diferenciada dos Preços do Petróleo')
axes[0].set_xlabel('Lags')
axes[0].set_ylabel('Autocorrelação')

# Gráfico PACF
plot_pacf(y_diff, lags=40, ax=axes[1])  # y_diff é a série diferenciada que ficou estacionária
axes[1].set_title('PACF da Série Diferenciada dos Preços do Petróleo')
axes[1].set_xlabel('Lags')
axes[1].set_ylabel('Autocorrelação Parcial')

# Ajustando o layout
plt.tight_layout()
plt.show()

Análise da Função de Autocorrelação e Autocorrelação Parcial

Interpretação:

ACF: A autocorrelação significativa no primeiro lag indica que a série tem uma dependência imediata. As autocorrelações para lags maiores caem rapidamente para dentro dos intervalos de confiança, sugerindo que não há dependência de longo prazo.

PACF: O primeiro lag no PACF também é significativo, confirmando a dependência imediata. Não há sinais de autocorrelação significativa para lags superiores.

Conclusão:

Com base na análise dos gráficos, um modelo ARIMA(1,1,0) pode ser adequado para a série temporal diferenciada, com um componente autoregressivo de ordem 1 e sem um componente de média móvel.

3.10)

Considere o banco de dados de emprego, que contém informações referentes ao total de admissões e demissões de empregados sob o regime da Consolidação das Leis do Trabalho (CLT) entre maio de 1999 e fevereiro de 2015. Para cada uma das séries (admissões e demissões), siga os passos abaixo para realizar a análise até obter as funções ACF e PACF das séries ajustadas:

3.10 - A)

O banco de dados de emprego contém informações referentes ao total de admissões e demissões de empregados sob o regime da Consolidação das Leis do Trabalho (CLT) entre maio de 1999 e fevereiro de 2015. Para cada uma das séries (admissões e demissões), serão realizados os seguintes passos para análise.

# Leitura dos dados do Excel
dados_emprego = pd.read_excel('emprego.xlsx')

# Converter a coluna 'Data' para datetime no formato 'YYYY/MM'
dados_emprego['Data'] = pd.to_datetime(dados_emprego['Data'].astype(str), format='%Y/%m')

# Definir 'Data' como índice
dados_emprego.set_index('Data', inplace=True)

# Plotando as séries temporais de admissões e demissões
plt.figure(figsize=(14, 6))

# Gráfico para Admissões
plt.subplot(121)
plt.plot(dados_emprego['admissao'], label='Admissões')
plt.xlabel('Tempo')
plt.ylabel('Total de Admissões')
plt.title('Série Temporal de Admissões')
plt.xticks(rotation=45)
plt.gca().get_yaxis().set_major_formatter(plt.FuncFormatter(lambda x, loc: "{:,}".format(int(x))))
plt.legend()

# Gráfico para Demissões
plt.subplot(122)
plt.plot(dados_emprego['demissao'], label='Demissões', color='orange')
plt.xlabel('Tempo')
plt.ylabel('Total de Demissões')
plt.title('Série Temporal de Demissões')
plt.xticks(rotation=45)
plt.gca().get_yaxis().set_major_formatter(plt.FuncFormatter(lambda x, loc: "{:,}".format(int(x))))
plt.legend()

plt.tight_layout()
plt.show()

Análise Visual da Série Temporal de Admissões e Demissões

1. Tendência:

• Ambas as séries, tanto de Admissões quanto de Demissões, apresentam uma tendência de crescimento ao longo do tempo.
• A tendência de aumento é visível principalmente até 2010, com uma estabilização ou leve queda após esse período nas admissões, enquanto as demissões continuam crescendo.

2. Sazonalidade:

• As séries mostram padrões sazonais claros, com oscilações regulares ao longo do tempo. Essas oscilações repetem-se anualmente, indicando a presença de sazonalidade.
• As variações sazonais são evidentes nas admissões, onde ocorrem aumentos e quedas recorrentes ao longo dos anos, especialmente próximos a períodos como o final de cada ano.

3. Variação na Estabilidade da Variância (Heterocedasticidade):

• Há indícios de heterocedasticidade nas séries. No início do período analisado (anos 2000), a amplitude das flutuações nas admissões e demissões é menor, mas aumenta de forma significativa nos anos mais recentes.
• Isso sugere que a variabilidade dos dados não é constante ao longo do tempo, especialmente em séries com maior volume de dados.

Essas observações indicam a presença de tendência, sazonalidade, e heterocedasticidade, elementos importantes a serem considerados para modelagem futura, como em modelos SARIMA ou GARCH

3.10 - C)

Aplique um teste de tendência adequado para verificar a presença de tendência nas séries. Em seguida, remova a tendência utilizando o método de sua escolha.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.stattools import adfuller

# Definição das séries de admissões e demissões
y_admissao = dados_emprego['admissao']
y_demissao = dados_emprego['demissao']

# Função para rodar o Teste ADF e verificar tendência
def adf_test(series, series_name):
    adf_result = adfuller(series)
    p_value = adf_result[1]
    print(f'Teste ADF para {series_name}: p-value = {p_value}')
    return p_value

# Verificando tendência para Admissões
print("Admissões:")
p_value_admissao = adf_test(y_admissao, "Admissões")

# Aplicar diferenciação se a série não for estacionária
if p_value_admissao > 0.05:
    print("Tendência detectada para Admissões, aplicando primeira diferenciação.")
    y_admissao_diff = np.diff(y_admissao)  
    y_admissao_diff = pd.Series(y_admissao_diff, index=y_admissao.index[1:])  
    
    p_value_admissao_diff = adf_test(y_admissao_diff, "Admissões após primeira diferenciação")
    
    if p_value_admissao_diff > 0.05:
        print("Tendência ainda presente. Aplicando segunda diferenciação.")
        y_admissao_diff2 = np.diff(y_admissao_diff)  
        y_admissao_diff2 = pd.Series(y_admissao_diff2, index=y_admissao_diff.index[1:])  
        
        p_value_admissao_diff2 = adf_test(y_admissao_diff2, "Admissões após segunda diferenciação")
        
        if p_value_admissao_diff2 <= 0.05:
            y_admissao_final = y_admissao_diff2  
        else:
            print("A tendência ainda não foi removida.")
    else:
        y_admissao_final = y_admissao_diff  
else:
    y_admissao_final = y_admissao  

# Verificando tendência para Demissões
print("Demissões:")
p_value_demissao = adf_test(y_demissao, "Demissões")

if p_value_demissao > 0.05:
    print("Tendência detectada para Demissões, aplicando primeira diferenciação.")
    y_demissao_diff = np.diff(y_demissao)  
    y_demissao_diff = pd.Series(y_demissao_diff, index=y_demissao.index[1:])  
    
    p_value_demissao_diff = adf_test(y_demissao_diff, "Demissões após primeira diferenciação")
    
    if p_value_demissao_diff > 0.05:
        print("Tendência ainda presente. Aplicando segunda diferenciação.")
        y_demissao_diff2 = np.diff(y_demissao_diff)  
        y_demissao_diff2 = pd.Series(y_demissao_diff2, index=y_demissao_diff.index[1:])  
        
        p_value_demissao_diff2 = adf_test(y_demissao_diff2, "Demissões após segunda diferenciação")
        
        if p_value_demissao_diff2 <= 0.05:
            y_demissao_final = y_demissao_diff2  
        else:
            print("A tendência ainda não foi removida.")
    else:
        y_demissao_final = y_demissao_diff  
else:
    y_demissao_final = y_demissao  

# Plotagem das séries finais ajustadas
fig, axes = plt.subplots(2, 1, figsize=(12, 10))

# Admissões
axes[0].plot(y_admissao_final, label='Admissões (Ajustada)', color='blue')
axes[0].set_title('Série Temporal de Admissões (Ajustada)')
axes[0].set_xlabel('Tempo')
axes[0].set_ylabel('Admissões')
axes[0].legend()

# Demissões
axes[1].plot(y_demissao_final, label='Demissões (Ajustada)', color='green')
axes[1].set_title('Série Temporal de Demissões (Ajustada)')
axes[1].set_xlabel('Tempo')
axes[1].set_ylabel('Demissões')
axes[1].legend()

plt.tight_layout()
plt.show()

Admissões:
Teste ADF para Admissões: p-value = 0.7481354905932903
Tendência detectada para Admissões, aplicando primeira diferenciação.
Teste ADF para Admissões após primeira diferenciação: p-value = 0.12286533389899673
Tendência ainda presente. Aplicando segunda diferenciação.
Teste ADF para Admissões após segunda diferenciação: p-value = 3.996618057891359e-23
Demissões:
Teste ADF para Demissões: p-value = 0.9392854759936037
Tendência detectada para Demissões, aplicando primeira diferenciação.
Teste ADF para Demissões após primeira diferenciação: p-value = 0.020425471994547705

3.10 - D)

Verifique se há presença de sazonalidade nas séries. Se identificada, remova-a utilizando um método apropriado

# Supondo que y_admissao_final e y_demissao_final são pandas Series com index datetime
# Definição da função para aplicar diferenciação sazonal
def seasonal_difference(series, period=12):
    """Aplica diferenciação sazonal para uma série temporal."""
    return series.diff(periods=period).dropna()

# Aplicação da diferenciação sazonal
y_admissao_final_diff = seasonal_difference(y_admissao_final, period=12)
y_demissao_final_diff = seasonal_difference(y_demissao_final, period=12)

# Definição da função para realizar o teste de Ljung-Box
def ljung_box_test(series, lags=[12]):
    """Executa o teste de Ljung-Box para verificar autocorrelação residual."""
    ljung_box_result = acorr_ljungbox(series, lags=lags, return_df=True)
    return ljung_box_result

# Executando o teste de Ljung-Box após diferenciação sazonal
ljung_admissao_diff = ljung_box_test(y_admissao_final_diff, lags=[12])
ljung_demissao_diff = ljung_box_test(y_demissao_final_diff, lags=[12])

print("Teste Ljung-Box para Admissões após Diferenciação Sazonal:")
print(ljung_admissao_diff)
print("\nTeste Ljung-Box para Demissões após Diferenciação Sazonal:")
print(ljung_demissao_diff)

# Plotando as séries diferenciadas para visualização
plt.figure(figsize=(12, 6))
plt.subplot(121)
plt.plot(y_admissao_final_diff, label='Admissões (Após Diferenciação Sazonal)', color='blue')
plt.title('Admissões')
plt.xlabel('Tempo')
plt.ylabel('Admissões')
plt.legend()

plt.subplot(122)
plt.plot(y_demissao_final_diff, label='Demissões (Após Diferenciação Sazonal)', color='orange')
plt.title('Demissões')
plt.xlabel('Tempo')
plt.ylabel('Demissões')
plt.legend()

plt.tight_layout()
plt.show()

Teste Ljung-Box para Admissões após Diferenciação Sazonal:
      lb_stat     lb_pvalue
12  76.900493  1.604234e-11

Teste Ljung-Box para Demissões após Diferenciação Sazonal:
      lb_stat     lb_pvalue
12  98.354975  1.168544e-15

3.10 - B)

Verifique a estabilidade da variância ao longo do tempo (homocedasticidade). Caso observe heterocedasticidade, aplique uma transformação adequada para estabilizar a variância.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import statsmodels.api as sm
from scipy.stats import boxcox
from statsmodels.stats.diagnostic import het_white

# Função para rodar o Teste de White e verificar homocedasticidade
def white_test(series):
    X = sm.add_constant(np.arange(len(series)))  # Criando um modelo simples de tendência
    model = sm.OLS(series, X).fit()
    test = het_white(model.resid, model.model.exog)
    labels = ['Lagrange Multiplier Statistic', 'p-value', 'f-value', 'f p-value']
    return dict(zip(labels, test))

# Função para aplicar transformação de Box-Cox com ajuste para positividade
def apply_boxcox(series):
    # Garantir que todos os dados sejam positivos
    offset = abs(min(series)) + 1 if min(series) <= 0 else 0
    series_adjusted = series + offset
    transformed_data, lmbda = boxcox(series_adjusted)
    return transformed_data, lmbda, offset

# Verificar e transformar admissões e demissões
for series_name, series_data in [('Admissões', y_admissao_final_diff), ('Demissões', y_demissao_final_diff)]:
    wt_result = white_test(series_data)
    print(f"Teste de White para {series_name}: p-value = {wt_result['p-value']}")

    if wt_result['p-value'] < 0.05:
        print(f"Heterocedasticidade detectada para {series_name}. Aplicando transformação de Box-Cox.")
        series_bc, lmbda, offset = apply_boxcox(series_data)
        plt.plot(series_bc, label=f'{series_name} (Box-Cox com offset {offset})', color='green')
    else:
        print(f"Não foi detectada heterocedasticidade para {series_name}. Usando dados originais.")
        plt.plot(series_data, label=f'{series_name} (Original)', color='blue')
    
    plt.title(f'Série Transformada de {series_name}')
    plt.xlabel('Tempo')
    plt.ylabel(series_name)
    plt.legend()
    plt.show()

Teste de White para Admissões: p-value = 0.00017128131774348678
Heterocedasticidade detectada para Admissões. Aplicando transformação de Box-Cox.

Teste de White para Demissões: p-value = 0.004056734376528203
Heterocedasticidade detectada para Demissões. Aplicando transformação de Box-Cox.

3.10 - E & F)

E) Com a série ajustada (sem tendência, sazonalidade e com variância estabilizada), calcule e plote as funções de Autocorrelação (ACF) e Autocorrelação Parcial (PACF).

F) Interprete os gráficos de ACF e PACF obtidos. Comente sobre a estrutura da autocorrelação na série ajustada e como essa informação pode ser utilizada para modelagem futura.

# Definição das funções de teste e transformação
def white_test(series):
    X = sm.add_constant(np.arange(len(series)))  # Criando um modelo simples de tendência
    model = sm.OLS(series, X).fit()
    test = het_white(model.resid, model.model.exog)
    labels = ['Lagrange Multiplier Statistic', 'p-value', 'f-value', 'f p-value']
    return dict(zip(labels, test))

def apply_boxcox(series):
    # Garantir que todos os dados sejam positivos
    offset = abs(min(series)) + 1 if min(series) <= 0 else 0
    series_adjusted = series + offset
    transformed_data, lmbda = boxcox(series_adjusted)
    return transformed_data, lmbda, offset

# Processamento das séries para verificar heterocedasticidade e aplicar Box-Cox se necessário
final_series = {}
for series_name, series_data in [('Admissões', y_admissao_final_diff), ('Demissões', y_demissao_final_diff)]:
    wt_result = white_test(series_data)
    print(f"Teste de White para {series_name}: p-value = {wt_result['p-value']}")

    if wt_result['p-value'] < 0.05:
        print(f"Heterocedasticidade detectada para {series_name}. Aplicando transformação de Box-Cox.")
        series_bc, lmbda, offset = apply_boxcox(series_data)
        final_series[series_name] = series_bc  # Armazena a série transformada
    else:
        print(f"Não foi detectada heterocedasticidade para {series_name}. Usando dados originais.")
        final_series[series_name] = series_data  # Armazena a série original

# Plotando ACF e PACF para cada série processada
for series_name, series_data in final_series.items():
    plot_acf_pacf(series_data, series_name)

Teste de White para Admissões: p-value = 0.00017128131774348678
Heterocedasticidade detectada para Admissões. Aplicando transformação de Box-Cox.
Teste de White para Demissões: p-value = 0.004056734376528203
Heterocedasticidade detectada para Demissões. Aplicando transformação de Box-Cox.

Análise de ACF e PACF para Admissões

Interpretação dos Gráficos de ACF e PACF

• ACF (Função de Autocorrelação): O gráfico ACF mostra uma queda significativa no primeiro lag, seguido de correlações que decaem lentamente. Isso indica que há uma estrutura de autocorrelação nas admissões. As autocorrelações positivas após o primeiro lag podem sugerir a presença de um processo AR (auto-regressivo).

• PACF (Função de Autocorrelação Parcial): O gráfico PACF mostra uma grande queda no primeiro lag e alguns valores significativos nas defasagens subsequentes. Esse padrão sugere que a série pode ser explicada por um modelo AR (auto-regressivo), possivelmente de baixa ordem, uma vez que a maioria das correlações parciais após o primeiro lag caem rapidamente para zero.

Implicações para a Modelagem

Com base nesses gráficos:

1. O padrão de autocorrelação e autocorrelação parcial sugere que um modelo AR seria apropriado para capturar a dependência temporal nas admissões.
2. A queda acentuada no primeiro lag do PACF indica que um modelo AR de ordem 1 ou 2 poderia ser suficiente para capturar a estrutura subjacente da série temporal.
3. O decaimento lento no ACF também indica que modelos ARMA podem ser considerados, combinando a dependência auto-regressiva com componentes de média móvel (MA).

Essas informações podem ser usadas para selecionar um modelo ARIMA ou ARMA na modelagem futura, ajustando o modelo conforme os parâmetros indicados pelas funções ACF e PACF.

Análise de ACF e PACF para Demissões

Interpretação dos Gráficos de ACF e PACF

• ACF (Função de Autocorrelação): O gráfico ACF mostra uma correlação significativa no primeiro lag e decai de maneira relativamente lenta, com várias correlações positivas e negativas ao longo dos lags. Esse comportamento pode sugerir um padrão de dependência ao longo do tempo, que pode ser capturado por um modelo AR (auto-regressivo) ou ARMA (auto-regressivo com média móvel).

• PACF (Função de Autocorrelação Parcial): O gráfico PACF apresenta um declínio acentuado no primeiro lag, seguido por algumas autocorrelações parciais significativas até o lag 10. Isso indica que um modelo AR de baixa ordem (provavelmente de ordem 1) pode ser adequado para modelar a estrutura de autocorrelação das demissões.

Implicações para a Modelagem

Com base nos gráficos de ACF e PACF:

1. A queda acentuada no primeiro lag do PACF sugere que um modelo AR de ordem 1 ou 2 pode ser suficiente para modelar a série de demissões.
2. O comportamento oscilante das autocorrelações no ACF indica que um modelo ARMA também pode ser considerado, para capturar tanto a dependência de longo prazo quanto os componentes de média móvel.
3. Modelos ARIMA também podem ser explorados para considerar a presença de tendências ou sazonalidade na série de demissões.

Essas informações são úteis para a seleção de modelos na modelagem futura, sugerindo que um modelo de baixa ordem AR pode ser adequado, possivelmente combinado com um componente MA se necessário.

3.11)

Considere o banco de dados de produção, que contém a série temporal da produção de veículos comerciais leves montados (quantidade), fornecida pela Associação Nacional dos Fabricantes de Veículos Automotores (ANFAVEA), conforme registrado no Anuário Estatístico da Indústria Automobilística Brasileira ou na Carta Mensal (Anfavea)

3.11 - A)

Plote as séries temporais originaise descreva visualmente se há presença de tendência, sazonalidade ou variação na estabilidade da variância (heterocedasticidade)

# Substitua o caminho abaixo pelo correto no seu ambiente
data = pd.read_excel(r'producao.xlsx')

# Convertendo a coluna 'Data' para o formato datetime
data['Data'] = pd.to_datetime(data['Data'], format='%Y/%m')

# Agora vamos ajustar o gráfico para mostrar o eixo x com datas adequadas
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 6))
plt.plot(data['Data'], data['producao'], label='Produção de Veículos Comerciais Leves', color='b')
plt.title('Produção de Veículos Comerciais Leves (Original)')
plt.xlabel('Ano')
plt.ylabel('Quantidade Produzida')
plt.legend()

# Definindo a série temporal original de produção (y1)
y1 = data['producao']

# Melhorando a formatação do eixo x para mostrar os anos corretamente
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Análise da Série Temporal da Produção de Veículos Comerciais Leves

Descrição Visual

Ao observar o gráfico, podemos identificar as seguintes características:

1. Tendência

• Tendência Ascendente: A série temporal mostra uma clara tendência de crescimento ao longo do tempo. Nos primeiros períodos, a produção de veículos comerciais leves era relativamente baixa e estável. No entanto, a partir de aproximadamente o ponto 400, a produção começa a crescer de forma acentuada, atingindo níveis muito mais altos nos períodos finais.

2. Sazonalidade

• Possível Sazonalidade: Embora não seja imediatamente óbvia, há variações cíclicas menores ao longo do tempo, que podem estar associadas a um padrão sazonal. Isso é sugerido por flutuações regulares em certos períodos, como na região entre 200 e 400 e, de forma mais pronunciada, após o ponto 500. No entanto, essa sazonalidade não é muito clara e pode precisar de uma análise mais detalhada (por exemplo, com a decomposição da série).

3. Heterocedasticidade (Variação na Estabilidade da Variância)

• Aumento da Variância ao Longo do Tempo: Podemos observar que, à medida que a produção aumenta, a variância dos dados também parece crescer, especialmente após o ponto 500. As flutuações nos valores tornam-se muito mais pronunciadas, o que indica a presença de heterocedasticidade (variação não constante na variância). Nos períodos iniciais, as variações em torno da média eram pequenas, enquanto nos períodos mais recentes, as variações são muito mais amplas.

Conclusão

• Tendência: Claramente presente, com um crescimento acentuado nos períodos finais.
• Sazonalidade: Pode estar presente, mas não é totalmente evidente sem uma análise mais detalhada.
• Heterocedasticidade: A variância não é constante e aumenta conforme a produção cresce, o que pode impactar a modelagem da série temporal.

3.11 - C)

Aplique um teste de tendência adequado para verificar a presença de tendência na série. Em seguida, remova a tendência utilizando o método de sua escolha.

# Teste de Tendência (Dickey-Fuller) na série original y1
adf_result = adfuller(y1)
print(f'Teste ADF para tendência: p-value = {adf_result[1]}')

# Se a tendência for detectada (p-value > 0.05), aplica-se a diferenciação
if adf_result[1] > 0.05:
    print("Tendência detectada, aplicando diferenciação.")
    y2 = np.diff(y1)  # Aplicando a primeira diferenciação
    y2 = pd.Series(y2, index=y1.index[1:])  # Ajustando o índice da série diferenciada
else:
    y2 = y1  # Se não houver tendência, y2 será igual a y1

# Teste ADF após a diferenciação (ou na série original se não houver tendência)
adf_result_diff = adfuller(y2)
print(f'Teste ADF após a diferenciação: p-value = {adf_result_diff[1]}')

# Visualizar a série temporal diferenciada (ou original, se não houver diferenciação)
plt.figure(figsize=(10, 6))
plt.plot(y2, label='Série Temporal Após Diferenciação (ou Original)')
plt.xlabel('Tempo')
plt.ylabel('Valor')
plt.title('Série Temporal Após Diferenciação (ou Original)')
plt.legend()
plt.show()

Teste ADF para tendência: p-value = 0.9402495626816348
Tendência detectada, aplicando diferenciação.
Teste ADF após a diferenciação: p-value = 1.6062779445308792e-09

3.11 - D)

Verifique se há presença de sazonalidade na série. Se identificada, remova-a utilizando um método apropriado.

# Inicializar y_final como None ou com um valor padrão
y_final = None

# Supondo que y2 é a série temporal ajustada anteriormente

# 7. Testar Sazonalidade usando o periodograma
frequencies, Pxx = periodogram(y2)

# 8. Plotando o periodograma de y2
plt.figure(figsize=(10, 6))
plt.plot(frequencies, Pxx, label='Periodograma')
plt.xlabel('Frequência')
plt.ylabel('Densidade Espectral')
plt.title('Periodograma de y2')
plt.legend()
plt.show()

# 9. Teste de Ljung-Box para sazonalidade
ljung_box_result = acorr_ljungbox(y2, lags=[12], return_df=True)
print("Teste Ljung-Box:")
print(ljung_box_result)

# Decisão automatizada com base no p-value
if ljung_box_result['lb_pvalue'].iloc[0] < 0.05:
    print("Sazonalidade detectada (p-value < 0.05). Aplicando diferenciação para remover sazonalidade.")
    
    # Aplicação da diferenciação sazonal com lag de 6
    y3 = y2.diff(periods=6).dropna()

    # Reavaliando a série ajustada com o periodograma de y3
    frequencies_y3, Pxx_y3 = periodogram(y3)
    
    plt.figure(figsize=(10, 6))
    plt.plot(frequencies_y3, Pxx_y3, label='Periodograma após Diferenciação')
    plt.xlabel('Frequência')
    plt.ylabel('Densidade Espectral')
    plt.title('Periodograma de y3')
    plt.legend()
    plt.show()

    # Novo teste Ljung-Box após remoção de sazonalidade em y3
    ljung_box_result_y3 = acorr_ljungbox(y3, lags=[12], return_df=True)
    print("Teste Ljung-Box após remoção de sazonalidade:")
    print(ljung_box_result_y3)

    # Verificação da autocorrelação residual após remoção de sazonalidade
    if ljung_box_result_y3['lb_pvalue'].iloc[0] < 0.05:
        print("Autocorrelação significativa ainda detectada após a diferenciação sazonal.")
        
        # Tentativa de nova diferenciação sazonal com um período diferente (lag de 12)
        y4 = y3.diff(periods=12).dropna()

        # Reavaliando a série ajustada com o periodograma de y4
        frequencies_y4, Pxx_y4 = periodogram(y4)
        
        plt.figure(figsize=(10, 6))
        plt.plot(frequencies_y4, Pxx_y4, label='Periodograma após Diferenciação com Lag 12')
        plt.xlabel('Frequência')
        plt.ylabel('Densidade Espectral')
        plt.title('Periodograma de y4')
        plt.legend()
        plt.show()

        # Novo teste Ljung-Box após nova diferenciação sazonal em y4
        ljung_box_result_y4 = acorr_ljungbox(y4, lags=[12], return_df=True)
        print("Teste Ljung-Box após nova diferenciação sazonal:")
        print(ljung_box_result_y4)
        
        if ljung_box_result_y4['lb_pvalue'].iloc[0] < 0.05:
            print("Autocorrelação significativa ainda presente")
            y_final = y4  # Definindo y_final como y4
            
        else:
            print("Autocorrelação reduzida. y4 será a série final ajustada.")
            y_final = y4
    else:
        print("Nenhuma autocorrelação significativa detectada após a remoção de sazonalidade. y3 será a série final ajustada.")
        y_final = y3
else:
    print("Nenhuma sazonalidade significativa detectada. y_final será igual a y2.")
    y_final = y2  # Definindo y_final como y2

# Exibir o resumo da série final ajustada
print("\nResumo da série final ajustada (y_final):")
print(y_final.head())

# Plotando a série final sem sazonalidade
plt.figure(figsize=(10, 6))
plt.plot(y_final, label='Série Final sem Sazonalidade')
plt.title('Série Temporal após Remoção de Sazonalidade')
plt.xlabel('Ano')
plt.ylabel('Produção')
plt.legend()
plt.show()

# Confirme que o código alcançou esse ponto

Teste Ljung-Box:
       lb_stat     lb_pvalue
12  108.870634  1.000593e-17
Sazonalidade detectada (p-value < 0.05). Aplicando diferenciação para remover sazonalidade.

Teste Ljung-Box após remoção de sazonalidade:
       lb_stat     lb_pvalue
12  413.050095  6.510055e-81
Autocorrelação significativa ainda detectada após a diferenciação sazonal.

Teste Ljung-Box após nova diferenciação sazonal:
       lb_stat     lb_pvalue
12  282.792486  1.909504e-53
Autocorrelação significativa ainda presente

Resumo da série final ajustada (y_final):
19    128.0
20   -424.0
21    152.0
22   -417.0
23     97.0
dtype: float64

3.11 - B)

Verifique a estabilidade da variância ao longo do tempo (homocedasticidade). Caso observe heterocedasticidade, aplique uma transformação adequada para estabilizar a variância.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import statsmodels.api as sm
from statsmodels.stats.diagnostic import het_white
from scipy import stats

# Função para rodar o Teste de White
def white_test(y):
    X = sm.add_constant(range(len(y)))  # Criando um modelo simples de tendência
    model = sm.OLS(y, X).fit()
    test = het_white(model.resid, X)
    labels = ['Lagrange Multiplier Statistic', 'p-value', 'f-value', 'f p-value']
    return dict(zip(labels, test))

# Supondo que y_final já foi definido anteriormente e contém a série ajustada

# Verificando a homocedasticidade para a série final ajustada (y_final)
wt_final = white_test(y_final)
print(f"Teste de White para a Série Final Ajustada: p-value = {wt_final['p-value']}")

# Aplicação da transformação de Box-Cox ou uso dos dados originais para a Série Final
if wt_final['p-value'] < 0.05:
    print("Heterocedasticidade detectada para a Série Final Ajustada. Aplicando transformação de Box-Cox.")
    
    # Adicionar um offset para garantir que todos os valores sejam positivos
    offset = abs(min(y_final)) + 1 if min(y_final) <= 0 else 0
    y_final_adjusted = y_final + offset
    
    # Aplicar a transformação de Box-Cox
    lmbda_final = stats.boxcox_normmax(y_final_adjusted, method='mle')
    y_transformed = stats.boxcox(y_final_adjusted, lmbda_final)
else:
    print("Não foi detectada heterocedasticidade para a Série Final Ajustada. Usando dados originais.")
    y_transformed = y_final

# Converter y_transformed para uma série temporal com o mesmo índice de y_final
y_transformed = pd.Series(y_transformed, index=y_final.index)

# Criando a figura e os dois subplots lado a lado
plt.figure(figsize=(14, 6))

# Primeiro gráfico: Série transformada ou original dependendo do teste
plt.subplot(1, 2, 1)  # 1 linha, 2 colunas, primeiro gráfico
plt.plot(y_final.index, y_transformed, label='Série Temporal após Box-Cox' if wt_final['p-value'] < 0.05 else 'Série Temporal Original')
plt.xlabel('Ano')
plt.ylabel('Produção Transformada' if wt_final['p-value'] < 0.05 else 'Produção')
plt.title('Série Temporal com Box-Cox')
plt.legend()

# Segundo gráfico: Série original sem transformação
plt.subplot(1, 2, 2)  # 1 linha, 2 colunas, segundo gráfico
plt.plot(y_final.index, y_final, label='Série Final Ajustada (Original)')
plt.title('Série Final Ajustada (Original)')
plt.xlabel('Ano')
plt.ylabel('Quantidade Produzida')
plt.legend()

# Exibindo os gráficos lado a lado
plt.tight_layout()
plt.show()

# Exibindo o valor estimado de lambda se a transformação foi aplicada
if wt_final['p-value'] < 0.05:
    print(f"Valor estimado de lambda para Box-Cox: {lmbda_final}")
    print(f"Offset aplicado: {offset}")

Teste de White para a Série Final Ajustada: p-value = 7.056625815179311e-38
Heterocedasticidade detectada para a Série Final Ajustada. Aplicando transformação de Box-Cox.

Valor estimado de lambda para Box-Cox: 1.0867379338420309
Offset aplicado: 25131.0

3.11 - E & F)

E) Com a série ajustada (sem tendência, sazonalidade e com variância estabilizada), calcule e plote as funções de Autocorrelação (ACF) e Autocorrelação Parcial (PACF).

F) Interprete os gráficos de ACF e PACF obtidos. Comente sobre a estrutura da autocorrelação na série ajustada e como essa informação pode ser utilizada para modelagem fu

# Criação da figura e dos eixos para ACF e PACF
fig, ax = plt.subplots(1, 2, figsize=(16, 6))

# Plotar ACF no primeiro eixo (usando a série transformada 'y_transformed')
plot_acf(y_transformed, lags=40, ax=ax[0])
ax[0].set_title('ACF da Série ANFAVEA')

# Plotar PACF no segundo eixo (usando a série transformada 'y_transformed')
plot_pacf(y_transformed, lags=40, ax=ax[1])
ax[1].set_title('PACF da Série ANFAVEA')

# Ajustar o layout
plt.tight_layout()
plt.show()

Interpretação dos Gráficos de ACF e PACF

ACF (Autocorrelação)

• No gráfico de ACF, podemos observar uma forte correlação positiva no primeiro lag seguida por oscilações menores ao longo dos lags subsequentes.
• As correlações parecem decair gradualmente com valores próximos de zero após o lag 5, indicando que existe uma dependência de curto prazo nos dados.
• Este comportamento é típico de um modelo AR (Auto-regressivo) de baixa ordem, sugerindo que a série tem memória curta.

PACF (Autocorrelação Parcial)

• O gráfico de PACF apresenta uma queda acentuada no primeiro lag, seguido de algumas autocorrelações parciais significativas até o lag 10.
• Após os primeiros lags, as autocorrelações parciais se estabilizam, sugerindo que a maioria da variabilidade da série pode ser explicada por um modelo AR de ordem baixa.
• Um modelo AR(1) ou AR(2) pode ser adequado para modelar a série, já que a correlação diminui rapidamente após os primeiros lags.

Implicações para Modelagem

Com base nestes gráficos:

1. A estrutura da autocorrelação sugere que um modelo ARIMA pode ser uma boa escolha, especialmente com um componente AR (Auto-regressivo) dominante.
2. Um modelo AR(1) ou AR(2) provavelmente será suficiente para capturar a dependência temporal dos dados.
3. A queda rápida na PACF e o comportamento oscilante na ACF indicam que a série pode ser modelada sem a necessidade de componentes de média móvel (MA), embora essa hipótese possa ser testada durante a modelagem.

!jupyter nbconvert --to html  "CODE DA LISTA 3 COM TODOS INPUTS.ipynb"

This application is used to convert notebook files (*.ipynb)
        to various other formats.

        WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.

Options
=======
The options below are convenience aliases to configurable class-options,
as listed in the "Equivalent to" description-line of the aliases.
To see all configurable class-options for some <cmd>, use:
    <cmd> --help-all

--debug
    set log level to logging.DEBUG (maximize logging output)
    Equivalent to: [--Application.log_level=10]
--show-config
    Show the application's configuration (human-readable format)
    Equivalent to: [--Application.show_config=True]
--show-config-json
    Show the application's configuration (json format)
    Equivalent to: [--Application.show_config_json=True]
--generate-config
    generate default config file
    Equivalent to: [--JupyterApp.generate_config=True]
-y
    Answer yes to any questions instead of prompting.
    Equivalent to: [--JupyterApp.answer_yes=True]
--execute
    Execute the notebook prior to export.
    Equivalent to: [--ExecutePreprocessor.enabled=True]
--allow-errors
    Continue notebook execution even if one of the cells throws an error and include the error message in the cell output (the default behaviour is to abort conversion). This flag is only relevant if '--execute' was specified, too.
    Equivalent to: [--ExecutePreprocessor.allow_errors=True]
--stdin
    read a single notebook file from stdin. Write the resulting notebook with default basename 'notebook.*'
    Equivalent to: [--NbConvertApp.from_stdin=True]
--stdout
    Write notebook output to stdout instead of files.
    Equivalent to: [--NbConvertApp.writer_class=StdoutWriter]
--inplace
    Run nbconvert in place, overwriting the existing notebook (only
            relevant when converting to notebook format)
    Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory=]
--clear-output
    Clear output of current file and save in place,
            overwriting the existing notebook.
    Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory= --ClearOutputPreprocessor.enabled=True]
--coalesce-streams
    Coalesce consecutive stdout and stderr outputs into one stream (within each cell).
    Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory= --CoalesceStreamsPreprocessor.enabled=True]
--no-prompt
    Exclude input and output prompts from converted document.
    Equivalent to: [--TemplateExporter.exclude_input_prompt=True --TemplateExporter.exclude_output_prompt=True]
--no-input
    Exclude input cells and output prompts from converted document.
            This mode is ideal for generating code-free reports.
    Equivalent to: [--TemplateExporter.exclude_output_prompt=True --TemplateExporter.exclude_input=True --TemplateExporter.exclude_input_prompt=True]
--allow-chromium-download
    Whether to allow downloading chromium if no suitable version is found on the system.
    Equivalent to: [--WebPDFExporter.allow_chromium_download=True]
--disable-chromium-sandbox
    Disable chromium security sandbox when converting to PDF..
    Equivalent to: [--WebPDFExporter.disable_sandbox=True]
--show-input
    Shows code input. This flag is only useful for dejavu users.
    Equivalent to: [--TemplateExporter.exclude_input=False]
--embed-images
    Embed the images as base64 dataurls in the output. This flag is only useful for the HTML/WebPDF/Slides exports.
    Equivalent to: [--HTMLExporter.embed_images=True]
--sanitize-html
    Whether the HTML in Markdown cells and cell outputs should be sanitized..
    Equivalent to: [--HTMLExporter.sanitize_html=True]
--log-level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
    Equivalent to: [--Application.log_level]
--config=<Unicode>
    Full path of a config file.
    Default: ''
    Equivalent to: [--JupyterApp.config_file]
--to=<Unicode>
    The export format to be used, either one of the built-in formats
            ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'qtpdf', 'qtpng', 'rst', 'script', 'slides', 'webpdf']
            or a dotted object name that represents the import path for an
            ``Exporter`` class
    Default: ''
    Equivalent to: [--NbConvertApp.export_format]
--template=<Unicode>
    Name of the template to use
    Default: ''
    Equivalent to: [--TemplateExporter.template_name]
--template-file=<Unicode>
    Name of the template file to use
    Default: None
    Equivalent to: [--TemplateExporter.template_file]
--theme=<Unicode>
    Template specific theme(e.g. the name of a JupyterLab CSS theme distributed
    as prebuilt extension for the lab template)
    Default: 'light'
    Equivalent to: [--HTMLExporter.theme]
--sanitize_html=<Bool>
    Whether the HTML in Markdown cells and cell outputs should be sanitized.This
    should be set to True by nbviewer or similar tools.
    Default: False
    Equivalent to: [--HTMLExporter.sanitize_html]
--writer=<DottedObjectName>
    Writer class used to write the
                                        results of the conversion
    Default: 'FilesWriter'
    Equivalent to: [--NbConvertApp.writer_class]
--post=<DottedOrNone>
    PostProcessor class used to write the
                                        results of the conversion
    Default: ''
    Equivalent to: [--NbConvertApp.postprocessor_class]
--output=<Unicode>
    Overwrite base name use for output files.
                Supports pattern replacements '{notebook_name}'.
    Default: '{notebook_name}'
    Equivalent to: [--NbConvertApp.output_base]
--output-dir=<Unicode>
    Directory to write output(s) to. Defaults
                                  to output to the directory of each notebook. To recover
                                  previous default behaviour (outputting to the current
                                  working directory) use . as the flag value.
    Default: ''
    Equivalent to: [--FilesWriter.build_directory]
--reveal-prefix=<Unicode>
    The URL prefix for reveal.js (version 3.x).
            This defaults to the reveal CDN, but can be any url pointing to a copy
            of reveal.js.
            For speaker notes to work, this must be a relative path to a local
            copy of reveal.js: e.g., "reveal.js".
            If a relative path is given, it must be a subdirectory of the
            current directory (from which the server is run).
            See the usage documentation
            (https://nbconvert.readthedocs.io/en/latest/usage.html#reveal-js-html-slideshow)
            for more details.
    Default: ''
    Equivalent to: [--SlidesExporter.reveal_url_prefix]
--nbformat=<Enum>
    The nbformat version to write.
            Use this to downgrade notebooks.
    Choices: any of [1, 2, 3, 4]
    Default: 4
    Equivalent to: [--NotebookExporter.nbformat_version]

Examples
--------

    The simplest way to use nbconvert is

            > jupyter nbconvert mynotebook.ipynb --to html

            Options include ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'qtpdf', 'qtpng', 'rst', 'script', 'slides', 'webpdf'].

            > jupyter nbconvert --to latex mynotebook.ipynb

            Both HTML and LaTeX support multiple output templates. LaTeX includes
            'base', 'article' and 'report'.  HTML includes 'basic', 'lab' and
            'classic'. You can specify the flavor of the format used.

            > jupyter nbconvert --to html --template lab mynotebook.ipynb

            You can also pipe the output to stdout, rather than a file

            > jupyter nbconvert mynotebook.ipynb --stdout

            PDF is generated via latex

            > jupyter nbconvert mynotebook.ipynb --to pdf

            You can get (and serve) a Reveal.js-powered slideshow

            > jupyter nbconvert myslides.ipynb --to slides --post serve

            Multiple notebooks can be given at the command line in a couple of
            different ways:

            > jupyter nbconvert notebook*.ipynb
            > jupyter nbconvert notebook1.ipynb notebook2.ipynb

            or you can specify the notebooks list in a config file, containing::

                c.NbConvertApp.notebooks = ["my_notebook.ipynb"]

            > jupyter nbconvert --config mycfg.py

To see all available configurables, use `--help-all`.

[NbConvertApp] WARNING | pattern 'CODE DA LISTA 3 COM TODOS INPUTS.ipynb' matched no files