AC网络深度强化学习：从算法原理到工程实践

1次阅读

共计 2990 个字符，预计需要花费 8 分钟才能阅读完成。

深度强化学习（Deep Reinforcement Learning, DRL）近年来在游戏、机器人控制、推荐系统等领域取得了显著进展。其中，Actor-Critic（AC）网络作为一种结合了策略梯度（Policy Gradient）和价值函数（Value Function）的方法，在序列决策问题中表现出独特的优势。

AC 网络的独特价值 ：AC 网络通过 Actor（策略网络）和 Critic（价值网络）的协同工作，既避免了纯策略梯度方法的高方差问题，又克服了纯值函数方法的策略退化问题。这种平衡使得 AC 网络在复杂环境中表现出更强的稳定性和收敛性。
应用场景 ：AC 网络特别适合需要连续动作空间的任务，如机器人控制、自动驾驶等。此外，AC 网络在部分可观测环境（POMDP）中也表现良好，因为 Critic 网络可以通过学习值函数来弥补环境信息的不完整性。

与 Q -Learning 对比 ：
Q-Learning 基于值函数，适用于离散动作空间，但在连续动作空间中表现不佳。
AC 网络通过 Actor 网络直接输出动作分布，适用于连续动作空间。
与 Policy Gradient 对比 ：
Policy Gradient 方法直接优化策略，但方差较大，训练不稳定。
AC 网络引入 Critic 网络来估计值函数，减少了方差，提高了训练稳定性。
与 PPO 对比 ：
PPO（Proximal Policy Optimization）是 AC 的改进版本，通过剪辑策略更新来确保稳定性。
AC 网络实现简单，但在某些任务中可能需要更多调参工作。

以下是一个基于 PyTorch 的 AC 网络核心实现示例：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

class Actor(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(Actor, self).__init__()
        self.fc1 = nn.Linear(state_dim, 256)
        self.fc2 = nn.Linear(256, action_dim)

    def forward(self, state):
        x = F.relu(self.fc1(state))
        return torch.tanh(self.fc2(x))  # 输出动作范围 [-1, 1]

class Critic(nn.Module):
    def __init__(self, state_dim):
        super(Critic, self).__init__()
        self.fc1 = nn.Linear(state_dim, 256)
        self.fc2 = nn.Linear(256, 1)

    def forward(self, state):
        x = F.relu(self.fc1(state))
        return self.fc2(x)  # 输出状态值

# 初始化网络
state_dim = 10  # 状态维度
action_dim = 2  # 动作维度
actor = Actor(state_dim, action_dim)
critic = Critic(state_dim)

# 定义优化器
actor_optimizer = optim.Adam(actor.parameters(), lr=1e-4)
critic_optimizer = optim.Adam(critic.parameters(), lr=1e-3)

# 训练循环示例
for episode in range(1000):
    state = env.reset()  # 假设 env 是环境对象
    total_reward = 0

    while True:
        # 选择动作
        action = actor(torch.FloatTensor(state))
        next_state, reward, done, _ = env.step(action.detach().numpy())

        # 计算 Critic 损失
        value = critic(torch.FloatTensor(state))
        next_value = critic(torch.FloatTensor(next_state))
        td_target = reward + 0.99 * next_value * (1 - int(done))
        critic_loss = F.mse_loss(value, td_target.detach())

        # 计算 Actor 损失
        advantage = td_target - value
        actor_loss = -torch.mean(advantage.detach() * actor(torch.FloatTensor(state)))

        # 更新网络
        critic_optimizer.zero_grad()
        critic_loss.backward()
        critic_optimizer.step()

        actor_optimizer.zero_grad()
        actor_loss.backward()
        actor_optimizer.step()

        state = next_state
        total_reward += reward

        if done:
            break