强化学习算法A2C（Advantage Actor-Critic）和A3C(Asynchronous Advantage Actor-Critic)算法详解以及A2C的Pytorch实现

一、策略梯度算法回顾

策略梯度（Policy Gradient）算法目标函数的梯度更新公式为：
$$▽{\bar{R}}_{\theta }=\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}(\sum _{t^{\prime }=t}^{T_n}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}^n-b)▽log{p}_{\theta }(a_t^n|s_t^n)\text{\hspace{1em}(1)}$$
公式（1）各个参数详解：$N$表示采样的样本个数，因为我们要数值逼近奖励的期望；$\gamma$ 表示折扣因子，指actor对未来奖励的重视程度，越接近1越重视未来各个时间步的奖励，越接近0越不重视；$r_{t^{\prime }}^n$ 表示第$n$条采样样本第 $t^{\prime }$ 时刻的奖励；$b$ 表示baseline，加了baseline之后，奖励就会有正有负，负奖励对应的动作的概率就会在优化之后下降，而正的奖励对应的动作的概率就会增加，也就是baseline起到了不能将所有采样得到的动作对应的概率都增大，这是因为采样得到的动作未必是好的动作。$p_{\theta }(a_t^n|s_t^n)$ 表示给定状态$s_t^n$时采取动作$a_t^n$ 的概率。

现在我们取
$$G_t^n=\sum _{t^{\prime }=t}^{T_n}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}^n\text{\hspace{1em}(2)}$$
我们知道无论是环境还是actor本身都具有随机性（比如我们生活的现实世界里面，环境的变化是不可测的，也就是随机性很大），因此如果不采样足够多的数据，我们很难较为准确的逼近奖励的期望，但是数据太多，就会给计算资源带来负担。因次$G_t^n$是一个非常不稳定的随机变量，也就方差很大，这样训练的模型的效果也会很差。只有足够很多的episode样本我们才可以更加准确的来数值逼近奖励的期望。如果还是不明白，可以参考我的策略梯度详解这篇博客。

上面我们引入了$G_t^n$十分不稳定这个问题，那么我们该如何解决这个问题呢？
问题：我们是否可以使用一个神经网络来估计这个$G_t^n$这个值？
答：可以，我们使用强化学习的值函数方法。

二、QLearning算法回顾

下面先来介绍两个值函数以及他们之间的关系。

1. 状态价值函数$V^{\pi }(s)$
   该函数的意义是：actor和环境互动，当访问到状态 $s$ 时，直到互动结束，所积累的奖励的期望。
   举一个sutton强化学习书上的例子。
   例子1：
   假设我们采样得到8个eposides,分别如下：
   1、$s_a,r=0,s_b,r=0,End$
   2、$s_b,r=1,End$
   3、$s_b,r=1,End$
   4、$s_b,r=1,End$
   5、$s_b,r=1,End$
   6、$s_b,r=1,End$
   7、$s_b,r=1,End$
   8、$s_b,r=0,End$
   这里给出了8个采样得到的eposide，并且忽略所采取的动作，这里是采样得到8个eposide来逼近$V^{\pi }(s)$,选择采样来逼近$V^{\pi }(s)$，是因为actor所处的环境和actor本身都具有随机性，由上面的公式（1）可以看到，如果所有的eposides有无穷多个，那么计算机根本无法实现计算$V^{\pi }(s)$
   根据上面的8个eposides，可以计算得到$V^{\pi }(s_b)$：
   $V^{\pi }(s_b)=\frac{1+1+1+1+1+1}{8}=\frac{3}{4}$
   因为是要遇到状态 $s_b$ 才开始计算，第一条样本和最后一条的样本在遇到状态$s_b$时，得到的奖励是0，因此分子上面只有6个1，而分母是8.，这里的例子只是使用8条采样的样本来数值逼近的，如果条件允许，还可以采样更多的样本来更加精确的数值逼近$V^{\pi }(s_b)$.
