Örnekle R Programlamada Fonksiyonlar

R'de Fonksiyon Nedir?

A işlev, bir programlama ortamında bir dizi talimattır. Bir programcı kaçınılacak bir işlev geliştirir aynı görevi tekrarlamakveya azaltın karmaşıklık.

Bir fonksiyon olmalı

• belirli bir görevi yerine getirmek için yazılmış
• argümanlar içerebilir veya içermeyebilir
• bir vücut içerir
• Bir veya birden fazla değer döndürebilir veya döndürmeyebilir.

Bir fonksiyona genel bir yaklaşım argüman kısmını şu şekilde kullanmaktır: girişler, bir şeyi beslemek vücut parça ve sonunda geri dönmek çıktıBir fonksiyonun sözdizimi aşağıdaki gibidir:

function (arglist)  {
  #Function body
}

R önemli yerleşik işlevler

R'de çok sayıda yerleşik işlev vardır. R, giriş parametrelerinizi işlev bağımsız değişkenleriyle değere veya konuma göre eşleştirir ve ardından işlev gövdesini çalıştırır. İşlev bağımsız değişkenleri varsayılan değerlere sahip olabilir: Bu bağımsız değişkenleri belirtmezseniz, R varsayılan değeri alır.
not:
Konsolda fonksiyonun adını çalıştırarak bir fonksiyonun kaynak kodunu görmek mümkündür.

Typing Köşeli parantez olmadan yazılan bir fonksiyon adı, aşağıdaki konsolda gösterildiği gibi kaynak kodunu yazdırır.

Üç grup işlevi çalışırken göreceğiz

• Genel işlev
• Matematik işlevi
• İstatistiksel fonksiyon

Genel fonksiyonlar

cbind(), rbind(), range() gibi genel fonksiyonlara zaten aşinayız. çeşit()ve order() fonksiyonları. Bu fonksiyonların her birinin belirli bir görevi vardır ve çıktı döndürmek için argümanlar alır. Bilmeniz gereken önemli fonksiyonlar şunlardır:

fark() işlevi

üzerinde çalışırsan Zaman serisiseriyi alarak durağanlaştırmanız gerekir. gecikme değerleri. bir sabit süreç Zaman içinde sabit ortalama, varyans ve otokorelasyon sağlar. Bu, esas olarak zaman serisi tahminini iyileştirir. Bu, diff() fonksiyonu ile yapılabilir. Trend içeren rastgele bir zaman serisi verisi oluşturabilir ve ardından seriyi durağanlaştırmak için diff() fonksiyonunu kullanabiliriz. diff() fonksiyonu tek bir argüman, bir vektör alır ve uygun gecikmeli ve yinelemeli farkı döndürür.

notSıklıkla rastgele veri oluşturmamız gerekiyor, ancak öğrenme ve karşılaştırma için sayıların tüm makinelerde aynı olmasını istiyoruz. Hepimizin aynı veriyi üretmesini sağlamak için, 123 gibi rastgele değerlerle set.seed() fonksiyonunu kullanıyoruz. set.seed() fonksiyonu, sözde rastgele sayı üretecinin başlangıç ​​noktasını sabitler, böylece her makine aynı diziyi üretir. set.seed() fonksiyonu olmadan, her çalıştırma farklı bir dizi döndürür.

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

Aşağıdaki iki panelde, orijinal kümülatif seri, artık sabit bir ortalama etrafında dalgalanan fark alınmış serinin yanına yerleştirilmiştir.

uzunluk() işlevi

Birçok durumda, hesaplama yapmak veya bir for döngüsünde kullanmak için bir vektörün uzunluğunu bilmek isteriz. `length()` fonksiyonu, x vektöründeki satır sayısını sayar. Aşağıdaki kodlar, `cars` veri setini içe aktarır ve satır sayısını döndürür.

not`length()` fonksiyonu bir vektördeki eleman sayısını döndürür. Fonksiyon bir parametre olarak geçirilirse... matris Veya bir veri çerçevesi ise, sütun sayısı döndürülür.

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

Çıktı:

## [1] 1

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

Çıktı:

## [1] 50

Matematik fonksiyonları

Genel yardımcı fonksiyonların ötesinde, R'de bir vektör üzerinde eleman eleman işlem yapan bir dizi matematiksel fonksiyon bulunur.

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

Çıktı:

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

Çıktı:

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

Çıktı:

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

İstatistiksel fonksiyonlar

