R - Guida rapida

R è un linguaggio di programmazione e un ambiente software per l'analisi statistica, la rappresentazione grafica e il reporting. R è stato creato da Ross Ihaka e Robert Gentleman presso l'Università di Auckland, in Nuova Zelanda, ed è attualmente sviluppato dall'R Development Core Team.

Il nucleo di R è un linguaggio per computer interpretato che consente la ramificazione e il loop, nonché la programmazione modulare utilizzando le funzioni. R consente l'integrazione con le procedure scritte nei linguaggi C, C ++, .Net, Python o FORTRAN per l'efficienza.

R è disponibile gratuitamente sotto la GNU General Public License e sono fornite versioni binarie precompilate per vari sistemi operativi come Linux, Windows e Mac.

R è un software gratuito distribuito sotto una copia in stile GNU a sinistra e una parte ufficiale del progetto GNU chiamata GNU S.

Evoluzione di R

R è stato inizialmente scritto da Ross Ihaka e Robert Gentlemanpresso il Dipartimento di Statistica dell'Università di Auckland ad Auckland, Nuova Zelanda. R ha fatto la sua prima apparizione nel 1993.

  • Un folto gruppo di persone ha contribuito a R inviando codice e segnalazioni di bug.

  • Dalla metà del 1997 esiste un gruppo principale ("R Core Team") che può modificare l'archivio del codice sorgente R.

Caratteristiche di R

Come affermato in precedenza, R è un linguaggio di programmazione e un ambiente software per l'analisi statistica, la rappresentazione grafica e il reporting. Le seguenti sono le caratteristiche importanti di R -

  • R è un linguaggio di programmazione ben sviluppato, semplice ed efficace che include condizionali, cicli, funzioni ricorsive definite dall'utente e funzionalità di input e output.

  • R dispone di un'efficace struttura di gestione e archiviazione dei dati,

  • R fornisce una suite di operatori per calcoli su array, liste, vettori e matrici.

  • R fornisce una raccolta ampia, coerente e integrata di strumenti per l'analisi dei dati.

  • R fornisce funzionalità grafiche per l'analisi e la visualizzazione dei dati direttamente sul computer o per la stampa sui giornali.

In conclusione, R è il linguaggio di programmazione statistica più utilizzato al mondo. È la scelta n. 1 dei data scientist ed è supportata da una vivace e talentuosa comunità di contributori. R viene insegnato nelle università e distribuito in applicazioni aziendali mission-critical. Questo tutorial ti insegnerà la programmazione R insieme ad esempi adatti in passaggi semplici e facili.

Configurazione dell'ambiente locale

Se sei ancora disposto a configurare il tuo ambiente per R, puoi seguire i passaggi indicati di seguito.

Installazione di Windows

È possibile scaricare la versione Windows installer di R da R-3.2.2 per Windows (32/64 bit) e salvarla in una directory locale.

Poiché è un programma di installazione di Windows (.exe) con un nome "R-version-win.exe". Puoi semplicemente fare doppio clic ed eseguire il programma di installazione accettando le impostazioni predefinite. Se la tua versione di Windows è a 32 bit, installa la versione a 32 bit. Ma se Windows è a 64 bit, installa entrambe le versioni a 32 bit e 64 bit.

Dopo l'installazione è possibile individuare l'icona per eseguire il programma in una struttura di directory "R \ R3.2.2 \ bin \ i386 \ Rgui.exe" sotto i Programmi di Windows. Facendo clic su questa icona viene visualizzata la R-GUI che è la console R per eseguire la programmazione R.

Installazione di Linux

R è disponibile come binario per molte versioni di Linux nella posizione R Binaries .

Le istruzioni per installare Linux variano da un gusto all'altro. Questi passaggi sono menzionati sotto ogni tipo di versione Linux nel collegamento citato. Tuttavia, se hai fretta, puoi usareyum comando per installare R come segue -

$ yum install R

Il comando sopra installerà le funzionalità principali della programmazione R insieme ai pacchetti standard, tuttavia è necessario un pacchetto aggiuntivo, quindi è possibile avviare il prompt R come segue:

$ R
R version 3.2.0 (2015-04-16) -- "Full of  Ingredients"          
Copyright (C) 2015 The R Foundation for Statistical Computing
Platform: x86_64-redhat-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many  contributors.                    
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
>

Ora puoi utilizzare il comando di installazione al prompt R per installare il pacchetto richiesto. Ad esempio, verrà installato il seguente comandoplotrix pacchetto necessario per i grafici 3D.

> install.packages("plotrix")

Come convenzione, inizieremo ad apprendere la programmazione R scrivendo un "Hello, World!" programma. A seconda delle esigenze, è possibile programmare al prompt dei comandi R oppure è possibile utilizzare un file di script R per scrivere il programma. Controlliamo entrambi uno per uno.

Prompt dei comandi R.

Dopo aver configurato l'ambiente R, è facile avviare il prompt dei comandi R semplicemente digitando il seguente comando al prompt dei comandi:

$ R

Questo avvierà l'interprete R e riceverai un prompt> dove puoi iniziare a digitare il tuo programma come segue:

> myString <- "Hello, World!"
> print ( myString)
[1] "Hello, World!"

Qui la prima istruzione definisce una variabile stringa myString, dove assegniamo una stringa "Hello, World!" e quindi viene utilizzata l'istruzione successiva print () per stampare il valore memorizzato nella variabile myString.

File di script R.

Di solito, farai la tua programmazione scrivendo i tuoi programmi in file di script e poi eseguirai quegli script al prompt dei comandi con l'aiuto dell'interprete R chiamato Rscript. Quindi iniziamo con la scrittura del codice seguente in un file di testo chiamato test.R come sotto -

# My first program in R Programming
myString <- "Hello, World!"

print ( myString)

Salvare il codice sopra in un file test.R ed eseguirlo al prompt dei comandi di Linux come indicato di seguito. Anche se utilizzi Windows o un altro sistema, la sintassi rimarrà la stessa.

$ Rscript test.R

Quando eseguiamo il programma sopra, produce il seguente risultato.

[1] "Hello, World!"

Commenti

I commenti sono come aiutare il testo nel programma R e vengono ignorati dall'interprete durante l'esecuzione del programma effettivo. Il singolo commento viene scritto usando # all'inizio dell'istruzione come segue:

# My first program in R Programming

R non supporta i commenti su più righe ma puoi eseguire un trucco che è qualcosa come segue:

if(FALSE) {
   "This is a demo for multi-line comments and it should be put inside either a 
      single OR double quote"
}

myString <- "Hello, World!"
print ( myString)
[1] "Hello, World!"

Anche se i commenti sopra saranno eseguiti dall'interprete R, non interferiranno con il tuo programma attuale. Dovresti inserire tali commenti all'interno, virgolette singole o doppie.

In genere, durante la programmazione in qualsiasi linguaggio di programmazione, è necessario utilizzare varie variabili per memorizzare varie informazioni. Le variabili non sono altro che posizioni di memoria riservate per memorizzare i valori. Ciò significa che, quando crei una variabile, riservi dello spazio in memoria.

Potresti voler memorizzare informazioni di vari tipi di dati come carattere, carattere largo, intero, virgola mobile, doppio virgola mobile, booleano ecc. In base al tipo di dati di una variabile, il sistema operativo alloca memoria e decide cosa può essere memorizzato nel memoria riservata.

A differenza di altri linguaggi di programmazione come C e Java in R, le variabili non vengono dichiarate come un tipo di dati. Le variabili vengono assegnate con R-Objects e il tipo di dati dell'oggetto R diventa il tipo di dati della variabile. Esistono molti tipi di oggetti R. Quelli di uso frequente sono:

  • Vectors
  • Lists
  • Matrices
  • Arrays
  • Factors
  • Frame di dati

Il più semplice di questi oggetti è il file vector objecte ci sono sei tipi di dati di questi vettori atomici, chiamati anche sei classi di vettori. Gli altri R-Oggetti sono costruiti sui vettori atomici.

Tipo di dati Esempio Verificare
Logico VERO FALSO
v <- TRUE 
print(class(v))

produce il seguente risultato:

[1] "logical"
Numerico 12.3, 5, 999
v <- 23.5
print(class(v))

produce il seguente risultato:

[1] "numeric"
Numero intero 2L, 34L, 0L
v <- 2L
print(class(v))

produce il seguente risultato:

[1] "integer"
Complesso 3 + 2i
v <- 2+5i
print(class(v))

produce il seguente risultato:

[1] "complex"
Personaggio 'a', '"buono", "TRUE", '23 .4'
v <- "TRUE"
print(class(v))

produce il seguente risultato:

[1] "character"
Crudo "Hello" è memorizzato come 48 65 6c 6c 6f
v <- charToRaw("Hello")
print(class(v))

produce il seguente risultato:

[1] "raw"

Nella programmazione R, i tipi di dati di base sono gli oggetti R chiamati vectorsche contengono elementi di classi diverse come mostrato sopra. Si noti che in R il numero di classi non è limitato ai soli sei tipi di cui sopra. Ad esempio, possiamo usare molti vettori atomici e creare un array la cui classe diventerà array.

Vettori

Quando vuoi creare un vettore con più di un elemento, dovresti usare c() funzione che significa combinare gli elementi in un vettore.

# Create a vector.
apple <- c('red','green',"yellow")
print(apple)

# Get the class of the vector.
print(class(apple))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "red"    "green"  "yellow"
[1] "character"

Liste

Una lista è un oggetto R che può contenere molti diversi tipi di elementi al suo interno come vettori, funzioni e anche un'altra lista al suo interno.

# Create a list.
list1 <- list(c(2,5,3),21.3,sin)

# Print the list.
print(list1)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[[1]]
[1] 2 5 3

[[2]]
[1] 21.3

[[3]]
function (x)  .Primitive("sin")

Matrici

Una matrice è un set di dati rettangolare bidimensionale. Può essere creato utilizzando un input vettoriale per la funzione matrice.

# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[,1] [,2] [,3]
[1,] "a"  "a"  "b" 
[2,] "c"  "b"  "a"

Array

Mentre le matrici sono limitate a due dimensioni, le matrici possono avere un numero qualsiasi di dimensioni. La funzione array accetta un attributo dim che crea il numero richiesto di dimensione. Nell'esempio seguente creiamo un array con due elementi che sono matrici 3x3 ciascuno.

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

Quando eseguiamo il codice sopra, produce il seguente risultato:

, , 1

     [,1]     [,2]     [,3]    
[1,] "green"  "yellow" "green" 
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green" 

, , 2

     [,1]     [,2]     [,3]    
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green" 
[3,] "yellow" "green"  "yellow"

Fattori

I fattori sono gli oggetti r che vengono creati utilizzando un vettore. Memorizza il vettore insieme ai valori distinti degli elementi nel vettore come etichette. Le etichette sono sempre caratteri indipendentemente dal fatto che siano numeriche, caratteri o booleane ecc. Nel vettore di input. Sono utili nella modellazione statistica.

I fattori vengono creati utilizzando il factor()funzione. Ilnlevels funzioni fornisce il conteggio dei livelli.

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')

# Create a factor object.
factor_apple <- factor(apple_colors)

# Print the factor.
print(factor_apple)
print(nlevels(factor_apple))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] green  green  yellow red    red    red    green 
Levels: green red yellow
[1] 3

Frame di dati

I data frame sono oggetti dati tabulari. A differenza di una matrice nel frame di dati, ogni colonna può contenere diverse modalità di dati. La prima colonna può essere numerica mentre la seconda colonna può essere carattere e la terza colonna può essere logica. È un elenco di vettori di uguale lunghezza.

I data frame vengono creati utilizzando l'estensione data.frame() funzione.

# Create the data frame.
BMI <- 	data.frame(
   gender = c("Male", "Male","Female"), 
   height = c(152, 171.5, 165), 
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

Quando eseguiamo il codice sopra, produce il seguente risultato:

gender height weight Age
1   Male  152.0     81  42
2   Male  171.5     93  38
3 Female  165.0     78  26

Una variabile ci fornisce una memoria con nome che i nostri programmi possono manipolare. Una variabile in R può memorizzare un vettore atomico, un gruppo di vettori atomici o una combinazione di molti Robject. Un nome di variabile valido è composto da lettere, numeri e caratteri punto o sottolineatura. Il nome della variabile inizia con una lettera o il punto non seguito da un numero.

Nome variabile Validità Motivo
var_name2. valido Contiene lettere, numeri, punti e trattini bassi
var_name% Non valido Ha il carattere "%". Sono consentiti solo il punto (.) E il trattino basso.
2var_name non valido Inizia con un numero

.var_name,

var.name

valido Può iniziare con un punto (.) Ma il punto (.) Non deve essere seguito da un numero.
.2var_name non valido Il punto iniziale è seguito da un numero che lo rende non valido.
_var_name non valido Inizia con _ che non è valido

Assegnazione variabile

Alle variabili possono essere assegnati valori utilizzando l'operatore sinistro, destro e uguale a. I valori delle variabili possono essere stampati utilizzandoprint() o cat()funzione. Ilcat() combina più elementi in un output di stampa continuo.

# Assignment using equal operator.
var.1 = c(0,1,2,3)           

# Assignment using leftward operator.
var.2 <- c("learn","R")   

# Assignment using rightward operator.   
c(TRUE,1) -> var.3           

print(var.1)
cat ("var.1 is ", var.1 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 0 1 2 3
var.1 is  0 1 2 3 
var.2 is  learn R 
var.3 is  1 1

Note- Il vettore c (TRUE, 1) ha una combinazione di classe logica e numerica. Quindi la classe logica viene forzata in classe numerica rendendo TRUE come 1.

Tipo di dati di una variabile

In R, una variabile stessa non è dichiarata di alcun tipo di dati, ma ottiene il tipo di dati dell'oggetto R assegnato ad essa. Quindi R è chiamato linguaggio tipizzato dinamicamente, il che significa che possiamo cambiare il tipo di dati di una variabile della stessa variabile ancora e ancora quando lo si utilizza in un programma.

var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"\n")

var_x <- 34.5
cat("  Now the class of var_x is ",class(var_x),"\n")

var_x <- 27L
cat("   Next the class of var_x becomes ",class(var_x),"\n")

Quando eseguiamo il codice sopra, produce il seguente risultato:

The class of var_x is  character 
   Now the class of var_x is  numeric 
      Next the class of var_x becomes  integer

Trovare variabili

Per conoscere tutte le variabili attualmente disponibili nell'area di lavoro utilizziamo il file ls()funzione. Anche la funzione ls () può utilizzare modelli per abbinare i nomi delle variabili.

print(ls())

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"

Note - È un output di esempio a seconda delle variabili dichiarate nel proprio ambiente.

La funzione ls () può utilizzare modelli per abbinare i nomi delle variabili.

# List the variables starting with the pattern "var".
print(ls(pattern = "var"))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"

Le variabili che iniziano con dot(.) sono nascosti, possono essere elencati utilizzando l'argomento "all.names = TRUE" nella funzione ls ().

print(ls(all.name = TRUE))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] ".cars"        ".Random.seed" ".var_name"    ".varname"     ".varname2"   
[6] "my var"       "my_new_var"   "my_var"       "var.1"        "var.2"        
[11]"var.3"        "var.name"     "var_name2."   "var_x"

Eliminazione di variabili

Le variabili possono essere eliminate utilizzando il file rm()funzione. Di seguito cancelliamo la variabile var.3. Durante la stampa viene lanciato il valore della variabile error.

rm(var.3)
print(var.3)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "var.3"
Error in print(var.3) : object 'var.3' not found

Tutte le variabili possono essere eliminate utilizzando il file rm() e ls() funzionano insieme.

rm(list = ls())
print(ls())

Quando eseguiamo il codice sopra, produce il seguente risultato:

character(0)

Un operatore è un simbolo che dice al compilatore di eseguire specifiche manipolazioni matematiche o logiche. Il linguaggio R è ricco di operatori incorporati e fornisce i seguenti tipi di operatori.

Tipi di operatori

Abbiamo i seguenti tipi di operatori nella programmazione R:

  • Operatori aritmetici
  • Operatori relazionali
  • Operatori logici
  • Operatori di assegnazione
  • Operatori vari

Operatori aritmetici

La tabella seguente mostra gli operatori aritmetici supportati dal linguaggio R. Gli operatori agiscono su ogni elemento del vettore.

Operatore Descrizione Esempio
+ Aggiunge due vettori
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v+t)

produce il seguente risultato:

[1] 10.0  8.5  10.0
- Sottrae il secondo vettore dal primo
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v-t)

produce il seguente risultato:

[1] -6.0  2.5  2.0
* Moltiplica entrambi i vettori
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v*t)

produce il seguente risultato:

[1] 16.0 16.5 24.0
/ Dividi il primo vettore con il secondo
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v/t)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 0.250000 1.833333 1.500000
%% Dare il resto del primo vettore con il secondo
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%%t)

produce il seguente risultato:

[1] 2.0 2.5 2.0
% /% Il risultato della divisione del primo vettore con il secondo (quoziente)
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%/%t)

produce il seguente risultato:

[1] 0 1 1
^ Il primo vettore elevato all'esponente del secondo vettore
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v^t)

produce il seguente risultato:

[1]  256.000  166.375 1296.000

Operatori relazionali

La tabella seguente mostra gli operatori relazionali supportati dal linguaggio R. Ciascun elemento del primo vettore viene confrontato con l'elemento corrispondente del secondo vettore. Il risultato del confronto è un valore booleano.

Operatore Descrizione Esempio
> Controlla se ogni elemento del primo vettore è maggiore dell'elemento corrispondente del secondo vettore.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>t)

produce il seguente risultato:

[1] FALSE  TRUE FALSE FALSE
< Controlla se ogni elemento del primo vettore è minore dell'elemento corrispondente del secondo vettore.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v < t)

produce il seguente risultato:

[1]  TRUE FALSE  TRUE FALSE
== Controlla se ogni elemento del primo vettore è uguale all'elemento corrispondente del secondo vettore.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v == t)

produce il seguente risultato:

[1] FALSE FALSE FALSE  TRUE
<= Controlla se ogni elemento del primo vettore è minore o uguale all'elemento corrispondente del secondo vettore.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<=t)

produce il seguente risultato:

[1]  TRUE FALSE  TRUE  TRUE
> = Controlla se ogni elemento del primo vettore è maggiore o uguale all'elemento corrispondente del secondo vettore.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>=t)

produce il seguente risultato:

[1] FALSE  TRUE FALSE  TRUE
! = Controlla se ogni elemento del primo vettore è diverso dall'elemento corrispondente del secondo vettore.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v!=t)

produce il seguente risultato:

[1]  TRUE  TRUE  TRUE FALSE

Operatori logici

La tabella seguente mostra gli operatori logici supportati dal linguaggio R. È applicabile solo a vettori di tipo logico, numerico o complesso. Tutti i numeri maggiori di 1 sono considerati come valore logico VERO.

Ciascun elemento del primo vettore viene confrontato con l'elemento corrispondente del secondo vettore. Il risultato del confronto è un valore booleano.

Operatore Descrizione Esempio
& Si chiama operatore AND logico per elementi. Combina ogni elemento del primo vettore con l'elemento corrispondente del secondo vettore e fornisce un output TRUE se entrambi gli elementi sono TRUE.
v <- c(3,1,TRUE,2+3i)
t <- c(4,1,FALSE,2+3i)
print(v&t)

produce il seguente risultato:

[1]  TRUE  TRUE FALSE  TRUE
| Si chiama operatore OR logico per elemento. Combina ogni elemento del primo vettore con l'elemento corrispondente del secondo vettore e fornisce un output VERO se uno degli elementi è VERO.
v <- c(3,0,TRUE,2+2i)
t <- c(4,0,FALSE,2+3i)
print(v|t)

