剖析强化学习 - 第六部分

以你之姓@ 2022-05-24 22:26 661阅读 0赞

作者：Massimiliano Patacchiola

你好！欢迎来到“解剖强化学习”系列的第六部分。到现在我们已经了解了强化学习如何工作。然而，我们将大部分技术应用于机器人清洁示例，我决定采用这种方法的原因，是因为我认为应用于不同技术的同一个例子，可以帮助读者更好地理解从一种场景到另一种场景的变化。现在是将这些知识应用于其他问题的时候了。在下面的每一节中，我将介绍一个强化学习问题，并且将向您展示如何解决它。首先我将解释应用程序背后的历史，然后将应用强化学习技术来解决，并使用Python实现它。我将遵循渐进的方法，从最简单的案例开始，到最复杂的案例。在这里，我们将使用一个离散化来表示效用和动作值函数，这意味着我将用矩阵表示这些函数（或者如果您愿意的话，可以使用查找表）。**离散化**是我们在这个系列中可以使用的唯一方法。在下一篇文章中，我将介绍函数逼近，它是处理复杂问题的强大工具。

![20180503213154192][]

这篇文章的参考文献是[Sutton和Barto的书][Sutton_Barto]（第11章，案例研究），以及Masashi Sugiyama[撰写的][Sutton_Barto][“统计强化学习”][Link 1]，其中包含我将要讲到的一些应用。在这篇文章中，**我想让你亲自参与这些项目！**有很多代码可以运行，参数可以更改，图形可以绘制，你应该通过亲自动手来学习。如果您拥有Github帐户，请将[Github存储库][Github]Fork[出来，][Link 2]如果您还没有，请[从这里][Link 2]下载最新的[zip存档][Link 2]。

## 多臂老虎机(Multi-Armed Bandit) ##

摇臂老虎机是在拉斯维加斯的一种奇特的老虎机，他们是*盗贼，*因为他们偷了你的钱！在20世纪50年代，Mosteller和Bush 研究[T型迷宫][T]对老鼠的奖励效应，为了比较与人类的表现，他们实现了双臂老虎机实验。受试者可以选择拉动左臂或右臂以获得奖励，两臂中的一个更加慷慨。

![20180503213225415][]

在这个实验中，受试者必须在**探索和利用****(exploration and exploitation)**之间找到一个很好的平衡点。让我们假设这个受试者玩了一轮，发现左臂更慷慨，下一步怎么办？你必须记住，机器是随机的，最好的一个可能不会在很短的一段时间内再回报奖品。受试者是否应探索看起来较差的选项或利用当前最佳选项？形式上，我们可以将这个问题定义为**具有单一状态**的**马尔可夫决策过程**（参见[第一篇文章][Link 3]）。有N个臂可以拉动，以及每个臂都以一定的概率返还奖励，有一个单一的状态和N个可能的动作（每个臂一个动作）。Agent在每一轮选择一只臂拉动，并获得奖励，Agent的目标是最大化奖励。多年来已经提出了许多解决多臂老虎机问题的办法。在接下来的文章中，我将向您展示其中的一些解决方案，并且我会根据经验向您展示从每个解决方案中获得的结果。

![20180503213242140][]

我将考虑的例子是N = 3，意味着我们有3种可能的动作（3只臂），我称这个例子为一个**三臂测试平台**。Sutton和Barto在[他们的书2.1章中][Sutton_Barto]已经考虑过类似的情况，但他们使用了一个10臂的老虎机和一个高斯分布来模拟奖励函数。在这里，我将使用[伯努利分布][Link 4]，这意味着奖励是0或1。从初始状态s0开始我们可以选择三只臂之一（A，B，C），第一只臂（A）以30％的概率返回1的正奖励，并且以70％的概率返回0，第二只臂（B）在50％的概率中返回正奖励，第三只臂（C）以80％的概率返回正奖励。每个动作的效用是：0.3,0.5,0.8，效用可以在运行时使用**action-utility (或 action-value) 方法**进行估计。如果动作a被选中ka次，导致一系列奖励r1,r2,...,rka，那么这个具体动作的效用可以通过以下方式来估计：

![20180503213304831][]

运行这个例子并尝试不同的策略是有帮助的，在运行之前，我们需要一种方法来衡量探索和利用。在接下来的部分中，我将使用**平均累计奖励**来量化**利用**，使用真实效用分布和平均估计之间的[均方根误差（RMSE）][RMSE]来量化**探索**。当RMSE和平均累计回报均较低时，Agent正在使用基于探索的策略;相反，当RMSE和平均累计回报均较高时，Agent正在使用基于利用的策略。为了简化我们的系统，我创建了一个名为multi\_armed\_bandit.py的Python模块，其中有一个类名为MultiArmedBandit。必须传递给对象的唯一参数是包含该概率∈\[0,1\]的列表，并获得正的奖励：

from multi_armed_bandit import MultiArmedBandit
    
    # Creating a bandit with 3 arms
    my_bandit = MultiArmedBandit(reward_probability_list=[0.3, 0.5, 0.8])

step()方法的输入参数是表示必须拉动臂的索引的动作。例如，调用my\_bandit.step(action=0)会拉动第一只臂，调用my\_bandit.step(action=2)会拉动第三只臂。step()方法返回拉动该臂获得的奖励，该值可以是1或0，该方法不返回任何其他内容。在t+1时返回状态或者代表终止状态的变量没有意义，因为正如我所说的那样，多臂老虎机具有单一状态。在接下来的小节中，我将向您展示一些可用于三臂测试平台的策略。

**无所不知(Omniscient)**：**无所不知**的词源于中世纪的拉丁文，它意味着*全知*。无所不知的agent在玩之前就知道效用的分配情况，并遵循最优策略。假设你在生产三臂老虎机的公司工作，您的职责是实现机器的固件，既然你是设计师，你完全知道这三臂中每一个的正回报的可能性。现在是度假的时间，你决定去拉斯维加斯，并进入一家赌场，你就能看到你设计的机器。你要去做什么？可能你会像疯了一样开始拉第三只臂（C），直到你的口袋里装满了硬币。你知道最好的办法是把重点放在第三只臂上，因为它有80％的概率返回正回报的可能性。现在让我们假设无所不知的agent玩了1000回合，最终获得的累积奖励会是多少？如果第三只臂有80％的概率获得一枚硬币，我们可以说在1000轮后，玩家将获得大约800枚硬币。请记住这个值，因为它是所有情况的上限。

**随机(Random)**：最直观的策略是随机策略。只需以相同的概率拉动任何一只臂，这是一个天真的赌徒的策略。让我们看看随机agent将以这种方式获得什么。我们可以在几行代码中创建一个随机agent：

from multi_armed_bandit import MultiArmedBandit
    import numpy as np
    
    my_bandit = MultiArmedBandit(reward_probability_list=[0.3, 0.5, 0.8])
    tot_arms = 3
    tot_steps = 1000
    cumulated_reward = 0
    print("Starting random agent...")
    for step in range(tot_steps):
        action = np.random.randint(low=0, high=tot_arms)
        reward = my_bandit.step(action)
        cumulated_reward += reward
    print("Cumulated Reward: " + str(cumulated_reward))

