标签: parallel-processing

我正在尝试优化这个功能：

bool interpolate(const Mat &im, float ofsx, float ofsy, float a11, float a12, float a21, float a22, Mat &res)
{         
   bool ret = false;
   // input size (-1 for the safe bilinear interpolation)
   const int width = im.cols-1;
   const int height = im.rows-1;
   // output size
   const int halfWidth  = res.cols >> 1;
   const int halfHeight = res.rows >> 1;
   float *out = res.ptr<float>(0);
   const float *imptr  = im.ptr<float>(0);
   for (int j=-halfHeight; j<=halfHeight; ++j)
   {
      const float rx = ofsx …

我对在 Tensorflow 中实现递归神经网络感兴趣，就像如何在 TensorFlow 中实现递归神经网络？。

然而，在他的实现中，该语句parallel_iterations的tf.while_loop被固定为 1。我担​​心这可能太慢了。由于我要输入张量流的树具有彼此不依赖的部分，因此我希望可以设置parallel_iterations为更高的值。然而，我作为张量流的输入输入的树中不可避免地需要一些依赖项，并且我担心将其设置为更高的值可能会破坏依赖项属性。

所以我的问题是，Tensorflow 是否tf.while_loop已经自动捕获了依赖关系，以便仅在彼此不依赖的位置上使用并行性？

张量流文档说明如下：

对于正确的程序，while_loop 对于任何并行迭代 > 0 都应返回相同的结果。

但我不确定他们所说的“正确的程序”是什么意思。

我已经编写了一个用于求解拉普拉斯方程的串行代码，但是当我尝试在 Julia 中并行编写它时，它比串行代码需要更多的时间和内存。我写了一个简单的例子。我怎样才能并行这段代码？

有一个域t1。

t2将被计算，然后t1 = t2

@everywhere function left!(t1,t2,n,l_type,b_left,dx=1.0,k=50.0)
    if l_type==1
            for i=1:n
                t2[i,1]=(b_left*dx/k)+t1[i,2];
                t1[i,1]=t2[i,1];
            end
    else 
        for i=1:n
        t1[i,1]=b_left;
        end
    end
    return t1 end

# parallel left does not work.
@everywhere function pleft!(t1,t2,n,l_type,b_left,dx=1.0,k=50.0)
    if l_type==1
           @parallel for i=1:n
                t2[i,1]=(b_left*dx/k)+t1[i,2];
                t1[i,1]=t2[i,1];
            end
    else 
     @parallel for i=1:n
        t1[i,1]=b_left;
        end
    end
    return t1
end
n = 10;
t1 = SharedArray(Float64,(n,n));
t2=t1;
typ = 0;
value = 10;
dx = 1;
k=50;

@time t3 = pleft!(t1,t2,n,typ,value,dx,k)
@time t2 …

我正在尝试在 node.js 中创建一个程序，使用 的fork()方法创建两个进程childproccess。流程如下：

• 父亲.js
• Son1.js
• Son2.js

我想直接在两个子进程之间传输数据，而不是在父进程和子进程之间传输数据。我向您展示了我正在尝试做的事情的图表。

子进程之间的通信

我尝试使用以下代码，但它对我不起作用。

在father.js代码中，我创建子进程如下：

const cp = require("child_process");
var son1 = cp.fork("${__dirname}/son1.js");
var son2 = cp.fork("${__dirname}/son2.js");

console.log("father sending message to son1..");
son1.send({msg:'Hi son1',br:son2});

console.log("father sending message to son2..");
son2.send({msg:'Hi son1',br:son1});

Son1.js的代码：

var brother=null;
process.on('message', function(json)
{
  console.log('message father in son1.js;', json.msg);
  brother=json.br;
  brother.send("hello I'm son1.js"); 
});

Son2.js的代码：

var brother=null;     
process.on('message', function(json)
{     
  console.log('message father in son2.js;', json.msg);       
  brother=json.br;
  brother.send("hello I'm son2.js");         
});

如何在不向 发送消息的情况下从 …

xarray我正在尝试遵循文档上的教程： http://xarray.pydata.org/en/stable/dask.html#automatic-parallelization

我的最终目标是从具有约 100,000 个属性的数据集中获取成对的斯皮尔曼相关矩阵，这使我找到了上面提到的教程。我正在测试iris datasetfrom的实现sklearn，但我遇到了问题，因为这种类型的并行化语法与joblib.

我不知道如何获取下面的代码来制作成对的斯皮尔曼相关矩阵，其结果形状为(150,150)。我展示了一个执行此操作的示例，pandas但这不是并行的，并且在我的实际数据集上将花费很长时间。

有谁知道如何调整此xarray代码以创建对称相关性度量？如果没有，有人可以指导我一种更好的方法来进行成对相似性测量。我知道，sklearns pairwise_distance但我想知道这是否是唯一的实现？

import bottleneck
import pandas as pd
import xarray as xr
from sklearn.datasets import load_iris

X_iris = pd.DataFrame(load_iris().data,
                       index = ["iris_%d" % i for i in range(load_iris().data.shape[0])],
                       columns = [x.split(" (cm)")[0].replace(" ","_") for x in load_iris().feature_names])
da_iris = xr.DataArray(X_iris, dims=["samples", "attributes"])

def covariance_gufunc(x, y):
    return ((x - x.mean(axis=-1, keepdims=True))
            * (y - y.mean(axis=-1, keepdims=True))).mean(axis=-1)

def pearson_correlation_gufunc(x, y): …

我有一个这样的项目设置：

:root
  :common
  :module1
  :module2
  :module3
  :module4
  :app

模块之间的依赖关系如下：

:common --> "none"
:module* --> :common
:app --> "all other modules"

根构建 gradle 仅为某些插件（如 kotlin gradle 插件）定义构建脚本。插件的实际应用发生在模块 build.gradle 文件中。此外，由于所有模块仅对自身负责，因此不会发生配置注入。

我在 gradle.properties 中启用了 org.gradle.parallel 并运行./gradlew build

预期的执行顺序如下（省略不相关的任务）：

:common:build
  :module1:build
  :module2:build
  :module3:build
  :module4:build
    :app:build

但不幸的是我得到了：

:common:build
  :module1:build
    :module2:build
      :module3:build
        :module4:build
          :app:build 

我可以做些什么来并行构建所有模块，因为最终会有更多模块，并且顺序执行将不必要地进一步延长所需的构建时间。

我有这个函数（见下文），它接受一个点坐标元组，如果该点位于形状多边形（全局变量）内，则返回一个布尔值。我想将其向量化以获取元组数组并返回等效的 bool 数组。

它与 numpy.vectorize 配合得很好，但速度很慢（6-7s），特别是因为我在 for 循环中调用它。

我读到在 GPU 上运行函数可能比在单核上运行更快。这是我根据互联网上的示例尝试的，但我使用了TypeError: invalid signature: 'str' instance not allowed函数装饰器。

函数签名有什么问题以及如何修复它？

import shapely.geometry as sp
import numba as nb
import numpy as np

#the matrix of tuples:
obj_location = np.empty((800,800), object)
for idx in np.ndindex(maxY,maxX):
    obj_location[idx] = idx

#the polygon
poly=sp.Polygon([(200,200),(200,600),(600,600),(600,200)])

#function definition
@nb.vectorize(['bool(tuple)'], target='cuda')
def inside(point_coordinates):
    (y,x) = point_coordinates
    return poly.contains(sp.Point(x,y))

#call function
inside(obj_location)

我对机器学习领域比较陌生，如果我的一些问题确实很基本，请原谅。

目前情况：总体目标是尝试改进在超级计算机集群上运行的 r 中的 h2o 包的一些代码。然而，由于数据量太大，单个节点用 h2o 确实需要一天多的时间，因此，我们决定使用多个节点来运行模型。我想出了一个主意：

(1) 分布每个节点构建(nTree/num_node)棵树并保存到模型中；

(2)在集群的每个节点上运行(nTree/num_node)个森林中的树；

(3)将树木重新合并并改造原始森林，并取测量结果的平均值。

后来我意识到这可能有风险。但我找不到实际的支持或反对声明，因为我不是专注于机器学习的程序员。

问题：

1. 如果这种处理随机森林的方法会导致一些风险，请参考我的链接，以便我可以基本了解为什么这是不正确的。
2. 如果这种方式实际上是一种“好的”方式。我应该做什么来合并树，有我可以借用的包或方法吗？
3. 如果这确实是一个解决问题，请参考我的链接，我可能搜索了错误的关键字，谢谢！

我可以在这里展示的实际涉及数字的例子是：

我有一个包含 80k 行和 2k 列的随机森林任务，并且希望树的数量为 64 棵。我所做的是将 16 棵树放在每个节点上，与整个数据集一起运行，并且四个节点中的每一个都提出一个 RF 模型。我现在正在尝试将每个模型中的树合并到这个大型 RF 模型中，并对测量值进行平均（来自这四个模型中的每一个）。

我安装 MS-MPI

我喜欢用 Sublime Text 编写代码，特别是 C/C++

我使用 gcc/g++ 在 cmd 中运行代码

我怎样才能编译并运行从 cmd 编译并运行 MPI 代码

我不喜欢视觉工作室

那么，有什么方法可以在 cmd 中使用 MS-MPI 编译和运行我的 C/C++ MPI 代码

我知道标题中有一个问题： Compile C++ MPI Code on Windows

但没有明确的答案或评论。这就是为什么我现在重新问

我有一个python需要使用不同参数值重复调用的函数。我想在多个 CPU 上并行执行此操作。我已经使用该joblib模块成功完成了此操作。我现在想让我的代码作为网络应用程序使用，在多个 CPUflask上运行AWS EC2 instance。这是我尝试过的一个玩具示例：

from flask import Flask
from joblib import Parallel, delayed
from time import sleep

def myfunc(x):
    sleep(5)
    return x

application = Flask(__name__)

@application.route('/', methods = ['GET'])
def getresult():
    out = Parallel(n_jobs=-1, verbose=10)(delayed(myfunc)(i) for i in range(5))
    return str(sum(out))

if __name__ == "__main__":
    application.debug = True
    application.run()

问题是该代码不能在多个 CPU 上并行运行。我收到以下警告和输出（经过的时间确认它没有并行运行）：

    /Library/anaconda/lib/python3.6/site-packages/joblib/parallel.py:547:
    UserWarning: Multiprocessing-backed parallel loops cannot be nested below 
    threads, setting n_jobs=1
      **self._backend_args)
    [Parallel(n_jobs=-1)]: Done   1 …