R Academy · Ders

Hız için Vektörleştirme

Q: “Hız için Vektörleştirme” dersi ücretsiz mi?

Evet — “Hız için Vektörleştirme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

Q: R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

Q: “Hız için Vektörleştirme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Q: Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Büyük hız kazanımları için açık döngüleri vektörleştirilmiş işlemlerle değiştirin.

Hız için Vektörleştirme, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

Vektörleştirme Neden Önemlidir?

R yorumlanan bir dil olduğu için for döngülerinde her yinelemede ek yük oluşur: işlev çağrılarının yönlendirilmesi, sınır denetimi ve tür dönüştürme. Vektörleştirilmiş işlemler bu işi, çok daha yüksek hızda çalışan derlenmiş C koduna aktarır.

Vektörleştirme, temel R'de kullanılabilen en etkili tek iyileştirmedir.

Döngü ve cumsum() Örneği

Çalışan toplamı bir for döngüsüyle hesaplamak ile yerleşik cumsum() işlevini kullanmak arasındaki farkı açıkça gösterir. cumsum(), C düzeyinde derlenmiş kodu çağırır ve tüm vektörü tek geçişte işler.

n <- 500000
x <- rnorm(n)

t_loop <- system.time({
  result <- numeric(n)
  result[1] <- x[1]
  for (i in 2:n) result[i] <- result[i-1] + x[i]
})['elapsed']

t_vec <- system.time({
  result2 <- cumsum(x)
})['elapsed']

