Funkciók az R programozásban (példával)

Tartalomjegyzék:

Anonim

Mi a függvény R-ben?

A függvény programozási környezetben utasítások halmaza. A programozó egy funkciót készít, hogy elkerülje ugyanazon feladat megismétlését , vagy csökkentse a bonyolultságot.

A függvény legyen

  • egy meghatározott feladat végrehajtásához írt
  • vagy nem tartalmazhat érveket
  • testet tartalmaznak
  • egy vagy több értéket adhat vissza, vagy nem.

A függvény általános megközelítése az argumentumrész bemenetként történő felhasználása , a testrész betáplálása és végül egy kimenet visszaadása . A függvény szintaxisa a következő:

function (arglist) {#Function body}

Ebben az oktatóanyagban megtanuljuk

  • R fontos beépített funkciók
  • Általános funkciók
  • Matematikai függvények
  • Statisztikai függvények
  • Írási függvény R-ben
  • Mikor írjunk függvényt?
  • Feltételek funkciói

R fontos beépített funkciók

R-ben sok beépített függvény található. R vagy érték, vagy pozíció szerint egyezteti a bemeneti paramétereket a függvény argumentumaival, majd végrehajtja a függvénytestet. A függvény argumentumoknak lehetnek alapértelmezett értékei: ha nem adja meg ezeket az argumentumokat, akkor R az alapértelmezett értéket veszi fel.

Megjegyzés : Megtekinthető egy függvény forráskódja, ha a függvény nevét futtatja a konzolon.

Három funkciócsoportot fogunk látni működés közben

  • Általános funkció
  • Matematika funkció
  • Statisztikai függvény

Általános funkciók

Már ismerjük az olyan általános függvényeket, mint a cbind (), rbind (), range (), sort (), order () függvények. Ezeknek a függvényeknek mindegyiküknek van egy sajátos feladata, argumentumokat vesz fel a kimenet visszaadásához. A következő fontos funkciók ismeretesek

diff () függvény

Ha idősorokon dolgozik, akkor a sorozatokat úgy kell rögzítenie, hogy figyelembe veszik azok lemaradását . A helyhez kötött folyamat lehetővé teszi az állandó átlagot, varianciát és autokorrelációt az idő múlásával. Ez főleg javítja az idősor előrejelzését. Könnyen elvégezhető a diff () függvénnyel. Felépíthetünk egy véletlenszerű idősoros adatot egy trenddel, majd a diff () függvény segítségével rögzíthetjük a sorokat. A diff () függvény elfogad egy argumentumot, egy vektort, és megfelelő elmaradt és iterált különbséget ad vissza.

Megjegyzés : Gyakran véletlenszerű adatokat kell létrehoznunk, de a tanuláshoz és az összehasonlításhoz azt akarjuk, hogy a számok azonosak legyenek a gépek között. Annak biztosítására, hogy mindannyian ugyanazokat az adatokat állítsuk elő, a set.seed () függvényt tetszőleges 123 értékkel használjuk. A set.seed () függvényt az álvéletlenszám-generátor folyamata generálja, amely minden modern számítógépet azonos sorrendűvé tesz. számok. Ha nem használjuk a set.seed () függvényt, akkor mindannyian különböző számsorozattal rendelkezünk.

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

hossz () függvény

Sok esetben szeretnénk megismerni egy vektor hosszát a számításhoz vagy egy for for ciklusban történő felhasználáshoz. A length () függvény megszámolja az x vektor sorainak számát. A következő kódok importálják az autók adatkészletét, és visszaadják a sorok számát.

Megjegyzés : A length () egy vektor elemeinek számát adja vissza. Ha a függvény átkerül egy mátrixba vagy egy adatkeretbe, az oszlopok száma visszatér.

dt <- cars## number columnslength(dt)

Kimenet:

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

Kimenet:

## [1] 50

Matematikai függvények

R matematikai függvényekkel rendelkezik.

Operátor Leírás
abs (x) Az x abszolút értékét veszi fel
log (x, alap = y) Az x logaritmusát y bázissal veszi fel; ha az alap nincs megadva, akkor a természetes logaritmust adja vissza
exp (x) Visszaadja az x exponenciáját
sqrt (x) Visszaadja az x négyzetgyökét
faktoriális (x) Visszaadja az x (x!) Tényezőjét 
# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)

Kimenet:

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

Kimenet:

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

Kimenet:

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

Statisztikai függvények

Az R standard telepítés statisztikai funkciók széles skáláját tartalmazza. Ebben az oktatóanyagban röviden áttekintjük a legfontosabb funkciót ...

Statisztikai alapfunkciók

Operátor

Leírás

átlag (x)

Az x átlaga

medián (x)

Az x mediánja

var (x)

X szórása

sd (x)

Az x szórása

skála (x)

Az x standard pontszámai (z-pontszámai)

kvantilis (x)

Az x kvartilisei

összefoglalás (x)

X összefoglalása: átlag, min, max stb.

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

Kimenet:

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

Kimenet:

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

Kimenet:

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

Kimenet:

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

Kimenet:

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

Kimenet:

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

Kimenet:

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

Eddig a pontig rengeteg R beépített funkciót megtanultunk.

Megjegyzés : Legyen óvatos az argumentum osztályával, azaz numerikus, logikai vagy karakterlánccal. Például, ha át kell adnunk egy karakterlánc értéket, akkor a karakterláncot idézőjelbe kell tennünk: "ABC".

Írási függvény R-ben

Bizonyos esetekben meg kell írnunk a saját függvényünket, mert el kell végeznünk egy adott feladatot, és nincs kész funkció. A felhasználó által definiált függvény tartalmaz nevet , argumentumokat és törzset .

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

Megjegyzés : Jó gyakorlat a felhasználó által definiált függvény megnevezése, amely eltér a beépített függvénytől. Kerüli a zavart.

Egy argumentumfüggvény

A következő részletben meghatározunk egy egyszerű négyzetfüggvényt. A függvény elfogad egy értéket, és visszaadja az érték négyzetét.

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

Kód Magyarázat:

  • A függvény neve square_function; hívhatjuk, amire csak akarunk.
  • "N" argumentumot kap. Nem adtuk meg a változó típusát, hogy a felhasználó átadhasson egész számot, vektort vagy mátrixot
  • A függvény felveszi az "n" bemenetet, és visszaadja a bemenet négyzetét.

    Ha befejezte a függvény használatát, eltávolíthatjuk az rm () függvénnyel.

# a függvény létrehozása után 

rm(square_function)square_function

A konzolon hibaüzenetet láthatunk: Hiba: A (z) 'square_function' objektum nem található, és azt mondja, hogy a függvény nem létezik.

Környezet hatóköre

R-ben a környezet olyan objektumok gyűjteménye , mint a függvények, változók, adatkeret stb.

R minden alkalommal megnyit egy környezetet, amikor az Rstudio-t kéri.

A legfelső szintű környezet a globális környezet , az úgynevezett R_GlobalEnv. És megvan a helyi környezet.

Sorolhatjuk az aktuális környezet tartalmát.

ls(environment())

Kimenet

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

Láthatja az R_GlobalEnv-ben létrehozott összes változót és függvényt.

A fenti lista az R Studio-ban végrehajtott történelmi kód alapján változik.

Vegye figyelembe, hogy n, a square_function függvény argumentuma nem ebben a globális környezetben található .

Egy új környezet jön létre minden funkció. A fenti példában a square_function () függvény új környezetet hoz létre a globális környezetben.

A globális és a lokális környezet közötti különbség tisztázása érdekében tanulmányozzuk a következő példát

Ezek a függvények egy x értéket vesznek fel argumentumként, és hozzáadják azt a függvényen kívül és belül definiálandó y értékhez

Az f függvény visszaadja a 15 kimenetet. Ennek oka, hogy y globális környezetben van definiálva. Bármely, a globális környezetben definiált változó helyileg használható. Az y változó értéke 10 minden függvényhívás során, és bármikor elérhető.

Lássuk, mi történik, ha az y változót megadjuk a függvényen belül.

Le kell dobnunk az `y`-t, mielőtt futtatnánk ezt a kódot az rm r használatával

A kimenet is 15, ha meghívjuk f (5) -t, de hibát ad vissza, amikor megpróbáljuk kinyomtatni az y értéket. Az y változó nincs a globális környezetben.

Végül R a legfrissebb változódefinícióval adja át a függvénytesten belül. Vizsgáljuk meg a következő példát:

R figyelmen kívül hagyja a függvényen kívül meghatározott y értékeket, mert kifejezetten létrehoztunk egy változót a függvény testén belül.

Több argumentum működik

Több argumentummal írhatunk függvényt. Tekintsük a "times" nevű függvényt. Ez egy egyszerű függvény, amely két változót szoroz.

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

Kimenet:

## [1] 8

Mikor írjunk függvényt?

Az adatkutatónak sok ismétlődő feladatot kell elvégeznie. Leggyakrabban ismétlődően másoljuk és illesztjük be a kóddarabokat. Például a változó normalizálása nagyon ajánlott, mielőtt gépi tanulási algoritmust futtatnánk. A változó normalizálására szolgáló képlet:

Már tudjuk, hogyan kell használni a min () és a max () függvényt R-ben. Az adatkeret létrehozásához a tibble könyvtárat használjuk. A Tibble egyelőre a legkényelmesebb funkció egy adatkészlet létrehozásához a semmiből.

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

Két lépésben folytatjuk a fent leírt függvény kiszámítását. Első lépésben létrehozunk egy c1_norm nevű változót, amely a c1 átméretezése. A második lépésben csak másoljuk és illesszük be a c1_norm kódját, és változtassuk meg c2-vel és c3-mal.

A funkció részlete a c1 oszloppal:

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

Nevező: max (data_frame $ c1) -min (data_frame $ c1))

