强化学习笔记之【SAC算法】

这可就有点麻烦了2024-10-11 21:12

强化学习笔记之【SAC算法】

前言：

本文为强化学习笔记第四篇，第一篇讲的是Q-learning和DQN，第二篇DDPG，第三篇TD3

TD3比DDPG少了一个target_actor网络，其它地方有点小改动

CSDN主页：https://blog.csdn.net/rvdgdsva

博客园主页：https://www.cnblogs.com/hassle

目录


STAND ALONE COMPLEX = S . A . C

首先，我们需要明确，Q-learning 算法发展成DQN 算法，DQN 算法发展成为DDPG 算法，而DDPG 算法发展成TD3 算法，TD3 算法发展成SAC算法

Soft Actor-Critic (SAC) 是一种基于策略梯度 的深度强化学习算法，它具有最大化奖励与最大化熵（探索性）的双重目标 。SAC 通过引入熵正则项，使策略在决策时具有更大的随机性，从而提高探索能力。

一、SAC算法

OK，先用伪代码让你们感受一下SAC算法

python 复制代码 
# 定义 SAC 超参数
alpha = 0.2               # 熵正则项系数
gamma = 0.99              # 折扣因子
tau = 0.005               # 目标网络软更新参数
lr = 3e-4                 # 学习率

# 初始化 Actor、Critic、Target Critic 网络和优化器
actor = ActorNetwork()                      # 策略网络 π(s)
critic1 = CriticNetwork()                   # 第一个 Q 网络 Q1(s, a)
critic2 = CriticNetwork()                   # 第二个 Q 网络 Q2(s, a)
target_critic1 = CriticNetwork()            # 目标 Q 网络 1
target_critic2 = CriticNetwork()            # 目标 Q 网络 2

# 将目标 Q 网络的参数设置为与 Critic 网络相同
target_critic1.load_state_dict(critic1.state_dict())
target_critic2.load_state_dict(critic2.state_dict())

# 初始化优化器
actor_optimizer = torch.optim.Adam(actor.parameters(), lr=lr)
critic1_optimizer = torch.optim.Adam(critic1.parameters(), lr=lr)
critic2_optimizer = torch.optim.Adam(critic2.parameters(), lr=lr)

# 经验回放池（Replay Buffer）
replay_buffer = ReplayBuffer()

# SAC 训练循环
for each iteration:
    # Step 1: 从 Replay Buffer 中采样一个批次 (state, action, reward, next_state)
    batch = replay_buffer.sample()
    state, action, reward, next_state, done = batch

    # Step 2: 计算目标 Q 值 (y)
    with torch.no_grad():
        # 从 Actor 网络中获取 next_state 的下一个动作
        next_action, next_log_prob = actor.sample(next_state)
        
        # 目标 Q 值的计算：使用目标 Q 网络的最小值 + 熵项
        target_q1_value = target_critic1(next_state, next_action)
        target_q2_value = target_critic2(next_state, next_action)
        min_target_q_value = torch.min(target_q1_value, target_q2_value)

        # 目标 Q 值 y = r + γ * (最小目标 Q 值 - α * next_log_prob)
        target_q_value = reward + gamma * (1 - done) * (min_target_q_value - alpha * next_log_prob)

    # Step 3: 更新 Critic 网络
    # Critic 1 损失
    current_q1_value = critic1(state, action)
    critic1_loss = F.mse_loss(current_q1_value, target_q_value)

    # Critic 2 损失
    current_q2_value = critic2(state, action)
    critic2_loss = F.mse_loss(current_q2_value, target_q_value)

    # 反向传播并更新 Critic 网络参数
    critic1_optimizer.zero_grad()
    critic1_loss.backward()
    critic1_optimizer.step()

    critic2_optimizer.zero_grad()
    critic2_loss.backward()
    critic2_optimizer.step()

    # Step 4: 更新 Actor 网络
    # 通过 Actor 网络生成新的动作及其 log 概率
    new_action, log_prob = actor.sample(state)

    # 计算 Actor 的目标损失：L = α * log_prob - Q1(s, π(s))
    q1_value = critic1(state, new_action)
    actor_loss = (alpha * log_prob - q1_value).mean()

    # 反向传播并更新 Actor 网络参数
    actor_optimizer.zero_grad()
    actor_loss.backward()
    actor_optimizer.step()

    # Step 5: 软更新目标 Q 网络参数
    with torch.no_grad():
        for param, target_param in zip(critic1.parameters(), target_critic1.parameters()):
            target_param.data.copy_(tau * param.data + (1 - tau) * target_param.data)

        for param, target_param in zip(critic2.parameters(), target_critic2.parameters()):
            target_param.data.copy_(tau * param.data + (1 - tau) * target_param.data)

二、SAC算法Latex解释

1、初始化 Actor、Critic1、Critic2、TargetCritic1 、TargetCritic2 网络

2、Buffer中采样 (state, action, reward, next_state)

3、Actor 输入 next_state 对应输出 next_action 和 next_log_prob

4、Actor 输入 state 对应输出 new_action 和 log_prob

5、Critic1 和 Critic2 分别输入next_state 和 next_action 取其中较小输出经熵正则计算得 target_q_value

6、使用 MSE_loss(Critic1(state, action), target_q_value) 更新 Critic1

7、使用 MSE_loss(Critic2(state, action), target_q_value) 更新 Critic2

8、使用 (alpha * log_prob - critic1(state, new_action)).mean() 更新 Actor

