Funktioner i R-programmering (med eksempel)

Indholdsfortegnelse:

Anonim

Hvad er en funktion i R?

En funktion i et programmeringsmiljø er et sæt instruktioner. En programmør bygger en funktion for at undgå at gentage den samme opgave eller reducere kompleksiteten.

En funktion skal være

  • skrevet til at udføre en specificeret en opgaver
  • kan eller ikke inkluderer argumenter
  • indeholder et legeme
  • returnerer muligvis en eller flere værdier.

En generel tilgang til en funktion er at bruge argumentdelen som input , føde kropsdelen og endelig returnere en output . Syntaks for en funktion er følgende:

function (arglist) {#Function body}

I denne vejledning lærer vi

  • R vigtige indbyggede funktioner
  • Generelle funktioner
  • Matematiske funktioner
  • Statistiske funktioner
  • Skriv funktion i R
  • Hvornår skal vi skrive funktion?
  • Funktioner med tilstand

R vigtige indbyggede funktioner

Der er mange indbyggede funktioner i R. R matcher dine inputparametre med dens funktionsargumenter, enten efter værdi eller efter position, og derefter udfører funktionsdelen. Funktionsargumenter kan have standardværdier: hvis du ikke angiver disse argumenter, tager R standardværdien.

Bemærk : Det er muligt at se kildekoden for en funktion ved at køre navnet på selve funktionen i konsollen.

Vi vil se tre funktionsgrupper i aktion

  • Generel funktion
  • Matematik funktion
  • Statistisk funktion

Generelle funktioner

Vi er allerede fortrolige med generelle funktioner som cbind (), rbind (), range (), sort (), order () -funktioner. Hver af disse funktioner har en bestemt opgave, tager argumenter for at returnere et output. Følgende er vigtige funktioner, man skal kende til

diff () funktion

Hvis du arbejder på tidsserier , skal du stille serien ved at tage deres forsinkelsesværdier . En stationær proces tillader konstant gennemsnit, varians og autokorrelation over tid. Dette forbedrer hovedsageligt forudsigelsen af ​​en tidsserie. Det kan let gøres med funktionen diff (). Vi kan oprette tilfældige tidsseriedata med en tendens og derefter bruge funktionen diff () til at stille serien. Funktionen diff () accepterer et argument, en vektor og returnerer passende forsinket og itereret forskel.

Bemærk : Vi har ofte brug for at oprette tilfældige data, men for læring og sammenligning ønsker vi, at tallene skal være identiske på tværs af maskiner. For at sikre, at vi alle genererer de samme data, bruger vi funktionen set.seed () med vilkårlige værdier på 123. Funktionen set.seed () genereres gennem processen med pseudorandom-talgenerator, der får alle moderne computere til at have den samme sekvens af tal. Hvis vi ikke bruger funktionen set.seed (), har vi alle forskellige rækkefølge af tal.

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),)

længde () funktion

I mange tilfælde vil vi vide længden af en vektor til beregning eller bruges i en for-loop. Funktionen længde () tæller antallet af rækker i vektor x. Følgende koder importerer datasættet biler og returnerer antallet af rækker.

Bemærk : længde () returnerer antallet af elementer i en vektor. Hvis funktionen sendes til en matrix eller en dataramme, returneres antallet af kolonner.

dt <- cars## number columnslength(dt)

Produktion:

## [1] 1
## number rowslength(dt[,1])

Produktion:

## [1] 50

Matematiske funktioner

R har en række matematiske funktioner.

Operatør Beskrivelse
abs (x) Tager den absolutte værdi af x
log (x, base = y) Tager logaritmen af ​​x med base y; hvis base ikke er specificeret, returneres den naturlige logaritme
exp (x) Returnerer eksponentialet for x
sqrt (x) Returnerer kvadratroden af ​​x
faktor (x) Returnerer faktoren for x (x!) 
# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)

Produktion:

## [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)

Produktion:

## [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)

Produktion:

## [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

Statistiske funktioner

R-standardinstallation indeholder en lang række statistiske funktioner. I denne vejledning vil vi kort se på den vigtigste funktion ...

Grundlæggende statistiske funktioner

Operatør

Beskrivelse