Ezért fel tudjuk osztani őket, hogy megkapjuk a c1 oszlop normalizált értékét:

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

Hozhatunk létre c1_norm, c2_norm és 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)

Kimenet:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Működik. Másolhatunk és beilleszthetünk

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

akkor változtassa meg a c1_norm értéket a c2_norm értékre és a c1 értéket c2-re. Ugyanezt tesszük a c3_norm létrehozásáért

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

Tökéletesen átméreteztük a c1, c2 és c3 változókat.

Ez a módszer azonban hajlamos a tévedésre. Beillesztés után kimásolhatjuk és elfelejthetjük az oszlop nevének megváltoztatását. Ezért jó gyakorlat az, hogy minden egyes alkalommal egy függvényt írunk, amikor ugyanazt a kódot kétszer kell beilleszteni. Átrendezhetjük a kódot képletté, és hívhatjuk, amikor arra szükség van. Saját funkciónk megírásához meg kell adnunk:

  • Név: normalizál.
  • az argumentumok száma: Csak egy argumentumra van szükségünk, ez az az oszlop, amelyet a számítás során használunk.
  • A test: ez egyszerűen a képlet, amelyet vissza akarunk adni.

Folytatjuk a normalizálás funkció létrehozását.

1. lépés: Elkészítjük a jelölőt , ami. R-ben tárolhatjuk a jelölőt egy ilyen változóban:

