0

我do.call在并行化环境中嵌套了多个级别（每个级别本身都使用参数中命名的函数，而不是硬编码）%dopar%，并且最里面的函数无法找到来自外部环境的函数。我知道.export参数 onforeach并正在使用它，但不知何故，命名函数并没有沿着整个链传播。

我将问题简化为以下测试用例，它确实存在此问题：

library(doParallel)
cl <- makeCluster(4)
registerDoParallel(cl)

simple.func <- function(a, b) {
  return(a+b)
}

inner.func <- function(a, b) {
  return(do.call(simple.func, list(a=a, b=b)))
}

outer.func <- function(a, b, my.func=inner.func) {
  return(do.call(my.func, list(a=a, b=b)))
}

main.func <- function(my.list=1:10, my.func=outer.func,
                      my.args=list(my.func=inner.func)) {
  results <- foreach(i=my.list, .multicombine=TRUE, .inorder=FALSE,
                     .export="simple.func") %dopar% {
    return(do.call(my.func, c(list(a=i, b=i+1), my.args)))
  }
  return(results)
}

我没有给出正确答案（带有一些数字的列表），而是得到：

Error in { : task 1 failed - "object 'simple.func' not found"

添加if (!exists("simple.func")) stop("Could not find parse.data in scope main.func")到每个函数的开头（根据需要更改范围的名称）表明它是inner.func看不到的simple.func——即使outer.func 确实看到了。

我还测试了上面的几个变体，或者main.func硬outer.func编码下一级函数，而不是从参数中使用它。这两种变体都有效（例如，给出预期的结果），但对于现实世界的情况，我想保留将子函数作为参数的普遍性。

# Variation number one: Replace main.func() with this version
main.func <- function(my.list=1:10, my.func=outer.func,
                      my.args=list(my.func=inner.func)) {
  results <- foreach(i=my.list, .multicombine=TRUE, .inorder=FALSE,
                     .export=c("simple.func", "outer.func", "inner.func")) %dopar% {
    return(do.call(outer.func, list(a=i, b=i+1, my.func=inner.func)))
  }
  return(results)
}

# Variation number two: Replace outer.func() and main.func() with these versions
outer.func <- function(a, b, my.func=inner.func) {
  return(do.call(inner.func, list(a=a, b=b)))
}

main.func <- function(my.list=1:10, my.func=outer.func,
                      my.args=list(my.func=inner.func)) {
  results <- foreach(i=my.list, .multicombine=TRUE, .inorder=FALSE,
                     .export=c("simple.func", "inner.func")) %dopar% {
    return(do.call(my.func, c(list(a=i, b=i+1), my.args)))
  }
  return(results)
}

我也可以simple.func手动传递链，将它作为一个额外的参数包含在内，但这看起来非常混乱，为什么在simple.func应该作为环境的一部分传递时有必要呢？

# Variation number three: Replace inner.func(), outer.func(), and main.func()
# with these versions
inner.func <- function(a, b, innermost.func=simple.func) {
  return(do.call(innermost.func, list(a=a, b=b)))
}

outer.func <- function(a, b, my.func=inner.func,
                       innermost.args=list(innermost.func=simple.func)) {
  return(do.call(my.func, c(list(a=a, b=b), innermost.args)))
}

main.func <- function(my.list=1:10, my.func=outer.func,
                      my.args=list(my.func=inner.func,
                      innermost.args=list(innermost.func=simple.func))) {
  results <- foreach(i=my.list, .multicombine=TRUE, .inorder=FALSE,
                     .export="simple.func") %dopar% {
    return(do.call(my.func, c(list(a=i, b=i+1), my.args)))
  }
  return(results)
}

有没有人有关于不那么笨拙的解决方案的想法，或者这个问题的根本原因？

4

1 回答 1

0

对于doParallel，以及任何其他doNnn不分叉当前进程的适配器，我认为以下hack可以做到：

main.func <- function(my.list = 1:10, my.func=outer.func,
                      my.args = list(my.func=inner.func)) {
  results <- foreach(i = my.list, .multicombine = TRUE, .inorder = FALSE,
                     .export="simple.func") %dopar% {
    environment(my.args$my.func) <- environment()  ## <= HACK
    return(do.call(my.func, args = c(list(a=i, b=i+1), my.args)))
  }
  return(results)
}

或者，您可以使用doFuture适配器（我是作者）。然后您不必担心全局对象，因为它们会自动识别和导出。也就是说，不需要指定.export（或.packages）。例如，在您的情况下，以下工作：

library("doFuture")
registerDoFuture()
plan(multisession, workers = 4)

main.func <- function(my.list = 1:10, my.func = outer.func,
                      my.args = list(my.func = inner.func)) {
  foreach(i = my.list, .multicombine = TRUE, .inorder = FALSE) %dopar% {
    do.call(my.func, args = c(list(a = i, b = i+1), my.args))
  }
}

res <- main.func(1:3)
str(res)
## List of 10
##  $ : num 3
##  $ : num 5
##  $ : num 7

您也可以一直跳过foreach()并执行以下操作：

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

main <- function(my.list = 1:10, my.func = outer.func,
                 my.args = list(my.func = inner.func)) {
  future_lapply(my.list, FUN = function(i) {
    do.call(my.func, args = c(list(a = i, b = i+1), my.args))
  })
}

PS。有很多不同的plan()后端可供选择。唯一没有涉及的是如果您使用doRedis.

于 2017-03-17T04:27:53.867 回答