Keras + Tensorflow: Prognozy dla wielu procesorów graficznych

Question

Używam Keras z tensorflow jako zaplecza. Mam jeden skompilowany/wyszkolony model.

Moja pętla przewidywania jest wolna, więc chciałbym znaleźć sposób na zrównoleglenie wywołań predict_proba, aby przyspieszyć działanie. Chciałbym wziąć listę partii (danych), a następnie według dostępnego gpu, uruchomić model.predict_proba() nad podzestawem tych partii.
Zasadniczo:

data = [ batch_0, batch_1, ... , batch_N ] 
on gpu_0 => return predict_proba(batch_0) 
on gpu_1 => return predict_proba(batch_1) 
... 
on gpu_N => return predict_proba(batch_N) 

wiem, że jest to możliwe w czystej Tensorflow przypisać do danego ops GPU (https://www.tensorflow.org/tutorials/using_gpu). Jednak nie wiem, w jaki sposób przekłada się to na moją sytuację, odkąd zbudowałem/skompilowałem/wyszkoliłem mój model za pomocą api Keras'a.

Myślałem, że może potrzebowałem po prostu użyć modułu wieloprocesorowego Pythona i rozpocząć proces na Gpu, który działałby pod numerem predict_proba(batch_n). Wiem, że jest to teoretycznie możliwe, biorąc pod uwagę inne stanowisko SO: Keras + Tensorflow and Multiprocessing in Python. Jednak nadal pozostawia mi dylemat polegający na tym, że nie wiem, jak właściwie "wybrać" gpu do obsługi procesu.

Moje pytanie sprowadza się do: w jaki sposób można przeprowadzić jeden rzutowania równoległego dla jednego modelu w Kerasie na wielu procesach gpusowych, używając Tensorflow jako zaplecza Keras?

Dodatkowo jestem ciekawy, czy podobne równoległości do przewidywania jest możliwe tylko z jednym gpu.

Przykład wysokopoziomowego opisu lub kodu byłby bardzo doceniany!

Dzięki!

Answer 1

Stworzyłem jeden prosty przykład pokazujący, jak uruchomić model Keras w wielu procesach graficznych. Zasadniczo powstaje wiele procesów, a każdy proces jest właścicielem gpu. Aby określić identyfikator gpu w procesie, ustawienie zmiennej env CUDA_VISIBLE_DEVICES jest bardzo prostą metodą (os.environ ["CUDA_VISIBLE_DEVICES"]). Mam nadzieję, że to repozytorium git może ci pomóc.

https://github.com/yuanyuanli85/Keras-Multiple-Process-Prediction

Answer 2

Można użyć tej funkcji do parallelize modelowi Keras (kredyty na kuza55).
https://github.com/kuza55/keras-extras/blob/master/utils/multi_gpu.py .

from keras.layers import merge 
from keras.layers.core import Lambda 
from keras.models import Model 

import tensorflow as tf 

def make_parallel(model, gpu_count): 
    def get_slice(data, idx, parts): 
     shape = tf.shape(data) 
     size = tf.concat([ shape[:1] // parts, shape[1:] ],axis=0) 
     stride = tf.concat([ shape[:1] // parts, shape[1:]*0 ],axis=0) 
     start = stride * idx 
     return tf.slice(data, start, size) 

    outputs_all = [] 
    for i in range(len(model.outputs)): 
     outputs_all.append([]) 

    #Place a copy of the model on each GPU, each getting a slice of the batch 
    for i in range(gpu_count): 
     with tf.device('/gpu:%d' % i): 
      with tf.name_scope('tower_%d' % i) as scope: 

       inputs = [] 
       #Slice each input into a piece for processing on this GPU 
       for x in model.inputs: 
        input_shape = tuple(x.get_shape().as_list())[1:] 
        slice_n = Lambda(get_slice, output_shape=input_shape, arguments={'idx':i,'parts':gpu_count})(x) 
        inputs.append(slice_n)     

       outputs = model(inputs) 

       if not isinstance(outputs, list): 
        outputs = [outputs] 

       #Save all the outputs for merging back together later 
       for l in range(len(outputs)): 
        outputs_all[l].append(outputs[l]) 

    # merge outputs on CPU 
    with tf.device('/cpu:0'): 
     merged = [] 
     for outputs in outputs_all: 
      merged.append(merge(outputs, mode='concat', concat_axis=0)) 

     return Model(input=model.inputs, output=merged)