运行脚本将拉动臂1000次，获得的回报将累积在所调用的变量`cumulated_reward`中。我多次运行这个脚本（只需要几毫秒），我得到了527,551,533,511,538,540的累积奖励。在这里，我想让你对我们得到的结果进行推理,为什么所有累积奖励的价值在530左右？随机agent以几乎相同的概率拉动臂，这意味着它三分之一时间拉动了第一只臂，三分之一时间拉动第二只臂和三分之一的时间拉动第三只臂。最终得分可以近似如下：`300/3 +500/3 + 800/3 = 533.3`。请记住，这个过程是随机的，可能每次都有小的波动。为了消除这种波动，我重复2000次的脚本获得了2000次迭代的循环。

Average Cumulated Reward: 533.441
    Average utility distribution: [0.29912987  0.50015673  0.80060398]
    Average utility RMSE: 0.000618189621201

累计奖励的平均值为533.4，与我们所做的估计非常接近。同时，RMSE极低（0.0006），这意味着随机agent在方向上不平衡地使用探索而非利用。完整的代码在[官方存储库中][Github]名称是`random_agent_bandit.py`。

**贪婪(Greedy)**：执行贪婪策略的agent会在第一轮中拉动所有臂，然后选择回报最高奖励的臂。这个策略并不是真的鼓励探索，这并不奇怪。我们已经在[第二篇文章][Link 5]中看到，贪婪策略应该是更大规模的广义策略迭代（GPI）方案的一部分，以实现收敛。只有对效用函数进行持续更新，才有可能改进策略。一个使用贪婪策略的agent可能会被随机波动所愚弄，并且它可能认为第二只臂是最好的，因为在短期内它返回了更多的硬币。运行脚本执行2000个episode，每个episode有1000轮，我们得到：

Average cumulated reward: 733.153
    Average utility distribution: [0.14215225  0.2743839   0.66385142]
    Average utility RMSE: 0.177346151284

我们测试的结果是733，明显高于随机分数。我们说真正的效用分配是`[0.3, 0.5, 0.8]`。贪婪agent的平均使用分配`[0.14,0.27, 0.66]`和RMSE为0.18，这意味着它低估了效用，因为它的盲目策略不鼓励探索。在这里我们可以看到与随机agent相反的模式，意味着对于贪婪的玩家来说，平均奖励和RMSE都很高。

**Epsilon-greedy**：我们已经使用过这个策略。在每个时间步中，agent将以概率p=1−ϵ(利用)选择最慷慨的臂，以q=ϵ（探索）的概率随机选择另外臂的其中之一，epsilon 通常选择的值是ε=0.1。我创建了一个用于测试此agent的脚本，您可以在[官方存储库中][Github]找到该脚本，名称为`epsilon_greedy_agent_bandit.py`。使用等于0.1的epsilon值，并运行脚本1000个步骤和2000个episode，得到以下结果：

Average cumulated reward: 763.802
    Average utility distribution: [0.2934227   0.49422608  0.80003897]
    Average utility RMSE: 0.00505307354513

平均累计奖励是763，高于随机和贪婪的agent。随机探索有助于agent更近地收敛到真实的效用分布，导致RMSE较低（0.005）。

**Softmax-greedy**：在epsilon-greedy策略中，动作是从均匀分布随机抽取的。softmax采样更进一步，会带来更多的回报的动作被选择的概率更高。在讨论actor-critic方法时，我们已经在[第四篇文章中][Link 6]使用了softmax策略。这个策略的名字来自[softmax函数][softmax]，它可以很容易地在Python中实现：

def softmax(x):
        """Compute softmax distribution of array x. @param x the input array @return the softmax array """
        return np.exp(x - np.max(x)) / np.sum(np.exp(x - np.max(x)))

在softmax-greedy 策略中，我们选择概率为p=σ的最慷慨的臂，并以q=1−σ的概率选择其它的臂之一（使用softmax采样）。这种采样的效果是基于已经估计的效用分配来选择动作。如果第三只臂有较高的奖励机会，那么当需要随机选择动作时，softmax-greedy的agent将更频繁地选择该臂。以`sigma=0.1`运行python脚本，我们得到了以下结果：

Average cumulated reward: 767.249
    Average utility distribution: [0.29169784  0.49047397  0.79968229]
    Average utility RMSE: 0.00729776356239

767的结果略高于epsilon-greedy，但同时RMSE误差也略高。在增加利用的同时我们减少了探索。正如你所看到的，探索和利用之间有一种微妙的平衡，找到合适的权衡并不是那么直截了当。完整的代码包含在存储库中名称为`softmax_agent.py`。

**Epsilon-decreasing**：在epsilon-greedy算法中，我们必须选择一个随机动作，我们使用了一个固定的ε值0.1。然而，这并不总是一个好的选择，因为经过多轮调整后，我们对效用分配有了更准确的估计，我们可以减少探索。在减少策略中，我们设定在开始时ϵ = 0.1，在游戏中线性减少它。通过这种方式，agent将在开始时进行大量探索，并最终将重点放在最慷慨的臂上。脚本epsilon\_decresing\_agent\_bandit.py运行的策略具有线性递减的ε，从0.1开始，在episode的最后一步达到0.0001。运行脚本的结果是：

Average cumulated reward: 777.423
    Average utility distribution: [0.28969042  0.48967624  0.80007298]
    Average utility RMSE: 0.00842363169768

累计奖励的平均值为777，高于以前策略获得的分数。与此同时，效用分布接近原始值，但RMSE（0.008）略高于ε-greedy（0.005）。我们再次注意到探索和利用之间的平衡是多么微妙。

**波尔兹曼采样(Boltzmann sampling)**：该策略基于[softmax函数][softmax]，因此可以说它是softmax动作选择规则的一部分。在softmax采样动作中，导致更多奖励的采样概率更高。在Boltzmann采样中，使用softmax函数基于其它N个动作的概率来估计一个具体行动a的概率P(a)如下：

![20180503213716112][]

其中τ > 0是一个称为温度的参数。高温会产生一个分布，其中所有动作都具有大致相同的采样概率，而在τ →0的极限内动作选择变得贪婪。我们可以很容易地在Python中实现Boltzmann采样：

def boltzmann(x, temperature):
        """Compute boltzmann distribution of array x. @param x the input array @param temperature @return the boltzmann array """
        exponent = np.true_divide(x - np.max(x), temperature)
        return np.exp(exponent) / np.sum(np.exp(exponent))

函数`boltzmann()`接受一个数组和温度作为输入，并返回该数组的玻尔兹曼分布。一旦我们有了玻尔兹曼分布，我们可以使用Numpy方法`numpy.random.choice()`来采样一个动作。完整的脚本在[官方存储库项目中][Github]名为`boltzmann_agent_bandit.py`。运行脚本且τ从10线性降低到0.01导致以下结果：

Average cumulated reward: 648.0975
    Average utility distribution: [0.29889418  0.49732589  0.79993241]
    Average utility RMSE: 0.0016711564118

该策略达到了648分，这是迄今为止获得的最低分数，但效用分配的RMSE也是最低的（0.002）。改变温度衰减，我们可以看到性能是如何增加的，从0.5开始并减小到0.0001，我们得到以下结果：

