R'de Döngüler Eğitimi - Kullanım ve Alternatifler

For Döngülerinin Açıklaması

Dikdörtgen ‘init’ (veya başlatma) kutusu, elmas (romb) karar sembolü ve i1 dikdörtgen kutusundan oluşan bu döngü yapısı, bilinen sayıda kez yürütülür.

Akış şeması terimleriyle, dikdörtgen kutular “karar gerektirmeyen bir şey yap” anlamına gelir. Romblar ya da elmaslar ise “karar sembolleri”dir ve bu nedenle yalnızca iki olası mantıksal cevabı olan sorulara karşılık gelir: Doğru (T) veya Yanlış (F).

Not olarak, basit tutmak için, şekildeki diğer olası semboller atlanmıştır.

Başlatma dikdörtgenindeki bir veya daha fazla talimatı, belirli bir dizide değerler alabilen bir değişken üzerindeki koşulun değerlendirilmesi izler. Şekilde bu, elmasla temsil edilir: semboller “v değişkeninin mevcut değeri seq dizisine ait mi?” anlamına gelir.

Başka bir deyişle, v'nin mevcut değerinin belirli bir aralıkta olup olmadığını test ediyorsunuz. Bu aralığı genellikle başlatmada 1:100 gibi bir ifadeyle tanımlarsınız ki döngü başlasın.

Koşul sağlanmaz ve sonuç False olursa döngü hiç çalıştırılmaz. Bu, for döngü yapısının sağındaki serbest okla gösterilir. Program daha sonra, döngü bloğundan sonra bulunan ilk talimatı yürütür.

Koşul doğrulanırsa, bir talimat—veya talimatlar bloğu—i1 yürütülür. Ve belki de bu talimatlar bloğu başka bir döngüdür. Bu gibi durumlarda iç içe döngüden söz edilir.

Bu yapıldıktan sonra koşul yeniden değerlendirilir. Bu, i1'den yukarıya, başlatma kutusunun hemen sonrasına giden çizgilerle gösterilir. R'de—ve Python'da—bunu düz İngilizceyle ifade etmek mümkündür: değişkenimizin bir değer aralığına ait olup olmadığını sorarız.

Not ki diğer dillerde, örneğin C'de, koşul daha açık biçimde büyüktür-küçüktür, eşittir gibi mantıksal karşılaştırma operatörleriyle belirtilir…

İşte basit bir for döngüsü örneği:

# Create a vector filled with random normal values
u1 <- rnorm(30)
print("This loop calculates the square of the first 10 elements of vector u1")

# Initialize `usq`
usq <- 0. 

for (i in 1:10) {
    # i-th element of `u1` squared into `i`-th position of `usq`
    usq[i] <- u1[i] * u1[i]
    print(usq[i])
}

print(i)

for bloğu süslü parantezler içinde yer alır. Bu parantezler test koşulundan hemen sonra ya da tercihen girintiyle onun altına yerleştirilebilir. Hiçbiri zorunlu değildir, ancak süslü parantezler kesinlikle kodunuzun okunabilirliğini artırır ve döngü bloğunu ve içindeki olası hataları kolayca fark etmenizi sağlar.

Not olarak, kareler vektörü usq başlatılmıştır. Bu, sade RStudio kodunda gerekli olmayabilir; ancak işaretlemeli sürümde, knitr, vektöre döngüde kullanılmadan önce bir başvuru bulunamadığından derleme yapmaz ve RStudio içinde bir hata verir. knitr hakkında daha fazla bilgi için R Markdown sayfasına gidin.

For Döngülerini İç İçe Kullanma

Artık for döngülerinin iç içe de olabileceğini bildiğinize göre, muhtemelen bunu neden ve ne zaman kullanmanız gerektiğini merak ediyorsunuzdur.

Diyelim ki, iki boyutlu bir diziyi elemanlarını belirli değerlere ayarlayarak değiştirmek istiyorsunuz.

O zaman şöyle bir şey yapabilirsiniz:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeros
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

İpucu: matrix() fonksiyonu hakkında daha fazla bilgi için R Documentation'ı ziyaret edin.

You have two nested for loops in the code chunk above and thus two sets of curly braces, each with its own block and governed by its own index. That is, i runs over the lines and j runs over the columns.

 

Ne üretildi?

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

Not olarak, kullanıcının ekranı devasa tablolarla doldurmasını önlemek için, sonunda bir koşul koyarsınız: yalnızca kullanıcı 10'dan büyük bir tamsayı isterse ilk 10 x 10 parçası yazdırılır. Aksi hâlde, bir n x n parça yazdırılacaktır.

Tüm kod şu şekilde görünür:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeroes
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

For Döngüleri: Popüler ama Her Zaman Size En Uygunu Değil

for döngüsü açık ara en popüler olanıdır ve yapısı, yineleme sayısının önceden sabit ve biliniyor olmasını ima eder; “ilk 200 asal sayıyı üret” veya “en önemli 10 müşteriyi listele” gibi durumlarda olduğu gibi.

Ancak, yineleme sayısını bilmediğiniz ya da kontrol edemediğiniz ve önceden öngörülemeyen bir veya birkaç koşulun ortaya çıkabildiği durumlarda ne olur?

Örneğin, belirli bir posta koduyla tanımlanan bir bölgede yaşayan müşteri sayısını ya da son iki gün içinde bir web sayfası afişine tıklanma sayısını saymak isteyebilirsiniz; benzeri öngörülemeyen olaylar gibi.

Bu gibi durumlarda, while döngüsü ve kuzeni repeat imdada yetişebilir…

Döngülerinizi break ile Kırın

R yorumlayıcısı bir break ile karşılaştığında, denetimi döngünün hemen sonrasındaki talimata (varsa) devreder. İç içe döngülerde, break yalnızca en içteki döngüden çıkmaya izin verir.

İşte bir örnek.

Bu kod parçası sıfırlardan oluşan bir m x n matrisi tanımlar ve daha sonra, yalnızca iki indeks farklıysa, matrisin konumlarını doldurmak için iç içe bir for döngüsüne girer. Amaç, ana köşegenin altındaki elemanların sıfır olmayan değerlere sahip olduğu bir alt üçgensel matris oluşturmaktır. Diğerleri başlatılmış sıfır değerinde bırakılır.

İndeksler eşit olduğunda ve dolayısıyla sütun indeksi j üzerinde çalışan iç döngüdeki koşul sağlandığında, bir break çalıştırılır ve en içteki döngü, iç döngüyü izleyen talimata doğrudan atlama ile kesilir. Bu talimat bir print() talimatıdır. Daha sonra denetim, tekrar değerlendirilen dış for koşuluna (satırlar, indeks i) gelir.

Eğer indeksler farklıysa, atama yapılır ve sayaç 1 artırılır. Sonunda, atanan elemanların sayısını içeren ctr sayacı yazdırılır.

# Make a lower triangular matrix (zeroes in upper right corner)
m = 10
n = 10

# A counter to count the assignment
ctr = 0

# Create a 10 x 10 matrix with zeroes
mymat = matrix(0, m, n)

for (i in 1:m) {
    for (j in 1:n) {
        if (i == j) {
            break
        } else {
            # you assign the values only when i<>j
            mymat[i, j] = i * j
            ctr = ctr + 1
        }
    }
    print(i * j)
}

# Print how many matrix cells were assigned
print(ctr)

Not ki, zorunlu olmasalar bile, bazen aşırı temkinli davranıp süslü parantezleri koymak isteyebilirsiniz. Genellikle, bir { ile açılan her şeyin bir } ile kapandığından emin olmak için yaparsınız. Böylece { veya } sayılarının eşleşmediğini fark ederseniz bir hata olduğunu bilirsiniz—tersi her zaman doğru olmasa da!

Döngülerde next Kullanımı

next, belirli bir yinelemeyi sonlandırır ve bir sonraki çevrime atlar. Aslında mevcut döngünün koşulunun değerlendirilmesine sıçrar.

Diğer dillerde (biraz kafa karıştırıcı) eşdeğeri “continue” olarak bulunabilir; anlamı aynıdır: nerede olursanız olun, koşul doğrulanınca döngünün değerlendirilmesine atlayın.

Bir koşul gerçekleştiğinde belirli bir çevrimi atlayıp döngüyü sürdürmenin daha basit bir örneği şudur:

m = 20

for (k in 1:m) {
    if (!k %% 2)
        next
    print(k)
}

Bu kod parçası, 1:m aralığındaki tüm tek sayıları (m=20 burada) yazdırır. Başka bir deyişle, 2 ile bölündüğünde sıfır olmayan kalan veren tüm tamsayılar (bu yüzden %% modülüs işleci kullanılır) if testinde belirtildiği gibi yazdırılacaktır.

Kalanı sıfır olan sayılar yazdırılmayacaktır; çünkü program, i in 1:m koşulunun değerlendirilmesine atlar ve ardından gelebilecek talimatları yok sayar. Bu durumda print(k) yok sayılır.

