标签: parallel-processing

关于"特征选择/提取器/权重"是什么意思以及它们之间的区别,我有点困惑.在我阅读文献时,有时候我会感到迷茫,因为我发现这个术语使用得非常松散,我的主要关注点是 -

1. 当人们谈论特征频率,特征存在时 - 它是否是特征选择？

2. 当人们谈论信息增益,最大熵等算法时,它仍然是特征选择.

3. 如果我训练分类器 - 使用要求分类器记录文档中单词位置的特征集作为示例 - 是否仍然会调用此特征选择？

谢谢Rahul Dighe

引用http://www.mongodb.org/display/DOCS/MapReduce#MapReduce-Parallelism

截至目前,单个mongod进程上的MapReduce作业是单线程的.这是由于当前JavaScript引擎的设计限制.我们正在研究解决此问题的替代方法,但是现在如果要并行化MapReduce作业,则需要使用分片或在代码中进行聚合客户端.

没有并行性,与更简单或更传统的查询和数据聚合方法相比,MapReduce有哪些好处？

为避免混淆:问题不是"面向文档的DB比传统关系数据库有什么好处"

是否有R5RS或更高版本的Scheme实现并行化？例如,如果我说要这样做:

(map (lambda (x) 
        (pure-functional-stuff x))
     '(1 3 5 7 11 13))

如果机器可以同时处理1,3,5和7？这应该是函数式编程的一大优势,但我无法找到一个维护的,最新的方案来实现它.除非我断言该函数没有副作用,否则我会对那些不会并行化的它很好.

在并行计算中,理论上超线性加速是不可能的.但在实践中我们确实看到了这样的情况.一个原因是缓存效应,但我不明白它起什么作用.此外,还有其他事情,但它们是什么？综上所述,

超线性加速如何成为可能？

我是并行计算方面的初学者.

更新:我使用线程在内核数量中分割循环(在我的情况下为8),完整的循环在1秒内完成.所以问题不在于,线程操作不会更快.为什么Parralel Extension在这种情况下会失败？

嘿大家.我想用Parrallel.Foreach转换我的ForEach.问题是,parralelisation对我来说几乎没有任何好处.

原版的:

foreach (Entities.Buchung buchung in buchungen) {
    Int32 categoryID = manager.GetCategoryID(new Regelengine.Booking(buchung)); // Average 4ms
    buchung.Category = categoryID.ToString();
}

平行:

System.Threading.Tasks.Parallel.ForEach(buchungen, buchung => {
    Int32 categoryID = manager.GetCategoryID(new Regelengine.Booking(buchung));
    buchung.Category = categoryID.ToString();
});

结果:

---------------------------
Stopwatched Results for 1550 entries in the List:
---------------------------
Parallel.Foreach 00:00:07.6599066
Average Foreach: 00:00:07.9791303

也许问题是,循环中的实际动作如此之短？但没有人能告诉我,在英特尔I7上并行执行1550操作将无法节省时间.

在您看来哪个GPU最快的Delaunay三角剖分算法？或者更一般,并行

我刚刚尝试了多处理(并且非常棒!),但我想知道是否有任何指导来选择进程数量？它只是基于服务器上的核心数量？它是以某种方式基于应用程序运行(循环次数,它使用多少CPU等)？等...我如何决定产生多少个进程？现在,我只是猜测并添加/删除流程,但如果有某种指导方针或最佳实践,那将会很棒.

另一个问题,我知道如果我添加太少会发生什么(程序是slooow)但是如果我添加'太多'怎么办？

谢谢!

我想加快我的引导功能,它本身运行得非常好.我读过,因为R 2.14有一个名为的软件包parallel,但我觉得这对某人很难.对计算机科学知识不足以真正实现它.也许有人可以提供帮助.

所以这里有一个引导程序:

n<-1000
boot<-1000
x<-rnorm(n,0,1)
y<-rnorm(n,1+2*x,2)
data<-data.frame(x,y)
boot_b<-numeric()
for(i in 1:boot){
  bootstrap_data<-data[sample(nrow(data),nrow(data),replace=T),]
  boot_b[i]<-lm(y~x,bootstrap_data)$coef[2]
  print(paste('Run',i,sep=" "))
}

目标是使用并行处理/利用我的PC的多个核心.我正在Windows下运行R. 谢谢!

编辑(诺亚回复后)

以下语法可用于测试:

library(foreach)
library(parallel)
library(doParallel)
registerDoParallel(cores=detectCores(all.tests=TRUE))
n<-1000
boot<-1000
x<-rnorm(n,0,1)
y<-rnorm(n,1+2*x,2)
data<-data.frame(x,y)
start1<-Sys.time()
boot_b <- foreach(i=1:boot, .combine=c) %dopar% {
  bootstrap_data<-data[sample(nrow(data),nrow(data),replace=T),]
  unname(lm(y~x,bootstrap_data)$coef[2])
}
end1<-Sys.time()
boot_b<-numeric()
start2<-Sys.time()
for(i in 1:boot){
  bootstrap_data<-data[sample(nrow(data),nrow(data),replace=T),]
  boot_b[i]<-lm(y~x,bootstrap_data)$coef[2]
}
end2<-Sys.time()
start1-end1
start2-end2
as.numeric(start1-end1)/as.numeric(start2-end2)

但是,在我的机器上,简单的R代码更快.这是并行处理的已知副作用之一,即它会导致开销过程,这会增加像这样的"简单任务"中的时间吗？

编辑:在我的机器上,parallel代码比"简单"代码长约5倍.当我增加任务的复杂性(例如增加boot或n)时,这个因素显然不会改变.那么代码或我的机器可能存在问题(基于Windows的处理？).

我希望通过使用micein 来运行150次多次插补R.然而,为了节省一些计算时间,我将谎言将并行流中的流程细分(如Stef van Buuren在"针对缺失数据的灵活插补"中所建议的那样).

我的问题是:怎么做？

我可以想象2个选项:

opt.1:

imp1<-mice(data, m=1, pred=quicktry, maxit=15, seed=1)
imp2<-mice(data, m=1, pred=quicktry, maxit=15, seed=1)
imp...<-mice(data, m=1, pred=quicktry, maxit=15, seed=1)
imp150<-mice(data, m=1, pred=quicktry, maxit=15, seed=1)

然后通过使用complete和as.mids之后将插补结合在一起

opt.2:

imp1<-mice(data, m=1, pred=quicktry, maxit=15, seed=VAL_1to150)
imp2<-mice(data, m=1, pred=quicktry, maxit=15, seed=VAL_1to150)
imp...<-mice(data, m=1, pred=quicktry, maxit=15, seed=VAL_1to150)
imp150<-mice(data, m=1, pred=quicktry, maxit=15, seed=VAL_1to150)

通过添加VAL_1to150否则,在我看来(我可能是错的),如果它们都使用相同的数据集和相同的种子运行,那么您将获得相同结果的150倍.

还有其他选择吗？

谢谢

我正在尝试处理文件(每行都是一个json文档).文件的大小可以达到mbs到100的mbs.所以我写了一个生成器代码来逐行从文件中获取每个文档.

def jl_file_iterator(file):
    with codecs.open(file, 'r', 'utf-8') as f:
        for line in f:
            document = json.loads(line)
            yield document

我的系统有4个核心,所以我想并行处理4行文件.目前我有这个代码,一次需要4行,并调用代码进行并行处理

threads = 4
files, i = [], 1
for jl in jl_file_iterator(input_path):
    files.append(jl)
    if i % (threads) == 0:
        # pool.map(processFile, files)
        parallelProcess(files, o)
        files = []
    i += 1

if files:
    parallelProcess(files, o)
    files = []

这是我的代码,实际处理发生

def parallelProcess(files, outfile):
    processes = []
    for i in range(len(files)):
        p = Process(target=processFile, args=(files[i],))
        processes.append(p)
        p.start()
    for i in range(len(files)):
        processes[i].join()

def processFile(doc): …