Average cumulated reward: 703.271
    Average utility distribution: [0.29482691  0.496563    0.79982371]
    Average utility RMSE: 0.00358724122464

正如你所看到的，累计奖励显著增加，但同时增加了RMSE。像往常一样，我们必须找到适当的平衡点。现在让我们尝试一下初始温度为0.1，然后让它降低到0.0001：

Average cumulated reward: 731.722
    Average utility distribution: [0.07524908  0.18915708  0.64208991]
    Average utility RMSE: 0.239493838117

我们得到732分和RMSE 0.24，这与贪婪agent的得分非常接近（回报= 733，RMSE = 0.18）。这并不令人惊讶，因为如前所述，在τ →0的极限内动作的选择变得贪婪。Boltzmann采样保证了广泛的探索，这在大型空间中可能非常有用，然而它可能有一些缺点，在基于epsilon的策略中选择一个ϵ值通常很容易，但我们τ往往是不一样的，设置τ可能需要合适的手动调节，这在某些问题中并不总是可行的。我建议你用不同的温度值运行脚本来查看差异。

**Thompson采样**：为了理解这个策略，有必要了解[概率论][Link 7]和[贝叶斯统计的][Link 8]一些知识，特别是你应该知道最常见的概率分布以及[贝叶斯定理][Link 9]([Bayes’ theorem][Link 9])是如何工作的。在基于softmax的方法中，我们使用[频率方法][Link 10]([frequentist approach][Link 10])估计奖励概率。考虑到拉动每个臂获得的成功和失败的次数，我们估计了效用函数。从统计学的角度来看，效用函数是什么？效用函数是与老虎机臂相关的伯努利奖励分布的近似值。在频率分布情况下，伯努利分布是通过如下估计的[最大似然估计（MLE）][MLE]：

![20180503213837164][]

其中P(q)是特定臂的正奖赏的概率，s是成功的次数，f是失败的次数。你应该注意到这个方程和我们在开始时定义的Q函数之间的相似性。使用MLE不是最好的方法，因为当有少量样本时会引发问题。假设我们拉了第一只臂（A）两次，我们得到了两个正的奖励，在这种情况下，我们有s =2和f = 0导致P(q) = 1。这个估计是完全错误的，我们知道第一只臂以30％的概率返回正奖励，我们的估计表示它以100％的概率返回正奖励。在玻尔兹曼采样中，我们用温度参数部分抵消了这个误差，然而这种偏差可能会对最终分数产生影响。我们应该找到一种方法来根据当前可用的数据对伯努利分布进行最佳估计。使用贝叶斯方法，可以在每个臂的奖励分布的参数上定义先验分布，并根据作为最佳动作的后验概率来采样动作。这种方法被称为Thompson采样，[于1993年][1993]由[William Thompson][1993]发布。在三臂老虎机试验台中，我将老虎机定义为伯努利老虎机，这意味着每只臂给予的奖励是通过[伯努利分布][Link 4]([Bernoulli distribution][Link 4])获得的。每只臂都可以以成功的概率q返回正奖励，失败概率是1- q。根据定义，伯努利分布描述了单个实验的二元结果，例如掷单个硬币（0=尾部，1=头部）。这里我们感兴趣的是找到另一个分布，即P(q|s,f)，这在贝叶斯术语中被称为*后验*。知道后验我们就知道了哪个臂回报最高的奖励，我们可以像无所不知的agent一样。在这里我们必须小心，后验不是伯努利分布，因为它考虑到了s和f，这是一系列实验的成功/失败率。它是什么样的分布？我们怎么找到它？我们可以使用[贝叶斯定理][Link 9]。使用这个定理，我们可以根据前几轮收集的数据对后验进行最优近似。在这里我定义了s和f，它们是在以前的试验中为特定臂累计的成功和失败次数，以及q作为拉动该臂获得的正奖励的概率。后验可以通过贝叶斯定理估计如下：

![20180503213915520][]

从这个等式中可以清楚地看出，为了找到后验，我们需要P(s,f|q)（*似然*）和P(q)（*先验*）。我们从似然开始，正如我所说的伯努利分布代表了单个的实验结果,为了表示多个独立实验的结果，我们必须使用[二项式分布][Link 11]([Binomialdistribution][Link 11])。这种分布能够告诉我们在s \+ f试验中成功数量为s的概率是多少。分布表示如下：

![2018050321394924][]

太棒了，我们得到了第一个似然表达式，现在我们必须再找到先验。幸运的是伯努利分布有一个[共轭的先验][Link 12][分布][Link 13]([conjugate prior][Link 12])，即[Beta分布][Link 13]：

![20180503214003156][]

其中α,β>0是表示成功和失败率的参数，B是一个标准化常数（Beta函数），它可以确保概率归一化为1。现在我们有了所有的必须项，回到贝叶斯定理，我们可以用二项式分布替代似然，用Beta分布代替先验。经过一些化简后，我们得出以下结果：

![20180503214034348][]

如果你看看结果，你会发现我们的后验是另一个Beta分布，这对我们的问题来说是非常清晰的解决方案。为了获得给定臂的正奖励的概率，我们只需简单地把参数 (α\+s,β\+f)带入Beta分布中。这种方法的主要优点是，当成功和失败的次数增加时，我们将有更好的后验估计。例如，假设我们从α = β =1开始这意味着我们假设先前是一个平均分布，这是合理的，因为我们以前没有任何关于臂的知识。假设我们拉动臂三次，并获得两次成功和一次失败，我们可以通过Beta(α\+2,β\+1)得到该臂的伯努利分布的估计值，这是我们在三轮之后可以得到的最好的估计。当我们继续玩下去，后验会变得越来越准确。Thompson采样也可以用于非伯努利分布。如果奖励是通过[多项分布][Link 14]建模的，我们可以使用[Dirichlet分布][Dirichlet]作为共轭；如果奖励被建模为[高斯分布，][Link 15]我们可以使用高斯本身作为共轭。

在Python中，我们可以轻松实现三臂老虎机测试平台的Thompson agent。有必要在两个Numpy数组中记录成功和失败次数，这些数组传递给以下函数：

def return_thompson_action(success_counter_array, failure_counter_array):
        """Return an action using Thompson sampling @param success_counter_array (alpha) success rate for each action @param failure_counter_array (beta) failure rate for each action @return the action selected """
        beta_sampling_array = np.random.beta(success_counter_array, 
                                             failure_counter_array)
        return np.argmax(beta_sampling_array)

Numpy实现了numpy.random.beta()输入两个数组(α\+s,β\+f)并返回一个包含从基本Beta分布中采样的值的数组。一旦我们有了这个数组，我们只需要使用np.argmax()获得最高价值的动作，这对应于奖励概率最高的臂。运行脚本thompson\_agent\_bandit.py我们得到以下结果：

Average cumulated reward: 791.21
    Average utility distribution: [0.39188487  0.50654831  0.80154085]
    Average utility RMSE: 0.0531917417346