nominator <- x-min(x)

2. lépés) kiszámítjuk a nevező: . Megismételhetjük az 1. lépés ötletét, és a számítást egy változóban tárolhatjuk:

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

3. lépés: Elvégezzük a nevező és a nevező közötti felosztást.

normalize <- nominator/denominator

4. lépés: Az érték visszaadásához a hívó függvényhez át kell adnunk a normalize belső visszatérést (), hogy megkapjuk a függvény kimenetét.

return(normalize)

5. lépés : Készen állunk a funkció használatára úgy, hogy mindent becsomagolunk a tartóba.

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

Teszteljük működésünket a c1 változóval:

normalize(data_frame$c1)

Tökéletesen működik. Elkészítettük első funkciónkat.

A funkciók átfogóbb módszerek az ismétlődő feladatok végrehajtására. Használhatjuk a normalizálási képletet különböző oszlopokon, például alább:

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)

Annak ellenére, hogy a példa egyszerű, kikövetkeztethetjük a képlet erejét. A fenti kód könnyebben olvasható, és különösen elkerüli a hibákat a kódok beillesztésekor.

Feltételek funkciói

Néha feltételeket kell beiktatnunk egy függvénybe, hogy a kód különböző kimeneteket adhasson vissza.

A Gépi tanulás feladatokban el kell osztanunk az adatkészletet egy vonatsor és egy tesztkészlet között. A vonatsor lehetővé teszi, hogy az algoritmus tanuljon az adatokból. Modellünk teljesítményének teszteléséhez használhatjuk a tesztkészletet a teljesítménymérés visszaadásához. R nem rendelkezik két adatkészlet létrehozásának funkciójával. Felírhatjuk a saját függvényünket erre. Funkciónknak két argumentuma van, split_data () néven. Az ötlet egyszerű, az adatkészlet hosszát (azaz a megfigyelések számát) megszorozzuk 0,8-mal. Például, ha fel akarjuk osztani a 80/20 adatkészletet, és az adatkészletünk 100 sort tartalmaz, akkor a függvényünk szorzata 0,8 * 100 = 80 lesz. 80 sort választunk ki, hogy képzési adataink legyenek.

