【强化学习】13 —— Actor-Critic 算法

REINFORCE 存在的问题

• 基于片段式数据的任务
  • 通常情况下，任务需要有终止状态，REINFORCE才能直接计算累计折扣奖励
• 低数据利用效率
  • 实际中，REINFORCE需要大量的训练数据
• 高训练方差（最重要的缺陷）
  • 从单个或多个片段中采样到的值函数具有很高的方差

Actor-Critic

在 REINFORCE 算法中，目标函数的梯度中有一项轨迹回报，用于指导策略的更新。REINFOCE 算法用蒙特卡洛方法来估计$Q(s,a)$，能不能考虑拟合一个值函数来指导策略进行学习呢？这正是 Actor-Critic 算法所做的。

评论家Critic$Q_{\Phi }(s,a)$:

• 学会准确估计当前演员策略（actor policy）的动作价值。通过 Actor 与环境交互收集的数据学习一个价值函数，这个价值函数会用于判断在当前状态什么动作是好的，什么动作不是好的，进而帮助 Actor 进行策略更新。$$Q_{\Phi }(s,a)\simeq r(s,a)+\gamma {\mathbb{E}}_{s^{\prime }\sim p(s^{\prime }|s,a),a^{\prime }\sim {\pi }_{\theta }(a^{\prime }|s^{\prime })}[Q_{\Phi }(s^{\prime },a^{\prime })]$$

演员Actor${\pi }_{\theta }(s,a)$:

• 要做的是与环境交互，并在 Critic 价值函数的指导下用策略梯度学习一个更好的策略。$$\begin{array}{rl}J(\theta )& ={\mathbb{E}}_{s\sim p,{\pi }_{\theta }}[{\pi }_{\theta }(a|s)Q_{\Phi }(s,a)]\\ & \\ \frac{\partial f(\theta )}{\partial \theta }& ={\mathbb{E}}_{{\pi }_{\theta }}\left[\frac{\partial \log {\pi }_{\theta }(a|s)}{\partial \theta }{Q}_{\Phi }(s,a)\right]\end{array}$$

A2C： Advantageous Actor-Critic

思想：通过减去一个基线函数来标准化评论家的打分

• 更多信息指导：降低较差动作概率，提高较优动作概率
• 进一步降低方差

优势函数（Advantage Function）$$A^{\pi }(s,a)=Q^{\pi }(s,a)-V^{\pi }(s)$$

若只采用动作值的方式，虽然也会选择A2，但是方差相对会更大，同时所有的动作都是出于上升的状态，只是上升程度的问题。而采用优势函数的方式，部分动作的优势函数值是负的，可以直接降低相应动作的概率，同时方差更小。

状态-动作值和状态值函数$$\begin{array}{rl}{Q}^{\pi }(s,a)& =r(s,a)+\gamma {\mathbb{E}}_{s^{\prime }\sim p(s^{\prime }|s,a),a^{\prime }\sim {\pi }_{\theta }(a^{\prime }|s^{\prime })}\left[Q_{\Phi }(s^{\prime },a^{\prime })\right]\\ & =r(s,a)+\gamma {\mathbb{E}}_{s^{\prime }\sim p(s^{\prime }|s,a)}[V^{\pi }(s^{\prime })]\end{array}$$

因此我们只需要拟合状态值函数来拟合优势函数$$\begin{array}{rl}{A}^{\pi }(s,a)& =Q^{\pi }(s,a)-V^{\pi }(s)\\ & =r(s,a)+\gamma {\mathbb{E}}_{s^{\prime }\sim p(s^{\prime }|s,a)}[V^{\pi }(s^{\prime })-V^{\pi }(s)]\\ & \simeq r(s,a)+\gamma (V^{\pi }(s^{\prime })-V^{\pi }(s))\end{array}$$

---

在策略梯度中，可以把梯度写成下面这个更加一般的形式：$$g=\mathbb{E}\left[\sum _{t=0}^T{\psi }_t{\nabla }_{\theta }\log {\pi }_{\theta }(a_t|s_t)\right]$$其中，${\psi }_t$可以有很多种形式：$$\begin{array}{rl}& 1.\sum _{t^{\prime }=0}^T{\gamma }^{t^{\prime }}{r}_{t^{\prime }}:\text{轨迹的总回报;}\\ & 2.\sum _{t^{\prime }=t}^T{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}:\text{动作}{a}_t\text{之后的回报;}\\ & \begin{array}{r}3.\sum _{t^{\prime }=t}^T{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}-b(s_t):\text{基准线版本的改进};\end{array}\\ & 4.Q^{{\pi }_{\theta }}(s_t,a_t):\text{动作价值函数;}\\ & 5.A^{{\pi }_{\theta }}(s_t,a_t):\text{优势函数;}\\ & 6.r_t+\gamma V^{{\pi }_{\theta }}(s_{t+1})-V^{{\pi }_{\theta }}(s_t):\text{时序差分残差。}\end{array}$$

REINFORCE 通过蒙特卡洛采样的方法对策略梯度的估计是无偏的，但是方差非常大。我们可以用形式(3)引入基线函数$b(s_t)$（baseline function）来减小方差。此外，我们也可以采用 Actor-Critic 算法估计一个动作价值函数$Q$，代替蒙特卡洛采样得到的回报，这便是形式(4)。这个时候，我们可以把状态价值函数$V$作为基线，从$Q$函数减去这个$V$函数则得到了$A$函数，我们称之为优势函数（advantage function），这便是形式(5)。更进一步，我们可以利用等式$Q=r+\gamma V$得到形式(6)。

