Functies in R-programmering met voorbeeld

Wat is een functie in R?

A functie, in een programmeeromgeving, is een reeks instructies. Een programmeur bouwt een functie om te vermijden het herhalen van de dezelfde taak, of verminderen complexheid.

Een functie zou moeten zijn

  • geschreven om bepaalde taken uit te voeren
  • kan wel of geen argumenten bevatten
  • een lichaam bevatten
  • kan wel of niet een of meer waarden retourneren.

Een algemene benadering van een functie is om het argumentgedeelte as te gebruiken ingangen, Eten geven aan lichaam deel en uiteindelijk een terug uitgang. De syntaxis van een functie is de volgendewing:

function (arglist)  {
  #Function body
}

R belangrijke ingebouwde functies

Er zijn veel ingebouwde functies in R. R matcht uw invoerparameters met zijn functieargumenten, hetzij op waarde of op positie, en voert vervolgens de hoofdtekst van de functie uit. Functieargumenten kunnen standaardwaarden hebben: als u deze argumenten niet opgeeft, zal R de standaardwaarde aannemen.
Note:
Het is mogelijk om de broncode van een functie te zien door de naam van de functie zelf in de console uit te voeren.

R Belangrijke ingebouwde functies

We zullen drie groepen functies in actie zien

  • Algemene functie
  • Wiskundige functie
  • Statistische functie

Algemene functies

We zijn al bekend met algemene functies zoals cbind(), rbind(),range(),sort(),order() functies. Elk van deze functies heeft een specifieke taak en heeft argumenten nodig om een ​​uitvoer terug te geven. Volgwing zijn belangrijke functies die je moet kennen

diff()-functie

Als je werkt aan tijdreeksen, je moet de serie stationair maken door hun te nemen lag-waarden. Een stationair proces maakt een constant gemiddelde, variantie en autocorrelatie in de loop van de tijd mogelijk. Dit verbetert vooral de voorspelling van een tijdreeks. Dit kan eenvoudig worden gedaan met de functie diff(). We kunnen willekeurige tijdreeksgegevens met een trend opbouwen en vervolgens de functie diff() gebruiken om de reeks stationair te maken. De functie diff() accepteert één argument, een vector, en retourneert een geschikt vertraagd en herhaald verschil.

Note: We moeten vaak willekeurige gegevens creëren, maar voor het leren en vergelijken willen we dat de getallen op alle machines identiek zijn. Om ervoor te zorgen dat we allemaal dezelfde gegevens genereren, gebruiken we de functie set.seed() met willekeurige waarden van 123. De functie set.seed() wordt gegenereerd via het proces van pseudowillekeurig getal generator waardoor elke moderne computer dezelfde reeks getallen heeft. Als we de functie set.seed() niet gebruiken, hebben we allemaal een andere reeks getallen.

set.seed(123)
## Create the data
x = rnorm(1000)
ts <- cumsum(x)
## Stationary the serie
diff_ts <- diff(ts)
par(mfrow=c(1,2))
## Plot the series
plot(ts, type='l')
plot(diff(ts), type='l')

Diff()-functie

lengte() functie

In veel gevallen willen we weten wat de lengte van een vector voor berekening of voor gebruik in een for-lus. De functie length() telt het aantal rijen in vector x. De volgendewing codes importeren de autogegevensset en retourneren het aantal rijen.

Note: lengte() retourneert het aantal elementen in een vector. Als de functie wordt doorgegeven aan een matrix of een gegevensframe, wordt het aantal kolommen geretourneerd.

dt <- cars
## number columns
length(dt)

Output:

## [1] 1
## number rows
length(dt[,1])

Output:

## [1] 50

Wiskundige functies

R heeft een reeks wiskundige functies.

Operator Omschrijving
buikspieren (x) Neemt de absolute waarde van x
log(x,basis=y) Neemt de logaritme van x met grondtal y; als grondtal niet is opgegeven, retourneert de natuurlijke logaritme
exp(x) Geeft de exponentiële waarde van x
sqrt (x) Retourneert de vierkantswortel van x
faculteit(x) Geeft de faculteit van x (x!)
# sequence of number from 44 to 55 both including incremented by 1
x_vector <- seq(45,55, by = 1)
#logarithm
log(x_vector)

Output:

##  [1] 3.806662 3.828641 3.850148 3.871201 3.891820 3.912023 3.931826
##  [8] 3.951244 3.970292 3.988984 4.007333
#exponential
exp(x_vector)
#squared root
sqrt(x_vector)

