Cet article fait suite à l'article précédent (http://qiita.com/yuishihara/items/0e530e9c0a17a7fa0111). La dernière fois, j'ai présenté Nanchatte DQN (version incomplète), qui ne peut être implémenté qu'avec Tensorflow (à partir de juillet 2016), mais ici [Mnih et al .'s 2015 paper] 1 Écrit sur la façon de reproduire fidèlement la méthode réellement implémentée dans.
En particulier, 1 est un problème, et il n'est pas implémenté dans Tensorflow simple, vous devez donc l'implémenter vous-même. Ici, nous allons présenter comment l'implémenter dans Tensorflow et les résultats obtenus.
Pour créer un nouvel optimiseur avec Tensorflow, vous devez modifier le code Python Tensorflow et le code Cpp. Plus précisément, modifiez les fichiers suivants ou ajoutez des fichiers. En gros, si vous trouvez une implémentation RMS Drop existante, copiez-la et modifiez-la, et l'implémentation elle-même n'est pas si difficile.
(Python) 1.tensorflow/contrib/layers/python/layers/optimizers.py 2.tensorflow/python/training/training_ops.py 3.tensorflow / python / training / rmspropgraves.py (nouveau) 4.tensorflow / python / training / rmspropgraves_test.py (Non requis, mais il vaut mieux le tester, alors préparez-le)
(Côté Cpp) 1.tensorflow/core/kernels/training_ops.cc 2.tensorflow/core/kernels/training_ops_gpu.cu.cc 3.tensorflow/core/ops/training_ops.cc
Le code implémenté a été téléchargé sur [GitHub] 3, veuillez donc y jeter un œil pour l'implémentation spécifique.
Il est écrit dans [page officielle de Tensorflow] 4, mais j'en étais un peu accro, donc je vais me réveiller avec des étapes spécifiques. L'environnement sera Ubuntu 14.04.
Il vient de GitHub. Vérifiez ensuite la branche release (ici r0.9) car la branche master était instable et pouvait échouer à se construire.
$ git clone https://github.com/tensorflow/tensorflow
$ cd tensorflow
$ git checkout --track origin/r0.9
Tensorflow se construit à l'aide de bazel, alors installez-le d'abord. [Méthode décrite sur la page officielle de Bazel] Installer avec 5. La page Tensoflow est déroutante et doit être légèrement modifiée.
Ce n'est pas grave si vous le faites officiellement.
$ sudo apt-get install python-numpy swig python-dev python-wheel
Exécutez Configure dans le répertoire racine de tensorflow (le même que la racine du référentiel déposé par GitHub) pour définir l'environnement.
$ ./configure
(Abréviation)
Il vous sera demandé de différentes manières en chemin, mais si vous souhaitez configurer un environnement GPU, vous devriez pouvoir y aller en appuyant plusieurs fois sur y et sur Entrée. Dans le cas d'un environnement CPU uniquement, pas d'un environnement GPU,
Do you wish to build TensorFlow with GPU support? [y/N] n
En tant que, désactivez la prise en charge du GPU.
C'est un peu plus quand vous arrivez ici, mais si vous suivez la formule, vous serez obligé de construire un entraîneur que vous ne comprenez pas bien, alors faites attention. Ci-dessous, créez et installez whl pour l'installation de pip.
(Pour l'environnement CPU)
$ bazel build -c opt //tensorflow/tools/pip_package:build_pip_package
(Pour l'environnement GPU)
$ bazel build -c opt --config=cuda //tensorflow/tools/pip_package:build_pip_package
$ bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
$ sudo pip install /tmp/tensorflow_pkg/(Le nom dépend de la branche que vous avez construite)
Le code a également été téléchargé sur [GitHub] 6 cette fois, donc si vous êtes intéressé, jetez-y un œil. Cette section décrit l'implémentation clé de Loss Clipping.
LossClipping est une opération pour fixer la pente à 1 lorsque l'erreur dépasse 1, mais cette fois, en utilisant la propriété qu'une ligne droite avec une pente de 1 devient 1 lorsqu'elle est différenciée, L'écrêtage est réalisé en créant une fonction qui rend l'erreur linéaire lorsqu'elle dépasse 1. Plus précisément, procédez comme suit. L'implémentation ici a été légèrement modifiée en référence à [here] 7.
def clipped_loss(self, data, target, q_value_filter):
filtered_qs = self.filtered_q_values(data, q_value_filter)
error = tf.abs(target - filtered_qs)
quadratic = tf.clip_by_value(error, 0.0, 1.0)
linear = error - quadratic
return tf.reduce_sum(0.5 * tf.square(quadratic) + linear)
La différence avec les implémentations trouvées sur d'autres réseaux est qu'elles sont additionnées plutôt que moyennées. En regardant l'article de Nature, je n'ai pas trouvé d'énoncé clair selon lequel je devais prendre la moyenne, et prendre la moyenne n'avait aucun mérite dans la mesure où j'ai expérimenté à portée de main, mais a plutôt retardé considérablement la convergence.
Si vous l'implémentez pour prendre la moyenne, cela aura pour effet de réduire considérablement le taux d'apprentissage, donc cela peut conduire à un score plus élevé lorsque l'apprentissage progresse considérablement, mais les jeux atari avec DQN En ce qui me concerne, je ne pense pas que ce sera efficace personnellement.
À l'exception du changement de ReplayMemory de 1 million à 400 000, les paramètres sont les mêmes et le résultat de 1,5 million d'itérations est affiché.
DQN with tensorflow 2 pic.twitter.com/JRwM0MsTDG
— EpsilonCode (@epsilon_code) August 7, 2016
La vidéo a différents paramètres d'apprentissage et le nombre d'itérations de la version incomplète, de sorte que la version incomplète peut en fait avoir les mêmes performances. Vous pourriez penser cela, mais quand je l'ai essayé, ce n'était pas le cas, et ce paramètre était extrêmement meilleur en termes de performances. Le code est sur GitHub, alors essayez-le.
V.Mnih et al. Human-level control through deep reinforcement learning A.Graves Generating Sequences With Recurrent Neural Networks [Implémenter DQN avec Keras, TensorFlow et OpenAI Gym] 6
Recommended Posts