R 优化递归应用调用，以便在同一数据集上应用不同的函数

我在矩阵行的不同子集上应用了几个函数。以下是一些示例数据：

set.seed(1)
## The data is a simple matrix
dataset <- matrix(sample(1:25, 25), 5, 5)

#     [,1] [,2] [,3] [,4] [,5]
#[1,]    7   18    4   19    6
#[2,]    9   22    3   25   16
#[3,]   14   12   24    8    2
#[4,]   20   11   21   23   15
#[5,]    5    1   13   10   17

## The subsets is a list contain a list of matrices where the columns represent the rows of data
subsets <- list(list(matrix(seq(1:5), ncol = 1), matrix(c(c(1:3), c(2:4), c(3:5)), ncol = 3)))
#[[1]]
#[[1]][[1]]
#     [,1]
#[1,]    1
#[2,]    2
#[3,]    3
#[4,]    4
#[5,]    5
#
#[[1]][[2]]
#     [,1] [,2] [,3]
#[1,]    1    2    3
#[2,]    2    3    4
#[3,]    3    4    5

## The functions to apply successively (the first one outputs a matrix, the second a single numeric)
function_list <- list(var, sd)

或者更具体地说：

## The first function
(subset_out <- function_list[[1]](dataset[subsets[[1]][[1]][,1], ]))
#      [,1]   [,2]   [,3]   [,4]   [,5]
#[1,] 36.50   3.25  40.25  11.25  -4.25
#[2,]  3.25  63.70 -40.50  40.75 -12.70
#[3,] 40.25 -40.50  91.50 -37.25 -18.00
#[4,] 11.25  40.75 -37.25  58.50  23.25
#[5,] -4.25 -12.70 -18.00  23.25  45.70

## The second function
function_list[[2]](subset_out)
#[1] 35.6238

在我的例子中，在

子集

列表中有更多的元素，在

函数_列表

中有更多的函数，在

lapply.to.one.subset

函数中有更多的条件语句（为了简化而删除）。这使得大型数据集的速度相当慢。

---

关于如何更快地获得相同的结果有什么想法吗？

通过

parallel:parlappy

进行并行化，就像这样

library(parallel)
cl <- makeCluster(detectCores()-1)
clusterExport(
    cl,
    c("dataset", "subsets", "function_list", "lapply.to.one.subset")
)

或内部嵌套列表

# parallelize inner loop - subset[[1]][1-N]
lapply(
    subsets,
    function(i) {
        parLapply(
            cl,
            i,
            function(j) { lapply.to.one.subset(j, function_list, dataset) }
        )
    }
)

关闭并行集群

stopCluster(cl)
rm(cl)

---

我没有检查速度，因为它将比并行解决方案慢，但下面的方法似乎确实有效

library(dplyr)
lapply(subsets, lapply, function(lst) apply(lst, 2, 
                           function(Y) dataset[Y, , drop = FALSE] %>%
                              function_list[[1]]() %>% 
                                   function_list[[2]]()))

---

建议：并行化。这似乎是并行化的理想选择。问：相同的

子集

值集是否多次出现？对所有可能的子集进行“预计算”可能有意义。只需通过

snow:：parlappy

？A:我怀疑。矩阵通常很大，子集实际上是矩阵行的引导（应该是随机的）。无关：在编辑队列中，我遇到了一个问题，您在分类中投票了。你在那里做了错误的选择。请：仔细研究分类帮助，避免将不属于那里的项目放入编辑队列。请理解，您的投票有后果！我具体是说。这是（几乎）零努力的家庭作业转储。只有OP可以编辑它来改进它，没有其他人！如果您有进一步的问题或反馈，请随时给我留言。请注意，在进行基准测试时，请确保使用与实际数据接近的数据。由于初始化并行工作程序需要时间，而且数据集很小，所以在

parlappy

级别进行基准测试（忽略集群初始化）时，并行备选方案的速度可能会很慢，在这个简单的示例中已经快了六倍。非常感谢你！

# parallelize inner loop - subset[[1]][1-N]
lapply(
    subsets,
    function(i) {
        parLapply(
            cl,
            i,
            function(j) { lapply.to.one.subset(j, function_list, dataset) }
        )
    }
)

stopCluster(cl)
rm(cl)

library(dplyr)
lapply(subsets, lapply, function(lst) apply(lst, 2, 
                           function(Y) dataset[Y, , drop = FALSE] %>%
                              function_list[[1]]() %>% 
                                   function_list[[2]]()))