python中的全局变量'；s multiprocessing.Pool类

我有一个相对简单的并行化问题，它给我带来了太多的问题，使我无法有效地实现。我的程序的核心是两个矩阵和两个向量，我希望执行的两个计算中的每一个都有一个矩阵和向量

在代码中，这意味着我有

import numpy as np
matrices = dict([("type1", np.random.rand(10,10)), ("type2", np.random.rand(10,10))])
vectors = dict([("type1", np.random.rand(10)), ("type2", np.random.rand(10))])

我想做的（不是真的，但在简化的情况下）是：

对于每种类型，我有一个非常大的向量列表：

input_vectors = [np.random.rand(10) for i in range(1000)]

我想计算

A*v+b

，其中

A

是矩阵，

b

是每种类型的向量

因此，我需要的单线程代码是

def f(input_vector, matricx, vector):
    return np.dot(matrix, input_vector) + vector

results = {}
for type in ['type1', 'type2']:
    results[type] = []
    for input_vector in input_vectors:
        results.append(f(input_vector, matrices[type], vectors[type]))

然而，我想同时做到这一点。然而，我不知道如何解决这个问题，我想要映射到向量列表上的函数作为它的输入不仅仅是向量

我想写一些像这样的东西

from multiprocessing import Pool
p = Pool(4)
for type in types:
    p.map(lambda x: f(x, matrices[type], vectors[type] , input_vectors))

但是，这不起作用，因为lambda函数不能被pickle。有一件事确实有效，那就是把我想乘的矩阵附加到每个向量上，但这在内存方面当然是不可行的

有没有想过如何优雅地解决我的难题

---

我希望池中的每个元素都有一个它必须与之相乘的矩阵和向量的副本，但我不知道如何在

多处理中做到这一点

def f(matrix, vector, input_vector):
    return np.dot(matrix, input_vector) + vector

results = {}
for type_ in types:
    func = partial(f, matrices[type_], vectors[type_])
    results[type_] = p.map(func, input_vectors)

如果您希望在启动
池时将整个
矩阵
和
向量
列表传递给每个子级，然后在调用
映射
时只传递
类型
，您也可以这样做。使用
初始值设定项
/
initargs
参数来传递列表，然后在
初始值设定项
函数中使其成为全局的。这将使它们在每个子进程中都是全局的：

matrices = vectors = None

def init(_matrices, _vectors):
    global matrices, vectors
    matrices = _matrices
    vectors = _vectors


def f(type_, input_vector):
    return np.dot(matrices[type_], input_vector) + vectors[type_]

def main():
    # <declare matrices, vectors, input_vectors here>
    p = multiprocessing.Pool(initializer=init, 
                             initargs=(matrices, vectors))
    results = {}
    for type_ in ['type1', 'type2']:
        func = partial(f, type_)
        results[type_] = p.map(func, input_vectors)

if __name__ == "__main__":
    main()

矩阵=向量=无
def init（_矩阵，_向量）：
全局矩阵、向量
矩阵=_矩阵
向量=_向量
def f（类型、输入向量）：
返回np.dot（矩阵[type]，输入向量）+向量[type]
def main（）：
# 
p=多处理.Pool（初始值设定项=init，
initargs=（矩阵、向量））
结果={}
对于['type1'，'type2']中的类型uuu]：
func=部分（f，类型u1）
结果[类型]=p.map（func，输入向量）
如果名称=“\uuuuu main\uuuuuuuu”：
main（）
用于将多个参数传递给
map
：

def f(matrix, vector, input_vector):
    return np.dot(matrix, input_vector) + vector

results = {}
for type_ in types:
    func = partial(f, matrices[type_], vectors[type_])
    results[type_] = p.map(func, input_vectors)

如果您希望在启动
池时将整个
矩阵
和
向量
列表传递给每个子级，然后在调用
映射
时只传递
类型
，您也可以这样做。使用
初始值设定项
/
initargs
参数来传递列表，然后在
初始值设定项
函数中使其成为全局的。这将使它们在每个子进程中都是全局的：

matrices = vectors = None

def init(_matrices, _vectors):
    global matrices, vectors
    matrices = _matrices
    vectors = _vectors


def f(type_, input_vector):
    return np.dot(matrices[type_], input_vector) + vectors[type_]