获得的平均积分奖励为791，这是迄今为止达到的最高分数，并且非常接近无所不知玩家的最优策略，同时，效用分布的RMSE（0.05）也相当低。Thompson采样似乎是平衡探索和利用的完美策略，但也有一些缺点，在我们的例子中，我们使用了伯努利分布作为后验分布，但这过分简化。当底层函数完全未知时，对后验分布进行逼近可能很困难，而且对后验的评估需要一个可能在计算上非常昂贵的集成。

![20180503214225434][]

比较条形图上不同策略的结果，我们可以一目了然地获得所获得的性能。Thompson采样似乎是得分方面最好的策略，但实际上很难应用。Softmax-greedy和epsilon-greedy非常相似，选择一个或另一个取决于你想鼓励多少探索。epsilon-decreesing策略大多数时候是一个安全的选择，因为它已被广泛采用，并在各种情况下有明确的动态性。例如，现代方法（例如DQN，Double DQN等）使用基于epsilon的策略。本节的作业是**增加臂的数量**并运行算法以查看哪个更好，要改变臂的数量，你只需修改主函数的第一行：

reward_distribution = [0.3, 0.5, 0.8]

要生成一个10臂的老虎机，你可以用这种方式修改变量：

reward_distribution = [0.7, 0.4, 0.6, 0.1, 0.8, 0.05, 0.2, 0.3, 0.9, 0.1]

一旦你有了新的分布，你可以运行脚本并观察每个策略的表现。增加臂数量应该更加重视探索，更大的状态空间需要更多的探索才能获得更高的回报。

在本节中，我们看到了探索如何影响一个简单的三臂测试平台的结果。**多臂老虎机问题普遍存在于我们的日常生活中**。必须为患者选择最佳治疗方法的医生，必须找到最佳AdSense点击的最佳模板的网页设计师，或者必须决定如何管理预算以最大化收入的企业家，现在你知道了处理这些问题的一些策略。在下一节中，我将介绍山地车问题，并且我会告诉你如何使用强化学习来解决这个问题。

## 山地车(Mountain Car) ##

山地车是一个经典的强化学习问题。[Andrew Moore在他的博士论文][Andrew Moore]中首次描述了这个问题[，其][Andrew Moore]定义如下：一辆山地车正在两座山上行驶，该车的发动机没有足够的动力穿过陡峭的爬坡道，司机必须找到一条路径到达山顶。

![20180503214328488][]

Sugiyama的书的[4.5.2章][Link 1]给出了这个问题的一个很好的解释。我将在这里遵循相同的数学惯例。状态空间定义为：位置x通过函数sin(3x)定义在域\[-1.2，\+0.5\] (m)内，速度x˙定义在区间\[-1.5，\+ 1.5\] (m/s)内。有三种可能的行为a= \[-2.0,0.0, +2.0\]，这是施加在汽车上的力值（左，无操作，右）。只有当汽车达到目标时，获得的奖励才是正值1.0，在每个时间步骤中应用\-0.01的负值奖励。汽车的质量是m = 0.2 k g ，重力是g = 9.8 m / s2 ，摩擦定义为k=0.3 N和时间步长为Δt=0.1 s。给定所有这些参数，在t \+ 1时刻车的位置和速度使用以下等式进行更新：

![20180503214350239][]

山地车环境已在[OpenAI Gym中][OpenAI Gym]实现，但为了教学原因，我将在这里从头开始构建这一切。在存储库中，您可以找到包含类`MountainCar`的文件`mountain_car.py`，我只用`Numpy`和`matplotlib`建立了这个类，该类包含的方法与OpenAI Gym中使用的类似。main方法名称为`step()`并允许在环境中执行一个动作，该方法返回t+1时的状态奖励和一个值`done`，`True`表示汽车达到目标。该方法包含运动方程的实现，并使用之前定义的参数。

def step(self, action):
        """Perform one step in the environment following the action. @param action: an integer representing one of three actions [0, 1, 2] where 0=move_left, 1=do_not_move, 2=move_right @return: (postion_t1, velocity_t1), reward, done where reward is always negative but when the goal is reached done is True when the goal is reached """
        if(action >= 3):
            raise ValueError("[MOUNTAIN CAR][ERROR] The action value "
                             + str(action) + " is out of range.")
        done = False
        reward = -0.01
        action_list = [-0.2, 0, +0.2]
        action_t = action_list[action]
        velocity_t1 = self.velocity_t + \
                      (-self.gravity * self.mass * np.cos(3*self.position_t)
                       + (action_t/self.mass) 
                       - (self.friction*self.velocity_t)) * self.delta_t
        position_t1 = self.position_t + (velocity_t1 * self.delta_t)
        # Check the limit condition (car outside frame)
        if position_t1 < -1.2:
            position_t1 = -1.2
            velocity_t1 = 0
        # Assign the new position and velocity
        self.position_t = position_t1
        self.velocity_t= velocity_t1
        self.position_list.append(position_t1)
        # Reward and done when the car reaches the goal
        if position_t1 >= 0.5:
            reward = +1.0
            done = True
        # Return state_t1, reward, done
        return [position_t1, velocity_t1], reward, done

在对象初始化过程中，可以为模拟定义不同的参数。在这里我将定义一个新车对象，设置我们想要的参数：

from mountain_car import MountainCar
    
    my_car = MountainCar(mass=0.2, friction=0.3, delta_t=0.1)

我添加了一个有用的方法`render()`，它可以将episode动画保存为gif或视频（它需要[imagemagick][]和[avconv][]）。此方法可以每k个episode调用一次以保存动画并检查进度。例如，要保存mp4视频，可以使用以下参数调用该方法：

my_car.render(file_path='./mountain_car.mp4', mode='mp4')

如果你想要一个GIF动画，你可以用这种方式调用该方法：

my_car.render(file_path='./mountain_car.gif', mode='gif')

现在让我们尝试使用这个类，构建一个**使用随机策略**来选择动作的**Agent**。在这里，我将使用0.1秒的时间步长和总共100步（这意味着10秒长的episode）。代码非常紧凑，在本系列的基础上，您可以轻松理解它，而无需任何其他注释：

from mountain_car import MountainCar
    import random
    
    my_car = MountainCar(mass=0.2, friction=0.3, delta_t=0.1)
    cumulated_reward = 0
    print("Starting random agent...")
    for step in range(100):
        action = random.randint(a=0, b=2)
        observation, reward, done = my_car.step(action)
        cumulated_reward += reward
        if done: break
    print("Finished after: " + str(step+1) + " steps")
    print("Cumulated Reward: " + str(cumulated_reward))
    print("Saving the gif in: ./mountain_car.gif")
    my_car.render(file_path='./mountain_car.gif', mode='gif')
    print("Complete!")

观察脚本生成的动画中汽车的行为，可以看出该任务有多困难。采用纯粹的**随机策略**，汽车停留在山谷底部，并没有到达目标。**最优策略**是移到左侧积累惯性，然后尽可能地推到右侧。

![20180503214614922][]

我们如何使用离散方法来处理这个问题？状态空间是连续的，这意味着我们有无限的价值要考虑。我们可以做的是将连续的状态\-动作空间分成区间，这被称为**离散化**。如果在连续空间中的小车运动封闭在范围\[ - 1.2 ，0.5 \]内，可以创建10个bin来表示**位置**。当汽车在\-1.10时，它在第一个bin里，在\-0.9时在第二个bin等。

