Flux tensoriel distribué: la différence entre la réplication dans le graphique et la réplication entre les graphiques

Question

Je me suis trompé sur les deux concepts: In-graph replication Et Between-graph replication Lors de la lecture du Formation répliquée dans le How-to officiel de tensorflow.

Il est dit dans le lien ci-dessus que

Réplication dans le graphique. Dans cette approche, le client crée un seul tf.Graph qui contient un ensemble de paramètres (en tf.Variable nœuds épinglés sur/travail: ps); ...

Est-ce à dire qu'il y a plusieurs tf.Graph S dans l'approche Between-graph replication? Si oui, où sont les codes correspondants dans les exemples fournis?
Bien qu'il y ait déjà un exemple de Between-graph replication Dans le lien ci-dessus, quelqu'un pourrait-il fournir une implémentation de In-graph replication (Le pseudo-code est correct) et mettre en évidence ses principales différences par rapport à Between-graph replication?

Merci d'avance!

Edit_1: plus de questions

Merci beaucoup pour vos explications détaillées et votre code Gist @mrry @YaroslavBulatov! Après avoir regardé vos réponses, j'ai les deux questions suivantes:

Il y a la déclaration suivante dans Formation répliquée :

Réplication entre les graphiques. Dans cette approche, il existe un client distinct pour chaque tâche/job: worker, généralement dans le même processus que la tâche worker. Chaque client crée un graphique similaire contenant les paramètres (épinglés sur/job: ps comme avant d'utiliser tf.train.replica_device_setter () pour les mapper de manière déterministe à la mêmes tâches); et une copie unique de la partie à forte intensité de calcul du modèle, épinglée à la tâche locale dans/job: worker.

J'ai deux sous-questions liées aux mots ci-dessus en gras.

(A) Pourquoi disons-nous que chaque client crée un graphique similaire , mais pas le même graphique ? Je me demande si le graphique construit dans chaque client dans l'exemple de Formation répliquée devrait être le même car les codes de construction du graphique ci-dessous sont partagés entre tous les workers .:

# Build model...

loss = ...

global_step = tf.Variable(0)

(B) Ne devrait-il pas s'agir de plusieurs copies d'une partie du modèle à forte intensité de calcul, car nous avons plusieurs workers?
Est-ce que l'exemple de Formation répliquée prend en charge la formation sur plusieurs machines, chacune ayant plusieurs GPU? Sinon, pouvons-nous utiliser simultanément à la fois In-graph replication Pour prendre en charge la formation sur plusieurs GPU sur chaque machine et Between-graph replication Pour la formation multi-machine? Je pose cette question parce que @mrry a indiqué que le In-graph replication Est essentiellement le même que celui utilisé dans modèle d'exemple CIFAR-10 pour plusieurs GP .

mrry · Accepted Answer

Tout d'abord, pour certains contextes historiques, la "réplication dans le graphique" est la première approche que nous avons essayée dans TensorFlow, et elle n'a pas atteint les performances requises par de nombreux utilisateurs, donc l'approche "entre les graphiques" la plus compliquée est l'actuelle moyen recommandé d'effectuer une formation distribuée. Les bibliothèques de niveau supérieur telles que tf.learn Utilisent l'approche "entre les graphiques" pour la formation distribuée.

Pour répondre à vos questions spécifiques:

Cela signifie-t-il qu'il existe plusieurs tf.Graph Dans l'approche de réplication entre les graphiques? Si oui, où sont les codes correspondants dans les exemples fournis?

Oui. La configuration de réplication entre graphiques typique utilise un processus TensorFlow distinct pour chaque réplique de travail, et chacun de ces éléments crée un tf.Graph Distinct pour le modèle. Habituellement, chaque processus utilise le graphe global par défaut (accessible via tf.get_default_graph() ) et il n'est pas créé explicitement.

(En principe, vous pouvez utiliser un seul processus TensorFlow avec les mêmes tf.Graph Et plusieurs tf.Session Objets qui partagent le même graphique sous-jacent, tant que vous avez configuré l'option tf.ConfigProto.device_filters Pour chaque session différemment, mais cette configuration est rare.)
Bien qu'il existe déjà un exemple de réplication entre les graphiques dans le lien ci-dessus, quelqu'un pourrait-il fournir une implémentation de réplication dans les graphiques (le pseudocode est correct) et mettre en évidence ses principales différences par rapport à la réplication entre les graphiques?

Pour des raisons historiques, il n'y a pas beaucoup d'exemples de réplication dans le graphique ( Yaroslav's Gist est une exception). Un programme utilisant la réplication dans le graphique inclura généralement une boucle qui crée la même structure graphique pour chaque travailleur (par exemple, la boucle sur ligne 74 du Gist ), et utilisera le partage de variables entre les travailleurs.

Le seul endroit où la réplication dans le graphique persiste est d'utiliser plusieurs périphériques dans un seul processus (par exemple, plusieurs GPU). Le modèle d'exemple CIFAR-10 pour plusieurs GP est un exemple de ce modèle (voir la boucle sur les périphériques GPU ici ).

(À mon avis, l'incohérence entre la façon dont plusieurs travailleurs et plusieurs périphériques sont traités dans un même travailleur est regrettable. La réplication dans le graphique est plus simple à comprendre que la réplication entre les graphiques, car elle ne repose pas sur un partage implicite entre les répliques. Les bibliothèques de niveau supérieur, telles que tf.learn Et TF-Slim, masquent certains de ces problèmes et offrent l'espoir que nous pourrons offrir un meilleur schéma de réplication à l'avenir.)

Pourquoi disons-nous que chaque client crée un graphique similaire , mais pas le même graphique?

Parce qu'ils ne sont pas tenus d'être identiques (et il n'y a pas de contrôle d'intégrité qui les applique). En particulier, chaque travailleur peut créer un graphique avec différentes affectations explicites de périphériques ("/job:worker/task:0", "/job:worker/task:1", Etc.). L'employé en chef peut créer des opérations supplémentaires qui ne sont pas créées sur (ou utilisées par) les employés non chefs. Cependant, dans la plupart des cas, les graphiques sont logiquement identiques (c'est-à-dire les affectations des appareils modulo).

Ne devrait-il pas s'agir de plusieurs copies de la partie à forte intensité de calcul du modèle, car nous avons plusieurs travailleurs?

En règle générale, chaque travailleur dispose d'un graphique distinct qui contient une seule copie de la partie à forte intensité de calcul du modèle. Le graphique pour le travailleur i ne contient pas les nœuds du travailleur j (en supposant que i ≠ j). (Une exception serait le cas où vous utilisez la réplication entre les graphiques pour la formation distribuée et la réplication dans les graphiques pour utiliser plusieurs GPU dans chaque travailleur. Dans ce cas, le graphique d'un travailleur contiendrait généralement [ ~ # ~] n [~ # ~] copies de la partie à calcul intensif du graphique, où [~ # ~] n [~ # ~] est le nombre de GPU dans ce travailleur.)
Est-ce que l'exemple de Formation répliquée prend en charge la formation sur plusieurs machines, chacune ayant plusieurs GPU?

L'exemple de code ne couvre que la formation sur plusieurs machines et ne dit rien sur la façon de s'entraîner sur plusieurs GPU dans chaque machine. Cependant, les techniques se composent facilement. Dans cette partie de l'exemple:
```
# Build model... loss = ... 
```
... vous pouvez ajouter une boucle sur les GPU de la machine locale, pour obtenir une formation répartie sur plusieurs travailleurs dotés chacun de plusieurs GPU.