cat('Loop  :', t_loop, 's
')
cat('cumsum:', t_vec, 's
')

ifelse() ve for + if

ifelse(condition, yes, no), koşulu tüm vektör üzerinde tek seferde değerlendiren vektörleştirilmiş bir koşul işlevidir. Öğe öğe çalışan for + if döngülerinin yerini tek bir C düzeyi geçişiyle alır.

n <- 300000
x <- rnorm(n)

t_loop <- system.time({
  result <- numeric(n)
  for (i in seq_len(n)) result[i] <- if (x[i] > 0) x[i] else -x[i]
})['elapsed']

t_vec <- system.time({
  result2 <- ifelse(x > 0, x, -x)
})['elapsed']

cat('for+if :', t_loop, 's
')
cat('ifelse :', t_vec, 's
')

Sonuç Vektörlerini Önceden Ayırma

Döngü kaçınılmaz olduğunda, sonuç vektörünü döngüden önce önceden ayırın. Döngü içinde c(result, new_val) ile bir vektörü büyütmek, her yinelemede vektörün tamamını kopyalar ve toplamda O(n^2) bellek işlemi gerçekleştirir.

n <- 20000

t_grow <- system.time({
  result <- c()
  for (i in seq_len(n)) result <- c(result, i^2)
})['elapsed']

t_prealloc <- system.time({
  result2 <- numeric(n)
  for (i in seq_len(n)) result2[i] <- i^2
})['elapsed']

cat('Growing vector:', t_grow, 's
')
cat('Pre-allocated :', t_prealloc, 's
')

Doğru Önceden Ayırma Türleri

Önceden ayırma sırasında örtük tür dönüşümünü önlemek için verilerinize uygun tür oluşturucuyu kullanın:

numeric(n) — çift duyarlıklı kayan noktalı sayılar
integer(n) — tam sayılar
character(n) — boş dizeler
logical(n) — FALSE değerleri
vector('list', n) — NULL değerlerinden oluşan liste

n <- 5
cat('numeric  :', numeric(n), '
')
cat('integer  :', integer(n), '
')
cat('logical  :', logical(n), '
')
cat('character:', character(n), '
')
cat('list len :', length(vector('list', n)), '
')

colSums() ve rowSums() ile apply() Karşılaştırması

Matris işlemleri için colSums(m), rowSums(m), colMeans(m) ve rowMeans(m), büyük ölçüde iyileştirilmiş C yordamlarıdır. R işlevi olan sum'ı her satır için bir kez çağıran apply(m, 1, sum) işlevinden sürekli olarak daha hızlıdırlar.

m <- matrix(rnorm(1000 * 2000), nrow = 1000)

t_apply <- system.time(apply(m, 2, sum))['elapsed']
t_colsums <- system.time(colSums(m))['elapsed']

cat('apply(m,2,sum):', t_apply, 's
')
cat('colSums(m)    :', t_colsums, 's
')

Vektörleştirilmiş Aritmetik Her Zaman Hızlıdır

Vektörler üzerindeki temel aritmetik işlemlerin — +, -, *, /, ^, sqrt(), log(), exp() — tümü vektörleştirilmiştir. Bu işlemler, tek bir C çağrısında tüm vektör boyunca öğe bazında çalışır. Döngüler yerine her zaman bunları tercih edin.

x <- 1:1000000

t1 <- system.time(y <- x^2 + 2*x + 1)['elapsed']

t2 <- system.time({
  y2 <- numeric(length(x))
  for (i in seq_along(x)) y2[i] <- x[i]^2 + 2*x[i] + 1
})['elapsed']

cat('Vectorized:', t1, 's
')
cat('Loop      :', t2, 's
')

Döngüler Yerine Mantıksal Alt Kümeleme

Bir vektörü mantıksal bir koşulla filtrelemek vektörleştirilmiştir. Döngü kullanıp koşula bağlı olarak ekleme yapmak yerine bir mantıksal dizin oluşturup tek seferde alt kümeleyin — alttaki C kodu tek geçişte işlemi tamamlar.

x <- rnorm(500000)

t_loop <- system.time({
  pos <- c()
  for (v in x) if (v > 0) pos <- c(pos, v)
})['elapsed']

t_vec <- system.time({
  pos2 <- x[x > 0]
})['elapsed']

cat('Loop filter:', t_loop, 's
')
cat('Logical idx:', t_vec, 's
')

Dizin İşlemleri için which() ve tabulate()

TRUE değerlerinin konumlarına ihtiyacınız olduğunda which(condition) vektörleştirilmiştir ve hızlıdır. tabulate(bin_vector), yoğun tamsayı aralıklarında tamsayı oluşumlarını table() işlevinden daha hızlı sayar.

x <- sample(1:10, 100000, replace = TRUE)

t_table    <- system.time(table(x))['elapsed']
t_tabulate <- system.time(tabulate(x, nbins = 10))['elapsed']

cat('table()   :', t_table, 's
')
cat('tabulate():', t_tabulate, 's
')

idx <- which(x == 5)
cat('Positions of 5: first 5 =', head(idx, 5), '
')

Döngülerin Hâlâ Uygun Olduğu Durumlar

Her döngü kötü değildir. Şu durumlarda döngüler kullanılabilir:

Her yineleme önceki sonuca bağlıysa (ardışık bağımlılık)
Yineleme sayısı küçükse (< 1000)
Döngünün gövdesi, vektörleştirilmiş eşdeğeri olmayan karmaşık bir işlev çağırıyorsa

Bu durumlarda önceden yer ayırmaya odaklanın ve döngü içinde veri yapılarını büyütmekten kaçının.

# Sequential dependency -- loop is correct here
fib <- function(n) {
  result <- integer(n)
  result[1] <- 1L
  if (n >= 2) result[2] <- 1L
  for (i in seq_len(n)[-c(1,2)]) result[i] <- result[i-1] + result[i-2]
  result
}
cat('Fibonacci:', fib(10), '
')

Vektörleştirmenin Özeti

Hızlı R kodu için temel vektörleştirme kuralları:

Ardışık biriktirme için cumsum/cumprod/diff kullanın
Öğe bazlı koşullar için ifelse() kullanın
numeric(n) / vector('list',n) ile önceden yer ayırın
apply() yerine colSums/rowSums/colMeans/rowMeans kullanın
Mantıksal alt kümeleme, filtreleme döngülerinden daha etkilidir

Kısa Kontrol: Önceden Yer Ayırma

Büyük n değerleri için bir döngünün içinde result <- c(result, new_val) ile bir vektörü büyütmek neden bu kadar yavaştır?

Vektörleştirmeyi Hatırlama

Vektörleştirme, R'da performansı artırmanın temel yoludur:

Vektörleştirilmiş işlevler (cumsum, ifelse, aritmetik işleçler) derlenmiş C kodunu çağırır — eşdeğer R döngülerinden 10 ila 100 kat daha hızlıdır
Kaçınılmaz bir döngüden önce sonuç kapsayıcılarına önceden yer ayırarak O(n^2) boyutundaki kopyalamayı önleyin
Matris toplulaştırmalarında colSums/rowSums, apply() işlevinden daha hızlıdır
Mantıksal alt kümeleme, filtreleme döngülerinin yerini temiz ve hızlı biçimde alır

Sıkça Sorulan Sorular