produce il seguente risultato:

[1]  TRUE FALSE  TRUE  TRUE
! Si chiama operatore NOT logico. Prende ogni elemento del vettore e fornisce il valore logico opposto.
v <- c(3,0,TRUE,2+2i)
print(!v)

produce il seguente risultato:

[1] FALSE  TRUE FALSE FALSE

L'operatore logico && e || considera solo il primo elemento dei vettori e fornisce come output un vettore di singolo elemento.

Operatore Descrizione Esempio
&& Chiamato operatore AND logico. Prende il primo elemento di entrambi i vettori e fornisce il TRUE solo se entrambi sono TRUE.
v <- c(3,0,TRUE,2+2i)
t <- c(1,3,TRUE,2+3i)
print(v&&t)

produce il seguente risultato:

[1] TRUE
|| Chiamato operatore OR logico. Prende il primo elemento di entrambi i vettori e fornisce il VERO se uno di essi è VERO.
v <- c(0,0,TRUE,2+2i)
t <- c(0,3,TRUE,2+3i)
print(v||t)

produce il seguente risultato:

[1] FALSE

Operatori di assegnazione

Questi operatori vengono utilizzati per assegnare valori ai vettori.

Operatore Descrizione Esempio

<-

o

=

o

<< -

Chiamato Assegnazione di sinistra
v1 <- c(3,1,TRUE,2+3i)
v2 <<- c(3,1,TRUE,2+3i)
v3 = c(3,1,TRUE,2+3i)
print(v1)
print(v2)
print(v3)

produce il seguente risultato:

[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

->

o

- >>

Chiamato incarico corretto
c(3,1,TRUE,2+3i) -> v1
c(3,1,TRUE,2+3i) ->> v2 
print(v1)
print(v2)

produce il seguente risultato:

[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

Operatori vari

Questi operatori sono utilizzati per scopi specifici e non per calcoli matematici o logici generali.

Operatore Descrizione Esempio
: Operatore del colon. Crea la serie di numeri in sequenza per un vettore.
v <- 2:8
print(v)

produce il seguente risultato:

[1] 2 3 4 5 6 7 8
%in% Questo operatore viene utilizzato per identificare se un elemento appartiene a un vettore.
v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t) 
print(v2 %in% t)

produce il seguente risultato:

[1] TRUE
[1] FALSE
% *% Questo operatore viene utilizzato per moltiplicare una matrice con la sua trasposizione.
M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

produce il seguente risultato:

[,1] [,2]
[1,]   65   82
[2,]   82  117

Le strutture decisionali richiedono che il programmatore specifichi una o più condizioni che devono essere valutate o testate dal programma, insieme a una o più istruzioni da eseguire se la condizione è determinata truee, facoltativamente, altre istruzioni da eseguire se si determina che la condizione è false.

Di seguito è riportata la forma generale di una tipica struttura decisionale presente nella maggior parte dei linguaggi di programmazione:

R fornisce i seguenti tipi di dichiarazioni sul processo decisionale. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Sr.No. Dichiarazione e descrizione
1 istruzione if

Un if L'istruzione consiste in un'espressione booleana seguita da una o più istruzioni.

2 if ... else dichiarazione

Un if L'istruzione può essere seguita da un opzionale else istruzione, che viene eseguita quando l'espressione booleana è falsa.

3 istruzione switch

UN switch consente di verificare l'uguaglianza di una variabile rispetto a un elenco di valori.

Potrebbe esserci una situazione in cui è necessario eseguire un blocco di codice più volte. In generale, le istruzioni vengono eseguite in sequenza. La prima istruzione in una funzione viene eseguita per prima, seguita dalla seconda e così via.

I linguaggi di programmazione forniscono varie strutture di controllo che consentono percorsi di esecuzione più complicati.

Un'istruzione loop ci consente di eseguire un'istruzione o un gruppo di istruzioni più volte e la seguente è la forma generale di un'istruzione loop nella maggior parte dei linguaggi di programmazione:

Il linguaggio di programmazione R fornisce i seguenti tipi di loop per gestire i requisiti di loop. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Sr.No. Tipo e descrizione del loop
1 ripetere il ciclo

Esegue una sequenza di istruzioni più volte e abbrevia il codice che gestisce la variabile del ciclo.

2 while loop

Ripete un'istruzione o un gruppo di istruzioni finché una determinata condizione è vera. Verifica la condizione prima di eseguire il corpo del ciclo.

3 per loop

Come un'istruzione while, tranne per il fatto che verifica la condizione alla fine del corpo del ciclo.

Dichiarazioni di controllo del loop

Le istruzioni di controllo del ciclo cambiano l'esecuzione dalla sua sequenza normale. Quando l'esecuzione esce da un ambito, tutti gli oggetti automatici creati in tale ambito vengono eliminati.

R supporta le seguenti istruzioni di controllo. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Sr.No. Dichiarazione di controllo e descrizione
1 dichiarazione di interruzione

Termina il loop istruzione e trasferisce l'esecuzione all'istruzione immediatamente successiva al ciclo.

2 Prossima dichiarazione

Il next L'istruzione simula il comportamento dell'interruttore R.

Una funzione è un insieme di istruzioni organizzate insieme per eseguire un'attività specifica. R ha un gran numero di funzioni integrate e l'utente può creare le proprie funzioni.

In R, una funzione è un oggetto quindi l'interprete R è in grado di passare il controllo alla funzione, insieme agli argomenti che potrebbero essere necessari affinché la funzione compia le azioni.

La funzione a sua volta svolge il suo compito e restituisce il controllo all'interprete così come qualsiasi risultato che può essere memorizzato in altri oggetti.

Definizione di funzione

Una funzione R viene creata utilizzando la parola chiave function. La sintassi di base della definizione di una funzione R è la seguente:

function_name <- function(arg_1, arg_2, ...) {
   Function body 
}

Componenti della funzione

Le diverse parti di una funzione sono:

  • Function Name- Questo è il nome effettivo della funzione. È memorizzato nell'ambiente R come un oggetto con questo nome.

  • Arguments- Un argomento è un segnaposto. Quando viene invocata una funzione, si passa un valore all'argomento. Gli argomenti sono facoltativi; ovvero, una funzione non può contenere argomenti. Anche gli argomenti possono avere valori predefiniti.

  • Function Body - Il corpo della funzione contiene una raccolta di istruzioni che definisce cosa fa la funzione.

  • Return Value - Il valore di ritorno di una funzione è l'ultima espressione nel corpo della funzione da valutare.

R ne ha molti in-builtfunzioni che possono essere richiamate direttamente nel programma senza prima definirle. Possiamo anche creare e utilizzare le nostre funzioni denominateuser defined funzioni.

Funzione incorporata

Semplici esempi di funzioni integrate sono seq(), mean(), max(), sum(x) e paste(...)ecc. Vengono richiamati direttamente dai programmi scritti dall'utente. È possibile fare riferimento alle funzioni R più utilizzate.

# Create a sequence of numbers from 32 to 44.
print(seq(32,44))

# Find mean of numbers from 25 to 82.
print(mean(25:82))

# Find sum of numbers frm 41 to 68.
print(sum(41:68))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 32 33 34 35 36 37 38 39 40 41 42 43 44
[1] 53.5
[1] 1526

Funzione definita dall'utente

Possiamo creare funzioni definite dall'utente in R. Sono specifiche per ciò che un utente desidera e una volta create possono essere utilizzate come le funzioni integrate. Di seguito è riportato un esempio di come viene creata e utilizzata una funzione.

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

Chiamare una funzione

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

# Call the function new.function supplying 6 as an argument.
new.function(6)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36

Chiamare una funzione senza un argomento

# Create a function without an argument.
new.function <- function() {
   for(i in 1:5) {
      print(i^2)
   }
}	

# Call the function without supplying an argument.
new.function()

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25

Chiamare una funzione con valori di argomento (per posizione e nome)

Gli argomenti di una chiamata di funzione possono essere forniti nella stessa sequenza definita nella funzione oppure possono essere forniti in una sequenza diversa ma assegnati ai nomi degli argomenti.

# Create a function with arguments.
new.function <- function(a,b,c) {
   result <- a * b + c
   print(result)
}

# Call the function by position of arguments.
new.function(5,3,11)

# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 26
[1] 58

Chiamata a una funzione con argomento predefinito

Possiamo definire il valore degli argomenti nella definizione della funzione e chiamare la funzione senza fornire alcun argomento per ottenere il risultato predefinito. Ma possiamo anche chiamare tali funzioni fornendo nuovi valori dell'argomento e ottenere un risultato non predefinito.

# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
   result <- a * b
   print(result)
}

# Call the function without giving any argument.
new.function()

# Call the function with giving new values of the argument.
new.function(9,5)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 18
[1] 45

Valutazione pigra della funzione

Gli argomenti delle funzioni vengono valutati pigramente, il che significa che vengono valutati solo quando necessario dal corpo della funzione.

# Create a function with arguments.
new.function <- function(a, b) {
   print(a^2)
   print(a)
   print(b)
}

# Evaluate the function without supplying one of the arguments.
new.function(6)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 36
[1] 6
Error in print(b) : argument "b" is missing, with no default

Qualsiasi valore scritto all'interno di una coppia di virgolette singole o doppie in R viene considerato come una stringa. Internamente R memorizza ogni stringa tra virgolette doppie, anche quando le crei con virgolette singole.

Regole applicate nella costruzione di stringhe

  • Le virgolette all'inizio e alla fine di una stringa devono essere entrambe virgolette doppie o entrambe virgolette singole. Non possono essere mescolati.

  • Le virgolette doppie possono essere inserite in una stringa che inizia e finisce con virgolette singole.

  • Le virgolette singole possono essere inserite in una stringa che inizia e finisce con virgolette doppie.

  • Le virgolette doppie non possono essere inserite in una stringa che inizia e finisce con virgolette doppie.

  • Non è possibile inserire virgolette singole in una stringa che inizia e finisce con virgolette singole.

Esempi di stringhe valide

I seguenti esempi chiariscono le regole sulla creazione di una stringa in R.

a <- 'Start and end with single quote'
print(a)

b <- "Start and end with double quotes"
print(b)

c <- "single quote ' in between double quotes"
print(c)

d <- 'Double quotes " in between single quote'
print(d)

Quando viene eseguito il codice sopra, otteniamo il seguente output:

[1] "Start and end with single quote"
[1] "Start and end with double quotes"
[1] "single quote ' in between double quote"
[1] "Double quote \" in between single quote"

Esempi di stringhe non valide

e <- 'Mixed quotes" 
print(e)

f <- 'Single quote ' inside single quote'
print(f)

g <- "Double quotes " inside double quotes"
print(g)

Quando eseguiamo lo script non riesce a fornire i risultati seguenti.

Error: unexpected symbol in:
"print(e)
f <- 'Single"
Execution halted

Manipolazione delle stringhe

Concatenazione di stringhe - funzione paste ()

Molte stringhe in R vengono combinate usando il paste()funzione. Può richiedere un numero qualsiasi di argomenti per essere combinati insieme.

Sintassi

La sintassi di base per la funzione Incolla è:

paste(..., sep = " ", collapse = NULL)

Di seguito la descrizione dei parametri utilizzati:

  • ... rappresenta un numero qualsiasi di argomenti da combinare.

  • seprappresenta qualsiasi separatore tra gli argomenti. È opzionale.

  • collapseviene utilizzato per eliminare lo spazio tra due stringhe. Ma non lo spazio all'interno di due parole di una stringa.

Esempio

a <- "Hello"
b <- 'How'
c <- "are you? "

print(paste(a,b,c))

print(paste(a,b,c, sep = "-"))

print(paste(a,b,c, sep = "", collapse = ""))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "Hello How are you? "
[1] "Hello-How-are you? "
[1] "HelloHoware you? "

Formattazione di numeri e stringhe - funzione format ()

Numeri e stringhe possono essere formattati con uno stile specifico utilizzando format() funzione.

Sintassi

La sintassi di base per la funzione formato è:

format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))

Di seguito la descrizione dei parametri utilizzati:

  • x è l'input vettoriale.

  • digits è il numero totale di cifre visualizzate.

  • nsmall è il numero minimo di cifre a destra del separatore decimale.

  • scientific è impostato su TRUE per visualizzare la notazione scientifica.

  • width indica la larghezza minima da visualizzare riempiendo gli spazi all'inizio.

  • justify è la visualizzazione della stringa a sinistra, a destra o al centro.

Esempio

# Total number of digits displayed. Last digit rounded off.
result <- format(23.123456789, digits = 9)
print(result)

# Display numbers in scientific notation.
result <- format(c(6, 13.14521), scientific = TRUE)
print(result)

# The minimum number of digits to the right of the decimal point.
result <- format(23.47, nsmall = 5)
print(result)

# Format treats everything as a string.
result <- format(6)
print(result)

# Numbers are padded with blank in the beginning for width.
result <- format(13.7, width = 6)
print(result)

# Left justify strings.
result <- format("Hello", width = 8, justify = "l")
print(result)

# Justfy string with center.
result <- format("Hello", width = 8, justify = "c")
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "23.1234568"
[1] "6.000000e+00" "1.314521e+01"
[1] "23.47000"
[1] "6"
[1] "  13.7"
[1] "Hello   "
[1] " Hello  "

Conteggio del numero di caratteri in una funzione stringa - nchar ()

Questa funzione conta il numero di caratteri inclusi gli spazi in una stringa.

Sintassi

La sintassi di base per la funzione nchar () è:

nchar(x)

Di seguito la descrizione dei parametri utilizzati:

  • x è l'input vettoriale.

Esempio

result <- nchar("Count the number of characters")
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 30

Modifica delle maiuscole e minuscole - funzioni toupper () e tolower ()

Queste funzioni cambiano il caso dei caratteri di una stringa.

Sintassi

La sintassi di base per le funzioni toupper () e tolower () è:

toupper(x)
tolower(x)

Di seguito la descrizione dei parametri utilizzati:

  • x è l'input vettoriale.

Esempio

# Changing to Upper case.
result <- toupper("Changing To Upper")
print(result)

# Changing to lower case.
result <- tolower("Changing To Lower")
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "CHANGING TO UPPER"
[1] "changing to lower"

Estrazione di parti di una funzione stringa - sottostringa ()

Questa funzione estrae parti di una stringa.

Sintassi

La sintassi di base per la funzione substring () è:

substring(x,first,last)

Di seguito la descrizione dei parametri utilizzati:

  • x è l'input del vettore di caratteri.

  • first è la posizione del primo carattere da estrarre.

  • last è la posizione dell'ultimo carattere da estrarre.

Esempio

# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "act"

I vettori sono gli oggetti dati R più basilari e ci sono sei tipi di vettori atomici. Sono logici, interi, doppi, complessi, di carattere e grezzi.

Creazione di vettore

Vettore di elemento singolo

Anche quando scrivi un solo valore in R, diventa un vettore di lunghezza 1 e appartiene a uno dei tipi di vettore sopra.

# Atomic vector of type character.
print("abc");

# Atomic vector of type double.
print(12.5)

# Atomic vector of type integer.
print(63L)

# Atomic vector of type logical.
print(TRUE)

# Atomic vector of type complex.
print(2+3i)

# Atomic vector of type raw.
print(charToRaw('hello'))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "abc"
[1] 12.5
[1] 63
[1] TRUE
[1] 2+3i
[1] 68 65 6c 6c 6f

Vettore di più elementi

Using colon operator with numeric data

# Creating a sequence from 5 to 13.
v <- 5:13
print(v)

# Creating a sequence from 6.6 to 12.6.
v <- 6.6:12.6
print(v)

# If the final element specified does not belong to the sequence then it is discarded.
v <- 3.8:11.4
print(v)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1]  5  6  7  8  9 10 11 12 13
[1]  6.6  7.6  8.6  9.6 10.6 11.6 12.6
[1]  3.8  4.8  5.8  6.8  7.8  8.8  9.8 10.8

Using sequence (Seq.) operator

# Create vector with elements from 5 to 9 incrementing by 0.4.
print(seq(5, 9, by = 0.4))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0

Using the c() function

I valori non di carattere vengono forzati al tipo di carattere se uno degli elementi è un carattere.

# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "apple" "red"   "5"     "TRUE"

Accesso agli elementi vettoriali

Gli elementi di un vettore sono accessibili tramite l'indicizzazione. Il[ ] bracketsvengono utilizzati per l'indicizzazione. L'indicizzazione inizia con la posizione 1. Dare un valore negativo nell'indice elimina quell'elemento dal risultato.TRUE, FALSE o 0 e 1 può essere utilizzato anche per l'indicizzazione.

# Accessing vector elements using position.
t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)

# Accessing vector elements using logical indexing.
v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)

# Accessing vector elements using negative indexing.
x <- t[c(-2,-5)]
print(x)

# Accessing vector elements using 0/1 indexing.
y <- t[c(0,0,0,0,0,0,1)]
print(y)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "Mon" "Tue" "Fri"
[1] "Sun" "Fri"
[1] "Sun" "Tue" "Wed" "Fri" "Sat"
[1] "Sun"

Manipolazione vettoriale

Aritmetica vettoriale

È possibile aggiungere, sottrarre, moltiplicare o dividere due vettori della stessa lunghezza, ottenendo il risultato come output vettoriale.

# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)

# Vector addition.
add.result <- v1+v2
print(add.result)

# Vector subtraction.
sub.result <- v1-v2
print(sub.result)

# Vector multiplication.
multi.result <- v1*v2
print(multi.result)

# Vector division.
divi.result <- v1/v2
print(divi.result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1]  7 19  4 13  1 13
[1] -1 -3  4 -3 -1  9
[1] 12 88  0 40  0 22
[1] 0.7500000 0.7272727       Inf 0.6250000 0.0000000 5.5000000

Riciclaggio di elementi vettoriali

Se applichiamo operazioni aritmetiche a due vettori di lunghezza diversa, gli elementi del vettore più corto vengono riciclati per completare le operazioni.

v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)

add.result <- v1+v2
print(add.result)

sub.result <- v1-v2
print(sub.result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1]  7 19  8 16  4 22
[1] -1 -3  0 -6 -4  0

Ordinamento degli elementi vettoriali

Gli elementi in un vettore possono essere ordinati utilizzando il sort() funzione.

v <- c(3,8,4,5,0,11, -9, 304)

# Sort the elements of the vector.
sort.result <- sort(v)
print(sort.result)

# Sort the elements in the reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

# Sorting character vectors.
v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)

# Sorting character vectors in reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1]  -9   0   3   4   5   8  11 304
[1] 304  11   8   5   4   3   0  -9
[1] "Blue"   "Red"    "violet" "yellow"
[1] "yellow" "violet" "Red"    "Blue"

Le liste sono gli oggetti R che contengono elementi di diverso tipo come - numeri, stringhe, vettori e un altro elenco al suo interno. Un elenco può anche contenere una matrice o una funzione come suoi elementi. L'elenco viene creato utilizzandolist() funzione.

Creazione di un elenco

Di seguito è riportato un esempio per creare un elenco contenente stringhe, numeri, vettori e valori logici.

