标签：这个 在线 一个 笔记 公开课 然后 卷积 我们 就是

七月在线公开课笔记（一）

【七月】NLP高端就业小班10期 - P1：1.循环神经网络与Pytorch框架_ev - 不看兵法的数据分析师 - BV1BC4y1C7E5

好OK那咱们就开始今天的一个课程内容啊，好，咱们这次课程主要是要给大家讲，这个关于神经网络这一块啊，神经网络这一块。

那我们先看一下今天要给大家讲的四块内容啊，首先呢我们会从这个基础的神经网络开始，给大家讲起啊，然后呢再给大家介绍关于啊，NIP当中用的比较多的这个循环神经网络，然后是卷积神经网络，卷积神经网络呢。

可能更多会应用在这个图像处理，这个图像处理当中啊，但实际上啊在NLP当中也还是有蛮多啊，使用这个卷积神经网络来处理文本的，那最后一部分的话，我们会做这样的一个文本分类的，这样的一个实战啊。

实战还是先讲理论后进行实战，好吧好OK，那我们就先来看我们今天的第一块内容啊，关于这个神经网络，神经网络，那什么是神经网络呢，我们这边举个小例子啊，举个小例子，假设呢我们现在想构建这样的一个模型啊。

这个模型的作用呢，是来预测我们这个深圳的这样的一个房价啊，深圳的这样的一个房价，那我们先从简单的开始考虑啊，假设啊假设我们这个房屋的总价格啊，只和我们这个面积有关系啊，只和我们面积有关系，那这样的话。

那可能就是看面积的单价是多少就OK了对吧，既然如此啊，我们大概会得到这样的一个函数关系啊，那一开始可能啊我们是从零开始吧对吧，那肯定没有说这个面积特别小的这样的房子啊，那这可能至少他也有一个压制品嘛。

对吧好他大概可能就是这个样子啊，他的关系可能是这个样子这样子，那这个是一个比较理想的一个状态啊，就说咱们的一个面积和咱们的这个价格啊，它是呈现这样的一个正相关的对吧，当然啊真实的情况的话。

可能咱们有些样本点啊，就可能会在啊咱们这个这条函数的两侧对吧，现在咱们这样的一个两侧啊，咱们只是说构建出了这样的一个函数，来拟合咱们这个面积和咱们价格，这之间的一个关系啊。

那假设我们的这个面积是那价格是Y，那实际上我们是可以得到这样的一个，映射关系的对吧，也就是Y等于这样的1WX加B，我们是可以得到这样的一个映射关系的，这样的一个映射关系的好。

那这个呢是我们只考虑了这个面积的一，个情况啊，但实际上呢咱们这个价格啊，其实影响因素有很多对吧，除了咱们的这个面积以外，那可能还得考虑一些房屋的一些，周边的一些配套对吧，是否啊临近地铁啊。

或者说你这个住宅楼距离市区的距离，远不远对吧，还有他的一个什么像房屋的一些年限，那如果你说你这个房屋还是九几年的房，那你现在嘛肯定没有10年建的房，卖的这个价格高对吧。

那假设啊我们每一个这样的一个影响因素，它都有自己这样的一个权重，也就是说对于面积这个值啊，假设对于这个特征我们定义为X1，那它对应肯定会有相应的权重对吧，我们这个W1来表示，就好比咱们刚才这样。

这个图对吧，我们的这个面积啊，会有对应这样的一个W1个权重，那你就可以得到这样的一个价格，那假设我们在这里多个因素的情况下，我们面积这个特征的对应的权重是W1，那对于我们第二个特征，我们假设10W2。

第三个特征是W3，然后我们的房屋年限是第四个特征啊，我们假设是W4的这样的一个特征，那，有了这些特征之后呢，我们会认为啊我们可以根据这些特征，我们实际上是可以得到我们最终的这样的一个，价格的对吧。

最终的这样的一个价格的，也就是说，如果我们把我们的这些每一个输入的，一个特征啊，看成这样的一个向量，看成一个向量，那最终呢我们的这个价格Y啊啊，实际上就等于我们的X乘以我们的W的转置，对吧，最后呢。

我们可能还需要再加上这样的一个偏移下，那这个东西呢这个关系映射啊，大家就可以把它简单的看成一个，所谓的一个神经网络，只是说啊，咱们这样的一个关系映射，到底应该是什么样子的，那就取决于你的这个神经网络。

它是什么样子的了，好我们继续往下看啊，这里呢我给大家罗列了一个很普通的一个，最基础版本的一个神经网络，那他这里呢，首先呢就输入了这样的一个四个特征对吧，那这个神经网络呢。

它会对这四个特征去做一些这样的一些，交互的一些计算啊，交互的一些计算，那对于这里呢我们就可以发现，它其实有三个这样的一个节点，三个这样的一个节点，那这三个节点呢实际上就是我们前一层对吧。

我们前一层的这些值得到的这样的一个，交互之后的这样的一个结果，那通常啊对于一个普通的一个神经网络来说，例如这个地方的一个值啊，这里咱们可以我们用H来表示，实际上呢就等于咱们这里这个X1对吧。

这里会有一个权重啊，这里会有一个权重，那就是啊我们这里用呃W1表示啊，这里呢我们用W2表示，这里呢我们用W4表示，那对于这个节点的一个值呢，就等于W1X1加上W2X2，再加上我们的W4X4。

最后呢我们会有这样的一个偏移项，对我们会有这样的一个偏移项，通常啊经过了我们这样的一个计算之后呢，我们都会在外面啊，再进行一个所谓的，加上一个所谓的一个激活函数啊，加上一个激活函数。

那这个激活函数的作用是什么呢，通常呢是引入一些非线性的一些变化啊，引入一些非线性的变化，我举个例子啊，假设啊，我们如果没有这样的一个非线性的一个变化，那走到下一层的时候。

我们实际上假设啊这里我又成了这样的一个W，假设我这里是用W来表示好，我把这个W5再和这个直接相乘，那相乘之后的结果是不是就是W1W5乘以哎，乘以X1对吧，后面我就不写了，就写不写了。

那最后一项的话就是W乘以B那可以发现啊，这个时候实际上啊，这里这个W1W5，和这里这个W其实可以用同一个值来表示，所以说啊咱们这个神经网络，每一层最最普通的神经网络啊。

每一层之间我们通常都会加上这样的一个，所谓的一个激活函数，去做一些非线性的一些变化，不然你的这个两层的神经网络实际上和一层啊，它就关系不会很大好吧，他的关系不会很大，所以啊我们需要去加上这样的一些。

非线性的一些变化啊，非线性的变化，那这就是我们的一个最基本的，最基础的一个神经网络，那这个时候可能就会有同学说了啊，那我怎么知道这个X1X2X3X，我到底应该构建什么样的一个神经网络呢。

那这里这个神经网络对吧，我们这里有一个中间这一层啊，我们通常称为隐藏层，然后最后这一层呢我们称为输出层，那有的同学会说，那我这个隐隐藏隐藏层，我到底应该设置几个节点呢对吧，或者说我这个隐藏层现在是一层。

那我可不可以搞两层或者三层，那都是OK的啊，都是OK的，那到底应该设置几个节点呢，这就是一个所谓的一个超参数啊，超参数需要我们去自己进行这样的一个，超参数的进行一个调整好吧，进行一个调整好。

这就是我们的神经网络啊，然后我们这里来看一下这里站的一个网站啊，啊这是一个神经网络可视化的这样的一个网站。

我们可以去看一下啊，我们可以随便选啊，啊这边是有一个数据的一个数据集啊，假设呢我们要分这样的一个数据集啊，可以看到中间是蓝色的点，然后外面这一圈的话是这样的一个橙色的点啊。

我们要把这个蓝色的点和这个橙色的点给啊，区分开啊，分成这个样子，然后这边呢我们会有一些这样的一个，输入的一些数据好，那我们可以给他添加一些这样的一些，输入的一些数据，中间呢就是咱们的这个隐藏层啊。

这边是咱们的输入值，这边是咱们的一个输入值，然后这边呢是咱们的一个啊隐藏层，隐藏层现在的话是四个节点对吧，我这边先去两个啊，我就用原始的X1和X2，这两个输入值作为我们的输入啊。

这边呢是四个这样的一个隐藏层的一个节点，然后这边的话就是咱们那个输出值，因为为什么这里是二呢，因为我们要做一个二分类对吧，我们要把它区分成蓝色节点和橙色节点，好，我们可以这边是可以调整一些超参数啊。

好OK我们执行一下，可以看到啊，这个时候模型就是正在收敛啊，正在收敛，那其中蓝色这一块的话，就是咱们的这个蓝色的点，橙色这一块呢里面就是咱们橙色的点对吧，然后这边呢，我们还可以添加更多的这样的一些层啊。

可以添加更多的一些层，然后这边呢，我们也可以去添加节点的一个数量啊，然后我们也可以再跑一下哎，他也是可以压收敛的，这边我们可以换一下，换成其他的，甚至你可以多加一些特征数据对吧，OK我们再跑一下好。

这边也是进行这样的一个收敛啊，这就是咱们的一个很普通的，这样的一个神经网络啊。

神经网络好，那除了这样的一个最基础版本的，神经网络以外呢，其实还有很多的一些其他的一些，神经网络的一些变体啊，啊例如咱们的这个卷积神经网络，卷积神经网络，还有咱们的这个循环神经网络。

那咱们今天除了给大家介绍这种最基本版本的，这个神经网络以外呢，我们也会给大家去介绍这个所谓的卷积，神经网络，还有循环神经网络，好吧，我们就分别来看啊，我们分别来看好，接下来呢我们来看一个概念啊。

就说如果我现在有了这样的一个神经网络对吧，我该怎么去把我神经网络当中，这些参数给求解出来，什么意思呢，就是说我这里的这些W，我这里不是有很多这样的W吗对吧，那这个W我该怎么求解出来呢。

如果我不知道这些W的话，那你最终你输入这个值对吧，我也拿不到最终的一个结果，所以关键啊神经网络你除了要有结构之外，还要有咱们的这个参数对吧，还有还要有咱们这样的一个参数啊。

也就是咱们这里这个WOK那我们来看个例子啊，看个例子，假设呢我现在要输入一张图片，我要判断一下啊，我输入的这张图片，它到底是个什么动物啊，是个什么动物，那这里呢，我们就把这个图片给到咱们这样的一个模型。

那这个模型的话其实就是两部分组成，刚刚说的这个结构和咱们这个参数啊，结构的话就看你去是怎么构建了，你可以去构建一个啊，普通的这样的一个神经网络对吧，你也可以去构建这样的一个卷积神经网络好。

那当我们把我们这张图片，输入给我们的模型的时候呢，我们的模型啊它会输出一个值，它会输出一个值，那这个值呢表示的是我们的图片的某个类别，某个类别好，这个输出值到底该怎么定义，我们待会再说啊，待会再说。

那有了输出值之后呢，实际上啊我们对于每一张图片，我们都是有真实的这样的一个标签的对吧，人工可以给这个图片打上标签，那对于模型的一个输出结果，和我们真实的这样的一个结果。

我们就可以去计算它之间的这样的一个差值，那这个值呢我们把它称之为loss，loss值啊，也就是说我们的预测值和我们的这个真实值之，间的这样的一个差距有多大，那我们的目标是什么。

我们的目标实际上就是要把这个差距缩小对吧，我们要把这个差距缩小好，那把这个差距缩小，我们就等于是在去，怎么才能把我们的差距缩小呢，说白了就是要去让我们的这个参数变得，越来越好对吧。

越来越适合我们这样的一个场景，我们可以回到刚才那个例子啊，假设我们要让我们的房价预测的特别准，那肯定也得保证我们的这个W对吧，我们这个W尽可能的让我们的这些样本点，和我们真实的这个结果。

它的这个差距最小，那才是最合适的对吧，所以说啊我们就需要不停的去把这个最合适的，或者说最优的这个W给求解出来啊，给求解出来，那这个求解的过程呢，我们通常采用的是梯度下降法，梯度下降法好。

那接下来的话我们就分别来看一下，我们的这个loss和我们的这个啊，梯度下降法到底是怎么回事啊，怎么回事啊，好等一下啊，我们在看这个loss和梯度之前呢，我们先把咱们这个前项的这个流程啊。

我们再简单梳理一下，我们刚才这里说到说哎，我们这里会输出一个这样的一个值对吧，我们这里的话是输出了一个零，那这里这个零表示的是什么意思，或者说我每次输出的时候，我到底应该输出什么东西好。

我们先看这个问题啊，我们先看输出，再看loss，再看我们的梯度下降法好不好，我们先看输出，首先呢我们这边会有一张图片，我们把图片转换成这样的一个数字，那一张图片的话放到咱们的计算机当中。

它实际上就是一个0~25之间的，这样的一些啊，数字的组成的这样的一个张亮对吧，OK那我们可以把咱们这些值啊，首先呢作为一个这样的一个归一化的一个处理，很简单啊，就把每一个值的除以255就OK了。

然后呢我们把我们每个这样的一个输入值啊，给到我们这样的一个神经网络，神经网络，那这个神经网络网络呢你可以去设置多层，也可以设置为一层，你也可以用刚才说的卷积神经网络也好，或者其他神经网络都是OK的好。

那这里啊，假设我们中间已经经过了一系列的一，些神经网络，最后呢我们这边又经过了这样的一层，普通的一个神经网络，最后我们又加上了这样的一个激活函数，激活函数，那这里呢我们采用的是一个叫做SIGMOID。

激活函数，那这个激活函数它有什么作用呢，它是这样子啊，这个激活函数它是这个样子的，我们简单画一下，简单画一下，嗯这是咱们的一个0。50点，他大概是这个样子啊，大概是这个样子，也就是说如果你的这个值啊。

它是就是我当我们把这个值啊，输入给咱们的这个激活函数的时候，它可以输出一个0_{1之间的一个值啊，这个最大值是一最大值，最小值的话就是咱们的一个零，它可以输出一个0}1之间的一个值。

那通常啊假设我们要去判断这张图片，它是不是猫，那我们就可以把我们神经网络的输出结果，给到这样的一个SIGMOID激活函数，那这个激活函数如果它的一个输出值大于零，那这个输出值啊它大于零给到我们奇偶函数。

它就会输出一个大于0。5的一个值对吧，那大于0。5我们就认为它属于猫，如果呢他这个神经网络，它的一个输出值差小于零小于零的，那给到我们的激活函数，它输出的值就是一个小于0。5的。

这个时候我们就认为它不是猫，那在我们这个场景当中啊，假设我们最终的结果是0。75，0。75哦，0。730。73的话，它是大于0。5的对吧，所以最终呢我们就认为这张图片，它实际上就是一只猫。

我们就以这样的一个模式，来得到我们的一个输出值好吧，输出值好，我们再简单总那个总结一下啊，输入一张图片给到我们的神经网络，把神经网络的一个输出值给到我们的SIGMOID，激活函数。

激活函数根据它的一个输出值是否大于0。5，来决定它是否是猫，如果大于0。5，我们认为它是毛，如果小于0。5，我们就认为它不是毛好，这就是一个很简单的一个所谓的一个二分类啊，二分类判断一张图片是不是毛好。

这个时候可能会有同学说，那假设我现在不是想去做二分类，我并不是说我要去判断这张图片是不是猫，而是我想知道这张图片它是什么动物，假设啊，假设呢我们这边嗯我们有这样几个类别啊，可能有啊，有狗有猫。

还有咱们的这个长颈鹿，OK我想判断一下我当前这张图片，它到底是狗还是猫还是长颈鹿，那怎么办呢，有一种方案啊，就是说我们可以把我们的这个数，这个神经网络啊，我们可以搞三个节点对吧，刚才的这个神经网络呢。

我们这边实际上就一个节点对吧，那实际上呢我们可以搞三个节点啊，三个节点可以看到这里呢，实际上就分别是三个节点啊，那每一个节点的一个值啊，我们都会经过这样的一个SIGMOID。

都会经过这样的一个SIGMOID，那每一个SIGMOID呢，它都会输出一个0~1之间的这样的一个值，对吧好，那我们还是和刚才一样，假设对于第一个类别哎，他这里实际上想知道是否是dog对吧。

OK那如果要输出一个0。1R，它是小于0。5的，那我们就认为它不是狗这个类别，OK这边0。73他输出是大于0。5的，那我们就认为它是猫的这个类比，那如果他是一个啊，他最后这个是0。04，它是小于0。

5的，那我们就认为它不是这样的一个长颈鹿，那我们最终的结论就是A他是毛，他是毛，那这样的一个方法啊，这样的一个输出的一个方法，还有一个优势啊，还有一个优势，假设你的这张图片里面既有猫又有狗对吧。

那这个时候你去进行输出的时候，你就会发现诶，可能这里它输出的是一个0。6对吧，它是大于0。5的，那这个时候啊，你就会有这张这张图片的一个输出值啊，实际上就也包含dog对吧。

那这就是一种多分类的一种方法啊，多分类的方法，并且它还支持咱们所谓的一个多标签，也就是说我这张图片不单可以进行多分类，还可以得到多个这样的一个输出的一个标签值，好吧，好啊。

刚才咱们这里只给了一个节点对吧，那如果我们想让我们的模型的这个，收敛能力更强一些啊，我们就可以去加一些所谓的hidden layer啊，hidden layer在我们的这个节点之前呢。

我们再去加一些其他的一些层对吧，可以加一个中间层啊，中间层，那这个中间层呢我们就可以继续啊，也是给他一些所谓的一些激活函数好吧，比如你可以在这一层啊，给他加上一个啊。

ten h9函数或者revue的这样的一些九函数，当然这里用SIGMOID啊也是可以的，也是可以的好吧，好那如果我们这个hidden layer，如果我们这个黑灯layer啊，很大，它可能等于很多层啊。

很多层可能十层20层都是OK的啊，那当我们这个层数比较深的时候呢，我们又称我们的神经网络为深度神经网络，也就是咱们所谓的深度学习，好吧，这就是我们的深度学习，深度学习，深度神经网络，好那我们继续往下啊。

继续往下，这是咱们刚才看到的啊，整个这样的一个流程，咱们的一个猫对吧，给到了咱们这个单层的神经网络，然后经过了我们的SIGMOID，最终做了这样的一个二分类，二分类好，那这个是我们的第一步啊。

也就是拿到我们的一个输出结果对吧，拿到我们的输出结果，那接下来我们要考虑什么，刚才说的我们要去计算我们的这个loss对吧，我们的这个输出结果，我们希望它和我们的真实的目标，是越接近越好啊，越接近越好。

OK接下来的话我们就来考虑一下这个loss function，loss function啊，我们考虑一个问题啊，考虑一个问题，对于我们这里的这个嗯这个猫的这个小例子啊，我们实际上是什么，是一个二分类。

二分类好，那我们就以二分类来举例啊，我们以二分类来举例，假设啊啊假设我们现在有这样的一个，我们要求解这样的一个概率值啊，就PY等于1given x好，那假如这个值呢我们用啊y hat来表示。

也就是说什么意思呢，就是说我给我这张图片，X表示我们的图片，我给我这张图片，那它是猫的一个概率，我们用y hat来表示好，对于它不是猫的一个概率，也就是PY等于零，Given x。

那这种时候是不是就是咱们的一减掉Y对吧，这就是我们是猫的概率和不是猫的一个概率，OK那这个东西啊，实际上我们可以把它做一个这样的一个合并啊，简单做这样的一个合并，合并完之后呢。

它实际上就是啊YH的Y次方，再乘以咱们的一减y hat的一键Y次方，那为什么是这样的一个公式呢，我们可以这么看啊，我们把这个公式给带进去看一下，假设我们Y等于一，Y等于一的话，我们看一下啊，啊Y等于一。

Y等于一，那后面这一项实际上就是一减y hat的零次方，那就是一对吧，那我们最终的结果就是y hat，那如果Y等于零，Y等于零，Y等于零的话，那前面这一项就是一对吧。

那我们最终的结果就是一个啊一减掉y hat，那这边是零的话，那1-0的话就是一对吧，那这个东西和这个东西，是不是就是咱们的前面的这个结果对吧，所以呢我们是可以把我们的这样的一个结果啊。

用这样的就把这两个式子啊，用这样的一个式子来表示，那通常啊这个式子呢，实际上就是我们需要去求解的一个目标，那么这个式子呢也称为这个所谓的一个，极大自然估计啊，极大自然估计。

那通常我们会对这个式子啊去做一些处理，就取一个log，取个log，取log，它有什么优势呢，它可以让我们的这个乘法变成这样的一个，加法的一个形式，那最终的话这里实际上就变成了一个Y乘以log。

咱们的y hat，加上咱们的一减Y乘以咱们的这个log，一减YX对吧，这就是咱们的一个啊自然函数啊，自然函数，那我们的目的是什么呢，我们肯定是希望我们的这个指它越大越好对吧，我们肯定是我们先看这一类啊。

我们先看这里，我们肯定是希望对于这样的一个概率值，它越大越好嘛对吧，当我Y输入X的时候，Y等于一的这个值，我希望它越大越好，那X输入XY等于零的时候，这个概率值越大越好对吧，那所以啊。

我们的目标就是让这个东西它越大越好，越大越好，我们要让它大啊，居然让它大，但是我们这里需要考虑一点啊，我们需要考虑一点，如果我们要让它越大越好的话，实际上他是没有上限的对吧，他是没有上限的。

那我们这反过来考虑这个问题，如果我们把它让它变得越越小呢，我们是不是就可以让它，尽可能的把这个值给减小到接近零，那如果它接近于零的，我们就认为它是好的，所以啊我们就把我们的这个自然函数啊。

进行了进一步的一个处理，也就是最终就得到了我们的这个loss function，那我们这个loss function呢，我们的YY就等于，在前面加上了这样的一个负号，在前面加上这样一个负号。

用Y乘以log y hat，这里的话也是继续加上我们的一减Y乘以，他们的log1减y at，那这个就是我们最终的一个loss function，因为我们在前面加了一个负号。

所以呢我们最终就变成了要让他越小越好，越小越好越小，这个过程实际上就是要让它接近于零，接近于零好吧，接近一零好，那这是我们这个啊，单条数据的情况我们考虑一下啊，那通常我们在训练的过程当中。

我们肯定不可能就输入一条数据对吧，我们肯定是要输入很多条这样的一个数据对吧，所以呢我们可以再把这里啊再展开一下啊，所以我们最终啊最终的这个loss function，实际上就等于咱们的一个负的。

M分之1formation，从I到M，咱们里面呢就是每一条这样的一个每一条站的，一个每一条站的一个值啊，一条一条的，这里的话是咱们的IOK啊，再加上咱们的一键YI和乘以咱们的log理解y hi。

这个啊就是咱们最终的这里漏了，最终的一个loss function，Loss function，这里这个M呢，表示就是我们的一个数据的一个量啊，数据量，假设你这里有100条数据，那你应该考虑的是。

把100条数据的这个loss function都要算出来对吧，loss function的指定要给算出来，但是我们肯定不能求和吗，你肯定得去平均，因为求和的话。

你100条的这个loss肯定是没有1000条的，loss多的，我们应该保证这个loss是在，同一个这样的一个级别的对吧，所以呢，我们通常要是要取一个这样的一个均值均值。

这就是我们求解我们的这个loss的一个过程，好吧，二分类求解loss的一个过程啊，求解loss的一个过程，好那讲完了咱们这个lost的求解之后呢，我们再来考虑一个问题啊。

那接下来我们该怎么去更新我们的这个参数呢，嗯我们有哪些参数呢，啊我们再考虑一下啊，对于我们这里这个Y啊，哎对于我们这里这个y hat，我们这里先用好，我们就用啊，我用y head表示吧。

就我我就用Y表示，我就用Y表示，那我们这个Y，它实际上就等于咱们的一个SIGMOID，也是咱们的期望函数对吧，然后里面就是咱们的这个权重，和我们的输入的这个特征，加上我们的一个偏移下好。

这是我们的一个Y那对于我们的这个激活函数，激活函数啊，它实际上等于是11加上一的负Z次方啊，不Z次方，好各位，这是我们的这个前向传播的一个过程啊，那我们刚才也得到了我们这样的一个啊。

loss function对吧，Loss function，Ok，那梯度下降他是在做什么呢，它实际上是这样子啊，假设我们现在的这个loss function，它是这个样子的，假设他是这个样子的。

那我们是不是希望让我们的这个loss，尽可能小对吧，尽可能小，那肯定希望诶我这个loss如果能到这个位置，那对于我们来说，就等于是拿到了一个非常好的这样的一个loss，吧对吧。

那这个时候的loss对应的这个权重啊，也就是W就是我们想要的这样的一个W，但是这样的一个值，我们或者说这样的一个loss怎么整，怎样才能得到呢，这就是需要涉及到我们的这样的一个，梯度下降法，梯度下降法。

也就是说在每一次去更新的一个过程中，我们首先会计算得到这样的一个loss，这样的一个值对吧，那有了这样的一个，loss这样一个值之后呢，我们呢就可以去根据我们的这个loss啊。

去求解我们对应的权重的一个梯度，也就是说我们要去求解，我们的这个W的一个梯度，W的梯度，那这个梯度实际上就等于对我们的这个啊loss，去进行求导就OK了对吧，进行对loss进行求导好。

那求出来我们的这个梯度之后，那梯度是什么呢，举个例子啊，假设我们要求的是这个点的一个梯度，它实际上表示的就是它距离，就是他的这个点的这样的一个切线对吧，他的这样的一个切线，那这个切线的一个位置是距离啊。

咱们最优点它下降过程最快的一个方向，所以呢它实际上就是指引了，或者说告诉了我们的这个啊权重啊，你接下来应该往哪个方向走对吧，接下来往哪个方向走，那好你OK那接下来我告诉你要往这个方向走。

那关键啊你要走多少，这个时候我们就需要引入另外一个概念，叫做学习率啊，学习力，那通常啊我们更新我们每一个权重的时候啊，W实际上是等于W乘以这样的一个啊，贝塔再乘以咱们的这个W的一个权重，这是减号减号啊。

这里这个贝塔表示就是咱们的这个learning rate，学习率，learning rate学习力，这个学习力就决定了你要走多少步，就如果你这个学习力设计的比较大对吧，那他就可能往下面走很大一步。

那如果你这个学习力设计的比较小，他可能就只会走一小步，走一小步啊，这个有什么区别呢，我们这边再画一个图啊，再画一个图，如果你的学习力特别大，他可能最后变成什么情况呢，他可能就变成这样的情况。

这样的情况他是这样子走的，那如果你的学习率比较小呢，他可能就是每次就只走一小步啊，每次就只走一小步，学习力比较大的话，其实啊它不容易收敛到一个嗯比较合适的，或者说loss是比较小的一个点的一个情况。

他可能收敛的没有，咱们这个学习力比较小的时候效果那么好，但是学习越大的话，能让我们收敛的速度变快啊，能让我们收敛的速度变快好，那这整个过程呢就是咱们的这个梯度下降法，梯度下降法好。

我们再把整个流程梳理一遍啊，我们再把整个流程梳理一遍，首先呢第一步我们是有咱们这样的一个输入值，对吧，有这样的一个输入值，然后给到我们的模型model，model啊，给到我们的模型之后呢。

我们拿到我们这样的一个输出值out，也就是咱们，这样的一个结结果输入值给到我们的模型，达到我们的输出值好，有了我们的输出值之后呢，第二步我们就可以根据我们真实的label吧，真实的label。

真实的label，还有我们的这个输出值啊，还有我们的输出值，我这里用来表示这两个值，我们就可以去计算我们的loss，就算我们的loss好，有了loss之后呢，我们可以采用我们的这个梯度下降法。

梯度下降法来得到我们的这样的一个梯度啊，来得到我们的一个梯度来进行我们的反向传播，反向传播，那反向传播的过程中呢，也就是咱们的这个执行梯度下降法的，这个过程啊，那最终呢我们就会去更新我们的这个参数啊。

更新我们的参数，那参数更新好了呢，我们要继续这个循环，继续这个循环又继续走到第一步，好把X给到我们的模型，再得到输出值，好在有了输出值之后呢，再把我们的预测值和我们的标签去计算loss。

而再继续进行BP又更新我们的这样的一个权重，那这个过程呢实际上就是一个持续循环的一个，递归的这样的一个过程对吧，直到啊直到我们认为这个W已经收敛的不错了，或者说这个loss我们认为它已经足够小了。

那我们就认为整个过去训练的过程啊，我们就结束了好吧，这就是我们整个咱们的这个神经网络啊，神经网络在进行训练过程的一个流程，一个流程，好那说完了神经网络这一块呢，那咱们接下来的话。

就来进入我们的这个第二部分啊，我们要进入我们的这个第二部分，接下来我们来看一下我们的这个循环神经网络，循环神经网络啊，我们再看循环神经网络呢，之前呢，我们先来看一下，左边这个普通的一个神经网络啊。

左边这个呢是一个非常普通的一个神经网络啊，那我们先看一下啊，对于H来说，对于中间这个H啊，它实际上等于的是咱们的这个U，我先写个奇函数吧，我们用西格玛表示奇函数，然后U乘以X加上B对吧。

这是我们的一个XH的这样的一个值，那我们这里还有个输出值好，那这个输出值呢实际上也是咱们的cm好，V乘以H加上咱们的B对吧，好，这是我们的这样的一个普通的一个神经网络啊，那循环神经网络是什么呢。

循环神经网络啊，实际上就是在中间这里就加上了这样的一个环，加上了这样的一个环，可以看到啊，他这里额外多了一条路线，这里有这样的一个W的权重，那有了这个W的权重之后呢，我们再来看一下这个H。

那这个H实际上除了咱们的这个U和X对吧，实际上还要再加上一下对吧，还要再加上一下，那这一项呢，哎这也是这一项是什么东西呢对吧，他好像还要和咱们这个W进行相乘对吧，然后和W进行相乘。

然后再最后再加上我们的偏移下，我们才能得到我们的H，OK那接下来我们就来看一下，这里到底应该输入的是什么，是什么，好我们来看一下我们呢在这里啊，把这个环给展开给展开，展开之后呢。

我们实际上会得到这样的一个图啊，OK接下来呢我们就要引入一个概念啊，一个概念叫做时间点，时间点我们用T来表示啊，用T来表示好，我们先看这里啊，这里是XTXT的意思，就是说在T时刻我输入的是XT。

那我上一个时时刻点我输入的是XT减一对吧，那下一个时刻点的话，我输入的就是XT加一，OK那对于我这里这个HT来说，它实际上就包含两个部分嘛，好我们在这里看一下啊，那这里这个HT。

它实际上就是咱们的这个U乘以XT，再加上咱们的这边过来的一个值对吧，这边过来的这边过来的值是什么，是HT减一乘以咱们的W，然后再加上我们的激活函数，还有我们的建议下，就得到了我们HT的一个结果。

好那这个HT减一又是怎么得到的呢，那这里这个HT减一啊，实际上就等于U乘以XT减一，加上HT减二乘以W，加上B加上B也就是说这里这个HT减一啊，它实际上是根据是这个时刻的输入值。

还有上一个时刻的HT减二乘以W来得到的，来得到的，所以啊咱们这里的关键就在于这里的这个HT，和咱们的这个W，那大家可以发现一个问题啊，咱们这里所有的这个W啊，还有咱们这些UV它其实权重都是共享的啊。

可以发现它其实都是同一个值对吧，它是同一个值，那这些权重啊它是共享的好吧，这些权重是共享的，它唯一的不同点就在于它输入不同，它输入不同，那为什么说RN适合用在文本当中呢，大家考虑一下我们的文本对吧。

实际上它也是带有这个所谓的一个顺序属性的，或者说时间属性的，它是从左往右进行这样的一个输入的对吧，比如我爱自然语言处理，那他就是按顺序进行这样的一个输入的对吧，按顺序进行这样的一个输入的。

所以啊我们通常也会使用这个RN来处理文本，就是因为它自带的这个所谓的一个顺序的，一个属性或者说位置的一个属性，也就是说它自带了给所谓的一个position，Position。

position的这样的一个属性啊，好那这个时候可能又有同学会问了，那既然如此，我一开始这个HT减一怎么办呢，是这样子啊，其实一开始啊，一开始的时候咱们这个HT减一呢。

