Funkcijas R programmēšanā (ar piemēru)

Kas ir funkcija R?

Funkcija , kādā programmēšanas vidē, ir instrukciju kopums. Programmētājs izveido funkciju, lai izvairītos no tā paša uzdevuma atkārtošanas vai samazinātu sarežģītību.

Funkcijai vajadzētu būt

• rakstiski, lai veiktu noteiktu uzdevumu
• var ietvert argumentus
• satur ķermeni
• var vai nevar atgriezt vienu vai vairākas vērtības.

Vispārēja pieeja funkcijai ir izmantot argumentu daļu kā ievadi , ievadīt ķermeņa daļu un visbeidzot atgriezt rezultātu . Funkcijas sintakse ir šāda:

function (arglist) {#Function body}

Šajā apmācībā mēs iemācīsimies

• R svarīgas iebūvētās funkcijas
• Vispārīgās funkcijas
• Matemātikas funkcijas
• Statistikas funkcijas
• Rakstīšanas funkcija R
• Kad mums vajadzētu rakstīt funkciju?
• Funkcijas ar nosacījumu

R svarīgas iebūvētās funkcijas

R ir daudz iebūvētu funkciju. R atbilst jūsu ievades parametriem ar tās argumentiem vai nu pēc vērtības, vai pēc pozīcijas, pēc tam izpilda funkcijas ķermeni. Funkciju argumentiem var būt noklusējuma vērtības: ja jūs nenorādīsit šos argumentus, R ņems noklusējuma vērtību.

Piezīme . Funkcijas avota kodu ir iespējams redzēt, konsolē palaižot pašas funkcijas nosaukumu.

Mēs redzēsim trīs funkciju grupas darbībā

• Vispārējā funkcija
• Matemātikas funkcija
• Statistikas funkcija

Vispārīgās funkcijas

Mēs jau esam iepazinušies ar tādām vispārīgām funkcijām kā cbind (), rbind (), range (), sort (), order (). Katrai no šīm funkcijām ir īpašs uzdevums, ir nepieciešami argumenti, lai atgrieztu izvadi. Šīs ir svarīgas funkcijas, kas jāzina:

diff () funkcija

Ja strādājat pie laika rindām , jums jāstacionē sērijas, ņemot to aiztures vērtības . Stacionārs process ļauj konstantu vidējo, dispersiju un autokorelācijas laika gaitā. Tas galvenokārt uzlabo laika rindu prognozēšanu. To var viegli izdarīt ar funkciju diff (). Mēs varam izveidot nejaušus laika rindu datus ar tendenci un pēc tam izmantot funkciju diff (), lai stacionētu virkni. Funkcija diff () pieņem vienu argumentu, vektoru un atgriež piemērotu atpalikušo un iterēto starpību.

Piezīme : Mums bieži ir jāizveido nejauši dati, taču, lai mācītos un salīdzinātu, mēs vēlamies, lai skaitļi būtu vienādi visās mašīnās. Lai nodrošinātu, ka mēs visi ģenerējam vienus un tos pašus datus, mēs izmantojam funkciju set.seed () ar patvaļīgām vērtībām 123. Funkcija set.seed () tiek ģenerēta, izmantojot pseidorandom skaitļu ģeneratoru procesu, kas liek visiem mūsdienu datoriem būt vienādai secībai. no skaitļiem. Ja mēs neizmantosim set.seed () funkciju, mums visiem būs atšķirīga skaitļu secība.

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

garuma () funkcija

Daudzos gadījumos mēs vēlamies uzzināt vektora garumu aprēķinam vai izmantot for for ciklā. Funkcija length () saskaita rindu skaitu vektorā x. Šie kodi importē automašīnu datu kopu un atgriež rindu skaitu.

Piezīme : length () atgriež vektora elementu skaitu. Ja funkcija tiek nodota matricā vai datu rāmī, tiek atgriezts kolonnu skaits.

dt <- cars## number columnslength(dt)

Izeja:

## [1] 1

## number rowslength(dt[,1])

Izeja:

## [1] 50

Matemātikas funkcijas

R ir matemātisko funkciju masīvs.

Operators	Apraksts
abs (x)	Tiek ņemta x absolūtā vērtība
žurnāls (x, bāze = y)	Ņem x logaritmu ar bāzi y; ja bāze nav norādīta, atgriež dabisko logaritmu
derīguma termiņš (x)	Atgriež x eksponenci
kvrt (x)	Atgriež x kvadrātsakni
faktoriāls (x)	Atgriež x (x!) Faktoriālu

# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)

Izeja:

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

Izeja:

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

Izeja:

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

Statistikas funkcijas

R standarta instalācija satur plašu statistikas funkciju klāstu. Šajā apmācībā mēs īsi aplūkosim vissvarīgāko funkciju ...

Statistikas pamatfunkcijas

Operators	Apraksts
vidējais (x)	Vidējais x
mediāna (x)	X mediāna
var (x)	X dispersija
SD (x)	X standartnovirze
skala (x)	X standarta rādītāji (z-rādītāji)
kvantiļa (x)	X kvartiles
kopsavilkums (x)	X kopsavilkums: vidējais, min, maksimālais utt.

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

Izeja:

## [1] 15.4

# Median speed of cars datasetmedian(speed)

Izeja:

## [1] 15

# Variance speed of cars datasetvar(speed)

Izeja:

## [1] 27.95918

# Standard deviation speed of cars datasetsd(speed)

Izeja:

## [1] 5.287644

# Standardize vector speed of cars datasethead(scale(speed), 5)

Izeja:

## [,1]## [1,] -2.155969## [2,] -2.155969## [3,] -1.588609## [4,] -1.588609## [5,] -1.399489

# Quantile speed of cars datasetquantile(speed)

Izeja:

## 0% 25% 50% 75% 100%## 4 12 15 19 25

# Summary speed of cars datasetsummary(speed)

Izeja:

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

Līdz šim esam iemācījušies daudz R iebūvēto funkciju.

Piezīme . Esiet uzmanīgs ar argumenta klasi, ti, ciparu, Būla vai virkni. Piemēram, ja mums ir jānodod virknes vērtība, virkne jāievieto pēdiņās: "ABC".

Rakstīšanas funkcija R

Dažos gadījumos mums ir jāuzraksta sava funkcija, jo mums ir jāveic konkrēts uzdevums, un nav gatavas funkcijas. Lietotāja definētā funkcija ietver vārdu , argumentus un pamattekstu .

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

Piezīme . Laba prakse ir nosaukt lietotāja definētu funkciju, kas atšķiras no iebūvētās funkcijas. Tas ļauj izvairīties no neskaidrībām.

Viena argumenta funkcija

Nākamajā fragmentā mēs definējam vienkāršu kvadrāta funkciju. Funkcija pieņem vērtību un atgriež vērtības kvadrātu.

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

Koda skaidrojums:

• Funkcijas nosaukums ir square_function; to var nosaukt kā vien vēlamies.
• Tas saņem argumentu "n". Mēs nenorādījām mainīgā veidu, lai lietotājs varētu nodot veselu skaitli, vektoru vai matricu
• Funkcija ņem ievadu "n" un atgriež ievades kvadrātu.

  Kad esat pabeidzis funkcijas izmantošanu, mēs to varam noņemt, izmantojot funkciju rm ().

# pēc funkcijas izveides

rm(square_function)square_function

Konsolē mēs varam redzēt kļūdas ziņojumu: Kļūda: objekts “square_function” nav atrasts, sakot, ka funkcija neeksistē.

Vides darbības joma

R vidē vide ir objektu, piemēram, funkciju, mainīgo, datu ietvara uc kolekcija .

R atver vidi katru reizi, kad tiek pieprasīts Rstudio.

Pieejamā augstākā līmeņa vide ir globālā vide ar nosaukumu R_GlobalEnv. Un mums ir vietējā vide.

Mēs varam uzskaitīt pašreizējās vides saturu.

ls(environment())

Rezultāts

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

Jūs varat redzēt visus mainīgos un funkciju, kas izveidota R_GlobalEnv.

Šis saraksts jums mainīsies atkarībā no vēsturiskā koda, kuru izpildāt R Studio.

Ņemiet vērā, ka n, laukuma_funkcijas arguments neatrodas šajā globālajā vidē .

Jauna vide tiek izveidota katrai funkcijai. Iepriekš minētajā piemērā funkcija square_function () rada jaunu vidi globālās vides iekšienē.

Lai noskaidrotu atšķirību starp globālo un vietējo vidi , izpētīsim šādu piemēru

Šīs funkcijas kā argumentu vērtība ir x, un tā tiek pievienota y, lai definētu funkcijas ārpus un iekšpusē

Funkcija f atgriež izeju 15. Tas ir tāpēc, ka y ir definēts globālajā vidē. Jebkuru mainīgo, kas definēts globālajā vidē, var izmantot lokāli. Mainīgajam y visu funkciju izsaukumu laikā ir vērtība 10, un tas ir pieejams jebkurā laikā.

Apskatīsim, kas notiek, ja mainīgais y ir definēts funkcijas iekšpusē.

Pirms šī koda palaišanas, izmantojot rm r, mums jāizlaiž “y”

Izeja ir arī 15, kad mēs izsaucam f (5), bet atgriež kļūdu, mēģinot izdrukāt vērtību y. Mainīgais y nav globālajā vidē.

Visbeidzot, R izmanto jaunāko mainīgo definīciju, lai pārietu funkcijas iekšpusē. Apsvērsim šādu piemēru:

R ignorē y vērtības, kas definētas ārpus funkcijas, jo mēs skaidri izveidojām ay mainīgo funkcijas iekšpusē.

Funkcija Vairāki argumenti

Mēs varam uzrakstīt funkciju ar vairāk nekā vienu argumentu. Apsveriet funkciju, ko sauc par "reizes". Tā ir vienkārša funkcija, reizinot divus mainīgos.

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

Izeja:

## [1] 8

Kad mums vajadzētu rakstīt funkciju?

Datu zinātniekam jāveic daudzi atkārtoti uzdevumi. Lielāko daļu laika mēs atkārtoti kopējam un ielīmējam koda gabalus. Piemēram, pirms mašīnmācīšanās algoritma palaišanas ir ļoti ieteicama mainīgā normalizēšana. Formula mainīgā normalizēšanai ir:

Mēs jau zinām, kā izmantot min () un max () funkcijas R. Mēs izmantojam tibble bibliotēku, lai izveidotu datu rāmi. Tibble līdz šim ir ērtākā funkcija, lai izveidotu datu kopu no nulles.

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

Mēs veiksim divas darbības, lai aprēķinātu iepriekš aprakstīto funkciju. Pirmajā solī mēs izveidosim mainīgo ar nosaukumu c1_norm, kas ir c1 atkārtota mērogošana. Otrajā solī mēs vienkārši kopējam un ielīmējam kodu c1_norm un mainām ar c2 un c3.

Sīkāka informācija par funkciju ar kolonnu c1:

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

Saucējs: max (data_frame $ c1) -min (data_frame $ c1))

