Question

我对R有点新意，请原谅这里的新手......

我在R中编写代码，在脚本中加载1000个已保存的数据帧（文件），该脚本对每个文件中的数据运行一个函数，并将结果值存储在向量中。我必须一遍又一遍地使用不同的功能，这需要很长时间。

我正在尝试使用多核mclapply来并行化这个过程，但不幸的是，2到8个核心的任何东西似乎都需要比在一个核心上运行它更长的时间。

由于磁盘I / O限制，这个想法是否根本不健全？多核，甚至是R，不是正确的解决方案吗？打开像Python这样的文件，然后在内容上运行R函数会比R更好吗？

对此有任何指导或想法将不胜感激 -

为了清晰起见，添加了代码：

    library(multicore)

    project.path = "/pathtodata/"

    #This function reads the file location and name, then loads it and runs a simple statistic
    running_station_stats <- function(nsrdb_stations)
    {
      varname <- "column_name"
      load(file = paste(project.path, "data/",data_set_list[1], sep = ""))
      tempobj <- as.data.frame(coredata(get(data_set_list[2])))
      mean(tempobj[[varname]],na.rm=TRUE)
    }



    options(cores = 2)

    #This file has a list of R data files data_set_list[1] and the names they were created with data_set_list[2]
    load(file = paste(project.path, "data/data_set_list.RData", sep = ""))

    thelist <- list()

    thelist[[1]] <- data_set_list[1:50,]

    thelist[[2]] <- data_set_list[51:100,]

    thelist[[3]] <- data_set_list[101:150,]

    thelist[[4]] <- data_set_list[151:200,]


    #All three of these are about the same speed to run regardless of the num of cores
    system.time(
    {
      apply(nsrdb_stations[which(nsrdb_stations$org_stations==TRUE),][1:200,],1,running_station_stats)
    })

    system.time(
      lapply(thelist, apply, 1, running_station_stats)
     )

    system.time(
      mclapply(thelist, apply, 1, running_station_stats)
    )

Answer 1

Python和R都会尝试使用多个内核来处理数字运算。它对于读取大量文件没有帮助。多线程也不是答案（重新python GIL）。

一些可能的解决方案（其中没有一个简单）是：

使用扭曲的东西，你可以（某些）你的文件io异步。硬编程，它不是非常友好。
使用Celery或其他一些本土主从解决方案。很多人都会采取行动。
使用Ipython（w / ipcluster）生成python将为您重组的多个进程（最佳解决方案IMO）

Answer 2

我会首先尝试在Python中进行良好的老式多处理。上面的选项都是可能的。以下是使用多处理模块执行批处理作业的示例。


import multiprocessing as mp
import time

def worker(x):
    time.sleep(0.2)
    print "x= %s, x squared = %s" % (x, x*x)
    return x*x

def apply_async():
    pool = mp.Pool()
    for i in range(100):
        pool.apply_async(worker, args = (i, ))
    pool.close()
    pool.join()

if name == 'main':
    apply_async()

，输出如下：


x= 0, x squared = 0
x= 1, x squared = 1
x= 2, x squared = 4
x= 3, x squared = 9
x= 4, x squared = 16
x= 6, x squared = 36
x= 5, x squared = 25
x= 7, x squared = 49
x= 8, x squared = 64
x= 10, x squared = 100
x= 11, x squared = 121
x= 9, x squared = 81
x= 12, x squared = 144

正如您所看到的，数字不是按顺序排列的，因为它们是异步执行的。只需更改上面的worker（）函数进行处理，并可能使用mp.Pool（10）或mp.Pool（15）或其他任何内容更改并发进程的数量。这样的事情应该是相对紧张的前进。。

在R中加载和处理1000个文件

2 个答案: