L'AMBIENTE IML

Sas è un ambiente molto potente per l'analisi dei dati. L'analisi avviene applicando procedure, nel nostro caso statistiche, che però non mettono a disposizione alcun strumento per operazioni di tipo algebrico. Questi tipi di strumenti risultano determimanti quando si vogliono costruire dei programmi personalizzati (ad esempio le macro ma non solo) e quando si conducono analisi non standard cioè non previste da alcuna procedura Sas.

L'ambiente IML (Interactive matrix language) permette a Sas di eseguire qualsiasi operazioni matematico-algebrica sui dati. L'ambiente si realizza attraverso la  Proc iml all'interno della quale si possono sfruttare le potenzialità di questo ambiente. 

Interfacciare data-set Sas con IML

La situazione tipica è quella in cui abbiamo disposizione un data-set e vogliamo eseguire delle particolari operazioni su di  esso per avere  come output  un data-set trasformato o semplicemente per svolgenere operazioni algebriche. Qui vedremo un modo semplice per interfacciare sas/base con sas/iml anche se ce ne sono molti altri (vedere l'ambiente iml sull'help in linea). Nel seguente esempio si leggono due dataset e banalmente si esegue la moltiplicazione tra le due matrici. Il risultato viene trasferito in un nuovo data-set

data prv;
infile"H:\datisas\tt.txt" firstobs=2;                             /*primo dataset      prv*/
input a b c d e f;run;
data vett;
infile "H:\datisas\w.txt" firstobs=2;                           /*secondo dataset  vett*/
input w1 w2 w3;run;

/*entro nell'ambiente iml*/
proc iml;
use prv;                                                  /*rendo attivo il data set prv nell'ambiente*/
read all var _num_ into x; print x;      /*leggo tutte le variabili di tipo numerico e visualizzo la matrice*/
use vett;                                                 /*rendo attivo il data set vett nell'ambiente*/
read all var _num_ into y;print y;       /*leggo tutte le variabili di tipo numerico e visualizzo la matrice*/
w=y*x;                                                 /*moltiplicazione tramatrici (dimensionalità rispettate ovviamente)*/
create re from w;                                  /*creo un data set nuovo di nome re*/
append from w;                                    /*attacco la matrice di mio interesse al data set creato*/
quit;                                                     /*esco dall'ambiente iml*/
proc print data=re;run;                      /*visualizzo il nuovo data-set*/

Come si vede nell'esempio i comandi qui utilizzati per interfacciare il data-set con l'ambiente iml sono:

use dataset rende attivo il data-set nell'ambiente iml
read ... legge le variabili all'interno del dataset (si può specificare di leggere solo le numeriche o solo quelle a carattere o solo certe variabili o solo determinate osservazioni)
create  x from matrice crea un nuovo data-set x con i dati di matrice
append from matrice scrive il data-set x dalla matrice

Questo è un semplice modo per interfacciare i due ambienti. Ovviamente ce ne sono altri (vedere l'help in linea).

Funzioni comandi sintassi...

Le seguenti tabelle illustrano alcune funzioni e comandi tipici dell'ambiente IML (lettera maiuscola indica una matrice, minuscola indica un vettore o uno scalare).        

Operazioni algebriche
 X=A+B    somma di matrici
 X=A-B   sottrazione di matrici
 X=A*B   prodotto di matrici
 X=A`      traspone la matrice A (`=carattere ascii 96) 
 X= A#b      matrice A per scalare b
 X=A/b  matrice A diviso scalare b
Funzioni algebriche
 x=vecdiag(A)  vettore che contiene gli elementi diagonali di A
 x= sum(A)  somma di tutti gli elementi della matrice
 x= ssq(A) somma al quadrato di tutti gli elementi della matrice
 x=trace(A)  traccia della matrice
 x=eigval(A)  vettore con gli autovalori della matrice
   
   
   
   
   
   
Generazione matrici/vettori e riferimenti a matrici/vettori
 x={1 2 3 4 5 6}  vettore riga 1*6
 x={1,2,3,4,5,6}  vettore colonna 6*1
 X= {1 2 3,4 5 6}   matrice 2*3
 X=j(n,k,c)  matrice di dimensione n k  di costanti c
