[PYTHON] Essayez les données en parallèle avec TensorFlow distribué

Qu'est-ce que les données parallèles?

La dernière fois a fait de la construction de Distributed TensorFlow pour modéliser le parallélisme, mais cette fois je vais essayer d'apprendre par le parallélisme de données. Il existe deux types de parallélisation, le parallélisme de modèle et la parallélisation des données, mais en gros, ils sont les suivants.

--Modèle parallèle: une énorme opération pour 1000 données est partagée par 100 personnes

• Parallèle de données: divisez 10 données par personne et partagez-les avec 100 personnes

Le parallélisme de modèle dépend naturellement du modèle, on peut donc dire qu'il est plus polyvalent de réduire les données traitées en même temps dans le parallélisme de données.

Partage de paramètres

Dans la parallélisation des données lors de la formation, plusieurs copies de modèles avec les mêmes paramètres sont effectuées, les lots sont divisés en petits lots, transmis à chaque copie du modèle et chacun est fait pour calculer le différentiel. En d'autres termes, il est nécessaire d'avoir un modèle avec les mêmes paramètres pour chaque appareil, mais la manipulation autour de cela est un peu difficile à comprendre. Je n'utiliserai pas de GPU cette fois, mais pour le calcul et le partage de paramètres sur plusieurs appareils, la description officielle de la procédure autour du GPU (Using GPUs .7 / how_tos / using_gpu / index.html # using-gpus), Sharing Variables) Sera utile.

Vous pouvez utiliser tf.variable_scope () pour définir la portée d'une variable. Si vous souhaitez utiliser des variables avec le même nom dans la même portée, vous pouvez appeler get_variable () avec l'indicateur de réutilisation défini. get_variable () se comporte comme renvoyer une nouvelle création si l'indicateur de réutilisation n'est pas défini, et renvoyer un lien vers une variable existante avec le même nom si elle est définie. Vous pouvez l'utiliser pour partager des paramètres.

Lorsque vous vous référez au graphique plus tard, utilisez Collection.

Configuration du cluster

Dans Distrubuted Tensorflow White Paper, le serveur qui gère Variable, qui est un périphérique de paramètres, gère et met à jour les paramètres, et le maître travaille pour chaque worker. Il y a une description du lancer (désolé, je ne l'ai pas lu correctement ...). En lisant en diagonale autour de cela, j'ai décidé de gérer les variables collectivement avec master et d'en faire une configuration dans laquelle deux travailleurs gèrent les lots subdivisés. Il est possible de séparer le serveur (ps) pour les paramètres séparément, mais cette fois, il sera inclus dans le maître.

--Créez une variable de portée ps sur le périphérique maître

• Réutiliser les variables de portée ps pour calculer la différenciation sur chaque appareil de travail --Sur l'appareil maître, mettez à jour les paramètres en utilisant la moyenne des différentiels calculés par chaque travailleur

Je vais le décrire dans la division. La figure est la suivante.

Essayez de bouger

Démarrez le serveur grpc. La configuration du cluster est un maître et deux travailleurs, donc

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 &

Vraiment?

Similaire à Dernière fois, apprenons l'approximation de $ y = e ^ x $ dans des données parallèles. Voir ici pour le code. À propos, je mets également une version de processeur unique et une version parallèle de modèle au même endroit.

Pour partager des paramètres avec le maître et le travailleur, spécifiez simplement le périphérique et la portée, et remplacez la partie de création de variable créée par tf.Variable () par get_variable (). Je veux le réutiliser, donc je vais tout unifier avec la portée ps. Il semble passer un initialiseur pour initialiser la variable.

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

Si vous l'appelez avec l'indicateur de réutilisation défini dans la même portée, il sera réutilisé. Je suis un peu confus ici, mais comme la portée ici est une portée variable, seule la variable est réutilisée et le graphique est une instance distincte.

La transmission du lot à chaque travailleur se fera plus tard dans la boucle principale, mais à ce moment-là, nous utiliserons une collection afin de pouvoir identifier le dossier d'espace de chaque travailleur.

tf.add_to_collection("x",x)  #Collectez x pour une utilisation ultérieure
...
x0= tf.get_collection("x")[0]　#Extraire le 0e de la collection x

De même, collectez les différentiels.

L'optimisation est une procédure de mise à jour des paramètres de calcul différentiel de calcul des coûts, mais je pense que généralement optimizer.minimize () etc. est utilisé pour tout effectuer, du calcul différentiel à la mise à jour des paramètres en même temps. Cependant, cette fois, nous n'utiliserons pas le différentiel obtenu immédiatement, donc apply_gradiends () après compute_gradients (). Dans l'ensemble du processus

--Calcul différentiel compute_gradients () dans chaque worker --Moyen de ces différentiels avec master --App_gradients () utilisant la différenciation moyenne

Suivez la procédure. L'endroit où faire la moyenne de la différenciation est détourné de TensorFlow sample code.

Comparons le degré de convergence.

Le bleu est la version à processeur unique et le rouge la version parallèle aux données. Puisque les graines de nombres aléatoires sont alignées, elles se chevauchent presque. (Pas exactement la même valeur)

Je n'ai pas augmenté le nombre de serveurs, les frais généraux sont énormes, l'opération par lots n'est pas lourde en premier lieu, etc. Il y a divers inconvénients dans cet exemple, donc la version parallèle est plus lente. C'était à peu près deux fois plus lent à portée de main.

finalement

Jusqu'à ce point, le but est de comprendre le mécanisme plutôt que d'accélérer, donc chaque fois que j'obtiens le résultat d'un ralentissement avec la parallélisation, La prochaine fois en parle enfin. Faisons-en un conteneur Docker et exécutons-le sur Google Clout Platform. Si vous créez beaucoup de conteneurs avec l'élan nécessaire pour utiliser le cadre libre de \ $ 300, cela devrait être plus rapide. Le sujet brûlant Alpha Go aurait 1200 CPU, mais j'ai hâte de voir ce qu'il peut faire pour \ $ 300.