![20180503214645482][]

在我们的例子中，位置和速度都必须离散化，因此我们需要两个数组来存储所有的状态。在这里我称之为**bin**的离散容器（数组的条目），其中存储着位置和速度。在Numpy中很容易使用`numpy.linspace()`函数创建这些容器，这两个数组可以用来定义一个策略矩阵。在脚本中，我将策略矩阵定义为具有`tot_bins`大小的方形矩阵，这意味着速度和位置都具有相同数量的bin。然而，也可以将速度和位置进行不同的离散化，从而获得矩形矩阵。

tot_bins = 10  # the number of bins to use for the discretization
    # Generates two arrays having bins of equal size
    velocity_state_array = np.linspace(-1.5, +1.5, num=tot_bins-1, endpoint=False)
    position_state_array = np.linspace(-1.2, +0.5, num=tot_bins-1, endpoint=False)
    # Random policy as a square matrix of size (tot_bins x tot_bins)
    # Three possible actions represented by three integers
    policy_matrix = np.random.randint(low=0, 
                                      high=3, 
                                      size=(tot_bins,tot_bins)).astype(np.float32)

当新的观察到达时，可以使用Numpy方法`numpy.digitize()`将其分配给特定的bin，该方法将观察（速度和位置）作为输入并将其放入先前声明的容器内。将观察数字化可用于访问特定地址的策略矩阵。

# Digitizing the continuous observation
    observation = (np.digitize(observation[1], velocity_state_array), 
                   np.digitize(observation[0], position_state_array))
    # Accessing the policy using observation as index
    action = policy_matrix[observation[0], observation[1]]

现在是时候使用强化学习来解决山地车问题了。在这里，我将使用我在[第三篇文章中][Link 16]介绍的称为**SARSA**的时间差分方法。我建议你可以尝试使用其他方法来检查可能获得的不同表现。为了运行先前帖子的代码，只需要进行一些更改。在这个例子中，我运行105个episode来训练策略（`gamma`= 0.999，`tot_bins`= 12），使用ε衰减值（从0.9到0.1），这有助于在训练的第一部分进行探索。该脚本每104个episode自动保存gif。以下是**每****episode累计奖励**的图表，其中淡红线是原始数据，深红线是500个episode的移动平均值：

![20180503215150785][]

从图中可以看到在第65 × 103 episode附近获得了稳定的策略，同时，在步骤图中显示了完成该episode所需的**步骤**数量显著减少。

![2018050321524433][]

该算法获得的策略之一是非常有效的，在6.7秒内达到目标位置，累计奖励为0.34。该脚本在**终端上**打印出策略，该策略由三个动作符号表示（`<`= left，`O`= noop，`>`= right），位置（列）和速度（行）。

Episode: 100001
    Epsilon: 0.1
    Episode steps: 67
    Cumulated Reward: 0.34
    Policy matrix: 
     O   <   O   O   O   <   >   <   >   O   O   <
     <   <   >   <   <   >   <   <   >   >   O   >
     O   >   <   <   <   <   <   <   >   <   O   <
     O   <   <   <   >   >   <   <   >   >   <   O
     O   >   <   <   >   >   >   <   >   O   >   >
     O   >   >   <   >   O   >   <   >   >   <   <
     <   O   >   <   >   >   <   <   >   >   >   >
     O   >   <   <   >   >   >   >   >   >   >   >
     <   >   >   >   >   >   >   >   >   >   >   >
     O   >   >   >   >   >   >   >   >   >   O   >
     <   <   >   >   >   >   O   >   >   >   >   >
     >   O   >   >   >   >   >   >   >   <   >   <

获得的策略是次优策略，从步骤图（浅蓝色曲线）可以看出，有些策略可以在大约40个步骤（4秒）内达到目标，该策略可以在训练结束时生成的gif中观察到：

![20180503215349200][]

离散化方法在山地车问题上表现良好。但是，可能会出现一些可能的问题，首先，很难确定离散化应该使用多少个bin，大量的bin会导致很好的控制，但它们会导致[组合爆炸][Link 17]；第二个问题是，为了获得良好的策略，可能需要访问所有状态，这可能会导致很长的训练时间。我们将在本系列的其余部分看到如何处理这些问题。您应该从[官方存储库][Github]下载完整的代码名为`sarsa_mountain_car.py`，并使用它更改超参数以获得更好的性能。

## 倒立摆(Inverted Pendulum) ##

[倒立摆][Link 18]是另一个经典的问题，这被认为是控制理论的基准。[James Roberge][]可能是第一位提出解决方案的作者，他在1960年他的学士论文中给出了解决方案。问题是一个铰接在推车上的杆，为了保持杆处于垂直位置必须持续移动杆，[Sugiyama书中的][Link 1]4.5.1章详细描述了倒立摆。在这里，我将使用相同的数学符号。**状态空间**包括**角度**ϕ∈\[−π/2,π/2\]（弧度）（当它完全垂直时值为零）和**角速度**ϕ˙∈\[−π,π\]（弧度/秒）。**动作空间**是离散的，为了促使杆向上摆动，它由**三个力**\[-50，0，50\]（牛顿）施加到小车上。

![20180503215432625][]

系统有不同的参数可以决定动态性。杆的质量m = 2 k g，小车的质量M = 8 k g，杆的长度d = 0.5米，时间步Δt=0.1s。给定这些参数在t\+1时刻，角度φ和角速度ϕ˙更新如下：

![20180503215450223][]

这里α = 1 / M\+m，at是t时刻的动作。被更新的**奖励**和角度φ的余弦值有关，意味着角度越低，奖励越低。当杆是水平的时候奖励是0.0，垂直时是1.0，当杆子完全水平时，episode结束。就像在山地车的例子中一样，我们可以使用离散化将连续状态空间分配在预定义的bin中。例如，**位置**使用**角度**编码在范围\[\- π/ 2，π/ 2\]内，它可以分成4个bin。当杆具有角度\- π /5时它是在第三个bin内，当它具有角度π /6时它在第二个bin内，以此类推。

![20180503215506955][]

我写了一个特别模块`inverted_pendulum.py`包含类`InvertedPendulum`，就像在山地车模块中一样，有方法`reset()`、`step()`和`render()`，负责开始episode、移动杆并保存gif。该动画是使用Matplotlib制作的，可以想象成一个以相应移动的小推杆主关节为中心的相机。要创建一个新环境，有必要创建一个新的`InvertedPendulum`对象实例，定义主要参数（质量，杆长度和时间步长）。

from inverted_pendulum import InvertedPendulum
    
    # Defining a new environment with pre-defined parameters
    my_pole = InvertedPendulum(pole_mass=2.0, 
                               cart_mass=8.0, 
                               pole_lenght=0.5, 
                               delta_t=0.1)

我们可以测试遵循随机策略的agent的性能,代码名为`random_agent_inverted_pendulum.py`，在[存储库][Github]上可以找到。在杆平衡环境中使用随机策略导致的性能不令人满意，我多次运行脚本中最好时间是短暂1.5秒的episode。

![20180503215611725][]

