0Pricing
R Academy · Ders

future Çerçevesi

Eşzamansız ve taşınabilir paralel işlem için plan(multisession) ve future() kullanın.

future Çerçevesi, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 2. 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.

future Paketi Nedir?

future paketi, R'da eşzamansız ve paralel programlama için birleşik, üst düzey bir API sağlar. Bir future, daha sonra kullanılabilir hâle gelecek bir değer için yer tutucudur — bu değer başka bir çekirdekte veya makinede hesaplanabilir.

library(future)

# A simple future: computation happens asynchronously
f <- future({
  Sys.sleep(0.5)  # simulate slow work
  42
})

cat('Future created, doing other work...\n')

# Retrieve the result (blocks until done)
result <- value(f)
cat('Result:', result, '\n')

plan(): Bir Arka Uç Seçme

plan(), bundan sonra oluşturulacak tüm future'lar için yürütme stratejisini belirler. En yaygın stratejiler sequential (varsayılan, tek iş parçacıklı), multisession (birden çok R oturumu, her yerde çalışır) ve multicore (çatallama, yalnızca Unix/macOS) seçenekleridir.

library(future)

# Default: sequential (no parallelism)
plan(sequential)
cat('Strategy:', class(plan())[1], '\n')

# Parallel with separate R sessions (works on Windows too)
plan(multisession, workers = 4)
cat('Strategy:', class(plan())[1], '\n')

# Forking (Unix/macOS only, lower overhead)
if (.Platform$OS.type != 'windows') {
  plan(multicore, workers = 4)
  cat('Strategy:', class(plan())[1], '\n')
}

# Reset to sequential
plan(sequential)

value(): Sonuçları Bekleme

value(f), future hesaplaması tamamlanana kadar geçerli işlemi bekletir ve ardından sonucu döndürür. Future bir hata oluşturduysa value(), hatayı çağıran oturumda yeniden oluşturur.

library(future)
plan(multisession, workers = 2)

# Launch two slow tasks concurrently
f1 <- future({ Sys.sleep(0.3); sum(1:1000) })
f2 <- future({ Sys.sleep(0.3); prod(1:10) })

# Both run in parallel; total time ~ 0.3s not 0.6s
start <- proc.time()[['elapsed']]
v1 <- value(f1)
v2 <- value(f2)
elapsed <- proc.time()[['elapsed']] - start

cat('v1:', v1, ' v2:', v2, '\n')
cat('Elapsed:', round(elapsed, 2), 's\n')

plan(sequential)

%<-% İşleci

%<-% işleci, future() ile tembel value() değerlendirmesinin söz dizimsel kısaltmasıdır. Normal bir atama gibi görünür; ancak sağ taraf eşzamansız olarak çalışır. Değer, değişkene ilk kez erişildiğinde alınır.

library(future)
plan(multisession, workers = 2)

# %<-% starts the computation immediately in the background
x %<-% {
  Sys.sleep(0.3)
  rnorm(5, mean = 10)
}

y %<-% {
  Sys.sleep(0.3)
  runif(5, min = 1, max = 5)
}

cat('Both running in background...\n')

# Accessing x or y here blocks until ready
cat('x:', round(x, 2), '\n')
cat('y:', round(y, 2), '\n')

plan(sequential)

Genel Değişkenlerin Otomatik Algılanması

future'ın en güçlü özelliklerinden biri genel değişken algılama özelliğidir: Future kodunuzun çağıran ortamdaki hangi değişkenlere başvurduğunu otomatik olarak bulur ve bunları çalışan işleme gönderir — elle clusterExport() kullanmanız gerekmez.

library(future)
plan(multisession, workers = 2)

# These globals are auto-detected and sent to the worker
threshold <- 50
multiplier <- 3

f <- future({
  x <- threshold * multiplier  # uses both globals
  x + 1
})

cat('Result:', value(f), '\n')  # 151

# Inspect which globals were identified
future_obj <- future({
  threshold + multiplier
}, lazy = TRUE)
cat('Globals found:', paste(names(future::getGlobalsAndPackages(future_obj)$globals), collapse = ', '), '\n')

plan(sequential)

future_options: Davranışı Ayarlama

future.options (​options() veya future::plan() bağımsız değişkenleri aracılığıyla erişilir) genel ayarları denetler: future başına izin verilen en fazla bellek miktarını, genel değişken algılama stratejisini ve zaman aşımı davranışını.

library(future)

# Cap memory per future at 500 MB
options(future.globals.maxSize = 500 * 1024^2)  # bytes

# Disable automatic global detection (manual control)
options(future.globals.onReference = 'error')

# Inspect current settings
cat('Max globals size (MB):',
    getOption('future.globals.maxSize') / 1024^2, '\n')

# Restore defaults
options(future.globals.maxSize = 500 * 1024^2)
options(future.globals.onReference = NULL)

plan(multisession, workers = 2)

# Large object: you'd get an error if it exceeds the cap
big_vec <- 1:1e5  # small enough
f <- future(sum(big_vec))
cat('Sum:', value(f), '\n')

plan(sequential)

İç İçe Future'lar

Future'lar iç içe olabilir: bir future, kendisi de iç future'lar oluşturabilir. Varsayılan olarak iç future'lar sırayla çalışır; iç içe bir planı plan(list(...)) ile ayarlarsanız paralel çalışabilirler. Bu, iki düzeyli paralellik için kullanışlıdır.

library(future)

# Two-level parallelism: outer uses multisession, inner sequential
plan(list(multisession, sequential))

outer_futures <- lapply(1:3, function(i) {
  future({
    # Each outer worker runs its own sequential inner work
    inner <- lapply(1:4, function(j) i * j)
    unlist(inner)
  })
})

