标签: parallel-processing

我有一个相当大的训练矩阵(超过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上找到链接,它看起来也是一个很好的信息集合).

使用传统的顺序缩减方法,下面的图表减少为:

(+ (+ 1 2) (+ 3 4)) ->
(+ 3 (+ 3 4)) ->
(+ 3 7) ->
10

但是,图形缩减本质上是平行的.相反,人们可以将其减少为:

(+ (+ 1 2) (+ 3 4)) ->
(+ 3 7) ->
10

据我所知,每种函数式编程语言都使用第一种方法.我相信这主要是因为在CPU上,调度线程过度补偿了并行减少的好处.但是,最近,我们开始使用GPU而不是CPU用于并行应用程序.如果一种语言完全在GPU上运行,那么这些通信成本就会消失.

是否有功能语言利用这个想法？

我创建了一个简单的例子来说明我目前遇到的问题.

我有一个名为example.Rmd的R-markdown文件,其中包含以下代码

```{r}
plot(rnorm(10000))
```

和一个包含以下内容的Makefile文件

all : example01.html example02.html

example01.html : example.Rmd
    Rscript -e "library(knitr); knit2html(input='example.Rmd', output='example01.html')"

example02.html : example.Rmd
    Rscript -e "library(knitr); knit2html(input='example.Rmd', output='example02.html')"

如果我按顺序运行Makefile文件

make

没有问题.

如果我并行运行makefile

make -j 2

knit2html函数生成的块重叠,两个html文件包含相同的图像.

有什么建议吗？我一直在寻找解决方案,但我一无所获.

考虑下面的代码,是不是OK做async/await里面Parallel.ForEach？

例如.

Parallel.ForEach(names, name =>
{
    // Do some stuff...

    var foo = await GetStuffFrom3rdPartyAsync(name);

    // Do some more stuff, with the foo.
});

还是有一些我需要知道的问题？

编辑:不知道这是否编译,顺便说一句.只是Pseduo代码..大声思考.

我正在使用GNU parallel在几个不同的服务器(最多25个)上运行一个作业.

实现此目的的shell脚本当前执行:

parallel --tag --nonall -S $some_list_of_servers "some_command"
state=$?
echo -n "RESULT: "
if [ "$state" -eq "0" ]
then
    echo "All jobs successful"
else
    echo "$state jobs failed"
fi
return $state

其中some_list_of_servers是一个数组,而install_command例如是git fetch.

我想要的是更多的信息,而不仅仅是失败的工作量.我想知道哪个命令和哪个服务器失败了.

我已经浏览了手册页,谷歌和SO,但找不到我正在寻找的开关.

任何帮助感激不尽.

WeeDom

编辑回答答案1:

我试过了,发生了一些奇怪的事情.

weedom@host1: ~/$ parallel --tag --nonall  -j8 --joblog test.log -S host1,host2 uptime 
host2   10:41:17 up 36 days, 20:45,  1 user,  load average: 0.00, 0.00, 0.00
host1         10:41:17 up 22:34,  3 users,  load average: 0.06, 0.11, 0.04
weedom@host1: ~/$ cat test.log …

该ConcurrentHashMap有一对夫妇的新方法.我有两个问题:

1. 他们为什么不宣布ConcurrentMap？
2. 究竟是什么parallelismThreshold意思或做什么？

我试图将并行性添加到将.bmp转换为灰度.bmp的程序中.我发现并行代码的性能通常会低2-4倍.我正在调整parBuffer/chunking大小,但似乎仍无法推理它.寻找指导.

这里使用的整个源文件:http://lpaste.net/106832

我们Codec.BMP用来读取由...表示的像素流type RGBA = (Word8, Word8, Word8, Word8).要转换为灰度,只需在所有像素上映射"亮度"变换.

串行实现字面意思是:

toGray :: [RGBA] -> [RGBA]
toGray x = map luma x

测试输入.bmp是5184 x 3456(71.7 MB).

串行实现运行在~10s,~550ns /像素.Threadscope看起来很干净:

为什么这么快？我想它有懒惰的ByteString(即使Codec.BMP使用严格的ByteString - 这里是否发生了隐式转换？)和融合.

添加并行性

添加并行性的第一次尝试是通过parList.好家伙.该程序使用~4-5GB内存并开始交换系统.

然后我读了Simon Marlow的O'Reilly书中的"使用parBuffer并行化Lazy Streams"部分并尝试parBuffer了大尺寸.这仍然没有产生理想的性能.火花尺寸非常小.

然后我尝试通过分块懒惰列表然后坚持parBuffer并行性来增加火花大小:

toGrayPar :: [RGBA] -> [RGBA]
toGrayPar x = concat $ (withStrategy (parBuffer 500 rpar) . map (map luma))
                       (chunk 8000 x)

chunk :: Int -> [a] -> [[a]]
chunk n [] …

我在Matlab代码中运行了两个for循环.内部循环使用Matlabpool在12个处理器中进行并行化(这是Matlab在单个机器中允许的最大值).

我没有分布式计算许可证.请帮我使用Octave或Scilab如何做到这一点.我只想将'for'循环并行化.

当我在谷歌搜索它时,有一些断开的链接.

我一直在测试一个OpenMP并行代码中的代码,memset并行运行会有什么好处吗？我正在观察一些意外的事情.

我的系统是一个单插槽Xeon E5-1620,它是一个Ivy Bridge处理器,有4个物理内核和8个超线程.我使用的是Ubuntu 14.04 LTS,Linux Kernel 3.13,GCC 4.9.0和EGLIBC 2.19.我编译gcc -fopenmp -O3 mem.c

当我在链接中运行代码时,它默认为八个线程并给出

Touch:   11830.448 MB/s
Rewrite: 18133.428 MB/s

但是,当我绑定线程并将线程数设置为这样的物理核心数

export OMP_NUM_THREADS=4 
export OMP_PROC_BIND=true

我明白了

Touch:   22167.854 MB/s
Rewrite: 18291.134 MB/s

触控率增加了一倍!绑定后运行几次总是比重写更快.我不明白这一点.绑定线程并将其设置为物理核心数后,为什么触摸比重写更快？为什么触控率翻倍？

这是我使用的代码,没有修改Hristo Iliev的答案.

#include <stdio.h>
#include <string.h>
#include <omp.h>

void zero(char *buf, size_t size)
{
    size_t my_start, my_size;

    if (omp_in_parallel())
    {
        int id = omp_get_thread_num();
        int num = omp_get_num_threads();

        my_start = (id*size)/num;
        my_size = ((id+1)*size)/num - my_start;
    }
    else
    {
        my_start = 0;
        my_size …