furrr: Paralel purrr İşlemleri
map() işlevini anında paralelleştirme için future_map() ile doğrudan değiştirin.
furrr: Paralel purrr İşlemleri, 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.
furrr: Paralel purrr
furrr (future + purrr), tüm purrr::map_*() işlevleri için doğrudan kullanılabilen paralel karşılıklar sağlar. Bir plan() ayarladıktan sonra yalnızca map() yerine future_map() yazmanız yeterlidir; işlem hattınızda yapısal değişiklik olmadan paralel çalışır.
library(furrr)
library(future)
# Set up parallel workers
plan(multisession, workers = 4)
# Sequential (purrr)
# result <- purrr::map(1:8, ~.x^2)
# Parallel (furrr) — identical API
result <- future_map(1:8, ~.x^2)
cat(unlist(result), '\n') # 1 4 9 16 25 36 49 64
plan(sequential)plan(multisession, workers = 4)
plan() içinde workers değerini açıkça belirtmek, paralel R oturumlarının sayısını sınırlar. CPU'yu yoğun kullanan görevlerde, işletim sistemine bir çekirdek bırakmak için workers = parallel::detectCores() - 1 yaygın bir kuraldır.
library(furrr)
library(future)
library(parallel)
# Explicit worker count
n_workers <- max(1, detectCores() - 1)
plan(multisession, workers = n_workers)
cat('Active workers:', nbrOfWorkers(), '\n')
cat('Strategy:', class(plan())[1], '\n')
# Run a simple parallel task
results <- future_map_dbl(1:8, ~sqrt(.x))
cat(round(results, 3), '\n')
plan(sequential)future_map_dbl ve Tür Belirtilen Karşılıklar
purrr gibi furrr da tür belirtilen karşılıklar sağlar: future_map_dbl(), future_map_int(), future_map_chr() ve future_map_lgl(). Bunlar dönüş türünü zorunlu kılar ve liste yerine atomik bir vektör döndürür.
library(furrr)
plan(multisession, workers = 2)
# Returns a numeric vector
square_roots <- future_map_dbl(1:6, ~sqrt(.x))
cat('dbl:', round(square_roots, 3), '\n')
# Returns an integer vector
counts <- future_map_int(list('hello', 'world', 'R'), nchar)
cat('int:', counts, '\n')
# Returns a character vector
formatted <- future_map_chr(c(1.23, 4.56, 7.89), ~sprintf('%.1f', .x))
cat('chr:', formatted, '\n')
# Returns a logical vector
positive <- future_map_lgl(-3:3, ~.x > 0)
cat('lgl:', positive, '\n')
plan(sequential)future_map2: İki Girdiyle Eşleme
future_map2(.x, .y, .f), iki liste veya vektör üzerinde paralel olarak yineler ve karşılık gelen çiftleri işleve iletir. purrr::map2()'nin paralel karşılığıdır.
library(furrr)
plan(multisession, workers = 2)
# Simulate different sample sizes and means
sizes <- c(100, 200, 300, 400)
means <- c(0, 5, -3, 10)
# future_map2 passes each (n, mu) pair to rnorm
samples <- future_map2(sizes, means, ~rnorm(.x, mean = .y))
# Verify: each element has the expected length and approximate mean
for (i in seq_along(samples)) {
cat('n=', sizes[i], 'target_mean=', means[i],
'observed_mean=', round(mean(samples[[i]]), 2), '\n')
}
plan(sequential)furrr_options: Davranışı Denetleme
furrr_options(), herhangi bir future_map_*() çağrısına .options bağımsız değişkeni olarak verilir. En önemli ayar, çalışanlar arasında tekrarlanabilir rastgele sayılar üretmek üzere paralel L'Ecuyer-CMRG RNG'sini etkinleştiren seed = TRUE seçeneğidir.
library(furrr)
plan(multisession, workers = 2)
# Without seed: results differ each run
r1 <- future_map_dbl(1:4, ~rnorm(1))
r2 <- future_map_dbl(1:4, ~rnorm(1))
cat('Without seed - same?', identical(r1, r2), '\n')
# With seed: reproducible
opts <- furrr_options(seed = 42L)
r3 <- future_map_dbl(1:4, ~rnorm(1), .options = opts)
r4 <- future_map_dbl(1:4, ~rnorm(1), .options = opts)
cat('With seed - same?', identical(r3, r4), '\n')
cat('r3:', round(r3, 4), '\n')
plan(sequential)progressr ile İlerleme Bildirimi
progressr paketi, paralel yürütme sırasında ilerleme çubukları görüntülemek için furrr ile bütünleşir. Kodunuzu with_progress() içine alın ve eşlenen işlevin içinde bir progressor() oluşturun.
library(furrr)
library(progressr)
plan(multisession, workers = 2)
# Enable progress reporting
handlers(global = TRUE) # show progress in console
with_progress({
p <- progressor(steps = 8)
results <- future_map(1:8, function(i) {
p() # increment the progress bar
Sys.sleep(0.1)
i^2
})
})
cat('Results:', unlist(results), '\n')
plan(sequential)furrr'da Genel Değişkenler
future paketi gibi furrr da .f içinde başvurulan genel değişkenleri otomatik olarak algılar. Büyük ortamlar için ek yükü azaltmak ve gönderilecek genel değişkenleri tam olarak belirtmek üzere bunu furrr_options(globals = c('var1', 'var2')) ile geçersiz kılabilirsiniz.
library(furrr)
plan(multisession, workers = 2)
# Global variables auto-detected
scale_factor <- 10
offset <- 5
result <- future_map_dbl(
1:6,
function(x) x * scale_factor + offset
)
cat(result, '\n') # 15 25 35 45 55 65
# Explicit globals control
opts <- furrr_options(
globals = c('scale_factor', 'offset'),
seed = FALSE
)
result2 <- future_map_dbl(
1:6,
function(x) x * scale_factor + offset,
.options = opts
)
cat('Manual globals:', result2, '\n')
plan(sequential)future_pmap: Çoklu Bağımsız Değişkenlerle Eşleme
future_pmap(.l, .f), purrr::pmap()'nin paralel sürümüdür. Vektör veya listelerden oluşan bir listeyi kabul eder ve karşılık gelen satırları adlandırılmış bağımsız değişkenler olarak iletir; böylece birden çok parametre birleşimi üzerinde paralel hesaplama yapılabilir.
library(furrr)
plan(multisession, workers = 2)
# Parameter grid
params <- list(
n = c(50, 100, 150, 200),
mean = c(0, 1, 2, 3),
sd = c(1, 2, 1, 0.5)
)
# future_pmap passes each row as arguments to rnorm
samples <- future_pmap(params, function(n, mean, sd) {
x <- rnorm(n, mean = mean, sd = sd)
c(obs_mean = round(mean(x), 3), obs_sd = round(sd(x), 3))
})
for (i in seq_along(samples)) {
cat('n=', params$n[i], ':', samples[[i]], '\n')
}
plan(sequential)furrr ile purrr'ı Karşılaştırmalı Ölçme
Paralelliğin sağladığı fayda görevlerin ağırlığıyla birlikte artar. Önemsiz işlemlerde (x^2) ek yük baskın olur ve sıralı çalışma daha hızlıdır. Çok sayıda model uydurma gibi ağır görevlerde ise paralellik önemli ölçüde zaman kazandırır.
library(furrr)
library(purrr)
plan(multisession, workers = 4)
# Heavy task: bootstrap a linear model 100 times
heavy <- function(i) {
n <- 200
df <- data.frame(x = rnorm(n), y = rnorm(n))
coef(lm(y ~ x, data = df))[['x']]
}
seq_time <- system.time(map_dbl(1:40, heavy))[['elapsed']]
par_time <- system.time(
future_map_dbl(1:40, heavy, .options = furrr_options(seed = TRUE))
)[['elapsed']]
cat('Sequential:', round(seq_time, 2), 's\n')
cat('Parallel: ', round(par_time, 2), 's\n')
cat('Speedup: ', round(seq_time / max(par_time, 0.001), 2), 'x\n')
plan(sequential)future_map'te Hata Yönetimi
Herhangi bir öğenin hesaplaması hata oluşturursa future_map() durur ve hatayı yeniden oluşturur. Hatalara rağmen devam etmek için işlevinizin çevresinde purrr::safely() veya purrr::possibly() sarmalayıcılarını kullanın.
library(furrr)
library(purrr)
plan(multisession, workers = 2)
# Wrap with safely() to capture errors as results
safe_log <- safely(log, otherwise = NA_real_)
inputs <- list(10, -1, 100, 'text', 0.5)
results <- future_map(inputs, safe_log)
for (i in seq_along(results)) {
if (is.null(results[[i]]$error)) {
cat('Input', i, '-> result:', round(results[[i]]$result, 4), '\n')
} else {
cat('Input', i, '-> error:', conditionMessage(results[[i]]$error), '\n')
}
}
plan(sequential)Uygulamalı furrr İşlem Hattı
İşte baştan sona eksiksiz bir işlem hattı: verileri yükleyin, tekrarlanabilir başlangıç değerleriyle birden çok modeli paralel olarak uydurun, performans ölçütlerini çıkarın ve tüm bunları furrr yaklaşımını kullanarak en iyi modeli seçin.
library(furrr)
library(purrr)
plan(multisession, workers = 4)
set.seed(1)
n <- 300
df <- data.frame(
x1 = rnorm(n), x2 = rnorm(n), x3 = rnorm(n),
y = rnorm(n)
)
formulas <- list(
y ~ x1,
y ~ x1 + x2,
y ~ x1 + x2 + x3,
y ~ x1 * x2
)
# Fit all models in parallel
models <- future_map(
formulas,
~lm(.x, data = df),
.options = furrr_options(seed = FALSE)
)
# Extract adjusted R-squared
adj_r2 <- map_dbl(models, ~summary(.x)$adj.r.squared)
cat('Adjusted R2 per model:',
paste(round(adj_r2, 4), collapse = ', '), '\n')
cat('Best model:', which.max(adj_r2), '\n')
plan(sequential)Hızlı Denetim
Paralel future_map() çağrılarında tekrarlanabilir rastgele sayılar istiyorsunuz. Bunu hangi furrr_options() ayarı sağlar?
Özet: furrr Paketi
Temel çıkarımlar:
furrr,purrriçin doğrudan kullanılabilen paralel bir karşılıktır — yalnızcamapyerinefuture_mapyazın- Önce
plan(multisession, workers = n)ile bir arka uç ayarlayın - Tür belirtilen karşılıklar:
future_map_dbl(),future_map_int(),future_map_chr() - Birden çok girdiyi paralel olarak eşlemek için
future_map2()vefuture_pmap() - Tekrarlanabilir paralel RNG için
furrr_options(seed = 42L) - Uzun paralel görevler sırasında ilerleme çubukları için
progressrile bütünleştirin - Hatalara dayanıklı işlem hatları için
future_map()içindepurrr::safely()kullanın
library(furrr)
plan(multisession, workers = 2)
results <- future_map_dbl(
1:6,
~.x^2 + sqrt(.x),
.options = furrr_options(seed = TRUE)
)
cat(round(results, 3), '\n')
plan(sequential)Sıkça Sorulan Sorular
“furrr: Paralel purrr İşlemleri” dersi ücretsiz mi?
Evet — “furrr: Paralel purrr İşlemleri” 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.
“furrr: Paralel purrr İşlemleri” dersinde ne öğreneceğim?
map() işlevini anında paralelleştirme için future_map() ile doğrudan değiştirin. 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 3. dersidir.
“furrr: Paralel purrr İşlemleri” 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
- parallel Paketi ve detectCores()
- future Çerçevesi
- furrr: Paralel purrr İşlemleri
- Paralel Kodda Hata Ayıklama ve Yük Dengeleme