R语言中的并行计算实现

并行计算有显性并行和隐式并行,

隐式并行:OpenBLAS,Intel MKL,NVIDIA cuBLAS,H2O(参考我的博客)等

显性并行:parallel(主打lapply应用)、foreach(主打for循环)、SupR、还有利用GPU的办法(gpuR)

介绍可以参考:
https://cosx.org/2016/09/r-and-parallel-computing
https://blog.csdn.net/sinat_26917383/article/details/52719232

parallel是比较基础的,不需要额外安装,直接加载就行,但是不是很稳定,关于parallel包的介绍可以参考:
https://blog.csdn.net/weixin_41929524/article/details/81707053
https://blog.csdn.net/faith_mo_blog/article/details/51646386

parallel包

paralle包的并行主要靠parLapply()、parSapply()、parApply()、parRapply()、parCapply()函数实现

	cl<- makeCluster(detectCores())  
    all.pcg <-  c("httr","jsonlite","magrittr")  
    worker.init <- function(p) sapply(p,library,character.only=TRUE) 
    clusterCall(cl, worker.init, all.pcg)    
    #此句用于将各个子进程的环境全部加载分配到各进程环境中
    mydata2 <- parLapply(
                cl,      #进程环境
                1:16,    #遍历参数
                GETPDF   #测试代码语句
               ) %>% rlist::list.rbind()
  stopCluster(cl)
cl <- makePSOCKcluster(使用核的数量)
clusterExport(cl,输入变量)
clusterEvalQ(cl, 输入包)
x <- parLapply(cl,循环次数,函数)

情形1:
myfun <- function(x){
   x^2
}
这个函数输入就只有x,则并行可以如下
cl <- makePSOCKcluster(2) #使用两个核
out <- parLapply(cl,1:10,myfun) # 这样1:10直接输入到函数myfun里面,作为x的值
情形2:
myfun <- function(x){
   x^2 + y + z
}
这时候函数里除了x还多出来y和z,先给y和z赋值
y <- 1
z <- 2
通过clusterExport把赋值的变量送进函数里面
cl <- makePSOCKcluster(2)
clusterExport(cl,c("y","z")) #传输外部变量
out <- parLapply(cl,1:10,myfun)
情形3:
myfun <- function(x){
   某函数(x^2 + y + z)
}
这个情形需要用到某函数,该函数包含在某包中。这时候需要通过clusterEvalQ将某包传入
cl <- makePSOCKcluster(2)
clusterExport(cl,c("y","z"))
clusterEvalQ(cl,c("某包"))
x <- parLapply(cl,1:10,myfun)
stopCluster(cl)
gc()

foreach包

实例

# foreach
library(foreach)
library(doParallel)

#分配核心数,这里获取了物理核心数
cores <- detectCores(logical=F)
cl <- makeCluster(cores)
registerDoParallel(cl, cores=cores)

system.time(
#.combine是数据的合并方法,如果缺省则返回一个list
  res <- foreach(i=1:20, .combine='rbind', .packages=c('需要的包')) %dopar%
    { 
    	#主要代码区域
      for (j in 1:100000) {
        s=i+j
      }
      
  return(s)
    }
)

#关闭并行
stopImplicitCluster()
stopCluster(cl)

参数介绍

  • %do%: 严格按照顺序执行任务(所以,也就非并行计算),%dopar%并行执行任务,%do%时候就像sapply或lapply,%dopar%就是并行启动器

  • .combine:运算之后结果的显示方式,default是list,“c”返回vector, cbind和rbind返回矩阵,并把数据整合起来.

  • .init:.combine函数的第一个变量

  • .final:返回最后结果

  • .inorder:TRUE则返回和原始输入相同顺序的结果(对结果的顺序要求严格的时候),FALSE返回没有顺序的结果(可以提高运算效率)。这个参数适合于设定对结果顺序没有需求的情况。

  • .muticombine:设定.combine函数的传递参数,default是FALSE表示其参数是2,TRUE可以设定多个参数

  • .maxcombine:设定.combine的最大参数

  • .errorhandling:如果循环中出现错误,对错误的处理方法

  • .packages:指定在%dopar%运算过程中依赖的package(%do%会忽略这个选项),用于并行一些机器学习算法。

  • .export:在编译函数的时候需要预先加载一些内容进去,类似parallel的clusterExport

用法举例:

x <- foreach(ii=1:100,.combine = "c",.export = c("semimetric.pca","quadratic"))%dopar% func(ii)

可参考:https://blog.csdn.net/u011178441/article/details/90742330

Snowfall包

另外一个比较稳定的并行包是snowfall依赖snow包和parallel包,可以参考:
https://blog.csdn.net/weixin_41929524/article/details/81742322

可以比较一下运行速度:

library(parallel) #用于并行计算
library(snowfall)  # 载入snowfall包,用于并行计算
system.time(
  for (i in 1:2250) {
    for (j in 1:100000) {
      s=i+j
    }
  }
)

myfun<-function(i){
  for (j in 1:100000) {
    s=i+j
  }
}
system.time(
  # 并行初始化
  sfInit(parallel = TRUE, cpus = detectCores(logical = F) - 1)
  # 进行lapply的并行操作
  s<-sfLapply(1:2250, myfun)
  # 结束并行,返还内存等资源
  sfStop()
)

snowfall的一般框架

library((parallel))
library(snowfall)

#初始化计算群
sfInit(parallel = TRUE, cpus = min(coresmax,detectCores(logical = T)))

sfExport(XXX)#为每个进程载入相关的函数,数据
sfLibrary(XXX)#为每个进程载入相关的包

parlresult<-sfLapply(1:100, fun)
 
sfStop() #结束并行

并行计算的嵌套

对于第一级并行化,必须使用分布式内存技术(如 snow 包中的 makeCluster()),而在第二级并行化中,必须使用共享内存技术(多核包,mclapply())。

你可能感兴趣的:(R,并行)