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

策略网络更新

策略网络的目标是最大化奖励和熵，等价于最小化： $$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]$$

目标值函数更新

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

PyTorch 实现

下面是基于 PyTorch 的 Soft Actor-Critic 算法完整实现。为了便于理解，我将代码拆分为参数设置、网络定义、缓冲区和主循环几个部分。

1. 参数设置

"""《SAC, Soft Actor-Critic 算法》"""
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. 策略网络

策略网络负责生成随机的策略动作，这里使用了重参数化技巧（Reparameterization Trick）和 Tanh 分布来限制动作范围。

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)
        action = y_t * self.max_action
        log_prob = normal.log_prob(x_t)
        log_prob -= torch.log(1 - y_t.pow(2) + 1e-6)
        log_prob = log_prob.sum(dim=-1, keepdim=True)
        return action, log_prob

3. Q 网络

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)

        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}")

运行环境

Python 3.11.5, torch 2.1.0, torchvision 0.16.0, gym 0.26.2

注：由于博文主要介绍算法原理，实际效果可能受环境适配和调参影响。上述代码用于了解和学习算法足够，若应用于实际项目还需进一步优化。

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.