Matematiksel fonksiyonlar değerleri dönüştürürken, istatistiksel fonksiyonlar bunları özetler. R'nin standart kurulumu geniş bir yelpazede istatistiksel fonksiyon içerir. Bu eğitimde, en önemlilerine kısaca göz atacağız.

Temel istatistik fonksiyonları

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

Çıktı:

## [1] 15.4

# Median speed of cars dataset
median(speed)

Çıktı:

## [1] 15

# Variance speed of cars dataset
var(speed)

Çıktı:

## [1] 27.95918

# Standard deviation speed of cars dataset
sd(speed)

Çıktı:

## [1] 5.287644

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

Çıktı:

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

# Quantile speed of cars dataset
quantile(speed)

Çıktı:

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

# Summary speed of cars dataset
summary(speed)

Çıktı:

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

Bu noktaya kadar birçok R yerleşik fonksiyonunu öğrendik.

notDikkatli olun argümanın sınıfıÖrneğin, sayısal, mantıksal veya metinsel bir değer olabilir. Örneğin, bir metinsel değer geçirmemiz gerekiyorsa, metinsel değeri tırnak içine almalıyız: “ABC”.

R'ye fonksiyon yaz

Bazı durumlarda, belirli bir görevi yerine getirmemiz gerektiğinden ve hazır bir fonksiyon bulunmadığından kendi fonksiyonumuzu yazmamız gerekir. Kullanıcı tanımlı bir fonksiyon şunları içerir: isim, argümanlar ve vücut.

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

not: Kullanıcı tanımlı bir işlevi yerleşik işlevden farklı bir şekilde adlandırmak iyi bir uygulamadır. Karışıklığı önler.

Bir argüman işlevi

Bir sonraki kod parçasında basit bir kare fonksiyonu tanımlıyoruz. Fonksiyon bir değer alır ve bu değerin karesini döndürür.

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

Code açıklama

• İşlev kare_işlevi olarak adlandırılır; ne istersek onu çağırabiliriz.
• “n” argümanını alır. Biz Kullanıcının bir tam sayı, bir vektör veya bir matris iletebilmesi için değişkenin türü belirtilmedi
• Fonksiyon “n” girdisini alır ve girdinin karesini döndürür. Fonksiyonu kullanmayı bitirdiğinizde rm() fonksiyonuyla onu kaldırabiliriz.

#fonksiyonu oluşturduktan sonra

rm(square_function)
square_function

Konsolda, işlevin mevcut olmadığını belirten bir hata mesajı görebiliriz: Hata: 'kare_işlev' nesnesi bulunamadı.

Çevre Scoping

R'de, çevre Fonksiyonlar, değişkenler, veri çerçeveleri vb. nesnelerin bir koleksiyonudur.

RStudio her başlatıldığında R yeni bir ortam açar.

Mevcut en üst düzey ortam, küresel çevre'R_GlobalEnv' olarak adlandırılan bir şey. Ve elimizde şunlar var: yerel Çevre.

Mevcut ortamın içeriğini listeleyebiliriz.

ls(environment())

Çıktı

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

R_GlobalEnv'de oluşturulan tüm değişkenleri ve işlevleri görebilirsiniz.

Yukarıdaki liste, RStudio'da çalıştırdığınız geçmiş kodlara bağlı olarak sizin için farklılık gösterecektir.

Bunu not et nsquare_function fonksiyonunun argümanı bu global ortamda yer almıyor.

Her fonksiyon için yeni bir ortam oluşturulur. Yukarıdaki örnekte, square_function() fonksiyonu, içinde yeni bir ortam oluşturur. küresel çevre.

Aradaki farkı açıklığa kavuşturmak için global hem de yerel Çevre bağlamında, aşağıdaki örneği inceleyelim.

Bu fonksiyon argüman olarak x değerini alır ve fonksiyonun dışını ve içindekini tanımlamak için onu y'ye ekler.

f fonksiyonu 15 çıktısını döndürür. Bunun nedeni y'nin global ortamda tanımlanmış olmasıdır. Global ortamda tanımlanan herhangi bir değişken yerel olarak kullanılabilir. Y değişkeni tüm işlev çağrıları sırasında 10 değerine sahiptir ve istenildiği zaman erişilebilir.

Fonksiyonun içinde y değişkeni tanımlanırsa ne olacağını görelim.

Bu kodu rm r kullanarak çalıştırmadan önce `y'yi bırakmamız gerekiyor

f(15) çağırdığımızda da çıktı 5 olur ancak y değerini yazdırmaya çalıştığımızda hata verir. Y değişkeni global ortamda değil.

Son olarak, R bir fonksiyonun gövdesine geçmek için en son değişken tanımını kullanır. Aşağıdaki örneği ele alalım:

R, fonksiyonun dışında tanımlanan y değerlerini yok sayar çünkü fonksiyonun gövdesi içinde açıkça bir ay değişkeni yarattık.

Çoklu argüman işlevi

Birden fazla argümanla bir fonksiyon yazabiliriz. “Times” adı verilen işlevi düşünün. İki değişkeni çarpan basit bir fonksiyondur.

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

Çıktı:

## [1] 8

Fonksiyonu ne zaman yazmalıyız?

Veri bilimcilerinin birçok tekrarlayan görevi yapması gerekir. Çoğu zaman, kod parçalarını tekrar tekrar kopyalayıp yapıştırırız. Örneğin, bir değişkenin normalleştirilmesi, bir işlemi çalıştırmadan önce şiddetle tavsiye edilir. makine öğrenme algoritma. Bir değişkeni normalleştirme formülü şöyledir:

R'de min() ve max() fonksiyonunun nasıl kullanılacağını zaten biliyoruz. Veri çerçevesini oluşturmak için tibble kütüphanesini kullanıyoruz. Tibble, sıfırdan bir veri seti oluşturmak için şimdiye kadarki en kullanışlı işlevdir.

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

Yukarıda açıklanan fonksiyonu hesaplamak için iki adımda ilerleyeceğiz. Birinci adımda, c1'in yeniden ölçeklendirilmesi olan c1_norm adında bir değişken oluşturacağız. İkinci adımda ise, c1_norm'un kodunu kopyalayıp yapıştıracağız ve c2 ile c3 ile değiştireceğiz.

c1 sütunlu fonksiyonun detayı:

Aday gösteren: : data_frame$c1 -min(data_frame$c1))

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

Bu nedenle, c1 sütununun normalleştirilmiş değerini elde etmek için bunları bölebiliriz:

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

c1_norm, c2_norm ve c3_norm'u oluşturabiliriz:

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)

Çıktı:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

İşe yarıyor. Kopyalayıp yapıştırabiliriz

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

daha sonra c1_norm'u c2_norm olarak ve c1'i c2 olarak değiştirin. c3_norm'u oluşturmak için de aynısını yapıyoruz

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

C1, c2 ve c3 değişkenlerini mükemmel şekilde yeniden ölçeklendirdik.

Ancak bu yöntem hatalara açıktır. Kopyalayıp yapıştırdıktan sonra sütun adını değiştirmeyi unutabiliriz. Bu nedenle, aynı kodu iki kereden fazla yapıştırmanız gerektiğinde her seferinde bir fonksiyon yazmak iyi bir uygulamadır. Kodu bir formüle dönüştürüp gerektiğinde çağırabiliriz. Kendi fonksiyonumuzu yazmak için şunları vermemiz gerekir:

• Adı: normalize et.
• argüman sayısı: Yalnızca bir argümana ihtiyacımız var, o da hesaplamamızda kullandığımız sütun.
• Beden: Bu sadece geri dönmek istediğimiz formül.

Normalleştirme fonksiyonunu oluşturmak için adım adım ilerleyeceğiz.

) 1 Adım Payı, yani x – min(x)'i oluşturuyoruz. R'da, payı şu şekilde bir değişkende saklayabiliriz:

nominator <- x-min(x)

) 2 Adım Paydayı hesaplıyoruz: max(x) – min(x). 1. adımdaki fikri tekrarlayabilir ve hesaplamayı bir değişkende saklayabiliriz:

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

) 3 Adım Payda ve payda arasındaki bölmeyi yapıyoruz.

normalize <- nominator/denominator

) 4 Adım Değeri çağıran fonksiyona döndürmek için, fonksiyonun çıktısını almak amacıyla normalleştirmeyi return() içine geçirmemiz gerekir.

return(normalize)

) 5 Adım Fonksiyonu wrap yöntemiyle kullanmaya hazırız.ping Parantez içindeki her şey.

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

Fonksiyonumuzu c1 değişkeniyle test edelim:

normalize(data_frame$c1)

Mükemmel çalışıyor. İlk fonksiyonumuzu oluşturduk.

Bir fonksiyon, tekrarlayan bir görevi gerçekleştirmenin daha kapsamlı bir yoludur. Aşağıdaki gibi farklı sütunlar üzerinde normalleştirme formülünü kullanabiliriz:

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)

Örnek basit olsa da, bir formülün gücünü çıkarabiliriz. Yukarıdaki kodun okunması daha kolaydır ve kod yapıştırmanın getirdiği hatalardan kaçınır.

Koşullu işlevler

`normalize()` fonksiyonu her zaman aynı şeyi yapar. Bazen, kodun farklı çıktılar döndürmesine izin vermek için bir fonksiyona koşullar eklememiz gerekir.

Makine Öğrenimi görevlerinde veri setini bir tren seti ve bir test seti arasında bölmemiz gerekir. Tren seti, algoritmanın verilerden öğrenmesine olanak tanır. Modelimizin performansını test etmek amacıyla performans ölçüsünü döndürmek için test setini kullanabiliriz. R'nin iki veri kümesi oluşturma işlevi yoktur. Bunu yapmak için kendi fonksiyonumuzu yazabiliriz. Fonksiyonumuz iki argüman alır ve split_data() olarak adlandırılır. Arkasındaki fikir basit; veri kümesinin uzunluğunu (yani gözlem sayısını) 0.8 ile çarpıyoruz. Örneğin veri setini 80/20'ye bölmek istiyorsak ve veri setimiz 100 satır içeriyorsa fonksiyonumuz 0.8*100 = 80'i çarpacaktır. Eğitim verimiz olarak 80 satır seçilecektir.

Kullanıcı tanımlı işlevimizi test etmek için hava kalitesi veri kümesini kullanacağız. Hava kalitesi veri kümesinde 153 satır bulunmaktadır. Aşağıdaki kodla görebiliriz:

nrow(airquality)

Çıktı:

## [1] 153

Aşağıdaki gibi ilerleyeceğiz:

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

Fonksiyonumuzun iki argümanı vardır. Argümanlar train bir Boolean parametresidir. TRUE olarak ayarlanırsa, fonksiyonumuz train veri kümesini oluşturur, aksi takdirde test veri kümesini oluşturur.

Normalize() fonksiyonunda yaptığımız gibi devam edebiliriz. Kodu sanki tek seferlik bir kodmuş gibi yazıyoruz ve ardından her şeyi koşulla birlikte fonksiyonun gövdesine sarıyoruz.

1 Adım:

Veri setinin uzunluğunu hesaplamamız gerekiyor. Bu, nrow() fonksiyonuyla yapılır. Nrow, veri kümesindeki toplam satır sayısını döndürür. Değişken uzunluk diyoruz.

length<- nrow(airquality)
length

Çıktı:

## [1] 153

2 Adım:

Uzunluğu 0.8 ile çarpıyoruz. Seçilecek satır sayısını döndürecektir. 153*0.8 = 122.4 olmalıdır

total_row <- length*0.8
total_row

Çıktı:

## [1] 122.4

Hava kalitesi veri setindeki 122 satır arasından 153 satırı seçmek istiyoruz. 1'den total_row'a kadar değerleri içeren bir liste oluşturuyoruz. Sonucu split adı verilen değişkende saklıyoruz

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

Çıktı:

## [1] 1 2 3 4 5

split veri kümesindeki ilk 122 satırı seçer. Örneğin split değişkenimizin 1, 2, 3, 4, 5 vb. değerleri topladığını görebiliriz. Döndürülecek satırları seçeceğimizde bu değerler indeks olacaktır.

3 Adım:

Hava kalitesi veri kümesindeki satırları, split değişkeninde saklanan değerlere göre seçmemiz gerekiyor. Bu şu şekilde yapılır:

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

Çıktı:

##[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 Adım:

Geriye kalan 123:153 satırını kullanarak test veri setini oluşturabiliriz. Bu, split'in önünde – kullanılarak yapılır.

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

Çıktı:

##[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 Adım:

Koşulu fonksiyonun gövdesi içinde yaratabiliriz. Unutmayın, tren setini döndürmek için varsayılan olarak TRUE olarak ayarlanmış Boolean olan bir argüman trenimiz var. Koşulu oluşturmak için if sözdizimini kullanırız:

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

İşte bu, fonksiyonu yazabiliriz. İşlevimizi herhangi bir şekilde denemek istediğimiz için yalnızca hava kalitesini df olarak değiştirmemiz gerekiyor. veri çerçevesiyalnızca hava kalitesi değil:

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

Fonksiyonumuzu hava kalitesi veri seti üzerinde deneyelim. 122 satırdan oluşan bir eğitim seti ve 31 satırdan oluşan bir test setimiz olmalı.

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

Çıktı:

## [1] 122   6

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

Çıktı:

## [1] 31  6

SSS