如何在python中并行for循环？ [关闭]

Question

更新1.0开始

看来打电话的时候

for i, Wi in enumerate(W.T):
    idx.append(i)
    result.append(pool.apply_async(ALS_Y, (X, Wi, Q, lambda_, n_factors, i,)))

传递给函数ALS_Y/ALS_X的参数不是引用，它复制了参数。因此，当X或Y是非常large matrixes ，例如，在我的情况下，它是6000*40左右（并且它是一个for-loop ，我们假设迭代次数是50 000 ，所以...），它超出了内存的限制。
然后我尝试使用全局参数，只是将索引作为参数传递给函数，

import multiprocessing
import time
import numpy as np

def func(idx):
    global a
    a[idx] += 1



if __name__ == "__main__":
    a=range(10)
    for j in xrange(2):
        pool = multiprocessing.Pool(processes=8)
        result = []
        for i in xrange(10):
            result.append(pool.apply_async(func, (i, )))
        pool.close()
        pool.join()
        print a
        print "Sub-process(es) done."

它输出：`

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Sub-process(es) done.
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Sub-process(es) done.

So, this means it still copied `！ 现在，我想知道有没有办法处理这个问题？ 欣赏！

更新1.0结束

---

下面是我在python中解码矩阵分解问题的代码。 W = XY。 但是，下面的代码效率不高，我希望它可以转换成并行版本，使用GPU是最好的，CPU也很好。 我对并行编程没有经验，所以有人可以给我一些建议吗？

下面是使用ALS对矩阵进行分解的代码（交替最小二乘，详细信息在这里 ）

for ii in range(n_iterations):
    for u, Wu in enumerate(W):
        X[u] = np.linalg.solve(np.dot(Y, np.dot(np.diag(Wu), Y.T)) + lambda_ * np.eye(n_factors),
                               np.dot(Y, np.dot(np.diag(Wu), Q[u].T))).T #X_inner loop

    for i, Wi in enumerate(W.T):
        Y[:,i] = np.linalg.solve(np.dot(X.T, np.dot(np.diag(Wi), X)) + lambda_ * np.eye(n_factors), #Y_inner loop
                                 np.dot(X.T, np.dot(np.diag(Wi), Q[:, i])))#Y_inner loop
    error = get_error(Q, X, Y, W)
    weighted_errors.append(error)
    print '{}th iteration is completed'.format(ii)

使用多处理lib后，我的代码现在：

def ALS_X(Y, Wu, Q, lambda_, n_factors, u):
return np.linalg.solve(np.dot(Y, np.dot(np.diag(Wu), Y.T)) + lambda_ * np.eye(n_factors),
                           np.dot(Y, np.dot(np.diag(Wu), Q[u].T))).T  

for ii in range(n_iterations):
pool = multiprocessing.Pool(processes=12)#create pool
result = []#store each row for X
idx = []#store the row number
for u, Wu in enumerate(W):
    idx.append(u)
    result.append(pool.apply_async(ALS_X, (Y, Wu, Q, lambda_, n_factors, u,)))
pool.close()
pool.join()
for u, vector in zip(idx, result):
    X[u] = vector.get()#assign the result to X
######################################
pool = multiprocessing.Pool(processes=12)#for Y, much similar to X
result = []
idx = []
for i, Wi in enumerate(W.T):
    idx.append(i)
    result.append(pool.apply_async(ALS_Y, (X, Wi, Q, lambda_, n_factors, i,)))
pool.close()
pool.join()
for i, vector in zip(idx, result):
    Y[:,i]  = vector.get()
error = get_error(Q, X, Y, W)
weighted_errors.append(error)
print '{}th iteration is completed'.format(ii), 'error: ',error

但有点痛苦，程序总是默默崩溃......

下面是我的一大堆代码..它一切都很混乱。 只是忽略load_data get_error和vec2str ，因为在这里我随机生成矩阵。

import pandas as pd
import numpy as np
import multiprocessing

def vec2str(vec):
    res = ''
    for dim in len(vec):
        res += str(vec[dim]) + ','
    return res

def load_data(heads, filename, sep,header=None):
    data = pd.read_table(filename, sep=sep, header=header, names=heads)
    rp = data.pivot_table(columns=['sid'],index=['uid'],values=['rating'])#not generally...
    Q = rp.fillna(0)
    Q = Q.values
    W = Q >0.5
    W[W == True] = 1
    W[W == False] = 0
    W = W.astype(np.float64, copy=False)
    return Q, W, rp

def get_error(Q, X, Y, W):
    return np.sum((W * (Q - np.dot(X, Y)))**2)

'''
X[u] = np.linalg.solve(np.dot(, np.dot(np.diag(), .T)) +  * np.eye(),
                               np.dot(, np.dot(np.diag(), Q[u].T))).T
'''
def ALS_X(Y, Wu, Q, lambda_, n_factors, u):
    return np.linalg.solve(np.dot(Y, np.dot(np.diag(Wu), Y.T)) + lambda_ * np.eye(n_factors),
                               np.dot(Y, np.dot(np.diag(Wu), Q[u].T))).T

'''
Y[:,i] = np.linalg.solve(np.dot(X.T, np.dot(np.diag(Wi), X)) + lambda_ * np.eye(n_factors),
                                 np.dot(X.T, np.dot(np.diag(Wi), Q[:, i])))
'''

def ALS_Y(X, Wi, Q, lambda_, n_factors, i):
    return np.linalg.solve(np.dot(X.T, np.dot(np.diag(Wi), X)) + lambda_ * np.eye(n_factors),
                                 np.dot(X.T, np.dot(np.diag(Wi), Q[:, i])))



