近接ポリシー最適化-PPO

これは近接ポリシー最適化（PPO）のPyTorch実装です。

PPOは強化学習のポリシーグラデーション法です。シンプルなポリシーグラデーションメソッドでは、サンプル (またはサンプルセット) ごとに 1 回のグラデーション更新を行います。1つのサンプルに対して複数のグラデーションステップを実行すると、ポリシーの偏差が大きすぎて不適切なポリシーになるため、問題が発生します。PPO では、ポリシーをデータのサンプリングに使用したポリシーに近い状態に保つことで、サンプルごとに複数のグラデーション更新を行うことができます。更新されたポリシーがデータのサンプリングに使用されたポリシーに合わない場合は、グラデーションフローをクリッピングして更新します

。

これを使った実験はこちらからご覧いただけます。この実験では、一般化アドバンテージ推定を使用しています

。

28import torch
29
30from labml_helpers.module import Module
31from labml_nn.rl.ppo.gae import GAE

PPO ロス

PPO 更新ルールは次の方法で導き出されます。

$θ max J (π_{θ}) = E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} r_{t}]$ ここで、 $r$ が報酬、がポリシー、 $π$ がポリシーからサンプリングされた軌跡、 $τ$ $γ$ そしてその間の割引係数で、ポリシーの報酬を最大化したいと考えています。 $[0, 1]$

E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} A^{π_{O L D}} (s_{t}, a_{t})] E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} (Q^{π_{O L D}} (s_{t}, a_{t}) - V^{π_{O L D}} (s_{t}))] E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} (r_{t} + V^{π_{O L D}} (s_{t + 1}) - V^{π_{O L D}} (s_{t}))] E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} (r_{t})] - E_{τ \sim π_{θ}} [V^{π_{O L D}} (s_{0})] = = = = J (π_{θ}) - J (π_{θ_{O L D}})

だから、 $θ max J (π_{θ}) = θ max E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} A^{π_{O L D}} (s_{t}, a_{t})]$

割引後の将来の状態分布を定義し、 $d^{π} (s) = (1 - γ) t = 0 \sum \infty γ^{t} P (s_{t} = s ∣ π)$

次に、

J (π_{θ}) - J (π_{θ_{O L D}}) = E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} A^{π_{O L D}} (s_{t}, a_{t})] = \frac{1}{1 - γ} E_{s \sim d^{π_{θ}}, a \sim π_{θ}} [A^{π_{O L D}} (s, a)]

$a$ $π_{θ_{O L D}}$ からの重要度サンプリング

J (π_{θ}) - J (π_{θ_{O L D}}) = \frac{1}{1 - γ} E_{s \sim d^{π_{θ}}, a \sim π_{θ}} [A^{π_{O L D}} (s, a)] = \frac{1}{1 - γ} E_{s \sim d^{π_{θ}}, a \sim π_{θ_{O L D}}} [\frac{π _{θ} ( a ∣ s )}{π _{θ_{O L D}} ( a ∣ s )} A^{π_{O L D}} (s, a)]

そうすると、 $d^{π_{θ}} (s)$ $d^{π_{θ_{O L D}}} (s)$ 似たようなものだと仮定します。 $J (π_{θ}) - J (π_{θ_{O L D}})$ この仮定によって生じる誤差は、 $π_{θ}$ との間の KL の相違によって決まります。 $π_{θ_{O L D}}$ 制約付きポリシー最適化はその証拠です。まだ読んでないよ。

J (π_{θ}) - J (π_{θ_{O L D}}) = \frac{1}{1 - γ} E_{a \sim π _{θ_{O L D}} s \sim d ^{π_{θ}}} [\frac{π _{θ} ( a ∣ s )}{π _{θ_{O L D}} ( a ∣ s )} A^{π_{O L D}} (s, a)] \approx \frac{1}{1 - γ} E_{a \sim π _{θ_{O L D}} s \sim d ^{π_{θ_{O L D}}}} [\frac{π _{θ} ( a ∣ s )}{π _{θ_{O L D}} ( a ∣ s )} A^{π_{O L D}} (s, a)] = \frac{1}{1 - γ} L^{CP I}

34class ClippedPPOLoss(Module):

136    def __init__(self):
137        super().__init__()

139    def forward(self, log_pi: torch.Tensor, sampled_log_pi: torch.Tensor,
140                advantage: torch.Tensor, clip: float) -> torch.Tensor:

比率 $r_{t} (θ) = \frac{π _{θ} ( a _{t} ∣ s _{t} )}{π _{θ_{O L D}} ( a _{t} ∣ s _{t} )}$ 。これは報酬とは異なります $r_{t}$ 。

143        ratio = torch.exp(log_pi - sampled_log_pi)

ポリシー比率のクリッピング

L^{C L I P} (θ) = E_{a_{t}, s_{t} \sim π_{θ O L D}} [min (r_{t} (θ) \overset{ˉ}{A_{t}}, c l i p (r_{t} (θ), 1 - ϵ, 1 + ϵ) \overset{ˉ}{A_{t}})]

比率は 1 に近づくようにクリッピングされます。 $π_{θ}$ $π_{θ_{O L D}}$ $1 - ϵ$ 比率がとの間でない場合にのみ勾配が傾くように最小化しています $1 + ϵ$ 。これにより、との間の KL $π_{θ}$ の相違が抑えられます $π_{θ_{O L D}}$ 。大きな偏差があると、ポリシーのパフォーマンスが低下し、不適切なポリシーからサンプリングしているためにポリシーのパフォーマンスが低下し、回復しない場合があります。

正規化されたアドバンテージを使用すると、 $\overset{ˉ}{A_{t}} = \frac{A _{t} ^ - μ ( A _{t} ^ )}{σ ( A _{t} ^ )}$ ポリシー勾配推定量に偏りが生じますが、分散は大幅に減少します。

172        clipped_ratio = ratio.clamp(min=1.0 - clip,
173                                    max=1.0 + clip)
174        policy_reward = torch.min(ratio * advantage,
175                                  clipped_ratio * advantage)
176
177        self.clip_fraction = (abs((ratio - 1.0)) > clip).to(torch.float).mean()
178
179        return -policy_reward.mean()

クリッピングバリュー関数の損失

同様に、値関数の更新もクリップします。

V_{C L I P}^{π_{θ}} (s_{t}) L^{V F} (θ) = c l i p (V^{π_{θ}} (s_{t}) - \hat{V_{t}}, - ϵ, + ϵ) = \frac{1}{2} E [m a x ((V^{π_{θ}} (s_{t}) - R_{t})^{2}, (V_{C L I P}^{π_{θ}} (s_{t}) - R_{t})^{2})]

クリッピングにより、 $V_{θ}$ 値関数が大きくずれないようにします。 $V_{θ_{O L D}}$

182class ClippedValueFunctionLoss(Module):

204    def forward(self, value: torch.Tensor, sampled_value: torch.Tensor, sampled_return: torch.Tensor, clip: float):
205        clipped_value = sampled_value + (value - sampled_value).clamp(min=-clip, max=clip)
206        vf_loss = torch.max((value - sampled_return) ** 2, (clipped_value - sampled_return) ** 2)
207        return 0.5 * vf_loss.mean()