v1 <- c(3,4,5)
v2 <- c(3,4,6)
v3 <- c(0,0,0)
n = length(v1)

for (i in 1:n) {
    v3[i] <- v1[i] + v2[i]
}
v3

v3 = v1 + v2
v3

A <- matrix(1:6, nrow = 3, ncol = 2)
B <- matrix(c(2,4,3,1,5,7), nrow=3, ncol=2)

C= A + B
C

R'de Vektörleştirme Açıklaması

Görünürde temel işlemlerin sayısı aynıyken, vektörleştirmenin neden daha hızlı çalıştığını merak edebilirsiniz.

Bu, R'nin iç işleyişine bakılarak en iyi şekilde açıklanır; bu da ayrı bir yazı gerektirir; ancak kısaca: her şeyden önce, R yorumlanan bir dildir ve bu nedenle değişken tanımlarıyla ilgili tüm ayrıntılar yorumlayıcı tarafından ele alınır. Örneğin, bir sayının kayan noktalı olduğunu belirtmeniz ya da bellekte bir işaretçi kullanarak bellek ayırmanız gerekmez.

R yorumlayıcısı bu hususları, komutlarınızı girerken bağlamdan “anlar”; ancak bunu komut bazında yapar. Dolayısıyla, belirli bir komutu her verdiğinizde, onu tekrarlasanız bile, bu tanımlarla uğraşması gerekir.

Derleyici ise, tüm tanımları ve bildirileri, herhangi bir şeyi çalıştırmayı denemeden önce, tüm kod üzerinde derleme zamanında çözer; kodu, derli toplu ve optimize edilmiş ikili koda çevirir. Şimdi, R fonksiyonları bu alt düzey dillerden biriyle yazıldığından, daha verimlidir.

Pratikte, alt düzey koda bakılsa, genellikle “sarmalayıcı” kod içinde uygulanmış C veya C++ çağrıları görülecektir.

İkinci olarak, vektörleştirmeyi destekleyen dillerde (R veya Matlab gibi), sayısal bir veriyi kullanan her talimat, tek bir elemandan oluşsa bile, yerel olarak vektör olarak tanımlanan bir nesne üzerinde çalışır. Örneğin, tek bir sayısal değişken tanımladığınızda; R'deki iç temsili, yalnızca bir sayıdan oluşsa da, her zaman bir vektör olacaktır.

Döngüler kaputun altında varlığını sürdürür; ancak daha alt ve çok daha hızlı C/C++ derlenmiş düzeyde. Bir vektöre sahip olmanın avantajı, tanımların, boyutundan bağımsız olarak, yorumlayıcı tarafından tüm vektör için yalnızca bir kez çözülmesidir; skaler üzerinde yapılan bir döngüde ise tanımlar ve ayırmalar eleman bazında yapılmak zorundadır ve bu daha yavaştır.

Son olarak, yerel vektör formatıyla çalışmak, çok verimli Doğrusal Cebir yordamlarını (BLAS gibi—Basic Linear Algebra Subprograms) kullanmayı mümkün kılar; böylece vektörleştirilmiş talimatlar yürütülürken R bu verimli sayısal yordamları devreye alır. Dolayısıyla mesaj şudur: mümkünse, yürütülen tüm kopyalama işlemlerinden kaçınmak için tüm veri yapılarını tek bir fonksiyon çağrısı içinde işleyin.

Fazla dalmadan, şimdi vektörleştirmenin genel bir örneğini yapalım; ardından bir sonraki alt bölümde, döngülerin yerine geçecek daha özel ve popüler R vektörleştirilmiş fonksiyonlarına ineceksiniz.

R'de Vektörleştirmeye Bir Örnek

“Veri büyütme” kavramına geri dönelim; bir veri çerçevesini “güncellemenin” tipik olarak verimsiz bir yolu.

Önce, replicate(m, rnorm(n)) ile m x n bir matris oluşturursunuz; burada m=10 adet, her biri n=10 elemanlı sütun vektörü rnorm(n) ile (rastgele normal sayılar) oluşturulur.

Sonra bunu bir veri çerçevesine dönüştürürsünüz (böylece 10 değişkenin 10 gözlemi) ve iç içe bir for döngüsü kullanarak her eleman üzerinde cebirsel bir işlem yaparsınız: her yinelemede, iki indeksin işaret ettiği her elemana sinüsoidal bir fonksiyon eklenir.