2. 状态动作价值函数$Q^{\pi }(s,a)$
   这个函数的意义就是actor在和环境互动过程中遇到状态 $s$,确定采取动作$a$之后直到互动结束所累积的奖励的期望，这个函数值和上面的计算类似，下面修改一下上面那个例子，来举例说明如何计算
   例子2：
   假设我们采样得到8个eposides,分别如下：
   1、$s_a,a_1,r=0,s_b,a_2,r=0,End$
   2、$s_b,a_2,r=1,End$
   3、$s_b,a_2,r=1,End$
   4、$s_b,a_2,r=1,End$
   5、$s_b,a_2,r=1,End$
   6、$s_b,a_2,r=1,End$
   7、$s_b,a_2,r=1,End$
   8、$s_b,a_2,r=0,End$
   我们现在来计算$Q^{\pi }(s_b,a_2)$,因为第一条样本和第二条样本在遇到状态$s_b$之后采取动作$a_2$之后得到的奖励是0，因此有：
   $Q^{\pi }(s_b,a_2)=\frac{1+1+1+1+1+1}{8}=\frac{3}{4}$
   因为我只是简单的做了一个修改，计算的结果和上面的那个是一样的，当然这八条样本里面在观测到状态 $s_b$ 之后都采取了动作 $a_2$,实际更为复杂多变，actor不一定在观测到状态$s_b$都采取动作 $a_2$的，还有别的动作可以采用。
3. 两个价值函数之间的关系
   假设actor在观测到状态 $s$之后采取的动作是 $a$ ,从环境里面得到的奖励是 $r$，因为做出动作 $a$ 之后，导致环境发生变化，或者环境自身发生变化，状态转移到 $s^{\prime }$ ,那么就有$$Q^{\pi }(s,a)=E[r+V^{\pi }(s^{\prime })]\text{\hspace{1em}(3)}$$
   公式解释：上面说了$Q^{\pi }(s,a)$是actor在观测到状态 $s$ 确定采取动作 $a$ 之后所获得的奖励的期望，而在状态 $s$ 之后的状态我们却是不得而知的，因此上面的等式是成立的。

三、A2C算法推导

3.1、算法流程

由公式（2）我们有
$$G_t^n=\sum _{t^{\prime }=t}^{T_n}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}^n\text{\hspace{1em}(2)}$$
我们根据上面的两个值函数可以得到$G_t^n$的期望是：
$$E[G_t^n]=Q^{\pi }(s_t^n,a_t^n)\text{\hspace{1em}(4)}$$
公式（3）的解释：为什么会成立？
由公式（2）可知，$G_t^n$是奖励的累加和，因为奖励是actor观测到某个状态之后由环境反馈过来的，因次这和状态动作价值函数是一样的。主要是因为actor得到的奖励都是在确定所采取的动作之后才得到的，而状态动作价值函数$Q^{\pi }(s,a)$也是在actor观测到状态$s$采取动作$a$之后所获得奖励的期望。因此公式（3）成立。

我们可以使用$V^{{\pi }_{\theta }}(s_t^n)$ 来估计公式（1）中的baseline $b$,也就是$$b=V^{{\pi }_{\theta }}(s_t^n)\text{\hspace{1em}(5)}$$
将公式（1），（4），（5）结合起来于是公式（1）就变为下面的公式（6）.
$$▽{\bar{R}}_{\theta }=\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}(Q^{\pi }(s_t^n,a_t^n)-V^{{\pi }_{\theta }}(s_t^n))▽log{p}_{\theta }(a_t^n|s_t^n)\text{\hspace{1em}(6)}$$

但是公式（6）会引入一个问题，我们使用神经网络来估计 $Q^{\pi }(s_t^n,a_t^n)$ 和 $V^{{\pi }_{\theta }}(s_t^n)$,但是我们可以看到这两个函数的自变量是不一样的，也就是如果使用公式(6)来作为梯度更新的公式的话，这会引入两个神经网络，那么模型的复杂度也就会增加，复杂的模型会导致一系列问题，比如过拟合，两个值函数估测不准的可能性也会增加等等。

问题：我们是否可以只引入一个神经网络来解决这个问题？
答案是显然的，因为公式(6)里面有两个值函数，上面的（3）描述了这两个值函数之间的关系，我们要使用公式（3）来简化问题。
由公式（3）我们有$$Q^{\pi }(s,a)=E[r+V^{\pi }(s^{\prime })]\text{\hspace{1em}(3)}$$
公式（3）只是提供了理论上的可能性，但是计算期望是一件很麻烦的事情，而且在无穷多的情况下，计算机在实操时根本无法计算，那么我们就需要简化问题，于是有$$Q^{\pi }(s,a)=r+V^{\pi }(s^{\prime })\text{\hspace{1em}(7)}$$
公式解释：状态 $s^{\prime }$ 是actor观测到状态 $s$ 时采取动作 $a$之后，状态转移到了状态 $s^{\prime }$,这种状态的转移可能是由于actor所采取的动作导致的，也可能是环境本身自己发生了变化而发生了转移。

将公式（7）带入到公式（6），于是就有：
$$▽{\bar{R}}_{\theta }=\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}{r}_t^n+V^{{\pi }_{\theta }}(s_{t+1}^n)-V^{{\pi }_{\theta }}(s_t^n)▽log{p}_{\theta }(a_t^n|s_t^n)\text{\hspace{1em}(8)}$$

公式（8）解释：虽然上面是说使用$V^{{\pi }_{\theta }}(s_t^n)$来作为baseline，但是我更加觉得这个是在使用$V^{{\pi }_{\theta }}(s_{t+1}^n)-V^{{\pi }_{\theta }}(s_t^n)$来逼近环境给出的奖励$r_t^n$.我对这个公式的直观理解有点描述不出来，感觉和TD方法的思想有点类，从公式可以看出，计算这个梯度只需要使用$(s_t^n,a_t^n,r_t^n,s_{t+1}^n)$这样的四元组，因为我们在采样数据的时候只需要存储这样的四元组就可以了，和TD方法的思想是一样的，我觉得是可以实现单步更新，无需等待一个回合结束再更新模型的。我们知道 $r_t^n$是一个random variable（r.v.）,因此公式里面还是引入了具有随机性的东西，只有在考虑的期望的时候才是正确的，但是 $r_t^n$的随机性相对于$G_t^n$的随机性是小了很多，因为$G_t^n$是各个时间步奖励的和，因为相对来说，随机性不大。

3.2、两个tips

1. 参数共享
   我们知道状态价值函数和策略网络的输入都是状态，但是输出是不一样的，因此我们可以将一些参数共享来减少模型的复杂性。
   
2. 探索
   我们为了避免actor陷入一个局部最优解，我们要增加actor的探索能力，也就是去尝试做出更多的动作，可以是策略网络输出的动作的分布更加均匀一点，这样可以每个动作都有被优化到的可能性。例如可以使用e-greedy算法增加模型的探索能力，有一定的随机性选择新的动作。

四、A3C

也就是多个actor和环境互动，并行更新网络

最上面的那个网络我们认为是global network，然后将他的参数复制，弄出多个网络，然后数据，计算梯度，更新global network。
算法流程：

1、复制网络参数生成多个网络，放在不同的GPU上
2、每个网络都和环境互动，生成数据
3、计算梯度
4、更新global network

五、A2C的Pytorch实现

import random
import numpy as np
import gym
import torch.nn as nn
import torch as t
from torch.nn import functional as F
import matplotlib.pyplot as plt
import os

# env.close()

eplison = 0.1
criterion = nn.CrossEntropyLoss()
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
gamma = 0.9
actor_lr = 0.001
critic_lr = 0.01
env = gym.make("CartPole-v0")
env.seed(1)     # reproducible, general Policy gradient has high variance
env = env.unwrapped
batch_size = 1
epochs = 500


class Share_layer(nn.Module):
    def __init__(self):
        
        super(Share_layer, self).__init__()
        self.linear1 = nn.Linear(4, 20)
        nn.init.normal_(self.linear1.weight, 0, 0.1)
        nn.init.constant_(self.linear1.bias, 0.1)
        
    def forward(self, out):
        
        out = self.linear1(out)
        out = F.relu(out)
        
        return out
        
        

class Actor(nn.Module):
    
    def __init__(self, sl):
        
        super(Actor, self).__init__()
        
        self.share_layer = sl
      
        self.linear2 = nn.Linear(20, 2)
        nn.init.normal_(self.linear2.weight, 0, 0.1)
        nn.init.constant_(self.linear2.bias, 0.1)
        
    def forward(self, x):
        
        out = t.from_numpy(x).float()

        out = self.share_layer(out) 
        out = self.linear2(out)
        prob = F.softmax(out, dim = 1) #这个输出主要是用来使用概率来挑选动作
        return prob, out
    
    
