绿色健康小清新

耐得住寂寞,守得住繁华

李宏毅机器学习-51-RL-01-Deep Reinforcement Learning

Deep Reinforcement Learning

2015年2月的时候,google在nature上发了一篇用reinforcement learning 的方法来玩akari的小游戏,然后痛鞭人类

2016的春天,又有大家都耳熟能详的alpha go,也是可以痛鞭人类

David Silver 说 AI 就是 Reinforcement Learning+Deep Learning Deep Reinforcement Learning : AI = RL + DL


Reference

  1. Textbook: Reinforcement Learning: An Introduction
  2. Lectures of David Silver
  3. Lectures of John Schulman

上面是一些学习资源,有兴趣的可以看看。

Example: Scenario of Reinforcement Learning(强化学习的应用场景)

在Reinforcement Learning里面会有一个Agent跟一个Environment。这个Agent会有Observation看到世界种种变化,这个Observation又叫做State,这个State指的是环境的状态,也就是你的machine所看到的东西。所以在这个Reinforcement Learning领域才会有这个XXX做法,我们的state能够观察到一部分的情况,机器没有办法看到环境所有的状态,所以才会有这个partial of state 这个想法,这个state其实就是Observation。machine会做一些事情,它做的事情叫做Action,Action会影响环境,会跟环境产生一些互动。因为它对环境造成的一些影响,它会得到Reward,这个Reward告诉它,它的影响是好的还是不好的。看下图:

举个例子,比如机器看到一杯水,然后它就take一个action,这个action把水打翻了,Environment就会得到一个negative的reward,告诉它不要这样做,它就得到一个负向的reward。

在Reinforcement Learning这些动作都是连续的,因为水被打翻了,接下来它看到的就是水被打翻的状态,它会take另外一个action,决定把它擦干净,Environment觉得它做得很对,就给它一个正向的reward。

机器生来的目标就是要去学习采取那些action,可以让maximize expected reward

接着,以alpha go为例子:

一开始machine的Observation是棋盘,棋盘可以用一个19*19的矩阵来描述,接下来,它要take一个action,这个action就是落子的位置。落子在不同的位置就会引起对手的不同反应,对手下一个子,Agent的Observation就变了。Agent看到另外一个Observation后,就要决定它的action,再take一个action,落子在另外一个位置。

用机器下围棋就是这么个回事。在围棋这个case里面,还是一个蛮难的Reinforcement Learning,在多数的时候,你得到的reward都是0,落子下去通常什么事情也没发生这样子。只有在你赢了,得到reward是1,如果输了,得到reward是-1。Reinforcement Learning困难的地方就是有时候你的reward是sparse的,只有倒数几步才有reward。即在只有少数的action 有reward的情况下去挖掘正确的action。

对于machine来说,它要怎么学习下围棋呢,就是找一某个对手一直下下,有时候输有时候赢,它就是调整Observation和action之间的关系,调整model让它得到的reward可以被maximize。

Supervised vs Reinforcement Learning(监督 vs 强化)

我们可以比较下下围棋采用Supervised 和Reinforcement 有什么区别。

如果是Supervised 你就是告诉机器说看到什么样的态势就落在指定的位置。Supervised不足的地方就是具体态势下落在哪个地方是最好的,其实人也不知道,因此不太容易做Supervised。用Supervised就是machine从老师那学,老师说下哪就下哪。

如果是Reinforcement 呢,就是让机器找一个对手不断下下,赢了就获得正的reward,没有人告诉它之前哪几步下法是好的,它要自己去试,去学习。Reinforcement 是从过去的经验去学习,没有老师告诉它什么是好的,什么是不好的,machine要自己想办法,其实在做Reinforcement 这个task里面,machine需要大量的training,可以两个machine互相下。alpha Go 是先做Supervised Learning,做得不错再继续做Reinforcement Learning。


applications(应用)

Learning a chat-bot

Reinforcement Learning 也可以被用在Learning a chat-bot。chat-bot 是seq2seq,input 就是一句话,output 就是机器的回答。

其实这块内容我们之前再讲GAN对于Sequence Generation的提高的时候也说过了:👉 机器学习-42-Improving Sequence Generation by GAN(通过GAN提高Sequence的生成)我们这里再简单说一下吧!

如果采用Supervised ,就是告诉机器有人跟你说“hello”,你就回答“hi”。如果有人跟你说“bye bye”,你就要说“good bye”。