你可以是随机给这样的一个值就OK了，好吧，随机给这样的一个值，好这就是我们的这个最基础的一个RN好吧，最基础的一个RN，但是呢其实大家也可以发现啊，现在RN其实用的并不多，更多的还是这个咱们的这个呃。

嗯RSTM这一块啊啊我们先看这里吧，我们先看这里好，我们先看这里，那这里的话给大家介绍了这个RNRN的话，它其实会有很多种不同的输入和输出啊，我们先一个一个来看，那假设我们只有一个输入，一个输出对吧。

那这种情况，实际上就是我们普通的一个神经网络啊，它就是一个普通的神经网络，普通的一个神经网络好，那假如我们这个RN它有一个输入，以多个输出呢，我们一个输入多个输出，那这种情况实际上是什么。

你可以简单的理解啊，他就类似于在做一些所谓的一个，续写的一个处理啊，就说诶我输入了某个这样的一个啊标题对吧，你去帮我把后文给续写出来，续写啊去写，让我们再来看一下这个many to one。

比如说我输入多个值，但是我只输出一个值，这种情况呢就是最典型的，就是咱们的一个文本分类对吧，我把我整段文本输入进去，你最终帮我输出这个文本，到底属于什么样的一个类别啊，文本分类好，我们再来看一下这个啊。

Many to many，那这种情况呢它其实是有一个错位的啊，它会有一个错位的，那这种情况大家可以看成A，类似于他做一些机器翻译，或者说文本摘要，文本摘要就是说我这边输入的是一个中文对吧。

Chinese，这边输出的这样的一个ENGLISH，翻译，那最终呢最后呢我们再来看一下这个啊，Many to many，这个many to many，和这边这个唯一的区别就在于。

它这个位置是一一对应的对吧，这边的话位置它是错开的，那这种一一对应的话，其实应用场景也很多啊，就是咱们的N1啊实体识别啊，实体识别或者说词性标注，甚至说分词对吧。

这都是一个many to many的一个结构啊，好这就是我们R经常遇到的一些不同的这种啊，输入输出的一些格式啊，大家其实也可以发现啊，这个RN他可以做的这样的一些，基于文本的任务很多对吧。

很多啊很多不同的一个输入输出的话，他做的这样的一个任务，他也是不一样的啊，不一样的，OK那接下来我们再来看一个概念啊，就大家其实也可以发现啊，我们其实RN用的并不多，用的多的其实还是RN的一些变体。

就像LSTM啊，或者说gr u啊这样的一些模型对吧，这些模型我们用的会更多一些，那为什么呢，就是因为RN它有一个非常大的一个缺点，就是它非常容易出现这个，所谓的一个梯度消失啊。

容易出现这个所谓的一个梯度消失，为什么会容易出现一个梯度消失呢，我们这边给大家详细解释一下啊，详细解释一下，当然啊这里这个问题啊，其实也是面试当中会经常问到的一个点啊，所以大家这里要注意听，好吧好。

那假设我们现在有三个是时间点啊，第一个时间点，第二个时间点，第三个时间点，那第一个时间点呢我们输入的是这个X1，第二个时间点输入的是X2，第三个时间点我们说的是X3好，那这边呢会有输入一个H0啊。

这边是咱们的一个W，那这里呢我们就可以得到我们的H1对吧，然后进行一个输出，输出的话，我们这里用用O1表示好，这是咱们的O1K啊，对于第二个节点，我们可以等拿到hr，然后输出结果的话就是我们的OR。

最后的话是我们的这个拿到我们的H3好，这边的话这个节点输出的是我们的O3O3嗯，我们中间的权重呢我们用W表示啊，然后下面这一层呢我们用的权重，我们用U来表示上面这层权重，我们用V来表示啊。

这里大家我再重复说一遍啊，咱们这里这个UV还有W他对于每一个时刻点，他的这个权重啊，它是共享的好吧，权重是共享的，权重是共享的好，那接下来呢我们先去看一下啊，它的一个啊求解loss的一个过程。

它是什么样子的，也就是所谓的这个前向传播的一个过程，它是什么样子的，好我们先看我们一步一步来啊，我们先看这里这个H1，那这里这个H1，实际上就等于咱们的这个激活函数对吧，还是用西格玛来表示啊。

然后X1乘以我们的U加上我们的H0，乘以咱们的一个W，然后还有咱们这样的一个偏移向偏移项，我这里就不写了啊，我们就先简化一下，我们就不写了啊，这是我们的H1的一个值，然后我们再看一下O1。

那我们的OE的值是不是也是这样的一个，奇偶函数对吧，然后H1乘以咱们的一个V，这是我们的H1和O1，我们再来看一下我们的H2，H2的话，实际上也是咱们的一个激活函数，X2U加上H1，然后W对吧。

那对应的我们的O2就等于西格玛H2乘以，我们的V也是我们的H3，H3还是一样啊，西格玛X3U加上hr w，然后这里是我们的O3对吧，O3O3的话，西格玛H3乘以为二，这是我们的一个前向传播的一个值啊。

前向传播的一个值，OK那最终的话啊，假设我们这里是一个假设，我们是一个many to many的一个过程，好吧，嗯many to many的过程，那对于也就是说假设我们现在在最后一个吧。

我们以N2举例子好吧，我们以N2举例子，那与N12举例子的话，那这里我们实际上可以得到A1，这样的一个loss，这里也可以得到第二个glass，这里可以得到第三个loss对吧，第三个loss。

那我们最终的这个loss呢实际上就是，啊咱们的这个13扫描I从1_{3对吧，I从1}3，然后LI好，这就是我们最终的一个lost的一个值啊，最终的一个lost的一个值，OK那有了我们的loss之后呢。

我们下一步是要去计算我们的这个梯度对吧，我们要去计算我们的梯度好，我们来看一下我们梯度啊，我们嗯我们取这个L3啊，我们来算L3的一个这个loss，它对应的咱们这个U和V的这样的一个梯度啊。

这样的一个梯度为什么要取L3，不取L1和L2呢，大家看完就知道了，好不好，我们fl3，我们对咱们的这个我们先对V求导啊，我们先对V求导，也是对这个对V求导，那对V求导呢。

首先第一步是不是要先对我们的O3求导，对YO3FO3求导，然后呢，我们的FO3再对我们的这个反V进行求导，这样的话我们就可以拿到这里，这个V这里是U好，这里的都标一下，这里是V这里是U好WW好。

这样的话我们就可以拿到我们这里，这个V的这样的一个梯度对吧，就是L3对应的这个V它的一个梯度啊，它的一个梯度，OK这里很简单啊，这里很简单，就是一个非常简单的一个链式求导的一个过程，非常简单好。

那V求导简单，但是对于U求导来说，它就有点麻烦了，为什么这么说呢，我们来看一下啊，我们FL3对于five这个FU求导，它实际上首先是fl3对于FO3求的对吧，嗯然后呢再加上我们的YO3。

对我们的FH3进行求导对吧，那这里求解完之后呢，我们还得这个FH3，对我们的five这个法U进行求导对吧，法U进行求导好，这样的话我们就把U的导数给求出来了，但实际上我们并没有求解啊，为什么呢。

我们换个颜色啊，我们这里求出来的导数，只是这一条路径上的对吧，只是这一条路径上的，但实际上啊我们这边还有一些U啊，我们这里也还有U对吧，这些U对我们最终的这个L3的一个结果，都有一定的影响。

所以我们的我们在求解U的梯度的时候，还得去考虑这些路径上的一些优，但是有同学就会说，哎，那为什么我这里这个V就只求解这一个地方的，因为这些地方的V，他只对这里的L1和L2造成影响。

他并没有对这里的A23造成影响，所以我们求V的梯度的时候，只需要求解这个V的梯度就OK了，好吧，所以啊当我们求U的梯度的时候呢，我们现在这里啊只是第一个U的一个梯度。

我们还得去求第二个时刻和第一个时刻对应的，这个U的梯度好，那我们就继续加嘛，OK前面的话就还是fl3，five o3还是一样啊，前面是一样的，这里是FO3five h3好，到这里就会有点不一样了。

那接下来的话我们实际上是要走，这边就要往回走一步了对吧，往回走的话，那就是FH3对FH2进行求导，那到这里才是FH2对FU最近求导对吧好，这是第二个时刻的U的梯度，接下来我们看第一个时刻啊。

第一个时刻其实也是一样啊，fl3FO3乘以FO3，FH三YH3YHR，最后这也是FHI对FH1进行求导，然后FH1再对我们的法U来进行求导啊，进行求导，那这到这里呢。

我们整个求导的一个过程啊才结束了结束了，所以说啊对于咱们的这个过程，他其实还是挺复杂的，挺麻烦的对吧好，那接下来我们把他的一些这一块啊，我们可以看一下，就这一块啊。

这里它实际上会有一些这样的一个重复项对吧，这一项它是一个重复的，这一项他也是这样的一个重复项，那这两项呢取决于什么，取决于你的序列的一个长度对吧，假设你的序列长度越长，那你在求解这个U的梯度的时候。

你中间的这一项它就越长对吧，那这里我们可以解呢做一个合并啊，合并合并完之后呢，最终咱们的这个fl t对FU进行求导之后，它的一个梯度实际上就是fl t除以FUT，再乘以我们的FUT除以咱们的发。

这个周末八小时做三哎，等一下啊，这里写错了啊，这里不是U这里是啊，我们的O啊，这是我们的OOT这是O写错了，反OT在对我们的这个啊HT进行求导是吧，HT求导进行求导啊，这是我们前面这一项嘛。

这是我们的前面这一项对吧，那关键是中间这一项，那中间这一项我们实际上啊就可以去对他这个，求机啊，那这里的话我们用下面要用J来表示啊啊，我们从追到T那里面呢，实际上就是咱们的这个FHJ。

在对我们的FH这1-1，进行这样的一个求导对吧，这个呢就是我们中间这一块啊，中间这一块，但是啊这里大家需要考虑一下，我们这里实际上是什么，是有三个部分，是有三个部分对吧，我们这里是有三个部分的。

那三个部分的话，那我们，前面这里前面这一块我们是可以提取出来的嘛，对吧，前面这一块我们可以提取出来放到前面吧，所以呢后面这一块啊，我们实际上还有一个相加的一个过程对吧。

所以我们这里还有一个相加的一个过程，所以这里啊我们还有这样的一个扫描，这里还有个扫描，然后我们这里用用K来表示K，从一到咱们的一个T，那这里这个J呢实际上是从咱们的K加一开始，K加一开始。

那这一项呢就是咱们对应的，咱们蓝色框里的这一项对吧，然后最后是咱们的这个啊，最后这一项啊，最后这一项，那最后这一项呢，实际上就是咱们的这个FHK，在对咱们的FU进行求导就OK了啊，就OK了。

那这个过程就是我们最终的一个这个诶，这里写错了啊，这里是怎么回事啊，这个地方写错了，这个地方就是FU对吧，我在我这写的啥，L对U求导，T对OO对HT好，这就是我们最终的一个梯度啊。

这是我们最终的一个梯度，OK那看到这里之后呢，我们来考虑一下，那为什么说RN容易出现梯度消失呢，我们看一下这里我们看一下这一块，这一块是HJHJHJ减一求导，也就是说他是在对这个链路上进行一个求导。

那这个链路他做了一个什么事情呢，它其实就是一个激活函数对吧，是这样的一个西格玛，我们可以看到啊，他这里会有这样的一个西格玛，那在我们的R或者说在我们RN当中啊，我们通常使用的一个奇偶函数。

要么是这个SIGMOID，要么是这个T，那这两个激活函数它有它有什么样的一个问题，我们可以再简单回顾一下那个SIGMOID激活函数，它是什么样子，他是大概这个样子的对吧，大概是这个样子的诶。

画的不太好啊，这是0。5这个奇偶函数，大家可以看一下啊，他的这个梯度啊，它是很容易就说他这个梯度，它很容易出现一个比较小的这样一个值对吧，他这个梯度也是一个0~1之间的，这样的一个值，他梯度很小。

几率很小，好OK那假设我现在这个梯度，我现在这个梯度假设啊，求解出来它是0。10。1，那我们再假设我们这这个这里这个T，也就是说这是个T啊，假设T等于50，T等于50的意思。

就是说我这个序列长度是50对吧，那我们这里这里就我们这里啊，这一块求解出来的梯度就是0。1的50次方，50次方这个东西是不是就趋近于零，对吧，那你的梯度就会变得很小，你梯度变得很小，会出现什么问题呢。

T6变得很小，你咱们刚刚这里说的对吧，你每一次这个值都特别小特别小，特别现在已经接近于零了对吧，那就等于你这个W就很难去更新，你每次虽然就算你更新100次，1000次，但是你每一次的值基本上都是零。

就等于你这个W没有怎么更新，所以你模型就会很难收敛啊，你的模型就会很难收敛好吧，这就是RN当中的一个所谓的一个，梯度消失的一个问题啊，RN当中的梯度消失的一个问题，那怎么解决这个问题呢。

或者说怎么有没有什么办法能缓解这个问题呢，这就是我们接下来要给大家讲的这个LIST，MASTMAISTM呢，又被称为这个所谓的长短期记忆网络，它能有效的去学习一些长期依赖的关系啊。

也能有效的去啊缓解T6小时的问题，这里不能说解决啊，这里我改一下，这里应该说缓解缓解梯度消失的问题，好，那接下来我们就给大家介绍一下，这个LSTM啊，给大家介绍一下LISTM。

啊第一个图呢是咱们的这个RRN，下面这个是我们的LISTM可以看到啊，RN的结构还是非常简单的，但是对于LSTM来说，里面其实有很多这样的一些计划函数对吧，这里有SIGMOID，有ten h。

这里这个西格玛表示就是这样的一个西格玛啊，西格玛啊，这里我也简单说一下，有同学会说这个ten，这个激活函数是什么东西啊，我这里也简单画个图啊，咱们SIGMOID它是就咱们SIGMOID是啊。

在这个都是大于零的一个这样的一个值对吧，但是呢它其实是关于原点对称的啊，它是这样子的，它是这样子的，它是它是经过原点的啊，画的不太好，它是经过原点的，那SIGMOID的话。

它是全都是这样的一个大于零的值啊，好那接下来的话我们就把这个LSTM啊，展开详细看一下啊，我们展开详细看一下，首先呢LSTM这个模型啊，它额外添加了一个叫做细胞状态的一个东西，它是用C来表示啊。

在我们的RN当中，我们只有一个H对吧，用H那我们通常称这个H叫做hidden state，隐藏状态，隐藏状态，那在我们的这个ISTM当中多加了一个cl state，细胞状态啊。

细胞状态我们这里用C来表示，他其实hidden state也有对吧，在下面这里啊，在下面这里，那这里这个cal state呢，就是这个图当中的上面这一条线，上面的向右的表示的就是sales state。

它传递的一个过程，那这个sales state什么东西呢，我们详细来看一下啊，详细来看一下好，我们先在先看这个sales state之前呢，我们先来了解几个概念啊。

几个概念叫做门LSTM一个比较关键的东西，就是它有一个所谓的一个门的一个机制啊，门的一个机制，这个机制是什么意思呢，我们来看一下啊，就是说LSTM啊，它能决定我当前哪些值需要保留，哪些值不需要保留。

我们可以先看一下下面这里这个例子啊，我们可以先看一个例子，就是说假如我现在有句话叫做他今天有事，所以我当处理到我这个字的时候，我们实际上希望看到的是说，我们这个模型能把我之前的这个主语。

它就是遗忘了就不要了对吧，遗忘了不要了，要保留我对吧对吧，这个时候我们应该更加关注的是我，而不是他那1万门，也是我们LISTM当中的第一步啊，也就是这一块它的作用就是把它这个字给忘了，他是怎么忘了呢。

我们看一下啊，首先呢这是我们的上一个时刻的hidden state HT，是我们当前时刻的一个输入值，我们把当前时刻的一个输入值，和我们上一时刻的这个hidden state啊，进行这样的一个拼接。

拼接完之后呢还是一样啊，会有这样的一个权重进行相乘，再加上我们的偏移下，然后经过SIGMOID的层，刚才说了SIGMOID的层，它是输出一个零一之间的一个值对吧，它输出的是一个零一之间的一个值好。

说白了就是说我这里我这里啊，就是输出这样的一个零一之间的这个值，那如果这个值它接近于一，它接近于一，意思就是说我会把之前的内容保存下来，如果接近于零，就等于是把之前的内容完全就给遗弃了。

那如果他是一个0。20。6，意思就是说我之前的只要保保留20%，保留60%，就这样的一个思路，啊这是我们的一个遗忘门，遗忘门，那接下来我们再来看我们的一个输入门，那刚才我们把一部分内容给遗忘了对吧。

但是上文的其他内容，我们还是得留一部分下来嘛对吧，我们要留，把留下来的内容作为我们的一个输入对吧，作为我们的一个输入好，那怎么作为输入呢，其实也很简单啊，还是把刚才的PDD和当前时刻。

我们的这个输入值啊，先作为拼接，然后给到我们对应的一个权重，好这里大家可以发现诶，我好像计算了两个部分，第一个部分和刚才的一样，它也是一个门，因为它是一个SIGMOID，它还是输出一个零一之间的一个值。

那对于第二部分，我们经过的是ten这样的一个激活函数，大家可以理解为，我把输入和上一时刻的hidden sat，去做了一些非线性的变换，然后呢我就得到了，再把这两个部分啊。

会去做一个所谓的一个相乘的一个操作，可以看到这里我做了一个相乘的一个操作，也就是这里啊T乘以CT德尔塔，那这里这个相乘实际上表示的是什么，就是我CT是我当前时刻的一些输入值对吧。

我这里这个IT是这样的一个门，比如说当前这些东西，我哪些东西要保留下来对吧，这就是我们当前要表保留下来的一些值啊，当前保留下来的一些值好，我们再看这一块，这里是FT乘以T减一。

CT减一是上一时刻的cell state，ft t是我们刚才这里说的1万门对吧，1万门，那这里的意思就是说，我要把我之前的这个ct减一保留下来，多少1万掉多少对吧，所以说啊这里我们进行相乘对吧。

就是这一块这里进行相加呢，就等于是把我们上一时刻经过1万门之后的，一个值，和当前时刻，经过了咱们门之后的这样的一个值，进行了一个融合，这样呢，我们就得到了我们当前新的这个时刻的CD，好吧，好再说一遍啊。

这个FT，第一个FT是我们的之前的一个1万门的，一个指，这里这个T减也是我们上一个时刻的cell state相乘，表示的就是说我要把之前的cell state移忘掉多少。

那后面这一块it是我们当前的这个输入的，这个值，我需要保留多少，那CTTT的话，是当前的输入值的一个非线性变化，这两块相乘意思就是说我当前的输入值，我需要输入哪些内容，保留哪些内容。

最后再把这两者进行相加，意思就是说，我要把之前的上一个时刻的剩余的内容，和我当前的输入的内容进行合并在一起，就是这样的一个意思啊，这就是我们的一个输入门，那这样的话我们就可以得到当前时刻的一个。

cell state啊，cs那有了sale state的之后呢，我们还要考虑一下，我们也还有这样的一个当前时刻的HT，我们还没有算嘛对吧，所以接下来我们就来输出门，看一下我们当前时刻的这个HT唉。

怎么进行计算，好我们看一下啊，他的他的这个思路，其实还是延续，咱们刚才这个门的这样的一个想法啊，首先呢还是把我们上一时刻的health hidden state，和当前时刻的输入进行拼接。

进行非线性变换啊，不是非线性变化啊，经过我们那个SIGMOID的，那，这个时候实际上又是一个0_{1之间的一个值，对吧，0}1之间的值好，然后呢我们会把刚才的这里这个值啊。

这个这里我们是已经拿到了这个cell sat对吧，当前时刻的cell sat，我们会把当前时刻的cell state经过这个ten啊，经过ten经过完ta之后呢。

说白了就是把CD做了一个非线性的变换对吧，再和这样的一个门之后的一个结果进行相乘，而作为当前时刻的一个hidden state，作为当前时刻的hidden state。

这里的意思就是说我当前要进行输出了对吧，但是呢我现在有了我们啊上一时刻的这些cl state，然后呢，我是不是应该考虑一下我哪些应该输出对吧，我们这里也可以看一个例子啊，假设啊有这样的一个例子啊。

the cat会说radiate what food，当处理到was的时候，由于前面获取的主语是cat对吧，那我们这里肯定就要用with，那如果我们前面这是cats对吧，如果是cats。

那我们后面这里就应该用were，就是这样的一个意思啊，就这样的一个意思，这就是我们的这个ANSTM的一个输出门啊，输出门，好最后呢我们再来简单看一下，关于为什么LSTM才能解决。

这个所谓的一个梯度消失的一个问题啊，那这里呢是我们的这个啊cal state，它求解这个梯度的过程的时候，它的一个公式啊，它的一个公式，其实大家对比的时候就可以发现啊。

我们这里这个cell state它其实它的一个梯度啊，它是一个相加的形式，它是一个相加的一个形式，那我们这边的这个RN，它是一个纯相乘的一个形式对吧，然后我们再再注意一点啊，他这里啊它有一个FT这一项。

比如说这里这个FT是啥，这个FT表示的是我们这里，这个这里这样的一个值啊，也就是说我们的遗忘门它的一个输出值，那这个值它是个0~1之间的一个值，所以说啊就算你前面这些地方，你都是一些相乘的对吧。

你这些前面那些地方就算成，假设我你这三个部分假设是一个0。0，000001接近于零的一个值，但我最终这个FT它是一个0_{1之间的，一个值，是一个0}1之间的值，它可能是0。1，可能是0。2对吧。

当然他也有可能是0。01也是有可能的，但是啊就是因为这里是一个相加的一项，他就就算你前面这些全都是零，我也能保证你最后这个值，它是一个0~1之间的一个值，但是它不会特别接近一零，就以这样的一个形式啊。

来缓解咱们的一个梯度消失的一个问题，注意这里是缓解啊，这是缓解，假设你最终这里这个FT，你求解出来也是一个0。001的一个值对吧，非常接近于零的值，那其实他也没有办法，完全解决这个梯度消失的问题啊。

所以说咱们说的是缓解，好吧啊，我这里这个标题要改一下，缓解缓解，好这就到这里的话，我们就给大家介绍完了这个LSTM啊，我们就介绍完了LST，那接下来的话我们再来看我们的啊，下一个部分啊。

下一个部分咱们的这个卷积神经网络啊，卷积神经网络，好我们来考虑一下啊，就对于RN站的一个模型来说，除了刚才说的这个所谓的梯度消失的，一个问题啊，它其实还有一个问题啊，就是它时间复杂度。

时间复杂度比较高啊，它的时间复杂度是ON，因为它是一个创新的一个过程对吧，它是一个从左到右，它需要一个节点，一个节点的去进行这样的一个处理，它是一个串行的过程啊，串行的过程你序列长度越长。

它处理的时间点就越多对吧，花费的时间就越多，那对于我们的这个文本分类的一个任务来说啊，我们其实刚才也说过啊，我们在这里的时候，我们通常如果要去做文本分类对吧，把每一个词进行一个输入，X 1x2。

一直到XN进行输入，然后要取的是最后一个时刻的一个这个值，用这个out值来进行我们的文本分类，所以说啊他很耗时，那既然如此，我们是有没有可能采用一些并行模型的，一些思路，例如像咱们的一个CN模型对吧。

它其实就是一个并行的思想，咱们的我们来看一下啊，如何使用我们的卷积神经网络，来加速一下我们这个RN的一些缺点，大家可能都会觉得，这个卷积可能更适合去处理图像对吧，但实际上在文本当中它处理的也非常的多啊。

非常的多好，那我们来看一下，如果我们使用这个卷积神经网络，是怎么去处理文本的好，那我们这里假设有一句话，叫做他毕业于上海交通大学这样一句话，那我们分词分完之后呢，它一共有六个词啊，六个词对于on来说。

它实际上每次处理的是一个字对吧，这样哎或者说一个词哎，先输入它，然后输入毕业输入语，再输入上海，ok now啊，那个如果我们使用的是卷积神经网络，卷积神经网络它就有一个优势啊，他可以干什么。

他可以去处理你的这个所谓的，更大力度的这样的一些特征，例如我可以去处理，把这个他毕业于这三个词放在一起，一起去提取特征，毕业于上海三个词放在一起去提取特征，还有最后这样的一个上海交通大学。

我可以把把这三个词放在一起一起来提取特征，但是对于N来说，他就没有办法做到这样的一个情况，那为什么卷积可以做到这个所谓的这种，多词或者短语级别的一个特征的一个提取呢，那接下来我们就来详细给大家介绍一下。

卷积神经网络啊，我们就详细介绍一下，在介绍卷积神经网络之前呢，我们先了解一下什么是卷积，什么是卷积，通常啊我们就称为F乘以G，就是对于F和G的一个卷积，好好像很难理解是吧，很难理解，好不着急。

我们慢慢来看啊，如果我们现在这个是一个连续的啊，如果是一个连续的一个情况，它实际上就是求解积分的一个过程，那如果是一个离散的情况呢，我们就是要去对我们所有的情况啊，去求和求和，但是看完这个公式。

好像还是非常难理解这个卷积到底啥意思对吧，没关系，我们慢慢来，我们可以去看一个例子啊，假设我们令X等于啊，涛比Y等于N卷套，那么X加Y等于N啊，就是下面这条线可以看到啊，我们有这样的一条线，这条线。

那这一条线它实际上就好比什么呢，就好比我们把一条毛巾啊，沿着左下角的这样的一个角，就往右上角去卷，去卷那个卷的过程呢，我们把它称为这样的一个卷积的一个操作啊，这个过程我们把它称之为卷积的一个操作。

我们再看一个离散的一个例子啊，我们看一个离散卷积的一个例子，这个例子看完，大家就能对卷积有一个更直观的理解了，假如我们现在有两个啊，两个桃子啊，这两个桃子呢，我们希望啊扔到的点数加起来是四的一个概念。

就是我们要求解啊，加起来是四的这样的一个概率，那我们用F来表示第一个，用G来表示第二个，那F1呢表示的是投出一的一个概率啊，F2F3的话就以此类推积也是啊，G1的话就是表示我扔出第二个这个投资。

扔出一的这样的一个概率值啊，好那我们就来计算一下啊，计算一下，OK那我们来看一下，如果我们把所有的这个这个这个啊是就相加，它的这个概率，是咱们的这个四的这个投资的这个情况啊，给算一下啊。

首先呢是咱们的第一个骰子，扔到一的一个概率值，要乘以咱们的第二个骰子扔到三的一个概率值，然后再加上我们扔到二的一个概念，分别扔到二的对吧，还有情况呢是我第一个投资扔到三。

第二个投资扔到的是一的一个概率值对吧，我们要进行分别进行相乘再相加，那这个呢实际上就是我们两枚骰子，点数加起来为四的这样的一个概率对吧，好那接下来呢我们把它改变一下啊，改变成我们卷积的定义。

它实际上就是，表示为F4gm再乘以gm，然后前面是一个累加formation，那这个啊实际上就是我们的一个卷积卷积，那再解释一下，说白了他就是先相乘再相加对吧，先相乘再相加，这就是我们的一个卷积卷积。

我们也可以回到我们一开始的这样的一个，离散的一个公式，可以看一下对吧，它实际上就是一个先相乘再相加的一个过程，这就是我们的一个卷积操作啊，卷积操作好，那有了这样的一个卷积计算的，这样的一个概念之后呢。

我们再把这个卷积啊，拿到我们的图像上面来看一下啊，下面呢这里有一张啊，噪点非常严重的一个图片啊，如果我们想去做一个所谓的去噪的一个处理，我们就可以把这个采用一个卷积的一个方式，我们可以把高频信号啊。

以周围的一些数值去做一个平均一下一个处理，怎么做呢，好举个例子啊，假设这是我们的这样的一个图片啊，这是我们的一个图片啊，我们要去平滑这个A1这个点，它周围的这些加速点。

OK那我们就把A11附近的这些像素点啊，全部给取出来，取出来取出来之后呢，我们可以得到这样的一个矩阵F啊，我们的一个矩阵F，接下来我们去定义这样的一个啊卷积核，也就是用积，也就是我们的卷积卷积核啊。

这个卷积核因为我刚才说我们如果去造的话，就是取个均值对吧，那我们就把所有的卷积核的每一个位置，都设置为1/9，然后呢我们再把这个这里这个F啊，和我们的这个G进行相乘再相加，也就是说A00乘以我们的19。

加上A01乘以我们的19，再加上A02乘以我们的19，就对位相乘再相加，最终啊我们对位相乘相加之后呢，我们就可以得到一个所谓的，卷积之后的一个结构啊，卷积之后的一个结果，这就是我们在图像当中去做的。

这个所谓的卷积的一个处理啊，卷积的一个处理，啊这就是我们可以看一下啊，这是我们的一个啊卷积的一个动图，左边呢是我们这样的一张图片啊，中间是我们的一个卷积核，那这个卷积核呢在这里啊。

我们只是对我们图像的这一部分，做了卷积处理对吧，但是你对这一部分做完卷积处理之后，其他地方你其实也需要做卷积处理，这个时候呢你就需要去移动你的卷积核对吧，我们可以看一下啊，我们这个动图是啊。

先向这边先向右移对吧，然后再向下进行移动，你看第一次卷积完了之后向右移一个单位，做一次卷积，再往右移一个单位，再做一次卷积，直到移不动了，我们再往下进行移动，这就是我们完整的一个卷积的一个过程啊。

卷积的一个过程，好那有了卷积这个概念之后呢，我们来看一下卷积神经网络啊，那卷积神经网络，实际上呢就是在寻找最合适的一个卷积核，那刚才我们是要去造对吧，那去噪的卷积核就求均值就OK了，但是我们想一下哈。

如果我们现在是在处理我们的图片，或者说我们在处理我们的文本，我们想去做这个所谓的分类，或者说图片识别对吧，那我们就应该去找到最合适的一个卷积核对吧，那如何去找到最合适的一个卷积核呢。

这个是不是就是我们刚才给大家介绍，神经网络那个部分给大家提到的对吧，先计算我们的loss，要去求解我们的这个季度要进行反向反向传播，更新我们的权重对吧，那在我们这里其实也是一样嘛。

我们的卷积核实际上就是我们的W，我们只需要根据我们的目标得到我们的输出值，要求解我们的loss，再根据loss进行反向传播，就可以更新我们卷积核的一个值对吧，这样的话我们就可以得到我们最合适的卷积和。

啊我们可以看一下这里这个图片啊，啊左边的话是我们的一个输入的图片，右边的话是我们的一个卷积核，右边的是我们得到的一个结果，得到一个结果，然后红色的话啊，我在这里乘以1×0乘以一。

就是我们对应的一个卷积核啊，那右上角这个卷积核和黄色这一块，进行卷积之后得到的结果就是四啊，就是四对位相乘再相加啊，好这就是我们卷积神经网络好吧，卷积神经网络，那接下来呢我们再看一下啊。

如何把这个卷积神经网络，应用到我们的这个文本当中呢，好接下来好，我们这边有这样的一句话啊，这句话我们做了一个分词，1234567好，我们分成了七个词啊，这句话我们分成了七个词，分成了七个字。

那每一个词呢它有对应的这样的一个embedding，就上节课我们去讲那个word vector的时候，给大家讲过吧对吧，就每一个词，我们可以把它转换成这样的一个，embedding的一个形式。

那在这里呢它每一个词的embedding是四维的，四维的，所以说我们的一个输入啊，就是一个7×4的输入，这是7×4的好吧，7×4的，接下来呢，我们就会去定义一个这样所谓的一个卷积核，卷积核。

那这个卷积核它需要有两个维度对吧，第一个维度的话是我们这个序列长度，这个方向的一个维度，第二个维度的话是他的这个embedding，这个维度对吧，这里大家就需要注意一下啊，对于它的第一个维度。

你是可以自定义的，你第一个维度你可以是二，你可以是三，你可以是四，但是对于第二个维度，你必须和文本的embedding这个维度保持一致，也就是说你必须设置为四，为什么呢，假设你的这个维度小于四。

那你这个卷积核它可能是什么样子呢，就变成了这个样子，那你这样的一个卷积核卷积出来，实际上是没有意义的，因为你这个词，你没有把这个词它完整的embedding给加进去，你没有加进去的话。

你这个词的这个语音可能会改变对吧，所以你在做卷积的时候啊，你要把当前这个文本的embedding，全部给包含进去，你才能拿到当前这个文字或者这个词，它完整的一个语义，好吧，这里是关键点啊。

大家必须注意一下，这个维度必须保持统一，第二个维度是多少，取决于你输入的文本的embedding的维度是多少，好吧，好我们再看我们的第一个维度啊，那对于第一个维度来说，就得看你想去取多大力度的一个特征。

就像我们刚才这里给大家举的那个例子，如果你每次想取的是一个字，一个字或者一个词，一个词的特征，那你就设置为一，那对于我们这里，我们这里取的这些是短语，它是三个词对吧，那你就把你的卷积和大小设置为三。

如果你想取两个词，那你就集合大家就设置为啊，所以啊，这就是得到了我们最终的这样的一个卷积核啊，那这个卷积核实际上就是一个3×4的啊，3×4的好，那我们就把这个卷积核在我们的这个文本上啊。

去做卷积的一个处理，最终我们就可以得到这样的一个输出值，这样的一个输出值，第一个输出值的话就是前面三个词，它的一个前面三个词啊，然后这这个值呢就是也是这三个字，这三个字，对于最后这个啊。

就是最后三个词它的一个卷积之后的结果啊，这就是咱们的一个卷积卷积，OK那了解了这个卷积的概念之后呢，我们再来看一个东西啊，对于我们这里来说，我们可以看到啊，我们做了卷积操作之后呢。

我们这个序列长度从七变成了五对吧，但是大家可以考虑一下啊，就有些情况，假设我现在是要做N12，我要做N12，我们的输入和输出必须长度保持一致对吧，那你这里缩短了不行啊，那如何才能保证这个长度不变呢。

我们就可以在头和尾啊去补充一个padding位，就补零，只要补零之后呢，我们这里一开始的这个长度就由七变成了九，但是啊我们经过卷积操作之后呢，它的这个长度就还是七啊，就和我们原来保持一样的保持一样。

为什么它会一样呢，因为我们每次做卷积的时候，就是从这里开始的对吧，我们之前的话是从这里开始的，好这就是我们补padding啊，补padding，那看完补padding之后呢，我们再来看一个概念。

叫做mari channel，处理图像的时候呢，图像它是一个RGB3原色的对吧，所以呢我们通常处理图像的时候，我们会有最少你得准备三个卷积核对吧，分别处理RGBRGRGB的一个通道。

那对于文本来说其实也是一样嘛，你可以多准备几个卷集合，你卷积核准备的越多，你提取的这个特征维度就越多对吧，那这里的话，我们就等于是准备了三个这样的一个群集合啊，三个卷集合。

然后再加上我们的padding，那正常情况来说，我们只能得到一个啊啊77×1的对吧，7×1的这样的一个矩阵，那三个局那个卷积核的话，最终我们就可以得到7×3的这样的一个特征，矩阵三的这样的一个特征好。

这是我们的一个多通道，多通道，好接下来我们再来看一个概念叫做池化操作啊，池化操作，那我们这里多个卷积核，我们呢达到了一个7×3的这样的一个矩阵，但如果我们要最后去做一个二分类对吧。

假设我们要去做文本二分类，你肯定不能给我一个7×3类啊对吧，你肯定得给我一个啊7×1的，或者说7×7的对吧，你不能，总之你不能给我一个多维的呀，我只能给我一个一维的一个向量，我们才能去作为一个分类嘛。

你不能给我这样的一个7×3的对吧，所以呢我们这边就会做一些所谓的池化操作啊，这里呢我们采用的是一个最大石化层，就说我们去吧，当前这个里面啊它最大值给取出来，这一列里面最大值给取出来，这是0。3。

然后这边取出来是1。6，这是1。4，所以最终我们就能得到了一个，一维的这样的一个向量啊，一维的一个向量，这是我们的最大池化层，最大池化层，好那我们接下来看一下啊，这个卷积的这个过程怎么去计算。

我们输入的这个值，经过卷积之后，它输出值的一个维度呢啊我们以图片举例，假设我们输输入的图片大小是W乘以W，我们卷积核的大小是F乘以F，那不长是S不长，什么意思呢，就是说你每次移动多少步。

有的时候呢你可能会移动一步，但是有可能你也会移动两步三步对吧，然后还有一个是padding，Padding，我们用P来表示，OK那假设我们现在不padding啊，如果我们不padding。

那我们的这个输入和输出的一个这个维度，大小呢，这是win的话，是我们的一个输入输入啊，就是输入减掉我们卷积核的大小，再除以我们的S也是咱们的步长加一，就是我们输出解输出的这个啊长度啊。

那如果我们要保持不变的话，那就是我们输入的一个维度，再加上二乘以padding，因为padding你前面要补，后面也要补对吧，所以你要乘以二，然后再减掉我们的这个filter的大小，再除以我们的步长。

再加上一，这是我们的输出的一个维度的大小啊，好到这里的话，我们就给大家把这个卷积神经网络这一块啊，咱们就讲完了，讲完了，今天的话到这里的话，基本上就是要给大家讲的所有的啊，这个理论方面的一个内容啊。

理论方面的内容，那接下来的话，我们就进入到我们的这个实战环节啊，我们给大家介绍了这个卷积网络，又给大家介绍了这个循环神经网络对吧，那我们就来应用一下啊。

应用一下我们进入实战环节啊，实战环节。

啊，接下来我们来看一个基于LST作战的一个，文本分类的这样的一个小例子啊，看个小例子好，我们把字体调大一点，OK啊我们可以看一下啊，我们从train方法开始看吧，好这个try方法当中呢，首先呢。

我们会去进行这样的一个数据的一个加载，我们会去加载一个数据加载数据，然后呢去啊拿我们的模型，我们先看我们的这个加载数据这一块吧，好吧，我们一步一步来好，呃加载数据这边呢我们是从本地这边啊。

加载了一个这样的一个啊，情感分析的一个二分类的一个数据，我们可以简单看一下，蒙牛真果粒美丽有新意，这是个正例啊，还有什么密密麻麻，孩子不喜欢，这是一个复利啊，嗯总之是个二分类啊。

咱们情感分析的二分类一的话是正理，零的话是咱们的一个复利啊，复利好，那我们就来看一下啊，我们看一下这个load date这个方法，先看一下load date这个方法，首先呢我们去把这个文件给读取出来啊。

然后循环每一行，循环读取每一行啊，今天的代码因为比较多，可能我就没有办法全部带着大家写了，好吧，我们就把一些关键代码会给大家详细讲一下啊，好这边循环每一行代码，那每一行代码呢。

我们这里是根据这个tab键进行这样的一个区分，这样的话我们就可以拿到我们的这个标签，还有我们的文本啊，拿到我们的标签，拿到我们的标签，我们的文本好，那有了标签，有了文本之后呢，我们考虑一下啊。

我们上节课给大家讲这个word faction那块的时候，说过啊，我们需要先构建一个词典对吧，我们需要构建一个词典，那构建词典呢怎么构建呢，首先第一步肯定是需要进行分词嘛对吧，那我们就去遍历一下啊。

我们所有的这样的一个文本，然后把便利出来的文本呢，去做这样的一个分词的一个处理啊，分词的一个这样的一个处理啊，我们这里可以看一下啊，这里是好token nice，这个方法我们去看一下啊，可以看到啊。

这个TOISE呢，其实就是调用了一下结巴的这个分词啊，调用了一下结巴分词，结巴就可以进行分词了啊，可以进行分词，好，这边的话，我们就拿到了我们所有的这个分词的，一个结果啊，这里大家需要注意一下。

这个分词的结果是一个list，然后list里面呢又是list内部的这个list，就是一个一个的这样的一个分词好吧，那接下来呢我们去定义这样的一个词典啊，定义一个词典。

这边呢我们就开始对这个分出来的这个词啊，去进行一个便利，然后呢我们去统计一下每一个词，它的一个词频，统计一下每一个词的词频，统计词频好，统计完视频之后呢，我们去根据这个视频去做这样的一个呃。

降序的一个排序啊，因为我们说过啊，我们要把这个视频比较高的排在前面，视频比较低的排在后面啊，排在后面，这样的话我们就排好序了，排排好序之后呢，我们要来定义我们的一个词典。

这个词典当中呢我们需要两个标记位啊，这个也是在我们上一节课给大家讲过的，一个呢是pad标记位，表示的是我们这个五零的对吧，一个是UNK标记为UNK的话，就是啊OV的一些词，我们就用UNK来表示对吧。

好这是我们前两个词啊，那后面的一些词呢，我们就去便利我们的这个排好序的一个，词典当中，排好序的这个词啊，把这些词加到我们的词典当中，这样的话我们就能拿到我们的一个词典，好，我们这里可以给大家看一下。

我们这个词典是什么样子啊，好稍等一下啊，OK我们把这个词典展开看一下啊，它实际上就是这样的一个字典的一个格式对吧，啊，key的话就是我们对应的这个词，value的话就是它的一个下标对吧。

就是它的一个下标，那我们输入一个这样的一个词，就可以拿到它对应的一个下标的一个值啊，这就是我们的一个词典，这是我们的词典好，那有了词典之后呢，那接下来的话我们就要去做什么事情呢。

是不是要把我们的这个训练的一个数据，先转换成我们的一个下标对吧，我们就要便便利我们每一条数据啊，把这个数据转换成一个下标，好，我们就来看一下这个文本转下标，这个函数它是怎么写的啊，首先还是一样。

我们先分词，分完词之后呢，我们去遍历每一个词对吧，然后根据我们的这个词典get的话，就是根据我们的key把value给取出来对吧，如果取不到，那我就取一个一，为什么是一呢，因为我们UNK表示对应的是一。

所以我们这里是一好吧，这样的话我们就把我们的这个下标啊，给取出来了，取出来之后呢，我们要去做一个padding的一个处理对吧，padding的一个处理好，这里我们也看一下这个函数啊，也很简单啊。

这边先去便利我们每一个句子啊，遍历每一个句子，那如果我们这个句子的长度，是小于我们最大长度的，我们这个最大长度出了个十啊，如果我们这个句子的长度小于了最大长度，那我们就需要补零，补零怎么补呢。

那我们就去做慷慨，把我们的X和零进行一个拼接，拼接多少个零呢，拼接的是最大长度，减掉我们当前文本长度的这个长度的零好，这样的话我们就可以把短的补偿对吧，那我们再看一下啊。

如果我们这个长度它是大于这个最大长度的话，那我们就截取对吧，我们就截取，这样的话，我们就做了这样的一个补偿的一个操作啊，这样的话我们所有的文本的长度就能保持一致，接下来呢我们再把我们的这个输入值。

还有我们的标签给到我们这个啊，Tensor data set，这个DATASET是干什么的呢，大家可以把它看成他就是这个所谓的这样的，一个list的一个格式，只是说这个list当中哈。

它包含了我们的训练数据，也包含了我们的label，好吧好，那有了这个data set之后呢，我们接下来呢需要去定义一个data load，这个data loader又是干什么的呢。

因为我们每次在训练的时候啊，我们的这个GPU的一个显存，是有一定大小的限制的对吧，或者说即使你用CPU跑也是一样啊，是有这个大小限制的，那如果你的这个数据量特别大，你有100万的数据量对吧，你没有办法。

一次性把所有的数据都放到你的这个，显存或者内存里，所以呢我们通常都会分批进行跑啊，采用这个besides的形式，就我们每次只计算一部分的这样的一个数据，那我们使用data load。

就可以生成一批一批的这样的一些数据，那每一批的数据它的数量都是固定的，也就是dbh size条数哈，excite条数，当然他有个输出值啊，就是这个data set。

这个data set就是根据我们的腾讯data set来得到的，那我们把这个东西呢，还有我们big size啊，就给到我们的data loader，就能拿到我们的数据的这个data load。

当我们来便利这个dota data load的时候呢，每次就可以取出有一个BH的一个数据啊，那接下来的话我们就把这个data loader，还有我们的这个vocab进行反馈，也就是我们的训练数据。

我们的词典我们就进行返回啊，返回好，我们再回到哎，我们再回到一开始的地方啊，啊这是我们加载数据的一个代码，这样的话我们就拿到了我们的训练数据，拿到了我们的词典，对吧好，接下来我们来看一下我们的模型啊。

我们的模型我们的模型很简单啊，我们这里用了一个LSTM的一个模型，然后加了两个全连接层，全连接层是什么东西呢，就是我们的普通的一个神经网络，好吧好，我们来看一下我们这个模型是什么样子啊。

其实内容都是我们今天学过的，首先呢我们需要定义这个embedding，这个embedding层是什么东西呢，就是我们上节课给大家讲的这个，Embedding metrics。

就是我们输入一开始输入的是什么，我们输入的是文本的一个下标对吧，或者说一个one hot，我们需要去经过这个embedding metrics，把这个embedding给映射出来对吧。

所以呢我们首先需要去定义这个embedding层，Embedding，这里忘记说了啊，啊很多同学可能都没有接触过这个PYTORCH啊，可能没有接触过PYTORCH。

那我这边先给大家简单介绍一下这个Python是吧，PYTORCH去定义一个模型呢，它非常简单啊，非常简单，如何定义一个模型呢，首先呢你实现一个类，这个类呢需要继承自拍，他这个touch到N打model。

继承完这个类之后呢，你需要重写两个方法，一个是构造方法，一个是forward的方法，构造方法他做的事情是什么呢，准备我们需要用到的参数和layer，就是说我们需要用到哪些参数，你需要去做一些准备。

有需要用到哪些层，你要用RN，你要用CN还是要用LSTM，你就在我们构造方法当中去进行准备，这是我们第一个要写的方法啊，要重写的方法，第二个要重写的方法的话是我们的符号的方法。

这个方法呢就是我们的前向传播，前向传播，这是在什么，在干什么呢，就是把我们准备好的layer拼接在一起，拼接在一起，就你这里准备了这么多layer对吧，那每一层layer他这个数据是怎么传递的。

你需要把它拼接在一起，你才能构建成一个神经网络对吧，这就是我们的前向传播做的一个事情啊，做的一个事情就这么简单啊，Python是构建模型就这么简单，就这么简单，好吧好，那我们回到刚才的内容啊。

首先我们来看我们的构造方法，我们先构建我们的embedding层，这个embedding层的话就是刚才说的，我们要把我们的下标转换成这个，embedding的一个形式对吧。

那这个embedding呢这个EBEDDING层啊，它有两个参数，第一个参数的话是这个词典的一个大小，第二个参数的话就是embedding size，那分别对应的，实际上就是我们上节课给大家讲的这个。

embedding matrix的一个维度，一个是词典的大维度，一个是embedding的维度，所以这两个参数需要传递进来，这样的话我们就构建好了我们的EB0层，然后呢我们这边使用的是LSTM好。

我们就来构建我们的LISTM层，LSTM层，首先的话是你的输入维度对吧。

你的这个X对吧，你的输入维度是什么，还有你的这个hidden hidden side，就是你的这个hidden state和咱们的这个sales。

它的维度是多少，这个东西需要定义出来好，然后是这里有个参数叫做number layers，什么意思呢，就是说你要构建几层这样的LSTM。

正常的话就是一层嘛对吧，我们实际上可以这样做啊，我们可以啊，诶稍等一下，诶，这是我们的一层，要听我们可以在上面再叠加一层啊，再叠加一层两天，这样的话就是两层的LISTM。

那在我们这边代码当中也是一样啊，我们就设置两层两层，然后这里我们额外还有个参数叫做bh fast first，就是我们把第一个维度设置为这个啊，这个BH的一个维度，它默认第一个维度不是背驰的维度啊。

所以我们这里把它设置为true，那这样的话我们这个维度实际上就是一个维度，是咱们的啊，BESIZE是吧，第二个维度的话是我们的序列的长度，第三个维度的话就是我们的这个啊，输出的一个维度。

也就是hidden size对吧，这就是我们最终AISTM的一个，输出值的一个维度啊，输出值的一个维度好，这是我们LISTM层，最后我们再构建两个全连接层，第一个全连接层的话。

你的输入维度肯定和上一层的维度保持一致，你才能进行计算对吧，所以是这里是256，那这里就是256，然后接下来呢我们给这一层的一个输出维度啊，我们给个100，然后最后我们再给一个啊。

再给一个LINUX层啊，输入位就是100，输出维度是二，为什么这里输出维度是二呢，因为我们接下来要去计算我们的那个and，cross entropy交叉熵损失，所以呢我们这里就输出两个值。

输出两个值去计算我们的cross entropy，好，这是我们的构造方法啊，接下来我们看我们的形象传播，那形象传播的话，就是把我们准备好的layer，去进行一些什么拼接对吧，首先是embedding层。

我们把我们的X给过来啊，这个X是什么呢，这个X就是我们刚才it load date的时候呢，我们把他做了转序列长度，然后补偿之后的这个X啊，我们进行了返回了，只是封装成了loader的一个形式对吧。

但实际上里面还是这样的一个下标，并且做了补偿对吧，所以这个东西呢，待会呢我们就会把它传递进来啊，传递进来就先给到我们embedding层，拿到我们的embedding。

再把embedding给到我们的LISTM好，这也是我们的重点啊，这也是我们重点，我们可以去看一下LISTM的代码的说明，嗯我们看一下它的output，output的话，它包括两个部分，一个是输出值。

还有一个是HN和这个CN，HN的话就是我们的hidden state，CN的话就是刚才说的这个sales state，那我们其实不需要后面这两个东西，我们只需要output对吧。

我们只需要他的输出值输出值，所以呢啊我们这里就用这个用这个符号啊，就表示刚才这里的eden state cal state，我们不需要啊，我们不需要只需要他的输出值，那这个输出值的维度啊。

就是这个which size序列长度state。

那我们现在要做的是什么，做的是文本分类对吧，我们文本分类刚才我们有个这样的一个图，它是一个many to one的一个形式。

并且我们取的是最后一个时刻点的一个输出值，对吧，所以啊。

我们这里应该取的是最后一个时刻的输出值，最后一个时刻怎么取呢，是不是就是一这两个维度的话，就是就全曲，为什么是全曲呢，因为besides你要全取吧，Peter size，你要全取唯独序列长度对吧。

我们要取最后一个字，那就是一好，这样的话我们就可以把最后这个时刻的值啊，也就是这个值这个蓝色框的值就取出来了，我们就给到我们的全连接层，给完全连接层之后呢，我们再给到第二个全连接层层。

然后再把结果进行输出，这就是我们构建的一个神经网络啊。

神经网络好，我们的模型就准备好了，我们再回过回到这边啊，有了数据，有了模型，那接下来就是开始进行训练了对吧，接下来开始训练训练好，训练过程呢，我们这边啊首先去定义我们的这个优化器。

优化器这个优化器是什么东西呢，这个东西大家可以理解为。

就是我们在求解这个进行啊梯度下降的过程中，我们不是要用这个W减掉这个学习力，再乘以我们的这个梯度对吧，那这个东西呢就被这个过程啊。

我们就采用了这个所谓的一个优化器，但不同的一个优化器啊。

它会有针对于我们这个梯度下降，会有一些更多的一些优化方法。

那我们用的这里这种方法被称为这个梯度下降，这是个随机梯度下降法，就是咱们有这个SGD，我们有可以给大家看一下啊，有这个touch点，有GDGD，SGDSGD的话就是我们的随机梯度下降法。

就是我们对一个位置的数据啊，去采用我们的梯度下降法，那ADAM呢，就是在SGD的基础上，去做了进一步的一些优化啊，让他收敛的更好一些，或者说收敛的速度更快一些啊，更快一些。

那我们啊这里这个原理啊我们就不展开讲了，大家大家感兴趣的话，可以下来搜索一下相关的资料啊，好，那我们这里就去定义一个这样的一个优化器啊，这个优化器呢需要去优化，我们当前这个模型里的所有参数对吧。

并且学习率我们要设置一个啊，就设置为我们这里设置为0。01，接下来我们去定义我们的这个loss function。

Loss function，像我们这里这个例子对吧，这里这个例子啊，我们采用的是这个binary cross出品，它是一个二分类的一个交叉熵损失对吧。

然后我们这里呢就采用普通的cross entropy啊，其实你用BO cross roy也是一样的好吧，都是可以的，好优化器，有了cross function我们也定义好了。

那接下来呢我们就可以进行我们的训练了对吧，这边呢这个代码什么意思呢，就是说我们要把我们的模型啊，如果你的QA是可用的，就把模型放到我们的GPU上，好，这边我们跑五个apple啊。

好每个apple的时候我会去便利我这个data loader对吧，我们这个data loader，那便利data loader的时候呢，我们就可以把每一个batch size的数据给取出来。

取出来之后呢也是一样啊，要放到GPU上，对于我们的标签也是哈，我们把它放到GPU上面，OK那X呢我们就给到我们的模型，给到我们的模型，给到我们的模型呢，实际上就是去执行我们的服务的方法。

就可以得到我们的输出值，好得到我们输出值之后呢，我们就可以去去他的augment x，来得到我们真实的一个标签，让我们把真实的标签啊存到我们这个list当中，然后这是我们的label label。

我们也存在这个list当中，接下来我们把我们的输出值啊，和我们的这个真实的label啊，去算一下我们的loss loss值，算完这个loss值之后，我们就有了loss对吧，有了loss好，首先第一步。

我们把我们优化器当中之前的梯度啊，先清理清理，因为在PYTORCH当中啊，这个优化其它会保留之前的一个梯度，你如果不清零的话，他这个梯度会累加，所以我们在进行更新梯度的时候啊，要先把这个七梯度清零。

清零之后呢。

我们去进行反向传播，反向传播是在干什么，就是在去求解咱们的这个梯度啊。

就是在求解FW在求解我们的梯度，那求解好梯度之后呢，我们再执行我们的这个optimizer的step方法，就可以去进行反向传播更新我们这里的W好吧。

这里就是在更新我们W这是在求梯度好吧，这里可以给大家写一下，这里是在求解梯度，这里是在诶更新我们的权重好，这样的话我们这个就是在一个循环的一个过程，对吧，这是我们循环的一个过程。

最后的话我们每跑完一个boss，我们就去求解一下这个准确率，准确率，最后我们把代码执行一下啊，把代码执行一下，整个流程就是这个样子啊，整个流程就是这个样子，好稍等一下啊。

O这第一个IPOD是67的准确率啊，啊我们跑了五个epoch之后，准确率就很高了对吧，已经90多了啊，90多了，这个就是我们整个使用这个啊PYTORCH啊，构建这样的一个LSTM。

来做咱们的这个文本分类的，这样的一个小例子啊。

小例子好吧好，最后的话我们在对今天的一个内容啊，建做一个简单的一个总结啊，今天的话，首先呢我们给大家介绍了这个神经网络对吧，包括什么是神经网络啊，神经网络啊是怎么去求解它的一个输出值的。

要怎么求解我们loss，那有了loss呢，又怎么去进行我们这个权重的一个优化和更新，对吧，那知道了这个什么是神经网络之后呢，我们又进行了一些扩展，给大家介绍了文本当中用的比较多的，这个循环神经网络。

循环神经网络的话，它容易出现这个所谓的梯度消失的问题对吧，所以呢我们引出了这个LISTM，那除了这个循环神经网络，它可以处理文本，其实呢卷积神经网络啊，它也可以处理这个文本。

那我们又从卷积的角度去给大家介绍了，如何去处理这样的一个文本对吧，包括卷积，什么是卷积，什么是这个卷积神经网络，再到我们如何在文本上去处理我们的啊，用卷积网络处理文本对吧，最后呢。

我们又给大家去取得这样的一个实战环节啊。

去构建了这样的一个，基于LISTM的一个文本分类模型，文本分类模型好的，那咱们今天的内容啊基本上就到这边了，到这边了，今天的内容还是蛮多的啊。

蛮多的啊，大家下来就多花点时间去啊复习一下啊，特别是这一块啊，就这个RN为什么会梯度消失，这一块这一块是非常重要的啊，基本上面试的时候是绝对会问的好吧，绝对会问的绝对会问的，嗯好行。

那咱们今天的内容就给大家介绍到这边了，后续大家如果还有什么疑问的疑问的话。

欢迎在这个群里面找我进行啊咨询，好吧好，那咱们今天的课程就到这边好。

【七月】NLP高端就业小班10期 - P2：2.基于RNN的文本分类与语言模型_ev - 不看兵法的数据分析师 - BV1BC4y1C7E5

我们今天这节课主要讲的内容，是关于语言模型和啊文本分类的一些问题，然后在PYTORCH这个方面呢，我们会主要主要介绍一下RNN相关的模型，就是recurrent neural network。

所以在课之前，我先我先把我的PPT给找出来，然后这节课内容其实还挺多，我们能讲多少，讲多少，如果讲不完的话，就明天继续讲，啊这是文本分类，然后，啊这这是我们这节课的PPT。

然后我们就可以开始讲今天的内容了，首先我们这节课的内容是，关于语言模型和文本分类，然后这两个问题其实看起来没有那么相关，但是因为他们都涉及到我们这节课要讲的，关于PYTORCH的。

如何写一个循环神经网络的内容，所以我们就把它放到一起讨论，这是一个非常快速的review，因为大家可能都有一些相应相应的啊，关于关于关于这两个部分的经验，所以我们就不会详细的讲了。

那我们先开始进入到语言模型，什么是一个语言模型呢，简单的来说一个语言模型，我们要讨论的任务就是给你一句话，我要告诉你这句话，它出现的概率有多大，那什么叫概率有多大呢，嗯这个概率其实是呃。

它它是一个人为定义的一个东西，就是我们我们想要知道这一句话，他一个人有多大的概率能够讲出这样一句话来，比如说下面有一个下面有一些例子说7月在线，7月在线是一所好学校，跟7月在线一是学好所效。

那第一句话就比第二句话，它出现的概率要更大一些，一般一个正常的人会讲第一句话，但是不太会讲出第二句话来，然后这个第二个还有一些选词也很重要，比如7月在线是一所好学校，就比7月在线是一所好教室。

出现的概率要大得多，他其实是衡量一句话，他的啊，它的合理性有多高的一种一种表示，然后我们想象一下，如果你能够知道每句话，它出现的概率有多多大的话，那就可以，你就可以做很多事情。

有有一个同学说他看不到画面，别的同学可以看到吧，我继续讲这个，OK那可能是那位同学需要自己重新刷新一下，然后我们讲到说啊，如果你能够知道，如果你能够知道这个一句话出现的概率有多大，你就可以完成很多任务。

比如说你可以做一些完形填空的任务对吧，就是如果这个句子里少了一个单词，然后给你几个不同的选项，你就能够去填，你也可以去啊做一些文本的生成，就给你一句话，你可以继续往下写文章。

就是有一些很很多各种各样的功能，都可以靠着这个这样一套模型去实现它，然后当我们在做这个在做语言模型的时候，我们往往会遵从这样一个法则，就是一个链式法则。

这个其实是conditional probability，条件概率是吧，每每后面一个单词出现的概率是，它是基于前面一个单词的，然后你这样就可以一条链式把乘法乘起来，然后应用到这个语言模型当中呢。

你就会拿到最下面的这样一套一套公式，就是它是一个连续的，连续的乘法，能够帮你把这个概率给算出来，嗯然后我们我们在以往做传统的这个语，言模型的时候，往往会遵守一个叫做MARCO假设。

这个MARCO马尔科夫假设的意思是说，后面一个单词往往只基于前面的N个单词，至于前面的N加1N加二个单词，我们就忽略不计了，就这样的话呢，在做一些传统模型的时候，能够帮你帮你把这个模型的啊参数调小。

就是你不需要看太远的过去发生了什么事情，你只要知道目前当前这前那个单词，你说的什么话，你就遇到下一个单词说什么话，当然这个在我们这节课里面，会稍微有点不太一样，因为我们这个神经网络的模型。

其实可以再往前看的更多一点，嗯最后讲一下这个语言模型的评价，我知道我讲的有点快，所以同学们有什么问题，可以在那个留言的地方评论，呃，因为因为我我我会稍微假设，大家对于这个方面有了一定的了解。

然后我们一般评价一个语言模型，是用一个一个东西叫做perplexity，perplexity是是什么呢，它其实就是把啊，就是把一句话出现的概率，取一个负的N分之一次方啊。

群群里的PPT我会在之后更新一下，没有问题，有perplexity是嗯，把把一个概率取了一个负的N分之一次方，为什么要取一个N分之一次，负的N分之一次方呢，首先它一个负的负的次方，是。

因为这个条是这个概率非常的小，往往概率是一个0。000几的东西，然后你看起来不太方便，然后你取一个负的什么次方呢，就可以把它变成一个比较大的数字，然后第二个为什么要取N分之一次方呢。

是因为你的句子的长度实际上是不一样的，如果是一个太长的句子，自然而然根据我们前面条件概率的定义，这个句子的出现概率就会非常的小，然后你你帮他做了一个N分之一次方之后，就可以normalize它。

那就可以把这个单词，把这个语句的长度的这个factor给它取消，那这样你会拿到的是一个正的数字，如果perplexity越高，就表示你这个呃LEXITY越高，就表示你这个语言越不好。

perplex CD呢就表示你出现了这个语言啊，比较符合你这个模型的预期，所以这个是对语言模型的一套评价，就是我们往往会训练一套模型，然后在一些新的语句上面，预去计算一下你的perplexity。

如果它越低，那就表示你这个语言模型越好，那基于神经网络的语言模型呢，其实跟刚刚是一样的，就也是一样的道理，它也是根据前面的若干个单词，来预测下一个单词啊，在这个在这个概率上面并没有任何的不同。

但是唯一的区别呢是，我们希望用用一个神经网络来拟合这个概率P，就这个P在我们传统的engram当中呢，其实只是计算一个频数的问题，就计算一个频率，你把它都数一数，然后数一数算个频率。

就这个这个前面若干个单词一共出现了多少次，然后你在基于前面若干个单词情况下出现，下一个单词出现了多少次，然后你把这个分子除以分母，你就能算出一个概率来，这是n gram，但是神经网络呢。

就是我们的目标是要训练一个神经网络的模型，我们前面讲过这个feedforward network这些模型来来，你和他在特别特别的来说，在这个神经在语言模型当中呢，我们经常用一些循环神经网络来啊。

预测这个下一个出现的单词是什么，这个模型呢，它的基本架构就是给你一个单词的输入，我根据前面当前的hidden state HT减一，和我的上一个单词HTXT减一，我要能够啊做一些做一个神经网络的操作。

帮你生成一个hidden state，这个hidden state，再下一步可以预测啊，我刚刚好像把它都调了一个调了一个位置嗯，就是这是这是xx t减一这个单词，然后你把它传到他这里。

其实拿拿了上面一个HT减二这样一个hidden state，然后这样进来之后呢，生成HT减一这个hidden state，拿到这个hidden state之后，最后你再做一个这个线性的线性的变换。

可以把它map到一个输出的层，这个YT减一呢其实就是为了预测XT，然后当你拿到了XT跟HT减一之后呢，你又可以做一些神经网络的操作，拿到一个HT，然后用这个HT再预测下一个单词。

所以往往同学们经常会看到一些啊，一般你能看到的图表是。

先把它放大一下，就是一般我们能够看到的图表，经常是有一个有一个这样的连接，就是这个YT跟YT和YT减一，都是为了预测下面一个单词啊，当然这个地方也会预测下一个单词，就这是我们经常看到的一些啊。

很容易看到的一些定义，然后看看同学们这里有一个问题，他说第二次课word to veg，输入层到隐藏层，玩house到W矩阵，这个W矩阵，啊这有有一个同学提了一个上一节课的问题。

但我还是我还是回答一下吧，就是上一节课，我们在训练那个词向量矩阵的时候，其实我们训练了一个输出项，输出矩阵和输出矩阵啊，输入矩阵和输出矩阵，然后在一般大家是拿那个输入的矩阵作为，我们的词向量输出的矩阵。

你就扔掉不要了，就是这个是一个比较随意的决定，就是当年MIKO发的那篇文章的时候，他说他说他发现这个input，hidden input的那个embedding比较好，比那个output的要好。

所以我们大家就基本上都沿用了这个习惯，大家都都用这个input embedding，来来训练我们的词向量好，那我们具体来看循环神经网络呢。

你会发现它其实就是一个简单的feed forward network，然后连续套了无限无限次，这样就达到了一个循环神经网络，你在计算每一个hidden state HT的时候呢。

