0Pricing
R Academy · Pelajaran

furrr: Operasi purrr Paralel

Ganti map() secara langsung dengan future_map() untuk paralelisasi seketika.

furrr: Operasi purrr Paralel adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

furrr: purrr Paralel

furrr (future + purrr) menyediakan pengganti paralel yang dapat langsung digunakan untuk semua fungsi purrr::map_*(). Cukup ganti map() dengan future_map() setelah menetapkan plan(), dan alur kerja Anda berjalan secara paralel tanpa perubahan struktur.

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)

Menentukan workers secara eksplisit dalam plan() membatasi jumlah sesi R paralel. Untuk tugas yang terikat CPU, workers = parallel::detectCores() - 1 adalah konvensi umum agar satu inti tetap tersedia untuk OS.

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 dan Varian Bertipe

Seperti purrr, furrr menyediakan varian bertipe: future_map_dbl(), future_map_int(), future_map_chr(), dan future_map_lgl(). Fungsi-fungsi ini memaksakan tipe hasil dan mengembalikan vektor atomik, bukan daftar.

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: Pemetaan Dua Input

future_map2(.x, .y, .f) melakukan iterasi pada dua daftar atau vektor secara paralel dengan meneruskan pasangan yang bersesuaian ke fungsi. Ini adalah padanan paralel dari purrr::map2().

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: Mengendalikan Perilaku

furrr_options() diteruskan sebagai argumen .options ke pemanggilan future_map_*() apa pun. Pengaturan yang paling penting adalah seed = TRUE, yang mengaktifkan RNG paralel L'Ecuyer-CMRG untuk menghasilkan angka acak yang dapat direproduksi di seluruh pekerja.

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)

Pelaporan Kemajuan dengan progressr

Paket progressr terintegrasi dengan furrr untuk menampilkan bilah kemajuan selama eksekusi paralel. Bungkus kode Anda dengan with_progress() dan buat progressor() di dalam fungsi yang dipetakan.

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)

Variabel Global dalam furrr

Seperti paket future, furrr secara otomatis mendeteksi variabel global yang dirujuk di dalam .f. Anda dapat menggantinya dengan furrr_options(globals = c('var1', 'var2')) untuk menentukan dengan tepat variabel global yang akan dikirim, sehingga mengurangi beban untuk lingkungan yang besar.

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: Pemetaan Banyak Argumen

future_pmap(.l, .f) adalah versi paralel dari purrr::pmap(). Fungsi ini menerima daftar vektor/daftar dan meneruskan baris yang bersesuaian sebagai argumen bernama, sehingga memungkinkan perhitungan paralel pada beberapa kombinasi parameter.

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)

Membandingkan Kinerja furrr dan purrr

Manfaat paralelisme meningkat seiring bobot tugas. Untuk operasi sepele (x^2), beban tambahan lebih dominan sehingga eksekusi berurutan lebih cepat. Untuk tugas berat seperti menyesuaikan banyak model, pemrosesan paralel menghemat banyak waktu.

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)

Penanganan Error dalam future_map

Jika perhitungan elemen mana pun menghasilkan error, future_map() berhenti dan menghasilkan kembali error tersebut. Untuk tetap melanjutkan meskipun ada error, gunakan pembungkus purrr::safely() atau purrr::possibly() pada fungsi Anda.

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)

Alur Kerja Praktis furrr

Berikut alur kerja lengkap dari awal hingga akhir: memuat data, menyesuaikan beberapa model secara paralel dengan seed yang dapat direproduksi, mengekstrak metrik kinerja, lalu memilih model terbaik—semuanya menggunakan gaya furrr.

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)

Pemeriksaan Singkat

Anda ingin menghasilkan angka acak yang dapat direproduksi pada beberapa pemanggilan paralel future_map(). Pengaturan furrr_options() mana yang mewujudkannya?

Ringkasan: Paket furrr

Hal-hal penting:

  • furrr adalah pengganti paralel yang dapat langsung digunakan untuk purrr—cukup ganti map dengan future_map
  • Tetapkan backend terlebih dahulu dengan plan(multisession, workers = n)
  • Varian bertipe: future_map_dbl(), future_map_int(), future_map_chr()
  • future_map2() dan future_pmap() untuk pemetaan paralel dengan banyak input
  • furrr_options(seed = 42L) untuk RNG paralel yang dapat direproduksi
  • Integrasikan progressr untuk menampilkan bilah kemajuan selama pekerjaan paralel yang panjang
  • Gunakan purrr::safely() di dalam future_map() untuk alur kerja yang tahan terhadap error
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)

Pertanyaan yang Sering Diajukan

Apakah pelajaran “furrr: Operasi purrr Paralel” gratis?

Ya — teks lengkap “furrr: Operasi purrr Paralel” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “furrr: Operasi purrr Paralel”?

Ganti map() secara langsung dengan future_map() untuk paralelisasi seketika. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “furrr: Operasi purrr Paralel” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Paket parallel dan detectCores()
  2. Kerangka Kerja future
  3. furrr: Operasi purrr Paralel
  4. Men-debug dan Menyeimbangkan Beban Kode Paralel
← Kembali ke R Academy