Tādēļ mēs varam tos sadalīt, lai iegūtu kolonnas normalizēto vērtību c1:

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

Mēs varam izveidot c1_norm, c2_norm un 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)

Izeja:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Tas strādā. Mēs varam kopēt un ielīmēt

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

tad mainiet c1_norm uz c2_norm un c1 uz c2. Mēs darām to pašu, lai izveidotu 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))

Mēs perfekti mainījām mainīgos mainīgos c1, c2 un c3.

Tomēr šī metode ir pakļauta kļūdām. Pēc ielīmēšanas mēs varētu nokopēt un aizmirst mainīt kolonnas nosaukumu. Tāpēc laba prakse ir rakstīt funkciju katru reizi, kad viens un tas pats kods ir jāielīmē vairāk nekā divas reizes. Mēs varam pārkārtot kodu formulā un izsaukt to ikreiz, kad tas ir nepieciešams. Lai uzrakstītu savu funkciju, mums jādod:

• Nosaukums: normalizēt.
• argumentu skaits: mums ir nepieciešams tikai viens arguments, kas ir kolonna, kuru izmantojam aprēķinos.
• Ķermenis: tā ir vienkārši formula, kuru mēs vēlamies atgriezties.

Mēs turpināsim soli pa solim, lai izveidotu funkciju normalizēt.

