Funktsioonid R-i programmeerimises näitega

Mis on R-i funktsioon?

A funktsioon, programmeerimiskeskkonnas, on käskude komplekt. Programmeerija loob funktsiooni, mida vältida kordades sama ülesanne või vähendada keerukus.

Funktsioon peaks olema

• määratud ülesannete täitmiseks
• võib sisaldada argumente või mitte
• sisaldavad keha
• võib tagastada ühe või mitu väärtust või mitte.

Funktsiooni üldine lähenemisviis on kasutada argumendiosa kui sisendite, söödake keha osa ja lõpuks tagastada an väljund. Funktsiooni süntaks on järgmine:

function (arglist)  {
  #Function body
}

R olulised sisseehitatud funktsioonid

R-s on palju sisseehitatud funktsioone. R sobitab teie sisendparameetrid oma funktsiooni argumentidega kas väärtuse või asukoha järgi, seejärel käivitab funktsiooni keha. Funktsiooni argumentidel võivad olla vaikeväärtused: kui te neid argumente ei määra, võtab R vaikeväärtuse.
märkused:
Funktsiooni lähtekoodi on võimalik näha, käivitades konsoolis funktsiooni enda nime.

Näeme töös kolme funktsioonirühma

• Üldine funktsioon
• Matemaatika funktsioon
• Statistiline funktsioon

Üldised funktsioonid

Oleme juba tuttavad selliste üldiste funktsioonidega nagu cbind(), rbind(),range(),sort(),order() funktsioonid. Igal neist funktsioonidest on konkreetne ülesanne, väljundi tagastamiseks kasutatakse argumente. Järgmised on olulised funktsioonid, mida peate teadma:

funktsioon diff().

Kui töötate edasi aegridad, peate sarja paigal hoidma, võttes nende lag väärtused. statsionaarne protsess võimaldab konstantset keskmist, dispersiooni ja autokorrelatsiooni ajas. See parandab peamiselt aegrea prognoosi. Seda saab hõlpsasti teha funktsiooniga diff(). Saame koostada trendiga juhuslikud aegridaandmed ja seejärel kasutada seeria statsionaarseks muutmiseks funktsiooni diff(). Funktsioon diff() aktsepteerib ühte argumenti, vektorit ja tagastab sobiva viivitatud ja itereeritud erinevuse.

märkused: Sageli peame looma juhuslikke andmeid, kuid õppimiseks ja võrdlemiseks tahame, et numbrid oleksid masinates identsed. Tagamaks, et me kõik genereerime samu andmeid, kasutame funktsiooni set.seed() suvaliste väärtustega 123. Funktsioon set.seed() genereeritakse pseudojuhuslike arvude generaatori protsessiga, mis muudab kõik kaasaegsed arvutid sama jada. numbritest. Kui me funktsiooni set.seed() ei kasuta, on meil kõigil erinev numbrijada.

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

pikkus() funktsioon

Paljudel juhtudel tahame teada pikkus vektorist arvutamiseks või for-tsüklis kasutamiseks. Funktsioon length() loeb ridade arvu vektoris x. Järgmised koodid impordivad autode andmestiku ja tagastavad ridade arvu.

märkused: pikkus() tagastab vektori elementide arvu. Kui funktsioon edastatakse maatriksisse või andmeraami, tagastatakse veergude arv.

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

Väljund:

## [1] 1

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

Väljund:

## [1] 50

Matemaatilised funktsioonid

R-l on rida matemaatilisi funktsioone.

Operator	Kirjeldus
abs (x)	Võtab x absoluutväärtuse
log(x,base=y)	Võtab x-i logaritmi alusega y; kui alust pole määratud, tagastab naturaallogaritmi
exp(x)	Tagastab x eksponentsiaali
sqrt (x)	Tagastab x ruutjuure
faktoriaal(x)	Tagastab x faktoriaali (x!)

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

Väljund:

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

Väljund:

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

Väljund:

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

Statistilised funktsioonid

R standardinstallatsioon sisaldab laias valikus statistilisi funktsioone. Selles õpetuses vaatleme lühidalt kõige olulisemat funktsiooni.

