martedì 9 giugno 2020

Inserimento manuale dei dati [3]

Abbiamo già visto nel post Inserimento manuale dei dati [1] e nel post Inserimento manuale dei dati [2] alcuni esempi di dati riportati direttamente (cablati) nel codice R, dove comunque possono essere modificati a piacere. Una modalità molto elementare ma utile nella pratica quando si debbano inserire pochi dati, come in un test chi-quadrato, in un grafico a torta o quant'altro.

Vediamo ora due nuovi esempi un po' particolari, in quanto prevedono l'inserimento dei dati in modo interattivo, cioè da parte di un operatore che deve inserire manualmente i dati nella Console di R su richiesta, nel punto previsto dallo script, perché l'esecuzione dello script possa proseguire. Si tratta di una modalità di inserimento dei dati che, oltre a consentire di illustrare potenzialità di R generalmente poco note, potrebbe risultare utile in casi particolari.

Copiate lo script che segue quindi incollatelo nella Console di R e premete ↵ Invio:

# INSERIMENTO MANUALE DEI DATI [3a]
# inserimento di un singolo dato
#
# predispone la funzione inserisci_un_dato() compresa tra { e }
inserisci_un_dato <- function() {
# legge il dato inserito nella Console di R
datoinserito <- readline("Dato da elaborare = ")
# converte il dato inserito in un numero
datoinserito <- as.numeric(datoinserito)
# calcola la radice quadrata del numero inserito e mostra il risultato
print(paste("La radice quadrata di", datoinserito, "è", sqrt(datoinserito)), quote=FALSE)
}
# esegue la funzione inserisci_un_dato() in modalità interattiva attendendo un input da tastiera
if(interactive()) inserisci_un_dato()

Con le prime quattro righe di codice viene predisposta la funzione inserisci_un_dato, il cui codice è incluso tra la parentesi graffa { e la parentesi graffa }. La funzione prevede di acquisire il dato dalla Console di R con readline(), trasformare quanto immesso in un numero con as.numeric() quindi calcolarne la radice quadrata e mostrare il risultato con la quarta riga di codice. L'ultima riga di codice con if(interactive()) manda in esecuzione la funzione inserisci_un_dato() in modo interattivo, restando in attesa dell'immissione da tastiera nella Console di R del dato. 

I commenti inseriti nel codice R sono sufficientemente esplicativi di quanto avviene, mentre la documentazione delle funzioni impiegate può essere visualizzata come al solito digitando help(nomedellafunzione) nella Console di R.

Ora copiate lo script che segue quindi incollatelo nella Console di R e premete ↵ Invio:

# INSERIMENTO MANUALE DEI DATI [3b]
# inserimento di più dati
#
# imposta 1 come dato iniziale
datoinserito <- 1
# ripete le istruzioni inserite nel loop fino a quando il dato inserito è diverso da 0 (zero)
while(datoinserito!=0) {
# richiede di inserire la temperatura in gradi Celsius
datoinserito <- readline("Temperatura in gradi Celsius = ")
# converte il dato inserito in un numero
datoinserito <- as.numeric(datoinserito)
# effettua il calcolo e presenta il risultato
print(paste(datoinserito, "gradi Celsius corrispondono a", ((datoinserito * 1.8) + 32), "gradi Fahrenheit"), quote=FALSE)
}

Mediante la funzione while() viene realizzato un loop, il cui codice è incluso tra la parentesi graffa { e la parentesi graffa }, che viene reiterato fino a quando il dato inserito risulta diverso da 0 (datoinserito!=0). Il codice prevede che nella Console di R sia inserito manualmente da tastiera un dato di temperatura (datoinserito) in gradi Celsius (°C), per il quale viene calcolata e mostrata la corrispondente temperatura in gradi Fahrenheit (°F) essendo

°F = (°C ∙ 1.8) + 32

Possono essere inseriti anche valori negativi di temperatura in gradi Celsius.

Anche in questo caso i commenti inseriti nel codice R sono sufficientemente esplicativi di quanto avviene mentre di nuovo al bisogno la documentazione delle funzioni impiegate può essere visualizzata digitando help(nomedellafunzione) nella Console di R.

