tensorflow - Cómo usar evaluation_loop con train_loop en tf-slim

Question

Estoy tratando de implementar algunos modelos diferentes y entrenarlos en CIFAR-10, y quiero usar TF-slim para hacer esto. Parece que TF-slim tiene dos bucles principales que son útiles durante el entrenamiento: train_loop y evaluation_loop.

Mi pregunta es: ¿cuál es la forma canónica de usar estos bucles? Como seguimiento: ¿es posible usar la detención anticipada con train_loop?

Actualmente tengo un modelo y mi archivo de entrenamiento train.py se parece a esto

import ...
train_log_dir = ...

with tf.device("/cpu:0"):
  images, labels, dataset = set_up_input_pipeline_with_fancy_prefetching( 
                                                                subset=''train'', ... )
logits, end_points = set_up_model( images ) // Possibly using many GPUs
total_loss = set_up_loss( logits, labels, dataset )
optimizer, global_step = set_up_optimizer( dataset )
train_tensor = slim.learning.create_train_op( 
                                      total_loss, 
                                      optimizer,
                                      global_step=global_step,
                                      clip_gradient_norm=FLAGS.clip_gradient_norm,
                                      summarize_gradients=True)
slim.learning.train(train_tensor, 
                      logdir=train_log_dir,
                      local_init_op=tf.initialize_local_variables(),
                      save_summaries_secs=FLAGS.save_summaries_secs,
                      save_interval_secs=FLAGS.save_interval_secs)

Lo cual es asombroso hasta ahora: mis modelos se entrenan y convergen muy bien. Puedo ver esto a partir de los eventos en train_log_dir donde todas las métricas van en la dirección correcta. Y yendo en la dirección correcta me hace feliz.

Pero me gustaría verificar que las métricas también estén mejorando en el conjunto de validación. No conozco ninguna forma de hacer con TF-slim de una manera que funciona bien con el ciclo de entrenamiento, así que creé un segundo archivo llamado eval.py que contiene mi ciclo de evaluación.

import ...
train_log_dir = ...

with tf.device("/cpu:0"):
  images, labels, dataset = set_up_input_pipeline_with_fancy_prefetching( 
                                                                subset=''validation'', ... )
logits, end_points = set_up_model( images )
summary_ops, names_to_values, names_to_updates = create_metrics_and_summary_ops( 
                                                                logits,
                                                                labels,
                                                                dataset.num_classes() )

slim.get_or_create_global_step()
slim.evaluation.evaluation_loop(
      '''',
      checkpoint_dir=train_log_dir,
      logdir=train_log_dir,
      num_evals=FLAGS.num_eval_batches,
      eval_op=names_to_updates.values(),
      summary_op=tf.merge_summary(summary_ops),
      eval_interval_secs=FLAGS.eval_interval_secs,
      session_config=config)

Preguntas:

1) Actualmente tengo este modelo para evaluation_loop que almacena una GPU completa, pero rara vez se usa. Supongo que hay una mejor manera de asignar recursos. Sería muy bueno si pudiera usar el mismo evaluation_loop para monitorear el progreso de múltiples modelos diferentes (puntos de control en múltiples directorios). Es algo como esto posible?

2) No hay comentarios entre la evaluación y la capacitación. Estoy entrenando una tonelada de modelos y me encantaría usar paradas tempranas para detener los modelos que no están aprendiendo o que no están convergiendo. ¿Hay alguna forma de hacer esto? Lo ideal es usar la información del conjunto de validación, pero si tiene que basarse simplemente en los datos de capacitación, también está bien.

3) ¿Está mi flujo de trabajo mal y debería estructurarlo de manera diferente? No está claro en la documentación cómo usar la evaluación junto con la capacitación.

Actualización ~~ Parece que a partir de TF r0.11 también estoy obteniendo un segfault al llamar a slim.evaluation.evaluation_loop . Solo sucede a veces (para mí cuando envío mis trabajos a un clúster). Sucede en sv.managed_session --específicamente prepare_or_wait_for_session . ~~ Esto se debió solo al bucle de evaluación (una segunda instancia de tensorflow) que intentaba usar la GPU, que ya había sido requisitada por la primera instancia.

Answer 1

1. evaluation_loop está destinado a ser utilizado (como lo está usando actualmente) con un único directorio. Si quiere ser más eficiente, puede usar slim.evaluation.evaluate_once y agregar la lógica apropiada para intercambiar directorios según lo considere apropiado.

2. Puede hacerlo anulando el argumento slim.learning.train (..., train_step_fn). Este argumento reemplaza la función ''train_step'' con una función personalizada. Aquí puede proporcionar una función de formación personalizada que devuelve los valores de ''total_loss'' y ''should_stop'' como mejor le parezca.

3. Su flujo de trabajo se ve muy bien, este es probablemente el flujo de trabajo más común para el aprendizaje / evaluación utilizando TF-Slim.

Answer 2

Agregar mi 2 centavos:

Actualmente tengo este modelo para evaluación_loop acaparando una GPU completa, pero rara vez se usa

Por lo general, un modelo de evaluación requiere menos memoria GPU. Podría evitar que TF acapare toda la memoria de la GPU configurando la configuración de sesión allow_growth en True . De esta forma puede usar la misma GPU para entrenamiento y evaluación

Ejemplo @ Entrenamiento

session_config = tf.ConfigProto()
session_config.gpu_options.allow_growth = True

slim.learning.train(train_tensor, 
                  logdir=train_log_dir,
                  local_init_op=tf.initialize_local_variables(),
                  save_summaries_secs=FLAGS.save_summaries_secs,
                  save_interval_secs=FLAGS.save_interval_secs,
                  session_config=session_config)

Ejemplo @ validación

session_config = tf.ConfigProto()
session_config.gpu_options.allow_growth = True

slim.evaluation.evaluation_loop(
      '''',
      checkpoint_dir=train_log_dir,
      logdir=train_log_dir,
      num_evals=FLAGS.num_eval_batches,
      eval_op=names_to_updates.values(),
      summary_op=tf.merge_summary(summary_ops),
      eval_interval_secs=FLAGS.eval_interval_secs,
      session_config=session_config)

Answer 3

Gracias a @kmalakoff, el problema de TensorFlow brindó una manera brillante al problema de cómo validar o probar el modelo en la capacitación de tf.slim . La idea principal es anular la función train_step_fn :

import …
from tensorflow.contrib.slim.python.slim.learning import train_step

...

accuracy_validation = ...
accuracy_test = ...

def train_step_fn(session, *args, **kwargs):
    total_loss, should_stop = train_step(session, *args, **kwargs)

    if train_step_fn.step % FLAGS.validation_every_n_step == 0:
        accuracy = session.run(train_step_fn.accuracy_validation)
        print(''your validation info'')

    if train_step_fn.step % FLAGS.test_every_n_step == 0:
        accuracy = session.run(train_step_fn.accuracy_test)
        print(''your test info'')

    train_step_fn.step += 1
    return [total_loss, should_stop] 

train_step_fn.step = 0
train_step_fn.accuracy_validation = accuracy_validation
train_step_fn.accuracy_test = accuracy_test

# run training.
slim.learning.train(
    train_op,
    FLAGS.logs_dir,
    train_step_fn=train_step_fn,
    graph=graph,
    number_of_steps=FLAGS.max_steps)