[PYTHON] Versuchen Sie Daten parallel zu Distributed TensorFlow

Was ist Daten parallel?

Letztes Mal hat Distributed TensorFlow erstellt, um Parallelität zu modellieren, aber dieses Mal werde ich versuchen, durch Datenparallelität zu lernen. Es gibt zwei Arten der Parallelisierung: Modellparallelität und Datenparallelisierung. Grob gesagt sind dies jedoch die folgenden.

• Modell parallel: Eine große Operation für 1000 Daten wird von 100 Personen gemeinsam genutzt
• Daten parallel: Teilen Sie 10 Daten pro Person und teilen Sie sie mit 100 Personen

Die Modellparallelität hängt natürlich vom Modell ab, sodass gesagt werden kann, dass es vielseitiger ist, die Daten zu reduzieren, die gleichzeitig in der Datenparallelität verarbeitet werden.

Parameterfreigabe

Bei der Datenparallelisierung im Training werden mehrere Kopien von Modellen mit denselben Parametern erstellt, Stapel werden in kleine Stapel unterteilt, an jede Kopie des Modells übergeben und jeweils zur Berechnung des Differentials erstellt. Mit anderen Worten, es ist notwendig, für jedes Gerät ein Modell mit denselben Parametern zu haben, aber die Handhabung ist etwas schwierig zu verstehen. Ich werde diesmal keine GPU verwenden, sondern für die Berechnung und gemeinsame Nutzung von Parametern auf mehreren Geräten die offizielle Beschreibung der GPU (Verwenden von GPUs). .7 / how_tos / using_gpu / index.html # using-gpus), Sharing Variables) Wird hilfreich sein.

Mit tf.variable_scope () können Sie den Bereich einer Variablen definieren. Wenn Sie Variablen mit demselben Namen im selben Bereich verwenden möchten, können Sie get_variable () mit gesetztem Wiederverwendungsflag aufrufen. get_variable () verhält sich wie das Zurückgeben einer neuen Erstellung, wenn das Wiederverwendungsflag nicht gesetzt ist, und das Zurückgeben eines Links zu einer vorhandenen Variablen mit demselben Namen, wenn es gesetzt ist. Sie können dies verwenden, um Parameter zu teilen.

Wenn Sie später auf das Diagramm verweisen, verwenden Sie Sammlung.

Cluster-Konfiguration

In Whitepaper zu verteiltem Tensorflow verwaltet und aktualisiert der Server, der Variable verwaltet, ein Parametergerät, Parameter, und der Master arbeitet für jeden Mitarbeiter. Es gibt eine Beschreibung zum Werfen (sorry, ich habe es nicht richtig gelesen ...). Während ich diagonal darüber las, entschied ich mich, Variablen gemeinsam mit master zu verwalten und eine Konfiguration zu erstellen, bei der zwei Mitarbeiter die unterteilten Stapel verarbeiten. Es ist möglich, den Server (ps) für Parameter separat zu trennen, diesmal wird er jedoch in den Master aufgenommen.

--Erstellen Sie eine Variable mit ps-Bereich auf dem Master-Gerät --Verwenden Sie ps-Bereichsvariablen, um die Differenzierung auf jedem Arbeitsgerät zu berechnen

• Aktualisieren Sie auf dem Master-Gerät die Parameter anhand des Durchschnitts der von jedem Mitarbeiter berechneten Differentiale

Ich werde es in der Abteilung beschreiben. Die Figur ist wie folgt.

Versuche dich zu bewegen

Starten Sie den grpc-Server. Die Clusterkonfiguration besteht also aus einem Master und zwei Workern

grpc_tensorflow_server --cluster_spec='master|localhost:2222,worker|localhost:2223,worker_|localhost:2224' --job_name=master --task_index=0 &
grpc_tensorflow_server --cluster_spec='master|localhost:2222,worker|localhost:2223,worker_|localhost:2224' --job_name=worker --task_index=0 &
grpc_tensorflow_server --cluster_spec='master|localhost:2222,worker|localhost:2223,worker_|localhost:2224' --job_name=worker_ --task_index=0 &

