Proceso autorregresivo AR(p)
Contents
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn')
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from statsmodels.tsa.arima_process import ArmaProcess # MODELO TEORICO
def graficar_impulso_respuesta(fig, proceso, maxlag=18, **kwargs):
fig.add_trace(go.Bar(y=proceso.impulse_response(maxlag)), **kwargs)
def graficar_autocorrelacion(fig, proceso, maxlag=12, **kwargs):
rezagos = 1 + np.arange(maxlag)
fig.add_trace(go.Bar(x=rezagos, y=proceso.acf(maxlag+1)[1:]), **kwargs)
def graficar_autocorrelacion_parcial(fig, proceso, maxlag=12, **kwargs):
rezagos = 1 + np.arange(maxlag)
fig.add_trace(go.Bar(x=rezagos, y=proceso.pacf(maxlag+1)[1:]), **kwargs)
def graficar_simulacion(fig, proceso, nperiodos=120, **kwargs):
fig.add_trace(go.Scatter(y=proceso.generate_sample(nperiodos)), **kwargs)
def graficar_raices(fig, raices):
r, theta = np.abs(1/raices), np.angle(1/raices, True)
rmax = 1.0 if np.max(r) < 1.0 else np.maximum(r)
fig.add_trace(go.Scatterpolar(
r=r,
theta=theta,
mode = 'markers',
marker_size=14
))
fig.update_layout(
title='Raíces inversas del polinomio de rezagos',
polar={'angularaxis': {'thetaunit': 'radians', 'dtick': np.pi / 4},
'radialaxis': {'tickvals': [0.0, 1.0], 'range': [0, rmax]}}
)
opciones = dict(height=300, width=800, showlegend=False, margin=dict(l=40, r=20, t=40, b=20))
3.3. Proceso autorregresivo AR(p)#
Proceso autorregresivo de primer orden: AR(1)#
Sea \(\left\{\epsilon_t\right\}_{t=-\infty}^\infty\) un proceso ruido blanco. Se define el proceso AR(1) como:
Siempre que \(|\phi|<1\) podemos invertir el término \((1 - \phi\Lag)\)
Vemos por tanto que si \(|\phi|<1\) el proceso AR(1) puede escribirse como el proceso MA(\(\infty\))
Por lo que su valor esperado es:
y su varianza es
La representación MA(\(\infty\)) nos muestra que \(y_t\) depende de la perturbación presente \(\epsilon_{t}\) y de todas las pasadas \(\epsilon_{t-1}, \epsilon_{t-2}, \dots\), pero no depende de ninguna de las perturbaciones futuras \(\epsilon_{t+1}, \epsilon_{t+2}, \dots\).
Por ello, la covarianza de \(y_t\) con cualquier perturbación posterior \(\epsilon_{t+k}\) (con \(k>0\)) es cero.
Sabiendo que un proceso AR(1) es estacionario si \(|\phi|<1\), es fácil obtener sus momentos sin necesidad de obtener su representación MA(\(\infty\)).
En el caso de la media:
Restando la tercera línea de la primera, vemos que el proceso puede escribirse como un AR(1) para la desviación respecto a la media sin la constante:
Por ello, en adelante ocasionalmente asumiremos que \(c=0\) para simplificar el álgebra.
Para obtener su varianza elevamos al cuadrado la expresión anterior y tomamos su valor esperado
Para obtener su autocovarianza \(\gamma_j\), para \(j\geq 1\), escribimos
multiplicamos ambos lados por \(\tilde{y}_{t-j}\) y tomamos esperanza
Vemos que la función de autocorrelación es la solución de una ecuación en diferencia homogénea de primer orden, cuya solución es
Resumiendo los resultados que hemos obtenido
vemos que ninguno de estos momentos depende del tiempo \(t\), por lo que el proceso AR(1) es covarianza-estacionario siempre y cuando \(|\phi|<1\).
A partir de la representación MA(\(\infty\)) del proceso AR(1) con \(|\phi|<1\)
es fácil observar que su función de impulso respuesta
es idéntica a su función de autocorrelaciones.
modelo_ar1p = ArmaProcess.from_coeffs(arcoefs=[0.9])
fig = make_subplots(rows=1, cols=2, subplot_titles=('Simulación', 'Autocorrelación'))
graficar_simulacion(fig, modelo_ar1p, row=1, col=1)
graficar_autocorrelacion(fig, modelo_ar1p, row=1, col=2)
fig.update_layout(**opciones)
fig.show()
modelo_ar1n = ArmaProcess.from_coeffs(arcoefs=[-0.9])
fig = make_subplots(rows=1, cols=2, subplot_titles=('Simulación', 'Autocorrelación'))
graficar_simulacion(fig, modelo_ar1n, row=1, col=1)
graficar_autocorrelacion(fig, modelo_ar1n, row=1, col=2)
fig.update_layout(**opciones)
fig.show()
El proceso AR(p)#
Es fácil extender el proceso AR(1) para incluir más rezagos. El proceso AR(p) es
El proceso AR(p) es una ecuación en diferencia de orden \(p\). Esta ecuación es estable si y solo si las raíces del polinomio \(1 - \phi_1z^1 -\dots - \phi_pz^p\) están todas fuera del círculo unitario.
Si el proceso es estable, resolvemos para \(y_t\)
Su valor esperado es
Similar a lo que obtuvimos para el proceso AR(1), podemos escribir el proceso AR(p) en términos de desviación de la media \(\tilde{y}\equiv y-\mu\).
Para obtener su varianza y autocovarianzas multiplicamos la expresión anterior por \(\tilde{y}_{t-j}\), con \(j\geq0\), y calculamos el valor esperado
Si dividimos la última línea entre la varianza \(\gamma_0\) obtenemos las
Important
Ecuaciones Yule-Walker
Esta es la misma ecuación en diferencia que el proceso original, por lo que en principio se puede resolver con los métodos convencionales, una vez que tengamos \(p\) valores iniciales \(\rho_0, \rho_1, \dots,\rho_{p-1}\).
En general, no es tan sencillo obtener despejar los valores de las autocorrelaciones \(\rho_j\).
Para obtener la función de impulso respuesta, podríamos partir de la forma
pero esto requiere que obtengamos la forma explícita del polinomio de rezagos
Ahora bien, reconociendo que un proceso AR(p) es una ecuación en diferencia de orden \(p\), encontramos que
donde \(\lambda_j\) son las raíces del polinomio característico \(\lambda^p - \phi_1 \lambda^{p-1} -\dots - \phi_p\) (ver tema 2, p.19-20).
Para un proceso AR(p) estacionario, sabemos que todas las raíces \(\lambda_j\) están dentro del círculo unitario.
Por ello, a partir de
sabemos que la función de impulso respuesta converge a cero en el largo plazo.
La forma de la función depende especialmente del valor \(\lambda_j\) más grande:
Si es positivo, decae geométricamente,
Si es negativo, decae alternando de signo,
Si es complejo, decae oscilando periódicamente (ver tema 2, p.25).
modelo_ar2 = ArmaProcess.from_coeffs(arcoefs=[0.9, -0.625])
fig = make_subplots(rows=1, cols=2, subplot_titles=('Simulación', 'Autocorrelación'))
graficar_simulacion(fig, modelo_ar2, row=1, col=1)
graficar_autocorrelacion(fig, modelo_ar2, row=1, col=2)
fig.update_layout(**opciones)
fig.show()
Con las ecuaciones Yule-Walker
encontramos
Las demás autocorrelaciones las encontramos con
La ecuación característica es
con raíces
por lo que el proceso es estacionario:
fig = go.Figure()
graficar_raices(fig, modelo_ar2.arroots)
fig.update_layout(height=400, width=500, showlegend=False)
fig.show(**(opciones | dict(width=450)))
Usando las fórmulas de dinámica del ajuste, encontramos su función impulso respuesta
la cual converge a cero, oscilando periódicamente conforme \(j\to\infty\).
fig = go.Figure()
graficar_impulso_respuesta(fig, modelo_ar2, maxlag=24)
fig.update_layout(**(opciones | dict(width=450)))
fig.show()
y = ArmaProcess.from_coeffs(arcoefs=[0.9])
z = ArmaProcess.from_coeffs(arcoefs=[0.5, 0.4])
fig = make_subplots(rows=1, cols=2, subplot_titles=('Autocorrelación del AR(1)','Autocorrelación del AR(2)'))
graficar_autocorrelacion(fig, y, row=1, col=1)
graficar_autocorrelacion(fig, z, row=1, col=2)
fig.update_layout(**opciones)
fig.show()
Este caso ilustra que es sumamente difícil identificar el orden \(p\) de un proceso AR(p) a partir de su autocorrelograma.
Para resolver este problema, a continuación estudiaremos la autocorrelación parcial.
Autocorrelación parcial#
La autocorrelación parcial mide la correlación restante entre \(y_t\) y \(y_{t-k}\) una vez que se han eliminado la influencia de \(y_{t-1}, y_{t-2},\dots, y_{t-k+1}\).
Es decir, las primeros \(m\) autocorrelaciones parciales vienen de
Para encontrar el valor de \(a^{(k)}_k\) basta con resolver
En adelante, denotaremos la \(k\)-ésima correlación parcial por \(\varphi(k) \equiv a_k^{(k)}\)
Comparando las ecuaciones del proceso AR(p) y de la autocorrelación parcial \(k\):
vemos que
si \(k=p\), entonces \(\varphi_k = \phi_p\)
si \(k>p\), entonces \(\varphi_k = 0\)
si \(k=1\), entonces \(\varphi_1 = \rho_1\)
Consideremos de nuevo estos procesos autorregresivos:
fig = make_subplots(rows=1, cols=2, subplot_titles=('Autocorrelación parcial del AR(1)','Autocorrelación parcial del AR(2)'))
graficar_autocorrelacion_parcial(fig, y, row=1, col=1)
graficar_autocorrelacion_parcial(fig, z, row=1, col=2)
fig.update_layout(**opciones)
fig.show()
Ahora es muy sencillo identificar el orden \(p\) de los proceso AR.
Para encontrar la segunda autocorrelación parcial, resolvemos
de donde \(\varphi_2 = \frac{\rho_2 - \rho_1^2}{1-\rho_1^2}\).
Para el proceso AR(1) sabemos que \(\rho_k = \phi^k\), con lo que comprobamos que \(\varphi_2 = \frac{\phi^2 - \phi^2}{1-\phi^2} = 0\).
En un ejemplo anterior encontramos que para un proceso AR(2) se cumple
Al sustituir en la expresión para \(\varphi_2\) comprobamos que