# Create a list containing strings, numbers, vectors and a logical
# values.
list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
print(list_data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[[1]]
[1] "Red"

[[2]]
[1] "Green"

[[3]]
[1] 21 32 11

[[4]]
[1] TRUE

[[5]]
[1] 51.23

[[6]]
[1] 119.1

Denominazione degli elementi dell'elenco

È possibile assegnare nomi agli elementi dell'elenco ed è possibile accedervi utilizzando questi nomi.

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Show the list.
print(list_data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

$`1st_Quarter` [1] "Jan" "Feb" "Mar" $A_Matrix
     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

$A_Inner_list $A_Inner_list[[1]]
[1] "green"

$A_Inner_list[[2]]
[1] 12.3

Accesso agli elementi dell'elenco

È possibile accedere agli elementi della lista tramite l'indice dell'elemento nella lista. In caso di elenchi denominati è possibile accedervi anche utilizzando i nomi.

Continuiamo a utilizzare l'elenco nell'esempio precedente:

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Access the first element of the list.
print(list_data[1])

# Access the thrid element. As it is also a list, all its elements will be printed.
print(list_data[3])

# Access the list element using the name of the element.
print(list_data$A_Matrix)

Quando eseguiamo il codice sopra, produce il seguente risultato:

$`1st_Quarter` [1] "Jan" "Feb" "Mar" $A_Inner_list
$A_Inner_list[[1]] [1] "green" $A_Inner_list[[2]]
[1] 12.3

     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

Manipolazione degli elementi dell'elenco

Possiamo aggiungere, eliminare e aggiornare gli elementi dell'elenco come mostrato di seguito. Possiamo aggiungere ed eliminare elementi solo alla fine di un elenco. Ma possiamo aggiornare qualsiasi elemento.

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Add element at the end of the list.
list_data[4] <- "New element"
print(list_data[4])

# Remove the last element.
list_data[4] <- NULL

# Print the 4th Element.
print(list_data[4])

# Update the 3rd Element.
list_data[3] <- "updated element"
print(list_data[3])

Quando eseguiamo il codice sopra, produce il seguente risultato:

[[1]]
[1] "New element"

$<NA> NULL $`A Inner list`
[1] "updated element"

Unione di elenchi

Puoi unire molti elenchi in un elenco inserendo tutti gli elenchi all'interno di una funzione list ().

# Create two lists.
list1 <- list(1,2,3)
list2 <- list("Sun","Mon","Tue")

# Merge the two lists.
merged.list <- c(list1,list2)

# Print the merged list.
print(merged.list)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] "Sun"

[[5]]
[1] "Mon"

[[6]]
[1] "Tue"

Conversione da elenco a vettore

Un elenco può essere convertito in un vettore in modo che gli elementi del vettore possano essere utilizzati per ulteriori manipolazioni. Tutte le operazioni aritmetiche sui vettori possono essere applicate dopo che l'elenco è stato convertito in vettori. Per fare questa conversione, usiamo ilunlist()funzione. Prende l'elenco come input e produce un vettore.

# Create lists.
list1 <- list(1:5)
print(list1)

list2 <-list(10:14)
print(list2)

# Convert the lists to vectors.
v1 <- unlist(list1)
v2 <- unlist(list2)

print(v1)
print(v2)

# Now add the vectors
result <- v1+v2
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[[1]]
[1] 1 2 3 4 5

[[1]]
[1] 10 11 12 13 14

[1] 1 2 3 4 5
[1] 10 11 12 13 14
[1] 11 13 15 17 19

Le matrici sono gli oggetti R in cui gli elementi sono disposti in un layout rettangolare bidimensionale. Contengono elementi degli stessi tipi atomici. Sebbene possiamo creare una matrice contenente solo caratteri o solo valori logici, non sono di grande utilità. Utilizziamo matrici contenenti elementi numerici da utilizzare nei calcoli matematici.

Una matrice viene creata utilizzando il matrix() funzione.

Sintassi

La sintassi di base per creare una matrice in R è:

matrix(data, nrow, ncol, byrow, dimnames)

Di seguito la descrizione dei parametri utilizzati:

  • data è il vettore di input che diventa l'elemento dati della matrice.

  • nrow è il numero di righe da creare.

  • ncol è il numero di colonne da creare.

  • byrowè un indizio logico. Se TRUE, gli elementi del vettore di input sono disposti per riga.

  • dimname sono i nomi assegnati alle righe e alle colonne.

Esempio

Crea una matrice prendendo come input un vettore di numeri.

# Elements are arranged sequentially by row.
M <- matrix(c(3:14), nrow = 4, byrow = TRUE)
print(M)

# Elements are arranged sequentially by column.
N <- matrix(c(3:14), nrow = 4, byrow = FALSE)
print(N)

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[,1] [,2] [,3]
[1,]    3    4    5
[2,]    6    7    8
[3,]    9   10   11
[4,]   12   13   14
     [,1] [,2] [,3]
[1,]    3    7   11
[2,]    4    8   12
[3,]    5    9   13
[4,]    6   10   14
     col1 col2 col3
row1    3    4    5
row2    6    7    8
row3    9   10   11
row4   12   13   14

Accesso agli elementi di una matrice

È possibile accedere agli elementi di una matrice utilizzando l'indice di colonna e riga dell'elemento. Consideriamo la matrice P sopra per trovare gli elementi specifici di seguito.

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

# Create the matrix.
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))

# Access the element at 3rd column and 1st row.
print(P[1,3])

# Access the element at 2nd column and 4th row.
print(P[4,2])

# Access only the  2nd row.
print(P[2,])

# Access only the 3rd column.
print(P[,3])

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 5
[1] 13
col1 col2 col3 
   6    7    8 
row1 row2 row3 row4 
   5    8   11   14

Calcoli di matrici

Varie operazioni matematiche vengono eseguite sulle matrici utilizzando gli operatori R. Anche il risultato dell'operazione è una matrice.

Le dimensioni (numero di righe e colonne) devono essere le stesse per le matrici coinvolte nell'operazione.

Addizione e sottrazione di matrici

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Add the matrices.
result <- matrix1 + matrix2
cat("Result of addition","\n")
print(result)

# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","\n")
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of addition 
     [,1] [,2] [,3]
[1,]    8   -1    5
[2,]   11   13   10
Result of subtraction 
     [,1] [,2] [,3]
[1,]   -2   -1   -1
[2,]    7   -5    2

Moltiplicazione e divisione di matrici

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Multiply the matrices.
result <- matrix1 * matrix2
cat("Result of multiplication","\n")
print(result)

# Divide the matrices
result <- matrix1 / matrix2
cat("Result of division","\n")
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of multiplication 
     [,1] [,2] [,3]
[1,]   15    0    6
[2,]   18   36   24
Result of division 
     [,1]      [,2]      [,3]
[1,]  0.6      -Inf 0.6666667
[2,]  4.5 0.4444444 1.5000000

Gli array sono gli oggetti dati R che possono memorizzare dati in più di due dimensioni. Ad esempio: se creiamo un array di dimensioni (2, 3, 4), vengono create 4 matrici rettangolari ciascuna con 2 righe e 3 colonne. Gli array possono memorizzare solo il tipo di dati.

Un array viene creato utilizzando il array()funzione. Prende i vettori come input e utilizza i valori indim parametro per creare un array.

Esempio

L'esempio seguente crea una matrice di due matrici 3x3 ciascuna con 3 righe e 3 colonne.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

Denominazione di colonne e righe

Possiamo dare nomi alle righe, colonne e matrici nell'array usando il dimnames parametro.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
   matrix.names))
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

, , Matrix1

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

, , Matrix2

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

Accesso agli elementi dell'array

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
   column.names, matrix.names))

# Print the third row of the second matrix of the array.
print(result[3,,2])

# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])

# Print the 2nd Matrix.
print(result[,,2])

Quando eseguiamo il codice sopra, produce il seguente risultato:

COL1 COL2 COL3 
   3   12   15 
[1] 13
     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

Manipolazione di elementi di array

Essendo l'array composto da matrici in più dimensioni, le operazioni sugli elementi di array si effettuano accedendo agli elementi delle matrici.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
array1 <- array(c(vector1,vector2),dim = c(3,3,2))

# Create two vectors of different lengths.
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))

# create matrices from these arrays.
matrix1 <- array1[,,2]
matrix2 <- array2[,,2]

# Add the matrices.
result <- matrix1+matrix2
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[,1] [,2] [,3]
[1,]   10   20   26
[2,]   18   22   28
[3,]    6   24   30

Calcoli sugli elementi dell'array

Possiamo fare calcoli attraverso gli elementi in un array usando il apply() funzione.

Sintassi

apply(x, margin, fun)

Di seguito la descrizione dei parametri utilizzati:

  • x è un array.

  • margin è il nome del set di dati utilizzato.

  • fun è la funzione da applicare agli elementi dell'array.

Esempio

Usiamo la funzione apply () di seguito per calcolare la somma degli elementi nelle righe di un array su tutte le matrici.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
new.array <- array(c(vector1,vector2),dim = c(3,3,2))
print(new.array)

# Use apply to calculate the sum of the rows across all the matrices.
result <- apply(new.array, c(1), sum)
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

[1] 56 68 60

I fattori sono gli oggetti dati che vengono utilizzati per classificare i dati e archiviarli come livelli. Possono memorizzare sia stringhe che numeri interi. Sono utili nelle colonne che hanno un numero limitato di valori univoci. Come "Male," Female "e True, False ecc. Sono utili nell'analisi dei dati per la modellazione statistica.

I fattori vengono creati utilizzando il factor () prendendo un vettore come input.

Esempio

# Create a vector as input.
data <- c("East","West","East","North","North","East","West","West","West","East","North")

print(data)
print(is.factor(data))

# Apply the factor function.
factor_data <- factor(data)

print(factor_data)
print(is.factor(factor_data))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "East"  "West"  "East"  "North" "North" "East"  "West"  "West"  "West"  "East" "North"
[1] FALSE
[1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
[1] TRUE

Fattori nel frame di dati

Quando si crea un frame di dati con una colonna di dati di testo, R tratta la colonna di testo come dati categoriali e crea fattori su di essa.

# Create the vectors for data frame.
height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")

# Create the data frame.
input_data <- data.frame(height,weight,gender)
print(input_data)

# Test if the gender column is a factor.
print(is.factor(input_data$gender)) # Print the gender column so see the levels. print(input_data$gender)

Quando eseguiamo il codice sopra, produce il seguente risultato:

height weight gender
1    132     48   male
2    151     49   male
3    162     66 female
4    139     53 female
5    166     67   male
6    147     52 female
7    122     40   male
[1] TRUE
[1] male   male   female female male   female male  
Levels: female male

Modifica dell'ordine dei livelli

L'ordine dei livelli in un fattore può essere modificato applicando nuovamente la funzione fattore con un nuovo ordine dei livelli.

data <- c("East","West","East","North","North","East","West",
   "West","West","East","North")
# Create the factors
factor_data <- factor(data)
print(factor_data)

# Apply the factor function with required order of the level.
new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
 [1] East  West  East  North North East  West  West  West  East  North
Levels: East West North

Generazione di livelli di fattore

Possiamo generare livelli di fattore utilizzando il gl()funzione. Richiede due numeri interi come input che indica quanti livelli e quante volte ogni livello.

Sintassi

gl(n, k, labels)

Di seguito la descrizione dei parametri utilizzati:

  • n è un numero intero che fornisce il numero di livelli.

  • k è un numero intero che fornisce il numero di repliche.

  • labels è un vettore di etichette per i livelli di fattore risultanti.

Esempio

v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
print(v)

Quando eseguiamo il codice sopra, produce il seguente risultato:

Tampa   Tampa   Tampa   Tampa   Seattle Seattle Seattle Seattle Boston 
[10] Boston  Boston  Boston 
Levels: Tampa Seattle Boston

Un data frame è una tabella o una struttura a matrice bidimensionale in cui ogni colonna contiene i valori di una variabile e ogni riga contiene un insieme di valori da ogni colonna.

Di seguito sono riportate le caratteristiche di un data frame.

  • I nomi delle colonne non devono essere vuoti.
  • I nomi delle righe dovrebbero essere univoci.
  • I dati memorizzati in un data frame possono essere di tipo numerico, di fattore o di carattere.
  • Ogni colonna dovrebbe contenere lo stesso numero di elementi di dati.

Crea frame di dati

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the data frame.			
print(emp.data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

emp_id    emp_name     salary     start_date
1     1     Rick        623.30     2012-01-01
2     2     Dan         515.20     2013-09-23
3     3     Michelle    611.00     2014-11-15
4     4     Ryan        729.00     2014-05-11
5     5     Gary        843.25     2015-03-27

Ottieni la struttura del data frame

La struttura del data frame può essere vista utilizzando str() funzione.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Get the structure of the data frame.
str(emp.data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

'data.frame':   5 obs. of  4 variables:
 $ emp_id : int 1 2 3 4 5 $ emp_name  : chr  "Rick" "Dan" "Michelle" "Ryan" ...
 $ salary : num 623 515 611 729 843 $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...

Riepilogo dei dati nel frame di dati

Il riepilogo statistico e la natura dei dati possono essere ottenuti applicando summary() funzione.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the summary.
print(summary(emp.data))

Quando eseguiamo il codice sopra, produce il seguente risultato:

emp_id    emp_name             salary        start_date        
 Min.   :1   Length:5           Min.   :515.2   Min.   :2012-01-01  
 1st Qu.:2   Class :character   1st Qu.:611.0   1st Qu.:2013-09-23  
 Median :3   Mode  :character   Median :623.3   Median :2014-05-11  
 Mean   :3                      Mean   :664.4   Mean   :2014-01-14  
 3rd Qu.:4                      3rd Qu.:729.0   3rd Qu.:2014-11-15  
 Max.   :5                      Max.   :843.2   Max.   :2015-03-27

Estrai dati dal frame di dati

Estrai una colonna specifica da un data frame utilizzando il nome della colonna.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract Specific columns.
result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

emp.data.emp_name emp.data.salary
1              Rick          623.30
2               Dan          515.20
3          Michelle          611.00
4              Ryan          729.00
5              Gary          843.25

Estrai le prime due righe e poi tutte le colonne

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract first two rows.
result <- emp.data[1:2,]
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

emp_id    emp_name   salary    start_date
1      1     Rick      623.3     2012-01-01
2      2     Dan       515.2     2013-09-23

Estrarre 3 ° e 5 ° fila con 2 ° e 4 ° colonna

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
	start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Extract 3rd and 5th row with 2nd and 4th column.
result <- emp.data[c(3,5),c(2,4)]
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

emp_name start_date
3 Michelle 2014-11-15
5     Gary 2015-03-27

Espandi Data Frame

Un data frame può essere espanso aggiungendo colonne e righe.

Aggiungi colonna

Basta aggiungere il vettore della colonna usando un nuovo nome di colonna.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Add the "dept" coulmn.
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)

Quando eseguiamo il codice sopra, produce il seguente risultato:

emp_id   emp_name    salary    start_date       dept
1     1    Rick        623.30    2012-01-01       IT
2     2    Dan         515.20    2013-09-23       Operations
3     3    Michelle    611.00    2014-11-15       IT
4     4    Ryan        729.00    2014-05-11       HR
5     5    Gary        843.25    2015-03-27       Finance

Aggiungi riga

Per aggiungere più righe in modo permanente a un data frame esistente, dobbiamo portare le nuove righe nella stessa struttura del data frame esistente e utilizzare il rbind() funzione.

Nell'esempio seguente creiamo un data frame con nuove righe e lo uniamo al data frame esistente per creare il data frame finale.

# Create the first data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   dept = c("IT","Operations","IT","HR","Finance"),
   stringsAsFactors = FALSE
)

# Create the second data frame
emp.newdata <- 	data.frame(
   emp_id = c (6:8), 
   emp_name = c("Rasmi","Pranab","Tusar"),
   salary = c(578.0,722.5,632.8), 
   start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
   dept = c("IT","Operations","Fianance"),
   stringsAsFactors = FALSE
)

# Bind the two data frames.
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)

Quando eseguiamo il codice sopra, produce il seguente risultato:

emp_id     emp_name    salary     start_date       dept
1      1     Rick        623.30     2012-01-01       IT
2      2     Dan         515.20     2013-09-23       Operations
3      3     Michelle    611.00     2014-11-15       IT
4      4     Ryan        729.00     2014-05-11       HR
5      5     Gary        843.25     2015-03-27       Finance
6      6     Rasmi       578.00     2013-05-21       IT
7      7     Pranab      722.50     2013-07-30       Operations
8      8     Tusar       632.80     2014-06-17       Fianance

I pacchetti R sono una raccolta di funzioni R, codice conforme e dati di esempio. Sono memorizzati in una directory chiamata"library"nell'ambiente R. Per impostazione predefinita, R installa una serie di pacchetti durante l'installazione. Più pacchetti vengono aggiunti in seguito, quando sono necessari per uno scopo specifico. Quando si avvia la console R, per impostazione predefinita sono disponibili solo i pacchetti predefiniti. Altri pacchetti già installati devono essere caricati esplicitamente per essere utilizzati dal programma R che li utilizzerà.

Tutti i pacchetti disponibili in linguaggio R sono elencati in Pacchetti R.

Di seguito è riportato un elenco di comandi da utilizzare per controllare, verificare e utilizzare i pacchetti R.

Controllare i pacchetti R disponibili

Ottieni percorsi di libreria contenenti pacchetti R.

.libPaths()

Quando eseguiamo il codice precedente, produce il seguente risultato. Può variare a seconda delle impostazioni locali del tuo PC.

[2] "C:/Program Files/R/R-3.2.2/library"

Ottieni l'elenco di tutti i pacchetti installati

library()

Quando eseguiamo il codice precedente, produce il seguente risultato. Può variare a seconda delle impostazioni locali del tuo PC.

Packages in library ‘C:/Program Files/R/R-3.2.2/library’:

base                    The R Base Package
boot                    Bootstrap Functions (Originally by Angelo Canty
                        for S)
class                   Functions for Classification
cluster                 "Finding Groups in Data": Cluster Analysis
                        Extended Rousseeuw et al.
codetools               Code Analysis Tools for R
compiler                The R Compiler Package
datasets                The R Datasets Package
foreign                 Read Data Stored by 'Minitab', 'S', 'SAS',
                        'SPSS', 'Stata', 'Systat', 'Weka', 'dBase', ...
graphics                The R Graphics Package
grDevices               The R Graphics Devices and Support for Colours
                        and Fonts
grid                    The Grid Graphics Package
KernSmooth              Functions for Kernel Smoothing Supporting Wand
                        & Jones (1995)
lattice                 Trellis Graphics for R
MASS                    Support Functions and Datasets for Venables and
                        Ripley's MASS
Matrix                  Sparse and Dense Matrix Classes and Methods
methods                 Formal Methods and Classes
mgcv                    Mixed GAM Computation Vehicle with GCV/AIC/REML
                        Smoothness Estimation
nlme                    Linear and Nonlinear Mixed Effects Models
nnet                    Feed-Forward Neural Networks and Multinomial
                        Log-Linear Models
parallel                Support for Parallel computation in R
rpart                   Recursive Partitioning and Regression Trees
spatial                 Functions for Kriging and Point Pattern
                        Analysis
splines                 Regression Spline Functions and Classes
stats                   The R Stats Package
stats4                  Statistical Functions using S4 Classes
survival                Survival Analysis
tcltk                   Tcl/Tk Interface
tools                   Tools for Package Development
utils                   The R Utils Package

Ottieni tutti i pacchetti attualmente caricati nell'ambiente R.

search()

Quando eseguiamo il codice precedente, produce il seguente risultato. Può variare a seconda delle impostazioni locali del tuo PC.

[1] ".GlobalEnv"        "package:stats"     "package:graphics" 
[4] "package:grDevices" "package:utils"     "package:datasets" 
[7] "package:methods"   "Autoloads"         "package:base"

Installa un nuovo pacchetto

Esistono due modi per aggiungere nuovi pacchetti R. Uno sta installando direttamente dalla directory CRAN e un altro sta scaricando il pacchetto sul tuo sistema locale e installandolo manualmente.

Installa direttamente da CRAN

Il comando seguente ottiene i pacchetti direttamente dalla pagina Web di CRAN e installa il pacchetto nell'ambiente R. Potrebbe essere richiesto di scegliere il mirror più vicino. Scegli quello appropriato alla tua posizione.

install.packages("Package Name")
 
# Install the package named "XML".
 install.packages("XML")

Installa il pacchetto manualmente

Vai al collegamento Pacchetti R per scaricare il pacchetto necessario. Salva il pacchetto come file.zip file in una posizione adatta nel sistema locale.

Ora puoi eseguire il seguente comando per installare questo pacchetto nell'ambiente R.

install.packages(file_name_with_path, repos = NULL, type = "source")

# Install the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

Carica il pacchetto nella libreria

Prima che un pacchetto possa essere utilizzato nel codice, deve essere caricato nell'ambiente R corrente. È inoltre necessario caricare un pacchetto già installato in precedenza ma non disponibile nell'ambiente corrente.

Un pacchetto viene caricato utilizzando il seguente comando:

library("package Name", lib.loc = "path to library")

# Load the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

Il rimodellamento dei dati in R riguarda la modifica del modo in cui i dati sono organizzati in righe e colonne. La maggior parte delle volte l'elaborazione dei dati in R viene eseguita prendendo i dati di input come frame di dati. È facile estrarre i dati dalle righe e dalle colonne di un frame di dati, ma ci sono situazioni in cui abbiamo bisogno del frame di dati in un formato diverso dal formato in cui lo abbiamo ricevuto. R ha molte funzioni per dividere, unire e modificare le righe in colonne e viceversa in un frame di dati.

Unione di colonne e righe in un frame di dati

Possiamo unire più vettori per creare un data frame usando il cbind()funzione. Inoltre possiamo unire due frame di dati usandorbind() funzione.

# Create vector objects.
city <- c("Tampa","Seattle","Hartford","Denver")
state <- c("FL","WA","CT","CO")
zipcode <- c(33602,98104,06161,80294)

# Combine above three vectors into one data frame.
addresses <- cbind(city,state,zipcode)

# Print a header.
cat("# # # # The First data frame\n") 

# Print the data frame.
print(addresses)

# Create another data frame with similar columns
new.address <- data.frame(
   city = c("Lowry","Charlotte"),
   state = c("CO","FL"),
   zipcode = c("80230","33949"),
   stringsAsFactors = FALSE
)

# Print a header.
cat("# # # The Second data frame\n") 

# Print the data frame.
print(new.address)

# Combine rows form both the data frames.
all.addresses <- rbind(addresses,new.address)

# Print a header.
cat("# # # The combined data frame\n") 

# Print the result.
print(all.addresses)

Quando eseguiamo il codice sopra, produce il seguente risultato:

# # # # The First data frame
     city       state zipcode
[1,] "Tampa"    "FL"  "33602"
[2,] "Seattle"  "WA"  "98104"
[3,] "Hartford" "CT"   "6161" 
[4,] "Denver"   "CO"  "80294"

# # # The Second data frame
       city       state   zipcode
1      Lowry      CO      80230
2      Charlotte  FL      33949

# # # The combined data frame
       city      state zipcode
1      Tampa     FL    33602
2      Seattle   WA    98104
3      Hartford  CT     6161
4      Denver    CO    80294
5      Lowry     CO    80230
6     Charlotte  FL    33949

Unione di frame di dati

Possiamo unire due frame di dati usando il merge()funzione. I frame di dati devono avere gli stessi nomi di colonna su cui avviene l'unione.

Nell'esempio seguente, consideriamo i set di dati sul diabete nelle donne indiane Pima disponibili nei nomi di libreria "MASS". uniamo i due set di dati in base ai valori di pressione sanguigna ("bp") e indice di massa corporea ("bmi"). Scegliendo queste due colonne per l'unione, i record in cui i valori di queste due variabili corrispondono in entrambi i set di dati vengono combinati insieme per formare un unico frame di dati.

library(MASS)
merged.Pima <- merge(x = Pima.te, y = Pima.tr,
   by.x = c("bp", "bmi"),
   by.y = c("bp", "bmi")
)
print(merged.Pima)
nrow(merged.Pima)

Quando eseguiamo il codice sopra, produce il seguente risultato:

bp  bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y
1  60 33.8       1   117     23 0.466    27     No       2   125     20 0.088
2  64 29.7       2    75     24 0.370    33     No       2   100     23 0.368
3  64 31.2       5   189     33 0.583    29    Yes       3   158     13 0.295
4  64 33.2       4   117     27 0.230    24     No       1    96     27 0.289
5  66 38.1       3   115     39 0.150    28     No       1   114     36 0.289
6  68 38.5       2   100     25 0.324    26     No       7   129     49 0.439
7  70 27.4       1   116     28 0.204    21     No       0   124     20 0.254
8  70 33.1       4    91     32 0.446    22     No       9   123     44 0.374
9  70 35.4       9   124     33 0.282    34     No       6   134     23 0.542
10 72 25.6       1   157     21 0.123    24     No       4    99     17 0.294
11 72 37.7       5    95     33 0.370    27     No       6   103     32 0.324
12 74 25.9       9   134     33 0.460    81     No       8   126     38 0.162
13 74 25.9       1    95     21 0.673    36     No       8   126     38 0.162
14 78 27.6       5    88     30 0.258    37     No       6   125     31 0.565
15 78 27.6      10   122     31 0.512    45     No       6   125     31 0.565
16 78 39.4       2   112     50 0.175    24     No       4   112     40 0.236
17 88 34.5       1   117     24 0.403    40    Yes       4   127     11 0.598
   age.y type.y
1     31     No
2     21     No
3     24     No
4     21     No
5     21     No
6     43    Yes
7     36    Yes
8     40     No
9     29    Yes
10    28     No
11    55     No
12    39     No
13    39     No
14    49    Yes
15    49    Yes
16    38     No
17    28     No
[1] 17

Fusione e colata

Uno degli aspetti più interessanti della programmazione R riguarda la modifica della forma dei dati in più passaggi per ottenere la forma desiderata. Vengono chiamate le funzioni utilizzate per farlomelt() e cast().

Consideriamo il dataset denominato navi presente nella libreria denominato "MASS".

library(MASS)
print(ships)

Quando eseguiamo il codice sopra, produce il seguente risultato:

type year   period   service   incidents
1     A   60     60        127         0
2     A   60     75         63         0
3     A   65     60       1095         3
4     A   65     75       1095         4
5     A   70     60       1512         6
.............
.............
8     A   75     75       2244         11
9     B   60     60      44882         39
10    B   60     75      17176         29
11    B   65     60      28609         58
............
............
17    C   60     60      1179          1
18    C   60     75       552          1
19    C   65     60       781          0
............
............

Sciogli i dati

Ora fondiamo i dati per organizzarli, convertendo tutte le colonne diverse da tipo e anno in più righe.

molten.ships <- melt(ships, id = c("type","year"))
print(molten.ships)

Quando eseguiamo il codice sopra, produce il seguente risultato:

type year  variable  value
1      A   60    period      60
2      A   60    period      75
3      A   65    period      60
4      A   65    period      75
............
............
9      B   60    period      60
10     B   60    period      75
11     B   65    period      60
12     B   65    period      75
13     B   70    period      60
...........
...........
41     A   60    service    127
42     A   60    service     63
43     A   65    service   1095
...........
...........
70     D   70    service   1208
71     D   75    service      0
72     D   75    service   2051
73     E   60    service     45
74     E   60    service      0
75     E   65    service    789
...........
...........
101    C   70    incidents    6
102    C   70    incidents    2
103    C   75    incidents    0
104    C   75    incidents    1
105    D   60    incidents    0
106    D   60    incidents    0
...........
...........

Cast the Molten Data

Possiamo trasformare i dati fusi in una nuova forma in cui viene creato l'aggregato di ogni tipo di nave per ogni anno. È fatto usando ilcast() funzione.

recasted.ship <- cast(molten.ships, type+year~variable,sum)
print(recasted.ship)

Quando eseguiamo il codice sopra, produce il seguente risultato:

type year  period  service  incidents
1     A   60    135       190      0
2     A   65    135      2190      7
3     A   70    135      4865     24
4     A   75    135      2244     11
5     B   60    135     62058     68
6     B   65    135     48979    111
7     B   70    135     20163     56
8     B   75    135      7117     18
9     C   60    135      1731      2
10    C   65    135      1457      1
11    C   70    135      2731      8
12    C   75    135       274      1
13    D   60    135       356      0
14    D   65    135       480      0
15    D   70    135      1557     13
16    D   75    135      2051      4
17    E   60    135        45      0
18    E   65    135      1226     14
19    E   70    135      3318     17
20    E   75    135       542      1

In R, possiamo leggere i dati dai file archiviati al di fuori dell'ambiente R. Possiamo anche scrivere dati in file che verranno archiviati e accessibili dal sistema operativo. R può leggere e scrivere in vari formati di file come csv, excel, xml ecc.

In questo capitolo impareremo a leggere i dati da un file csv e poi scrivere i dati in un file csv. Il file dovrebbe essere presente nella directory di lavoro corrente in modo che R possa leggerlo. Ovviamente possiamo anche impostare la nostra directory e leggere i file da lì.

Recupero e impostazione della directory di lavoro

È possibile controllare a quale directory punta lo spazio di lavoro R utilizzando getwd()funzione. Puoi anche impostare una nuova directory di lavoro usandosetwd()funzione.

# Get and print current working directory.
print(getwd())

# Set current working directory.
setwd("/web/com")

# Get and print current working directory.
print(getwd())

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "/web/com/1441086124_2016"
[1] "/web/com"

Questo risultato dipende dal tuo sistema operativo e dalla directory corrente in cui stai lavorando.

Input come file CSV

Il file csv è un file di testo in cui i valori nelle colonne sono separati da una virgola. Consideriamo i seguenti dati presenti nel file denominatoinput.csv.

È possibile creare questo file utilizzando il blocco note di Windows copiando e incollando questi dati. Salva il file comeinput.csv utilizzando l'opzione Salva come tutti i file (*. *) nel blocco note.

id,name,salary,start_date,dept
1,Rick,623.3,2012-01-01,IT
2,Dan,515.2,2013-09-23,Operations
3,Michelle,611,2014-11-15,IT
4,Ryan,729,2014-05-11,HR
5,Gary,843.25,2015-03-27,Finance
6,Nina,578,2013-05-21,IT
7,Simon,632.8,2013-07-30,Operations
8,Guru,722.5,2014-06-17,Finance

Leggere un file CSV

Di seguito è riportato un semplice esempio di read.csv() funzione per leggere un file CSV disponibile nella directory di lavoro corrente -

data <- read.csv("input.csv")
print(data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

Analisi del file CSV

Per impostazione predefinita, il file read.csv()la funzione fornisce l'output come frame di dati. Questo può essere facilmente verificato come segue. Inoltre possiamo controllare il numero di colonne e righe.

data <- read.csv("input.csv")

print(is.data.frame(data))
print(ncol(data))
print(nrow(data))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] TRUE
[1] 5
[1] 8

Una volta letti i dati in un data frame, possiamo applicare tutte le funzioni applicabili ai data frame come spiegato nella sezione successiva.

Ottieni lo stipendio massimo

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)
print(sal)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 843.25

Ottieni i dettagli della persona con lo stipendio massimo

Possiamo recuperare le righe che soddisfano criteri di filtro specifici simili a una clausola WHERE di SQL.

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)

# Get the person detail having max salary.
retval <- subset(data, salary == max(salary))
print(retval)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id    name  salary  start_date    dept
5     NA    Gary  843.25  2015-03-27    Finance

Ottieni tutte le persone che lavorano nel reparto IT

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset( data, dept == "IT")
print(retval)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT
6      6    Nina      578.0    2013-05-21   IT

Ottieni le persone nel reparto IT il cui stipendio è superiore a 600

# Create a data frame.
data <- read.csv("input.csv")

info <- subset(data, salary > 600 & dept == "IT")
print(info)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT

Ottieni le persone che si sono iscritte a partire dal 2014

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
print(retval)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id   name     salary   start_date    dept
3      3    Michelle 611.00   2014-11-15    IT
4      4    Ryan     729.00   2014-05-11    HR
5     NA    Gary     843.25   2015-03-27    Finance
8      8    Guru     722.50   2014-06-17    Finance

Scrittura in un file CSV

R può creare file CSV dal data frame esistente. Ilwrite.csv()viene utilizzata per creare il file csv. Questo file viene creato nella directory di lavoro.

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv")
newdata <- read.csv("output.csv")
print(newdata)

Quando eseguiamo il codice sopra, produce il seguente risultato:

X      id   name      salary   start_date    dept
1 3      3    Michelle  611.00   2014-11-15    IT
2 4      4    Ryan      729.00   2014-05-11    HR
3 5     NA    Gary      843.25   2015-03-27    Finance
4 8      8    Guru      722.50   2014-06-17    Finance

Qui la colonna X proviene dal data set newper. Questo può essere eliminato utilizzando parametri aggiuntivi durante la scrittura del file.

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv", row.names = FALSE)
newdata <- read.csv("output.csv")
print(newdata)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id    name      salary   start_date    dept
1      3    Michelle  611.00   2014-11-15    IT
2      4    Ryan      729.00   2014-05-11    HR
3     NA    Gary      843.25   2015-03-27    Finance
4      8    Guru      722.50   2014-06-17    Finance

Microsoft Excel è il programma di fogli di calcolo più utilizzato che memorizza i dati nel formato .xls o .xlsx. R può leggere direttamente da questi file utilizzando alcuni pacchetti specifici di Excel. Alcuni di questi pacchetti sono: XLConnect, xlsx, gdata ecc. Useremo il pacchetto xlsx. R può anche scrivere in un file excel usando questo pacchetto.

Installa il pacchetto xlsx

È possibile utilizzare il seguente comando nella console R per installare il pacchetto "xlsx". Potrebbe richiedere l'installazione di alcuni pacchetti aggiuntivi da cui dipende questo pacchetto. Segui lo stesso comando con il nome del pacchetto richiesto per installare i pacchetti aggiuntivi.

install.packages("xlsx")

Verifica e carica il pacchetto "xlsx"

Utilizzare il seguente comando per verificare e caricare il pacchetto "xlsx".

# Verify the package is installed.
any(grepl("xlsx",installed.packages()))

# Load the library into R workspace.
library("xlsx")

Quando lo script viene eseguito, otteniamo il seguente output.

[1] TRUE
Loading required package: rJava
Loading required package: methods
Loading required package: xlsxjars

Immettere come file xlsx

Apri Microsoft Excel. Copia e incolla i seguenti dati nel foglio di lavoro denominato foglio1.

id	name      salary    start_date	dept
1	Rick	    623.3	  1/1/2012	   IT
2	Dan       515.2     9/23/2013    Operations
3	Michelle  611	     11/15/2014	IT
4	Ryan	    729	     5/11/2014	   HR
5	Gary	    43.25     3/27/2015  	Finance
6	Nina	    578       5/21/2013	   IT
7	Simon	    632.8	  7/30/2013	   Operations
8	Guru	    722.5	  6/17/2014	   Finance

Copia e incolla anche i seguenti dati in un altro foglio di lavoro e rinomina questo foglio di lavoro in "città".

name	    city
Rick	    Seattle
Dan       Tampa
Michelle  Chicago
Ryan	    Seattle
Gary	    Houston
Nina	    Boston
Simon	    Mumbai
Guru	    Dallas

Salva il file Excel come "input.xlsx". Dovresti salvarlo nella directory di lavoro corrente dello spazio di lavoro R.

Leggere il file Excel

Il file input.xlsx viene letto utilizzando il file read.xlsx()funzionare come mostrato di seguito. Il risultato viene memorizzato come frame di dati nell'ambiente R.