Output:

##  [1] 6.708204 6.782330 6.855655 6.928203 7.000000 7.071068 7.141428
##  [8] 7.211103 7.280110 7.348469 7.416198
#factorial
factorial(x_vector)

Output:

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

Statistische functies

De standaardinstallatie van R bevat een breed scala aan statistische functies. In deze tutorial bekijken we kort de belangrijkste functie.

Basisstatistische functies

Operator Omschrijving
gemiddelde(x) Gemiddelde van x
mediaan(x) Mediaan van x
var(x) Variantie van x
sd(x) Standaardafwijking van x
schaal(x) Standaardscores (z-scores) van x
kwantiel(x) De kwartielen van x
samenvatting(x) Samenvatting van x: gemiddelde, min, max etc..
speed <- dt$speed
speed
# Mean speed of cars dataset
mean(speed)

Output:

## [1] 15.4
# Median speed of cars dataset
median(speed)

Output:

## [1] 15
# Variance speed of cars dataset
var(speed)

Output:

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

Output:

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

Output:

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

Output:

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

Output:

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

Tot nu toe hebben we veel ingebouwde R-functies geleerd.

Note: Wees voorzichtig met de klasse van het argument, dat wil zeggen numeriek, Booleaans of string. Als we bijvoorbeeld een tekenreekswaarde moeten doorgeven, moeten we de tekenreeks tussen aanhalingstekens plaatsen: “ABC” .

Schrijffunctie in R

In sommige gevallen moeten we onze eigen functie schrijven omdat we een bepaalde taak moeten volbrengen en er geen kant-en-klare functie bestaat. Een door de gebruiker gedefinieerde functie omvat a naam, argumenten en lichaam.

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

Note: Het is een goede gewoonte om een ​​door de gebruiker gedefinieerde functie een andere naam te geven dan een ingebouwde functie. Het voorkomt verwarring.

Eén argumentfunctie

In het volgende fragment definiëren we een eenvoudige vierkante functie. De functie accepteert een waarde en retourneert het kwadraat van de waarde.

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

Code Uitleg

  • De functie heet vierkante_functie; het kan worden genoemd wat we willen.
  • Het ontvangt een argument “n”. Wij heeft het type variabele niet gespecificeerd, zodat de gebruiker een geheel getal, een vector of een matrix kan doorgeven
  • De functie neemt de invoer “n” en retourneert het kwadraat van de invoer. Wanneer u klaar bent met het gebruik van de functie, kunnen we deze verwijderen met de functie rm().

# nadat u de functie hebt gemaakt

rm(square_function)
square_function

Op de console kunnen we een foutmelding zien: Error: object 'square_function' not found, wat aangeeft dat de functie niet bestaat.

Omgevingsonderzoek

In R, de milieu is een Collectie van objecten zoals functies, variabelen, dataframe, enz.

R opent een omgeving telkens wanneer Rstudio daarom wordt gevraagd.

De beschikbare omgeving op het hoogste niveau is de mondiale milieu, genaamd R_GlobalEnv. En wij hebben de Lokale omgeving.

We kunnen de inhoud van de huidige omgeving vermelden.

ls(environment())

uitgang

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

U kunt alle variabelen en functies zien die zijn gemaakt in R_GlobalEnv.

De bovenstaande lijst varieert voor u op basis van de historische code die u uitvoert in R Studio.

Merk op dat n het argument van de vierkante functie is niet in deze mondiale omgeving.

A nieuwe Voor elke functie wordt een omgeving gecreëerd. In het bovenstaande voorbeeld creëert de functie square_function() een nieuwe omgeving binnen de globale omgeving.

Om het verschil tussen te verduidelijken globaal en Lokale omgeving, laten we het volgende bestuderenwing voorbeeld

Deze functie neemt een waarde x als argument en voegt deze toe aan de y-definitie buiten en binnen de functie

Omgevingsonderzoek

De functie f retourneert de uitvoer 15. Dit komt omdat y is gedefinieerd in de mondiale omgeving. Elke variabele die in de globale omgeving is gedefinieerd, kan lokaal worden gebruikt. De variabele y heeft bij alle functieaanroepen de waarde 10 en is op elk moment toegankelijk.

Laten we eens kijken wat er gebeurt als de variabele y binnen de functie wordt gedefinieerd.

We moeten `y` verwijderen voordat we deze code kunnen uitvoeren met rm r

Omgevingsonderzoek

