blocks|key|2730368|text|我使用doSNOW包在8核上运行了一段代码。我可以只复制并粘贴代码中引用这个包的部分。希望它能帮上忙！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2730369|++++#+use+multicore+libraries
++++++#+specify+number+of+cores+to+use
++++cores<-+8
++++++cluster+<-+makeCluster(cores,+type="SOCK")
++++++registerDoSNOW(cluster)

++++++#+check+how+many+cores+will+be+used
++++++ncores+<-+getDoParWorkers()
++++print(paste("Computing+algorithm+for+",+cores,+"+cores",+sep=""))
++++++fph+<-+rep(-100,12)

++++++#+start+multicore+cicle+on+12++subsets
++++++fph+<-+foreach(i=1:12,+.combine='c')+%25dopar%25+{
++++++++PhenoRiceRun(sub=i,+mpath=MODIS_LOCAL_DIR,+masklocaldir=MASK_LOCAL_DIR,+startYear=startYear,+tile=tile,+evismoothopt=FALSE)
++++++}


++stopCluster(cluster)+#+check+if+gives+error
++gc(verbose=FALSE)|code-block|syntax|javascript|2730370|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I used the package doSNOW to run a code on 8 cores.
I can just copy&amp;paste the part of the code that refers to this package.
Hope it helps!

<pre><code> # use multicore libraries
 # specify number of cores to use
 cores&lt;- 8
 cluster &lt;- makeCluster(cores, type="SOCK")
 registerDoSNOW(cluster)

 # check how many cores will be used
 ncores &lt;- getDoParWorkers()
 print(paste("Computing algorithm for ", cores, " cores", sep=""))
 fph &lt;- rep(-100,12)

 # start multicore cicle on 12 subsets
 fph &lt;- foreach(i=1:12, .combine='c') %dopar% {
 PhenoRiceRun(sub=i, mpath=MODIS_LOCAL_DIR, masklocaldir=MASK_LOCAL_DIR, startYear=startYear, tile=tile, evismoothopt=FALSE)
 }


 stopCluster(cluster) # check if gives error
 gc(verbose=FALSE)
</code></pre>

blocks|key|44691|text|这是一个粗略的解决方案，至少有一些希望。非常感谢Ben+Bolker指出，许多/大多数优化例程都允许用户指定的梯度函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|44692|具有更多参数值的测试问题可能会显示出更显着的改进，但在8核机器上，使用并行化梯度函数的运行时间大约是串行版本的70%25。注意，这里使用的粗糙梯度近似似乎会减慢收敛速度，因此会增加一些时间。|44693|##+Set+up+the+cluster
require("parallel");
.nlocalcores+=+NULL;+#+Default+to+"Cores+available+-+1"+if+NULL.
if(is.null(.nlocalcores))+{+.nlocalcores+=+detectCores()+-+1;+}
if(.nlocalcores+<+1)+{+print("Multiple+cores+unavailable!+See+code!!");+return()}
print(paste("Using+",.nlocalcores,"cores+for+parallelized+gradient+computation."))
.cl=makeCluster(.nlocalcores);
print(.cl)


#+Now+define+a+gradient+function:+both+in+serial+and+in+parallel
mygr+<-+function(.params,+...)+{
++dp+=+cbind(rep(0,length(.params)),diag(.params+*+1e-8));+#+TINY+finite+difference
++Fout+=+apply(dp,2,+function(x)+fn(.params+%2B+x,...));+++++#+Serial+
++return((Fout[-1]-Fout[1])/diag(dp[,-1]));++++++++++++++++#+finite+difference+
}

mypgr+<-+function(.params,+...)+{+#+Now+use+the+cluster+
++dp+=+cbind(rep(0,length(.params)),diag(.params+*+1e-8));+++
++Fout+=+parCapply(.cl,+dp,+function(x)+fn(.params+%2B+x,...));+#+Parallel+
++return((Fout[-1]-Fout[1])/diag(dp[,-1]));++++++++++++++++++#
}


##+Lets+try+it+out!
fr+<-+function(x,+slow=FALSE)+{+##+Rosenbrock+Banana+function+from+optim()+documentation.
++if(slow)+{+Sys.sleep(0.1);+}+++##+Modified+to+be+a+little+slow,+if+needed.
++x1+<-+x[1]
++x2+<-+x[2]
++100+*+(x2+-+x1+*+x1)%5E2+%2B+(1+-+x1)%5E2
}

grr+<-+function(x,+slow=FALSE)+{+##+Gradient+of+'fr'
++if(slow)+{+Sys.sleep(0.1);+}+++##+Modified+to+be+a+little+slow,+if+needed.
++x1+<-+x[1]
++x2+<-+x[2]
++c(-400+*+x1+*+(x2+-+x1+*+x1)+-+2+*+(1+-+x1),
++++200+*++++++(x2+-+x1+*+x1))
}