Põhilised statistilised funktsioonid

Operator	Kirjeldus
keskmine (x)	x keskmine
mediaan(x)	Mediaan x
var(x)	x dispersioon
sd(x)	Standardhälve x
skaala (x)	Standardskoorid (z-skoorid) x-st
kvantiil(x)	X kvartiilid
kokkuvõte(x)	X-i kokkuvõte: keskmine, min, max jne.

speed <- dt$speed
speed
# Mean speed of cars dataset
mean(speed)

Väljund:

## [1] 15.4

# Median speed of cars dataset
median(speed)

Väljund:

## [1] 15

# Variance speed of cars dataset
var(speed)

Väljund:

## [1] 27.95918

# Standard deviation speed of cars dataset
sd(speed)

Väljund:

## [1] 5.287644

# Standardize vector speed of cars dataset		
head(scale(speed), 5)

Väljund:

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

# Quantile speed of cars dataset
quantile(speed)

Väljund:

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

# Summary speed of cars dataset
summary(speed)

Väljund:

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

Siiani oleme õppinud palju R sisseehitatud funktsioone.

märkused: Olge ettevaatlik argumendi klassiga, st numbriline, Boolean või string. Näiteks kui meil on vaja edastada stringi väärtus, peame panema stringi jutumärkidesse: "ABC" .

Kirjutage funktsioon R-i

Mõnel juhul peame kirjutama oma funktsiooni, kuna peame täitma konkreetse ülesande ja valmis funktsiooni pole olemas. Kasutaja määratud funktsioon hõlmab a nimi, argumendid ja keha.

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

märkused: Hea tava on anda kasutaja määratud funktsioonile nimi, mis erineb sisseehitatud funktsioonist. See väldib segadust.

Üks argument funktsioon

Järgmises lõigus defineerime lihtsa ruudufunktsiooni. Funktsioon aktsepteerib väärtuse ja tagastab väärtuse ruudu.

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

Code Selgitus

• Funktsiooni nimi on ruut_funktsioon; seda võib nimetada kuidas iganes tahame.
• See saab argumendi "n". Meie ei täpsustanud muutuja tüüpi, et kasutaja saaks edastada täisarvu, vektori või maatriksi
• Funktsioon võtab sisendi “n” ja tagastab sisendi ruudu. Kui olete funktsiooni kasutamise lõpetanud, saame selle eemaldada funktsiooniga rm().

# pärast funktsiooni loomist

rm(square_function)
square_function

Konsoolis näeme veateadet :Error: objekti 'ruutfunktsiooni' ei leitud, mis annab teada, et funktsiooni ei eksisteeri.

Keskkonna SCOping

R-is on keskkond on kogumine objektidest, nagu funktsioonid, muutujad, andmeraam jne.

R avab keskkonna iga kord, kui Rstudio küsib.

Saadaval on tipptasemel keskkond globaalses keskkonnas, nimega R_GlobalEnv. Ja meil on kohalik keskkond.

Saame loetleda praeguse keskkonna sisu.

ls(environment())

Väljund

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

Näete kõiki R_GlobalEnvis loodud muutujaid ja funktsioone.

Ülaltoodud loend varieerub teie jaoks sõltuvalt ajaloolisest koodist, mida R Studios käivitate.

Pange tähele, et n, funktsiooni ruut_funktsioon argument on mitte selles globaalses keskkonnas.

A uus iga funktsiooni jaoks luuakse keskkond. Ülaltoodud näites loob funktsioon square_function() globaalses keskkonnas uue keskkonna.

Et selgitada erinevust globaalne ja kohalik keskkond, uurime järgmist näidet

Need funktsioonid võtavad argumendina väärtuse x ja lisavad selle y-le, mis määratleb funktsiooni väljaspool ja sees

Funktsioon f tagastab väljundi 15. Seda seetõttu, et y on defineeritud globaalses keskkonnas. Kõiki globaalses keskkonnas määratletud muutujaid saab kasutada lokaalselt. Muutuja y väärtus on 10 kõigi funktsioonikutsete ajal ja see on igal ajal juurdepääsetav.

