0
0

强化学习之AC系列算法（AC、A2C、A3C）

文章目录

AC算法

我们之前讲过基于价值的强化学习，我们也讲过基于策略的强化学习，这节课所讲的AC系列算法就是同时使用了这两种方法包含有：AC——Actor Critic、A2C——Advantage Actor Critic、A3C——Asynchronous Advantage Actor Critic。

AC

Actor-Critic算法分为两部分，Actor用的是policy gradient，它可以在连续动作空间内选择合适的动作，Critic用的是Q-learning，它可以解决离散动作空间的问题。除了这个，又因为Actor只能在一个回合之后进行更新，导致学习效率较慢，Critic的加入就可以使用TD方法实现单步更新。这样两种算法相辅相成就形成了我们的Actor-Critic。
Actor输出每个Action的概率，有多少个Action就有多少个输出。Critic 基于 Actor 输出的行为评判得分, Actor 再根据 Critic 的评分修改选行为的概率。这是两个神经网络。因此策略梯度可以写成：

  1.          g
  2.         
  3.         
  4.          =
  5.         
  6.         
  7.          E
  8.         
  9.         
  10.          [
  11.         
  12.         
  13.          
  14.           ∑
  15.          
  16.          
  17.           
  18.            t
  19.           
  20.           
  21.            =
  22.           
  23.           
  24.            0
  25.           
  26.          
  27.          
  28.           ∞
  29.          
  30.         
  31.         
  32.          
  33.           ψ
  34.          
  35.          
  36.           t
  37.          
  38.         
  39.         
  40.          
  41.           ∇
  42.          
  43.          
  44.           θ
  45.          
  46.         
  47.         
  48.          l
  49.         
  50.         
  51.          o
  52.         
  53.         
  54.          g
  55.         
  56.         
  57.          
  58.           π
  59.          
  60.          
  61.           θ
  62.          
  63.         
  64.         
  65.          (
  66.         
  67.         
  68.          
  69.           a
  70.          
  71.          
  72.           t
  73.          
  74.         
  75.         
  76.          ∣
  77.         
  78.         
  79.          
  80.           s
  81.          
  82.          
  83.           t
  84.          
  85.         
  86.         
  87.          )
  88.         
  89.         
  90.          ]
  91.         
  92.        
  93.       
  94.      
  95.      
  96.      
  97.     
  98.    
  99.    
  100.      \begin{align} g=E[\sum_{t=0}^\infty \psi_t \nabla_\theta logπ_\theta (a_t|s_t)] \end{align} 
  101.    
  102.   
  103.  g=E[t=0∑∞​ψt​∇θ​logπθ​(at​∣st​)]​​

公式里的π指的就是Actor的策略，

  1.     ψ
  2.    
  3.   
  4.   
  5.    \psi
  6.   
  7.  
  8. ψ指的就是Critic，评估Actor策略的好坏，它可以表示成很多种形式：

（1）

  1.      ∑
  2.     
  3.     
  4.      
  5.       t
  6.      
  7.      
  8.       =
  9.      
  10.      
  11.       0
  12.      
  13.     
  14.     
  15.      ∞
  16.     
  17.    
  18.    
  19.     
  20.      r
  21.     
  22.     
  23.      t
  24.     
  25.    
  26.   
  27.   
  28.    \sum\limits_{t=0}^\infty r_t
  29.   
  30.  
  31. t=0∑∞​rt​：一个轨迹中的Reward相加；

（2）

  1.      ∑
  2.     
  3.     
  4.      
  5.       t
  6.      
  7.      
  8.       =
  9.      
  10.      
  11.       
  12.        t
  13.       
  14.       
  15.        ′
  16.       
  17.      
  18.     
  19.     
  20.      ∞
  21.     
  22.    
  23.    
  24.     
  25.      r
  26.     
  27.     
  28.      
  29.       t
  30.      
  31.      
  32.       ′
  33.      
  34.     
  35.    
  36.   
  37.   
  38.    \sum\limits_{t=t'}^\infty r_{t'}
  39.   
  40.  
  41. t=t′∑∞​rt′​：动作后的Reward（从该动作往后算，可以看成前期的对后面没有影响）；