1. solis) Mēs izveidojam nominatoru , kas ir. R, mēs varam saglabāt nominatoru šādā mainīgajā:

nominator <- x-min(x)

Step 2) Mēs aprēķināt saucējs: . Mēs varam atkārtot 1. darbības ideju un saglabāt aprēķinu mainīgajā:

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

3. solis) Mēs veicam sadalījumu starp nominatoru un saucēju.

normalize <- nominator/denominator

4. solis. Lai atgrieztu vērtību izsaukšanas funkcijai, mums jānokārto normalizācija atgriešanās iekšienē (), lai iegūtu funkcijas izvadi.

return(normalize)

5. solis. Mēs esam gatavi izmantot šo funkciju, ietinot visu kronšteina iekšpusē.

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

Pārbaudīsim savu funkciju ar mainīgo c1:

normalize(data_frame$c1)

Tas darbojas nevainojami. Mēs izveidojām savu pirmo funkciju.

Funkcijas ir visaptverošāks veids, kā veikt atkārtotu uzdevumu. Mēs varam izmantot normalizācijas formulu dažādās kolonnās, piemēram, zemāk:

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)

Lai gan piemērs ir vienkāršs, mēs varam secināt par formulas spēku. Iepriekš minēto kodu ir vieglāk nolasīt un jo īpaši izvairīties no kļūdām, ielīmējot kodus.