其实都是拿上一个hidden state HT减一，做一个线性变换，然后再加一个啊，我们现在输入当前输入的单词XT，再做一个线性变换，这样你就可以拿到一个当前的hidden state HT。

然后再拿它来做一部这个做一步操作，把它map到你整个单词的这个空间上去，我们可以想象这个HT可能是一个，100维或者300维的hidden state，但是你这个YT呢。

可能是要展现在整个vocabulary size上面，所以就是说嗯我们HT可能是一个，可能是一个300mslogan state，然后但是我们的YTYT这个hat，我想说的是hat y t呢。

它应该是一个啊，比如说是5万维的hidden state，因为它要在整个单词的表上面做一个预测，所以这是一个把它把它斩，这个WS呢就是一个啊，相当于是一个5万×300位的这样一个向量。

能够把它转回到你想要的单词表上面，这是一个recurrent neural network，然后H0那一般就是一个全部为零的向量，这个是大家一般经常用的这个初始化的过程。

然后如果你要训练这样的一个循环神经网络呢，我们就一般会用一个cross entropy的损失函数，然后要注意的是，这个cross entropy，它是在所有的每一个你预测的单词上面。

都要做一个这个cross entropy的计算，因为我们我们如果回到前面这张图呢，你会看到我其实预测了YT减一，预测了YT预测了YT加一，就是你一直在不停的预测下一个单词，所以假设如果说你一共有一共。

比如说有text，从一到，那我们想要预测的target呢其实是从二到N加一，就这是我们我我们要预测的东西，就是我每一步拿了上一个单词，我都可以预测下一个单词，当然你要注意这个循环神经网络。

它其实是从左往右走的，所以我们当我们在预测第二个单词的时候，我们没有看到后面的单词，就是你不希望先把后面的单词给看了，把答案揭晓了啊，这个是我们预测的这样一个任务。

所以当你预测出了第二到N减一个单词之后呢，你就可以用它来计算你的loss啊，这个loss在在我们这里讲的就是一个，cross entropy的损失函数，然后那个嗯优化的方法呢就是GD。

或者你也可以用ADAM，或者我们用im prop，其实我最常用的就是at啊，就是ADAM这这样一个随机梯度下降的方法嗯，因为它的效果一般比较好，然后我们讲了这个perplexity，其实就是二的J次方。

这个跟我们前面定义的那个cross entrop，应该是等价的，同学们可以自己思考一下，就是这个J是我们一个loss对吧，然后这个二的J次方呢，实际上就是就是我们刚刚的那个这个语句，出现的概率。

它取一个负的N分之一次方的这样一个结果，好但是呢呃人们发现训练阿能比较困难，因为它有一个梯度消失和梯度爆炸的问题，为什么呢，因为我们这个循环神经网络，它是一路从左往右开始这样训练，然后当你每一次呃。

当你计算gradient的时候，其实你是不断的不断的在啊求导求导，求导再求导，然后我们知道这个求导公式，如果你给它展开的话呢，它是类似于下面的这样一种构造，就第一个你如果要这个E3是这里的一个loss。

然后你希望用这个loss对S3求导的，那你是啊partial e3除以partial S3，然后当你在对S2求导的时候呢，又要partial S3对partial s2求导，然后一直一直往前走。

一直到这个partial s1除以partial s0，然后现在如果我问你，这个E3对S0的导数是多少，那就是一个这就是一个连续点乘的一个过程呃，连续相乘的过程，然后如果你把这四个东西都乘到一起。

这个梯度很容易降到太低，所以啊我就不太具体讲讲述这个理论的问题，因为只要大家知道这个训练一个容易梯度消失，一个容易梯度爆炸，然后后来人们发明了什么办法呢，就有一些有一些经验性的方法。

一个是gradient clipping，就是当你每一步求导之后，你发现gradients太大了，我都把你往下一卡，卡到一个低于threshold的位置，再做这个再做这个更新啊。

这个是解决梯度爆炸的问题，就是梯度太大了，你可以把它往下卡，但梯度如果太小怎么办呢，梯度太小的话，我们可以想象，如果你一个模型的梯度非常小，你这个模型就几乎不会更新，你就一直等着它在那它都不会动。

那怎么办呢，后来人们又发现了，又发明了几套模型，这个长短记忆网络，Long short memory，讲到这个launch time memory啊，大家应该知道。

最近那个图灵奖颁给了三个做深度学习的人，做深度学习的一个是JOHHINGTON，一个是呃yellow on，一个是就说uh you sure benjam，然后就有很多人说。

发明long shots memory的，这个人也也应该能拿这个图灵奖，就他是一个叫什么什mt huber的一个人，忘了他的她的名字叫什么了啊，但是就这个人非常可惜，他没有拿到图灵奖嗯，一部分原因是。

因为他据说他的学术圈比较喜欢骂人，然后就啊大家都不太喜欢它，然后有同学问说这个perplexity是什么意思，就是你中文直接翻译一下，perplexity其实是一个叫做困惑度的东西。

就是当我拿到了一个模型，我们知道我前面定义了一个语言模型，其实是为了计算一些句子的概率的，所以如果我现在手上有一个模型，我给你一个句子，你这个模型应该能给我一个概率对吧。

那我现在是希望嗯我希望那些好的句子，它出现的概率应该越大越好，而差的概率差的句子呢，你的模型应该告诉我它的概率比较小，然后perplexity呢其实是我们知道是求的一个，求了一个inverse对吧。

就是一个呃相反数是吗，就是一除以那个东西，然后再给他normalize了一下，所以他其实是啊，相当于你数字越大，就表示你的困惑度越大，困惑度越大，就是说你这个模型有点问题，我明明这个句子挺好的。

你怎么把这个困惑度调这么大，所以啊一般是这个样子的，就当我们一般在评估一个模型的时候，你是给它一些比较好的句子，让他去计算一下概率，如果他给你算出来的这个困惑度特别大呢，就表示他这个模型看不懂你的句子。

那就表示他这个模型有点问题，就是这样一个直观的解释嗯，然后这个长度这个LSTM呢，呃具体的这个模型我都不想再细讲了，但它这是这是一个RNN的一个记忆细胞。

因为因为是船上一个hidden state加一个当前的input，生成一个当前的output，当前的hidden state，然后LSTM那它里面就有很多gate啊，有一个input gate。

有一个output gate，有一个forget gate，有一个叫做啊，另外一个叫什么gate来着，反正他有四个git啊，我们这里后面后面会讲这个LSTM，它的这个细胞有几个gate啊。

一个是它有它有若干个门来控制这个输入，然后这个门呢有有一个这个叫做forget gate对吧，然后这个I呢叫做input gate，然后这个C应该是一个cell gate对吧，然后最后一个啊。

最后还有一个git叫做output gate，就是这几个门可以控制你这个输入输出，它看起来很复杂，然后这个呢其实是最经典的一个，长短记记忆网络网，shot memory其实只有五个公式。

但是如果同学们看这个公式就会发现它，那他比较好的解决了，我们刚刚讲的这个gradient消失的问题，因为当你用这个后面的后面的输出，对前面求导的时候，你会发现他他的那个梯度，并没有被完全的消失掉。

但是我这里就不讲了，但这个下面的这个长短记忆网络呢，其实是更常用的一个长短记忆网络，就它并不是他并他跟刚刚的其实有一些变化啊，但这是一个更加popular的版本。

也是我们在PYTORCH当中能够写到的一个版本，就是你直接扣，你直接用PYTORCH里面的OSTM，它实现的就是这样的一套公式，这个是啊长短记忆网络嗯，还有一个非常常用的啊网络。

叫做gated recurrent unit，它是2014年提出的一个比较新的网络，这个网络呢就比我们刚刚的LSTM，又少了一个git，它有一个啊。

有一个他把一个他把忘记门和这个就forget gate，和input gate拼成了一个叫做reset gate，然后这样呢啊，就能够相当于是拿了一个更加简单的公式，只有它只有ZT跟RT这两个部分。

然后用它来对我们的，用它来对我们前面的一些输入，对对于我们前面的hidden state和新的输入，做一个线性的变化和什么非线性的激活，但嗯总结一下我们关于语言模型。

主要就是有三三套模型是我们经常拿来用的，一个叫做一个是传统的recurrent neural network，一个是LSTM，一个是GW，在实际的大多数项目当中。

我们很少使用这个最原始的recurrent neural network，大部分时候我们使用的都是LSTM和啊，Groove，然后注意这两个模型的一个区别，就是LOSTM。

它其实同时在传两个两个hidden state，就是我们同时要传这个ct和HT，这两个都是沿着我们的这个轨道再往后传的，如果我们看这张图就会发现，它其实都他其实上下有两条轨道在走，这两条我们都要传。

好然后然后还有一个呃总结一点，总结下来的一点，就是我们的模型的训练方法，是训练这个cross entropy loss，并且这个cross entropy loss，是要定义在每一个你输出的啊。

输出的这个单词上面，这个是想要提醒大家的一个点，然后我们就可以开始代码的部分，那我把这个拿过来啊，我们我们这节课的学习目标，我们已经讲了，我们要学习语言模型，然后呢我们会给大家介绍一个包。

叫做torch text，它可以啊，帮我们处理很多自然语言中，经常要处理到的任务啊，我是一个比较方便的库，但它其实现在也在开发当中，很多API还不是很稳定啊。

然后下面我们是要介绍如何写这个recurrent，Neural network，IOSTM和GP，然后我们讲怎么样训练它，就是一个一个最常用的技巧，是要做gradient clipping。

即使我们做LSTM，一般我们也经常会做gradient clipping，因为其实这些循环神经网络都很容易气度爆炸，梯度爆炸之后你就会出现一堆NAM，就是整个gradient非常非常大。

然后我们会讲一些这个小的细节问题，比如如何保存和读取一个模型好，那我们第一步就是要用啊，torch text来创建一个vocabulary，大家可以自己打开torch text之后。

读他的这个read me，就这个这个这个库其实非常小，它都没有多少代码，就是只是帮我们实现了一，些最常用的文本处理的功能，那我们我们这节课就会快速过一下。

第一步还是我们把想要想要import的库都import，主要是torch，还有这个torch text，然后我们还是把这个random seed全都freeze掉啊。

这个use coa呢是看我有没有COAVAILABLE，然后我们我们这里其实我这边是有哭的的，所以我待会很多可以用，可以用GPU来帮忙训练，会快很多，然后下面有一些HYPERPARAMETER。

一个是batch size，就是整个啊每一句话有多一个batch，里面有多少个句子啊，这个embedding size是我们一会儿要用到的这个啊，输输入的时候把这个单词EMBEDE成多少为。

其实我们可以试一个稍微小一点的数字，就是我给大家提供在提供在我们的那个呃，提供在群里面的那个课件，应该是650位的，是一个比较大的模型，但是我们现在课上可以用一个小一点的模型。

这样方便我一会儿训练的时候，可能速度会快一些，然后我们讲啊。

我要用一个什么训练的训练的数据呢，嗯我这边有，给大家看一下，我们还是用我之前经常用的text8点点train。

我们应该看点train对吧，我给大家先稍微熟悉一下，它其实是一个帮你处理好的一堆文字，我们看到它就是呃，他把那些标点符号全都去掉了，就是它都是一句完整的话，然后我们就直接用它来训练。

相当于是做一个demo的过程，因为我们知道其实标点符号也是挺重要的，但是我们这里就忽略不计了，然后就直接用这个来训练，那我们首先想到第一步，你得把这些把这些文本都读进来。

然后我们就用torch text来帮我们处理这个问题，我们可以用torch text点data点field来定义一个field，什么叫做field呢，field其实就是呃其实就是相当于告诉你。

我输入的东西是一些是一些什么，然后呢field你可以声明一些要求，就是因为它处理的全都是文本的东西，所以这些field全都是一个一个的单词，然后我们告诉他，我们想要把单词全都lower case。

然后下一步呢你就可以创建我们的数据集，然后torch text里面有一些啊，有一个DATASETS，点language model in data set。

这个language modeling dataset，就是专门帮我们创建language modeling的这个DATASET，然后我们可以传给他这个splits，他的path就我们告诉他这些文。

这些文件都在当前文件夹下，然后这个训练数据呢train，我们告诉他这个train的文件等于text，八点train点TXT，然后我们要给他传三个文件，一个是train，一个是一个是validation。

就是验证机，还有一个是测试集，就是test，我们给他这三个集合，然后我们告诉他这个text field是text，也就是说我们我们这个这些文本都要被lower case，然后它是一个一个field。

这样你就可以拿到train val test这样三个部分，下一步呢啊这样我们就拿到了，这里出了什么问题，Has no attribute language，我可能打错了。

Model in data set，这样你就拿到了train will test这样三个DATASET啊，它包含了什么东西呢，其实train will test，相当于他都把这些。

我们刚刚给大家看的那些文章，他都读进来了，读进来之后呢，第一步，我们要做的事情是要创建一个vocabulary，什么叫做vocabulary，那大家还记得我们上上一次训练词向量的时候。

我们就是把频率最高的那些单词留下来啊，作为我们的作为我们的单词表，然后PYTORCH啊，这个torch text直接帮我们做了这件事情，所以我们可以写text点build vocab train。

就是从训练数据里面去找，词频数最高的那些单词，当做你的vocabulary，然后呢我们还要指定一个max size，就是告诉我最最大一共有多少个单词，然后可以用max for CAB size。

这样就可以拿到啊，我们看到刚刚max for capites是5万，所以我们想要构建一个5万个单词的单词表，至于5万个以上的单词呢，我们就留着，啊5万个以上的这个单词。

我们就把它全都定义成一个叫做AK的东西，然后我们可以看一下，现在它build完vocab之后呢，所以你如果看这个text for CAB，你会发现它一共有5万02个单词啊，再给大家看一下这个vocab。

它有一些什么重要的功能啊，这个vocab它有一个它里面包含一个一个函数，叫做ITOS，这个是index to to string啊，我们看一下它的，它是个什么样的东西呢。

首先它的type是这个i two os，它是一个list，然后我们看一下这个list它具体长什么样子，如果你看十的话呢，他就告诉你前十个单词是什么，他有ak pad，The of and one。

就这些都是出现频率非常高的单词，然后有两个特殊的字符，AK叫AK和pad，UNK表示的是unknown word，就是两个不一样的啊，unknown是一个特殊字符。

就表示任何你没见过的单词都是unknown，pad呢，嗯是因为我们往往在传一个batch的text的时候，这个单词有长有短，然后这些太短的句子，我们就会给给它加上这个pad的字符在后面。

然后帮帮你补全到一样长，这样可以传进来，然后同学问三个文件一样吗，三个文件是不一样的，就他是三个三个不同的不同的哦，Sorry，非常感谢同学们提醒我，就这里是我这个地方打错了。

应该是应该是有三个不一样的文件是text8，这里三个文件对好，非常感谢同学提醒，然后我们在beautiful cap，这样你就拿到了vocabulary，然后除了i to o s呢。

还有一个s two i这个是string to index，然后看一下string to index呢，它其实是一个dictionary对吧，它其实是一个dictionary。

所以我们可以把它把他的items全都拿出来，或者或者我可以给大家看一下，如果你现在传一个AK进去呢，他就会告诉你是零，然后你如果你传一个apple进去，他就告诉你这个index是多少啊。

就是你可以传各种不同的单词进去，他就给你给你返回一个index，然后有了这个之后呢，下一步我们要做的事情就是训，就是把构建一个iterator，什么叫做iterator，就是你有这么多的，你在这个训练。

训练验证和测试集上面有这么多的text，你希望把它变成一个一个的batch，每一个batch里面包含了32个句子，然后你用这32个句子来做训练，因为我们刚刚定义的这个batch size是32对吧。

所以呢现在我们要构建一个iterator，iterator的构建方法就是我们可以用train eater，因为我们一共有三个部分，有train eater，well eater和test eater。

然后它可以被你一起构建出来，我们torch text点data点同学们注意这些啊，这些很多就batch type，Batch，Touch text，这些写法其实呃并不用背下来。

我一般都是直接从他们的官网上面抄，他们的做法，就因为这些库呢还没有特别稳定，所以没有必要把很多的时间花在记这些API上面，就是当你需要用的时候直接去抄就行了，这是一个他们的，啊一些一些做这个的。

就他们他们目前还是比较随机的定义的，一些做iteration的方法，然后我们看这些device等于一，然后这个BP t t length，bb t d length是什么呢。

BP t d length其实就是，啊这个device我应该应该给他写成一个touch device，你要想一下，我可以写torch点device，哭哭的嗯，其实我应该先把device给定义下来。

大家知道device是定义，你要不是一个CPU，要不是一个GPU，所以我可以写torch点device，if you could的，我就写哭的else CPU，这样你就拿到了一个device。

我们可以看一下device，现在是一个扩大的device，然后他就在我的一张GPU上面，所以我这里device可以写device等于，device等于device。

然后BP t d length是什么东西呢，就是我们知道，刚刚刚刚我们介绍语言模型的时候，我讲到了啊，你这个recurrent neural network，它的梯度是一路不停的传回去的。

所以这个啊这样的一种传梯度的方式，我们叫做back propagation through time，就是他根据时间的这个维度上往回back propagate，所以这个BP t t length。

就是表示你的往回传的长度要有多少，其实我们可以随便定义一个，我本来定义的是32，但我现在想32跟那个batch size可能会搞混，所以我干脆写一个bt size等于50。

然后我们写repeat等于false，就是当你过完一个epoch之后，就训练完，走完一遍这个文件之后，他不会再给你重复，然后我们写shuffle等于true，就是它能够帮你把，嗯把它杀后一下。

然后这样你就拿到了一个一个一几个iterator，然后我们看一下这些iterator，分别可以干什么事情，如果你想要拿一个iterator呢，你可以写eer train eater。

这样你就拿到了一个training iterator，然后我们可以看下一个batch，等于batch等于next eater，这样你就拿到了一个batch，然后我们想要看这个batch。

它里面有一些什么信息，你要怎么看呢，我先拿一个batch给大家看，然后看到如果你把batch打出来之后，它有两个部分，一个是点text，一个是点target。

我们分别看一下点text和点target是什么东西啊，字面上的意思来看，点text就是你当前的文本，target是你需要你需要预测的这个文本，然后我们看它的形状都是50×32。

这个32是我们的batch size，50呢是句子的长度，所以我们可以看啊batch点text，看看他是个什么样，它就是一个这样的矩阵，然后你拿到这样一个矩阵之后呢，我们可以把它用我们刚刚讲过的。

我们刚刚讲过text点vocab点IOS，IOS是把我们的index换成单词，然后我们可以用for i in fresh text，然后我们知道batch点text，它第二个维度是batch size。

所以我们可以把第二个维度是，把第一个维度上面所有的单词全拿出来，第二个维度上面我们只拿一个一个sequence，比如说第零个sequence，然后我们看他点data，然后我们再用把它给join起来。

我们看看这里点data还要还要做什么呢，点我们可以点点CPU，然后现在在print出来，Invalid syntax，Okay，Jubian，然后我们看到这样，它就你就拿到第一个句子。

他说ANARCHORIGINATED是什么东西，然后呢我们还希望把target一起打印，一起打印出来，所以我们看到中间隔开，第一句话是我们的我们的输入的这个文字，第二段话呢是我们输出的文字。

我们发现其实它基本上是一样的，他们只是差了一个一个offset，就是他们差了一个位置，你用前面的这一句话，当你读到anarchism的时候，我希望你预测originated。

当你当你读到originate的时候，我希望你预测as，就是我希望你每次都预测下一个单词，这是我们的我们的一个任务对吧，然后我们再看一看这些句子呢，啊我们可以再继续拿下一个batch。

我们可以写for i in range5，然后我可以再继续拿batch等于next it，我们看它会发生什么，然后我们再print，我只要把这些都拿下来就行。

然后再print i让我们看到它就会告诉你啊，然后我为什么要展示这个给大家来看呢，我就想我就希望大家知道，其实这些它是连续预测出来的，就是destroy the organization。

然后你看下面又是organization of society，It has also been taken up as positive，然后这里有什么啊，你看这边最后是。

Interpretation，然后下面一句话又是interpretation of what this means，就是它其实是连续的一些文字下来，所以你是可以理论上来说。

你可以一路训练一个循环神经网络，往下一直一直把这些参数都，把这些句子都传进去，这个也是我们一会儿要做的这样一件事情，就先给大家预告一下，然后我们刚刚已经讲了，这个为什么有5万02个单词。

而不是5万个单词，因为有两个特别的字符，一个叫做AK，一个叫做pad，它是会自动赠送给你的啊，然后我们说这个语言模型的任务是，根据之前的单词预测下一个单词，所以这是为什么我们输入是这个样子。

那下面我就要开始写我们的这个模型了，为了定一个模型呢，我们回顾一下，我们上节课讲讲，我们我们这个模型是要用torch，点NNSNN来定义一个模型对吧。

然后我们现在要写一个class anon model，这个anna model呢我希望把它写成一个非常generic model，但是在课上我可能就写的简单一点，我们这个群里面的那个模型。

它可以同时处理各种啊，可以可以同时处理recurrent neural network，可以处理group，可以处理LSTM，那我们现在就写啊，首先你要定义一个init function。

这个init function里面有一个iron type，但是我想呃，ison type就是我希望知道这个recurrent，neural network是什么什么类型的。

它是一个嗯最简单的RECURRNATURAL，可能还是一个OSTM，还是一个GP，然后我还想知道下一个是and token，其实是我们的vocabulary size。

或者我可以把这个名字改得更加好一点，我可以改成不capsize，然后嗯下面我们需要的是一个embedding size，Embedded size，然后我们还需要知道hidden size。

注意我稍微改了一下这些变量的名字，我感觉这样可能更加清晰的一些，这个and layers呢，是因为我们的RECURRENNETWORK，其实可以一层套一层套好几层，所以你可以声明一个有多少layer。

然后最后的是一个drop out，等于说pass我都想先不加了，就是这个先不给大家讲，包括这个and layer c也不要了吧，就我们就训练一个最简单的模型。

然后呢我们先初始化super ron model，self点image，这个其实就是，反正大家只要把这段背下来就行了，我们一般就是直接写一段初始化这个模型，它上面的那个，然后我们现在要做的是self点。

encoder等于NN点embedding，或者你也可以写in bed点embedding，然后vocab size到n a capsize die in bed size。

这个是一个啊embedding的层，相当于我给你一段话进来，每一个单词我先给你，embed成一个100维的向量或者300维的向量，我们刚刚定义的embed size是100。

所以我们会拿到一个100维的向量啊，然后下一步呢我们就是要定义一个recurrent，neural network点，我这边就写个LSTM吧，同学们具体可以看就是别的几种应该要怎么写。

可以去参照我们的啊，群里的那个已经上传的代码，那我们可以写LSTMNN点，L s t m，然后IOSTM需要哪些参数呢，他需要的第一个是，所以我把这个ann tap也扔掉，就使用IOSTM，然后呢。

呃我们相当于是要告诉他，我们的bt size跟这个hidden size，这样这样就已经可以了，这样你就拿到一个LSTM，然后最后我们再加个self点啊，Decoder layer。

decoder是什么意思呢，就是我们这张slides里面啊，你最后输出的时候，这个YT减一，其实是一个5万5万02维的这样一个向量，因为这样它要能够最终被你arg max回，我们的单词表。

所以它是一个5万02维的向量，所以这个东西呢它是一个NN点，linear hidden size到vocab size没有问题，这样我们就拿到了我们想要拿的拿的东西。

然后我们就可以定义一个forward函数，Self，so对有同学问说这个super不写可以吗，就是在在这个模型里面是要写的，因为它是继承继承自这个N点module，所以你要先super他。

然后再做做下面的事情，就是为了继承上面的一个类型，然后下一步我们需要啊forward，就是我们我们其实拿到的是两部分内容，一个是input，一个是hidden，就forward。

还记得是是我们我们前面讲过的一个forward pass，然后对于我们这个forward pass来说呢，其实我们就是拿到，就是我们刚刚拿到的这个batch点，text是我们要处理的东西。

所以我可以把input改成text，这样可能更统一一些，这样拿到text之后呢，我们要做什么事情呢，首先我们要给它变成embedding self，点in bed text，我一般写这些代码的时候。

我经常会把他的shape给写下来，我们知道这个text它应该是sequence l乘以batch size，对吧，这里要稍微注意一点，就是torch它拍torch，它默认做这些啊。

recurrent的处理的时候，他的第一个维度都是sequence length，第二个维度是batch size，其实这个稍微有点不是特别直观，如果同学们看着不太爽的话呢。

可以把它特别声明一个batch first等于true，这样就可以让你的recurrent，neural network都改成处理batch，把batch放在第一个维度上，也就是给它转置一下。

变成batch size sequence，And，但是我们这里就先不做这个处理，先沿用它原始的这个习惯，然后这样你拿到了一个embedding，然后下一步呢。

我们就是直接把embedding传进我们的传递，我们的recurrent neural network，所以我们写self点Lt m in bed hidden。

注意hidden是上一个hidden state，就是这个LSTM它究竟在做什么呢，我先写，他会给你输出一个output和hidden，等于这个。

我应该把PYTORCH的这个documentation给打开，然后跟大家一起看一下，IOSTM它具体是怎么怎么用的，就LSTM这个函数呢，啊这个这个类这个class对吧，它实际上是啊。

我们看到他的公式在这里，这个是我刚才给大家看过的这一套公式，这是他干的一件事情，然后呢它的输入是你当前的input，然后我们看到这个input。

它的shape是sequence length乘以batch乘以input size，也就是说它一共有多少个单词，这个batch有多少多大，然后告诉你这个input size。

这个其实就是你embedding的这个layer之类的，然后呢H0我们注意他这里还有number of layers，就是你其实可以有若干层这个LSTM，但是很多我们在这里。

其实就直接写一层的这个LSTM，然后number of directions，你还可以写双向LSTM，但我们这里是个单向，然后呢是batch跟hidden size，这个batch。

这个H0呢就是告诉你你这个LSTM，因为我们一共有sequence length对吧，就你传进来的时候，其实传了sequence length这个token，他会一路把LSTM跑到底。

然后告诉你最后的时候，就这个H0是第一个hidden state，C0是第一个cell state，我们刚刚讲过，LSTM有个有个有两个有两个东西在往后传。

然后它的output呢其实是也是sequence乘以batch，乘以number of directions in hidden size啊，就是说一共一共输出了多少个啊。

就是把输出的每一个hidden state他都给你拿出来了，有一个成一个hidden size，然后这个HM那就是当你跑到结尾的时候，那个hidden state这个cm是你跑到结尾的时候。

这个cell state我不知道同学们有没有被我搞混了，就是其实其实这个他完全处理的，就是我刚刚才在slides里面给大家看的这张图，就这张图里面他拿进来的这个input呢。

是相当于是你这个XX0到XNX0到XT，然后呢，他的输出其实就是你输出的这个H0到HT，或者说是H就是当你X0到XT之后呢，他输入是H0到HT，或者我们说X1到XT输入是H1到HT。

然后他会帮帮你把最后一个hidden state也留下来，然后最后还有一个cell state是LSTM特有的，所以如果直接进入写代码的这个，我们再回到写代码这里，你下一步呢你这样就会拿到一个啊。

我们注意这个这个embedding呢，它其实是sequence dance乘以batch size乘以in bed size，对吧，然后这里呢我们我们可以想一下output。

它究竟是一个什么样的shape，这个output它其实是我们看一下这个output，是它告诉你是一个sequence length乘以batch乘以。

它其实是一个sequence length乘以batch size，再乘以乘以什么呢，乘以hidden size，就是你拿到的output，然后这个hidden是什么呢。

hidden其实就是最后一个hidden state，就当你sequence Lt拿到底的时候，所以它其实就是一乘以，他其实这个hidden有两个部分对吧，它是一乘以batch size chhi。

另外一个也是1×123乘以系统，为什么有个一乘以南，因为它的LOSTM其实可以是有若干层的，所以啊当你只有一层，只有一个方向的时候，它就是个就是一个定制一，但我们可以暂时就这么记住它。

这样你就拿到了OUTCAHIDDEN，然后下面下一步你要做的事情，你是要把它给decode，掉到这个vocabulary size上面，所以我们可以把output，直接啊linear掉。

但是这里要注意一个什么问题呢，因为我们的output是sequence length乘以batch size，它是一个三个维度的，但是实际上我们在啊，就是当我们在做这个线性变化的时候。

它必须它只能取一个两维的这个变量，所以我们常常做的一件事情是，我们会把output点，output变成output点，-1output，电shape2，就这个是干什么事情呢。

就是我们把前两个维度给拼到一起，就变成sequence length in batch size，就这两个维度直接给你拼到一起，这样你就变成一个二维的啊，这样这样一个向一个向量。

然后一个tensor只有两个dimension的一个tensor，然后这样拿到之后，你再把它把它啊decode出来，然后我们往往会这么做，我就直接把它给传进去算了，就这样这样传进去一个啊，你新的。

State，我们把它叫做decoded，等于你decoded这个这个部分，然后这样这样当你拿到decoded之后呢，我们我们再记一下decoded，它是一个什么什么形状呢。

decoded它其实也是sequence length乘以batch，再乘以一个vocab size对吧，但是我们注意我们又会，我们又会希望把这两个维度给拆开，就是不要啊啊。

有个同学问为什么decoder是个线性变换，其实这是一个好问题，因为decoder一般其实往往是这个名字，确实不太好，我我把它直接转成零一也算，我换一个名字叫做linear，这样应该就没有没有歧义了。

就decoder往往其实是个I呢，所以这个同学其实说的说的很有道理，就是我可以把它啊叫做叫什么名字呢，就叫out voca，然后这个out of a CAB最后要做的一件事情是return。

我们是我们希望把out of a CAB，再变成我们本来的那个形状，所以我会用out of a CAB等于out of a camp，点view view什么呢，output点size。

注意这个size跟shape其实是一样的，就是shape你只要写啊方括号，然后size你得写这个这种括号，然后我们再写个output size，一，最后我们写啊，他应该是。

其实他应该是vocabulary size，但是我们直接写out for cap，点size-1就可以了，这个是我们的啊，这个是我们最终返回的，我们最终就希望返回这个out of the cap。

因为我们我们要知道每一个每一个位置，是每一个位置是什么样子啊，每一个位置分别预测了哪一个单词，然后另外一个我想要输出的是，我要把这个hidden也给输出出去，因为这个hidden呢。

它是包含了到目前为止句子的信息，然后同学们后面就会知道，为什么我要把这个hidden也传出去，然后看同学这里有一个问题，他说隐藏层到输出层没有SIGMOID或者RU嘛，我记得我同学们问的是。

为什么这个output到这个out of the CAB之间只有LI，也没有一个离你没有一个activation，就一般来说我们在做这种LSTM的时候，不太会再加一个activation。

因为LSTM里面本身有很多的activation，就它每一个gate，每一个那些啊，每一个那个unit里面都做了一些activation，所以一般我们不会在这里再加一个activation。

同学们如果感兴趣，也可以自己去加这些activation，看会不会有效果，相当于是个惯例吧，大家一般不会加，然后呢嗯另外我还要定义一个函数是def in it，Hidden，我们刚刚讲过。

我们一般一般hidden其实全都是全零的那个参数，所以我们就会直接写一个，直接初始化一个hidden state，然后我们接requires grad等于true。

怎么样怎么样产生一个hidden state，这里这里有一个有一些比较奇音技巧的地方，就是我们一般因为因为有一个问题啊，就是我我们我们这个hidden呢。

其实我们就希望直接return一个类似于这样的东西，类似类似于一个全零的这样一个一个hidden state，但是这里有一个问题啊，是你其实不知道你的，你现在的模型是在COA上面还是不在KA上面。

就你是在用GPU还是在用CPU，然后我们一般这种时候，经常会直接把这个self点parameters呃，self and parameters是一个iterator对吧。

它相当于是所有的你模型里面所有的参数，然后我就随便拿一个参数，然后我用这个参数写一个点，New zero，这个是什么意思呢，其实就是你创建创建一些全民的啊，这个hidden创建一个全新的tensor。

但是它的类型跟你的weight是一个类型，所以你就可以拿到一堆，如果这个如果你的模型在GPU上，你就可以拿到GPU的全名的tensor，如果是在CPU上，你就可以拿到CPU上确定的tensor。

