强化学习之SAC

参考视频：周博磊强化学习课程

价值函数优化学习主线：Q-learning→DQN→DDPG→TD3→SAC

Q-Learning，DQN和DDPG请可以参考我之前的文章：强化学习实践教学

TD3可以参考我之前的博客：强化学习之TD3(pytorch实现)

SAC可以参考博客：https://blog.csdn.net/qq_38587510/article/details/104970837

参考论文：

1. Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor，2018年8月发表。
2. Soft Actor-Critic Algorithms and Applications，2019年1月发表。

​ SAC全称Soft Actor-Critic，它整合了entropy regularization的思想。论文有以上两篇，第一篇采用模型包括一个actor网络，两个状态价值V网络，两个动作价值Q网络，第二篇的模型包括一个actor网络，四个动作价值Q网络。

​ model-free深度强化学习算法面临两个主要挑战：高采样复杂度和脆弱的收敛性，因此严重依赖调参，这两个挑战限制了强化学习向现实应用的推广。SAC引入了最大熵（Maximum Entropy）强化学习，要求actor在同时最大化期望和策略分布的熵，也就是说，在保证任务成果的同时希望策略尽可能的随机。

信息熵

这里说明一下信息熵的概念：当一件事情发生的概率越小，这件事情的信息量越大，对于一个分布而言，信息量的计算方式是：
$$H(U)=E[-\log p_i]=-\sum _{i=1}^n{p}_{i}log{p}_i$$
因此actor输出总概率相加为1的情况下，动作概率的分布越散，越不集中于一个action，这个熵的值越大。对于连续动作领域来说，就是随机噪声的采样值越偏离平均值，越出现在高斯分布边缘，这个值越大。

Maximum Entropy

​ 在标准强化学习中需要最大化累积期望reward：
$$\sum _t{E}_{（s_t,a_t）～p_{\pi }}[{\gamma }^{t}r(s_t,a_t)]$$
​ 在最大熵强化学习中需要优化的目标是：
$$argma{x}_{\pi }\sum _t{E}_{\tau ～\pi }[{\gamma }^t(R(s_t,a_r,s_{t+1})+\alpha H(\pi (.|s_t)))]$$
​ 最大熵强化学习在标准的最大reward强化目标上增加了一个最大熵项，提高了探索能力和鲁棒性。既降低了采样复杂度，又提高了收敛稳定性。可以学到更多near-optimal的行为，也就是在一些状态下，可能存在多个动作都是最优的，那么使选择它们的概率相同，可以提高学习的速度。

此时有：
$$V^{\pi }(s)=E_{\tau ～\pi }[\sum _t{\gamma }^t(R(s_t,a_r,s_{t+1})+\alpha H(\pi (.|s_t)))|s_0=s]$$

$$\begin{gathered} Q^{\pi }(s，a)=E_{s^{\prime }～P,a^{\prime }～\pi }[R(s,a,s^{\prime })+\gamma (Q^{\pi }(s^{\prime },a^{\prime })+\alpha H(\pi (.|s_t)))] \\ =E_{s^{\prime }～P,a^{\prime }～\pi }[R(s,a,s^{\prime })+\gamma (Q^{\pi }(s^{\prime },a^{\prime })-\alpha \log \pi (a^{\prime }|s^{\prime }))] \end{gathered}$$

因此，采样更新公式应该是：
$$Q^{\pi }(s，a)\approx r+\gamma (Q^{\pi }(s^{\prime },\widehat{a^{\prime }})-\alpha \log \pi (\widehat{a^{\prime }}|s^{\prime })),\widehat{a^{\prime }}～\pi (.|s^{\prime })$$
损失函数为：
$$L（{\varphi }_i,D）=E[(Q_{\varphi }(s,a)-y(r,s^{\prime },d){)}^2]$$
TD3类似，SAC也采用了两个Q网络的更新形式，然后使用较小的Q值进行更新。
$$y(r,s^{\prime },d)=r+\gamma (1-d)(\underset{j=1,2}{\min }{Q}_{{\varphi }_{targ,j}}(s^{\prime },\widehat{a^{\prime }})-\alpha \log {\pi }_{\theta }(\widehat{a^{\prime }}|s^{\prime })),\widehat{a^{\prime }}～\pi (.|s^{\prime })$$
对于状态价值V有：
$$\begin{gathered} V^{\pi }(s)=E_{a～\pi }[Q^{\pi }(s,a)]+\alpha H(\pi (.|s)) \\ =E_{a～\pi }[Q^{\pi }(s,a)]-\alpha \log \pi (a|s)) \end{gathered}$$

Reparameterization Trick

同时也在动作输出中加入了噪声。这就是Reparameterization Trick。让a从策略网络中进行采样转变成和其没有什么关系的采样。
$$\widehat{a_{\theta }}(s,ϵ)=\tanh ({\mu }_{\theta }(s)+{\sigma }_{\theta }(s)\odot ϵ),ϵ～N(0,1)$$
其中μ和σ都是由神经网络学习得到的，因此在奖励最大化的同时鼓励探索的话，σ会尽可能增大以达到探索的目的，这样一个μ和σ都会变化的动作分布大大增加了动作策略的灵活性。

actor部分代码：

class GaussianPolicy(nn.Module):
    def __init__(self, num_inputs, num_actions, hidden_dim, action_space=None):
        super(GaussianPolicy, self).__init__()
        
        self.linear1 = nn.Linear(num_inputs, hidden_dim)
        self.linear2 = nn.Linear(hidden_dim, hidden_dim)

        self.mean_linear = nn.Linear(hidden_dim, num_actions)
        self.log_std_linear = nn.Linear(hidden_dim, num_actions)
        # 使用对应函数初始化所有的全连接层参数
        self.apply(weights_init_)

        # action rescaling
        if action_space is None:
            self.action_scale = torch.tensor(1.)
            self.action_bias = torch.tensor(0.)
        else:
            self.action_scale = torch.FloatTensor(
                (action_space.high - action_space.low) / 2.)
            self.action_bias = torch.FloatTensor(
                (action_space.high + action_space.low) / 2.)

    def forward(self, state):
        x = F.relu(self.linear1(state))
        x = F.relu(self.linear2(x))
        mean = self.mean_linear(x)
        log_std = self.log_std_linear(x)
        log_std = torch.clamp(log_std, min=LOG_SIG_MIN, max=LOG_SIG_MAX)
        return mean, log_std

    def sample(self, state):
        mean, log_std = self.forward(state)
        std = log_std.exp()
        # 创建高斯分布
        normal = Normal(mean, std)
        x_t = normal.rsample()  # for reparameterization trick (mean + std * N(0,1))
        y_t = torch.tanh(x_t)
        action = y_t * self.action_scale + self.action_bias
        log_prob = normal.log_prob(x_t)
        # Enforcing Action Bound
        # ---重点问题---
        log_prob -= torch.log(self.action_scale * (1 - y_t.pow(2)) + epsilon)
        log_prob = log_prob.sum(1, keepdim=True)
        
        mean = torch.tanh(mean) * self.action_scale + self.action_bias
        return action, log_prob, mean

    def to(self, device):
        self.action_scale = self.action_scale.to(device)
        self.action_bias = self.action_bias.to(device)
        return super(GaussianPolicy, self).to(device)