P6：Lecture 6 - CNNs and Deep Q Learning - 大佬的迷弟的粉丝 - BV1Cc411h7QQ
所以第二个作业现在出来了，我认识到有一个非常广泛的背景，就人们以前是否见过深度学习或上过课而言，或者广泛使用，嗯，只是一个敏捷谦逊的人，你们谁用过TensorFlow还是Pytorch，之前。
你们中的一些人，但不是每个人，所以我们本周要做的是，没有被期望成为或成为一个深度学习专家在这个班上，但是我们你需要有一些基本技能才能做作业，嗯，并能够使用函数逼近与深度神经网络。
所以我鼓励你们本周去参加会议，如果你没有这方面的背景，我们今天要，稍微介绍一下深度学习，但是非常非常非常小的量，嗯，更多地关注深度强化学习，但这些课程将是一个很好的机会来赶上这些材料，嗯，我们还将达到。
呃，明天结束前发布，默认项目是什么，呃这个班，你们可以选择，你是否想做自己的建筑项目，或者呃，默认项目，嗯，这些建议书很快就会到期，在那里一周多一点的时间里，人们现在有什么其他问题吗，是啊，是啊。
停车问题的作业，如果赋值仅限于TensorFlow，我是，我很确定一切都依赖于你使用的张量流，所以是的，请随时在广场上伸出援手，仔细检查一下，但是，我很确定任何。
我们所有的自动平地机都是为TensorFlow设置的，那么这个呢，即使你正常使用Pytorch，请使用张量流，嗯，你们所有人也应该可以获得蔚蓝信用，如果你对建立这个有任何问题，请随意使用广场频道。
上周我们还发布了一个教程，教你如何设置你的机器，所以如果你有任何问题，那是个开始的好地方，如果你看教程，大家可以看一下视频，或者你可以在广场上联系我们，任何其他问题，所有的权利，所以我们要开始了，嗯。
呃，我们今天要讲的是什么，是关于深度学习和深度Q学习的一个非常简短的概述，嗯，就班上的位置而言，我们一直在讨论如何学会在这个世界上做决定，当我们事先不知道奖励模型的动力学模型时。
上周我们讨论了价值函数近似，特别线性值函数逼近，今天，我们将开始讨论其他形式的值函数逼近，特别是，嗯，呃，利用深度神经网络，那么我们为什么要把这件事做得很好呢，我们想开始思考的原因，嗯，啊。
使用函数逼近器就是，如果我们想用强化学习来解决真正复杂的毛茸茸的问题，嗯，我们需要能够处理这样一个事实，即经常，我们将有非常高维的输入信号或观测，嗯，所以我们希望能够处理像素输入，像图像。
或者我们希望能够处理非常复杂的，嗯，顾客、病人或学生的信息，嗯，我们可能有巨大的状态和行动空间，今天我会注意到，我们大多不会谈论太多巨大的行动空间，但是我们会考虑很多关于非常大的状态空间。
所以当我们开始谈论这些，我认为我们要么需要模型的表现，这些意味着动力或奖励模型，T或R或状态操作值，q或v，或者我们的政策可以概括各州和我们的行动，我们的想法是我们可以，事实上。
再也不会遇到完全相同的状态了，你可能再也看不到完全相同的世界图像了，但我们希望能够从过去的经验中总结出来，所以我们想，而不是用一个表来表示我们的值函数，嗯，我们将使用这个泛型函数逼近器。
那里我们现在有一个W，就是一些参数，当我们想这么做的时候，我们说我们要关注的是，我们将关注可微的函数逼近，可微表示的好处是我们可以使用我们的数据，我们可以估计我们的参数。
然后我们可以使用梯度下降来适应我们的函数，试着写那个，写或表示我们的Q函数或值函数，我上次提到过，那个，大多数时候，我们将考虑尝试量化我们函数的拟合度，与真值比较为均方误差。
这样我们就可以确定我们的损失，我们可以用梯度下降法找到参数，优化，作为一个提醒，随机梯度下降是有用的，因为当我们可以慢慢地更新我们的参数时，随着我们得到更多的信息，这些信息现在可能是以插曲的形式出现的。
也可以是单个元组，当我说元组，我通常指国家诉讼，奖励下一个状态，好的是，预期的随机梯度下降与全梯度更新相同，所以只是为了提醒自己，上次我们讲到线性值函数逼近器，这意味着我们要做的是。
我们将有一大堆特征来描述我们的世界，嗯，因为你知道这些特性，我们将输入我们的状态，状态是世界的真实状态，我们会输出我们的特性，所以这可能是我们机器人的激光测距仪，它告诉我们墙在一百八十度的方向上有多远。
我们谈到了这样一个事实，那是世界的别名版本，因为多个走廊可能看起来相同，所以我们的值函数现在是这些特征之间的点积，我们已经了解了这个世界，嗯，用重量，我们的目标函数又是均方误差。
然后我们可以做同样的体重更新，关键的困难是我们不知道这是什么，所以这才是保单的真正价值，问题是我们不知道保单的真正价值是什么，否则我们就不必做所有这些学习，所以我们需要有不同的方法来近似它。
所以我们上次讲的两种方法都是受到我们工作的启发，在蒙特卡洛或在TD学习是，我们可以插入完整集的回归，这是奖励的总和，或者我们可以进行自助返回，所以现在我们在做自举，我们看奖励的地方。
下一个状态和我们下一个状态的值，在这种情况下，我们对所有的东西都使用线性值函数逼近器，这给了我们一个非常简单的形式，这个函数的导数是什么，关于W，基本上只是我们的特性，基本上乘以这个预测误差。
所以人们有时称之为预测错误，因为这是价值之间的差异，或者现在我们用GT作为真正的值，当然啦，在现实中，它只是价值的一个样本，但真实价值和我们估计价值之间的差异，我们想缩小这种差异，所以在这种情况下。
我写的这些方程都是为了线性值函数逼近，但是使用线性值函数逼近有一些局限性，尽管这可能是研究得最充分的，所以如果你有正确的功能集，从历史上看，有很多工作要弄清楚，这些正确的特征是什么，他们经常工作得很好。
事实上，当我们进入，我想我之前简短地提到过，当我们开始谈论深度神经网络时，你可以想到一个深度神经网络，只是一种非常复杂的方法来获得功能，加上最后一层是这些特征的线性组合，当我们谈论深RL的时候。
用深度神经网络来表示Q函数，这就是我们将要研究的代表类型，所以线性值函数通常工作得很好，如果你是正确的功能集，但这是对什么是正确的功能集的挑战吗，关于是否，我们甚至可以写下真值函数，使用我们的一组特性。
我们有多容易收敛到这一点，所以我们上次没有太多讨论的一个选择是使用，一个非常非常丰富的函数逼近类，我们不必直接表示特征，其中一些是基于内核的方法，嗯，有没有人看到像，呃。
在K个最近邻类型方法之前或类似K个最近邻类型方法之前基于内核的方法，如果你学过机器学习，你听说过K个最近的邻居，这些是非参数化的方法，其中表示大小往往随着许多数据点的增长而增长，嗯，然后他们会很好。
它们有一些非常好的收敛特性，用于强化学习，问题是您需要的数据点的数量往往会随着维度而缩放，所以如果你有，假设那一百八十个特征，需要平铺的点数，一百八十度的空间通常随维度呈指数缩放，所以就计算复杂性而言。
这并不那么吸引人，内存需求和样本复杂度，所以这些实际上有更强的收敛结果，与线性值函数逼近器相比，嗯，但它们还没有被广泛使用，嗯，每个人都先说出名字，请帮帮我，是啊，是啊，呃，所以你再想想。
为什么指数行为，是啊，是啊，问题是，为什么指数行为会发生在许多这样的内核中，基于逼近器或非参数逼近器，直觉是我，如果你想对你的值函数有一个准确的表示，你用，说，呃，它周围的局部点，比如说。
类似于K最近邻方法，那么你需要让一切都接近的点数，就像在一个Epsilon球的尺度上，所以基本上你只是把空间网格化，所以如果你想到，如果你想到，如果你想在这条线上有任何一个点，请靠近。
然后你可以在这里放一个点，在这里放一个点，为了拥有一切，对于这条线上的所有点都是epsilon关闭的，有一个在Epsilon距离内的邻居，如果你想把它放在一个正方形里，你需要四分。
这样一切都可以有点接近其中一个点，一般来说，你需要的点的数量会随着维度呈指数级增长，但他们真的很好，我因为它们可以保证是平均数，我们简短地讨论过，上次，查看线性值函数逼近器，嗯，当你做行李员备份时。
它不再一定是收缩算子了，这就是为什么当你做越来越多的备份时，你有时会爆炸，平均数最酷的一点是它的名字，当您使用这种类型的近似值时，你没有，它们保证是不膨胀的，这意味着当你把它们和行李员备份结合在一起时。
它保证仍然是收缩，这真的很酷，所以这意味着这些近似器保证收敛，与许多其他的相比，好吧，但它们不会很好地缩放，在实践中，你不会看到他们，尽管我的同事做了一些很酷的工作，哈佛大学的终结者多希·维勒兹。
谁在考虑将这些用于医疗保健应用，你是如何从相关的病人中概括出来的，所以它们可以很有用，但一般不会缩放得那么好，我们今天要讨论的是深度神经网络，它们也有非常灵活的表示，但我们希望我们能扩大规模，嗯。
总的来说，我们几乎没有理论上的保证，在今天剩下的时间里，我和，但在实践中，他们经常工作得非常非常好，所以它们已经成为强化学习的一个非常有用的工具，在机器学习方面，那么我们所说的深度神经网络是什么意思。
你们中的许多人都是专家，但它通常意味着什么，在这种情况下是，我们要考虑做一个函数逼近器，它是由许多函数组成的，所以我们将有我们的输入x，现在我们要把它输入到某个函数中，它会承受一些重量，所以一般来说。
所有这些东西都可以是向量，所以你要吸收一些重量，并把它们和你的X结合起来，然后你要把它们推入某种功能，然后你会输出一些东西，它可能也是一个向量，然后你可以把它放到另一个函数中加入更多的权重。
我们会这样做很多次，然后在最后，我们可以输出一些Y，你可以把它想象成我们的Q，然后我们可以把它输出到某个损失函数j，那么这在这里是什么意思，这意味着y等于h n的h n减去点的一个，x中每一个的点。
我还没有把所有的重量都写在里面，但也有一大堆重量，然后这是我们的损失函数，像以前一样，你可以把它想象成我们的Q，比如说，但这些在无监督学习中经常发生，比如预测某物是不是猫，或者你知道一个特定物体的图像。
um或用于回归，那么我们为什么要做好这件事，首先，应该清楚的是，当你组成许多函数时，嗯，你可以通过以下方法来表示非常复杂的函数，你知道的，多项式的加减乘除，你可以通过把函数组合在一起来做各种各样的事情。
这可能是一个非常强大的函数空间，你可以表示，但写下来的好理由，像这样，你可以用链式法则来尝试随机梯度下降，那么这怎么工作得好呢，这意味着我们可以写下那个DJ，所以我们真的想，你知道的。
对于所有这些不同的参数，所以我们可以在这里写的是，我们可以写下hn的dj和dw n的dh n，我们可以在任何地方都这样做，所以H二的DJ，dh2的dh2和dhh2dw2。
所以您可以使用链式法则来传播所有这些，你的损失函数的梯度，关于W，通过写下链式法则来追溯所有这些不同的作文，所以这可能很好，因为这意味着你可以把你的输出信号，然后把它传播回来更新你所有的体重。
现在我要和自己约会了，所以当我第一次了解深度神经网络时，你必须用手做这件事，所以你可能会想象这是一个不太受欢迎的任务，然后呃，这叫做反向传播，所以你可以手工推导这个，嗯。
我一会儿就会讲到这些类型的功能是什么，你知道你需要H的可微函数，但我认为那里发生的主要创新之一，你知道的，在过去的五到八年里，汽车差异化，所以现在你不必手动驾驶所有这些坡度，相反。
您可以只写下您的网络参数，然后你的网络包括一堆参数，然后你有像TensorFlow这样的软件来为你做所有的区分，所以我认为这些工具让人们更实用，很多很多的人可以使用，嗯，深度神经网络，因为你没有。
你可以有非常非常复杂的网络，有非常非常多的层，没有手写什么，渐变是，那么这些h函数是什么，通常它们结合了线性变换和非线性变换，基本上它们必须是可微的，所以你知道，这些h需要是可微的。
如果我们要用梯度下降来拟合它们，所以常见的选择要么是线性的，或非线性，我们可以认为hn等于某个函数hn-1，如果它是非线性的，我们通常称之为激活函数，由于时间的原因。
我不打算在课堂上多谈与神经网络的联系，这就是我们大脑内部的东西，这就是鼓舞人心的地方，这些人工神经网络，嗯，但在大脑内部，人们认为有这种非线性激活函数，其中，如果信号通过某个阈值，然后呢，比如说。
神经元会发射，所以这些非线性激活函数可以是乙状结肠函数，或Relu，relu现在特别受欢迎，但是嗯，所以你可以选择线性函数或非线性函数的不同组合，和往常一样我们最后需要一个损失函数。
通常我们使用均方误差，您还可以使用对数似然，但我们需要一些，然后我们就可以区分我们离实现目标有多近，为了更新我们的重量，是啊，是啊，名字第一，所以这个射线环函数是不可微的，对呀，它是可微的，就像你可以。
你可以，你可以用不同的方式做这件事，最近它比乙状结肠更受欢迎，虽然我觉得这是一个，但我不明白渐变下降对这部分有什么作用，嗯，是零，所以结果很好，只是为了在这里，所以问题是对于饶来说，有很多平坦的地方。
所以如果你的梯度为零，然后你的渐变就会在那里消失，总的来说，实际上我们不会在课堂上谈论这个，但肯定有一个问题是，你开始有非常非常深的神经网络，因为其中的一些功能，你有时会结束几乎没有信号回到早期的层。
但我不打算谈论这些，我们谈谈，我们会在会议上讨论这个问题，他们很好地意识到，我们也很乐意给其他指针，但是是的，没关系，你仍然可以有一个，零分，所有的权利，那么我们为什么要把这件事做好呢，这很好。
我们可以使用这种更复杂的表示，嗯，另一件事是，如果你至少有一个隐藏层，如果您有足够数量的节点，嗯，你可以想象好像你不熟悉，这基本上只是一组足够复杂的功能组合，um和函数，这是一个通用函数逼近器。
这意味着你可以用深度神经网络表示任何函数，所以这真的很好，我们不会有任何容量问题，如果我们使用一个充分表达的函数逼近器，这很重要，因为如果你想想我们用线性值函数逼近器做的事情，很明显是这样。
有时你可能有太有限的功能，你就不能表达某些状态的真值函数，通用函数逼近器，um属性说明，对于深度神经网络来说，这不会发生，如果是的话，呃，现在足够富有了，当然啦，你总是可以想到用非常，非常丰富的功能。
然后就等价了，这样你就知道另一个好处是什么，另一个好处是，您可以使用指数级减少的节点或参数，与使用浅网相比，这意味着没有那么多的成分来代表相同的功能，这很优雅，我很乐意在线下谈论这一点。
或者我们可以在广场上谈谈，最后一件事是，你可以使用随机梯度来学习参数，血统，所有的权利，所以这差不多是，你知道的，深度神经网络在五秒钟内，我们现在要谈谈卷积神经网络，一次又一次。
这一切都将是一个相当轻松的介绍，因为你不需要知道细节，为了做作业，除了大部分，理解这些是非常有表现力的函数逼近器的事实，那么我们为什么要关心卷积神经网络呢，嗯好吧，它们在计算机视觉中得到了广泛的应用。
和，如果我们对机器人感兴趣，和其他可以在现实世界中相互作用的代理，我们的主要感觉方式之一是视觉，而且很有可能，我们希望能够在我们的，我们的机器人和我们的人工代理，所以如果你想想这个，嗯。
想想在爱因斯坦的例子中有一个形象，嗯，爱因斯坦身上有一大堆不同的像素，嗯，爱因斯坦的这张照片，假设是一千乘一千，所以它是一千乘一千，嗯，你知道X和Y，所以我们有十到六。
所以这个标准通常被称为前馈深度神经网络，你会有所有这些像素，然后它们将作为输入进入另一层，您可能希望有一堆不同的节点接受输入，从所有这些，所以你可以得到大量的重量，所以你可能有10到6个砝码。
因为这是我们经常想到的，我知道我没有给你足够的细节，但我们通常认为这是一种深度神经网络，在那里我们有许多函数并行，所以它不仅仅是一个单一的，那么所有这些都将以某种复杂的方式变成其他功能。
所以你可以让很多函数并行计算，所以你可以想象你的形象，你有一个函数，计算图像的某些方面，和另一个计算图像其他方面的函数，然后你要结合，以各种复杂的方式将它们结合起来，所以这是在说，对于第一个，也许会有。
你知道吗，一大堆N个不同的函数在计算图像，这里有十个到六个参数，所以如果我们有重量，次数，那么这将是10的6个参数，以吸收所有的x，那是很多，然后如果我们想做不同类型的重量，都是平行的，那将是一个非常。
非常多的参数，我们现在确实有很多数据，但这仍然是大量的参数要表示，它也忽略了一些要点，我们经常用视觉思考，所以如果我们考虑多次这样做并且有很多隐藏的单元，我们可以得到大量的参数，为了避免这种时空复杂性。
事实上，我们忽略了图像的结构，卷积神经网络试图有一种特殊形式的深度神经网络，它试图思考图像的属性，所以特别是图像通常有结构，我们的大脑承诺图像的方式也有结构，以及空间和频率的显著特征。
所以当你有一个卷积神经网络，我们认为有特定类型的运算符，嗯，所以这里的运算符就像我们的函数h 1和h n，我之前说过，它可以是线性的，也可以是非线性的，在卷积神经网络中，我们会有特殊的结构。
这些函数试图，考虑我们可能想要从图像中提取的属性，这里的关键方面是，我们将做大量的权重分担来减少参数，所以我不会说我会有完全不同的参数，每个都吸收了所有的像素，我最终会得到一些相同的局部参数。
然后我把它们应用到图像的不同部分试图提取，例如特性，因为，最终，这样做的重点是，试图提取我们认为有用的特征，预测你是否认识图像中的人脸，或者帮助我们理解Q函数应该是什么，所以关键的想法。
其中一个关键的想法是说，我们将有一个过滤器或接受场，我们会有一些隐藏的单位，所以它将是一个函数，应用于以前的一些输入，在开始的时候，这只是我们图像的一个子集，而不是把整个图像，我们只是要参加。
所以我们只需要一个补丁，现在我们把上面这个角，我们要走中间，所以就像，我们会试着计算一些属性，图像的特定补丁，所以我们可以想象把它通常被称为过滤器，那个小，嗯，我们在补丁上应用的那些权重。
我们可以在图像上到处做，我们经常称之为有一个大步，这意味着你在每个时间点移动这个小补丁的程度，还有一个叫做零填充的东西，即在每个输入层上添加多少个零，这决定了如何，在这种情况下，你的输出是什么。
如果你有一个2 8乘2 8的输入，你有一个五乘五的小补丁，你要在整个图像上滑动，那么你最终会得到一个二，四乘二四下一层，因为基本上你只要拿着这个，然后你把它移过来一点，你把它移过去。
每次你都要拿这两个五，所以这是五乘五，所以你会有两个五输入x，你要用一些重量点积它们，这会给你一个输出，所以在这种情况下，这意味着我们需要两个五砝码，所以一件事是，我们没有完整的x输入，我们只是要接受。
我们将把X输入的不同部分引导到不同的神经元，你可以把它看作是不同的功能，嗯，但另一个好主意是，我们将对所有东西都有相同的重量，所以当我们把这些重量，我们会有一种，你可以想到他们。
试图从图像的子补丁中提取特征，比如说，是否有优势，所以你可以想象，我在尝试检测，在图像的那一部分有一个看起来像水平边缘的东西，我试着，这是由重量决定的，我在说明，我只是把它移到我的整个图像上。
看看它是否存在，所以现在重量是相同的，你只需在整个图像上移动它们，而不是让你知道10到6个重量，我只有两个五砝码，我把这些应用到同样的，只是把它们放在图像的许多不同部分，所以这就是它的样子。
你有这种输入，你去，嗯，隐藏层，是的，是的，你也在向下采样图像，你为什么要把这件事做好，我们认为大脑经常这样做，它试图提取不同类型的特征，事实上，在深度学习之前的许多计算机视觉都试图构建这些特殊的特征。
像特征或其他特征之类的东西，我认为这些特征捕捉到了图像的一些重要属性，也可能对翻译等事情是不变的，因为我们也认为你知道，不管我是在看，嗯，这样的世界，或者我稍微移动一下我的头，嗯。
我看到的特征通常是相同的，我是向左移动还是向右移动，一点点，世界上有一些特别突出的方面，这将与检测有关，是否有一张脸，并与决定我的值函数相关，所以我们想提取特征，我们认为将代表这种翻译，不变性。
所以这也意味着不仅仅是计算你，你可以这样做，您在整个功能中使用相同的权重，整个图像，然后您可以对多种不同类型的功能进行此操作，所以有一个很好的讨论，更深入，从你们中的一些人可能拿走的2-3-1-N。
有一个很好的动画，他们展示了，好的，想象你有你的投入，你可以把这看作是一个图像，然后你可以在上面应用这些不同的过滤器，你可以把它想象成试图检测不同的特征，然后你在你的图像周围移动它们。
并查看该功能是否存在于任何地方，所以你可以用多种不同类型的过滤器来做到这一点，你可以把这看作是试图寻找，不管是那样还是那样，你知道，水平或垂直不同类型的边缘，嗯，这些给你不同的功能。
基本上是被提取出来的，嗯，CNN中另一个真正重要的事情是所谓的汇集层，它们经常被用作一种，向下，对图像进行采样，所以你可以做像最大池这样的事情，检测是否存在特定特征，嗯，或者取平均值或其他方法，呃。
压缩你得到的信息，只要记住在这种情况下，在许多情况下，我们将从一个非常高维的输入开始，像x可能是一个图像，并输出像，嗯，你知道的，Q值，所以我们必须以某种方式进行高维输入，然后放慢速度。
直到我们可以得到一个低维的输出，所以最后一层通常是完全连接的，所以我们可以再次思考之前的所有过程，本质上是计算一些新的特征表示，所以基本上从这里到这里，我们正在计算图像的新特征表示。
然后在最后我们可以取一些完全连接的层，就像做线性回归，并用它再次输出预测或标量，我也知道，对于你们中的一些人来说，这是一种快速的浅层复习，对于你们其他人来说，这显然不在，呃，这将是一个旋风式的介绍，嗯。
但我们不会要求你知道很多这些细节，一次又一次，如果你有什么问题就去参加一个会议，请随时联系我们，好的，所以这些类型的表示，深度神经网络和卷积神经网络，两者都广泛应用于深度强化学习，嗯。
所以大约是在2014年，我在哪里车间，大卫·西尔弗开始谈论，我们如何对雅达利使用这些类型的近似值，那么为什么这令人惊讶，我只是想把所以带回来，在1994年左右，大约1994年，我们有TD双陆棋。
使用深度神经网络，他们使用神经网络，我想有些死深，他们得到了一个世界级的双陆棋玩家，所以那是很早的时候，然后我们得到了周围发生的结果，从1995年到1998年，它说函数逼近，无法收敛。
所以我们上次讨论过这个，一般来说，一旦我们开始做这个函数近似，即使使用线性函数逼近器，嗯，当您结合策略控制引导时，这意味着我们在做TD学习或Q学习，嗯和啊，函数逼近器。
然后你就可以开始有这个有挑战性的三联，嗯，这通常意味着我们不能保证收敛，即使我们保证会聚，解决方案可能不是一个好办法，所以早期有一个令人鼓舞的成功，然后在90年代中期有了这些结果。
我们正在努力更好地理解这一点，这表明事情可能会非常糟糕，有一些，除了理论结果，有一些简单的测试用例，嗯嗯，你知道，这些出错的简单案例，所以这不仅仅是原则上可能发生的，但也有失败的案例。
所以我想在那之后的很长一段时间里，社区有点远离深度神经网络，暂时，人们对使用它们相当谨慎，因为它们显然是简单的案例，函数逼近开始变得非常糟糕，理论上，人们可以证明它可能会变得很糟糕。
所以在很长一段时间里，人们对它的关注较少，然后嗯，深度神经网络的兴起，你知道2000年中期的人喜欢，现在，嗯，所以深度神经网络变得巨大，他们显然取得了巨大的成功，对于视觉和其他领域，有一大堆数据。
有一大堆计算，他们得到了非常非凡的结果，所以也许这是很自然的，就像在，像二十个，DeepMind将它们结合在一起，在雅达利上取得了一些非常惊人的成功，所以我认为这真的改变了人们对，使用，嗯。
这些复杂的功能，近似计和RL，在那个，是呀，它可能无法收敛，是呀，事情可能会变得非常糟糕有时在练习中确实会变得非常糟糕，但也有可能经常，尽管如此，你知道我们并不总是完全理解，为什么他们总是工作，嗯。
在实践中经常，我们现在仍然可以得到相当好的政策，我们常常不知道它们是否是最佳的，我们经常知道它们不是最佳的，因为我们知道人们可以玩得更好，但这并不意味着他们可能不太好。
所以我们看到了对深度强化学习的兴趣的复苏，是啊，是啊，我想从你的角度来看，深度学习解决了什么问题，他们在90年代中期提出的问题，还是只是通过计算能力的增加，以及收集大量数据的能力，当它失败的时候。
这并不重要，我们可以尝试一些不同的东西，比如阅读，你知道的，再试一次，重新把它放在一起，然后一直尝试直到成功，我想我的问题是，我们实际上克服了90年代末出现的任何问题，还是我们只是在努力解决这个问题。
就是，你知道的，我们如何从根本上解决90年代末的一些问题，或者嗯，我们是不是有点残忍地强迫它，嗯，我认为1995年出现的一些问题，就趋同而言，现在有一些算法，更真实的，第十一章介绍的随机梯度算法，嗯。
这样就保证了会聚，它们可能不能保证收敛到最优策略，所以还是有很多，还有大量的工作要做，我认为要理解功能，近似器和非策略控制，我认为也有一些算法的想法，我们将在这节课后面看到。
这有助于性能避免一些收敛问题，我觉得人们在进入2013年的时候就知道了，二十四，所以他们试着好好想想，2。什么时候会发生这种情况？我们怎样才能避免一些事情，比如导致这种情况的原因，所以至少在算法上。
我们可以尝试让人们经常谈论的稳定性，所以我们能试着确保深度神经网络，似乎并没有开始有向无穷大移动的重量，至少在经验上有更稳定的性能，是呀，所以具体到目标，你有没有避免这个问题，我只是不知道，我为自己想。
但事实并非如此，事实上，在最初的实验中他们更新了性能以实时匹配所有这些，他们致力于政策问题，为了避免这个问题，问题是在这种情况下，呃，或者在雅达利的情况下，就像，你知道的，他们是否改变了事情。
以更多地关注政策，或者或者嗯，我们知道它可以更稳定，嗯，他们在做深度学习，在这种情况下，深度Q学习，所以它仍然很不稳定，但他们会做些什么，网络更新的频率，试着让它更稳定，这些都是很好的问题，让我。
我们看看它在那里是如何工作的，任何其他人，好的，很好很好，我们很快就会看到一个突破的例子，嗯，他们的所作所为，嗯，所以再一次，现在，我们将讨论使用深度神经网络来表示值函数，嗯，下周不久。
我们将讨论使用深度神经网络来表示政策，那么我们该怎么办，我们会再次，有我们的重量，我们将有相同的近似值，现在我们将使用深度神经网络，在这种情况下，只是想说清楚，我们将使用Q函数，因为我们希望能够控制。
所以我们要做的是，在这种情况下的控制，嗯，所以我们需要学习行动的价值，在雅达利说清楚，它通常没有一个真正高维度的动作空间，通常在4到18岁之间，取决于游戏，嗯，所以它是相当低的维度，公平地，它是离散的。
相当小，所以尽管状态空间是巨大的，因为它是像素，它的图像，嗯我，动作空间很小，所以作为Q学习的提醒，我们看到的是Q学习是这样的，为了我们的体重，我们必须得到函数的导数，这不一定会是线性的。
但是我们更新体重的方式是，我们做了一个TD备份，我们有这个目标，嗯，但我们现在要拿一个最大值超过一个最大值，我们的下一个州，和我们的行动，我们的重量现在注意到这个方程，你看到的所有W在右手边都是一样的。
所以我们用相同的权重来表示我们的当前值，我们用同样的重量插进去，并得到我们未来价值的估计以及我们的衍生品，我们将看到的一件事是它是另一种选择，好的，所以他们的想法是。
我们真的希望能够使用这种类型的函数逼近器，这些深度函数逼近器来做雅达利，他们选择了部分雅达利，嗯，我想至少德，和，我想戴维斯和大卫都是在电子游戏方面联合创业的，很久以前，我想是在大卫回到研究生院之前。
如果我没记错的话，嗯，所以他们都对这个感兴趣，很明显，游戏对人们来说往往很难学习，嗯，所以这是一种很好的智力展示，他们认为我们可以接触到这个，有一篇论文发表了，忘记了什么时候，可能是2011年。
谈论雅达利游戏和模拟器，作为，对RL来说是一个有趣的挑战，那么在这种情况下会发生什么，嗯，状态将是完整的图像，动作将相当于，你在游戏中通常可以做什么，这通常在4到18岁之间，大约四到十八个动作，嗯。
回报可以很好，真的无论你想要什么，但你可以用分数或其他方面来，嗯，呃，作为代理奖励，一般来说我们会考虑得分，那么会发生什么，嗯，他们将使用一个特定的输入状态，我们以前讨论过一个表示是否是马尔可夫的。
在这些游戏中，你通常需要有速度，因为你需要速度，您需要的不仅仅是当前的图像，所以他们选择做的是，嗯，你需要使用之前的四帧，所以这至少可以让你抓住球的速度和位置，诸如此类的事情，嗯，这并不总是足够的。
有人能想到一个例子吗，可能是雅达利游戏，我不知道有多少人玩雅达利，嗯，我这可能还不够，在你知道的地方，对于最后四个图像仍然可能不够，或者是不够的游戏类型，如果你想在前一个房间拿一件东西。
然后你很晚才用它，在微上是完全正确的，就像蒙特祖玛的复仇，你经常要拿钥匙的东西，然后你得抓住那把钥匙，然后嗯，也许它在屏幕上是可见的，也许不是，嗯，然后呃，但也许它储存在某个地方的库存中。
所以你必须记住你有它才能做出正确的决定，很久以后，或者你可能在早期看到了一些信息，所以有很多游戏和任务，嗯，即使是最后四帧也不会给你所需的信息，但这是一个不错的近似值，这比代表整个历史要容易得多。
所以他们从那个开始，所以在这种情况下，有18个操纵杆按钮位置，或者可能不需要在特定的游戏中使用所有这些，奖励可以是现在分数的变化，请注意，这可能很有帮助，也可能不是，这取决于游戏，所以在一些游戏中。
你需要非常非常长的时间才能到达，任何你的分数可能会改变的地方，所以在这种情况下，你可能会得到很少的奖励，在其他情况下，你会得到很多奖励，所以学习该怎么做就容易多了，他们在论文中做的一件重要的事情。
这是一篇2015年的自然论文，他们在所有游戏中使用相同的架构和超参数，现在我想说清楚，然后他们将学习不同的Q函数和每个游戏的不同策略，但他们的观点是，他们不必使用完全不同的架构。
并对每一个游戏分别进行完全不同的超参数调整，为了让它工作，这真的是那种将军，UM体系结构和设置，足以让他们学会为所有的比赛做出正确的决定，我认为这是对这篇论文的另一个很好的贡献，就是说，嗯。
我们会试着得到一个通用的算法和设置，这将远远超出正常的那种，我们在强化学习论文中看到的三个例子，但它将努力在所有50场比赛中表现出色，经纪人将在五十场比赛中从头开始学习，嗯。
但它将以相同的基本参数这样做，相同超参数，和相同的神经网络，所以同函数逼近器，好的是我认为这实际上是大自然所需要的，他们也发布了源代码，所以你可以玩这个，那么他们是怎么做好的呢，他们要做价值函数逼近器。
它们代表q函数，他们会最小化均方，随机梯度下降损失，但我们知道这可以与值函数逼近器发散，这其中的两个问题是什么，嗯，一个是嗯，在那里，样本之间的相关性，这意味着如果你有，这是一个R s素数，素数r素数。
它是双素数，如果您考虑值函数或返回对于s是什么，值函数和s素数的返回，他们是独立的吗，没有权利，事实上，就像你期望它们高度相关一样，他们可能是你知道的，我的意思是这取决于s质数的概率。
如果这是一个确定性系统，它们之间唯一的区别是r所以它们高度相关，这些不是身份证样本，当我们做更新的时候，有很多相关性，嗯，还有非静止目标的问题，那是什么意思，这意味着当你试图进行监督学习时。
并训练您的值函数预测器，你并不总是有相同的V PI神谕，它告诉你真正的价值是什么，随着时间的推移，这种情况正在改变，因为你在做Q学习，试图估计那是什么，你的政策正在改变，如此大量的非平稳。
所以你没有固定的目标，当你甚至只是试图适应你的功能，因为它可能在每一步都在不断变化，嗯，所以你改变了你的政策，你改变体重，然后你改变你的政策，现在你又要改变体重了，所以这也许并不奇怪，就收敛而言。
事情可能很难，所以那种呃，DQN深度Q学习地址，这些是由经验丰富的重播和固定的Q目标，体验重播，你们很多人都听说过这件事，如果你以前学过DQN，我们将存储所有数据，我们以前谈过一点，在他们的标准方法中。
如何像TD学习一样，现在只使用一个数据点，这里的数据点其实是，A r s素数元组，以最简单的TD学习或Q学习的方式，你用一次，你把它扔掉，这对数据存储很好，而且对性能不太好。
所以我们的想法是把这个储存起来，我们将保留一些有限的先前经验缓冲，我们基本上要重做Q学习更新，记住这里的Q学习更新是这样的，我们会更新我们的体重，这被认为是一个更新，以获取一个元组并更新权重。
就像一个随机梯度下降更新，所以你可以从你的经验中吸取教训，嗯，重播你的重播缓冲区，给定当前的Q函数，计算目标值，然后你做随机梯度下降，现在，注意这里，因为你的Q函数会随着时间的推移而变化。
每次更新相同元组的，您可能有不同的目标值，因为你的Q函数已经改变了，所以这很好，因为基本上这意味着你重用你的数据，而不仅仅是使用每个数据点，一旦你可以重用它，这可能会有帮助，我们一会儿再看。
所以即使我们把目标当作标量，体重会在下一轮更新，这意味着我们的目标值会改变，所以嗯，你可以传播这些信息，主要的想法是我们要不止一次地使用数据，这通常很有帮助，是的，呃，邻居，我的问题是。
这是否相当于在我们的表示中保留了更多的帧，或者这不是很好的问题吗，这相当于在我们的表示中保留更多的帧，它不是，虽然这是一个非常有趣的问题，嗯，更多的帧就像保持一个更复杂的状态表示。
但您仍然可以使用州诉讼，奖励下一个状态元组一次，并扔掉该数据，这就像说我周期性地喜欢，假设我去了一个一个一个一个两个，然后我继续前进，现在我在喜欢三三三三四，所以这就是我在这个世界上的真正位置。
我现在处于第四状态，就像我突然假装，哦等等，我要假装我回来了，1拿了1拿了R 1我去了2，我要再次更新我的体重，更新会与以前不同的原因，是因为我现在用我的第二次更新和第三次更新更新了。
所以我的Q函数一般会和以前不一样，所以它会导致不同的重量更新，所以即使它和以前是相同的数据点，它会导致不同的体重更新，和一般情况下，我们很久以前谈论过的一件事是，如果你做TD学习收敛。
这意味着你像无限长的时间一样检查你的数据，至少在表格中，这相当于如果你学习了一个MDP模型，你学会了过渡动态和奖励模型，你刚刚用它做了MDP计划，这就是TD学习的汇合点。
如果你在无限长的时间内反复浏览你的数据，最终会汇聚到，就像你学会了一个模型和一个动态模型，奖励模型，然后为此做了计划，挺酷的，所以这让我们更接近那个，嗯，我，但我们不想一直这样做，因为有一个计算权衡。
尤其是在这里，因为我们在游戏中，嗯，在计算和获得更多的经验之间有一个直接的权衡，这实际上是一个非常有趣的权衡，因为在这些情况下，这有点像，你是否应该考虑更多，计划更多，使用你的旧数据。
还是你应该积累更多的经验，但我们可以稍后再谈，是啊，是啊，问题和名字第一，拜托了，所以体验重播缓冲区有一个固定的大小，只是为了澄清理解，这些样品在固定的时间后被新的样品替换了吗。
或者有没有特定的方法来选择将哪些样本存储在缓冲区中，大问题，也可以，这可能是一个固定大小的缓冲区，如果是固定大小的缓冲区，你怎么挑，里面有什么，并且是最近的，你怎么把东西弄出来，如何从中删除项目。
这是一个非常有趣的问题，不同的人通常做不同的事情，它通常是最近的缓冲区，嗯可以，比如说，最后一百万个样本，这给了你一个亮点，我们将要谈论的样本有多少，嗯一个，但你可以做出不同的选择，还有一些有趣的问题。
你应该把什么东西踢出去，嗯，这也取决于你的问题是否真的是非静止的，我的意思是，就像现实世界是不静止的，就像你的客户群在改变，当我们试图在继续体验和，比如新的数据点和回复它。
我们会做一些类似于开发和探索的事情吗，本质上就像随机概率一样，只是决定重播关于我们如何在，就像你知道的，获取新数据以及要重播多少，等等，我们能不能做这种探索开发交易，我想这通常是研究不足的。
人们使用很多不同的启发式，经常，人们对他们更新的内容有某种固定的比例，根据经验，重播和得到嗯，把新的样本放在现在，这是一种启发式的权衡，你当然可以想象试图最优地解决这个问题，但这也需要计算。
这让我们进入了一个非常有趣的问题，元计算和元认知，如果您知道您的代理正在考虑如何对自己的计算进行优先级排序，这是一个超级酷的问题，这是我们一直在解决的问题，好的。
所以DQN做的第二件事是它先有它先保持路线，这个旧数据，它做的第二件事是它有固定的Q目标，那么这意味着什么呢，嗯，所以为了提高稳定性，我们所说的稳定是什么意思，这里，我们不想让我们的重量爆炸，走向无限。
我们看到这可能发生在线性值函数中，用于多次更新，所以记住这里，我所说的目标计算是指奖励加上s质数的γv，所以这本身是w的函数，我们要把W修好，我们在S素数的那个值中使用了几轮，所以不要总是更新。
不管最近的是什么，我们只是要去修复它一段时间，这基本上是让它更稳定，是V星神谕的近似值，所以你真的希望先知把这个给你，每次你到达，你知道的，It’全盛时期，或者你采取行动，得到奖励去S Prime。
你希望神谕告诉你真正的价值是什么，你没有那个，每走一步都可能改变，因为你可以更新重量，意思是不要那样做，保持重量固定，曾经计算过一段时间的质数，大概十步，也许走一百步，嗯，这正好使目标。
你试图将损失降至最低的那种事情，相对于更稳定，所以我们要有，嗯，我们仍然有我们单一的网络，但我们将为该网络保持两组不同的权重，嗯，一个是这个重量减去，叫它减号，因为嗯，可能会有其他公约。
但特别是它是旧的一套重量，我们现在不更新的，这些就是我们在目标计算中使用的，所以这些是我们要用的，当我们要算出s素数的值时，然后我们有一些其他的W，这就是我们用来更新的，所以当我们计算目标值时。
我们再次可以从数据集中采样和体验元组，从我们的经验重播缓冲区，我们用我们的w减去计算目标值，然后我们使用随机梯度下降来更新网络权重，所以这个是和负一起用的，这是和当前的一起使用的，我想有两个问题。
比如直觉上为什么这有帮助，为什么它会让它更稳定，其次除了不稳定还有其他好处吗，从做这两个问题，一个是直觉上为什么这有帮助，这是一个很好的问题，其次是稳定之外，还有其他好处吗，所以直觉上。
为什么这有助于稳定性，在稳定性方面，这很有帮助，因为你基本上降低了目标的噪音，如果你回想一下蒙特卡洛，嗯，在那里而不是用这个目标，就像这个引导目标，我们用的是GT，所以蒙特卡洛是GT，我告诉过你。
好处是，它是V pi的无偏估计器，但缺点是方差很大，因为你只是在总结奖励，直到这一集结束，嗯，所以如果事情是高方差，当你试图在他们身上倒退的时候，会更吵，嗯，你可能是方差，想象我们做某事，采取这种极端。
如果我们想嗯，为了稳定，你总是可以让你的目标等于一个常数，总是可以使它等于零，比如说，如果你永远固定你的目标，您将学习将误差最小化为常数函数的权重，然后就稳定了，因为你总是有相同的目标值。
你总是试图预测，最终你会明白你应该把你的w设为零，那就没问题了，所以这只是为了减少噪音和我们试图达到的目标，如果你把这看作是一个监督学习问题，我们有一个输入x和输出y，RL中的挑战是我们的Y正在改变。
如果你做到了你的Y没有改变，它更容易合身，第二个问题是除了稳定之外，是否有任何好处，我想大部分不是，嗯我，这也在某种程度上降低了传播信息的速度，因为你用的是一套不新鲜的砝码，表示状态的值。
所以你可能会错过对一个状态的价值的估计，因为你没有用新的信息更新旧的，这是我们想做的吗，或者线性近似器是一样的，这是针对复杂问题的，这是深度神经网络特有的，或者可以将其与线性值函数逼近器一起使用。
或任何价值，您可以将其与任何值函数逼近器一起使用，这不是具体的，这真的只是关于稳定，体验回放也是如此，我也是，体验重播只是为了更有效地传播信息，这只会让它更稳定，所以这些并不是独一无二的。
利用深度神经网络，我想他们只是更担心稳定性，用这些非常复杂的函数逼近器，是啊，是啊，在红色中，你有更新九减说，哦，我有一个很好的问题，所以这个，问题是我们是否更新过W减，是呀，我们有。
我们也可以定期更新w减，所以在固定的时间表中，说每五十，或者你知道，每n集，或者每n步，你更新得像每一个，你会把w-设置为w，就像我们知道这是为了给布景打分而做的工作，并且您没有使用与渐变相同的结构。
我们用了很好但有不同的功能，减去函数的值，这怎么会像不破大梯度，就像所有这些假设，别拿着，问题没问题，这在渐变方面真的有效吗，这不是，我是说，这是个很好的问题，这些Q学习是不正确的，梯度下降法。
他们是这样的近似值，他们经常做得非常好，鉴于最近的一些，哪个嗯，第十一章对这类gtd或梯度进行了很好的讨论，时差学习更真实，梯度下降算法，这些真的只是近似值，正是这个，嗯作为点，这不能保证收敛，不过。
这有望有所帮助，但我们不能保证，是啊，是啊，所以如果实际上两个人，有一些周期性的模式，以及它们如何刷新用于计算的方式，呃，这个渐变，问题是，你知道的，在实践中，是不是有某种周期性的模式。
你更新W减的频率，是呀，是啊，是啊，通常有特定的模式或超，它是一个超参数选择，可以选择更新的速度和频率，它将在更快地传播信息和可能更不稳定之间权衡，所以如果你，嗯，你知道如果n是一个。
那么你又回到了标准的TD学习，如果n是无穷大，就是说你从来没有更新过，所以有一个，有一个平滑的连续体，在那里，我们知道喜欢W，有比零更好的初始化，如果你考虑到，我想就像平均值和方差一样。
你会初始化w减吗，就两个W，或者对于w-有更好的初始化，讨论是关于，你知道，我们如何初始化W的影响可能很重要，嗯，那就是我们如何初始化w-，通常我们将w-初始化为与w完全相同，在开始的时候。
它的选择也会影响，当然他们的领先表现，伟大的问题，让我继续，因为我想确保我们也能得到一些扩展，总结一下DQN是如何工作的，它的两个主要创新是，它使用经验回放和固定的Q目标。
它在这种重播缓冲区或重播内存中绘制过渡，您从D中随机抽取迷你批，所以通常一个样本，一个小批次而不是一个单一的，所以也许样本十或其他参数，嗯，你做梯度下降，考虑到那些，嗯，你用这些旧目标计算Q学习。
优化Q网络之间的均方误差，和Q学习目标，使用随机梯度下降，还有一些我在这里没有提到的东西，我们通常在做贪婪的探索，所以你在这里也需要一些时间表，如何腐烂，贪婪，所以他们没有做，原始论文中的复杂探索。
所以这就是它看起来的样子，你进去做多个不同的卷积，他们有图像，嗯，他们做一些完全连接的层，然后它们为每个动作输出一个Q值，好吧，让我把它提出来。
嗯，对于那些以前没见过的人来说，所以好的是他们，所以你即将看到突破，这是一款雅达利游戏，他们所做的就是向你展示代理人所做的事情的表现，所以说，记住代理只是从这里的像素中学习，怎么做。
所以当他们在2014年展示这个时非常特别，和它学习的开始，这种政策，你可以看到，做正确的事情并不是很重要，然后随着时间的推移，随着剧集的增加，它开始学会如何做出更好的决定，有趣的是，正如你所希望的那样。
随着它得到越来越多的数据，它学会做出更好的决定，但人们最喜欢的一点是，呃，你可以学习利用奖励功能，呃，所以说，在这种情况下，它发现，如果你真的只是想让我最大化预期的回报。
对我来说最好的办法就是在那里打个洞，然后一旦我能开始在上面弹来弹去，血，嗯，所以这是你知道的事情之一，如果你要求代理人最大化奖励，它就会，只要有足够的数据，它就会学会最大化回报的正确方法，嗯。
所以这真的很酷，它可以发现一些东西，也许你的策略，人们在第一次学习游戏时也需要一点时间来学习。
所以当他们这样做的时候，然后他们在许多不同的游戏中表现出了相当惊人的表现，很多游戏它们可以做得和人类一样好准确地说，哦耶，我只是想知道为什么，嗯，它在打球就像在周围打了很多球，好像不确定自己的动作。
就像它在不同的地方移动，经常喜欢桨，是啊，是啊，是啊，是啊，所以嗯，你可能会看到，我想我可以提到踏板移动了很多，就像特工试图了解的那样，就像我们看到你去，你为什么要从探员的角度。
尤其是如果搬家有成本的话，那么它可能只是在胡言乱语和进行探索，只是想看看什么管用，从我们的角度来看，这样做显然是一个没有经验的球员，那将是一件奇怪的事情，但从代理人的角度来看，这是完全合理的。
它没有变得积极或消极，从中得到奖励，所以它不能区分，你知道吗，保持静止与向左或向右，如果你为移动支付费用，这可能会有所帮助，这可能会在报纸上报道，但是他们为什么要引进一种，里面可能有一个，我在那里。
我不记得完整的网络体系结构问题了，里面是否有汇集层，我想里面可能有，他们必须从图像一直到，但他们有完整的架构，所以你可以在这里看到的好东西是，他们在许多不同的雅达利游戏中获得了人类水平的表现。
这里大约有50场比赛，嗯，我想说清楚，当他们说人类水平的表现时，这意味着渐近，所以在他们训练好他们的经纪人之后，他们说他们不是在谈论他们或他们的经纪人花了多长时间才知道，你们会在第二个家庭作业中发现。
可以是很多经验，有很多时间学习，如何做好业绩，但尽管如此，在很多情况下，就游戏而言，这可能是合理的，嗯，所以他们在一些领域做得很好，有些领域他们做得很差，嗯，人们对这些很感兴趣，尾巴底部的游戏。
通常被称为那些艰苦的探索游戏，我们可能会谈谈，呃，我们将在以后的课程中更多地讨论探索，那么关键的是什么，所以我很喜欢，这篇论文有很多可爱的地方，其中一个很好的事情是他们做了一个很好的消融。
研究和我们了解什么是重要的特征，如果你看看这些数字，我认为很明显，真正重要的功能是重播，所以这是他们的表演，使用线性网络，深度线性网络使用固定队列似乎没有太大帮助。
这里的固定队列意味着使用像固定目标一样的，好的，这让你有点，十比三，你做重播，突然间你就变成了二百四十一个，所以扔掉每个数据点，你用过一次不是一件很好的事情，您想重用该数据，嗯。
然后如果你把重播和固定Q结合起来，你确实得到了进步，但是呃，你真的得到了巨大的增长，至少在其他一些游戏中爆发，通过重播，现在在其他一些，嗯，你开始得到显著的改善，一旦你使用一个更复杂的函数逼近器。
但总的来说，重播是非常重要的，它给了我们一个更好的方法来使用数据，是啊，是啊，在这张桌子上判断，似乎你想在线性模型中使用重播和固定Q，在这里使用深度模型可能是一个错误，你同意这张桌子上的观点吗。
也许你可以用线性的，哦，所以我想我应该说清楚，所以这就是所有的一切，接下来的四个都很深，所以他们没有这里，线性加回放，但你当然可以想象尝试线性加重播，似乎你在这里会做得很好，这可能取决于您使用的功能。
有一些很酷的工作，嗯，呃，在过去的几年里，也在观察，呃，你能不能把这两者结合起来，所以我们用贝叶斯最后一层做了一些工作，用贝叶斯线性回归，这对不确定性很有用，其他人刚刚做了线性回归。
这个想法是你在某种程度上是一个深度神经网络，然后你就做了，嗯，一种直接的线性回归，以准确地拟合最后一层的权重，因此，这可以提高数据效率，但你仍然有一个复杂的表示，所有的权利，所以从那以后。
人们对这个领域产生了巨大的兴趣，又是这样，和自己约会，强化学习过去常常去做一个关于强化学习的演讲，大约40个人会出现，你认识的大多数人，然后，嗯，然后，它开始真正改变，我想可能是在2016年，嗯。
icml在纽约，突然间有四百人在房间里进行强化学习讲座，今年在纽瑞普斯，这是主要的机器学习会议之一，八分钟就卖光了，所以有八千人在那里，人们对深度学习非常感兴趣，和深度学习工作坊。
你有一个2000人的礼堂，所以基于这项工作，有大量的兴奋，我认为这真的是一个巨大的荣誉，大卫的工作，银和其他人一直在做，嗯，以表明这是可能的，呃，我们很快就会经历的一些直接的改进，这里是嗯双DQN。
分清轻重缓急，重播与决斗DQN，比这多得多的文件，嗯，但这些是DQN早期的一些真正大的改进，所以双DQN有点像双Q学习，我们在几节课结束时简短地讨论了一下，我们讨论的是这种最大化偏差。
估计状态动作值的最大值，可以是真最大值的有偏估计器，所以我们简短地讨论了双Q学习，所以在双Q学习中，我们的想法是维护两个不同的Q网络，嗯，我们可以选择我们的行动使用像E贪婪的政策。
我们在这些Q网络之间的平均值，然后我们将在一个状态下观察奖励，我们基本上用其中一个线索作为另一个线索的目标，所以如果你知道，有百分之五十的可能性，我们要更新一个网络。
我们将通过从另一个网络中挑选动作来做到这一点，这是试图区分我们如何选择我们的行动，与我们对该行动价值的估计相比，来处理这种最大化偏差问题，然后有50个其他的概率，我们更新Q 2。
我们从另一个网络中选择下一个动作，所以这是一个相当小的变化，意味着你必须保持两个不同的网络或两组不同的权重，嗯，它可以很有帮助，所以如果您将这个想法扩展到DQN，您有我们当前的Q网络W选择操作。
这个旧的是用来评估动作的，所以你可以把这个放在那里做动作选择，然后你可以用你的其他网络来评估它的价值，其他网络权重，所以这是一个相当小的变化，这与我们已经为目标网络权重所做的非常相似，事实证明。
它给你带来了巨大的好处，在很多情况下为了雅达利游戏，所以这是通常非常有用的事情，嗯，并立即显著提高性能，所以你知道，相当于少量的编码，这是一个想法，这是一种直接的提升，你知道的。
双Q学习第二件事是优先级重播，所以让我们回到火星探测器，例子，嗯，所以在火星探测器上，我们有一个非常小的领域，我们在讨论七个州的表格设置，我们在谈论一项总是采取行动的政策，一个结果大多向左的。
所以我们有这个轨迹，我们从三号州出发，1。我们采取了行动，我们得到了零奖励，我们去了二号，我们在S 2呆了一轮，当我们做一个，然后最终去了一号，然后我们终止了，原来是这样，第一次访问蒙特卡洛时。
每个州的v估计是1-1-0，零零零，alpha等于1的TD估计是这样的，那时我们谈到了TD只使用每个数据点的事实，一次，它没有把信息传播回来，所以TD学习的唯一更新是当我们到达状态1时。
我们采取了行动一，我们得到了一个奖励，然后我们终止了，所以我们只更新了状态一的值，所以现在让我们想象一下你要做什么，所以现在让我们想想你喜欢重播缓冲区是什么，在这种情况下，你会有这样的东西。
你会得到3 a 1 0 s 2 s对1，结束，终止，这就是你的重播缓冲区的样子，所以假设您可以选择两个重播备份来这样做，您有四个可能的重播备份，如果你愿意，你可以选择两次相同的，我会要求你选择重播备份。
以某种方式改进值函数，我想让你想一想，或者和邻居谈谈你应该从这两个中选择哪一个，为什么你会按哪个顺序做，以及这是否有什么不同，也许你只挑这些中的任何一个都无关紧要，你会得到相同的值函数，不管你怎么做。
是不是有两个更新特别好，如果是的话，你会按什么顺序做呢？希望你有机会考虑一下，一秒钟，首先，这有关系吗，所以我首先要问你们问题投票，如果你认为根据价值函数选择哪一个很重要，你出去，这是正确的。
所以根据结果值函数选择哪两个绝对重要，您不会得到相同的值函数，不管你选哪两个，嗯，现在我要求再投一次票，所以问我们应该先做哪一个，我们要不要更新一下，我们应该做四个吗前四个是重播缓冲区的最后一个。
我们应该先做三个吗，我们应该先做两个吗，所有的权利，所以三个人都有有人想解释一下为什么，我想这对你的背部有帮助，将状态一已有的信息传播到状态二，哦耶，是啊，是啊，所以这是对的，所以如果你选择，嗯备份三。
后援3号是什么？是s 2 a 1 0 s 1，所以如果你做备份，那是零，加上s素数s 1的v的γ，这是一个，所以这意味着现在你要倒车了，现在s2的v等于1，所以你可以备份这些信息。
所以我不是很清楚在这里做什么是正确的，但是A，但我最主要的是，我想强调的是，这有很大的不同，那个嗯，就顺序而言很重要，我们下一步该怎么办？我们应该举起你的手吗，如果我们再做三次，举起你的手。
如果我们应该做两个，举起你的手，如果我们应该做一个，是的，有的人有，呃，我想解释一下为什么，是啊，是啊，在后面，和上次一样，现在你必须去，所以你想把它传播回学校，这是正确的，是啊，是啊。
所以如果你想一路去蒙特卡洛，估计你想在这里做什么，你想做的是三一一零二，这将允许您的B中的三个更新为一个，此时你的值函数将与蒙特卡洛完全相同，所以这绝对很重要，重要的是，你做这件事的顺序，如果你做了。
你的S 3也不会改变，所以订购会有很大的不同，所以我们不仅要思考之前提到的问题，但我想说，就像，我们应该在重播缓冲区中放入什么，你不仅要考虑重播缓冲区中应该有什么，而且我们要按什么顺序取样。
在收敛速度方面会有很大的不同，尤其是几年前的一些非常酷的作品，从形式上看，排序是如何重要的，嗯，所以在2016年有一份报纸，试图看看最优顺序是什么，所以想象一下你有一个神谕可以，嗯精确计算，现在。
这将是计算上难以解决的，我们一般不能做到这一点，但想象一下一个神谕可以通过挑选并找出，正确的顺序是什么，然后他们在这个案例中发现对于这种小链条来说，例如，你在收敛方面得到了指数级的改善，这是非常棒的。
那么这意味着你需要做的更新数量，直到你的值函数收敛到正确的东西，它可以指数级地小，如果你仔细更新，你可以有一个神谕，确切地告诉你什么元组，超酷的样品，所以你可以做得更好，但你不能那样做。
你不会把这些都花在，啊，这是嗯，这在计算上非常昂贵或不可能，在某些情况下弄清楚到底是什么啊，甲骨文排序应该是，嗯，但它确实说明了我们可能需要小心，我们做的顺序，所以他们对此的直觉是。
让我们尝试对重播的元组进行优先级排序，根据它的DQN误差，所以在这种情况下，DQN错误只是我们的TD学习错误，所以这将是我们的手推车之间的区别，这基本上是我们的预测误差，这是我们的预测误差。
几乎是我们的预测误差，我就叫它TD，因为它不太，因为我们在做最大值，这就像我们预测的，我会说，如果你有一个非常非常大的错误，然后我们会优先更新更多，你在每次更新时都更新这个安静的数量。
您将新元组的设置为零，一种方法，他们有两种不同的方法来尝试进行这种优先级排序，嗯，但有一种方法基本上采用这些优先级，把他们提升到一些力量，然后归一化，然后是选择那个元组的概率，所以你优先考虑更多的重量。
是啊，是啊，不会先冻僵，请不要冻结旧的重量，或者是传播回信息的计数器，如果你冻结了旧的砝码，我们刚才举的例子，你喜欢繁殖一次回来之后，你就不能再做了，因为你的值仍然是零，提出了一个很好的观点，也就是说。
如果你在修复，嗯，呃你的w减，如果你在看我们以前的案子，那么你就不能继续把它传播回来，因为你还没有更新，是啊，是啊，完全正确，所以会有这种紧张关系，当你修复事情而不是传播信息时，嗯，这是一种紧张。
人们必须弄清楚，不一定有原则性的方法来确定正确的时间表，但这样做是一个超参数，点菜有什么关系呢？如果你在修理，所以你没有改变对吧，那就无所谓什么顺序了，我们以前的都取样了，对吧？好的。
所以基本上秩序问题也是如此，在这种情况下，这仍然很重要，因为我们仍然会做，重播，权重将在其中的时间段内发生变化，将在缓冲区上重播，所以缓冲区可能有一百万，你可能会更新你的体重，就像每50步或类似的事情。
所以在一个，在您的重播缓冲区中，现在考虑这一点很有用，你的体重变了，您需要什么订单？这是个很好的问题，另一边，好的，那么这是什么方法呢，我来澄清一下，如果我们设alpha等于零。
在现有元组中选择的规则是什么，所以出来，所以圆周率基本上是我们的DQN错误，如果我们设alpha等于零，是啊，是啊，所以这种在制服之间的交换，没有优先级来完全选择我喜欢的那个，如果alpha是无穷大。
那么这将是选择DQ和误差最高的一个，所以这是一个权衡，这是随机的，所以他们把这个和原因结合起来，我选了这三个顺序做，它们都是一层一层的吗，所以优先考虑重播和嗯，我想这是优先重播，加DM。
双DQN与仅双DQN，大多数时候，嗯，这是零，会是，呃，香草DQ双DQN更好，上面的意思是优先级重播更好，大多数时候优先级重播更好，这里有一些超参数可以玩，但大多数时候这是有用的，这当然是有用的思考。
你知道吗，在秩序可能很重要的地方，所有的权利，我们剩下的时间不多了，所以我只想做个简短的介绍，只是为了让你意识到这一点，ML 216中最好的论文之一是《决斗》，这个想法是如果你想在这个世界上做决定。
可能有一些状态更好或更差，它们只会有更高的价值或更低的价值，但这是你真正想做的，就是弄清楚在特定的状态下正确的行动是什么，所以你想理解的是这个优势函数，你想知道好了多少还是坏了多少。
采取特定的行动是对的，遵循真正喜欢的现行政策，我不在乎估计国家的价值，我关心的是能够理解哪种行为更有价值，我们在看这个优势函数，所以他们要做的是，与输出所有线索的DQN形成鲜明对比，他们要分开。
他们会首先估计一个州的价值，他们会估计这个优势函数，等于s的q a减去s的v，s的q a 2减去s的v，所以我要把它分开，这是一个建筑选择，然后他们会把这些重新组合成Q，他们争论。
这将帮助我们专注于我们关心的信号，它能够准确地估计哪个动作更好或更坏，关于这是否可以识别，有一个有趣的问题，2。今天我没有足够的时间来讨论这些问题，无法识别，我很乐意在线下谈论所有这些，嗯我那个。
这很重要的原因，它只是迫使一个人做出某种默认的假设，嗯，指定优势，职能，从经验上看，这往往是超级有帮助的，与优先级重播的双DQN相比，我们刚刚看到的，已经比W好了，双DQN，也比DQN好。
这再次给了您另一个性能增益，实质性的，实质性的，所以基本上这是三种，三个不同的，在DQN之后的两年里，它开始制作一些非常大的性能游戏，与完全做香草相比，dqn，嗯家庭作业2，您将实现DQN。
而不是其他欢迎您实施的，其他一些，意识到这一点是很好的，这些都是一些主要的初始改进，以获得更好的性能，雅达利嗯，我把这些留在上面，我们快没时间了，请随意查看这篇文章的最后几张幻灯片。
约翰·舒尔曼的一些实用建议，约翰舒尔曼是伯克利的博士生，那是现在开放的头之一，ai，只有一件事我会确保强调，它可能是超级诱人的，试着从，比如直接在雅达利上实现Q学习，高度鼓励你首先完成作业的顺序。
就像用线性案例做一样，在部署雅达利之前，请确保您的Q学习完全有效，即使是像我们正在研究的乒乓球这样的小游戏，嗯，这是非常耗时的，嗯，所以就理解和调试而言，最好事先确保你知道你的Q学习方法是有效的。
你等了十二个小时看是否，哦，它在乒乓球上什么也没学到，所以有一个原因，我们建立了我们在作业中的方式，另一个实用的技巧，请随意看看那些，嗯和嗯。
P7：Lecture 7 - Imitation Learning - 大佬的迷弟的粉丝 - BV1Cc411h7QQ
All right， so homework two， you guys are probably starting to work on。
We’re having sessions this week that are good for if you don’t have background and deep， learning。
Feel free to reach out and be out。 Oh， yeah。 Just to make sure it seemed perfect to note on the charts that it’s like either default。
or suggested ones。 Can we also do something outside of that？ Questions is a great one。
The post on Piazza， you’re always welcome to design your own project。 That’s always completely fine。
A number of you have come talk to me about those or talked to other TAs。
These are an additional option。 So if people are interested in looking at either the default project。
which we released yesterday， which is to do with Bandits and Warfarin。
or if you want to look at some of the suggestions， from senior PhD students or postdocs。
those are great opportunities。 Particularly， I think if you haven’t ever done reinforcement learning before。
it’s often， I wouldn’t expect it three weeks in that you’d be able to defy the state of the art project。
So if you’re interested in learning more about RL research， then it can be a really great。
opportunity to look at some of those suggested projects that reach out to people。 All right。
The other thing that I just wanted to do a friendly reminder about is we explicitly post。
FAQs for each of the homeworks。 And some of the CAs are mentioning that some of the students coming into ops hours right。
now might not have had a chance to look at those。 So if you have a question when you’re going to learn with homework。
the first thing to， do is to go to Piazza and particularly to look at those pin notes at the very top。
which， have very common FAQs about the assignment。
So make sure to read those before you go to office hours。 And then， of course。
feel free to come to office hours as well。 But those are a really good resource to look at。
Any other questions？ All right。 So just in terms of where we are in the course right now。
we went through DQN on Monday。 We’re going to talk today some a bit more about-- we’re going to wrap up some of the。
stuff that I had to rush through at the end of Monday in terms of deep Q learning and some。
of the recent extensions。 And then we’re going to talk some about imitation learning in large state spaces before next week。
starting to talk about policy gradient methods。 So just as we’ll start off with a refresher from what DQN was doing。
DQN was this idea， of combining between Q learning and using deep neural networks as function approximators。
And the two key sort of algorithmic changes compared to prior work was that they used。
experience replay and fixed Q targets。 And by fixed Q targets there。
that was meaning that when we used our RRT plus gamma max over， a Q of STAST plus 1。
that the weights that were used for that Q representation were fixed， for a while。
So maybe we’d update those every 100 steps or every 50 episodes or some interval。
And so this provided a more stable target for supervised learning because the supervised。
learning part， again， is that we had this combination of we want to have weights and。
we want to minimize this error versus our current estimate。 So minimizing the TD error。
So the way that this proceeded is that we’d sort of store transition in a replay memory， buffer。
We do mini batches， we’d sample a bunch of state extra word， next state tuples and then。
do these backups where we’re sort of updating our Q function and refitting our Q function。
And like a lot of the linear value function methods we saw before， it uses stochastic gradient。
descent。 And the really cool thing about this is that they did it on 50 games。
They use the same architecture for those 50 games and the same hyper parameters and they。
got human level performance。 So we’ve talked quite a lot about that before and then we sort of briefly talked about three。
sort of major extensions to that in the immediate following years。 And again。
there’s been a lot of extensions and a lot of work in deep reinforcement learning， right now。
But three of them were as follows。 The first was double DQN and we talked before we got it to functional approximation talking。
about the issue with maximization bias that when you’re using the same representation。
to pick an action and estimate the value of that action， you can get into a maximization。
bias problem。 And the way that that’s avoided in double DQN。
and I wanted to go over this again because， I had a couple of questions after class。
we didn’t have much time to discuss it， is what， happens is we have a current Q network which is parameterized by a set of weights and that。
is what is used to select actions。 To be clear here， often we’re doing some sort of E greedy method。
So we’d use the current Q network weights to decide on the best action and we would pick。
that with one minus epsilon probability。 And then there is an older Q network that is used to evaluate those actions。
So if we look at how we’re going to be changing our weights， we’re going to be having an action。
evaluation using these other weights， W minus， and then action selection using W。
So when you look at this， it might start to look pretty similar to what DQN was doing。
Because DQN was saying we’re going to use a fixed set of weights for these target updates。
So what DQN was doing was this R plus gamma Q， I’ll write the max in。 And then the max， R， A。
Q of S prime， A， W minus， minus the current S。 So in the normal DQN， they were also using a W minus。
But here in a double DQN， it can be a little bit different。
And the reason it’s a little bit different than what we just saw is that you can maintain。
two sets of weights at all times and you can flip between them on every step or every batch。
So when DQN was introduced， it was more of an idea of you fix your weights， let’s say。
from time step T to time step T plus 100， use the same weights that whole time period。
for your target。 In double DQN， you don’t necessarily have to do that。
you can flip back and forth between， these， which is what we’d seen with a double Q learning that on step one。
you could use， weights one to act and weights two to evaluate。 On step two。
you could do weights two to evaluate and weights one to act。
So it means that you can propagate information faster。
So instead of waiting 50 episodes or 100 episodes to update the weights that you’re using for。
your target， so again， this is your target， you can flip back and forth between them， which。
allows you to update both networks a lot。 Both of them， both of them， the network weights。
the networks are identical。 Yeah。 In general， when we’re evaluating these kinds of different approaches to improve these techniques。
is there basically a trade-off between how fast the information propagates and then how。
unstable it is？ So we might find that if the system we’re trying to learn on is itself relatively well-behaved。
and stable， we want to pick something that has faster information propagation， but if it’s。
highly noisy or unstable that we need to do something that’s more conservative。 Make a suggestion。
which is， you know， is there generally a trade-off in terms of these。
methods between sort of characterizing the stability of the system and then how fast。
you can propagate information back？ Unfortunately， I feel like it’s not very well characterized。
So I feel like most of the time these are heuristics and people evaluate them， they evaluate them。
a lot of different benchmarks and that’s sort of the way we get generalization。
But I don’t think that there’s a good characterization systematically of how to characterize the stability。
of the system with these deep neural networks， particularly in the context of RL。
So there’s a lot of great opportunities for theoretical analysis here too or just sort。
of more formal understanding。 Right now I think we’re at the level of saying this either just seems to consistently work。
a bunch across Atari games and maybe Moojoko or it doesn’t try to characterize the successes。 Yeah。
Yes。 I was wondering if you talk a bit more about the switching that you’re referencing and。
like why how。 Yeah。 So the question is about， you know。
how could we switch between these W and W minus and how， would you， you know。
why and how would you do this？ So in the DQN setting you could set W minus。
So at the beginning W minus is equal to W on time step zero。
And then in DQN you would keep W minus to be the same， maybe for the next 50 episodes。
but you’d be updating W。 And then 50 episodes in you would update W minus。 The downside about that。
which we talked a little bit about before is that you’re not。
using the information you’re getting to update this estimate because you’re using that old。
stale set of W。 So essentially you’re just not using the information you’ve got over those 50 episodes to update。
what would happen if you got an S prime and took action A。
So an alternative would be to flip between， let’s say， instead of thinking this is W and， W minus。
you can think of it that way。 You can just think of maintaining two different sets of weights。
And imagine， I’ll say this is T times equals one， time equals two， time equals three。
So imagine that we’re just picking between what are the weights that we used to select。
an action and that weights that we use to evaluate the action。 So on the first time step。
you could use this to evaluate and this to select the action and。
then you could flip it back and forth。 So that essentially means that both sets of weights are getting updated very frequently。
So instead of updating only one of them every 50 episodes， you’re continuing to propagate。
that information back quickly。 And there’s of course tons of choices here about how frequently do you update。
you know， when do you switch back and forth between these。
You can think of all of those as hyper parameters you can imagine tuning。
But this is instead of keeping that， keeping this target fixed for 50 steps or， you know， end steps。
these are all parameters， you could flip back and forth between them， which is。
what double Q learning did before。 Yeah。 In the normal DQN setting。
when we’re using a target weight， when that target weight， like。
for action selection or for like evaluations， there’ll be another Q network。
So how is that different from double QN， except for the fact that your selection is a little。
bit more often。 It is almost， the question is how different is this from the previous year？
It’s almost identical。 So I think the main difference here is that you could switch。
as long as you’re maintaining， some set of weights for your target。
this is saying you could sort of switch。 Now you really just have you have the same network。
two sets of weights that you have to， maintain in memory。
And what this is saying is you can switch back and forth with those very frequently and。
help avoid the maximization bias during that time。 It doesn’t always work。 It frequently helps。
There is still the issue with stability， but it can be better and it avoids the maximization， bias。
We also talked about prioritized experience replay。
We went through a small sort of tabular example where we looked at the impact of doing backups。
So if we have this experience replay buffer of SARS prime tuples， which one should we use。
to do our backups and how do we propagate that information back。 And in this paper。
they talked about the fact that if you can do this optimally， in some。
cases you might get an exponential speed up in convergence， but it’s hard to do that。
It’s computationally intensive。 So what they proposed here is to prioritize something based on the size of sort of the。
DQ and error， the difference between the current estimate of it and your sort of target estimate。
that you’re looking at。 And so we talked about how you could use that as a priority and it could be a stochastic。
priority to try to select items。 And we also talked about the fact that if we set alpha equal to zero。
this becomes uniform。 And so then there’s no particular prioritization over your tuples。
And then the thing that we had almost no time to talk about was dueling。
So dueling was the best paper from 2016 in ICML。 Let me just give a little bit of refresher on this because we went through it very。
very， fast。 So the intuition here is that the features that you might need to write down the value。
of a state might be different than those need to specify the relative benefit of different。
actions in that state。 And you want to understand the relative benefit of actions in order to decide what your policy。
should be。 So looking at things like game score， it’s obviously very relevant to the value， but it。
might be you might want other features to try to decide what actions to do right now， in a game。
And so the advantage function that came up that was designed by Baird a long time ago。
and this is the same Baird that had that counter example to show why value function。
approximation can be bad。 So Baird’s work before it said， well， look， you can decompose。
you think of your Q function， which is representing the value of a policy starting in state and taking a particular action。
versus the value of just that state。 So this is sort of implicitly Q pi s pi s。
So like what is the difference between taking this particular action versus just following。
your policy from the current state？ And he called this the advantage。
The advantage of that action for that state。 So in Dooling DQN。
instead of having one network that just predicts Q functions， they use an。
architecture that separates into predicting values and predicting these advantage functions。
and then adds them back together。 With the idea being that you might get different sort of features here and here。
So you’d sort of decouple for a little bit to make sure that you’re capturing the features。
that are relevant to capturing the salient things you want to look at for Qs。
Now one thing that I mentioned very briefly last time is that is the advantage function。
identifiable？ And what do I mean by that in this case？ I mean that if you have a Q function。
which is what ultimately we’re going to use， can， we decompose it into a unique A pi and B pi？
So here ultimately we want a Q。 And the question is if we then are in architecture decomposing this into a value and an advantage。
is there a unique way to do that？ But there isn’t。 So if you add a constant to both Q and B。
then you can get the same advantage function。 So there’s not a unique。
you can always shift your words by a constant and that’s not going， to change your policy。
will change your value function。 So there’s lots of different ways to decompose your advantage function and your values。
It’s not a unique decomposition。 So the way that they defined it there is to say。
well let’s force the advantage for state， and action to be zero if A is the action taken。
So here they compare it to the action that’s taken if you’re using sort of say a greedy， approach。
This is really just a way to， all of this we can think of in some ways as an analogy to。
supervised learning。 So we want to have a stable target and we want to be able to learn these advantage functions。
and these value functions if we had lots and lots of data about them。
So this is sort of choosing a particular fixed point for how to define the advantage function。
And then they also said， well empirically you could just use the mean to， so you could just。
average over your advantage functions。 It’s more a stochastic approach。 And what they find， again。
so we sort of were layering up these additional techniques。
We started with DQN and we thought about adding double Q learning to DQN and then we thought。
about adding prioritized replay。 And then this is dueling and what they find is that dueling versus double DQN with prioritized。
replay is a lot better most of the time。 Now let me see if I can find Montezumas。 Yep。
So for Montezumas， this new method is basically no better。
I think none of these methods are really tackling hard exploration problems but they are doing。
better ways of sort of propagating information in the network and trying to change the way。
we’re training the network。 Yeah， question in the back。 A name first please。
Can you speak a bit louder than I’m able to hear you。 Okay， I’ll try to speak a little bit louder。
Can people in the back over there hear me or is it just a pen？ Good。 All right。
so these were three of the methods that ended up making a big difference。
We talked very briefly about practical tips。 I won’t go on these too much。
The main thing is just that we try to actively encourage you to build up your Q&A representation。
first before you try an Atari。 You can try different forms of losses。
Learning weight is important but in this case in our assignment we’re going to be using。
the atom optimizer which means that you don’t have to worry too much about it。
This issue of sort of trying different exploration schemes is something that we’re going to talk。
about later in this class。 So for right now we’re still thinking about just simple e-greeti approaches。
A nice paper that came out， I think it was started 2018， was Rainbow which was a paper。
that basically just tried to combine a whole bunch of these recent methods to see really。
how big of an improvement do you get。 Now， again note in this case and we’ll come back to this in just a couple slides。
This is a lot of data。 There’s a lot of experience in the world， 200 million frames of experience。
They developed an algorithm called Rainbow that combines a lot of the things we’ve just。
been talking about， double DQN， prioritized and Dooling as well as some other recent advances。
Noisy is one that also tries to do some different forms of exploration。
So they found that kind of by adding these improvements together then you could get a。
significant improvement。 I think this is a useful insight because often it’s not clear whether or not these different。
gains are additive or if they’re just sort of， they’re kind of doing the same thing but。
maybe in a slightly different way。 And so it’s nice to see that in some of these cases these different sort of ideas are additive。
in terms of the resulting performance gain。 These aren’t sort of。
this is still a very large amount of data。 Okay， so just to summarize。
which are wrapping up where we are with model-free deep neural， networks for RL right now。
They’re very expressive function approximators。 You should be able to understand how you represent the Q function and you can do some Monte。
Carlo based methods or TD style methods。 And at this point it’s sort of good to make sure you understand how you would do that。
with tabular methods， with linear value function methods and with deep neural networks。
So sort of algorithmically it looks very similar across all of those but then you， in some。
cases you have to do this step of doing function approximation in other cases you don’t。
And then it would be good to just make sure you can sort of list a few extensions that。
help beyond DQN and why they do。 Alright， so now let’s go back to our sort of high level view of what we want from a reinforcement。
learning algorithm。 These algorithms that are sort of doing optimization， handling generalization。
doing exploration， and doing it all， statistically and computationally efficiently。
And we’ve just been spending quite a lot of time on looking at generalization as well as。
optimization。 But we haven’t talked very much about efficiency。
So one of the challenges is that if you wanted to find efficiency formally like in terms of。
how much data an agent needs to learn to make a good decision， there are hardness results。
that are known。 So our lab has developed some lower bounds， other people have too。
I think we now have basically tight upper and lower bounds for the tabular MDB case which。
indicate that there are some really pathological MDPs out there for which we just need a lot。
of data。 Not a data that you know would not scale very well as you start to go up to really huge domains。
So some of these problems are really hard to do。 Formally you just need a lot of exploration。
We can do something much better than e-greety but we’ll talk about that soon。
But even when we do those much better things than e-greety we can prove that it’s still。
really hard to learn in those we still might need a lot of data。
So an alternative is to say well there’s lots of other supervision that we could have。
in the world to try to learn how to do things and so how can we use that additional information。
in order to sort of speed reinforcement learning。 So what we’re going to do is talk about some about imitation learning today and then we’re。
going to start talking about policy search and policy gradient methods next week。
And those you can also think of as another different way to impose structure because in。
policy gradient methods you always have to define your policy class。
Sometimes that can be a really rich policy class and so maybe that’s not too much of。
a limitation but other times you’re encoding domain knowledge by the class that you represent。
Okay and in particular we’re going to be thinking about imitation learning in large。
state spaces which is exactly the place where you might hope to benefit from additional。
helper supervision。 So if we think about something like Montezuma’s revenge there’s some nice work on looking。
at sort of how far did DQN get in this case。 So Montezuma’s revenge for those of you who haven’t played it is sort of a very long horizon。
game in which you’re sort of trying to navigate through this world and like pick up keys and。
make decisions and it involves a lot of different rooms。
So you can see here what the outline is of all the white squares are basically rooms。
and on the left hand side sort of a DQN that was trained for 50 million frames only gets。
through the first two rooms。 It’s just doing very badly it’s not making very much progress。
Whereas on the right hand side we see something which is explicitly trying to explore and。
it uses some of the techniques that we’ll be talking more about later but notice that。
it still doesn’t get all the way through the game。
And so I think this sort of illustrates the fact that some of these games are really hard。
There has been some really nice additional progress since both with me and Percy Lang’s。
web we now can basically sell Montezumas and there’s also been some really nice work。
from Uber AI lab on solving Montezumas but a lot of the places that people originally。
got traction on this was by starting to use imitation learning demonstrations。
So in particular if we think about cases where ARL might work well， ARL works pretty well。
when it’s easy or certainly we’ve seen a lot of success so far when data is cheap and。
parallelization is easy and it can be much harder to use the methods that we’ve talked。
about so far when data is expensive and when maybe failure is not tolerable。
So if you try to use the methods that we just described to learn to fly like a remote control。
helicopter typically require a lot of helicopters because they would be a lot it would be very。
expensive and so there’s many cases where this type of performance is just not going。
to be practical。 So one of the benefits is that if you can give the agent a lot of rewards you can shape。
behavior pretty quickly。 So one of the challenges in Montezumas revenge is that reward is very sparse。
The agent has to try lots of different things before it gets any signal of whether it’s doing。
the right thing。 And where do these rewards come from？
I think this generally is actually a really deep question but for right now let’s think。
about sort of just even the challenge of specifying rewards。
So if you manually design them that might be pretty brittle depending on the task。
And an alternative is just to demonstrate。 So if you have to write down the reward function for driving a car it’s quite complicated like。
you don’t want to hit roads。 Here hit the hit people you don’t want to drive off the road you want to get to your。
destination and so it’s very complicated reward function to write down but it’s pretty easy。
for most of us to just drive to a destination and show an example of maybe an optimal behavior。
So that’s sort of the idea behind learning from demonstrations。
There’s been lots and lots of work on this but since people started thinking about learning。
from demonstrations or imitation learning I would argue probably that this was started。
roughly 20 years ago around 1999 2000 was a paper which started to think about learning。
rewards from demonstration。 But then there’s been lots of applications to it since so thinking about it for things。
like highway driving or navigation or parking lot navigation。
There’s a lot of these cases particularly in driving right now but where people have been。
thinking and robotics to to think about how do you do demonstrations of like how to pick。
up a cup or things like that to try to teach robots how to do those tasks。
There’s also some really interesting questions too about like you know how do you do things。
like path planning or goal inference and again these sort of cases where it’s quite complicated。
to write down a reward function directly or it might be brittle。
And the problem with brittle reward functions is that your agent will optimize to that and。
it may not be the behavior that you wanted。 So the setting from learning from demonstrations and today I’m going to be somewhat informal。
about whether I call things learning from demonstrations。
There’s also inverse RL and there’s also imitation learning。
And there are sort of differences but a lot of these things are somewhat interchangeable。
Most of this is about the idea of saying that you have some demonstration data and then。
you’re going to use it in order to help either bootstrap or completely learn a new policy。
So the idea is that you might get an expert and maybe they’re a perfect expert or maybe。
they’re a pretty good expert to provide some demonstration trajectories of taking actions。
in states。 And in many cases it’ll be easier for people to do this but it’s useful to think about。
when it’s easier to specify one or the other and what situations are common for each。
So what’s the problem setup？ The problem setup is that we have this state space and action space。
some transition model， that is typically unknown， no reward function and instead sort of a set of teachers demonstrations。
from some particular， we assume for now optimal policy。
And in behavior cloning we’re going to say how do we directly learn the teacher’s policy？
So how do we try to， how do we get sort of an approximation of pi star directly from。
these demonstrations？ Invers RL is typically about saying how can we recover the reward function？
Once we have the reward function then we can use it in computer policy。 And that often。
that last step often is combined with apprenticeship learning。
So that we were both trying to get that reward function and then actually generate a good。
policy with that。 In some cases you might just want the reward function。
Can anybody think of a case where you might be interested in just the reward function？
Maybe you don’t want to recover the policy but you’re just curious about what the reward。
function is of another agent。 Okay。 >> [INAUDIBLE]， >> Yeah。 >> [INAUDIBLE]， >> Yeah。
[INAUDIBLE]， >> So I think this is a great example。 So in a lot of science， biology， et cetera。
you often want to understand the behavior of organisms， or animals or things like that。
And so if you can just look at their behavior， you could say， track monkeys or things like。
that and then use that to back solve。 Like what is their reward function？
What are the goals or preferences？ I think there’s a number of cases where that’s useful and maybe down the line。
maybe there’s， some optimization that will happen。 But generally， often there。
it’s just about understanding like what is the goal structure。
or what is the preference structure of the organism or individual。
That could happen with people too that you might want to understand like the choices people。
are making in terms of commuting or in terms of buying preferences or things like that。
Maybe later you want to optimize for that， but also you’re just curious about how do。
people’s behavior reveal the sort of an underlying reward structure or underlying preference model。
Yeah。 >> [INAUDIBLE]， >> Yeah。 >> [INAUDIBLE]， >> Yeah。 >> [INAUDIBLE]， >> Yeah。 >> [INAUDIBLE]。
Yeah。 >> [INAUDIBLE]， >> Yeah。 >> [INAUDIBLE]， >> Yeah。 >> [INAUDIBLE]， >> Yeah。
As the nice question of like， is the experts behavior an upper bound or are there cases。
also where the agent can go beyond this？ We’re not going to talk too much about this today。
but there’s a lot of work right now， on combining imitation learning with RL。
So there’s a lot of work on say like inverse RL plus RL where for example you might use。
this to bootstrap the system and then your agent would continue to learn on top of this。
There’s also some nice work from Peter Beals group where they looked at assuming that。
the expert was providing like a noisy demonstration of an optimal path。
And so the goal is to learn the optimal path， not the noisy demonstration of it。
So often you do want to go beyond the expert。 There’s limitations to that and we’ll talk about that in a second actually。
What are some of the limitations that you might have if you don’t get to continue to。
gather data in the new environment？ Okay。 So let’s start with behavioral cloning which is probably the simplest one。
Because essentially in behavioral cloning we’re just going to treat this as a standard supervised。
learning problem。 So we’re going to fix a policy class which means sort of some way to represent our mapping。
from states to actions。 And this could be a deep neural network， it could be a decision tree。
it could be lots， of different things。 And then we’re just going to estimate a policy from the training examples。
So we’re just going to say we saw all these times we saw a state and an action from our。
expert and that’s just our input output for our supervised learning model and we’re just。
going to learn a mapping from states to actions。 And early on。
so this has been around really for quite a long time and I should have said， more like 30 years。
there were some nice examples of doing this。 So Alvin was a very early paper and system about thinking about driving down the road。
seen a neural network and was trained at least in part using behavioral cloning or supervised。
learning to imitate trajectories。 Okay， so let’s think about why this might go wrong。 And to first。
let’s think about what happens in supervised learning。 So in supervised learning。
we’re going to assume IID pairs， SA， and we’re going to ignore the， temporal structure。
So if we’re just doing supervised learning in general， we just imagine that we have these。
state action pairs and then maybe we learn some classifier or， yeah， let’s just say a。
classifier to classify what action we should do and it might have some sort of errors。
It might have errors of probability epsilon。 And so if we were thinking about doing this over the course of T time steps。
then we might， have expected total number of errors of epsilon times T。
So let’s just take a second and think about what goes wrong when we’re doing this in the。
supervised learning or in the RL context。 So by the RL context。
I mean the fact that the decisions that we make influence the next， state。
So let’s just take like one minute， maybe talk to you your neighbor and say like， what。
do you think could be the problem with behavioral cloning and these sorts of scenarios？
And if that’s a simple thing to think about， then maybe think about how you would address， it。
So what you might do in that case if there is problems that happen when we try to apply。
standard supervised learning to this case where it’s really underlying an MDP。 [ Pause ]。
[ Background Conversations ]， [ Background Conversations ]， >> All right， so first of all。
let’s just make a guess。 I’m going to ask you guys whether you think the total expected errors。
if we’re doing this in where the underlying world is an MDP。
is going to be greater than or less than the number of errors that we’d expect according to a supervised learning approach。
So who thinks that we’re going to have greater expected total errors？ Okay。
so who thinks we’re going to have less？ Who many people must be confused？ [ Laughter ]， >> Okay。
so how about so many who thinks the answer is that we’re going to have greater？
Maybe somebody who thinks that’s the case could say why they think we might have more errors if the real world is MDP and we’ve tried to do the supervised learning technique。
Yeah， and name first please。 >> My idea is that kind of like as a human you’re planning a more long term horizon or like you’re doing one step and then you know how that action is going to then give you like another sequence。
But since we just start taking a state in action and then like predicting right from there we can’t plan that long term sequence so it’s going to like compound our errors as we go。
That’s right。 This is a quick way we will compound those errors and one of the challenging aspects of this is that the errors can compound a lot。
And this is because the distribution of states that you get can depend on the actions that you take。
So if you think about this like a navigation case like if I was supposed to go out the right hand door and I watched and go out this door and I saw that he went right and I tried to learn a supervised learning classifier for what I should do here。
My supervised learner was a little bit broken and so instead of going right here I actually went left。
Well now I’m in part of the room which I never went to because he was going over there to go to the door and so like now I have no idea what to do here。
Like now I’m in the state distribution is something that I haven’t seen before。
It’s very likely that I’m going to make an error。 In fact my probability of error now may not be my probability of error here is under assuming the fact that the data that you get in the future is the same distribution as the data you got in the past。
Our supervised learning guarantees generally say when we have them that if your data is comes from an ID distribution then in the future this is what your test is。
The problem is that in reinforcement learning and Markov decision processes your actions determine what is the data you’re going to see。
So the fact that instead of following the right action here I went over here and now I have no data and my data distribution is different。
So now there’s no guarantees for my super bullet by his learning algorithm because my data is different。
It’s never been trained on anything like that so it can’t generalize。
So that’s exactly the problem and this was noted by like Drew Bagnell’s group from CMU in 2011 of arguing that this is a really big problem for what’s called behavioral cloning。
So even though there’d been some nice empirical demonstrations of it he and his former students took on Ross indicated why this might fundamentally be a very big problem and sort of demonstrated some things that people had sometimes seen empirically。
So the idea is that as soon as you deviate so this is the time where you make your mistake then essentially the whole rest of the trajectory might all be errors。
You might make team or team or errors and so that means that the total number of errors that you make is not expected。
Epsilon times t but is that’s one times t squared it’s much worse。
And it’s really due to these compounding errors leading to you to a place where your distribution of states is very different than what you have data about。
And this issue will come up again again to sort of a quote this thinking about what is the distribution of states that you get under the policy or following versus the policy that you want to follow that issue comes up again again in reinforcement learning。
So it really is this sort of foundational issue that you know what is the data distribution you’re going to get under the policy that you’ve learned versus the true policy and looking at this mismatch。
And so once you go off the race course you’re not going to have any data about that。
So one of the ideas that drew back now and his students came up with to think about this was to say well what if we could get more data。
So what if when I you know my I only able to mail data to start with I’ve learned my my supervised learning policy to say you know what should I do in each date and sometimes I make a mistake。
So sometimes you know I go out that way my race car drives off the race course。
What if I could know what to do in that in that state。
So I reached a state that I don’t have any data about what if I could ask my expert。
Hey what should I do now。 So like I go over here and I’m like oh my god I don’t know you know what to do now。
And then you ask your expert and they’re like oh just turn right it’s fine you can still get out of the right door。
It’s okay。 So if you could ask your expert for labels well now you’re getting labels about states that you are encountering。
And as long as all the as long as you have data that covers all the states that you’re going to potentially experience then you’re then your supervised learning should do pretty well。
The bigger issue tends to come up with the fact that you’re in counting in states that you don’t have any coverage of your training data。
So the idea of Dagger which sort of data set aggregation is essentially you just keep growing your data set。
So what happens in this case is you start off you don’t have any data you initialize your policy you follow your policy。
So in this case we’re going to assume that you have an expert some expert policy。
So that might be you know an expert is taking some steps and then also your other policy you can you collect a trajectory。
So sometimes you’re following one policy sentence you’re not and then what you get is you get this state you get to go ask your expert for every single state。
What would you have done here？ So yeah for every state that you encountered in that trajectory and then you add all of those tuples to your data set and you train your supervised learning policy on that。
So everything inside of your data set that you’re using to train your policy on is with an expert label。
And you’re slowly growing the size of that data set。
So the idea is you’re sort of getting more and more experts more and more labels of expert actions across the the strategies you’ve actually seen。
And there’s nice formal properties for this so you can be guaranteed that you will converge to a good policy by following this under the induced state distribution。
Yeah。 Just to confirm this is assuming we have a star of all states。
What are we doing in the case where we don’t have the expert。 Yeah。
no this is a quick question so when I was looking at this just now I would have to tell check I think this is assuming your expert can give you the action there。
It doesn’t assume that you have explicit access to pie star because if you had explicit access to pie star you wouldn’t need to learn anything。
I think in this case it’s like tossing a coin about whether the expert just directly gives you the action in that case or whether you follow the other policy。
Which because you have to have the expert around all the time anyway because they’re always going to have to eventually tell you what they would have done there。
That’s how you get that data set。 So that’s。 And I’m curious about how this is done efficiently。
I can imagine that for some situations having a person sit the command line while your your GPU trains and inputs actions won’t be efficient。
How do people generally do this in such a way that doesn’t require manual intervention。 Yeah。
it was a great one which is you know， well this requires you have an expert either around for every single step or like at the end of the structure that can go back and label everything and that’s incredibly expensive and you if you’re doing this for you know millions and millions of time steps that’s completely。
I think that’s why this this line of research has been less influential in certain ways than some of the other techniques that we’re going to see next in terms of how you do sort of inverse RL。
So what this is really assuming is that you have this human loop that’s really in the loop as opposed to just asking them to provide demonstrations once and then your algorithm goes off。
And I think that practically in most cases it’s much more realistic to say you know drive the car around the box 10 times。
but then you can leave and we’ll do all of our rl versus saying I need you to be in the car or you know like label all of the trajectories that the car is doing and keep telling me whether it’s right or wrong。
I think this is just very label intensive it’s very expensive。
So I think that in some limited cases like if your action rate is very slow。
Like if your action rate is you know making decisions in the military or no others would have very high level very sparse decisions this could be very reasonable because you could basically throw you know infinite compute at it before between each decision making。
If you’re doing this for sort of real time hurts level decisions I think that’s very hard。 Yeah。
With an expert taking over the system right like somebody sitting behind a wheel letting an agent drive and then all like recognizing that there’s an emergency situation coming up and taking the wheel。
Yeah so like so is this compatible with sort of an expert taking over。
Yes I mean I think and that might be an easier way to get labels so you might say if you have an expert there every action that’s taken that’s the same as the action the expert would take maybe they don’t intervene otherwise they only provide labels。
Or interventions when it would differ but it still requires like an expert to be monitoring which is often still mentally challenging essentially you know it’s still high cost。
Alright so that that is a nice I mean it’s very nice to see sort of their formal characterization of why behavior cloning can be bad and what is the reason for this。
And I think that dagger is can be very useful in certain circumstances but there’s a lot of cases where just practically it’s much easier to get an example demonstrations and then assume that there’s no longer a human in the loop。
Alright so inverse RL is more of one of the second categories。
So what does what happens in inverse RL well first let’s just think about you know feature based reward function。
So well okay we’ll get to there in a second so again we’re thinking about this case where we have some transition model that we might not observe or maybe we do in a lot of the techniques here to start with they did assume that you knew the transition model。
That’s pretty strong for a lot of real world domains but in some cases that’s reasonable so for right now we’re going to assume that the only thing that we don’t know is their award function。
There’s some extensions to when you don’t know the transition model to。
So then we have again our set of demonstrations and the goal now is not to directly learn a policy but just to infer the reward function。
So if I don’t tell you anything about the optimality of the teachers policy。
What can be referred about their work function。 I could say like it’s not an expert it’s just demonstrations。
If you get a demonstration of a state action state etc。 Can you infer anything about our。
If you don’t know anything about the optimality。 I’m going to be the same as samples or you get more demonstrations are approved like our story。
This is assuming no assumptions about optimality。 So if I don’t tell you anything about the optimality of the policy or scene。
Is there any or any information you can gather in that case。
Or you’ll be able to say that the choice of the teacher may under their policy。 Just right。
For that particular person you could say something about。
For their reward function assuming that they’re rational agent that that that was higher in their own function。
That’s true。 But if you want it to be about the general word function。
This would tell you maybe I’m staying it so that it seems a little bit more。
Subtle that I mean it to be it doesn’t tell you anything right like if you if you see me like wandering around。
Like if you see an agent flailing around right and you know nothing about whether it’s making good decisions or not。
With respect to the true reward function demonstrations don’t tell you anything like they don’t give you any information about the word function。
Unless you’re trying to make it an assumption that the agent is acting rationally with respect to the true reward function。
Or maybe you can get some information about their internal one like what you’re saying。
But in general if we don’t make any assumptions about agent behavior and we don’t assume that they’re doing anything optimal with respect to the global reward function。
There’s no information you can get。 Now the more challenging one is the next。
So let’s assume that the teacher’s policy is optimal with respect to the true global reward function which the agent is also maybe going to want to optimize in the future。
So you get expert driver performer driver driving around。
This is I think for a second about what you can infer about their award function in this case。
And whether in particular there’s more than one reward function that could explain their behavior。
So think about whether it’s unique。 So let’s say imagine data is no issue。
I give you 10 trillion examples of the agent following the optimal policy。 10 trillion examples。
And you want to see if you could learn what their word function is。
And the question is is there a single reward function that is consistent with their data or their many。
Maybe take a second to talk to somebody around you just to see whether there’s the question really is there one reward function is their unique reward function。
If you have infinite data so it’s not a data sparsity issue versus money。 [ Inaudible ]。
[ Inaudible ]， [ Inaudible ]， [ Inaudible ]， [ Inaudible ]， [ Inaudible ]， [ Inaudible ]。
[ Inaudible ]， [ Inaudible ]， [ Inaudible ]， [ Inaudible ]， [ Inaudible ]， [ Inaudible ]。
[ Inaudible ]， [ Inaudible ]， (indistinct conversation)， I’m gonna do a quick poll。 Okay。
I’m gonna poll you guys， and I’m gonna ask whether you think， there is one reward function。
or if there’s more than one reward function。 So who thinks there’s a single reward function？
Infinite data， single reward function that’s consistent。
Who thinks there’s more than one reward function？ Okay， can someone give me a reward function。
that is always consistent with any optimal policy？ (keyboard clicking)。
I guess what you need to do is， in the first step， just give the older report。
that the teacher is going to have as a policy， and then the random after that。
Maybe on the first step that you could make， give the most of the reward。
that the agent would experience， and then be random after that。 So。
and that might depend on the state。 I guess I was thinking of， can anybody tell me like a number。
which would allow a specification of a reward function， like a constant。
like a choice of a constant， which would make any policy optimal？ Yeah， in the yellow。
- You just give a reward of zero for a reaction。 - That’s right。 - Yes， that is exactly correct。
If you give a reward of zero， any policy is optimal or respect that。
You never get any reward anywhere。 It’s a sad life， unfortunately。 And in this case。
all policies are optimal。 So if you just observe trajectories， then one reward function for which。
that policy is optimal is zero， but it’s not unique。 So this issue was observed。
I think it was by Andrew Ng， and Stuart Russell back in 2000。
Where there is a paper talking about inverse RL， where they noted this issue。
The problem is that this is not unique， without further assumptions。
There are many reward functions that are consistent。 So we have to。
we’re gonna have to think about how do we break ties， and how do we impose additional structure。
Yeah， in the back。 - If you have a consistent reward function business， if you add a constant。
it’s a lower reward。 It’s also a relatively consistent reward function。 - There are lots。 Yeah。
so they’re， oh， remember my mirror name？ So yeah， what you said is， there’s many。
many reward functions。 So if you have a constant， everything has the same， any constant。
but also be identical。 So there’s generally many different reward functions。
that would all give you， there are many different reward functions， for which any policy is optimal。
And so that would mean that if you’re trying， to deliver an inferior word function， given some data。
there are many reward functions， that you can write down so that that data。
would be optimal with respect to their reward function。
And that second part is really what we’re trying to get as。
We’re trying to sort of infer what reward function， would make this data look like it’s coming。
from an optimal policy。 If we assume that the expert is optimal。
So let’s think about also how we do this in， in large state spaces。
So we’re gonna think about linear value function， approximators， because again， often the places。
where we particularly need to be sample efficient， is when our state space is huge。
and we’re not gonna be able to explore it efficiently。
So let’s think about linear value function approximator， and we’re gonna think of this reward also。
as being linear over the features。 So our reward function might be some weights。
times some feature as representation of our state space。
And the goal is to compute a good set of weights， given our demonstration。
I already said that in general， this is not unique。
but we’re gonna try to figure out ways to do this， and different methods。
So the value function for a policy pi， can be expressed as the following， I mean。
just write it down as the expected value， of the discounted sum of rewards。
And this is the states that you would reach， under that policy。
Under the distribution of states that you get， under this policy， these are the rewards。
So now what we’re gonna do is re-express this。 So what we’re doing now is this is gonna be。
assuming a linear representation of our reward function。 So we can write。
we can re-express it like this。 So we can write it down in terms of the features。
of the state we reach on each time step times the weight。
And then because the weight vector is constant， for everything， you can just move it out。
And then you get this interesting expression， which is you basically just have this discounted sum。
of the state features that you encounter。 And we’re gonna call that mu。
So we talked about this very briefly earlier， but now we’re talking about mu as being sort of。
the discounted weighted frequency of state features， under our policy。
How much time do you spend in different features？ Or you know， basically how much time do you spend。
in different states？ It’s for the futureized version of that。
Discounted by kind of when you reach those， because some states you might reach really far。
in the future versus now。 So it’s related to the stationary distributions。
we were talking about before。 Now we’re using discounting。 So why is this good？ Okay。
so what we’re gonna say now is that instead， of thinking directly about reward functions。
then we can start to think about distributions of states， and think about sort of the probability。
of reaching different distributions of states。 Different state distributions as representing。
different policies essentially。 Different policies for a particular reward function。
would reach different distributions of states。 And so we can think about using this formulation。
for apprenticeship learning。 So in this case， we have this nice setting。
for apprenticeship learning right now。 We’re using the linear value function approximation。
We call it apprenticeship learning， 'cause we’re learning like the agents being apprenticeship。
from the demonstrator。 So now we have this discounted weighted frequency， of the feature states。
So we’re always sort of moving， into the feature space of states now。
And then we wanna note the following。 So if we define what is the value function for pi star。
that’s just equal to the expected discount， of some of rewards we reach。 And by definition。
that is better， than the value for any other policy。
At least it’s good 'cause either pi is the same， as the optimal policy or it’s different。
And this is just equal to the same thing， same reward function， which we don’t know。
but under a different distribution of states。 So under the distribution of states。
you’d get to if you follow this alternative policy。
And so if we think that the experts demonstrations， are from the optimal policy。
in order to identify W， it’s sufficient to find W star， such that if you dot product that。
with the distribution of states you got to， under the optimal policy， remember this is what we know。
These are， we can get this from our demonstrations。
This has to look better than the same weight vector， times the distribution of states you’d get。
to under any other policy。 Any questions about that？ So it’s by making this observation。
that the value of the optimal policy， is directly related to the distribution of states。
you get under it times this weight vector。 And that value has to be higher than the value。
of any other policy， which is using that same weight vector。
and just gives you a different distribution of states。 Yes？ - My question。
I conceptualize you by nipple。 In fact， in problem rights， you assume that you need。
to be placed in the environment of the main actor， to convert tests。
So the very state of you in this case is sort of like。
the stationary distribution of the proportion， of the degree to each state given the policy。 - Yes。
In terms of conceptualizing you， what’s the sort of a good way to think of it？
Should we think of it as like the stationary distribution， of states？ Yeah。
I think it’s a reasonable sort of thing， of essentially the stationary distribution of states。
weighted with this discount factor on top of it。 So it’s very similar to the stationary distributions。
we saw before。 All right， so essentially it’s the same。
We want to find a reward function so that the expert policy。
and the distribution of states you reach under it， looks better when you compute the value function。
compared to that same weight vector， under any other distribution of states。
And so if we can find a policy， so that its distribution of states。
matches the distribution of states of our expert， then we’re gonna do pretty well。
So what this says here is that if we have a policy， so the discounted distribution of states。
that we reach under it is close to the distribution， of states that you got from your demonstration。
So this is the expert。 So if that’s small， then your value function error， will also be small。
So for IDW， if you can basically match features， match feature expected features or match distributions。
of states， then you’re good。 Then you found a value that’s gonna have。
a very similar value to the true value。 So this actually means for any WT here。
So it means no matter what the true reward function is。
if you can find a policy so that your state features match。
then no matter what the true reward function is， you know that you’re gonna be close to the true value。
Yeah。 - This still means that when you find you would be， used to calculate， I guess。
an expectation， what your value is of state。 - Yeah， so you could， once you have a W。
you can combine that with your muse， to compute a value of the state。 - Right。
- Or you can sum over it。 - How do you， I guess， that translates directly。
to being able to use that to make decisions， when you’re out of state？
- So I think the question is about saying like， okay， so if we’re getting these Ws。
or sort of what are we solving for resolving， for the policy or resolving for W， et cetera。
In this case， I think a reasonable way to think about it， is solving for Pi。
So what this is saying is that， let’s say you’re optimizing over Pi。 If you found a Pi。
so right now we know the transition model， which is not always true。
But if you know the transition model， for a given Pi， you couldn’t compute mu。
because it’s just following。 Like you could do Monte Carlo rollouts， for example。
So if someone’s given you a Pi， and they tell you the transition model。
you can roll that out and you can estimate mu of Pi。 And it’s saying that if you do that。
so let’s say I have some policy， I roll this out a bunch of times。
I estimate my mu and I check whether that seems， to be close to my mu of my demonstration policy。
If that’s small， this is saying no matter， what the real reward function is。
you’re gonna have the same value as， like you’ve matched the value。
that you would get under the expert policy， so you’re good， you could just use this policy that。
Yeah。 - And I’m looking at the constraint， on the identity norm for W。 - Yeah。
- And I don’t quite see where that comes from。 I’m curious if I’m missing it here。
or if we haven’t gone over it。 - And here’s what why we have this constraint over W。
I would have to double check the details， to be careful about this， but I’m pretty sure it’s there。
so that as we do these backups， we do this approximation that your errors are all bounded。
so that things don’t explode。 And that when you do this proof。
that I think I’d have to double check it， but I think you basically use holders inequality。
and then you use the fact that the W is bounded， to ensure that your ultimate value is bounded。 So。
I can check that。 In general， you want your reward function to be bounded， particularly in the。
even with discounting， like it’s useful， you always need to make sure。
that your bellman operator is like a contraction， to have a hope of， I mean。
we’ve already talked about the fact， that with linear value function approximated。
and you don’t always converge， but if your rewards are unbounded， it gets worse。 Yeah。
- Trying to fit this into other things I’m familiar with。
is this basically like a maximum likelihood， play of looking at the policy， right？
Like if we flip to coin 100 times， and we got nine to nine heads and one tails。
it’s possible that came from a fair coin。 We can’t discount that， but it’s unlikely， right？
So if we observe some expert agent doing the same thing。
100 times that could come from a reward function， at zero everywhere， but not as likely。
as some other reward function， is that–， - Oh， great question。
- Is this sort of giving us some way to deal， with the fact that the reward could be zero。
that we have this sort of unidentifiability problem。 This does not handle that， unfortunately。 So。
this is still not guaranteeing that we couldn’t， learn a weight that’s zero everywhere。
but what this is saying here is that， instead of thinking about trying to learn。
the reward function directly， if you match， expected state features， then that’s another way。
to guarantee that your policy is basically， doing the same thing as the expert。
So if you have a policy that basically looks like。
that visits the same state and exactly the same frequency， is what the expert does。
then you’ve matched their policy。 And you still don’t necessarily know。
that the W you’ve got is accurate， or is a good estimate of the reward function。
but maybe you don’t need it， because if you really。
just care about being able to match the expert’s policy， then you’ve matched it。
Because if you visit all the states， with exactly the same frequency as what the expert does。
you have identical policies。 So it’s sort of giving up on it。 It’s saying。
we still don’t know what the real reward function， is， but it doesn’t matter。
'cause we’ve uncovered， the expert policy。 - Is there like a nonlinear log to this。
that might be more effective？ - Great question， yeah。 There’s been a lot of work also on doing this。
with deep neural networks。 I’ll give a couple pointers later to sort of， other approaches。 Okay。
so this sort of observation led to an algorithm， for learning the policy， which is you try to find。
some sort of reward function。 Like that means you know a W， a choice of W。
Such that the teacher looks better， than everything else， looks better。
than all the other controllers you’ve got before。 So it makes it look like sort of the。
this W for this state distribution looks better， than W for all other distributions。
And then you find the optimal control policy， for the current W， which can allow you to then get。
new， new because you have your transition model here。 And you repeat this until sort of the gap。
is sufficiently small。 (mumbles)， Now this is not perfect。 If your expert policy is suboptimal。
it’s a little tricky how to combine these。 I don’t want to dwell too much on this particular algorithm。
It is not something most people use anymore。 People would use more deep learning approaches。
But I think that the key things to understand from this。
is sort of this aspect of kind of if you match date features。
that that’s sufficient to say that the policies， are identical。 It’s actually that you’re learning。
Yeah。 I remind me your name personally。 - Is there any significance to using normal one。
versus neither norm？ They norm two。 - Ah， good question。
- Good question is why do we use norm one and equation seven？ That is actually important。
It’s not necessarily the only choice， but here this is saying you have to match on all states。
That’s what the norm one is saying here。 So you can think of mu pi really being of s。
I’m not showing that explicit dependency here， but it’s of s。
And so what norm one is saying is that， when you sum up all of those errors， it has to be one。
So really you’re evaluating the error over all of this。
You could choose other things to change the analysis。
Norm one and an infinity norm tend to be particularly easy， to reason about when you start to do。
when you’re trying to bound the error， and the value function。 (mouse clicking)， Okay， so。
there still is ambiguity that we’ve talked about。 So there’s this sort of infinite number。
of different word functions。 The algorithm that we just talked about， doesn’t solve that issue。
And so there’s been a lot of work on imitation learning， and in reverse reinforcement learning。
And two of the key papers are as follows。 The first one is called maximum entropy in reverse RL。
And the idea here was to say， we want to kind of want to pick something。
which has the maximum uncertainty， given that still respects the constraints。
of the data that we have from our expert。 So we’re saying we’re really not sure。
what the reward function is。 We may not really be sure what the policy is。
but let’s try to pick distributions， that have maximum entropy， sort of make least commitment。
It’s sort of the opposite of what we’re fitting。 You kind of want to like under fit as much as possible。
and only make sure that you match， in these expected state frequencies。
So both of these methods and a lot of the methods。
think very carefully about the expected state frequencies， you get and comparing the data you get。
versus the data you have from the demonstrator。 These type of methods can be extended。
to where the transition model is at node。 (mouse clicking)。
Often that requires access to a simulator。 Often it means， so you can imagine。
for the thing we had before， if you didn’t have access to the transition model。
but you did have access to ACTI in the real world， you could just try out new policies。
see what your distribution of states are like， and how that matches your expert demonstration。
And in fact， that’s often what’s done。 So maximum entropy in reverse RL。
has been hugely influential。 And then the second one， and this is also a note。
so also from Drew Bagnell’s group， who is the same person that came up with Dagger。
So that group’s been thinking a lot about， and did a lot of nice contributions to inverse RL。
And then in terms of extending this， to sort of much broader function approximators， Stefan O’Ran。
who’s here at Stanford， extended this to using deep neural networks。 And again。
it’s doing sort of this feature matching。 So the idea in this case。
both of these methods compared to sort of the Dagger work。
or assuming that you have a fixed set of trajectories， at the beginning。
and then you’re gonna do more things in the future。 And in particular。
the general generative adversarial， inverse imitation learning， has these initial trajectories。
and then is gonna allow the agent， to go out and gather more data。 So it can gather more data。
it can compute the state frequencies， it can also use sort of a discriminator， to compare。
one of the challenges is， writing down the form of mu， can be hard when you have a really， really。
high dimensional state space。 So writing down a distribution of our images is hard。
So what they do in this case， they mostly are focusing on mu-joko style tasks。
like robot style tasks， where you’d have like a lot of different joints。
but still hard to write down， nice distributions over that。 So what they focus on in this case。
is thinking about things like a discriminator， that could tell between your expert demonstrations。
and the trajectories that are being generated， by an agent。
And so if you can tell the difference between those， then you’re not matching。
That’s a nice insight， as I say that we could use these sort of， discriminators， GANS。
and the discriminator function to try to figure out， how do we quantify what it means to have。
the same state distribution， and really high dimensional state spaces。 So this is known as gale。
and there’s been a lot of extensions to gale as well。
Earlier we said that there could be real practical benefits。
to learning the reward function in certain situations。 It seemed like the takeaway though。
is that we can’t actually do that。 Is that the correct takeaway？ - Yeah， so for example。
earlier is you were arguing that maybe there were ties， where we really want the reward function。
but maybe you’re telling us that we can’t really do that。 I think in this。
so we’ve mostly been talking about like， frequentist style statistics。
when we’re talking about statistical methods here。 From that perspective。
it’s often very hard to uncover the reward function。 One thing that’s often people do。
when they want to say， understand animal behavior， or things like that， is you have a prior。
You can do another way to do this， is you have a Bayesian prior over reward functions。
and then you do Bayesian updating。 So that given the data that you see。
you try to refine your posterior， over the possible reward functions。 So it avoids。
like then you could just not have your prior cover， that reward is zero everywhere， for example。
So if you have a structured prior， that can be one way to still use information。
to try to reduce your uncertainty， for people’s or agents or animals reward functions。 Yeah。
- What is the prior one to the word function？ Like， you know， it’s sometimes the last thing。
that’s the statistics where you assume a prior， or a little hospital。
you understand if you’re a weak first of all。 - Yeah。 - What sort of prior leads are you？
- It’s a great question。 It says you must， you know， what are realistic priors for reward functions？
It’s a great question。 I think mostly it depends on the domain。 That people do use。
I think we’ll talk a little bit about it， for the exploration aspects。
People do use priors over reward functions， for exploration as well。
Things like Thompson sampling require you to do that。
If you want it to be as close to frequentist as possible， often people do a Dirichlet distribution。
over multi-nomials or things like that， or Gaussians and so you use conjugate exponential families。
So everything’s conjugate。 But those aren’t necessarily realistic。 I think in real domains。
the benefit probably of using these sort of priors。
would be to really encode domain knowledge about， you know， whether people are risk sensitive。
what sort of rewards you expect， to be reasonable in these cases。 - Yeah， I mean。
I think to go back to point two， I think a lot of it does depend on what you want out。
So if you really want to just understand， the reward function of the preference function。
then we need to maybe do something Bayesian， or we need to try to have a method。
that’s going to help us uncover it。 I think what a lot of other methods ended up saying is， well。
maybe we care about the reward function， but mostly we just care about getting high performance。
So if we can uncover a policy， that’s matching the expert policy， we’re fine。
Behavior cloning wasn’t a good way to do that， because errors compound。
but now there are these other ways that can do that better。 And so we’re fine with that part。
And again， I just want to emphasize like Sergei Lamin。
and others have done work which really combines， like you can take Gaol and then go beyond that。
in terms of exploration so you can end up， with a policy that’s better than your demonstrator。
which I think is good because often， like if your demonstrator comes from YouTube。
which is nice because it’s a freely available place， to get demonstrations。
you don’t necessarily know the quality。 So often you might want to use that。
to sort of bootstrap learning， but not necessarily be limited by it。 All right。
so just to summarize， in practice， there’s been an enormous amount of work， on imitation learning。
particularly in robotics， but in lots of domains。 And I think that if you’re going to leave class today。
and go out into industry， that imitation learning can be very useful practically。
because often it’s easier to get demonstrations， and it can really bootstrap learning。
and complicated Atari games， et cetera。 But there’s still a lot of challenges that remain。
particularly in a lot of the domains that I think about， we don’t know the optimal policy。
So I think about healthcare or like customers， or education like intelligent tutoring systems。
and all of those， one of the big challenges， that you don’t know the optimal policy。
and you’re maybe doing all of this， because you think you can do something better。
than what’s in the existing data。 So that’s a big challenge。
And how do you combine sort of in BRS RL。
and then maybe online RL in a safe way？ So one of the motivations I said for imitation learning was。
oh， well， if you want to be safe， but then if you only say things right now， don’t do very well。
then you have to figure out， how to do safe exploration in the future。 All right。
I think that’s everything for today， and I’ll see you guys next week。
or we’re gonna start to talk about policy search。 (clapping)， (buzzing)。
You。
P8：Lecture 8 - Policy Gradient I - 大佬的迷弟的粉丝 - BV1Cc411h7QQ
所有的权利，我们要开始了，嗯，家庭作业2应该正在进行中，如果你有任何问题，请随时联系我们，呃，项目建议书，如果你对此有疑问，请随时来我们的办公时间或联系，嗯，通过广场，大家还有什么问题吗？
我现在就能回答，所有的权利，所以今天我们要开始，这声音有点大，嗯，今天我们要开始讨论策略梯度方法，嗯，策略梯度方法可能是目前强化学习中最常用的方法，嗯，所以我认为熟悉它们是非常有用的东西，嗯。
每当我们谈到强化学习，我们一直回到我们想要的这些主要属性，学会对他们做出决定的代理人，能够进行这种优化，处理，勘探过程中的延迟后果，嗯，并在非常高的维空间中统计有效地完成这一切，嗯，我们上次开始讨论的。
就模仿学习而言是一种不同的方式来提供额外的结构，或对我们代理的额外支持，这样他们就可以试着学会如何更快地做事，模仿学习是通过利用人们的演示来提供结构支持的一种方式。
我们已经看到了编码结构或人类先验知识的其他方法，当我们开始讨论函数逼近时，所以当我们思考如何定义Q时，就像我们把Q定义为s a和w，其中这是一组参数，我们含蓄地做出了一个选择，即强加一些结构。
就我们如何表示我们的值函数而言，这种选择可能相当强烈，就像假设它是线性的一样，所以这是一个相当强烈的假设，或者这可能是一个非常弱的假设，比如使用深度神经网络，所以当我们指定这些函数的近似和表示时。
我们隐含地选择了多少结构，以及我们想投入多少领域知识以便我们的代理人学习，我们今天要开始讨论的是，本周我们要讨论的是策略搜索，这是另一个可以很自然地将领域知识，我们将在今天的一些机器人例子中看到这一点。
这也是一种非常有效的学习方式，正如我所说的，在我们做模型之前，自由强化学习，当我们开始尝试扩展到非常大的状态空间时，嗯，我一直有几个不同的人，问我关于真正大的动作空间，这是一个非常重要的话题。
我们不打算在本季度谈论太多，不过，我们会稍微讨论一下当你的动作空间是连续的，但低维，但是我们已经开始讨论当状态空间非常高的时候，尺寸很大，所以我们讨论了用某种参数化来近似事物，比如参数θ，或者我们。
或者我们经常使用w，但是函数的某种参数化，所以我们用我们的值函数来定义预期的，来自特定州或州行动的奖励折现总额，然后我们可以从这个值函数中提取一个策略，或者至少从状态操作值函数，相反。
我们今天要做的只是直接参数化策略，所以当我们谈到表格策略时，我们的政策只是从国家到行动的映射，在表格设置中，我们可以把它看作是每个州的查找表，我们可以写下我们将采取什么行动，我们现在要做的是说，嗯。
把我们的政策写下来是不可行的，所以我们要做的是参数化它，我们将使用一组权重或θ，今天我们主要用θ，但这可以被认为是重量，嗯，只是一种参数化我们政策的方法，我们将更多地讨论参数化的特殊形式，嗯。
但就像我们看到的状态动作值函数一样，嗯，这会有很大的影响，因为这有效地定义了你可以学习的空间，所以有点，嗯，它决定了，你可能学到的政策类别，嗯，我们将再次关注模型，自由强化学习。
这意味着我们不会假设我们可以访问，和世界动力或回报的先验模型，所以我们在本季度开始的时候有一些图表，我只想回去，嗯，我们一直在谈论某种价值，我们还没有谈太多关于模特的事，模型也是超级重要的。
但是我们已经讨论了很多关于基于值函数的方法，就是这个，现在我们来谈谈政策，直接策略搜索方法，正如你所料，有很多工作试图将他们两人结合起来，这些通常被称为演员批评方法，嗯，其中您试图显式维护参数化策略。
并显式维护参数化的批评或值函数，所以这是政策，这是一个提示，所以我们今天就开始，我们将讨论基于策略的方法，那么你为什么要把这件事做好呢，这实际上又回到了我们上周讨论的，用模仿学习，用于模仿学习。
我们说过，事实上，有时人类很难写下奖励函数，所以他们可能更容易展示政策是什么样子的，在某些情况下类似，也许，更容易写下策略空间的参数化，比写下状态作用空间的参数化，值函数，此外。
它们通常在高维或连续作用空间中更有效，它们允许我们学习随机策略，到目前为止我们还没有谈过很多，但我要给你们一些关于，我们肯定想要随机政策的地方，嗯，它们有时有更好的收敛政策收敛，呃，属性，嗯。
这可能会有点争论，这完全取决于我们是否在比较，为基于模型的方法建模，我们要做多少计算，嗯，所以这可能是计算的一个功能，计算可能很重要，一个真正大的缺点是它们是，通常只收敛到局部最优，所以我们要收敛到。
希望有一个相当好的政策，但我们通常不能保证收敛到全局最优，现在有一些技术可以保证将当地的，到全局最优，我今天会试着强调其中的一些，但通常你看到的几乎所有方法，像深层加固，基于策略梯度的学习。
仅收敛于局部最优，然后另一个挑战是，通常我们会通过评估一个策略来做到这一点，然后估计它的梯度，通常这可以是一些样本和有效的，我们可能需要相当多的数据来估计梯度是什么，当我们采用基于梯度的方法时。
那么为什么我们想要一个随机的策略，所以在我之前提到的表格设置中，所以让我回到这里，所以我们为什么想要这个，我们想要这个，如果你回想一下最初的讲座，嗯，我说的是如果我们有一个表格，它是确定性的和最优的。
所以在表格MDP设置中，我们不需要，嗯，我们不需要随机政策，因为总是存在一个确定性的策略，与最优策略具有相同的价值，因此，在表格马尔可夫决策过程中不需要这样做，但我们并不总是。
我们并不总是在表格马尔可夫决策过程中行动，所以作为一个例子，这里谁熟悉石头剪刀布，大多数人，嗯，我可能，如果你不是，你可能用了另一个名字，所以在石头、纸、剪刀中，呃，这是两个人的游戏，嗯。
每个人都可以选择剪刀石头布，你必须从其中挑一个剪刀胜过纸，布石头打败剪刀布打败石头，嗯，在这种情况下，如果你有一个确定性的策略，你可能会失去很多，你很容易被其他特工利用，嗯。
但是统一的随机策略基本上是最优的，我所说的最优性是什么意思，在这种情况下，我是说，如果你赢了，你可以说一个加一个，假设为零或负一，如果你现在输了，在这堂课上，我们不会过多讨论多智能体的案例。
但这是一个非常有趣的研究领域，在这种情况下，你知道环境不是不可知论的，环境可以对我们正在做的政策做出反应，而且可能是对抗性的，所以我们想要一个对对手强有力的政策，所以第二个案例，um是别名网格世界。
所以嗯，所以在这种情况下，所以为什么你知道为什么随机在这里很重要，因为我们不是在一个随机的环境中，我们在一个对抗性的环境中，我们有另一个经纪人在耍我们，他们可以不稳定，根据我们的政策改变他们的政策，嗯。
所以它不是一个，环境不会选择下一个，它不挑石头布剪刀，不管我们的行动，在过去，它可以对那些，所以它有一种非平稳性或对抗性，另一种情况是它不是马尔科夫，所以它真的是部分可观察的，你有别名。
这意味着我们无法根据传感器区分多种状态，所以我们之前看到了这个，当我们谈到机器人时，你知道机器人可以有激光测距仪，告诉他们在走廊的什么地方，每一个，嗯第一点，呃，障碍是他们所有的一百八十度。
所以在很多不同的走廊里看起来都是一样的，嗯，这是一个简单的例子，所以在别名网格世界中，嗯，假设代理人因为他们的传感器不能区分灰色状态，它们具有特定形式的特征，嗯，它们有一个特征，即北面是否有一堵墙。
东、南、西，所以它基本上可以像，如果它在这里，它可以分辨出，哦，我两边都有墙，而不是在我前面或后面，嗯，但在那边也可能是一样的在那边也可能是一样的，um灰色状态。
所以如果我们做了一个基于价值的强化学习方法，使用某种近似值函数，需要这些特征结合我要采取什么行动，我周围是否有墙，嗯，或者我们可以有一个基于政策的方法，它也吸收了这些特征，然后直接决定采取什么行动。
这些动作可能是随机的，所以在这种情况下，代理试图弄清楚如何在这个世界上导航，它真的很想来到这里，这是有很大奖励的地方，所以这很好，它想避开头骨和交叉骨，这些将是负面奖励，所以因为别名。
探员分不清它是在这里还是在这里，所以它必须在两个州做同样的事情，所以要么向左要么向右，我们称之为西方或东方，嗯，不管怎样，这都不是最佳的，因为如果它真的在这里，它应该往那边走，而不是这边和下面，嗯。
这样我们就可以区分它是在这里还是在这里，它可能会来回移动或者做出非常糟糕的决定，所以它可能会卡住，永远不知道是什么，下去拿钱是安全的，所以它学会了一个确定性的策略，因为这是我们通常用这些学到的，嗯。
它是贪婪的还是贪婪的，它会做得很差，但是如果你有一个随机策略，当你处于一种不存在的状态时，你可以随机化，你可以说，我不确定我是否真的处于这种状态，这个状态还是这个状态，嗯，所以我就走了。
我不是向东就是向西，有百分之五十的可能性，然后一般很快就会达到目标状态，因为注意，当它到达这里时，它可以知道它应该做什么，因为这看起来和这两种状态不同，所以一旦它在中间，它很清楚该怎么做。
所以这又是一次，一个例子，随机策略比确定性策略有更好的价值，这是因为这里的域不是马尔可夫的，它是部分可观察到的，好的，所以这也是我们可能想，我们想要的一些原因可能是，呃，直接基于策略，还有很多其他原因。
嗯，那么这意味着什么呢，嗯，呃，我们将有这个参数化策略，目标是我们想找到，是啊，是啊，你说的话，我们能得出结论吗，当世界不是我们的这一部分，我们的随机政策总是更好，这么大的问题是对的吗，是啊，是啊。
所以我说的是，我们能得出这样的结论吗？如果世界是部分可观测的，随机政策总是更好，嗯，我想这取决于你想做的模特，我认为在这种情况下比随机好，因为它仍然在灰色的州做一些不太聪明的事情，只是随机的。
将有一个部分可观察的马尔可夫决策过程策略，然后你可以跟踪你在世界上的位置，这样你就可以跟踪一个信仰状态，你处于什么状态，然后你可以希望唯一地识别它，哦，如果我只是在这种状态，我现在必须处于这种状态。
然后你可以确定地向右或向左，所以这取决于模特们愿意做好事，问题，好的，所以当我们开始做参数化策略搜索时，我们要做的是找到产生最佳价值的参数，类中具有最佳值的策略，与我们以前看到的如此相似。
我们可以考虑一些情节设置和无限的连续设置，所以在一个插曲的背景下，这意味着代理将在多个时间步内发挥作用，经常，让我们说H步，但它可能是可变的，就像它可能是，直到你到达，你知道的，终结状态。
然后我们可以考虑什么是期望值或者什么是价值，预期的是什么，我们从起始状态或起始状态分布中获得的奖励的折扣总和，然后我们要做的是找到参数化的策略，价值最高的，嗯，另一个选择是，如果我们在一个连续的环境中。
这意味着我们在在线环境中，我们不按步骤行事，我们只是永远行动，没有终结状态，我们可以使用嗯平均值，即我们对状态分布的平均值，所以这就像我们在考虑分布之前看到的，由特定策略诱导的马尔可夫链上的平稳分布。
因为我们之前说过，如果你修改政策，然后基本上你进入了一个马尔可夫奖励过程，你也可以想想状态的分布，你得到的是马尔可夫链，嗯，如果我们永远在演戏，我们会说平均来说，我们在固定分布下到达的状态的值是多少。
另一种方法也是说，我们只看每次的平均奖励，为了今天的简单，现在就一步，我们将几乎完全集中在情节设置上，但我们可以为这些其他形式的设置考虑类似的技术，和以前一样，这是一个优化问题。
类似于我们在线性值函数的值函数近似情况下看到的，并使用深度神经网络，嗯，我们要做优化，这意味着我们需要做某种优化工具，试图寻找最好的θ。
所以一个选择是做无梯度优化，在策略搜索方法中，我们不太倾向于这样做，嗯，但是有很多不同的方法是梯度冻结优化，只是为了让我们找到任何参数，最大化这个vπθ，嗯，只是为了连接这个，就像我们看到的Q函数。
现在我们有了θ，它指定了一个策略，它可能会有一些有趣的风景，然后我们希望能够找到最大值在哪里，所以我们真的试图找到一个函数的最大值，尽可能有效地，有很多方法可以做到这一点，不要依赖函数是可微的，嗯。
在某些情况下，这些实际上是非常好的，嗯，这是我的一个同事在。
我们开发了一种自动识别外骨骼的方法，在行走过程中最大限度地减少人体代谢能成本的辅助模式，在优化过程中，用户第一次体验到一个控制律，同时进行呼吸测量，稳态，通过拟合第一个来估计能源成本。
将动态模型订购为两分钟瞬态数据，然后改变控制规律，再次估计代谢率，对于规定数量的控制法律，重复这一过程，形成一代，然后使用协方差矩阵自适应进化策略来创建下一代。
每一代的平均值表示最优控制参数值的最佳估计，经过一个小时左右的优化，与没有援助相比，能源成本平均降低了24%。
这是我同事做的工作，史蒂夫·柯林斯，他是机械工程专业的，我们一直在合作一些，嗯，所以这个想法，在这种情况下，有很多例子，你想用外骨骼，很多人都中风了，很多人行动不便，当然，有很多退伍军人失去了一条腿。
在这些情况下，挑战之一是，你如何计算出这些外骨骼的参数，为了给走路的人提供支撑，一般来说，它因生理而异，对许多不同的人来说，他们需要不同类型的参数，但你想快点做到这一点。
所以你希望能够很快地计算出每个人，什么是正确的控制参数，以帮助他们在行走时获得最大的帮助，嗯，所以史蒂夫的实验室把这当成了一种政策，策略搜索问题，你在做什么，你让某人戴上他们的设备。
你在尝试一些控制法律，这些法律提供了一种特殊形式的支持，就他们的外骨骼而言，你在测量他们的新陈代谢效率，你怎么知道，他们呼吸有多困难，他们工作有多辛苦，如果他们没有戴这个或在不同的控制法律下。
然后你可以用这些信息来找出，你使用的下一套控制法则是什么，并以闭环的方式尽快完成这一切，现在，我提出这个问题的原因之一是因为它非常有效，这是一篇很好的科学论文，这说明了这是如何比以前的技术更有效的。
第二，因为它使用CMA，是呀，这是一种无梯度的方法，所以即使我们今天要讨论的大部分内容，在课堂上都是基于梯度的方法，有一些不使用基于梯度的方法的很好的例子，还可以对许多其他类型的应用程序进行策略搜索。
所以我认为这是有用的，在你的工具箱里知道，人们不必局限于基于梯度的方法，像Cme这样的东西有一个很好的地方，他们保证会达到一个全局最优，所以在某些情况下，你可能真的想保证你在这么做。
因为这是一个高风险的情况，和一般情况下，最近人们反复注意到，有时，这些方法确实有点尴尬，嗯，嗯，他们往往在某种程度上是一种蛮力，聪明的蛮力方式，嗯，这往往是非常有效的，因此。
从你所看到的应用程序的角度来看，它们是很好的考虑因素，你知道的，尽管如此，嗯，呃，即使他们真的很好，有时它们对并行化非常非常有帮助，他们一般取样效率不高，因此取决于您正在查看的域，你有什么样的结构。
通常使用基于梯度的方法是有用的，特别是如果您可能对最后的本地解决方案感到满意，所以我们是局部最优的，所以我们今天要讲的主要是，就像我们为价值所做的那样，就像，呃，基于值的方法是梯度的。
基于下降和梯度的方法，嗯，和其他试图利用决策问题的顺序结构的方法，所以CME对这个事实一无所知，世界可能是一个MDP，或者任何一种顺序随机过程，我们将重点关注那些有杠杆作用的。
马尔可夫决策过程的结构和决策过程本身，那么让我们来谈谈策略梯度方法，嗯，我们只是用θ来定义事物，这样我们就可以显式地了解参数，我们将专注于插曲MDPS，这意味着我们将在一定的时间步数内运行我们的策略。
直到我们达到一定的终结状态，你知道的，也许H步，在这段时间里，我们会得到一些奖励，然后我们要重置，我们要找一个局部最大值，我们要取梯度，关于定义策略的参数，然后用一些小的学习率，所以这看起来应该很相似。
非常类似于，这里的主要区别是，而不是对定义q函数的参数求导，我们是根据定义我们政策的参数来接受它们的，所以这里最简单的事情就是做有限差分，因此，对于您的每个策略参数，你只要稍微扰动一下。
如果您对定义策略参数的每一个维度都这样做，呃，然后你会得到梯度的估计，你只是在做有限的差分，梯度的估计，在每种情况下，您可以使用一定数量的评估来做到这一点，这样你就可以，假设你有这个K维。
定义策略的一组参数，你试着改变其中一个，你重复一遍，你得到了一堆新政策的样本，你对所有不同的维度都这么做，现在你有了梯度的近似值，这很简单，挺吵的，效率不是特别高，但它有时是有效的，我是说。
策略梯度方法在RL上下文中如何非常有用，好的是，策略本身不必是可微的，因为我们只是在做梯度的有限差分近似，那么我看到的第一个例子是什么，嗯，我想到了，当我想到，策略梯度方法或策略搜索方法如何真正有效。
彼得·斯通做机器人杯的工作是什么，这里有谁见过像机器人杯。
好的，几个人，但不是每个人，所以让我们看看我们是否能像一个简短的演示一样站起来。
就像这些机器人的样子，所以说。
好的，所以你可能看不到它，我们现在不会那么做，嗯，但本质上你所拥有的是，有一堆不同级别的机器人杯，其中一个目标是，嗯，我想到2050年，我们的目标是要有一支机器人足球队，有点能够打败，喜欢能够。
你知道吗，赢得世界杯，嗯，所以这是我们的驱动目标之一，RoboCup的倡议，这里面有很多不同的联盟，其中之一是四足机器人，嗯，他们试图在彼此的比赛中进球。
其中一个关键的挑战是它们看起来有点像，嗯，你得弄清楚走路的门，你希望它们能快速行走，但你不想让他们摔倒，所以问题很简单，就像，你如何优化大门是一个重要的问题，以便获胜。
因为你需要你的机器人在球场上快速移动。
所以彼得·斯通在很长一段时间里都是机器人杯的领军人物，他们的目标只是学习一种快速的走路方式，通过真实的经验和数据来做这件事在这里真的很重要，因为它很贵，就像你让这些机器人来回走动一样。
你想让他们很快优化步态，你不想不停地更换电池之类的东西，所以你真的想用很少的数据量来做这件事，在这种情况下，他们想做的是做一个参数化的策略，并试图优化这些政策，所以这就是重要的领域知识出现的地方。
这是一种注入领域知识的方法，所以他们用这种连续的椭圆来指定它，关于Gate是如何为这个小机器人工作的，所以他们用这十二个连续的参数来参数化它，这完全定义了您可以学习的可能策略的空间，这可能不是最佳的。
彼得·斯通，他的团队在制作机器人杯方面有丰富的经验，在他们写这篇论文的时候，所以他们真的有很多知识可以注入这里，在某些方面，这是一种提供这种层次结构的方法，什么样的政策可能是好的，然后他们所做的是。
他们只是做了这种有限差分的方法，为了尝试优化所有这些参数，所以这里重要的一点是，他们所有的政策评估都将在真正的机器人上完成，他们只是想让人们偶尔干预一下，为了更换电池，大约每小时发生一次。
所以他们在三个ibos上做了，非常少量的硬件，嗯，他们每次迭代执行大约15个策略，他们对每项政策进行了三次评估，所以不是很多，那可能是一个非常嘈杂的信号，每一代大约花了7。5分钟。
所以他们必须选择一些学习速度，所以我们在这种情况下看到了什么，嗯，我们看到他们的迭代次数，与那里的速度相比，当然，您必须定义您的优化标准，在这种情况下，他们考虑的是稳定行走的速度，嗯。
很多人一直在想如何做到这一点，使用手动调音，嗯，呃，包括，他们是奥斯汀别墅队，嗯，包括他们过去，人们找到了不同的方法来手动调音，嗯，我不知道你是怎么用的，监督学习，等，你可以看到他们所做的。
尝试寻找更好的策略的多次迭代，用这种有限差分法，他们比其他一切都快，这不是很多迭代，嗯，所以这是发生在，你知道吗，几个小时，所以我想，这是一个非常引人注目的例子，策略梯度方法确实可以比以前做得更好。
它不需要大量的数据，这可能和你在作业二中所经历的很不一样，所以这不是迭代的总数，嗯，我想这是在，让我们看看，就像我知道这是在，你知道的，几十到上百份保单，不是数以百万计的步骤。
所以这些东西可以非常有效地处理数据，但也有很多信息是这样给出的，如果你想想，就像我这里有一点，所以在他们的论文中他们讨论了在这种情况下是什么影响了性能，有很多事情会影响性能，所以你知道我们怎么开始，嗯。
所以它可能有一种感觉，为什么你知道，为什么使用的初始策略参数，这类方法的问题，嗯，因为我们不能保证有一个全局最优，只有局部最优，所以你的出发点会影响到你能找到的当地医院，我刚才说的是。
因为这些方法只保证，特别是，这种方法只保证找到局部最优，所有的策略梯度样式方法都是，然后呢，无论你从哪里开始，你会到达最近的本地最优，你不能保证这是最好的全局最优，嗯，所以在这种情况下。
尝试大量随机重启是很重要的，或者拥有领域知识，另一个重要的问题是你在多大程度上扰乱了，你的有限差异的大小，然后我认为最关键的是政策参数化，比如你如何写下可能的政策空间，你可以在其中学习。
因为如果这不是一个好的政策空间，那你什么也学不到，五，二，六，我是一个开放的团体，而是扩展得更多一点，是啊，是啊，嗯，所以问题是关于开放循环政策的部分，所以我们正在学习的这些政策不一定是适应性的。
开环策略本质上是一个计划，这是一系列要采取的行动，嗯，不管您可能有任何额外的输入，所以说，嗯，我们通常认为策略是从状态到操作的映射，但它们也可以只是一系列的动作，所以当我们谈论开环策略时。
这是一个非反应性的政策，因为这只是一系列的动作，不管机器人的状态如何，你只要继续前进，所以也许中间有很大的风，机器人的下一个动作是一样的，风是否很大，它不一定是反应性的，好的，所以说，但总的来说，嗯。
你知道，有限差分是一个合理的尝试，嗯，我们通常会使用梯度信息和杠杆，事实上，我们的函数策略实际上是可微的，所以我们现在要做的是计算，分析政策梯度，抱歉，打扰一下，这在现在使用的大多数技术中都是最常见的。
嗯，我们假设它在任何不为零的地方都是可微的，嗯，我们可以显式地计算这个，所以当我们说我们，当我们说我们知道，这意味着这是可计算的，我们可以显式地计算这个，所以现在我们将只考虑基于梯度的方法。
所以我们只是，嗯，我们将只收敛到局部最优，希望，希望我们能达到当地的最佳状态，这是我们所能希望的最好结果，在这种情况下，所以我们要谈谈，人们经常谈论可能性，比率政策，嗯，他们将按照以下方式进行。
所以我们在考虑插曲案件，所以我们要把它看作是有轨迹的，所以国家行动，奖励下一个状态，等等，一直到某种终端状态，所以这就是我们终止的地方，和，我们将使用tau的r，表示轨迹的奖励总和，所以保单的价值。
在这种情况下，只是意料之中的，我们按照这项政策获得的折扣金额，我们可以把它表示为我们观察到特定轨迹的概率，那个轨迹的回报，所以它只是说在这个政策下给出，你知道什么，看到任何轨迹的概率有多大。
那么这个轨迹的回报是什么，因为奖励只是轨迹的确定性函数，一旦你知道状态动作，奖励，等，那么你的奖励就是所有这些的总和，所以现在在这个特殊的符号中，我们的目标是找到策略参数，这是这个的arg最大值。
我们在这里改变了什么，嗯，现在的变化是我们将专注于这里，所以请注意，现在政策参数只出现在轨迹分布方面，在这项政策下，我们可能会遇到，这和我们所说的模仿学习有点相似，在我们进行模仿学习之前。
我们讲了很多关于状态的分布，状态和动作的分布，并试图找到一个策略，将匹配相同的州行动分布，正如一位专家所证明的那样，今天我们不再讨论状态作用分布，但我们谈论的是我们可能遇到的轨迹分布。
根据我们的特殊政策，那么这个梯度是多少，嗯，所以我们要取这个函数相对于θ的梯度，所以我们要这样做，我们要重写轨道在θ下的概率，所以说，我超过了一个tau，我们要做tau的概率，时间好吧，首先，其实。
我把它搬进去，然后我们要做的就是确保我得到了符号，同样的，那么我们要做的是我们要做一些简单的事情，我们只是乘以和除以同样的东西。
所以我们要把τ{\displaystyle\tau}的概率加上θ{\displaystyle\theta}，除以给定θ的tau概率乘以给定θ的tau概率的导数，如果我们有一个日志，所以如果我们对数求导。
给定的θ正好等于，1除以给定θ的tau的概率乘以给定θ的tau的p的导数，所以我们可以这样重新表达，tau的和，在给定θ的情况下，相对于在给定θ的情况下，对p的对数的导数，到目前为止。
这似乎不一定会很有用，嗯，所以我们已经做到了，这是一个合理的转变，但我们很快就会看到为什么这种转变是有帮助的，尤其是这种转变是有帮助的原因是，这将是非常有用的，当我们想到想做这一切的时候。
在不知道动态或奖励模型的情况下，所以我们需要能够，呃，你知道吗，根据轨迹获得奖励，但我们希望能够评估策略的梯度，在不知道动力学模型的情况下，这个技巧会帮助我们到达那里，所以当我们这样做的时候。
这通常被称为似然比，然后我们可以转换它，只是说好，我们注意到通过这样做，这实际上和日志完全一样，现在，为什么这开始看起来像一些可能很有用的东西，我们这里有什么我们这里有，如果我们这是所有轨迹的总和。
当然，我们不一定能接触到所有可能的轨迹，但我们可以取样，所以你可以想象，开始能够通过多次运行您的策略来近似这一点，对一些轨迹进行采样，看着那些，嗯，然后对给定的轨道概率求导。
所以通常我们会通过运行策略来做到这一点，m次，嗯，然后θτ{\displaystyle\tau}的p{\displaystyle p}给θ{\displaystyle\theta}。
我们将用下面的方法来近似它，所以这部分掉了，我们只是要权衡我们得到的所有轨迹，在我们统一取样期间，然后我们看这个轨迹的回报和p f的对数，呃tau给定θ，那么在这种情况下发生了什么，好的。
所以这意味着梯度是这样的，嗯，呃，原始奖励，我们有时间吗，那个轨迹概率的日志，对于与相关单词times theta相关联的奖励，那么在那种情况下发生了什么，所以在这种情况下，我们有一个函数，对我们来说。
这是奖励，它可以测量特定的轨迹有多好，或者那个样品有多好，所以这是在做什么，我们只是沿着样本的对数概率的轨迹向上移动，基于它有多好，所以我们想提高我们的参数，这些参数对我们负责，得到好的样品。
所以我们希望在我们的政策中有参数，会导致我们执行轨迹，给我们带来高，奖赏，所以如果我们把这里的f乘以x作为奖励，我们这将是我们的政策，参数化策略，我们想增加我们空间中导致高回报的东西的重量。
所以如果这是我们的x的f，也就是我们的奖励功能，这是我们轨迹的概率，那么我们要重新调整我们的政策，试图增加产生高回报的轨迹的概率，所以你最终会对高价值的东西有更大的梯度，高回报，好的，那么下一个问题是。
如果我要这么做，那么我必须能够近似第二项，就是这个日志，你知道吗，对弹道概率的导数，嗯，在某些参数下，所以我必须弄清楚，在一组参数下，轨迹的概率是多少，我们可以这样做，所以这将是对数的δθ。
s零的亩的戳，所以这是我们最初的起始状态，我们初始状态的概率，乘以j的乘积等于0到t，减去观察的概率，下一个状态，考虑到所采取的行动，根据我们目前的政策，采取那种行动的可能性，所以在末端有一个支架。
既然这是日志，我们可以把这个分解，所以这将等于对数的△θ，加Δθ和除以Δθ，因为它是j=0到t的对数项，减去转换模型的对数之一，记住，我们一般不知道这一点，这是未知的，我们只是希望最终得到一个表达式。
这意味着我们不需要拥有它，我在这里索引的是我们在哪个轨道上，和j等于0到2减去1，这将是我们实际的政策参数，所有的权利，有人能告诉我为什么这是一个有用的分解，我们是否需要，所以让我，参数化所有这些东西。
嗯，就我们而言，这看起来有希望吗，不需要知道动力学模型是什么，一件事可能在任何状态下，在状态中，在行动中，比如其中的一些，你怎么得到，那当然每个人都和你的邻居谈谈怎么样，然后告诉我哪项是零。
所以我们对θ求导，哪些项依赖于θ，她说，我最喜欢，所以六点以后，i，记住，θ是决定策略参数的因素，θ是决定你在给定状态下采取什么行动的因素，所有的权利，我要做个快速调查，嗯，所以我要调用这些项目。
一二三，第一项与θ有关吗，举起你的手，如果有，举起你的手，如果没有很好，好的，是的，所以这与θ无关，所以这将是零，嗯，举起你的手，如果第二项与θ无关，所以这个归零，所以我们只剩下这个了这很好，所以嗯。
好在，所以现在变得更清楚了，为什么我们要做这个奇怪的日志转换，因为当我们做这个奇怪的日志转换时，它允许我们得到我们所采取的行动的概率的乘积，和状态转换，然后我们可以把它分解成和。
现在一旦我们看到我们把它分解成总和，我们可以单独应用导数，这意味着其中一些术语直接消失了，这真的很酷，所以这意味着我们实际上不需要知道过渡模型是什么，我们不需要有明确的表示，是啊，是啊，问题和名字第一。
拜托了，问题是我在想，制度的动力不是取决于政策吗，尽管总的来说是个大问题，所以问题是，系统的动态绝对取决于政策吗，但只有通过这一部分，所以就像特工可以选择他们采取什么行动。
但一旦他们选择了动力学独立于代理，所以这种脱钩，所以如果你有不同的政策，你绝对会得到不同的轨迹，但是你得到不同轨迹的方式，UM只在所选择的操作方面受策略的影响，然后环境将决定你得到的下一个状态。
所以我们不需要知道，在估计行动对环境的影响方面，就你得到的奖励而言，它也会通过，因为你得到的奖励也是国家的函数，所以你绝对会参观这个州的不同地方，取决于你采取的行动任何其他问题。
我想确保我明白我是如何得到估计的概率，给定数据看起来像，我们只是说，如果我们拍M集，这个出现了，你知道我的时间会是，我是说，我们在这里做的是正确的伟大的问题，所以你是在问，嗯，你知道这是我放在这里的。
只是其中一个内部术语，能应付一个人，我是的，所以我们在这里做的是，我们在说，我们准备采取这个政策，我们将在m时间跑步，我们可能不会得到任何相同的轨迹，我们要做的是计算，每一个单独的轨迹概率的日志。
然后总结一下，你可能会得到它，我是说，你知道的，在确定性的情况下，您可能，嗯，或者如果您的域没有很大的随机性，你的政策也没有，你可能会得到多个总体上相同的轨迹，你所有的轨迹都将完全不同。
你对它们局部梯度的估计也是如此，所以这真的很好，我们最终会陷入这种境地，我们只需要有一个解析形式，我们的政策对我们的参数的派生，所以我们仍然需要，我们稍后会更多地讨论这个问题，我们还需要这个。
我们要评估一下，这是关于我们如何参数化我们的政策，如果我们想让这是分析的，我们需要参数化我们的策略，以一种我们可以精确计算任何状态的方式，所以我们会更多地讨论一些方法，你知道的，一些策略参数。
这使得这个计算分析性强，很好，在其他情况下，你可能要通过，你知道吗，蛮力或计算，或者有限差分什么的，但是如果我们选择一种特定形式的参数化策略，然后这部分是分析的，所以另一件事是。
我没找到这个，呃，我找不到这个附加术语，特别有帮助，但到处都在用，所以我想介绍一下，也就是人们常说的分数函数，得分函数，这不是特别有帮助，我觉得，但仍然经常被使用，叫做这个，这就是我们刚才所说的数量。
需要能够评估，所以这真的进入了，好吧，我们再把它写出来，所以嗯，当我们对值函数求导时，我们通过得到M个样本来近似，我们和i等于1到m，我们看看轨迹的回报，然后我们求和，后面有人能读懂吗，是啊，是啊。
好的，伟大，是啊，是啊，这些是我们的评分函数，这些是我们的评分函数，嗯，在我们看到的每一个状态动作对上，我们不需要知道动力学模型，所以策略梯度定理稍微概括了这一点，它将如何推广这个音符，在这种情况下。
我们在这里做的是，这是为了情节设置，这是为了当我们把我们的原始奖励功能，所以我们看看这个轨迹的奖励总和，然后我们用这种导数来衡量它，就我们的政策参数而言，原来我们也可以稍微概括一下，假设我要打电话。
所以说，这是一个值函数，嗯，假设我们之前讨论过的目标函数略有不同，我们如何才能有情节奖励或每时间步数的平均奖励或平均值，所以我们可以让我们的目标函数等于我们的正常值。
或者我们可以让它等于我所说的J A VR，也就是每次的平均奖励，步骤，或者我们可以把它作为平均值，假设我们一直在继续，我们想平均我们遇到的状态的分布，所以我们可以考虑这种情况，在所有这些情况下。
你可以做一个类似的推导，就像我们在这里为插曲案例所做的那样，我们发现我们有目标函数的导数，现在可能有点，这些不同的目标函数中的任何一个都等于期望值，在这种情况下，导数的当前策略只涉及这些策略参数。
乘以q，和萨顿·巴托在第十三章，我们也在时间表上参考，嗯，就这些不同的问题进行了很好的讨论，嗯，所以再次，我们不打算过多地讨论这些稍微不同的目标函数，但要知道，这一切都可以扩展到持续的案例，好的。
到目前为止，我们在这里所说的是，我们有这个近似值，我们所做的是，我们只是把我们的政策，我们在每一个m次运行它，我们得到了一系列的状态、行动和奖励，然后我们平均一下，这是对政策梯度的无偏估计，但是很吵。
所以这将是公正的，吵吵闹闹，如果你想想我们之前看到的蒙特卡洛方法，它应该看起来有点眼熟，同样的精神，对呀，我们有，嗯，我们的保单用完了，我们会得到一些奖励，就像我们在蒙特卡洛得到的估计。
但这将是梯度的无偏估计，所以它是梯度的无偏估计，梯度估计，但是很吵，那么什么能让这变得实用呢，嗯，有许多不同的技术来做到这一点，但是我们今天要开始讨论的一些事情是暂时的，结构和基线。
那么我们如何解决这个问题，我们要开始看，你知道的，修复，在我们继续之前，嗯，根据我刚才所说的蒙特卡洛估计，嗯，你们中的一些人的想法是什么，我们如何才能减小这个估计的方差。
根据我们到目前为止在课堂上看到的东西，就像，蒙特卡洛方法的替代方案是什么，你一开始能不能构造，是呀，这是完全正确的，所以D说，您可以使用引导吗，是啊，是啊，所以我们反复看到，嗯。
我们在偏差和方差之间进行了权衡，那种自举，嗯，就像我们在Q中看到的时差方法，了解你在DQN做什么，有助于减少差异和加快信息的传播，所以是的，所以我们绝对可以做一些事情，比如引导，嗯，以一种取代。
用别的东西，或者在R之外使用协变，试图减小r的方差，所有权利，所以我们现在要做的是，我们首先要做一些不是一直到那里的事情，但至少试图利用我们处于时间上的事实，时间。
对于你们中任何一个以前玩过重要样本的人来说，这与嗯密切相关，每项决定，重要抽样，基本上，我们要利用的是这样一个事实，即奖励，只能嗯做的时间结构，我先写出来，好的，所以我们之前说过，嗯。
tau期望值对θ的导数，回报等于你可以得到的轨迹下的期望值，t的和等于0到t，减去RT的一个，所以你得到的奖励总和，这个，m/t等于0到t，减去与策略参数有关的一个导数，那是我们以前吃的。
所以我们只是总结我们所有的奖励，然后我们把它乘以总和，在每个操作状态对的策略的所有梯度上，我们在那个轨迹上，所以让我们考虑一下为了一个奖励而做这件事，而不是看奖励的总和，所以让我们看看。
我们对RT素数的期望值θ求导，这只是我们可能遇到的一个单步奖励，你知道沿着我们的轨迹，这将等于RT素数的期望值，乘以和等于0到这个导数的t质数，所以这看起来和以前几乎一模一样，除了这里唯一的关键区别是。
我只总结T素数，所以我们只是总结一下，你可以把这看作是一个缩短的轨迹，我在看美国的产品，我所付出的努力和回报，当我到了RT Prime，这样我就不必对未来的所有内容进行求和了，所以我们可以把这个表达式。
现在我们可以对所有的时间步长求和，所以这上面写着，预期的报酬是多少，或衍生物，关于时间步T素数的奖励，现在我要总结一下，这将和我的第一个表达式一样，所以我要做的是，我要说θ的v等于导数，关于E r的θ。
我要总结一下内部表达式，所以我对t求和一撇等于零，减去一个RT质数，然后插入第二个表达式，所以我所做的就是，我把它放进去，求和T一撇等于零，一直到T减1，然后我要做的是。
我将通过以下观察来重新排序这个和这个，所以如果我们想想这些对数πθ中有多少项，A T T出现在，所以如果我们看1的对数πθ，所以如果我们看看它出现了多少次，出现在早期奖励中，它出现在所有后来的奖励中。
我也是，好的，这会出现在R one身上，这将为R2出现，它将一个接一个地一直打到我们队，因为我们总是在那之前总结一切，所以我们现在要做的，我们要接受这些条件，我们要重组那些。
所以这些术语中的一些出现了很多次，其中一些是最后一个，t的πθ的对数，它只会出现一次，它只负责决定最后的奖励，所以我们可以利用这种洞察力稍微重组这个方程，如下所示，所以现在我们要说这等于求和的期望值。
t=0 t减去1，请注意，在我把T素数放在外面之前，T在里面，现在我要做的是把T放在外面，我会说我有Δθ对数，πθa t s t乘以t质数之和等于t，一直到t减去一个r t素数，所以我所做的就是。
我已把那笔钱重新整理好了，是啊，是啊，是啊，是啊，从底部开始的第二行，它应该是导数吗，关于θ的值函数，在最左边，好的，是呀，哦对不起，你是说，这应该是这个的导数，是呀，好的。
所以我们在这个例子中所做的是我们重组了太阳，我们只是以稍微不同的方式回忆了术语，但这将以一种有用的方式进行，所以让我们把这个向上移动，我把这个向下移动，所以现在我们还在研究时间结构，这会让我们做得好吗。
第二个术语应该看起来有点熟悉，那是什么意思，俗话说，奖励是什么，我们准时出发，一直走到最后，这只是回报，所以我们之前定义了，嗯，当我们谈论蒙特卡洛方法的时候，等，我们可以一直看着，i的质数。
这正好等于回报，这一集剩下的回归，从时间开始，上第一集，所以这看起来应该很熟悉我们在蒙特卡洛方法中看到的，我们总是可以说从这个状态在行动，我们从那个状态开始在行动中得到的奖励总数是多少，直到这一集结束。
这意味着我们可以重新表示关于θ的导数，在所有轨道上近似为1/m和，我们在总结所有的时间步骤，对实际策略参数θ的导数，时间只是回报，这将是一个比以前略低的方差估计，所以我们不必单独总结我们所有的奖励。
然后我们把它相乘，所有这些对数导数的总和，我们只需要，把一些奖励条款的日志总和，所以在这种情况下，我们可以减少方差，因为在某些方面，这是怎么回事，这是说每一个奖励，因为你可以把它重新表达为奖励的总和。
每一个奖励，你必须通过整个轨迹来确定它，根据梯度的导数，政策参数的导数，现在我们说你不必把它乘以，你只需要把它乘以所有这些，与特定奖励相关的，这意味着你会有一个稍微低一点的方差估计器。
当我们这样做的时候，我们最终可以得到所谓的加强，谁听说过加强，很多人，不是每个人，增强是最常见的强化学习策略分级算法之一，所以你得到了强化算法，所以它是如何工作的是你，嗯，算法是你随机初始化initθ。
您总是必须首先决定如何参数化策略，所以在某个地方，你已经决定了如何参数化你的策略，现在您将随机设置该策略的值，然后每集，所以你要用那个政策写一集，所以你会收集一大堆行动和奖励。
这是从您当前的保单中取样的，因此，您根据当前保单中的某人对当前保单进行采样，你得到一个轨迹，然后在轨道上的每一步。
您将更新策略参数，每次走进那一集，我们将更新我们的策略参数，所以会和以前一样，一些学习率，我不会在那里用W，我会用阿尔法，嗯，乘以对θlogπθt a t gt的导数，GT就在这一集里。
从T A T开始的奖励总额是多少，所以这只是正常的回报，就像我们用蒙特卡洛的方法，就像我们在估计线性值函数时所做的那样，我们从国家和行动开始使用奖励，我们要在这里做同样的事情，除了我们要更新政策参数。
我们做了这么多，很多，很多次，然后在最后我们返回参数，问题，所以对于每一集，您都从更新的策略中取样，我们与你同在，好的，这是正确的，所以在这种情况下，嗯，呃，在你完成一集的所有更新后。
所以你得到了这些增量更新，嗯嗯，然后在完成所有增量更新的最后，然后用新的更新参数得到另一集，因为我们每次都在更新，这会是一种偏见方法吗，嗯好问题，所以说，因为我们每次都在做论文，嗯，这应该是对，呃。
它仍然应该是梯度的无偏估计，它是随机的，但是我们对国家和行动的概念是不一样的，嗯，这将是渐近一致的，这是个好问题，所以嗯的概念，在这种情况下，状态和动作是不同的，因为我们只有这些策略参数。
所以我们在这里不是在估计一个国家在行动的价值，这当然是渐近一致的，我认为这仍然是公正的，如果我，如果我以后重新考虑，我会发封广场邮件，嗯，但我认为这仍然只是对梯度的无偏估计，这是个好问题。
所以我回到我的幻灯片笔记，嗯，我最不想做的事，嗯，我会，我会提几件事，嗯，一个关键问题，这里是，是否或如何计算与策略参数有关的此微分，所以我认为谈谈，你知道的。
人们通常认为有哪些类型的政策有很好的可微形式，所以人们认为的一些类是像SoftMax这样的东西，高斯与神经网络，这些可能是最常见的，我这么说是什么意思，我是说，这就是我们将如何实际参数化我们的策略。
所以让我们看一个例子，所以SoftMax是我们简单地，具有特征的线性组合，我们把它们按指数加权，所以我们要做的是，我们将有我们的状态和行动空间的一些特征，我们要把它们乘以一些权重或参数。
这些是我们的参数，然后实际获得采取行动的概率，所以如果我们想有我们的政策，我们说，给定一个状态，作用的概率是多少，我们将这些加权特征的指数，所以我们有，e，Phi tθ除以所有动作的和，所以请注意。
当我们的动作空间是离散的时，这是一个合理的做法，作用空间离散，很多雅达利游戏，很多不同的场景，你确实有一个离散的动作空间，所以你可以用这个指数除以归一化的，有些超过指数，这立即产生了我们的参数化策略类。
所以如果我们想对这个求导，关于日志，这很好，因为我们这里有指数，我们有对数，我们正在记录这个，所以如果我们想计算这个项，从这种参数化策略类，我们得到的是对数θ的导数。
这种类型的参数化策略正好等于我们的特性，这就是我们使用的任何特征表示，就像移动机器人的情况一样，这就像所有不同的，嗯，这可能是这样的，你知道吗，角或关节，或者类似的东西，这就是我们使用的任何功能。
减去的θ的期望值，使用一个指数，该指数与您的期望值相对于您在该策略下可能采取的所有操作，所以它在某种程度上说你观察到的特征，与平均特征相比，平均特征在动作中的平均特征，所以这是可微的，嗯，你可以解决它。
然后它给你一个解析形式，嗯，另一个真正流行的是高斯政策，为什么这可能是好的，嗯，这可能是好的，因为我们通常有连续的动作空间，所以这很好，如果我们有离散的作用空间，我们通常有连续的动作空间。
这在控制和机器人技术中很常见，所以你有许多不同的参数，在您希望能够设置的连续标量值中，我们在这里可以说的是，假设我们使用μs可能是状态特征的线性组合，乘以某个参数，为了简单起见，让我们想象一下。
我们有一个方差，但那是静态的，所以我们也可以考虑它不是，但是我们要假设我们有一个固定的方差项，这不是参数，这不是我们要学的东西，我们只是要学习θ，这就是定义我们的μ函数，然后我们的政策是高斯的。
所以A将从高斯图中提取，对特征使用此平均值，所以我们将我们当前的状态与平均值进行比较，然后我们选择一个与之相关的操作，在这种情况下，得分函数是高斯函数的导数，所以score是高斯函数的导数。
它最终是S的负MU，状态特征除以西格玛平方，所以它可以通过分析来完成，另一个非常常见的是深度神经网络，所以那些是，嗯，这些是非常常见的形式，人们使用的，在我们结束之前，我们将在下次讨论另一种常见的方法。
我们会花大约五分钟来做一些早期的课堂反馈，这对我们弄清楚是什么帮助你学习真的很有帮助，你认为有哪些可以改进的地方，所以我现在要做的是打开，如果你们能去广场，那就太好了，如果你能把这个填一下。
一切都是匿名的，我的目标是在周三给你们反馈，所以我只是让我看看我是否可以重做，所以它是，张贴，好的，让我看看能不能，我把它钉上，所以更容易找到，所以现在应该是钉住了，我们在最顶端，是的，如果你去广场。
嗯，这是一个很短的调查，你可以把信息反馈给我们，那就太好了，我们下次要做的是，我们将继续讨论策略搜索，我们将讨论基线，这是减少方差的另一种方法，这也是一个非常活跃的研究领域，因此。
在深度强化学习和政策梯度方面有大量的工作，所以我们将讨论其中的一些工作，然后你就有机会，呃，玩这个，在中期后，确实获得了政策梯度的经验，所以我们会在期中考试后发布一个关于这个问题的作业。
P9：Lecture 9 - Policy Gradient II - 大佬的迷弟的粉丝 - BV1Cc411h7QQ
所有的权利，欢迎大家回来，在我们今天开始之前，我有什么关于后勤或期中考试的问题吗，或者类似的东西，星期一我们要做期中复习。
然后期中考试就在周三，嗯，因为班上有很多人，我们会把大家分散在几个房间里，我们会，呃，发出关于这件事的指示，可能有任何其他物流问题，学期期间就是上课时间，嗯说明也会在网上，但你可以带一页。
书面笔记的um，嗯，除此之外，一切都关闭了，书的数据类型，它必须被传递的地方，我想我们已经发布了一份政策地图，经过双重检查，已经，好的，在那之前让我们开始吧，我只想说声谢谢，给所有参与课堂反馈调查的人。
这对我和其他人都很有帮助，什么能帮助你学习，什么不能帮助你学习，好的，所以就，嗯，答复，所以注意，你知道所有这些事情，这个班大约有二百三十人注册，嗯，所以对你们中的一些人来说，如果你不给我反馈。
我很难知道什么对你有帮助，或者不帮助你学习，所以我们就用，人们给我们的反馈是什么，嗯，65%的人认为这是正确的节奏，大约27%的人认为它进展得太快了，只有大约8%的人认为进展太慢，嗯。
所以我们要保持大致相同的速度，就像我们以前吃过的那样，嗯，许多人指出，他们希望这是一个学期的课程，我会提到还有许多其他的课程进行强化学习，我非常鼓励你把它们，我提供高级班，本·范·罗伊通常在春天上课。
那更多的是理论上的，这是超级有争议的，我没想到会是这样的分裂，嗯，所以我们在周四和周五提供课程，上座率一直很低，我想我们大概有三到七个人来参加会议，嗯，所以我们认为这将是每个人都想拿出来的东西。
因为它是平分的，我让所有的助教比较，上班时间来上班的人，与来参加会议的人相比，嗯，我们大概有四到五个，X人试图去办公时间，试图去会议，所以我们要改在办公时间，这样我们就可以为尽可能多的人服务，嗯。
所以让我把它写在那里，所以我们要改在办公时间，现在，其他日子仍将提供会议，他们仍然会被记录下来，所以对于任何想在周四和周五去的人来说，你还是可以去的，你仍然可以在缩放上参与，或者你可以观看录制的讲座。
但我们要改在办公时间，因为我的助教们一直在说，他们有几个办公时间，他们要么不得不呆到很晚，或者他们觉得他们没有接触到一些人，又是这样，就服务最多的人而言，我会说当我经历这些回应时。
这真的让我想到了一个事实，在强化学习中，和顺序决策，嗯，我们总是为预期的回报而优化，所以这和我们在这里做的事情完全一样，我知道每个人需要的东西略有不同，我们只是尽力做好我们最好的工作和期望。
但这正是为什么像智能辅导系统这样的东西，其他的东西可能会更好，嗯好吧，就人们认为对他们很有效的事情而言，我们得到了许多关于做工作的积极评价，课堂上的例子，做推导。
很多人真的很喜欢我的iPad在周一出现问题的事实，所以我们在黑板上做了一些事情，所以我们会试着继续做相同数量或更多的导数，人们也普遍对家庭作业持积极态度，就我们反复看到的事情而言，所以我所做的是。
我得到了，我刚整理了所有的免费回复，试图寻找共同的主题和任何出现的东西，你知道的，三五次或更多我认为这是一个常见的问题，人们会喜欢解决，人们会更关注大局，解释，嗯，以及从玩具例子到现实世界的例子。
所以我们会尽量做到这一点，嗯，我也会试着确保我自始至终都在大声说话，几个人说，有时有时很难听到，所以我会努力做得更好，如果你在后面听不到我，请随意举手，人们想要更多的例子，嗯工作的例子。
所以我们要特别确保，在会话中，我们强调工作示例，甚至更多，让我再说一遍，如果这不是你最关心的事情之一，对不起，这学期我们不可能解决所有的问题，嗯，我们肯定，这是一种有趣的经历，这会让人们说完全相反的话。
有时就在一排，嗯，就它是如何整理的而言，比如，有些人不喜欢，幻灯片有空隙的事实，我在课堂上做推导，其他一些人真的很喜欢这样，我在课堂上做推导，嗯，有些人觉得它移动得太慢了，其他人说它移动得太快了，嗯。
所以再次，我们只是要努力做到最好，我们可以满足每个人的需求，所有的权利，所以今天我们将继续讨论策略搜索，那个，正如我之前所说的，这可能是最重要的强化学习，这学期你要学，我觉得这个现在应用非常广泛，嗯。
为了优化功能，我们可以在这里再次想到策略搜索，因为很多事情听起来都很像，当我们在做值函数逼近时，我们在这里考虑的是有一个参数化的策略，我们经常用θ来参数化它，但我们可以用W或其他任何东西。
但我们有一个参数化的策略，嗯，然后我们有一些政策的价值，我们要做的是，正在努力寻找，你知道的，好的最佳状态，试图最大化该政策的价值，我们在模仿学习后立即这样做的原因之一是，就是把它和。
你必须选择一个策略类的想法，指定参数化的方法，因此，从本质上来说，它是一个构建结构的地方，好的，所以作为回顾，我提到到目前为止我们已经在模型上做了很多工作，基于自由值的方法。
我们现在开始研究直接策略搜索方法，今天我们还将讨论更多关于演员评论的方法，我们保持的地方，都是，我们坚持，显式参数化策略和显式参数化值函数，也贯穿所有，你知道的，在过去的几周里，包括昨天或星期一，今天。
我们主要讨论的是案件，我们希望能够在非常非常大的状态空间中工作，我们为什么要把这件事做好，我们一般会，能够保证我们收敛到局部最优，我们并不总是保证基于值函数的方法，嗯，这可能很重要，呃，嗯，这很好。
这是一个很好的财产，嗯，缺点是，如果您通常使用策略梯度方法，我们只收敛到局部最优，上次我给你们看外骨骼的例子，他们使用全局最优方法，所以还有其他的可以基于rl的策略，并不总是能让你找到本地的解决方案。
但是基于梯度的方法通常会，我们谈论的另一个问题，嗯，试图解决这个问题的方法是，嗯，或作为解决，事实上，评估一个政策本身可能是相当低效和高方差的，所以我们之前定义的是一个策略梯度，在哪里，嗯，现在。
在我们考虑用θ来参数化这些东西之前，所以我们可以认为策略的值是由θ参数化的，或θ的pi表示参数化，但是我们经常会谈论值函数，因为最终值函数取决于策略，而策略取决于参数。
当我们思考我们想从这些算法中得到什么时，通常，我们真正想要的是，试图收敛到一个真正好的局部最优，我们通常对此没有太多的控制，但我们经常控制的事情，比如我们收敛到局部最优的速度有多快。
所以我们想让你尽可能快地沿着坡度走下去，如果我们在做一个基于梯度的方法，并尽可能地使用我们的数据，所以我们今天要更多地讨论的一件事是，当我们做这种策略梯度技术时，所以我们要向下移动。
现在我们要有我们的渐变，我们可以有我们的功能，所以这是vπ，这是我们的参数化圆周率，当我们向下移动到某个局部梯度时，嗯，如果当我们更新我们的政策时，它单调地改善，那就太好了。
所以谁能给我一个理由为什么我们想要单调的改进，以帮助保证趋同，答案是我绝对可以帮助保证收敛，虽然我和你们一样热爱数学，这是一个很好的理由，但也许我也在想一个经验原因，为什么我们也想要那个，是啊，是啊。
在后面，尤其是如果你要在高风险的情况下部署这些，所以我们以前看到的，事实上，我的一个学生昨天给你做了一个实习工作演讲，他为DQN展示了这张图表，它看起来是这样的，这就像表演一样，这就是奖励。
现在是时候了，当然它并不总是这样，通常当你去，当你读报纸的时候，人们顺利地跑了很多很多次，但通常看起来是这样的，当你穿越多个剧集或多个时间步时，就像你真的得到了一个非常参差不齐的上上下下的表演。
你对保单的价值，你像你做的那样奔跑，dqn，那么为什么这在，就像高风险的情况，是啊，是啊，在那边，就是这个名字，如果这是很高的赌注，你有好的东西，然后它就下去了，人们会生你的气，你现在做了更糟糕的事。
即使它以后会回升，是啊，是啊，那就是它存在于一个高风险的场景中，嗯，如果你这样做，你知道如果你的政策很有效，然后下一集，下一集，它真的很糟糕，即使以后可能会上涨，嗯，你知道你的老板可能会解雇你，嗯。
我是说，我开玩笑的，但我认为人们往往厌恶损失，而且在，可能不太好，你知道在一个公司说好，这个季度我们做得很好，下个季度我们要做，你知道更糟的是，但最终你知道，经过多次，嗯季度我们会做得很好，就像。
我们可能经常想确保我们是单调的，或者其他类型的高风险，场景或飞机之类的东西，嗯，只是人们可能无法容忍，如果你说这段时间我们会做得更糟，嗯，现在所有这些都有例外，但我想有很多情况下你真的喜欢单调的改进。
如果可以的话，所以说，我认为这是一个真正的除了理论上的好处，呃，它可以帮助我们证明事情，呃，它也可以是对人们有吸引力的东西，实际上能够部署，我们知道总的来说，人们很有风险，喜欢非常厌恶损失。
所以有单调改进的政策是非常好的，和DQN，许多基于价值的方法没有这些保证，嗯，我们也可以更多地讨论这是否总是可能的，嗯，在这方面，如果你想达到全局最优，只是我能证明的一个，虽然，在这些情况下。
关于您可以访问或看到的数据，所以从技术上来说，如果你的生活环境有分布，它可能与您的实际模拟或数据环境有些不同，对呀，你可能不一定有四个改进，即使在政策分级中也是这样吗，一个问题，也就是说。
我们什么时候会，你知道什么，这种单调的改进是什么，在什么条件下这将得到保证或可能，我们这样做是基于我们以前的数据吗，对未来做出一些假设，绝对收集的未来数据，我们将假设我们仍处于相同的决策过程中。
它是静止的，我的意思是，过渡模型和奖励模型是相同的，你知道你可能还没有观察到所有的状态，但在不同的剧集里都是一样的，所以我们不是在处理，事实上，你知道客户的偏好已经完全改变了，或者嗯。
你知道气候变化正在改变你的环境，我们正在处理这样一个事实，如果世界是静止的，那么我们现在就可以保证有单调的改进了，另一件事，否则我就给你看，在某些情况下，我们可以保证另一件非常重要的事情是。
我们希望在期望中表现出单调的改善，所以值函数是预期的，奖励，所以我们希望能说的是，是我们在环境中部署的一系列政策，它们的值函数在上升，那么这意味着什么呢？这意味着，我们希望它小于或等于vπ2。
小于等于Vπ3点，这是我们部署的策略，每次迭代或每一轮，它不能保证一次运行，这个政策更好，所以你可以很容易地拥有它，平均来说，你部署的策略更好，等，但对个别病人来说，这可能更糟。
我认为现在一个非常有趣的活跃研究领域是，安全加固，学习嗯，和安全勘探，很多不同的人都在想这个，我们在小组中看到的一件事是，如何真正有效地找到安全的解决方案，你说安全是什么意思，在这种情况下。
我是说你可能不想匹配最大预期回报，你可能希望能够最大化某种风险厌恶标准，我们想找到真正有效的解决方案，但有很多非常有趣的东西说，你知道的，我们如何尝试进行策略搜索，或者我们如何进行这种改进。
在我们不仅仅关心预期结果的情况下，所有的权利，所以我们今天要做的是，理想情况下，不仅仅是单调的改进，但是大的单调改进，嗯，正如您可能猜到的那样，尝试实现小的单调改进更容易，比保证真正大的单调改进，嗯。
有人有直觉知道为什么这是真的吗，我可能更难，这可以追溯到状态分布，所以如果你经常改变你的政策，国家是否，就你访问的州而言，州分布会发生很大变化吗，如此直观，答案应该是肯定的。
所以我们讨论了一些政策是如何诱导国家分配的，就像你运行了很长时间，你会在状态上有一个固定的分布，如果你的政策真的和你以前的政策不同，那么状态分布可能看起来真的不同，这意味着您可能没有太多数据，嗯，然而。
如果您的政策与以前几乎完全相同，你可能会有一个很好的概念，估计中的价值，但我们以后会有更多的讨论，所以我们今天要做的是试着思考超越，我们上次说的，我们试图做策略梯度方法。
我们试图以一种高效的方式来做这件事，我们将讨论其他方法，使它更有效率，噪音更小，然后尝试去单调的改进，所有的权利，我们上次讲的是我们一开始说，在政策梯度方面，我们可以做什么。
我们可以做的一件事是你做蒙特卡洛回归，这些是蒙特卡洛的回报，有时人们用tau的大r，这是一个轨迹，所以你可以用完你的保单直到世界毁灭，或者每一步，或者无论如何，你在定义你的剧集，嗯，然后看看奖励。
看看对面的奖励，你知道吗，每时间步长，我们也可以用，T表示我们从时间中得到的奖赏，第一集的T步，我们之前说过的是，这是对梯度的无偏估计，但是真的很吵，所以我们开始讨论额外的结构。
我们可以用在强化学习问题上，我们假设世界是马尔科夫的，试图减少这个估计的方差，我们上次讲的是使用时间结构，我们在黑板上做了一个人，直觉是你在某个时间点得到的奖励，嗯可以不受你后来做出的决定的影响。
所以你不必把行动概率的完整乘积，鉴于各州，因为未来的行动不会追溯性地改变，你早期对直觉的奖励，所以我们现在要开始讨论的是其他事情，这是蒙特卡洛的基线和替代方案，那么基线井是什么，基线是，让我们还是想想。
看看我们从这段时间开始得到的奖励总数，所以这和我们经常称之为GT的东西是一样的，这就是我们从这一步到这一集结束的奖励，我们将减去一个依赖于状态的基线，我很快就要展示的是，减去这个只取决于状态的基线。
您得到的梯度估计器仍然可以是无偏的，但它的方差可能不会低得多，尤其是，一个真正好的选择往往是预期的回报，它基本上是值函数，那么我们为什么要做好这件事，然后我们可以看看，我们增加一个动作的对数概率。
与它比基线好多少成正比，总的来说，它最终会有点像优势函数，那么为什么这是真的呢，好的，所以嗯，我们在这里要做什么，我们会说我们现在有一个很高的方差估计，如果我们没有想象我们没有这个，我们没有那个。
我们有我们的，标准估计数，我们上次说到，我想说服你的是，如果我们减去这个东西，它是状态的函数，一个期望，那个附加条款，我们减去的是零，这意味着我们的估计量仍然是无偏的，所以我说我们最初的估计是无偏的。
现在，我们在减去这个奇怪的东西，我们希望证明得到的估计器仍然是无偏的，我们这样做的方式是通过展示这一点，我们的目标是展示，这等于零，所以这就是我们要尝试做的，如果我们能证明。
那么这就证明了为什么我们可以减去这个随机的东西，然后我们可以开始讨论那个随机的东西应该是什么，但首先我们要展示，不管那个随机的东西是什么，如果它只是这个期望值为零的状态的函数，那么我们如何做好这件事。
首先在外面注意到，对tau有一种期望，这就是我们运行当前政策可能遇到的所有轨迹，所以我首先要做的是，我要把它分成两部分，所以这仍然是tau，我在这里所做的只是，我把它分成了第一部分。
这是一直到时间步骤T，第二部分是准时步骤T，一直到最后，所以我只是有点分解，我只是写了什么，嗯，一个轨迹是，然后分解成两部分，我在分解弹道，一旦我们这样做了，那么我们可以看到基线项只是t的函数。
所以我们可以把它从这个内项中拉出来，所以我们要把这个拉出来，因为它不依赖于这些未来的时间步长，它独立于那些，接下来我们要做的是，我们要写出或注意到这样一个事实，在这种情况下，我们在这个内部项中所拥有的。
这里是s t和a t，这样我们就可以再次放弃所有未来的条款，那种，这里唯一的东西是当时行动的概率，给定状态t和θ的步t，所以我们不需要担心未来的状态，或今后采取的行动，我们独立于那些。
所以现在我们拉出第一个，我们拉出基线，而现在，我们要放弃那些我们不需要依赖的东西，所以我们在这里所拥有的只是对所采取的行动的期望，现在我要做的是读，那么这个期望是什么，这是一个超过T的期望，有什么问题。
你知道的，那个期望是什么，我们只是要明确地把它写出来，这取决于我们的政策，所以我们要把这个概率加起来，那个，当然啦，这取决于我们遵循的策略乘以对数的导数，这就是我写出的期望，现在我要对对数求导。
所以这只是关于保单本身的导数，除以a t tθ的π，但是现在我们注意到分子上有一个项，就我们可以取消的分母而言，所以这开始简化，s的b乘以a的和，只是保单的导数，刚刚取消了分子和分母，我们注意到。
我们可以反转求和和导数，这是证明的另一个关键步骤，现在我们要做的是，我们要把导数移出，嗯，这只是一个，因为我们在策略下选择某些行动的概率总是，所以现在我们看到我们只是对1求导，所以我们试着对1求导。
当然，这是一个常数，所以这等于零，所以这很酷，这意味着我们在这个基线中添加了，那是某种功能，这取决于国家，我们还没说是哪一个，我们，你知道，我们还没有讨论所有不同的计算方法，但我们说是什么并不重要。
不管你在那里加了什么，它总是不偏不倚的。
所以只是为了检查我们的理解。
如果我们回到这个方程，如果我把st的b设为常数，梯度估计量仍然无偏，只要八分钟，和你的邻居聊天，说，如果我是这样，根据我刚才说的，如果s t的b等于一个常数，这是一个常数。
不带偏见只要花一秒钟或一分钟和你的邻居谈谈，所有的权利，所以让我们从每个认为它仍然没有偏见的人开始，投票，是呀，伟大，好的，是呀，它仍然必须是无偏见的，现在它是一个函数，甚至不是S的，它只是一个常数。
所以它肯定是s的函数，这是一个微不足道的函数，其中s的值是多少并不重要，所以它仍然是无偏见的，只是在这里注意一下，嗯，如果S是一个，如果基线是状态和作用的函数，你认为这个证据会通过不不对。
因为我们一开始做的一件事是，我们把B个S T一路搬了出去，如果这也取决于行动，我们不可能那样做，所以这是特定于这个存在的，只是状态的函数，不要给你一个公正的B，B有什么函数吗，如果b只是状态的函数。
他们都是无偏见的，是啊，是啊，所以它总是无偏见的，可能真的有我的意思是，就像我放在这里的，嗯，你可以输入一个常数，它可能根本不会减少你的方差，因此，基线的定义肯定是无用的，但都是无偏见的。
所以他们不会影响，你的估计量是否无偏，它们可能会使您的估计器变得更糟，如果他们真的很糟糕，嗯，或者他们真的是他们自己，嗯，非常糟糕的估计量，潜在的，嗯，他们当然可以让它变得更好，最终。
允许我们定义所谓的香草策略梯度算法，嗯，所以香草策略梯度通过，我们使用当前的策略收集一堆轨迹，然后每一次进入轨迹，我们计算从那个时间步到结束的返回，然后我们计算优势估计。
所以好吧，我们将写出香草策略梯度，好的，因此，香草策略梯度的工作方式如下，你启动，您使用一些参数θ初始化策略，你需要从基线的一些估计开始，好的，所以香草策略梯度发生的事情是为了迭代，我等于1到点，点。
点，我们要收集一组轨迹，使用当前策略，然后对于t等于一个点的每一个时间步长，点，点你轨迹的长度，然后你做两件事，您计算返回，这正好等于所有回报的总和，直到这一集结束，然后你计算一个帽子的优势。
正好等于这个返回，我会用i来参数化它，只是为了表明这是第i条轨迹减去s的b，在这里注意一下，嗯，这是到本集结束的奖励总和的回报，这是一个基线，就像一个固定的函数，所以这可能是，你知道的，深度神经网络。
这可能是表查找，但这是一个函数，你输入状态，轨迹中的T步，我和你输出一个标量，这就是基线在那里做的，然后我们做的是简单的政策梯度，然后我们把基线，所以在这种情况下，基线将是GS平均值的估计。
所以在香草策略库中，香草策略梯度，我们要做的是下一步，我们把到目前为止得到的所有轨迹加起来，我们把所有的时间步长加起来，我们基本上只是做一个最小二乘拟合，所以现在这个可以用像，这是监督学习。
我们只是有一个基线函数，可以参数化，我保证在那儿写上“i”，所以我们有一个基线函数，可以参数化，与一些完全其他的权重或参数，然后我们有回报，到目前为止我们所看到的，我们只是试着把距离最小化。
所以基线实际上代表了预期的奖励总和，注意，这在某些方面有点有趣，对，因为我们正在使用我们所见过的所有数据，所以这可以在你见过的所有数据上完成，也可以只做最近一轮，如何做基线有很多选择，嗯嗨。
如果你用你见过的所有数据，嗯，那么这就是它的作用，因为你有来自不同政策的数据，如果你在最近一轮中这样做，那么你就会得到一个基本的v pi的估计，v pi，我喜欢迭代，这最终将接近，如果你只是在轨迹上做。
如果你不这么做，但你把它和这一轮的轨迹相加，我想我写这篇文章的方式有点不清楚，所以让我看看我能不能说得更清楚一点，所以假设我们有一个，我们有D轨迹，所以如果我们这样做，那么它正好等于vπi。
所以i现在是迭代，d是我们在迭代中收集的轨迹，所以这只是对这个特定的保单的平均，的，这一特定政策的轨迹，3。我说我最近有点失常，有人对我们在这个案子里到底在做什么有什么问题吗，所以在这种情况下。
通常会有一系列的回合，这是每个人的，所以我们要吃一系列的馅饼，基本上，然后对于每个策略，我们将有一组轨迹，对于每个轨迹，我们有一组时间步长，这里所说的是所有轨迹的平均值，并将基线与当前策略相匹配，好吧。
一旦你有了，所以这给了你基线，然后我们更新政策，使用渐变，它将是包括这些导数的项的总和，关于政策，和你的优势功能，所以你要把你在这里计算的优势函数，然后你要把它乘以，在给定的状态下。
这些行为的概率是多少，θ是它的对数导数，然后我们把，把梯度的估计变成随机梯度下降或原子，别的东西，所以这是香草策略梯度，在今天剩下的时间里，我们将看到什么，只是这个基本模板上的一些不同的轻微变体。
所以我马上就去找你，但我只想强调，如果你，如果你当你离开，我想让你从，政策梯度的主要思想本质上是董事会上的东西，我们现在要做的是，2。我们买一样东西，我们从中得到了一堆数据。
然后我们必须适应一些类似优势的东西，会有不同的计算方法，我们最终可能会做自助，做某种TD估计，或者我们可以直接用回报，我们经常使用一个随着时间的推移而拟合的基线，然后我们要更新政策。
并且必须根据梯度选择一些步长，所以最重要的是说，嘿嘿，几乎所有策略梯度算法都有一个基本模板，我可以选择不同的东西插在这里，我可以选择不同的方式来调整我的步数，这将定义一系列不同的政策，你看到的渐变算法。
那么我们用什么函数来表示圆周率，这样我们就可以把它的梯度，大问题，所以我问你知道，我们如何表示策略，这样我们就可以把它的渐变，我们必须能把这个放在这里，我们上次简短地讨论过这个。
但它也在接近尾声的黑板上，高斯工作，软马克斯，两者都是你可以分析求导的，我们经常使用深度神经网络或浅深度神经网络，是呀，我在后面看到一个问题，先说出名字，拜托了，我想知道是否有什么问题，像非站。
如果我们像，神经网络的基线，如果有不稳定的问题，是啊，是啊，这是个很好的问题，所以我相信问题是说，嗯，你是，你在问我基线，对呀，就像，你怎么会在那里，非平稳问题，经验上，包括我在内的很多人都在想，嗯。
我们有所有其他的数据，所以当我们现在估计梯度时，通常我们在运行策略，只是你知道D轨迹，然后我们用它来估计梯度，嗯，也许我们可以使用其他数据来做到这一点，但最终却不在政策范围内。
因为这样你就把数据混合在一起了，你从不同的政策中收集到的，经验上，我认为人们最终往往只使用当前运行的数据，然后你基本上只是用这个估计v pi，您不一定要为许多其他策略混合数据，经验上。
似乎经常在政策上很有帮助，你可以重新加权旧数据，但这引入了方差，所以从经验上来说，往往是最好的，我想陪审团还没有定论，对它的研究正在进行中，我们已经看过了，谢尔盖·莱文的小组已经研究过了，但是嗯。
大多数时候，使用on policy数据是有意义的，是啊，是啊，还有问题吗？拜托了，我只想确认一下，所以当你说改装基线的时候，我们在设定基线，等于使函数最小化的值，挺酷的，是的，是的，是啊，是啊，这里。
如果我们这样做，当我们这样做的时候，它本质上是，这基本上和我们做蒙特卡洛政策评估时一样，所以这几乎完全像蒙特卡洛的政策价值，我们有固定的政策，然后我们有一个参数化的函数来表示它。
然后我们只需要符合这些参数，这样我们就可以最好地估计政策，好的，所以我要，有一点关于自动差异的信息，你可以在幻灯片上查看，我们接下来要经历的事情，嗯正在考虑这方面，正如我所说的，然后我们谈谈这个。
所以这部分是我们思考单调改进的地方，因为一旦我们有了渐变，我们得弄清楚要走多远，我们能保证根据我们走多远，我们是否会得到单调的改进，这部分是关于更好地估计我们的梯度，理想情况下。
用更少的数据并减少它的方差，所以它们都很重要，他们做的事情略有不同，所以让我们来谈谈，我们能提前一点吗，请谢谢，好的，就像我们之前开始谈论的，嗯，呃，嗯，让我们，让我们先谈谈，基准。
那么我们应该如何选择基线呢，我们可以为基线做的一件事是喜欢，我们在那里看到的，这是对V pi i的经验估计，所以我们可以说，一般来说，我们只想用v pi i作为基线，这意味着我们必须以某种方式计算它。
我们估计这可能来自蒙特卡洛，也可能来自TD方法，到目前为止，我们看到的是用这些作为一个，如此如此，我猜，我想说清楚，有几个不同的地方我们可以，也许在做蒙特卡洛回归和做TD之间切换，就像一个在这里。
另一个是我们的基线，好的，所以我们在这里有一个基线函数，我们在减去，我们这里也有一个G T素数，所以如果我们再想想我们的一般方程，在这个例子中我们得到的是θ的δθ，这是我们的参数。
这是指定我们的策略参数，我们说过这约等于1/m，i的和等于1到m的奖励，嗯，我把这个放进去，和等于0到，改变我的想法，好的，我要把这个放在这里，因为它最终会成为，一个我们可以用很多不同方式使用的函数。
这是我们一直在研究的基本方程，我们说过，该值对我们的策略参数的导数，近似为m个轨迹之和，我们从政策时代取样了这些轨迹，我们在那个轨迹上得到的总奖励，总时间之和，保单派生的步骤，嗯。
鉴于我们在该州采取的行动，我们很好，我们说很吵，嗯，但不带偏见，现在我们可以把它作为一个目标，所以这是对保单价值的无偏见估计，现在我们可以考虑用其他东西代替，所以我们可以想象在这里做各种各样的事情，嗯。
你知道的，TD或MC方法，如果我们用值函数来做，或者如果我们试图显式计算一个值函数，或状态动作值函数，那么我们通常称之为批评家，所以一个批评家，所以当我们谈论演员的时候，批评方法。
这时我们有了策略的显式参数化表示，我们有一个明确的，状态动作值的值的一般参数化表示，如果我们有，然后我们可以想象用它来改变我们的目标，我想在这里强调的是，所以演员评论家的方法结合了。
这两者结合了政策加上批评，其中最受欢迎的可能是三C，由in和al组成，这是在二十六个ICML中引入的，它非常受欢迎，这是深度神经网络的版本，但是演员，批评家的想法本身已经存在了更长的时间。
但是三C是最流行的版本之一，对于深度神经网络，所有的权利，那么我们如何用值函数排序策略梯度公式，你可以在这里做什么，我会把你能做的放在这个网站上，你可以得到几乎和我们以前一样的方程。
所以相对于值函数等于期望，相对于你可能遇到的轨迹和，在这个轨迹中的所有时间步骤，关于策略参数的导数，s t w的q减去s t的b，所以这里没有你的蒙特卡洛估计，你可以插入你对Q函数的估计。
另一种表示方法是如果我们认为这是对价值的估计，这基本上是我们的优势函数，但它可能是我们的所以我们在这里有一个优势功能，您在这里定义优势函数，但这是那一集蒙特卡洛回归的功能，这是一个不同的优势函数。
也就是Q函数，一个批评家可以坚持这一点，减去你的基线，它是值函数的估计，所以它们看起来很相似，但是你可以在这里插入不同的选择，这些将有不同的权衡，所以蒙特卡洛对回报的估计是无偏的，当前保单价值的估计。
这将是有偏见的，所有的权利，所以我也想在这里强调当我们考虑，得到这个估计器，我们常说批评家要计算这个估计量，嗯，不一定是，只有TD估计或蒙特卡洛估计，但是你可以在这些之间插值，它通常被称为n步返回。
那么这意味着什么呢，所以让我们打电话，让我们把这个写在一个稍微好的地方，我把这个叫这里，所以让我们把这个当成帽子，请注意，你可以把这看作是一个函数，它将是对状态作用值函数的估计，所以我们可以拥有的是。
我们可以有一个估计器，从时间步T开始的值的估计值，等于实际，这是真的，我们准时到了，所以我把这叫做，我要把这种i逗号叫做一，这将是，那么实际的奖励，你很准时，进来吧。
一集i加s t的gamma v加i so，这应该看起来几乎完全像TD风格的估计，我们之前谈过这个，所以这说明我得到了，我看着我得到的实际即时一步奖励，然后我引导，我加上价值。
这将是我为我的批评家得到的这个值函数，我会把它插进去，然后那就是我的目标，然后我会在这个方程中使用，所以这是你做的一件事，你可以做，所以我们看到了这个，我们见过很多这样的事情，我将称之为无限或蒙特卡洛。
这个是你对所有质数的和，一直到这一集结束伽马到T素数减去T，这是蒙特卡洛回归，我们只是总结一下，我们不做任何自举，我们总结了这几集的所有奖励，但正如你在这里看到的，应该有一个。
你知道可能有某种方法可以在这两者之间插值，这些通常被称为n步返回，所以，比如说，你可以这么做，你可以说我会在时间里加上奖励，我和我当时得到的奖励，步t加一，然后我要引导，所以说。
这只是介于这两个极端之间的估计量之一，一个是你只接受一步奖励，另一个问题是你是否总结了所有的奖励，然后你可以在这些之间做一大堆插值，你为什么要把它做好呢？这个通常会有点偏差，但方差小，这将是公正的。
但方差真的很大，没有理由假设，最好的解决办法是在这两个极端中的任何一个，所以你可以在TD估计和蒙特卡洛估计之间插值，所有这些都只是形式返回，然后你可以从基线中减去，所以传统的。
所有这些可能被认为是一个超参数，我们可以通过验证和交叉验证来选择，人们在这里所做的是计算密集型的，所以你只需要挑一些东西，问题是他们是否在做一个破碎的机器学习，这将被认为是某种超参数。
你知道你可以把这变成N，你会决定你做多少步，人们做什么，问题是做什么，在强化学习中，人们会这样做吗，还是觉得太贵了，你当然可以，我觉得这是个有趣的问题，我觉得在这种情况下人们所做的把戏。
我想我可能会看到更多这样的东西，但变化更大，在大量引导过程中使用TD Zero，但这可能取决于您的应用程序域，它可能依赖于的另一件事是，如果你的域真的是马尔可夫的，所以这个案子还在工作。
这是给你一个真实的估计你的政策回报，即使你的域不是马尔科夫，在这种情况下，你在做一个更强烈的马尔可夫假设，嗯，你也可能想做一个，根据您的领域做不同的事情，以及收集数据的成本，所有的权利。
所以这给了我们一种不同的方式来插入东西，到普通策略梯度算法，我放在那里，这样你就可以插入这些目标，在偏差和方差之间进行权衡，当你对梯度进行估计时，所以这个在这里做的是，它正在改变我们的目标，它在改变。
我们如何计算梯度，但接下来我想说的是这部分，一旦我们得到了渐变，然而我们选择了得到它，我们必须弄清楚沿着梯度走多远，为什么这很重要，嗯，可能很重要，因为，嗯，这只是一个局部近似，你得到了梯度的局部估计。
是啊，是啊，更新参数的频率，问题是你多久更新一次批评家的参数，这又是一个很好的问题，视情况而定，这样你就可以，要么，您可以经常异步地这样做，所以你可以为你的评论家提供不同的线程和不同的网络，和你的政策。
嗯和原理，你可以一直更新你的评论家，就像你知道的，您可以为此使用DQN并进行很多很多的备份，嗯，总的来说，这要看情况而定我想你需要有一个时间表，是啊，是啊，很多时候你可能会做大约一百个。
它确实因应用而异，嗯，但是没有理由评论家只需要在相同的时间表上更新，您正在更新策略，异步执行通常很有意义，所有的权利，所以如果我们想想这里发生了什么，这是我们的参数化策略，这就是我们的价值。
我们有一些疯狂的功能，然后我们计算我们的梯度，所以在这里，事情看起来很线性，事情看起来很好，但当然，当我们走得更远时，就像这里一样，会很糟糕的，就像如果我们，如果我们试图沿着梯度走得太远。
我们将得到一个与实际价值非常不同的估计，实值函数，所以当我们测量步数时，在这种情况下，最后很重要的是要考虑到这个事实，你希望你的步数有多大，嗯，让我回到一分钟前，如果我能，好的。
所以我们想知道我们应该在梯度中走多远，这很重要，嗯，现在你可能会说，好的，这总是真的，对呀，就像，你要时刻小心，当你在任何监督学习问题中做梯度下降或上升时，当你使用随机梯度下降时，当然。
你不想在你的步数上走得太远，因为你可能会超调，然后嗯，你在用这个线性近似，而且很糟糕，呃，为什么有人这么做，有人知道为什么，这可能更糟，在强化学习案例中，考虑步长可能更重要，这与数据来自哪里有关。
当你有一个糟糕的政策，那是俱乐部，你可能会去那个房间，那么什么是完全正确的呢，所以它不是在监督学习的案例中，您的数据是由iID分布生成的，你刚刚为你的随机梯度做了什么选择并不重要，在RL中。
这决定了下一个策略，我们在迭代中使用它来收集数据，所以我们不会，你知道的，如果我们采取一个非常糟糕的，如果我们得到非常非常糟糕的政策，我们可能没有得到关于这个函数的实际最佳状态的数据，所以更重要的是。
仔细想想我们要去哪里，理想情况下，希望得到单调的改进，所以这是真的，嗯，这在强化学习案例中非常重要，想想我们是如何做这个步长的，因为这决定了，在我的一个同事谈论类似问题的一个版本中。
他有一张走鹃从悬崖上跑下来的照片，对然后，如果你在一个地方，你的政策真的真的很糟糕，你可能不会得到更多有用的数据，那你就不能得到一个好的估计，在渐变的地方，然后你就被困住了。
你可能会陷入非常非常糟糕的最佳状态，好的，所以我们要仔细考虑这一部分，嗯，所以我们可以做的一件事是做一些类似线搜索的事情，所以我们现在说的是，我们该怎么办，所以说，如何做步长，所以我们可以做的一件事是。
试着沿着渐变做一些线搜索，这样就可以了，但是有点贵，所以很简单，它倾向于忽略线性近似好的地方，所以我们想做得比这更好，所以现在我们要回到我在开始时提到的那一点，这是我们真正希望能够做到的。
就是我们在做这个更新的时候，我们希望确保单调的改进，所以我们可以选择我们的步长，或者选择沿着梯度走多远，以实现单调改善，所以我们的目标是我们想拥有它，所以i加1的v pi大于或等于v pi，和。
我们希望通过改变我们的步长来实现这一点，让我们再想想我们的目标函数是什么，嗯，所以我们得到了，我们有我们的价值，我们的参数化值，所以θ中的b等于我们政策下的期望值，它是由t=0的和的θ定义的。
根据我们的政策，伽马T的无穷大，这就是我们观察一系列状态的地方，我们得到了我们的政策，这就是我们这里的基本方程，在表示参数化策略的值方面，我们想做什么，这里是我们想要一个有更好价值的新政策。
但问题是我们有一份旧保单的样本，所以当我们这样做的时候，我们正在收集政策与皮尼，然后我们试图计算出我们的πi加1应该是多少，所以这将从根本上涉及，嗯，所以我们可以访问，你。
可以获得从θ的圆周率中采样的轨迹，我们现在想预测θ的π的v的值，我把πi i加1，所以我们想，现在，弄清楚一个新的值是什么，如果我们更新这些，以某种方式更新这些参数，并获得最大值。
你知道我们想弄清楚新的参数是什么，但这从根本上说是一个政策问题因为我们有上一次政策的数据，好的，所以我们要做的是，我们首先要表达，嗯，就优势而言，我们政策的价值，哦，就我们的新政策比旧政策的优势而言。
我们的新政策的价值，所以我现在要向下移动新的政策梯度，好的，所以我们有的是，我们有波浪形的v，所以那可能是。
就像，我们的新参数化策略，将等于我们旧的参数化策略的值，所以不管我们以前有什么，加上下面，我们将得到的州和行动的分布，如果我们执行我们的新政策，现在我们不知道，但让我们，让我们忽略这一点。
t的和的一秒钟等于0到无穷大，伽马到T，优势圆周率，所以这通常是成立的，嗯，这不一定要做任何事情，嗯参数化，这只是说任何政策的价值，这里用圆周率作为参数，等于另一个策略的值。
加上你在目标下达到的状态和行动的总和，你接受这项新政策比旧政策的好处，所以这就表达了我们如何说，什么，新保单的价值与旧保单的价值有何关系，这和旧的价值观政策完全一样，加上如果你执行新政策。
你会得到的好处，看看你会遇到的状态动作分布，我告诉他们好处，下标应该是策略吗，嗯是的，所以我们在做，我把这个写下来，所以这个问题很好，让我把这个写出来更正式一点，好的。
所以我们得到θ的v加上所有状态的和，我们要用s的mu pi波浪，所以要记住，这是平稳分布，嗯，我们用它来表示我们将达到的状态上的静止分布，如果我们执行我们的新政策，它是参数化的Tilda，好的。
所以这里的意思是T和T在我们想要的政策下，这里的优势是使用旧的，所以这让我们可以比较，所以它的作用是让我们比较，这是在，所以它允许我们比较它有多好，如果我们采取新的行动，所有的权利。
但问题之一是我们不知道这一点，两个中的一些，哦，太谢谢你了，是啊，是啊，是啊，是啊，是啊，是啊，也如此如此，问题是，有没有，谢谢你让我澄清，所以在这种情况下，我们所做的是，我们对所有的时间步骤都有期望。
这是在我们将到达的轨迹上说的，根据我们的新政策，我现在重新制定了，说得很好，我们在状态上有一个平稳分布，如果我们看看，达到那些状态的概率是多少，然后我们根据优势来权衡。
所以我们从一个平均的时间变成了一个状态，平均，那是有道理的，所以我们可以把我们的值函数，平均我们的值函数跨时间步长，或者我们可以认为这里是所有州的平均值，每个州是什么。
遵循新保单和旧保单的相对价值是多少，青少年做什么，哦对不起，谢谢。然后呢，那些是错别字，所以我们把这个，所以这将是在，所以我们看看每个州的州，按照我们的新政策，我们达到那种地步的可能性有多大？
相对优势是什么，你指的东西不应该，不应该，哦对不起，我们这里有一个波浪形，这是我们原来的价值，加上对所有州的加权优势，所以我在这里做这个只是为了明确高度，我会说皮蒂尔德也是，圆周率参数化，这是一项政策。
以波浪参数化，我只是说这就像，期望你是第一个迹象，你写的，就像你没有演出的时候，所以我只是其中之一，好的，是啊，是啊，我们也不能投票，我只想说清楚，嗯，这个符号经常在使用，你想制定明确的政策吗。
这只是参数，我认为在这里有一个政策和参数更清楚，但我们也经常使用，你可以直接用θ参数化值函数，与θ{\displaystyle\theta}的v pi{\displaystyle v pi}相反。
但我要用这些中的任何一个都可以，有人困惑于，这是，我是说，如果更容易的话，我可以这样走，我可以把这些都去掉，好的，所以这只是每当我说pi tilde，这是由新的参数化的策略，那是你们的新政策，就是这样。
我知道这份爱，所以我们对此有什么问题吗，你是最后一个，名字第一，所以我想我有点困惑，主要是因为它和幻灯片有点不同，我只是想知道幻灯片不会有什么不同，但我想上去想知道，那么在这种情况下。
我们是否对给定状态的可能作用进行求和，或者正如这里指出的那样，我们是否假设我们在每个，呃，使用策略，这就是我们这里的，所有的权利，我忘了，所有的权利，我要走了，再做一次，好的，好的，让我们说。
波浪形的v，与幻灯片完全相同的符号等于θ的v，状态加和，我们在s的圆周率上的平稳分布，这是我们得到的分布，这是我们目标政策下的贴现加权分配，所以这是加权的事情，这是各州下的加权分布。
我们从时域到考虑各州时间的分布，看看我们在目标政策下可能采取的所有行动，以及与我们以前的政策相比，每一种政策的相对优势，这个看起来应该很，在某些方面与模仿学习非常相似，就像这样，我们又在想。
而不是考虑随时间步数的奖励总和，我们在考虑，在新政策下，我们可能得到的固定分布是什么，这与我们在旧政策下的固定分布相比如何，到目前为止，我们看到的是，我们正在研究目标策略下的固定分布，问题是。
我们不知道这个，所以我们不能计算这个，这只是一个表达，但这是未知的，我们没有皮蒂尔德的样品，我们只有圆周率的样本，所以我们不能计算这个，我们为什么要回去，我们为什么要做这些，我们正在努力做到这一点。
因为当我们做香草策略梯度时，我们将设法制定一项新政策，这比我们的旧政策有更好的价值，我们在这里做的是，我们试图估计现行政策的导数，嗯，但我们还不知道一旦我们迈出这一步的价值，所以我们在这里想说的是，嗯。
我们能理解一项新政策的价值吗，在我们执行它之前，我们要试着把它与，我们以前的保单有什么价值，加上旧政策和新政策之间的某种距离，根据我们可以实际评估的东西来理想地计算，使用我们目前的样品。
那就是我们要去的地方，所有的权利，所以我们有一个很好的表情，但我们无法计算，所以我们要做一个新的目标函数，我们要把这个倒着做，因为我们要弥补，然后我们将展示为什么这样做是一件好事，我们想做什么。
我们想用这样的东西，如果我们有这个，然后我们可以比较新保单和旧保单的价值，问题是我们没有这个，因为我们没有，新政策下的固定分布，所以我们要做的，相反，我们将定义一个目标函数l pi，它是这样的。
这是你旧保单的价值，加上你所有州的总和，平稳分布，旧保单的折扣分销，这就是它不同的地方，所以这是旧的，您目前的政策，然后表达式的其余部分看起来是一样的，现在注意我们可以计算这个，好的，这是，嗯。
我们可以把当前这一集的所有轨迹平均一下，我们可以从当前的数据估计我们的平稳分布，我们可以知道新政策的作用，所以如果有人给我一个新的政策，我可以计算这个，我也可以评估优势，好的。
因为这个优势只根据我以前的圆周率来定义，只要我有状态动作值函数的表示，因为我以前的政策，我可以评估一下，所以现在所有这些都是可以评估的，这可能不是一件好事，但我们可以计算出这是传入的，i作为参数。
我只是传入θ，然后把它给圆周率本身，是呀，就符号而言，是否是的，我把圆周率和，你可以想到有一些计算的新参数，所以我们的策略总是由一组参数参数来参数化，你可以把这看作是一项新政策。
或者你可以把它看作是新的参数要么很好，你能解释一下，如果给你，嗯嗨，告诉我为什么你不能计算，呃穆，你没有那么多，所以问题是，如果你得到新政策的圆周率，为什么你不能计算亩，这是个好问题。
因为你没有任何数据，所以有人给了你一个新政策，可能有接近这一点的方法，但你现在掌握的唯一数据来自PI的当前旧策略，所以你已经把这个用完了，m次，你有m的轨迹，这是在你的旧政策下收集的M轨迹。
你没有任何来自圆周率的数据，一般来说，如果圆周率和圆周率不一样，你会得到不同的轨迹，所以你没有任何对每个人都有意义的直接估计，所以如果我们回到香草政策梯度，我们该怎么办，我们有一个政策，皮尼。
我们运行了它，我们得到了圆周率的d轨迹，我们可以用它来估计给我们的政策数据，我们所经历的状态和行为是什么，当我们跟着圆周率，我们没有圆周率的任何数据，我还加了一个，我们还没有运行它。
旧策略的平稳分布估计，呃，你基本上看所有的数据，你有像所有的轨迹，看看你在一个状态下花费的时间有多少，原来如此完全正确，你会怎么从这个，只是原始数据，这些到MU的D轨迹，你可以数数。
你知道我是说总的来说，如果你在很高的维度，你想做一些比那更流畅的事情，你想近似密度函数，嗯，但本质上你可以直接在一种状态下，你可以数数，看看我有多少次达到这种状态并采取这种行动。
然后这将给你一个直接的估计，嗯，一般的缪斯，你会想要某种高维的参数函数，但你可以用你可以，你可以想象这本身就是参数化的，您可以使用现有的策略数据来适应它，直觉上做这项工作。
因为我们假设各州的分布在政策之间不会有太大变化，我的问题是直觉上的，为什么这项工作，3。我还没有告诉你这是为什么，我刚说过这是我们能做的，它是可计算的，我还没有告诉你为什么这是一件好事，但我们要证明。
嗯，这将允许我们得到一个下界，然后我们可以在那些下限上改进，好的，所以这里有一件事要注意，也就是说如果你这样做，如果你做圆周率的L，这就是目标函数，如果你把旧政策插在那里，这正好等于V，因此。
如果您在相同的策略下评估此函数，它只是给你价值，如此保守，我就简短地说几句，我们以后得继续这样做，但是嗯，所以我们可以用它来做所谓的保守策略迭代，保守，嗯，这里的直觉是，让我们先从混合开始，混合政策。
所以想象一下你有一个新的政策，混合了嗯，旧政策和不同的东西，所以你有一个负阿尔法乘以你的旧政策，加上阿尔法时间，一些新政策，π质数，所以这只是意味着你把一些旧的你目前现有的政策，你混合了其他东西，好的。
那么在这种情况下，您可以保证新保单的价值大于或等于，如果你在这里取这个目标函数，你用你的新政策来评估它，所以你拿着你的新政策，根据你的旧政策，你很重视它，你把它插进去，那是可计算的。
因为您有旧策略中的数据，负2εγ，1-伽马平方，α平方，这样您就可以降低新策略的值，不管这个目标函数是什么，当你计算它减去这个表达式时，嗯，我只想用另外两个想法来结束，再次注意，如果你插入，α等于零。
这意味着π新和π旧是一样的，这就归零了，这意味着既然我们知道这等于那，只是说你的新保单必须大于或等于你的旧保单，因为同样，他们的政策都一样，说紧，好的，所以我们，这与我们预期的有点不同。
因为PDF的技术挑战，呃，所以我要用这里来结束，我们接下来要做的是展示，我们可以用它来导出新值函数的下界，我们基本上可以证明，如果我们提高了下限，我们保证实际值函数是单调提高的，所以我们会经历的，嗯。
我还没有决定，我们星期一是否会完成那件事，因为那是中期审查，或者我们是否会等到期中考试后的下周，政策梯度作业要到期中考试后才会发布，所以我们有更多的时间，我会经历，也喜欢政策梯度的主要外卖。
当我们结束这一部分的时候。
605
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
