web-dev-qa-db-fra.com

Gradients de stratégie dans Keras

J'ai essayé de construire un modèle en utilisant 'Deep Q-Learning' où j'ai un grand nombre d'actions (2908). Après un succès limité avec l'utilisation du DQN standard: ( https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf ), j'ai décidé de faire un peu plus de recherche parce que je figurais le l'espace d'action était trop grand pour permettre une exploration efficace.

J'ai ensuite découvert cet article: https://arxiv.org/pdf/1512.07679.pdf où ils utilisent un modèle acteur-critique et des gradients de politique, ce qui m'a ensuite conduit à: https: //arxiv.org/pdf/1602.01783.pdf où ils utilisent des gradients de politique pour obtenir de bien meilleurs résultats que DQN dans l'ensemble.

J'ai trouvé quelques sites où ils ont mis en œuvre des gradients de stratégie dans Keras, https://yanpanlau.github.io/2016/10/11/Torcs-Keras.html et https : //oshearesearch.com/index.php/2016/06/14/kerlym-a-deep-reinforcement-learning-toolbox-in-keras/ mais je ne sais pas comment ils sont mis en œuvre. Dans le premier (et quand j'ai lu les articles), il semble qu'au lieu de fournir une paire d'entrée et de sortie pour le réseau d'acteurs, vous fournissez les gradients pour tous les poids, puis utilisez le réseau pour le mettre à jour, tandis que dans le dernier ils calculent simplement une paire entrée-sortie.

Je viens de me confondre? Suis-je simplement censé entraîner le réseau en fournissant une paire entrée-sortie et utiliser le standard "fit", ou dois-je faire quelque chose de spécial? Si c'est le dernier, comment puis-je le faire avec le backend Theano? (les exemples ci-dessus utilisent TensorFlow).

pythondeep-learningtheanokerasq-learning
21
simeon

TL; DR

  1. Découvrez comment implémenter des fonctions de perte et des dégradés personnalisés à l'aide de Keras.backend. Vous en aurez besoin pour des algorithmes plus avancés et c'est en fait beaucoup plus facile une fois que vous aurez compris
  2. Un exemple CartPole d'utilisation de keras.backend pourrait être https://Gist.github.com/kkweon/c8d1caabaf7b43317bc8825c226045d2 (bien que son backend utilise Tensorflow mais il devrait être très similaire sinon identique)

Problème

En jouant,

l'agent a besoin d'une politique qui est essentiellement une fonction qui mappe un état dans une politique qui est une probabilité pour chaque action. Ainsi, l'agent choisira une action en fonction de sa politique.

c'est-à-dire, politique = f (état)

Lors de l'entraînement,

Le gradient de politique n'a pas de fonction de perte. Au lieu de cela, il essaie de maximiser le retour attendu des récompenses. Et, nous devons calculer les gradients de log (action_prob) * avantage

  1. l'avantage est fonction des récompenses.
    • avantage = f (récompenses)
  2. action_prob est une fonction des états et action_taken. Par exemple, nous devons savoir quelle action nous avons entreprise afin de pouvoir mettre à jour les paramètres pour augmenter/diminuer la probabilité de l'action que nous avons entreprise.
    • action_prob = sum (policy * action_onehot) = f (states, action_taken)

Je suppose quelque chose comme ça

  • politique = [0,1, 0,9]
  • action_onehot = action_taken = [0, 1]
  • alors action_prob = sum (policy * action_onehot) = 0.9

Résumé

Nous avons besoin de deux fonctions

  • fonction de mise à jour: f (état, action_taken, récompense)
  • choisir la fonction d'action: f (état)

Vous savez déjà que ce n'est pas facile à implémenter comme des problèmes de classification typiques où vous pouvez simplement model.compile (...) -> model.fit (X, y)

Cependant,

  • Afin d'utiliser pleinement Keras, vous devez être à l'aise avec la définition de fonctions de perte et de dégradés personnalisés. Il s'agit essentiellement de la même approche que celle de l'auteur de la première.

  • Vous devriez lire plus de documentations sur l'API fonctionnelle Keras et keras.backend

De plus, il existe de nombreux types de gradients politiques.

  • Le premier est appelé DDPG, ce qui est en fait assez différent des gradients de politique habituels
  • Le dernier que je vois est un gradient de politique REINFORCE traditionnel (pg.py) qui est basé sur l'exemple de gradient de politique de Kapathy. Mais c'est très simple par exemple, cela ne suppose qu'une seule action. C'est pourquoi il aurait pu être implémenté à l'aide de model.fit (...) à la place.

Références

9
Mo K

Les implémentations apparemment conflictuelles que vous avez rencontrées sont toutes deux des implémentations valides. Ce sont deux façons équivalentes dont deux mettent en œuvre les gradients de politique.

  1. Dans l'implémentation Vanilla, vous calculez les gradients du réseau de stratégie w.r.t. récompense et met à jour directement les poids dans le sens des gradients. Cela vous obligerait à suivre les étapes décrites par Mo K.

  2. La deuxième option est sans doute une implémentation plus pratique pour les frameworks autodiff comme keras/tensorflow. L'idée est d'implémenter une fonction d'entrée-sortie (état-action) comme l'apprentissage supervisé, mais avec une fonction de perte dont le gradient est identique au gradient de la politique. Pour une politique softmax, cela signifie simplement prédire la "véritable action" et multiplier la perte (entropie croisée) par les rendements/avantages observés. Aleksis Pirinen a quelques notes utiles à ce sujet [1].

La fonction de perte modifiée pour l'option 2 dans Keras ressemble à ceci:

import keras.backend as K

def policy_gradient_loss(Returns):
    def modified_crossentropy(action,action_probs):
        cost = K.categorical_crossentropy(action,action_probs,from_logits=False,axis=1 * Returns)
        return K.mean(cost)
    return modified_crossentropy

où 'action' est la véritable action de l'épisode (y), action_probs est la probabilité prédite (y *). Ceci est basé sur une autre question de stackoverflow [2].

Références

  1. https://aleksispi.github.io/assets/pg_autodiff.pdf
  2. Créer une fonction de perte personnalisée en keras
3
Arjan Groen