Wie funktioniert das asynchrone Training im verteilten Tensorflow?

Ich habe verteilte Tensorflow Doc gelesen, und es erwähnt das im asynchronen Training,

Jede Replik des Graphen hat eine unabhängige Trainingsschleife, die ohne Koordination ausgeführt wird.

Von dem, was ich verstehe, wenn wir Parameterserver mit Datenparallelität Architektur verwenden, bedeutet dies, dass jeder Arbeiter Gradienten berechnet und seine eigenen Gewichte aktualisiert, ohne sich um andere Arbeiter-Updates für verteiltes Training Neural Network zu kümmern. Da alle Gewichte auf Parameterserver (ps) geteilt werden, denke ich, dass ps immer noch Gewichtstitel von allen Mitarbeitern in irgendeiner Weise koordinieren (oder aggregieren) muss. Ich frage mich, wie funktioniert die Aggregation im asynchronen Training. Oder in allgemeineren Worten, wie funktioniert asynchrone Ausbildung im verteilten Tensorflow?

    3 Solutions collect form web for “Wie funktioniert das asynchrone Training im verteilten Tensorflow?”

    Wenn du asynchron in Distributed TensorFlow trainierst, macht ein bestimmter Arbeiter folgendes:

    1. Der Arbeiter liest alle gemeinsam genutzten Modellparameter parallel von der PS-Task (s) und kopiert sie in die Worker-Task. Diese Lesungen sind mit allen gleichzeitigen Schreibvorgängen unkoordiniert, und es werden keine Sperren erfasst: Insbesondere kann der Arbeiter teilweise Aktualisierungen von einem oder mehreren anderen Mitarbeitern sehen (zB eine Teilmenge der Aktualisierungen eines anderen Arbeitnehmers kann angewendet worden sein oder eine Teilmenge der Elemente In einer Variable kann aktualisiert worden sein).

    2. Der Arbeiter berechnet die Gradienten lokal, basierend auf einem Batch von Eingangsdaten und den Parameterwerten, die er in Schritt 1 gelesen hat.

    3. Der Arbeiter sendet die Gradienten für jede Variable an die entsprechende PS-Aufgabe und wendet die Gradienten auf ihre jeweilige Variable an, wobei eine Aktualisierungsregel verwendet wird, die durch den Optimierungsalgorithmus bestimmt wird (zB SGD, SGD mit Momentum, Adagrad, Adam usw.). Die Aktualisierungsregeln verwenden typischerweise (ungefähr) kommutative Operationen, so dass sie unabhängig von den Aktualisierungen von jedem Arbeiter angewendet werden können und der Status jeder Variablen ein laufendes Aggregat der Folge von empfangenen Aktualisierungen ist.

    Bei der asynchronen Schulung wird jedes Update vom Worker gleichzeitig angewendet und die Updates können etwas koordiniert werden, wenn das optionale use_locking=True Flag gesetzt wurde, wenn der jeweilige Optimierer (zB tf.train.GradientDescentOptimizer ) initialisiert wurde. Beachten Sie jedoch, dass die Verriegelung hier nur gegenseitigen Ausschluss für zwei gleichzeitige Updates, und (wie oben erwähnt) liest nicht erziehen Schlösser; Die Verriegelung stellt keine Atomität über den gesamten Satz von Updates zur Verfügung.

    (Im Gegensatz dazu wird bei einem synchronen Training ein Dienstprogramm wie tf.train.SyncReplicasOptimizer dafür sorgen, dass alle Mitarbeiter die gleichen, aktuellen Werte für jeden Modellparameter lesen und dass alle Updates für einen synchronen Schritt aggregiert werden Bevor sie auf die zugrunde liegenden Variablen angewendet werden. Dazu werden die Arbeiter durch eine Barriere synchronisiert, die sie nach dem Senden ihrer Gradientenaktualisierung eingeben und nach dem aggregierten Update auf alle Variablen verlassen werden.)

    Betrachten Sie das Beispiel in der Dokumentation, die Sie verknüpfen:

     with tf.device("/job:ps/task:0"): weights_1 = tf.Variable(...) biases_1 = tf.Variable(...) with tf.device("/job:ps/task:1"): weights_2 = tf.Variable(...) biases_2 = tf.Variable(...) with tf.device("/job:worker/task:7"): input, labels = ... layer_1 = tf.nn.relu(tf.matmul(input, weights_1) + biases_1) logits = tf.nn.relu(tf.matmul(layer_1, weights_2) + biases_2) # ... train_op = ... with tf.Session("grpc://worker7.example.com:2222") as sess: for _ in range(10000): sess.run(train_op) 

    Sie können sehen, dass das Training auf drei Maschinen verteilt wird, die alle eine Kopie identischer Gewichte teilen, aber wie gerade unterhalb des Beispiels erwähnt wird:

    Im obigen Beispiel werden die Variablen auf zwei Tasks im ps-Job angelegt und der rechenintensive Teil des Modells wird im Worker-Job angelegt. TensorFlow wird die entsprechenden Datenübertragungen zwischen den Aufträgen (von ps zum Arbeiter für den Vorwärtspass und vom Arbeiter zu ps für die Anwendung von Gradienten) einfügen.

    Mit anderen Worten wird ein Gpu verwendet, um den Vorwärtsdurchlauf zu berechnen und überträgt dann die Ergebnisse an die beiden anderen Maschinen, während jeder der anderen Maschinen die Rückwärtsausbreitung für einen Teil der Gewichte berechnet und dann die Ergebnisse an die anderen Maschinen sendet Sie können alle ihre Gewichte entsprechend aktualisieren.

    GPUs werden verwendet, um Matrixmultiplikationen und parallele mathematische Operationen zu beschleunigen, die für die Vorwärts- und Rückwärtsausbreitung sehr intensiv sind. So verteiltes Training bedeutet einfach, dass man diese Operationen auf viele GPUs verteilt, das Modell ist immer noch zwischen den Maschinen synchronisiert, aber jetzt kann die Rückwärtsausbreitung unterschiedlicher Gewichte parallel berechnet werden und die Vorwärtsfahrt an einem anderen Mini-Batch kann berechnet werden Die gleiche Zeit wie Backprop aus der vorherigen Mini-Batch wird noch berechnet. Verteiltes Training bedeutet nicht, dass Sie auf jeder Maschine völlig unabhängige Modelle und Gewichte haben.

    Bei der asynchronen Ausbildung gibt es keine Synchronisation von Gewichten unter den Arbeitern. Die Gewichte werden auf dem Parameterserver gespeichert. Jeder Arbeiter lädt und verändert die gemeinsamen Gewichte unabhängig voneinander. Auf diese Weise, wenn ein Arbeiter eine Iteration schneller als die anderen Arbeiter beendet hat, geht es mit der nächsten Iteration ohne zu warten. Die Arbeiter interagieren nur mit dem gemeinsamen Parameterserver und interagieren nicht miteinander.

    Insgesamt kann es (abhängig von der Aufgabe) die Berechnung erheblich beschleunigen. Allerdings sind die Ergebnisse manchmal schlechter als die, die mit den langsameren synchronen Updates erhalten wurden.

    Python ist die beste Programmiersprache der Welt.