Funksjoner i R-programmering (med eksempel)

Innholdsfortegnelse:

Anonim

Hva er en funksjon i R?

En funksjon , i et programmeringsmiljø, er et sett med instruksjoner. En programmerer bygger en funksjon for å unngå å gjenta den samme oppgaven, eller redusere kompleksiteten.

En funksjon skal være

  • skrevet for å utføre en spesifisert oppgave
  • kan eller ikke inkluderer argumenter
  • inneholde en kropp
  • kan eller ikke returnere en eller flere verdier.

En generell tilnærming til en funksjon er å bruke argumentdelen som innganger , mate kroppsdelen og til slutt returnere en utgang . Syntaksen til en funksjon er følgende:

function (arglist) {#Function body}

I denne opplæringen vil vi lære

  • R viktige innebygde funksjoner
  • Generelle funksjoner
  • Matematiske funksjoner
  • Statistiske funksjoner
  • Skriv funksjon i R
  • Når skal vi skrive funksjon?
  • Funksjoner med tilstand

R viktige innebygde funksjoner

Det er mange innebygde funksjoner i R. R samsvarer med inngangsparametrene dine med funksjonsargumentene, enten etter verdi eller posisjon, og utfører deretter funksjonsdelen. Funksjonsargumenter kan ha standardverdier: Hvis du ikke spesifiserer disse argumentene, vil R ta standardverdien.

Merk : Det er mulig å se kildekoden til en funksjon ved å kjøre navnet på selve funksjonen i konsollen.

Vi vil se tre funksjonsgrupper i aksjon

  • Generell funksjon
  • Matematikk funksjon
  • Statistisk funksjon

Generelle funksjoner

Vi er allerede kjent med generelle funksjoner som cbind (), rbind (), range (), sort (), order () -funksjoner. Hver av disse funksjonene har en spesifikk oppgave, tar argumenter for å returnere en utgang. Følgende er viktige funksjoner man må vite-

diff () -funksjon

Hvis du jobber med tidsserier , må du stille serien ved å ta forsinkelsesverdiene . En stasjonær prosess tillater konstant gjennomsnitt, varians og autokorrelasjon over tid. Dette forbedrer hovedsakelig spådommen av en tidsserie. Det kan enkelt gjøres med funksjonen diff (). Vi kan bygge tilfeldige tidsseriedata med en trend og deretter bruke funksjonen diff () til å stasjonær serien. Funksjonen diff () godtar ett argument, en vektor, og returnerer passende forsinket og iterert forskjell.

Merk : Vi trenger ofte å lage tilfeldige data, men for læring og sammenligning vil vi at tallene skal være identiske på tvers av maskiner. For å sikre at vi alle genererer de samme dataene, bruker vi set.seed () -funksjonen med vilkårlige verdier på 123. Set.seed () -funksjonen genereres gjennom prosessen med pseudorandom-talgenerator som gjør at alle moderne datamaskiner har samme sekvens av tall. Hvis vi ikke bruker set.seed () -funksjonen, vil vi alle ha forskjellige sekvenser av tall.

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

lengde () -funksjon

I mange tilfeller ønsker vi å vite lengden på en vektor for beregning eller å brukes i en for-loop. Funksjonen lengde () teller antall rader i vektor x. Følgende koder importerer datasettet for biler og returnerer antall rader.

Merk : lengde () returnerer antall elementer i en vektor. Hvis funksjonen overføres til en matrise eller en dataramme, returneres antall kolonner.

dt <- cars## number columnslength(dt)

Produksjon:

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

Produksjon:

## [1] 50

Matematiske funksjoner

R har en rekke matematiske funksjoner.

Operatør Beskrivelse
abs (x) Tar den absolutte verdien av x
logg (x, base = y) Tar logaritmen til x med base y; hvis base ikke er spesifisert, returnerer den naturlige logaritmen
exp (x) Returnerer eksponentiell for x
sqrt (x) Returnerer kvadratroten til x
fabrikk (x) Returnerer faktoren til x (x!) 
# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)

Produksjon:

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

Produksjon:

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

Produksjon:

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

R standardinstallasjon inneholder et bredt spekter av statistiske funksjoner. I denne opplæringen vil vi kort se på den viktigste funksjonen ...

Grunnleggende statistikkfunksjoner

Operatør

Beskrivelse

gjennomsnitt (x)

Gjennomsnitt av x

median (x)

Median av x

var (x)

Variasjon av x

sd (x)

Standardavvik på x

skala (x)

Standardpoeng (z-poeng) på x

kvantil (x)

Kvartilene til x

oppsummering (x)

Sammendrag av x: gjennomsnitt, min, maks osv ...

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

Produksjon:

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

Produksjon:

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

Produksjon:

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

Produksjon:

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

Produksjon:

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

Produksjon:

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

Produksjon:

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

Fram til dette har vi lært mange R-innebygde funksjoner.

Merk : Vær forsiktig med klassen til argumentet, dvs. numerisk, boolsk eller streng. For eksempel, hvis vi trenger å sende en strengverdi, må vi legge strengen i anførselstegnet: "ABC".

Skriv funksjon i R

I noen tilfeller trenger vi å skrive vår egen funksjon fordi vi må utføre en bestemt oppgave og ingen ferdige funksjoner eksisterer. En brukerdefinert funksjon involverer et navn , argumenter og en kropp .

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

Merk : En god praksis er å navngi en brukerdefinert funksjon som er forskjellig fra en innebygd funksjon. Det unngår forvirring.

Ett argument funksjon

I neste utdrag definerer vi en enkel firkantfunksjon. Funksjonen aksepterer en verdi og returnerer kvadratet til verdien.

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

Kode Forklaring:

  • Funksjonen heter square_function; det kan kalles hva vi vil.
  • Den får argumentet "n". Vi spesifiserte ikke typen variabel slik at brukeren kan passere et heltall, en vektor eller en matrise
  • Funksjonen tar inngangen "n" og returnerer kvadratet til inngangen.

    Når du er ferdig med å bruke funksjonen, kan vi fjerne den med rm () -funksjonen.

# etter at du oppretter funksjonen 

rm(square_function)square_function

På konsollen kan vi se en feilmelding: Feil: objektet 'square_function' ble ikke funnet og forteller at funksjonen ikke eksisterer.

Miljøomfang

I R er miljøet en samling av objekter som funksjoner, variabler, dataramme, etc.

R åpner et miljø hver gang Rstudio blir bedt om det.

Det tilgjengelige miljøet på toppnivå er det globale miljøet , kalt R_GlobalEnv. Og vi har nærmiljøet.

Vi kan liste innholdet i dagens miljø.

ls(environment())

Produksjon

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

Du kan se alle variablene og funksjonene som er opprettet i R_GlobalEnv.

Listen over vil variere for deg basert på den historiske koden du utfører i R Studio.

Merk at n, argumentet til funksjonen kvadrat_funksjon ikke er i dette globale miljøet .

Det opprettes et nytt miljø for hver funksjon. I eksemplet ovenfor skaper funksjonen square_function () et nytt miljø i det globale miljøet.

For å avklare forskjellen mellom globalt og lokalt miljø , la oss studere følgende eksempel

Disse funksjonene tar en verdi x som et argument og legger den til y definere utenfor og inne i funksjonen

Funksjonen f returnerer utdata 15. Dette er fordi y er definert i det globale miljøet. Enhver variabel som er definert i det globale miljøet, kan brukes lokalt. Variabelen y har verdien 10 under alle funksjonsanrop og er tilgjengelig når som helst.

La oss se hva som skjer hvis variabelen y er definert inne i funksjonen.

Vi må droppe `y` før du kjører denne koden ved hjelp av rm r

Utgangen er også 15 når vi kaller f (5), men returnerer en feil når vi prøver å skrive ut verdien y. Variabelen y er ikke i det globale miljøet.

Til slutt bruker R den siste variabeldefinisjonen for å passere i kroppen til en funksjon. La oss vurdere følgende eksempel:

R ignorerer y-verdiene som er definert utenfor funksjonen fordi vi eksplisitt opprettet ay-variabel inne i funksjonen.

Multi argumenter funksjon

Vi kan skrive en funksjon med mer enn ett argument. Tenk på funksjonen som kalles "tider". Det er en grei funksjon som multipliserer to variabler.

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

Produksjon:

## [1] 8

Når skal vi skrive funksjon?

Dataforsker må gjøre mange repetitive oppgaver. Mesteparten av tiden kopierer og limer vi inn biter av kode gjentatte ganger. For eksempel anbefales normalisering av en variabel på det sterkeste før vi kjører en maskinlæringsalgoritme. Formelen for å normalisere en variabel er:

Vi vet allerede hvordan vi bruker min () og max () -funksjonen i R. Vi bruker tibble-biblioteket til å lage datarammen. Tibble er så langt den mest praktiske funksjonen for å lage et datasett fra bunnen av.

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 fortsetter i to trinn for å beregne funksjonen beskrevet ovenfor. I det første trinnet vil vi lage en variabel kalt c1_norm som er omskalering av c1. I trinn to kopierer og limer vi inn koden til c1_norm og endrer med c2 og c3.

Detalj av funksjonen med kolonnen c1:

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

Nevner: max (data_frame $ c1) -min (data_frame $ c1))

Derfor kan vi dele dem for å få den normaliserte verdien av kolonne c1:

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

Vi kan opprette 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)

Produksjon:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Det fungerer. Vi kan kopiere og lime inn

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

endre deretter c1_norm til c2_norm og c1 til c2. Vi gjør det samme for å lage 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 skalerte perfekt variablene c1, c2 og c3.

Imidlertid er denne metoden utsatt for feil. Vi kunne kopiere og glemme å endre kolonnenavnet etter liming. Derfor er en god praksis å skrive en funksjon hver gang du trenger å lime inn samme kode mer enn to ganger. Vi kan omorganisere koden til en formel og kalle den når det er behov for det. For å skrive vår egen funksjon, må vi gi:

  • Navn: normaliser.
  • antall argumenter: Vi trenger bare ett argument, som er kolonnen vi bruker i beregningen.
  • Kroppen: dette er ganske enkelt formelen vi ønsker å returnere.

Vi fortsetter trinn for trinn for å opprette funksjonen normalisere.

Trinn 1) Vi oppretter nominatoren , altså . I R kan vi lagre nominatoren i en variabel som denne:

nominator <- x-min(x)

Trinn 2) Vi beregne evner: . Vi kan kopiere ideen til trinn 1 og lagre beregningen i en variabel:

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

