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.
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'hrlp in linea).
Agli studenti non risulterà difficile avvicinarsi a IML visto che segue la logica del pacchetto R da noi usato in parecchi corsi.
Le seguenti tabelle illustrano alcune funzioni e comandi tipici dell'ambiente IML (lettera maiscola 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 |
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 |
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 |
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 |
x=abs(a) | valore assoluto |
x=int(a) | troncatura a volore intero |
x=sin(a)/cos(a)/tan(a) | seno coseno tangente |
x= log(a) | logaritmo naturale |
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 |
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 |
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;
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.