Funkcijas ar nosacījumu

Dažreiz mums ir jāiekļauj nosacījumi funkcijā, lai kods varētu atgriezt dažādas izejas.

Mašīnmācības uzdevumos mums datu kopa ir jāsadala starp vilcienu kopu un testa kopu. Vilcienu kopa ļauj algoritmam mācīties no datiem. Lai pārbaudītu mūsu modeļa veiktspēju, mēs varam izmantot testa komplektu, lai atgrieztu veiktspējas mērījumu. R nav divu datu kopu izveidošanas funkcijas. Mēs to varam uzrakstīt paši. Mūsu funkcijai ir divi argumenti, un to sauc par split_data (). Ideja ir vienkārša, mēs reizinām datu kopas garumu (ti, novērojumu skaitu) ar 0,8. Piemēram, ja mēs vēlamies sadalīt datu kopu 80/20 un mūsu datu kopā ir 100 rindas, tad mūsu funkcija reizināsies ar 0,8 * 100 = 80. Tiks atlasītas 80 rindas, kas kļūs par mūsu apmācības datiem.

Mēs izmantosim gaisa kvalitātes datu kopu, lai pārbaudītu lietotāja definēto funkciju. Gaisa kvalitātes datu kopā ir 153 rindas. Mēs to varam redzēt ar kodu zemāk:

nrow(airquality)

Izeja:

## [1] 153 

Mēs rīkosimies šādi:

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

Mūsu funkcijai ir divi argumenti. Argumenti vilciens ir Būla parametrs. Ja tā ir iestatīta uz TRUE, mūsu funkcija izveido vilciena datu kopu, pretējā gadījumā tā izveido testa datu kopu.

Mēs varam rīkoties tāpat kā mēs normalizējām () funkciju. Mēs uzrakstām kodu tā, it kā tas būtu tikai vienreizējs kods, un pēc tam visu ar nosacījumu ietinam ķermenī, lai izveidotu funkciju.

1. darbība:

Mums jāaprēķina datu kopas garums. Tas tiek darīts ar funkciju nrow (). Nrow atgriež kopējo rindu skaitu datu kopā. Mēs saucam mainīgo garumu.

length<- nrow(airquality)length

Izeja:

## [1] 153

2. darbība:

Mēs reizinām garumu ar 0,8. Tas atgriezīs atlasāmo rindu skaitu. Tam vajadzētu būt 153 * 0,8 = 122,4

total_row <- length*0.8total_row

Izeja:

## [1] 122.4

Mēs vēlamies atlasīt 122 rindas starp 153 rindām gaisa kvalitātes datu kopā. Mēs izveidojam sarakstu ar vērtībām no 1 līdz total_row. Rezultātu mēs saglabājam mainīgajā, ko sauc par split

split <- 1:total_rowsplit[1:5] 

Izeja:

## [1] 1 2 3 4 5

split izvēlas pirmās 122 datu kopas rindas. Piemēram, mēs varam redzēt, ka mūsu mainīgais sadalījums apkopo vērtību 1, 2, 3, 4, 5 un tā tālāk. Šīs vērtības būs indekss, kad mēs atlasīsim atgriezamās rindas.

3. solis:

Mums ir jāizvēlas rindas gaisa kvalitātes datu kopā, pamatojoties uz vērtībām, kas saglabātas sadalītajā mainīgajā. Tas tiek darīts šādi:

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

Izeja:

##[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. solis:

Mēs varam izveidot testa datu kopu, izmantojot atlikušās rindas 123: 153. Tas tiek darīts, izmantojot - split priekšā.

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

Izeja:

##[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. darbība:

Mēs varam izveidot nosacījumu funkcijas iekšpusē. Atcerieties, ka mums ir arguments vilciens, kas pēc noklusējuma ir Būla iestatījums uz TRUE. Lai izveidotu nosacījumu, mēs izmantojam sintaksi if:

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

Tas ir tas, mēs varam uzrakstīt funkciju. Mums tikai jāmaina gaisa kvalitāte uz df, jo mēs vēlamies izmēģināt savu funkciju uz jebkuru datu rāmi, ne tikai ar gaisa kvalitāti:

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

Izmēģināsim savu funkciju gaisa kvalitātes datu kopā. mums vajadzētu būt vienam vilcienu komplektam ar 122 rindām un testa komplektam ar 31 rindu.

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

Izeja:

## [1] 122 6

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

Izeja:

## [1] 31 6