Sử dụng mảng numpy trong bộ nhớ dùng chung để xử lý đa

Tôi muốn sử dụng một mảng numpy trong bộ nhớ dùng chung để sử dụng với mô-đun đa xử lý. Khó khăn là sử dụng nó như một mảng numpy, và không chỉ như một mảng ctypes.

from multiprocessing import Process, Array
import scipy

def f(a):
    a[0] = -a[0]

if __name__ == '__main__':
    # Create the array
    N = int(10)
    unshared_arr = scipy.rand(N)
    arr = Array('d', unshared_arr)
    print "Originally, the first two elements of arr = %s"%(arr[:2])

    # Create, start, and finish the child processes
    p = Process(target=f, args=(arr,))
    p.start()
    p.join()

    # Printing out the changed values
    print "Now, the first two elements of arr = %s"%arr[:2]

Điều này tạo ra đầu ra như:

Originally, the first two elements of arr = [0.3518653236697369, 0.517794725524976]
Now, the first two elements of arr = [-0.3518653236697369, 0.517794725524976]

Mảng có thể được truy cập theo cách ctypes, ví dụ như hợp arr[i]lý. Tuy nhiên, nó không phải là một mảng phức tạp và tôi không thể thực hiện các phép toán như -1*arr, hoặc arr.sum(). Tôi cho rằng một giải pháp sẽ là chuyển đổi mảng ctypes thành một mảng numpy. Tuy nhiên (ngoài việc không thể thực hiện điều này), tôi không tin rằng nó sẽ được chia sẻ nữa.

Có vẻ như sẽ có một giải pháp tiêu chuẩn cho những gì phải là một vấn đề chung.

Để thêm vào câu trả lời của @ unutbu (không còn nữa) và @Henry Gomersall. Bạn có thể sử dụng shared_arr.get_lock()để đồng bộ hóa quyền truy cập khi cần:

shared_arr = mp.Array(ctypes.c_double, N)
# ...
def f(i): # could be anything numpy accepts as an index such another numpy array
    with shared_arr.get_lock(): # synchronize access
        arr = np.frombuffer(shared_arr.get_obj()) # no data copying
        arr[i] = -arr[i]

Thí dụ

import ctypes
import logging
import multiprocessing as mp

from contextlib import closing

import numpy as np

info = mp.get_logger().info

def main():
    logger = mp.log_to_stderr()
    logger.setLevel(logging.INFO)

    # create shared array
    N, M = 100, 11
    shared_arr = mp.Array(ctypes.c_double, N)
    arr = tonumpyarray(shared_arr)

    # fill with random values
    arr[:] = np.random.uniform(size=N)
    arr_orig = arr.copy()

    # write to arr from different processes
    with closing(mp.Pool(initializer=init, initargs=(shared_arr,))) as p:
        # many processes access the same slice
        stop_f = N // 10
        p.map_async(f, [slice(stop_f)]*M)

        # many processes access different slices of the same array
        assert M % 2 # odd
        step = N // 10
        p.map_async(g, [slice(i, i + step) for i in range(stop_f, N, step)])
    p.join()
    assert np.allclose(((-1)**M)*tonumpyarray(shared_arr), arr_orig)

def init(shared_arr_):
    global shared_arr
    shared_arr = shared_arr_ # must be inherited, not passed as an argument

def tonumpyarray(mp_arr):
    return np.frombuffer(mp_arr.get_obj())

def f(i):
    """synchronized."""
    with shared_arr.get_lock(): # synchronize access
        g(i)

def g(i):
    """no synchronization."""
    info("start %s" % (i,))
    arr = tonumpyarray(shared_arr)
    arr[i] = -1 * arr[i]
    info("end   %s" % (i,))

if __name__ == '__main__':
    mp.freeze_support()
    main()

Nếu bạn không cần quyền truy cập đồng bộ hoặc bạn tạo khóa của riêng mình thì mp.Array()không cần thiết. Bạn có thể sử dụng mp.sharedctypes.RawArraytrong trường hợp này.

Đối Arraytượng có một get_obj()phương thức được liên kết với nó, phương thức này trả về mảng ctypes hiển thị một giao diện đệm. Tôi nghĩ những điều sau đây sẽ hoạt động ...

from multiprocessing import Process, Array
import scipy
import numpy

def f(a):
    a[0] = -a[0]

