Ö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 tekrarlamak aynı görevi yapın veya 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 daha 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.

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

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

Genel fonksiyonlar

cbind(), rbind(),range(),sort(),order() fonksiyonları gibi genel fonksiyonlara zaten aşinayız. Bu fonksiyonların her birinin belirli bir görevi vardır, bir çıktı döndürmek için argümanlar alır. Aşağıda bilinmesi gereken önemli fonksiyonlar yer almaktadı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 otokorelasyona izin verir. Bu esas olarak bir zaman serisinin tahminini geliştirir. diff() fonksiyonu ile kolaylıkla yapılabilir. Trendli rastgele bir zaman serisi verisi oluşturabilir ve ardından seriyi durağan hale getirmek için diff() fonksiyonunu kullanabiliriz. diff() işlevi bir argümanı, bir vektörü kabul eder ve uygun gecikmeli ve yinelenen farkı döndürür.

not: Genellikle rastgele veri oluşturmamız gerekir, ancak öğrenme ve karşılaştırma için sayıların makineler arasında aynı olmasını isteriz. Hepimizin aynı veriyi ürettiğinden emin olmak için, 123'lük keyfi değerlerle set.seed() fonksiyonunu kullanırız. set.seed() fonksiyonu, her modern bilgisayarın aynı sayı dizisine sahip olmasını sağlayan sözde rastgele sayı üreteci süreciyle üretilir. set.seed() fonksiyonunu kullanmazsak, hepimizin farklı sayı dizisi olur.

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

uzunluk() işlevi

Çoğu durumda bilmek isteriz uzunluk hesaplama için veya bir for döngüsünde kullanılacak bir vektörün. 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: uzunluk(), bir vektördeki öğelerin sayısını döndürür. İşlev bir matrise veya veri çerçevesine aktarılırsa 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ı

R bir dizi matematiksel fonksiyona sahiptir.

Kullanım	Açıklama
abs (x)	x'in mutlak değerini alır
log(x,taban=y)	x'in y tabanlı logaritmasını alır; taban belirtilmezse, doğal logaritmayı döndürür
deneyim (x)	x'in üstel değerini döndürür
sqrt (x)	x'in karekökünü döndürür
faktöriyel(x)	x (x!)'in faktöriyelini döndürür

# 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

R standart kurulumu çok çeşitli istatistiksel işlevler içerir. Bu derste kısaca en önemli fonksiyona bakacağız..

Temel istatistik fonksiyonları

Kullanım	Açıklama
ortalama(x)	x'in ortalaması
medyan(x)	x'in medyanı
var(x)	x'in varyansı
sd(x)	x'in standart sapması
ölçek(x)	x'in standart puanları (z puanları)
nicelik(x)	x'in çeyrekleri
özet(x)	X'in özeti: ortalama, minimum, maksimum vb.

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.

not: Argümanın sınıfına (örneğin sayısal, Boolean veya dize) dikkat edin. Örneğin, bir dize değeri aktarmamız gerekiyorsa, dizeyi tırnak içine almamız gerekir: “ABC”.

R'ye fonksiyon yaz

Bazı durumlarda kendi fonksiyonumuzu yazmamız gerekir çünkü belirli bir görevi yerine getirmemiz gerekir ve hazır bir fonksiyon yoktur. Kullanıcı tanımlı bir işlev ş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)

Kod 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ı.

Ortam Kapsamının Belirlenmesi

R'de, çevre bir Toplamak işlevler, değişkenler, veri çerçevesi vb. gibi nesnelerin

R, Rstudio her istendiğinde bir ortam açar.

Mevcut en üst düzey ortam, küresel çevre, R_GlobalEnv olarak adlandırıldı. Ve bizde 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, R Studio'da çalıştırdığınız geçmiş koda bağlı olarak sizin için değişiklik gösterecektir.

square_function fonksiyonunun argümanı olan n'nin şu olduğuna dikkat edin: bu küresel ortamda değil.

A yeni Her fonksiyon için ortam yaratılır. Yukarıdaki örnekte square_function() işlevi küresel ortam içinde yeni bir ortam yaratır.

Aradaki farkı açıklığa kavuşturmak için global ve yerel Çevre, 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 bilimcinin 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şkeni çalıştırmadan önce bir değişkenin normalleştirilmesi ş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. İlk adımda c1'in yeniden ölçeklenmesi olan c1_norm adında bir değişken oluşturacağız. İkinci adımda c1_norm kodunu kopyalayıp yapıştırıyoruz ve c2 ve c3 ile değiştiriyoruz.

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öntemin hata yapma olasılığı yüksektir. Kopyalayıp yapıştırdıktan sonra sütun adını değiştirmeyi unutabiliriz. Bu nedenle, aynı kodu iki defadan fazla yapıştırmanız gerektiğinde bir işlev yazmak iyi bir uygulamadır. Kodu bir formül halinde yeniden düzenleyebilir ve gerektiğinde çağırabiliriz. Kendi fonksiyonumuzu yazmak için şunu vermemiz gerekir:

• İsim: normalleştir.
• 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 biz yaratırız aday, hangisi . R'de adayı şu şekilde bir değişkende saklayabiliriz:

nominator <- x-min(x)

) 2 Adım biz hesaplıyoruz payda: . 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 Her şeyi braketin içine sararak fonksiyonu kullanmaya hazırız.

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.

İşlevler, tekrarlanan bir görevi gerçekleştirmenin daha kapsamlı bir yoludur. Normalleştirme formülünü aşağıdaki gibi farklı sütunlar üzerinde 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 formülün kuvvetini çıkarabiliriz. Yukarıdaki kodun okunması daha kolaydır ve özellikle kodları yapıştırırken hatalardan kaçınılır.

Koşullu işlevler

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.

Normalise() fonksiyonunda yaptığımız gibi ilerleyebiliriz. Kodu sanki tek seferlik bir kodmuş gibi yazıyoruz ve ardından koşulu içeren her şeyi gövdeye sararak fonksiyonu oluşturuyoruz.

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 sıralı bir tren setimiz ve 31 sıralı 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