使用Python编写科学代码时遇到以下问题:

• 通常,您会迭代地编写代码,作为执行某些计算的脚本.
• 最后,它有效; 现在您希望使用多个输入和参数运行它,并发现它需要花费太多时间.
• 回想一下,你为一个优秀的学术机构工作,可以使用大约100台CPU机器,你很困惑如何获得这种能力.首先准备小shell脚本,使用不同的输入运行原始代码并手动运行它们.

作为一名工程师,我知道所有关于正确的架构(工作项排队,工作线程或进程,工作结果排队并写入持久存储); 但我不想自己实施.最棘手的问题是由于代码更改或临时系统问题(例如内存不足)而需要重新运行.

我想找到一些框架,我将提供所需的输入(例如,每个运行一行文件)然后我将能够启动一些框架提供的代理的多个实例,它将运行我的代码.如果运行时出现问题(例如临时系统问题或由于bug导致的抛出异常),我将能够删除结果并运行更多代理.如果我占用太多资源,我将能够在不担心数据不一致的情况下杀死一些代理,而其他代理会在找到时间时获取工作项.

现有解决方案吗？有人希望分享他的代码吗？谢谢!

有人可以提供一个使用最新软件包的例子,如何使用R在并行编程中有效地使用GPU 吗？很高兴知道理论上可行的是什么,但谁有一个实际的例子呢？

我正在处理大约150万次观测的数据集.我发现在我的数据的一小部分上运行一个回归树(我正在使用包中的mob()*函数party)花费的时间非常长(我不能运行超过50k的一个子集).

我可以想到两个主要问题是减慢计算速度

1. 使用整个数据集在每个步骤计算拆分.我会对基于数据的随机子集选择变量在每个节点上拆分的结果感到满意,只要它继续补充树中每个子节点处的样本大小即可.
2. 该操作未并行化.在我看来,只要树首次拆分,它就应该能够使用两个处理器,这样当我的机器中的每个处理器有16个分裂时,它们就会被使用.在实践中,似乎只有一个被使用.

有没有人对替代树实现提出建议,这些实现对大型数据集更有效,或者我可以改变以使计算更快的事情**？

*我正在使用mob(),因为我想在每个节点的底部进行线性回归,根据它们对治疗变量的响应来分割数据.

**似乎减慢计算量的一件事是我有一个16种类型的因子变量.计算要拆分的变量的哪个子集似乎比其他拆分需要更长的时间(因为有很多不同的方法可以对它们进行分组).这个变量是我们认为重要的变量,因此我不愿完全放弃它.是否有推荐的方法在将类型放入树模型之前将其分组为较少数量的值？

I would like to parallelize a loop like

td        <- data.frame(cbind(c(rep(1,4),2,rep(1,5)),rep(1:10,2)))
names(td) <- c("val","id")

res <- rep(NA,NROW(td))
for(i in levels(interaction(td$id))){
res[td$id==i] <- mean(td$val[td$id!=i])
}  

with the help of foreach() of the library(doParallel) in order to speed up computations. Unfortunately foreach doesn't seem to support direct assignments, at least

registerDoParallel(4)
res <- rep(NA,NROW(td))
foreach(i=levels(interaction(td$id))) %dopar%{
res[td$id==i] <- mean(td$val[td$id!=i])}

不做我想要的(给出与上面的正常循环相同的结果).任何想法我做错了什么或我怎么能以某种方式"破解" foreach中的.combine选项以便做我想要的？请注意,id变量的顺序在原始数据集中并不总是相同.任何提示都将非常感谢!

我试图刮掉大量的网页,以便以后分析它们.由于URL的数量巨大,我决定使用该parallel包XML.

具体来说,我正在使用htmlParse()函数from XML,它在使用时工作正常sapply,但在使用时会生成类HTMLInternalDocument的空对象parSapply.

url1<- "http://forums.philosophyforums.com/threads/senses-of-truth-63636.html"
url2<- "http://forums.philosophyforums.com/threads/the-limits-of-my-language-impossibly-mean-the-limits-of-my-world-62183.html"
url3<- "http://forums.philosophyforums.com/threads/how-language-models-reality-63487.html"

myFunction<- function(x){
cl<- makeCluster(getOption("cl.cores",detectCores()))
ok<- parSapply(cl=cl,X=x,FUN=htmlParse)
return(ok)
}

urls<- c(url1,url2,url3)

#Works
output1<- sapply(urls,function(x)htmlParse(x))
str(output1[[1]])
> Classes 'HTMLInternalDocument', 'HTMLInternalDocument', 'XMLInternalDocument', 'XMLAbstractDocument', 'oldClass' <externalptr>
output1[[1]]


#Doesn't work
myFunction<- function(x){
cl<- makeCluster(getOption("cl.cores",detectCores()))
ok<- parSapply(cl=cl,X=x,FUN=htmlParse)
stopCluster(cl)
return(ok)
}

output2<- myFunction(urls)
str(output2[[1]])
> Classes 'HTMLInternalDocument', 'HTMLInternalDocument', 'XMLInternalDocument', 'XMLAbstractDocument', 'oldClass' <externalptr>
output2[[1]]
#empty

谢谢.