让我们看一下，这个时候你需要拿到的这个tensor，应该是一乘以batch size乘以self点，我想说的是hidden size，所以我要写self点。

hidden size等于hidden size，这样就可以拿到hidden size，然后最后我们再写一个request grade，这个是表示你要不要做gradient。

这个gradient要不要back prop到这个地方啊，具体的含义我们一会儿一会儿同学们就会理解，所以我这里先不多讲这样，因为我们这是因为我们这是个LSTM，所以它要返回两个hidden state。

一个是真正的这个hidden state，另外一个叫做cell cell state对吧，是我们的啊，LSTM里面特有的两个hidden state，那这样这个模型基本上就写完了。

就这个模型其实就这么简单，因为我稍微忽略掉了几个啊，忽略掉了几个部分，就是如何写glue，如何写啊，但基本上性质是一样的，然后有了这个模型之后呢，你就可以初始化一个模型。

初始化一个模型的方法是model，点on n on n and model，然后它有哪些参数，我们可以把这些参数都拿下来，Capitalize，我一般在写这个这些模型的时候，会把它的每一个参数都指定好。

它的capsize应该是，是不是我们的我已经前面把它定下来了对吧，其实我们的vocab size应该是text点vocab，是没有把text of a CAB给拿下来，所以我们可以写啊。

我可以直接写length of text and vocab，这样是你当前的vocabulary size，然后它的embedding size应该是点in，我记得我前面有一个。

Embedding size，这应该是个global variable，然后这个hidden size呢，tan size又是什么啊，我就直接定义成sorry，外面外面很吵。

我们再定义一个hidden size，这个hidden size我们就写hidden size，等于我们也写100吧，因为这个模型小一点，训练的快一点，那我们就再把他的hidden size也拿下来。

这样就拿到了一个hidden size，这样就拿到了一个模型，然后呢如果如果我有KDA的话呢，If use coa，我希望把模型变成model点two device，这样就可以了。

我们刚刚device其实是个哭的，所以我们现在可以看一下我的模型长什么样，他就告诉你这是个N模型啊，然后我们可以看一下model，我们可以看一下刚刚我们做的这个model next点heroes。

这样你相当于就拿到了一个parameter，然后你看到这个parameter，它其实是在KA上面，这样你就知道你的模型它都在coda0，这个device上面，那下面呢我们就可以开始写这个模型了。

写这个模型啊，训练这个模型要怎么做呢，其实它的跟苏训的，所有其他模型的套路都是一样的，我们就是做uh for epoch in range，Number of epox。

我忘了number of epox，我定了多少，number of epox等于诶，我是不是根本就没有定义number of epox，但是问题不大。

我们一会随便定义一个number of epox等于，我们可以number of epoch等于两个epoch，然后下面我要做什么事情呢，你要写model点train。

因为因为模型我不知道上一节课有没有讲过，就是PYTORCH里面模型其实有两种不同的setting，一种是训练模型，训练模式，一种是测试模式，在训练的时候跟测试的时候，有很多地方是不一样的。

比如说这个drop out bonalization，算了，外面外面警车太多了，就这个嗯有很多不同的不同的地方，所以同学们只要记住，你每次开始训练之前都写model点train。

然后我们把这个train的这个iterator给拿过来，然后就可以开始循环了，然后我要做的一件事情，首先我要把当前的hidden state给拿出来，所以我写model init hidden啊。

把我们的batch size传进去，下一步呢我就要写for i batch in enumerate，我们知道enumerate是可以帮你enumerate。

enumerate可以帮你循环这个iterator，然后还可以帮你拿到这个index i，然后呢我们就可以用data target等于我们的batch点text，batch点target u。

然后这样呢其实其实我有点好奇这一点啊，我们前面应该拿到过一个batch对吧，这是我们之前拿到的patch batch，然后你看到这个batch点data啊，fresh点text。

你看看他其实已经在哭到零上面，这个就非常方便，所以它已经在哭到零上面，那我们就不用把它转成哭的，然后下面一步我要做一个什么事情呢，呃这个稍微有一点tricky啊，就是因为因为我刚刚我刚刚特别跟大家讲过。

这个句子，它是一路往下连下去的，就是我这个地方你发现它的句子，其实这个batch跟下一个batch，它的句子是连着走的，所以理论上你这个hidden state可以一直往下传。

就是当你这句话跑了一个LSTM，最后拿到了一个hidden state，这个hidden state你其实可以再传到这个地方，再接着往下走，又拿到一个hidden state，然后再接着往下走对吧。

就这个没有什么问题对吧，就是你这个hidden state其实你可以一路往下走，然后你这个文章如果一共有比如说1万个单词，你可以一路跑1万个这个这个back propagation。

Through time，但是实际上呢在训练的时候，我们知道你的神经网络是不能太深的，当你的神经网络太深了之后，一个是他back propagation会非常的慢，另外一个呢你的内存也也存不下。

这么大的一个计算图，所以实际上我们经常在做的一件事情呢，是实际上我们经常在做的一件事情，是我确实希望把hidden state往下传，就是我希望做，我希望做这样一件事情，就是output dm。

啊我希望做的是output hidden等于model，然后你写的是，我觉得其实我都可以直接这么写啊，就你希望把data和hidden直接传进去，变成output hidden。

就是我们看到这个hidden，他过了一个iteration，过了一个iteration之后又是hidden，过了一个iteration之后又是hidden，等于说你这个hidden在不断的往下传。

但这样有一个什么问题呢，就是你会back prop propagate，Propagate through all iterations，就想你想象一下，如果这个循环它有它循环了1万次。

那我这个back propagation就要back prop，50×10000次，就这样就会非常的这个计算图非常的大，非常的深，然后你的内存很快就会爆掉，对这位同学说的没错。

只有训练语言模型的时候会这样穿hidden，因为你训练别的模型的时候，这个hidden跟前面的一个batch其实就没有关系了，就这个语言模型的时候才有关系，然后我们经常做的一件事情呢。

就是对这位同学说的没错，就是翻译什么的，一般就不会这样做，因为你翻译的下一个batch跟上一个batch，其实基本上没什么关系，它就是只是一些很短的句子，但在语言模型的时候呢，训练一个语言模型的时候。

你往往会希望把这些信息能保存的都保存下来，但是所以为了做这件事情呢，我们一般会定义一个function叫做the package a hidden，这个是什么事情呢。

就是当你给我一个hidden states的时候，其实我想要返回的是这么一个东西，就是我想返回一点detach，detach干的是什么事情呢。

detach就是说啊我这个hidden state还是在这没错，但是我把这个hidden state跟之前所有的history，全部detach掉，就是这个H它其实是H表面上是一个tensor。

但在PYTORCH里面，这个tensor其实是计算图里面的一个节点，这个节点跟你计算图里面，之前所有的节点都是有联系的，但是你detach之后呢，你可以把它从前面的这张计算图里截断。

等于说这个H它就是一个全新的开始了，它相当于是复制了一个新的这样同样的tensor，它只是把这些值给复制下来，他没有把他的历史给背下来，那这样呢你就可以你做back propagation的时候。

这个就是back propagation的起点，而不是前面就这个反向传播，从这里开始，然后注意，因为我们的tensor啊，因为我们这个啊，我们我们现在在做的一件事情是，它有这个LOSTM。

有两个hidden，所以我们就要特别处理一下its instance，H如果它是torch点tensor的话，我就直接返回detach，然后else的话呢，因为我知道他他另外一种方法。

其实它就是一个突破，就是两个突破，就是一个用逗号隔开的那个那个格式，所以我可以repair k对的，就是我recursively call一下v for v in h，就如果他有两。

它有若干个hidden state，我就把每一个hidden state都重重新package一下，所以我这里要做的一件事情是啊，当我在传进这个模型之前，我要先做hidden。

等于repackage hidden hidden，这样我能确保这个hidden它是一个全新的hidden，而不是一个带着一大堆历史的hidden，下一步就是我们啊最基本的操作了。

就是你其实就是做model点嗯，应该什么，应该是optimizer点，Zero grad，我们要先算一个loss对吧，loss等于loss function of output。

然后output can target，注意这个target其实就是这个target，然后我们我们记得这个，然后这里要稍微注意一下，就是我们啊这个loss function我都还没定义啊。

我可以在这里定义一下，我们先把loss function跟这些optimizer什么的，全都定义了，这个loss function是我们刚刚讲过，我们要用的是一个cross entropy loss。

然后learning rate我调个0。001，然后我们的optimizer我写一个torch点，OPTIM点，adam model点parameters，我把所有的参数都传进去优化。

然后learning rate等于the learning rate，U这个就可以了，这样你有了一个optimizer，然后我们可以optimizer zero grad。

然后我们就可以做我们前面讲过的啊，啊这里这里要刚刚，为什么我刚刚我还要强调的一个点是什么呢，就是这个loss function，这个loss function是一个呃，他希望你传进来。

因为这个loss function它是cross entropy loss，他希望你传进来的是batch size乘以number of targets，就target dimension。

然后第二个是，第二个参数，它希望你传进来的就是batch size，因为它其实就只需要知道你正确的class是哪一类，然后这个是等于说target啊，Class dimension，然后有同学问题。

tech的时候，grade会清零吗，其实这个问题我还真不知道，我不知道他会不会清零，但是我我想他应该会帮你清零，就同学们可以自己看一下，你点detect时候，他的grade有没有清零，但是问题都不大。

即使他没有清零，我这个地方还是会帮他把呃，里面model里面所有的参数哦，grade有没清零，我认为应该是清零了，就他他没有理由不清零，我觉得，但同学们可以自己检查一下，看一看他的grade。

就是其实你只要看这个hidden点grade，你就能知道他有没有被清理好，那我们现在计算了一个loss之后，然后这个形状不对对吧，就是这个output，我们还记得他刚刚的形状，其实是它其实是一个啊。

如果我们还记得刚刚我模型定义的时候，它其实返回的是一个sequence，length乘以batch size，乘以vocabulary size，它其实是有三个部分，那我现在想要把它变成两个部分。

那我可以做optimize啊，我可以写这个点view，-1vocab size，Vocab size，我其实应该把它写到外面去，就是vocab size应该是等于length of。

Text dm vocab，这是我们的vocab size，应该是5万02，那这样你就拿到vocabulary size，然后这个target呢你就给他view-1就行了。

然后后面我们是不是就要做loss backward，再下一步我们是写optimizer点step对吧，但是这里注意有一个问题是什么，就是我们讲了你训练RNN的时候需要gradient。

需要clip gradient，所以我们要做的一件事情，我们是touch点NN点UTILS点clip grade nm，就是把他的norm给cut down model parameters。

我们希望把model parameters里面的parameter，全都cut到gradient clips这个这个区间下面，所以我们要定义gradient clip啊，一般我们会定一个5。

0之类的数字，所以我们就用个5。0吧，然后有同学问就是拷贝data，对，其实那个规定，其实那个DETECH基本就是copy了这个它的data。

但是没有copy他的history是copy这个当前的data，那这个这样现在就可以了，我们可以试一下啊，if i divided by100等于零，然后我就print los los，点item。

看一下这个模型可不可以训练起来，然后你就看到这个loss，它已经开始了，你看到这个loss会降下来，然后我们边训练边说，我们还可以做一些什么事情，还可以做的一件事情呢，是啊。

我们我们往往希望把你训练时候的一，些模型给存下来，那我们怎么样存一个模型呢，我们一般做的方法就是，比如说你是希望每1万个iteration保存一次，那我可以每当每当过1万个iteration的时候。

我可以写torch点，Safe model，点state dict，State dict，就是model的那些state diction state什么东西，然后你要把这个模型的名字告诉他。

我可以写language model点啊，Pytorch，这样你就把它存下来了，但是呢嗯我先把它断掉了，就是因为我们一会还会重新训练，但这里又有一个什么小问题要提醒大家，就是啊也没有也不是一个小问题吧。

就先给大家看一下，这个model sett究竟是个什么东西，就model state dict呢，它其实就是一个order dictionary，它帮你把里面每一个模型的参数都存下来了。

其实这就是模型所有的参数，然后当你存下来之后呢，下次你就给给他漏了回来，这个是PYTORCH推荐的一个保存的方法，就是你把他的state dict给保存下来，但是还有一个呃我想讲的一个问题是。

我们一般不会把每个模型都保存下来，就是我们一般的常常用常用的做法是，我我先给他在validation set上面evaluate一下，因为我们有三个set，三个data set，一个叫training。

一个叫validation，一个叫test，然后我们会经常在validation上面evaluate一下，所以我现在定义一个evaluate这样一个function。

然后呢你把这个模型在while it上面，validation iteration上面啊，去给他1evaluate一下，那如果我发现这个if we lost be，毕业最好的那个loss要要好的话。

我就给他存下来，所以我会写一个while losses，等于等于一个一个一个list，然后如果他的我希望做的事情，就是如果现在是第一次做validation，file losses等于零。

or will loss小于minimum of their losses，就是它比之前的每一次validation结果都好，我就把模型保存下来对吧，然后我可以做一个print啊，Best model。

嗯我们来看一下，我可以写print best model，saved to l m点PTH，这样就告诉你这个模型已经保存了，else else我要做什么事情呢，就是当你发现这个模型不太好的时候啊。

我们常常做的一件事情是直接schedule，我们常常这个时候我们常常做一件什么事情呢，就是当你发现这个时候，模型的loss在validation上面的loss没有降下来。

这个就表示你现在的这个optimizer，已经心有余而力不足，就是这个它的模型已经loss降不下来了，这个时候我们常常会做一件事情，叫做learning rate decay。

什么叫做learning is decay，就是当你发现现在这个learning rate下面，模型的loss降不下来，你把这个learning rate降一下，那你为降了之后。

这个模型调的就变得更精细一点，往往你会发现它又能够降下来，然后PYTORCH里面提供提供了一个，将这个啊降learning rate的方法，就是你可以定义一个schedule，一个schedule啊。

就是它可以帮你，它可以帮你调这个模型的learning rate，然后你就可以用touch点OPTIM，它也是一个optimizer点l r sky jua点，Exponential。

Exponential l r，它其实就是呃你每你每扣一次这个schedule，他都帮你把learning rate降一降一个一个点，我这0。5就表示它learning rate降一半。

然后这样你有了一个schedule之后呢，你就可以写schedule点step，这样他learning rate就降，就有时候有时候这里还有很多啊，很多细节的地方。

有时候人们会说我如果连续三次learning rate不降，连续三次这个loss不降，我就降learning rate，我们这里是每一次loss不降，我就降一次learning rate。

就这个取决于大家同学们自己调模型的时候，看哪一个更有效果，然后我们唯一缺的一点就是，我们还没有写evaluate这个这个function对吧，下一步我要写的是写一个def evaluate model。

这个其实是一个iterator，但我把它叫做data，就是我传了一个well well那个iterator进来，下面我们要做的一件事情是，我基本上其实只要把这个模型一抄就行了啊。

就把这把这段代码我一抄起来就可以了，就除了把最后这个optimizer之类的东西，不要剩下的东西我全部直接抄一遍就可以，嗯还要注意点什么呢，就这个地方不是model点train，而是model点了。

然后当你完之后，最后我还是希望我们还是需要把它改回model点，Train，就是你突然进了evaluate之后，你得把这个模型给evaluate1遍，然后还有一点我们希望保存什么呢。

我希望把total loss给保存下来，所以total loss是零点，然后我还希望把这个total count，就是我一共预测了多少个单词也保存下来，然后这个it应该是iterate data。

然后hidden还是应该说hidden没有什么问题，但是这里又要包一层特别的啊，因为我们现在是在做预测，是在做16000ATION，而不是在做training，所以你要写model点NO grade。

这样你就能确保这个context，下面所有的东西都没有gradient啊，然后我们看看还有没有这个还有没有什么问题，这里是init grade啊。

然后这里的requires grade应该要等于false，这样可以让他没有gradient进来，注意这个这个request grade是我之前写的，这个写在这个地方。

quest grade就是让他不要有gradient进来，然后我们再看一下还有什么需要改的，这个hidden是repackage hidden，然后with NO啊，然后这里有output。

然后这里要计算loss，然后下一步我们要做的是更新一下，total loss等于loss，这里要注意什么呢，因为这个loss它其实是被平均过的，所以我希望把它loss总的加回来。

所以我其实只要loss点item乘以啊，我希望把这个data的size给传进来，因为他一共一共预测了这么多这么多个位置，所以我们可以用npd multiply，把这个data点size给拿拿出来。

这个表示就是把因为data点size是一个突破，然后我这个就相当于把这个突破给拆开，然后给它全都存到一起，然后这个是total loss，另外一个要改的是total。

这个total count也是lost啊，total count应该是什么呢，应该就是把lost in item给去掉，这就是你的total count，然后我现在要返回的是return loss。

然后希望把loss等于total loss除以total count，这样我们就拿到了evaluate，然后我们不出意外的话，我们应该已经可以evaluate，我稍微把这个数字写小一点。

这样1000个位置我们就160一次，然后我们看看这个啊模型有没有什么问题，但是能够一次通过，要不然的话，要不然的话跑一下还是挺费时间的，然后看看同学们有没有什么问题想要问的。

因为我觉得我一口气其实讲了很多，讲了不少内容呃，为什么为什么出现了两次best model shift，应该是出现了一个bug，为什么会出现一直一直在safe，同学们有没有看出来是。

为什么一直在safe这个模型呢，有没有同学可以找出来我这个模型里啊，我这个代码里有什么bug，如果没有的话，我可以直接看一下，这里我怀疑我是不是一直在loss没有加进列表，对lost没有加进列表。

所以我要把这是一个bug，但是这个VLOSSES点end will loss，但是这样也不应该出这个bug吧，是不是我在哪个地方把I给改了三，可能这个100太慢了吧，嗯anyway。

但这个模型基本上应该开始训练，我把这些数字再调小一点，我这里比如说三这边是五吧，然后我们看这样有没有什么问题，我稍微多打一点信息啊，就是epoch，epoch是epoch，Iteration。

这样就可以了，再把这个I应该没有什么问题，现在看起来I哦对，非常感谢，就这个地方应该是等于零，就是非常感谢同学们告诉我这个bug，这个非常尴尬啊，这样应该应该这个模型就到这里，没有什么问题了。

然后你就看到会呃某一些位置要保存一下，他有best model safe，有的时候又没有safe，然后没有safe的话呢，它的learning rate应该就decay了。

你是不是可以这里写一个print learning rate decay，然后当你训练完这样一个模型之后呢，下一步就是我们我们之前说的呃，啊我我讲完了这个呃，讲完了保存模型。

还没有讲怎么样把模型漏的回来，这个low的模型的方法就是，load模型的方法是我们一般会这样做，就是你首先建一个模型，best model等于ann model。

看一下他一直没有learning with decay嘛，说明validation loss可能还是在降吧，其实我应该把这个validation loss给print出来。

就是我们可以print a validation loss，Validation loss，然后把这个well loss也给打出来，这个well loss应该是一个数字，算了，我要重新训练一把。

然后我我讲怎么样把一个模型读回来呢，就是如果要把一个模型的参数给load回来，你也是一样的，就是我们前面有这样一个model对吧，我们前面做这个model的时候，是这样定义的一个模型。

我现在可以新建一个模型，叫做best model，就best model跟这个model基本上是一样的，这个best model跟跟那个model几乎没有区别，他嗯也是也是要use code。

但是我现在可以把它best model点load state dict，然后再把它从touch那边load回来，把这个LM啊，我这个LM叫什么名字来着，叫做LM，我的模型叫做LM点PHPH。

你就可以把它在load回来，LOM点PTH，注意这个torch点，load呢，先把这个点拿出来，给大家拿出来看一下这个touch点load，啊sorry，因为刚刚这个这里跑到一半。

我发现其实validation loss没有怎么降下去，但我也不管了，然后我们看这个touch点load呢，它其实会帮你把这个order dict给load回来，你相当于可以把模型的参数全都拿回来。

然后帮你模型的参数拿回来之后呢，你就可以把它load回这个best model里面去，这样你就可以拿到这个best model，然后我们就可以用best model来做1evaluation。

然后这里我就不给大家展示一，evaluate出来之后会是什么样子的，因为这个其实我训练了挺长时间，才训练出了140跟178这两个PLEXITY，我现在呃给到evaluate出来的perplexity。

肯定会非常的差，所以就啊就这样给大家看一下，然后训练好的这些模型呢，你还可以用它来生成一些句子，我这里生成句子的方法是直接拿啊，就是你可以初始化一些HIIT，一个hidden state。

就是直接拿一个batch size，是一的一个hidden state，然后你在啊用它来传到你的这个best model里面，去拿这个best model啊，然后就是你用它来生成之后。

最后再一个一个生成，每生成一个hidden state之后，你给他给他传到那个啊outputs的这个shape上面，就这是vocabulary size。

然后你用motorial sampling来sample1些单词，就相当于我如果给你一个vector，告诉你这个单词有多大的概率，就其实这里你可以用MULTINOMIAL，你也可以用啊。

GRADY的方法，就GRADY的方法就是用arg max来卖，来sample那个啊，你的sample里的那个logic最高的位置，来预测下一个单词，然后就这样就可以产生一些嗯。

还算比较reasonable的句子，啊其实这节课讲的有点长，然后我后面其实还还还想再讲一些内容，我们要不简单的休息5分钟，然后我回来再看20分钟，我们能讲多少，讲多少，perplexity是越小越好。

嗯我就在这边跟大家一边答疑，一边说吧，我们休息，同学们可以简单休息五到10分钟，然后我们马上就呃休息休息5分钟，我们就继续加，有同学问这个BPTT是干什么用的，没有太懂，我给大家稍微解释一下。

就是同学们如果看我这篇文章，我如果这里随便打一个，打开一个text8点def点TXT呢，你会看到这个文章其实很长对吧，它其实只有一行，然后这一行到底有有很多单词，我们可以看一下word count。

应该有我不知道这是100个，就是应该这是这么多个character，然后呢你有这么多单词，但是嗯但是我们自己在训练的时候，我不能一把直接训练，比如一起，比如100万个单词，我只能每次只能拿50个单词。

50个单词这样训练，所以这个BPTT就是拿50个单词出来，你每次训练这个语言模型的时候，只拿50个单词训练，就是这个是BP t t length这样的事情。

它的英文名字叫做back propagation through time，这个time就是它每一个单词叫做一个time step，所以才叫BPTT这个东西，对就是他给你切过长没有错。

然后有同学说这个time step是可以自己设定的吗，呃我不知道同学指的这个time step，是不是BP t t length，如果你指的是BP t t length的话，就是他在拍torch啊。

他在这个torch text里面，就你有一个参数是可以设定这个BPTTLE，但很多时候我自己写代码，其实我不太用torch text，就是它并没有帮你完成太多的功能，而且没有特别flexible。

所以有时候我会自己写，可能我们后面的这个项目也会里面会自己写，就其实上面其实你自己构建一个dictionary，并不是很复杂，就是我们上一节课讲那个wording ebedding的时候。

那个dictionary就是自己造的，其实你只需要很简单的几个功能，一个是呃，一个是build一个vocabulary，一个是把每一个单词变成变成一个index。

对就很多时候自己手写一个data loader，可能也会更加flexible一点，OK有同学说想看一看这个生成句子，这个地方我们可以一起简单的看一看，这里的模型在做什么事情啊，哦这里的代码在做什么事情。

你看他呃，首先这个hidden是生成了一个零的hidden，然后这个它的第一个单词呢，它其实是random int，就是他随机拿到一个，先随机拿到一个呃数字作为你这个文章的开头。

然后后面呢你就开始做传进这个模型，然后你把它放到这个best model，然后你注意你进去的是一个单词，所以它出来的也是一个单词，然后这个单词呢再把它这个word waits。

应该是一个5万02维的这样的一个一个vector，然后这里有一个5万02维的这样的一个vector，之后呢，然后你做一个multinomial sampling，拿到一个单词的index。

然后你再把这个单词的index，fill到这个input里面去，这input是我们刚刚讲这个随机生成的一个东西，然后这个input你拿回去之后呢，再把它变成我们的啊，再再回到这个循环里面去。

再生成下一个单词，所以你其实是一个单词，一个单词都在生成，然后有同学问这个output，The squeeze，Squeeze，其实是把那些所有维度为一的维度全都给扔掉，就比如说你有一个100×1。

乘以一的一个tensor，它就会变成一个100维的tensor，就把那个一跟一跟掉了，好我感觉我们就呃这个部分我们先讲到这里，然后我接着往下讲后面的内容，后面我们是想给大家讲，文本分类的一些问题。

然后我们先想一下文本分类是个什么，什么问题呢，有没有，我觉得这节课可能只能把这个slides，给过一遍了，就是文本分类他啊，我们可以可以有这样一些功能，就比如说啊识别垃圾邮件啊，比如说情感分类啊。

给你一段文字，它是正向的情感还是负面的情感，Sorry，我看到同学们又有一个问题，我再回答一下，然后最后再确认一下，当然没有问题，我再说这里为什么要加EXP，这个是因为，呃其实同学们可以试一试。

如果你不加EXP可不可以，因为我怀疑跟这个torch点，MTOMIAL有一定的关系，我们看一下MTOMIAL具体干了一件什么事情，Touch the multinomial，还是告诉你说。

Returns a tensor with a rock，And taste number of samples from a multinomial，Probability。

Distribution located in the corresponding row of，就我我我的我的猜想啊，就是这个我也我也不太确定，就是他这个位置可能必须要是，啊应该没有什么关系。

我觉得他这个EXP只是为了让让一些LOGIES，大的概率更大，让LOGIST小的概率更小，就是让他整个分布更加极端一点，我的我的感觉是这样的，因为比如说你是一和二的话。

那其实一和二相当于一个是1/3的概率，一个是1/2的概率，但如果是E和ex平方的话，可能概率的相差会选更悬殊一点，对就是同学说的没错，就跟soft max应该是一个一个道理。

然后range100中有同学问output是啥，这个output其实是啊，我们我们还记得刚刚我们定义这个模型的时候，这个hidden是当前的hidden state。

这个output是你输出的输出的单词，在vocabulary size上面的log，等于说它是一个5万02维的这样的一个向量，所以同学们可以啊，我还是自己print一下。

就print output shape，你们就知道了，这里为什么会不行呢，这是因为object of fd CPU，But got back ka for argument index。

这是因为我的hidden没有，应该是有些东西没有哭的，我看一下，我是因为hidden点现在是一个COA吗，应该是因为这个hidden没有变成哭的，但是为什么呢，best model应该在KA上才对啊。

哦这里是因为我这里best model忘了放到best model，点code上去，这样就没有问题，然后我再把它拿过来，然后就看到它其实就是一个5万02维的向量。

然后它其实就是在5万5万02维的向量上面，拿那个啊，取这个取取这个MTONIAL，Sampling，Mtonial，就是你有你这个logic越大的话，它被sample到的概率越大。

你可以把它改成一个arg max之类一样的东西，就是你如果做这个arg max也会出现类似的效果，当然这里的八个max是touch max，还有没有什么问题啊。

同学们就它的一个基本套路就是run forward pass，然后这个是相当于同学说的soft max，就是把这个LOGIES给他做一个exp，然后这里是multinomial sampling。

拿到你一个单词，然后这个是嗯，Though in the current，Predicted wor to the current input，然后你用这个current input。

再预测下一个input就可以了，那这样这样OK的吧，就是如果同学们没有什么问题，我就接着讲后面的后面的slides，好那我们继续讲后面slice就是这个文本分类，主要是有一些主要的这个任务其实非常简单。

就是给你一句话或者一段话，然后让你把它分个类，有一个同学啊算了，我就还是有同学继续提问，我就继续把它再讲清楚一点，有同学说为什么这里要做MTOMIAL，其实你不一定要做MULTINOMIAL。

就是这个同学他的意思是说，有一个同学说直接soft max换成生成的字不就行了，那同学这位同学问的问题是说，直接用它来生成字，那你还是有一个问题，你要生成哪个字呢，你是要生成阿格max。

因为soft max给你的是一个概率分布对吧，那你返回的，你是不是想返回一个概率最大的那个单词呢，就这样，当然是可以的，就是你直接拿那个arg max也可以出一个结果。

但是大家有时候也经常会做个multi omial sampling，因为有时候阿戈麦斯给你返回的并不是最好的，那个句子，应该来说这个arg max的方法。

给你返回的是一个deterministic的句子，就是你生成的句子是每次生成的都是一样的，我如果这里用的是arg max的话呢，你每次生成的句子都是同一个句子。

但是你用这个用我们的这个sampling的方法，你每次拿到的句子是不一样的，就这个是这个是为什么要用arg max，然后有同学说soft max以后不是要取最大值的吗，呃这个其实是随便。

你的soft max跟阿max没有任何关系，就是soft max只是给了你一个概率分布而已，后面你想做什么事情是你自己决定的，就这个是呃这两个事情是独立的。

并不是说你soft max之后一定要带一个阿max，只是人们经常在后面做一个arg max，然后我们可以想象文本的生成，你其实是希望比较比较那个呃random一点，就是它能够随机帮你生成一些句子。

但是如果啊如果你是做翻译之类的任务，就经常容易用arg max或者beam search之类的方法，就是它是比较deterministic的，你不希望每次翻译出来的句子都不一样对吧，就是说给我一个句子。

我希望翻译出来就是一个相应的句子，所以这个是为什么，同学们可能会认为soft max后面总是会跟一个阿max，因为我们经常会做这件事情好的，那这样我就继续回到这个呃文本分类的问题。

然后我们讲到这个文本分类，其实它本质上也是一个模型预测和学习的过程，就是我给你一个给你一个句子，给你一个句子，我我我的目标是啊，用这个分类器把它做一个分类，那在文本分类上面呢，我们介绍几个常用的模型嗯。

如果如果我给你一个句子，你要给它分成几个类，比如说是情感分类分成是正的还是负的，那有一个非常简单，但是非常robust的模型叫做word average。

这个这个模型不是不是最简单的word average，它是word average，后面加了两层神经网络，两层这个前向神经网络造的这个文本分类器，就是这个基本的思路，其实就是把每个单词都变成一个词向量。

就这里的每一个单词都变成了一个向量，然后给他求个平均，然后再过两次neural network，然后最后再比如说这是个二分类问题，那就是一个binary cross entropy loss。

训练出来的一个一个模型，所以这个模型非常的简单，但是非常的高效，在情感分类里面，就是把每个单词拿到一个词向量，然后算一个平均，然后你再用这个平均的向量来做后面的这个，一个线性分类。

做一个做一个分类的过程，这个是文本分类啊，这个是word average的模型，然后呢我们已经知道，其实常用的做这个文本分类的套路啊，都是你要想办法拿到一个句子的vector。

就这个句子是由若干个单词组成的，然后如果你能把每个词向量有机的组合在一起，无论你是word average还是任何别的，你想你能想到的那些嗯函数，把这些单词拼单词的词向量拼到一起，变成一个句子的向量。

然后这个句子的向量你再做一个线性变换，你就可以做一做一个分类的问题，那我们刚刚学到了，你用一个神经网络啊，用一个recurrent neural network，也可以很好的encode这个句子。

然后我们常用的一些做法呢，就是比如说你可以把这个句子跑一个双向，神经网络，其实我还没有讲过双向recurrent neural network，但大家应该可以想象，就是你有一个前向的I。

有一个反向的recurrent neural network，然后你把这个前向的跟反向的拼到一起，然后这样你就可以拿到每一个单词的，Contextualized word embedding。

就是它包括了他的context这样的一个embedding，然后这个embedding你在想办法做一些啊，还有这个堆叠神经网络，其实就是跑若干层神经网络，也能拿到一个hidden state。

然后这些hidden state，你又可以把它当word average来处理，就当你拿到了Y1Y2Y三，一直到YT，你再套到这个模型里面去做一个word average，又可以拿到一个一个分类器啊。

当然人们之前也做过很多不同的实验，就是你可以跑一个单向的神经网络啊，你可以跑一个单向的这个recurrent neural network，然后拿最后一个hidden state y t。

我还在大写的T来当做你这个句子的表示，然后你用这个vector来做预测，也能做出一个比较好的效果，因为这个YT你看这张图就会发现，它其实包含了从X1到XT所有的信息，它唯一的缺点就是。

它比较容易拿到XT附近单词的信息，前面的很多单词的信息，它其实比较容易忘掉，因为因为隔得太远了，所以很多时候大家其实经常做的是，跑一个双向recovery unetwork，然后给他求个平均之类的。