##+Make+sure+the+nodes+can+see+these+functions+&+other+objects+as+called+by+the+optimizer
fn+<-+fr;++#+A+bit+of+a+hack
clusterExport(cl,+"fn");

#+First,+test+our+gradient+approximation+function+mypgr
print(+mypgr(c(-1.2,1))+-+grr(c(-1.2,1)))

##+Some+test+calls,+following+the+examples+in+the+optim()+documentation
tic+=+Sys.time();
fit1+=+optim(c(-1.2,1),+fr,+slow=FALSE);++++++++++++++++++++++++++toc1=Sys.time()-tic
fit2+=+optim(c(-1.2,1),+fr,+gr=grr,+slow=FALSE,+method="BFGS");+++toc2=Sys.time()-tic-toc1
fit3+=+optim(c(-1.2,1),+fr,+gr=mygr,+slow=FALSE,+method="BFGS");++toc3=Sys.time()-tic-toc1-toc2
fit4+=+optim(c(-1.2,1),+fr,+gr=mypgr,+slow=FALSE,+method="BFGS");+toc4=Sys.time()-tic-toc1-toc2-toc3


##+Now+slow+it+down+a+bit
tic+=+Sys.time();
fit5+=+optim(c(-1.2,1),+fr,+slow=TRUE);+++++++++++++++++++++++++++toc5=Sys.time()-tic
fit6+=+optim(c(-1.2,1),+fr,+gr=grr,+slow=TRUE,+method="BFGS");++++toc6=Sys.time()-tic-toc5
fit7+=+optim(c(-1.2,1),+fr,+gr=mygr,+slow=TRUE,+method="BFGS");+++toc7=Sys.time()-tic-toc5-toc6
fit8+=+optim(c(-1.2,1),+fr,+gr=mypgr,+slow=TRUE,+method="BFGS");++toc8=Sys.time()-tic-toc5-toc6-toc7

print(cbind(fast=c(default=toc1,exact.gr=toc2,serial.gr=toc3,parallel.gr=toc4),
++++++++++++slow=c(toc5,toc6,toc7,toc8)))|code-block|syntax|javascript|44694|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is a rough solution, that at least has some promise. Big thanks to Ben Bolker for pointing out that many/most optimization routines allow user-specified gradient functions. 

A test problem with more parameter values might show more significant improvements, but on an 8 core machine the run using the parallelized gradient function takes about 70% as long as the serial version. Note the crude gradient approximation used here seems to slow convergence and thus adds some time to the process.

<pre><code>## Set up the cluster
require("parallel");
.nlocalcores = NULL; # Default to "Cores available - 1" if NULL.
if(is.null(.nlocalcores)) { .nlocalcores = detectCores() - 1; }
if(.nlocalcores &lt; 1) { print("Multiple cores unavailable! See code!!"); return()}
print(paste("Using ",.nlocalcores,"cores for parallelized gradient computation."))
.cl=makeCluster(.nlocalcores);
print(.cl)


# Now define a gradient function: both in serial and in parallel
mygr &lt;- function(.params, ...) {
 dp = cbind(rep(0,length(.params)),diag(.params * 1e-8)); # TINY finite difference
 Fout = apply(dp,2, function(x) fn(.params + x,...)); # Serial 
 return((Fout[-1]-Fout[1])/diag(dp[,-1])); # finite difference 
}

mypgr &lt;- function(.params, ...) { # Now use the cluster 
 dp = cbind(rep(0,length(.params)),diag(.params * 1e-8)); 
 Fout = parCapply(.cl, dp, function(x) fn(.params + x,...)); # Parallel 
 return((Fout[-1]-Fout[1])/diag(dp[,-1])); #
}


## Lets try it out!
fr &lt;- function(x, slow=FALSE) { ## Rosenbrock Banana function from optim() documentation.
 if(slow) { Sys.sleep(0.1); } ## Modified to be a little slow, if needed.
 x1 &lt;- x[1]
 x2 &lt;- x[2]
 100 * (x2 - x1 * x1)^2 + (1 - x1)^2
}

grr &lt;- function(x, slow=FALSE) { ## Gradient of 'fr'
 if(slow) { Sys.sleep(0.1); } ## Modified to be a little slow, if needed.
 x1 &lt;- x[1]
 x2 &lt;- x[2]
 c(-400 * x1 * (x2 - x1 * x1) - 2 * (1 - x1),
 200 * (x2 - x1 * x1))
}

## Make sure the nodes can see these functions &amp; other objects as called by the optimizer
fn &lt;- fr; # A bit of a hack
clusterExport(cl, "fn");

# First, test our gradient approximation function mypgr
print( mypgr(c(-1.2,1)) - grr(c(-1.2,1)))