# Read the first worksheet in the file input.xlsx.
data <- read.xlsx("input.xlsx", sheetIndex = 1)
print(data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id,   name,     salary,   start_date,   dept
1      1    Rick      623.30    2012-01-01    IT
2      2    Dan       515.20    2013-09-23    Operations
3      3    Michelle  611.00    2014-11-15    IT
4      4    Ryan      729.00    2014-05-11    HR
5     NA    Gary      843.25    2015-03-27    Finance
6      6    Nina      578.00    2013-05-21    IT
7      7    Simon     632.80    2013-07-30    Operations
8      8    Guru      722.50    2014-06-17    Finance

Un file binario è un file che contiene informazioni memorizzate solo sotto forma di bit e byte (0 e 1). Non sono leggibili dall'uomo poiché i byte in esso contenuti si traducono in caratteri e simboli che contengono molti altri caratteri non stampabili. Il tentativo di leggere un file binario utilizzando un qualsiasi editor di testo mostrerà caratteri come Ø e ð.

Il file binario deve essere letto da programmi specifici per essere utilizzabile. Ad esempio, il file binario di un programma Microsoft Word può essere letto in un formato leggibile solo dal programma Word. Il che indica che, oltre al testo leggibile dall'uomo, ci sono molte più informazioni come la formattazione dei caratteri e dei numeri di pagina, ecc., Che sono anche memorizzati insieme ai caratteri alfanumerici. E infine un file binario è una sequenza continua di byte. L'interruzione di riga che vediamo in un file di testo è un carattere che unisce la prima riga alla successiva.

A volte, i dati generati da altri programmi devono essere elaborati da R come file binario. Anche R è necessario per creare file binari che possono essere condivisi con altri programmi.

R ha due funzioni WriteBin() e readBin() per creare e leggere file binari.

Sintassi

writeBin(object, con)
readBin(con, what, n )

Di seguito la descrizione dei parametri utilizzati:

  • con è l'oggetto di connessione per leggere o scrivere il file binario.

  • object è il file binario che deve essere scritto.

  • what è la modalità come carattere, numero intero ecc. che rappresenta i byte da leggere.

  • n è il numero di byte da leggere dal file binario.

Esempio

Consideriamo i dati R incorporati "mtcars". Per prima cosa creiamo un file csv da esso e lo convertiamo in un file binario e lo memorizziamo come file del sistema operativo. Successivamente leggiamo questo file binario creato in R.

Scrittura del file binario

Leggiamo il data frame "mtcars" come file csv e poi lo scriviamo come file binario nel sistema operativo.

# Read the "mtcars" data frame as a csv file and store only the columns 
   "cyl", "am" and "gear".
write.table(mtcars, file = "mtcars.csv",row.names = FALSE, na = "", 
   col.names = TRUE, sep = ",")

# Store 5 records from the csv file as a new data frame.
new.mtcars <- read.table("mtcars.csv",sep = ",",header = TRUE,nrows = 5)

# Create a connection object to write the binary file using mode "wb".
write.filename = file("/web/com/binmtcars.dat", "wb")

# Write the column names of the data frame to the connection object.
writeBin(colnames(new.mtcars), write.filename)

# Write the records in each of the column to the file.
writeBin(c(new.mtcars$cyl,new.mtcars$am,new.mtcars$gear), write.filename)

# Close the file for writing so that it can be read by other program.
close(write.filename)

Leggere il file binario

Il file binario creato sopra memorizza tutti i dati come byte continui. Quindi lo leggeremo scegliendo i valori appropriati dei nomi delle colonne e dei valori delle colonne.

# Create a connection object to read the file in binary mode using "rb".
read.filename <- file("/web/com/binmtcars.dat", "rb")

# First read the column names. n = 3 as we have 3 columns.
column.names <- readBin(read.filename, character(),  n = 3)

# Next read the column values. n = 18 as we have 3 column names and 15 values.
read.filename <- file("/web/com/binmtcars.dat", "rb")
bindata <- readBin(read.filename, integer(),  n = 18)

# Print the data.
print(bindata)

# Read the values from 4th byte to 8th byte which represents "cyl".
cyldata = bindata[4:8]
print(cyldata)

# Read the values form 9th byte to 13th byte which represents "am".
amdata = bindata[9:13]
print(amdata)

# Read the values form 9th byte to 13th byte which represents "gear".
geardata = bindata[14:18]
print(geardata)

# Combine all the read values to a dat frame.
finaldata = cbind(cyldata, amdata, geardata)
colnames(finaldata) = column.names
print(finaldata)

Quando eseguiamo il codice sopra, produce il seguente risultato e grafico:

[1]    7108963 1728081249    7496037          6          6          4
 [7]          6          8          1          1          1          0
[13]          0          4          4          4          3          3

[1] 6 6 4 6 8

[1] 1 1 1 0 0

[1] 4 4 4 3 3

     cyl am gear
[1,]   6  1    4
[2,]   6  1    4
[3,]   4  1    4
[4,]   6  0    3
[5,]   8  0    3

Come possiamo vedere, abbiamo recuperato i dati originali leggendo il file binario in R.

XML è un formato di file che condivide sia il formato di file che i dati sul World Wide Web, intranet e altrove utilizzando testo ASCII standard. È l'acronimo di Extensible Markup Language (XML). Simile all'HTML, contiene tag di markup. Ma a differenza dell'HTML dove il tag di markup descrive la struttura della pagina, in xml i tag di markup descrivono il significato dei dati contenuti nel file.

Puoi leggere un file xml in R usando il pacchetto "XML". Questo pacchetto può essere installato utilizzando il seguente comando.

install.packages("XML")

Dati in ingresso

Crea un file XMl copiando i dati seguenti in un editor di testo come il blocco note. Salva il file con estensione.xml estensione e scegliendo il tipo di file come all files(*.*).

<RECORDS>
   <EMPLOYEE>
      <ID>1</ID>
      <NAME>Rick</NAME>
      <SALARY>623.3</SALARY>
      <STARTDATE>1/1/2012</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>
	
   <EMPLOYEE>
      <ID>2</ID>
      <NAME>Dan</NAME>
      <SALARY>515.2</SALARY>
      <STARTDATE>9/23/2013</STARTDATE>
      <DEPT>Operations</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>3</ID>
      <NAME>Michelle</NAME>
      <SALARY>611</SALARY>
      <STARTDATE>11/15/2014</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>4</ID>
      <NAME>Ryan</NAME>
      <SALARY>729</SALARY>
      <STARTDATE>5/11/2014</STARTDATE>
      <DEPT>HR</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>5</ID>
      <NAME>Gary</NAME>
      <SALARY>843.25</SALARY>
      <STARTDATE>3/27/2015</STARTDATE>
      <DEPT>Finance</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>6</ID>
      <NAME>Nina</NAME>
      <SALARY>578</SALARY>
      <STARTDATE>5/21/2013</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>7</ID>
      <NAME>Simon</NAME>
      <SALARY>632.8</SALARY>
      <STARTDATE>7/30/2013</STARTDATE>
      <DEPT>Operations</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>8</ID>
      <NAME>Guru</NAME>
      <SALARY>722.5</SALARY>
      <STARTDATE>6/17/2014</STARTDATE>
      <DEPT>Finance</DEPT>
   </EMPLOYEE>
	
</RECORDS>

Lettura del file XML

Il file xml viene letto da R utilizzando la funzione xmlParse(). È memorizzato come elenco in R.

# Load the package required to read XML files.
library("XML")

# Also load the other required package.
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Print the result.
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

1
Rick
623.3
1/1/2012
IT

2
Dan
515.2
9/23/2013
Operations

3
Michelle
611
11/15/2014
IT

4
Ryan
729
5/11/2014
HR

5
Gary
843.25
3/27/2015
Finance

6
Nina
578
5/21/2013
IT

7
Simon
632.8
7/30/2013
Operations

8
Guru
722.5
6/17/2014
Finance

Ottieni il numero di nodi presenti nel file XML

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Find number of nodes in the root.
rootsize <- xmlSize(rootnode)

# Print the result.
print(rootsize)

Quando eseguiamo il codice sopra, produce il seguente risultato:

output
[1] 8

Dettagli del primo nodo

Diamo un'occhiata al primo record del file analizzato. Ci darà un'idea dei vari elementi presenti nel nodo di primo livello.

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Print the result.
print(rootnode[1])

Quando eseguiamo il codice sopra, produce il seguente risultato:

$EMPLOYEE
   1
   Rick
   623.3
   1/1/2012
   IT
 

attr(,"class")
[1] "XMLInternalNodeList" "XMLNodeList"

Ottieni diversi elementi di un nodo

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Get the first element of the first node.
print(rootnode[[1]][[1]])

# Get the fifth element of the first node.
print(rootnode[[1]][[5]])

# Get the second element of the third node.
print(rootnode[[3]][[2]])

Quando eseguiamo il codice sopra, produce il seguente risultato:

1 
IT 
Michelle

Da XML a frame di dati

Per gestire i dati in modo efficace in file di grandi dimensioni, leggiamo i dati nel file xml come frame di dati. Quindi elaborare il frame di dati per l'analisi dei dati.

# Load the packages required to read XML files.
library("XML")
library("methods")

# Convert the input xml file to a data frame.
xmldataframe <- xmlToDataFrame("input.xml")
print(xmldataframe)

Quando eseguiamo il codice sopra, produce il seguente risultato:

ID    NAME     SALARY    STARTDATE       DEPT 
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

Poiché i dati sono ora disponibili come dataframe, possiamo utilizzare la funzione relativa al data frame per leggere e manipolare il file.

Il file JSON memorizza i dati come testo in formato leggibile dall'uomo. Json sta per JavaScript Object Notation. R può leggere file JSON utilizzando il pacchetto rjson.

Installa il pacchetto rjson

Nella console R, puoi emettere il seguente comando per installare il pacchetto rjson.

install.packages("rjson")

Dati in ingresso

Crea un file JSON copiando i dati seguenti in un editor di testo come il blocco note. Salva il file con estensione.json estensione e scegliendo il tipo di file come all files(*.*).

{ 
   "ID":["1","2","3","4","5","6","7","8" ],
   "Name":["Rick","Dan","Michelle","Ryan","Gary","Nina","Simon","Guru" ],
   "Salary":["623.3","515.2","611","729","843.25","578","632.8","722.5" ],
   
   "StartDate":[ "1/1/2012","9/23/2013","11/15/2014","5/11/2014","3/27/2015","5/21/2013",
      "7/30/2013","6/17/2014"],
   "Dept":[ "IT","Operations","IT","HR","Finance","IT","Operations","Finance"]
}

Leggi il file JSON

Il file JSON viene letto da R utilizzando la funzione da JSON(). È memorizzato come elenco in R.

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Print the result.
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

$ID
[1] "1"   "2"   "3"   "4"   "5"   "6"   "7"   "8"

$Name [1] "Rick" "Dan" "Michelle" "Ryan" "Gary" "Nina" "Simon" "Guru" $Salary
[1] "623.3"  "515.2"  "611"    "729"    "843.25" "578"    "632.8"  "722.5"

$StartDate [1] "1/1/2012" "9/23/2013" "11/15/2014" "5/11/2014" "3/27/2015" "5/21/2013" "7/30/2013" "6/17/2014" $Dept
[1] "IT"         "Operations" "IT"         "HR"         "Finance"    "IT"
   "Operations" "Finance"

Converti JSON in un frame di dati

Possiamo convertire i dati estratti sopra in un data frame R per ulteriori analisi utilizzando il as.data.frame() funzione.

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Convert JSON file to a data frame.
json_data_frame <- as.data.frame(result)

print(json_data_frame)

Quando eseguiamo il codice sopra, produce il seguente risultato:

id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

Molti siti Web forniscono dati per il consumo da parte dei propri utenti. Ad esempio, l'Organizzazione mondiale della sanità (OMS) fornisce rapporti su informazioni sanitarie e mediche sotto forma di file CSV, txt e XML. Utilizzando i programmi R, possiamo estrarre in modo programmatico dati specifici da tali siti Web. Alcuni pacchetti in R che vengono utilizzati per scartare i dati dal web sono - "RCurl", XML "e" stringr ". Sono usati per connettersi agli URL, identificare i collegamenti richiesti per i file e scaricarli nell'ambiente locale.

Installa pacchetti R.

I seguenti pacchetti sono necessari per l'elaborazione degli URL e dei collegamenti ai file. Se non sono disponibili nel tuo ambiente R, puoi installarli utilizzando i seguenti comandi.

install.packages("RCurl")
install.packages("XML")
install.packages("stringr")
install.packages("plyr")

Dati in ingresso

Visiteremo i dati meteorologici dell'URL e scaricheremo i file CSV utilizzando R per l'anno 2015.

Esempio

Useremo la funzione getHTMLLinks()per raccogliere gli URL dei file. Quindi useremo la funzionedownload.file()per salvare i file nel sistema locale. Poiché applicheremo lo stesso codice ripetutamente per più file, creeremo una funzione da chiamare più volte. I nomi dei file vengono passati come parametri sotto forma di un oggetto elenco R a questa funzione.

# Read the URL.
url <- "http://www.geos.ed.ac.uk/~weather/jcmb_ws/"

# Gather the html links present in the webpage.
links <- getHTMLLinks(url)

# Identify only the links which point to the JCMB 2015 files. 
filenames <- links[str_detect(links, "JCMB_2015")]

# Store the file names as a list.
filenames_list <- as.list(filenames)

# Create a function to download the files by passing the URL and filename list.
downloadcsv <- function (mainurl,filename) {
   filedetails <- str_c(mainurl,filename)
   download.file(filedetails,filename)
}

# Now apply the l_ply function and save the files into the current R working directory.
l_ply(filenames,downloadcsv,mainurl = "http://www.geos.ed.ac.uk/~weather/jcmb_ws/")

Verifica il download del file

Dopo aver eseguito il codice precedente, è possibile individuare i seguenti file nella directory di lavoro corrente R.

"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv"
   "JCMB_2015_Mar.csv"

I dati sono sistemi di database relazionali sono memorizzati in un formato normalizzato. Quindi, per eseguire calcoli statistici avremo bisogno di query Sql molto avanzate e complesse. Ma R può connettersi facilmente a molti database relazionali come MySql, Oracle, server SQL ecc. E recuperare i record da essi come frame di dati. Una volta che i dati sono disponibili nell'ambiente R, diventano un normale set di dati R e possono essere manipolati o analizzati utilizzando tutti i potenti pacchetti e funzioni.

In questo tutorial utilizzeremo MySql come database di riferimento per la connessione a R.

Pacchetto RMySQL

R ha un pacchetto integrato denominato "RMySQL" che fornisce la connettività nativa tra il database MySql. È possibile installare questo pacchetto nell'ambiente R utilizzando il seguente comando.

install.packages("RMySQL")

Collegamento di R a MySql

Una volta installato il pacchetto, creiamo un oggetto di connessione in R per connetterci al database. Prende il nome utente, la password, il nome del database e il nome host come input.

# Create a connection Object to MySQL database.
# We will connect to the sampel database named "sakila" that comes with MySql installation.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
   host = 'localhost')

# List the tables available in this database.
 dbListTables(mysqlconnection)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] "actor"                      "actor_info"                
 [3] "address"                    "category"                  
 [5] "city"                       "country"                   
 [7] "customer"                   "customer_list"             
 [9] "film"                       "film_actor"                
[11] "film_category"              "film_list"                 
[13] "film_text"                  "inventory"                 
[15] "language"                   "nicer_but_slower_film_list"
[17] "payment"                    "rental"                    
[19] "sales_by_film_category"     "sales_by_store"            
[21] "staff"                      "staff_list"                
[23] "store"

Interrogare le tabelle

Possiamo interrogare le tabelle del database in MySql usando la funzione dbSendQuery(). La query viene eseguita in MySql e il set di risultati viene restituito utilizzando Rfetch()funzione. Infine viene memorizzato come frame di dati in R.

# Query the "actor" tables to get all the rows.
result = dbSendQuery(mysqlconnection, "select * from actor")

# Store the result in a R data frame object. n = 5 is used to fetch first 5 rows.
data.frame = fetch(result, n = 5)
print(data.fame)

Quando eseguiamo il codice sopra, produce il seguente risultato:

actor_id   first_name    last_name         last_update
1        1         PENELOPE      GUINESS           2006-02-15 04:34:33
2        2         NICK          WAHLBERG          2006-02-15 04:34:33
3        3         ED            CHASE             2006-02-15 04:34:33
4        4         JENNIFER      DAVIS             2006-02-15 04:34:33
5        5         JOHNNY        LOLLOBRIGIDA      2006-02-15 04:34:33

Query con clausola di filtro

Possiamo passare qualsiasi query di selezione valida per ottenere il risultato.

result = dbSendQuery(mysqlconnection, "select * from actor where last_name = 'TORN'")

# Fetch all the records(with n = -1) and store it as a data frame.
data.frame = fetch(result, n = -1)
print(data)

Quando eseguiamo il codice sopra, produce il seguente risultato:

actor_id    first_name     last_name         last_update
1        18         DAN            TORN              2006-02-15 04:34:33
2        94         KENNETH        TORN              2006-02-15 04:34:33
3       102         WALTER         TORN              2006-02-15 04:34:33

Aggiornamento delle righe nelle tabelle

Possiamo aggiornare le righe in una tabella Mysql passando la query di aggiornamento alla funzione dbSendQuery ().

dbSendQuery(mysqlconnection, "update mtcars set disp = 168.5 where hp = 110")

Dopo aver eseguito il codice sopra possiamo vedere la tabella aggiornata nell'ambiente MySql.

Inserimento di dati nelle tabelle

dbSendQuery(mysqlconnection,
   "insert into mtcars(row_names, mpg, cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb)
   values('New Mazda RX4 Wag', 21, 6, 168.5, 110, 3.9, 2.875, 17.02, 0, 1, 4, 4)"
)

Dopo aver eseguito il codice sopra possiamo vedere la riga inserita nella tabella nell'ambiente MySql.

Creazione di tabelle in MySql

Possiamo creare tabelle in MySql usando la funzione dbWriteTable(). Sovrascrive la tabella se esiste già e prende un frame di dati come input.

# Create the connection object to the database where we want to create the table.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila', 
   host = 'localhost')

# Use the R data frame "mtcars" to create the table in MySql.
# All the rows of mtcars are taken inot MySql.
dbWriteTable(mysqlconnection, "mtcars", mtcars[, ], overwrite = TRUE)

Dopo aver eseguito il codice sopra possiamo vedere la tabella creata nell'ambiente MySql.

Eliminazione di tabelle in MySql

Possiamo rilasciare le tabelle nel database MySql passando l'istruzione drop table in dbSendQuery () nello stesso modo in cui l'abbiamo usata per interrogare i dati dalle tabelle.

dbSendQuery(mysqlconnection, 'drop table if exists mtcars')

Dopo aver eseguito il codice sopra, possiamo vedere che la tabella viene rilasciata nell'ambiente MySql.

Il linguaggio di programmazione R ha numerose librerie per creare grafici e tabelle. Un grafico a torta è una rappresentazione di valori come fette di un cerchio con colori diversi. Le sezioni vengono etichettate e nel grafico vengono rappresentati anche i numeri corrispondenti a ciascuna sezione.

In R il grafico a torta viene creato utilizzando il pie()funzione che accetta numeri positivi come input vettoriale. I parametri aggiuntivi vengono utilizzati per controllare etichette, colore, titolo ecc.

Sintassi

La sintassi di base per creare un grafico a torta usando la R è:

pie(x, labels, radius, main, col, clockwise)

Di seguito la descrizione dei parametri utilizzati:

  • x è un vettore contenente i valori numerici utilizzati nel grafico a torta.

  • labels è usato per dare una descrizione alle fette.

  • radius indica il raggio del cerchio del grafico a torta (valore compreso tra −1 e +1).

  • main indica il titolo del grafico.

  • col indica la tavolozza dei colori.

  • clockwise è un valore logico che indica se le fette sono disegnate in senso orario o antiorario.

Esempio

Viene creato un grafico a torta molto semplice utilizzando solo il vettore di input e le etichette. Lo script seguente creerà e salverà il grafico a torta nella directory di lavoro corrente R.

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city.png")

# Plot the chart.
pie(x,labels)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Titolo e colori del grafico a torta

Possiamo espandere le caratteristiche del grafico aggiungendo più parametri alla funzione. Useremo parametromain per aggiungere un titolo al grafico e un altro parametro è colche utilizzerà la tavolozza dei colori dell'arcobaleno durante il disegno del grafico. La lunghezza del pallet dovrebbe essere uguale al numero di valori che abbiamo per il grafico. Quindi usiamo length (x).

Esempio

Lo script seguente creerà e salverà il grafico a torta nella directory di lavoro corrente R.

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city_title_colours.jpg")

# Plot the chart with title and rainbow color pallet.
pie(x, labels, main = "City pie chart", col = rainbow(length(x)))

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Percentuali di sezione e legenda del grafico

Possiamo aggiungere la percentuale della fetta e una legenda del grafico creando variabili del grafico aggiuntive.

# Create data for the graph.
x <-  c(21, 62, 10,53)
labels <-  c("London","New York","Singapore","Mumbai")

piepercent<- round(100*x/sum(x), 1)

# Give the chart file a name.
png(file = "city_percentage_legends.jpg")

# Plot the chart.
pie(x, labels = piepercent, main = "City pie chart",col = rainbow(length(x)))
legend("topright", c("London","New York","Singapore","Mumbai"), cex = 0.8,
   fill = rainbow(length(x)))

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Grafico a torta 3D

Un grafico a torta con 3 dimensioni può essere disegnato utilizzando pacchetti aggiuntivi. Il pacchettoplotrix ha una funzione chiamata pie3D() che viene utilizzato per questo.

# Get the library.
library(plotrix)

# Create data for the graph.
x <-  c(21, 62, 10,53)
lbl <-  c("London","New York","Singapore","Mumbai")

# Give the chart file a name.
png(file = "3d_pie_chart.jpg")

# Plot the chart.
pie3D(x,labels = lbl,explode = 0.1, main = "Pie Chart of Countries ")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Un grafico a barre rappresenta i dati in barre rettangolari con lunghezza della barra proporzionale al valore della variabile. R utilizza la funzionebarplot()per creare grafici a barre. R può disegnare barre sia verticali che orizzontali nel grafico a barre. Nel grafico a barre a ciascuna delle barre possono essere assegnati colori diversi.

Sintassi

La sintassi di base per creare un grafico a barre in R è:

barplot(H,xlab,ylab,main, names.arg,col)

Di seguito la descrizione dei parametri utilizzati:

  • H è un vettore o una matrice contenente valori numerici utilizzati nel grafico a barre.
  • xlab è l'etichetta per l'asse x.
  • ylab è l'etichetta per l'asse y.
  • main è il titolo del grafico a barre.
  • names.arg è un vettore di nomi che appaiono sotto ogni barra.
  • col viene utilizzato per dare colori alle barre nel grafico.

Esempio

Viene creato un semplice grafico a barre utilizzando solo il vettore di input e il nome di ciascuna barra.

Lo script seguente creerà e salverà il grafico a barre nella directory di lavoro R corrente.

# Create the data for the chart
H <- c(7,12,28,3,41)

# Give the chart file a name
png(file = "barchart.png")

# Plot the bar chart 
barplot(H)

# Save the file
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Etichette, titolo e colori del grafico a barre

