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

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

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

data_parallel.png

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.

compare.png

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.

Recommended Posts

Essayez les données en parallèle avec TensorFlow distribué
Essayez Distributed Tensor Flow
Apprenez les données distribuées avec TensorFlow Y = 2X
Lecture de données avec TensorFlow
Essayez la régression avec TensorFlow
Essayez l'apprentissage en profondeur avec TensorFlow
Essayez TensorFlow MNIST avec RNN
Essayez de travailler avec des données binaires en Python
Essayez de convertir en données ordonnées avec les pandas
Essayez TensorFlow RNN avec un modèle de base
Zundokokiyoshi avec TensorFlow
Casser des blocs avec Tensorflow
Essayez d'agréger les données de musique doujin avec des pandas
Essayez Tensorflow avec une instance GPU sur AWS
Essayez d'exécuter Distributed TensorFlow sur Google Cloud Platform
Essayez Theano avec les données MNIST de Kaggle ~ Retour logistique ~
Essayez de gratter avec Python.
Visualisation des données avec les pandas
Manipulation des données avec les Pandas!
Challenge classification des images par TensorFlow2 + Keras 3 ~ Visualiser les données MNIST ~
Mélangez les données avec les pandas
Augmentation des données avec openCV
Normariser les données avec Scipy
Analyse de données avec Python
CHARGER DES DONNÉES avec PyMysql
Essayez de gratter les données COVID-19 Tokyo avec Python
Essayez d'extraire la table de données d'Azure SQL Server avec pyodbc
Essayez d'acquérir des données lors de la redirection de port vers RDS avec anaconda.
Essayez de traiter les données Titanic avec la bibliothèque de prétraitement DataLiner (encodage)
Essayez de traiter les données Titanic avec la bibliothèque de prétraitement DataLiner (conversion)
Essayez d'extraire les caractéristiques des données de capteur avec CNN
Traduire Premiers pas avec TensorFlow
Exemple de données créées avec python
Essayez de défier le sol par récursif
Essayez l'optimisation des fonctions avec Optuna
Incorporer des données audio avec Jupyter
Graphique des données Excel avec matplotlib (1)
Utiliser TensorFlow avec Intellij IDEA
Génération artificielle de données avec numpy
Essayez d'utiliser PythonTex avec Texpad.
Essayez la détection des bords avec OpenCV
Tutoriel TensorFlow - Téléchargement de données MNIST (traduction)
Essayez d'implémenter RBM avec chainer.
Essayez Google Mock avec C
Expérience de réglage des données Tensorflow
Essayez d'utiliser matplotlib avec PyCharm
Essayez la programmation GUI avec Hy
Essayez Auto Encoder avec Pytorch
Essayez la sortie Python avec Haxe 3.2
Essayez l'opération matricielle avec NumPy
Obtenez des données Youtube avec python
Essayez d'exécuter CNN avec ChainerRL
Essayez différentes choses avec PhantomJS
Apprenez de nouvelles données avec PaintsChainer
Binariser les données photo avec OpenCV
Essayez «100 coups sur la science des données» ①
Graphique des données Excel avec matplotlib (2)