## Some test calls, following the examples in the optim() documentation
tic = Sys.time();
fit1 = optim(c(-1.2,1), fr, slow=FALSE); toc1=Sys.time()-tic
fit2 = optim(c(-1.2,1), fr, gr=grr, slow=FALSE, method="BFGS"); toc2=Sys.time()-tic-toc1
fit3 = optim(c(-1.2,1), fr, gr=mygr, slow=FALSE, method="BFGS"); toc3=Sys.time()-tic-toc1-toc2
fit4 = optim(c(-1.2,1), fr, gr=mypgr, slow=FALSE, method="BFGS"); toc4=Sys.time()-tic-toc1-toc2-toc3


## Now slow it down a bit
tic = Sys.time();
fit5 = optim(c(-1.2,1), fr, slow=TRUE); toc5=Sys.time()-tic
fit6 = optim(c(-1.2,1), fr, gr=grr, slow=TRUE, method="BFGS"); toc6=Sys.time()-tic-toc5
fit7 = optim(c(-1.2,1), fr, gr=mygr, slow=TRUE, method="BFGS"); toc7=Sys.time()-tic-toc5-toc6
fit8 = optim(c(-1.2,1), fr, gr=mypgr, slow=TRUE, method="BFGS"); toc8=Sys.time()-tic-toc5-toc6-toc7

print(cbind(fast=c(default=toc1,exact.gr=toc2,serial.gr=toc3,parallel.gr=toc4),
 slow=c(toc5,toc6,toc7,toc8)))
</code></pre>

blocks|key|2730377|text|由于您还没有接受答案，因此这个想法可能会有所帮助:对于全局优化，DEoptim()包有一个用于并行优化的内置选项。好的是，它很容易使用，文档也写得很好。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2730378|c.f.http://www.jstatsoft.org/v40/i06/paper+(当前已关闭)|2730379|http://cran.r-project.org/web/packages/DEoptim/index.html|2730380|注意:差分Evolglobal优化器可能仍然会遇到局部优化。|2730381|entityMap|0|LINK|mutability|MUTABLE|url|http://www.jstatsoft.org/v40/i06/paper|1^0|W|9|0|4|12|0|0|0|1L|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|J|3|K|5|6|7|15|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]|T|$5|O|P|Q|E|$R|I]]]]

As you have not accepted an answer, this idea might help:
For global optimisation the package <code>DEoptim()</code> has an in-built option for parallel optimisation. Nice thing is, it's easy to use and documentation well written.

c.f. 
<a href="http://www.jstatsoft.org/v40/i06/paper" rel="nofollow">http://www.jstatsoft.org/v40/i06/paper</a> (currently down)

<a href="http://cran.r-project.org/web/packages/DEoptim/index.html" rel="nofollow">http://cran.r-project.org/web/packages/DEoptim/index.html</a>

Beware: Differential Evolglobal optimizers might still run into locals.

I'm running R on linux box that has 8 multicore processors, and have an optimization problem I'd like to speed up by parallelizing the optimization routine itself. Importantly, this problem involves (1) multiple parameters, and (2) inherently slow model runs. A fairly common problem! 

Anyone know of a parallelized optimizer for such occasions?

More specifically, solvers like <code>nlm()</code> run multiple model evaluations (two per parameter value) each time the algorithm takes a step in parameter space, so parallelizing that instance of multiple model runs would greatly speed things up in these situations when more than a few parameter values are being fit. 

It seems like code that makes use of the package <code>parallel</code> could be written in a way that the user would have to do minimal code modification to move from using <code>nlm()</code> or <code>optim()</code> to this parallelized optimization routine. That is, it seems one could rewrite these routines basically with no changes, except that the step of calling the model multiple times, as is common in gradient-based methods, would be done in parallel.

Ideally, something like nlmPara() would take code that looks like

<pre><code>fit &lt;- nlm(MyObjFunc, params0);
</code></pre>

and require only minor modifications, e.g., 

<pre><code>fit &lt;- nlmPara(MyObjFunc, params0, ncores=6);
</code></pre>

Thoughts/suggestions? 

PS: I've taken steps to speed up those model runs, but they're slow for a variety of reasons (i.e. I don't need advice on speeding up the model runs! ;-) ).

Parallelized optimization in R

我在有8个多核处理器的linux机器上运行R，并且有一个优化问题，我想通过并行化优化例程本身来加快速度。重要的是，这个问题涉及(1)多个参数，(2)模型运行固有的缓慢。一个相当常见的问题！有没有人知道针对这种情况的并行优化器？更具体地说，每次算法在参数空间中执行一步时，像nlm()这样的求解器都会运行多个模型评估(每个...

问R语言中的并行优化
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问R语言中的并行优化EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问R语言中的并行优化
EN