**最优策略**包含补偿角和速度的变化保持杆尽可能多地垂直。就像山地车一样，我会用离散化来处理这个问题。速度和角度都是以相同大小的bin离散化，所得到的数组用作方形策略矩阵的索引。算法我使用**首次访问蒙特卡洛****(first-visit Monte Carlo)**控制，这已在[该系列][Link 19]的[第二篇文章中][Link 5]介绍过。我训练了5 × 105 个episode的策略（`gamma`= 0.999，`tot_bins`=12），为了鼓励探索，我使用了ϵ\-greedy策略，ϵ从0.99到0.1线性衰减，每一个episode都是100步长（10秒），可以获得的最大奖励是100（在所有步骤中杆保持完全垂直）。奖励图表显示，该算法可以迅速找到好的解决方案，达到了45分的平均分数。

![20180503215654125][]

最终的策略表现非常出色，并且有利的出发位置可以轻松地保持整个episode（10秒）的平衡。

![20180503215729236][]

完整的代码命名为`montecarlo_control_inverted_pendulum.py`并包含在项目的[Github存储库][Github]中。随意更改参数并检查它们是否对学习产生影响，此外，您应该测试杆平衡问题上的其他算法，并验证哪一个会获得最佳性能。

## 无人机着陆(Drone landing) ##

有很多可能的强化学习应用，其中最有趣的是机器人控制。强化学习为复杂的策略实现提供了广泛的技术，例如，它已被应用于[人形机器人控制][Link 20]和[直升机杂技动作][Link 21]，我建议你阅读[Kober et at][][（2013年）][Kober et at]的文章。在这个例子中，我们将使用强化学习来控制**自主无人机**，特别是我们必须训练无人机**降落在地面平台上**。

![20180503220033255][]

无人机在一个独立的3D世界中移动，以小房间表示，标记总是在同一点（地板的中心）。规则与gridworld中使用的规则类似，如果无人机撞到墙壁上的其中一点，它会弹回到之前的位置。在平台上着陆导致\+1.0的正奖励，而在其它点上着陆导致\-1.0的负奖励，在每个时间步骤应用\-0.01的负成本。有六种可能的动作：向前，向后，向左，向右，向上，向下，为了简化，我们假设环境是完全确定性的，每个行动导致1米的移动。这个例子对于理解组合爆炸和基于简单查找表的强化学习算法的影响特别有用。

我实现了一个Python模块名为`drone_lading.py`包含类`DroneLanding`，使用这个类可以用几行代码创建一个新的环境：

from drone_landing import DroneLanding
    
    my_drone = DroneLanding(world_size=11)

唯一需要设置的是以米为单位的世界大小。这个类实现了通常的方法`step()`、`reset()`和`render()`。step方法使用一个整数来表示六个动作之一（向前，向后，向左，向右，向上，向下），并返回由元组（x，y，z）表示的t+1处的观察值，该元组标识无人机的位置，照常该方法还返回`reward`和布尔变量`done`，其中为`True`时表示一个终止状态的情况（无人机降落）。方法`render()`基于matplotlib，通过三维图形生成无人机移动的gif或视频。我们从一个随机agent开始，下面是代码：

from drone_landing import DroneLanding
    import numpy as np
    
    my_drone = DroneLanding(world_size=11)
    cumulated_reward = 0
    print("Starting random agent...")
    for step in range(50):
        action = np.random.randint(low=0, high=6)
        observation, reward, done = my_drone.step(action)
        print("Action: " + str(action))
        print("x-y-z: " + str(observation))
        print("")
        cumulated_reward += reward
        if done: break
    print("Finished after: " + str(step+1) + " steps")
    print("Cumulated Reward: " + str(cumulated_reward))
    my_drone.render(file_path='./drone_landing.gif', mode='gif')
    print("Complete!")

多次运行该脚本，您可以了解该任务有多困难。使用随机策略很难到达平台。在11米大小的世界里，获得奖励的概率只有0.07％。下面您可以看到为随机agent的episode生成的gif。

![20180503220157568][]

无人机用红点表示，红色表示着陆时导致负值奖励的区域，中央的绿色方形表示平台。正如你所看到的，无人机一直在房间的同一部分移动，完成episode，但根本没有着陆。在这里，我将使用Q-learning解决这个问题，该技术已经在[该系列][Link 22]的[第三篇文章中][Link 16]介绍过。该代码与gridworld的代码非常相似，您可以在官方存储库中名为`qlearning_drone_landing.py`的文件中找到它。每一个episode（50步）的平均累积奖励最高为1.0（如果无人机在第一步登陆），如果无人机在最后一步非常不幸地落在平台外，则它是\-1.5，如果无人机在没有着陆的情况下继续移动，则为\-0.5（50步中的\-0.01负成本的总和）。运行脚本执行5 × 105个episode，使用epsilon-greedy策略（epsilon = 0.1）我得到了以下结果：

![20180503220232490][]

算法收敛很快。奖励从负（前1000episode）变化到正，并持续增长，直到达到0.9的平均值，在我的笔记本电脑（英特尔四核i5）上训练花了大约3分钟的时间。看看使用`render()`方法生成的gif，我们可以看到无人机如何立即向平台移动，仅需10秒即可到达该平台。

![20180503220306489][]

使用11米的世界很容易获得稳定的策略。现在让我们尝试21米的世界，在脚本`qlearning_drone_landing.py`中，您只需设置参数`world_size=21`即可。在这个新的环境中，获得奖励的可能性降至0.01％。我不会改变任何其他参数，因为通过这种方式，我们可以将该世界的算法性能与前一个的性能进行比较。

![20180503220337854][]

如果你仔细看上图，你会注意到两件事情。首先，奖励增长非常缓慢，平均达到0.6；其次，episode的数量要高得多，我必须为策略训练25 × 105个episode，比以前的环境多四倍，在之前的实验的同一台笔记本电脑上花了40分钟。看看在训练结束时创建的gif，我们可以看到最终该策略足够强大，可以保证在平台上着陆。

![20180503220409689][]

在这一点上，应该清楚为什么使用查找表来存储状态\-动作效用是一种有限的方法。当状态空间增长时，我们需要增加表的大小。从大小为11的世界和6个动作开始，为了存储所有的状态我们需要一个大小为11 × 11 × 11 = 1331大小的查找表，以及为了存储所有的状态\-动作对需要大小为11× 11 × 11 × 6 = 7986的查找表。把世界的大小加倍到21时，我们必须增加大约9倍的查找表，而对于31大小的世界，我们需要一个25倍大的查找表。在下面的图片中，我总结了这些观察，橙色方块表示存储状态\-动作对所需的查找表的大小，方块越暗表格的大小越大。

![20180503220433769][]

探索高维空间的问题在所考虑的维数上变得越来越困难。在我们的例子中，我们只考虑了三维空间，但考虑到更大的超空间会使一切变得更加复杂，这是一个众所周知的问题，称为[维度诅咒][Link 23]([curse ofdimensionality][Link 23])，这个名词由**Richard Bellman**（一个你应该知道的人，回忆一下[第一篇文章][Link 3]的内容）首次提出。在下一篇文章中，我们将看到如何使用逼近器来解决这个问题。在最后一节中，我想介绍另外一些问题，这些问题被认为是非常困难的，并且不太容易解决。