（3）

  1.      ∑
  2.     
  3.     
  4.      
  5.       t
  6.      
  7.      
  8.       =
  9.      
  10.      
  11.       
  12.        t
  13.       
  14.       
  15.        ′
  16.       
  17.      
  18.     
  19.     
  20.      ∞
  21.     
  22.    
  23.    
  24.     
  25.      r
  26.     
  27.     
  28.      
  29.       t
  30.      
  31.      
  32.       ′
  33.      
  34.     
  35.    
  36.    
  37.     −
  38.    
  39.    
  40.     b
  41.    
  42.    
  43.     (
  44.    
  45.    
  46.     
  47.      s
  48.     
  49.     
  50.      t
  51.     
  52.    
  53.    
  54.     )
  55.    
  56.   
  57.   
  58.    \sum\limits_{t=t'}^\infty r_{t'}-b(s_t)
  59.   
  60.  
  61. t=t′∑∞​rt′​−b(st​)：动作后的总汇报相加后的Reward减去一个baseline；

（4）

  1.      Q
  2.     
  3.     
  4.      π
  5.     
  6.    
  7.    
  8.     (
  9.    
  10.    
  11.     
  12.      s
  13.     
  14.     
  15.      t
  16.     
  17.    
  18.    
  19.     ,
  20.    
  21.    
  22.     
  23.      a
  24.     
  25.     
  26.      t
  27.     
  28.    
  29.    
  30.     )
  31.    
  32.   
  33.   
  34.    Q^π(s_t,a_t)
  35.   
  36.  
  37. Qπ(st​,at​)：用行为价值函数Q计算；

（5）

  1.      A
  2.     
  3.     
  4.      π
  5.     
  6.    
  7.    
  8.     (
  9.    
  10.    
  11.     
  12.      s
  13.     
  14.     
  15.      t
  16.     
  17.    
  18.    
  19.     ,
  20.    
  21.    
  22.     
  23.      a
  24.     
  25.     
  26.      t
  27.     
  28.    
  29.    
  30.     )
  31.    
  32.   
  33.   
  34.    A^π(s_t,a_t)
  35.   
  36.  
  37. Aπ(st​,at​)：用优势函数A计算；

（6）

  1.      r
  2.     
  3.     
  4.      t
  5.     
  6.    
  7.    
  8.     +
  9.    
  10.    
  11.     γ
  12.    
  13.    
  14.     
  15.      V
  16.     
  17.     
  18.      π
  19.     
  20.    
  21.    
  22.     (
  23.    
  24.    
  25.     
  26.      s
  27.     
  28.     
  29.      
  30.       t
  31.      
  32.      
  33.       +
  34.      
  35.      
  36.       1
  37.      
  38.     
  39.    
  40.    
  41.     )
  42.    
  43.    
  44.     −
  45.    
  46.    
  47.     
  48.      V
  49.     
  50.     
  51.      π
  52.     
  53.    
  54.    
  55.     (
  56.    
  57.    
  58.     
  59.      s
  60.     
  61.     
  62.      
  63.       t
  64.      
  65.      
  66.       +
  67.      
  68.      
  69.       1
  70.      
  71.     
  72.    
  73.    
  74.     )
  75.    
  76.   
  77.   
  78.    r_t+\gamma V^π(s_{t+1})-V^π(s_{t+1})
  79.   
  80.  
  81. rt​+γVπ(st+1​)−Vπ(st+1​)：用TD-error，计算新的状态价值减去原本的状态价值；

前三个都是直接应用轨迹的回报累计回报，这样计算出来的策略梯度不会存在偏差，但是因为需要累计多步的回报，所以方差会很大。
后三个是利用动作价值函数，优势函数和TD偏差代替累计回报，其优点是方差小，但是三种方法中都用到了逼近方法，因此计算出来的策略梯度都存在偏差。这三种方法是以牺牲偏差来换取小的方差。
算法结构图如下：
AC结构
AC算法流程：
输入：策略

  1.      π
  2.     
  3.     
  4.      θ
  5.     
  6.    
  7.    
  8.     (
  9.    
  10.    
  11.     
  12.      a
  13.     
  14.     
  15.      t
  16.     
  17.    
  18.    
  19.     ∣
  20.    
  21.    
  22.     
  23.      s
  24.     
  25.     
  26.      t
  27.     
  28.    
  29.    
  30.     )
  31.    
  32.   
  33.   
  34.    π_\theta (a_t|s_t)
  35.   
  36.  
  37. πθ​(at​∣st​)、参数化状态
  39.  
  40.   
  41.    
  42.     V
  43.    
  44.    
  45.     (
  46.    
  47.    
  48.     s
  49.    
  50.    
  51.     ,
  52.    
  53.    
  54.     ω
  55.    
  56.    
  57.     )
  58.    
  59.   
  60.   
  61.    V(s,\omega)
  62.   
  63.  
  64. V(s,ω)；