Actor 的更新采用策略梯度的原则，那 Critic 如何更新呢？我们将 Critic 价值网络表示为$V_{\omega }$，参数为$\omega$。于是，我们可以采取时序差分残差的学习方式，对于单个数据定义如下价值函数的损失函数：$$\mathcal{L}(\omega )=\frac{1}{2}(r+\gamma V_{\omega }(s_{t+1})-V_{\omega }(s_t){)}^2$$

与 DQN 中一样，我们采取类似于目标网络的方法，将上式中$r+\gamma V_{\omega }(s_{t+1})$作为时序差分目标，不会产生梯度来更新价值函数。因此，价值函数的梯度为：
$${\nabla }_{\omega }\mathcal{L}(\omega )=-(r+\gamma V_{\omega }(s_{t+1})-V_{\omega }(s_t)){\nabla }_{\omega }{V}_{\omega }(s_t)$$

然后使用梯度下降方法来更新 Critic 价值网络参数即可。

算法伪代码：

代码实践

import gymnasium as gym
import numpy as np
from tqdm import tqdm
import torch
import torch.nn.functional as F
import util

class PolicyNet(torch.nn.Module):
    def __init__(self, state_dim, hidden_dim, action_dim):
        super(PolicyNet, self).__init__()
        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)
        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        return F.softmax(self.fc2(x), dim=1)

# 输入是某个状态，输出则是状态的价值。
class ValueNet(torch.nn.Module):
    def __init__(self, state_dim, hidden_dim):
        super(ValueNet, self).__init__()
        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)
        self.fc2 = torch.nn.Linear(hidden_dim, 1)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        return self.fc2(x)

class ActorCritic:
    def __init__(self, state_dim, hidden_dim, action_dim, actor_lr, critic_lr, gamma,
                device, numOfEpisodes, env):
        self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device)
        self.critic = ValueNet(state_dim, hidden_dim).to(device)
        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)
        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)
        self.gamma = gamma
        self.device = device
        self.env = env
        self.numOfEpisodes = numOfEpisodes

    # 根据动作概率分布随机采样
    def takeAction(self, state):
        state = torch.tensor(np.array([state]), dtype=torch.float).to(self.device)
        action_probs = self.actor(state)
        action_dist = torch.distributions.Categorical(action_probs)
        action = action_dist.sample()
        return action.item()

    def update(self, transition_dict):
        states = torch.tensor(np.array(transition_dict['states']), dtype=torch.float).to(self.device)
        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)
        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)
        next_states = torch.tensor(np.array(transition_dict['next_states']), dtype=torch.float).to(self.device)
        terminateds = torch.tensor(transition_dict['terminateds'], dtype=torch.float).view(-1, 1).to(self.device)
        truncateds = torch.tensor(transition_dict['truncateds'], dtype=torch.float).view(-1, 1).to(self.device)
        # 时序差分目标
        td_target = rewards + self.gamma * self.critic(next_states) * (1 - terminateds + truncateds)
        # 时序差分误差
        td_delta = td_target - self.critic(states)
        log_probs = torch.log(self.actor(states).gather(1, actions))
        # 均方误差损失函数
        actor_loss = torch.mean(-log_probs * td_delta.detach())
        critic_loss = torch.mean(F.mse_loss(self.critic(states), td_target.detach()))
        self.actor_optimizer.zero_grad()
        self.critic_optimizer.zero_grad()
        actor_loss.backward()
        critic_loss.backward()
        self.actor_optimizer.step()
        self.critic_optimizer.step()

    def ACTrain(self):
        returnList = []
        for i in range(10):
            with tqdm(total=int(self.numOfEpisodes / 10), desc='Iteration %d' % i) as pbar:
                for episode in range(int(self.numOfEpisodes / 10)):
                    # initialize state
                    state, info = self.env.reset()
                    terminated = False
                    truncated = False
                    episodeReward = 0
                    transition_dict = {
                        'states': [],
                        'actions': [],
                        'next_states': [],
                        'rewards': [],
                        'terminateds': [],
                        'truncateds': []
                    }
                    # Loop for each step of episode:
                    while 1:
                        action = self.takeAction(state)
                        next_state, reward, terminated, truncated, info = self.env.step(action)
                        transition_dict['states'].append(state)
                        transition_dict['actions'].append(action)
                        transition_dict['next_states'].append(next_state)
                        transition_dict['rewards'].append(reward)
                        transition_dict['terminateds'].append(terminated)
                        transition_dict['truncateds'].append(truncated)
                        state = next_state
                        episodeReward += reward
                        if terminated or truncated:
                            break
                    self.update(transition_dict)
                    returnList.append(episodeReward)
                    if (episode + 1) % 10 == 0:  # 每10条序列打印一下这10条序列的平均回报
                        pbar.set_postfix({
                            'episode':
                                '%d' % (self.numOfEpisodes / 10 * i + episode + 1),
                            'return':
                                '%.3f' % np.mean(returnList[-10:])
                        })
                    pbar.update(1)
        return returnList

结果

可以发现，Actor-Critic 算法很快便能收敛到最优策略，并且训练过程非常稳定，抖动情况相比 REINFORCE 算法有了明显的改进，这说明价值函数的引入减小了方差。

参考

[1] 伯禹AI
[2] https://www.davidsilver.uk/teaching/
[3] 动手学强化学习
[4] Reinforcement Learning