Berechnung der Aktualisierung des Akteursgradienten im DDPG-Algorithmus (Deep Deterministic Policy Gradient)

8

Diese Frage bezieht sich auf das Deepmind-Papier zu DDPG: https://arxiv.org/pdf/1509.02971v5.pdf .

Die meisten (alle?) Implementierungen des DDPG-Algorithmus, die ich gesehen habe, berechnen die Gradientenaktualisierung für das Akteursnetzwerk durch $\nabla(J)=\nabla_{\mu(s|\theta)}(Q(s,\mu(s|\theta))\nabla_{\theta}(\mu(s|\theta))$ , wo $\theta$ stellt die Parameter des Akteursnetzwerks dar, $\mu$ repräsentiert das Akteursnetzwerk, $Q$ repräsentiert das Kritikernetzwerk und $s$ repräsentiert die Zustandseingabe. Ich werde diese Gleichung 1 nennen.

Gleichung 1 wird, wie in der Veröffentlichung gezeigt, durch Anwenden der Kettenregel auf abgeleitet $\nabla(J)=\nabla_{\theta}(Q(s,\mu(s|\theta))$ . Das gibt $\nabla_{\mu(s|\theta)}(Q(s,\mu(s|\theta))\nabla_{\theta}(\mu(s|\theta))$ .

Meine Frage ist, ob ich mit einem Auto-Grad-Softwarepaket (Theano / Tensorflow / Torch / etc) einen Grund habe, warum ich nicht einfach den Gradienten der Ausgabe von berechnen konnte $Q$ wrt $\theta$ direkt? Aus irgendeinem Grund scheinen alle Implementierungen zuerst den Gradienten der Ausgabe von zu berechnen $Q$ wrt $\mu(s)$ und multiplizieren Sie es dann mit dem Gradienten von $\mu(s)$ wrt zu $\theta$ gemäß der Kettenregel. Ich verstehe nicht, warum sie das tun - warum nicht einfach den Gradienten von direkt berechnen $Q$ wrt $\theta$ stattdessen? Gibt es einen Grund, warum Sie dies nicht tun können? Dh warum scheinen die meisten Updates dies zu tun:

Q_grad = gradients( Q(s, mu(s|theta)), mu(s|theta) )
mu_grad = gradients( mu(s|theta), theta )
J_grad = Q_grad * mu_grad

An Stelle von:

J_grad = gradients( Q(s, mu(s|theta)), theta )

Wobei die erste Eingabe für "Farbverläufe" die Funktion ist, die Sie unterscheiden möchten, und die zweite Eingabe die Funktion ist, in Bezug auf die Sie unterscheiden möchten.

Um klar zu sein, ich sehe keinen Grund warum $\nabla(J)=\nabla_{\theta}(Q)$ ist eine andere Aktualisierung als Gleichung 1, da Gleichung 1 buchstäblich durch Anwenden der Kettenregel auf abgeleitet wird $\nabla_{\theta}(Q)$ , aber ich möchte sicherstellen, dass mir keine Subtilität fehlt.

— Rechnung
quelle

Könnten Sie genauer sagen, welchen Gradienten Sie vorschlagen? Ich bin mir nicht sicher, was Sie unter "Verwenden Sie die Gleichung, bevor Sie die Kettenregel als Update

— anwenden

@ DaVinci Entschuldigung für die Mehrdeutigkeit! Ich habe den ursprünglichen Beitrag aktualisiert, um (hoffentlich) klarer zu sein.

— Bill

6

Es gibt keinen Unterschied in der Berechnung. Ich habe mich das Gleiche gefragt und in meiner eigenen TensorFlow DDPG-Implementierung überprüft, indem ich beide ausprobiert und behauptet habe, dass die numerischen Werte identisch sind. Wie erwartet sind sie.

Mir ist aufgefallen, dass die meisten Tutorial-ähnlichen Implementierungen (z. B. Patrick Emamis ) die Multiplikation explizit zeigen. Die Baseline-Implementierung von OpenAI $does$ direkt berechnen $\nabla_{\theta^\mu} Q$ . (Sie definieren dazu einen Verlust im Akteursnetzwerk von $-\nabla_{\theta^\mu} Q$ gemittelt über die Charge).

Es gibt einen Grund, den Sie trennen möchten $\nabla_a Q$ von $\nabla_{\theta^\mu} \mu$ und multipliziere sie. Dies ist der Fall, wenn Sie einen der Begriffe direkt bearbeiten möchten. Zum Beispiel machen Hausknecht und Stone "invertierende Gradienten" an $\nabla_a Q$ Maßnahmen zu erzwingen, um in der Reichweite der Umwelt zu bleiben.

— Brenden Petersen
quelle

2

Auf diese Weise können Sie zwei unabhängige Netzwerke definieren. Andernfalls müssen Sie möglicherweise ein großes Netzwerk definieren und unterscheiden, welcher Teil zur Richtlinie und welcher zur Statusaktionswertfunktion gehört.

— user1467618
quelle

0

Ich bin mir nicht sicher, ob ich diese Multiplikation zwischen den beiden Gradiententermen verstehen kann.

Wenn Sie dies mit Tensorflow berechnen:

J_grad = gradients( Q(s, mu(s|theta)), theta )

Es wendet die Kettenregel an und berechnet daher die Gadients für Qdie Ausgabe des Richtliniennetzwerks mu(s|theta)und propagiert diese "Fehler" dann über das Richtliniennetzwerk zurück, um die abgetasteten Farbverläufe theta(die Parameter jeder Schicht Ihres Richtliniennetzwerks) zu erhalten.

Wenn Sie jedoch Folgendes tun:

Q_grad = gradients( Q(s, mu(s|theta)), mu(s|theta) )
mu_grad = gradients( mu(s|theta), theta )
J_grad = Q_grad * mu_grad

Dann berechnet es nach meinem Verständnis (1) den Gradienten Qder Ausgabe des Richtliniennetzwerks mu(s|theta)und (2) den Gradienten der Ausgabe des Richtliniennetzwerks mu(s|theta)für die Richtlinienparameter theta, diesmal jedoch SEPARAT. Was ich nicht verstehe, ist, dass Sie jetzt einerseits Ihren ersten Farbverlauf haben, der ein Größenvektor ist, (1, action_dim)und andererseits Ihren zweiten Farbverlauf, der ein Größenvektor ist (1, theta_dim). Um Ihr Update anzuwenden, benötigen Sie einen Farbverlauf für Theta, der ein Vektor der Größe wäre (1, theta_dim). Was genau bewirkt diese Multiplikation in der dritten Zeile und wie entspricht sie der Rückübertragung des ersten Gradienten durch das Richtliniennetzwerk:

J_grad = Q_grad * mu_grad

Frage:

Führt es nur ein Außenprodukt aus, das eine Formmatrix erstellt (action_dim, theta_dim)und dann durch Summieren über die Dimension reduziert, um unseren Aktualisierungsvektor der Form zu erhalten (1, theta)? Wenn ja, warum ist dies gültig (entspricht der Rückübertragung des ersten Gradienten durch das Richtliniennetzwerk)?

— Julep
quelle