0Pricing
R Academy · Урок

furrr: параллельные операции purrr

Заменяйте map() без дополнительных изменений на future_map() для мгновенной распараллелизации

«furrr: параллельные операции purrr» — бесплатный урок R Academy на CoddyKit. Это урок 3 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения R Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс R Academy содержит 4 уроков всего.

furrr: параллельный purrr

furrr (future + purrr) предоставляет прямые параллельные замены для всех функций purrr::map_*(). После задания plan() достаточно заменить map() на future_map(), и конвейер начнёт выполняться параллельно без структурных изменений.

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)

Явное указание workers в plan() ограничивает количество параллельных сеансов R. Для задач, ограниченных производительностью CPU, часто используют workers = parallel::detectCores() - 1, оставляя одно ядро для 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 и варианты с заданным типом

Как и purrr, furrr предоставляет варианты с заданным типом: future_map_dbl(), future_map_int(), future_map_chr() и future_map_lgl(). Они проверяют тип возвращаемого значения и возвращают атомарный вектор, а не список.

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: отображение двух входных наборов

future_map2(.x, .y, .f) параллельно проходит по двум спискам или векторам, передавая функции соответствующие пары элементов. Это параллельный аналог 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: управление поведением

furrr_options() передаётся как аргумент .options в любой вызов future_map_*(). Наиболее важная настройка — seed = TRUE: она активирует параллельный генератор случайных чисел L'Ecuyer-CMRG, обеспечивая воспроизводимость результатов на рабочих процессах.

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

Пакет progressr интегрируется с furrr и отображает индикаторы выполнения во время параллельного запуска. Оберните код в with_progress() и создайте progressor() внутри отображаемой функции.

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

Как и пакет future, furrr автоматически обнаруживает глобальные переменные, на которые ссылаются внутри .f. Это можно переопределить с помощью furrr_options(globals = c('var1', 'var2')), точно указав, какие глобальные переменные отправлять, чтобы уменьшить накладные расходы для больших окружений.

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: отображение с несколькими аргументами

future_pmap(.l, .f) — параллельная версия purrr::pmap(). Она принимает список векторов или списков и передаёт соответствующие строки как именованные аргументы, позволяя параллельно выполнять вычисления для нескольких комбинаций параметров.

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 и purrr

Преимущества параллелизма зависят от сложности задач. Для тривиальных операций (x^2) накладные расходы преобладают, поэтому последовательное выполнение быстрее. Для тяжёлых задач, например обучения множества моделей, параллелизм существенно экономит время.

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

Если при вычислении любого элемента возникает ошибка, future_map() останавливается и повторно вызывает её. Чтобы продолжить выполнение несмотря на ошибки, используйте оболочки purrr::safely() или purrr::possibly() вокруг своей функции.

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)

Практический конвейер furrr

Вот полный конвейер от начала до конца: загрузка данных, параллельное обучение нескольких моделей с воспроизводимыми начальными значениями, извлечение показателей качества и выбор лучшей модели — всё в стиле 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)

Быстрая проверка

Вам нужны воспроизводимые случайные числа при параллельных вызовах future_map(). Какая настройка furrr_options() это обеспечивает?

Итоги: пакет furrr

Главное:

  • furrr — прямая параллельная замена purrr: просто замените map на future_map
  • Сначала задайте обработчик с помощью plan(multisession, workers = n)
  • Варианты с заданным типом: future_map_dbl(), future_map_int(), future_map_chr()
  • Используйте future_map2() и future_pmap() для параллельного отображения нескольких входных наборов
  • Используйте furrr_options(seed = 42L) для воспроизводимого параллельного генератора случайных чисел
  • Интегрируйте progressr, чтобы отображать ход выполнения длительных параллельных задач
  • Используйте purrr::safely() внутри future_map() для устойчивого к ошибкам конвейера
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)

Часто задаваемые вопросы

Урок «furrr: параллельные операции purrr» бесплатный?

Да — полный текст урока «furrr: параллельные операции purrr» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс R Academy, подпишись на CoddyKit PRO. Курс R Academy содержит 4 уроков всего.

Чему я научусь в уроке «furrr: параллельные операции purrr»?

Заменяйте map() без дополнительных изменений на future_map() для мгновенной распараллелизации Ты практикуешь R Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать R Academy?

Предыдущий опыт не требуется. R Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 4.

Сколько времени занимает урок «furrr: параллельные операции purrr»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке R Academy?

Да. Каждый урок R Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Пакет parallel и detectCores()
  2. Фреймворк future
  3. furrr: параллельные операции purrr
  4. Отладка и балансировка нагрузки параллельного кода
← Назад к R Academy