class Critic(nn.Module):
    
    def __init__(self, sl):
        
        super(Critic, self).__init__()
        
        self.share_layer = sl
        
        self.linear2 = nn.Linear(20, 1)
        nn.init.normal_(self.linear2.weight, 0, 0.1)
        nn.init.constant_(self.linear2.bias, 0.1)
        
    def forward(self, x):
        
        out = t.from_numpy(x).float()
        
        out = self.share_layer(out)
        
        out = self.linear2(out)
       
        return out
  
#下面该函数用来选择动作
def choose_action(prob):
    # print(prob)
    action = np.random.choice(a = 2, p = prob[0].detach().numpy())    
    return action
    
    # action = np.random.choice(a = 6, p = prob[0].detach().numpy())
    # v = random.uniform(0, 1)
    # p, index = t.topk(prob, 1, dim = 1)
        
    # #下面开始eplison-greedy 算法
    # if v > eplison:       
    #     #这里是求最大的状态价值函数对应的动作
    #     action = index[0][0].item()        
    # else: 
    #     #下面是随机产生动作
    #     action = random.randint(0, 1)  

    # return action

#下面的函数主要用来计算Actor部分训练的损失函数
def Actor_learn(optim, critic, s, s_, a, r, logits):
    
    '''
    根据当前的状态，奖励以及下一个时间步的章台完成损失函数的计算
    Parameters
    ----------
    critic : Critic（）实例
        用来估计当前时间的奖励的期望
    s : float array
        当前时间步的状态.
    a : int scalar
        当前时间步根据当前状态s所采取的动作
    r : float scalar
        当前时间步的奖励.
    s_ : float array
        下一个时间步的状态.
    logits : actor网络最后一层的输出
        用来计算交叉熵损失

    Returns
    -------
    Actor 的损失.

    '''
    V_s = critic(s)
    V_s_ = critic(s_)
    #开始计算动作对应的交叉熵
    a = t.tensor([a]).long()
    logp_a = criterion(logits, a)
    
    l = r + V_s_ - V_s
    l = l.item()
    loss = l * logp_a
    # print('Actor loss is :', loss)
    optim.zero_grad()
    
    loss.backward()
    optim.step()
    

def Critic_learn(optim, critic, s, r, s_):
    
    '''
    用来计算Critic网络的损失，来更新Critic网络
    Parameters
    ----------
    critic : Critic实例
        用来计算各个时间步的值函数.
    s : float array
        当前时间步的状态.
    r : float scalar
        当前时间步的奖励.
    s_ : float array
        下一个时间步的状态.

    Returns
    -------
    Critic网络的损失.
    '''
    
    V_s = critic(s)
    V_s_ = critic(s_)
    
    loss = (r + gamma * V_s_.item()- V_s)**2
    optim.zero_grad()
    loss.backward()
    
    optim.step()
    
    return r + gamma * V_s_.item()- V_s
    
 
    
def learn():
    
    #下面采用时间差分方法学习，该方法的学习速度较快，且很稳，时间差分方法和蒙特卡洛方法各有自己的优势
    sl = Share_layer()
    actor = Actor(sl)
    critic = Critic(sl)
    
    actor.train()
    critic.train()
    
    #还需要两个优化器
    actor_optim = t.optim.Adam(actor.parameters(), lr = actor_lr)
    critic_optim = t.optim.Adam(critic.parameters(), lr = critic_lr)
    train_rewards = []
    
    for i in range(epochs):
        
        state = env.reset()
        done = False
        sum_rewards_i = 0
        step = 0

            
        
        while not done:
            
            step += 1
            
            env.render()
            state = np.expand_dims(state, axis = 0)
            
            prob, logits = actor(state)
            
            #下面开始选择动作
            action = choose_action(prob)
            
            state_, reward, done, info = env.step(action)
            if done:
                reward = -20.0
            sum_rewards_i += reward
            
            
            #下面开始学习，先学习的是critic网络，接着才是actor网络
            l = Critic_learn(critic_optim, critic, state, reward, state_)
            Actor_learn(actor_optim, critic, state, state_, action, reward, logits)                       
            state = state_
            
        train_rewards.append(sum_rewards_i)
        print('epoch is :', i)
        print('step nums is :', step)
        
        
        
    plt.plot(train_rewards)
        
            
            
if __name__ == "__main__":
    learn()    
    env.close()

参考内容主要是李宏毅老师的强化学习课程和莫烦python的代码