Le caratteristiche del grafico a barre possono essere ampliate aggiungendo più parametri. Ilmain parametro viene utilizzato per aggiungere title. Ilcolparametro viene utilizzato per aggiungere colori alle barre. Ilargs.name è un vettore avente lo stesso numero di valori del vettore di input per descrivere il significato di ciascuna barra.

Esempio

Lo script seguente creerà e salverà il grafico a barre nella directory di lavoro R corrente.

# Create the data for the chart
H <- c(7,12,28,3,41)
M <- c("Mar","Apr","May","Jun","Jul")

# Give the chart file a name
png(file = "barchart_months_revenue.png")

# Plot the bar chart 
barplot(H,names.arg=M,xlab="Month",ylab="Revenue",col="blue",
main="Revenue chart",border="red")

# Save the file
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Grafico a barre di gruppo e grafico a barre in pila

Possiamo creare un grafico a barre con gruppi di barre e pile in ogni barra utilizzando una matrice come valori di input.

Più di due variabili sono rappresentate come una matrice che viene utilizzata per creare il grafico a barre di gruppo e il grafico a barre in pila.

# Create the input vectors.
colors = c("green","orange","brown")
months <- c("Mar","Apr","May","Jun","Jul")
regions <- c("East","West","North")

# Create the matrix of the values.
Values <- matrix(c(2,9,3,11,9,4,8,7,3,12,5,2,8,10,11), nrow = 3, ncol = 5, byrow = TRUE)

# Give the chart file a name
png(file = "barchart_stacked.png")

# Create the bar chart
barplot(Values, main = "total revenue", names.arg = months, xlab = "month", ylab = "revenue", col = colors)

# Add the legend to the chart
legend("topleft", regions, cex = 1.3, fill = colors)

# Save the file
dev.off()

I boxplot sono una misura di quanto ben distribuiti sono i dati in un set di dati. Divide il set di dati in tre quartili. Questo grafico rappresenta il minimo, il massimo, la mediana, il primo quartile e il terzo quartile nel set di dati. È anche utile per confrontare la distribuzione dei dati tra i set di dati disegnando boxplot per ciascuno di essi.

I grafici a scatole vengono creati in R utilizzando il boxplot() funzione.

Sintassi

La sintassi di base per creare un boxplot in R è:

boxplot(x, data, notch, varwidth, names, main)

Di seguito la descrizione dei parametri utilizzati:

  • x è un vettore o una formula.

  • data è il data frame.

  • notchè un valore logico. Imposta come TRUE per disegnare una tacca.

  • varwidthè un valore logico. Imposta come true per disegnare la larghezza della casella proporzionata alla dimensione del campione.

  • names sono le etichette di gruppo che verranno stampate sotto ogni boxplot.

  • main è usato per dare un titolo al grafico.

Esempio

Usiamo il set di dati "mtcars" disponibile nell'ambiente R per creare un boxplot di base. Diamo un'occhiata alle colonne "mpg" e "cil" in mtcars.

input <- mtcars[,c('mpg','cyl')]
print(head(input))

Quando eseguiamo il codice sopra, produce il seguente risultato:

mpg  cyl
Mazda RX4         21.0   6
Mazda RX4 Wag     21.0   6
Datsun 710        22.8   4
Hornet 4 Drive    21.4   6
Hornet Sportabout 18.7   8
Valiant           18.1   6

Creazione del boxplot

Lo script seguente creerà un grafico a scatole per la relazione tra mpg (miglia per gallone) e cil (numero di cilindri).

# Give the chart file a name.
png(file = "boxplot.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon", main = "Mileage Data")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Boxplot con Notch

Possiamo disegnare un boxplot con notch per scoprire come le mediane di diversi gruppi di dati corrispondono tra loro.

Lo script seguente creerà un grafico a scatole con tacca per ciascuno dei gruppi di dati.

# Give the chart file a name.
png(file = "boxplot_with_notch.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, 
   xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon", 
   main = "Mileage Data",
   notch = TRUE, 
   varwidth = TRUE, 
   col = c("green","yellow","purple"),
   names = c("High","Medium","Low")
)
# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Un istogramma rappresenta le frequenze dei valori di una variabile suddivisa in intervalli. L'istogramma è simile alla chat bar, ma la differenza è che raggruppa i valori in intervalli continui. Ogni barra nell'istogramma rappresenta l'altezza del numero di valori presenti in quell'intervallo.

R crea l'istogramma usando hist()funzione. Questa funzione accetta un vettore come input e utilizza alcuni parametri in più per tracciare gli istogrammi.

Sintassi

La sintassi di base per creare un istogramma utilizzando R è:

hist(v,main,xlab,xlim,ylim,breaks,col,border)

Di seguito la descrizione dei parametri utilizzati:

  • v è un vettore contenente valori numerici utilizzati nell'istogramma.

  • main indica il titolo del grafico.

  • col viene utilizzato per impostare il colore delle barre.

  • border viene utilizzato per impostare il colore del bordo di ciascuna barra.

  • xlab viene utilizzato per fornire una descrizione dell'asse x.

  • xlim viene utilizzato per specificare l'intervallo di valori sull'asse x.

  • ylim viene utilizzato per specificare l'intervallo di valori sull'asse y.

  • breaks è usato per menzionare la larghezza di ogni barra.

Esempio

Viene creato un semplice istogramma utilizzando i parametri di input vector, label, col e border.

Lo script fornito di seguito creerà e salverà l'istogramma nella directory di lavoro R corrente.

# Create data for the graph.
v <-  c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "yellow",border = "blue")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Intervallo di valori X e Y.

Per specificare l'intervallo di valori consentito nell'asse X e nell'asse Y, possiamo utilizzare i parametri xlim e ylim.

La larghezza di ciascuna barra può essere decisa utilizzando le interruzioni.

# Create data for the graph.
v <- c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram_lim_breaks.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "green",border = "red", xlim = c(0,40), ylim = c(0,5),
   breaks = 5)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Un grafico a linee è un grafico che collega una serie di punti tracciando segmenti di linea tra di loro. Questi punti sono ordinati secondo uno dei loro valori di coordinate (di solito la coordinata x). I grafici a linee vengono solitamente utilizzati per identificare le tendenze nei dati.

Il plot() la funzione in R viene utilizzata per creare il grafico a linee.

Sintassi

La sintassi di base per creare un grafico a linee in R è:

plot(v,type,col,xlab,ylab)

Di seguito la descrizione dei parametri utilizzati:

  • v è un vettore contenente i valori numerici.

  • type prende il valore "p" per disegnare solo i punti, "l" per disegnare solo le linee e "o" per disegnare sia i punti che le linee.

  • xlab è l'etichetta per l'asse x.

  • ylab è l'etichetta per l'asse y.

  • main è il titolo del grafico.

  • col è usato per dare colori sia ai punti che alle linee.

Esempio

Viene creato un semplice grafico a linee utilizzando il vettore di input e il parametro type come "O". Lo script seguente creerà e salverà un grafico a linee nella directory di lavoro R corrente.

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart.jpg")

# Plot the bar chart. 
plot(v,type = "o")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Titolo, colore ed etichette del grafico a linee

Le funzionalità del grafico a linee possono essere espanse utilizzando parametri aggiuntivi. Aggiungiamo colore ai punti e alle linee, assegniamo un titolo al grafico e aggiungiamo etichette agli assi.

Esempio

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart_label_colored.jpg")

# Plot the bar chart.
plot(v,type = "o", col = "red", xlab = "Month", ylab = "Rain fall",
   main = "Rain fall chart")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Più linee in un grafico a linee

È possibile tracciare più di una linea sullo stesso grafico utilizzando il lines()funzione.

Dopo che la prima linea è stata tracciata, la funzione lines () può usare un vettore aggiuntivo come input per disegnare la seconda linea nel grafico,

# Create the data for the chart.
v <- c(7,12,28,3,41)
t <- c(14,7,6,19,3)

# Give the chart file a name.
png(file = "line_chart_2_lines.jpg")

# Plot the bar chart.
plot(v,type = "o",col = "red", xlab = "Month", ylab = "Rain fall", 
   main = "Rain fall chart")

lines(t, type = "o", col = "blue")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

I grafici a dispersione mostrano molti punti tracciati nel piano cartesiano. Ogni punto rappresenta i valori di due variabili. Una variabile viene scelta sull'asse orizzontale e un'altra sull'asse verticale.

Il semplice grafico a dispersione viene creato utilizzando il plot() funzione.

Sintassi

La sintassi di base per creare un grafico a dispersione in R è:

plot(x, y, main, xlab, ylab, xlim, ylim, axes)

Di seguito la descrizione dei parametri utilizzati:

  • x è il set di dati i cui valori sono le coordinate orizzontali.

  • y è il set di dati i cui valori sono le coordinate verticali.

  • main è la tessera del grafico.

  • xlab è l'etichetta sull'asse orizzontale.

  • ylab è l'etichetta sull'asse verticale.

  • xlim sono i limiti dei valori di x utilizzati per la stampa.

  • ylim sono i limiti dei valori di y utilizzati per la stampa.

  • axes indica se entrambi gli assi devono essere disegnati sul grafico.

Esempio

Usiamo il set di dati "mtcars"disponibile nell'ambiente R per creare un grafico a dispersione di base. Usiamo le colonne "wt" e "mpg" in mtcars.

input <- mtcars[,c('wt','mpg')]
print(head(input))

Quando eseguiamo il codice sopra, produce il seguente risultato:

wt      mpg
Mazda RX4           2.620   21.0
Mazda RX4 Wag       2.875   21.0
Datsun 710          2.320   22.8
Hornet 4 Drive      3.215   21.4
Hornet Sportabout   3.440   18.7
Valiant             3.460   18.1

Creazione del grafico a dispersione

Lo script seguente creerà un grafico a dispersione per la relazione tra wt (peso) e mpg (miglia per gallone).

# Get the input values.
input <- mtcars[,c('wt','mpg')]

# Give the chart file a name.
png(file = "scatterplot.png")

# Plot the chart for cars with weight between 2.5 to 5 and mileage between 15 and 30.
plot(x = input$wt,y = input$mpg,
   xlab = "Weight",
   ylab = "Milage",
   xlim = c(2.5,5),
   ylim = c(15,30),		 
   main = "Weight vs Milage"
)
	 
# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Matrici del grafico a dispersione

Quando abbiamo più di due variabili e vogliamo trovare la correlazione tra una variabile rispetto alle rimanenti, utilizziamo la matrice del grafico a dispersione. Noi usiamopairs() funzione per creare matrici di grafici a dispersione.

Sintassi

La sintassi di base per creare matrici di grafici a dispersione in R è:

pairs(formula, data)

Di seguito la descrizione dei parametri utilizzati:

  • formula rappresenta la serie di variabili usate a coppie.

  • data rappresenta il set di dati da cui verranno prese le variabili.

Esempio

Ogni variabile è abbinata a ciascuna delle rimanenti variabili. Viene tracciato un grafico a dispersione per ciascuna coppia.

# Give the chart file a name.
png(file = "scatterplot_matrices.png")

# Plot the matrices between 4 variables giving 12 plots.

# One variable with 3 others and total 4 variables.

pairs(~wt+mpg+disp+cyl,data = mtcars,
   main = "Scatterplot Matrix")

# Save the file.
dev.off()

Quando il codice precedente viene eseguito, otteniamo il seguente output.

L'analisi statistica in R viene eseguita utilizzando molte funzioni integrate. La maggior parte di queste funzioni fa parte del pacchetto base R. Queste funzioni accettano il vettore R come input insieme agli argomenti e danno il risultato.

Le funzioni che stiamo discutendo in questo capitolo sono media, mediana e modo.

Significare

Viene calcolato prendendo la somma dei valori e dividendo per il numero di valori in una serie di dati.

La funzione mean() viene utilizzato per calcolare questo in R.

Sintassi

La sintassi di base per il calcolo della media in R è:

mean(x, trim = 0, na.rm = FALSE, ...)

Di seguito la descrizione dei parametri utilizzati:

  • x è il vettore di input.

  • trim viene utilizzato per eliminare alcune osservazioni da entrambe le estremità del vettore ordinato.

  • na.rm viene utilizzato per rimuovere i valori mancanti dal vettore di input.

Esempio

# Create a vector. 
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <- mean(x)
print(result.mean)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 8.22

Applicazione dell'opzione Trim

Quando viene fornito il parametro trim, i valori nel vettore vengono ordinati e quindi i numeri richiesti di osservazioni vengono eliminati dal calcolo della media.

Quando trim = 0,3, 3 valori da ciascuna estremità verranno eliminati dai calcoli per trovare la media.

In questo caso il vettore ordinato è (−21, −5, 2, 3, 4.2, 7, 8, 12, 18, 54) ei valori rimossi dal vettore per il calcolo della media sono (−21, −5,2) da sinistra e (12,18,54) da destra.

# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <-  mean(x,trim = 0.3)
print(result.mean)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 5.55

Applicazione dell'opzione NA

Se sono presenti valori mancanti, la funzione media restituisce NA.

Per eliminare i valori mancanti dal calcolo, utilizzare na.rm = TRUE. il che significa rimuovere i valori NA.

# Create a vector. 
x <- c(12,7,3,4.2,18,2,54,-21,8,-5,NA)

# Find mean.
result.mean <-  mean(x)
print(result.mean)

# Find mean dropping NA values.
result.mean <-  mean(x,na.rm = TRUE)
print(result.mean)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] NA
[1] 8.22

Mediano

Il valore più medio in una serie di dati è chiamato mediana. Ilmedian() viene utilizzata in R per calcolare questo valore.

Sintassi

La sintassi di base per il calcolo della mediana in R è:

median(x, na.rm = FALSE)

Di seguito la descrizione dei parametri utilizzati:

  • x è il vettore di input.

  • na.rm viene utilizzato per rimuovere i valori mancanti dal vettore di input.

Esempio

# Create the vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find the median.
median.result <- median(x)
print(median.result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 5.6

Modalità

La modalità è il valore con il maggior numero di occorrenze in un insieme di dati. Media e mediana Unike, la modalità può avere sia dati numerici che caratteri.

R non ha una funzione incorporata standard per calcolare la modalità. Quindi creiamo una funzione utente per calcolare la modalità di un set di dati in R. Questa funzione prende il vettore come input e fornisce il valore della modalità come output.

Esempio

# Create the function.
getmode <- function(v) {
   uniqv <- unique(v)
   uniqv[which.max(tabulate(match(v, uniqv)))]
}

# Create the vector with numbers.
v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)

# Calculate the mode using the user function.
result <- getmode(v)
print(result)

# Create the vector with characters.
charv <- c("o","it","the","it","it")

# Calculate the mode using the user function.
result <- getmode(charv)
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 2
[1] "it"

L'analisi di regressione è uno strumento statistico molto diffuso per stabilire un modello di relazione tra due variabili. Una di queste variabili è chiamata variabile predittore il cui valore viene raccolto tramite esperimenti. L'altra variabile è chiamata variabile di risposta il cui valore è derivato dalla variabile predittore.

Nella regressione lineare queste due variabili sono correlate tramite un'equazione, dove l'esponente (potenza) di entrambe queste variabili è 1. Matematicamente una relazione lineare rappresenta una linea retta quando tracciata come grafico. Una relazione non lineare in cui l'esponente di qualsiasi variabile non è uguale a 1 crea una curva.

L'equazione matematica generale per una regressione lineare è:

y = ax + b

Di seguito la descrizione dei parametri utilizzati:

  • y è la variabile di risposta.

  • x è la variabile predittore.

  • a e b sono costanti chiamate coefficienti.

Passaggi per stabilire una regressione

Un semplice esempio di regressione è prevedere il peso di una persona quando la sua altezza è nota. Per fare questo dobbiamo avere il rapporto tra altezza e peso di una persona.

I passaggi per creare la relazione sono:

  • Eseguire l'esperimento di raccolta di un campione dei valori osservati di altezza e peso corrispondente.

  • Crea un modello di relazione utilizzando il lm() funzioni in R.

  • Trova i coefficienti dal modello creato e crea l'equazione matematica usando questi

  • Ottieni un riepilogo del modello di relazione per conoscere l'errore medio nella previsione. Chiamato ancheresiduals.

  • Per prevedere il peso di nuove persone, utilizzare il predict() funzione in R.

Dati in ingresso

Di seguito sono riportati i dati campione che rappresentano le osservazioni:

# Values of height
151, 174, 138, 186, 128, 136, 179, 163, 152, 131

# Values of weight.
63, 81, 56, 91, 47, 57, 76, 72, 62, 48

Funzione lm ()

Questa funzione crea il modello di relazione tra il predittore e la variabile di risposta.

Sintassi

La sintassi di base per lm() funzione nella regressione lineare è -

lm(formula,data)

Di seguito la descrizione dei parametri utilizzati:

  • formula è un simbolo che presenta la relazione tra x e y.

  • data è il vettore su cui verrà applicata la formula.

Crea un modello di relazione e ottieni i coefficienti

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(relation)

Quando eseguiamo il codice sopra, produce il seguente risultato:

Call:
lm(formula = y ~ x)

Coefficients:
(Intercept)            x  
   -38.4551          0.6746

Ottieni il riepilogo della relazione

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(summary(relation))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Call:
lm(formula = y ~ x)

Residuals:
    Min      1Q     Median      3Q     Max 
-6.3002    -1.6629  0.0412    1.8944  3.9775 

Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept) -38.45509    8.04901  -4.778  0.00139 ** 
x             0.67461    0.05191  12.997 1.16e-06 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 3.253 on 8 degrees of freedom
Multiple R-squared:  0.9548,    Adjusted R-squared:  0.9491 
F-statistic: 168.9 on 1 and 8 DF,  p-value: 1.164e-06

Funzione predicire ()

Sintassi

La sintassi di base per predire () nella regressione lineare è:

predict(object, newdata)

Di seguito la descrizione dei parametri utilizzati:

  • object è la formula che è già stata creata utilizzando la funzione lm ().

  • newdata è il vettore contenente il nuovo valore per la variabile predittore.

Prevedi il peso delle nuove persone

# The predictor vector.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)

# The resposne vector.
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

# Find weight of a person with height 170.
a <- data.frame(x = 170)
result <-  predict(relation,a)
print(result)

Quando eseguiamo il codice sopra, produce il seguente risultato:

1 
76.22869

Visualizza graficamente la regressione

# Create the predictor and response variable.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
relation <- lm(y~x)

# Give the chart file a name.
png(file = "linearregression.png")

# Plot the chart.
plot(y,x,col = "blue",main = "Height & Weight Regression",
abline(lm(x~y)),cex = 1.3,pch = 16,xlab = "Weight in Kg",ylab = "Height in cm")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

La regressione multipla è un'estensione della regressione lineare in relazione tra più di due variabili. Nella relazione lineare semplice abbiamo un predittore e una variabile di risposta, ma nella regressione multipla abbiamo più di una variabile predittore e una variabile di risposta.

L'equazione matematica generale per la regressione multipla è:

y = a + b1x1 + b2x2 +...bnxn

Di seguito la descrizione dei parametri utilizzati:

  • y è la variabile di risposta.

  • a, b1, b2...bn sono i coefficienti.

  • x1, x2, ...xn sono le variabili predittive.

Creiamo il modello di regressione utilizzando il lm()funzione in R. Il modello determina il valore dei coefficienti utilizzando i dati di input. Successivamente possiamo prevedere il valore della variabile di risposta per un dato insieme di variabili predittore utilizzando questi coefficienti.

Funzione lm ()

Questa funzione crea il modello di relazione tra il predittore e la variabile di risposta.

Sintassi

La sintassi di base per lm() la funzione nella regressione multipla è -

lm(y ~ x1+x2+x3...,data)

