neste tutorial, iremos abordar o tema de série de tempo de modelação com autoregressive processos.este artigo abrangerá os seguintes elementos-chave na análise das séries cronológicas::processo autoregressivo: equação de Yule-Walker: stationarity: teste aumentado de Dicker-Fuller: teste aumentado de Dicker-Fuller. O código e o conjunto de dados estão disponíveis aqui.vamos começar!

Aprenda a trabalhar com modelos mais complexos como SARIMAX, VARMAX, e aplique modelos de aprendizagem profunda (LSTM, CNN, ResNet, autoregressive LSTM) para a análise de séries cronológicas com a análise de séries cronológicas aplicada em Python!

processo Autorregressivo

um modelo autorregressivo usa uma combinação linear de valores anteriores do alvo para fazer previsões. É claro que a regressão é feita contra o próprio alvo. Matematicamente, um AR(p) modelo é expresso como:

Em que:

• p: é a ordem
• c: é uma constante
• epsilon: o modelo de ruído

AR(p) é incrivelmente flexível e pode modelar vários tipos diferentes de padrões de séries cronológicas. Isto é facilmente visualizado quando simulamos processos autoregressivos.Normalmente, os modelos autoregressivos são aplicados apenas a séries cronológicas estacionárias. Isto restringe a gama dos parâmetros phi.

Por exemplo, um modelo AR (1) irá restringir o phi entre -1 e 1. Essas restrições tornam-se mais complexas à medida que a ordem do modelo aumenta, mas elas são automaticamente consideradas quando modelagem em Python.

simulação de um processo AR(2)

vamos simular um processo AR(2) em Python.

começamos por importar algumas bibliotecas. Nem todos serão usados para a simulação, mas serão necessários para o resto deste tutorial.

from statsmodels.graphics.tsaplots import plot_pacf
from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.tsa.arima_process import ArmaProcess
from statsmodels.tsa.stattools import pacf
from statsmodels.regression.linear_model import yule_walker
from statsmodels.tsa.stattools import adfuller
import matplotlib.pyplot as plt
import numpy as np%matplotlib inline

usaremos a biblioteca ArmaProcess para simular a série cronológica. Requer que definamos os nossos parâmetros.

vamos simular o seguinte processo:

uma vez que estamos lidando com um autoregressive modelo de ordem 2, é necessário definir o coeficiente de lag 0, 1 e 2.

também, vamos cancelar o efeito de um processo de média móvel.finalmente, vamos gerar 10 000 pontos de dados.

em código:

ar2 = np.array()
ma = np.array()simulated_AR2_data = ArmaProcess(ar2, ma).generate_sample(nsample=10000)

podemos traçar a série cronológica:

plt.figure(figsize=); # Set dimensions for figure
plt.plot(simulated_AR2_data)
plt.title("Simulated AR(2) Process")
plt.show()

And you should get something similar to this:

Now, let’s take a look at the autocorrelation plot (correlogram):

plot_acf(simulated_AR2_data);

Você pode ver que o coeficiente é degradam lentamente. Isto significa que é improvável um processo de movimento médio e sugere que a série cronológica pode provavelmente ser modelada com um processo autorregressivo (o que faz sentido desde que o que estamos simulando).

para ter a certeza de que isto está correcto, vamos traçar a parcela de autocorrelação parcial:

plot_pacf(simulated_AR2_data);

Como você pode ver, os coeficientes não são significativos após gal 2. Portanto, a parcela de autocorrelação parcial é útil para determinar a ordem de um processo AR(p).

Você também pode verificar os valores de cada coeficiente, executando:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

Now, in a real project setting, it can be easy to find the order of an AR(p) process, but we need to find a way to estimate the coefficients phi.para isso, usamos a equação de Yule-Walker. Estas equações permitem estimar os coeficientes de um modelo AR(p), dado que conhecemos a ordem.

rho, sigma = yule_walker(simulated_AR2_data, 2, method='mle')
print(f'rho: {-rho}')
print(f'sigma: {sigma}')

Como você pode ver, o Yule-Walker equação fez um trabalho decente na estimativa de nossa coeficientes e ficou muito perto de 0,33 e 0.5.

simulação de um processo AR(3)

Agora, vamos simular um processo AR(3). Especificamente, vamos simular:

