TF_CONFIG für Details verteilter Trainings

AI Platform legt für jede Trainingsinstanz eine Umgebungsvariable namens TF_CONFIG fest. Der Dienst und Ihre Anwendung können während der Ausführung in TF_CONFIG auf Details der Trainingsjobs zugreifen.

In dieser Anleitung wird beschrieben, wie Sie in der Umgebungsvariablen TF_CONFIG auf Details Ihrer Trainingsjobs zugreifen können. Diese Technik ist nützlich für verteilte Trainingsjobs und Hyperparameter-Abstimmungsjobs, da diese zusätzliche Kommunikation zwischen der Trainingsanwendung und dem Dienst erfordern.

TensorFlow und TF_CONFIG

Die Estimator API von TensorFlow parst die Umgebungsvariable TF_CONFIG, wenn sie vorhanden ist. Die API verwendet die jeweils erforderlichen Details von TF_CONFIG zum Erstellen der Attribute für das verteilte Training, einschließlich Clusterspezifikation, Aufgaben-ID und anderer Attribute.

Wenn Ihre Anwendung tf.estimator für verteiltes Training verwendet, erfolgt die Weitergabe von Attributen an die Clusterspezifikation automatisch, da AI Platform TF_CONFIG festlegt.

Ähnlich verhält es sich, wenn Sie Ihre Anwendung für verteiltes Training in AI Platform mit einem benutzerdefinierten Container ausführen. In diesem Fall legt AI Platform TF_CONFIG fest und füllt die Umgebungsvariable CLUSTER_SPEC auf jeder Maschine.

Format von TF_CONFIG

Die Umgebungsvariable TF_CONFIG ist ein JSON-String mit dem folgenden Format:

Key Beschreibung
"cluster" Die TensorFlow-Clusterbeschreibung. Dieses Objekt ist als TensorFlow-Clusterspezifikation formatiert und kann an den Konstruktor von tf.train.ClusterSpec übergeben werden.
"task" Beschreibt die Aufgabe des jeweiligen Knotens, auf dem Ihr Code läuft. Sie können diese Informationen verwenden, um Code für bestimmte Worker in einem verteilten Job zu schreiben. Dieser Eintrag ist ein Wörterbuch mit folgenden Schlüsseln:
"type" Die Art der Aufgabe, die von diesem Knoten ausgeführt wird. Mögliche Werte sind master, worker und ps.
"index" Der nullbasierte Index der Aufgabe. Die meisten verteilten Trainingsjobs haben eine einzige Masteraufgabe, einen oder mehrere Parameterserver und einen oder mehrere Worker.
"trial" Die Kennzeichnung des gerade ausgeführten Hyperparameter-Abstimmungstests. Wenn Sie die Hyperparameter-Abstimmung für Ihren Job konfigurieren, legen Sie eine Reihe von Tests fest, die trainiert werden sollen. Mit diesem Wert können Sie zwischen den verschiedenen Tests unterscheiden, die in Ihrem Code ausgeführt werden. Die Kennzeichnung ist ein Stringwert, der die Testnummer enthält, beginnend mit Test 1.
"job" Die Jobparameter, die Sie beim Initiieren des Jobs verwendet haben. In den meisten Fällen können Sie diesen Eintrag ignorieren, da er die über die Befehlszeilenargumente an Ihre Trainer-Anwendung übermittelten Daten repliziert.

TF_CONFIG abrufen und die verteilte Clusterspezifikation einstellen

Das folgende Beispiel zeigt, wie Sie den Inhalt von TF_CONFIG in Ihrer Anwendung abrufen.

Das Beispiel zeigt auch, wie Sie mit TF_CONFIG während des verteilten Trainings tf.train.ClusterSpec festlegen. Hinweis: Sie müssen tf.train.ClusterSpec nur dann aus TF_CONFIG erstellen, wenn der Code die TensorFlow Core APIs nutzt. Wenn Sie tf.estimator verwenden, parst TensorFlow die Variable und erstellt die Clusterspezifikation. Weitere Informationen finden Sie im Abschnitt über TensorFlow und TF_CONFIG auf dieser Seite.

def train_and_evaluate(args):
  """Parse TF_CONFIG to cluster_spec and call run() method.

  TF_CONFIG environment variable is available when running using
  gcloud either locally or on cloud. It has all the information required
  to create a ClusterSpec which is important for running distributed code.

  Args:
    args (args): Input arguments.
  """

  tf_config = os.environ.get('TF_CONFIG')
  # If TF_CONFIG is not available run local.
  if not tf_config:
    return run(target='', cluster_spec=None, is_chief=True, args=args)

  tf_config_json = json.loads(tf_config)
  cluster = tf_config_json.get('cluster')
  job_name = tf_config_json.get('task', {}).get('type')
  task_index = tf_config_json.get('task', {}).get('index')

  # If cluster information is empty run local.
  if job_name is None or task_index is None:
    return run(target='', cluster_spec=None, is_chief=True, args=args)

  cluster_spec = tf.train.ClusterSpec(cluster)
  server = tf.train.Server(cluster_spec,
                           job_name=job_name,
                           task_index=task_index)

  # Wait for incoming connections forever.
  # Worker ships the graph to the ps server.
  # The ps server manages the parameters of the model.
  #
  # See a detailed video on distributed TensorFlow
  # https://www.youtube.com/watch?v=la_M6bCV91M
  if job_name == 'ps':
    server.join()
    return
  elif job_name in ['master', 'worker']:
    return run(server.target, cluster_spec, is_chief=(job_name == 'master'),
               args=args)

device_filters für verteiltes Training einstellen

Bei einem verteilten Training in großem Maßstab müssen Sie dafür sorgen, dass die Kommunikation zwischen den Maschinen zuverlässig ist, sodass Ihre Trainingsanwendung auch bei Maschinenausfällen stabil bleibt.

Dazu müssen Sie in Ihrer Trainingsanwendung Gerätefilter festlegen, die dafür sorgen, dass der Master nicht darauf angewiesen ist, dass alle Worker aktiv sind. Mit device_filters können Sie sicherstellen, dass die Master- und Worker-Maschinen nur mit Parameterservern kommunizieren.

Das folgende Beispiel zeigt, wie device_filters bei Verwendung der Bibliothek tf.estimator festgelegt wird:

def _get_session_config_from_env_var():
    """Returns a tf.ConfigProto instance that has appropriate device_filters
    set."""

    tf_config = json.loads(os.environ.get('TF_CONFIG', '{}'))

    if (tf_config and 'task' in tf_config and 'type' in tf_config['task'] and
            'index' in tf_config['task']):
        # Master should only communicate with itself and ps
        if tf_config['task']['type'] == 'master':
            return tf.ConfigProto(device_filters=['/job:ps', '/job:master'])
        # Worker should only communicate with itself and ps
        elif tf_config['task']['type'] == 'worker':
            return tf.ConfigProto(device_filters=[
                '/job:ps',
                '/job:worker/task:%d' % tf_config['task']['index']
            ])
    return None

Übergeben Sie dann diese session_config so an tf.estimator.RunConfig:

config = tf.estimator.RunConfig(session_config=_get_session_config_from_env_var())

Ab TensorFlow Version 1.10 ist dies in der Bibliothek tf.estimator voreingestellt.

Weitere Informationen

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...

AI Platform für TensorFlow