if __name__ == "__main__":

    lambda_ = 0.1
    n_factors = 40
    filename = 'data_songID'
    n_iterations = 20
    #Q, W, rp = load_data(['uid', 'sid', 'rating'], filename, ',')
    Q = np.random.rand(1000,1000)
    m, n = Q.shape
    W = np.eye(1000)
    print 'Loading data finished, ', 'size: ', Q.shape
    print 'Settings ', 'lambda = {}'.format(lambda_), 'n_factors = {}'.format(n_factors)
    X = 5 * np.random.rand(m, n_factors) 
    Y = 5 * np.random.rand(n_factors, n)
    errors = []
    for ii in range(n_iterations):
        X = np.linalg.solve(np.dot(Y, Y.T) + lambda_ * np.eye(n_factors), 
                        np.dot(Y, Q.T)).T
        Y = np.linalg.solve(np.dot(X.T, X) + lambda_ * np.eye(n_factors),
                        np.dot(X.T, Q))
        if ii % 100 == 0:
            print('{}th iteration is completed'.format(ii))
        errors.append(get_error(Q, X, Y, W))
        Q_hat = np.dot(X, Y)
        print('Error of rated movies: {}'.format(get_error(Q, X, Y, W)))
    print errors
    #####ALS start....#####
    print '*'*100
    weighted_errors = []
    for ii in range(n_iterations):
        pool = multiprocessing.Pool(processes=12)
        result = []
        idx = []
        for u, Wu in enumerate(W):
            idx.append(u)
            result.append(pool.apply_async(ALS_X, (Y, Wu, Q, lambda_, n_factors, u,)))
        pool.close()
        pool.join()
        for u, vector in zip(idx, result):
            X[u] = vector.get()
        ######################################
        pool = multiprocessing.Pool(processes=12)
        result = []
        idx = []
        for i, Wi in enumerate(W.T):
            idx.append(i)
            result.append(pool.apply_async(ALS_Y, (X, Wi, Q, lambda_, n_factors, i,)))
        pool.close()
        pool.join()
        for i, vector in zip(idx, result):
            Y[:,i]  = vector.get()
        error = get_error(Q, X, Y, W)
        weighted_errors.append(error)
        print '{}th iteration is completed'.format(ii), 'error: ',error

    weighted_Q_hat = np.dot(X,Y)
    print weighted_errors
    X.tofile('X.bin')
    Y.tofile('Y.bin')
    latent_user_file = open('user_latent','w')
    for idx in len(rp.axes[0]):
        latent_user_file.write(str(rp.axes[0][idx]) + '\t' + vec2str(X[idx,:]) + '\n')

    latent_mid_file = open('mid_latent', 'w')
    for idx in len(rp.axes[1]):
        latent_mid_file.write(str(rp.axes[1][idx]) + '\t' + vec2str(Y.T[idx,:]) + '\n')

Answer 1

去年我遇到了你想在python中进行“并行循环”的愿望，并将其作为我物理论文工作的一部分。 有很多模块，你想要什么做的，但我发现我真的可以只得到它与PP工作我想为任意函数的方式。

如果你想要这样的东西：

ResultList = Library_ParallelLoop.Main(
    Function = ExampleFunction,
    ListOfArgSets = ListOfArgSets,
    Algorithm = 'pp',
    PrintExtra = True
    )

然后我指向你的git hub，而不是在这篇文章中提供我的整个源代码，因为实际上让它工作的实现很痛苦很多行，并涉及深度复制python函数，这显然是其他非预先构建的非常好的东西在python中。

寻找Primes示例：

https://github.com/douglasquincyadams/Main/blob/master/Test_ParallelLoop.py

回购：

https://github.com/douglasquincyadams/Main

如果您在计算机的某个黑暗角落下载我的回购 - 那么您的工作代码应为：

import Library_ParallelLoop

def do_the_thing_function(ii):
    for u, Wu in enumerate(W):
    X[u] = np.linalg.solve(np.dot(Y, np.dot(np.diag(Wu), Y.T)) + lambda_ * np.eye(n_factors),
                           np.dot(Y, np.dot(np.diag(Wu), Q[u].T))).T #X_inner loop

    for i, Wi in enumerate(W.T):
    Y[:,i] = np.linalg.solve(np.dot(X.T, np.dot(np.diag(Wi), X)) + lambda_ * np.eye(n_factors), #Y_inner loop
                             np.dot(X.T, np.dot(np.diag(Wi), Q[:, i])))#Y_inner loop
    error = get_error(Q, X, Y, W)
    weighted_errors.append(error)
    print '{}th iteration is completed'.format(ii)
    return #whatever your result is supposed to be... your code doesn't work on its own

ListOfArgSets = []
for ii in range(n_iterations):
    ListOfArgSets.append(  { "ii"  :  ii ,  }  )

ResultList = Library_ParallelLoop.Main(
    Function = do_the_thing_function,
    ListOfArgSets = ListOfArgSets,
    Algorithm = 'pp',
    PrintExtra = True
    )

如果你问我 - 一个非常类似于上面那个的并行循环应该已经是一个非常方便并且内置于语言中的东西，但似乎总是以某种方式被塔中的巫师加密地示例，并且当你尝试它时不能很好地工作在你的笔记本电脑上。 无论如何 - 希望这会有所帮助。

附加说明 - 我还建议如果你想解决ARBITRARY大规模并行化问题（除了简单的循环之外），你使用MPI因为它有各种各样的铃声和口哨声，它们可以让进程互相交流中途。 MPI是科学界人士喜欢用于最大模拟的因素，因此设计用于处理非常大的作业（~10k +核心）的更大尺寸的集群都支持MPI，并且肯定不太可能支持pp甚至多处理模块。 如果您只想利用PC中的所有核心（或网络上的几台PC），那么只需选择最简单的核心即可。