middelværdi (x)

Gennemsnit af x

median (x)

Median af x

var (x)

Variant af x

sd (x)

Standardafvigelse på x

skala (x)

Standard score (z-scores) på x

kvantil (x)

Kvartilerne af x

resume (x)

Oversigt over x: middel, min, maks osv ...

 
speed <- dt$speedspeed# Mean speed of cars datasetmean(speed)

Produktion:

## [1] 15.4
# Median speed of cars datasetmedian(speed)

Produktion:

## [1] 15
# Variance speed of cars datasetvar(speed)

Produktion:

## [1] 27.95918
# Standard deviation speed of cars datasetsd(speed)

Produktion:

## [1] 5.287644
# Standardize vector speed of cars datasethead(scale(speed), 5)

Produktion:

## [,1]## [1,] -2.155969## [2,] -2.155969## [3,] -1.588609## [4,] -1.588609## [5,] -1.399489
# Quantile speed of cars datasetquantile(speed)

Produktion:

## 0% 25% 50% 75% 100%## 4 12 15 19 25
# Summary speed of cars datasetsummary(speed)

Produktion:

## Min. 1st Qu. Median Mean 3rd Qu. Max.## 4.0 12.0 15.0 15.4 19.0 25.0

Indtil dette tidspunkt har vi lært en masse R-indbyggede funktioner.

Bemærk : Vær forsigtig med klassen for argumentet, dvs. numerisk, boolsk eller streng. For eksempel, hvis vi har brug for at videregive en strengværdi, skal vi vedlægge strengen i anførselstegn: "ABC".

Skriv funktion i R

I en eller anden lejlighed er vi nødt til at skrive vores egen funktion, fordi vi er nødt til at udføre en bestemt opgave, og der findes ingen færdiglavet funktion. En brugerdefineret funktion involverer et navn , argumenter og et organ .

function.name <- function(arguments){computations on the argumentssome other code}

Bemærk : En god praksis er at navngive en brugerdefineret funktion, der adskiller sig fra en indbygget funktion. Det undgår forvirring.

Et argument funktion

I det næste uddrag definerer vi en simpel firkantet funktion. Funktionen accepterer en værdi og returnerer kvadratet for værdien.

square_function<- function(n){# compute the square of integer `n`n^2}# calling the function and passing value 4square_function(4)

Kode Forklaring:

  • Funktionen hedder firkantet_funktion; det kan kaldes hvad vi vil.
  • Den modtager argumentet "n". Vi specificerede ikke typen af ​​variabel, så brugeren kan passere et heltal, en vektor eller en matrix
  • Funktionen tager input "n" og returnerer kvadratet for input.

    Når du er færdig med at bruge funktionen, kan vi fjerne den med rm () -funktionen.

# når du opretter funktionen 

rm(square_function)square_function

På konsollen kan vi se en fejlmeddelelse: Fejl: objektet 'firkantfunktion' blev ikke fundet, der fortæller, at funktionen ikke findes.

Miljøomfang

I R er miljøet en samling af objekter som funktioner, variabler, dataramme osv.

R åbner et miljø hver gang Rstudio bliver bedt om det.

Det øverste miljø, der er tilgængeligt, er det globale miljø , kaldet R_GlobalEnv. Og vi har det lokale miljø.

Vi kan liste indholdet af det aktuelle miljø.

ls(environment())

Produktion

## [1] "diff_ts" "dt" "speed" "square_function"## [5] "ts" "x" "x_vector"

Du kan se alle de variabler og funktioner, der er oprettet i R_GlobalEnv.

Ovenstående liste vil variere for dig baseret på den historiske kode, du udfører i R Studio.

Bemærk, at n, argumentet for funktionen square_function ikke er i dette globale miljø .

Der oprettes et nyt miljø for hver funktion. I ovenstående eksempel skaber funktionen square_function () et nyt miljø inde i det globale miljø.

For at afklare forskellen mellem globalt og lokalt miljø , lad os studere følgende eksempel

Disse funktioner tager en værdi x som et argument og føjer den til y definerer uden for og inde i funktionen

Funktionen f returnerer output 15. Dette skyldes, at y er defineret i det globale miljø. Enhver variabel, der er defineret i det globale miljø, kan bruges lokalt. Variablen y har værdien 10 under alle funktionsopkald og er tilgængelig til enhver tid.

Lad os se, hvad der sker, hvis variablen y er defineret inde i funktionen.

Vi er nødt til at droppe `y`, før vi kører denne kode ved hjælp af rm r

Outputtet er også 15, når vi kalder f (5), men returnerer en fejl, når vi prøver at udskrive værdien y. Variablen y findes ikke i det globale miljø.

Endelig bruger R den nyeste variabeldefinition til at passere inde i kroppen af ​​en funktion. Lad os overveje følgende eksempel:

R ignorerer de y-værdier, der er defineret uden for funktionen, fordi vi eksplicit oprettede en a-variabel inde i funktionens krop.

Multi argumenter funktion

Vi kan skrive en funktion med mere end et argument. Overvej funktionen kaldet "tider". Det er en ligetil funktion, der multiplicerer to variabler.

times <- function(x,y) {x*y}times(2,4)

Produktion:

## [1] 8

Hvornår skal vi skrive funktion?

Datavidenskabsmand skal udføre mange gentagne opgaver. Det meste af tiden kopierer og indsætter vi klumper af kode gentagne gange. F.eks. Anbefales normalisering af en variabel, inden vi kører en maskinlæringsalgoritme. Formlen til normalisering af en variabel er:

Vi ved allerede, hvordan vi bruger min () og max () -funktionen i R. Vi bruger tibble-biblioteket til at oprette datarammen. Tibble er hidtil den mest bekvemme funktion til at oprette et datasæt fra bunden.

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),)

Vi fortsætter i to trin til at beregne funktionen beskrevet ovenfor. I det første trin opretter vi en variabel kaldet c1_norm, som er skalering af c1. I trin to kopierer og indsætter vi bare koden for c1_norm og ændrer med c2 og c3.

Detalje af funktionen med kolonnen c1:

Nominator:: data_frame $ c1 -min (data_frame $ c1))

Nævner: max (data_frame $ c1) -min (data_frame $ c1))

Derfor kan vi dele dem for at få den normaliserede værdi af kolonne c1:

(data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))

Vi kan oprette c1_norm, c2_norm og 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)

Produktion:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Det virker. Vi kan kopiere og indsætte

data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))

skift derefter c1_norm til c2_norm og c1 til c2. Vi gør det samme for at oprette 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))

Vi omskalede perfekt variablerne c1, c2 og c3.

Denne metode er imidlertid tilbøjelig til at tage fejl. Vi kunne kopiere og glemme at ændre kolonnenavnet efter indsættelse. Derfor er en god praksis at skrive en funktion hver gang du skal indsætte den samme kode mere end to gange. Vi kan omarrangere koden i en formel og kalde den, når det er nødvendigt. For at skrive vores egen funktion skal vi give:

  • Navn: normaliser.
  • antallet af argumenter: Vi har kun brug for et argument, som er den kolonne, vi bruger i vores beregning.
  • Kroppen: dette er simpelthen den formel, vi vil returnere.

Vi fortsætter trin for trin for at oprette funktionen normalisere.

Trin 1) Vi opretter nominatoren , hvilket er. I R kan vi gemme nominatoren i en variabel som denne:

nominator <- x-min(x)

Trin 2) Vi beregner den nævneren: . Vi kan replikere ideen til trin 1 og gemme beregningen i en variabel:

denominator <- max(x)-min(x)

Trin 3) Vi udfører opdelingen mellem nominatoren og nævneren.

normalize <- nominator/denominator

Trin 4) For at returnere værdien til opkaldsfunktionen er vi nødt til at passere normalisere inde i retur () for at få output af funktionen.

return(normalize)

Trin 5) Vi er klar til at bruge funktionen ved at indpakke alt inden i beslaget.

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)}

Lad os teste vores funktion med variablen c1:

normalize(data_frame$c1)

Det fungerer perfekt. Vi oprettede vores første funktion.

Funktioner er en mere omfattende måde at udføre en gentagende opgave på. Vi kan bruge normaliseringsformlen over forskellige kolonner, som nedenfor:

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)