Di seguito la descrizione dei parametri utilizzati:

  • formula è un simbolo che presenta la relazione tra la variabile di risposta e le variabili predittive.

  • data è il vettore su cui verrà applicata la formula.

Esempio

Dati in ingresso

Considera il set di dati "mtcars" disponibile nell'ambiente R. Fornisce un confronto tra i diversi modelli di auto in termini di chilometraggio per gallone (mpg), cilindrata ("disp"), potenza del motore ("hp"), peso dell'auto ("wt") e altri parametri.

L'obiettivo del modello è stabilire la relazione tra "mpg" come variabile di risposta con "disp", "hp" e "wt" come variabili predittive. A questo scopo creiamo un sottoinsieme di queste variabili dal set di dati mtcars.

input <- mtcars[,c("mpg","disp","hp","wt")]
print(head(input))

Quando eseguiamo il codice sopra, produce il seguente risultato:

mpg   disp   hp    wt
Mazda RX4          21.0  160    110   2.620
Mazda RX4 Wag      21.0  160    110   2.875
Datsun 710         22.8  108     93   2.320
Hornet 4 Drive     21.4  258    110   3.215
Hornet Sportabout  18.7  360    175   3.440
Valiant            18.1  225    105   3.460

Crea un modello di relazione e ottieni i coefficienti

input <- mtcars[,c("mpg","disp","hp","wt")]

# Create the relationship model.
model <- lm(mpg~disp+hp+wt, data = input)

# Show the model.
print(model)

# Get the Intercept and coefficients as vector elements.
cat("# # # # The Coefficient Values # # # ","\n")

a <- coef(model)[1]
print(a)

Xdisp <- coef(model)[2]
Xhp <- coef(model)[3]
Xwt <- coef(model)[4]

print(Xdisp)
print(Xhp)
print(Xwt)

Quando eseguiamo il codice sopra, produce il seguente risultato:

Call:
lm(formula = mpg ~ disp + hp + wt, data = input)

Coefficients:
(Intercept)         disp           hp           wt  
  37.105505      -0.000937        -0.031157    -3.800891  

# # # # The Coefficient Values # # # 
(Intercept) 
   37.10551 
         disp 
-0.0009370091 
         hp 
-0.03115655 
       wt 
-3.800891

Crea equazione per modello di regressione

Sulla base dei valori di intercetta e coefficiente di cui sopra, creiamo l'equazione matematica.

Y = a+Xdisp.x1+Xhp.x2+Xwt.x3
or
Y = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3

Applica equazione per la previsione di nuovi valori

Possiamo utilizzare l'equazione di regressione creata sopra per prevedere il chilometraggio quando viene fornito un nuovo set di valori per spostamento, potenza e peso.

Per un'auto con disp = 221, hp = 102 e wt = 2,91 il chilometraggio previsto è -

Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.7104

La regressione logistica è un modello di regressione in cui la variabile di risposta (variabile dipendente) ha valori categoriali come Vero / Falso o 0/1. In realtà misura la probabilità di una risposta binaria come il valore della variabile di risposta in base all'equazione matematica che la mette in relazione con le variabili predittive.

L'equazione matematica generale per la regressione logistica è:

y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))

Di seguito la descrizione dei parametri utilizzati:

  • y è la variabile di risposta.

  • x è la variabile predittore.

  • a e b sono i coefficienti che sono costanti numeriche.

La funzione utilizzata per creare il modello di regressione è glm() funzione.

Sintassi

La sintassi di base per glm() la funzione nella regressione logistica è:

glm(formula,data,family)

Di seguito la descrizione dei parametri utilizzati:

  • formula è il simbolo che presenta la relazione tra le variabili.

  • data è il set di dati che fornisce i valori di queste variabili.

  • familyè un oggetto R per specificare i dettagli del modello. Il suo valore è binomiale per la regressione logistica.

Esempio

Il set di dati integrato "mtcars" descrive diversi modelli di un'auto con le loro varie specifiche del motore. Nel dataset "mtcars" la modalità di trasmissione (automatica o manuale) è descritta dalla colonna am che è un valore binario (0 o 1). Possiamo creare un modello di regressione logistica tra le colonne "am" e altre 3 colonne: hp, wt e cil.

# Select some columns form mtcars.
input <- mtcars[,c("am","cyl","hp","wt")]

print(head(input))

Quando eseguiamo il codice sopra, produce il seguente risultato:

am   cyl  hp    wt
Mazda RX4          1   6    110   2.620
Mazda RX4 Wag      1   6    110   2.875
Datsun 710         1   4     93   2.320
Hornet 4 Drive     0   6    110   3.215
Hornet Sportabout  0   8    175   3.440
Valiant            0   6    105   3.460

Crea modello di regressione

Noi usiamo il glm() funzione per creare il modello di regressione e ottenere il suo riepilogo per l'analisi.

input <- mtcars[,c("am","cyl","hp","wt")]

am.data = glm(formula = am ~ cyl + hp + wt, data = input, family = binomial)

print(summary(am.data))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Call:
glm(formula = am ~ cyl + hp + wt, family = binomial, data = input)

Deviance Residuals: 
     Min        1Q      Median        3Q       Max  
-2.17272     -0.14907  -0.01464     0.14116   1.27641  

Coefficients:
            Estimate Std. Error z value Pr(>|z|)  
(Intercept) 19.70288    8.11637   2.428   0.0152 *
cyl          0.48760    1.07162   0.455   0.6491  
hp           0.03259    0.01886   1.728   0.0840 .
wt          -9.14947    4.15332  -2.203   0.0276 *
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for binomial family taken to be 1)

    Null deviance: 43.2297  on 31  degrees of freedom
Residual deviance:  9.8415  on 28  degrees of freedom
AIC: 17.841

Number of Fisher Scoring iterations: 8

Conclusione

Nel riepilogo, poiché il valore p nell'ultima colonna è maggiore di 0,05 per le variabili "cil" e "hp", le consideriamo non significative nel contribuire al valore della variabile "am". Solo il peso (wt) influisce sul valore "am" in questo modello di regressione.

In una raccolta casuale di dati da fonti indipendenti, si osserva generalmente che la distribuzione dei dati è normale. Ciò significa che, tracciando un grafico con il valore della variabile sull'asse orizzontale e il conteggio dei valori sull'asse verticale, otteniamo una curva a campana. Il centro della curva rappresenta la media del set di dati. Nel grafico, il cinquanta percento dei valori si trova a sinistra della media e l'altro cinquanta percento si trova a destra del grafico. Questa viene definita distribuzione normale nelle statistiche.

R ha quattro funzioni integrate per generare la distribuzione normale. Sono descritti di seguito.

dnorm(x, mean, sd)
pnorm(x, mean, sd)
qnorm(p, mean, sd)
rnorm(n, mean, sd)

Di seguito è riportata la descrizione dei parametri utilizzati nelle funzioni di cui sopra:

  • x è un vettore di numeri.

  • p è un vettore di probabilità.

  • n è il numero di osservazioni (dimensione del campione).

  • meanè il valore medio dei dati del campione. Il suo valore predefinito è zero.

  • sdè la deviazione standard. Il valore predefinito è 1.

dnorm ()

Questa funzione fornisce l'altezza della distribuzione di probabilità in ogni punto per una data media e deviazione standard.

# Create a sequence of numbers between -10 and 10 incrementing by 0.1.
x <- seq(-10, 10, by = .1)

# Choose the mean as 2.5 and standard deviation as 0.5.
y <- dnorm(x, mean = 2.5, sd = 0.5)

# Give the chart file a name.
png(file = "dnorm.png")

plot(x,y)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

pnorm ()

Questa funzione fornisce la probabilità che un numero casuale distribuito normalmente sia inferiore al valore di un dato numero. È anche chiamata "Funzione di distribuzione cumulativa".

# Create a sequence of numbers between -10 and 10 incrementing by 0.2.
x <- seq(-10,10,by = .2)
 
# Choose the mean as 2.5 and standard deviation as 2. 
y <- pnorm(x, mean = 2.5, sd = 2)

# Give the chart file a name.
png(file = "pnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

qnorm ()

Questa funzione prende il valore di probabilità e fornisce un numero il cui valore cumulativo corrisponde al valore di probabilità.

# Create a sequence of probability values incrementing by 0.02.
x <- seq(0, 1, by = 0.02)

# Choose the mean as 2 and standard deviation as 3.
y <- qnorm(x, mean = 2, sd = 1)

# Give the chart file a name.
png(file = "qnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

rnorm ()

Questa funzione viene utilizzata per generare numeri casuali la cui distribuzione è normale. Prende la dimensione del campione come input e genera tanti numeri casuali. Disegniamo un istogramma per mostrare la distribuzione dei numeri generati.

# Create a sample of 50 numbers which are normally distributed.
y <- rnorm(50)

# Give the chart file a name.
png(file = "rnorm.png")

# Plot the histogram for this sample.
hist(y, main = "Normal DIstribution")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

Il modello di distribuzione binomiale si occupa di trovare la probabilità di successo di un evento che ha solo due possibili esiti in una serie di esperimenti. Ad esempio, il lancio di una moneta dà sempre una testa o una coda. La probabilità di trovare esattamente 3 teste nel lanciare una moneta ripetutamente per 10 volte è stimata durante la distribuzione binomiale.

R ha quattro funzioni integrate per generare la distribuzione binomiale. Sono descritti di seguito.

dbinom(x, size, prob)
pbinom(x, size, prob)
qbinom(p, size, prob)
rbinom(n, size, prob)

Di seguito la descrizione dei parametri utilizzati:

  • x è un vettore di numeri.

  • p è un vettore di probabilità.

  • n è il numero di osservazioni.

  • size è il numero di prove.

  • prob è la probabilità di successo di ogni prova.

dbinom ()

Questa funzione fornisce la distribuzione della densità di probabilità in ogni punto.

# Create a sample of 50 numbers which are incremented by 1.
x <- seq(0,50,by = 1)

# Create the binomial distribution.
y <- dbinom(x,50,0.5)

# Give the chart file a name.
png(file = "dbinom.png")

# Plot the graph for this sample.
plot(x,y)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

pbinom ()

Questa funzione fornisce la probabilità cumulativa di un evento. È un singolo valore che rappresenta la probabilità.

# Probability of getting 26 or less heads from a 51 tosses of a coin.
x <- pbinom(26,51,0.5)

print(x)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 0.610116

qbinom ()

Questa funzione prende il valore di probabilità e fornisce un numero il cui valore cumulativo corrisponde al valore di probabilità.

# How many heads will have a probability of 0.25 will come out when a coin
# is tossed 51 times.
x <- qbinom(0.25,51,1/2)

print(x)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 23

rbinom ()

Questa funzione genera il numero richiesto di valori casuali di una data probabilità da un dato campione.

# Find 8 random values from a sample of 150 with probability of 0.4.
x <- rbinom(8,150,.4)

print(x)

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 58 61 59 66 55 60 61 67

La regressione di Poisson coinvolge modelli di regressione in cui la variabile di risposta è sotto forma di conteggi e non di numeri frazionari. Ad esempio, il conteggio del numero di nascite o il numero di vittorie in una serie di partite di calcio. Anche i valori delle variabili di risposta seguono una distribuzione di Poisson.

L'equazione matematica generale per la regressione di Poisson è:

log(y) = a + b1x1 + b2x2 + bnxn.....

Di seguito la descrizione dei parametri utilizzati:

  • y è la variabile di risposta.

  • a e b sono i coefficienti numerici.

  • x è la variabile predittore.

La funzione utilizzata per creare il modello di regressione di Poisson è la glm() funzione.

Sintassi

La sintassi di base per glm() funzione nella regressione di Poisson è -

glm(formula,data,family)

Di seguito è riportata la descrizione dei parametri utilizzati nelle funzioni di cui sopra:

  • formula è il simbolo che presenta la relazione tra le variabili.

  • data è il set di dati che fornisce i valori di queste variabili.

  • familyè un oggetto R per specificare i dettagli del modello. Il suo valore è "Poisson" per la regressione logistica.

Esempio

Abbiamo il set di dati integrato "warpbreak" che descrive l'effetto del tipo di lana (A o B) e della tensione (bassa, media o alta) sul numero di rotture di ordito per telaio. Consideriamo le "pause" come la variabile di risposta che è un conteggio del numero di interruzioni. Il "tipo" e la "tensione" della lana vengono presi come variabili predittive.

Input Data

input <- warpbreaks
print(head(input))

Quando eseguiamo il codice sopra, produce il seguente risultato:

breaks   wool  tension
1     26       A     L
2     30       A     L
3     54       A     L
4     25       A     L
5     70       A     L
6     52       A     L

Crea modello di regressione

output <-glm(formula = breaks ~ wool+tension, data = warpbreaks,
   family = poisson)
print(summary(output))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Call:
glm(formula = breaks ~ wool + tension, family = poisson, data = warpbreaks)

Deviance Residuals: 
    Min       1Q     Median       3Q      Max  
  -3.6871  -1.6503  -0.4269     1.1902   4.2616  

Coefficients:
            Estimate Std. Error z value Pr(>|z|)    
(Intercept)  3.69196    0.04541  81.302  < 2e-16 ***
woolB       -0.20599    0.05157  -3.994 6.49e-05 ***
tensionM    -0.32132    0.06027  -5.332 9.73e-08 ***
tensionH    -0.51849    0.06396  -8.107 5.21e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for poisson family taken to be 1)

    Null deviance: 297.37  on 53  degrees of freedom
Residual deviance: 210.39  on 50  degrees of freedom
AIC: 493.06

Number of Fisher Scoring iterations: 4

Nel riepilogo cerchiamo che il valore p nell'ultima colonna sia inferiore a 0,05 per considerare un impatto della variabile predittore sulla variabile di risposta. Come visto il tipo di lana B con tensione di tipo M e H ha un impatto sul conteggio delle rotture.

Usiamo l'analisi di regressione per creare modelli che descrivono l'effetto della variazione nelle variabili predittori sulla variabile di risposta. A volte, se abbiamo una variabile categoriale con valori come Sì / No o Maschio / Femmina ecc. La semplice analisi di regressione fornisce più risultati per ogni valore della variabile categoriale. In tale scenario, possiamo studiare l'effetto della variabile categoriale utilizzandola insieme alla variabile predittore e confrontando le linee di regressione per ogni livello della variabile categoriale. Tale analisi è definita comeAnalysis of Covariance chiamato anche come ANCOVA.

Esempio

Considera il set di dati R incorporato mtcars. In esso osserviamo che il campo "sono" rappresenta il tipo di trasmissione (automatica o manuale). È una variabile categoriale con valori 0 e 1. Da essa può dipendere anche il valore di miglia per gallone (mpg) di un'auto oltre al valore della potenza del motore ("hp").

Studiamo l'effetto del valore di "am" sulla regressione tra "mpg" e "hp". È fatto usando ilaov() funzione seguita dal anova() funzione per confrontare le regressioni multiple.

Dati in ingresso

Crea un data frame contenente i campi "mpg", "hp" e "am" dal data set mtcars. Qui prendiamo "mpg" come variabile di risposta, "hp" come variabile predittore e "am" come variabile categoriale.

input <- mtcars[,c("am","mpg","hp")]
print(head(input))

Quando eseguiamo il codice sopra, produce il seguente risultato:

am   mpg   hp
Mazda RX4          1    21.0  110
Mazda RX4 Wag      1    21.0  110
Datsun 710         1    22.8   93
Hornet 4 Drive     0    21.4  110
Hornet Sportabout  0    18.7  175
Valiant            0    18.1  105

ANCOVA Analisi

Creiamo un modello di regressione prendendo "hp" come variabile predittore e "mpg" come variabile di risposta tenendo conto dell'interazione tra "am" e "hp".

Modello con interazione tra variabile categoriale e variabile predittiva

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp*am,data = input)
print(summary(result))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Df Sum Sq Mean Sq F value   Pr(>F)    
hp           1  678.4   678.4  77.391 1.50e-09 ***
am           1  202.2   202.2  23.072 4.75e-05 ***
hp:am        1    0.0     0.0   0.001    0.981    
Residuals   28  245.4     8.8                     
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Questo risultato mostra che sia la potenza che il tipo di trasmissione hanno un effetto significativo sulle miglia per gallone poiché il valore p in entrambi i casi è inferiore a 0,05. Ma l'interazione tra queste due variabili non è significativa poiché il valore p è superiore a 0,05.

Modello senza interazione tra variabile categoriale e variabile predittiva

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp+am,data = input)
print(summary(result))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Df  Sum Sq  Mean Sq   F value   Pr(>F)    
hp           1  678.4   678.4   80.15 7.63e-10 ***
am           1  202.2   202.2   23.89 3.46e-05 ***
Residuals   29  245.4     8.5                     
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Questo risultato mostra che sia la potenza che il tipo di trasmissione hanno un effetto significativo sulle miglia per gallone poiché il valore p in entrambi i casi è inferiore a 0,05.

Confronto di due modelli

Ora possiamo confrontare i due modelli per concludere se l'interazione delle variabili è veramente non significativa. Per questo usiamo ilanova() funzione.

# Get the dataset.
input <- mtcars

# Create the regression models.
result1 <- aov(mpg~hp*am,data = input)
result2 <- aov(mpg~hp+am,data = input)

# Compare the two models.
print(anova(result1,result2))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Model 1: mpg ~ hp * am
Model 2: mpg ~ hp + am
  Res.Df    RSS Df  Sum of Sq     F Pr(>F)
1     28 245.43                           
2     29 245.44 -1 -0.0052515 6e-04 0.9806

Poiché il valore p è maggiore di 0,05, concludiamo che l'interazione tra la potenza del motore e il tipo di trasmissione non è significativa. Quindi il chilometraggio per gallone dipenderà in modo simile dalla potenza del motore dell'auto sia in modalità di trasmissione automatica che manuale.

Le serie temporali sono una serie di punti dati in cui ogni punto dati è associato a un timestamp. Un semplice esempio è il prezzo di un'azione nel mercato azionario in diversi momenti in un dato giorno. Un altro esempio è la quantità di pioggia in una regione in diversi mesi dell'anno. Il linguaggio R utilizza molte funzioni per creare, manipolare e tracciare i dati delle serie temporali. I dati per la serie temporale vengono archiviati in un oggetto R chiamatotime-series object. È anche un oggetto dati R come un vettore o un data frame.

L'oggetto della serie temporale viene creato utilizzando l'estensione ts() funzione.

Sintassi

La sintassi di base per ts() la funzione nell'analisi delle serie temporali è:

timeseries.object.name <-  ts(data, start, end, frequency)

Di seguito la descrizione dei parametri utilizzati:

  • data è un vettore o una matrice contenente i valori utilizzati nelle serie temporali.

  • start specifica l'ora di inizio per la prima osservazione nelle serie temporali.

  • end specifica l'ora di fine dell'ultima osservazione nelle serie temporali.

  • frequency specifica il numero di osservazioni per unità di tempo.

Ad eccezione del parametro "dati", tutti gli altri parametri sono opzionali.

Esempio

Considera i dettagli delle precipitazioni annuali in un luogo a partire da gennaio 2012. Creiamo un oggetto serie temporale R per un periodo di 12 mesi e lo tracciamo.

# Get the data points in form of a R vector.
rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)

# Convert it to a time series object.
rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall.png")

# Plot a graph of the time series.
plot(rainfall.timeseries)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato e grafico:

Jan    Feb    Mar    Apr    May     Jun    Jul    Aug    Sep
2012  799.0  1174.8  865.1  1334.6  635.4  918.5  685.5  998.6  784.2
        Oct    Nov    Dec
2012  985.0  882.8 1071.0

Il grafico delle serie temporali -

Intervalli di tempo diversi