Trinn 3) Vi utfører skillet mellom nominator og nevner.

normalize <- nominator/denominator

Trinn 4) For å returnere verdien til anropsfunksjonen, må vi passere normalisere inni retur () for å få utdata fra funksjonen.

return(normalize)

Trinn 5) Vi er klare til å bruke funksjonen ved å pakke alt inn i braketten.

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

La oss teste funksjonen vår med variabelen c1:

normalize(data_frame$c1)

Det fungerer perfekt. Vi opprettet vår første funksjon.

Funksjoner er en mer omfattende måte å utføre en repeterende oppgave på. Vi kan bruke normaliseringsformelen over forskjellige 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)

Selv om eksemplet er enkelt, kan vi utlede kraften til en formel. Ovennevnte kode er lettere å lese og unngår spesielt feil ved liming av koder.

Funksjoner med tilstand

Noen ganger må vi inkludere forhold i en funksjon for å tillate at koden returnerer forskjellige utganger.

I maskinlæringsoppgaver må vi dele datasettet mellom et togsett og et testsett. Togsettet lar algoritmen lære av dataene. For å teste ytelsen til modellen vår, kan vi bruke testsettet til å returnere ytelsesmål. R har ikke en funksjon for å lage to datasett. Vi kan skrive vår egen funksjon for å gjøre det. Vår funksjon tar to argumenter og kalles split_data (). Ideen bak er enkel, vi multipliserer lengden på datasettet (dvs. antall observasjoner) med 0,8. For eksempel, hvis vi vil dele datasettet 80/20, og datasettet vårt inneholder 100 rader, vil funksjonen vår multipliseres med 0,8 * 100 = 80. 80 rader vil bli valgt for å bli treningsdataene våre.

Vi vil bruke luftkvalitetsdatasettet for å teste vår brukerdefinerte funksjon. Luftkvalitetsdatasettet har 153 rader. Vi kan se det med koden nedenfor:

nrow(airquality)

Produksjon:

## [1] 153

Vi fortsetter 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

Vår funksjon har to argumenter. Argumentertoget er en boolsk parameter. Hvis det er satt til SANN, oppretter vår funksjon togsettet, ellers oppretter det testdatasettet.

Vi kan fortsette som vi gjorde normaliseringsfunksjonen (). Vi skriver koden som om det bare var en engangskode og pakker deretter alt med tilstanden inn i kroppen for å skape funksjonen.

Trinn 1:

Vi må beregne lengden på datasettet. Dette gjøres med funksjonen nrow (). Nrow returnerer totalt antall rader i datasettet. Vi kaller variabel lengde.

length<- nrow(airquality)length

Produksjon:

## [1] 153

Steg 2:

Vi multipliserer lengden med 0,8. Det vil returnere antall rader du vil velge. Det skal være 153 * 0,8 = 122,4

total_row <- length*0.8total_row

Produksjon:

## [1] 122.4

Vi vil velge 122 rader blant de 153 radene i luftkvalitetsdatasettet. Vi oppretter en liste som inneholder verdier fra 1 til total_row. Vi lagrer resultatet i variabelen kalt split

split <- 1:total_rowsplit[1:5]

Produksjon:

## [1] 1 2 3 4 5

split velger de første 122 radene fra datasettet. For eksempel kan vi se at vår variable split samler verdien 1, 2, 3, 4, 5 og så videre. Disse verdiene vil være indeksen når vi velger radene som skal returneres.

Trinn 3:

Vi må velge radene i luftkvalitetsdatasettet basert på verdiene som er lagret i delt variabel. Dette gjøres slik:

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

Produksjon:

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

Trinn 4:

Vi kan lage testdatasettet ved å bruke de resterende radene, 123: 153. Dette gjøres ved å bruke - foran split.

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

Produksjon:

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

Trinn 5:

Vi kan skape tilstanden inne i funksjonen. Husk at vi har et argument tog som er et boolsk sett som SANT som standard for å returnere togsettet. For å opprette tilstanden bruker 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 funksjonen. Vi trenger bare å endre airquality til df fordi vi ønsker å prøve vår funksjon til en hvilken som helst dataramme, ikke bare airquality:

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

La oss prøve funksjonen vår i luftkvalitetsdatasettet. vi skulle ha ett togsett med 122 rader og et testsett med 31 rader.

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

Produksjon:

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

Produksjon:

## [1] 31 6