da mesma forma que foi feito anteriormente, vamos definir nosso coeficientes e gerar 10 000 pontos de dados:

ar3 = np.array()
ma = np.array()simulated_AR3_data = ArmaProcess(ar3,ma).generate_sample(nsample=10000)

em Seguida, pode-se visualizar as séries de tempo:

plt.figure(figsize=); # Set dimensions for figure
plt.plot(simulated_AR3_data)
plt.title("Simulated AR(3) Process")
plt.show()

E você deve ver algo similar a:

Now, looking at the PACF and ACF:

plot_pacf(simulated_AR3_data);
plot_acf(simulated_AR3_data);

You see that the coefficients are not significant after lag 3 for the PACF function as expected.

Finally, let’s use the Yule-Walker equation to estimate the coefficients:

rho, sigma = yule_walker(simulated_AR3_data, 3, method='mle')
print(f'rho: {-rho}')
print(f'sigma: {sigma}')

Novamente, as estimativas são bastante próximos dos valores reais.

Project-Forecasting the quarterly EPS for Johnson &Johnson

Now, let’s apply our knowledge of autoregressive processes in a project setting.

O objectivo é modelar os ganhos trimestrais por acção (EPS) da empresa Johnson&Johnson entre 1960 e 1980.

Primeiro, vamos ler o conjunto de dados:

import pandas as pddata = pd.read_csv('jj.csv')
data.head()

Agora, as cinco primeiras linhas não são muito úteis para nós. Vamos traçar todo o conjunto de dados para obter uma melhor representação visual.

plt.figure(figsize=); # Set dimensions for figure
plt.scatter(data, data)
plt.title('Quaterly EPS for Johnson & Johnson')
plt.ylabel('EPS per share ($)')
plt.xlabel('Date')
plt.xticks(rotation=90)
plt.grid(True)
plt.show()

Incrível! Agora podemos a tendência de aumento dos dados é clara. Embora isto possa ser um bom sinal para a empresa, não é bom em termos de modelagem de séries cronológicas, uma vez que significa que a série cronológica não está estacionária.o processo AR (p) funciona apenas para séries estacionárias.

portanto, devemos aplicar algumas transformações em nossos dados para torná-lo estacionário.

neste caso, terá a diferença de log. Isto é equivalente a pegar o log de cada valor, e subtrair o valor anterior.

# Take the log difference to make data stationarydata = np.log(data)
data = data.diff()
data = data.drop(data.index)
data.head()

Plotting the transformed time series:

plt.figure(figsize=); # Set dimensions for figure
plt.plot(data)
plt.title("Log Difference of Quaterly EPS for Johnson & Johnson")
plt.show()

Agora, parece que foi removida a tendência. No entanto, temos de ter a certeza de que a nossa série está estacionária antes da modelização com um processo AR(p).assim, utilizaremos o teste de Dicker-Fuller aumentado. Isto dar-nos-á a confiança estatística de que a nossa série cronológica é, de facto, estacionária.

ad_fuller_result = adfuller(data)
print(f'ADF Statistic: {ad_fuller_result}')
print(f'p-value: {ad_fuller_result}')

Desde que temos um grande negativo ADF estatística e p-valor menor que 0,05, podemos rejeitar a hipótese nula e dizer que a nossa série temporal é estacionária.

agora, vamos encontrar a ordem do processo, traçando o PACF:

plot_pacf(data);
plot_acf(data);

Como você pode ver, depois de gal 4, a PACF coeficientes não são significativos mais. Portanto, assumiremos um processo autoregressivo de ordem 4.

agora, vamos usar esta informação para estimar os coeficientes usando a equação de Yule-Walker:

# Try a AR(4) model
rho, sigma = yule_walker(data, 4)
print(f'rho: {-rho}')
print(f'sigma: {sigma}')

Therefore, the function is approximated as:

Note that this equation models the transformed series.

Conclusion

Congratulations! Agora você entende o que é um modelo autoregressivo, como reconhecer um processo autoregressivo, como determinar sua ordem, e como usá-lo para modelar uma série de tempo da vida real.

Afie as suas competências de análise de séries cronológicas e aprenda as melhores práticas para a análise de séries cronológicas em Python:

• Análise de séries cronológicas aplicadas em Python

Cheers 🍺