Il valore di frequencyparametro nella funzione ts () decide gli intervalli di tempo in cui vengono misurati i punti dati. Un valore di 12 indica che la serie temporale è per 12 mesi. Altri valori e il loro significato sono i seguenti:

  • frequency = 12 fissa i punti dati per ogni mese dell'anno.

  • frequency = 4 fissa i punti dati per ogni trimestre dell'anno.

  • frequency = 6 fissa i punti dati per ogni 10 minuti di un'ora.

  • frequency = 24*6 fissa i punti dati per ogni 10 minuti di un giorno.

Serie temporali multiple

Possiamo tracciare più serie temporali in un grafico combinando entrambe le serie in una matrice.

# Get the data points in form of a R vector.
rainfall1 <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)
rainfall2 <- 
           c(655,1306.9,1323.4,1172.2,562.2,824,822.4,1265.5,799.6,1105.6,1106.7,1337.8)

# Convert them to a matrix.
combined.rainfall <-  matrix(c(rainfall1,rainfall2),nrow = 12)

# Convert it to a time series object.
rainfall.timeseries <- ts(combined.rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall_combined.png")

# Plot a graph of the time series.
plot(rainfall.timeseries, main = "Multiple Time Series")

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato e grafico:

Series 1  Series 2
Jan 2012    799.0    655.0
Feb 2012   1174.8   1306.9
Mar 2012    865.1   1323.4
Apr 2012   1334.6   1172.2
May 2012    635.4    562.2
Jun 2012    918.5    824.0
Jul 2012    685.5    822.4
Aug 2012    998.6   1265.5
Sep 2012    784.2    799.6
Oct 2012    985.0   1105.6
Nov 2012    882.8   1106.7
Dec 2012   1071.0   1337.8

Il grafico delle serie temporali multiple -

Quando si modellano i dati del mondo reale per l'analisi di regressione, si osserva che è raro che l'equazione del modello sia un'equazione lineare che fornisce un grafico lineare. Il più delle volte, l'equazione del modello dei dati del mondo reale coinvolge funzioni matematiche di grado più elevato come un esponente di 3 o una funzione sin. In un tale scenario, il grafico del modello fornisce una curva piuttosto che una linea. L'obiettivo della regressione lineare e non lineare è regolare i valori dei parametri del modello per trovare la linea o la curva che si avvicina di più ai dati. Trovando questi valori saremo in grado di stimare la variabile di risposta con buona precisione.

Nella regressione dei minimi quadrati, stabiliamo un modello di regressione in cui la somma dei quadrati delle distanze verticali di diversi punti dalla curva di regressione è ridotta al minimo. In genere iniziamo con un modello definito e assumiamo alcuni valori per i coefficienti. Quindi applichiamo ilnls() funzione di R per ottenere i valori più accurati insieme agli intervalli di confidenza.

Sintassi

La sintassi di base per creare un test dei minimi quadrati non lineare in R è:

nls(formula, data, start)

Di seguito la descrizione dei parametri utilizzati:

  • formula è una formula del modello non lineare che include variabili e parametri.

  • data è un data frame utilizzato per valutare le variabili nella formula.

  • start è una lista con nome o un vettore numerico con nome di stime iniziali.

Esempio

Considereremo un modello non lineare con l'assunzione dei valori iniziali dei suoi coefficienti. Successivamente vedremo quali sono gli intervalli di confidenza di questi valori presunti in modo da poter giudicare quanto bene questi valori siano inseriti nel modello.

Quindi consideriamo l'equazione seguente per questo scopo:

a = b1*x^2+b2

Supponiamo che i coefficienti iniziali siano 1 e 3 e adattiamo questi valori alla funzione nls ().

xvalues <- c(1.6,2.1,2,2.23,3.71,3.25,3.4,3.86,1.19,2.21)
yvalues <- c(5.19,7.43,6.94,8.11,18.75,14.88,16.06,19.12,3.21,7.58)

# Give the chart file a name.
png(file = "nls.png")


# Plot these values.
plot(xvalues,yvalues)


# Take the assumed values and fit into the model.
model <- nls(yvalues ~ b1*xvalues^2+b2,start = list(b1 = 1,b2 = 3))

# Plot the chart with new data by fitting it to a prediction from 100 data points.
new.data <- data.frame(xvalues = seq(min(xvalues),max(xvalues),len = 100))
lines(new.data$xvalues,predict(model,newdata = new.data))

# Save the file.
dev.off()

# Get the sum of the squared residuals.
print(sum(resid(model)^2))

# Get the confidence intervals on the chosen values of the coefficients.
print(confint(model))

Quando eseguiamo il codice sopra, produce il seguente risultato:

[1] 1.081935
Waiting for profiling to be done...
       2.5%    97.5%
b1 1.137708 1.253135
b2 1.497364 2.496484

Possiamo concludere che il valore di b1 è più vicino a 1 mentre il valore di b2 è più vicino a 2 e non a 3.

L'albero decisionale è un grafico per rappresentare le scelte ei loro risultati sotto forma di albero. I nodi nel grafico rappresentano un evento o una scelta e i bordi del grafico rappresentano le regole o le condizioni di decisione. Viene utilizzato principalmente nelle applicazioni di Machine Learning e Data Mining che utilizzano R.

Esempi di utilizzo del tress decisionale sono: prevedere un'e-mail come spam o non spam, prevedere un tumore canceroso o prevedere un prestito come un rischio di credito buono o cattivo in base ai fattori di ciascuno di questi. In genere, viene creato un modello con i dati osservati chiamati anche dati di addestramento. Quindi una serie di dati di convalida viene utilizzata per verificare e migliorare il modello. R ha pacchetti che vengono utilizzati per creare e visualizzare alberi decisionali. Per il nuovo set di variabili predittive, utilizziamo questo modello per arrivare a una decisione sulla categoria (sì / no, spam / non spam) dei dati.

Il pacchetto R. "party" viene utilizzato per creare alberi decisionali.

Installa il pacchetto R.

Utilizzare il comando seguente nella console R per installare il pacchetto. È inoltre necessario installare i pacchetti dipendenti, se presenti.

install.packages("party")

Il pacchetto "party" ha la funzione ctree() che viene utilizzato per creare e analizzare l'albero decisionale.

Sintassi

La sintassi di base per creare un albero decisionale in R è:

ctree(formula, data)

Di seguito la descrizione dei parametri utilizzati:

  • formula è una formula che descrive il predittore e le variabili di risposta.

  • data è il nome del set di dati utilizzato.

Dati in ingresso

Useremo il set di dati R in-built denominato readingSkillsper creare un albero decisionale. Descrive il punteggio delle capacità di lettura di qualcuno se conosciamo le variabili "età", "taglia", "punteggio" e se la persona è madrelingua o meno.

Ecco i dati di esempio.

# Load the party package. It will automatically load other
# dependent packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

Quando eseguiamo il codice sopra, produce il seguente risultato e grafico:

nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

Esempio

Useremo il file ctree() funzione per creare l'albero decisionale e vederne il grafico.

# Load the party package. It will automatically load other
# dependent packages.
library(party)

# Create the input data frame.
input.dat <- readingSkills[c(1:105),]

# Give the chart file a name.
png(file = "decision_tree.png")

# Create the tree.
  output.tree <- ctree(
  nativeSpeaker ~ age + shoeSize + score, 
  data = input.dat)

# Plot the tree.
plot(output.tree)

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato:

null device 
          1 
Loading required package: methods
Loading required package: grid
Loading required package: mvtnorm
Loading required package: modeltools
Loading required package: stats4
Loading required package: strucchange
Loading required package: zoo

Attaching package: ‘zoo’

The following objects are masked from ‘package:base’:

   as.Date, as.Date.numeric

Loading required package: sandwich

Conclusione

Dall'albero decisionale mostrato sopra possiamo concludere che chiunque abbia un punteggio di readingSkills inferiore a 38,3 e l'età superiore a 6 non è un madrelingua.

Nell'approccio forestale casuale, viene creato un gran numero di alberi decisionali. Ogni osservazione viene inserita in ogni albero decisionale. Il risultato più comune per ciascuna osservazione viene utilizzato come output finale. Una nuova osservazione viene inserita in tutti gli alberi e con un voto a maggioranza per ogni modello di classificazione.

Viene effettuata una stima degli errori per i casi che non sono stati utilizzati durante la costruzione dell'albero. Questo è chiamato un fileOOB (Out-of-bag) stima dell'errore che è indicata come percentuale.

Il pacchetto R. "randomForest" viene utilizzato per creare foreste casuali.

Installa il pacchetto R.

Utilizzare il comando seguente nella console R per installare il pacchetto. È inoltre necessario installare i pacchetti dipendenti, se presenti.

install.packages("randomForest)

Il pacchetto "randomForest" ha la funzione randomForest() che viene utilizzato per creare e analizzare foreste casuali.

Sintassi

La sintassi di base per creare una foresta casuale in R è:

randomForest(formula, data)

Di seguito la descrizione dei parametri utilizzati:

  • formula è una formula che descrive il predittore e le variabili di risposta.

  • data è il nome del set di dati utilizzato.

Dati in ingresso

Useremo il set di dati R in-built denominato readingSkills per creare un albero decisionale. Descrive il punteggio delle capacità di lettura di qualcuno se conosciamo le variabili "età", "taglia", "punteggio" e se la persona è madrelingua.

Ecco i dati di esempio.

# Load the party package. It will automatically load other
# required packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

Quando eseguiamo il codice sopra, produce il seguente risultato e grafico:

nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

Esempio

Useremo il file randomForest() funzione per creare l'albero decisionale e vedere il suo grafico.

# Load the party package. It will automatically load other
# required packages.
library(party)
library(randomForest)

# Create the forest.
output.forest <- randomForest(nativeSpeaker ~ age + shoeSize + score, 
           data = readingSkills)

# View the forest results.
print(output.forest) 

# Importance of each predictor.
print(importance(fit,type = 2))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Call:
 randomForest(formula = nativeSpeaker ~ age + shoeSize + score,     
                 data = readingSkills)
               Type of random forest: classification
                     Number of trees: 500
No. of variables tried at each split: 1

        OOB estimate of  error rate: 1%
Confusion matrix:
    no yes class.error
no  99   1        0.01
yes  1  99        0.01
         MeanDecreaseGini
age              13.95406
shoeSize         18.91006
score            56.73051

Conclusione

Dalla foresta casuale mostrata sopra possiamo concludere che le dimensioni delle scarpe e il punteggio sono i fattori importanti per decidere se qualcuno è un madrelingua o meno. Inoltre il modello ha solo l'1% di errore, il che significa che possiamo prevedere con una precisione del 99%.

L'analisi di sopravvivenza si occupa di prevedere il momento in cui si verificherà un evento specifico. È anche noto come analisi del tempo di guasto o analisi del tempo fino alla morte. Ad esempio, prevedere il numero di giorni in cui una persona malata di cancro sopravviverà o prevedere il tempo in cui un sistema meccanico fallirà.

Il pacchetto R denominato survivalviene utilizzato per eseguire analisi di sopravvivenza. Questo pacchetto contiene la funzioneSurv()che prende i dati di input come una formula R e crea un oggetto di sopravvivenza tra le variabili scelte per l'analisi. Quindi usiamo la funzionesurvfit() per creare un grafico per l'analisi.

Installa pacchetto

install.packages("survival")

Sintassi

La sintassi di base per creare analisi di sopravvivenza in R è:

Surv(time,event)
survfit(formula)

Di seguito la descrizione dei parametri utilizzati:

  • time è il tempo di follow-up fino al verificarsi dell'evento.

  • event indica lo stato di accadimento dell'evento atteso.

  • formula è la relazione tra le variabili predittive.

Esempio

Considereremo il set di dati denominato "pbc" presente nei pacchetti di sopravvivenza installati sopra. Descrive i punti di dati di sopravvivenza sulle persone affette da cirrosi biliare primaria (PBC) del fegato. Tra le tante colonne presenti nel set di dati ci occupiamo principalmente dei campi "ora" e "stato". Il tempo rappresenta il numero di giorni tra la registrazione del paziente e la prima dell'evento tra il paziente che riceve un trapianto di fegato o la morte del paziente.

# Load the library.
library("survival")

# Print first few rows.
print(head(pbc))

Quando eseguiamo il codice sopra, produce il seguente risultato e grafico:

id time status trt      age sex ascites hepato spiders edema bili chol
1  1  400      2   1 58.76523   f       1      1       1   1.0 14.5  261
2  2 4500      0   1 56.44627   f       0      1       1   0.0  1.1  302
3  3 1012      2   1 70.07255   m       0      0       0   0.5  1.4  176
4  4 1925      2   1 54.74059   f       0      1       1   0.5  1.8  244
5  5 1504      1   2 38.10541   f       0      1       1   0.0  3.4  279
6  6 2503      2   2 66.25873   f       0      1       0   0.0  0.8  248
  albumin copper alk.phos    ast trig platelet protime stage
1    2.60    156   1718.0 137.95  172      190    12.2     4
2    4.14     54   7394.8 113.52   88      221    10.6     3
3    3.48    210    516.0  96.10   55      151    12.0     4
4    2.54     64   6121.8  60.63   92      183    10.3     4
5    3.53    143    671.0 113.15   72      136    10.9     3
6    3.98     50    944.0  93.00   63       NA    11.0     3

Dai dati di cui sopra stiamo considerando il tempo e lo stato per la nostra analisi.

Applicazione delle funzioni Surv () e survfit ()

Ora procediamo ad applicare il Surv() funzione al set di dati sopra e creare un grafico che mostrerà la tendenza.

# Load the library.
library("survival")

# Create the survival object. 
survfit(Surv(pbc$time,pbc$status == 2)~1) # Give the chart file a name. png(file = "survival.png") # Plot the graph. plot(survfit(Surv(pbc$time,pbc$status == 2)~1))

# Save the file.
dev.off()

Quando eseguiamo il codice sopra, produce il seguente risultato e grafico:

Call: survfit(formula = Surv(pbc$time, pbc$status == 2) ~ 1)

      n  events  median 0.95LCL 0.95UCL 
    418     161    3395    3090    3853

L'andamento nel grafico sopra ci aiuta a prevedere la probabilità di sopravvivenza alla fine di un certo numero di giorni.

Chi-Square testè un metodo statistico per determinare se due variabili categoriali hanno una correlazione significativa tra di loro. Entrambe queste variabili dovrebbero provenire dalla stessa popolazione e dovrebbero essere categoriche come - Sì / No, Maschio / Femmina, Rosso / Verde ecc.

Ad esempio, possiamo costruire un set di dati con osservazioni sul modello di acquisto del gelato delle persone e provare a correlare il sesso di una persona con il sapore del gelato che preferiscono. Se viene trovata una correlazione, possiamo pianificare uno stock appropriato di sapori conoscendo il numero di sesso delle persone che visitano.

Sintassi

La funzione utilizzata per eseguire il test chi-quadrato è chisq.test().

La sintassi di base per creare un test chi-quadrato in R è:

chisq.test(data)

Di seguito la descrizione dei parametri utilizzati:

  • data è il dato sotto forma di tabella contenente il valore di conteggio delle variabili nell'osservazione.

Esempio

Porteremo i dati Cars93 nella libreria "MASS" che rappresenta le vendite di diversi modelli di auto nell'anno 1993.

library("MASS")
print(str(Cars93))

Quando eseguiamo il codice sopra, produce il seguente risultato:

'data.frame':   93 obs. of  27 variables: 
 $ Manufacturer      : Factor w/ 32 levels "Acura","Audi",..: 1 1 2 2 3 4 4 4 4 5 ... 
 $ Model : Factor w/ 93 levels "100","190E","240",..: 49 56 9 1 6 24 54 74 73 35 ... $ Type              : Factor w/ 6 levels "Compact","Large",..: 4 3 1 3 3 3 2 2 3 2 ... 
 $ Min.Price : num 12.9 29.2 25.9 30.8 23.7 14.2 19.9 22.6 26.3 33 ... $ Price             : num  15.9 33.9 29.1 37.7 30 15.7 20.8 23.7 26.3 34.7 ... 
 $ Max.Price : num 18.8 38.7 32.3 44.6 36.2 17.3 21.7 24.9 26.3 36.3 ... $ MPG.city          : int  25 18 20 19 22 22 19 16 19 16 ... 
 $ MPG.highway : int 31 25 26 26 30 31 28 25 27 25 ... $ AirBags           : Factor w/ 3 levels "Driver & Passenger",..: 3 1 2 1 2 2 2 2 2 2 ... 
 $ DriveTrain : Factor w/ 3 levels "4WD","Front",..: 2 2 2 2 3 2 2 3 2 2 ... $ Cylinders         : Factor w/ 6 levels "3","4","5","6",..: 2 4 4 4 2 2 4 4 4 5 ... 
 $ EngineSize : num 1.8 3.2 2.8 2.8 3.5 2.2 3.8 5.7 3.8 4.9 ... $ Horsepower        : int  140 200 172 172 208 110 170 180 170 200 ... 
 $ RPM : int 6300 5500 5500 5500 5700 5200 4800 4000 4800 4100 ... $ Rev.per.mile      : int  2890 2335 2280 2535 2545 2565 1570 1320 1690 1510 ... 
 $ Man.trans.avail : Factor w/ 2 levels "No","Yes": 2 2 2 2 2 1 1 1 1 1 ... $ Fuel.tank.capacity: num  13.2 18 16.9 21.1 21.1 16.4 18 23 18.8 18 ... 
 $ Passengers : int 5 5 5 6 4 6 6 6 5 6 ... $ Length            : int  177 195 180 193 186 189 200 216 198 206 ... 
 $ Wheelbase : int 102 115 102 106 109 105 111 116 108 114 ... $ Width             : int  68 71 67 70 69 69 74 78 73 73 ... 
 $ Turn.circle : int 37 38 37 37 39 41 42 45 41 43 ... $ Rear.seat.room    : num  26.5 30 28 31 27 28 30.5 30.5 26.5 35 ... 
 $ Luggage.room : int 11 15 14 17 13 16 17 21 14 18 ... $ Weight            : int  2705 3560 3375 3405 3640 2880 3470 4105 3495 3620 ... 
 $ Origin : Factor w/ 2 levels "USA","non-USA": 2 2 2 2 2 1 1 1 1 1 ... $ Make              : Factor w/ 93 levels "Acura Integra",..: 1 2 4 3 5 6 7 9 8 10 ...

Il risultato sopra mostra che il set di dati ha molte variabili Fattore che possono essere considerate come variabili categoriali. Per il nostro modello considereremo le variabili "AirBags" e "Type". Qui ci proponiamo di scoprire qualsiasi correlazione significativa tra i tipi di auto vendute e il tipo di Airbag che ha. Se si osserva una correlazione, possiamo stimare quali tipi di auto possono vendere meglio con quali tipi di airbag.

# Load the library.
library("MASS")

# Create a data frame from the main data set.
car.data <- data.frame(Cars93$AirBags, Cars93$Type)

# Create a table with the needed variables.
car.data = table(Cars93$AirBags, Cars93$Type) 
print(car.data)

# Perform the Chi-Square test.
print(chisq.test(car.data))

Quando eseguiamo il codice sopra, produce il seguente risultato:

Compact Large Midsize Small Sporty Van
  Driver & Passenger       2     4       7     0      3   0
  Driver only              9     7      11     5      8   3
  None                     5     0       4    16      3   6

         Pearson's Chi-squared test

data:  car.data
X-squared = 33.001, df = 10, p-value = 0.0002723

Warning message:
In chisq.test(car.data) : Chi-squared approximation may be incorrect

Conclusione

Il risultato mostra il valore p inferiore a 0,05 che indica una correlazione tra stringhe.