# Actor-Critic算法

# 基本概念

Actor-Critic是一种结合了策略梯度和值函数近似的强化学习算法。它包含两个网络：Actor网络负责学习策略，Critic网络负责评估状态值，两者协同工作以提高学习效率和稳定性。

# 数学原理

# 1. 双网络架构

Actor-Critic包含两个网络：

Actor：策略网络 $\pi_\theta(a|s)$
Critic：值函数网络 $V_\phi(s)$

其中：

$\theta$ 是Actor网络的参数
$\phi$ 是Critic网络的参数

# 2. 优势函数

使用TD误差作为优势函数估计：

$A(s_t,a_t) \approx r_t + \gamma V_\phi(s_{t+1}) - V_\phi(s_t)$

其中：

$A(s_t,a_t)$ 是优势函数
$r_t$ 是即时奖励
$\gamma$ 是折扣因子

# 3. 策略更新

Actor网络的更新公式：

$\nabla_\theta J(\theta) = E_{\pi_\theta}[\nabla_\theta \log \pi_\theta(a_t|s_t)A(s_t,a_t)]$

Critic网络的更新公式：

$L(\phi) = E[(r_t + \gamma V_\phi(s_{t+1}) - V_\phi(s_t))^2]$

# 算法步骤

初始化
- 创建Actor和Critic网络
- 初始化网络参数
- 设定超参数
交互循环
- 对每个时间步：
  1. Actor选择动作
  2. 执行动作获得奖励和下一状态
  3. Critic评估状态值
  4. 计算TD误差
  5. 更新Actor和Critic网络

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

class Actor(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(Actor, self).__init__()
        self.network = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, action_dim),
            nn.Softmax(dim=-1)
        )
    
    def forward(self, x):
        return self.network(x)

class Critic(nn.Module):
    def __init__(self, state_dim):
        super(Critic, self).__init__()
        self.network = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 1)
        )
    
    def forward(self, x):
        return self.network(x)

class ActorCritic:
    def __init__(self, state_dim, action_dim, lr_actor=0.001, lr_critic=0.005, gamma=0.99):
        self.actor = Actor(state_dim, action_dim)
        self.critic = Critic(state_dim)
        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=lr_actor)
        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=lr_critic)
        self.gamma = gamma
    
    def select_action(self, state):
        state = torch.FloatTensor(state)
        probs = self.actor(state)
        action = torch.multinomial(probs, 1)
        return action.item(), probs
    
    def update(self, state, action, reward, next_state):
        # 转换为张量
        state = torch.FloatTensor(state)
        next_state = torch.FloatTensor(next_state)
        
        # 计算TD误差
        value = self.critic(state)
        next_value = self.critic(next_state)
        td_error = reward + self.gamma * next_value.detach() - value
        
        # 更新Critic
        critic_loss = td_error.pow(2)
        self.critic_optimizer.zero_grad()
        critic_loss.backward()
        self.critic_optimizer.step()
        
        # 更新Actor
        probs = self.actor(state)
        log_prob = torch.log(probs[action])
        actor_loss = -log_prob * td_error.detach()
        self.actor_optimizer.zero_grad()
        actor_loss.backward()
        self.actor_optimizer.step()

# 优势特点

# 1. 结构优势

策略与值函数分离
互补学习机制
灵活的网络设计

# 2. 学习效率

降低方差
加速收敛
样本利用率高

# 3. 适应性

连续动作空间
复杂环境
实时控制

# 应用场景

机器人控制
- 运动规划
- 任务执行
- 技能学习
自动驾驶
- 路径规划
- 速度控制
- 决策系统
资源管理
- 能源调度
- 网络优化
- 任务分配
游戏AI
- 策略制定
- 实时对抗
- 多智能体协作

# 优缺点

# 优点

结合两种方法优势
方差较小
适应性强
收敛性好

# 缺点

结构复杂
参数敏感
训练不稳定
计算开销大

# 实践建议

# 1. 网络设计

合适的网络规模
共享特征提取
归一化技术

# 2. 参数调优

学习率平衡
更新频率
折扣因子选择

# 3. 训练策略

经验回放
多步预测
并行训练

# 4. 稳定性优化

梯度裁剪
熵正则化
目标网络

# 进阶优化

A3C（Asynchronous Advantage Actor-Critic）
- 异步并行训练
- 多个工作进程
- 更好的探索
SAC（Soft Actor-Critic）
- 最大熵框架
- 自动温度调节
- 更好的探索-利用平衡
PPO（Proximal Policy Optimization）
- 信任域约束
- 稳定更新
- 单调改进
TD3（Twin Delayed DDPG）
- 双Q网络
- 延迟策略更新
- 目标策略平滑

← 策略梯度算法大模型技术 →