Per entrambi gli script ci si può inoltre divertire a immaginare i controlli che potrebbero essere eseguiti sul dato inserito, e per il secondo script anche a trovare qualcosa di meglio dell'uscita dal loop piuttosto grezza realizzata inserendo 0 come dato, ma questo va al di la degli scopi del post.

In definitiva i due script, pur nella loro semplicità, forniscono come sottoprodotto utile due esempi didattici:
di come con R sia possibile realizzare una funzione, cioè un blocco di codice che può essere eseguito semplicemente richiamando nomedellafunzione(eventualiargomenti);
di come con R sia possibile realizzare un loop (ciclo, iterazione), cioè la ripetizione ciclica di una sequenza di operazioni finché risulta vera la condizione di controllo prefissata, una struttura di controllo ampiamente utilizzata in qualsiasi linguaggio di programmazione, oltre che all'interno delle funzioni di R.


----------

mercoledì 8 aprile 2020

Analizzare graficamente la distribuzione di una variabile

Questa volta l'obiettivo è di fornire uno strumento pratico, immediatamente riadattabile a nuovi dati, che condensa in una sola immagine quattro grafici che illustrano la distribuzione di una variabile: una sintesi che rappresenta il necessario complemento a tutti i test statistici di gaussianità che si vorranno eseguire.

I dati sono contenuti nel file ais.csv (vedere il post Il set di dati ais). Incollate questo script nella Console di R e premete ↵ Invio:

# ANALIZZARE GRAFICAMENTE LA DISTRIBUZIONE DI UNA VARIABILE
#
ais <- read.table("C:/Rdati/ais.csv", header=TRUE, sep=";", dec=",") # carica i dati
mydata <- ais$ferr # salva in mydata i valori della variabile ferritina
par(mfrow=c(2,2)) # suddivide la finestra in quattro quadranti, uno per grafico
# 1/4
hist(mydata, xlim=c(0,250), ylim=c(0,0.012), freq=FALSE, breaks="FD", main="Istogramma\ne kernel density plot", xlab="Ferritina in µg/L", ylab = "Densità di probabilità") # traccia l'istogramma dei dati
par(new=TRUE, ann=FALSE) # consente di sovrapporre il grafico successivo
plot(density(mydata, n=1024, from=0, to=250), xlim = c(0,250), ylim=c(0,0.012), yaxt="n", col="black") # sovrappone il kernel density plot della distribuzione campionaria
# 2/4
plot(density(mydata, n=1024, from=0, to=250), xlim = c(0,250), ylim=c(0,0.012)) # traccia il kernel density plot della distribuzione campionaria
par(new=TRUE, ann=FALSE) # consente di sovrapporre il grafico successivo
x <- seq(0,250, length.out=1024) # calcola i valori in ascisse della gaussiana teorica
y <- dnorm(x, mean=mean(mydata), sd=sd(mydata)) # calcola i valori in ordinate della gaussiana teorica
plot(x, y, xlim=c(0,250), ylim=c(0,0.012), yaxt="n", col="red", type="l") # sovrappone la distribuzione gaussiana teorica in colore rosso
title(main="Distribuzione campionaria\nvs. gaussiana teorica", xlab="Ferritina in µg/L", ylab = "Densità di probabilità") # aggiunge titolo e legende degli assi
# 3/4
par(new=FALSE, ann=TRUE) # per mostrare titolo e legende degli assi
plot(ecdf(scale(mydata)), main="Cumulativa campionaria\nvs. cumulativa teorica", xlab="Deviata normale standardizzata z", ylab = "Frequenza cumulativa", xlog = FALSE, ylog = FALSE, xlim = c(-4,4), ylim = c(0,1), xaxp = c(-4, 4, 5), yaxp = c(0,1,5)) # traccia il grafico della distribuzione cumulativa campionaria
par(new=TRUE, ann=FALSE) # consente di sovrapporre il grafico successivo
plot(ecdf(rnorm(10000, mean=0, sd=1)), col="red", xlog = FALSE, ylog = FALSE, xlim = c(-4,4), ylim = c(0,1), xaxp = c(-4, 4, 5), yaxp = c(0,1,5)) # sovrappone la distribuzione cumulativa teorica in colore rosso
# 4/4
par(new=FALSE, ann=TRUE) # per mostrare titolo e legende degli assi
qqnorm(scale(mydata), main="Quantili campionari\nvs. quantili teorici", xlab="Quantili teorici", ylab = "Quantili campionari", xlim = c(-4,4), ylim = c(-4,4)) # traccia il grafico della distribuzione dei quantili campionari
abline (0,1, col="red") # sovrappone la distribuzione dei quantili teorica in colore rosso
#

La ferritina è una proteina che, pur con alcune limitazioni, fornisce una misura dei depositi di ferro presenti nell'organismo, necessari per garantire una adeguata produzione di emoglobina. L'analisi grafica dei dati consente di confermare visivamente per la concentrazione della ferritina nel sangue una distribuzione non gaussiana.











fare click sull'immagine per ingrandirla









Il codice dello script è illustrato dai commenti via via inseriti, ma vediamo brevemente il significato di questa rappresentazione.

Il primo grafico presenta la distribuzione dei dati sotto forma del classico istogramma [1] impiegando la funzione hist(), calcolando il numero di classi (breaks="FD") mediante la regola di Freedman-Diaconis, e ponendo in ordinate la densità di probabilità (freq=FALSE). Questo consente di sovrapporre all'istogramma, nella stessa scala, il corrispondente kernel density plot, calcolato mediante la funzione density() su 1024 punti (n=1024) con valori compresi tra 0 (from=0) e 250 (to=250), e rappresentato mediante la funzione plot()

Con il secondo grafico entriamo nel vivo del confronto tra la distribuzione dei dati osservata, o distribuzione empirica o distribuzione campionaria che dir si voglia, e quella che i dati dovrebbero avere se fossero distribuiti secondo una gaussiana. Questo viene fatto riportando la distribuzione campionaria sotto forma di kernel density plot come al punto precedente, e riportando per confronto (in colore rosso) la distribuzione gaussiana teorica corrispondente, ottenuta calcolando con la funzione dnorm() la densità di probabilità (y), quella che avremmo se dati con la media mean=mean(mydata) e la deviazione standard sd=sd(mydata) dei dati osservati fossero distribuiti in modo gaussiano, in corrispondenza di 1024 valori (length.out=1024) della x ottenuti con la funzione seq().

Il terzo grafico riporta la distribuzione cumulativa campionaria calcolata con la funzione ecdf() sui dati (mydata) del campione, e riporta per confronto (in colore rosso) la corrispondente distribuzione cumulativa teorica, calcolata sempre con la funzione ecdf() su un campione di 10 000 dati distribuiti in modo gaussiano con media 0 e deviazione standard 1, generati impiegando la funzione rnorm() con gli argomenti 10000, mean=0, sd=1.

Il quarto grafico impiega la funzione qqplot() per calcolare i quantili della distribuzione campionaria in funzione dei quantili teorici, e ne confronta l'andamento con quello previsto (la linea retta in colore rosso) per dati che seguono una distribuzione gaussiana. Concettualmente, si tratta della trasformazione lineare del grafico della distribuzione cumulativa di cui al punto precedente

In definitiva vediamo come tre grafici, realizzati in modo semplice, forniscono una indicazione concisa di come e di quanto una distribuzione campionaria si discosta da una distribuzione gaussiana. E, come già detto all'inizio, offrono una sintesi che rappresenta un indispensabile complemento a tutti i test statistici di gaussianità che si vorranno eseguire. Aggiungo che, nonostante siano ovviamente tecnicamente ineccepibili, distribuzione cumulativa e quantili tendono a comprimere, dal punto di vista grafico, la differenza tra la distribuzione campionaria e la distribuzione attesa nel caso di dati distribuiti in modo gaussiano. Differenza che a mio avviso appare invece più evidente nel semplice confronto tra la distribuzione osservata, rappresentata sotto forma di kernel density plot, e la corrispondente distribuzione gaussiana.

I dettagli delle funzioni e degli argomenti impiegati li trovate riportati nei post che trattano le rispettive rappresentazioni grafiche (vedere alla pagina Indice). Per tutti gli eventuali approfondimenti aggiuntivi è possibile come al solito digitare help(nomedellafunzione) nella Console di RSi fa infine notare, come piccola novità, la comparsa nel codice R di un \n che impone un “a capo” in alcune delle righe di testo.

