强化学习

强化学习

一、基本概念

  • 状态state

    智能体相对于环境的状态, 用 s 表示

  • 状态空间 state space

    智能体所有的状态的集合叫做状态空间, 用 \(S_i\) 表示

  • 行动 action

    在每一个状态可以采取的行动, 用 A 表示

  • 行动空间 action space

    在某个状态下,所有可行动的集合交集合空间 用 \(A(S_i)\) 表示

  • 状态变化 state transition

    从某个状态经过某个动作转化为了另一个状态

    \[S_1 \mathop{\rightarrow} \limits^{A_i} S_2 \]

  • 状态转化表

    将每一个状态和行动的关系通过表格的形式列举出来,该表叫做状态转化表。实际上使用这种方式只能表示状态转化确定的情况,适用范围有限。

  • 状态转移概率

    状态转化表表示确定的状态转移的情况。但是很多时候状态转移是不确定的。因此引入转移概率,表示某个状态执行某个动作后转移到另一个状态的概率。例如

    \[P(S_2|S_1,A_2) = 1 \]

    该式子表示在状态 \(s_1\) 执行动作 \(a_2\) 转移到状态 \(s_2\) 的概率为 1

  • 策略 Policy

    在某个状态,智能体为了达到目标执行的动作。在强化学习中,执行某个策略的概率用 \(\pi\) 表示。例如 \(\pi(A_1, S_1) = 0\) 表示在 状态 \(S_1\) 执行动作 \(A_1\) 作为当前策略的概率为 0。强化学习训练的过程就是寻找最优策略的过程,即使得最优策略被执行的概率尽可能的变大。

  • 奖励 reward

    一个具体的数值,可正可负,表示智能体采用某个策略到达某个状态后的奖励或者惩罚。reward = 0 表示没有任何奖励或惩罚。奖励一定是状态和动作的函数,而和执行动作后的下一个状态无关。奖励的具体的值也可以通过概率来表示。例如 \(P(r = 1| S_1, A_1)\) 表示在状态 \(S_1\) 执行 动作 \(A_1\) 获得奖励 1 的概率

  • 轨迹 trajectory

    智能体从初始状态到最终状态经过的转台和动作的链

  • 回报 return

    智能体沿着某个轨迹行动奖励的和。通过衡量return 的大小可以衡量轨迹的优劣,进一步评估策略的好坏

  • 折扣因子 \(\gamma\)

    在训练的过程中,我们可能希望得到的轨迹长度经可能的短(因为智能体为了得到更多的回报可能刻意选择轨迹长的策略,使得模型无法收敛)。因此引入折扣因子,再每次执行策略对回报打折。

  • 马尔可夫链(MDP)

    有以上所有概念组合形成的智能体可以行动的解空间叫构成了马尔科夫链。

    马尔科夫链有一个很重要的性质:当前状态转移的概率以及获得回报的概率和历史状态和历史回报无关

    • 马尔可夫过程

      智能体从初始状态行动到达最终状态的过程就是马尔可夫过程

