Usa l'array numpy nella memoria condivisa per il multiprocessing

Vorrei utilizzare un array numpy nella memoria condivisa da utilizzare con il modulo multiprocessing. La difficoltà è usarlo come un array numpy e non solo come array 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]

Questo produce output come:

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

È possibile accedere all'array in un modo ctypes, ad esempio arr[i]ha senso. Tuttavia, non è un array numpy e non posso eseguire operazioni come -1*arr, o arr.sum(). Suppongo che una soluzione sarebbe convertire l'array ctypes in un array numpy. Tuttavia (oltre a non essere in grado di farlo funzionare), non credo che sarebbe più condiviso.

Sembra che ci sarebbe una soluzione standard a quello che deve essere un problema comune.

Da aggiungere alle risposte di @ unutbu (non più disponibile) e di @Henry Gomersall. È possibile utilizzare shared_arr.get_lock()per sincronizzare l'accesso quando necessario:

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]

Esempio

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

Se non hai bisogno dell'accesso sincronizzato o crei i tuoi lucchetti, mp.Array()non è necessario. Potresti usare mp.sharedctypes.RawArrayin questo caso.

L' Arrayoggetto ha un get_obj()metodo associato con esso, che restituisce la matrice ctypes che presenta un'interfaccia buffer. Penso che quanto segue dovrebbe funzionare ...

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]

Quando viene eseguito, viene stampato il primo elemento di anow 10.0, che mostra ae bsono solo due visualizzazioni nella stessa memoria.

Per assicurarti che sia ancora sicuro per multiprocessore, credo che dovrai usare i metodi acquiree releaseche esistono Arraysull'oggetto a, e il suo blocco integrato per assicurarti che sia tutto accessibile in modo sicuro (anche se non sono un esperto di modulo multiprocessore).

Sebbene le risposte già fornite siano buone, esiste una soluzione molto più semplice a questo problema a condizione che siano soddisfatte due condizioni:

1. Sei su un sistema operativo conforme a POSIX (ad esempio Linux, Mac OSX); e
2. I tuoi processi figli necessitano dell'accesso in sola lettura all'array condiviso.

In questo caso non è necessario giocherellare con la condivisione esplicita delle variabili, poiché i processi figli verranno creati utilizzando un fork. Un bambino biforcuto condivide automaticamente lo spazio di memoria del genitore. Nel contesto del multiprocessing di Python, questo significa che condivide tutte le variabili a livello di modulo ; nota che questo non vale per gli argomenti che passi esplicitamente ai tuoi processi figli o alle funzioni che chiami su uno multiprocessing.Poolo giù di lì.

Un semplice esempio:

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

Ho scritto un piccolo modulo python che utilizza la memoria condivisa POSIX per condividere array numpy tra interpreti python. Forse lo troverai utile.

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

Ecco come funziona:

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

Puoi usare il sharedmemmodulo: https://bitbucket.org/cleemesser/numpy-sharedmem

Ecco quindi il tuo codice originale, questa volta usando la memoria condivisa che si comporta come un array NumPy (nota l'ultima istruzione aggiuntiva che chiama una sum()funzione 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()