Vaatame, mis juhtub, kui muutuja y on funktsiooni sees defineeritud.

Peame enne selle koodi käivitamist käsuga rm r ära jätma "y".

Väljund on ka 15, kui kutsume f(5), kuid tagastab veateate, kui proovime printida väärtust y. Muutuja y ei ole globaalses keskkonnas.

Lõpuks kasutab R funktsiooni kehas liikumiseks uusimat muutuja definitsiooni. Vaatleme järgmist näidet:

R ignoreerib väljaspool funktsiooni määratletud y-väärtusi, kuna lõime ay-muutuja selgesõnaliselt funktsiooni kehasse.

Mitme argumendi funktsioon

Funktsiooni saab kirjutada rohkem kui ühe argumendiga. Mõelge funktsioonile nimega "time". See on lihtne funktsioon, mis korrutab kaks muutujat.

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

Väljund:

## [1] 8

Millal peaksime funktsiooni kirjutama?

Andmeteadlane peab tegema palju korduvaid ülesandeid. Enamasti kopeerime ja kleebime kooditükke korduvalt. Näiteks on enne a käivitamist väga soovitatav muutuja normaliseerimine masinõpe algoritm. Muutuja normaliseerimise valem on järgmine:

Teame juba, kuidas kasutada R-is funktsioone min() ja max(). Kasutame andmeraami loomiseks tibble teeki. Tibble on seni kõige mugavam funktsioon andmestiku nullist loomiseks.

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

Eespool kirjeldatud funktsiooni arvutamiseks jätkame kahes etapis. Esimeses etapis loome muutuja nimega c1_norm, mis on c1 skaleerimine. Teises etapis kopeerime ja kleepime lihtsalt koodi c1_norm ja muudame koodiga c2 ja c3.

Funktsiooni üksikasjad veeruga c1:

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

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

Seetõttu saame need jagada, et saada veeru c1 normaliseeritud väärtus:

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

Saame luua c1_norm, c2_norm ja c3_norm:

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)

Väljund:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

See toimib. Saame kopeerida ja kleepida

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

seejärel muutke c1_norm väärtuseks c2_norm ja c1 väärtuseks c2. Teeme sama, et luua 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))

Muutsime muutujad c1, c2 ja c3 suurepäraselt ümber.

See meetod on aga altid eksimustele. Võime kopeerida ja unustada veeru nime pärast kleepimist muuta. Seetõttu on hea tava kirjutada funktsioon iga kord, kui peate sama koodi kleepima rohkem kui kaks korda. Saame koodi ümber paigutada valemiks ja kutsuda seda alati, kui see on vajalik. Oma funktsiooni kirjutamiseks peame andma:

• Nimi: normaliseerida.
• argumentide arv: vajame ainult ühte argumenti, mis on veerg, mida arvutuses kasutame.
• Keha: see on lihtsalt valem, mille tahame tagastada.

Jätkame samm-sammult, et luua funktsiooni normaliseerimine.

Step 1) Me loome nimetaja, mis on . R-is saame nimetaja salvestada sellises muutujas:

nominator <- x-min(x)

Step 2) Arvutame välja nimetaja: . Saame korrata 1. sammu ideed ja salvestada arvutuse muutujas:

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

Step 3) Teostame jagamise nimetaja ja nimetaja vahel.

normalize <- nominator/denominator

Step 4) Funktsiooni kutsuva väärtuse tagastamiseks peame funktsiooni väljundi saamiseks läbima normalise inside return().

return(normalize)

Step 5) Oleme valmis funktsiooni wrap'i abil kasutamaping kõik kronsteini sees.

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

Testime oma funktsiooni muutujaga c1:

normalize(data_frame$c1)

See töötab ideaalselt. Lõime oma esimese funktsiooni.

Funktsioonid on terviklikum viis korduva ülesande täitmiseks. Normaliseerimisvalemit saame kasutada erinevates veergudes, näiteks allpool:

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)

