########################################################################## # Lezione 5: Laboratorio di Analisi delle Serie Storiche con R (Parte 5) ########################################################################## # # Indice: # * i processi a media mobile # * invertibilità di un processo # * i processi autoregressivi # * il concetto di stazionarietà # * il processo random walk # ########################################################################## rm(list = ls()) # Possiamo simulare ogni processo nella classe dei processi ARIMA(p, i, q) # usando il comando 'arima.sim' ?arima.sim ##### I PROCESSI A MEDIA MOBILE ##### # Iniziamo con i processi MA(1) # simuliamo un processo (invertibile) con coefficiente positivo n = 1000 Y1 = arima.sim(n=n, model = list(ma = c(0.8)), sd = sqrt(1), rand.gen = rnorm) # e con coefficiente negativo Y2 = arima.sim(n=n, model = list(ma= c(-0.8)), sd = sqrt(1), rand.gen = rnorm) par(mfrow=c(2,1)) ts.plot(Y1, main = 'coeff. positivo') ts.plot(Y2, main = 'coeff. negativo') # confrontiamo le acf dei due processi acf(Y1, main = 'coeff. positivo') acf(Y2, main = 'coeff. negativo') # confrontiamo le pacf dei due processi pacf(Y1, main = 'coeff. positivo') pacf(Y2, main = 'coeff. negativo') # possiamo ottenere gli stessi processi simulandoli senza il comando 'arima.sim' # inizializziamo due vettori Ysim1 e Ysim2 Ysim1 = c() Ysim2 = c() # fissiamo la prima osservazione e generiamo la componente di errore Ysim1[1] = 0 Ysim2[1] = 0 shock = rnorm(n, 0, 1) for (i in 2:n){ Ysim1[i] = 0.8 * shock[i-1] + shock[i] Ysim2[i] = -0.8 * shock[i-1] + shock[i] } par(mfrow=c(2,1)) ts.plot(Ysim1, main = 'coeff. positivo') ts.plot(Ysim2, main = 'coeff. negativo') # confrontiamo le acf dei due processi acf(Ysim1, main = 'coeff. positivo') acf(Ysim2, main = 'coeff. negativo') # confrontiamo le pacf dei due processi pacf(Ysim1, main = 'coeff. positivo') pacf(Ysim2, main = 'coeff. negativo') # Approfondiamo ora il concetto di invertibilità di un processo: # per ogni rappresentazione MA(1) invertibile esiste una rappresentazione # MA(1) non invertibile che possiede la stessa ACF. theta = .8 theta.star = 1/theta Y3 = arima.sim(n=n, list(ma= theta.star), sd = sqrt(1)) Y4 = arima.sim(n=n, list(ma= -theta.star), sd = sqrt(1)) # confrontiamo le acf dei due processi acf(Y1, main='Processo invertibile') # processo invertivbile acf(Y3, main='Processo analogo non invertibile') # processo non invertibile # confrontiamo le pacf dei due processi pacf(Y1, main='Processo invertibile') # processo invertivbile pacf(Y3, main='Processo analogo non invertibile') # processo non invertibile # I due processi hanno identiche proprietà e dunque sarebbe impossibile # discriminarli a partire da una serie storica. Tale problema di identificazione # viene risolto appunto vincolando il parametro nell'intervallo (-1,+1). # Il vincolo permette anche di riscrivere il processo come un AR(1) stazionario... # Passiamo ai processi MA(2)... possiamo avere quattro casi: # 1. coefficienti entrambi positivi Y5 = arima.sim(n=n, list(ma= c(0.6, 0.3)), sd = sqrt(1)) # 2. coefficienti entrambi negativi Y6 = arima.sim(n=n, list(ma= c(-0.6, -0.3)), sd = sqrt(1)) # 3. coefficienti con segni alterni Y7 = arima.sim(n=n, list(ma= c(0.6, -0.3)), sd = sqrt(1)) # 4. coefficienti con segni alterni Y8 = arima.sim(n=n, list(ma= c(-0.6, 0.3)), sd = sqrt(1)) par(mfrow=c(2,2)) ts.plot(Y5, main = 'coeff. positivi') ts.plot(Y6, main = 'coeff. negativi') ts.plot(Y7, main = 'coeff. alterni (+, -)') ts.plot(Y8, main = 'coeff. alterni (-, +)') # confrontiamo le acf dei quattro processi acf(Y5, main = 'coeff. positivi') acf(Y6, main = 'coeff. negativi') acf(Y7, main = 'coeff. alterni (+, -)') acf(Y8, main = 'coeff. alterni (-, +)') # confrontiamo le pacf dei quattro processi pacf(Y5, main = 'coeff. positivi') pacf(Y6, main = 'coeff. negativi') pacf(Y7, main = 'coeff. alterni (+, -)') pacf(Y8, main = 'coeff. alterni (-, +)') # possiamo ottenere gli stessi processi simulandoli senza il comando 'arima.sim' # inizializziamo i vettori che conterranno i dati # NOTA! Adesso è necessario fissare la prima e anche la seconda osservazione Ysim5 = c(); Ysim5[1] = 0; Ysim5[2] = 0; Ysim6 = c(); Ysim6[1] = 0; Ysim6[2] = 0; Ysim7 = c(); Ysim7[1] = 0; Ysim7[2] = 0; Ysim8 = c(); Ysim8[1] = 0; Ysim8[2] = 0; for (i in 3:n){ Ysim5[i] = 0.6 * shock[i-1] + 0.3 * shock[i-2] + shock[i] Ysim6[i] = -0.6 * shock[i-1] - 0.3 * shock[i-2] + shock[i] Ysim7[i] = 0.6 * shock[i-1] - 0.3 * shock[i-2] + shock[i] Ysim8[i] = -0.6 * shock[i-1] + 0.3 * shock[i-2] + shock[i] } par(mfrow=c(2,2)) ts.plot(Ysim5, main = 'coeff. positivi') ts.plot(Ysim6, main = 'coeff. negativi') ts.plot(Ysim7, main = 'coeff. alterni (+, -)') ts.plot(Ysim8, main = 'coeff. alterni (-, +)') #******************************************************************* ##### I PROCESSI AUTOREGRESSIVI ##### # Iniziamo con i processi AR(1) #******************************************************************* # Come per i processi MA, utilizziamo il comando 'arima.sim' Y1 = arima.sim(n=n, list(ar= 0.9), sd = sqrt(1)) Y1.short = arima.sim(n=n, list(ar= 0.2), sd = sqrt(1)) # processo a memoria breve # e con coefficiente negativo Y2 = arima.sim(n=n, list(ar= -0.9), sd = sqrt(1)) # vediamo l'effetto del coefficiente sulla serie par(mfrow=c(2,1)) ts.plot(Y1, main = 'coeff. 0.9') ts.plot(Y1.short, main = 'coeff. 0.2') # vediamo l'effetto del coefficiente sulla ACF acf(Y1, main = 'coeff. 0.9') acf(Y1.short, main = 'coeff. 0.2') # confrontiamo le acf dei due processi: # uno con coefficiente positivo e l'altro con coefficiente negativo acf(Y1, main = 'coeff. positivo') acf(Y2, main = 'coeff. negativo') # confrontiamo le pacf dei due processi pacf(Y1, main = 'coeff. positivo') pacf(Y2, main = 'coeff. positivo') # possiamo ottenere gli stessi processi simulandoli senza il comando 'arima.sim' # inizializziamo i vettori che conterranno i dati Ysim1 = c(); Ysim1[1] = 0 Ysim2 = c(); Ysim2[1] = 0 for (i in 2:n){ Ysim1[i] = 0.9 * Ysim1[i-1] + rnorm(1, 0, 1) Ysim2[i] = -0.9 * Ysim2[i-1] + rnorm(1, 0, 1) } par(mfrow=c(2,1)) ts.plot(Ysim1, main = 'coeff. positivo') ts.plot(Ysim2, main = 'coeff. negativo') # confrontiamo le acf dei due processi acf(Ysim1, main = 'coeff. positivo') acf(Ysim2, main = 'coeff. negativo') # confrontiamo le pacf dei due processi pacf(Ysim1, main = 'coeff. positivo') pacf(Ysim2, main = 'coeff. negativo') # La stazionarietà è una caratteristica fondamentale che desideriamo da un processo AR: # se il processo non è stazionario diventa impossibile studiarne le proprietà # Simuliamo un processo AR(1) non stazionario con coefficiente 1.1 Y3 = c(); Y3[1]=0 for (i in 2:n){ Y3[i] = 1.1 * Y3[i-1] + rnorm(1, 0, 1) } par(mfrow=c(1,1)) ts.plot(Y3) # il processo esplode: esso diverge a +/- infinito all'aumentare di n # esiste un particolare tipo di processo non stazionario chiamato Random Walk in cui # il coefficiente che determina l'impatto di ogni osservazione sulla successiva è esattamente 1 Y4 = c(); Y4[1]=0 for (i in 2:n){ Y4[i] = 1 * Y4[i-1] + rnorm(1, 0, 1) } par(mfrow=c(1,1)) ts.plot(Y4) # confrontiamo le acf di un processo stazionario e un Random Walk par(mfrow=c(2,1)) acf(Y1, main='Processo stazionario') acf(Y4, main='Processo Random Walk') # Introduciamo il test di Dickey-Fuller (adf.test): l'ipotesi nulla (H0) è che il processo è un Random Walk (default) # NOTA! Il comando 'adf.test' da la possibilità di scegliere l'ipotesi alternativa (H1): library(tseries) adf.test(Y4, alternative = "stationary") # Attenzione! Il test di D-F testa solo la non stazionarietà in covarianza (radice unitaria) # Passiamo ai processi AR(2)... possiamo avere quattro casi: # NOTA! Vedi triangolo stazionarietà # 1. coefficienti con segni alterni (-, +) Y5 = arima.sim(n=n, list(ar= c(-0.6, 0.3)), sd = sqrt(1)) # 2. coefficienti entrambi positivi Y6 = arima.sim(n=n, list(ar= c(0.6, 0.3)), sd = sqrt(1)) # 3. coefficienti entrambi negativi e radici complesse Y7 = arima.sim(n=n, list(ar= c(-1.6, -0.8)), sd = sqrt(1)) # 4. coefficienti con segni alterni (+, -) e radici complesse Y8 = arima.sim(n=n, list(ar= c(1.6, -0.8)), sd = sqrt(1)) par(mfrow=c(2,2)) ts.plot(Y5, main = 'segni alterni (-, +)') ts.plot(Y6, main = 'entrambi positivi') ts.plot(Y7, main = 'negativi e radici compl.') ts.plot(Y8, main = 'alterni (+, -) e radici compl.') # confrontiamo le acf dei quattro processi acf(Y5, main = 'segni alterni (-, +)') acf(Y6, main = 'entrambi positivi') acf(Y7, main = 'negativi e radici compl.') acf(Y8, main = 'alterni (+, -) e radici compl.') # confrontiamo le pacf dei quattro processi pacf(Y5, main = 'segni alterni (-, +)') pacf(Y6, main = 'entrambi positivi') pacf(Y7, main = 'negativi e radici compl.') pacf(Y8, main = 'alterni (+, -) e radici compl.') # possiamo ottenere gli stessi processi simulandoli senza il comando 'arima.sim' Ysim5 = c(); Ysim5[1] = 0; Ysim5[2] = 0; Ysim6 = c(); Ysim6[1] = 0; Ysim6[2] = 0; Ysim7 = c(); Ysim7[1] = 0; Ysim7[2] = 0; Ysim8 = c(); Ysim8[1] = 0; Ysim8[2] = 0; for (i in 3:n){ Ysim5[i] = -0.6 * Ysim5[i-1] + 0.3 * Ysim5[i-2] + rnorm(1, 0, 1) Ysim6[i] = 0.6 * Ysim6[i-1] + 0.3 * Ysim6[i-2] + rnorm(1, 0, 1) Ysim7[i] = -1.6 * Ysim7[i-1] - 0.8 * Ysim7[i-2] + rnorm(1, 0, 1) Ysim8[i] = 1.6 * Ysim8[i-1] - 0.8 * Ysim8[i-2] + rnorm(1, 0, 1) } par(mfrow=c(2,2)) ts.plot(Ysim5, main = 'segni alterni (-, +)') ts.plot(Ysim6, main = 'entrambi positivi') ts.plot(Ysim7, main = 'negativi e radici compl.') ts.plot(Ysim8, main = 'alterni (+, -) e radici compl.') ##### ESEMPI EMPIRICI DI PROCESSI AR ##### library(tseries) data(NelPlo) ?NelPlo # Consideriamo la serie storica dell'indice dei prezzi al consumo dal 1860 al 1988 (frequenza annuale) par(mfrow=c(3,1)) plot(cpi) acf(cpi) # ci fa pensare ad un processo autoregressivo molto persistente pacf(cpi) # Come potrebbe essere l'analogo processo simulato? Provate voi!!! n = length(cpi) YsimSpec = c() #... # for (i in ??:n){ # YsimSpec[i] = ... # } ts.plot(YsimSpec) acf(YsimSpec) pacf(YsimSpec) # Un altro esempio plot(unemp) acf(unemp) # Potrebbe essere un AR(2) con radici complesse pacf(unemp) # con segni alterni (+, -) come il caso Y8