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

最小化值函数损失： $$J_V = \mathbb{E} \left[ \left( V_\psi(s) - y_V \right)^2 \right]$$

值函数 $V_\psi$ 的目标是逼近以下值：
$$y_V = \mathbb{E}{a \sim \pi} \left[ \min{i=1,2} Q_{\theta_i}(s, a) - \alpha \log \pi_\phi(a|s) \right]$$

最小化以下损失函数： $$J_Q = \mathbb{E} \left[ \left( Q_{\theta_i}(s, a) - y \right)^2 \right] \quad (i = 1, 2)$$

使用 TD 目标更新 Q 值： $$y = r + \gamma (1 - \text{done}) \cdot V_{\psi'}(s')$$

公式推导

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]$$

2. 值函数更新

值函数估计策略的长期价值，目标值为： $$y_V = \mathbb{E}{a \sim \pi} \left[ \min{i=1,2} Q_{\theta_i}(s, a) - \alpha \log \pi_\phi(a|s) \right]$$

损失函数为： $$J_V = \mathbb{E}{s \sim D} \left[ \left( V\psi(s) - y_V \right)^2 \right]$$

3. 策略网络更新

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

4. 目标值函数更新

目标值函数使用软更新规则： $$\psi' \gets \tau \psi + (1 - \tau) \psi'$$

其中 $\tau \in (0, 1]$ 控制更新步长。

Python 实现

以下是基于 PyTorch 的 Soft Actor-Critic (SAC) 算法完整实现。代码涵盖了从环境配置、网络定义到训练循环的全过程。

1. 参数设置

"""
《SAC, Soft Actor-Critic 算法》
时间：2024.12
"""
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import gym
import random
from collections import deque

# 超参数设置
GAMMA = 0.99          # 折扣因子，用于计算未来奖励
TAU = 0.005           # 软更新目标网络的参数
ALPHA = 0.2           # 熵正则化系数，鼓励探索
LR = 0.001            # 学习率，用于优化器
BATCH_SIZE = 256      # 每次训练的样本数量
MEMORY_CAPACITY = 100000  # 经验回放缓冲区的最大容量

2. 策略网络

策略网络负责生成随机的策略动作。这里使用了重参数化技巧来保证梯度可导。

class PolicyNetwork(nn.Module):
    def __init__(self, state_dim, action_dim, max_action):
        super(PolicyNetwork, self).__init__()
        self.fc1 = nn.Linear(state_dim, 256)
        self.fc2 = nn.Linear(256, 256)
        self.mean = nn.Linear(256, action_dim)
        self.log_std = nn.Linear(256, action_dim)
        self.max_action = max_action

    def forward(self, state):
        x = torch.relu(self.fc1(state))
        x = torch.relu(self.fc2(x))
        mean = self.mean(x)
        log_std = self.log_std(x).clamp(-20, 2)  # 将对数标准差限制在合理范围内
        std = torch.exp(log_std)
        return mean, std

    def sample(self, state):
        mean, std = self.forward(state)
        normal = torch.distributions.Normal(mean, std)
        x_t = normal.rsample()  # 使用重参数化技巧采样
        y_t = torch.tanh(x_t)   # 使用 Tanh 将动作限制在 [-1, 1]
        action = y_t * self.max_action
        log_prob = normal.log_prob(x_t)
        log_prob -= torch.log(1 - y_t.pow(2) + 1e-6)  # Tanh 的修正项
        log_prob = log_prob.sum(dim=-1, keepdim=True)
        return action, log_prob

3. Q 网络

Q 网络用于评估状态 - 动作对的价值。SAC 通常使用两个独立的 Q 网络来减少过估计偏差。

class QNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(QNetwork, self).__init__()
        self.fc1 = nn.Linear(state_dim + action_dim, 256)
        self.fc2 = nn.Linear(256, 256)
        self.fc3 = nn.Linear(256, 1)

    def forward(self, state, action):
        x = torch.cat([state, action], dim=-1)  # 将状态和动作连接起来作为输入
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

4. 经验回放缓冲区

存储过往经验以便离线采样，提升训练稳定性。

class ReplayBuffer:
    def __init__(self, capacity):
        self.buffer = deque(maxlen=capacity)

    def push(self, state, action, reward, next_state, done):
        self.buffer.append((state, action, reward, next_state, done))

    def sample(self, batch_size):
        batch = random.sample(self.buffer, batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)
        return (
            np.array(states),
            np.array(actions),
            np.array(rewards),
            np.array(next_states),
            np.array(dones)
        )

    def __len__(self):
        return len(self.buffer)

5. SAC 智能体

整合上述组件，管理训练逻辑。

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)

6. 主函数循环

env = gym.make("Pendulum-v1")
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.shape[0]
max_action = float(env.action_space.high[0])

agent = SACAgent(state_dim, action_dim, max_action)
num_episodes = 500

for episode in range(num_episodes):
    state = env.reset()
    episode_reward = 0
    done = False
    while not done:
        action = agent.select_action(state)
        next_state, reward, done, _ = env.step(action)
        agent.update_replay_buffer(state, action, reward, next_state, done)
        agent.train()
        state = next_state
        episode_reward += reward
    print(f"Episode {episode}, Reward: {episode_reward}")

注意事项

本代码旨在展示 SAC 算法的核心逻辑与结构。实际应用中，建议根据具体任务调整超参数（如 ALPHA, LR），并进行适当的调优。此外，确保运行环境兼容（Python 3.8+, PyTorch 1.7+）。

SAC 优势

1. 样本效率高：使用离线经验池，充分利用历史数据。
2. 探索能力强：通过最大化熵，鼓励更广泛的探索。
3. 稳定性好：结合双 Q 网络和目标网络，降低训练波动。
4. 适用于连续动作空间：支持复杂控制任务，如机器人控制。

参考文献：

• Haarnoja, Tuomas, et al. "Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor." arXiv preprint arXiv:1801.01290 (2018).
• Haarnoja, Tuomas, et al. "Soft actor-critic algorithms and applications." arXiv preprint arXiv:1812.05905 (2018).