Aşağıdaki örnek biraz yapaydır; ancak rastgele bir gürültüye bir sinyal eklenmesini temsil edebilir:

# This is a bad loop with 'growing' data
set.seed(42)
m = 10
n = 10

# Create matrix of normal random numbers
mymat <- replicate(m, rnorm(n))

# Transform into data frame
mydframe <- data.frame(mymat)

for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
    print(mydframe)
  }
}

Burada, yürütme süresinin çoğu kopyalamaya ve döngünün yönetilmesine gider.

Vektörleştirilmiş bir çözüm nasıl görünüyor, bakalım:

set.seed(42)
m = 10
n = 10
mymat <- replicate(m, rnorm(n))
mydframe <- data.frame(mymat)
mydframe <- mydframe + 10 * sin(0.75 * pi)
mydframe

Bu daha basit görünüyor: son satır, iç içe for döngüsünün yerini alıyor. Not olarak, iki uygulamanın tam olarak aynı sonucu verdiğinden emin olmak için set.seed() kullanımına dikkat edin.

Şimdi iki çözümün yürütme süresini nicelleştirelim.

Bunu, system.time() gibi R sistem komutlarını kullanarak yapabilirsiniz; bir kod parçası şu şekilde geçirilir:

İpucu: değerlendirmek istediğiniz kodu system.time() fonksiyonunun parantezleri arasına koymanız yeterlidir.

# Insert `system.time()` to measure loop execution
for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
  }
}

# Add `system.time()` to measure vectorized execution
mydframe <- mydframe + 10 * sin(0.75 * pi) 

Yukarıdaki kod parçasında, m ve n'in seçimi, matrisin oluşturulması ve veri çerçevesine dönüştürülmesi işini başta bir kez yapar; ardından for parçasını, vektörleştirilmiş sürümün “tek satırlık” hâline karşı, iki ayrı system.time() çağrısıyla değerlendirirsiniz.

m=n=10 gibi asgari bir ayarda bile, vektörleştirilmiş sürümün 7 kat daha hızlı olduğunu görürsünüz; bu kadar düşük değerlerde kullanıcı için pek önemli olmasa da.

Farklılıklar, m=n=100 koyarsanız (insan ölçeğinde) fark edilir hâle gelir; 1000'e çıkarmak, for döngüsünün onlarca saniye takılı kalıyormuş gibi görünmesine neden olurken, vektörleştirilmiş form hâlâ göz açıp kapayıncaya kadar çalışır.

m=n=10000 için for döngüsü bir dakikadan fazla takılı kalır; vektörleştirilmiş sürüm ise 2,54 sn sürer. Elbette bu ölçümler hafife alınmalı ve donanım-yazılım yapılandırmasına bağlı olacaktır; muhtemelen dizüstü bilgisayarınızı tarayıcınızda onlarca açık sekmeyle ve arka planda çalışan uygulamalarla aşırı yüklememek gerekir; ancak bu ölçümler farkları göstermek için yeterlidir.

Hakkaniyet gereği, m ve n'in artırılmasının, çoğaltma fonksiyonu etrafına başka bir system.time() çağrısı koyarak kolayca görebileceğiniz gibi, matris üretimini de ciddi biçimde etkilediğini söyleyelim.

Yürütme süresinin nasıl değiştiğini görmek için m ve n ile oynamanız, yürütme süresini m x n çarpımının bir fonksiyonu olarak çizmeniz teşvik edilir. Bu, oluşturulan matrislerin boyutunu ifade ettiğinden anlamlı bir göstergedir. Böylece, nset edilmiş for döngüsüyle görevi tamamlamak için gereken yineleme sayısını da niceler.

Yani bu, vektörleştirmeye bir örnektir. Ama daha pek çoğu var. R News, R projesinin bülteninde 46. sayfada, diziler veya matrislerde belirli boyutlar için toplam ve ortalamaları hesaplamada çok verimli fonksiyonlardan söz edilir: rowSums(), colSums(), rowMeans() ve colMeans().

Ayrıca, bültende “...‘apply’ ailesindeki fonksiyonların, adları [s,l,m,t]apply olan fonksiyonların, başka bir fonksiyonu nesnelerin öğelerine/boyutlarına uygulamak için sağlandığı; bu ‘apply’ fonksiyonlarının, kötü yazılmış döngülerden daha okunabilir ve daha hızlı olan, bazen oldukça karmaşık görevler için derli toplu bir sözdizimi sunduğu” belirtilir.