这个平均也叫做average pooling，对吧嗯，然后后面CNN的作文本分类，我先这节课先不讲，我们先快速稍微简单的讲一下，这个sentiment analysis的这个代码。

可能只能讲一讲这个预处理，然后在这节课里面呢，我们会讲嗯，用这个IMDB的数据集，就是IMDB是一堆电影的评论，电影的评论有正的有负的，然后我们就是把这个电影的评论拿出来，做一个文本分类的过程。

然后为了准备这个数据呢，我们还是用啊，我们还是用这个torch text来帮我们做这个事情，这里唯一的区别是我现在的啊，我要就是我对他的field传了一个token，相当于是个分词的过程。

然后其实英文的分词是比较简单的，因为英文里面它空格就表示单词的分隔符，但是还是有一些比较tricky的地方，就比如说一个单词跟最后的句号，往往是连在一起的，他们中间没有空格隔开。

但是啊如果你只用空格当分隔符就分不出来，然后就有一些比较好的TOIZER，比如说SPACY就是一个包啊，同学们可以用pastors base来装这个库，然后把这个ENGLISH的model给装下来。

然后就可以帮你做ENGLISHTOIZATION，然后还有一个特别的field叫做label field，就表示这个句子是哪一个类型啊，好然后我们拿进来之后呢，下一步是这个IMDB的数据集。

是由torch text直接提供的，所以你其实只要用DATASETSIMDB点spit，所以用torch text，很多时候可以比较简单的做这些事情，就是能够很迅速的拿到一些简单的数据集，来做实验。

嗯然后后面我们看一下一共有多少个training data，有多少个test data，然后我们可以看一个看一个training example，这里是我之前跑出来的，就是它其实大致就长这个样子。

我们看下这个training example，他就告诉你什么brilliant adaptation of the novel that。

什么famous relatives of children pgm，就其实你看了前几个单词，你就知道这个评论还是比较好的，他说brilliant adaptation。

所以后面他的label是一个positive的example，然后呃他这个数据集默认给你的是一个，training和test validation，然后我想把train再翻译下。

分成这个train validation跟contest，所以我再把它分分一个类，这个也是嗯你可以直接split，然后按照按照某一个呃ratio来分类，它默认的分类方法是七三分，就是七时30分。

然后我们可以看一下现在你能拿到多少东西，然后后面后面也是一样的，就非常抱歉，这段代码跑的比较慢，因为它其实我也不知道他为什么跑的很慢，但是就是有点慢，然后后面我们就还是迅速回顾啊。

就是上一段上半节课我们讲过，你要你要从这个training data里面去build，这个vocabulary，然后max size，我这里设了2万5，然后这里还有一个特别的参数vectors。

我把它定成是glove，6b100 d，这是什么意思呢，就是glove是一个预训练的词向量，然后我现在等于说，我是要把这个单词的词向量也带进来，因为这个词向量在很多时候非常有用，就是预训练的这些词向量。

可以帮助你训练的速度收敛快很多，所以我在这里把它啊，把GLOCK的这个100维的向量给拿进来，glove是一个比较好的词向量，然后我们就看到这里有2万5000多个单词啊。

好那现在这样数据都数据都漏的进来了，然后你有这个vocabulary，I two x i t s u s t i，然后我们再把它全都变成iterator。

这里的iterator我们用一个什么什么iterator呢，用一个bucket iterator啊，这个bucket iterator可以把嗯，bucket iteration干的是什么事情呢。

它其实是把一些长度差不多的句子，都放到同一个batch当中，确保每一个batch不会出现太多的padding，什么意思呢，因为我这里有很多电影的评论，电影的评论有长有短。

然后我希望一个batch里面的句子尽量差不多长，就是太长的跟太短的句子不要在一起，因为我们知道最终你这个单词进来之后，最终你这些text进来之后，它会变成一个sequence。

LN乘以batch size的一个一个tensor，然后如果你这个单，如果你这个句子有100个单词长度的，有1000个单词长度的，那对于那100个单词来说，它后面的900个单词全都是padding。

这样就会对你的模型的效果不太好啊，所以我们希望这个padding越少越好，然后在写这个为了简单处理啊，我们这节课写这个模型的时候，我不会把这些padding处理掉，这些padding。

我也直接当做模型的输入给输入进去了，嗯然后我感觉时间可能有点不太够了，我想就基本上就在这里结束了，然后我把我会把这个，我会把这个notebook也传到群里面，然后同学们可以自己花点时间学习一下。

然后下一节课我们可能会非常快的讲讲一遍，这个下面的这些模型，其实最关键的是最关键的是这个CNN模型，因为RNN跟这个word average，我相信同学们理解起来都不困难。

所以我们下节课主要是讲CN模型，然后我们会开始跟大家讲一些图像的，图像的一些问题，然后有同学问说，用bucket的话会不会打乱顺序，就bucket确实打乱顺序，就是但是同学们注意在我的这个任务里面。

顺序是不重要的，因为我只有我的，我的所有的数据都是一段电影评论加一个label，一段电影评论加一个label，就是这个顺序你打乱了，其实没有关系，就是本来是第一个出现的example。

你现在第一个位置出现，它还是出现了，那就没有关系，就这不是一个语言语言模型的训练问题，所以顺序是没有关系的，然后同学们还有什么问题，就我见我，我是想把这个传到群里面，然后同学们看一看呃。

用torch text load这些text，然后熟悉一下这个单词的熟悉，熟悉一下这些输入输出向量是长什么样子，然后下一节课我们再把模型给打一遍就可以了，哦这个要不我们这节课就先到这里了。

然后同学们可以提几个问题，有同学说顺序重要的时候用CN效果不好，不是的，就是呃同学们可能理解错我的意思了，这个bucket iterator，并不是说你把一句话里面的单词打乱了。

而是如果我现在有1000句话，并不是把并不是把一个一个instance，里面的任何句子给打乱了，他是一段评论里面，比如说有五个句子，然后我现在有1000段评论，我把这个1000段评论分成bucket。

每一段评论里面的句子，还是按照原来的顺序来排的，并没有打乱他的顺序，然后再有同学说，如果分类的时候除了文本，还有一个特征是数字，怎么将这个特征一起加进去，嗯这个我觉得有很多方法可以处理啊。

就是比如说我们我们刚刚讲的word average，是不是可以把一段文本给你一个向量，然后你如果还有一个数字的话，你完全可以把这个数字concatenate到你，你拿到的这个文本向量上面去。

就word average是一个向量，然后再加上你想要加的数字，你可以一起把它拼成一个向量，然后再做后面的这些线性分线性转换，然后有同学问word average，是将各个词向量对应维度相加平均吗。

没错就是这个同学说的没错，就是把各个维度都做一个相加的平均，然后有同学问顺序，重要的时候用CN效果不好啊，这个问题我想等下一节课再回答，但我认为你说的基本上是对的，就是因为CN很难capture到。

很长的这个单词的关系，然后有同学说，word average是将词相对应维度三线啊，这个这个已经回答过了，就不再继续回答，你这边还有什么问题吗，如果没有的话，那我们这节课就讲到这里。

然后我们有什么问题可以在群里面继续交流。

那就这样了。

【七月】NLP高端就业小班10期 - P3：3.基于CNN的文本分类_ev - 不看兵法的数据分析师 - BV1BC4y1C7E5

好刚好啊，对于昨天的课程，各位同学有没有什么疑问的，现在可以提一下，我们在开课之前先简单做个答疑，看昨天的内容，各位同学有没有什么疑问，有问题吗，各位同学，都没什么问题是吧，好行吧。

那我们就继续开始今天的内容吧。

好啊，今天的内容是，这个我们是使用卷积神经网络来处理，咱们的这个NLP的一个问题啊，好我们简单看一下今天的几部分内容啊。

今天四个部分内容啊，首先第一部分的话，是要把昨天我们这个没有讲完的，这个transformer那个部分咱们再讲一下啊，把剩余的一部分给补充完，然后第二点的话是啊，这边之前额外加了一点内容啊。

就是很多同学会来问啊，就是说啊如何去阅读这样的一个论文啊，这边的话我也给简单的给一下，自己的一些建议啊，而第三点的话就是啊，进入我们今天的一个重点啊，就关于卷积卷积神经网络这一块。

就包括什么是卷积神经网络，然后在这个咱们LP当中，如何去运用这个连接神经网络，好吧，这就是咱们今天的一个内容啊，好那我们就先进入我们的这个第一部分啊，关于这个transformer的这个补充啊。

对于昨天这个刚才有同学可能还没进直播间啊，我简单提一下，就对于昨天上课的一个内容，如果还有疑问的地方，现在可以提出来好吧，我们可以解决解决一下啊，好，那我们来看今天的这个transformer。

这一块的内容啊，昨天讲到了这个嗯，Mari head，腾讯这一块对吧，Mari head，腾讯这一块好，那接下来我们就来看一下啊，他的这个transformer当中的其他的一些结构。

OK我们把这个encoder部分单独拿出来，看一下，这个self attention这一块呢是我们昨天已经讲过的，在接下来的一个结构当中可以先看一下啊，首先呢是这一个部分，它这里有一个X加上Z。

这个Z的话，就是经过我们这个self attention得到之后的一个，结果对吧，那这个X是什么呢，X是我们一开始这个输入的这样的一个值啊，X是我们输入的这个值，那如果是第一层，第一层。

那就是我们的这个文本的这个，embedding的一个结果对吧，那如果是后面的层，那这个表示的就是每一层这个encoder，输出的一个结果好吧，因为咱们的这个transformer啊。

它通常都是有多层的这个decoder啊，这个decoder它是这样子的，多层的它是多层的，第一第二第三它是多层的啊，对于第一层的话，传给第一层的是咱们这个embedding，那传给咱们第二层的。

其实就是第一层的一个输出对吧，所以这里是个X啊，如果是第一层就是embedding，第二层的话就是上一层传递过来的一个结果，那这里可以看到啊，他是用这里这个X加上了这里这个Z，那这样的一个操作呢。

就被称为这个所谓的残差模块啊，残差模块对应到咱们的这个图当中啊，就是这个位置啊，ADD ADD好，那做完这一步呢，他会做这个layer normalization，Layonalization。

这个LAYONALIZATION又是什么东西呢，它其实就是在做一个所谓的一个规划规划，那这两步呢通常都会啊放在一起啊，就被称为这个AD and NO，OK那经过这两步之后呢。

就会拿到我们这样的一个输出结果对吧，输出结果呢给到我们这个fateful world层，那feed forward层，昨天和大家说过了，这个实际上就是可以简单的看成，就是这样的一个全连接层，全连接层好。

那经过这个全连接层之后呢，又继续给到了这样的一个ADAMN，也就是刚才这里说的这个残障模块，和这个没有MALIZATION，那整体的这个encoder的一个结构就是这个样子。

那最终呢实际上就是多层的这样的一个encoder，堆叠在一起，那具体你要去堆叠多少层，就看你自己的一个选择了好吧，那像我们自己啊，比较常用的这个预训练的语言模型，BERT这个模型。

它实际上就是这个encoder堆叠了12层好吧，12层就搞了12个这样的一个encoder，堆叠在一起啊，堆叠在一起，这个大家需要注意一下啊，BT这个模型是transformer encoder部分。

好吧，它只包括encoder部分，这里很重要啊，好这是我们内部的一个结构，好，接下来我们就详细看一下这里的这个啊，残差模块，还有这里这个LEONALIZATION。

那后面的这个fateful world我就不说了好吧，全连接层这个相信各位同学都很清楚了啊，嗯好那我们就先来看这个残差模块啊，那通常上来说呢，我们再去训练一个模型的时候，理论上来说网络的这个越深的话。

理论上来说，它能提取的这个特征应该是会更强一些对吧，而且模型如果越深，它能承载的这样的一些特征值就越多，但是啊啊在之前的一些实验当中，特别是在对这个RESNET做一些实验的时候，大家发现一个问题啊。

当这个网络变得特别深的时候，它会容易出现一些所谓的退化问题，退化问题我们可以看一下下面这个图啊，对于左边这个图啊，纵坐标是一个训练集的这个错误率啊，可以看一下，对于这个20层的这样的一个网络结构来说。

它反而错误率会低一些，56层的反而高一些啊，可以看到20层的第一集对吧，要在验证这个测试机也是一样啊，20层的这个测这个错误率会稍微低一点，56层的错误率会更高一点。

就感觉和我们的这个常识好像是有违背的对吧，理论上来说你越深效果越好啊，那这就是所谓的一个退化问题啊，那为了去解决这个退化问题呢，就有就有提出了这个残差网络，残差网络。

那为什么会出现这种所谓的一个退化问题呢，其实这个东西啊就可以啊，我们可以回忆一下，昨天我们讲RN的时候，其实当我们去做一个很长的一个，序列的特征提取的时候，那他很容易出现一些所谓的一些。

类似梯度消失的一些问题对吧，那你梯度如果发生了消失，那你有些层其实更新的就不好对吧，你参数更新的就不好，那你模型其实收敛的效果就会变差，那这个其实就是所谓的一个退化问题啊。

那残差网络它是怎么解决这个问题呢，我们来看一下啊，残差的主要的核心思想，就是让训练变得更加简单，这个大家需要注意啊，就是让训练变得更加简单，我们可以看一下下面这个图，首先呢我这边输入的是一个X。

然后经过了这样的一层，然后再经过一个real这样的一个计划函数，然后又经过了一层这样的一个神经网络，最后进行一个输出，那正常情况来说的话，我们就是输出我们的FX对吧，我们把FX进行输出。

那残差它是怎么做的呢，他会把我一开始的一个输入啊，再给他一条捷径这样的一条捷径，同时把我们的输入给到输出的位置，把输入和输出进行这样的一个相加的一个处理，相加的一个处理，那为什么要这样子做呢。

我们其实可以考虑一下啊，假如我们现在输入的这个X的值它是十，假如输入的是十，X等于十，那我经过一系列的网络之后呢，那他这个差值实际上就是0。10。1带，我们去求解，这个也就是说我们的一个输入和输出。

其实相差的是特别小的，相差的特别小的，这个时候我们来求这个梯度的时候，实际上就很容易出现一些梯度过小的一些情况，从而类似于梯度消失的情况发生，那如果我们把原来的一个输入，和咱们的一个输出都合并在一起。

最终就变成了这样的一个20。1对吧，就变成了这样的一个啊20。1的情况，20。1，那我们这个时候的差值实际上就变成了十对吧，那这个时候我们再来求梯度的时候，就会更大一些啊，所以说残差的一个思想。

就是说我会给你一条捷径，给你一条捷径，并且啊在我进行反向传播的时候，我也可以走这一条捷径，去求解它的这样的一个梯度，好吧，就以这样的一个思想啊，来控制我们这样的一个梯度，不要让它变得太小。

出现这种所谓梯度消失的一个情况啊，这就是我们的一个残差模块啊，残差模块那应用到我们的这个transformer当中，也是一样的道理啊，那我经过了这个cf attention之后呢。

我希望你这个收敛的时候啊，这个梯度回传的时候更顺畅一些对吧，所以呢这里就添加了这样一个残差模块啊，残差模块，OK那残差模块之后呢，又添加了一层这个LEONALIZATION。

这个时候可能各位同学开始以后，这个LEMALIZATION它又是干什么的，好我们来看一下啊，在说LEOMALIZATION之前呢，我们先来说这个normalization好吧。

Normalization，normalization的话，它其实有很多种，但是它们都有一个共同的目的，就是把输入转化成均值为零，方差为一的这样的一个数据，均值为零，均值为零，方差为一，均值为零。

方差为一，所以说我们实际上就是要把数据送入激活函数，之前呢，进行这样的一个规划，大家可以考虑一下啊，那假如我不去做这样的一个归一化的一些处理，我直接给到后面的一些层，那假如我现在不做过优化处理对吧。

我们都知道我们在上节课去讲那个呃SIGMOID，还有tech的时候，我们都会发现一个问题啊，他的这个梯度一旦这个值太大或者太小的时候，就会容易出现一些所谓的一个梯度消失的情况，对吧。

就看就像下面下面这个图，就是SIGMOID的这个激活函数，右边的话，这个是TX的一个激活函数，的梯度的这样的一个图，当你这个值稍微大一点点对吧，就容易出现一些梯度消失，或者说梯度爆炸的情况。

那这个时候啊，我们就可以考虑去做一个所谓的规划，做完归一化之后呢，我们让它的均值为零，方差为一对吧，那最终它的这个值就会聚集在这个这个区间内，聚集在这个区间内对吧，这边也是啊，聚集在这个区间内。

那这个区间内的一个值，你去求解它的这个梯度的时候，可以看一下，这些梯度其实就很大了对吧，这个梯度很大，这图梯度很大啊，梯度很大，就不容易出现所谓的一个梯度消失的，一个问题啊。

啊这就是LEONALIZATION的一个作用，那LEONALIZATION呢比较常见的是两种啊，一种是这个BATIONALIZATION，那这个batch normalization。

是在每一个batch上面去进行，这样的一个normalization的，是什么意思呢，这个同学可能也有同学啊，这个在beach这个维度上面去做什么意思呢，好我们这么看啊，我们这么看，那假如我现在好。

我们先从这个机器学习的一个角度来理解啊，从机器学习的一个角度来理解，假如我现在有一条样本，这个样本呢它包括了很多的一个特征，好吧，我假设我用X来表示特征，它可能有X1X2X3X4，还有四个特征啊。

还有这四个特征，这是第一条样本，这是第一条样本，那对于第二条样本来说，它也会有对应的X1这个特征，X2X3X四好，我用二再加个商标了啊，这是一，好它是这个样子的啊，那这个样子。

那如果是对于第三条样本的话，也是类似啊，也是LH，也是类似那个BALIZATION，他去做这个LEONALIZATION的时候，他是怎么做的，他是在换个颜色的笔，他是在这个维度上面去做啊。

他是在这个维度上面去做，所谓的一个归一化这个维度去做，这就是我们的，Realization，那对于LAMALIZATION它是怎么走的，Lu normalization，它是在这个维度上面做的。

但是在这个维度上面做的话，好那可能有些同学就会问，那为什么我们的这个处理文本的时候，我们要去使用这种LEONALIZATION，那我处理文本为什么不能用RELATIONALIZE，我们考虑一下啊。

那假如我们现在是两条文本，那对于第一条文本来说，对于第一条文本来说，它可能长度这里是四，那对于第二条文本，假如它的长度是五，那我们就需要在这个啊把这条这两条文本啊，进行这样所谓的一个补偿的一个处理。

也就是说我需要把我的这些输入的数据的长度，做成统一的，假如啊，我设置了一个叫做序列最大程度的一个参数，这个参数呢假如我设的是五，假如设的是五，那对于长度比较短的。

那第一条文本我们就需要在它的结尾进行补的，然后这个如果是五的话，那就是X5补零好，如果补了零，我们看一下啊，如果我在这个维度去做这个BALIZATION，你看是不是有问题了对吧。

你明显我在这个维度去做这个国际化，肯定是有问题的，因为你这里是零，还有其他位，那其他序列可能这个位置也是零，所以就导致会出现这样的一些问题啊，出现问题，所以啊在文本上面。

我需要去做这样的一个LEONALIZATION，在它的这个维度啊，就是绿色，绿色这个框的这个维度来做这样的一个没，我们来这事，好吧好，我们先啊，接下来我们来看一下啊。

他的这个BALIZATION和这个LEONALIZATION，它的一个计算是什么样子的啊，那这对于正常的一个规划来说，它实际上啊就是咱们的一个，比如我们有一个X对吧，去减掉这样的一个均值。

再除以这样的一个方差对吧，处于这样的一个方差，这是我们正常的一个啊规划的一个方式啊，那对于BGALIZATION和LEONORMALIZATION，它是怎么做的呢，我们可以看一下啊，它还是一样啊。

这个部分实际上是一样的对吧，这个部分是一样的，可以看一下啊，这个也是这个部分是一样的，但是除了这个部分呢，他这里多了个PC，还有外面有两个参数，一个阿尔法，一个贝塔，那这个是干嘛的呢。

他就是为了怕你的这个分母是零，所以呢通常会添加一个这样的一个app，它是一个非常小的数啊，接近于趋近于零的这样的一个数，你可以设一个十的八次方啊之类的，这样一个特别小的一个数就OK了。

关键是在于这里的阿尔法和这里这个贝塔，那这两个东西呢，实际上是两个可以训练出来的一个权重啊，大家其实就可以很简单的把它理解为，我这里先做了一个普通的一个规划，然后给到了一层这样的全连接层。

其实全连接层也是这样的一个权重，后面一个偏移向对吧，分别对应的就是咱们的阿尔法，和这样的一个贝塔好，那这里可能有同学又会有疑问了，你这里啊我去做这个规划的，是时候啊，先把这个均值给减了。

要除以这样的一个方差，结果呢你这里又成了一个东西，就感觉好像这个东西这个阿尔法对吧，和这一项相乘，那如果这个阿尔法就是他的这样的一个方差，那相乘之后是不是就约了。

然后如果贝塔和这里这个你如果又是相等的话，那这里相加是不是也约了，那这个时候实际上就变回了原来的这样的，一个结果对吧，就变回了原来的一个结果诶，那为什么还要乘以这样的一个阿尔法和贝塔呢，关键原因就在于。

如果我们只去做这样的一个归一化啊，就会把模型之前学习到的这样的一个，数据分布给重新打乱，那可能我之前的一个模型对吧，已经学习就我前面的这些模型啊，我现在有这样的一个encoder部分对吧。

好我用用model是吧，model我现在有一个model，我这一部分已经学的很好了，已经学出了某个这样的一个分布，但这个分布呢，你如果直接去做这样的一个规划对吧，他这个分布就会被你强行打乱。

那这个时候呢，我们就可以考虑加两个参数进来啊，一个阿尔法，一个贝塔，再把它学习到的这个分布给拉回来好吧，给拉回来，这虽然我归一化了，但是我的这个分布是没有变化的，就是这样的一个意思啊，就是这样的意思好。

这就是我们的这个LEONALIZATION，好吧，OK啊我们这里先停一下啊，对于这里的LEONALIZATION，还有咱们的一个残差模块，看看各位同学有没有什么疑问的，有问题吗，各位同学，有问题吗。

各位同学，两种我们normalization可以同时用吗，一般用一种就好了，因为实际上你只是为了去把它这个规划之后，然后防止它出现这种所谓的梯度消失的情况，对吧，所以你任选其一就行了，没有必要两种都用。

你两种都用的话，实际上就等同于你做了两次归一化，这个实际上是没有意义的啊，没有意义的，好其他同学还有问题吗，好OK那我们就继续往下了啊，大家有问题及时提出来啊。

那transformer的一个encoder，基本上就给大家讲完了，讲完了，然后大家自己下来的时候呢，可以自己去找张纸，然后去画一下它整体的一个结构，到底是什么样子的好吧，自己去画一下。

把整体结构画一下，包括他的excel tention，它内部是怎么计算的，你要把它全部写出来啊，全部写出来，transformer是这个面试当中必问的好吧，必问的参数A和B是不是随机初始化的啊。

对一般的话是就是你随机初始化就OK了啊，随机初始化就OK了，但是对于一些特定的一些模型，它可能会有一些特殊的一些初始化的一些方法，好吧，这个得看具体的一些模型，像BERT的话。

它可能有具体自己的这样的一套，这样的一个初始化的一个方式，好吧啊，每个位置后面补的零会对模型有影响吗，这个是不会有影响的啊，这个好，这个我简单说一下啊，这个可能有些同学还不清楚嗯，我看找一页空一点的好。

简单说一下啊，是这样子啊，我们一般处理文本的时候啊，因为序列长度不一样嘛，那可能有的长度假如是四，有的长度是五，有的长度是十，假如说989，那这个时候呢我们首先第一步啊，回去做一个序列，长度统一统一啊。

那假如我们设置的这个啊max lx等于五，这时候对于四这样的一个序列，我们就不零，那对于九这样的一个序列，我们就会把它的末尾啊，末尾的四个词给直接给舍弃，只保留前面五个字，就我X1X二一直到X9。

我会把后面这些词全部直接舍去啊，只留X1到X1，就是这样的一个情况啊，就是这样的一个情况，那五零的话是不会有不会有这个影响的，不会有影响的，为什么会不会有影响的，是这样子啊，当我们补零的时候。

因为我们在给到我们模型的时候，去计算这个attention的时候，大家啊如果去看过这个BT的源码的时候，你会发现它其实有一个东西叫做attention mask。

叫做attention attention mask，那这个东西是什么意思呢，就是说假如我现在有一条序列啊，X1假如一直到X5，那那假如我现在序列长度是十，那我就会在这里补五个零对吧，补补个零。

他这个attention mask它就是什么样子，它就是111111，前面是五个一，后面是零，然后当我来计算这个attention的时候，就是我们计算这个Q和K进行相乘，然后除以根号DK的时候。

那我们这里这个D和K会进行相乘嘛，对吧，他这里就会把这个东西给引入进来，那我的那个矩阵啊，我的这个矩阵，那对于后面的这些位置啊，后面的这些位置就这些位置可能是零对吧，这些位置是零。

他就会把这些地方全部置为零，这些地方值为零，所以说啊你即使后面补零，也是不会有影响的好吧，就是在你可以简单的理解为，就是说我在做腾讯的时候，它这些地方的权重是零，只要你不零了，这边就是零好吧。

这位同学我有说明白吗，位置编码好不着急啊不着急啊，这位同学我也说明白了，好好好，我们继续啊，呃位置编码我看一下，我这里有球吗，哎呦位置编码没写啊，好这边简单说一下位置编码，简单说一下位置编码。

位置编码是这样子啊，就是在我们输入给咱们的这个模型的时候啊，就我们输入给模型的时候，那这里大家可以看到啊，这里其实是一个叫做token embedding的那个东西。

也是some的那个what embedding对吧，那实际上呢在我们的transformer当中呢，还会引入一个叫做位置编码这个东西，那为什么需要位置编码呢，啊我们可以考虑一下啊。

对于RN这样的一个模型来说，它是一个这样的一个创新的一个结构对吧，他天生自带所谓的一个位置信息，但是对于我们的transformer来说，我们是一个并行的结构输入进去的对吧。

包括我们在计算我们的self attention的时候，他也是这样的一个矩阵嘛，所以它是一个并行的一个处理，它实际上是没有考虑这样一个，所谓的一个位置信息的，所以呢我们需要把我们的位置信息啊。

给添加进去啊，给添加进去，那在这个transformer当中，它的这个位置信息是怎么做的呢，它实际上是一个正余弦的一个计算，一个公式计算出来的啊，这个可以给大家看一下啊。

有点慢有点慢。

好我这边先回到PPT啊，先回到PPT诶。

好我们待会再看到这里，先说他这里会有一个这样的一个，正余弦的一个公式，来把这个位置信息给计算出来，那计算出来之后呢，这里就等于有两个东西嘛，一个是咱们的一个token in bei。

还有一个是咱们这个position psection in be，他会把这两个东西啊进行一个相加，进行一个相加相加之后的一个结果呢，再给到咱们的相加之后的一个结果，就是这个东西啊，就是这个东西。

然后再给他后面的一个cf，那这个位置编码其实有很多种啊，有相对文字编码，有绝对位置编码，那对于我们的这个transformer。

这个原始的一个模型来说，它是使用这样的一个正余弦的一个方式，啊有点慢啊有点慢好。

我们先给他那边加载着，我们先说后面好吧，我们先说在后面，等那边加载出来啊，啊我们位置编码待会再说啊，我们先继续往下啊，那我们说到这里的话，基本上就把咱们这个transformer的encoder。

这一部分就讲完了对吧，包括他的animal fboard，Mari，Had a tension，就都给大家讲完了好，那接下来我们就来看一下这个decoder，这一部分啊。

decoder这部分引入了一个所谓的MASKET东西啊，我们看一下这个mask到底是干嘛的，OK对于我们的这个decoder来说，我们回顾一下我们昨天的这个sequence，sequence的内容。

那同样是这样sequence sequence的一个模型，那decoder它肯定是这样的一个序列模型嘛对吧，他要不停的把这个值进行一个输出对吧，所以decoder是要生成。

咱们咱们这样的一个新的一个序列的，生成新的一个序列的好，但是transformer我刚才说了也说了一点啊，它是一个什么模型，它是一个并行模型，那如果是一个并行模型来说的话，它就生成序列会有什么问题呢。

我举个例子啊，就假如我现在有这样一句话叫做人工智能对吧，我要把这句话，我要把人工智能这句话给生成出来啊，生成出来，那对于我们的这个RNN来说是怎么做的呢，哎这里输入我们的一个起始符对吧。

然后这边生成咱们的第一个字人，然后呢再把这个人给到我们下一个节点，然后来输出我们的一个弓对吧，他是这样的一个逻辑，但是对于我们的这个transformer来说，它是一个并行的一个模型，并行的模型。

并行的模型，它就不存在这样的一个，按顺序进行输入的一个情况啊，所以说在我们这个解码的过程中，它就会存在一个问题，假如我要生成人工智能，这句话对吧，当我们去做这个self attention的时候。

我们会让这个QK进行相乘，而得到这样的一个attention metrics，那好我们看一下这个attention matrix，如果我们不做任何的一个处理。

我们把这个attention metrics展开，它其实是这个样子的吗，它是它是这个样子的啊，这边是一个即使服务，然后人工智能这边是人工智能都终止服务，我们现在好，我现在要根据这个起始服务人工智能。

然后我们结果想输出人工智能终止服务，这是我们昨天那个讲sequence，sequence这样的一个流程嘛对吧，输入的时候一定要有这样的一个起始符，没问题吧，这里好，OK那接下来我们来看一下啊。

那假如我现在想生成人这个字，在我们RN里面是怎么做，是不是我只是输入了起始符，但是在我们的这个transformer当中，因为是并行的人这个字啊，它实际上是可以拿到所有的。

你看起始伏人工智能这几个词的一个权重的，你看它这里实际上都可以进行相乘嘛，对吧啊，我这里用W表示RW1W2W3W4W五，理论上来说，如果人和人工智能这几个字如果不可见的话，理论上来说WR一直到W5。

它的权重应该是零对吧，应该是零才对，但是当我们现在这样一个情况，你去算这个Q和K的时候，你的这个Q可是能是能互相计算这个权重的，也就导致我在预测人的智字的时候啊，我已经去看到了人工智能的一些信息了。

那这个时候模型会认为，我根本不是在预测下一个字，而是直接把这个人copy过来copy过来，那我去预测公这个字的时候也是嘛，模型会认为我只需要把公这个字对吧，直接copy过来就OK了对吧。

所以说业余这个transformer来说，就是因为它是一个并行的，就没有办法来让他以RN的那样子，按顺序的一个情况来进行一个输出，那怎么办呢怎么办呢，我们考虑一下啊，刚才我们是怎么分析的。

我们认为如果要生成人这个字，理论上上来说，我应该只能看到起始符，起始符对吧，也就是说只有W1，它这个权重应该是一个非零的一个值，其他的一个权重应该等于零对吧，应该等于零，那对于公这个字来说也是一样嘛。

那我们要在RN当中我要生成这样一个公，我可以看到起始符，我可以看到人对吧，那我可以看到骑士服，我可以看到这里这个人，那对于这里的这个啊，W23吧，这是四，这里的W23W2和W2，那几个值应该是零对吧。

那这几个值应该为零，那对于质这个字来说也是一样的，那这个地方应该是零，这个地方是零，那这个地方是零对吧，对于结束服务来说，它就可以看到所有内容了，就像我们昨天的那个图，我这里最后输出了这样的一个呃。

那个那个能字对吧，我这里输输了这样的一个能字，最后要输出咱们的一个结束符，所以说这个结束符它可以看到所有，是没有问题的，OK但有了这样的一个思路之后呢，我们就知道哦，那我只需要去把这个。

这几个位置这个权重啊全部置零就OK了啊，就是我们看到右边这个图，也就是说紫色这部分，我们只需要把紫色的这部分的这个权重啊，全部置零对吧，其他权重我们正常计算就OK了就OK了，OK那怎么做呢。

其实也很简单啊，我们还是一样啊，去计算这个QK的这样的一个权重矩阵，计算出来之后呢，我们再去乘上这样的一个矩阵，这个矩阵就这些位置全是零，要这些位置是一，好，我用这样的一个矩阵。

和我们QK的这个矩阵进行相乘，相乘之后呢，是一的位置，权重是保留的对吧，是零的位置啊，这些地方的权重就全部变成了零对吧，就以这样的一个形式啊，就能防止出现一个所谓的一个标签泄漏。

那这个思路呢实际上就是咱们这里的这个，就这里这个咱们这个mask好吧，就是这里这个mask，那可以看到啊，对于encoder部分来说，我们是在进行这样的一个编码的处理，所以它不涉及到生成对。

所以它是不需要的，那只有在我们这个decoder部分啊，我们会用到这个mask，会用到这样的mask啊，就是这样的一个思路啊，好这个时候可能也有同学问了，哎你这里mask了。

那为什么这里你没有去做这个mask呢，因为这里啊这里的Q和K还有V它不是相等的，这里的Q和K是一部分，是来源于这个encoder这部分啊，就是来源于encoder这个部分啊。

所以这个地方大家是需要区分开的啊，需要区分开的，他这里实际上就是在和我们上节课给大家讲，Sequence，sequence那个思路就一样啊，我需要把我encoder部分的一个结果拿过来对吧。

和我decoder经过了mask的处理之后的结果，去做这样的一个attention，然后再去加权，就这样的一个思路好吧，大家可以这么看啊，这里就是Q，这里是咱们的一个K。

就是VQ和encoder q和这个decode k相乘，拿到这样的一个权重矩阵对吧，然后我们再用这个权重矩阵和这里这个V，进行加权加权，就是这样的一个思路啊，就这样的一个思路，好啊，我们在这里停一下啊。

对于这个max可能理解起来会稍微有点困难，看各位同学嗯，我这里有说明白吗，还需不需要再讲一遍，这里可能理解起来会有点小小难啊，还需要再讲一遍吗，各位同学，再讲一遍是吧，好好再来一遍，再来一遍。

OK这里是有点不太好理解啊，好我们再来一遍，再来一遍，那我们先把，先把这里这个删了啊，我们再来一遍啊，啊这里有问Q是什么，Q就是你的一个输入，你的decoder的输入。

这个这位同学昨天有有听我们的课程吗，咱们这个attention里面，self attention里面Q是等于K等于V的，也就是咱们的一个输入啊，就是咱们的一个输入，你输入是什么，它就是什么好。

我们再来一遍啊，我们再来一遍，这里可能不太好理解，我们还是先简单回顾一下啊，在我们的一个RN结构当中，我们去做生成的时候，就我们这边是encoder嘛对吧，encoder会给到我们的这个context。

Context，要把context给到我们的这个decoder，好，Decoder，decoder第一个时间点会输入这个起始符对吧，提示符，然后进行一个输出，进行一个输出好。

那对应到我们的这个attention matrix里面，什么是什么意思呢，我们先看这个字，第一个字人，如果我们想生成人这个字，我们是不是应该拿到起始符的信息，对吧，只应该拿到起始符的一个信息。

好先看看这个同学的问题，序列的元素不应该看到后面的元素，所以它后面的对对对，就是这个意思啊，就是这个意思啊，我继续啊，好我们现在理论上来说应该输出人这个字对吧，正常情况，我们要把这个人这个字给输出。

在RNN的结构里面，我们只会输入起始符S，只会输入起始符S，那对应到我们的attention matrix里面是什么意思呢，就是说我再去做这个attention matrix的时候。

我的人应该只能看到你起始符，因为我这里要计算权重嘛对吧，我要计算这个W11，这个权重就是你人和起始符的一个权重对吧，人和起始符的一个权重，在我们的RN里面，人质和起始符有关系，和其他是没有关系的。

但是在我们的tension matrix里面，我们可以看到啊，人和其他的这些字也是可以进行计算的，对吧，我的这个人可以和这些人工智能这些字，进行这个权重的一个计算，那如果这个人和人工智能这四个。

只能进行权重的计算，就说明什么呢，就好比啊我这里RN里面，我直接把这个人工智能这几个字，全部在第一个时刻进行了输入，给到了我第一个节点，然后让我节点输出人，那显然这种事不科学的嘛对吧。

我应该只告诉模型啊，这是一个起始符，这是一个起始符，所以啊我们的这个W啊，对于输入输出第一个字的时候，我们的这个W1的2~5，它的权重应该是等于零，应该等于零才对对吧，应该等于零才对。

所以我们通常就会把这些位置置0~0好，那如果我们现在要输出的是R哦，是输出的是公这个字在我们RN里面是怎么做，我们是把人作为了一个输入对吧，把人作为了一个输入，然后输出了公。

那对于RN来说哎这个时候输出弓的时候，他其实可以看到两个东西啊，一个是人，一个是我们的一个起始符对吧，这里我就不管了啊，一个是人，一个是我们的起始符，它是可以看到这两个东西的。

但是回到我们的attention matrix还是一样啊，还是一样，这个人这个工这个字啊，它还是可以分别得到起始符，还有人工智能这几个词的一个权重，但是理论上来说，我们应该让后面这。

也就是咱们的W23W，它的权重应该是为零才对吧，我生成弓这个字的时候，我只能看到起始符合人，其他是不能看到的对吧，所以这些地方应该治理下面也是一样啊，这个字的话，那就是这两个地方治理。

能的话就是这个地方指令，然后结束符的话，就是我所有东西都可以看到对吧，所以这些地方就都是零，这叫什么啊，好那正常计算的时候怎么计算呢，就是我先得到这样的一个attention matrix。

然后我去乘以这样的一个，下三角的一个矩阵就OK了，好吧，就是这样的一个思路，就是这样的一个思路，因为这么一相乘的话，是一的地方原来的权重可以保留吗，是零的地方原来的权重就全部是零了，好吧好有。

我就说明白了吗，各位同学，OKOK好行啊，那如果我有的同学还是没有听懂的话，这个没关系啊，可以下来再复习一下这个课件啊，可以下来再复习一下课件，接下来的内容的话，我们也不会完全用到这个mask，好吧好。

如果听明白就好，听明白就好啊，这一块还是比较重要的，好我这边就顺便说一下啊，顺便说一下咱们的这个transformer，它不是分为两个部分吗，一个是encoder对吧，一个是我们的一个encoder。

一个是咱们的一个decoder啊，我们现在呢有两个这样的一个，或者说我们的预训练语言模型啊，通常分为分为两类，第一类是以BT为啊为主的，这样一类叫做auto encoding模型，自编码模型啊。

自编码模型，那BERT这样一个模型的一个结构是什么样子呢，它就是我们的transformer的encoder，一个base版本的话是12层，12层，也就是说他就把这个船从我们的encoder拿过来。

然后砂层堆叠在一起，然后进行一个预训练，这就是我们的一个bird，那还有一类预训练模型呢是基于这个GBT来的，这个所谓的auto regret regressive的一个模型。

这样的一个模型它是什么样子的，它是transformer的decoder decoder，但是他没有这一块，这个部分是没有的，这个部分是没有的，它只有下面这个部分和这里这个部分啊。

嗯大家也可以把这个GBT理解为是encoder，然后把self attention那里加上了这样的一个mask，那这个GBT啊，就是用来做这样所谓的一个序列生成的好吧，序列生成的。

所以大家可以简单的理解为BT，就是transformer的encoder，GBT的话就是transformer的decoder，好吧，可以简单这么理解，啊那我这里也再简单说一下啊。

BT的话通常是用来做这个所谓的成为2U的，三语言理解，也就是他的这个任务呢通常是用上下文对吧，假如这里X1X2X3X4X五，它有一个任务是什么完形填空，就假如我把X3这个词给mask住了，我把它给遮住。

然后我要用X1X2X4X5来预测这个词，来预测这个词啊，所以说它是可以看见上下文的，那对于GBT这个模型来说呢，它是怎么做的，它是给你上文X2X3X四好，我要预测，下午我要预测X5好。

X5得到之后我要预测X6，它是这样的一个形式，好吧，这就是咱们的一个bird和GBT啊，这是为什么，我们要来花很多时间去讲这个transformer啊，只要transformer大家弄明白了。

那你的这个BT和GBT你就弄明白了好吧，像昨天有同学不是提到那个GBTC，GBTC它是怎么做的，它实际上就是一个GBT啊，这里它不是一个咱们一个普通版本的GPT，是12层，它这个GPT碎。

它这个堆叠就特别深了啊，就特别深了，它一共有1000啊，1900亿的参数，然后对于我们这个12层的一个啊BT来说，它只有1。1亿的参数啊，然后GBTC的话有1900亿的一个参数。

所以它模型结构是特别大的啊，好这就是transformer这一块，基本上就给大家讲到这里，然后看一下这边对。

还有哦，OK它的一个位置编码简单看一下啊，简单看一下啊。

它的位置编码，就是根据这样的一个公式给计算出来的啊，计算出来的，但是在BD当中呢，BT的位置编码和这个transformer，自带的这个位置编码呢又会有一点点不一样。

那BT当中的位置编码是什么样子的，它是这个样子啊，这里简单说一下，它是因为我们的BT，最大的这个长度是1~512，就是你序列的最大长度是支持512，所以呢它会有这样的一个。

也是有一个embedding metrics，Embedding metrics，那只是这个embedding matrix，输入的是这个序列的一个下标，就是如果你第一个位置，那就是一嘛。

第二个位置是二，第三个位置是三，最后一个位置是512，他把这个位置信息啊，给到了这样的一个embedding matrix来，得到了所谓的一个position，Position，Embedding。

好吧，Position ebedding，这是BT的一个位置编码，和咱们的这个transformer的位置编码，的一个区别好吧，有区别，好接下来我们来看第二个部分啊，就关于这个啊一些读论文的一些建议啊。

一些读论文的一些建议，很多同学就是可能在才接触这个，NLP的时候呢，他可能会想说啊，那我能不能花些时间去多去阅读一些原论文，对吧，包括我们上课的时候，实际上也会讲完之后呢，也会把这个原论文给罗列出来。

我希望大家能去阅读一下原论文，包括像transformer这样的一些。

比较经典的一句论文啊，我是建议大家就一定要自己去阅读一遍好吧，就可能我上课讲解出来的东西，是我对这篇论文的一个理解，那你去阅读完这篇论文，你可能会说啊，我对这个东西可能还会有一些新的理解。

这也是完全有可能的好吧，就包括我去讲这个的时候，我就讲这个mask的时候，我都是根据我自己的一个想法来讲给大家听的，这种想法可能是我认为一种啊比较通俗，比较简单的一种理解啊。

所以说很希望大家能自己去阅读一下原论文，那你阅读完之后，你可能自己就会有一些新的一些收获。

好吧好，那接下来就说一下关于论文这一块啊，首先的话肯定就是一个找论文嘛对吧，找论文像各位同学才接触N2P的时候，大家不需要去啊，就是说啊我一定要去升装，就是某一部分，或者说啊某一个点的这样的一个论文。

像今年比较火的这个prompt，或者说contrastive learning对吧，大家可能现在都还是在打基础，那就没有必要去花时间，去跟这些比较新的这些技术啊，你只需要去把一些嗯比较热门的一些东西的。

一些论文给看一下，例如刚才说的这个transformer对吧，或者包括今天要给大家讲的这个，text n这一块的一些论文，大家可以去看一下，还有像昨天给大家说的那个卢恩腾讯，像这些经典论文啊。

大家可以去好好看一下，那最近的这些比较新的论文，因为大家现在学的还比较浅，所以大家就可以不用去跟这些新东西好吧，先把这些老的东西给先吃透吃透，然后等到等到你真的这个有一定的一些基础了。

然后你再想去了解更多的一些东西，想去自己去看一些论文的时候，那你也可以去啊，首先怎么找怎么找，你可以去简单的方式啊，你可以去先去看一些资讯网站啊，包括咱们国内的一些什么知乎啊，公众号啊。

SSDN啊之类的对吧，像国外的一些什么mu啊，这些东西大家都可以去看，还有像一些专门推推这个paper的一些网站，像paper weekly啊。

还有这个paper with code这些网站啊，大家都可以去看一下嗯，像这个我看一下啊啊paper weekly，大家可以去看一下对吧，它会有一些热门的论文的一些推荐。

然后还有一些那个啊paper is called，大家可以去看一下，那paper recalled，它这是干什么的，就假如你现在想去做这个啊机器翻译对吧，你只要来到这个网站啊，这边有个机器翻译。

你点进去他这边就会罗列出来，而最近的一些啊索塔模型是什么样子的，包括它的一些代码，还有一些论文地址，他的需要全把你给罗列出来，你都可以对应这里去点进去去阅读他的一些paper。

要去看他一些代码都是OK的好吧。

然后这边的话，我甚至还最近有一个比较火的一个阅读paper的，一个叫做，叫做read paper啊。

大家可以去看一下这个网站啊，啊它是一个阅读paper的这样的一个网站啊。

例如啊举个简单的例子，就是你可以去把你自己的paper上传上去。

你也可以在他这里去搜索这篇paper啊，像我们的这个A。

怎么老跳出来，像我们的transformer的paper对吧。

你可以在这里进行一个搜索，然后你就可以直接在这里进行这样的一个阅读，他这边可以进行，他会帮你把这些什么表格啊，什么给提取出来，然后这个应该要登录啊，他关键就在于它很方便，你去管理你的这个paper好吧。

所以推荐大家去使用一下。

这个挺好用的啊，这是关于收集paper这一块啊，然后等到大家真的就是有能力了，或者说基础已经学的差不多了啊，就一定要去自己去阅读这样的一些paper啊，毕竟别人的这些解读，都是一些所谓的一些二手读物嘛。

那是别人的一些想法对吧，甚至可能还会有一些理解上的错误啊，所以建议大家这些比较重要的一些paper，一定要去读一下原论文，一定要去读原论文，那要说一下关于如何去阅读这样的一篇paper啊。

那大部分的一些啊NP方面的一些paper的话，有两个啊，章节是比较重要的，一个是模型部分，一个是实验部分啊，那你只需要把这两个部分就是看完。

基本上就大概能理解一下啊，这篇paper啊，那拿拿到一篇paper的时候呢。

大家先不要去急着详细吧，整篇看完你就先去看一下他的这个摘要是吧。

看一下他的简介啊，先简单看一下啊，这边这边paper大概是讲什么的对吧，我对你哎先简单看一下，然后看一下对你是否有帮助有帮助，OK那你可以去看像前面这些介绍啊，这些背景啊，你就可以先不着去看。

直接先去看他的一些模型结构对吧，模型结构是什么样子的，然后再去看他的一些相关的一些实验啊，像一些实验啊之类的，可以去看一下，甚至实验这些一开始你也不用细看，直接去看它的这个这个结果。

看一下整体结果提升了多少，如果你对这个结果是满意的话，你再去看好吧。

这是一个阅读论文的一个这样的一个顺序啊，顺序，用下标做embedding，会不会造成下标值大的词作用，会啊，不会啊，不会，这个不会，并不是说你的这个下标越大，它的这个embedding就越大。

没有这种说法啊，没有这种说法，雁门要比这个这个要说什么数值有序，in bin后可能不止序有关系啊，对他这个不仅仅是包含顺序的一个一个那个值，好吧，并不会出现这样一个所谓明白那个下标越大，引力越大的情况。

不会出现这个版型啊，这个继续说回我们的这个阅读paper啊，啊大概了解了一篇paper之后呢，那接下来你可能会说啊，我想花一些时间去对这个paper去做一些出现对吧。

我想去把这个paper里面的一些东西，应用到我们自己的这个模型当中对吧，唉那怎么搞呢，你首先啊你可以去看一下这篇paper啊。

有没有啊，去开源这个代码，开源了代码的话，那你可以自己去看一下这个言论文的一个作者。

他这个代码是怎么写的，像我们的这个啊attention，我们可以搜一下，看一下有没有啊，你看他这边啊，这个这个好像不是啊，我们再搜一下有没有，好像没有，换一下刚才的屏啊。

OK你看他这边实际上就会把这个罗列出来啊，这篇paper他的这个代码地址，他就会帮他帮你罗列出来，你就可以去看一下他的这个代码对吧，是怎么写的，你可以借鉴一下，那其实啊各位同学可能没有复现过。

如果复现过的同学的话，就会其实你会发现一个问题啊，有些paper他和自己的这个开源出来的，代码会有偏差啊，就论文里面可能是这么说的，但实际上实现的时候它是另外一种实现方式。

就挺奇怪的啊，这个可能也是啊水分有点大吧，这样的一些paper好吧，然后啊复线的话大概就是这个样子啊。

还有一点大家需要注意一下，就是复线这个东西呢，有时候你投入很多，会出现没有产出的一个情况，首先是市面上的确有水分的，赔本太多了，其次呢就是啊现在大部分这个paper啊。

他都是在这个英文的数据集上去作战的一些啊，Ation study，但实际上它在中文上有没有效果，这实际上是需要打一个问号的，所以就只能你自己去联系一下原作者，或者说你自己去做这样的一些实验。

来得到最终的最终的这样的一个结果，好吧啊，这是复线的这一块啊，那复线这一块我再简单说一点啊，就有些同学会说啊。

这个复线到底该怎么去复现对吧，那这个东西还是建议大家先去才，你第一次去复现paper的时候，你不用着急下手，去找一些比较热门的，然后去看一下那些作者他是怎么写的代码好吧，当你看的多了。

你自然这种复现的能力就会慢慢的给提升起来，提升起来啊，这是关于阅读paper这一块的一些建议啊，建议，好那我们就继续往后继续往后，接下来就来我们第三部分，也就是今天的一个主要给大家讲的内容。

就是关于卷积神经网络这一块，我看一下哎好起，那这样吧，我们稍微休息一会儿好吧，刚好讲了一半的一个内容啊，那我们就稍微休息一会儿，然后我们休息5分钟，休息5分钟，现在8。54啊，我们九点上课吧，好吧。

我们休息5分钟，我们九点上课，然后下节课，下半节课我们再来讲我们的这个卷积网络，卷积网络大家有什么问题就要及时提出来好吧，及时提出来，上半节课应该难点就在于，应该mask这一块是比较难的。

其他应该难度不高啊，难度不高好，我们稍微休息一会啊，好我们准备开始上课了啊，准备开始上课了，先看一下同学的问题啊，嗯LN和BN，具体是怎么解决梯度消失和梯度爆炸的规划，把数据大部分集中在中间。

然后如何解决梯度消失和梯度爆炸的好，我们看一下，看一下啊，怎么解决，其实是这样子的嗯，这是我们的这个SIGMOID激活函数，这是tan h计划函数，那SIGMOID激活函数和ten h计划函数。

最大的问题在于什么，它容易出现梯度消失嘛对吧，只要我的这个值，你看这个mod大于五，小于五的时候，这些地方的这些值实际上就已经很激烈，就已经零了嘛对吧，你看这里是零嘛，这里是零对吧。

这些值已经很接近于零了，这些地方的值都是很接近于零的值了，那如果你不做过异化，那你的值就可能会在这些地方，那在这些地方的话，你的这根梯度是不是就会接近于零，那就出现梯度消失的问题了吗。

所以呢我们做完过优化之后呢，它变成均值为零，方差为一对吧，就会限制在这样的一个区间内，那这个区间内你可以看一下，这些梯度对应的是多少，就没有那么大嘛对吧，你看这一块的梯度啊对吧，这一块的梯度对应过来。

他就不会不会特别小，从而就解决了所谓的一个梯度消失的问题，也不能说解决也是缓解好吧，说缓解的时候更严谨一点啊，缓解更严谨，我也说明白了，这位同学，嗯阅读配对的时候时常遇到公式看不懂的。

或者说不理解公式所表达的意思，这个东西只能说是一个啊，一个慢慢我觉得慢慢熟悉的一个过程吧，就当你自己看了，多看看多了之后，你反而会觉得这公式有时候会说得更明白一些，其实是这样子啊。

为什么会有公式这个东西，大家有没有考虑过这个问题，为什么会有公式这个东西，就是因为他文字说不清楚，所以才会有文，才会有公式，就如果你真的已经说的非常清楚了，那实际上是没有必要要公示这个东西。

所以说当你自己去接触神经网络这些东西，接触的多了之后，你会发现那些公式其实都差不多，都是差不多这样，我们简单看一下啊。

那假如我们看一下这个，我们就简单拿这个公式为例嘛对吧，我们就拿这个attention这个公公式为例，就很多时候你去看到这个QK相乘的时候，当你看多了之后，你第一印象就知道哦。

你这个Q和K相乘就是在求这样的一个权重，你很快就能反映出来这个东西是在干什么的，所以说这个东西你问我怎样才能看懂，真的就只有你自己去多看，你自己看多了自然就有那样的感觉了好吧，看多了自己就有感觉了。

这个东西还是一个看多和看少的一个问题，好吧，这位同学，我觉得嗯没有一个特别好的一个方式去理解，还有就是你要详细去看一下，他对这个公式的一个说明好吧，详细去看公式的一个说明，只能慢慢看啊。

这东西只能慢慢看，你看多了，要是考的稍微慢一点，自然就能看明白了好吧，这个的确是没有什么特别好的一些技巧，我觉得还是熟能生巧的一个过程吧。

好吧，好我们来看我们今天第三部分，第三部分就是关于这个CN这一部分的内容，啊，那对于一个咱们常规的来处理，这个文本的RN来说，它的一个时间复杂度是ON对吧，因为它是按顺序来的嘛，你序列长度。

假如你是那个序列的长度是N，那它的时间复杂度就是ON，所以这个时间复杂度啊它是ON，那通常呢我们去使用RN，提取了这样的一个文本特征之后呢，都会使用最后一个时刻对吧。

最后一个时刻的一个值作为它的一个输出值，给到我们的这样的一个分类层，进行这样的一个分类，但这里啊，RNN它实际上只考虑了每一个词或者字的特征，那如果你是分字，那考虑的就是字的特征，如果是分词的话。

你考虑的是词的特征对吧，那我们考虑一个问题啊，能不能就说为特定长度的一些词序，去计算出它的一些特征表示呢，或者向量表示呢，例如我这里有一句话啊，我们做个分词，他毕业于上海交通大学对吧。

他其实我们把它分成一些小短语，它可能会有，他毕业于毕业于上海与上海交通对吧，还有上海交通大学，那我们使用RN的时候，都是这样的一个字一个字的这样的一些提取，这样的一个特征，那我们能不能组成一些短语对吧。

像他毕业于，我们把这个东西的一些特征给提取出来，我说上海交通大学这一整个短语的特征，给提取出来对吧，那能不能这样子做呢，好这就能这个如果你想去提取这样的一个特征，就需要用到我们的这个卷积神经网络。

卷积神经网络，Ok，接下来的话我们就简单看一下这个，什么是卷积神经网络啊，那说到这个卷积神经网络呢，第一点我们肯定要来聊什么是卷积对吧，什么是卷积，然后呢，我们通常我们称这个F乘以G。

就为F和GA这样的一个卷积，这里有两个定义啊，一个是这样一个连续的一个定义，连续的定义的话，那就是去求这个不定积分啊，那对于离散的话，那实际上你就是一个求和的一个过程，求和的一个过程。

那这里可能各位同学看起来会有点懵懵啊，有点懵，这到底什么意思啊，啊不着急啊，我们继续往下看，继续往下看好，那例如例如啊我们现在有这样的一个啊式子啊，比如说我们令这个X等于零，然后Y等于N减套。

那么我们的这个X加上Y实际上就等于N对吧，就等于N好，我们把这一条键啊，把它画在我们这样的一个啊坐标当中，这就好比什么啊，那这个X加Y它实际上是会变的嘛对吧，所以这个N的这个值它是会变的。

就一直从左下角一直到右上角，那我们可以看一下这条线，而这条绿色的线它实际上就好比什么，就好比我们有一条毛巾，它沿着一个角卷了起来对吧，我们从左下角左下角一直往上面卷，卷到了右上角，那这样的一个操作呢。

就被称为这样的一个卷积的一个操作啊，卷积的一个操作好，接下来我们来看一个具体的一个例子啊，我们以一个离散卷积的一个例子为例啊，我们来看一下，那假如我们现在啊有两个桃子啊，我们读骰子吧好吧。

读骰子这个骰子读着舒服一点好，那我们用F来表示第一个啊，这个第一个傻子啊，那F1表示投出这个一的概率啊，比如说我F1的话，那就是投到一个点，投到一个点的时候，一个概率F2的话，那就投到两个点。

然后我们用G来表示第二枚骰子啊，OK那我们现在考虑一下，如果两枚骰子点数加起来为四，它的一个概率怎么表示呢，那是不是就有三种情况，第一种情况我第一个骰子扔一，第二个人三，第二种情况两个都扔二。

还有一种情况是我第一个骰子扔三，第二个骰骰子扔一对吧，那我们把这三者给加起来，把这三种情况加起来嘛，那这就是我们扔出来为四的一个概率对吧，扔出来为四的一个概率，Ok，那我们把这三者再简单进行一个。

这样的一个化解化解，把它变成一个这样的一个累加的一个形式，变成一个累加的形式，那这样的一个形式呢，就符合我们刚才的这个卷积的一个定义啊，卷积的定义好，我们这边再回到这边来看一下啊，我们的一个离散卷积。

它的一个定义，是不是就是我们的这个扔骰子的一个情况对吧，F套乘以及N件套，就这样的一个情况啊，这样的话就可以以这样的一个扔骰子的一个，形式来表示出我们这样的一个卷积的定义啊，这样的一个定义好。

那我们大概理解了这样的一个卷积的一个意思，之后呢，我们再看一下我们的这个图像上面，它的一个卷积是怎么做的，好，我们现在这里有一张图片啊，有张图片可以看到这张图片上，界面有很多这样的一个严重的噪点对吧。

那如果我们想去做一个去噪的一个处理，那么我们就可以把一些高频信号与周围的数值，去平均一下，就是说我可以取这个地方这个值对吧，我把这个值它周围的这些值，例如这些值，就把这个范围的值啊去取一个所谓的均值。

取完均值之后呢，他就会得到一个所谓的去噪的效果好，那我们详细去看一下这个计算过程吧，啊例如我们还是以刚才这个点为例啊，A1这个点为例，那在A1这个点当中呢，我们先去取一个它周围为一的这样的一个啊。

这个矩形，这个矩形就把它周围的这些值给圈出来了，对吧好，我们用F来表示，它这样圈出来的这样的一个矩阵啊，我们用F来表示，OK接下来呢我们会去做这个均值的一个处理，对吧，均值的处理，那这个均值的处理呢。

那实际上就等于给每一个位置，一个1/9的一个权重嘛对吧，一个1/9的一个权重好，给了权重之后，那我们就对位相乘再相加嘛对吧，把这个G和F进行对位相乘相加，OK那对位相乘相加是什么。

那是不是就是我们的F和G进行相乘相乘，完了之后进行相加嘛对吧，我们的F和G进行相乘相乘，完了进行求和的一个操作，所以说卷积和这里这样的一个，塑造的一个过程啊，就完全就是我们刚才说的那样的一个。

卷积的一个处理好吧，卷积的一个处理，好这就是我们的一个卷积啊，这就是我们的一个卷积，只不过这里这样的一个卷积核啊，也就是咱们的一个基，我们就把它称为这样的一个卷积核，那这个卷积核呢实际上就是一个。

权重是一样的对吧，权重是一样的，好接下来我们看一个动图啊，看一个动图，那如果我们要对左边这张大图，左边这是我们的一个哎，左边这个是我们的一个输入的一张图片啊，然后中间呢这个呢是我们的这样的一个卷积核。

你可以把这边这个看成我们的F，这个看成我们的一个G，Ok，那如果我们要把我们这个卷积核，应用在我们的这个F上进行刚才的操作，是不是也就对位进行相乘，然后进行一个相加，最终呢就能得到对应的这样的一个。

卷积之后的一个结果，这就是我们一个卷积的一个操作啊，卷积的一个操作，那大家这里需要注意一下啊，当我们做卷积操作的时候呢，可以看一下，对于第一个位置处理完，我们会向右平移一个位置对吧，继续做卷积。

直到往右边移移不动了，那我们再往下移对吧，你看移到第三个位置移不动了，往下移要继续做卷积啊，继续做卷积，这就是一个卷积操作啊，说白了就是还是一个这个求权的加权的一个，过程嘛对吧，加权求和这个过程。

好那接下来我们就来详细看看卷积神经网络啊，那卷积神经网络和刚才的卷积，它唯一的区别就在于我们的这个卷积核，卷积核还是可以去动态去进行更新的，可以去动态进行更新的，那刚才我们的这个卷积核。

这里这个这个积对吧，它里面每个值都是1/9，它是不需要去更新这个权重的，那对于我们的卷积神经网络，他的这个权重可以在BP的过程中，就反向传播的过程中去更新它的一个值，好我们这边看一个具体的一个例子啊。

然后这边有一张啊，我们要把这个表示为一张图片啊图片，然后黄色的这个部分呢，就是我们的这个啊卷卷积核，卷积核是一个3×3的一个卷积核，然后红色的这个数字啊，表示的就是卷积核的一个值。

然后绿色的整个的话就是我们的一张图片啊，图片，那我们把这样的一个3×3的卷积核，就应用起来，应用到这个部分对吧，就黄色这部分啊，黄色这部分，那我们就先做一个对位相乘相加，那我们就可以得到四这个结果啊。

好接下来我们把这个卷积核往这边平移一下，平移一下，平移一下之后呢，我们这个卷积核还是这里的，101010和101对吧，我们再把这个卷积核呢和红色这一块这一块啊，进行对位相乘相加。

然后把结果呢得到的就写到这个位置啊，写到这个位置，这就是一个卷积的一个过程啊，卷积的一个过程，那最终呢实际上我们会做这样的一个，所谓的一个分类对吧，假如这里有个soft max。

soft max走进行分类啊，然后呢拿到了我们这个loss function，根据loss function我们得到了一个loss的一个值，那有了loss值呢，我们就可以进行我们的BP对吧，反向传播好。

这个时候呢我们就可以拿到卷积核的权重，它的卷积核的一个梯度啊，梯度啊，有了梯度之后呢，我们就可以对卷积核的权重来进行一个更新，对吧，就等于原来的W除以这样的一个学习率，学习率我们用啊用什么表示呢。

用阿尔法表示吧，然后乘以这样的一个W的一个梯度对吧，就这样一个形式啊，就来把咱们的卷积核来进行一个更新啊，这就是咱们的一个卷积神经网络，卷积神经网络好，那卷积神经网络，是如何应用在我们的文本上面的呢。

我们来看一下啊，我们现在呢这里有这样的一个句子啊，这个句子中123456有七个词，七个词，那每一个词呢，它都有四维的这样的一个向量表示，也就是说他是这里有这样的一个矩阵，这个矩阵是7×4的对吧。

7×4的，OK接下来呢我们这边会有一个卷积核，这个卷积核呢它是一个啊3×4的，3×4的一个卷积核输入是7×4啊，7×4卷积核是3×4的，3×4的好，那接下来我们把这个卷积核。

应用到我们的这个文本数据上面，运用到文本数据上面，好在应用之前，我们先说一个东西啊，在文本当中，我们这个卷积核大小该去怎么处理，或者说这个卷积核我到底应该设置多大，大家觉得呢。

大家觉得我们在处理文本的时候，这个卷积核的大小我们应该设置多大呢，例如我这里不设成3×3乘四，我设成3×3行不行，我设置成这个3×5行不行，可以吗，各位同学，不行好看看各位同学都知道啊。

实际上啊第一个参数，第一个参数卷积核的第一个参数，实际上想表示的是你想提取出来的这个短语，特征的一个长度，我们回到刚才那一页PPT啊，我们这一页PPT说哎，我们想去提取这样的一个短语的一个长度对吧。

那如果我每次想提三个字的一个短语，或者说三个词的一个短语，那你这个卷积合计应该选三，你卷积和第一个维度是三的，意思就是说我每次可以考虑三个词，我对这三个词来作为一个卷积，那如果你第一个维度设的是四。

那你可能就是每次考虑四个词，就是这样的一个意思啊，好我们再看第二个维度，第二个维度为什么这里是四，因为我们输入的这个embedding，它第二个维度是四，那如果是三行不行，如果是三，在我们的这个图当中。