对Actor网络参数

  1.     θ
  2.    
  3.   
  4.   
  5.    \theta
  6.   
  7.  
  8. θ以及Critic网络参数
  10.  
  11.   
  12.    
  13.     ω
  14.    
  15.   
  16.   
  17.    \omega
  18.   
  19.  
  20. ω初始化；

开始循环：
  利用当前策略

  1.      π
  2.     
  3.     
  4.      θ
  5.     
  6.    
  7.    
  8.     (
  9.    
  10.    
  11.     
  12.      a
  13.     
  14.     
  15.      t
  16.     
  17.    
  18.    
  19.     ∣
  20.    
  21.    
  22.     
  23.      s
  24.     
  25.     
  26.      t
  27.     
  28.    
  29.    
  30.     )
  31.    
  32.   
  33.   
  34.    π_\theta (a_t|s_t)
  35.   
  36.  
  37. πθ​(at​∣st​)对
  39.  
  40.   
  41.    
  42.     (
  43.    
  44.    
  45.     
  46.      s
  47.     
  48.     
  49.      t
  50.     
  51.    
  52.    
  53.     ,
  54.    
  55.    
  56.     
  57.      r
  58.     
  59.     
  60.      t
  61.     
  62.    
  63.    
  64.     ,
  65.    
  66.    
  67.     
  68.      s
  69.     
  70.     
  71.      
  72.       t
  73.      
  74.      
  75.       +
  76.      
  77.      
  78.       1
  79.      
  80.     
  81.    
  82.    
  83.     )
  84.    
  85.   
  86.   
  87.    (s_t,r_t,s_{t+1})
  88.   
  89.  
  90. (st​,rt​,st+1​)采样；

  计算行为值函数，并进行更新（

  1.     Q
  2.    
  3.    
  4.     =
  5.    
  6.    
  7.     r
  8.    
  9.    
  10.     +
  11.    
  12.    
  13.     γ
  14.    
  15.    
  16.     V
  17.    
  18.    
  19.     (
  20.    
  21.    
  22.     
  23.      s
  24.     
  25.     
  26.      
  27.       t
  28.      
  29.      
  30.       +
  31.      
  32.      
  33.       1
  34.      
  35.     
  36.    
  37.    
  38.     )
  39.    
  40.   
  41.   
  42.    Q=r+\gamma V(s_{t+1})
  43.   
  44.  
  45. Q=r+γV(st+1​)）
  48.  
  49.   
  50.    
  51.     δ
  52.    
  53.    
  54.     =
  55.    
  56.    
  57.     Q
  58.    
  59.    
  60.     −
  61.    
  62.    
  63.     V
  64.    
  65.    
  66.     (
  67.    
  68.    
  69.     
  70.      s
  71.     
  72.     
  73.      t
  74.     
  75.    
  76.    
  77.     ,
  78.    
  79.    
  80.     ω
  81.    
  82.    
  83.     )
  84.    
  85.   
  86.   
  87.    \delta=Q-V(s_t,\omega)
  88.   
  89.  
  90. δ=Q−V(st​,ω)
  93.  
  94.   
  95.    
  96.     ω
  97.    
  98.    
  99.     ←
  100.    
  101.    
  102.     ω
  103.    
  104.    
  105.     +
  106.    
  107.    
  108.     
  109.      α
  110.     
  111.     
  112.      ω
  113.     
  114.    
  115.    
  116.     δ
  117.    
  118.    
  119.     
  120.      ∇
  121.     
  122.     
  123.      ω
  124.     
  125.    
  126.    
  127.     V
  128.    
  129.    
  130.     (
  131.    
  132.    
  133.     s
  134.    
  135.    
  136.     ,
  137.    
  138.    
  139.     ω
  140.    
  141.    
  142.     )
  143.    
  144.   
  145.   
  146.    \omega \leftarrow \omega+\alpha^\omega\delta\nabla_\omega V(s,\omega)
  147.   
  148.  
  149. ω←ω+αωδ∇ω​V(s,ω)（critic网络参数更新）
  152.  
  153.   
  154.    
  155.     θ
  156.    
  157.    
  158.     ←
  159.    
  160.    
  161.     θ
  162.    
  163.    
  164.     +
  165.    
  166.    
  167.     
  168.      α
  169.     
  170.     
  171.      θ
  172.     
  173.    
  174.    
  175.     δ
  176.    
  177.    
  178.     
  179.      ∇
  180.     
  181.     
  182.      θ
  183.     
  184.    
  185.    
  186.     l
  187.    
  188.    
  189.     o
  190.    
  191.    
  192.     g
  193.    
  194.    
  195.     π
  196.    
  197.   
  198.   
  199.    \theta\leftarrow\theta+\alpha^\theta\delta\nabla_\theta logπ
  200.   
  201.  
  202. θ←θ+αθδ∇θ​logπ（actor网络参数更新）

A2C

A2C即Advantage Actor-Critic此算法的出现是为了应对AC方法高方差的问题，为什么会有这个问题呢，是因为一个动作轨迹中假如所有的动作回报都为正的这并不代表所有动作都是好的，他可能只是个次优的动作。因此我们采用引入基线的方式来解决这个问题,基线函数的特点是能在不改变策略梯度的同时降低其方差。这里的基线baseline一般由

  1.     V
  2.    
  3.    
  4.     (
  5.    
  6.    
  7.     
  8.      s
  9.     
  10.     
  11.      t
  12.     
  13.    
  14.    
  15.     )
  16.    
  17.   
  18.   
  19.    V(s_t)
  20.   
  21.  
  22. V(st​)来代替，原来的Q值就变成了：
  24.  
  25.   
  26.    
  27.     
  28.      
  29.      
  30.       
  31.        
  32.         
  33.          Q
  34.         
  35.         
  36.          =
  37.         
  38.         
  39.          Q
  40.         
  41.         
  42.          (
  43.         
  44.         
  45.          
  46.           s
  47.          
  48.          
  49.           t
  50.          
  51.         
  52.         
  53.          ,
  54.         
  55.         
  56.          
  57.           a
  58.          
  59.          
  60.           t
  61.          
  62.         
  63.         
  64.          )
  65.         
  66.         
  67.          −
  68.         
  69.         
  70.          V
  71.         
  72.         
  73.          (
  74.         
  75.         
  76.          
  77.           s
  78.          
  79.          
  80.           t
  81.          
  82.         
  83.         
  84.          )
  85.         
  86.         
  87.          =
  88.         
  89.         
  90.          
  91.           r
  92.          
  93.          
  94.           t
  95.          
  96.         
  97.         
  98.          +
  99.         
  100.         
  101.          γ
  102.         
  103.         
  104.          V
  105.         
  106.         
  107.          (
  108.         
  109.         
  110.          
  111.           s
  112.          
  113.          
  114.           
  115.            t
  116.           
  117.           
  118.            +
  119.           
  120.           
  121.            1
  122.           
  123.          
  124.         
  125.         
  126.          )
  127.         
  128.         
  129.          −
  130.         
  131.         
  132.          V
  133.         
  134.         
  135.          (
  136.         
  137.         
  138.          
  139.           s
  140.          
  141.          
  142.           t
  143.          
  144.         
  145.         
  146.          )
  147.         
  148.        
  149.       
  150.      
  151.      
  152.      
  153.     
  154.    
  155.    
  156.      \begin{align} Q=Q(s_t,a_t)-V(s_t)=r_t+\gamma V(s_{t+1})-V(s_t) \end{align} 
  157.    
  158.   
  159.  Q=Q(st​,at​)−V(st​)=rt​+γV(st+1​)−V(st​)​​

A3C

A3C即Asynchronous Advantage Actor Critic，在讲DQN算法时我们讲过神经网络训练时，需要的数据是独立同分布的，否则Agent很容易学习到一种固定的策略，DQN采用的是经验回放机制解决这个问题的，但这种机制存在两个问题：
（1）Agent每次交互的时候都需要更多的内存和计算；
（2）经验回放机制要求 Agent 采用离策略（off-policy）方法来进行学习，而同样的条件下，离线策略算法不如在线策略算法稳定；
打破数据的相关性，经历回放并非是唯一方法。另一种为异步的方法，通过在多个环境实例中并行地执行多个智能体，由于探索的随机性，所以产生的数据是各不相同的。并行的交互采样和训练。在异步方法中，同时启动多个线程，智能体将在多个线程中同时进行环境交互。
A3C算法就是采用多线程进行训练，采用几个独立的副本网络去单独学习训练，然后将学到的神经网络参数上传到全局的网络，全局的网络再适时的将最新的参数分发给各个副本网络，使其拥有最新的知识。通过多个副本独立训练打破了数据的相关性。A3C网络结构如图：
A3C网络结构
A3C算法价值模型采用多步回报的估计方法，这个方法可以减小模型的偏差，权重计算公式为：

  1.           ∑
  2.          
  3.          
  4.           
  5.            i
  6.           
  7.           
  8.            =
  9.           
  10.           
  11.            1
  12.           
  13.          
  14.          
  15.           n
  16.          
  17.         
  18.         
  19.          
  20.           γ
  21.          
  22.          
  23.           
  24.            i
  25.           
  26.           
  27.            −
  28.           
  29.           
  30.            1
  31.           
  32.          
  33.         
  34.         
  35.          
  36.           r
  37.          
  38.          
  39.           
  40.            t
  41.           
  42.           
  43.            +
  44.           
  45.           
  46.            1
  47.           
  48.          
  49.         
  50.         
  51.          +
  52.         
  53.         
  54.          v
  55.         
  56.         
  57.          (
  58.         
  59.         
  60.          
  61.           s
  62.          
  63.          
  64.           
  65.            t
  66.           
  67.           
  68.            +
  69.           
  70.           
  71.            n
  72.           
  73.          
  74.         
  75.         
  76.          )
  77.         
  78.         
  79.          −
  80.         
  81.         
  82.          v
  83.         
  84.         
  85.          (
  86.         
  87.         
  88.          
  89.           s
  90.          
  91.          
  92.           t
  93.          
  94.         
  95.         
  96.          )
  97.         
  98.        
  99.       
  100.      
  101.      
  102.      
  103.     
  104.    
  105.    
  106.      \begin{align} \sum_{i=1}^n \gamma^{i-1}r_{t+1}+v(s_{t+n})-v(s_t) \end{align} 
  107.    
  108.   
  109.  i=1∑n​γi−1rt+1​+v(st+n​)−v(st​)​​

为提高算法的探索能力，通过增大目标函数中策略的熵，增加概率分布的随机性。策略梯度的公式如下：

  1.           ∇
  2.          
  3.          
  4.           θ
  5.          
  6.         
  7.         
  8.          J
  9.         
  10.         
  11.          (
  12.         
  13.         
  14.          θ
  15.         
  16.         
  17.          )
  18.         
  19.         
  20.          =
  21.         
  22.         
  23.          
  24.           1
  25.          
  26.          
  27.           T
  28.          
  29.         
  30.         
  31.          
  32.           ∑
  33.          
  34.          
  35.           t
  36.          
  37.          
  38.           T
  39.          
  40.         
  41.         
  42.          
  43.           ∇
  44.          
  45.          
  46.           θ
  47.          
  48.         
  49.         
  50.          l
  51.         
  52.         
  53.          o
  54.         
  55.         
  56.          g
  57.         
  58.         
  59.          π
  60.         
  61.         
  62.          (
  63.         
  64.         
  65.          
  66.           a
  67.          
  68.          
  69.           t
  70.          
  71.         
  72.         
  73.          ∣
  74.         
  75.         
  76.          
  77.           s
  78.          
  79.          
  80.           t
  81.          
  82.         
  83.         
  84.          ;
  85.         
  86.         
  87.          θ
  88.         
  89.         
  90.          )
  91.         
  92.         
  93.          (
  94.         
  95.         
  96.          
  97.           ∑
  98.          
  99.          
  100.           
  101.            i
  102.           
  103.           
  104.            =
  105.           
  106.           
  107.            1
  108.           
  109.          
  110.          
  111.           n
  112.          
  113.         
  114.         
  115.          
  116.           γ
  117.          
  118.          
  119.           
  120.            i
  121.           
  122.           
  123.            −
  124.           
  125.           
  126.            1
  127.           
  128.          
  129.         
  130.         
  131.          
  132.           r
  133.          
  134.          
  135.           
  136.            t
  137.           
  138.           
  139.            +
  140.           
  141.           
  142.            1
  143.           
  144.          
  145.         
  146.         
  147.          +
  148.         
  149.         
  150.          v
  151.         
  152.         
  153.          (
  154.         
  155.         
  156.          
  157.           s
  158.          
  159.          
  160.           
  161.            t
  162.           
  163.           
  164.            +
  165.           
  166.           
  167.            n
  168.           
  169.          
  170.         
  171.         
  172.          )
  173.         
  174.         
  175.          −
  176.         
  177.         
  178.          v
  179.         
  180.         
  181.          (
  182.         
  183.         
  184.          
  185.           s
  186.          
  187.          
  188.           t
  189.          
  190.         
  191.         
  192.          )
  193.         
  194.         
  195.          )
  196.         
  197.         
  198.          +
  199.         
  200.         
  201.          β
  202.         
  203.         
  204.          
  205.           ∇
  206.          
  207.          
  208.           θ
  209.          
  210.         
  211.         
  212.          H
  213.         
  214.         
  215.          (
  216.         
  217.         
  218.          π
  219.         
  220.         
  221.          (
  222.         
  223.         
  224.          
  225.           s
  226.          
  227.          
  228.           t
  229.          
  230.         
  231.         
  232.          ;
  233.         
  234.         
  235.          θ
  236.         
  237.         
  238.          )
  239.         
  240.         
  241.          )
  242.         
  243.        
  244.       
  245.      
  246.      
  247.      
  248.     
  249.    
  250.    
  251.      \begin{align} \nabla_\theta J(\theta)=\frac 1T \sum_{t}^T \nabla_\theta logπ(a_t|s_t;\theta)(\sum_{i=1}^n \gamma^{i-1}r_{t+1}+v(s_{t+n})-v(s_t))+\beta \nabla_\theta H(π(s_t;\theta)) \end{align} 
  252.    
  253.   
  254.  ∇θ​J(θ)=T1​t∑T​∇θ​logπ(at​∣st​;θ)(i=1∑n​γi−1rt+1​+v(st+n​)−v(st​))+β∇θ​H(π(st​;θ))​​

