Soft Actor-Critic (SAC) 算法详解与 PyTorch 实现

Soft Actor-Critic (SAC) 算法详解

Soft Actor-Critic (SAC) 是一种基于最大熵强化学习（Maximum Entropy RL）的先进算法，属于 Actor-Critic 方法的变体。它特别擅长处理连续动作空间，通过引入熵正则化项有效解决了传统算法在探索与利用平衡、训练稳定性及样本效率方面的挑战。

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 网络取最小值作为目标。
更新值函数网络：逼近状态价值，目标值为 $y_V = \mathbb{E}{a \sim \pi} [\min{i=1,2} Q_{\theta_i}(s, a) - \alpha \log \pi_\phi(a|s)]$。
更新策略网络：最大化奖励和熵，等价于最小化 $J_\pi = \mathbb{E}[\alpha \log \pi_\phi(a|s) - \min_{i=1,2} Q_{\theta_i}(s, a)]$。
更新目标值函数网络：使用软更新规则 $\psi' \gets \tau \psi + (1 - \tau) \psi'$。

公式推导细节

1. Q 值更新

Q 值通过 Bellman 方程更新，目标是最小化 TD 误差： $$y = r + \gamma (1 - \text{done}) \cdot V_{\psi'}(s')$$ 损失函数为： $$J_Q = \mathbb{E}{\theta_i}(s, a) - y \right)^2 \right] \quad (i = 1, 2)$$

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) 算法详解与 PyTorch 实现