Cos'è una funzione in R?
Una funzione , in un ambiente di programmazione, è un insieme di istruzioni. Un programmatore crea una funzione per evitare di ripetere la stessa attività o ridurre la complessità.
Una funzione dovrebbe essere
- scritto per svolgere una specifica attività
- può o non può includere argomenti
- contenere un corpo
- può o non può restituire uno o più valori.
Un approccio generale a una funzione consiste nell'usare la parte argomento come input , alimentare la parte del corpo e infine restituire un output . La sintassi di una funzione è la seguente:
function (arglist) {#Function body}
In questo tutorial impareremo
- R importanti funzioni integrate
- Funzioni generali
- Funzioni matematiche
- Funzioni statistiche
- Scrivi la funzione in R
- Quando dovremmo scrivere function?
- Funziona con condizione
R importanti funzioni integrate
Ci sono molte funzioni incorporate in R. R abbina i parametri di input con i suoi argomenti della funzione, sia per valore che per posizione, quindi esegue il corpo della funzione. Gli argomenti delle funzioni possono avere valori predefiniti: se non si specificano questi argomenti, R assumerà il valore predefinito.
Nota : è possibile vedere il codice sorgente di una funzione eseguendo il nome della funzione stessa nella console.
Vedremo tre gruppi di funzioni in azione
- Funzione generale
- Funzione matematica
- Funzione statistica
Funzioni generali
Abbiamo già familiarità con funzioni generali come cbind (), rbind (), range (), sort (), order (). Ciascuna di queste funzioni ha un'attività specifica, accetta argomenti per restituire un output. Di seguito sono elencate funzioni importanti che è necessario conoscere-
funzione diff ()
Se lavori su serie temporali , devi stazionare le serie prendendo i loro valori di ritardo . Un processo stazionario consente media, varianza e autocorrelazione costanti nel tempo. Ciò migliora principalmente la previsione di una serie temporale. Può essere fatto facilmente con la funzione diff (). Possiamo costruire dati di una serie temporale casuale con una tendenza e quindi utilizzare la funzione diff () per stazionare la serie. La funzione diff () accetta un argomento, un vettore e restituisce una differenza ritardata e iterata adeguata.
Nota : spesso abbiamo bisogno di creare dati casuali, ma per l'apprendimento e il confronto vogliamo che i numeri siano identici su tutte le macchine. Per assicurarci di generare tutti gli stessi dati, utilizziamo la funzione set.seed () con valori arbitrari di 123. La funzione set.seed () viene generata tramite il processo di generatore di numeri pseudocasuali che fa sì che ogni computer moderno abbia la stessa sequenza di numeri. Se non usiamo la funzione set.seed (), avremo tutti una sequenza di numeri diversa.
set.seed(123)## Create the datax = rnorm(1000)ts <- cumsum(x)## Stationary the seriediff_ts <- diff(ts)par(mfrow=c(1,2))## Plot the seriesplot(ts,)plot(diff(ts),)
funzione length ()
In molti casi, vogliamo conoscere la lunghezza di un vettore per il calcolo o da utilizzare in un ciclo for. La funzione length () conta il numero di righe nel vettore x. I seguenti codici importano il set di dati delle auto e restituiscono il numero di righe.
Nota : length () restituisce il numero di elementi in un vettore. Se la funzione viene passata in una matrice o in un data frame, viene restituito il numero di colonne.
dt <- cars## number columnslength(dt)
Produzione:
## [1] 1
## number rowslength(dt[,1])
Produzione:
## [1] 50
Funzioni matematiche
R ha una serie di funzioni matematiche.
| Operatore | Descrizione |
|---|---|
| addominali (x) | Prende il valore assoluto di x |
| log (x, base = y) | Prende il logaritmo di x con base y; se base non è specificato, restituisce il logaritmo naturale |
| exp (x) | Restituisce l'esponenziale di x |
| sqrt (x) | Restituisce la radice quadrata di x |
| fattoriale (x) | Restituisce il fattoriale di x (x!) |
# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)
Produzione:
## [1] 3.806662 3.828641 3.850148 3.871201 3.891820 3.912023 3.931826## [8] 3.951244 3.970292 3.988984 4.007333
#exponentialexp(x_vector)
#squared rootsqrt(x_vector)
Produzione:
## [1] 6.708204 6.782330 6.855655 6.928203 7.000000 7.071068 7.141428## [8] 7.211103 7.280110 7.348469 7.416198
#factorialfactorial(x_vector)
Produzione:
## [1] 1.196222e+56 5.502622e+57 2.586232e+59 1.241392e+61 6.082819e+62## [6] 3.041409e+64 1.551119e+66 8.065818e+67 4.274883e+69 2.308437e+71## [11] 1.269640e+73
Funzioni statistiche
L'installazione standard R contiene un'ampia gamma di funzioni statistiche. In questo tutorial, esamineremo brevemente la funzione più importante ...
Funzioni statistiche di base
|
Operatore |
Descrizione |
|---|---|
|
media (x) |
Media di x |
|
mediana (x) |
Mediana di x |
|
var (x) |
Varianza di x |
|
sd (x) |
Deviazione standard di x |
|
scala (x) |
Punteggi standard (punteggi z) di x |
|
quantile (x) |
I quartili di x |
|
riepilogo (x) |
Riepilogo di x: media, min, max ecc ... |
speed <- dt$speedspeed# Mean speed of cars datasetmean(speed)
Produzione:
## [1] 15.4
# Median speed of cars datasetmedian(speed)
Produzione:
## [1] 15
# Variance speed of cars datasetvar(speed)
Produzione:
## [1] 27.95918
# Standard deviation speed of cars datasetsd(speed)
Produzione:
## [1] 5.287644
# Standardize vector speed of cars datasethead(scale(speed), 5)
Produzione:
## [,1]## [1,] -2.155969## [2,] -2.155969## [3,] -1.588609## [4,] -1.588609## [5,] -1.399489
# Quantile speed of cars datasetquantile(speed)
Produzione:
## 0% 25% 50% 75% 100%## 4 12 15 19 25
# Summary speed of cars datasetsummary(speed)
Produzione:
## Min. 1st Qu. Median Mean 3rd Qu. Max.## 4.0 12.0 15.0 15.4 19.0 25.0
Fino a questo punto, abbiamo imparato molte funzioni integrate di R.
Nota : prestare attenzione alla classe dell'argomento, ovvero numerica, booleana o stringa. Ad esempio, se dobbiamo passare un valore stringa, dobbiamo racchiudere la stringa tra virgolette: "ABC".
Scrivi la funzione in R
In alcune occasioni, abbiamo bisogno di scrivere la nostra funzione perché dobbiamo svolgere un compito particolare e non esiste alcuna funzione già pronta. Una funzione definita dall'utente comprende un nome , argomenti e un corpo .
function.name <- function(arguments){computations on the argumentssome other code}
Nota : una buona pratica è denominare una funzione definita dall'utente in modo diverso da una funzione incorporata. Evita la confusione.
Una funzione argomento
Nel prossimo frammento, definiamo una semplice funzione quadrata. La funzione accetta un valore e restituisce il quadrato del valore.
square_function<- function(n){# compute the square of integer `n`n^2}# calling the function and passing value 4square_function(4)
Spiegazione del codice:
- La funzione si chiama square_function; può essere chiamato come vogliamo.
- Riceve un argomento "n". Non abbiamo specificato il tipo di variabile in modo che l'utente possa passare un numero intero, un vettore o una matrice
- La funzione prende l'input "n" e restituisce il quadrato dell'input.
Quando hai finito di usare la funzione, possiamo rimuoverla con la funzione rm ().
# dopo aver creato la funzione
rm(square_function)square_function
Sulla console, possiamo vedere un messaggio di errore: Errore: oggetto 'square_function' non trovato indicando che la funzione non esiste.
Ambito ambientale
In R, l' ambiente è una raccolta di oggetti come funzioni, variabili, data frame, ecc.
R apre un ambiente ogni volta che viene richiesto Rstudio.
L'ambiente di primo livello disponibile è l' ambiente globale , denominato R_GlobalEnv. E abbiamo l' ambiente locale.
Possiamo elencare il contenuto dell'ambiente corrente.
ls(environment())
Produzione
## [1] "diff_ts" "dt" "speed" "square_function"## [5] "ts" "x" "x_vector"
Puoi vedere tutte le variabili e le funzioni create nel file R_GlobalEnv.
L'elenco sopra varierà per te in base al codice storico che esegui in R Studio.
Notare che n, l'argomento della funzione square_function non è in questo ambiente globale .
Per ogni funzione viene creato un nuovo ambiente. Nell'esempio sopra, la funzione square_function () crea un nuovo ambiente all'interno dell'ambiente globale.
Per chiarire la differenza tra ambiente globale e locale , studiamo il seguente esempio
Queste funzioni accettano un valore x come argomento e lo aggiungono a y definiscono all'esterno e all'interno della funzione
La funzione f restituisce l'output 15. Questo perché y è definito nell'ambiente globale. Qualsiasi variabile definita nell'ambiente globale può essere utilizzata localmente. La variabile y ha il valore 10 durante tutte le chiamate di funzione ed è accessibile in qualsiasi momento.
Vediamo cosa succede se la variabile y è definita all'interno della funzione.
Dobbiamo rilasciare "y" prima di eseguire questo codice usando rm r
Anche l'output è 15 quando chiamiamo f (5) ma restituisce un errore quando proviamo a stampare il valore y. La variabile y non è nell'ambiente globale.
Infine, R utilizza la definizione di variabile più recente per passare all'interno del corpo di una funzione. Consideriamo il seguente esempio:
R ignora i valori y definiti all'esterno della funzione perché abbiamo creato esplicitamente una variabile y all'interno del corpo della funzione.
Funzione multi argomenti
Possiamo scrivere una funzione con più di un argomento. Considera la funzione chiamata "times". È una funzione semplice che moltiplica due variabili.
times <- function(x,y) {x*y}times(2,4)
Produzione:
## [1] 8
Quando dovremmo scrivere function?
Il data scientist deve svolgere molte attività ripetitive. Il più delle volte, copiamo e incolliamo ripetutamente blocchi di codice. Ad esempio, la normalizzazione di una variabile è altamente consigliata prima di eseguire un algoritmo di apprendimento automatico. La formula per normalizzare una variabile è:
Sappiamo già come usare le funzioni min () e max () in R. Usiamo la libreria tibble per creare il data frame. Tibble è finora la funzione più conveniente per creare un set di dati da zero.
library(tibble)# Create a data framedata_frame <- tibble(c1 = rnorm(50, 5, 1.5),c2 = rnorm(50, 5, 1.5),c3 = rnorm(50, 5, 1.5),)
Procederemo in due passaggi per calcolare la funzione sopra descritta. Nel primo passaggio, creeremo una variabile chiamata c1_norm che è il ridimensionamento di c1. Nel secondo passaggio, copiamo e incolliamo semplicemente il codice di c1_norm e lo cambiamo con c2 e c3.
Particolare della funzione con la colonna c1:
Nominatore:: data_frame $ c1 -min (data_frame $ c1))
Denominatore: max (data_frame $ c1) -min (data_frame $ c1))
Pertanto, possiamo dividerli per ottenere il valore normalizzato della colonna c1:
(data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))
Possiamo creare c1_norm, c2_norm e c3_norm:
Create c1_norm: rescaling of c1data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))# show the first five valueshead(data_frame$c1_norm, 5)
Produzione:
## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991
Funziona. Possiamo copiare e incollare
data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))
quindi modificare c1_norm in c2_norm e c1 in c2. Facciamo lo stesso per creare c3_norm
data_frame$c2_norm <- (data_frame$c2 - min(data_frame$c2))/(max(data_frame$c2)-min(data_frame$c2))data_frame$c3_norm <- (data_frame$c3 - min(data_frame$c3))/(max(data_frame$c3)-min(data_frame$c3))
Abbiamo perfettamente ridimensionato le variabili c1, c2 e c3.
Tuttavia, questo metodo è soggetto a errori. Potremmo copiare e dimenticare di cambiare il nome della colonna dopo averlo incollato. Pertanto, una buona pratica è scrivere una funzione ogni volta che è necessario incollare lo stesso codice più di due volte. Possiamo riorganizzare il codice in una formula e chiamarlo ogni volta che è necessario. Per scrivere la nostra funzione, dobbiamo dare:
- Nome: normalizza.
- il numero di argomenti: abbiamo solo bisogno di un argomento, che è la colonna che usiamo nel nostro calcolo.
- Il corpo: questa è semplicemente la formula che vogliamo restituire.
Procederemo passo passo per creare la funzione normalizza.
Passaggio 1) Creiamo il nominatore , che è. In R, possiamo memorizzare il nominatore in una variabile come questa:
nominator <- x-min(x)
Punto 2) Si calcola la denominatore: . Possiamo replicare l'idea del passaggio 1 e memorizzare il calcolo in una variabile:
denominator <- max(x)-min(x)
Step 3) Eseguiamo la divisione tra il nominatore e il denominatore.
normalize <- nominator/denominator
Passaggio 4) Per restituire valore alla funzione chiamante, è necessario passare normalize all'interno di return () per ottenere l'output della funzione.
return(normalize)
Passaggio 5) Siamo pronti per utilizzare la funzione avvolgendo il tutto all'interno della staffa.
normalize <- function(x){# step 1: create the nominatornominator <- x-min(x)# step 2: create the denominatordenominator <- max(x)-min(x)# step 3: divide nominator by denominatornormalize <- nominator/denominator# return the valuereturn(normalize)}
Testiamo la nostra funzione con la variabile c1:
normalize(data_frame$c1)
Funziona perfettamente. Abbiamo creato la nostra prima funzione.
Le funzioni sono un modo più completo per eseguire un'attività ripetitiva. Possiamo usare la formula di normalizzazione su colonne diverse, come di seguito:
data_frame$c1_norm_function <- normalize (data_frame$c1)data_frame$c2_norm_function <- normalize (data_frame$c2)data_frame$c3_norm_function <- normalize (data_frame$c3)
Anche se l'esempio è semplice, possiamo dedurre la potenza di una formula. Il codice sopra è più facile da leggere e soprattutto evita errori quando si incollano i codici.
Funziona con condizione
A volte, è necessario includere condizioni in una funzione per consentire al codice di restituire output diversi.
Nelle attività di Machine Learning, è necessario suddividere il set di dati tra un set di treni e un set di test. Il set di treni consente all'algoritmo di apprendere dai dati. Per testare le prestazioni del nostro modello, possiamo utilizzare il set di test per restituire la misura delle prestazioni. R non ha una funzione per creare due set di dati. Possiamo scrivere la nostra funzione per farlo. La nostra funzione accetta due argomenti e si chiama split_data (). L'idea alla base è semplice, moltiplichiamo la lunghezza del set di dati (cioè il numero di osservazioni) per 0,8. Ad esempio, se vogliamo dividere il set di dati 80/20 e il nostro set di dati contiene 100 righe, la nostra funzione moltiplicherà 0,8 * 100 = 80. 80 righe verranno selezionate per diventare i nostri dati di allenamento.
Useremo il set di dati di qualità dell'aria per testare la nostra funzione definita dall'utente. Il set di dati sulla qualità dell'aria ha 153 righe. Possiamo vederlo con il codice qui sotto:
nrow(airquality)
Produzione:
## [1] 153
Procederemo come segue:
split_data <- function(df, train = TRUE)Arguments:-df: Define the dataset-train: Specify if the function returns the train set or test set. By default, set to TRUE
La nostra funzione ha due argomenti. L'argomento train è un parametro booleano. Se è impostato su TRUE, la nostra funzione crea il set di dati del treno, altrimenti crea il set di dati di prova.
Possiamo procedere come abbiamo fatto con la funzione normalize (). Scriviamo il codice come se fosse solo un codice una tantum e quindi avvolgiamo tutto con la condizione nel corpo per creare la funzione.
Passo 1:
Dobbiamo calcolare la lunghezza del set di dati. Questo viene fatto con la funzione nrow (). Nrow restituisce il numero totale di righe nel set di dati. Chiamiamo lunghezza variabile.
length<- nrow(airquality)length
Produzione:
## [1] 153
Passo 2:
Moltiplichiamo la lunghezza per 0,8. Restituirà il numero di righe da selezionare. Dovrebbe essere 153 * 0,8 = 122,4
total_row <- length*0.8total_row
Produzione:
## [1] 122.4
Vogliamo selezionare 122 righe tra le 153 righe nel set di dati sulla qualità dell'aria. Creiamo una lista contenente valori da 1 a total_row. Memorizziamo il risultato nella variabile chiamata split
split <- 1:total_rowsplit[1:5]
Produzione:
## [1] 1 2 3 4 5
split sceglie le prime 122 righe del set di dati. Ad esempio, possiamo vedere che la nostra divisione variabile raccoglie il valore 1, 2, 3, 4, 5 e così via. Questi valori saranno l'indice quando selezioneremo le righe da restituire.
Passaggio 3:
Dobbiamo selezionare le righe nel dataset di qualità dell'aria in base ai valori memorizzati nella variabile di divisione. Questo è fatto in questo modo:
train_df <- airquality[split, ]head(train_df)
Produzione:
##[1] Ozone Solar.R Wind Temp Month Day##[2] 51 13 137 10.3 76 6 20##[3] 15 18 65 13.2 58 5 15##[4] 64 32 236 9.2 81 7 3##[5] 27 NA NA 8.0 57 5 27##[6] 58 NA 47 10.3 73 6 27##[7] 44 23 148 8.0 82 6 13
Passaggio 4:
Possiamo creare il set di dati di test utilizzando le righe rimanenti, 123: 153. Questo viene fatto usando - davanti alla divisione.
test_df <- airquality[-split, ]head(test_df)
Produzione:
##[1] Ozone Solar.R Wind Temp Month Day##[2] 123 85 188 6.3 94 8 31##[3] 124 96 167 6.9 91 9 1##[4] 125 78 197 5.1 92 9 2##[5] 126 73 183 2.8 93 9 3##[6] 127 91 189 4.6 93 9 4##[7] 128 47 95 7.4 87 9 5
Passaggio 5:
Possiamo creare la condizione all'interno del corpo della funzione. Ricorda, abbiamo un argomento train che è un valore booleano impostato su TRUE per impostazione predefinita per restituire il train set. Per creare la condizione, usiamo la sintassi if:
if (train ==TRUE){train_df <- airquality[split, ]return(train)} else {test_df <- airquality[-split, ]return(test)}
Questo è tutto, possiamo scrivere la funzione. Dobbiamo solo cambiare la qualità dell'aria in df perché vogliamo provare la nostra funzione su qualsiasi frame di dati, non solo qualità dell'aria:
split_data <- function(df, train = TRUE){length<- nrow(df)total_row <- length *0.8split <- 1:total_rowif (train ==TRUE){train_df <- df[split, ]return(train_df)} else {test_df <- df[-split, ]return(test_df)}}
Proviamo la nostra funzione sul dataset di qualità dell'aria. dovremmo avere un set di treni con 122 file e un set di test con 31 file.
train <- split_data(airquality, train = TRUE)dim(train)
Produzione:
## [1] 122 6
test <- split_data(airquality, train = FALSE)dim(test)
Produzione:
## [1] 31 6