## 困难的问题 ##

我在上面描述的问题虽然有些难，但并不是非常困难，最终我们使用表格方法设法找到了好的策略。**使用强化学习难以解决哪类问题？**

**![20180503220718366][]**

一个例子是**体操机器人****(acrobat)**。体操机器人是一个平面机器人，由两条等长的连杆表示，第一个连杆连接到一个固定的关节，第二个连杆连接到第一个连杆上，它们都可以自由摆动并可以相互擦身而过，机器人可以控制施加到第二关节的扭矩以摆动和移动系统。状态空间由连杆的两个位置和两个速度表示，动作空间由机器人可应用于关节的扭矩量来表示。在episode开始时，两个连杆指向下方，目标是摆动连杆直到尖端通过特定边界。在机器人到达终止状态（\+1.0）之前，给出的回报为负值（\-1.0）。体操机器人的状态空间很大，对我们的离散方法来说是一个挑战，这就像有**两个倒立摆**在相同的系统中相互作用。此外，正的**奖励是稀疏的**，这意味着它只能在经过一系列长时间的协调运动之后才能获得。在[Sutton和Barto的书的][Sutton_Barto]第11.3章中描述了体操机器人，Sutton使用SARSA(λ)和一个**线性逼近器****(linear approximator)**来解决这个问题。我们还没有掌握这个问题的正确解决方法，只有在下一篇文章中，我们才会看到线性逼近器是什么。如果您对Sutton的解决方案感兴趣，您可以[阅读该文][Link 24]。此外，如果您想尝试其中的一种算法，您可以使用在[OpenAIGym中][OpenAIGym]的实现。有什么比体操机器人更难？是的，一个集成式的机器人：**人形机器人控制****(humanoid control)**。

![20180503220736877][]

一个人形机器人有很多自由度，协调所有这些真的很难。状态空间很大，并且由多个关节的速度和位置表示，为了实现有效的运动，必须同步控制多个关节的速度和位置。动作空间是可以应用于每个关节的扭矩量，关节位置、关节速度和扭矩是连续量，奖励功能取决于任务。例如，在双足步行者中，奖励可以是机器人在有限时间内达到的距离，试图用离散的方法获得合适的结果是不可行的。在这几年中，不同的技术已经被应用，取得了或多或少的成功。尽管[最近取得进展][Link 25]，但人形机器人控制仍然被认为是一个未解决的问题。如果你想尝试的话，[在OpenAI Gym中][OpenAI Gym 1]有一个[双足步行者][OpenAI Gym 1]的实现。有比人形机器人控制更难的东西吗？可能是**电子游戏？**

**![20180503220751890][]**

如果你玩过[2600 Atari游戏，][2600 Atari]你可能已经注意到其中一些操作真的很难。算法如何玩这些游戏？嗯，我们可以作弊。如果游戏可以减少到一个有限的特征集，可以使用基于模型的强化学习来解决它。然而，大多数时候奖励函数和转移矩阵都是未知的，在这些情况下，唯一的解决方案是将**原始图像**用作**状态空间**。由原始图像表示的状态空间非常大，使用查找表没有意义，因为大多数状态将无法被访问到。我们应该使用一个可以描述一组简化的状态空间参数的逼近器，很快我会告诉你**深度强化学习**如何使用神经网络来解决这类问题。

## 结论 ##

在这篇文章中，我介绍了一些经典的强化学习问题，展示了如何使用以前的帖子中的技术来获得稳定的策略。然而，我们总是从一个由查找表或矩阵描述的离散状态空间的假设开始，这种方法的主要局限在于，在许多应用中，状态空间非常大，不可能访问所有的状态。为了解决这个问题，我们可以使用**函数逼近****(function approximation)**。在下一篇文章中，我将介绍函数逼近，并且将向您展示如何使用**神经网络**来描述一个大的状态空间。神经网络的使用开辟了新的视野，它是现代方法的第一步，例如**深度强化学习**。

## 索引 ##

1. [\[第一篇][Link 3]\]马尔科夫决策过程，贝尔曼方程，值迭代和策略迭代算法。

2.  [\[第二篇\]][Link 5]蒙特卡罗概念，蒙特卡洛方法，预测与控制，广义策略迭代，Q函数。

3.  [\[第三篇][Link 16]\]时间差分概念，动物学习，TD(0), TD(λ)和资格痕迹，SARSA，Q-learning。

4.  [\[第四篇][Link 6]\]Actor-Critic方法背后的神经生物学，计算Actor-Critic方法，Actor-only和Critic-only方法。

5.  [\[第五篇][Link 26]\]进化算法介绍，强化学习中的遗传算法，遗传算法的策略选择。

6.  **[\[第六篇][Link 27]\]**强化学习应用，多臂老虎机，山地车，倒立摆，无人机着陆，难题。

7.  [\[第七篇][Link 28]\]函数逼近概念，线性逼近器，应用，高阶逼近器。

8. **[\[第八篇\]][Link 29]** 非线性函数逼近，感知器，多层感知器，应用，政策梯度。

**资源**

·        The **complete code** for theReinforcement Learning applications is available on the [dissecting-reinforcement-learning][Github] officialrepository on GitHub.

·        **Reinforcement learning:An introduction (Chapter 11 ‘Case Studies’)** Sutton, R. S., &Barto, A. G. (1998). Cambridge: MIT press. [\[html\]][html]

·        **History ofInverted-Pendulum Systems** Lundberg, K. H., & Barton, T. W.(2010). [\[pdf\]][James Roberge]

·        **Reinforcement Learningon autonomous humanoid robots** Schuitema, E. (2012). [\[pdf\]][Link 20]

·    **Generalization inreinforcement learning: Successful examples using sparse coarse coding** Sutton, R.S. (1996). [\[pdf\]][Link 24]

## 参考 ##

Abbeel, P., Coates, A., Quigley, M., & Ng, A. Y. (2007). Anapplication of reinforcement learning to aerobatic helicopter flight. InAdvances in neural information processing systems (pp. 1-8).

Kober, J., Bagnell, J. A., & Peters, J. (2013).Reinforcement learning in robotics: A survey. The International Journal ofRobotics Research, 32(11), 1238-1274.

Lundberg, K. H., & Barton, T. W. (2010). History ofinverted-pendulum systems. IFAC Proceedings Volumes, 42(24), 131-135.

Sutton, R. S. (1996). Generalization in reinforcement learning:Successful examples using sparse coarse coding. In Advances in neuralinformation processing systems (pp. 1038-1044).

Thompson, W. R. (1933). On the likelihood that one unknownprobability exceeds another in view of the evidence of two samples. Biometrika,25(3/4), 285-294.

