Soft Actor-Critic (SAC) 算法详解

Soft Actor-Critic (SAC) 是一种先进的强化学习算法，属于 Actor-Critic 方法的变体。它特别适合处理 连续动作空间，并通过引入最大熵（Maximum Entropy）强化学习的思想，有效解决了传统算法中的稳定性和探索问题。

SAC 背景与核心思想

1. 强化学习的挑战

在强化学习实践中，我们常面临以下难题：

探索与利用的平衡：传统算法在初期探索新策略与后期利用已有最优策略之间难以达到平衡。
不稳定性：在连续动作空间中，训练容易出现发散或收敛缓慢的问题。
样本效率：数据采集成本高，如何高效利用经验池中的数据是关键。

SAC 通过以下核心思想应对这些问题：

最大熵强化学习：在最大化累计奖励的同时，最大化策略的随机性（熵），以鼓励探索。
双 Q 网络：缓解 Q 值过估计的问题。
目标网络：使用目标网络稳定 Q 值计算。

2. 最大熵强化学习的目标

传统强化学习的目标是最大化期望累计奖励：

$$J(\pi) = \mathbb{E}{\pi} \left[ \sum{t=0}^T \gamma^t r(s_t, a_t) \right]$$

而 SAC 则通过添加一个熵项，在奖励中加入策略随机性的权重，目标变为：

$$J(\pi) = \mathbb{E}{\pi} \left[ \sum{t=0}^T \gamma^t \left( r(s_t, a_t) + \alpha \mathcal{H}(\pi(\cdot|s_t)) \right) \right]$$

其中：

$\alpha$：熵系数，控制熵和奖励之间的平衡。
$\mathcal{H}(\pi(\cdot|s_t)) = -\mathbb{E}_{a \sim \pi} [\log \pi(a|s_t)]$：表示策略的熵，鼓励策略更随机化。

效果：

更好的探索：熵的最大化使策略更加多样化。
更稳定的学习：避免陷入次优策略。

SAC 算法流程

SAC 使用了 Actor-Critic 框架，结合策略梯度和 Q 函数更新。以下是算法的关键步骤：

初始化

创建目标值函数网络 $V_{\psi'}$，并设置其参数为 $V_{\psi}$ 的初始值。
初始化策略网络 $\pi_\phi$ 和值函数网络 $V_\psi$。
初始化两组 Q 网络 $Q_{\theta_1}, Q_{\theta_2}$，用于计算 Q 值。

每一回合循环

采样动作：根据策略网络 $\pi_\phi$ 采样动作 $a \sim \pi(a|s)$。
执行环境：执行动作，记录 $(s, a, r, s', \text{done})$ 到经验池中。
更新 Q 网络：最小化 TD 误差，使用双 Q 网络取最小值。
更新值函数网络：逼近软价值函数。
更新策略网络：最大化奖励和熵。
更新目标值函数网络：使用软更新规则。

使用软更新规则： $$\psi' \gets \tau \psi + (1 - \tau) \psi'$$

策略网络的目标是最大化奖励和熵，最小化以下损失： $$J_\pi = \mathbb{E} \left[ \alpha \log \pi_\phi(a|s) - \min_{i=1,2} Q_{\theta_i}(s, a) \right]$$

class SACAgent: def __init__(self, state_dim, action_dim, max_action): self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.actor = PolicyNetwork(state_dim, action_dim, max_action).to(self.device) self.q1 = QNetwork(state_dim, action_dim).to(self.device) self.q2 = QNetwork(state_dim, action_dim).to(self.device) self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=LR) self.q1_optimizer = optim.Adam(self.q1.parameters(), lr=LR) self.q2_optimizer = optim.Adam(self.q2.parameters(), lr=LR) self.replay_buffer = ReplayBuffer(MEMORY_CAPACITY) self.max_action = max_action def select_action(self, state): state = torch.FloatTensor(state).to(self.device).unsqueeze(0) action, _ = self.actor.sample(state) return action.cpu().detach().numpy()[0] def train(self): if len(self.replay_buffer) < BATCH_SIZE: return states, actions, rewards, next_states, dones = self.replay_buffer.sample(BATCH_SIZE) states = torch.FloatTensor(states).to(self.device) actions = torch.FloatTensor(actions).to(self.device) rewards = torch.FloatTensor(rewards).unsqueeze(1).to(self.device) next_states = torch.FloatTensor(next_states).to(self.device) dones = torch.FloatTensor(dones).unsqueeze(1).to(self.device) # 更新 Q 网络 with torch.no_grad(): next_actions, log_probs = self.actor.sample(next_states) target_q1 = self.q1(next_states, next_actions) target_q2 = self.q2(next_states, next_actions) target_q = torch.min(target_q1, target_q2) - ALPHA * log_probs q_target = rewards + GAMMA * (1 - dones) * target_q q1_loss = ((self.q1(states, actions) - q_target) ** 2).mean() q2_loss = ((self.q2(states, actions) - q_target) ** 2).mean() self.q1_optimizer.zero_grad() q1_loss.backward() self.q1_optimizer.step() self.q2_optimizer.zero_grad() q2_loss.backward() self.q2_optimizer.step() # 更新策略网络 new_actions, log_probs = self.actor.sample(states) q1_new = self.q1(states, new_actions) q2_new = self.q2(states, new_actions) q_new = torch.min(q1_new, q2_new) actor_loss = (ALPHA * log_probs - q_new).mean() self.actor_optimizer.zero_grad() actor_loss.backward() self.actor_optimizer.step() def update_replay_buffer(self, state, action, reward, next_state, done): self.replay_buffer.push(state, action, reward, next_state, done)

Soft Actor-Critic (SAC) 算法详解