De uitvoer is ook 15 als we f(5) aanroepen, maar geeft een foutmelding als we de waarde y proberen af ​​te drukken. De variabele y bevindt zich niet in de mondiale omgeving.

Ten slotte gebruikt R de meest recente variabeledefinitie om binnen de hoofdtekst van een functie te komen. Laten we het volgende eens bekijkenwing voorbeeld:

Omgevingsonderzoek

R negeert de y-waarden die buiten de functie zijn gedefinieerd, omdat we expliciet een variabele binnen de hoofdtekst van de functie hebben gemaakt.

Functie voor meerdere argumenten

We kunnen een functie schrijven met meer dan één argument. Beschouw de functie genaamd “tijden”. Het is een eenvoudige functie die twee variabelen vermenigvuldigt.

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

Output:

## [1] 8

Wanneer moeten we functie schrijven?

Datawetenschappers moeten veel repetitieve taken uitvoeren. Meestal kopiëren en plakken we stukjes code herhaaldelijk. Het normaliseren van een variabele wordt bijvoorbeeld ten zeerste aanbevolen voordat we a uitvoeren machine learning algoritme. De formule om een ​​variabele te normaliseren is:

Formule om een ​​variabele te normaliseren

We weten al hoe we de functies min() en max() in R moeten gebruiken. We gebruiken de tibble-bibliotheek om het dataframe te maken. Tibble is tot nu toe de handigste functie om een ​​dataset helemaal opnieuw te creëren.

library(tibble)
# Create a data frame
data_frame <- tibble(  
  c1 = rnorm(50, 5, 1.5), 
  c2 = rnorm(50, 5, 1.5),    
  c3 = rnorm(50, 5, 1.5),    
)

We gaan in twee stappen te werk om de hierboven beschreven functie te berekenen. In de eerste stap zullen we een variabele creëren met de naam c1_norm, wat de herschaling van c1 is. In stap twee kopiëren en plakken we gewoon de code van c1_norm en veranderen deze met c2 en c3.

Detail van de functie met de kolom c1:

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

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

Daarom kunnen we ze verdelen om de genormaliseerde waarde van kolom c1 te krijgen:

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

We kunnen c1_norm, c2_norm en c3_norm creëren:

Create c1_norm: rescaling of c1		
data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))
# show the first five values
head(data_frame$c1_norm, 5)

Output:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Het werkt. We kunnen kopiëren en plakken

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

verander vervolgens c1_norm in c2_norm en c1 in c2. We doen hetzelfde om c3_norm te creëren

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

We hebben de variabelen c1, c2 en c3 perfect opnieuw geschaald.

Deze methode is echter gevoelig voor fouten. We kunnen kopiëren en vergeten de kolomnaam na het plakken te wijzigen. Daarom is het een goede gewoonte om elke keer dat u dezelfde code meer dan twee keer moet plakken, een functie te schrijven. We kunnen de code herschikken in een formule en deze oproepen wanneer dat nodig is. Om onze eigen functie te schrijven, moeten we geven:

  • Naam: normaliseren.
  • het aantal argumenten: We hebben slechts één argument nodig, namelijk de kolom die we gebruiken in onze berekening.
  • Het lichaam: dit is simpelweg de formule die we willen teruggeven.

We gaan stap voor stap te werk om de functie normaliseren te creëren.

Stap 1) Wij creëren de noemer, dat is. In R kunnen we de teller opslaan in een variabele als deze:

nominator <- x-min(x)

Stap 2) Wij berekenen de noemer: . We kunnen het idee van stap 1 repliceren en de berekening opslaan in een variabele:

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

Stap 3) We voeren de scheiding uit tussen de teller en de noemer.

normalize <- nominator/denominator

Stap 4) Om waarde terug te geven aan de aanroepende functie moeten we normalize doorgeven aan return() om de uitvoer van de functie te krijgen.

return(normalize)

Stap 5) We zijn klaar om de functie te gebruiken door alles in de beugel te wikkelen.

normalize <- function(x){
  # step 1: create the nominator
  nominator <- x-min(x)
  # step 2: create the denominator
  denominator <- max(x)-min(x)
  # step 3: divide nominator by denominator
  normalize <- nominator/denominator
  # return the value
  return(normalize)
}

Laten we onze functie testen met de variabele c1:

normalize(data_frame$c1)

Het werkt perfect. We hebben onze eerste functie gemaakt.

Functies zijn een uitgebreidere manier om een ​​repetitieve taak uit te voeren. We kunnen de normalisatieformule gebruiken voor verschillende kolommen, zoals hieronder:

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)