x= diag({1 2 3})    matrice diagonale 3*3 con 1 2 3 sulla diagonale
 x= 1:5    vettore riga 1 2 3 4 5
 x= 4:6`   vettore colonna 4 5 6 nota il simbolo `  (codice ascii 96)
 s= do(x,y,z)      vettore riga con una serie che inizia da x finisce a y con passo z
 x=a||b  concateno matrici a e b nel senso orizzontale
 x=a//b  concateno matrici a e b nel senso verticale
 x=a[i,j]    elemento (i,j) della matrice
 x=a[,j]     vettore colonna j della matrice
 x=a[i,]     vettore riga i della matrice
Funzioni su matrici
 x=det(A)   determinante della matrice
 x=nrow(A)   numero di righe della matrice
 x=ncol(A)   numero di colonne della matrice
 X= inv(A)      inversa della matrice
 X= i(n)   matrice identità di ordine n
 x=max(A)      elemento max della matrice
 x=min(A)      elemento min della matrice
  x=all(A) 1 se tutti gli elementi della matrice sono diversi da zero altrimenti produce 0
 x=any(A)    1 se alcuni degli elementi della matrice sono diversi da zero altrimenti produce 0
 x=max(A)       elemento max della matrice
Funzioni scalari statistico/matematiche
 x=abs(a)   valore assoluto
 x=int(a)   troncatura a volore intero
 x=a##n  elevamento a potenza
 x=sin(a)/cos(a)/tan(a)   seno coseno tangente
 x= log(a)      logaritmo naturale
 x= sqrt(a)      radice quadrata
 x= probnorm(q)  Funzione di ripartizione in q della normale standard
 x=probchi(q,df,nc)    Funzione di ripartizione in q di un chi-quadrato con gradi di libertà df  e parametro di non centralità nc
 x=probt(q,df,nc))   Funzione di ripartizione in q di una t di student con gradi di libertà df  e parametro di non centralità nc
 x=probf(q,df1,df2,nc )  Funzione di ripartizione in q di una F di Snedecor con gradi di libertà df1 e df2  e parametro di non centralità nc
 x=uniform(seme)  genera un valore causale da una uniforme [0,1]
 x=normal(seme);  genera un valore casuale da una normale[0,1]
Controlli /cicli IML
 IF espressione THEN comando1;
     ELSE IF espressione THEN comando2;
 controllo if
 DO variable = start TO stop ;
...comandi iml...
end;
 ciclo for
 DO WHILE (espressione);
...comandi iml...      
end;
 ciclo while
 DO UNTIL (espressione);
...comandi iml...
end;
 ciclo do until

Moduli IML

Iml consente anche di costruire funzioni personalizzate in maniera abbastanza semplice. In Iml si chiamano moduli. Un modulo assolve il compito di una classica funzione: accetta parametri e restituisce output a seconda dei comandi del modulo. 

Vediamo un esempio semplice. Per assurdo non abbiamo a disposizione la proc reg, e vogliamo condurre un analisi sul modello lineare classico.

y=Xb + e

Creiamo quindi un modulo che, data la matrice del disegno X e la variabile di risposta y, calcola le stime dei parametri e degli errori. I comandi chiave per definire un modulo sono

start  nome_modulo(parametri);
...comandi iml...
finish;

proc iml;
start reg(x,y);              /*definisco il modulo*/
   n=nrow(x);
   k=ncol(x);
   xx= inv(x`*x);
   xy=x`*y;
   b=xx*xy;
   print "stima paramentri ", b;    /*stampo i parametri*/
   prev=x*b /*moltiplicazione tra matrici*/;
   e=y-prev;print "errori ", e;     /*stampo gli errori*/
   mse=ssq(e)/(n-k); print "mse ", mse ; 
finish;                       /*fine modulo*/


x = {1 1 1 , 1 2 4 , 1 3 9 , 1 4 16, 1 5 25}; /*matrice del disegno*/
y = {1,5,9,23,36};                            /*variabili di risposta*/
run reg(x,y);                /*mando in esecuzione il modulo*/
 
 

Ovviamente è possibile unire l'ambiente IML con le potenzialità delle macro.