if __name__ == '__main__':
    # Create the array
    N = int(10)
    unshared_arr = scipy.rand(N)
    a = Array('d', unshared_arr)
    print "Originally, the first two elements of arr = %s"%(a[:2])

    # Create, start, and finish the child process
    p = Process(target=f, args=(a,))
    p.start()
    p.join()

    # Print out the changed values
    print "Now, the first two elements of arr = %s"%a[:2]

    b = numpy.frombuffer(a.get_obj())

    b[0] = 10.0
    print a[0]

Khi chạy, phần tử này in ra phần tử đầu tiên ahiện là 10.0, hiển thị avà bchỉ là hai khung nhìn vào cùng một bộ nhớ.

Để đảm bảo rằng nó vẫn an toàn với đa xử lý, tôi tin rằng bạn sẽ phải sử dụng các phương thức acquirevà releasephương thức tồn tại trên Arrayđối tượng acũng như khóa tích hợp của nó để đảm bảo rằng tất cả các đối tượng đều được truy cập an toàn (mặc dù tôi không phải là chuyên gia về mô-đun đa xử lý).

Mặc dù các câu trả lời đã đưa ra là tốt, nhưng có một giải pháp dễ dàng hơn nhiều cho vấn đề này với điều kiện hai điều kiện được đáp ứng:

1. Bạn đang sử dụng hệ điều hành tương thích với POSIX (ví dụ: Linux, Mac OSX); và
2. Các quy trình con của bạn cần quyền truy cập chỉ đọc vào mảng được chia sẻ.

Trong trường hợp này, bạn không cần phải làm cho các biến được chia sẻ một cách rõ ràng, vì các quy trình con sẽ được tạo bằng cách sử dụng một nhánh rẽ. Một con được chia tự động chia sẻ không gian bộ nhớ của cha mẹ. Trong bối cảnh đa xử lý Python, điều này có nghĩa là nó chia sẻ tất cả các biến cấp mô-đun ; lưu ý rằng điều này không áp dụng cho các đối số mà bạn chuyển rõ ràng cho các quy trình con của bạn hoặc cho các hàm mà bạn gọi trên một multiprocessing.Poolhoặc lâu hơn.

Một ví dụ đơn giản:

import multiprocessing
import numpy as np

# will hold the (implicitly mem-shared) data
data_array = None

# child worker function
def job_handler(num):
    # built-in id() returns unique memory ID of a variable
    return id(data_array), np.sum(data_array)

def launch_jobs(data, num_jobs=5, num_worker=4):
    global data_array
    data_array = data

    pool = multiprocessing.Pool(num_worker)
    return pool.map(job_handler, range(num_jobs))

# create some random data and execute the child jobs
mem_ids, sumvals = zip(*launch_jobs(np.random.rand(10)))

# this will print 'True' on POSIX OS, since the data was shared
print(np.all(np.asarray(mem_ids) == id(data_array)))

Tôi đã viết một mô-đun python nhỏ sử dụng bộ nhớ chia sẻ POSIX để chia sẻ các mảng numpy giữa các trình thông dịch python. Có thể bạn sẽ thấy nó tiện dụng.

https://pypi.python.org/pypi/SharedArray

Đây là cách nó hoạt động:

import numpy as np
import SharedArray as sa

# Create an array in shared memory
a = sa.create("test1", 10)

# Attach it as a different array. This can be done from another
# python interpreter as long as it runs on the same computer.
b = sa.attach("test1")

# See how they are actually sharing the same memory block
a[0] = 42
print(b[0])

# Destroying a does not affect b.
del a
print(b[0])

# See how "test1" is still present in shared memory even though we
# destroyed the array a.
sa.list()

# Now destroy the array "test1" from memory.
sa.delete("test1")

# The array b is not affected, but once you destroy it then the
# data are lost.
print(b[0])

Bạn có thể sử dụng sharedmemmô-đun: https://bitbucket.org/cleemesser/numpy-sharedmem

Sau đó, đây là mã ban đầu của bạn, lần này sử dụng bộ nhớ dùng chung hoạt động giống như một mảng NumPy (lưu ý câu lệnh cuối cùng bổ sung gọi một sum()hàm NumPy ):

from multiprocessing import Process
import sharedmem
import scipy

def f(a):
    a[0] = -a[0]

if __name__ == '__main__':
    # Create the array
    N = int(10)
    unshared_arr = scipy.rand(N)
    arr = sharedmem.empty(N)
    arr[:] = unshared_arr.copy()
    print "Originally, the first two elements of arr = %s"%(arr[:2])

    # Create, start, and finish the child process
    p = Process(target=f, args=(arr,))
    p.start()
    p.join()

    # Print out the changed values
    print "Now, the first two elements of arr = %s"%arr[:2]

    # Perform some NumPy operation
    print arr.sum()