ใช้อาร์เรย์ numpy ในหน่วยความจำแบบแบ่งใช้สำหรับการประมวลผลหลายขั้นตอน

ฉันต้องการใช้อาร์เรย์ numpy ในหน่วยความจำที่ใช้ร่วมกันเพื่อใช้กับโมดูลมัลติโปรเซสเซอร์ ความยากคือการใช้มันเหมือนกับอาร์เรย์ numpy ไม่ใช่แค่อาร์เรย์ 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]

สิ่งนี้สร้างผลลัพธ์เช่น:

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

อาร์เรย์สามารถเข้าถึงได้ในลักษณะ ctypes เช่นarr[i]เหมาะสม อย่างไรก็ตามมันไม่ใช่อาร์เรย์ numpy และฉันไม่สามารถดำเนินการเช่น-1*arrหรือarr.sum(). ฉันคิดว่าวิธีแก้ปัญหาคือการแปลงอาร์เรย์ ctypes เป็นอาร์เรย์ numpy อย่างไรก็ตาม (นอกจากจะไม่สามารถทำงานนี้ได้) ฉันไม่เชื่อว่ามันจะถูกแชร์อีกต่อไป

ดูเหมือนว่าจะมีวิธีแก้ปัญหามาตรฐานสำหรับปัญหาที่พบบ่อย

เพื่อเพิ่มในคำตอบของ @ unutbu (ไม่มีแล้ว) และคำตอบของ @Henry Gomersall คุณสามารถใช้shared_arr.get_lock()เพื่อซิงโครไนซ์การเข้าถึงเมื่อจำเป็น:

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]

ตัวอย่าง

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()

หากคุณไม่ต้องการการเข้าถึงแบบซิงโครไนซ์หรือสร้างการล็อกของคุณเองก็mp.Array()ไม่จำเป็น คุณสามารถใช้mp.sharedctypes.RawArrayในกรณีนี้

Arrayวัตถุมีget_obj()วิธีการที่เกี่ยวข้องกับมันซึ่งจะส่งกลับอาร์เรย์ ctypes ที่นำเสนออินเตอร์เฟซบัฟเฟอร์ ฉันคิดว่าสิ่งต่อไปนี้น่าจะใช้ได้ ...

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]

เมื่อเรียกใช้สิ่งนี้จะพิมพ์องค์ประกอบแรกของaตอนนี้ที่เป็น 10.0 ซึ่งแสดงaและbเป็นเพียงสองมุมมองในหน่วยความจำเดียวกัน

เพื่อให้แน่ใจว่ายังปลอดภัยสำหรับมัลติโปรเซสเซอร์ฉันเชื่อว่าคุณจะต้องใช้acquireและreleaseวิธีการที่มีอยู่ในArrayวัตถุaและในตัวล็อคเพื่อให้แน่ใจว่าทั้งหมดเข้าถึงได้อย่างปลอดภัย (แม้ว่าฉันจะไม่ใช่ผู้เชี่ยวชาญด้าน โมดูลมัลติโปรเซสเซอร์)

แม้ว่าคำตอบที่ได้จะดีอยู่แล้ว แต่ก็มีวิธีแก้ปัญหานี้ที่ง่ายกว่ามากหากตรงตามเงื่อนไขสองประการ:

1. คุณใช้ระบบปฏิบัติการที่รองรับ POSIX (เช่น Linux, Mac OSX) และ
2. กระบวนการย่อยของคุณต้องการการเข้าถึงอาร์เรย์ที่แชร์แบบอ่านอย่างเดียว

ในกรณีนี้คุณไม่จำเป็นต้องซอกับการสร้างตัวแปรที่แชร์อย่างชัดเจนเนื่องจากกระบวนการย่อยจะถูกสร้างขึ้นโดยใช้ส้อม ลูกที่ถูกแยกจะแบ่งปันพื้นที่หน่วยความจำของผู้ปกครองโดยอัตโนมัติ ในบริบทของการประมวลผลหลายขั้นตอนของ Python หมายความว่ามันจะแชร์ตัวแปรระดับโมดูลทั้งหมด โปรดทราบว่าสิ่งนี้ไม่ถือเป็นข้อโต้แย้งที่คุณส่งผ่านไปยังกระบวนการย่อยของคุณอย่างชัดเจนหรือไปยังฟังก์ชันที่คุณเรียกใช้multiprocessing.Poolหรือมากกว่านั้น

ตัวอย่างง่ายๆ:

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)))

ฉันได้เขียนโมดูล python ขนาดเล็กที่ใช้หน่วยความจำที่ใช้ร่วมกัน POSIX เพื่อแชร์อาร์เรย์จำนวนนับระหว่างตัวแปล python บางทีคุณอาจจะพบว่ามีประโยชน์

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

นี่คือวิธีการทำงาน:

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])

คุณสามารถใช้sharedmemโมดูล: https://bitbucket.org/cleemesser/numpy-sharedmem

นี่คือรหัสดั้งเดิมของคุณคราวนี้ใช้หน่วยความจำที่ใช้ร่วมกันซึ่งทำหน้าที่เหมือนอาร์เรย์ NumPy (สังเกตคำสั่งสุดท้ายเพิ่มเติมที่เรียกใช้sum()ฟังก์ชัน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()