[20180503213154192]: /images/20220525/efa4c25a652345518131618f54a09eed.png
[Sutton_Barto]: https://mpatacchiola.github.io/blog/2017/08/14/%28https:/webdocs.cs.ualberta.ca/~sutton/book/ebook/the-book.html%29
[Link 1]: https://www.crcpress.com/Statistical-Reinforcement-Learning-Modern-Machine-Learning-Approaches/Sugiyama/p/book/9781439856895
[Github]: https://github.com/mpatacchiola/dissecting-reinforcement-learning
[Link 2]: https://github.com/mpatacchiola/dissecting-reinforcement-learning/archive/master.zip
[T]: https://en.wikipedia.org/wiki/T-maze
[20180503213225415]: /images/20220525/7f6960fa0cb747cdb8b170d349838203.png
[Link 3]: https://blog.csdn.net/wilbertzhou/article/details/79822237
[20180503213242140]: /images/20220525/1e7dc39743e946628aa1ca6af67af9b6.png
[Link 4]: https://en.wikipedia.org/wiki/Bernoulli_distribution
[20180503213304831]: /images/20220525/739c4dc018d64275bd11f79cf194e65f.png
[RMSE]: https://en.wikipedia.org/wiki/Root-mean-square_deviation
[Link 5]: https://blog.csdn.net/wilbertzhou/article/details/79845415
[Link 6]: https://blog.csdn.net/wilbertzhou/article/details/80041495
[softmax]: https://en.wikipedia.org/wiki/Softmax_function
[20180503213716112]: /images/20220525/976af78263f142ecb94bbdc21b220f1f.png
[Link 7]: https://en.wikipedia.org/wiki/Probability_theory
[Link 8]: https://en.wikipedia.org/wiki/Bayesian_statistics
[Link 9]: https://en.wikipedia.org/wiki/Bayes%27_theorem
[Link 10]: https://en.wikipedia.org/wiki/Frequentist_probability
[MLE]: https://en.wikipedia.org/wiki/Maximum_likelihood_estimation
[20180503213837164]: /images/20220525/3bee2ac9fd644fba91c38c27fa7d2ef2.png
[1993]: http://www.jstor.org/stable/2332286
[20180503213915520]: /images/20220525/3534a486b936488f86915c1ae4bd04c7.png
[Link 11]: https://en.wikipedia.org/wiki/Binomial_distribution
[2018050321394924]: /images/20220525/2d96c8e43e3e4cd7ae506a28a9e3e123.png
[Link 12]: https://en.wikipedia.org/wiki/Conjugate_prior
[Link 13]: https://en.wikipedia.org/wiki/Beta_distribution
[20180503214003156]: /images/20220525/90c236e21ad34a6aa68a5553c8365053.png
[20180503214034348]: /images/20220525/a20d7a262a8442b6a3a901fe2cf0b21c.png
[Link 14]: https://en.wikipedia.org/wiki/Multinomial_distribution
[Dirichlet]: https://en.wikipedia.org/wiki/Dirichlet_distribution
[Link 15]: https://en.wikipedia.org/wiki/Normal_distribution
[20180503214225434]: /images/20220525/388c5b9c083a4ab1b993eb7e4e587300.png
[Andrew Moore]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.17.2654
[20180503214328488]: /images/20220525/dfbee34a63a245e681d4c9fa8761036f.png
[20180503214350239]: /images/20220525/e92497217e774bb69b3fbad9630a0adf.png
[OpenAI Gym]: https://gym.openai.com/
[imagemagick]: https://www.imagemagick.org/
[avconv]: https://libav.org/avconv.html
[20180503214614922]: /images/20220525/0af1609e4c4b47838f9783c487747870.png
[20180503214645482]: /images/20220525/7bd68c96a5244bf19dce17e3859953ec.png
[Link 16]: https://blog.csdn.net/wilbertzhou/article/details/79953950
[20180503215150785]: /images/20220525/6bc9983a0e73474792939a7aae896d9b.png
[2018050321524433]: /images/20220525/f0cdea66e1b74d39925c13f85bc4cd49.png
[20180503215349200]: /images/20220525/0ae99bcc237f4566bb8082d37258a97d.png
[Link 17]: https://en.wikipedia.org/wiki/Combinatorial_explosion
[Link 18]: https://en.wikipedia.org/wiki/Inverted_pendulum
[James Roberge]: http://ecee.colorado.edu/~taba7194/CPIFAC2oct11.pdf
[20180503215432625]: /images/20220525/9a818f8defa1484b8fd9a7cb05fb4452.png
[20180503215450223]: /images/20220525/ac06402a7d814943aab9a6ffb0a5c0f1.png
[20180503215506955]: /images/20220525/14822b33190c4235a4bd924e387f428f.png
[20180503215611725]: /images/20220525/7113cae0245c49afb5fc1e2f33a2a309.png
[Link 19]: https://mpatacchiola.github.io/blog/2017/01/15/dissecting-reinforcement-learning-2.html
[20180503215654125]: /images/20220525/81885303b150422b9b165ffc70a1db1f.png
[20180503215729236]: /images/20220525/a77806a4bc504f5bad41529ade59793d.png
[Link 20]: https://repository.tudelft.nl/islandora/object/uuid:986ea1c5-9e30-4aac-ab66-4f3b6b6ca002/datastream/OBJ
[Link 21]: http://heli.stanford.edu/papers/nips06-aerobatichelicopter.pdf
[Kober et at]: http://journals.sagepub.com/doi/full/10.1177/0278364913495721
[20180503220033255]: /images/20220525/75c27fcce1704768aa95eaca3a0b67af.png
[20180503220157568]: /images/20220525/d3ffb6a33c524ba3bbd50fe01d698e85.png
[Link 22]: https://mpatacchiola.github.io/blog/2017/01/29/dissecting-reinforcement-learning-3.html
[20180503220232490]: /images/20220525/461f866a5a9a4406bf06819cb379a213.png
[20180503220306489]: /images/20220525/660e55c991a0497b87be7cb8606ee1ed.png
[20180503220337854]: /images/20220525/8640baa256f543e49a08d485aa31d90d.png
[20180503220409689]: /images/20220525/21b91b234e294cbdaab2b12fa55c17e2.png
[20180503220433769]: /images/20220525/0b0862bdb7eb4eefbc7a16d89dbc9529.png
[Link 23]: https://en.wikipedia.org/wiki/Curse_of_dimensionality
[20180503220718366]: /images/20220525/66739ff33b4440d9870120c397728c5e.png
[Link 24]: http://papers.nips.cc/paper/1109-generalization-in-reinforcement-learning-successful-examples-using-sparse-coarse-coding.pdf
[OpenAIGym]: https://gym.openai.com/envs/Acrobot-v1
[20180503220736877]: /images/20220525/146c7b4683244119ab8a8ec62a996d8b.png
[Link 25]: https://deepmind.com/blog/producing-flexible-behaviours-simulated-environments/
[OpenAI Gym 1]: https://gym.openai.com/envs/Humanoid-v1
[20180503220751890]: /images/20220525/fcd272587b474f719d420a1b6f4d3c47.png
[2600 Atari]: https://en.wikipedia.org/wiki/List_of_Atari_2600_games
[Link 26]: https://blog.csdn.net/wilbertzhou/article/details/80113538
[Link 27]: https://blog.csdn.net/wilbertzhou/article/details/80187257
[Link 28]: https://blog.csdn.net/wilbertzhou/article/details/80260205
[Link 29]: https://blog.csdn.net/wilbertzhou/article/details/86743877
[html]: https://webdocs.cs.ualberta.ca/~sutton/book/ebook/the-book.html