如果是Reinforcement Learning 就是让机器胡乱去跟人讲话,讲讲,人就生气了,machine就知道一句话可能讲得不太好。不过没人告诉它哪一句话讲得不好,它要自己去发掘这件事情。

这个想法听起来很crazy,但是真正有chat-bot是这样做的,这个怎么做呢?因为你要让machine不断跟人讲话,看到人生气后进行调整,去学怎么跟人对话,这个过程比较漫长,可能得好几百万人对话之后才能学会。这个不太现实,那么怎么办呢,就用Alpha Go的方式,Learning 两个agent,然后让它们互讲的方式。

两个chat-bot互相对话,对话之后有人要告诉它们它们讲得好还是不好。在围棋里比较简单,输赢是比较明确的,对话的话就比较麻烦,你可以让两个machine进行无数轮互相对话,问题是你不知道它们这聊天聊得好还是不好,这是一个待解决问题。比如上图中:右边还好,左边就会陷入无限的“See you”循环!

现有的方式是制定几条规则,如果讲得好就给它positive reward ,讲得不好就给它negative reward,好不好由人主观决定,然后machine就从它的reward中去学说它要怎么讲才是好,看下图:

👉 Deep Reinforcement Learning for Dialogue Generation

后续可能会有人用GAN的方式去学chat-bot。通过discriminator判断是否像人对话,两个agent就会想骗过discriminator,即用discriminator自动认出给reward的方式。我们之前讲GAN的时候也说过了大概做法

Reinforcement Learning 有很多应用,尤其是人也不知道怎么做的场景非常适合。

More applications

Reinforcement Learning 还有很多应用,比如开个直升机,开个无人车呀,也有通过deepmind帮助谷歌节电,也有文本生成等。

  1. Flying Helicopter

  2. Driving

  3. Robot

  4. Google Cuts Its Giant Electricity Bill With DeepMind-Powered Al(AI省电)

  5. Text generation

在翻译上,翻译的结果其实没有固定的正确答案,因此用RL比普通的监督学习应该结果要好。

现在Reinforcement Learning最常用的场景是电玩。现在有现成的environment,比如Gym,Universe。让machine 用Reinforcement Learning来玩游戏,注意这跟我们游戏中的挂机是不一样的!跟人一样,它看到的东西就是一幅画面,就是pixel,然后看到画面,它要做什么事情它自己决定,并不是写程序告诉它说你看到这个东西要做什么。需要它自己去学出来。我们接下来也会举一个例子!

Interactive retrieval(交互搜索)

让machine学会做Interactive retrieval,意思就是说有一个搜寻系统,能够跟user进行信息确认的方式,从而搜寻到user所需要的信息。直接返回user所需信息,它会得到一个positive reward,然后每问一个问题,都会得到一个negative reward。

Example: Playing Video Game

现在Reinforcement Learning最常用的场景是电玩。现在有现成的environment,比如Gym,Universe。让machine 用Reinforcement Learning来玩游戏,注意这跟我们游戏中的挂机是不一样的!它跟人一样,它看到的东西就是一幅画面,就是pixel,然后看到画面,它要做什么事情它自己决定,并不是写程序告诉它说你看到这个东西要做什么。

这里以Space invader的游戏来举例!

游戏的终止条件时当所有的外星人被消灭或者你的太空飞船被摧毁。

这个游戏里面,你可以take的actions有三个:左移动,右移动和开火。

怎么玩呢,machine会看到一个observation,这个observation就是一幕画面。

一开始machine看到一个observation s1s_1,这个s1s_1 其实就是一个matrix,因为它有颜色,所以是一个三维的pixel。machine看到这个画面以后,就要决定它take什么action,现在只有三个action可以选择。比如它take 往右移。每次machine take一个action以后,它会得到一个reward,这个reward就是左上角的分数。往右移不会得到任何的reward,所以得到的reward r1=0r_1=0,machine 的action会影响环境,所以machine看到的observation就不一样了。

现在observation为 s2s_2 ,machine自己往右移了,同时外星人也有点变化了,这个跟machine的action是没有关系的,有时候环境会有一些随机变化,跟machine无关。machine看到s2s_2 之后就要决定它要take哪个action,假设它决定要射击并成功的杀了一只外星人,就会得到一个reward,发现杀不同的外星人,得到的分数是不一样的。假设杀了一只5分的外星人,这个observation就变了,少了一只外星人。

