En este tutorial, vamos a cubrir el tema de las series de tiempo de modelado con los procesos autorregresivos.

Este artículo cubrirá los siguientes elementos clave en el análisis de series temporales:

• proceso autorregresivo
• Yule-Walker ecuación
• la estacionariedad
• Aumentada Dicker-Fuller prueba

asegúrese de tener una Jupyter notebook listo para seguir adelante. El código y el conjunto de datos están disponibles aquí.

¡Comencemos!

Aprenda a trabajar con modelos más complejos como SARIMAX, VARMAX y a aplicar modelos de aprendizaje profundo (LSTM, CNN, ResNet, LSTM autorregresivo) para el análisis de series temporales con Análisis de Series Temporales Aplicadas en Python.

Proceso autorregresivo

Un modelo autorregresivo utiliza una combinación lineal de valores pasados del objetivo para hacer pronósticos. Por supuesto, la regresión se hace contra el objetivo en sí. Matemáticamente, un AR(p), el modelo se expresa como:

Donde:

• p: es el orden
• c: es una constante
• epsilon: el modelo de ruido

AR(p) es increíblemente flexible y puede modelar muchos tipos diferentes de patrones de series temporales. Esto se visualiza fácilmente cuando simulamos procesos autorregresivos.

Por lo general, los modelos autorregresivos se aplican solo a series temporales estacionarias. Esto limita el rango de los parámetros phi.

Por ejemplo, un modelo AR(1) restringirá la phi entre -1 y 1. Esas restricciones se vuelven más complejas a medida que aumenta el orden del modelo, pero se consideran automáticamente al modelar en Python.

Simulación de un proceso AR(2)

Simulemos un proceso AR(2) en Python.

Comenzamos importando algunas bibliotecas. No todos se utilizarán para la simulación, pero serán necesarios para el resto de este 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 la biblioteca ArmaProcess para simular la serie temporal. Requiere que definamos nuestros parámetros.

Simularemos el siguiente proceso:

Ya que estamos tratando con un modelo autorregresivo de orden 2, tenemos que definir el coeficiente de lag 0, 1 y 2.

Además, cancelaremos el efecto de un proceso de media móvil.

Finalmente, generaremos 10 000 puntos de datos.

En el código:

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

podemos trazar la serie de tiempo:

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);

Usted puede ver que el coeficiente de descomposición lenta. Esto significa que es poco probable que sea un proceso de media móvil y sugiere que la serie de tiempo probablemente se pueda modelar con un proceso autorregresivo (lo que tiene sentido ya que lo que estamos simulando).

Para asegurarnos de que esto es correcto, vamos a trazar la gráfica de autocorrelación parcial:

plot_pacf(simulated_AR2_data);

Como puede ver los coeficientes no son significativos después de lag 2. Por lo tanto, la gráfica de autocorrelación parcial es útil para determinar el orden de un proceso AR(p).

También puede comprobar los valores de cada coeficiente ejecutando:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

Ahora, en un entorno de proyecto real, puede ser fácil encontrar el orden de un proceso AR(p), pero necesitamos encontrar una manera de estimar los coeficientes phi.

Para ello, utilizamos la ecuación Yule-Walker. Estas ecuaciones nos permiten estimar los coeficientes de un modelo AR(p), dado que conocemos el orden.

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

Como puede ver, el Yule-Walker ecuación hizo un trabajo decente en la estimación de nuestro coeficientes y se puso muy cerca de 0.33 y 0.5.

Simulación de un proceso AR(3)

Ahora, simulemos un proceso AR(3). Específicamente, simularemos:

de manera Similar a lo que se hizo anteriormente, vamos a definir nuestro coeficientes y generar 10 000 puntos de datos:

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

a Continuación, se puede visualizar la serie de tiempo:

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

Y usted debería 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}')

de Nuevo, las estimaciones son bastante cercanas a los valores reales.

Proyecto: Previsión del EPS trimestral para Johnson& Johnson

Ahora, apliquemos nuestro conocimiento de los procesos autorregresivos en un entorno de proyecto.

El objetivo es modelar las ganancias trimestrales por acción (EPS) de la empresa Johnson&Johnson entre 1960 y 1980.

en Primer lugar, vamos a leer el conjunto de datos:

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

Ahora, las cinco primeras filas no son muy útiles para nosotros. Vamos a trazar todo el conjunto de datos para obtener una mejor representación 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()

¡Impresionante! Ahora podemos ver que hay una clara tendencia al alza en los datos. Si bien esto puede ser una buena señal para la empresa, no es bueno en términos de modelado de series temporales, ya que significa que la serie temporal no es estacionaria.

Como se mencionó anteriormente, el proceso AR(p) funciona solo para series estacionarias.

Por lo tanto, debemos aplicar algunas transformaciones a nuestros datos para que sean estacionarios.

En este caso, tomará la diferencia de registro. Esto equivale a tomar el registro de cada valor y restar el valor anterior.

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

Trazar la serie temporal transformada:

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

Ahora, parece que hemos eliminado la tendencia. Sin embargo, tenemos que asegurarnos de que nuestra serie es estacionaria antes de modelar con un proceso AR(p).

Por lo tanto, usaremos la prueba de Dicker-Fuller aumentada. Esto nos dará la confianza estadística de que nuestra serie temporal es realmente estacionaria.

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

Ya que tenemos un gran negativo ADF y estadística p-valor menor que 0,05, podemos rechazar la hipótesis nula y afirmar que nuestra serie de tiempo es estacionaria.

Ahora, vamos a encontrar el orden del proceso trazando el PACF:

plot_pacf(data);
plot_acf(data);

Como puede ver, después de gal 4, el FAP coeficientes no son significativos ya. Por lo tanto, asumiremos un proceso autorregresivo de orden 4.

Ahora, usaremos esta información para estimar los coeficientes utilizando la ecuación 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! Ahora entiendes lo que es un modelo autorregresivo, cómo reconocer un proceso autorregresivo, cómo determinar su orden y cómo usarlo para modelar una serie temporal de la vida real.

Mejore sus habilidades de análisis de series temporales y aprenda las últimas prácticas recomendadas para el análisis de series temporales en Python:

• Análisis de series temporales aplicado en Python

Saludos