我正在学习如何并行运行多个进程

  ./script1.sh param1 1>/dev/null 2>&1 &
  pid1=$!
  ./script1.sh param2 1>/dev/null 2>&1 &
  pid2=$!

我不确定这里发生了什么:

   1>/dev/null 2>&1
   pid1=$!

我试图理解"农场"在计算中的意义,因此,如果一个农场可以作为一个集群示例,那么必须有一个农场独立于集群的东西.

它与网格有什么不同？

这些概念是否具有一般意义,例如,谈论Web服务器只是一种常见的情景,或者它们是否完全不同于上下文？如果是这样,有什么不同的含义(或最常见的含义)？

另外,我应该在其他地方问这个吗？(如果是的话,我表示道歉).

我在R中使用无效记录器进行记录.我有一个在R中使用降雪实现的并行算法.并行过程的每个核心都在记录器中记录一个中间输出.但是这个输出没有出现在记录器中？

我们可以使用无效记录器从并行作业中使用降雪进行记录吗？

添加如何完成:

我的具体情况有点不同.我使用我创建的共享对象从R调用C函数.该函数是一个迭代算法,我需要每隔几次迭代记录输出.我有兴趣从C函数记录到无效记录器.为什么徒劳的记录器？因为这是Web应用程序的一部分,所以用户会话的所有输出都以一致的格式出现是有意义的.

这是我根据接受的答案遵循的一般方法.

# init script
# iter logger namespace global variable
assign("MCMC_LOGGER_NAMESPACE", "iter.logger", envir = .GlobalEnv)  

loginit <- function(logfile) { 
  require('futile.logger')
  flog.layout(layout.simple, name = ITER_LOGGER_NAMESPACE)  
  flog.threshold(TRACE, name = ITER_LOGGER_NAMESPACE)
  flog.appender(appender.file(logfile), name = ITER_LOGGER_NAMESPACE)   
  NULL
}

parallel_funct_call_in_R <- function(required args) {    
require('snowfall')  
sfSetMaxCPUs() 
sfInit(parallel = TRUE, cpus = NUM_CPU) 
sfLibrary(required libs)
sfExport(required vars including logger namespace variable ITER_LOGGER_NAMESPACE)
iterLoggers = sprintf(file.path(myloggingdir, 'iterativeLogger_%02d.log', fsep = .Platform$file.sep), seq_len(NUM_CPU))
sfClusterApply(iterLoggers, loginit)  
sfSource(required files)
estimates <- sfLapply(list_to_apply_over, func_callling_C_from_R, required args)
sfStop()  
return(estimates) …

我有一个相当大的训练矩阵(超过10亿行,每行两个特征).有两个类(0和1).这对于一台机器来说太大了,但幸运的是我有大约200台MPI主机供我使用.每个都是一个适度的双核工作站.

功能生成已成功分发.

Multiprocessing scikit-learn中的答案表明可以分发SGDClassifier的工作:

您可以跨核心分发数据集,执行partial_fit,获取权重向量,对它们求平均值,将它们分配给估算器,再次进行部分拟合.

当我在每个估算器上第二次运行partial_fit时,我从哪里开始获得最终的聚合估算器？

我最好的猜测是再次对coefs和截距进行平均,并使用这些值进行估算.结果估计器给出的结果与使用fit()在整个数据上构造的估计量不同.

细节

每个主机生成局部矩阵和局部矢量.这是测试集的n行和相应的n个目标值.

每个主机使用局部矩阵和局部向量来制作SGDC分类器并进行部分拟合.然后每个都将coef向量和截距发送到root.Root对这些进行平均并将它们发送回主机.主机执行另一个partial_fit并将coef向量和截距发送到root.

Root构造具有这些值的新估计器.

local_matrix = get_local_matrix()
local_vector = get_local_vector()

estimator = linear_model.SGDClassifier()
estimator.partial_fit(local_matrix, local_vector, [0,1])

comm.send((estimator.coef_,estimator.intersept_),dest=0,tag=rank)

average_coefs = None
avg_intercept = None

comm.bcast(0,root=0)
if rank > 0:
    comm.send( (estimator.coef_, estimator.intercept_ ), dest=0, tag=rank)
else:
    pairs = [comm.recv(source=r, tag=r) for r in range(1,size)]
    pairs.append( (estimator.coef_, estimator.intercept_) )
    average_coefs = np.average([ a[0] for a in pairs ],axis=0)
    avg_intercept = np.average( [ a[1][0] for a in pairs ] )

estimator.coef_ = comm.bcast(average_coefs,root=0)
estimator.intercept_ = …

有哪些技术可以缩短Grails项目构建和运行单元测试所需的时间？例如,Grails是否具有与Maven 3并行构建功能相同的功能？

我目前正在使用Grails来构建我的应用程序(不是Gradle等),使用Spock测试,由Jenkins驱动.我找到了一个脚本来并行化单元和集成测试,但我正在寻找更多.

以下是一些相关问题:

• 大型Grails项目中的集成和单元测试
• 如何对grails应用程序进行并发修改测试
• 如何加快grails测试执行速度

更新:

• 我想回答一些我自己的问题:查看Grails Partition Tests插件(在Grails Test Recipes上找到链接,它看起来也是一个很好的信息集合).