Python多进程处理（读、写）numpy矩阵

#定义一个double类型的RawArray，d表示double类型，100为其长度
import multiprocessing
X = multiprocessing.RawArray('d', 100)

#定义一个initializer函数
def init_pool(array):
    global glob_array    #定义全局变量
    glob_array = array
 
def func(array_SHAPE, alpha, i):
    for j in range(array_SHAPE[0]):  
        glob_array[i*array_SHAPE[0]+j] = i**2+j*alpha 
        # 子进程内直接读取全局变量glob_array，无需传入
        # glob_array为展平的矩阵（即multiprocessing.RawArray, 多进程不支持二维矩阵）
        # 此处需要对齐一维的glob_array与原始的二维array的对应位置关系。

if __name__ == '__main__'
    array = np.randn(30,30)
    func_partial = partial(func, array_SHAPE = array.shape, alpha = 3.1416) 
    #由于下面要使用的多线程的map函数仅支持输入一个参数，因此此处使用了python内置的偏函数
    #偏函数functools.partial()可以为某函数先行传入变量，第一个参数为函数名，其余参数为对应的原函数的输入变量。
    #此例中func_partial(i) 等同于 func(array_SHAPE, alpha, i)
    array_shared = multiprocessing.RawArray('d', array.ravel())  
    # 由于对矩阵元素的写入是有位置坐标的（各进程可以各自改动对应矩阵位置(即内存地址)处的值，
    # 故无需加进程锁
    p = multiprocessing.Pool(processes=6, initializer=init_pool, 
                             initargs=(array_shared,))
    # 定义一个进程池，指定进程数量(processes)，初始化函数(initializer)以及初始化函数中的输入(initargs)
    p.map(func_partial, range(array.shape[1]))
    # 此处使用进程池map()函数对numpy矩阵维度1(即，行)进行迭代
    # 此时可视为map函数向子进程中分配不同的行，各个子进程在分配的不同行中各自处理整行的数据。
    p.close()
    p.join()

    new_array = np.frombuffer(array_shared, np.double).reshape(array_SHAPE) 
    # 需要注意，此处要使用array_shared，而不是glob_array.
    # glob_array为子进程中的全局变量，在主进程中并未被定义，但主进程中的array_shared与子进程中的glob_radioScore_array指向同一内存地址.

import multiprocessing
import numpy as np
from functools import partial

# X = multiprocessing.RawArray('d', 100)
#
# X_shape = (16, 1000000)
# # Randomly generate some data
# data = np.random.randn(*X_shape)
# X = multiprocessing.RawArray('d', X_shape[0] * X_shape[1])
# # Wrap X as an numpy array so we can easily manipulates its data.
# X_np = np.frombuffer(X, dtype=np.float64).reshape(X_shape)
# # Copy data to our shared array.
# np.copyto(X_np, data)


# 定义一个initializer函数
def init_pool(array):
    global glob_array  # 定义全局变量
    glob_array = array


def func(i,array_SHAPE, alpha):
    print(array_SHAPE, alpha,i)
    for j in range(array_SHAPE):
        glob_array[i * array_SHAPE + j] = i ** 2 + j * alpha
        # 子进程内直接读取全局变量glob_array，无需传入
        # glob_array为展平的矩阵（即multiprocessing.RawArray, 多进程不支持二维矩阵）
        # 此处需要对齐一维的glob_array与原始的二维array的对应位置关系。

if __name__ == '__main__':
    X_shape = (30000, 30000)
    array = np.random.randn(*X_shape)
    func_partial = partial(func, array_SHAPE=array.shape[0], alpha=3.1416)
    # func_partial = partial(func, array_SHAPE=X_shape[0], alpha=3.1416)
    #由于下面要使用的多线程的map函数仅支持输入一个参数，因此此处使用了python内置的偏函数
    #偏函数functools.partial()可以为某函数先行传入变量，第一个参数为函数名，其余参数为对应的原函数的输入变量。
    #此例中func_partial(i) 等同于 func(array_SHAPE, alpha, i)
    array_shared = multiprocessing.RawArray('d', array.ravel())
    # 由于对矩阵元素的写入是有位置坐标的（各进程可以各自改动对应矩阵位置(即内存地址)处的值，
    # 故无需加进程锁
    p = multiprocessing.Pool(processes=6, initializer=init_pool,
                             initargs=(array_shared,))
    # 定义一个进程池，指定进程数量(processes)，初始化函数(initializer)以及初始化函数中的输入(initargs)
    p.map(func_partial, range(array.shape[1]))
    #p.map(func_partial, list(range(X_shape[1])))
    # p.map(func_partial, array.shape[1])
    # p.map(func_partial, range(16))
    # 此处使用进程池map()函数对numpy矩阵维度1(即，行)进行迭代
    # 此时可视为map函数向子进程中分配不同的行，各个子进程在分配的不同行中各自处理整行的数据。
    p.close()
    p.join()

Traceback (most recent call last):
  File "C:\yzm1\PycharmProjects\onnx_pro\test14.py", line 46, in <module>
    p.map(func_partial, range(array.shape[1]))
  File "C:\Users\13269\anaconda3\lib\multiprocessing\pool.py", line 367, in map
    return self._map_async(func, iterable, mapstar, chunksize).get()
  File "C:\Users\13269\anaconda3\lib\multiprocessing\pool.py", line 774, in get
    raise self._value
TypeError: func() got multiple values for argument 'array_SHAPE'