Selvom eksemplet er simpelt, kan vi udlede kraften i en formel. Ovenstående kode er lettere at læse og undgår især fejl ved indsættelse af koder.

Funktioner med tilstand

Nogle gange er vi nødt til at inkludere betingelser i en funktion for at tillade koden at returnere forskellige output.

I Machine Learning-opgaver er vi nødt til at opdele datasættet mellem et togsæt og et testsæt. Togsættet gør det muligt for algoritmen at lære af dataene. For at teste ydelsen af ​​vores model kan vi bruge testsættet til at returnere præstationsmålingen. R har ikke en funktion til at oprette to datasæt. Vi kan skrive vores egen funktion for at gøre det. Vores funktion tager to argumenter og kaldes split_data (). Ideen bag er enkel, vi multiplicerer længden af ​​datasættet (dvs. antal observationer) med 0,8. For eksempel, hvis vi vil opdele datasættet 80/20, og vores datasæt indeholder 100 rækker, så multiplicerer vores funktion 0,8 * 100 = 80. 80 rækker vælges til at blive vores træningsdata.

Vi bruger luftkvalitetsdatasættet til at teste vores brugerdefinerede funktion. Luftkvalitetsdatasættet har 153 rækker. Vi kan se det med nedenstående kode:

nrow(airquality)

Produktion:

## [1] 153

Vi fortsætter som følger:

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

Vores funktion har to argumenter. Argumentationstoget er en boolsk parameter. Hvis det er indstillet til SAND, opretter vores funktion togdatasættet, ellers opretter det testdatasættet.

Vi kan fortsætte som om vi gjorde normaliseringsfunktionen (). Vi skriver koden, som om det kun var en engangskode, og pakk derefter alt med tilstanden ind i kroppen for at skabe funktionen.

Trin 1:

Vi er nødt til at beregne længden af ​​datasættet. Dette gøres med funktionen nrow (). Nrow returnerer det samlede antal rækker i datasættet. Vi kalder den variable længde.

length<- nrow(airquality)length

Produktion:

## [1] 153

Trin 2:

Vi ganger længden med 0,8. Det returnerer antallet af rækker, der skal vælges. Det skal være 153 * 0,8 = 122,4

total_row <- length*0.8total_row

Produktion:

## [1] 122.4

Vi ønsker at vælge 122 rækker blandt de 153 rækker i luftkvalitetsdatasættet. Vi opretter en liste, der indeholder værdier fra 1 til total_row. Vi gemmer resultatet i variablen kaldet split

split <- 1:total_rowsplit[1:5]

Produktion:

## [1] 1 2 3 4 5

split vælger de første 122 rækker fra datasættet. For eksempel kan vi se, at vores variable split samler værdien 1, 2, 3, 4, 5 og så videre. Disse værdier vil være indekset, når vi vælger de rækker, der skal returneres.

Trin 3:

Vi er nødt til at vælge rækkerne i luftkvalitetsdatasættet baseret på de værdier, der er gemt i splitvariablen. Dette gøres sådan:

train_df <- airquality[split, ]head(train_df)

Produktion:

##[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

Trin 4:

Vi kan oprette testdatasættet ved hjælp af de resterende rækker, 123: 153. Dette gøres ved at bruge - foran split.

test_df <- airquality[-split, ]head(test_df)

Produktion:

##[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

Trin 5:

Vi kan skabe tilstanden inde i funktionens krop. Husk, vi har et argument, der er et boolsk sæt som SAND som standard for at returnere togsættet. For at oprette tilstanden bruger vi syntaxen if:

if (train ==TRUE){train_df <- airquality[split, ]return(train)} else {test_df <- airquality[-split, ]return(test)}

Dette er det, vi kan skrive funktionen. Vi skal kun ændre luftkvalitet til df, fordi vi vil prøve vores funktion til enhver dataramme, ikke kun luftkvalitet:

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)}}

Lad os prøve vores funktion på luftkvalitetsdatasættet. vi skulle have et togsæt med 122 rækker og et testsæt med 31 rækker.

train <- split_data(airquality, train = TRUE)dim(train)

Produktion:

## [1] 122 6
test <- split_data(airquality, train = FALSE)dim(test)

Produktion:

## [1] 31 6