强化学习策略梯度梳理3-SOTA上（附PPO2代码）

强化学习策略梯度梳理-SOTA

这个部分主要参考周博磊老师的第六节的顺序
主要参考课程 Intro to Reinforcement Learning，Bolei Zhou
相关文中代码 https://github.com/ThousandOfWind/RL-basic-alg.git

进阶方向1

PG

首先策略的优化目标是
$$J(\theta )={\mathbb{E}}_{\tau \sim {\pi }_{\theta }}[R(\tau )]$$
策略梯度的计算方法
$$\begin{array}{rl}{\nabla }_{\theta }J(\theta )& ={\mathbb{E}}_{{\pi }_{\theta }}\left[G_t{\nabla }_{\theta }\log {\pi }_{\theta }(s,a)\right]\\ & \approx \frac{1}{N}\sum _{i=1}^N{G}_t^i{\nabla }_{\theta }\log {\pi }_{\theta }\left(s_i,a_i\right)\end{array}$$

通过引入baseline我们可以削减方差
$$A^{\pi }(s,a)=Q^{\pi }(s,a)-V^{\pi }(s)$$

这里我还有个不太明白的地方， 为什么baseline可以用state value替代，因为我们期待的baseline应该是与策略无关吧， 但是V多多少少还是和策略有关呀，也可能我理解错了

总结

好精辟，这我不得背下来！

$$\begin{array}{rl}{\nabla }_{\theta }J(\theta )& ={\mathbb{E}}_{{\pi }_{\theta }}\left[{\nabla }_{\theta }\log {\pi }_{\theta }(s,a)G_t\right]-\text{ REINFORCE }\\ & ={\mathbb{E}}_{{\pi }_{\theta }}\left[{\nabla }_{\theta }\log {\pi }_{\theta }(s,a)Q^{\mathrm{w}}(s,a)\right]-\text{ Q Actor-Critic }\\ & ={\mathbb{E}}_{{\pi }_{\theta }}\left[{\nabla }_{\theta }\log {\pi }_{\theta }(s,a)A^{\mathrm{w}}(s,a)\right]-\text{ Advantage Actor-Critic }\\ & ={\mathbb{E}}_{{\pi }_{\theta }}\left[{\nabla }_{\theta }\log {\pi }_{\theta }(s,a)\delta \right]-\text{ TD Actor-Critic }\end{array}$$

TRPO

Trust region policy optimization. Schulman, L., Moritz, Jordan, Abbeel. 2015
考虑到PG的存在的两大问题：

1. 采样效率低（on-policy)
2. 容易收敛到局部最优

为了使得训练更稳定 -> Trust region & natural policy gradient
make it as off-policy policy optimization -> 重要性采样

natural policy gradient

这里数学过量。。。我姑且先放弃。话说周博磊老师视频讲natural policy gradient真的是贼来劲
请参考强化学习进阶 第七讲 TRPO

Importance sampling

我们知道策略梯度一个问题是只能on-policy，对经验的利用率很低，但如果加入重要性采样，我们就可以把过去的样本也利用上了
$${\mathbb{E}}_{x\sim p}[f(x)]=\int p(x)f(x)dx=\int q(x)\frac{p(x)}{q(x)}f(x)dx={\mathbb{E}}_{x\sim q}\left[\frac{p(x)}{q(x)}f(x)\right]$$
$$J(\theta )={\mathbb{E}}_{a\sim {\pi }_{\theta }}[r(s,a)]={\mathbb{E}}_{a\sim \hat{\pi }}\left[\frac{{\pi }_{\theta }(s,a)}{\hat{\pi }(s,a)}r(s,a)\right]$$

Trust Regions