A felhasználó által definiált funkciónk tesztelésére az airquality adatkészletet fogjuk használni. A légminőségi adatkészletnek 153 sora van. Az alábbi kóddal láthatjuk:

nrow(airquality)

Kimenet:

## [1] 153

A következőképpen fogunk eljárni:

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

Funkciónknak két érve van. A vonat argumentumok logikai paraméterek. Ha TRUE értékre van állítva, akkor a függvényünk létrehozza a vonat adatkészletét, ellenkező esetben létrehozza a teszt adatkészletet.

Folytathatjuk úgy, mint a normalizált () függvényt. Úgy írjuk a kódot, mintha csak egyszeri kód lenne, majd a feltétel létrehozásával mindent beillesztünk a törzsbe a függvény létrehozásához.

1. lépés:

Ki kell számolnunk az adatkészlet hosszát. Ez a nrow () függvénnyel történik. Az Nrow az adatkészlet sorainak teljes számát adja vissza. Hívjuk a változó hosszúságot.

length<- nrow(airquality)length

Kimenet:

## [1] 153

2. lépés:

Megszorozzuk a hosszt 0,8-mal. Visszaadja a kiválasztandó sorok számát. 153 * 0,8 = 122,4 legyen

total_row <- length*0.8total_row

Kimenet:

## [1] 122.4

122 sort akarunk kiválasztani a légminőségi adatkészlet 153 sora közül. Létrehozunk egy listát, amely 1 és total_row értékeket tartalmaz. Az eredményt a split nevű változóban tároljuk

split <- 1:total_rowsplit[1:5]

Kimenet:

## [1] 1 2 3 4 5

A split az első 122 sort választja ki az adatkészletből. Például láthatjuk, hogy a változó felosztásunk összegyűjti az 1, 2, 3, 4, 5 és így tovább értékeket. Ezek az értékek lesznek az indexek, amikor kiválasztjuk a visszatérni kívánt sorokat.

3. lépés:

A felosztott változóban tárolt értékek alapján kell kiválasztanunk a sorokat a légminőségi adatkészletben. Ez így történik:

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

Kimenet:

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

4. lépés:

Létrehozhatjuk a tesztadatkészletet a fennmaradó 123: 153 sorok felhasználásával. Ez a - split előtt használható.

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

Kimenet:

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

5. lépés:

Létrehozhatjuk a függvény testének belsejét. Ne feledje, hogy van egy argumentumvonatunk, amely egy logikai érték, amely alapértelmezés szerint IGAZ, hogy visszaadja a vonatsort. A feltétel létrehozásához az if szintaxist használjuk:

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

Ez az, megírhatjuk a függvényt. Csak a légminőséget kell df-re változtatnunk, mert nem csak a légminőséget, hanem bármilyen adatkeretre szeretnénk kipróbálni a funkciónkat:

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

Próbáljuk ki az airquality adatkészlet funkcióját. kellene egy vonatsorozat 122 sorral és egy teszt sor 31 sorral.

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

Kimenet:

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

Kimenet:

## [1] 31 6