Kuigi näide on lihtne, saame järeldada valemi võimsust. Ülaltoodud koodi on lihtsam lugeda ja eriti vältida vigu koodide kleepimisel.

Funktsioonid koos tingimusega

Mõnikord peame funktsiooni lisama tingimused, et kood saaks tagastada erinevaid väljundeid.

Masinõppe ülesannetes peame andmestiku rongikomplekti ja testkomplekti vahel jagama. Rongikomplekt võimaldab algoritmil andmetest õppida. Meie mudeli toimivuse testimiseks saame jõudlusnäitaja tagastamiseks kasutada testikomplekti. R-il pole funktsiooni kahe andmekogumi loomiseks. Selleks võime kirjutada oma funktsiooni. Meie funktsioon võtab kaks argumenti ja seda nimetatakse split_data(). Idee on lihtne, me korrutame andmekogumi pikkuse (st vaatluste arvu) 0.8-ga. Näiteks kui tahame andmestiku jagada 80/20 ja meie andmestik sisaldab 100 rida, siis meie funktsioon korrutab 0.8*100 = 80. Treeninguandmeteks valitakse 80 rida.

Kasutame õhukvaliteedi andmestikku oma kasutaja määratud funktsiooni testimiseks. Õhukvaliteedi andmestikus on 153 rida. Näeme seda alloleva koodiga:

nrow(airquality)

Väljund:

## [1] 153

Toimime järgmiselt:

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

Meie funktsioonil on kaks argumenti. Argumentide rong on Boole'i ​​parameeter. Kui see on seatud väärtusele TRUE, loob meie funktsioon rongiandmestiku, vastasel juhul loob see testandmestiku.

Võime jätkata samamoodi nagu normalise () funktsiooniga. Kirjutame koodi nii, nagu oleks see vaid ühekordne kood ja seejärel mähime funktsiooni loomiseks kõik koos tingimusega kehasse.

Samm 1:

Peame arvutama andmestiku pikkuse. Seda tehakse funktsiooniga nrow(). Nrow tagastab andmestiku ridade koguarvu. Nimetame muutuvat pikkust.

length<- nrow(airquality)
length

Väljund:

## [1] 153

Samm 2:

Me korrutame pikkuse 0.8-ga. See tagastab valitavate ridade arvu. See peaks olema 153 * 0.8 = 122.4

total_row <- length*0.8
total_row

Väljund:

## [1] 122.4

Soovime valida õhukvaliteedi andmestiku 122 rea hulgast 153 rida. Loome loendi, mis sisaldab väärtusi vahemikus 1 kuni total_row. Salvestame tulemuse muutujas nimega split

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

Väljund:

## [1] 1 2 3 4 5

split valib andmekogumist esimesed 122 rida. Näiteks näeme, et meie muutujate jaotus kogub väärtused 1, 2, 3, 4, 5 ja nii edasi. Need väärtused on indeks, kui valime tagastatavad read.

Samm 3:

Peame valima õhukvaliteedi andmestiku read jagatud muutujasse salvestatud väärtuste põhjal. Seda tehakse järgmiselt:

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

Väljund:

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

Samm 4:

Saame luua testandmestiku, kasutades ülejäänud ridu, 123:153. Seda tehakse spliti ees kasutades.

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

Väljund:

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

Samm 5:

Me saame luua tingimuse funktsiooni keha sees. Pidage meeles, et rongikomplekti tagastamiseks on meil argumendirong, mille Boole'i ​​väärtus on vaikimisi seatud väärtusele TRUE. Tingimuse loomiseks kasutame if-süntaksit:

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

See on kõik, me saame funktsiooni kirjutada. Peame ainult muutma õhukvaliteedi df-ks, sest tahame proovida oma funktsiooni mis tahes andmeraam, mitte ainult õhukvaliteet:

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

Proovime oma funktsiooni õhukvaliteedi andmestikul. meil peaks olema üks 122-realine rongikomplekt ja 31-realine katsekomplekt.

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

Väljund:

## [1] 122   6

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

Väljund:

## [1] 31  6