它的这个卷积核就是这个样子，是这个样子的，你从图像的角度去考虑是可以说得通的，但是在文本的角度来看的话，你没有考虑后面这个维度的这三个值，那你说白了就是你当前的这个词，你根本没有把它的这个特征给提取出。

你要提取，你就应该把整个词的一个特征都考虑进去，而不是只考虑它的前三维特征对吧，所以说我们设定第二个维度的时候，一定要和这个词向量的一个维度保持一样，如果这边是一个7×5的，那你这边就可以设335。

如果这边是七六的，那你这边就可以设三的六好吧，这个大家需要注意啊，这个东西千万不要错了，第二个维度是不是一个，你随便取读什么的都可以的，一个值，取决于你的这个文本的那个embedding的维度。

而第一个维度的话就看你了，你想取短语的，那你就设个二，设个三，你想取一个大比较长的一个短语的，那你取个四取个五都是可以的，好吧，好，那接下来我们就来看一下这里这个啊，卷积的一个计算过程啊。

这是我们一个输入的一个一个向量，表示文本的向量表示好，我们把这样的一个kernel应用起来啊，应用起来，那首先的话第一第一次应用的话，那就是前三行对吧，我们把前三行给取出来。

去做这样的一个碱基的一个处理，然后得到了这样的一个值，那这个值实际上就是卷积核和这三个位置，对位相乘进行相加，然后得到的一个值对吧，那这个值实际上表示的就是前面这三个词，它的一个特征。

OK接下来在图像当中啊，我们会向右移对吧，在图像当中我们先向右移，再向下移，但是我们在文本当中，我们实际上是不需要右移的啊，那做完第一次卷积之后，我们直接进行下一下一，这里大家需要注意啊。

下移多少多少个位置，它实际上是一个所谓的一个步长的，一个一个参数啊，通常我们的话就有下移一个位置就OK了好吧，下移一个位置，那下移一个位置之后就到了这个位置，回到了这个位置，我们再在这个位置做卷积。

就拿到了负的零点，那这个就表示的是这三个词的一个特征对吧，那接下来我们继续往下，那就到了这个位置好，画错了，这个位置继续就得到了这样的一个值，然后我们就一直往下，直到我们卷集合到最后这个位置。

做完卷积之后拿到这个值，那我们整个这个卷积的一个过程就结束了，就结束了，接下来呢我们就把这个卷积的一个结果，继续给到后面的一些层进行处理，那最终的话我们会给到我们的分类层。

然后拿到我们的loss boss进行BP，得到我们的梯度，然后来更新咱们的这个更新，我们的这个啊这集合好吧，这就是我们整个的流程啊，整个的流程，那好我们接下来再看一个情况啊。

刚才的刚才的情况会出现一个什么状况呢，我们这边输入的序列长度是七对吧，我们输入的序列长度是七，经过卷积处理之后呢，我们这个序列长度变成了多少，变成了五，变成了五，那如果我们现在做的是N12。

我们做的是N12，我们做的是序列标注，你把我这个序列变变短了呀，你不能把我序列变短变短了，我这个还怎么作为N1对吧，那怎么搞，我们就可以做一个所谓padding的一个处理，padding的处理。

我们在他的这个头，就是在我们序列最开始的位置先补零，然后在序列结尾的布置位置我们也补零也不列，然后应用咱们的一个卷积核之后呢，我们拿到的输出结果就还是七七啊，序列长度就不会变，就还是七。

原来我们序列长度是七对吧，补了零之后，我们的序列长度就变成了九，然后经过我们的卷积之后呢，序列长度还是保持原来的一个七好吧，保持原来的七好，这是我们的补贴，我padding的一个操作啊。

那除了补padding呢，我们还要再理解一个概念，叫做多通道，多通道对于我们的图片来说，我们图片是分为RGB的嘛对吧，RGB它有333部分吧，333原色吧，它有三个部分，那三个部分呢在图片当中。

也就等于它会有三个通道对吧，那三个通道我们是不是就需要应用三个kernel，我们每个通道给一个这样的一个term kernel嘛，对吧，三个通道的话就三个kernel，那对于我们这个文本来说。

我们也可以给他多个kernel，你不同的kernel提取的这个特征的角度，可能就会不一样对吧，这样的话我们就可以提取出不止一个特征，你看这里就提取出了三个特征，因为我们三个合同这里就提取出了三个特征。

就这样的一个意思啊，好这是多通道多通道好，接下来的话我们来说一下石化了，石化那经过我们的这个，卷积之后呢，我们实际上拿到的是这样的，这样的一个矩阵对吧，这样的一个矩阵它是一个7×3的，它是一个7×3的。

那我们没有办法把这个东西是，直接给到我们的这个啊分类层的理论上来说，分类层他应该拿到的是一个一维的一个向量，对吧，你这里是一个二维的，那我们通常就会去做一些所谓的一个，石化的一个操作啊。

石化的操作池化一般有两种啊，一个叫做最大池化层，还有一个叫做平均池化层，最大池化层什么意思呢，就是说我只去取你的最大值，平均值化层的话就是取均值，例如我们这里去做这样的一个最大池化层。

那我就会把这个特征啊，第一个维度的特征最大的那个值给取出来，那这个也是啊这个维度最大的特征给取出来，这个同理啊，最大的特征给取出来，然后把这个东西呢，就作为我们最终的一个向量表示。

然后给到我们的这个分类层，直接就可以给到我们的分类层，或者说我可以在这里先加一个dance全连接层，经过我们的全连接层之后，再给到我们的soft max，再来进行我们的求求求这个loss求loss。

这就是我们文本当中的卷积网络的一些处，理的一些逻辑和流程，好吧好，接下来的话我们就来看一下，那这个卷积神经网络它的这个处理的这个流程，这个图片的大小它到底是怎么变换的啊，例如我现在输入一张图片。

它的一个大小是W乘以W好，那接下来的话，我们需要去定义我们这样的一个filter，也就是咱们的这个卷积核，这个卷积核的大小假如是F乘以F好，让我们说一下我们的步长，步长是什么意思呢，就是我到底是走几步。

刚才的这个里面我们每次都是走一步对吧，但实际上你也可以每次走两步，也可以走三步都是可以的啊，好这是我们的这个步长，最后还有一个叫做padding，padding的话，就是我们刚才的那个5050。

好接下来的话我们就来算一下啊，如果我们采用的是一个叫做啊value的一个形式，value的意思就是图片的大小是可以变的，没关系啊，那这个时候我们输入的这个这个啊，不能说图片啊。

就是说我们的是一个输入和输出，它的一个维度是保持啊，这是可以变的，那如果是sim的话，就是输入和输出的维度是要保持不变的啊，就是这个维度啊，维度指的是它的一个序列长度的这个维度，OK那如果是可变的。

那我们的一个输入和输出之后的一个变化，是什么样子的，那就是用我们的W，减掉我们的这个卷积核的大小，然后除以我们的步长，然后加一这个值就是我们输出的这个结果，输出的一个结果，如果我们要保持它的这个不变。

序列长度的这个维度不变，怎么做呢，就是W加上二乘以pd，为什么是二呢，因为有padding，前面也会补，后面也会补对吧，所以要乘以二，然后减掉我们的这个啊kernel的一个大小。

然后再除以我们的一个误差，然后最后加一，就得到了我们的一个输出之后的一个结果，所以大家之后再去写这个卷积神经网络的时候，你需要去给这个卷积核去定义大小对吧，那你就要去自己手动自己计算一下。

我经过卷积之后，我这个卷积核我说我经过卷积之后，我这个维度变成什么样子，这个东西你是自己需要去计算出来的，好吧，这样的话你去写代码的时候，你才能把这个卷积核的一些参数给设置好啊，好这是啊。

这基本上就是要给大家讲的，在文本当中的这个卷积神经网络的这个基础了，好看各位同学有没有什么问题啊，有问题吗，这一块，有问题吗，各位同学，这能加二层，什么可以夹，可以夹，完全没问题，你可以把这个。

如何加是吧嗯这样子啊，嗯X1X2X3X4X五好，假如我现在做我这个卷积处理对吧，我可能啊我每次就取了两个词好，那我X1和X2做一次卷积，我可以得到这样的一个值，我用啊我用M来表示吧，M这是M1。

然后X2和X3走M2，这里又可以得到一个值对吧，在这里又可以得到一个值好几个，这四个值的话，就是我们这个卷积这一块的一个结果对吧，OK那你既然有了这个东西，那我是不是就可以针对于这四个值。

作为一个所谓的cf这个tension，对吧，我就可以做一个CP成什么，那做完之后，你是不是就是得到了这样的一个加权之后的，一个结果，你再把这个加权之后的一个结果给到下面的层。

然后再来做我们的分类就OK了好吧，所以说这个腾讯你想怎么加都是可以的，都是可以的，好我有说明白吗，这位同学，而且你也可以不按照我这个思路来，你也可以先对这里做腾讯，做完了腾讯之后。

你再来做这样的一个卷积也是可以的，也是可以的，嗯这个东西大家可以不用着急啊，然后啊我们待会在做应用的时候，这位同学不是这一块怎么运用，这个不用着急啊，待会我们还是会讲解，如何去做这样的一个应用的啊。

啊像这位同学说这个财产怎么加，其实你这样的一个想法我觉得挺好的啊，挺好的，已经想到了，去怎么去尝试做一些基础的一些模型，结构进行修改，这样的一个想法挺好的挺好的，好我们继续往下卷积操作。

提取的是相邻词的关系，对对对，就像我这里开始说的，你看我实际上提取的是这样子的东西嘛，就是相邻词，你说白了提取的就是一个所谓的短语对吧，提取的就是一个短语，短语短语特征。

我们RN它只能提取单个词的特征对吧，上了卷积之后呢，我们就可以提取一些短语特征，你甚至可以在短语之后呢，我们再做一次卷积对吧，我这里可能提取出了一个短语特征，这里提取出了一个短语特征，假如这是M1。

这里是M2，我可以在这里再做一次卷积，卷积得到一个N1，那这个东西就是可能就是一个段落向量对吧，或者句子向量啊，句子向量，好啊，其他还有问题吗，没有问题的话，我们就进入到CN的这个应用了。

有些短语没有意义，确实，但这个东西你想啊，如果没有意义的话，我们再进行反向传播的过程，因为权重会更新吗，对吧，群众会更新吗，你权重更新了，对于没有意义的那些词的那些特征，那就小嘛，那还有这里啊。

我们这里不是会做这个最大石化吗，那对于这个没有意义的那些那些值，就会被过滤掉吗，因为我们取的是最大尺寸的一个操作，最大池化就是保留最大值嘛，你没有意义的那些东西对吧，那些特征就可能就舍弃了，好吧。

这位同学，好OK我们继续，啊我们来第四部分，关于CN在文本当中的一些应用应用，然后这边呢我们先来看第一部分，叫做TXNTAXN，那既然要运用的话，那肯定是先用我们的CN来做这样一个，所谓的文本理解对吧。

或者说NRU，那这里罗列了啊两篇paper啊，两篇paper，这两篇paper呢都是以使用这个CN来做这样的一个，文本处理好，那接下来我们就来详细看一下啊，这两篇结构，这两篇paper的这个提出来的。

这个结构其实是很类似的啊，很类似，我们先看第一篇，第一篇嗯，它是有这样的一个句子啊，这个句子，那这个句子呢我们会去应用这样的一个不同的，这样的一个kernel，可以看到啊，这里有这个红色的。

还有这里有这样的一个黄色的这样的一个kernel，去提取它的一个特征，提取特征，那提取出来之后呢，我们就可以去做一些这样的一个，所谓的石化的一些操作对吧，石化的一些操作。

然后把提取出来的特征全部组合在一起，那组合在一起之后呢，再给到我们的全连接层来进行一个分类，很简单对吧，结构很简单，这就是最简单的一个TXT的一个网络结构，好我们再来看一下下面这篇这篇的话啊。

会更详细一些，我们想我们来看一下啊，他怎么做的，输入一句话，I like this movie very much，好，这句话一共有1234567个吧，七个每一个词它的向量表示的维度是五维好。

那这里就是一个7×7乘五的一个维度对吧，7×5的维度，OK他输入就是这样的一个75，接下来他会去采用三种不同大小的，一个这样的一个kernel，三种不同大小的kernel。

并且每个kernel每种类型的kernel呢，它分了两个通道啊，两个通道可以看一下啊，首先啊是一个2×5的2×5的，然后绿色的这一块呢是这个3×5，3×5，然后红色这一块的话就是4×5，4×5。

它分了三种不同的啊，对于黄色这种2×5的，那实际上这种短语嘛对吧，短语可能是两个词组合在一起的，那三个词的话，那就三个词组合在一起的，对于4×5的，那就四个词组成在一起的，那这里再重复一下啊。

五这个维度不能变，它要和你原来输入的这个维度保持统一好吧，保持统一变的就是前面这个维度啊，一个2×5，3×5，4×5好，OK那接下来我们来去做这个卷积的一个操作啊，我们先把这个红色的这个卷积的。

一个和卷积核啊拿过来，那我们就是放到这个位置，这个位置做一次卷积的一个操作对吧，然后得到的结果就是这个位置，然后往下平移，平移到这个位置，对吧，得到结果在这里要继续平移。

要得到这得到的结果放这里要继续平移，得到结果放这里，这是一个红色的卷积核，这是第一个啊，这是第一个，那我们还有一个，还有另外一个颜色稍微浅一点的卷积核，对吧，还是4×5的，那我们再提起一次。

就得到了这样的一个值，那对于下面的粉色和那个绿色的，和我们黄色的卷积核也是一样的，处理逻辑啊，分别去做卷积啊，这里是第三个，第四个，还有第五个，第二个好，做完之后呢，他这里也是一样啊。

取了一个最大磁化的一个处理，那四个深红色的就能就只能拿到一个结果对吧，这个红色的也是拿到一个结果，绿色的拿到一个结果，浅绿色一个结果，黄色的一个结果，柠檬黄的一个结果对吧，那最终呢就是拿到六个结果。

我们再把这六个结果啊拼接在一起，拼接在一起，拼接完之后呢，再给到下一层，我们就可以来进行这样的一个所谓的分类分类，这就是我们TX来做文本分类，这样一个比较典型的一个模型啊。

好这里就建议大家可以自己去阅读一下原论文，好吧，原文那TXT它最大的优势在于什么地方呢，它网络结构非常简单，可以看到吗，特别简单对吧，然后他的一个参数量也是特别少的啊。

特别少参数量关键就在于这几个卷积核对吧，卷积核关键就在于卷积核后面没什么参数了，你看一个最大石化一个拼接，然后一个全连接层，关键就在于这里的这个卷积核的一个参数啊，好这就是咱们的一个TXN好吧。

Tx i n，那对于CN来处理文本来说，它其实也有一定的缺点，大家觉得对于CN来说，处理文本进去，大家觉得会有什么样的一个缺点，什么意思序什么意思，单向传递什么意思，单向传递什么意思。

其他同学的其他同学有什么想法，只有局部特征，其实这位同学说的很有道理啊，这个局部特征，那大家可以可以其实可以考虑到啊，那对于CN来说，他其实感受也很小的对吧，他只能考虑到一些局部的一些特征。

他没有办法去考虑到一个全局的一个特征，所以说对于一个长文本来说，它是不适合使用RN来处理的，除非你的这个RN特别深特别深，就是像我刚才说的那种，就你这里做了一个RN，这里做个R，这里又做了个RN对吧。

可能后面还有这里RN这里做RN，这里这样一直做RN，一直做RN，那这样的话你可能到了最后这个位置，可以考虑到一个全局的信息，但是其实上整体来说啊，这种结构实际上是嗯比较臃肿的一个结构啊，也不太美观。

所以说对于RNN那个CN来说，CN来说，它只适合去处理这种短文本啊，只适合处理短文本，对于长文本来说，我们还是尽可能去使用类似于IS，TM这样的一些结构。

或者说transformer这样的一些结构来处理，短文本的话，我们用CN来处理，好吧好，除了这一点，其实还有一点就是我们的这个CNN，它没有所谓的一个序列的一个概念对吧。

它没有一个所谓的输入顺序的一个概念，所以啊我们在使用text n的时候，通常也会把这个psection in bedding，possession embedding应该考虑进去好吧。

possession embedding可以考虑进去啊，把它加上去，对他其实会容易丢失很多这样的一些信息，所以我们的这个text通常你要去做分类的话，只用来做短文本的分类好吧，短文本分类。

长文本分类的话，我就不推荐大家使用这个tag，好这是我们的taxi啊，Taxn，然后最后的话我们再来看一个模型啊，这篇模型的话啊，这篇paper的这个模型呢。

就是用我们的这个CNN来做我们的这个序列生成，序列生成，那对于我们昨天给大家讲的这个sequence，sequence来说，我们都是使用的这样的一个RN的一个结构对吧，那在这篇paper当中呢。

他把这个RN的结构替换成了这个CNN，但是替换成CN其实很容易出现一个问题，就是我们刚才在给大家介绍transformer的时候，提到了这个所谓的一个提前看到一些，额外的一些信息嘛对吧。

可能会出现一个所谓的标签泄露的问题啊，那我们就看一下这篇paper它是怎么解决的，好我们先看encoder部分啊，上面上面这一块的话是咱们的一个encoder部分，这是我们的一个输入对吧。

这是我们的一个输入，经过embedding层白顶层之后呢，他去做了这样的一个卷积，这个卷积的话，它它的这个卷积核的大小应该是三啊，应该是三，每次取得这样的三个词去做一个卷积，做完卷积之后呢。

它这里每个卷积会有两个和，所以呢他就会得到两个值，OK做完这里大家肯定又看到一个熟悉的东西啊，哎get it linear your nose，这是啥，这不就是LSTM当中的门控机制吗，对吧。

取了一个SIGMOID，拿到咱们昨天说的那个所谓的一个概率，再把这个概率和这几个卷积得到的，一个结果进行相乘，然后得到我们经过门之后的一个输出值，好这是我们第一个卷积，然后这边也是啊。

还是取三个序列的大小都是这样的，一些卷积的一些处理，加上门控机制得到它的一个特征对吧，这边也是，这就不重复说了，好，这样的话，我们就得到了一个卷积之后的一个结构啊，卷积之后的结果，然后呢。

他会把卷积之后的一个结果，和原始的这个输入的这个embedding一起拿过来，进行一个相加的一个处理，这是什么，这是什么，各位同学，这是什么对吗，这就是残差吗，有没有发现一个问题，一个新的模型结构。

实际上就是建立在老的模型结构的一些优势上，把一些老的模型结构的一些缺点进行改良，然后把该拿着东西给拿过来对吧，就是所谓的一个残差啊，好啊，这个地方就是我们的一个特征，然后这边是一个残差，残差之后呢。

好一个残差模块了对吧，相加之后呢，他继续往下走啊，但是呢这边它还没有结束啊，他会把这边根据CNN提取出来的特征啊，会给到这边来做一个所谓的腾讯，那个腾讯的目标是什么呢，是decoder的这个结果啊。

decoder的输入啊，以后的一个输入啊，他是怎么去解决这个所谓标签泄露的，他在前面去补了很多这样的一个拍定位，补了很多的一个拍定位，然后这里我们看一下啊，还是一样啊，他每次取的时候。

它你可以看一下他关注的词是这样子，他取的是前三个词，前三个词啊，他把这个拍定位考虑考虑进去了，前面有两个拍定位，大家需要注意一下啊，前面有两个拍定位好，然后呢这边还是一样啊，两个卷积核。

然后经过我们的门控机制，然后相乘得到这样的一个，经过门之后的一些特征对吧，这样就有四个特征，那我们先看第一个特征，第一个特征实际上是只有75S，而对于第二个特征来说，它包括了起始符，还有这个东西对吧。

那对于第一个，那我们再把它对应过来嘛，对应过来，那就是这个位置就是对应到这个地方对吧，这个地方就和我们这边这个值进行这样的一个，和腾讯的一个处理啊，额TENTION的处理，那这边就对应过来啊。

都是一样的，对应过来去做这样的一个腾讯的一个处理，最后呢我们这边就能拿到我们这个输入值，和encoder的输入值，和我们decoder的输入值的这样的一个啊，Attention metrics。

也就是bot product的一个结果啊，bot product的一个结果，它这里就会进行，那乘完之后呢，这个矩阵就是我们的一个权重嘛对吧，那拿到这个权重呢，我们就和这边这边的一个输入。

就经过残差之后的一个输入，去做这样的一个加权求和的过程，加权求和的一个过程，加权求和完了之后呢，那我们就能拿到这样的一个值，再把这个值啊和这个decoder的这个值，进行这样的一个相加。

进行这样的一个相加，那这一个部分其实也和昨天给大家去讲这个，Sequence，sequence的时候，实际上是很类似的啊，昨天的那个怎么讲的呢，昨天那里实际上是做了一个评级啊，这里是一个相加。

相加完之后再进行这样的一个结果的一个输出，结果的一个输出，他就是以这样的一个思路来做的好吧，好这就是我们的这个使用CN来做咱们的这个，sequence sequence的一个任务。

OK基本上要给大家讲的模型结构。

就是这些东西了啊，然后接下来呢我们就一起带着大家来，把这个TXT这一块的一个模型的这个代码啊。

给复现一下好吧，复现一下啊，然后我们这边简单说一下啊，在我们之后一节课程当中呢，我们都会使用这个PYTORCH，Pytorch，PYTORCH的话相比于腾格弗洛来说，它的这个使用起来会简单一些。

并且目前越来越多的人都在使用这个PYTORCH，好我们这边就重新进重新新建一个好吧，哦TX啊，然后我们把它先删了啊，先删了，OK我们就一起来带着大家，把这个TXN那个复现一下啊，复现一下好。

有些同学可能会说啊，我没有用过PYTORCH，不会不会没关系，你看我写一遍你就会了，好吧，很简单啊，PYTORCH很简单，怎么构建模型呢，首先，我们把咱们的这个torch导入进来啊。

然后我们把常用的这个NN也可以导入进来，OK接下来我们简单说一下啊，你在PYTORCH当中要定义一个模型，该怎么定义呢，新建一个类，新建一个类啊，然后我们让这个类继承自NNMODU嗯。

打磨点继承自N打磨掉，然后我们需要重写它的两个方法，一个是它的一个构造方法，一个是构造方法，那构造方法是在干嘛的，构造方法是在注意啊，注意听构造，构造方法是在啊准备我们需要用到的layer。

就是说你的模型结构需要用到哪些内容，那你就在你的构造方法当中去写，好吧好，这是我们的一个构造方法啊，还有一个是咱们的这个啊forward的方法，for word方法，这个方法是在干嘛，哎今天怎么回事。

这个方法是，嗯不要了吧，pass掉这个方法就是把layer拼装起来，拼装起来，进行选项传播，啊这就是我们的forward的方法啊，forward的方法，OK我们一步一步来嘛。

我们就先来准备我们需要用到的一个layer啊，这里我们先不考虑考虑位置编码啊，好吧，首先是什么，看一下，第一步是什么，Embedding，Embedding，直接就调用N导embedding。

我们就定义好embedding层的那embedding，第一个参数是这个词典的一个大小啊啊我们用，我们把这个参数从外面传递进来，从外面传递进来，然后我们还需要一个参数啊。

是这个embedding size，embedding fies就是embedding的一个维度，我们也从外面传递进来啊，传递进来好。

embedding层我们就定义好了，接下来是什么，我们看一下三种卷积核对吧。

那我们就定义三个卷积层吧，我们就叫CNNN导com td好，然后我们考虑一下啊，我们输入的这个embedding它是一维的对吧，所以说输入的这个channel的话，它是一好。

主要是我们要考虑一下我们的输出的channel，输出的这个channel的话，我们输出的是两个对吧，那我们就输个二就OK了，然后是我们的这个kernel size啊，KERNESIZE好。

我们这里的kernel size是234对吧，第一个是二，然后第二个维度要保持一样嘛，和embedding size保持一样对吧，那我们用元组吧，好那我们第一个卷积核，这个第一个卷积层我们就定义好了。

接下来呢我们还需要定义两个对吧，一个是二，一个是3A就是二。

分别对应我们刚才的这两个对吧。

那我们这个维度就需要改一下啊，改成这个三的四三的四好，那就变成了234好，三个卷积没问题吧，三个卷积卷积好了之后，我们看一下还差啥，哎怎么回事啊，怎么切不过去，卷积网络是不是磁化磁化好。

那我们来定义我们的磁化，我们叫X，好定义我们的一个池化，Ok，接下来我们要考虑一下，我们的一个kernel的大小啊，kernel的一个大小，这里可能是大小是多少呢，那假如我们现在哦我看一下啊。

我们需要有一个序列的最大长度嗯，我们看一下啊，这边序列最大长度设置是多少，好我们这边序列的最大长度设置的是32，32，32的话，我们考虑一下啊，序列最大长度是32对32。

那我们的这个kernel大小是二，也就是说我们输入的这个是32，然后续这个克隆大小是二，然后我们不长是一，那我们输出结果是多少，来各位同学，31其他同学呢，其他同学还有不同的一个结果吗。

这同学没有了是吧，好这是31就31好，我们接下来还需要两个这个置换啊，大家就一起来思考这些问题好吧，因为你在写代码，其实你自己去写的时候，你会遇到这些问题，所以大家就一起来思考啊，一起来思考啊。

这就是那因为这个是三嘛，好说一下怎么算的啊，首先是32对吧，你需要去减掉你的这个那个可能一个大小，那32减掉二，那就是30，30的话要除以步长，除以不长的话，那就是一级嘛，那还是30对吧。

那最后还要再加一对吧，我们可以一会回答怎么回事，诶怎么回事，怎么奇奇怪怪的点不回来了对吧。

那我们这边还要再加一嘛，所以就变成了31好，这里是30，那最后一个的话就是29对吧，29好，最后的话我们可以定义一个啊，加个drop out吧好吧，drop the part的话就是用来防止过拟合的啊。

the part我们可以给他这样的概率值啊，连接啊，然后最后来一个dance，嗯dance的话就是点LINU，点lei啊，好INO，那假如我们的这个embedding size。

我们用embedding size乘以33啊，为什么乘以三，如果我们这里是我们看一下啊，是不是乘以三呢，我看这是我这个输入值，输入值输入值的话，其实就是我们的怎么回事。

输入值的话实际上就是这一块对吧，就是这一块，那实际上我们这里一共有啊，这边是有两个值，这两个值这个值那一共是六个池子。

一共是六个值，那就不是这个东西啊，这里应该是我直接写啊，直接是六尺六五尺，output channel是二，所以2×3，所以这就是六啊，然后我们假设要做一个二分类，那这里你就输出二就OK了啊。

输出二就OK了，好这就是我们需要准备的一些网络结构，准备好了之后呢，我们来看我们的forward方法，word方法把雷也拼装起来对吧，那首先呢就是得到我们的这个embedding。

我们调用一下我们的这个self embedding。

我们需要把X传递进来啊，哎。

好吧，X传递进来传递进来，然后我们这边可以做一个这样的一个，这是在干嘛呢，就是给第一个维度啊，再加一个维度，因为我们这里是个二维卷，对于图片来说它是一个四维的，那对于我们文本来说是一个三维的。

所以我们可以在第二个维度，也就是也就是一的这个维度去给它扩一个维度，扩一个维度好，那我们接下来就进行一个输出，那第一层的这个CNCN21吧，CN21就调用我们的CNN1对吧。

然后把我们的这个结果传递进来，embedding传递进来，然后我们这里可以把那个那结果再缩回去啊，我们可以用EZE方法把最后一个维度给去了，其他也是一样，我们把这是二，这是三好，处理完之后呢。

我们接下来就是做什么石化嘛对吧，我们可以调用一下我们的max po，next book啊，这样的话我们就能得到我们的第一个，最大池化层的一个结果，我们来看第二个，哎哎呀，这个键盘不太习惯，这是第二个。

这是我们的第三个，第二个三个，OK那这些都准备好了之后呢。

我们就可以做一个什么啊，我们这边怎么做的，石化层拿到了一个结构进行拼接对吧。

再给我们分了一层，那我们也是一样的，我们调用一下cat方法啊，把它给拼接在一起，alt1alt2alt三，好拼接在一起啊，拼接的这个维度呢是一个维度啊，还是一样啊，我们去把最后一个维度给去了。

得到我们最终的一个输出值，然后我们这边可以调用一下我们的这个drop out，把我们的这个alt放进来，I好得到我们的输出值，我们再把我们最终的输出值给到我们的dance，dance把alt加进来。

OK最后进行输出，然后我们把我们的这个out值返回，OK整个我们的模型啊就搭建完成了，搭建完成，接下来的话我们来看一下啊，我们把我们的这个text返回一下，是二对吧啊，然后两个参数，一个词典大小。

一个embedding size，OK我们执行一下代码，看能不能一遍过啊，各位同学可以直接在自己的笔记本电脑上跑，是完全没问题的啊，因为TX这个模型结构比较简单，所以大家自己在自己的笔记本电脑上跑。

应该也是可以跑的，你没有GPU应该也是可以跑的啊，这个不用担心，模型结构比较小，然后这边的话还会有一些包括，数据的一些处理，这些东西的话就是一些逻辑代码了，我这里就暂时不给大家说了，好吧好。

这边就已经开始进行一个训练了啊，开始进行训练好，可以看到他这个效果好像是不太理想的对吧，不太理想，那我们可以考虑去简单调整一下，它的一些参数啊，他这里这个output channel的话。

就说你运用了几个这样的一个channel对吧，那我们可以考虑运用多一点的嘛，如果你太简单，我们可以考虑运用多一点，我们搞个搞个20吧好吧，看一下效果有没有提升，搞个20，那这里的话就变成了就变成60。

好，我们再试一下，诶好像效果变化也不是很大是吧，嗯好像比刚才稍微好一点点，再把这个参数简单调一下啊，我们来试一下，而其他的话我们也可以再调一下，其他的一些东西啊，啊这个哦对数据集我都忘记和大家说了。

这个其实就是一份那个情感分析的一个，数据集啊，还有一和零一的话就是正面情绪，零的话就是这样的一个负面情绪，负面情绪，好基本上整个流程就是这个样子啊，然后我们看一下嗯，诶这里好像有问题啊，这里忘记改了。

诶这里好像我看一下词典是在哪里打的，我记得我这个词典都还没生成呢，我们执行一下这个，OK这边我们看一下词典，1万多是1万，1156啊啊这个没问题啊，我们再跑一下，那当然应该是词典的一个大小啊。

不然效果应该不会那么差，那这个层数大家可以设置小它小一点啊，没必要设置这么大，没必要设这么大，啊我们先跑一下看一下好，可以看一下啊，这效果其实一下就起来了对吧，干那个词应该是词典的问题啊，一下就起来了。

已经达到89，我们再改回来啊，我们改了和原论文的一个超参数保持一致啊，我们就用二来看，我就用R啊，这里就是六，OK我们再看一下，好稍等一下还可以看到啊，其实效果还是不错的对吧，第二个epoch叫85了。

86还在不停的收入对吧，86。4甚至87了啊，效果已经还不错了，OK行，基本上这就是今天要给大家讲的一个内容了啊，大家下来把CN这一块弄明白的话。

可以一样啊，来把这个代码这一块给复现一下好吧，复现一下。

好行，看各位同学有没有什么问题，不传在哪里定义嗯，这里啊这里还有一个它，这个里面是有一个参数的，你看它有一个street的一个参数啊，默认是一，默认是一，你可以说啊，你也可以设三好吧。

好其他同学还有问题吗，图片为什么是四维的啊，是这样子啊，你图片输入是这样子吗，首先第一个维度是resize嘛，do a do bpage size诶，第二个维度是kernel size。

那第三个维度是它的宽，然后第三第四个维度是它的高传中size，因为它是RGB嘛，RGB所以，channel size等于三，那如果你是黑白图片的话，那这个channel size就是一好吧。

要是图片的宽和高，所以它是一个四维的四维好，我也说明白吧，好其他同学还有问题吗，啊没什么问题，咱们今天的课程内容就到这边了，好吧，就到这边了，好行呗，那咱们今天的内容就给大家讲到这边好吧。

那我们就下次课再见，然后大家有什么问题的话，也可以在群里面找我就OK了。

好吧嗯好的，各位同学。

标签：这个,在线,一个,笔记,公开课,然后,卷积,我们,就是
From： https://www.cnblogs.com/apachecn/p/18498039