Question

总体问题：当我调用Queue.get（）时，如何知道从Queue对象获取的内容？我如何对其进行排序或识别？你可以从队列中获取特定项目并留下其他人吗？

上下文

我想学习一些关于多处理（线程化）的知识，以便更有效地求解矩阵方程。

为了说明，下面是我的工作代码，用于在不利用多个核的情况下求解矩阵方程Ax = b。解决方案是[1,1,1]。

def jacobi(A, b, x_k):

    N = len(x_k)
    x_kp1 = np.copy(x_k)
    E_rel = 1
    iteration = 0

    if (N != A.shape[0] or N != A.shape[1]):
        raise ValueError('Matrix/vector dimensions do not match.')

    while E_rel > ((10**(-14)) * (N**(1/2))):
        for i in range(N):

            sum = 0

            for j in range(N):
                if j != i:
                    sum = sum + A[i,j] * x_k[j]

            x_kp1[i] =(1 / A[i,i]) * (b[i] - sum)

        E_rel = 0
        for n in range(N):
            E_rel = E_rel + abs(x_kp1[n] - x_k[n]) / ((abs(x_kp1[n]) + abs(x_k[n])) / 2)

        iteration += 1
        # print("relative error for this iteration:", E_rel)
        if iteration < 11:
            print("iteration ", iteration, ":", x_kp1)

        x_k = np.copy(x_kp1)

    return x_kp1

if __name__ == '__main__':

    A = np.matrix([[12.,7,3],[1,5,1],[2,7,-11]])
    b = np.array([22.,7,-2])
    x = np.array([1.,2,1])

    print("Jacobi Method:")
    x_1 = jacobi(A, b, x)

好的，所以我想按照这个很好的例子转换这段代码：https://p16.praetorian.com/blog/multi-core-and-distributed-programming-in-python

所以我得到了一些运行的代码，并在相同的迭代次数中收敛到正确的解决方案！这真的很棒，但是这种情况的保证是什么？似乎Queue.get（）只是从任何先完成（或最后？）的过程中获取结果。当我的代码运行时，我实际上非常惊讶，就像我预期的那样

  for i in range(N):
        x_update[i] = q.get(True)

混淆向量的元素。

以下是使用多处理库更新的代码：

import numpy as np
import multiprocessing as mu

np.set_printoptions(precision=15)

def Jacobi_step(index, initial_vector, q):
    N = len(initial_vector)
    sum = 0
    for j in range(N):
        if j != i:
            sum = sum + A[i, j] * initial_vector[j]

    # this result is the updated element at given index of our solution vector.
    q.put((1 / A[index, index]) * (b[index] - sum))


if __name__ == '__main__':

    A = np.matrix([[12.,7,3],[1,5,1],[2,7,-11]])
    b = np.array([22.,7,-2])
    x = np.array([1.,2,1])
    q = mu.Queue()
    N = len(x)
    x_update = np.copy(x)
    p = []
    error = 1
    iteration = 0

    while error > ((10**(-14)) * (N**(1/2))):

        # assign a process to each element in the vector x, 
        # update one element with a single Jacobi step
        for i in range(N):
            process = mu.Process(target=Jacobi_step(i, x, q))
            p.append(process)
            process.start()

        # fill in the updated vector with each new element aquired by the last step
        for i in range(N):
            x_update[i] = q.get(True)

        # check for convergence 
        error = 0
        for n in range(N):
            error = error + abs(x_update[n] - x[n]) / ((abs(x_update[n]) + abs(x[n])) / 2)
            p[i].join()

        x = np.copy(x_update)

        iteration += 1
        print("iteration ", iteration, ":", x)
        del p[:]

Answer 1

SPINE是先进先出，这意味着插入的第一个元素是按插入顺序检索的第一个元素。

由于你无法控制它，我建议你在队列中插入元组，包含值和一些可用于对原始计算进行排序/关联的识别对象。

HIP_CENTER

此示例将索引与Queue一起放在结果中，以便在result = (1 / A[index, index]) * (b[index] - sum) q.put((index, result))之后获得索引并使用它来知道这是用于哪个计算：

Queue

或类似的东西。

我从Queue.get（）（Python）得到什么

1 个答案: