R语言并行化基础与提高
本文将介绍R中的并行计算，并给出了一些常见的陷进以及避免它们的小技巧。
使用并行计算的原因就是因为程序运行时间太长。大部分程序都是可以并行化的，它们大部分都是。这里介绍几种可以并行化的方法：
Bootstrapping 交叉验证(Cross-validation) (Multivariate Imputation by Chained Equations ,MICE)相关介绍: 拟合多元回归方程
学习lapply是关键
没有早点学习lapply是我的遗憾之一。这函数即优美又简单：它只需要一个参数（一个vector或list），和一个以该参数为输入的函数，最后返回一个列表。
& lapply(1:3, function(x) c(x, x^2, x^3))
[1] 3 9 27
你还可以添加额外的参数：
& lapply(1:3/3, round, digits=3)
当每个元素都是独立地计算时，这个任务就是 的。当你学习完使用lapply之后，你会发现并行化你的代码就像喝水一样简单。
parallel包
使用 parallel包，首先要初始化一个集群，这个集群的数量最好是你CPU核数-1。如果一台8核的电脑建立了数量为8的集群，那你的CPU就干不了其他事情了。所以可以这样启动一个集群：
library(parallel)
# Calculate the number of cores
no_cores &- detectCores() - 1
# Initiate cluster
cl &- makeCluster(no_cores)
现在只需要使用并行化版本的lapply,parLapply就可以了
parLapply(cl, 2:4,
function(exponent)
2^exponent)
当我们结束后，要记得关闭集群，否则你电脑的内存会始终被R占用
stopCluster(cl)
变量作用域
在Mac/中你可以使用 makeCluster(no_core, type=&FORK&)这一选项从而当你并行运行的时候可以包含所有环境变量。
在Windows中由于使用的是Parallel Socket Cluster (PSOCK)，所以每个集群只会加载base包，所以你运行时要指定加载特定的包或变量：
cl&-makeCluster(no_cores)
clusterExport(cl, &base&)
parLapply(cl,
function(exponent)
base^exponent)
stopCluster(cl)
注意到你需要用clusterExport(cl, &base&)把base这一个变量加载到集群当中。如果你在函数中使用了一些其他的包就要使用clusterEvalQ加载进去，比如说，使用rms包，那么就用clusterEvalQ(cl, library(rms))。要注意的是，在clusterExport 加载某些变量后，这些变量的任何变化都会被忽略：
cl&-makeCluster(no_cores)
clusterExport(cl, &base&)
parLapply(cl,
function(exponent)
base^exponent)
stopCluster(cl)
使用parSapply
如果你想程序返回一个向量或者矩阵。而不是一个列表，那么就应该使用sapply,他同样也有并行版本parSapply:
& parSapply(cl, 2:4,
function(exponent)
base^exponent)
输出矩阵并显示行名和列名（因此才需要使用as.character）
& parSapply(cl, as.character(2:4),
function(exponent){
x &- as.numeric(exponent)
c(base = base^x, self = x^x)
self 4 27 256
设计foreach包的思想可能想要创建一个lapply和for循环的标准，初始化的过程有些不同，你需要register注册集群:
library(foreach)
library(doParallel)
cl&-makeCluster(no_cores)
registerDoParallel(cl)
要记得最后要结束集群（不是用stopCluster()）：
stopImplicitCluster()
foreach函数可以使用参数.combine控制你汇总结果的方法：
& foreach(exponent = 2:4,
.combine = c)
base^exponent
& foreach(exponent = 2:4,
.combine = rbind)
base^exponent
foreach(exponent = 2:4,
.combine = list,
.multicombine = TRUE)
base^exponent
注意到最后list的combine方法是默认的。在这个例子中用到一个.multicombine参数，他可以帮助你避免嵌套列表。比如说list(list(result.1, result.2), result.3) :
& foreach(exponent = 2:4,
.combine = list)
base^exponent
[[1]][[1]]
[[1]][[2]]
变量作用域
在foreach中，变量作用域有些不同，它会自动加载本地的环境到函数中：
& base &- 2
& cl&-makeCluster(2)
& registerDoParallel(cl)
& foreach(exponent = 2:4,
.combine = c)
base^exponent
stopCluster(cl)
但是，对于父环境的变量则不会加载，以下这个例子就会抛出错误：
test &- function (exponent) {
foreach(exponent = 2:4,
.combine = c)
base^exponent
Error in base^exponent : task 1 failed - &object 'base' not found&
为解决这个问题你可以使用.export这个参数而不需要使用clusterExport。注意的是，他可以加载最终版本的变量，在函数运行前，变量都是可以改变的：
cl&-makeCluster(2)
registerDoParallel(cl)
test &- function (exponent) {
foreach(exponent = 2:4,
.combine = c,
.export = &base&)
base^exponent
stopCluster(cl)
相似的你可以使用.packages参数来加载包,比如说：.packages = c(&rms&, &mice&)
使用Fork还是sock?
我在windows上做了很多分析，也习惯了使用PSOCK。对于使用其他系统的人要意识到这两个的区别：
FORK:&to divide in branches and go separate ways&
系统：Unix/Mac (not Windows)
环境: 所有 PSOCK:并行socket集群
系统: All (including Windows)
如果你不打算使用windows的话，建议你尝试FORK模式，它可以实现内存共享，节省你的内存。
library(pryr) # Used for memory analyses
cl&-makeCluster(no_cores)
clusterExport(cl, &a&)
clusterEvalQ(cl, library(pryr))
parSapply(cl, X = 1:10, function(x) {address(a)}) == address(a)
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
cl&-makeCluster(no_cores, type=&FORK&)
parSapply(cl, X = 1:10, function(x) address(a)) == address(a)
[1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
你不需要花费太多时间去配置你的环境，有趣的是，你不需要担心变量冲突:
parSapply(cl, X = 1:10, function(x) {b &- b + 1; b})
# [1] 1 1 1 1 1 1 1 1 1 1
parSapply(cl, X = 1:10, function(x) {b &&- b + 1; b})
# [1] 1 2 3 4 5 1 2 3 4 5
当你在并行环境中工作是，debug是很困难的，你不能使用browser/cat/print等参数来发现你的问题。
tryCatch-list方法
使用stop()函数这不是一个好方法，因为当你收到一个错误信息时，很可能这个错误信息你在很久之前写的，都快忘掉了，但是当你的程序跑了1，2天后，突然弹出这个错误，就只因为这一个错误，你的程序终止了，并把你之前的做的计算全部扔掉了，这是很讨厌的。为此，你可以尝试使用tryCatch去捕捉那些错误，从而使得出现错误后程序还能继续执行:
foreach(x=list(1, 2, &a&))
tryCatch({
c(1/x, x, 2^x)
}, error = function(e) return(paste0(&The variable '&, x, &'&,
& caused the error: '&, e, &'&)))
[1] 0.5 2.0 4.0
[1] &The variable 'a' caused the error: 'Error in 1/x: non-numeric argument to binary operator\n'&
这也正是我喜欢list的原因，它可以方便的将所有相关的数据输出，而不是只输出一个错误信息。这里有一个使用rbind在lapply进行conbine的例子：
`out &- lapply(1:3, function(x) c(x, 2^x, x^x))
do.call(rbind, out)
[,1] [,2] [,3]
创建一个文件输出
当我们无法在控制台观测每个工作时，我们可以设置一个共享文件，让结果输出到文件当中，这是一个想当舒服的解决方案：
cl&-makeCluster(no_cores, outfile = &debug.txt&)
registerDoParallel(cl)
foreach(x=list(1, 2, &a&))
stopCluster(cl)
starting worker pid=7392 on localhost:11411 at 00:11:21.077
starting worker pid=7276 on localhost:11411 at 00:11:21.319
starting worker pid=7576 on localhost:11411 at 00:11:21.762
创建一个结点专用文件
一个或许更为有用的选择是创建一个结点专用的文件，如果你的数据集存在一些问题的时候，可以方便观测：
cl&-makeCluster(no_cores, outfile = &debug.txt&)
registerDoParallel(cl)
foreach(x=list(1, 2, &a&))
cat(dput(x), file = paste0(&debug_file_&, x, &.txt&))
stopCluster(cl)
partools包
partools这个包有一个函数或许值得一看（使用非windows系统值得一看），他允许你联合多个终端给每个进程进行debug。
当做一个大型计算时，我强烈推荐使用一些缓存。这或许有多个原因你想要结束计算，但是要遗憾地浪费了计算的宝贵的时间。这里有一个包可以做缓存，，但是我发现自己写个函数来实现更加简单。你只需要嵌入digest包就可以。digest()函数是一个散列函数，把一个R对象输入进去可以输出一个md5值或sha1等从而得到一个唯一的key值，当你key匹配到你保存的cache中的key时，你就可以继续你的计算了，而不需要将算法重新运行，以下是一个使用例子：
cacheParallel &- function(){
vars &- 1:2
tmp &- clusterEvalQ(cl,
library(digest))
parSapply(cl, vars, function(var){
fn &- function(a) a^2
dg &- digest(list(fn, var))
cache_fn &-
sprintf(&Cache_%s.Rdata&,
if (file.exists(cache_fn)){
load(cache_fn)
var &- fn(var);
Sys.sleep(5)
save(var, file = cache_fn)
return(var)
这个例子很显然在第二次运行的时候并没有启动Sys.sleep，而是检测到了你的cache文件，加载了上一次计算后的cache，你就不必再计算Sys.sleep了，因为在上一次已经计算过了。
system.time(out &- cacheParallel())
# user system elapsed
# 0.003 0.001 5.079
system.time(out &- cacheParallel())
# user system elapsed
# 0.001 0.004 0.046
# To clean up the files just do:
file.remove(list.files(pattern = &Cache.+\.Rdata&))
需要注意的是，无论parLapply还是foreach都是一个包装(wrapper)的函数。这意味着他们不是直接执行并行计算的代码，而是依赖于其他函数实现的。在parLapply中的定义如下：
parLapply &- function (cl = NULL, X, fun, ...)
cl &- defaultCluster(cl)
do.call(c, clusterApply(cl, x = splitList(X, length(cl)),
fun = lapply, fun, ...), quote = TRUE)
注意到splitList(X, length(cl)) ，他会将任务分割成多个部分，然后将他们发送到不同的集群中。如果你有很多cache或者存在一个任务比其他worker中的任务都大，那么在这个任务结束之前，其他提前结束的worker都会处于空闲状态。为了避免这一情况，你需要将你的任务尽量平均分配给每个worker。举个例子，你要计算优化神经网络的参数，这一过程你可以并行地以不同参数来训练神经网络，你应该将如下代码：
# From the nnet example
parLapply(cl, c(10, 20, 30, 40, 50), function(neurons)
nnet(ir[samp,], targets[samp,],
size = neurons))
# From the nnet example
parLapply(cl, c(10, 50, 30, 40, 20), function(neurons)
nnet(ir[samp,], targets[samp,],
size = neurons))
在大数据的情况下使用并行计算会很快的出现问题。因为使用并行计算会极大的消耗内存，你必须要注意不要让你的R运行内存到达内存的上限，否则这将会导致崩溃或非常缓慢。使用Forks是一个控制内存上限的一个重要方法。Fork是通过内存共享来实现，而不需要额外的内存空间，这对性能的影响是很显著的(我的系统时16G内存，8核心)：
& rm(list=ls())
& library(pryr)
& library(magrittr)
& a &- matrix(1, ncol=10^4*2, nrow=10^4)
& object_size(a)
& system.time(mean(a))
system elapsed
& system.time(mean(a + 1))
system elapsed
& library(parallel)
& cl &- makeCluster(4, type = &PSOCK&)
& system.time(clusterExport(cl, &a&))
system elapsed
& system.time(parSapply(cl, 1:8,
function(x) mean(a + 1)))
system elapsed
& stopCluster(cl); gc();
& cl &- makeCluster(4, type = &FORK&)
& system.time(parSapply(cl, 1:8,
function(x) mean(a + 1)))
system elapsed
& stopCluster(cl)
FORKs可以让你并行化从而不用崩溃：
& cl &- makeCluster(8, type = &PSOCK&)
& system.time(clusterExport(cl, &a&))
system elapsed
& system.time(parSapply(cl, 1:8, function(x) mean(a + 1)))
Error in checkForRemoteErrors(val) :
8 n first error: cannot allocate vector of size 1.5 Gb
Timing stopped at: 0.004 0 0.389
& stopCluster(cl)
& cl &- makeCluster(8, type = &FORK&)
& system.time(parSapply(cl, 1:8, function(x) mean(a + 1)))
system elapsed
& stopCluster(cl)
当然，他并不能让你完全解放，如你所见，当我们创建一个中间变量时也是需要消耗内存的：
& a &- matrix(1, ncol=10^4*2.1, nrow=10^4)
& cl &- makeCluster(8, type = &FORK&)
& parSapply(cl, 1:8, function(x) {
b &- a + 1
Error in unserialize(node$con) : error reading from connection
尽量使用rm()避免无用的变量 尽量使用gc()释放内存。即使这在R中是自动执行的，但是当它没有及时执行，在一个并行计算的情况下，如果没有及时释放内存，那么它将不会将内存返回给操作系统，从而影响了其他worker的执行。 通常并行化在大规模运算下很有用，但是，考虑到R中的并行化存在内存的初始化成本，所以考虑到内存的情况下，显然小规模的并行化可能会更有用。 有时候在并行计算时，不断做缓存，当达到上限时，换回串行计算。 你也可以手动的控制每个核所使用的内存数量，一个简单的方法就是：memory.limit()/memory.size() = max cores
一个常用的CPU核数检测函数：
max(1, detectCores() - 1)
永远不要使用set.seed()，使用clusterSetRNGStream()来代替设置种子，如果你想重现结果。 如果你有Nvidia 显卡，你可以尝试使用gputools 包进行GPU加速（警告：安装可能会很困难） 当使用时记得使用ibind()来合并项。3.6 使用R包中的函数
本文所属图书&>&
O&Reilly Media通过图书、杂志、在线服务、调查研究和会议等方式传播创新知识。自1978年开始，O&Reilly一直都是前沿发展的见证者和推动者。超级极客们正在开创着未来，而我们关注真正重要的技术趋势...&&
计算机中已安装的R包可以是R的标准包，或者是通过网络下载的包。当你希望使用某个R包中的函数时，R却不能找到该函数。
使用函数library或者函数require把需要的R包载入R中：
& library(packagename)
R自带一些标准包。但在启动R时，并非所有的R包都会自动载入。同样，你可以通过CRAN网站下载和安装许多有用的R包，但是在启动R时这些包不会自动载入。例如，R包MASS是R的一个标准包，你在调用该包中的lda函数时，可能会出现以下信息：
Error: could not find function &lda&
R显示无法在当前载入内存中的R包中找到lda函数。
当使用library函数或require函数时，R将该对应的包载入内存中，此时载入的包中的内容便是可以使用的：
& lda(f ~ x + y)
Error: could not find function &lda&
& library(MASS) # Load the MASS library into memory
& lda(f ~ x + y)# Now R can find the function
lda(f ~ x + y)
Prior probabilities of groups:
在调用library函数前，R无法识别函数名。用library函数载入R包后，该R包中的内容便可调用，此时可正常使用lda函数。
注意，在library函数中的R包名称不需要用双引号括起来。
require函数与library函数几乎类似，但require函数有两个特性便于脚本程序的书写。一是它在成功载入R包后，返回TRUE；否则，返回FALSE。二是在载入失败时，它仅仅给出一条警告信息；而library载入失败时，会生成错误信息。
两个函数都有一个共同特性，即它们不会重复载入已载入的R包。因此可以两次重复调用同一个R包。这对书写脚本很有帮助，既然已经载入的R包不会再次载入，脚本就可以放心载入所需要的R包，而不用担心它是否已载入。
detach函数会卸载当前已载入的R包：
& detach(package:MASS)
注意，R包名称必须符合规范，即以package:MASS 的形式出现。
卸载R包的一个原因是，该包中的函数名与搜索列表中该包后面的包的某函数重名。发生这种情况时，次序在前的函数（搜索列表靠前的包中的函数）会遮盖次序在后的函数（搜索列表靠后的包中的函数）。R在找到高次序的函数后便会停止搜索。因此，你无法看到低次序的函数，所以需要卸载高次序的R包来使用低次序的包中的函数。
参见方法3.5。
您对本文章有什么意见或着疑问吗？请到您的关注和建议是我们前行的参考和动力&&
您的浏览器不支持嵌入式框架，或者当前配置为不显示嵌入式框架。如何在终端里编译R？要求不能通过提示符打开软件感谢大家关注我的问题，具体描述如下：我知道在linux下，甚至只要输一个R就可以进去R，但是这其实是打开软件。请问有没有可能在终端下，不通过运行软件，来写
如何在终端里编译R？要求不能通过提示符打开软件
感谢大家关注我的问题，具体描述如下：
我知道在linux下，甚至只要输一个R就可以进去R，但是这其实是打开软件。
请问有没有可能在终端下，不通过运行软件，来写R呢？
vi一个文件这种的回答，也不是我要的。
如果可以有其他办法写的话，请问有没有办法通过输入命令来保存workspace呢？同样是不通过任何软件的情况，要通过命令提示符这种。
环境是windows或者linux都行。
如果你觉得真没有不通过软件的方法，也请告诉我你觉得“真没有”
我不懂这个，但是我个人觉得，就你这个问题应该说简单，也应该说难，简单就因为你是软件的开发者，难就因为你不是软件的开发者！
【云栖快讯】首届阿里巴巴中间件技术峰会，揭秘阿里10年分布式技术沉淀！阿里高可用体系核心缔造者、全链路压测创始人，DRDS与TDDL负责人等大咖出场，干货分享，不可错过！&&
为您提供简单高效、处理能力可弹性伸缩的计算服务，帮助您快速构建更稳定、安全的应用，提升运维效率，降低 IT 成本...
RDS是一种稳定可靠、可弹性伸缩的在线数据库服务。支持MySQL、SQL Server、PostgreSQL、高...}