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

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 误差损失。
更新值函数网络：逼近软价值目标。
更新策略网络：最大化奖励和熵。
更新目标值函数网络：使用软更新规则 $\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}{(s, a, r, s') \sim D} \left[ \left( Q{\theta_i}(s, a) - y \right)^2 \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) 算法详解与 PyTorch 实现