三、SAC五大网络和模块

在 SAC 算法 中，Actor、Critic1、Critic2、Target Critic1 和 Target Critic2 网络是核心模块，它们分别用于输出动作、评估状态-动作对的价值，并通过目标网络进行稳定的更新。

3.1 Actor 网络

Actor 网络用于在给定状态下输出一个高斯分布的均值和标准差（即策略）。它是通过神经网络近似的随机策略。用于选择动作。

python 复制代码 
import torch
import torch.nn as nn

class ActorNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(ActorNetwork, self).__init__()
        self.fc1 = nn.Linear(state_dim, 256)
        self.fc2 = nn.Linear(256, 256)
        self.mean_layer = nn.Linear(256, action_dim)  # 输出动作的均值
        self.log_std_layer = nn.Linear(256, action_dim)  # 输出动作的log标准差

    def forward(self, state):
        x = torch.relu(self.fc1(state))
        x = torch.relu(self.fc2(x))
        mean = self.mean_layer(x)  # 输出动作均值
        log_std = self.log_std_layer(x)  # 输出 log 标准差
        log_std = torch.clamp(log_std, min=-20, max=2)  # 限制标准差范围
        return mean, log_std

    def sample(self, state):
        mean, log_std = self.forward(state)
        std = torch.exp(log_std)  # 将 log 标准差转为标准差
        normal = torch.distributions.Normal(mean, std)
        action = normal.rsample()  # 通过重参数化技巧进行采样
        log_prob = normal.log_prob(action).sum(-1)  # 计算 log 概率
        return action, log_prob

3.2 Critic1 和 Critic2 网络

Critic 网络用于计算状态-动作对的 Q 值，SAC 使用两个 Critic 网络（Critic1 和 Critic2）来缓解 Q 值的过估计问题。

python 复制代码 
class CriticNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(CriticNetwork, self).__init__()
        self.fc1 = nn.Linear(state_dim + action_dim, 256)
        self.fc2 = nn.Linear(256, 256)
        self.q_value_layer = nn.Linear(256, 1)  # 输出 Q 值

    def forward(self, state, action):
        x = torch.cat([state, action], dim=-1)  # 将 state 和 action 作为输入
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        q_value = self.q_value_layer(x)  # 输出 Q 值
        return q_value

3.3 Target Critic1 和 Target Critic2 网络

Target Critic 网络的结构与 Critic 网络相同，用于稳定 Q 值更新。它们通过软更新（即在每次训练后慢慢接近 Critic 网络的参数）来保持训练的稳定性。

python 复制代码 
class TargetCriticNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(TargetCriticNetwork, self).__init__()
        self.fc1 = nn.Linear(state_dim + action_dim, 256)
        self.fc2 = nn.Linear(256, 256)
        self.q_value_layer = nn.Linear(256, 1)  # 输出 Q 值

    def forward(self, state, action):
        x = torch.cat([state, action], dim=-1)  # 将 state 和 action 作为输入
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        q_value = self.q_value_layer(x)  # 输出 Q 值
        return q_value

3.4 软更新模块

在 SAC 中，目标网络会通过软更新逐渐逼近 Critic 网络的参数。每次更新后，目标网络参数会按照 ττ 的比例向 Critic 网络的参数靠拢。

python 复制代码 
def soft_update(critic, target_critic, tau=0.005):
    for param, target_param in zip(critic.parameters(), target_critic.parameters()):
        target_param.data.copy_(tau * param.data + (1 - tau) * target_param.data)

3.5 总结

  1. 初始化网络和参数：
    • Actor 网络：用于选择动作。
    • Critic 1 和 Critic 2 网络：用于估计 Q 值。
    • Target Critic 1 和 Target Critic 2：与 Critic 网络架构相同，用于生成更稳定的目标 Q 值。
  2. 目标 Q 值计算：
    • 使用目标网络计算下一状态下的 Q 值。
    • 取两个 Q 网络输出的最小值，防止 Q 值的过估计。
    • 引入熵正则项，计算公式：$$y=r+\gamma\cdot\min(Q_1,Q_2)-\alpha\cdot\log\pi(a|s)$$
  3. 更新 Critic 网络：
    • 最小化目标 Q 值与当前 Q 值的均方误差 (MSE)。
  4. 更新 Actor 网络：
    • 最大化目标损失：$$L=\alpha\cdot\log\pi(a|s)-Q_1(s,\pi(s))$$，即在保证探索的情况下选择高价值动作。
  5. 软更新目标网络：
    • 软更新目标 Q 网络参数，使得目标网络参数缓慢向当前网络靠近，避免振荡。
相关推荐
这可就有点麻烦了1 个月前
强化学习算法笔记之【DDPG算法】
ubuntu强化学习
这可就有点麻烦了1 个月前
强化学习笔记之【ACE:Off-PolicyActor-CriticwithCausality-AwareEntropyRegularization】
ubuntu强化学习
这可就有点麻烦了1 个月前
Python：条件分支 if 语句全讲解
ubuntu强化学习
这可就有点麻烦了2 个月前
ROS基础入门——实操教程
ubuntu强化学习
这可就有点麻烦了2 个月前
crypt.h：No such file or directory 报错处理
ubuntu强化学习
这可就有点麻烦了2 个月前
命令行gcc -v和g++ -v输出版本不一致
ubuntu强化学习
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06RAG 实践- Ollama+RagFlow 部署本地知识库07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10怎样让音频速度变慢？请跟随以下方法进行操作