这个过程会一直进行下去,直到machine的reward rTr_T 进入另一个step,这个step是一个terminal step,它会让游戏结束,在这个游戏背景里面就是你被杀死。可能这个machine往左移,不小心碰到alien的子弹,就死了,游戏就结束了。

从这个游戏的开始到结束,就是一个episode,machine要做的事情就是不断的玩这个游戏,学习怎么在一个episode里面怎么去maximize reward,maximize它在所有的episode可以得到的total reward。在死之前杀最多的外星人同时要闪避子弹,让自己不会被杀死。

强化学习的难点

那么Reinforcement Learning的难点在哪里呢?它有两个难点

  • Reward delay

    第一个难点是,reward出现往往会存在delay,比如在space invader里面只有开火才会得到reward,但是如果machine只知道开火以后就会得到reward,最后learn出来的结果就是它只会乱开火。对它来说,往左往右移没有任何reward。事实上,往左往右这些moving,它对开火是否能够得到reward是有关键影响的。虽然这些往左往右的action,本身没有办法让你得到任何reward,但它帮助你在未来得到reward,就像规划未来一样,machine需要有这种远见,要有这种visual,才能把电玩玩好。在下围棋里面,有时候也是一样的,短期的牺牲可以换来最好的结果。

  • Agent’s actions affect the subsequent data it receives

    Agent采取行动后会影响之后它所看到的东西,所以Agent要学会去探索这个世界。比如说在这个space invader里面,Agent只知道往左往右移,它不知道开火会得到reward,也不会试着击杀最上面的外星人,就不会知道击杀这个东西可以得到很高的reward,所以要让machine去explore它没有做过的行为,这个行为可能会有好的结果也会有坏的结果。但是探索没有做过的行为在Reinforcement Learning里面也是一种重要的行为。

强化学习的方法

Reinforcement Learning 的方法分成两大块,一个是Policy-based的方法,另一个是Valued-based的方法。注意是先有Valued-based的方法,再有Policy-based的方法。

在Policy-based的方法里面,会learn一个负责做事的Actor,在Valued-based的方法会learn一个不做事的Critic,专门批评不做事的人。我们要把Actor和Critic加起来叫做Actor+Critic的方法。

现在最强的方法就是Asynchronous Advantage Actor-Critic(A3C)。Alpha Go是各种方法大杂烩,有Policy-based的方法,有Valued-based的方法,有model-based的方法。

model-based的方法这里没有讲,这个方法主要用在棋类游戏,预测未来的棋局之类的,棋局走下一步的结果种类是有限。

Policy-based方法

先来看看怎么学一个Actor,所谓的Actor是什么呢?我们之前讲过,Machine Learning 就是找一个Function,Reinforcement Learning也是Machine Learning 的一种,所以要做的事情也是找Function。这个Function就是所谓的魔术发现,Actor就是一个Function。这个Function的input就是Machine看到的observation,它的output就是Machine要采取的Action。我们要透过reward来帮我们找这个best Function。

找个这个Function有三个步骤:

相信这三个步骤你已经不陌生了,我们前面也已经多次提及了!

步骤一:Neural Network as Actor

第一个步骤就是决定你的Function长什么样子,假设你的Function是一个Neural Network,就是一个deep learning。

如果Neural Network作为一个Actor,这个Neural Network的输入就是observation,可以通过一个vector或者一个matrix 来描述。output就是你现在可以采取的action。

举个例子,Neural Network作为一个Actor,input是一张image,output就是你现在有几个可以采取的action,output就有几个dimension。假设我们在玩Space invader,output就是可能采取的action左移、右移和开火,这样output就有三个dimension分别代表了左移、右移和开火。

这个Neural Network怎么决定这个Actor要采取哪个action呢?通常的做法是这样,你把这个image丢到Neural Network里面去,它就会告诉你说每个output dimension所对应的几率,可以采取几率最高的action,比如说left。

用这个Neural Network来做Actor有什么好处,Neural Network是可以举一反三的,可能有些画面Machine 从来没有看过,但是Neural Network的特性,你给它一个image,Neural Network吐出一个output。所以就算是它没看过的东西,它output可以得到一个合理的结果。Neural Network就是比较generous。