Hoewel het voorbeeld eenvoudig is, kunnen we de kracht van een formule afleiden. De bovenstaande code is gemakkelijker te lezen en voorkomt vooral fouten bij het plakken van codes.

Functies met voorwaarde

Soms moeten we voorwaarden in een functie opnemen, zodat de code verschillende uitvoer kan retourneren.

Bij Machine Learning-taken moeten we de dataset splitsen tussen een treinset en een testset. Dankzij het treinstel kan het algoritme leren van de gegevens. Om de prestaties van ons model te testen, kunnen we de testset gebruiken om de prestatiemaatstaf terug te geven. R heeft geen functie om twee datasets te creëren. We kunnen daarvoor onze eigen functie schrijven. Onze functie heeft twee argumenten nodig en heet split_data(). Het idee hierachter is eenvoudig: we vermenigvuldigen de lengte van de dataset (dat wil zeggen het aantal observaties) met 0.8. Als we bijvoorbeeld de dataset 80/20 willen splitsen, en onze dataset bevat 100 rijen, dan vermenigvuldigt onze functie 0.8*100 = 80. Er worden 80 rijen geselecteerd om onze trainingsgegevens te worden.

We zullen de luchtkwaliteitsdataset gebruiken om onze door de gebruiker gedefinieerde functie te testen. De luchtkwaliteitdataset bestaat uit 153 rijen. We kunnen het zien met de onderstaande code:

nrow(airquality)

Output:

## [1] 153

Wij gaan als volgt te werk:

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

Onze functie heeft twee argumenten. De argumententrein is een Booleaanse parameter. Als deze is ingesteld op TRUE, maakt onze functie de treindataset, otherwise, wordt de testgegevensset gemaakt.

We kunnen doorgaan zoals we deden met de functie normalise(). We schrijven de code alsof het maar een eenmalige code is en verpakken vervolgens alles met de voorwaarde in de hoofdtekst om de functie te creëren.

Stap 1:

We moeten de lengte van de dataset berekenen. Dit gebeurt met de functie nrow(). Nrow retourneert het totale aantal rijen in de gegevensset. We noemen de variabele lengte.

length<- nrow(airquality)
length

Output:

## [1] 153

Stap 2:

We vermenigvuldigen de lengte met 0.8. Het retourneert het aantal te selecteren rijen. Het moet 153*0.8 = 122.4 zijn

total_row <- length*0.8
total_row

Output:

## [1] 122.4

We willen 122 rijen selecteren uit de 153 rijen in de luchtkwaliteitsdataset. We maken een lijst met waarden van 1 tot total_row. Het resultaat slaan we op in de variabele genaamd split

split <- 1:total_row
split[1:5]

Output:

## [1] 1 2 3 4 5

split kiest de eerste 122 rijen uit de dataset. We kunnen bijvoorbeeld zien dat onze variabele splitsing de waarden 1, 2, 3, 4, 5 enzovoort verzamelt. Deze waarden zullen de index zijn wanneer we de rijen selecteren die moeten worden geretourneerd.

Stap 3:

We moeten de rijen in de luchtkwaliteitsgegevensset selecteren op basis van de waarden die zijn opgeslagen in de gesplitste variabele. Dit wordt als volgt gedaan:

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

Output:

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

Stap 4:

We kunnen de testgegevensset maken door de resterende rijen te gebruiken, 123:153. Dit wordt gedaan door – vóór de splitsing te gebruiken.

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

Output:

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

Stap 5:

We kunnen de voorwaarde binnen de hoofdtekst van de functie creëren. Houd er rekening mee dat we een argumenttrein hebben die standaard een Booleaanse waarde heeft die is ingesteld op TRUE om de treinset te retourneren. Om de voorwaarde te creëren, gebruiken we de if-syntaxis:

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

Dit is het, we kunnen de functie schrijven. We hoeven de luchtkwaliteit alleen maar te veranderen in df, omdat we onze functie op iedereen willen uitproberen dataframe, niet alleen luchtkwaliteit:

split_data <- function(df, train = TRUE){
  length<- nrow(df)
  total_row <- length *0.8
  split <- 1:total_row
  if (train ==TRUE){ 
    train_df <- df[split, ] 
      return(train_df)		
  } else {
    test_df <- df[-split, ] 
      return(test_df)		
  }
}

Laten we onze functie op de luchtkwaliteitsdataset uitproberen. we zouden één treinset met 122 rijen moeten hebben en een testset met 31 rijen.

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

Output:

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

Output:

## [1] 31  6