尽管如此，我们还是不希望我们将要用的经验距离现在的目标区别太大，
所以我们可以用KL散度进行约束
$$KL\left({\pi }_{{\theta }_{old}}\Vert {\pi }_{\theta }\right)=-\sum _a{\pi }_{{\theta }_{old}}(a\mid s)\log \frac{{\pi }_{\theta }(a\mid s)}{{\pi }_{{\theta }_{old}}(a\mid s)}$$
这样我们就得到了优化目标，然后再用拉格朗日法求解
$$\begin{array}{l}{J}_{{\theta }_{\text{old }}}(\theta )={\mathbb{E}}_t\left[\frac{{\pi }_{\theta }\left(a_t\mid s_t\right)}{{\pi }_{{\theta }_{\text{old }}}\left(a_t\mid s_t\right)}{R}_t\right]\\ \text{ subject to }KL\left({\pi }_{{\theta }_{\text{old }}}\left(\cdot \mid s_t\right)\Vert {\pi }_{\theta }\left(\cdot \mid s_t\right)\right)\le \delta \end{array}$$

由于TRPO涉及了大量会把我绕晕的理论我也姑且先不复现了

ACKTR

Y. Wu, et al. “Scalable trust-region method for deep reinforcement learning using Kronecker-factored approximation”. NIPS 2017

目标是为了提高TRPO的计算效率

SGD 是一阶优化
natural policy gradient 二阶优化，单数需要矩阵求逆，计算销量较低
K-FAC 不断分解矩阵，把大矩阵求逆变换成小矩阵求逆

PPO

保留了TRPO的约束条件

$$\begin{array}{l}{\mathrm{maximize}}_{\theta }{\mathbb{E}}_t\left[\frac{{\pi }_{\theta }\left(a_t\mid s_t\right)}{{\pi }_{{\theta }_{old}}\left(a_t\mid s_t\right)}{A}_t\right]\\ \text{ subject to }{\mathbb{E}}_t\left[KL\left[{\pi }_{{\theta }_{old}}\left(.\mid s_t\right),{\pi }_{\theta }\left(.\mid s_t\right)\right]\right]\le \delta \end{array}$$
unconstrained form ->
$${\mathrm{maximize}}_{\theta }{\mathbb{E}}_t\left[\frac{{\pi }_{\theta }\left(a_t\mid s_t\right)}{{\pi }_{{\theta }_{\text{old }}}\left(a_t\mid s_t\right)}{A}_t\right]-\beta {\mathbb{E}}_t\left[KL\left[{\pi }_{{\theta }_{\text{old }}}\left(\cdot \mid s_t\right),{\pi }_{\theta }\left(.\mid s_t\right)\right]\right]$$

PPO1

自适应优化

PPO2

这个实现除了周老师的tuturial还参考了https://github.com/zhangchuheng123/Reinforcement-Implementation/blob/master/code/ppo.py

记probability ratio 为
$$r_t(\theta )=\frac{{\pi }_{\theta }\left(a_t\mid s_t\right)}{{\pi }_{{\theta }_{\text{old }}}\left(a_t\mid s_t\right)}$$
用clip将这个值限定在一定范围内
$$L_t(\theta )=\min \left(r_t(\theta ){\hat{A}}_t,\mathrm{clip}\left(r_t(\theta ),1-ϵ,1+ϵ\right){\hat{A}}_t\right)$$
因此
当advantage 为正，loss 有上界
$$L\left(\theta ;{\theta }_{old}\right)=\min \left(\frac{{\pi }_{\theta }\left(a_t\mid s_t\right)}{{\pi }_{{\theta }_{old}}\left(a_t\mid s_t\right)},(1+ϵ)\right){\hat{A}}_t$$
否则，有下界
$$L\left(\theta ;{\theta }_{old}\right)=\max \left(\frac{{\pi }_{\theta }\left(a_t\mid s_t\right)}{{\pi }_{{\theta }_{old}}\left(a_t\mid s_t\right)},(1-ϵ)\right){\hat{A}}_t$$
因此

code

首先是动作部分，这里需要返回把做选择时候的action_log_probs以及value都保存到经验池

    def get_action(self, observation, *arg):
        obs = th.FloatTensor(observation)
        action_index, value, action_log_probs, _ = self.ac.select_action(obs=obs)
        return int(action_index), action_log_probs, value