步骤二:Goodness of Actor(决定function的好坏)

第二步骤就是,我们要决定一个Actor的好坏。在Supervised learning中,我们是怎样决定一个Function的好坏呢?举个Training Example例子来说,我们把图片扔进去,看它的结果和target是否像,如果越像的话这个Function就会越好,我们会一个loss,然后计算每个example的loss,我们要找一个参数去minimize这个参数。

在Reinforcement Learning里面,一个Actor的好坏的定义是非常类似的。假设我们现在有一个Actor,这个Actor就是一个Neural Network,Neural Network的参数是θ\theta ,即一个Actor可以表示为πθ(s)\pi_{\theta}(s) ,它的input就是Mechine看到的observation。

那怎么知道一个Actor表现得好还是不好呢?我们让这个Actor实际的去玩一个游戏,玩完游戏得到的total reward为 Rθ=t=1TrTR_{\theta} = \sum^T_{t=1}r_T ,把每个时间得到的reward合起来,这即是一个episode里面,你得到的total reward。这个total reward才是我们需要去maximize的对象。我们不需要去maximize 每个step的reward,我们是要maximize 整个游戏玩完之后的total reward。

假设我们拿同一个Actor,每次玩的时候,RθR_{\theta} 其实都会不一样的。因为两个原因,首先你Actor本身如果是Policy,看到同样的场景它也会采取不同的Action。所以就算是同一个Actor,同一组参数,每次玩的时候你得到的RθR_{\theta} 也会不一样的。再来游戏本身也有随机性,就算你采取同一个Action,你看到的observation每次也可能都不一样。所以是一个RθR_{\theta}Random Variable。我们做的事情,不是去maximize每次玩游戏时的RθR_{\theta},而是去maximize RθR_{\theta}的期望值。这个期望值就衡量了某一个Actor的好坏,好的Actor期望值就应该要比较大。

这里看的有点懵没关系,我们接下来会详细说明!

我们假设一场游戏就是一个trajectory τ\tau

τ={s1,a1,r1,s2,a2,r2,,sT,aT,rT}\tau = \{ s_1,a_1,r_1,s_2,a_2,r_2,\cdot\cdot\cdot,s_T,a_T,r_T\}

τ\tau包含了state,看到这个observation,take的Action,得到的Reward,是一个sequence,它们之间的关系可以看下面这张图:

其实在参数θ\theta下,发生一个τ\tau是一个概率事件:

计算概率的思想就是起始状态是s1s_1的概率p(s1)p(s_1) ,乘以在s1s_1 时选择Action a1a_1的概率p(a1s1,θ)p(a_1|s_1,\theta) 之后再乘以在s1s_1a1a_1之后进入到s2s_2和获得reward r1r_1的概率p(s2,21s1,a1)p(s_2,2_1 |s_1,a_1 )以此类推,最终得到:

P(τθ)=p(s1)t=1Tp(atst,θ)p(rt,st+1st,at)P(\tau|\theta) = p(s_1)\prod_{t=1}^Tp(a_t|s_t,\theta)p(r_t,s_{t+1}|s_t,a_t)

其实上个式子中,只有p(atst,θ)p(a_t|s_t,\theta)是跟θ\theta 有关的,接下来我们求梯度的时候也只需要考虑这一项即可,这里有点印象进行,我们接下来会详解!

R(τ)R(\tau) 代表在这个episode里面,最后得到的总reward:

R(τ)=n=1NrnR(\tau) = \sum^N_{n=1}r_n

当我们用某一个Actor去玩这个游戏的时候,每个τ\tau 都会有出现的几率,τ\tau 代表从游戏开始到结束过程,这个过程有千百万种,当你选择这个Actor的时候,你可能只会看到某一些过程,某些过程特别容易出现,某些过程比较不容易出现。

每个游戏出现的过程,可以用一个几率P(τθ)P(\tau|\theta)来表示它,就是说参数是θ\thetaτ\tau 这个过程出现的几率。那么RθR_{\theta}的期望值为:

Rθ=τR(τ)P(τθ)\overline{R_{\theta}} = \sum_{\tau}R(\tau)P(\tau|\theta)

实际上要穷举所有的τ\tau 是不可能的,那么要怎么做?

