Comment Surveiller les Sessions de Formation de travail?

Je ne peux pas donner quelques idées sur la façon de ces classes ont été créées, mais voici quelques choses que je pense sont relevants sur comment vous pourriez les utiliser.

La tf.Session est un faible niveau d'objet en python TensorFlow API tandis que,
comme vous l'avez dit, le tf.train.MonitoredTrainingSession livré avec un lot de fonctionnalités à portée de main, particulièrement utile dans la plupart des cas.

Avant de décrire certains des avantages de la tf.train.MonitoredTrainingSession, permettez-moi de répondre à la question sur le graphique utilisé par la session. Vous pouvez spécifier le tf.Graph utilisé par le MonitoredTrainingSession à l'aide d'un gestionnaire de contexte with your_graph.as_default():

from __future__ import print_function
import tensorflow as tf

def example():
    g1 = tf.Graph()
    with g1.as_default():
        # Define operations and tensors in `g`.
        c1 = tf.constant(42)
        assert c1.graph is g1

    g2 = tf.Graph()
    with g2.as_default():
        # Define operations and tensors in `g`.
        c2 = tf.constant(3.14)
        assert c2.graph is g2

    # MonitoredTrainingSession example
    with g1.as_default():
        with tf.train.MonitoredTrainingSession() as sess:
            print(c1.eval(session=sess))
            # Next line raises
            # ValueError: Cannot use the given session to evaluate tensor:
            # the tensor's graph is different from the session's graph.
            try:
                print(c2.eval(session=sess))
            except ValueError as e:
                print(e)

    # Session example
    with tf.Session(graph=g2) as sess:
        print(c2.eval(session=sess))
        # Next line raises
        # ValueError: Cannot use the given session to evaluate tensor:
        # the tensor's graph is different from the session's graph.
        try:
            print(c1.eval(session=sess))
        except ValueError as e:
            print(e)

if __name__ == '__main__':
    example()

Donc, comme vous l'avez dit, les avantages de l'utilisation de MonitoredTrainingSession sont que, cet objet prend soin de

• de l'initialisation des variables,
• de départ de la file d'attente runner
• la configuration du fichier écrivains,

mais il a aussi l'avantage de rendre votre code facile à distribuer, car il fonctionne différemment selon si vous avez spécifié le processus en cours d'exécution comme un maître ou non.

Par exemple, vous pouvez exécuter quelque chose comme:

def run_my_model(train_op, session_args):
    with tf.train.MonitoredTrainingSession(**session_args) as sess:
        sess.run(train_op)

que vous appelez dans une non distribués de la manière:

run_my_model(train_op, {})`

ou d'une manière distribuée (voir la distribué doc pour plus d'informations sur les entrées):

run_my_model(train_op, {"master": server.target,
                        "is_chief": (FLAGS.task_index == 0)})

D'autre part, les avantages de l'utilisation du raw tf.Session objet, c'est que, vous n'avez pas les avantages de tf.train.MonitoredTrainingSession, ce qui peut être utile si vous ne prévoyez pas de l'utiliser ou si vous souhaitez obtenir plus de contrôle (par exemple sur la façon dont les files d'attente sont démarrés).

MODIFIER (par commentaire):
Pour l'op de l'initialisation, vous devez faire quelque chose comme (cf. officiel doc:

# Define your graph and your ops
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init_p)
    sess.run(your_graph_ops,...)

Pour la QueueRunner, je vous invite à consulter le officiel doc où vous trouverez plus d'exemples complets.

EDIT2:

Le concept principal de comprendre pour avoir une idée sur la façon tf.train.MonitoredTrainingSession œuvres est la _WrappedSession classe:

Cette enveloppe est utilisée comme classe de base pour les différents session wrappers
qui fournissent des fonctionnalités supplémentaires telles que la surveillance, la coordination,
et la récupération.

La tf.train.MonitoredTrainingSession des travaux (comme de la version 1.1) de cette façon:

• Il vérifie d'abord si c'est un chef ou d'un travailleur (cf. le distribué doc pour lexicale question).
• Il commence les crochets qui ont été fournis (par exemple, StopAtStepHook voudrais juste récupérer le global_step tenseur à ce stade.
• Il crée une session qui est un Chief (ou Worker session) enveloppé dans un _HookedSession enveloppé dans un _CoordinatedSession enveloppé dans un _RecoverableSession.
  
  Le Chief/Worker séances sont chargés de l'exécution de l'initialisation de la fpo fournis par le Scaffold.

    scaffold: A `Scaffold` used for gathering or building supportive ops. If
  not specified a default one is created. It's used to finalize the graph.

• La chief session prend également soin de tous les point de contrôle de pièces: par exemple, la restauration à partir de points de contrôle à l'aide de la Saver de la Scaffold.
• La _HookedSession est essentiellement là pour décorer la run méthode: il appelle la _call_hook_before_run et after_run méthodes, le cas échéant.
• Lors de la création de la _CoordinatedSession construit une Coordinator qui commence la file d'attente des coureurs et sera responsable de leur fermeture.
• La _RecoverableSession sera assure qu'il n'y a réessayer en cas de tf.errors.AbortedError.

En conclusion, la tf.train.MonitoredTrainingSession évite beaucoup de chaudière plaque de code tout en étant facilement extensible avec les crochets mécanisme.