多进程-python-带多维数组的简单循环

我不熟悉多处理，我无法理解文档。如何跨多个进程运行此窗体的函数？这是我的尝试。我想通过多个进程运行卷积（从其他开始），以提高速度

from multiprocessing import Process, Value, Array 
import numpy as np
import scipy

A = np.ones((10,10,4))
B = np.random.rand(10,10)

def loop(i):
     C[:,:,i] = scipy.ndimage.convolve(A[:,:,i],B)

if __name__ == '__main__':
     C = Array('i',np.zeros((10,10,4)))
     arr    = Array('i',range(4))
     for i in arr:
        p = Process(target = loop, args=i)
        p.start()
        p.join()

当前错误：

回溯（最近一次呼叫最后一次）：

文件“”，第11行，在 y_检验=数组（'i'，np.零（（10,10,4）））

文件“/usr/lib/python2.7/multiprocessing/init.py”，第260行，在 排列 返回数组（类型代码或类型、大小或初始值设定项，**kwds）

文件“/usr/lib/python2.7/multiprocessing/sharedtypes.py”，第115行， 排列 obj=RAWARY（类型代码或类型、大小或初始值设定项）

文件“/usr/lib/python2.7/multiprocessing/sharedtypes.py”，第89行， 原始数组 结果。init（*size\u或\u初始值设定项）

TypeError：只有长度为1的数组才能转换为Python标量

y_测试将是输出

异常 这里有一个例外，因为数组（…）的第一个参数需要是一个有效的

ctype

比如

c_bool

，

c_int

，…，或者是一个表示这种类型的字符，比如

'i'

“y_测试”不是有效的ctype。似乎您输入了变量名，而不是它们的类型

如果要在此处使用整数，请尝试以下操作：

y_test = Array('i', np.zeros((10,10,4)))

有关阵列工作原理的更多详细信息，请参阅。还有一个你可以使用的

附加思想，并行执行 另外，请记住，该进程将仅使用您提供的参数运行函数

循环

。您提供了两个数组，但循环函数似乎需要一个数组和一个整数作为参数。当您希望使用不同的i值运行循环函数的多个实例时，可以创建多个流程实例，并为每个流程实例指定不同的值作为参数，如下所示：

p1 = Process(target = loop, args = (y_test, 1))
p2 = Process(target = loop, args = (y_test, 2))

每个进程将使用不同的参数运行循环函数。你也可以把它放在一个循环中，迭代你的

arr

来处理arr中的每一个值，我想这就是你想要的 这里有一个例外，因为数组（…）的第一个参数需要是一个有效的

ctype

比如

c_bool

，

c_int

，…，或者是一个表示这种类型的字符，比如

'i'

“y_测试”不是有效的ctype。似乎您输入了变量名，而不是它们的类型

如果要在此处使用整数，请尝试以下操作：

y_test = Array('i', np.zeros((10,10,4)))

有关阵列工作原理的更多详细信息，请参阅。还有一个你可以使用的

附加思想，并行执行 另外，请记住，该进程将仅使用您提供的参数运行函数

循环

。您提供了两个数组，但循环函数似乎需要一个数组和一个整数作为参数。当您希望使用不同的i值运行循环函数的多个实例时，可以创建多个流程实例，并为每个流程实例指定不同的值作为参数，如下所示：

p1 = Process(target = loop, args = (y_test, 1))
p2 = Process(target = loop, args = (y_test, 2))

每个进程将使用不同的参数运行循环函数。你也可以把它放在一个循环中，迭代你的

arr

来处理arr中的每一个值，我想这就是你想要的

y_test = Array('y_test',np.zeros((10,10,4)))

这显然是错误的。文档中说明了

多处理.Array

多处理.Array（typecode\u或\u type，size\u或\u初始值设定项，*，lock=True）
…
typecode_或_type确定返回数组元素的类型：它是ctypes类型或数组模块所使用类型的单字符typecode

错误只是说

y\u test

不是已知类型

不管怎样，你没有把问题放在正确的一边

因为

多处理.Array

是存储在共享内存中的基本类型数组。在这里，您可以通过numpy数组的

flat

迭代器轻松构建这样的数组：

y_test = Array('d', np.zeros((10,10,4)).flat)

resul = np.array(y_test).reshape((10,10,4), order = 'f')

y_测试现在是一个400倍的共享内存阵列

让我们暂时忘记多重处理。您可以这样处理：

for i in range(r):
    npi = start[:,:,i] + i
    y_test[10*10*i:10*10*(i+1)] = npi.flatten()

现在可以将其转换回numpy阵列：

y_test = Array('d', np.zeros((10,10,4)).flat)

resul = np.array(y_test).reshape((10,10,4), order = 'f')

这里有趣的一点是，10x10阵列的每个处理都会访问共享内存的不同部分：我们可以在不同的进程中构建它

def process(a, i):
    npi = start[:,:, i] + i    # computes a numpy array
    a[10*10*i:10*10*(i+1)] = npi.flatten()  # stores it in shared memory

def main():
    y_test = Array('d', np.zeros((10,10,4)).flat) # initializes shared memory
    processes = []
    for i in range(4):  # uses 4 processes, one per each 10x10 array
        p = Process(target = process, args = (y_test, i))
        processes.append(p)
        p.start()
        print("Start", i, p.pid)  # to be sure the processes were started
    for i in range(4):
        p.join()        # join child processes
        print("Join", i, p.exitcode)
    resul = np.array(y_test).reshape((10,10,4), order='f') # rebuild the final numpy array
    print(resul)

if __name__ == '__main__':
    main()

冒犯的界线是

y_test = Array('y_test',np.zeros((10,10,4)))

这显然是错误的。文档中说明了

多处理.Array

多处理.Array（typecode\u或\u type，size\u或\u初始值设定项，*，lock=True）
…
typecode_或_type确定返回数组元素的类型：它是ctypes类型或数组模块所使用类型的单字符typecode

错误只是说

y\u test

不是已知类型

不管怎样，你没有把问题放在正确的一边

因为

多处理.Array

是存储在共享内存中的基本类型数组。在这里，您可以通过numpy数组的

flat

迭代器轻松构建这样的数组：

y_test = Array('d', np.zeros((10,10,4)).flat)

resul = np.array(y_test).reshape((10,10,4), order = 'f')

y_测试现在是一个400倍的共享内存阵列

让我们暂时忘记多重处理。您可以这样处理：

for i in range(r):
    npi = start[:,:,i] + i
    y_test[10*10*i:10*10*(i+1)] = npi.flatten()

现在可以将其转换回numpy阵列：

y_test = Array('d', np.zeros((10,10,4)).flat)

resul = np.array(y_test).reshape((10,10,4), order = 'f')

这里有趣的一点是，10x10阵列的每个处理都会访问共享内存的不同部分：我们可以在不同的进程中构建它

def process(a, i):
    npi = start[:,:, i] + i    # computes a numpy array
    a[10*10*i:10*10*(i+1)] = npi.flatten()  # stores it in shared memory

def main():
    y_test = Array('d', np.zeros((10,10,4)).flat) # initializes shared memory
    processes = []
    for i in range(4):  # uses 4 processes, one per each 10x10 array
        p = Process(target = process, args = (y_test, i))
        processes.append(p)
        p.start()
        print("Start", i, p.pid)  # to be sure the processes were started
    for i in range(4):
        p.join()        # join child processes
        print("Join", i, p.exitcode)
    resul = np.array(y_test).reshape((10,10,4), order='f') # rebuild the final numpy array
    print(resul)

if __name__ == '__main__':
    main()

---

你的代码当前在做什么？你可能想从这里开始，向你展示如何正确创建数组，这似乎是你的问题。你的代码当前在做什么？你可能想从这里开始，向你展示如何正确创建数组，这似乎是你的问题。我得到一个错误：'类型错误：只能转换长度为1的数组变成Python标量的ori