A3C算法流程（单一线程）：
输入
T 

  1.     ←
  2.    
  3.   
  4.   
  5.    \leftarrow
  6.   
  7.  
  8. ← 0

全局和副本策略模型参数：

  1.     θ
  2.    
  3.    
  4.     ,
  5.    
  6.    
  7.     
  8.      θ
  9.     
  10.     
  11.      ′
  12.     
  13.    
  14.   
  15.   
  16.    \theta,\theta'
  17.   
  18.  
  19. θ,θ′

全局和副本价值模型参数：

  1.      θ
  2.     
  3.     
  4.      v
  5.     
  6.    
  7.    
  8.     ,
  9.    
  10.    
  11.     
  12.      θ
  13.     
  14.     
  15.      v
  16.     
  17.     
  18.      ′
  19.     
  20.    
  21.   
  22.   
  23.    \theta_v,\theta'_v
  24.   
  25.  
  26. θv​,θv′​

全局和副本梯度：

  1.     d
  2.    
  3.    
  4.     θ
  5.    
  6.    
  7.     ,
  8.    
  9.    
  10.     d
  11.    
  12.    
  13.     
  14.      θ
  15.     
  16.     
  17.      v
  18.     
  19.    
  20.   
  21.   
  22.    d\theta,d\theta_v
  23.   
  24.  
  25. dθ,dθv​

