다중 처리를 위해 공유 메모리에서 numpy 배열 사용

다중 처리 모듈과 함께 사용하기 위해 공유 메모리에서 numpy 배열을 사용하고 싶습니다. 어려운 점은 ctypes 배열이 아니라 numpy 배열처럼 사용하는 것입니다.

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메서드 를 사용해야하며 , 및 내장 된 잠금 장치를 사용하여 안전하게 액세스 할 수 있도록해야합니다. 다중 프로세서 모듈).Arraya

이미 주어진 대답은 좋지만 두 가지 조건이 충족되면이 문제에 대한 훨씬 더 쉬운 해결책이 있습니다.

1. 당신은에있는 POSIX 호환 운영 체제 (예 : 리눅스, 맥 OSX); 과
2. 자식 프로세스 는 공유 배열에 대한 읽기 전용 액세스 권한 이 필요합니다 .

이 경우 자식 프로세스가 포크를 사용하여 생성되므로 명시 적으로 변수를 공유하도록 만들 필요가 없습니다. 분기 된 자식은 자동으로 부모의 메모리 공간을 공유합니다. 파이썬 다중 처리의 맥락에서 이것은 모든 모듈 수준 변수를 공유 함을 의미합니다 . 이것은 자식 프로세스 또는 호출하는 함수에 명시 적으로 전달하는 인수 에는 적용되지 않습니다 .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)))

POSIX 공유 메모리를 사용하여 파이썬 인터프리터간에 numpy 배열을 공유하는 작은 파이썬 모듈을 작성했습니다. 아마도 당신은 그것이 편리하다는 것을 알게 될 것입니다.

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 배열처럼 동작하는 공유 메모리를 사용하는 원본 코드입니다 (NumPy sum()함수를 호출하는 추가 마지막 문에 유의하십시오 ).

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