Manuale di Gretl: Gnu Regression, Econometrics and Time-series Library
Indietro | Capitolo 10. Costrutti loop | Avanti

# Esempi di loop

## Esempio di procedura Monte Carlo

Un semplice esempio di uso della modalità "progressiva" per realizzare una procedura Monte Carlo è mostrato in Esempio 10-1.

Esempio 10-1. Un semplice loop di tipo Monte Carlo

    	  nulldata 50
    	  seed 547
    	  genr x = 100 * uniform()
    	  # Apre un loop "progressivo", da ripetere 100 volte
    	  loop 100 --progressive
    	     genr u = 10 * normal()
    	     # Costruisce la variabile dipendente
    	     genr y = 10*x + u
    	     # Esegue la regressione OLS
    	     ols y const x
    	     # Definisce variabili per i coefficienti e R-quadro
    	     genr a = coeff(const)
    	     genr b = coeff(x)
    	     genr r2 = $rsq
    	     # Mostra le statistiche su queste variabili
    	     print a b r2
    	     # Salva i coefficienti in un file
    	     store coeffs.gdt a b
    	  endloop

Questo loop mostrerà le statistiche di riepilogo per le stime di "a", "b" e R2 lungo le 100 iterazioni. Dopo aver eseguito il loop, è possibile aprire con `gretl` il file `coeffs.gdt`, che contiene le stime dei singoli coefficienti durante tutte le iterazioni, ed esaminare nel dettaglio la distribuzione di frequenza delle stime.

Il comando nulldata è utile per le procedure Monte Carlo: invece di aprire un "vero" dataset, `nulldata 50` (ad esempio) apre un finto dataset da 50 osservazioni, che contiene solo la costante e una variabile indice. Successivamente è possibile aggiungervi variabili usando il comando `genr`.

Si veda il comando set per informazioni su come generare numeri pseudo-casuali in modo ripetibile.

## Minimi quadrati iterati

L'Esempio 10-2 usa un loop di tipo "while" per replicare la stima di una funzione di consumo non lineare nella forma presentata in Greene (2000, Esempio 11.3). Questo script è compreso nella distribuzione di `gretl` con il nome `greene11_3.inp`; è possibile aprirlo usando il comando del menù "File, Apri file comandi, File di esempio, Greene...".

L'opzione `--print-final` per il comando `ols` fa sì che non vengano mostrati i risultati della regressione per ogni iterazione, ma solo quelli dell'ultima iterazione del loop.

Esempio 10-2. Funzione di consumo non lineare

    	  open greene11_3.gdt
    	  # Esegue la regressione OLS iniziale
    	  ols C 0 Y
    	  genr essbak = $ess
    	  genr essdiff = 1
    	  genr beta = coeff(Y)
    	  genr gamma = 1
    	  # Itera OLS finché la somma dei quadrati degli errori converge
    	  loop while essdiff > .00001
    	     # Genera le variabili linearizzate
    	     genr C0 = C + gamma * beta * Y^gamma * log(Y)
    	     genr x1 = Y^gamma
    	     genr x2 = beta * Y^gamma * log(Y)
    	     # Esegue la regressione OLS
    	     ols C0 0 x1 x2 --print-final --no-df-corr --vcv
    	     genr beta = coeff(x1)
    	     genr gamma = coeff(x2)
    	     genr ess = $ess
    	     genr essdiff = abs(ess - essbak)/essbak
    	     genr essbak = ess
    	  endloop
    	  # Mostra le stime dei parametri usando i "nomi giusti"
    	  noecho
    	  printf "alfa = %g\n", coeff(0)
    	  printf "beta  = %g\n", beta
    	  printf "gamma = %g\n", gamma

L'Esempio 10-3 (gentilmente fornito da Riccardo "Jack" Lucchetti dell'Università di Ancona) mostra come sia possibile usare un loop per stimare un modello ARMA usando la regressione "prodotto esterno del gradiente" (OPG - "outer product of the gradient") discussa da Davidson e MacKinnon nel loro Estimation and Inference in Econometrics.

Esempio 10-3. ARMA 1, 1

              open armaloop.gdt

              genr c = 0
              genr a = 0.1
              genr m = 0.1

              genr e = const * 0.0
              genr de_c = e
              genr de_a = e
              genr de_m = e

              genr crit = 1
              loop while crit > 1.0e-9

                 # Errori di previsione "one-step"
                 genr e = y - c - a*y(-1) - m*e(-1)

                 # Log-verosimiglianza
                 genr loglik = -0.5 * sum(e^2)
                 print loglik

                 # Derivate parziali degli errori di previsione rispetto a c, a e m
                 genr de_c = -1 - m * de_c(-1)
                 genr de_a = -y(-1) -m * de_a(-1)
                 genr de_m = -e(-1) -m * de_m(-1)

                 # Derivate parziali di l rispetto a c, a e m
                 genr sc_c = -de_c * e
                 genr sc_a = -de_a * e
                 genr sc_m = -de_m * e

                 # Regressione OPG
                 ols const sc_c sc_a sc_m --print-final --no-df-corr --vcv

                 # Aggiorna i parametri
                 genr dc = coeff(sc_c)
                 genr c = c + dc
                 genr da = coeff(sc_a)
                 genr a = a + da
                 genr dm = coeff(sc_m)
                 genr m = m + dm

                 printf "  constant        = %.8g (gradient = %#.6g)\n", c, dc
                 printf "  ar1 coefficient = %.8g (gradient = %#.6g)\n", a, da
                 printf "  ma1 coefficient = %.8g (gradient = %#.6g)\n", m, dm

                 genr crit = $T - $ess
                 print crit
              endloop

              genr se_c = stderr(sc_c)
              genr se_a = stderr(sc_a)
              genr se_m = stderr(sc_m)

              noecho
              print "
              printf "constant = %.8g (se = %#.6g, t = %.4f)\n", c, se_c, c/se_c
              printf "ar1 term = %.8g (se = %#.6g, t = %.4f)\n", a, se_a, a/se_a
              printf "ma1 term = %.8g (se = %#.6g, t = %.4f)\n", m, se_m, m/se_m

## Esempi di loop con indice

L'Esempio 10-4 mostra un loop con indice, in cui il comando `smpl` contiene la variabile indice `i`. Si supponga di avere un dataset di tipo panel, con osservazioni su alcuni ospedali per gli anni dal 1991 al 2000 (dove l'anno dell'osservazione è indicato da una variabile chiamata `anno`). Ad ogni iterazione, restringiamo il campione a un certo anno e calcoliamo statistiche di riepilogo sulla dimensione longitudinale (cross-section) per le variabili da 1 a 4.

Esempio 10-4. Statistiche panel

    	  open ospedali.gdt
    	  loop i=1991..2000
    	    smpl (annor=i) --restrict --replace
    	    summary 1 2 3 4
    	  endloop

L'Esempio 10-5 illustra un loop indicizzato per sostituire stringhe.

Esempio 10-5. Sostituzione di stringhe

    	  open bea.dat
    	  loop i=1987..2001
    	    genr V = COMP$i
    	    genr TC = GOC$i - PBT$i
    	    genr C = TC - V
    	    ols PBT$i const TC V
    	  endloop

Alla prima iterazione, la variabile `V` verrà impostata a `COMP1987` e la variabile dipendente per il comando `ols` sarà `PBT1987`. All'iterazione successiva, `V` verrà ridefinita come `COMP1988` e la variabile dipendente della regressione sarà `PBT1988`, e così via.

Indietro | Partenza | Avanti
La modalità "progressiva" | Risali | Funzioni definite dall'utente