results <- lapply(outer_futures, value)
for (i in seq_along(results)) {
  cat('Outer', i, ':', results[[i]], '\n')
}

plan(sequential)

Future'larla Hata Yönetimi

Bir future hesaplaması hata oluşturduğunda value() bu hatayı yeniden oluşturur. Tüm işlem hattınızı durdurmadan tek tek future hatalarını ele almak için value() çağrısını tryCatch() içine alın.

library(future)
plan(multisession, workers = 2)

# This future will error
bad_future <- future(log(-1, base = 'oops'))  # invalid arg
good_future <- future(sqrt(144))

# Handle errors gracefully
bad_result <- tryCatch(
  value(bad_future),
  error = function(e) {
    cat('Caught error:', conditionMessage(e), '\n')
    NA
  }
)

good_result <- value(good_future)
cat('bad_result:', bad_result, '\n')
cat('good_result:', good_result, '\n')

plan(sequential)

Future Durumunu Denetleme

resolved(f), bir future bekletme yapmadan tamamlandıysa TRUE döndürür. Bu sayede tamamlanma durumunu sorgulayabilir ve beklerken yararlı işler yaparak engellemesiz bir sorgulama döngüsü oluşturabilirsiniz.

library(future)
plan(multisession, workers = 2)

f <- future({
  Sys.sleep(0.5)
  'done'
})

# Poll without blocking
counter <- 0
while (!resolved(f)) {
  counter <- counter + 1
  Sys.sleep(0.1)
  cat('Polling... (', counter, ')\n')
}

cat('Future resolved! Result:', value(f), '\n')
cat('Polled', counter, 'times\n')

plan(sequential)

future ile lapply'yi Birleştirme

N görevi dağıtmak için lapply() ile future()'ı, sonuçları toplamak içinse lapply() ile value()'yu birleştirin. Bu düzen, her future'ın ne zaman başlayacağı üzerinde açık denetim sağlar.

library(future)
plan(multisession, workers = 4)

# Fan out: create all futures
params <- list(
  list(n = 1000, mean = 0),
  list(n = 1000, mean = 5),
  list(n = 1000, mean = 10),
  list(n = 1000, mean = -3)
)

futures <- lapply(params, function(p) {
  future({
    x <- rnorm(p$n, mean = p$mean)
    list(mean = mean(x), sd = sd(x))
  })
})

# Fan in: collect results
results <- lapply(futures, value)
for (i in seq_along(results)) {
  cat('Param mean', params[[i]]$mean,
      '-> observed mean:', round(results[[i]]$mean, 3), '\n')
}

plan(sequential)

Gerçek Kullanım Örneği: Çapraz Doğrulama Katlarının Değerlendirilmesi

Çapraz doğrulama, son derece uygun bir paralel problemidir: her kat bağımsızdır. Future'ları kullanarak tüm K katı aynı anda değerlendirebilir ve hesaplama açısından pahalı modellerin toplam geçen süresini önemli ölçüde azaltabilirsiniz.

library(future)
plan(multisession, workers = 4)

set.seed(42)
data <- data.frame(x = rnorm(200), y = rnorm(200))
fold_ids <- sample(rep(1:4, 50))

# Launch all folds in parallel
fold_futures <- lapply(1:4, function(k) {
  future({
    train <- data[fold_ids != k, ]
    test  <- data[fold_ids == k, ]
    fit   <- lm(y ~ x, data = train)
    preds <- predict(fit, newdata = test)
    rmse  <- sqrt(mean((test$y - preds)^2))
    rmse
  })
})

rmses <- unlist(lapply(fold_futures, value))
cat('Fold RMSEs:', round(rmses, 4), '\n')
cat('Mean RMSE:', round(mean(rmses), 4), '\n')

plan(sequential)

Hızlı Denetim

Hem Windows hem de macOS üzerinde çalışan paralel kod çalıştırmak istiyorsunuz. Hangi plan() stratejisini seçmelisiniz?

Özet: future Çerçevesi

Temel çıkarımlar:

  • future({expr}) bir ifadeyi eşzamansız olarak çalıştırır; value(f) sonucu alır
  • %<-%, tembel future değerlendirmesiyle yapılan atamanın söz dizimsel kısaltmasıdır
  • Platformlar arası kullanım için plan(multisession); Unix/macOS çatallaması için plan(multicore) kullanın
  • Genel değişkenler otomatik olarak algılanır ve çalışan işlemlere gönderilir — clusterExport() kullanmanız gerekmez
  • resolved(f), bekletme yapmadan tamamlanmayı denetler
  • Hatalara dayanıklı işlem hatları için value() çağrısını tryCatch() içine alın
  • İşiniz bittiğinde sıfırlamak için her zaman plan(sequential) veya plan() çağırın
library(future)
plan(multisession, workers = 2)

# Concise pattern: fan-out then fan-in
task <- function(i) future({ i^2 + i })
results <- lapply(1:6, task)
cat(unlist(lapply(results, value)), '\n')  # 2 6 12 20 30 42

plan(sequential)

Sıkça Sorulan Sorular

“future Çerçevesi” dersi ücretsiz mi?

Evet — “future Çerçevesi” 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.

“future Çerçevesi” dersinde ne öğreneceğim?

Eşzamansız ve taşınabilir paralel işlem için plan(multisession) ve future() kullanın. R Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

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 2. dersidir.

“future Çerçevesi” 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.

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.

Bu kursun tüm dersleri

  1. parallel Paketi ve detectCores()
  2. future Çerçevesi
  3. furrr: Paralel purrr İşlemleri
  4. Paralel Kodda Hata Ayıklama ve Yük Dengeleme
← R Academy Sayfasına Dön