multitarea - Keras+Tensorflow y Multiprocesamiento en Python

multitarea en python

Question

Estoy usando Keras con Tensorflow como back-end.

Estoy tratando de guardar un modelo en mi proceso principal y luego cargar / ejecutar (es decir, llamar a model.predict ) dentro de otro proceso.

Actualmente solo estoy intentando el enfoque ingenuo de los documentos para guardar / cargar el modelo: https://keras.io/getting-started/faq/#how-can-i-save-a-keras-model .
Así que básicamente:

1. model.save() en el proceso principal
2. model = load_model() en proceso hijo
3. model.predict() en proceso hijo

Sin embargo, simplemente se cuelga de la llamada load_model .

Al buscar, descubrí esta respuesta potencialmente relacionada que sugiere que Keras solo se puede utilizar en un proceso: usar multiprocesamiento con theano pero no estoy seguro de si esto es cierto (parece que no puede encontrar mucho sobre esto).

¿Hay alguna manera de lograr mi objetivo? Una descripción de alto nivel o un breve ejemplo es muy apreciada.

Nota: He intentado enfoques a lo largo de las líneas de pasar un gráfico al proceso pero fallé ya que parece que los gráficos de tensorflow no son seleccionables (publicación SO relacionada para eso aquí: Tensorflow: pasar una sesión a un multiproceso de Python ). Si de hecho hay una manera de pasar el gráfico / modelo de tensorflow al proceso secundario, entonces también estoy abierto a eso.

¡Gracias!

Answer 1

Creé un decorador que reparó mi código.

from multiprocessing import Pipe, Process
def child_process(func):
"""Makes the function run as a separate process."""
def wrapper(*args, **kwargs):
def worker(conn, func, args, kwargs):
conn.send(func(*args, **kwargs))
conn.close()
parent_conn, child_conn = Pipe()
p = Process(target=worker, args=(child_conn, func, args, kwargs))
p.start()
ret = parent_conn.recv()
p.join()
return ret
return wrapper
@child_process
def keras_stuff():
""" Keras stuff here"""

Answer 2

Creé un ejemplo simple para mostrar cómo ejecutar el modelo Keras en múltiples procesos con múltiples gpus. Espero que esta muestra te pueda ayudar. https://github.com/yuanyuanli85/Keras-Multiple-Process-Prediction

Answer 3

Según mi experiencia, el problema radica en cargar Keras en un proceso y luego generar un nuevo proceso cuando las keras se han cargado en su entorno principal. Pero para algunas aplicaciones (como, por ejemplo, entrenar una mezcla de modelos Keras ) es simplemente mejor tener todas estas cosas en un solo proceso. Entonces, lo que aconsejo es el siguiente enfoque (un poco engorroso, pero que funciona para mí):

1. NO CARGUE KERAS A SU ENTORNO PRINCIPAL . Si desea cargar Keras / Theano / TensorFlow, hágalo solo en el entorno de funciones. Por ejemplo , no hagas esto:

   import keras
   def training_function(...):
   ...

   pero haz lo siguiente:

   def training_function(...):
   import keras
   ...

2. Ejecuto el trabajo conectado con cada modelo en un proceso separado: generalmente estoy creando trabajadores que están haciendo el trabajo (por ejemplo, capacitación, ajuste, puntuación) y los estoy ejecutando en procesos separados. Lo bueno de esto es que toda la memoria utilizada por este proceso se libera por completo cuando finaliza el proceso. Esto lo ayuda con un montón de problemas de memoria que generalmente encuentra cuando usa multiprocesamiento o incluso ejecuta varios modelos en un proceso. Entonces esto se ve, por ejemplo, así:

   def _training_worker(train_params):
   import keras
   model = obtain_model(train_params)
   model.fit(train_params)
   send_message_to_main_process(...)
   def train_new_model(train_params):
   training_process = multiprocessing.Process(target=_training_worker, args = train_params)
   training_process.start()
   get_message_from_training_process(...)
   training_process.join()

Un enfoque diferente es simplemente preparar diferentes guiones para diferentes acciones del modelo. Pero esto puede causar errores de memoria, especialmente cuando sus modelos consumen mucha memoria. NOTA: debido a esta razón, es mejor hacer que su ejecución sea estrictamente secuencial.