强化学习之SAC

最新推荐文章于 2024-10-12 03:36:43 发布

微笑小星

最新推荐文章于 2024-10-12 03:36:43 发布

阅读量1.9k

点赞数 7

分类专栏：强化学习文章标签：深度学习机器学习 pytorch

本文链接：https://blog.csdn.net/tianjuewudi/article/details/120662471

版权

强化学习专栏收录该内容

44 篇文章 91 订阅

订阅专栏

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

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

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

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

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

参考论文：

Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor，2018年8月发表。
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在同时最大化期望和策略分布的熵，也就是说，在保证任务成果的同时希望策略尽可能的随机。

信息熵

这里说明一下信息熵的概念：当一件事情发生的概率越小，这件事情的信息量越大，对于一个分布而言，信息量的计算方式是：
$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)]$
在最大熵强化学习中需要优化的目标是：
$argmax_{\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]$

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

因此，采样更新公式应该是：
$Q^{\pi}(s，a) \approx r + \gamma (Q^{\pi}(s',\hat{ a'}) - \alpha \log \pi(\hat {a'}|s')) ,\hat{a'} ～ \pi(.|s')$
损失函数为：
$L（\phi_i,D） = E[(Q_{\phi}(s,a) - y(r,s',d))^2]$
TD3类似，SAC也采用了两个Q网络的更新形式，然后使用较小的Q值进行更新。
$\gamma (1-d)(\min_{j=1,2}Q_{\phi_{targ,j}}(s',\hat{a'}) - \alpha \log \pi_{\theta}(\hat{a'}|s')) ,\hat{a'} ～ \pi(.|s')$
对于状态价值V有：
$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))$

Reparameterization Trick

同时也在动作输出中加入了噪声。这就是Reparameterization Trick。让a从策略网络中进行采样转变成和其没有什么关系的采样。
$\hat{a_{\theta}}(s,\epsilon) = \tanh(μ_{\theta}(s) + \sigma_{\theta}(s) \odot \epsilon),\epsilon～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)