开始
循环直到

  1.     T
  2.    
  3.    
  4.     >
  5.    
  6.    
  7.     
  8.      T
  9.     
  10.     
  11.      
  12.       m
  13.      
  14.      
  15.       a
  16.      
  17.      
  18.       x
  19.      
  20.     
  21.    
  22.   
  23.   
  24.    T>T_{max}
  25.   
  26.  
  27. T>Tmax​

  将梯度清零：

  1.     d
  2.    
  3.    
  4.     θ
  5.    
  6.    
  7.     ←
  8.    
  9.    
  10.     0
  11.    
  12.    
  13.     ,
  14.    
  15.    
  16.     d
  17.    
  18.    
  19.     
  20.      θ
  21.     
  22.     
  23.      v
  24.     
  25.    
  26.    
  27.     ←
  28.    
  29.    
  30.     0
  31.    
  32.   
  33.   
  34.    d\theta \leftarrow0,d\theta_v \leftarrow0
  35.   
  36.  
  37. dθ←0,dθv​←0

  同步模型参数：

  1.      θ
  2.     
  3.     
  4.      ′
  5.     
  6.    
  7.    
  8.     ←
  9.    
  10.    
  11.     θ
  12.    
  13.    
  14.     ,
  15.    
  16.    
  17.     
  18.      θ
  19.     
  20.     
  21.      v
  22.     
  23.     
  24.      ′
  25.     
  26.    
  27.    
  28.     ←
  29.    
  30.    
  31.     
  32.      θ
  33.     
  34.     
  35.      v
  36.     
  37.    
  38.   
  39.   
  40.    \theta'\leftarrow\theta,\theta'_v\leftarrow\theta_v
  41.   
  42.  
  43. θ′←θ,θv′​←θv​

  用策略模型

  1.     π
  2.    
  3.    
  4.     (
  5.    
  6.    
  7.     
  8.      a
  9.     
  10.     
  11.      t
  12.     
  13.    
  14.    
  15.     ∣
  16.    
  17.    
  18.     
  19.      s
  20.     
  21.     
  22.      t
  23.     
  24.    
  25.    
  26.     ;
  27.    
  28.    
  29.     
  30.      θ
  31.     
  32.     
  33.      ′
  34.     
  35.    
  36.    
  37.     )
  38.    
  39.   
  40.   
  41.    π(a_t|s_t;\theta')
  42.   
  43.  
  44. π(at​∣st​;θ′)完成一回合训练，获得数据{
  46.  
  47.   
  48.    
  49.     
  50.      s
  51.     
  52.     
  53.      0
  54.     
  55.    
  56.    
  57.     ,
  58.    
  59.    
  60.     
  61.      a
  62.     
  63.     
  64.      0
  65.     
  66.    
  67.    
  68.     ,
  69.    
  70.    
  71.     
  72.      r
  73.     
  74.     
  75.      0
  76.     
  77.    
  78.    
  79.     ,
  80.    
  81.    
  82.     ⋅
  83.    
  84.    
  85.     ⋅
  86.    
  87.    
  88.     ⋅
  89.    
  90.    
  91.     ⋅
  92.    
  93.    
  94.     ⋅
  95.    
  96.    
  97.     ⋅
  98.    
  99.   
  100.   
  101.    s_0,a_0,r_0,······
  102.   
  103.  
  104. s0​,a0​,r0​,⋅⋅⋅⋅⋅⋅}
  107.  
  108.   
  109.    
  110.     T
  111.    
  112.    
  113.     ←
  114.    
  115.    
  116.     T
  117.    
  118.    
  119.     +
  120.    
  121.    
  122.     n
  123.    
  124.   
  125.   
  126.    T \leftarrow T+n
  127.   
  128.  
  129. T←T+n

  计算每一个回合价值

  1.      R
  2.     
  3.     
  4.      =
  5.     
  6.     
  7.      
  8.       {
  9.      
  10.      
  11.       
  12.        
  13.         
  14.          
  15.           
  16.            0
  17.           
  18.           
  19.            ,
  20.           
  21.          
  22.         
  23.        
  24.        
  25.         
  26.          
  27.           到达终点状态
  28.          
  29.         
  30.        
  31.       
  32.       
  33.        
  34.         
  35.          
  36.           
  37.            v
  38.           
  39.           
  40.            (
  41.           
  42.           
  43.            
  44.             s
  45.            
  46.            
  47.             t
  48.            
  49.           
  50.           
  51.            ;
  52.           
  53.           
  54.            
  55.             θ
  56.            
  57.            
  58.             v
  59.            
  60.            
  61.             ′
  62.            
  63.           
  64.           
  65.            )
  66.           
  67.           
  68.            ,
  69.           
  70.          
  71.         
  72.        
  73.        
  74.         
  75.          
  76.           未到达终点状态
  77.          
  78.         
  79.        
  80.       
  81.      
  82.     
  83.    
  84.    
  85.      R = \begin{cases} 0, & \text{到达终点状态} \\ v(s_t;\theta'_v), & \text{未到达终点状态} \\ \end{cases} 
  86.    
  87.   
  88.  R={0,v(st​;θv′​),​到达终点状态未到达终点状态​

  For 

  1.     i
  2.    
  3.    
  4.     ∈
  5.    
  6.   
  7.   
  8.    i\in
  9.   
  10.  
  11. i∈{n-1,0}do
  14.  
  15.   
  16.    
  17.     R
  18.    
  19.    
  20.     ←
  21.    
  22.    
  23.     
  24.      r
  25.     
  26.     
  27.      i
  28.     
  29.    
  30.    
  31.     +
  32.    
  33.    
  34.     γ
  35.    
  36.    
  37.     R
  38.    
  39.   
  40.   
  41.    R\leftarrow r_i+\gamma R
  42.   
  43.  
  44. R←ri​+γR
  47.  
  48.   
  49.    
  50.     d
  51.    
  52.    
  53.     θ
  54.    
  55.    
  56.     ←
  57.    
  58.    
  59.     d
  60.    
  61.    
  62.     θ
  63.    
  64.    
  65.     +
  66.    
  67.    
  68.     
  69.      ∇
  70.     
  71.     
  72.      
  73.       θ
  74.      
  75.      
  76.       ′
  77.      
  78.     
  79.    
  80.    
  81.     l
  82.    
  83.    
  84.     o
  85.    
  86.    
  87.     g
  88.    
  89.    
  90.     π
  91.    
  92.    
  93.     (
  94.    
  95.    
  96.     
  97.      a
  98.     
  99.     
  100.      t
  101.     
  102.    
  103.    
  104.     ∣
  105.    
  106.    
  107.     
  108.      s
  109.     
  110.     
  111.      t
  112.     
  113.    
  114.    
  115.     ;
  116.    
  117.    
  118.     
  119.      θ
  120.     
  121.     
  122.      ′
  123.     
  124.    
  125.    
  126.     )
  127.    
  128.    
  129.     (
  130.    
  131.    
  132.     R
  133.    
  134.    
  135.     −
  136.    
  137.    
  138.     V
  139.    
  140.    
  141.     (
  142.    
  143.    
  144.     
  145.      s
  146.     
  147.     
  148.      i
  149.     
  150.    
  151.    
  152.     ,
  153.    
  154.    
  155.     
  156.      θ
  157.     
  158.     
  159.      v
  160.     
  161.     
  162.      ′
  163.     
  164.    
  165.    
  166.     )
  167.    
  168.    
  169.     )
  170.    
  171.   
  172.   
  173.    d\theta\leftarrow d\theta+\nabla_{\theta'} logπ(a_t|s_t;\theta')(R-V(s_i,\theta'_v))
  174.   
  175.  
  176. dθ←dθ+∇θ′​logπ(at​∣st​;θ′)(R−V(si​,θv′​))
  179.  
  180.   
  181.    
  182.     d
  183.    
  184.    
  185.     
  186.      θ
  187.     
  188.     
  189.      v
  190.     
  191.    
  192.    
  193.     ←
  194.    
  195.    
  196.     d
  197.    
  198.    
  199.     
  200.      θ
  201.     
  202.     
  203.      v
  204.     
  205.    
  206.    
  207.     +
  208.    
  209.    
  210.     
  211.      ∇
  212.     
  213.     
  214.      
  215.       θ
  216.      
  217.      
  218.       v
  219.      
  220.      
  221.       ′
  222.      
  223.     
  224.    
  225.    
  226.     (
  227.    
  228.    
  229.     R
  230.    
  231.    
  232.     −
  233.    
  234.    
  235.     V
  236.    
  237.    
  238.     (
  239.    
  240.    
  241.     
  242.      s
  243.     
  244.     
  245.      i
  246.     
  247.    
  248.    
  249.     ,
  250.    
  251.    
  252.     
  253.      θ
  254.     
  255.     
  256.      v
  257.     
  258.     
  259.      ′
  260.     
  261.    
  262.    
  263.     )
  264.    
  265.    
  266.     
  267.      )
  268.     
  269.     
  270.      2
  271.     
  272.    
  273.   
  274.   
  275.    d\theta_v\leftarrow d\theta_v+\nabla_{\theta'_v}(R-V(s_i,\theta'_v))^2
  276.   
  277.  
  278. dθv​←dθv​+∇θv′​​(R−V(si​,θv′​))2

  End For
  异步更新

  1.     θ
  2.    
  3.    
  4.     ,
  5.    
  6.    
  7.     
  8.      θ
  9.     
  10.     
  11.      v
  12.     
  13.    
  14.   
  15.   
  16.    \theta,\theta_v
  17.   
  18.  
  19. θ,θv​，
  21.  
  22.   
  23.    
  24.     θ
  25.    
  26.    
  27.     ←
  28.    
  29.    
  30.     d
  31.    
  32.    
  33.     θ
  34.    
  35.    
  36.     ,
  37.    
  38.    
  39.     
  40.      θ
  41.     
  42.     
  43.      v
  44.     
  45.    
  46.    
  47.     ←
  48.    
  49.    
  50.     d
  51.    
  52.    
  53.     
  54.      θ
  55.     
  56.     
  57.      v
  58.     
  59.    
  60.   
  61.   
  62.    \theta\leftarrow d\theta,\theta_v\leftarrow d\theta_v
  63.   
  64.  
  65. θ←dθ,θv​←dθv​
标签： 算法 人工智能 机器学习
本文转载自: https://blog.csdn.net/qq_43838114/article/details/127257760
版权归原作者 哇咔咔FF 所有， 如有侵权，请联系我们删除。
登录后发布评论

“强化学习之AC系列算法（AC、A2C、A3C）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
AC算法ACA2CA3C