然后是训练部分，可以拆开看其中的两个主要部分：
首先是计算advantage：
最简单的版本是：

        advangtage = th.zeros_like(reward)
        pre_return = 0
        for i in range(advangtage.shape[0]-1, -1, -1):
            pre_return = reward[i] + (1 - done[i]) * self.gamma * pre_return
            advangtage[i] = pre_return - value[i]

高级版本里面可以用到$\lambda$ 的思路

        advangtage = th.zeros_like(reward)
        returns = th.zeros_like(reward)
        deltas = th.zeros_like(reward)
        pre_return = 0
        pre_value = 0
        pre_advantage = 0
        for i in range(advangtage.shape[0]-1, -1, -1):
            returns[i] = reward[i] + (1 - done[i]) * self.gamma * pre_return
            deltas[i] = reward[i] + (1 - done[i]) * self.gamma * pre_value - value[i]
            advangtage[i] = deltas[i] + (1 - done[i]) * self.gamma * self.lamda * pre_advantage
            pre_return = returns[i]
            pre_value = value[i]
            pre_advantage = advangtage[i]

然后是训练，可以注意到loss有三个部分组成

            minibatch_new_value, minibatch_new_action_log_prob, minibatch_dist_entropy, _ \
                = self.ac.evaluate_actions(obs=minibatch_obs, action=action_index)
            ratio = th.exp(minibatch_old_action_log_prob - minibatch_new_action_log_prob)
            surr1 = ratio * minibatch_advantange
            surr2 = ratio.clamp( 1 - self.clip, 1 + self.clip)
            loss_surr = - th.mean(th.min(surr1, surr2))

            if self.lossvalue_norm:
                minibatch_return_6std = 6 * minibatch_return.std()
                loss_value = th.mean((minibatch_new_value - minibatch_return).pow(2))/minibatch_return_6std
            else:
                loss_value = th.mean((minibatch_new_value - minibatch_return).pow(2))

            loss_entropy = th.mean(th.exp(minibatch_new_action_log_prob) * minibatch_new_action_log_prob)

            total_loss = loss_surr + self.loss_coeff_value * loss_value + self.loss_coeff_entropy * loss_entropy

            self.optimiser.zero_grad()
            total_loss.backward()
            self.optimiser.step()

最后呢有一个需要注意到部分是关于存储和采样的几个小细节，

1. 一般复现都是用rollout storage。我其实还困惑了蛮久，这和DQN的memory buffer有什么区别，但是经过反复对比验证，可能主要区别就在于DQN中理想情况下是不会丢弃旧经验的，但是在rollout storage中会有一个固定的相对小的空间，遵循先入先出原则。
2. 每次训练的时候实际上是取得所有存储的样本，然后对这些些样本做几次随机采样，并进行训练

    def learn(self, memory):
        batch = memory.get_current_trajectory()

        obs = th.FloatTensor(batch['observation'])
        action_index = th.LongTensor(batch['action_index'])
        next_obs = th.FloatTensor(batch['next_obs'])
        reward = th.FloatTensor(batch['reward'])
        done = th.FloatTensor(batch['done'])
        old_action_log_prob = th.FloatTensor(batch['action_log_prob'])
        value = th.FloatTensor(batch['value'])
		...
		
        for _ in range(self.ppo_epoch):
            minibatch_ind = np.random.choice(self.batch_size, self.minibatch_size, replace=False)
            minibatch_obs = obs[minibatch_ind]
            minibatch_old_action_log_prob = old_action_log_prob[minibatch_ind]
            minibatch_advantange = advangtage[minibatch_ind]
            minibatch_return = returns[minibatch_ind]
            ...

实验结果

loss 因为loss有三个项， 他们回传的程度分别是

loss_surr	loss_value	loss_entropy
1	loss_coeff_value	loss_coeff_entropy

需要自己调节吧，

• 当熵回传的比重低，就会早早停在一个不太好的解
• 当熵回传的比重高，策略就会倾向于均匀动作，相当于啥也没学到
• 感觉其实挺难调到好的解的

动作倾向
可以看到动作倾向黄了，这说明策略是相对匀称，
可能是他终于明白这个环境要求匀称的策略
但鉴于结果还是不太好，也可能只是最大熵push它表现出这种策略