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 dezelfde taak herhalen, of verminderen ingewikkeldheid.

Een functie zou moeten zijn

• geschreven om een ​​specifieke taak uit te voeren
• kan wel of geen argumenten bevatten
• een lichaam bevatten
• Kan al dan niet één of meerdere 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 uitvoerDe syntaxis van een functie is als volgt:

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.

Typing Een functienaam zonder haakjes print de broncode ervan, zoals de console hieronder laat zien.

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(), soort()en order(). Elk van deze functies heeft een specifieke taak en neemt argumenten aan om een ​​uitvoer te retourneren. De volgende functies zijn belangrijk om te kennen:

diff()-functie

Als je werkt aan tijdreeksen, je moet de serie stationair maken door hun te nemen lag-waarden. Een stationair proces Dit zorgt voor een constant gemiddelde, variantie en autocorrelatie in de tijd. Dit verbetert met name de voorspelling van een tijdreeks. Dit kan worden gedaan met de functie `diff()`. We kunnen een willekeurige tijdreeks met een trend genereren 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.

NoteWe moeten vaak willekeurige data genereren, maar voor leer- en vergelijkingsdoeleinden willen we dat de getallen op alle machines identiek zijn. Om ervoor te zorgen dat we allemaal dezelfde data genereren, gebruiken we de functie `set.seed()` met willekeurige waarden van 123. `set.seed()` fixeert het startpunt van de pseudowillekeurige getallengenerator, zodat elke machine dezelfde reeks produceert. Zonder `set.seed()` levert elke run een andere reeks op.

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

De twee onderstaande panelen tonen de oorspronkelijke cumulatieve reeks naast de gedifferentieerde reeks, die nu rond een constant gemiddelde schommelt.

lengte() functie

In veel gevallen willen we de lengte van een vector weten voor berekeningen of om te gebruiken in een for-lus. De functie `length()` telt het aantal rijen in vector x. De volgende code importeert de dataset `cars` en retourneert het aantal rijen.

Note: length() retourneert het aantal elementen in een vector. Als de functie wordt doorgegeven aan een Matrix Of het nu een dataframe is of niet, het aantal kolommen wordt geretourneerd.

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

Output:

## [1] 1

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

Output:

## [1] 50

Wiskundige functies

Naast de algemene hulpmiddelen beschikt R over een reeks wiskundige functies die element voor element op een vector werken.

# 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

Waar wiskundige functies waarden transformeren, vatten statistische functies deze samen. De standaardinstallatie van R bevat een breed scala aan statistische functies. In deze handleiding zullen we de belangrijkste kort bespreken.

Basisstatistische functies

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.

NoteWees voorzichtig met de klasse van het argument, oftewel numeriek, Booleaans of tekenreeks. Als we bijvoorbeeld een tekenreeks willen doorgeven, moeten we de tekenreeks tussen aanhalingstekens plaatsen: "ABC".

Schrijffunctie in R

Soms moeten we onze eigen functie schrijven omdat we een bepaalde taak moeten uitvoeren en er geen kant-en-klare functie bestaat. Een door de gebruiker gedefinieerde functie houdt in dat we een bepaalde taak zelf moeten uitvoeren. 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.

Milieu Scoping

In R, de omgeving houden Een dataframe is een verzameling objecten zoals functies, variabelen, dataframes, enzovoort.

R opent een omgeving telkens wanneer RStudio wordt gestart.

De beschikbare omgeving op het hoogste niveau is de mondiale milieu, genaamd R_GlobalEnv. En we 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 kan voor u variëren, afhankelijk van de historische code die u in RStudio uitvoert.

Merk op dat nHet argument van de functie square_function bevindt zich niet in deze globale omgeving.

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

Om het verschil tussen te verduidelijken globaal en lokaal Laten we, om de omgeving te begrijpen, het volgende voorbeeld bekijken.

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

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

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 door te geven in de body van een functie. Laten we het volgende voorbeeld bekijken:

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 steeds opnieuw stukken code. Het normaliseren van een variabele is bijvoorbeeld sterk aanbevolen voordat we een query uitvoeren. machine learning algoritme. De formule om een ​​variabele te normaliseren is:

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 maken we een variabele aan met de naam c1_norm, die de herschaling van c1 vertegenwoordigt. In de tweede stap kopiëren en plakken we de code van c1_norm en vervangen we 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 foutgevoelig. We zouden kunnen kopiëren en vergeten de kolomnaam aan te passen na het plakken. Daarom is het een goede gewoonte om een ​​functie te schrijven telkens wanneer je dezelfde code meer dan twee keer moet plakken. We kunnen de code herschikken in een formule en deze aanroepen wanneer dat nodig is. Om onze eigen functie te schrijven, moeten we het volgende invoeren:

• 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) We maken de teller, namelijk x – min(x). In R kunnen we de teller in een variabele opslaan, bijvoorbeeld zo:

nominator <- x-min(x)

Stap 2) We berekenen de noemer: max(x) – min(x). We kunnen het idee van stap 1 herhalen en de berekening in een variabele opslaan:

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 deze in te pakken.ping Alles binnen de haakjes.

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.

Een functie is een uitgebreidere manier om een ​​repetitieve taak uit te voeren. We kunnen de normalisatieformule toepassen op 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 hieruit afleiden. De bovenstaande code is gemakkelijker te lezen en voorkomt fouten die kunnen ontstaan ​​bij het plakken van code.

Functies met voorwaarde

De functie normalize() doet altijd hetzelfde. Soms moeten we voorwaarden aan een functie toevoegen om ervoor te zorgen dat de code verschillende resultaten retourneert.

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 argumenten train is een Booleaanse parameter. Als deze is ingesteld op TRUE, maakt onze functie de train-dataset, anders maakt deze de test-dataset.

We kunnen te werk gaan zoals we deden met de normalize()-functie. We schrijven de code alsof het eenmalige code is en plaatsen vervolgens alles met de voorwaarde in de body 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 eens uitproberen op de dataset met luchtkwaliteitsgegevens. We zouden een trainingsset met 122 rijen en een testset met 31 rijen moeten hebben.

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

Output:

## [1] 122   6

test <- split_data(airquality, train = FALSE)
dim(test)

Output:

## [1] 31  6

Veelgestelde vragen