0

我有一个代码，其中共享资源由函数调用更改。到目前为止，对于每个输入向量（维度 rxc 的输入矩阵），我都在串行运行它。

我想在每个函数调用中更改一个共享资源（比如 R）。到目前为止，我已经尝试使用 Python Multiprocessing 和 Pathos Multiprocessing 来加快速度。我什至尝试过 np.apply_along_axis 来加快速度。

到目前为止，我注意到串行处理是最快的方式。我不知道为什么会这样。

我尝试了以下方法

  1. np.apply_along_axis ：只有轻微的延迟（恒定时移）
  2. Pathos.multiprocessing.ProcessingPool.Map ：最多延迟 10 倍
  3. multiprocessing.Process（手动拆分）：最多延迟 5 倍
  4. multiprocessing.Pool ：符合 Pathos 结果。

我是 python 并行编程的新手，可能做错了什么。有什么好的方法吗？

更新：附上自组织地图代码

我在引用我正在做的事情。

class SOM(object):

    def __init__(self, X):
        pool = Pool()
        pool.ncpus=4
        self.map = pool.map


    def train_single( self, x, lr, r):
        b = np.argmin(np.linalg.norm(self.W-x, axis=1))

        N = np.where(np.linalg.norm(self.Y-self.Y[b],axis=1)<r)[0]
        d = np.linalg.norm(self.Y[N]-self.Y[b],axis=1)
        H = np.array([np.exp(-d**2/np.max(d)**2*0.5)]).T

        H/=H.max()
        gradients =  - (self.W[N] - x) * H * lr
        if np.isnan(gradients).any():
            return
    #
        self.W[N] += gradients

    def train_batch_parallel(self, X):
        self.W = np.random.random(size=(100, X.shape[1]))
        self.Y = np.array([[i, j] for i in range(10) for j in range(10)])
        self.X = X

        r = 10
        lr = .5
        self.rs = np.repeat(r, X.shape[0]).astype(float)
        self.lrs = np.repeat(lr, X.shape[0])
        for k in range(1, 100):
            self.rs *=0.8# np.append(self.rs, np.repeat(r * 0.8 ** k, X.shape[0]), axis=0)
            self.lrs *=0.9# np.append(self.rs, np.repeat(lr * 0.9 ** k, X.shape[0]), axis=0)
            #parallel execution using the pool.map
            self.map(self.train_single, X, self.lrs, self.rs)
4

0 回答 0