二、贝尔曼公式

  • 在轨迹确定的情况下,也就是智能体在环境中执行策略确定时:如何计算回报?

    举例来说,考虑如下环境

    image.png

    不难计算

    \[v_1 = r_1 + \gamma r_2 + \gamma^2 r_3 + ... \\ v_2 = r_2 + \gamma r_3 + \gamma^2 r_4 + ... \\ v_3 = r_3 + \gamma r_4 + \gamma^2 r_1 + ... \\ v_4 = r_4 + \gamma r_1 + \gamma^2 r_2 + ... \]

    提出 \(\gamma\) 上述公式也可以写为

    \[v_1 = r_1 + \gamma(r_2 + \gamma r_3 + ...) = r_1 + \gamma v_2 \\ v_2 = r_2 + \gamma(r_3 + \gamma r_4 + ...) = r_2 + \gamma v_3 \\ v_3 = r_3 + \gamma(r_4 + \gamma r_1 + ...) = r_3 + \gamma v_4 \\ v_4 = r_4 + \gamma(r_1 + \gamma r_2 + ...) = r_4 + \gamma v_1 \]

    换成矩阵的形式即

    \[\left[ \begin{array}{c} v_1 \\ v_2 \\ v_3 \\ v_4 \end{array}\right] = \left[ \begin{array}{c} r_1 \\ r_2 \\ r_3 \\ r_4 \end{array}\right] + \gamma \left[ \begin{array}{c} 0& 1&0&0 \\ 0&0&1&0 \\ 0&0&0&1 \\ 1& 0&0&0 \end{array}\right]\left[ \begin{array}{c} v_1 \\ v_2 \\ v_3 \\ v_4 \end{array}\right] \]

    总结成为一个方程即:

    \[v = r + \gamma Pv \]

    在r 和 \(\gamma\) 确定的情况下,可以解出方程

将上述问题推广到一般情况,每次策略的选择,回报的大小,形成的轨迹全部由概率决定。

假设状态转移的过程用如下符号表示

\[S_t \mathop{\rightarrow} \limits^{A_i} R_{t+1},S_{t+1} \]

其中 t 表示当前时刻,t+1 表示执行完动作 \(A_i\) 后时刻。\(R_{t+1}\)表示执行动作\(A_i\) 后获得的奖励。

在执行多次策略获得一个轨迹后,其回报为

\[G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} \]

但是,由于从某个状态出发,轨迹可能不止一条,所以定义状态价值(state value)

\[v_{\pi}(s) = E[G_t|S_t =s] \tag{1} \]

即,最终该状态的价值为达到目标所有轨迹回报的期望值。

其中公式中的\(\pi\) 表示采用不同策略会得到不同的轨迹

  • return 和 state value 有什么区别

    return 表示的某一个轨迹得到的回报,而状态价值表示的所有轨迹的回报期望。如果轨迹只有一条(也就是例子中的情况),return = state value

展开推导式子(1),可以得到贝尔曼公式:

\[\begin{array}{ll} v_{\pi}(s) &= E[G_t|S_t =s] \\ &= E[R_{t+1}|S_t=s] + \gamma E[G_{t+1}|S_t=s] \\ &= \sum_a \pi(a|s)\sum_r p(r|s,a) + \gamma \sum_a\pi(a|s)\sum_{s'}p(s'|s,a)v_{\pi}(s') \end{array} \tag{pre} \]

要求解贝尔曼公式,就需要对所有的状态都列出该公式。假设一共有 n 个状态。则可以列出 n 个贝尔曼公式。仿照例子中的形式,可以将这 n 个公式使用矩阵的形式表示为

\[v_\pi = r_\pi + \gamma P_{\pi} v_{\pi} \tag{bellman equation} \]

其中 \([P_{\pi}]_{ij}\) 表示 状态 \(S_i\) 跳转到 状态 \(S_j\) 的概率。即\([P_{\pi}]_{ij} = p_{\pi}(s_i, s_j)\)\(r_{\pi}\) 表示跳转状态的回报期望值。

解贝尔曼公式可以得到

\[v_{\pi} = (I-P_{\pi})^{-1}r_{\pi} \]

实际上,上述方程的解法并不常用,因为实际的问题解空间往往非常大,导致求逆操作非常耗时。在实际应用中,往往使用 值迭代法(value iteration)求解该方程

\[v_{k+1} = r_{\pi} + \gamma P_{\pi}r_k \quad 其中 \mathop{lim} \limits_{k\rightarrow \infty}v_k= v_{\pi} \]

继续观察贝尔曼公式,在 公式 pre 中最后一项中提出 \(\pi{(a|s)}\) 得到

\[v_{\pi}(s) = \sum_a \pi(a|s)(\sum_r p(r|s,a) + \gamma \sum_{s'}p(s'|s,a)v_{\pi}(s')) \]

其中 后面这一项被定义为 动作价值(action value)用 q 表示,该值衡量在某个状态执行某个动作a的价值大小。即:

\[q_{\pi}(s,a) = \sum_r p(r|s,a) + \gamma \sum_{s'}p(s'|s,a)v_{\pi}(s') \]

所以状态价值和动作价值的联系为

\[v_{\pi}(s) = \sum_a \pi(a|s)q_{\pi}(s,a) \]

其中 \(\pi(a|s)\) 表示在状态 s 执行 动作 a 的概率

三、贝尔曼最优公式

强化学习训练过程就是求解最优策略的过程。最优的策略也就是要是的总体回报最大。要使得回报最大,也就是要在每一步选择最优的动作,即使得最优动作被执行的概率最大。用数学的语言描述,该模型被定义为贝尔曼最优公式:

\[v_{\pi} = \mathop{max} \limits_{\pi} \sum_a \pi(a|s)q_{\pi}(s,a) \\ v_\pi = \mathop{max} \limits_{\pi} (r_\pi + \gamma P_{\pi} v_{\pi}) \]

寻找最优策略的过程,就是求解贝尔曼最优公式的过程。

在贝尔曼最优公式中,就有两个未知的变量,一个是概率 \(\pi\) 一个是 状态价值 \(v_{\pi}\)。这使得方程无法直接求解。但是也有一定的方法可以获得近似解。

  • 在求解方程之前还有一个问题就是方程有没有解?有几个解?

    • \(\pi\) 的角度看

      假设我们已经知道了 \(v_{\pi}\),那么,可以证明,只需要不断选择动作价值最大的动作就可以得到最优解。也就是说,此时的 \(\pi\) 的解为

      \[\pi = \left\{ \begin {array}{c} 1 \quad if \space a = a^*\\ 0 \quad if \space a \neq a^* \end{array}\right. \]

      其中 \(a^*\) 表示最优动作,即 \(a^* = \mathop{arg \space max}\limits_a{q(s,a)}\)

    • \(v\) 的角度看

      巴拿赫不动点定理(压缩映射原理)

      对于 \(x = f(x)\) 这一类方程, 如果存在一个值 \(\gamma\) 并且有 \(0 < \gamma < 1\) 使得该函数满足\(||(f(x_1) - f(x_2))|| \leq \gamma||x_1 - x_2||\)。则,该方程会有一下性质:

      1. 该方程有唯一解 \(x^*\) 使得 \(x^* = f(x^*)\)
      2. 从任意 \(x= x_0\) 出发计算 \(x_1 = f(x_0), ... ,x_{k+1} = f(x_k)\), 则 \(x^* = \mathop{lim}\limits_{k \rightarrow\infty} x_{k}\)。并且该过程为指数级收敛

      可以证明,贝尔曼最优公式满足巴拿赫不动点定理。

    通过以上两个角度,可以证明,当v 取得最优值时,\(\pi\) 取得最优值。

3.1 值迭代法

值迭代算法基于巴纳赫不动点定理。其基本的步骤如下

  1. 随机初始化 \(v_k\)(一般初始化为0)
  2. 使用当前的 \(v_k\) 求解 \(\pi_k\) (对于每一个状态选择最大的\(q_k\) 使对应的 \(\pi_{k+1} = 1\) 否则为 0)
  3. 使用计算出来的 \(\pi_{k+1}\) 计算 \(q_{k+1}\) 进一步计算 \(v_{k+1}\)
  4. 重复步骤2~3 直到 \(||v_{k+1} - v_k|| \leq \Theta\) 其中 \(\Theta\) 为阈值

3.2 策略迭代法

值迭代算法从值得角度出发,先初始化 \(v\) 然后迭代得到最优解。

策略迭代算法从策略得角度出发,先初始化策略,然后迭代得到最优解。具体步骤如下:

  1. 随机初始化策略\(\pi\)
  2. 使用策略\(\pi\) 计算 \(q\), 这里可以直接求解贝尔曼公式,也可以使用 值迭代法求解出 q(和3.1讲的值迭代区别在于\(\pi\)是固定的)。
  3. 使用求解出的 q 计算出新的\(\pi\)
  4. 重复步骤2~3,直到 \(\pi\) 不在改变

可以证明,使用策略迭代算法\(\pi\) 一定会收敛到最优解

3.3 截断策略迭代法

在策略迭代法的第2步,需要使用值迭代法去计算q。虽然在理论上q值一定会收敛。但是此时 \(k \rightarrow \infty\)。也就是说,该算法在理论上存在,但是实际无法实现。截断策略迭代法就是将 k 设置为一个较大的值,由于此时计算出来的 q 值接近收敛值,也可以其到优化的效果。

从截断策略迭代法的角度出发,值迭代法和策略迭代法分别是\(k=1\)\(k\rightarrow \infty\) 的特殊情况。

研究表明,值迭代算法收敛最慢,而策略迭代收敛最快,截断迭代算法介于两者之间。

四、免模型学习

在前面的值迭代算法和策略迭代算法中,有一个很关键的点就是我们已经完全掌握了智能体所处环境的情况,并且构建出了环境模型(P矩阵,各种action和state,这里主要是指P矩阵,action和state一般由人为定义),由此给出了上述动态规划的解法。但是,在现实应用中,有很多时候我们并不能完全理解环境,无法构建出环境模型。因此需要有一种不依赖模型的学习方法。

4.1 蒙特卡洛算法(MC Exploring Start)

大数定理告诉我们,在样本足够多的时候,样本的平均值就是样本的期望值。蒙特卡洛算法就借助了这一思想。

蒙特卡洛算法的基本步骤如下:

  1. 随机化初始状态和策略
  2. 选择一个随机的初始状态出发
  3. 若该状态有策略则使用策略,否则随机选择一个策略或者有默认的策略,进行移动转移状态。
  4. 重复步骤2~3直到移动到最终状态
  5. 回溯更新经过状态的价值为平均值,并更新该状态的策略
  6. 重复步骤2~5,迭代训练
  • 怎么理解这里的平均值?

    在每一轮的迭代中,随机从一个状态出发,由于环境和策略的影响,每一个状态可能被不止访问一次,这里的平均值计算的是每次访问该状态得到的回报平均值。而不是和该状态原本的回报平均。

  • \(\epsilon\)-贪心策略

    实际上,在上述算法中,还是存在一定的问题。由于实际的环境非常复杂,空间中的状态可能非常多,得到最优解的策略也非常复杂。在一次迭代中,很难刚好找到每一个状态的最优策略。因此,需要不断的迭代,尽可能的遍历所有的状态。\(\epsilon\)-贪心策略使得在每一个状态中有一定的概率不按该状态的策略行动,而执行其他动作,极大的扩展了每一次迭代遍历所有状态的概率,使得迭代过程可以一种从某一个状态出发。具体的概率计算方法如下:

    \[\pi(a|s) = \left\{ \begin{array}{ll} 1 - \dfrac{\epsilon}{|A{(s)}|}(A(s) - 1) &\qquad \text{for greed action}\\ \\ \dfrac{\epsilon}{|A(s)|} &\qquad \text{for other |A(s) - 1| action} \end{array} \right. \]

    但是 \(\epsilon\)-贪心策略,也有一定的缺点:

    当模型训练完成,应用到实际的场景下,肯定不能使用\(\epsilon\)-贪心策略。此时,如果 \(\epsilon\) 值设置的过大,模型可能不会收敛!!

    因此在实际的训练过程中,我们会在开始时将\(\epsilon\)的值设置的比较大,并逐渐减小\(\epsilon\)的值。得到最终的模型。

4.2 时序差分算法(TD)

TD算法包含一系列的算法,它蒙特卡洛最大的区别在于TD算法可以在状态转移的过程中迭代状态和动作的价值。TD算法借助了随机近似理论的思想。

  • 随机近似理论

    随机近似理论是时序差分算法的基础。在蒙特卡洛算法中,通过不断的随机搜索轨迹,在回溯的过程中计算平均值。但是这种方法有一个很明显的缺点,就是需要等待路径搜索完成。随机近似理论提供了一种马上更新平均值的方法。

    假设第k+1个平均值的表达式为

    \[w_{k+1} = \frac{1}{k}\sum_{i=1}^{k}x_i \]

    则有

    \[w_k = \dfrac{1}{k-1}\sum_{i=1}^{k-1}x_i \\ \space \\ \begin{array}{cl} w_{k+1} &= \dfrac{1}{k}\sum_{i=1}^{k-1}x_i + x_k \\ \\ &= \dfrac{1}{k}((k-1)w_k+x_k) \\ \\ &= w_k - \dfrac{1}{k}(w_k - x_k) \end{array} \]

    • Ribbins-Monro 算法(RM)

      Ribbins-Monro 算法将随机近似理论进行扩展,指出随机近似理论是该算法的特殊情况。

      但把随机近似理论中的 \(\dfrac{1}{k}\)替换为 \(a_k\)。若 \(a_k\) 满足 \(\sum \limits_{k=1}^{\infty}a_k^2 <\ \infty\)\(\sum \limits_{k=1}^{\infty}a_k = \infty\),则 \(w_k\)也会收敛到平均值。证明略。

    • 随机梯度下降算法SGD

      随机梯度下降算法也是Ribbins-Monro算法的特殊情况。在梯度下降的过程中中,一般会输入多组数据,也就是说,对于每一个参数,会产生很多个导数。一般情况下,会对这些导数求平均值作梯度。批量梯度下降算法则是在这些导数中随机抽取一些值(可以重复)然后计算平均值作为梯度。随机梯度下降算法,是指在这些导数中随机选取一个作为梯度。

      SGD算法相对于传统的梯度下降算法有这些优缺点:

      1. SGD引入了随机的性质,有利于跳出局部最优,收敛到全局最优
      2. SGD算法相对于Min-Batch和正常的梯度下降可能收敛的更慢

基于随机近似理论,不难想到,可以在状态转移时写出如下公式

\[v(s_{t+1}) = v(s_t) - \alpha(s_t) \overbrace{ \left[ v(s_t) - \underbrace{(r_{t+1} + \gamma v(s_{t+1})}_{\text{TD target}}) \right]} ^{\text{TD error}} \]

TD Target指的是真实的值,最终v(s) 需要收敛到 TD target。

TD error 指的是目前的值和真实值的误差。

TD算法的核心思想就是每次走一步就通过上述公式立刻更新上一步的状态价值。由此也可以计算出更新上一步的策略。

上述的算法实际上被称为TD(0)算法。与之对应有TD(n)算法。即走n步之后再回头更新状态价值。但\(n\rightarrow \infty\)或n为直到终态为止时,TD(n)算法退化为MC算法。

4.2.1 Sarsa (State Action Reward State Action)算法

在TD算法中,只是计算了状态的价值函数,再根据状态的价值函数更新动作价值函数,进而更新策略。Sarsa算法的核心思想为将TD算法中的状态价值替换为动作价值。直接更新策略。即

\[q_{t+1}(s_t, a_t) = q_t(s_t,a_t) - \alpha_t(s_t,a_t)\left[q_{t}(s_t, a_t) - \left[r_{t+1} + \gamma q_{t+1}(s_{t+1},a_{t+1})\right]\right] \]

其中 \(q_{t+1}(a_{t+1},s_{t+1})\) 表示在状态转移之后,新的状态\(s_{t+1}\)中最好的策略对应动作的价值

通过直接计算上一步的动作价值,就可以直接更新上一步的策略。在一般情况下,更新策略还会引入\(\epsilon\)-贪婪策略。

  • Exception sarsa 算法

    Exception sarsa 算法作为sarsa算法的一个扩展,将公式中的\(q_{t+1}(a_{t+1},s_{t+1})\) 替换为\(E(q_{t+1}(s_{t+1},A_{t+1}))\)。即所有动作价值的平均值。实际上\(v_t(s_{t+1}) = E(q_{t+1}(s_{t+1},A_{t+1}))\)

  • n-step sarsa

    与TD(n)算法对应,n-step sarsa算法在转移n步之后再回过头更新动作价值成为 n-step sarsa

4.2.2 Q-Learning算法

Q-Learning算法将Sarsa算法中的TD target 修改为 \(r_{t+1} + \gamma \mathop{max}\limits_{a \in A}(q_{t+1}(s_{t+1},a))\)

Q-Learning的迭代公式为:

\[q_{t+1}(s_t, a_t) = q_t(s_t,a_t) - \alpha_t(s_t,a_t)\left[q_{t}(s_t, a_t) - \left[r_{t+1} + \gamma \mathop{max}\limits_{a \in A}(q_{t+1}(s_{t+1},a))\right]\right] \]

Q-Learning本质上是把求解贝尔曼公式的过程替换为了求解贝尔曼最优公式。

TD learning/Sarsa learning 和 MC的比较

  1. TD learning 可以做到在线更新值,而MC做不到。也就是说TD是online的而MC是 offline的。
  2. TD learning 可以处理不中断的任务,而MC做不到
  3. TD learning 是 boosttraping(自举)的,因为TD更新状态值和之前的状态值相关,而MC不是
  4. TD learning 相对来说采样方差较小,但是计算出来的价值误差偏大。MC则反之。

四、值函数

以上介绍的所有方法都默认有一种动作价值的转换表。也就是说,状态是离散的。但是实际上,在很多场景下,由于状态空间过大或者状态空间是连续的,状态转化表的方法不再适用。因此引入了值函数的方法。

值函数的方法基本思想为求解一个函数\(f(x)\)作为状态到价值的映射。其中\(f(x)\) 可以是传统的线性函数函数也可以是非线性函数例如神经网络。

4.1 基本原理

从传统的函数入手。假设 \(f(x) = \vec{w}\vec{x} + b\)。使用梯度下降法可以迭代更新参数 \(\vec{w}\)。假设使用的损失函数为\(J = cost = \dfrac{1}{2}(\hat{v} - v)^2\) 其中\(\hat{v} = f(x)\)。则有:

\[w_i = w_i + \alpha[(v - \hat{v})\nabla_w\hat{v}] \]

于是问题就转化为了,如何知道实际的 \(v\) 值?

我们不可能知道实际的 \(v\) 值,如果知道实际的 \(v\) 值还要什么强化学习!!!

但是我们可以通过MC、Sarsa、Q-learning的方法来近似的到\(v\)值!!

当使用MC方法时,上述公式重写为:

\[w_{t+1} = w_t + \alpha(g_t(s) - \hat{v})\nabla_w\hat{v} \]

当使用TD方法时,上述公式重写为:

\[w_{t+1} = w_t + \alpha(r_{t+1} + \gamma \hat{v}(s_{t+1},w) - \hat{v})\nabla_w\hat{v} \]

当使用Q-Learning时,上述公式重写为:

\[w_{t+1} = w_t + \alpha(r_{t+1} + \gamma \mathop{max}\limits_a(\hat{v}(s_{t+1},a,w)) - \hat{v})\nabla_w\hat{v} \]

  • 特殊情况

    当参数\(\vec{w}\) 为1x1的向量时,使用MC或TD方法的值函数方法退化为普通的MC或者TD算法

4.2 深度强化学习(DQN)

DQN是第一种在强化学习中使用神经网络表现很好的方法。

DQN中有一下几个主要的思想:

  • 固定一个参数w

    DQN中使用的损失函数如下:

    \[J(w) = E\left[ (R + \gamma \mathop{max}\limits_{a\in A(S')}\hat{q}(S',a,w) - \hat{q}(S,A,w))^2\right] \]

    在上述损失函数中,如果使用梯度下降法更新w的值,会发现计算项 \(\gamma \mathop{max}\limits_{a\in A(S')}\hat{q}(S',a,w)\)的偏导数特变困难。因此DQN的基本思想是假设改项的w为一个固定的常数。只对后面一项求偏导并更新后一项w的值。

  • 使用两个神经网络

    在DQN中,使用了两个神经网络。其中一个叫main network,用来计算和迭代。第二个叫target network用来预测q值。在训练时,会先有一批数据,使用第二个神经网络的输出值作为标签,训练main network向第二个神经网络靠近。在一定的迭代后,将第二个神经网络的参数赋值给main network。持续迭代下去,得到最终的模型。

  • 使用记忆回放技术

    DQN中使用记忆回放技术保存数据集。数据被保存在经验池中。每次训练时,使用均匀分布从池中取出一定量的数据作为min-batch训练。

DQN的训练步骤如下:

  1. 随机初始化多个轨迹,放入经验池中。池中只保存动作状态转化关系,假设一个数据为\((s_t,a_t,s_{t+1})\)

  2. 在池中随机取出n个数据作为min-batch。使用Q target网络计算min-batch的标签。计算公式为:

    \[y_{s_t} = r_{t+1} + \gamma \mathop{max}\limits_{a\in A}Q_{target}(s_{t+1},a) \]

  3. 使用第二步中计算出的标签和min-batch训练main network,并迭代一定的次数。

  4. 将main network中的参数复制到 target network。

  5. 重复步骤2-4,进行迭代

其中,经验池中数据可以动态更新,和具体的实现过程相关。

4.3 策略梯度算法

在DQN算法中,使用神经网络迭代计算的状态价值,在通过状态价值计算策略。在策略梯度算法中,我们直接迭代策略。其中策略迭代的公式如下(数学推导没看懂暂时不放):

\[\theta_{t+1} = \theta_t + \alpha \nabla_{\theta} ln\pi (a_t|s_t,\theta_t)q_t(s_t,a_t) \]

其中 \(\pi\) 是策略函数,输入为 状态 s和参数 \(\theta\), 输出为动作a。有一下几点需要注意

  1. 迭代使用梯度上升法
  2. \(\pi\) 通常是一个神经网络
  3. \(q_t\) 的计算如果使用蒙特卡洛方法则称为 REINFOCE模型(第一个提出策略梯度算法的模型)
  4. \(q_t\) 的计算如果使用 基于值函数的td算法,则称为 Actor-Critic方法
  5. \(\nabla_{\theta} ln\pi (a_t|s_t,\theta_t) = \dfrac{\nabla_{\theta}\pi(a_t|s_t,\theta_t)}{\pi(a_t|s_t,\theta_t)}\)

4.4 Actor-Critic方法

  • QAC算法

    使用基于值函数td算法就是最简单的QAC算法。基本的迭代过程如下:

    在每次迭代中执行如下步骤

    1. 更新值函数或者神经网络的参数 w, 该步骤迭代计算q值的模型

      \[w_{t+1} = w_t + \alpha_w[r_{t+1}+\gamma q(s_{t+1},a_{t+1},w_t)-q(s_t)]\nabla_w q(s_t, a_t, w_t) \]

    2. 更新值函数或者神经网络得参数\(\theta\),该步骤迭代计算策略函数的模型

      \[\theta_{t+1} = \theta_t + \alpha_{\theta} \nabla_{\theta} ln\pi (a_t|s_t,\theta_t)q_t(s_t,a_t,w_{t+1}) \]

  • A2C算法

    Q2C算法修改计算策略的公式如下

    \[\theta_{t+1} = \theta_t + \alpha \nabla_{\theta} ln\pi (a_t|s_t,\theta_t)(q_t(s_t,a_t) - b(s)) \]

    其中\(b(s)\)表示一个关于状态的函数。

    • 为什么要添加\(b(s)\)

      \(b(s)\)的主要意义在于使得模型输出的值的方差变小。可以证明,\(b(s)\)不会影响模型的\(q\)值和\(v\)值。只是会影响函数输出方差的大小。文心一言解释说,更小的方差有利于模型的训练和提高模型的稳定性。

    • \(b(s)\) 一般取什么函数

      严格的数学证明可以得到,最优的函数\(b(s)\) 如下:

      \[b(s) = \dfrac{E_{A\sim\pi}[||\nabla_{\theta}ln\pi(A|s,\theta_t)||^2q(s,A)]}{E_{A\sim\pi}[||\nabla_{\theta}ln\pi(A|s,\theta_t)||^2} \]

      但是这个公式过于复杂,所以在一般情况下我们取

      \[b(s) = E_{A\sim\pi}q_{\pi}(s,A) = v_{\pi}(s) \]

    所以A2C的公式可以写为

    \[\theta_{t+1} = \theta_t + \alpha \nabla_{\theta} ln\pi (a_t|s_t,\theta_t)[q_t(s_t,a_t) - v_{\pi}(s)] \]

    \[\delta_t(s,a) = q_t(s_t,a_t) - v_{\pi}(s) \tag{advantage function} \]

    我们称\(\delta_t(s,a)\) 为优势函数。更进一步,通过td算法可以把\(\delta\) 改写为

    \[\delta_t(s,a) = r_{t+1} + \gamma v(s_{t+1}) - v(s_t) \]

    对比QAC算法可以发现,A2C算法把值函数计算q值替换为了值函数计算v值,并且A2C总体上的效果会更好。

    • 推广到离线学习

      在以上学习Actor-Critic算法中,都是在线学习。但是如果有一些离线的数据,怎么使用Actor-Critic算法?

      • 重要性采样

        假设本地有一些数据\(x\)服从概率分布 \(p_1\)。则\(E(x) = \sum p_1(x_i)x_i\)。当我们需要计算这些数据服从概率分布 \(p_0\) 时的期望时有:

        \[E(x) = \sum \dfrac{p_1(x_i)}{p_0(x_i)}p_0(x_i)x_i \]

        \(f(x) = \dfrac{p_1(x_i)}{p_0(x_i)}x_i\)。则

        \[E(x) = \sum p_0(x_i)f(x_i) \]

        所以 \(f(x)\) 服从 概率分布 \(p_0\)

      在实际的应用过程中,离线的数据就是根据一定的概率分布生成,也就是我们已知概率分布 \(p_1\)。而实际上的策略函数就是概率分布 \(p_0\)。因此如果将Q2C算法推广到离线学习,修改迭代公式如下:

      \[\theta_{t+1} = \theta_t + \alpha \dfrac{\pi(a_t|s_t,\theta_t)}{\beta(a_t|s_t)} \nabla_{\theta} ln\pi (a_t|s_t,\theta_t)\delta_t(s_t,a_t) \]

  • DPG算法

    在上述的所有方法中,动作空间都是有限的。DPG算法将动作空间推广到连续的空间。

    定义 \(a = \mu(s,\theta)\) 其中 \(\mu\) 是一个函数,也可以是神经网络,\(\theta\) 是函数的参数。此时\(\theta\)的迭代公式如下(具体推导没有):

    \[\theta_{t+1} = \theta_t + \alpha_{\theta}\nabla_{\theta}\mu(s_t)(\nabla_{\alpha}q_{\mu}(s_t,\alpha))|_{\alpha=\mu(s_t)} \]

posted @ 2024-12-13 15:23  nagimegesa  阅读(287)  评论(0)    收藏  举报