让Actor去玩N场这个游戏,获得N个过程{τ1,τ2,...,τN}\{\tau^1,\tau^2,...,\tau^N\} ,玩N场就好像从P(τθ)P(\tau|\theta) 去Sample N个τ\tau 。假设某个τ\tau 它的几率特别大,就特别容易被sample出来。sample出来的τ\tau 跟几率成正比。让Actor去玩N场,相当于从P(τθ)P(\tau|\theta)概率场抽取N个过程,可以通过N各Reward的均值进行近似,如下表达:

Rθ=τR(τ)P(τθ)1Nn=1NR(τN)\overline{R_{\theta}} = \sum_{\tau}R(\tau)P(\tau|\theta) ≈ \frac{1}{N}\sum_{n=1}^NR(\tau^N)

我们最终的目标其实就是MaximizeRθ\overline{R_{\theta}}

步骤三:Pick the best function

怎么选择最好的function,其实就是用我们的Gradient Ascent。我们已经找到目标了,就是最大化这个Rθ\overline{R_{\theta}}

Rθ=τR(τ)P(τθ)1Nn=1NR(τN)\overline{R_{\theta}} = \sum_{\tau}R(\tau)P(\tau|\theta) ≈ \frac{1}{N}\sum_{n=1}^NR(\tau^N)

可以用Gradient Ascent进行最大化,过程为:

  1. 初始化θ0\theta^ 0
  2. θ1θ0+ηRθ0\theta^1 \leftarrow \theta^0 +\eta\bigtriangledown\overline{R_{\theta^0}}
  3. θ2θ1+ηRθ1\theta^2 \leftarrow \theta^1 +\eta\bigtriangledown\overline{R_{\theta^1}}
  4. ……

其中,参数θ=w1,w2,...b1,...\theta = w_1,w_2,...b_1,...,那么Rθ\bigtriangledown\overline{R_{\theta}}就是Rθ\overline{R_{\theta}}对每个参数的偏微分,如下:

Rθ=[Rθ/w1Rθ/w2Rθ/b1]\bigtriangledown\overline{R_{\theta}} = \left[ \begin{matrix} \partial \overline{R_{\theta}}/\partial w_1 \\ \partial \overline{R_{\theta}}/\partial w_2 \\ \vdots \\ \partial \overline{R_{\theta}}/\partial b_1 \\ \vdots \end{matrix} \right]

接下来就是实际的计算下,前面我们已经知道了 Rθ=τR(τ)P(τθ)1Nn=1NR(τN)\overline{R_{\theta}} =\sum_{\tau}R(\tau)P(\tau|\theta) ≈ \frac{1}{N}\sum_{n=1}^NR(\tau^N),如果直接对最终的结果求Gradient显然是求不出来的。我们要用Rθ=τR(τ)P(τθ)\overline{R_{\theta}} = \sum_{\tau}R(\tau)P(\tau|\theta)来求,而在这个式子中,只有P(τθ)P(\tau|\theta)θ\theta有关系,所以只需要对P(τθ)P(\tau|\theta)做Gradient,即:

Rθ=tR(τ)P(τθ)\bigtriangledown\overline{R_{\theta}} = \sum_tR(\tau)\bigtriangledown P(\tau|\theta)

所以R(τ)R(\tau) 就算不可微也没有关系,或者是不知道它的function也没有差,我们只要知道把τ\tau 放进去得到值就可以。

进一步计算:

Rθ=tR(τ)P(τθ)=τR(τ)P(τθ)P(τθ)P(τθ)\begin{aligned} \bigtriangledown\overline{R_{\theta}} = & \sum_tR(\tau)\bigtriangledown P(\tau|\theta) \\ =& \sum_{\tau}R(\tau)P(\tau|\theta)\frac{\bigtriangledown P(\tau|\theta)}{P(\tau|\theta)} \end{aligned}

根据以下公式:

logf(x)=dlog(f(x))dx=1f(x)df(x)dx=f(x)f(x)▽logf(x) = \frac{dlog(f(x))}{dx} = \frac{1}{f(x)} \frac{df(x)}{dx} = \frac{▽f(x)}{f(x)}

将公式转换为:

Rθ=tR(τ)P(τθ)=τR(τ)P(τθ)P(τθ)P(τθ)=τR(τ)P(τθ)logP(τθ)1Nn=1NR(τn)logP(τnθ)\begin{aligned} \bigtriangledown\overline{R_{\theta}} = & \sum_tR(\tau)\bigtriangledown P(\tau|\theta) \\ =& \sum_{\tau}R(\tau)P(\tau|\theta)\frac{\bigtriangledown P(\tau|\theta)}{P(\tau|\theta)}\\ = & \sum_{\tau}R(\tau)P(\tau|\theta)\bigtriangledown logP(\tau|\theta) \\ ≈ & \frac{1}{N}\sum_{n=1}^NR(\tau^n)\bigtriangledown logP(\tau^n|\theta) \end{aligned}

上面最后一步是通过抽样的方式去近似!

这里我们思考一个问题,为什么最后求的logP(τnθ)\bigtriangledown logP(\tau^n|\theta)要加个log?换一种说法,为什么我们求P(τθ)\bigtriangledown P(\tau|\theta)的时候要除以一个P(τθ)P(\tau|\theta)?下面会给出答案!

即拿θ\theta去玩N次游戏,得到{τ1,τ2,...τN}\{\tau^1,\tau^2,...\tau^N\},算出每次的R(τ)R(\tau) 。我们接下来的问题是怎么计算logP(τnθ)\bigtriangledown logP(\tau^n|\theta)!其实我们前面已经算出了P(τnθ)P(\tau^n|\theta),假设一个τ\tau

τ={s1,a1,r1,s2,a2,r2,,sT,aT,rT}\tau = \{ s_1,a_1,r_1,s_2,a_2,r_2,\cdot\cdot\cdot,s_T,a_T,r_T\}

那么:

P(τθ)=p(s1)t=1Tp(atst,θ)p(rt,st+1st,at)P(\tau|\theta) = p(s_1)\prod_{t=1}^Tp(a_t|s_t,\theta)p(r_t,s_{t+1}|s_t,a_t)

通过取log,连乘转为连加,即:

logP(τθ)=log p(s1)+t=1Tlog p(atst,θ)+log p(rt,st+1st,at)logP(\tau|\theta) = log\ p(s_1) + \sum_{t=1}^Tlog \ p(a_t|s_t,\theta)+log\ p(r_t,s_{t+1}|s_t,a_t)

其实我们前面也说了,只有p(atst,θ)p(a_t|s_t,\theta) 这一项跟θ\theta是有关的,因此在计算梯度的时候,我们另外两项可以直接删掉,从而得到:

logP(τθ)=t=1Tlog p(atst,θ)\bigtriangledown logP(\tau|\theta) =\sum_{t=1}^Tlog \ p(a_t|s_t,\theta)

则我们最终求的梯度就是:

Rθ1Nn=1NR(τn)logP(τnθ)=1Nn=1NR(τn)t=1Tnlog p(atst,θ)=1Nn=1Nt=1TnR(τn)log p(atst,θ)\begin{aligned} \bigtriangledown\overline{R_{\theta}} & ≈ \frac{1}{N}\sum_{n=1}^NR(\tau^n)\bigtriangledown logP(\tau^n|\theta) \\ & = \frac{1}{N}\sum_{n=1}^NR(\tau^n)\sum_{t=1}^{T_n}log \ p(a_t|s_t,\theta) \\ & = \frac{1}{N}\sum_{n=1}^N\sum_{t=1}^{T_n}R(\tau^n)log \ p(a_t|s_t,\theta) \end{aligned}

然后更新参数θ\theta

θnewθold+ηRθold\theta^{new} \leftarrow \theta^{old} + \eta \bigtriangledown\overline{R}_{\theta^{old}}

Rθ\bigtriangledown\overline{R_{\theta}}的式子就告诉我们,当我们在某一次τn\tau^n 游戏中,

  • stns_t^n状态下采取at2a_t^2得到R(τn)R(\tau^n)是正的,我们就希望θ\theta能够使p(atnstn)p(a_t^n|s_t^n)的概率越大越好
  • 反之,如果R(τn)R(\tau^n)是负的,就要调整θ\theta参数,能够使p(atnstn)p(a_t^n|s_t^n)的几率变小

四个问题(※)

Rθ\bigtriangledown\overline{R_{\theta}}中的R(τn)R(\tau^n)能否换成rtnr_t^n

不能!某个时间点的p(atnstn,θ)p\left(a_{t}^{n} | s_{t}^{n}, \theta\right)是乘上这次游戏的所有reward R(τn)R(\tau^n)而不是这个时间点的reward。假设我们只考虑这个时间点的reward,那么就是说只有fire才能得到reward,其他的action你得到的reward都是0。Machine就只会增加fire的几率,不会增加left或者right的几率。最后Learn出来的Agent它就会fire。