Per riutilizzare questo script è sufficiente:
→ nella prima riga di codice sostituire ais con il nome che volete assegnare ai vostri dati e sostituire C:/Rdati/ais.csv con nome e posizione del file dal quale importare i dati, adeguando al bisogno il separatore dei campi (sep=";") e il separatore dei decimali (dec=",") a quelli da voi impiegati;
→ essendo (ad esempio) dati il nome dei vostri dati e var il nome della variabile che volete analizzare, sostituire nella seconda riga di codice ais$ferr con dati$var;
→ adattare opportunamente xlim, ylim, titoli e legende degli assi.

Vale infine la pena di ricordare che, impiegando l'utilità riportata nel post Salvare i grafici di R in un file, potete anche salvare le immagini realizzate con R, come quella qui riportata, sotto forma di file .bmp, .jpeg, .png, .pdf, .ps per poterle stampare, archiviare, inserire in una pubblicazione, in un post o in un sito web.


----------

[1] Da notare che a partire da R versione 4.0 di default le barre dell'istogramma sono riempite in colore grigio.

giovedì 12 marzo 2020

Importazione dei dati da un file di solo testo

Nel post Importazione dei dati da un file .csv abbiamo visto come sono organizzati i dati in un file .csv, il formato raccomandato per R. E abbiamo visto che un file .csv è un semplice file di testo. Se aprite con un editor di testo il file importa_csv.csv (se non l'avete già scaricato, trovate come farlo nella scheda Datiquesto è quello che vi appare:

id;sesso;anni;peso_kg;altezza_m
MT;M;69;76;1,78
GF;F;56;63;
MC;F;53;71;1,60
SB;M;28;73;1,78
FE;F;61;54;1,54
AB;M;46;92;1,84
RF;F;31;81;1,56

Se ci pensate bene, però, oltre a lettere, numeri, caratteri di interpunzione e qualche altro carattere accessorio, o, più tecnicamente, oltre a una serie di caratteri ASCII stampabili (vedere il post Codifica dei caratteri ASCII, ANSI, Unicode e UTF), nel testo è incluso un "a capo" (o se preferite un ↵ Invio) che segna il passaggio da una riga alla successiva, o, in altre parole, che separa un record dal successivo: ed è chiaro che in qualche modo questo carattere, uno dei caratteri non stampabili (o caratteri di controllo) del codice ASCII, deve essere stato codificato nel file.

Che proprio questo sia il caso è dimostrabile aprendo il file con un editor di testo che sia in grado di mostrare, oltre ai caratteri ASCII, anche i caratteri di controllo contenuti nel file, uno dei quali è appunto il carattere di "a capo". Per esempio se aprite il file importa_csv.csv con PSPad [1] ed attivate nel menù Visualizza la funzione Modalità esadecimale vedete questo:

















Sulla destra compaiono i caratteri ASCII contenuti nel file, sulla sinistra compare il valore esadecimale corrispondente. Sulla destra vedete ricorrere al termine di ogni riga/record una sequenza di due punti consecutivi (..), sulla sinistra vedete che ad essi corrisponde la sequenza 0D0A che è la rappresentazione esadecimale di CR (Carriage Return) e di LF (Line Feed) cioè rispettivamente del ritorno di carrello (0D esadecimale) e del passaggio ad una nuova riga (0A esadecimale) che l'informatica ha ereditato dalla macchina da scrivere. Questi due caratteri ASCII l'editor di testo li interpreta come caratteri di controllo, cioè come caratteri che non devono essere rappresentati, ma che indicano una azione da compiere: passare a una nuova riga di testo ovvero inserire nel testo un "a capo" (un ↵ Invio) [2].

R è ovviamente in grado di interpretare correttamente i caratteri di controllo, infatti se nella Console di R incollate questa riga di codice

mydatacsv <- read.table("C:/Rdati/importa_csv.csv", header=TRUE, sep=";", dec=",")

e premete ↵ Invio per importare i dati dal file .csv, quindi digitate

mydatacsv

e premete ↵ Invio per mostrare i dati importati, ottenete questo risultato:

> mydatacsv <- read.table("C:/Rdati/importa_csv.csv", header=TRUE, sep=";", dec=",")
> mydatacsv
  id sesso anni peso_kg altezza_m

1 MT     M   69      76      1.78
2 GF     F   56      63        NA
3 MC     F   53      71      1.60
4 SB     M   28      73      1.78
5 FE     F   61      54      1.54
6 AB     M   46      92      1.84
7 RF     F   31      81      1.56

(NA indica un dato mancante, trovate il riscontro nel file originale).

Ma con R è possibile un'altra cosa: si possono codificare i caratteri di controllo in chiaro, come viene fatto nel file importa_txt.txt che contiene gli stessi dati e che, aperto con un editor di testo, così vi appare:

MT;M;69;76;1,78\nGF;F;56;63;\nMC;F;53;71;1,60\nSB;M;28;73;1,78\nFE;F;61;54;1,54\nAB;M;46;92;1,84\nRF;F;31;81;1,56


Da notare che nel file importa_txt.txt rispetto al corrispondente file .csv:
i caratteri di controllo CR e LF (nascosti nel file .csv) sono stati sostituiti con i caratteri (in chiaro) \n ove la barra rovesciata \ (o backslash) indica a R la presenza di un carattere di controllo e n sta per New Line (“passa a una nuova riga”);
→ il file non contiene i nomi delle variabili, che devono essere specificati nella funzione read.table() mediante l'argomento col.names;
l'ultimo carattere nel file deve essere un ↵ Invio (cioè un "a capo") che in questo caso deve immediatamente seguire il 6 del dato finale 1,56.

Il file importa_txt.txt potete scaricarlo e installarlo nella cartella C:\Rdati seguendo le istruzioni fornite nella scheda Dati. Ora copiate nella Console di R questa riga di codice

mydatatxt <- read.table("c:/Rdati/importa_txt.txt", header=TRUE, col.names=c("id", "sesso", "anni", "peso_kg", "altezza_m"), sep=";", dec=",", allowEscapes=TRUE)

e premete ↵ Invio per importare i dati, quindi digitate

mydatatxt

e premete ↵ Invio per visualizzare i dati importati. 

Da notare che l'argomento allowEscapes=TRUE fa si che R interpreti la  sequenza \n come un carattere di controllo (un ↵ Invio) e non come due semplici caratteri di testo. Come vedete il risultato ottenuto

> mydatatxt <- read.table("c:/Rdati/importa_txt.txt", header=TRUE, col.names=c("id","sesso","anni","peso_kg","altezza_m"), sep=";", dec=",", allowEscapes=TRUE)
> mydatatxt
  id sesso anni peso_kg altezza_m

1 MT     M   69      76      1.78
2 GF     F   56      63        NA
3 MC     F   53      71      1.60
4 SB     M   28      73      1.78
5 FE     F   61      54      1.54
6 AB     M   46      92      1.84
7 RF     F   31      81      1.56

è identico a quello ottenuto importando i dati del file .csv.

Il senso di tutto ciò? Semplice. Guardate il set di dati Galton. Si tratta di 928 righe di dati, ciascuna corrispondente a un record, più una riga per i nomi delle variabili. Se invece di un file .csv impiegate un file .txt separando i record con \n potete compattare i dati in un numero enormemente inferiore di righe, cosa che ad esempio rende possibile inserire un numero così elevato di record in un testo.


----------


Addendum

Se siete arrivati fino a qui, avete certamente notato che nel post manca una cosa fondamentale: un metodo semplice per generare un file di testo nel quale i caratteri di controllo nascosti CR e LF sono sostituiti con un \n riportato in chiaro.

In effetti ci sono programmi che consentono di effettuare la sostituzione online. Alcuni forniscono come risultato un file nel quale la sequenza di caratteri di controllo CRLF è automaticamente sostituita con \n [3], altri forniscono come risultato un file nel quale detta sequenza è sostituita con uno spazio vuoto [4], che successivamente può essere sostituito manualmente con \n.

Qui vediamo invece come effettuare la sostituzione con questa seconda modalità, che è la più semplice, impiegando R e un comune editor di testo.

Scaricate dal CRAN e installate il pacchetto stringr [5]. Quindi copiate e incollate nella Console di R questo script e premete ↵ Invio

# SALVA I DATI IN UN FILE DI TESTO ELIMINANDO I CARATTERI DI CONTROLLO CR e LF
#
library(stringr) # carica il pacchetto
mydata <- readLines("C:/Rdati/importa_csv.csv") # legge il file
newdata <- mydata[-c(1)] # elimina la prima riga che contiene i nomi delle variabili
mystring <- str_c(newdata, collapse=" ") # concatena i record in un'unica stringa separandoli con uno spazio
write(mystring, file="C:/Rdati/temp.txt") # salva la stringa in un file di testo

Va subito precisato che il messaggio che vi comparirà

Warning message:
In readLines("C:/Rdati/importa_csv.csv") :
incomplete final line found on 'C:/Rdati/importa_csv.csv'

non indica un errore, ma è un semplice avvertimento che segnala la mancanza della sequenza CRLF (cioè di un ↵ Invio) alla fine del file: i dati sono importati correttamente, come potete constatare digitando mydata.

Nelle cinque righe di codice, nell'ordine:
→ con la funzione library() viene caricato il pacchetto stringr;
→ con readLine(s) un normale file .csv (vedere il post Importazione dei dati da un file .csv) viene importato riga per riga;
→ con [-c(1)] viene eliminata la prima riga, quella che contiene i nomi delle variabili;
→ con la funzione str_c() del pacchetto stringr le righe (record) del file importate sono concatenate in un'unica stringa separando l'una dall'altra con uno spazio (collapse=" ") ;
la stringa che risulta dal concatenamento viene salvata nel file C:/Rdati/temp.txt.

Digitate mydata, poi newdata e infine mystring per visualizzare la progressiva trasformazione dei dati.

Infine, impiegando un editor di testo come il Blocco note di Windows:
aprite il file C:/Rdati/temp.txt
utilizzate la funzione Modifica > Sostituisci per sostituire lo spazio vuoto con i caratteri \n














A questo punto ricordatevi che l'ultimo carattere del file deve essere un ↵ Invio (cioè un "a capo") che dovete inserire manualmente immediatamente dopo il 6 del dato finale 1,56. Poi salvate il risultato nel file definitivo, denominato a piacere ma possibilmente per coerenza con estensione .txt, e avrete finalmente un file di dati di R in formato testo come questo

MT;M;69;76;1,78\nGF;F;56;63;\nMC;F;53;71;1,60\nSB;M;28;73;1,78\nFE;F;61;54;1,54\nAB;M;46;92;1,84\nRF;F;31;81;1,56


che impiega come separatore di record la sequenza di caratteri \n codificata in chiaro, e che può essere importato in R mediante la funzione read.table() impiegando l'argomento allowEscapes=TRUE.

Supponendo che abbiate denominato questo file C:\Rdati\ilmiofile_txt.txt se copiate nella Console di R questa riga di codice

mydatatxt <- read.table("c:/Rdati/ilmiofile_txt.txt", header=TRUE, col.names=c("id", "sesso", "anni", "peso_kg", "altezza_m"), sep=";", dec=",", allowEscapes=TRUE)

e premete ↵ Invio per importare i dati, quindi digitate

mydatatxt

e premete ↵ Invio per visualizzare i dati importati, potete verificare che il tutto ha funzionato correttamente e che pertanto siete in grado, al bisogno, da un lato di generare un file di testo con i caratteri di controllo in chiaro, e dall'altro lato di importarne i dati in R.


----------

[1] PSPad freeware editor. URL consultato il 16/03/2020: http://bit.ly/3aUXAws

[2] In realtà esistono tre modi per codificare un "a capo" (un ↵ Invio), e dipendono dal sistema operativo impiegato:
 CRLF (\r\n): usato da MS-DOS e Microsoft Windows, al quale si fa qui riferimento;
 LF (\n): usato da sistemi Unix, Linux e Apple (GNU/Linux, Mac OS X e macOS);
 CR (\r): usato da Commodore e Apple (Mac OS fino alla versione 9 inclusa).

[3] Remove/Replace all line breaks of a text. URL consultato il 16/03/2020: http://bit.ly/39Wt2JF

[4] Convert Newlines to Spaces. URL consultato il 16/03/2020: http://bit.ly/2x481ht

[5] Vedere il manuale di riferimento del pacchetto Package 'stringr'. URL consultato il 16/03/2020: http://bit.ly/33lINaC