Ist es?

Ähnlich wie bei Letztes Mal lernen wir die Approximation von $ y = e ^ x $ in parallelen Daten. Siehe hier für den Code. Übrigens habe ich auch eine einzelne CPU-Version und eine modellparallele Version an derselben Stelle platziert.

Um Parameter für Master und Worker freizugeben, geben Sie einfach das Gerät und den Bereich an und ersetzen Sie den von tf.Variable () erstellten Teil zur Variablenerstellung durch get_variable (). Ich möchte es wiederverwenden, damit ich alles mit dem ps-Bereich vereinheitlichen kann. Es scheint einen Initialisierer zu übergeben, um die Variable zu initialisieren.

W1 = tf.Variable(tf.random_uniform([1,16], 0.0, 1.0))  # before
W1 = tf.get_variable("W1",shape=[1,16],initializer=tf.random_uniform_initializer(0,1)) # after

Wenn Sie es mit dem im selben Bereich gesetzten Wiederverwendungsflag aufrufen, wird es wiederverwendet. Ich bin hier etwas verwirrt, aber da der Bereich hier ein Variablenbereich ist, wird nur die Variable wiederverwendet, und das Diagramm ist eine separate Instanz.

Die Übergabe des Stapels an jeden Mitarbeiter erfolgt später in der Hauptschleife. Zu diesem Zeitpunkt verwenden wir jedoch eine Sammlung, damit wir den Ordner des Arbeitnehmers ermitteln können.

tf.add_to_collection("x",x)  #Sammle x für die spätere Verwendung
...
x0= tf.get_collection("x")[0]　#Extrahieren Sie den 0. der x-Sammlung

Sammeln Sie in ähnlicher Weise die Differentiale.

Optimierung ist ein Verfahren zur Kostenberechnung - Differenzialberechnung - Parameteraktualisierung, aber ich denke, dass normalerweise optimizer.minimize () usw. verwendet wird, um alles von der Differenzialberechnung bis zur Parameteraktualisierung gleichzeitig durchzuführen. Dieses Mal werden wir das erhaltene Differential jedoch nicht sofort verwenden, also apply_gradiends () nach compute_gradients (). Als ganzer Prozess

--Differentialberechnung compute_gradients () in jedem Worker

• Durchschnitt dieser Differenzen mit Master --App_gradients () mit gemittelter Differenzierung

Befolgen Sie die Anweisungen. Der Ort, an dem die Differenzierung gemittelt wird, wird von [TensorFlow-Beispielcode] umgeleitet (https://github.com/tensorflow/tensorflow/blob/master/tensorflow/models/image/cifar10/cifar10_multi_gpu_train.py).

Vergleichen wir den Konvergenzgrad.

Blau ist die Einzel-CPU-Version und Rot ist die datenparallele Version. Da die Keime von Zufallszahlen ausgerichtet sind, überlappen sie sich fast. (Nicht genau der gleiche Wert)

Ich habe die Anzahl der Server-Computer nicht erhöht, der Overhead ist enorm, der Batch-Betrieb ist in erster Linie nicht schwer usw. In diesem Beispiel gibt es verschiedene Nachteile, sodass die parallele Version langsamer ist. Es war ungefähr doppelt so langsam.

Schließlich

Bis zu diesem Punkt besteht der Zweck darin, den Mechanismus zu verstehen, anstatt ihn zu beschleunigen. Jedes Mal, wenn ich das Ergebnis einer Verlangsamung durch Parallelisierung erhalte, geht es bei Next time endlich darum. Machen wir es zu einem Docker-Container und führen es auf der Google Clout-Plattform aus. Wenn Sie viele Container mit dem Schwung erstellen, den freien Frame von \ $ 300 zu verbrauchen, sollte er schneller sein. Das heiße Thema Alpha Go soll 1200 CPUs haben, aber ich freue mich darauf zu sehen, wie viel es für 300 Dollar leisten kann.