我们之前挖了一个坑:为什么最后求的logP(τnθ)\bigtriangledown logP(\tau^n|\theta)要加个log?换一种说法,为什么我们求P(τθ)\bigtriangledown P(\tau|\theta)的时候要除以一个P(τθ)P(\tau|\theta)

假设某个state s在τ13,τ15,τ17,τ33\tau^{13},\tau^{15},\tau^{17},\tau^{33},采取不同的action,获得不同的reward,会偏好出现次数比较多的action,但是次数比较多的action有时候并没有比较好,就像b出现的比较多,但是得到的reward并没有比较大,Machine把这项几率调高。除掉一个几率,就是对那项做了个normalization,防止Machine偏好那些出现几率比较高的项。


假设reward R(τn)R(\tau^n)总是正的,那么会出现什么事情呢?

在理想的状态下,这件事情不会构成任何问题。假设有三个action,a,b,c采取的结果得到的reward都是正的,这个正有大有小(作图绿色),假设a和c的R(τn)R(\tau^n)比较大,b的R(τn)R(\tau^n)比较小,经过update之后,你还是会让b出现的几率变小,a,c出现的几率变大,因为会做normalization。


实做的时候,我们做的事情是sampling,所以有可能只sample b和c,这样b,c几率都会增加,a没有sample到,几率就自动减少,这样就会有问题了!

这样,我们就希望R(τn)R(\tau^n)有正有负这样,可以通过将R(τn)bR(\tau^n)-b来避免,bb需要自己设计(事实上,这个b是一个network的output。)。如下:

Rθ1Nn=1Nt=1Tn(R(τn)b)log p(atst,θ)\begin{aligned} \bigtriangledown\overline{R_{\theta}} ≈ \frac{1}{N}\sum_{n=1}^N\sum_{t=1}^{T_n}(R(\tau^n)-b)log \ p(a_t|s_t,\theta) \end{aligned}

这样R(τn)R(\tau^n)超过b的时候就把几率增加,小于b的时候就把几率降低,从而解决了都是正的问题。


两个技巧(※)

下面讲的是对于reward计算的两个技巧:

其中一个技巧我们上面已经说了,就是加一个Baseline:

Rθ1Nn=1Nt=1Tn(R(τn)b)log p(atst,θ)\begin{aligned} \bigtriangledown\overline{R_{\theta}} ≈ \frac{1}{N}\sum_{n=1}^N\sum_{t=1}^{T_n}(R(\tau^n)-b)log \ p(a_t|s_t,\theta) \end{aligned}

还有一个就是assign suitable credit:

这个意思就是(sba2)(s_b,a_2)的 r 和(saa1)(s_a,a_1)的 r 是没有任何关系的,但是假设总是从头开始计算的话,R的结果将总是被(saa1)(s_a,a_1) 来左右,所以我们就不再从头开始算,而是计算哪个(sa)(s,a) 对,就从哪里开始计算,这样更加准确:

Rθ1Nn=1Nt=1Tn(t=tTnrtnb)log p(atst,θ)\begin{aligned} \bigtriangledown\overline{R_{\theta}} ≈ \frac{1}{N}\sum_{n=1}^N\sum_{t=1}^{T_n}(\sum_{t'=t}^{T_n}r_{t'}^{n}-b)log \ p(a_t|s_t,\theta) \end{aligned}

其实还可以进一步优化:

Rθ1Nn=1Nt=1Tn(t=tTnγttrtnb)log p(atst,θ)       (γ<1)\begin{aligned} \bigtriangledown\overline{R_{\theta}} ≈ \frac{1}{N}\sum_{n=1}^N\sum_{t=1}^{T_n}(\sum_{t'=t}^{T_n}γ^{t'-t}r_{t'}^{n}-b)log \ p(a_t|s_t,\theta) \ \ \ \ \ \ \ (γ<1) \end{aligned}

时间的衰减度也是很重要的,所以每每下一步都要乘上这个衰减度。意思就是越往后的pair所获得的reward受当前的影响越小!

事实上,这个b是一个network的output。并且(t=tTnγttrtnb)(\sum_{t'=t}^{T_n}γ^{t'-t}r_{t'}^{n}-b)我们可以用一个Advantage Function:$r_{t}{n}+V{\pi}\left(s_{t+1}{n}\right)-V{\pi}\left(s_{t}^{n}\right) $来代替:

Rˉθ1Nn=1Nt=1Tn(rtn+Vπ(st+1n)Vπ(stn))logpθ(atnstn)\nabla \bar{R}_{\theta} \approx \frac{1}{N} \sum_{n=1}^{N} \sum_{t=1}^{T_{n}}\left(r_{t}^{n}+V^{\pi}\left(s_{t+1}^{n}\right)-V^{\pi}\left(s_{t}^{n}\right)\right) \nabla \log p_{\theta}\left(a_{t}^{n} \mid s_{t}^{n}\right)

上面这个式子其实是policy-based和value-based结合使用而产生的,也就是Actor-Critic!


Policy-based的另一种描述

看这个之前请务必先看完上面的Policy-based!

我们看以看policy gradient的具体过程,就是先有一个策略θ\theta ,之后用这个策略来收获很多数据:(s11,a11)(s_1^1,a_1^1)(s12,a12)(s_1^2,a_1^2)等,(s11,a11)(s_1^1,a_1^1)的reward 是R(τ1)R(\tau^1)(s12,a12)(s_1^2,a_1^2)的reward 是R(τ2)R(\tau^2)

用得到的数据来计算梯度,之后再用梯度上升来求得新的θ\theta ,用更新的θ\theta 再来获取数据,之后再更新θ\theta,如此巡回反复。

我们可以将它想成是一个classifier:

输入当前的state,通过neural network(Actor)会得到一个one hot,代表着每种action的几率。

通过Actor得到的yiy_i和我们的目标的y^i\hat{y}_i可以计算交叉熵,我们的目标就是最小化这个交叉熵;

换句话说,我们的目标就是在当前state(input)的情况下,action为"left"的几率越大越好!

综合上面的介绍,你可以想像有一个机构会将我们的输出和预期的结果进行比较得到一个action的reward,从而更新参数,1我们看下面的例子:

我们sample的数据是一个(stn,atn)(s_t^n,a_t^n)的pair

  • stns_t^n 是一个state
  • atna_t^n是当前state,θ\theta下的目标action

我们的stns_t^n通过neural network (Actor)会得到每个action的几率,然后使这个几率尽可能的接近我们的目标vector。

上图中的(s11,a11)(s_1^1,a_1^1),将state s11s_1^1输入actor,就会得到相应的action 为(“left”,“right”,“fire”)的几率,而我们的目标action a11a_1^1 是“left” ,因此它的vector就是(1,0,0),我们要做的就是使这两个vector越近越好!

你可能会问:这不就是分类问题了吗?

不是的,假设这是一个分类问题,我们其实还加了一个权值R(τn)R(\tau^n)

假设我们在τ1\tau^1下的reward 为 2,在τ2\tau^2下的reward为 1。看右下角的图:因为R(τ1)=2R(\tau^1)=2,如果是一个分类问题的话,就相当于将当前的梯度乘以2,因此我们就要拿这个pair train两次;类似的,因为R(τ2)=1R(\tau^2)=1,所以只要train一次。

因此,我们其实可以把一个classifier加个reward机构,就可以达到Reinforcement Learning了!

我们要做的就是sample数据,然后更新参数;sample数据,更新参数……注意这个和我们原始的classifier也有点不同,我们的classifier只要sample一次数据然后进行训练就可以了。

Value-based方法

Critic就是Learn一个Neural Network,这个Neural Network不做事,然后Actor可以从这个Critic中获得,这就是Q-learning。 Critic就是learn一个function,这个function可以告诉你说现在看到某一个observation的时候,这个observation有有多好这样。

  • 根据actor π\pi 评估critic function

    这个function是用Neural Network表示

  • state value function Vπ(s)V^\pi(s)

    这个累加的reward是通过观察多个observation

    那么如何估计 Vπ(s)V^\pi(s)呢?可以采用Monte-Carlo based approach。

  • State-action value function Qπ(s,a)Q^\pi(s,a)

    这个累加的reward是通过观察observation和take的action

Actor-Critic

-------------本文结束感谢您的阅读-------------
六经蕴籍胸中久,一剑十年磨在手

欢迎关注我的其它发布渠道