def main():
    # <declare matrices, vectors, input_vectors here>
    p = multiprocessing.Pool(initializer=init, 
                             initargs=(matrices, vectors))
    results = {}
    for type_ in ['type1', 'type2']:
        func = partial(f, type_)
        results[type_] = p.map(func, input_vectors)

if __name__ == "__main__":
    main()

矩阵=向量=无
def init（_矩阵，_向量）：
全局矩阵、向量
矩阵=_矩阵
向量=_向量
def f（类型、输入向量）：
返回np.dot（矩阵[type]，输入向量）+向量[type]
def main（）：
# 
p=多处理.Pool（初始值设定项=init，
initargs=（矩阵、向量））
结果={}
对于['type1'，'type2']中的类型uuu]：
func=部分（f，类型u1）
结果[类型]=p.map（func，输入向量）
如果名称=“\uuuuu main\uuuuuuuu”：
main（）
用于将多个参数传递给
map
：

def f(matrix, vector, input_vector):
    return np.dot(matrix, input_vector) + vector

results = {}
for type_ in types:
    func = partial(f, matrices[type_], vectors[type_])
    results[type_] = p.map(func, input_vectors)

如果您希望在启动
池时将整个
矩阵
和
向量
列表传递给每个子级，然后在调用
映射
时只传递
类型
，您也可以这样做。使用
初始值设定项
/
initargs
参数来传递列表，然后在
初始值设定项
函数中使其成为全局的。这将使它们在每个子进程中都是全局的：

matrices = vectors = None

def init(_matrices, _vectors):
    global matrices, vectors
    matrices = _matrices
    vectors = _vectors


def f(type_, input_vector):
    return np.dot(matrices[type_], input_vector) + vectors[type_]

def main():
    # <declare matrices, vectors, input_vectors here>
    p = multiprocessing.Pool(initializer=init, 
                             initargs=(matrices, vectors))
    results = {}
    for type_ in ['type1', 'type2']:
        func = partial(f, type_)
        results[type_] = p.map(func, input_vectors)

if __name__ == "__main__":
    main()

矩阵=向量=无
def init（_矩阵，_向量）：
全局矩阵、向量
矩阵=_矩阵
向量=_向量
def f（类型、输入向量）：
返回np.dot（矩阵[type]，输入向量）+向量[type]
def main（）：
# 
p=多处理.Pool（初始值设定项=init，
initargs=（矩阵、向量））
结果={}
对于['type1'，'type2']中的类型uuu]：
func=部分（f，类型u1）
结果[类型]=p.map（func，输入向量）
如果名称=“\uuuuu main\uuuuuuuu”：
main（）
用于将多个参数传递给
map
：

def f(matrix, vector, input_vector):
    return np.dot(matrix, input_vector) + vector

results = {}
for type_ in types:
    func = partial(f, matrices[type_], vectors[type_])
    results[type_] = p.map(func, input_vectors)

如果您希望在启动
池时将整个
矩阵
和
向量
列表传递给每个子级，然后在调用
映射
时只传递
类型
，您也可以这样做。使用
初始值设定项
/
initargs
参数来传递列表，然后在
初始值设定项
函数中使其成为全局的。这将使它们在每个子进程中都是全局的：

matrices = vectors = None

def init(_matrices, _vectors):
    global matrices, vectors
    matrices = _matrices
    vectors = _vectors


def f(type_, input_vector):
    return np.dot(matrices[type_], input_vector) + vectors[type_]

def main():
    # <declare matrices, vectors, input_vectors here>
    p = multiprocessing.Pool(initializer=init, 
                             initargs=(matrices, vectors))
    results = {}
    for type_ in ['type1', 'type2']:
        func = partial(f, type_)
        results[type_] = p.map(func, input_vectors)

if __name__ == "__main__":
    main()

矩阵=向量=无
def init（_矩阵，_向量）：
全局矩阵、向量
矩阵=_矩阵
向量=_向量
def f（类型、输入向量）：
返回np.dot（矩阵[type]，输入向量）+向量[type]
def main（）：
# 
p=多处理.Pool（初始值设定项=init，
initargs=（矩阵、向量））
结果={}
对于['type1'，'type2']中的类型uuu]：
func=部分（f，类型u1）
结果[类型]=p.map（func，输入向量）
如果名称=“\uuuuu main\uuuuuuuu”：
main（）
谢谢您的回答！这只是一个小问题，这个方法真的会导致每个进程都有其各自的矩阵副本吗？如果我对多重处理的理解正确的话，应该是这样的…@5xum Conce