标签: parallel-processing

对于我的特殊问题，我需要多次重新运行曾经构造过的Tensorflow图，每次将变量重新初始化为新值。图的每次执行都独立于下一个执行。可以将其视为建立模型，然后对每个模拟进行30次独立随机初始化的训练。尽管可以通过将Session.run（）语句放在for循环中来实现上述目的，但我认为这不能保证并行性。

所以问题是：运行多个独立Sims的最合适，与Tensorflow兼容的方式是什么？我应该在python while循环内执行session.run（）还是应该使用Tensorflow while_loop结构？

我有一些分类器，我想对一个样本进行评估。由于它们彼此独立，因此可以并行运行此任务。这意味着我要并行化它。

我用python和bash脚本尝试过。问题是，当我第一次运行该程序时，大约需要30到40秒才能完成。当我连续多次运行该程序时，只需1s-3s即可完成。即使我用不同的输入来输入分类器，我也得到了不同的结果，因此似乎没有缓存。当我运行其他程序并随后重新运行该程序时，它又需要40秒钟才能完成。

我在htop中还观察到，第一次运行该程序时CPU利用率不高，但是当我一次又一次重新运行时，CPU利用率就很高。

有人可以向我解释这种奇怪的行为吗？我如何避免这种情况，这样即使程序第一次运行也会很快？

这是python代码：

import time
import os
from fastText import load_model
from joblib import delayed, Parallel, cpu_count
import json

os.system("taskset -p 0xff %d" % os.getpid())

def format_duration(start_time, end_time):
    m, s = divmod(end_time - start_time, 60)
    h, m = divmod(m, 60)
    return "%d:%02d:%02d" % (h, m, s)

def classify(x, classifier_name, path):
    f = load_model(path + os.path.sep + classifier_name)    
    labels, probabilities = f.predict(x, 2)
    if labels[0] == '__label__True':
        return classifier_name
    else:
        return None

if __name__ == '__main__':
    with open('classifier_names.json') as …

我在"专业人士的PowerShell笔记"白皮书中发现了一个有趣的声明 - "在管道系列中,每个函数都与其他函数并行运行,如并行线程":

那是对的吗？如果"是",是否有支持此声明的技术文档？

我使用下面的代码,它是"npm install"的执行命令,现在在调试时我看到命令执行大约需要10..15秒(取决于我有多少模块).我想要的是这个命令将在后台执行,程序将继续.

cmd := exec.Command(name ,args...)
cmd.Dir = entryPath

在调试中我看到要移动到下一行tass大约10..15秒...

我有两个问题:

1. 我怎么能这样做？因为我想要并行做某事......
2. 我怎么知道它什么时候结束？提供与此命令相关的其他逻辑,即在npm install完成之后,我需要做其他事情.

我目前有一段代码产生多个进程,如下所示:

pool = Pool(processes=None)
results = [pool.apply(f, args=(arg1, arg2, arg3)) for arg3 in arg_list]

我的想法是,这将使用之后可用的所有核心将工作划分为核心processes=None.但是,多处理模块docs中Pool.apply()方法的文档如下:

相当于apply()内置函数.它会一直阻塞,直到结果准备就绪,因此apply_async()更适合并行执行工作.此外,func仅在池中的一个工作程序中执行.

第一个问题: 我不清楚这一点.如何apply在工人之间分配工作,以及与什么方式不同apply_async？如果任务分布在工人之间,那怎么可能func只在其中一个工人中执行？

我的猜测:我的猜测是apply,在我当前的实现中,给一个具有一组参数的工作者提供一个任务,然后等待该工作完成,然后将下一组参数提供给另一个工作者.通过这种方式,我将工作发送到不同的流程,但没有发生并行性.这似乎是这种情况,因为apply事实上只是:

def apply(self, func, args=(), kwds={}):
    '''
    Equivalent of `func(*args, **kwds)`.
    Pool must be running.
    '''
    return self.apply_async(func, args, kwds).get()

第二个问题:我也想更好地理解为什么在出台的文件,部分16.6.1.5.('使用工人池'),他们说,即使是apply_async像这样 的建筑[pool.apply_async(os.getpid, ()) for i in range(4)] 可能会使用更多的工艺,但它不确定它会.是什么决定是否使用多个流程？

我想在此代码中使用多进程包.我试图调用该函数create_new_population并将数据分发到8个处理器,但是当我这样做时,我得到了pickle错误.

通常函数会像这样运行: self.create_new_population(self.pop_size)

我尝试像这样分发工作:

f= self.create_new_population
pop = self.pop_size/8
self.current_generation = [pool.apply_async(f, pop) for _ in range(8)]

我得到 或Can't pickle local object 'exhaust.__init__.<locals>.tour_select'
PermissionError: [WinError 5] Access is denied

我仔细阅读了这个帖子,并尝试使用Steven Bethard的方法绕过错误,允许通过copyreg进行方法酸洗/ 取消:

def _pickle_method(method)
def _unpickle_method(func_name, obj, cls)

我还尝试使用pathos包没有任何运气.
我知道应该在
if __name__ == '__main__':块下调用代码,但我想知道是否可以在代码中尽可能少的更改来完成.

有没有办法git submodule foreach并行执行命令,类似于--jobs 8参数的工作方式git submodule update？

例如,我们工作的项目之一涉及近200个子组件(子模块),我们大量使用该foreach命令对它们进行操作.我想加快它们的速度.

PS:如果解决方案涉及脚本,我在Windows上工作,大多数时候,使用git-bash.

我的机器有4个核心.当我使用@sync @parallel进行并行运行时,我注意到Julia在将作业发送到4个处理器之前将作业分成4 个:

# start of do_something.jl
function do_something(i, parts)
    procs = zeros(Int, parts)
    procs[i] = myid()
    total = 0.0
    for j = 1:i * 100000000
        total = total + 1e-6
    end
    return procs
end
# end of do_something.jl

# synctest3a.jl
addprocs(Sys.CPU_CORES)
@everywhere include("do_something.jl")
parts = 20
procs = @sync @parallel (+) for i = 1:parts
    do_something(i, parts)
end
@printf("procs=%s\n", procs)

julia synctest3a.jl的结果,表示前5个被发送到处理器2,接下来的5个被发送到处理器3,依此类推:

procs=[2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, …

我使用OpenCL和MQL5为MetaTrader终端平台创建了一个基于GPU的指标.

我努力工作,我的[MetaTrader终端:策略测试程序]优化工作必须在GPU上转移到最大值.大多数计算都是由指标完成的.因此,我在指标中进行了更改,并在GPU上完全转移.

但是当我尝试在策略测试器部分进行优化过程时,真正的问题出现了.
我看到的过程同时使用了GPU和CPU,但对整个过程没有影响.

我怀疑这个过程并没有分配到每个GPU核心进行处理,而是所有GPU核心都在处理相同的进程或功能以便执行.

Kindly, let me know what I need to do to get the single GPU work for on single function execution to give faster output.

Here is my code link attached: Complete code with Expert

The kernel of my code is :

__kernel void calSMA(
                     int limit, 
                     int rates_total, 
                     __global double *price, 
                     __global double *ExtLineBuffer,
                     int InpMAPeriod

                   )
         { 

                int count = 0;
                int len = get_global_id(2);
                for(int i=limit;i<rates_total;i++) 

                     ExtLineBuffer[len+i] = ExtLineBuffer[len+ i-1]+(price[len+i]-price[len+i-InpMAPeriod])/InpMAPeriod;

         }


 __kernel void …

根据Chapel的可用文档,(整个)数组语句如

A = B + alpha * C;   // with A, B, and C being arrays, and alpha some scalar

在语言中实现如下的forall迭代:

forall (a,b,c) in zip(A,B,C) do
   a = b + alpha * c;

因此,默认情况下,数组语句由并行线程团队执行.不幸的是,这似乎也完全排除了这些陈述的(部分或完全)矢量化.对于习惯于Fortran或Python/Numpy等语言的程序员而言,这可能会带来性能上的惊喜(默认行为通常是只对数组语句进行矢量化).

对于使用(整数)数组语句与小到中等大小的数组的代码,矢量化的丢失(由Linux硬件性能计数器确认)和并行线程固有的显着开销(不适合有效地利用细粒度数据) - 在这些问题中可用的并行性)可能导致性能的显着损失.作为一个例子,考虑以下版本的Jacobi迭代,它们都解决了300 x 300区域的相同问题:

Jacobi_1 使用数组语句,如下所示:

/*
 *  Jacobi_1
 *
 *  This program (adapted from the Chapel distribution) performs
 *  niter iterations of the Jacobi method for the Laplace equation
 *  using (whole-)array statements.
 *
 */

config var n = 300;                  // size of n …