七月在线公开课笔记-三-

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

【七月在线】NLP高端就业训练营10期 - P3：3.基于CNN的文本分类_ev - IT自学网100 - BV1uxT5eEEr6

好刚好啊，对于昨天的课程，各位同学有没有什么疑问的，现在可以提一下，我们在啊开课之前啊，先简单做个答疑，看昨天的内容，各位同学有没有什么疑问，有问题吗，各位同学，都没什么问题是吧，好行吧。

那我们就继续开始今天的内容吧。

咳咳咳好啊，今天的内容是这个，我们是使用卷积神经网络来处理咱们的这个呃，NLP的一个问题啊。

好我们简单看一下今天的几部分内容啊，今天四个部分内容啊，首先第一部分的话，是要把昨天我们这个没有讲完的，这个transformer那个部分咱们再讲一下啊，把剩余的一部分给补充完，然后第二点的话是啊。

这边之前额外加了一点内容啊，就是很多同学会来问啊，就是说啊如何去阅读这样的一个论文，好，这边的话，我也给简单的给一下自己的一些建议啊，而第三点的话就是啊，进入我们今天的一个重点啊。

就关于卷积卷积神经网络这一块，就包括什么是卷积神经网络，而在这个咱们NLP当中，如何去运用这个卷积神经网络好吧，这就是咱们今天的一个内容啊，好那我们就先进入我们的这个第一部分啊。

关于这个transformer的这个补充啊，对于昨天的刚才有同学可能还没进直播间啊，我简单提一下，就对于昨天上课的一个内容，如果还有疑问的地方，现在可以提出来好吧，我们可以解决也解决一下啊，好。

那我们来看今天的这个transformer，这一块的内容啊，昨天讲到了这个嗯，mari had腾审这一块对吧，mari had腾审这一块好，那接下来我们就来看一下啊。

他的这个transformer当中的其他的一些结构，OK我们把这个encoder部分单独拿出来看一下，这个self attention这一块呢是我们昨天已经讲过的，在接下来的一个结构当中可以先看一下啊。

首先呢是这一个部分，它这里有一个X加上Z，这个Z的话，就是经过我们这个self attention得到之后的，一个结果对吧，那这个X是什么呢，X是我们一开始的这个输入的这样的一个值啊。

X是我们输入的这个值，那如果是第一层，第一层，那就是我们的这个文本的这个，embedding的一个结果对吧，那如果是后面的层，那这个表示的就是每一层，这个encoder输出的一个结果好吧。

因为咱们的这个transformer啊，它通常都是有多层的这个抵扣的啊，这个抵扣的它是这样子的，多层的它是多层的，这第一第二第三它是多层的啊，那对于第一层的话，传给第一层的是咱们这个embedding。

那传给咱们第二层的，其实就是第一层的一个输出对吧，所以这里这个X啊，如果是第一层就是embedding，第二层的话就是上一层传递过来的一个结果，那这里可以看到啊，他是用这里这个X加上了这里这个Z。

那这样的一个操作呢，就被称为这个所谓的残差模块啊，残差模块对应到咱们的这个图当中啊，就是这个位置啊，ADD ADD好，那做完这一步呢，他会做这样的一个layer normalization。

Layer normalization，这个layer normalization又是什么东西呢，它其实啊就是在做一个所谓的一个规划规划，那这两步呢通常都会啊放在一起啊，就被称为这个AD and of。

OK那经过这两步之后呢，就会拿到我们这样的一个输出结果对吧，输出结果呢给到我们这个fade for word层，那fade for word层，昨天和大家说过了，这个实际上就是可以简单的看成。

就是这样的一个全连接层啊，全连接层好，那经过这个全连接层之后呢，又继续给到了这样的一个ADD and n，也就是刚才这里说的这个残差模块，和这个没有normalization。

那整体的这个encoder的一个结构就是这个样子，那最终呢实际上就是多层的这样的一个encoder，堆叠在一起，那具体你要去堆叠多少层，就看你自己的一个选择了好吧，那像我们自己啊。

比较常用的这个预训练的语言模型，BT这个模型它实际上啊，就是这个encoder堆叠了12层好吧，12层就搞了12个这样的个encoder，堆叠在一起啊，堆叠在一起，这个大家需要注意一下啊。

BT这个模型是transformer encoder部分好吧，它只包括encoder部分，这里很重要啊，好这是我们啊内部的一个结构哈，接下来我们就详细看一下这里的这个啊，残差模块。

还有这里这个NONONALIZATION，那后面的这个fit for word我就不说了好吧，全连接层这个相信各位同学都很清楚了啊，嗯好那我们就先来看这个残差模块啊，那通常上来说呢。

我们再去训练一个模型的时候，理论上来说网络的这个越深的话，理论上来说啊，他能提取的这个特征应该是会更强一些对吧，而且模型如果越深，它能承载的这样的一些特征值就越多，但是啊啊在之前的一些实验当中。

特别是在对这个RESNET做一些实验的时候，大家发现一个问题啊，当这个网络变得特别深的时候，它会容易出现一些所谓的退化问题啊，退化问题我们可以看一下下面这个图啊，对于左边这个图啊。

纵坐标是一个训练集的这个啊错误率啊，可以看一下，对于这个20层的这样的一个网络结构来说，它反而错误率会低一些，56层的反而高一些啊，可以看到20层的低一些对吧，然后再验证这个测试集也是一样啊。

20层的这个测这个错误率会稍微低一点，56层的错误率会更高一点，这感觉和我们的这个常识好像是有违背的对吧，理论上来说你越深应该效果越好啊，那这就是所谓的一个退化问题啊，那为了去解决这个退化问题呢。

就提有就有提出了这个残差网络啊，残差网络，那为什么会出现这种所谓的一个退化问题呢，其实这个东西啊就可以啊，我们可以回忆一下昨天我们讲RN的时候，其实当我们去做一个很长的一个，序列的特征提取的时候。

那它很容易出现一些所谓的一些，类似梯度消失的一些问题对吧，那你梯度如果发生了消失，那你有些层其实更新的就不好对吧，你参数更新的就不好，那你模型其实收敛的效果就会变差，那这个其实就是所谓的一个退化问题啊。

那残差网络它是怎么解决这个问题呢，我们来看一下啊，残差的主要的核心思想啊，就是让训练变得更加简单，这个大家需要注意啊，就是让训练变得更加简单，我们可以看下下面这个图，首先呢我这边输入的是一个X。

然后经过了这样的一层，然后再经过一个软路这样的一个计划函数，然后又经过了一层这样的一个神经网络，最后进行一个输出，那正常情况来说的话，我们就是输出我们的FX对吧，我们把FX进行输出。

那残差他是怎么做的呢，它会把我一开始的一个输入啊，再给它一条捷径，这样的一条捷径，同时把我们的输入给到输出的位置，把输入和输出进行这样的一个相加的一个处理，相加的一个处理，那为什么要这样子做呢。

我们其实可以考虑一下啊，假如我们现在输入的这个X的值，它是十，假如输入的是十，X等于十，那我经过一系列的网络之后呢，那他这个差值实际上就是0。1对吧，0。1让我们去求解。

这个也就是说我们的一个输入和输出，其实相差的是特别小的，相差的特别小的，这个时候我们来求这个梯度的时候，实际上就很容易出现一些梯度过小的一些情况，从而类似于梯度消失这些情况发生。

那如果我们把原来的一个输入，和咱们的一个输出就合并在一起，最终就变成了这样的一个20。1对吧，就变成了这样的一个啊20。1的情况，20。0，那我们这个时候的差值是，实际上就变成了十对吧。

那这个时候我们再来求梯度的时候，就会更大一些啊，所以说残差的一个思想，就是说我会给你一条捷径，给你一条捷径啊，并且啊在我进行反向传播的时候，我也可以走这一条捷径，去求解它的这样的一个梯度，好吧。

就以这样的一个思想啊，来控制我们这样的一个梯度，不要让它变得太小，出现这种所谓梯度消失的一个情况，好，这就是我们的一个残差模块啊，残差模块那应用到我们的这个transformer当中，也是一样的道理啊。

那我经过了这个cf attention之后呢，我希望你这个收敛的时候啊，这个梯度回传的时候更顺顺畅一些对吧，所以呢这里就添加了这样一个残差模块啊，残差模块，OK那残差模块之后呢。

又添加了一层这个layer normalization，哎这个时候可能各位同学又开始以后啊，这个LANORMALIZATION他又是干什么的呢，好我们来看一下啊。

啊在说layer normalization之前呢，我们先来说这个normalization好吧，Normalization，normalization的话，它其实有很多种啊。

但是他们都有一个共同的目的，就是把输入转化成均值为零，方差为一的这样的一个数据，均值为零，均值为零，方差为一啊，均值为零，方差为一，所以说我们实际上就是要把数据送入聚合函数，之前呢，进行这样的一个规划。

大家可以考虑一下啊，那假如我不去做这样的一个规划的一些处理，我直接给到后面的一些层，那假如我现在不做过优化处理对吧，我们都知道我们在上节课去讲那个呃SIGMOID，还有ten h的时候。

我们都会发现一个问题啊，他的这个梯度一旦这个值太大或者太小的时候，就会容易出现一些所谓的一个梯度消失的，一个情况对吧，就看就像下面下面这个图，这是西格boy的这个激活函数，右边的话。

这个是tan h的一个激活函数，的梯度的这样的一个图，当你这个值稍微大一点点对吧，就容易出现一些梯度消失，或者说梯度爆炸的一些情况，那这个时候啊，我们就可以考虑去做一个所谓的规划，做完归一化之后呢。

我们让它的均值为零，方差为一对吧，那最终他的这个值就会聚集在这个这个区间内，聚聚集在这个区间内对吧，这边也是啊，聚集在这个区间内，那这个区间内的一个值，你去求解它的这个梯度的时候可以看一下嘛。

这些梯度其实就很大了对吧，这些梯度很大，这图梯度很大啊，梯度很大，就不容易出现所谓的一个梯度消失的，一个问题啊，啊这就是LEONALIZATION的一个作用。

那LINDONALIZATION呢比较常见的是两种啊，一种是这个BATIONALIZATION，那这个batch，normalization是在每一个batch上面去进行。

这样的一个normalization的，是什么意思呢，这个同学可能也有同学啊，这个在batch这个维度上面去做也什么意思呢，好我们这么看啊，我们这么看，那假如我现在好。

我们先从这个机器学习的一个角度来理解啊，从机器学习的一个角度来理解，假如我现在有一条样本，这个样本呢它包括了很多的一个特征，好吧啊，我假设我用X来表示特征，它可能有X1X2X3X4，它有四个特征啊。

它有这四个特征，这是第一条样本，这是第一条样本，那对于第二条样本来说，它也会有对应的X1这个特征，X2X3X四好，我用二再加个上标吧，啊这是一，好他是这个样子的啊，他这个样子。

那如果是对于第三条样本的话，也是类似啊，也是LH也是类似，那这个BACHALIZATION，他去做这个layer normalization的时候，他是怎么做呢，他是在换个颜色的笔。

他是在这个维度上面去做啊，他是在这这个维度上面去做，所谓的一个归一化这个维度去做，这就是我们的，Which honalization，那对于layer normalization，他是怎么做的呢。

Layonalization，他是在这个维度上面做的，而是在这个位置上面做的啊，好那可能有些同学就会问，那为什么我们的这个处理文本的时候，我们要去使用这种LAYONALIZATION的。

那我处理文本为什么不能用什么来，我们考虑一下啊，那假如我们现在是两条文本，那对于第一条文本来说，对于第一条文本来说，它可能长度这里是四，那对于第二条文本，假如它的长度是五。

那我们就需要在这个啊把这一条这两条文本啊，进行这样所谓的一个补偿的一个处理，也就是说我需要把我的这些输入的数据的长度，做成统一的，假如啊，我设置了一个叫做序列最大长度的一个参数。

这个参数呢假如我设的是五，假如设的是五，那对于长度比较短的那第一条文本，我们就需要在它的结尾进行补零，然后这个如果是五的话，那就是X5啊，补零好，如果补了零，我们看一下啊。

如果我在这个维度去做这个BATIONALIZATION，你看是不是就有问题了对吧，你明显我在这个维度去做这个规划，肯定是有问题的，因为你这里是零，还有其他位，那其他序列可能这个位置也是零。

所以就导致会出现这样的一些问题啊，出现问题，所以啊在文本上面我需要去做这样的一个layer，Normalization，在它的这个维度啊，就是绿色，绿色这个框的这个维度来做这样的一个lay，我们来的事。

好吧好，我们先啊，接下来我们再来看一下啊，他的这个bash normalization和这个layer，Normalization，它的一个计算是什么样子的啊，那这对于正常的一个规划来说。

它实际上啊就是咱们的一个，比如我们有一个X对吧，去减掉这样的一个啊均值，再除以这样的一个方差对吧，处于这样的一个方差，这是我们正常的一个啊规划的一个方式啊。

那对于BASSIONALIZATION和layer onalization，他是怎么做的呢，我们可以看一下啊，他还是一样啊，这个部分实际上是一样的对吧，这个部分是一样的，可以看一下啊，这个也是啊。

这个部分是一样的，但是除了这个部分呢，他这里多了个ABC龙，还有外面有两个参数，一个阿尔法，一个贝塔，那这个ABC龙是干嘛的呢，他就是为了怕你的这个分母是零。

所以呢通常会添加一个这样的一个episode，它是一个非常小的数啊，接近于趋近于零的这样的一个数，你可以设一个啊十的八次方啊之类的，这样一个特别小的一个数就OK了，好。

关键是在于这里的这个阿尔法和这里这个贝塔，那这两个东西呢，实际上是两个可以训练出来的一个权重啊，大家其实就可以很简单的把它理解为，我这里先做了一个普通的一个规划，然后给到了一层这样的全连接层。

其实全连接层也是这样的一个权重，后面一个偏移项对吧，分别对应的就是咱们的阿尔法，和这样的一个贝塔好，那这里可能有同学又会有疑问了，你这里啊我去做这个规划的，是时候啊，先把这个均值给减了。

然后除以这样的一个方差，结果呢你这里又先乘了一个东西，就感觉好像这个东西这个阿尔法对吧，和这一项相乘，那如果这个阿尔法就是它的这样的一个方差，那相乘之后是不是就约了，然后如果贝塔和这里这个mu。

如果又又是相等的话，那这里相加是不是也约了，那这个时候实际上就变回了，原来的这样的一个结果对吧，就变回了原来的一个结果，那为什么还要乘以这样的一个阿尔法和贝塔呢，关键原因就在于。

如果我们只去做这样的一个归一化啊，就会把模型之前学习到的这样的一个，数据分布给重新打乱，那可能我之前的一个模型对吧，已经学习就我前面的这些模型啊，我现在有这样的一个encoder部分对吧。

好我用用model bil是吧，model我现在有一个model，我这一部分已经学的很好了，已经学学出了某个这样的一个分布，但这个分布呢，你如果直接去做这样的一个规划对吧，他这个分布就会被你强行打乱。

那这个时候呢，我们就可以考虑加两个参数进来啊，一个阿尔法，一个贝塔，再把他学习到的这个分布给拉回来好吧，给拉回来就虽然我归一化了，但是我的这个分布是没有变化的，就是这样的一个意思啊，就这样一个意思好。

这就是我们的这个layer normalization，好吧，OK啊，我们这里先停一下啊，对于这里的layer normalization，还有咱们的一个残差模块，看各位同学有没有什么疑问的，有问题吗。

各位同学，有问题吗，各位同学，两种我们normalization可以同时用吗，一般用一种就好了，因为实际上你你只是为了去把他这个规划之后，然后防止它出现这种所谓的梯度消失的情况嘛，对吧。

所以你任选其一就行了啊，没有必要两种都用，你两种都用的话，实际上就等同于你做了两次归一化，这个实际上是没有意义的啊，没有意义的，好其他同学还有问题吗，好OK那我们就继续往下了啊，大家有问题及时提出来呃。

那transformer的一个encoder，基本上就给大家讲完了啊，讲完了，然后大家自己下来的时候呢，可以自己去找张纸，然后去画一下它整体的一个结构，到底是什么样子的好吧，自己去画一下。

把整体结构画一下，然后包括他的一个self attention，它内部是怎么计算的，你要把它全部写出来啊，写全部写出来，transformer是这个面试当中必问的好吧，必问的啊。

参数A和B是不是随机初始化的啊，对一般的话是就是你随机初始化就OK了啊，随机初始化就OK了，但是对于一些特定的一些模型，它可能会有一些特殊的一些初始化的一些方法，好吧，这个得看具体的一些模型了。

像BT的话，他可能有具体自己的这样的一套，这样的一个初始化的一个方式，好吧啊，每个倍数后面补的零会对模型有影响吗，啊这个是不会有影响的啊，这个好，这个我简单说一下啊，这个可能有些同学还不清楚嗯。

我看找一页空一点的好，我简单说一下啊，是这样子啊，我们一般处理文本的时候啊，因为序列长度不一样嘛，那可能有的长度假如是四，有的长度是五，有的长度是十，假如说九吧九，那这个时候呢我们首先第一步啊。

回去做一个序列，长度统一统一啊，那假如我们设置了这个啊，MAXINE等于五，这个时候对于四这样的一个序列，我们就补零，那对于九这样的一个序列，我们就会把它的末尾啊，末尾的四个词给直接给舍弃。

只保留前面五个词，就我X1X2，一直到X9，我会把后面这些词全部直接舍去啊，只留X1到X5，就是这样的一个情况啊，就这样的一个情况，那补零的话是不会有不会有这个影响的，不会有影响的。

为什么会不会有影响呢，是这样子啊，当我们补零的时候，因为啊我们在给到我们模型的时候，去计算这个attention的时候啊，大家啊如果去看过这个BERT的源码的时候，你会发现啊。

它其实有一个东西叫做啊attention mask，叫做attention，Attention mask，那这个东西是什么意思呢，就是说假如我现在有一条序列啊，X1假如一直到X5。

那那假如我现在序列长度是十，那我就会在这里补五个零对吧，补补个零，他这个attention mask它就是什么样子，它就是11111，前面是五个一，后面是零，然后当我来计算这个attention的时候。

就是我们计算这个Q和K进行相乘，然后除以根号DK的时候，那我们这里这个D和K会进行相乘嘛对吧，他这里就会把这个东西给引入进来，那我的那个矩阵啊，我的这个矩阵，那对于后面的这些位置啊。

后面的这些位置就这些位置可能是零对吧，这些位置是零，他就会把这些地方啊全部置为零，这些地方值为零，所以说啊你即使后面补零，也是不会有影响的，好吧，就是在你可以简单的理解为，就是说我在做腾审的时候。

他这些地方的权重是零，只要你补零了，这边就是零，好吧，这位同学啊，我有说明白吗，啊位置编码好，不着急啊，不着急啊，这位同学我也说明白吧，好OK好，我们继续啊啊位置编码我看一下，我这里有说吗。

哎呀位置编码没写啊，好这边简单说一下位置编码啊，简单说一下位置编码啊，位置编码是这样子啊，就是在我们输入给咱们的这个模型的时候啊，就我们输入给模型的时候，那这里大家可以看到啊。

这里其实是一个叫做token embedding的那个东西，也是some的那个world embedding对吧，那实际上呢在我们的transformer当中呢，还会引入一个叫做位置编码的一个东西。

那为什么需要位置编码呢，啊我们可以考虑一下啊，对于RN这样的一个模型来说，它是一个这样的一个创新的一个结构对吧，它天生自带所谓的一个位置信息，但是对于我们的transformer来说。

我们是一个并行的结构输入进去的对吧，包括我们在计算我们的cf attention的时候，它也是这样的一个矩阵嘛，所以它是一个并行的一个处理，它实际上是没有考虑这样一个，所谓的一个位置信息的。

所以呢我们需要把我们的位置信息啊，给添加进去啊，给添加进去，那在这个transformer当中，它的这个位置信息是怎么做的呢，它实际上是一个正余弦的一个计算，一个公式计算出来的啊。

这个可以给大家看一下啊。

那有点慢啊，有点慢。

好我这边先回到PPT啊，先回到PPT。

哎好我们待会再看哪啊，我这里先说，他这里呢会有一个这样的一个正余弦的一个公，式来把这个位置信息给计算出来，那计算出来之后呢，这里就等于有两个东西嘛，一个是咱们的一个token in bedding。

还有一个是咱们这个position随身embedding，他会把这两个东西啊进行一个相加，进行一个相加相加之后的一个结果呢，再给到咱们的啊相加之后的一个结果啊，就是这个东西啊，就是这个东西。

然后再给到后面的一个cf和参数，那这个位置编码其实有很多种啊，有相对位置编码，有绝对位置编码，那对于我们的这个啊。

transformer这个原始的一个模型来说啊，他是使用这样的一个正余弦的一个方式啊，啊有点慢啊有点慢好。

我们先给他那边加载着，我们先说后面好吧，我们先说这后面等那边加载出来啊，啊我们位置编码待会再说啊，我们先继续往下，那我们说到这里的话，基本上就把咱们这个transformer的encoder。

这一部分就讲完了对吧，包括他的ADNEREBALL，Mari，Had a tention，就都给大家讲完了好，那接下来我们就来看一下这个decoder，这一部分啊。

decoder这部分引入了一个所谓的一个，MASKET的东西啊，我们看一下这个mask到底是干嘛的，OK对于我们的这个decoder来说，我们回顾一下我们昨天的这个sequence。

sequence的一个内容，那同样是这样sequence sequence的一个模型，那decoder它肯定是这样的一个序列模型嘛对吧，他要不停的把这个值进行一个输出对吧。

所以decoder是要生成咱们咱们这样的一个，新的一个序列的啊，生成新的一个序列的好，但是transformer我刚才说了也说了一点啊，它是一个什么模型，它是一个并行模型，那如果是一个并行模型来说的话。

它去生成序列会有什么问题呢，我举个例子啊，就假如我现在啊有这样一句话啊，叫做人工智能对吧，我要把这句话，我要把人工智能这句话给生成出来啊，生成出来，那对于我们的这个RNN来说是怎么做的呢。

哎这里输入我们的一个起始符对吧，然后这边生成咱们的第一个字人，然后呢再把这个人给到我们下一个节点，然后来输出我们的一个弓对吧，他是这样的一个逻辑，但是对于我们的这个transformer来说。

它是一个并行的一个模型啊，并行的模型，并行的模型，它就不存在这样的一个，按顺序进行输入的一个情况啊，所以说在我们这个解码这个过程中，它就会存在一个问题，假如我要生成人工智能，这句话对吧。

当我们去做这个self attention的时候，我们会让这个Q和K进行相乘，然后得到这样的一个attention matrix对吧，那好我们看一下这个attention matrix。

如果我们不做任何的一个处理，我们把这个attention matrix展开，它其实是这个样子的嘛，它是它是这个样子的，好，这边是一个即时服，然后人工智能这边是人工智能，然后中止服，我们现在好。

我现在要根据这个起始符，人工智能，然后我们结果想输出人工智能终止符，这是我们昨天那个讲sequence，sequence这样的一个流程嘛对吧，输入的时候一定要有这样的一个起始符，没问题吧，这里好。

OK那接下来我们来看一下啊，那假如我现在想生成人这个字，在我们RNN里面是怎么做，是不是我只输入了起始符，但是在我们的这个transformer当中，因为是并行的人这个字啊，它实际上是可以拿到所有的。

你看起始符，人工智能这几个词的一个权重的，你看他这里实际上都可以进行相乘嘛，对吧啊，我这里用W表示啊，W1W2W3W4W五，理论上来说，如果人和人工智能这几个字如果不可见的话，理论上来说WR一直到W5。

他的权重应该是零对吧，应该是零才对，但是但我们现在这样一个情况，你去算这个Q和K的时候，你的这个QK是能是能互相去算这个权重的，也就导致我在预测人的这字的时候啊，我已经去看到了人工智能的一些信息了。

那这个时候模型会认为，我根本不是在预测下一个字，而是直接把这个人copy过来copy过来，那我去预测弓这个字的时候也是嘛，模型会认为哦，我只需要把弓这个字对吧，直接copy过来就OK了，对吧。

所以说对于这个transformer来说，你就是因为它是一个并行的，就没有办法来让它以RN的那样子，按顺序的一个情况来进行一个输出，那怎么办呢怎么办呢，我们考虑一下啊，刚才我们是怎么分析的。

我们认为如果我要生成人这个字，理论上上来说，我应该只能看到起始符，起始符对吧，也就是说只有W1，它这个权重应该是一个非零的一个值，其他的一个权重应该等于零对吧，应该等于零，那对于弓这个字来说也是一样嘛。

那我们要是在RN当中，我要生成这样一个弓，我可以看到起始符，我可以看到人对吧，那我可以看到起始符，我要可以看到这里这个人，那对于这里的这个啊W23吧，这是四对，这里的这个W23，W24和W25。

那这这几个值应该是零对吧，那这几个值应该为零，那对于质这个字来说也是一样嘛，那这个地方应该是零，这个地方是零，那这个地方是零对吧，对于结束符来说，它就可以看到所有内容了，就像我们昨天的那个图。

我这里最后输出了这样的一个啊，那个那个能字对吧，我这里输输入这样的一个能字，我最后要输出咱们一个结束符，所以说这个结束符它可以看到，所有是没有问题的，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，这是V啊。

Q和就encoder的Q和这个decoder的K进行相乘，拿到这样的一个权重矩阵对吧，然后我们再用这个权重矩阵，和这里这个V进行加权啊，进行加权啊，就是这样的一个思路啊，就这样的一个思路，好啊。

我们在这里停一下啊，对于这个mask可能理解起来会稍微有一点困难，让各位同学嗯，我这里有说明白吗，还需不需要再讲一遍，这里可能理解起来会有点小小难啊，啊还需要再讲一遍吗，各位同学，再讲一遍是吧。

好好再来一遍啊，再来一遍，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，这个权重就是你人和起始符的一个权重对吧，人和起始符的一个权重。

在我们的RNN里面，人只和起始符有关系，和其他是没有关系的，但是在我们的attention matrix里面，我们可以看到啊，人和其他的这些字也是可以进行计算的诶，对吧。

我的这个人可以和这些人工智能这些字，进行去这个权重的一个计算，那如果这个人和人工智能这四个字，能进行权重的计算，这说明什么呢，就好比啊我这里RNN里面，我直接把这个人工智能这几个字。

全部在第一个时刻进行了输入，给到了我第一个节点，然后让我节点输出人，那显然这种事不科学的嘛对吧，我应该只告诉模型啊，这是一个起始符，这是一个起始符，所以啊我们的这个W额，对于输入输出第一个字的时候。

我们的这个W1的R到五，他的权重应该是等于零，应该等于零才对对吧，应该等于零才对，所以呢我们通常就会把这些位置置零置零好，那如果我们现在要输出的是R哦，是输出的是弓这个字在我们RN里面是怎么做。

我们是把人作为了一个输入对吧，把人作为了一个输入，然后输出了弓，那对于RN来说哎这个时候输出弓的时候，他其实可以看到两个东西啊，一个是人，一个是我们的一个起始符对吧，这里我就不管了啊，一个是人。

一个是我们的起始符，它是可以看到这两个东西的，但是回到我们的attention matrix还是一样啊，还是一样，这个日这个攻这个字啊，他还是可以分别得到，即使符还有人工智能这几个词的一个权重。

但是理论上来说啊，我们应该让后面这，也就是咱们的W2的三到，他的一个权重应该是为零才对对吧，我生成弓这个字的时候，我只能看到起始符合人，其他是不能看到的对吧，所以这些地方应该置零，下面也是一样啊。

这个字的话，那就是这两个地方制零，能的话就是这个地方值零，然后结束符的话，就是我所有东西都可以看到对吧，所以这些地方就都是零，这都是零啊，好那正常计算的时候怎么计算呢。

就是我先得到这样的一个attention matrix，然后我去乘以这样的一个，啊下三角的一个矩阵就OK了，好吧，就是这样的一个思路啊，就这样的一个思路，因为这么一相乘的话。

是一的地方原来的权重可以保留吗，是零的地方原来的权重就全部置零了，好吧好有，我有说明白了吗，各位同学，OKOK好行啊，那如果我有的同学还是没有听懂的话，这个没关系啊，可以下来再复习一下这个课件啊。

可以下来再复习一下课件啊，接下来的内容的话哦，我们也不会完全用到这个mask，好吧好，如果听明白就好，听明白就好啊，这一块还是比较重要的，好我这边就顺便说一下啊。

顺便说一下咱们的这个transformer，它不是分为两个部分吗，一个是encoder对吧，一个是我们的一个encoder，一个是咱们的一个decoder啊，我们现在呢有两个这样的一个。

或者说我们的预训练语言模型啊，通常分为分为两类，第一类啊是以BT为啊为主的，这样一类叫做auto encoding模型，自编码模型啊，自编码模型，那BERT这样一个模型的一个结构是什么样子呢。

它就是我们的transformer的encoder，一个base版本的话是12层，12层，也就是说他就把这个船从我们的encoder拿过来，然后12层堆叠在一起，然后进行一个预训练。

这就是我们的一个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你基本上就要弄明白了，好吧，像昨天有同学不是提到那个GB t three吗，GBT碎它是怎么做的，它实际上就是一个GBT啊，这里它不是一个咱们一个普通版本的GBT，是12层。

他这个GPT碎，它这个堆叠就特别深了啊，就特别深了，它一共有1000啊，1900亿的参数，然后对于我们这个12层的一个啊BERT来说，它只有1。1亿的一个参数啊。

然后去BT税的话有啊1900亿的一个参数，所以他模型结构是特别大的啊，好这就是transformer这一块了啊，基本上就给大家讲到这里，然后看一下这边对。

还有哦，OK他的一个位置编码简单看一下啊，简单看一下呃。

它的位置编码，就是根据这样的一个公式给计算出来的啊，计算出来的，但是在bird当中呢，BT的位置编码和这个transformer自带的这个，位置编码呢又会有一点点不一样。

那BT当中的位置编码是什么样子呢，它是这个样子哈，这里也简单说一下，他是因为我们的BT，它最大的这个长度是1~512，就是你序列的最大长度是支持512，所以呢它会有这样的一个也是有一个啊。

Embedding metrics，Embedding metrics，那只是这个embedding matrix，输入的是这个序列的一个下标，就是如果你第一个位置，那就是一嘛，第二个位置是二。

第三个位置是三，最后一个位置是512嘛，他把这个位置信息啊，给到了这样的一个embedding matrix来，得到了所谓的一个position，Position embedding，好吧。

Possession embedding，这是BT的一个位置编码，和咱们的这个transformer的，位置编码的一个区别好吧，有区别，好接下来我们来看第二个部分啊，就关于这个啊一些读论文的一些建议啊。

一些读论文的一些建议，啊很多同学就是可能在才接触这个啊，NLP的时候呢，他可能会想说啊，那我能不能花些时间去多去阅读一些原论文，对吧，包括我们上课的时候，实际上也会讲完之后呢。

也会把这个原论文给罗列出来，我希望大家能去阅读一下原论文，然包括啊，像transformer这样的一些比较。

经典的医学论文啊，我是建议大家就一定要自己去阅读一遍好吧，就可能我上课讲解出来的东西，是我对这篇论文的一个理解，那你去阅读完这篇论文，你可能会说啊，我对这个东西可能还会有一些新的理解。

这也是完全有可能的好吧，就包括我去讲这个腾讯的时候，我去讲这个mask的时候，我都是根据我自己的一个想法来讲给大家听的，这种想法可能是我认为一种啊比较通俗，比较简单的一种理解啊。

所以说很希望大家能自己去阅读一下原论文，那你阅读完之后，你可能自己就会有一些新的一些收获。

好吧好，那接下来就说一下关于啊论文这一块啊，啊首先的话就是肯定就是一个找论文嘛对吧，找论文像各位同学就才接触NLP的时候，大家不需要去啊，就是说啊我一定要去深钻，就是某一部分。

或者说啊某一个点的这样的一个论文，像今年比较火的这个prompt，或者说contrastive learning对吧，大家可能现在都还是在打基础，那就没有必要去花时间去跟这些啊，比较新的这些技术啊。

你只需要去把一些嗯比较热门的一些东西的，一些论文给看一下，例如我刚才说的这个transformer对吧，或者包括今天要给大家讲的这个，text n n这一块的一些论文，大家可以去看一下。

还有像昨天给大家说的那个LUANTENTION，像这些经典论文啊，大家可以去好好看一下，那最近的这些比较新的论文，因为大家现在学的还比较浅，所以大家就可以不用去跟这些新东西好吧。

先把这些老的东西给先吃透啊吃透，然后等到等到你真的这个有一定的一些基础了，然后你再想去了解更多的一些东西，想去自己去看一些论文的时候，那你你也可以去啊，首先怎么找怎么找，你可以去简单的方式啊。

你可以去先去看一些资讯网站啊，包括咱们国内的一些什么知乎啊啊公众号啊，还有CSDN啊之类的对吧，像国外的一些什么mu啊，这些东西大家都可以去看，还有像一些专门啊推推这个paper的一些网站。

像paper weekly啊。

还有这个paper with code这些网站啊，大家都可以去看一下嗯，像这个我看一下啊啊paper weekly，大家可以去看一下对吧，它会有一些啊热门的论文的一些推荐。

然后还有一些那个啊paper with code，大家可以去看一下，那paper with code，它这是干什么的，就假如你现在想去做这个呃机器翻译对吧，你只要来到这个网站啊，这边有个机器翻译。

你点进去，他这边就会罗列出来啊，最近的一些啊索塔模型是什么样子的，包括它的一些代码，还有一些论文地址，他都需要全把你给罗列出来，你都可以来对应这里去点进去。

去阅读它的一些paper，要去看他一些代码都是OK的好吧。

然后这边的话我甚至还呃，最近有一个比较火的一个阅读paper的一个啊，叫做read，叫做read paper啊。

大家可以去看一下这个网站啊，啊它是一个阅读paper的这样的一个网站啊。

例如我啊举个简单的例子，就是你可以去把你自己的paper上传上去。

你也可以在他这里去搜索这篇paper啊，像我们的这个哎。

哎怎么老跳出来，像我们的transformer的paper对吧。

你可以在这里进行一个搜索好，你就可以啊，直接在这里进行这样的一个阅读，那他这边可以进行，他会帮你把这些什么表格啊，什么给提取出来，然后哦这个应该要登录啊，它关键就在于它很方便。

你去管理你的这个paper好吧，所以推荐大家去使用一下这个啊。

挺好用的啊，这是关于啊收集paper这一块啊，然后等到大家真的就是有能力了，或者说基础已经学的差不多了啊，就一定要去自己去阅读这样的一些paper啊，毕竟别人的这些解读，都是一些所谓的一些二手读物嘛。

那是别人的一些想法对吧，甚至可能还会有一些理解上的一些错误啊，所以建议大家这些比较重要的一些paper，一定要去读一下原论文啊，一定要去读原论文，那然后说一下关于如何去阅读这样的一篇paper啊。

那大部分的一些啊LP方面的一些paper的话，有两个啊，章节是比较重要的，一个是模型部分，一个是实验部分啊，那你只需要把这两个部分就是看完。

基本上就大概能理解一下啊，这篇paper啊，那拿拿到一篇paper的时候呢。

大家先不要去急着详细把整篇看完，你就先去看一下他的这个摘要是吧。

看下他的简介啊，先简单看一下啊，这边拍这篇paper大概是在讲什么的对吧，我对你哎先简单看一下啊，然后看一下对你是否有帮助啊，有帮助，OK那你可以去看像前面这些介绍啊，这些背景啊，你就可以先不着急看。

直接先去看它的一些模型结构对吧，模型结构是什么样子的，然后再去看他的一些相关的一些实验啊，像一些实验啊之类的，可以去看一下，甚至实验这些一开始你也不用细看，你直接去看他的这个这个结果啊。

看一下整体结果提升了多少，如果你对这个结果是满意的话，你再去看好吧啊。

这是一个阅读论文的一个这样的一个顺序啊，顺序，用下标做embedding，会不会造成下标值大的词作用吗啊不会啊，不会这个不会，并不是说你的这个下标越大，它的这个embedding就越大，没有这种说法啊。

没有这种说法，EMLP这个是这个要说什么吗，数值有序，embedding之后应该可能不止序有关系了啊，对他这个不仅仅是包含顺序的一个一个那个值，好吧，并不会出现这样一个所谓in白那个下标越大。

in be点越大的一个情况，不会出现啊，这个版型啊，这个继续说回我们的这个阅读paper啊，那啊大概了解了一篇paper之后呢，那接下来你可能会说啊，我想花一些时间去对这个paper去做一些布线对吧。

我想去把这个paper里面的一些东西啊，应用到我们自己的这个模型当中对吧，哎那怎么搞呢，你首先啊你可以去看一下这篇paper啊。

有没有啊，去开源这个代码，那开源的代码的话，那你可以自己去看一下。

就这个原论文的一个作者，他这个代码是怎么写的，像我们的这个啊attention一个为例，我们可以搜一下啊，看一下有没有啊，你看他这边哦，这个这个好像不是啊，我们再搜一下有没有，好像没有。

换一下刚才那篇啊，OK你看他这边实际上就会把这个啊罗列出来啊，这篇paper他的这个代码的地址，他就会把那帮你罗列出来，你就可以去看一下他的这个代码对吧，是怎么写的，你可以借鉴一下。

那其实啊各位同学可能没有复现过，如果复现过的同学的话，就会其实会发现一个问题啊，有些paper，他和自己的这个开源出来的代码会有偏差啊，就论文里面可能是这么说的，但实际上实现的时候他是另外一种实现方式。

就挺奇怪的啊，这个可能也是啊水分有点大吧，这样的一些赔款好吧，然后啊复线的话大概就是这个样子啊。

还有一点大家需要注意一下，就是复线这个东西呢，有时候你投入很多，会出现没有产出的一个情况，首先是市面上的确有水份的，赔本太多了，其次呢就是啊现在大部分这个paper啊。

他都是在这个英文的数据集上去做这样的一些，Ablation study，但实际上啊它在中文上有没有效果，这实际上是需要打一个问号的啊，所以就只能你自己去联系一下原作者，或者说你自己去做这样的一些实验。

来得到最终的最终的这样的一个结果，好吧啊，这是复线的这一块啊，那复线这一块我再简单说一点啊，就有些同学可能说啊。

这个复线到底该怎么去复现对吧，那这个东西还是建议大家先去才，你第一次去复现paper的时候，你不用着急下手，去找一些比较热门的，然后去看一下那些作者他是怎么写的代码好吧，当你看的多了。

你自然这种复现的能力，就会慢慢的给提升起来啊，提升起来好，这是关于阅读paper这一块的一些建议啊，建议，好那我们就继续往后啊，继续往后嗯，接下来就来我们第三部分啊，也就是今天的一个主要要和大家讲的。

一个内容啊，就是关于卷积神经网络这一块，我看一下哎，好像啊这样吧，我们稍微休息一会好吧，刚好讲了一半的一个内容啊，那我们就稍微休息一会，然后我们休息5分钟啊，休息5分钟，现在啊8。54啊。

我们九点上课吧，好吧，我们休息5分钟，我们九点上课，然后下节课，下半节课我们再来讲我们的这个卷积网络啊，卷积网络大家有什么问题就及时提出来好吧，及时提出来，上半节课应该难点就在于。

应该mask这一块是比较难的，其它应该难度不高啊，难度不高，好，我们稍微休息一会儿啊，好我们准备开始上课了啊，准备开始上课了，先看一下同学的问题啊，嗯LN和BN具体是怎么解决。

梯度消失和梯度爆炸的规划吧，数据大部分集中在中间，然后如何解决梯度消失和梯度爆炸的好，我们看一下，看一下啊，怎么解决，其实是这样子嗯，这是我们的这个SIGMMOID激活函数，这是ten h激活函数。

那SIG格MOID激活函数和tan h激活函数，最大的问题在于什么，它容易出现梯度消失嘛对吧，只要我的这个值，你看这西格玛id大于五，小于五的时候，这些地方的这些值，实际上就已经很接近于零了嘛对吧。

你看这里是零嘛，这里是零对吧，这些值已经很接近于零了，这些地方的值都是很接近于零的值了，那如果你不做规异化，那你的值就可能会在这些地方，那在这些地方的话，你的这个梯度是不是就会接近于零。

那就出现梯度消失的问题了吗，所以呢我们做完归一化之后呢，它变成均值为零，方差为一对吧，就会限制在这样的一个区间内，那这个区间内你可以看一下啊，这些梯度对应的是多少，就没有那么大嘛对吧。

你看这一块的这些梯度啊对吧，这一块的梯度对应过来，他就不会不会特别小吧，从而就解决了所谓的一个梯度消失的，一个问题嘛，也不能说解决也是缓解好吧，说缓解的时候更严谨一点啊，缓解更严谨，我有说明白吧。

这位同学，啊阅读配配的时候时常遇到公式看不懂的，或者说不理解公式所表达的意思，这个东西只能说是一个呃，一个慢慢我觉得慢慢熟悉的一个过程吧，就当你自己看了，多看看多了之后。

你反而会觉得这公式有时候会说的更明白一些，其实是这样子啊，为什么会有公式这个东西，大家有没有考虑过这个问题，为什么会有公式这个东西，就是因为他文字说不清楚，所以才会有文，才会有公式。

就如果你真的已经说的非常清楚了，那实际上是没有必要要公式这个东西，所以说当你自己去接触神经网络这些东西，接触的多了之后，你会发现那些公式其实都差不多，都会差不多，像，我们简单看一下啊。

那假如我们看一下这个，我们就简单拿这个公式为例嘛对吧，我们就拿这个attention这个公公式为例，就很多时候你去看到这个QK前程的时候，当你看多了之后，你第一印象就知道哦，你这个Q和K相乘。

你就是在求这样的一个权重，你很快就能反映出来这个东西是在干什么的，所以说这个东西你问我怎样才能看懂，真的就只有你自己去多看，你自己看多了，你自然就有那样的一个感觉了，好吧，看多了自己就有感觉了啊。

这个东西还是一个看多和看少的一个问题吧，好吧，这位同学，我觉得嗯没有一个特别好的一个方式去理解，还有就是你要详细去看一下，他对这个公式的一个说明好吧，详细去看公式的一个说明，只能慢慢看啊。

这东西只能慢慢看，你看多了要上看的稍微慢一点，自然就能看明白了好吧，这个的确是没有什么特别好的一些技巧啊。

我觉得还是熟能生巧的一个过程吧，好吧，好我们来看我们今天第三部分啊，第三部分就是关于这个啊，CN这一部分的一个内容，啊，那对于一个咱们常规的来处理这个文本的，RN来说，他的一个时间复杂度是ON对吧。

因为它是按顺序来的嘛，你序列长度，假如你是那个序列的长度是N，那它的时间复杂度就是ON，所以这个时间复杂度啊它是ON，那通常呢我们去使用RN，提取了这样的一个文本特征之后呢，都会使用最后一个时刻对吧。

最后一个时刻的一个值作为它的一个输出值，给到我们的这样的一个分类层，进行这样的一个分类好，但这里啊RNN，它实际上只考虑了每一个词或者字的特征，那如果你是分字，那考虑就是字的特征，如果是分词的话。

你要考虑的是词的特征对吧，那我们考虑一个问题啊，能不能就说为特定长度的一些词序，去计算出它的一些特征表示呢，或者向量表示呢，例如我这里有句话啊，我们做个分词，他毕业于上海交通大学对吧。

他其实我们把它分成一些小短语，他可能会有，他毕业于毕业于上海与上海交通对吧，还有上海交通大学，那我们使用RN的时候，都是这样的一个字一个字的这样的一些提取，这样的一个特征，那我们能不能组成一些短语对吧。

像他毕业于，我们把这个东西的一些特征给提取出来，或者说上海交通大学，这一整个短语的特征给提取出来对吧，那能不能这样子做呢，好这就能，这就是如果你想去提取这样的一个特征。

就需要用到我们的这个卷积神经网络啊，卷积神经网络，Ok，接下来的话，我们就简单看一下这个什么是卷积神经网络啊，那说到这个卷积神经网络呢，第一点我们肯定要来聊什么是卷积对吧，什么是卷积，然后呢。

我们通常啊我们称这个F乘以G就为F和积累，这样的一个卷积，那这里有两个定义啊，一个是这样一个连续的一个定义，连续的定义的话，那就是去求这个不定积分啊，那对于离散的话，那实际上你就是一个求和的一个过程。

求和的一个过程，那这里可能各位同学看起来会有点懵啊，啊有点懵，你这到底什么意思啊，啊不着急啊，我们继续往下看，继续往下看好，那例如例如啊，我们现在啊有这样的一个啊式子啊，就是我们令这个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了好吧，下移一个位置，那下移一个位置之后呢，就到了这个位置，就到了这个位置，我们再在这个位置做卷积，就拿到了负的0。5，那这个就表示的是这三个词的一个特征对吧。

那接下来的话我们继续往下吧，那就到了这个位置，好，画错了啊，这个位置，然后继续就得到了这样的一个值，然后我们就一直往下，直到我们卷积核到最后这个位置，做完卷积之后拿到这个值。

那我们整个这个卷积的一个过程就结束了啊，就结束了，接下来呢我们就把这个卷积的一个结果，继续给到后面的一些层进行处理，那最终的话我们会给到我们的分类层，然后拿到我们的loss boss进行BP。

得到我们的梯度，然后来更新咱们的这个更新，我们的这个额选集合好吧，这就是我们整个的流程啊，整个的流程，那好我们接下来再看一个情况啊，刚才那样刚才的情况会出现一个什么状况呢。

我们这边输入的序列长度是七对吧，我们输入的序列长度是七，经过卷积处理之后呢，我们这个序列长度变成了多少，变成了五，变成了五，那如果我们现在做的是N12，我们做的是N12，我们做的是序列标注。

你把我这个序列变成变短了呀，你不能把我序列变短啊，你变短了，我这个还怎么做N1加对吧，那怎么搞，我们就可以做一个所谓padding的一个处理，padding的一个处理，我们在他的这个头。

就是在我们序列最开始的位置先补零，然后在序列结尾的布置位置我们也补零，也补零，然后应用咱们的一个卷积核之后呢，我们拿到的输出结果啊就还是七七啊，序列长度就不会变，就还是七，原来我们序列长度是七对吧。

补了零之后，我们的序列长度就变成了九，然后经过我们的卷积之后呢，序列长度还是保持原来的一个七好吧，保持原来的一个七好，这是我们的补贴，我padding的一个操作啊，那除了补padding呢。

我们还要再理解一个概念啊，叫做多通道，多通道对于我们的图片来说，我们图片是分为RGB的嘛对吧，RGB他有333部分吧，三三原三原色吧，它有三个部分，那三个部分呢在图片当中，也就等于它会有三个通道对吧。

那三个通道我们是不是就需要应用三个kernel，我们每个通道给一个这样的一个term kernel嘛，对吧，三个通道的话就三个kernel，那对于我们这个文本来说，我们也可以给它多个kernel。

你不同的kernel提取的这个特征的角度，可能就会不一样对吧，这样的话我们就可以提取出不止一个特征，你看这里就提取出了三个特征，因为我们三个合同这里就提取出了三个特征，就这样的一个意思啊。

好这是多通道多通道好，接下来的话我们来说一下磁化了，磁化，那经过我们的这个，卷积之后呢，我们实际上拿到的是这样的，一个这样的一个矩阵对吧，这样的一个矩阵它是一个7×3的，它是一个7×3的。

那我们没有办法把这个东西是，直接给到我们的这个啊分类层的理论上来说，分类层他应该拿到的是一个一维的一个向量，对吧，你这里是一个二维的，那我们通常呢就会去做一些所谓的一个，池化的一个操作啊，池化的操作。

池化一般有两种啊，一个叫做最大池化层，还有一个叫做平均池化层，最大池化层什么意思呢，就是说我只去取你的最大值，平均池化层的话就是取均值，例如我们这里去做这样的一个最大池化层，那我就会把这个特征啊。

第一个维度的特征的最大的那个值给取出来，那这个也是啊这个维度最大的特征给取出来，这个同理啊，最大的特征给取出来，然后把这个东西呢，就作为我们最终的一个向量表示，然后给到我们的这个分类层。

直接就可以给到我们的分类层，或者说我可以在这里啊先加一个dance层，就全连接层，经过我们的全连接层之后呢，再给到我们的soft next，再来进行我们的求求求这个loss啊，求loss。

这就是我们文本当中的卷积网络的一些处，理的一些逻辑和流程，好吧好，接下来的话我们就来看一下，那这个卷积神经网络它的这个处理的这个流程，这个图片的一个大小它到底是怎么变换的啊，例如我现在输入一张图片。

它的一个大小是W乘以W好，那接下来的话，我们需要去定义我们这样的一个filter，也就是咱们的这个卷积核，这个卷积核的大小假如是F乘以F好，让我们设一下我们的步长啊，步长是什么意思呢。

就是我到底是走几步，刚才的这个里面我们每次都是走一步对吧，但实际上你也可以每次走两步，也可以走三步都是可以的啊，好这是我们的这个步长，而最后还有一个叫做padding，padding的话。

就是我们刚才的那个五零啊，五零，好接下来的话我们就来算一下啊，如果我们采用的是一个叫做啊，valid的一个形式，value的意意思就是图片的大小是可以变的，没关系啊，那这个时候我们输入的这个这个啊。

不能说图片啊，就是说我们的是一个输入和输出，它的一个维度是保持啊，可就是是可以变的，那如果是sim的话，就说输入和输出的这个维度是要保持不变的啊，就是这个维度啊，维度指的是它的一个序列长度的这个维度。

OK那如果是可变的，那我们的一个输入和输出之后的一个变化，是什么样子的，那就是用我们的W，减掉我们的这个卷积核的大小，然后除以我们的步长，然后加一这个值，就是我们输出的这个结果啊，输出的一个结果。

如果我们要保持它的这个不变，序列长度的这个维度不变，怎么做呢，就是W加上二乘以padding，为什么是are呢，因为有padding前面也会补，后面也会补对吧，所以要乘以二。

然后减掉我们的这个啊kernel的一个大小，然后再除以我们的一个步长，然后最后加一，就得到了我们的一个输出之后的一个结果啊，所以大家之后再去写这个卷积神经网络的时候，你需要去给这个卷积核去定义大小对吧。

那你就要去计自己手动自己计算一下，我经过卷积之后，我这个卷积核或者说我经过卷积之后，我这个维度变成什么样子了，这个东西你是自己需要去计算出来的，好吧，这样的话你去写代码的时候。

你才能把这个卷积核的一些参数给设置好啊，好这是啊，这基本上就是要给大家讲的，在文本当中的这个卷积神经网络的这个基础了，好看各位同学有没有什么问题啊，有问题吗，这一块，有问题吗，各位同学。

这能加尔腾什么可以加可以加，完全没问题，你可以把这个，如何加是吧嗯这样子啊，嗯X1X2X3X4X五好，假如我现在做我这个卷积处理对吧，我可能啊我每次就取了两个词好，那我X1和X2做一次卷积。

我可以得到这样的一个值，我用啊我用M来表示吧，M是M1，然后X2和X3走M2，这里又可以得到一个值对吧，在这里又可以得到一个值，好这几个这四个值的话，就是我们这个卷积这一块的一个结果。

对吧好OK那你既然有了这个东西，那我是不是就可以针对于这四个值，作为一个所谓的cf这个tension，对吧，我就可以做一个self或成什么对吧，那做完之后，你是不是就是得到了这样的一个加权之后的。

一个结果，你再把这个加权之后的一个结果，给到下面的一层，然后再来做我们的分类就OK了好吧，所以说这个腾讯你想怎么加都是可以的，都是可以的，好我有说明白吗，这位同学，而且你也可以不按照我这个思路来。

你也可以先对这里做腾审，做完了腾讯之后，你再来做这样的一个卷积也是可以的啊，也是可以的，额这个东西大家可以不用着急啊，然后啊我们待会再做应用的时候，这位同学不是这一块怎么应用，这个不用着急啊。

待会我们还是会讲解，如何去做这样的一个应用的啊，那像这位同学说这个腾讯怎么加，其实你这样的一个想法我觉得挺好的啊，挺好的，已经想到了去怎么去尝试做一些基础的一些啊，模型结构进行修改。

这样的一个想法挺好的啊，挺好的，好我们继续往下啊，卷积操作提取的是相邻词的关系，对对对，就像我这里开始说的，你看我实际上提取的是这样子的东西吗，提就是相邻词，你说白了提取的就是一个所谓的短语对吧。

提取的就是一个短语，短语短语特征，我们RN它只能提取单个词的特征对吧，上了卷积之后呢，我们就可以提取一些短语特征，你甚至可以在短语之后呢，我们再做一次卷积对吧，我这里可能提取出了一个短语特征。

这里提取出了一个短语特征，假如这是M1，这里是M2，我可以在这里再做一次卷积，卷积得到一个N1，那这个东西就是可能就是一个段落向量对吧，或者句子向量啊，句子向量，好啊，其他还有问题吗，没有问题的话。

我们就进入到CN的这个应用了，有些短语没有意义，确实，但这个东西你想啊，如果没有意义的话，我们再进行那个反向传播的一个过程，因为权重会更新嘛对吧，你群众会更新吗，你权重更新了。

对于没有意义的那些词的那些特征，那就小嘛，那还有这里啊，我们这里不是会做这个最大池化吗，那对于这个没有意义的，那些那些值就会被过滤掉嘛，因为我们取的是最大池化的一个操作，最大值化就是保留最大值嘛。

你没有意义的那些东西对吧，那些特征就可能就舍弃了，好吧，这位同学，好OK我们继续啊，啊我们来第四部分啊，关于CN在文本当中的一些应用啊应用，然后这边呢我们先来看第一部分啊，叫做tx i n tax n。

那既然要运用的话，那肯定是先用我们的CN来做这样一个，所谓的文本理解对吧，或者说N2U，那这里罗列了啊两篇paper啊，两篇paper，这两篇paper呢都是使用这个CN来做这样的一个，文本处理好。

那接下来我们就来详细看一下啊，这两篇结构，这两篇paper的这个提出来的，这个结构其实是很类似的啊，很类似，我们先看第一篇，第一篇嗯，它是有这样的一个句子啊，这个句子。

那这个句子呢我们会去应用这样的一个不同的，这样的一个kernel，可以看到啊，这里有这个红色的，还有这里有这样的一个黄色的这样的一个kernel，去提取它的一个特征，提取特征，那提取出来之后呢。

我们就可以去做一些这样的一个，所谓的池化的一些操作对吧，池化的一些操作，然后把提取出来的特征全部组合在一起，那组合在一起之后呢，再给到我们的全连接层来进行一个分类，很简单对吧，结构很简单。

这就是最简单的一个TXN的一个网络结构，好我们再来看一下下面这篇这篇的话啊，会更详细一些，我们想我们赶来看一下啊，他怎么做的啊，输入一句话，i like this movie very much好。

这句话一共有1234567个词对吧，七个词每一个词它的向量表示的维度是5A好，那这里就是一个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的，那我们再提起一次，就得到了这样的一个值，那对于下面的粉色和那个绿色的，和我们黄色的卷积核也是一样的，处理逻辑啊，分别去做卷积，那这里是第三个。

第四个，还有第五个，第六个好，做完之后呢，他这里也是一样啊，取了一个最大池化的一个处理，那四个深红色的就能就只能拿到一个结果对吧，这个红色的也是拿到一个结果，绿色的拿到一个结果，浅绿色一个结构。

黄色的一个结果，柠檬黄的一个结果对吧，那最终呢就是拿到六个结果，我们再把这六个结果啊拼接在一起，拼接在一起，拼接完之后呢，再给到下一层，我们就可以来进行这样的一个所谓的分类分类。

这就是我们TXN来做文本分类，这样一个比较典型的一个模型啊，好这里就建议大家可以自己去阅读一下原论文，好吧，原论文，那TAXN它最大的优势在于什么地方呢，它网络结构非常简单，可以看到吗，特别简单对吧。

然后他的一个参数量也是特别少的啊，特别少参数量关键就在于这几个卷积核对吧，卷积核关键就在于卷积核后面没什么参数了，你看一个最大石化一个拼接，然后一个全连接层，关键就在于这里的这个卷积核的一个参数啊。

好这就是咱们的一个TXNN好吧，TXN那对于CNN来处理文本来说，它其实也有一定的缺点啊，啊大家觉得对于CN来说，处理文本你去大家觉得会有什么样的一个缺点，嘘什么意思，序什么意思，单向传递什么意思。

单向传递什么意思，其他同学的其他同学有什么想法，只有局部特征，其实这位同学说的很有道理啊，这是局部特征，那大家可以可以其实可以考虑到啊，那对于CN来说，他其实感受也很小的对吧。

他只能考虑到一些局部的一些特征，他没有办法去考虑到一个全局的一个特征，所以说对于一个长文本来说，它是不适合使用RN来处理的，除非你的这个RN特别深啊，特别深，就是像我刚才说的那种，就你这里做了一个RN。

这里做个RN，这里又做个RN对吧，那么可能后面还有啊，然后这里RN这里做RN，这里这样一直做RN，一直做RN，那这样的话你可能到了最后这个位置，可以考虑到一个全局的一个信息，但是其实上整体来说啊。

这种结构实际上是嗯比较臃肿的一个结构啊，也不太美观，所以说对于RNN那个CN来说啊，CN来说它只适合去处理这种短文本啊，只适合处理短文本，对于长文本来说，我们还是尽可能去使用。

类似于ISTM这样的一些结构，或者说transformer这样的一些结构来处理，短文本的话，我们用CN来处理，好吧好，除了这一点，其实还有一点啊，就是我们的这个CNN。

它没有所谓的一个序列的一个概念对吧，它没有一个所谓的一个输入顺序的一个概念，所以啊我们在使用TXCN的时候，通常也会把这个啊possession embedding，我随身引白领也考虑进去好吧。

我随身embedding可以考虑进去啊，把它加上去，对他其实会容易丢失很多这样的一个信息，所以我们的这个text n通常你要去做分类的话，只用来做短文本的分类好吧，短文本分类，长文本分类的话。

我就不推荐大家使用这个TAXN，好这是我们的TXN啊，Tx n，然后最后的话我们再来看一个模型啊，这篇模型的话啊，这篇paper的这个模型呢，就是用我们的这个CNN，来做我们的这个啊序列生成啊。

序列生成，那对于我们昨天给大家讲的这个sequence，sequence来说，我们都是使用的这样的一个RN的一个结构，对吧，那在这篇paper当中呢，他把这个RN的结构啊替换成了这个CNN。

但是替换成CN其实很容易出现一个问题嘛，就是我们刚才在给大家介绍transformer的时候，提到了这个所谓的一个，提前看到一些额外的一些信息嘛对吧，可能会出现一个所谓的标签泄露的一个问题。

好那我们就看一下这篇paper它是怎么解决的，好我们先看encoder部分啊，上面上面这一块的话是咱们的一个啊，encoder部分，这是我们的一个输入对吧，这是我们的一个输入，经过embedding层。

embedding层之后呢，他去做了这样的一个卷积，这个卷积的话，它它的这个卷积核的这个大小应该是三啊，应该是三，每次取得这样的三个词去作为一个卷积，好，做完卷积之后呢，啊它这里每个卷积会有两个和。

所以呢他就会得到两个值，OK做完这里大家肯定又看到一个熟悉的东西啊，哎git的linear your nice，这是啥，这不就是LSTM当中的门控机制吗，对吧，取了一个SIGMOID的。

拿到咱们昨天说的那个所谓的一个概率，再把这个概率和这几个卷积得到的一个结果，进行相乘，然后得到我们经过门之后的一个输出值，好这是我们第一个卷积，然后这边也是啊，还是取三个序列的大小。

做这样的一些卷积的一些处理，加上门控机制得到它的一个特征对吧，这边也是，这就不重复说了啊，好，这样的话，我们就得到了一个卷积之后的一个结构啊，卷积之后的结果，然后呢，他会把卷积之后的一个结果。

和原始的这个输入的这个embedding啊，一起拿过来进行一个相加的一个处理，这是什么，这是什么，各位同学，这是什么对吗，这就是参差吗，有没有发现一个问题，你一个新的模型结构。

实际上就是建立在老的模型结构的一些优势上，把一些老的模型结构的一些缺点给进行改良，然后把该拿着东西给拿过来对吧，这就是所谓的一个残差啊，好而这个地方就是我们的一个特征，然后这边是一个残差，残差之后呢。

它一个残差模块的对吧，相加之后呢，他继续往下走啊，但是呢这边它还没有结束啊，他会把这边根据CNN提取出来的特征啊，会给到这边来做一个所谓的腾审，那这个腾讯的目标是什么呢，是decoder的这个结果啊。

decoder的一个输入啊，以后的一个输入好，他是怎么去解决这个所谓标签泄漏的呢，他在前面去补了很多这样的一个padding位啊，补了很多的一个牌定位，然后这里我们看一下啊，还是一样啊，他每次取的时候。

他是你可以看一下他关注的词是这样子，他取的是前三个词，前三个词啊，他把这个拍定位给考虑考虑进去了，前面有两个拍定位，大家需要注意一下啊，前面有两个拍定位好，然后呢这边还是一样啊，两个卷积核。

然后经过我们的门控机制，然后相乘得到这样的一个，经过门之后的一些特征对吧，这样也就有四个特征，那我们先看第一个特征，第一个特征实际上是只有起始伏S，而对于第二个特征来说，它包括了起始符。

还有这个东西对吧，那对于第一个，那我们再把它对应过来嘛，对应过来，那就是这个位置就是对应到这个地方对吧，这个地方就和我们的这边这个值，进行这样的一个额腾省的一个处理啊，啊TENTION的一个处理。

那这边就对应过来啊，都是一样的，对应过来去做这样的一个腾讯的一个处理，最后呢我们这边就能拿到我们这个输入值和，encoder的一个输入值，和我们decoder的一个输入值的这样的一个啊。

Attention matrix，也就是bot product的一个结果啊，dot product一个结果，他这里就会进行，那乘完之后呢，这个矩阵就是我们的一个权重嘛对吧，那拿到这个权重呢。

我们就和这边这边的一个输入，就经过残差之后的一个输入，去做这样的一个加权求和的一个过程，加权求和的一个过程，加权求和完了之后呢，那我们就能拿到这样的一个值，再把这个值啊。

和这个decoder的这个值进行这样的一个相加，进行这样的一个相加，那这一个部分其实也和昨天给大家去讲这个，sequence sequence的时候实际上是很类似的啊，昨天的那个怎么讲的呢。

昨天那里实际上是做了一个平结啊，这里是一个相加啊，相加完之后呢，再进行这样的一个结果的一个输出，结果的一个输出吧，他就是以这样的一个思路来做的好吧，好这就是我们的这个使用CN来做咱们的这个啊。

Sequence，sequence的一个任务，OK基本上要给大家讲的模型结构。

就是这些东西了啊，然后接下来呢，我们就一起带着大家来把这个TXN这一块的。

一个模型的这个代码啊，给复现一下好吧，复现一下，啊然后我们这边简单说一下啊，在我们之后的一些课程当中呢，我们都会使用这个PYTORCH啊，PYTORCH那PYTORCH的话啊，相比于TORFLOW来说。

它的这个使用起来会简单一些，并且啊，目前越来越多的人都在使用这个PYTORCH啊，好我们这边就要重新进重新新建一个好吧，嗯TAXN啊，然后我们把它先删了啊，先删了。

OK我们就一起来带着大家把这个TXN那个啊，复现一下啊，复现一下好，有些同学可能说啊，我没有用过PYTORCH，不会不会没关系，你看我写一遍你就会了好吧，很简单啊，PYTORCH很简单，怎么构建模型呢。

首先，我们把咱们的这个touch给导入进来啊，然后我们把常用的这个NN也给导入进来，OK接下来我们简单说一下啊，你在PYTORCH当中要定义一个模型，该怎么定义呢，新建一个类，新建一个类啊。

然后我们让这个类继承自NN导MODUN打磨点，继承自N打磨点，然后我们需要重写它的两个方法哎，一个是它的一个构造方法，一个是构造方法，那构造方法是在干嘛呢，构造方法是在注意啊，注意听构造构造方法是在啊。

准备我们需要用到的layer，就是说你的模型结构需要用到哪些layer，那你就在你的构造方法当中去写，好吧好，这是我们的一个构造方法啊，还有一个是咱们的这个啊for word方法，for word方法。

这个方法是在干嘛，哎今年怎么回事，这个方法是，嗯不要了吧，pass掉这个方法就是把layer拼装起来，拼装起来，进行前向传播，啊这就是我们的for word方法啊，forward的方法。

OK我们一步一步来嘛，我们就先来准备我们需要用到的一个layer啊，这里我们先不考虑考虑位置编码啊，好吧，首先是什么，看一下，第一步是什么，embedding嘛，Embedding。

直接就调用NN导embedding，我们就定义好embedding层了，那embedding第一个参数是这个词典的一个大小，啊啊我们用，我们把这个参数从外面传递进来啊，从外面传递进来。

然后我们还需要一个参数啊，是这个embedding size，embedding size就是embedding的一个维度，我们也从外面传递进来啊，传递进来好，embedding层我们就定义好了。

接下来是什么，我们看一下三种卷积核对吧，那我们就定义三个卷积层吧，我们就叫CNN啊，NN导cod好，然后我们考虑一下啊，我们输入的这个embedding它是一维的对吧。

所以说输入的这个channel的话，它是一好，主要是我们要考虑一下我们的输出的channel，输出的这个channel的话，我们输出的是两个对吧，那我们就输个二就OK了啊。

然后是我们的这个kernel size啊，kernel size好，我们这里的kernel size是234对吧，第一个是二，然后第二个维度要保持一样嘛，和embedding size保持一样对吧。

那我们用元组吧，好那我们第一个卷积核，这个第一个卷积层我们就定义好了，接下接下来呢我们还需要定义两个对吧，一个是二，一个是三，哎这是二，啊分别对应我们刚才的这两个对吧，那我们这个维度就需要改一下啊。

改成这个三的四三的四好，那就变成了234好，三个卷积没问题吧，三个卷积OK卷积好了之后，我们看一下还差啥，哎怎么回事啊，怎么切不过去啊，卷积网络是不是池化对吧，池化好，那我们来定义我们的池化吧。

嗯我们叫们XP，好定义我们的一个池化，Ok，接下来我们要考虑一下，我们的一个kernel的一个大小啊，kernel的一个大小，这里kernel大小是多少呢，那假如我们现在哦我看一下啊。

我们需要有一个序列的最大长度嗯，我们看一下啊，这边序列最大长度设置是多少，好我们这边序列的最大长度设置的是32啊，32，那32的话我们考虑一下啊，序列最大长度是32对吧，32。

那我们的这个kernel大小是二好，也就是说我们输入的这个是32，然后续这个克隆大小是二，然后我们步长是一，那我们输出结果是多少，来各位同学，31其他同学呢，其他同学还有不同的一个结果吗。

这同学没有了是吧，好这是31啊，这是31好，我们接下来还需要两个这个石化啊，啊大家就一起来思考这些问题好吧，因为你在写代码，其实你自己去写的时候，你会遇到这些问题的，所以大家就一起来思考啊。

一起来思考好，这就是那因为这个是三嘛，哦我说一下怎么算的啊，首先是32对吧，你需要去减掉你的这个那个可等一个大小，那32减掉二，那就是30，30的话，那除以步长除除以不长的话，那就是一嘛。

但是还是30对吧，那最后还要再加一对吧，我们可以一回回到哎怎么回事，诶怎么回事，怎么奇奇怪怪的点不回来了对吧。

那我们这边还要再加一嘛，所以就变成了31好，这里就是30，那最后一个的话就是29对吧，29好，最后的话我们可以定义一个啊，加个drop out吧好吧。

drop out trip part的话就是用来防止过拟合的啊，drop part我们可以给他这样的一个概率值啊，零点啊，然后最后来一个dance层嗯，dance层的话就是点兵也点mini2，好阴影。

那假如我们的这个embedding in size，我们用embedding size乘以三吧，乘以三啊，为什么乘以三，啊如果我们这里是我们看一下啊，是不是乘以三呢，哎我看下哎我这是我这是输入值对吧。

输入值输入值的话其实就是我们的啧，怎么回事。

数值的话实际上就是这一块对吧，就是这一块，那实际上我们这里一共有啊，这边是有两个值，这边两个值。

这边两个值，那一共是六个值对吧，一共是六个值，那就不是这个东西啊，这里应该是我直接写啊，直接是六个值，六个值，output channel是二，所以2×3，所以这就是六啊六，然后我们假设要做一个二分类。

那这里你就输出二就OK了啊，输出二就OK了，好这就是我们需要准备的一些网络结构，准备好了之后呢，我们来看我们的for word方法，forward的方法把雷也拼装起来对吧。

那首先呢就是得到我们的这个embedding嘛，我们调用一下我们的这个self法，Embedding。

我们需要把X传递进来啊，哎。

好把X传递进来啊，传递进来，然后我们这边可以做一个这样的一个，这是在干嘛呢，就是给第一个维度啊，再加一个维度，因为我们这里是个二维卷，对于图片来说它是一个四维的嘛，那对于我们文本来说是一个三维的。

所以我们可以在第二个维度，也就是也就是啊一的这个维度，去给他扩一个维度啊，扩一个维度好，那我们接下来就进行一个输出，那第一层的这个cn cn out1吧，cn out1就调用我们的CNN1对吧。

然后把我们的这个结果啊传递进来，embedding传递进来，然后我们这里可以把那个那结果再缩回去啊，我们也可以用square方法把最后一个维度给去了，嗯其他也是一样啊，我们把这是二。

这是三好处理完之后呢，我们接下来就是做什么石化嘛对吧，我们可以调用一下我们的max p，next p啊啊，这样的话我们就能得到我们的第一个，最大池化层的一个结果，我们来看第二个，哎嘶哎呀。

这个键盘不太习惯，这是第二个，这是我们的第三个，第二个三个，OK那这些都准备好了之后呢，我们就可以做一个什么啊，我们看看这边怎么做的，石化层拿到了一个结构进行拼接对吧，再给到我们分类层。

那我们也是一样的，我们调用一下cat方法啊，把它给拼接在一起，alt1alt2alt三，好拼接在一起呃，拼接的这个维度呢是一这个维度啊，还是一样啊，我们去把最后一个维度给去了，得到我们最终的一个输出值。

然后我们这边可以调用一下我们的这个DP out，把我们的这个alt放进来好得到我们的输出值，我们再把我们最终的这个输出值啊，给到我们的dance，dance把out加进来，OK最后进行输出。

然后我们把我们的这个out值返回，OK整个我们的模型啊就搭建完成了，搭建完成嗯，接下来的话我们来看一下啊，我们把我们的这个tag n返回一下，是二对吧啊，然后两个参数，一个词典大小。

一个embedding size，OK我们执行一下代码，看能不能一遍过啊，啊各位同学可以直接在自己的笔记本电脑上跑，是完全没问题的啊，因为TXN这个模型结构比较简单，所以大家自己在自己的笔记本电脑上跑。

应该也是可以跑的，你没有GPU应该也是可以跑的啊，这个不用担心，模型结构比较小，然后这边的话还会有一些包括额，数据的一些处理，这些东西的话就是一些逻辑代码了，我这里就暂时不给大家说了，好吧好。

这边就已经开始进行一个啊训练了啊，开始进行训练了啊，可以看到他这个效果好像是不太理想的对吧，不太理想，那我们可以考虑去简单调整一下，它的一些参数啊，他这里这个output channel的话。

就说你运用了几个这样的一个channel对吧，那我们可以考虑运用多一点的嘛，如果你太简单，我们可以考虑运用多一点啊，我们搞个搞个20吧好吧，看一下效果有没有提升，搞个80。

那这里的话就变成了就变成60好，我们再试一下，哎好像效果变化也不是很大是吧，嗯好像比刚才稍微好一点点嗯，再把这个参数简单调一下啊，我们再试一下，呃其他的话我们也可以再调一下，其他的一些东西啊。

呃这个哦对数据集我都忘记和大家说了，这个其实就是一份那个，情感分析的一个数据集啊，还有啊一和零一的话就是正面情绪，零的话就是这样的一个负面情绪啊，负面情绪，好基本上整个流程就是这个样子啊。

然后我们看一下啊，诶这里好像有问题啊，这里忘记改了，咦这里好像我看一下啊，词典是在哪里拿的，我记得我这个词典都还没生成呢，我们执行一下这个啊，OK这边我们看一下词典，1万多少词是1万1656啊。

好这个没问题，好我们再跑一下，那当然应该是词典的一个大小啊，不然效果应该不会那么差，啊这个参数大家可以设置小太小一点啊，没必要设这么大，没必要设置这么大，啊我们先跑一下看一下好，可以看一下啊。

这效果其实一下就起来了对吧，刚那个词应该是词典的问题啊，一下就起来了，已经到80级了，我们再改回来啊，我们改了和原论文的一个超参数保持一致啊，我们就用二来看，我们就用二呃，这里就是六，OK我们再跑一下。

好稍等一下诶，可以看到啊，其实效果还是不错的对吧嗯，第二个e Poke就85了，86了，还在不停的一个收入对吧，86。4好，升至87了啊，效果已经还不错了，OK行。

基本上这就是今天要给大家讲的一个内容了啊，大家下来把CN这一块弄明白的话，可以一样啊，来把这个代码这一块给复现一下好吧，复现一下。

好行，看各位同学有没有什么问题，步长在哪里定义嗯，这里啊，这里它有一个它这个里面是有一个参数的，你看它有一个stay的一个参数啊，默认是一，默认是一，你可以设二，你也可以设三，好吧。

好其他同学还有问题吗，图片为什么是四维的啊，是这样子啊，你图片输入是这样子吗，首先第一个维度是BESIZE嘛，Dua dupage page size he，第二个维度是kernel size。

那第三个维度是它的宽，然后第三第四个维度是它的高trl size，因为它是RGB嘛，RGB所以，kernel size等于三，那如果你是黑白图片的话，那这个channel size就是一好吧。

要是图片的宽和高，所以它是一个四维的，四维的好，我也说明白吧，好其他同学还有问题吗，嗯没什么问题，咱们今天的课程内容就到这边了，好吧就到这边了，好行呗，那咱们今天的内容就给大家讲到这边。

好吧啊，我们就下次课再见，然后大家有什么问题的话，也可以在群里面找我就OK了，好吧嗯好的，各位同学。

【七月在线】NLP高端就业训练营10期 - P4：4.文本相似度计算与文本匹配模型_ev - IT自学网100 - BV1uxT5eEEr6

OK今天的话我们要给大家讲这个文本相似度啊，文本相似度，那在之前的一些啊，包括一些录播课里面啊，我们已经简单的去了解了，包括像啊文本分类对吧，那今天的话我们还会去作战的一个NLP当中。

会经常应用应用到的这样的一个模型啊，就是咱们的这个文本相似度的一个计算，那当然我们今天的这个课程呢，也会带着大家一起从这个理论层面，再到代码层面，一起去实现这个所谓文本相似度的一个计算。

好吧好，那我们就先来看一下，我们今天会讲的三部分内容啊，第一部分内容呢我们会先给大家简单介绍一下，到底什么是这个文本相似度，包括这个文本相似度啊，它有什么样的一个作用，那对于文本分类来说。

那它的这个作用大家都很清楚嘛对吧，它的应用场景也比较广泛，那对于文本相似度来说，它又有什么样的一个作用呢，它可以应用在什么样的一个场景下呢，好这是我们今天要第一块讲的内容，第二块的话我们会来看一下啊。

基于这个表示学习的一个，文本相似度的一个计算，也就是说文本像素计算啊，其实有两种方式，第一种的话是基于咱们的这个表示学习，第二种的话是基于这样的一个匹配模型，匹配模型好，那匹配模型和这个表示学习模型。

它又有什么样的一个区别呢，这也是待会我们会详细说的点，好吧好，这是我们今天主要要讲的这个三块内容啊。

那我们接下来就进入到我们的第一部分内容啊，关于这个文本相似度好。

那这边开始之前呢，我也简单说一下啊，我们的这个课程上的这个代码呢，都会在这个啊GITHUB这个地址里啊，好给大家简单看一下，那啊大家上课之后，如果大家需要看这个代码，那就来到这边，来到这个页面上。

然后如果你需要去获取这个代码该怎么去拿呢，啊有两种方法啊，第一种方法你可以点击一下，这里这个绿色的这个按钮啊，因为这里为什么要说这个事呢，因为有些同学可能还是啊正在大学期间啊。

可能对GITHUB这一块用的还不太熟练，所以这边简单说一下好吧，那就点击这边这个code啊，然后呢你可以使用这个git命令把它clone下来，你也可以呢在这边直接把这个下载下来，那下载下来的话。

它就是这样的一个压缩包好吧，然后解压缩之后呢，就可以看到这个代码了，好两种形式好吧，一个是使用这个git命令，一种是使用这个下载压缩包的一个形式，当然大家最好是使用这个git命令啊。

那我这边代码更新的话，大家如果使用git克隆下来的话，你也方便去更新你的代码，好吧好，这是嗯关于代码这一块的一些东西啊，好提前说一下，OK那我们就要接下来就来看这个文本相似度啊。

那文本相似度说白了其实就是计算两个文本，它的一个相似度对吧，就是字面意思啊，就是计算两条文本它的一个相似度，它和文本分类它最大的一个点在于是什么呢，文本分类我们是针对于什么，我们针对的是单挑文本。

但是对于文本相似度来说，假设我们要去计算A和B的一个相似度，那我们是需要两条文本的对吧，这是它最大的一个点啊，在我们训练阶段，它最大的一个点分类是针对于一条文本，我们的这个相似度啊，针对的是两条文本。

那待会大家也可以从模型的结构层面看到，如何去针对于两条文本去设计，这样的一个模型结构，那知道了什么是文本相似度之后呢，我们需要考虑一下，就这个文本相似度啊，它到底是有什么样的一个应用场景。

它其实文本相似度啊，和文本分类一样，它的这个应用场景是非常多的啊，例如咱们的这个文本的一个检索信息检索，还有咱们的这个问答好，我们先说先说这个检索啊，检索这个相信各位同学都非常好理解啊。

例如咱们的一个搜索引擎对吧，那你搜索引擎你输入了一个问题，那咱们这个搜索引擎要把这个答案进行返回，那通常呢啊，用户输入了一个这样的一个question对吧，那他会返回很多的这样的一个啊document。

或者说它输入了一个query，我们要返回很多这样的一个document，可能有D1D2D三好，那如何去对这个D1D2D三进行一个排序呢，因为我们显示在页面上，那我们就需要对它进行一个排序对吧。

那其中一种方式啊，我们就可以根据我们的这个相似度来进行排序，那相似度越靠前的，我就把它往前面排，那假如A11它的相似度很高对吧，那我就把它排在第一位，第三它的相似度可能是第二，那我就把它排在第二位。

最后这个排在第三位，这是检索的这样的一个场景啊，那包括搜索引擎，它其实也会应用到这样的一个文本相似度，一个计算，当然啊一些做的比较好的一些搜索引擎，除了去考虑咱们的这个文本相似度以外。

还会去考虑一些额外的一些特征，举个简单的例子啊，假设你用的这个是百度的一个搜索，那百度搜索的话，你可能会遇到很多的一个一些广告对吧，那他其实是会对针对于这些广告，也是采用一些加权的一些形式。

把这些广告呢排到前面去，其次啊啊其次的一些排序的一些结果，甚至会涉及到一些learning to rank，一些类似于推荐的这样的一些模式，把你感兴趣的内容往前面排，它也是有的，好吧好，这是一个检索啊。

让我们再说一下问答，问答和检索呢其实是比较接近的啊，他的思路是比较接近的，举个例子啊，对于问答来说呢，首先呢我们需要有一个这样的一个，QA的一个库，也就是说我们哎有这样的一个数据库。

我的数据库里面呢存了很多的这样的一个，QA队啊，QA队，这个时候呢用户输入输入了一个问题，好用户输入了一个问题，那我们的这个可能有Q1Q二一直到QN，咱们的answer也是啊。

从一一直到answer n，这个时候呢用户输入进来的这个question，会和我们库里的这些question，去做一个相似度的一个计算，哎，这个时候可能算出来我Q2，它的相似度是最高的。

那么我们就把Q2对应的answer2，进行一个返回，进行一个返回，这就是一个非常简单的一个问答系统啊，问答系统，所以说可以看到啊，这个文本相似度的一个应用场景啊，实际上是非常多的非常多的。

这边再说一个简单的一个场景啊，那这个简单的场景，就是咱们的一个文本的一个聚类，假设你现在有非常多的这样的一个文本，你想把这个同义句给聚在一起，怎么做呢，这个时候您实际上也可以采用这个。

文本相似度的一个方式来进行计算，那我们去两两进行相似的一个计算，最后把相似度比较接近的就把它聚在一起，对吧好，这是第三个应用场景啊，聚类聚类，那目前文本相似度的主要是有两种方式啊。

就基于这样的一个表示学习的，就是刚才咱们这个大纲里说的一个表示学习，还有一种呢，就是基于咱们这样的一个双塔模式的啊，双塔模式的，当然啊，现在其实对于双塔模式这样的一个结构来说呢。

也会存在于一些啊单塔的一个结构，那具体是什么样子呢，待会我们来详细说好吧，推荐的双塔用embedding计算好，这就是我们的一个文本相似度，它的一个应用场景好吧，应用场景，好那咱们的这个文本相似度。

通常啊不管你是用什么样的一个方式来做，不管是说这里的一个表示学习也好，还是这里这样的一个双塔结构的一个模型也好，关键的有一个点啊，在我们去计算相似度的时候，我们是不是应该去确认一个这样的一个。

度量的一个标准，我们到底应该是采用什么样的一个距离，来判断两条文本它的一个相似度呢，哎例如我们这里有很多距离对吧，我们有欧式距离哎，有曼哈顿距离，有海明距离，有很多的一些距离都可以用来度量。

两条两个向量它的一个距离对吧，那我们会去使用什么样的一个方式呢，那对于计算文本相似度来说啊，我们通常会采用这个余弦相似度，那为什么都是建议采用这样的一个，余弦相似度呢。

最主要的原因啊在于咱们的这个余弦相似度啊，它的一个值域在这个-1_{1之间，那基本上啊对于文本来说，我们计算出来的这个相似度，大部分都是0}1之间，很少会出现于一个负数啊，很少会出现一个负数。

那余弦相似度它又是怎么计算的呢，我们可以看下下面这个公式啊，如果我们要求A这个向量和B这个向量，它的一个余弦相似度，实际上就是A向量乘以B向量，再除以A的模和B的模，这就是两个向量它的一个余弦相似度啊。

余弦相似度好，那了解了我们接下来要计算的这个相似度，用什么样的一个度量方式去计算之后呢，那接下来啊，我们就可以进入到我们后面的一个内容了。

好接下来我们来到我们第二块啊。

关于这个表示学习的一个相似度，那什么是一个表示学习的一个相似论的计算呢，其实表示学习啊，意思就是说我们需要通过一个模型，通过一个模型得到句子的embedding，这里大家需要注意一下啊。

是通过模型得到我们句子的embedding，那得到句子的embedding之后诶，那我们就可以把我们的这个embedding，根据我们这里提到的这个余弦相似度，来进行一个计算。

就可以最终得到我们想要的一个结果对吧，举个简单的例子啊，假设呢我们现在这里有A这条文本，B这条文本好，首先呢我们这里有一个这样的一个模型啊，我们先不考虑它到底是什么样子的一个模型啊。

我们先不考虑它是什么样的模型，总之我们这里有两条文本A和B，我们把这两条文本给到了我们的模型，我们的模型呢生成了两个向量，一个是VA，一个是vb，OK有了两个向量之后。

那我们是不是就可以去计算我们的余弦相似度，对吧，那就是VA乘以为B除以VA的模vb的么，这样子的话，我们就可以计算出我们的文本相似度了对吧，OK那知道了这个流程，那接下来就有一点比较关键了。

这里这个模型该怎么得到呢，好这就是我们需要关注的一个点啊，关注的点那在我们之前的这个啊，包括录播课里面啊，我们实际上已经讲过这个word to vector了对吧。

我们已经讲过这个word to vector了，好那既然如此，我们是不是可以考虑采用word to vector，的一个形式呢，对吧，OK啊，那我们就采用这样的一个形式嘛，假设啊我现在A这个句子。

A这个句子它里面可能包含了很多的一个词，可能有A1A2A3A4好，那接下来呢，我们就可以采用我们这样的一个，海量的一个数据，采用word to vector的一个形式，得到这样的一个模型。

word to vector一个模型对吧，那有了这样的一个word to vector一个模型之后呢，当用户输入了这句话，好，我们把就把这句话啊进行一个分词分词，这边的话就是分成了四个词啊。

分成了四个词，那有了这四个词之后呢，我们会把这四个词啊经过我们的word to vector，这样的话，我们是不是就能得到这四个词对应的一个，embedding对吧，哎那我们这里就得到了VA1。

VARVA3和我们的VA4对吧，好同理啊，同理，那对于B这个句子来说，我们也可以把它进行一个分词，再转换成对应的一个向量对吧，对应对应的一个向量，这个时候我们是做了什么呢，我们是把句子分了词。

转换成一个向量的一个形式，但是但是我们这里的这个向量啊，我们可以看一下，这里是四个词，假设我们的向量它的维度是64，假设是维度是64啊，那我们这边得到的实际上就是一个，4×64的这样的一个张量。

或者说举证对吧，我们得到的是这样的一个维度的一个数据，那对于这边来说，我们得到的就是啊啊假设我们的N是六好吧，我这里写个六好了，写个六好，那我们这边得到的这样的一个，就是一个6×64的这样的一个矩阵。

或者说张量好，那现在就有问题了，这两个矩阵，我们该怎么去计算它的一个相似度呢，哎刚才我们说嘶我们是两个向量对吧，两个向量才能去计算它的余弦相似度，那这个时候我们得到的这个内容到底是什么呢。

我们这里得到的这个矩阵到底是什么东西，有同学知道吗，或者说接下来我想去算这个余弦相似度，我该怎么做呢，来有同学知道吗，好我这边那我就解释了啊，我来解释好了，首先呢我们这边得到的实际上是什么。

是每一个词它对应的一个词的embedding，但是我们这里这个余弦相似度的公式，我们使用的这个是什么，是使用的是句子的embedding，但我们这里是啥，我们这里是词的embedding对吧，假设啊。

假设我们最终得到的是一个一维的，也就是说它只是单纯的一个向量，它不是一个矩阵的一个形式，假设他这边得到了一个64位的一个向量，诶，这边也得到了一个64位的一个向量。

那这个时候我们是不是就可以进行一个计算，对吧好，这里有一位同学说哎，是不是可以采用这个平均池化层，差不多啊，思路差不多，OK那既然如此啊，我们这里得到的是一个词的一个embedding。

那我们就应该想办法把它变成一个什么句子的，一个embedding嘛，对吧，我们要从词的embedding转换到句子的embedding，那怎么转呢，其中一种方法啊，就是这里这位同学说的。

我们可以采用一个平均池化层，平均池化层好，我们来看一下啊，那通常呢我们要把我们的这个embedding啊，从词从咱们的这个词转换成这样的一个句子，从word转换成这样的一个sentence对吧。

那最常用的一个方式呢，其实就是什么加权平均，加权平均，也就是说我的这个vs啊，实际上是等于，加上啊，这是第一个词啊，这是第一个词它的一个embedding。

这是第一个词的embedding对应的一个权重好，那假如我们有N个词，那接下来就是阿尔法二乘以W啊，一直加加到我们的阿尔法三乘以我们的啊，这是N阿尔法N到我们的WN，这样子呢。

我们就等于给我们每一个词加了一个权重对吧，最后再求和再求和，这就是咱们的一个加权平均的一个过程啊，假如我们的这个阿尔法一一等于我们的阿尔法，二等于我们的阿尔法N，就每一个词啊它都是相等的。

并且哦每一个词它的一个权重都是相等的，并且等于什么，等于N分之一的话，这是什么，这实际上就是取求平均嘛对吧，就是这位同学说的，做了一个类似于平均池化层的一个处理对吧，好那这个时候又有同学会说了。

哎那我这里这个权重，我这个阿尔法我到底该怎么去求对吧，好这里呢就需要去做一些小的一些处理了，例如啊我们呢在分词之后呢，我们可以去对每一个词，它的一个这个啊词性作为一个标注，诶假设我这是一个名词。

哎我这里是一个动词诶，那我就可能给它一个稍微大一点点的一个权重，那可能后面有些词诶它是一个副词对吧，我就给他一个稍微小一点点的一个权重，以这样的一个形式啊，来确认它的一个阿尔法到底是多大。

当然还有一些其他的一些方式，例如你可以采用这个TFIDF，你可以采用这个text rank去计算每一个词，它的一个权重，再把这个权重啊，来作为他的这样的一个阿尔法的一个值，也是可以的啊，也是可以的。

当然啊如果大家觉得这些啊有点麻烦对吧，没关系，我们就采用最简单的一个方式啊，就采用这样的一个平均值化的一个形式，就直接取一个均值啊，直接取个均值，这样子的话，我们就可以把我们的这个词的一个引白。

embedding转换成一个句子的一个embedding，好我们回到刚才这个例子啊，回到刚才这个例子，那对于A这个句子来说，我们是4×64的这样的一个矩阵对吧，OK那接下来呢我就对它求一个均值。

求完均值之后呢，实际上啊就是让我们的这个V1，加上我们的VA2加上VA3，加上VA4，最后再除以四对吧，所以这样呢我们就可以得到一个一维的，一个这样的一个向量对吧，得到一个向量，那对于B来说也是一样啊。

我们把每一个词的embedding进行一个相加，进行一个相加，相加完之后呢，再除以我们的六个词，也就是除以六对吧，就可以得到我们最终啊这64位的一个向量，接下来呢我们就可以把这两个向量拿去计算。

我们的什么余弦相似度，余弦相似度啊，这就是我们整个表示学习的一个过程啊，表示学习的一个过程，好再简单，我们梳理一遍啊，首先拿到一个句子，拿到一个sentence，我们要把sentence转换成什么。

转换成词，再把每一个词转换成我们的什么embedding，转换成我们的词的一个向量，再从这个词的一个向量，转换成我们这个句子的一个向量，句子的一个向量，那句子的向量怎么做呢，是进行有我们的这样的一个啊。

啊这里写VW吧，VWI好，是进行我们的什么加权平均对吧好，这就是我们哦对，还有一步啊，下一步就可以去计算我们的什么相似度了，计算我们的余弦相似度啊，计算我们的余弦相似度，这就是整个表示学习的一个过程啊。

好这个时候呢可能又有同学会说了，那有没有其他的一个方式，我们这里只是一个采用want to vector的一个形式，对吧，有没有其他的一个形式呢，那其他形式怎么做呢，其他形式啊。

实际上就是把咱们刚刚说的这里这个模型啊，进行一个优化，进行一个修改，我们从之前的word vector对吧，进行一个升级，升级成其他的一个模型，其他的一些语言模型啊，Language model。

language model对其中一种方法就是BT啊，其中一种方法就是BT，但是这个我们今天暂时不讲啊，今年暂时不讲，我们会放到后面来讲，因为BERT这个模型来说，相对会稍微复杂一点点啊。

好这里我们稍微停一下啊，对于表示学习的这个整个流程，各位同学有没有什么疑问，对就是给每一个词它一个权重，然后相加好吧，相加就是这个意思啊，简单一点的话，那你就把这个权重啊，把它变成一个N分之一。

这样的话实际上就是什么，就是求个均值嘛，求均值，求均值就是咱们刚才这位同学说的平均池化层，好，各位同学还有疑问吗，这里，还有疑问吗，各位同学，啊这里也简单说一下啊，就咱们是直播课嘛，直播课的话。

大家如果有什么疑问就及时提出来好吧，我们尽量就是在这个课程当中啊，帮大家把所有的问题都给解决，大家不要带着疑问，带着疑问呢，那接下来我们的这个直播的一些内容啊，你可能就会听不太明白好吧。

因为每一环都是相辅相成的啊，前面的内容你听不明白，后面的内容你可能就更听不明白了好吧，所以大家有疑问啊，一定要提出来，一定要提出来，我们就及时解决，及时解决，好那我们就继续往下啊，继续往下。

那刚才说了啊，我们刚才使用的模型是这样的，一个word vector的一个模型对吧，word vector一个模型好，那我们把这个word vector这个模型啊做一点点升级。

我们要把这个word vector升级成什么呢，升级成另外一个语言模型啊，language model或者说叫做预训练的语言模型，Pre train language model，Portrait。

Language model，预训练语言模型，那我们今天要给大家介绍的这个语言模型呢，叫做arm，有些同学可能会比较熟悉啊，像BERT这样的一个语言模型，那这样的一个语言模型呢。

其中的一些结构啊会稍微复杂一点点，我们需要放到后面去讲，那今天呢我们会给大家讲另外一个比较重要的，预训练的语言模型，而某这个模型，那这个模型呢它是基于这样的一个LSTM的，那LSTM的话。

相信各位同学在之前的一个录播课当中啊，已经了解过了对吧，已经学过了，那我们今天的话就来详细看一下，这个基于LSTM得到的这样的一个语言模型，预训练，语言模型它到底是什么样子的啊。

好他的一个结构整体来看其实并不复杂啊，我们可以看一下下面这个图，那arm这个模型呢，实际上采用的就是一个双层双向的LSTM，注意啊，它是一个双层的，并且是双向的，并且是一个双向的。

那他这个双向是什么意思呢，对于普通的一个RN的一个模型来说，咱们的一个结构是这个样子的对吧，哎我们这里进行一个输入，第二个时间点，输入第三个时间点进行一个输入，它是一个从左到右的一个过程。

那对于RN这样的一个结构的一个模型来说啊，实际上我们还可以进行一个，从右到左的一个结构，诶，它可能是这个样子的，就从右到左，或者说从后往前的这样的一个结构，那这样的话。

我们的模型除了可以看到我们的前文以外，我们还可以看到我们的后文对吧，那对于我们的第一种结构，从前往后，那模型其实就能看到的是什么，看到的是前文的一些信息，那对于我们的第二种结构来说，那模型看到的。

实际上就是我们的后文的一些内容对吧，那既然如此，我们把这两者结合一下对吧，结合一下，那结合之后呢，我们当前的这个时间节点，就既能看到我们之前的一些内容，又能看到我们这个之后的一些内容。

也就是说我们能看到什么，能看到我们的一个上下文啊，上下文，好这就是一个双向的N结构啊，双向的RN结构，那对于arm这个模型来说，它是把RN这样的一个结构啊，换成了这个LSTM，LSTM好。

我们来看一下啊，它的输入呢就是我们对应的每一个词的这样的，一个embedding，然后呢给到我们的一个前向的双层的，这是两层啊，两层的LISTM，那对于这边来说也是一样啊。

它是一个反向的LISTM当然也是两层的，最后呢我们会把这个两层的，它对应位置的一个输出值会把它拼在一起，拼在一起好，我们可以看一下啊，啊这是一个前向的，我们用F来表示啊，这是第一个位置，那啊这边的话啊。

我们也用这个啊B来表示啊，这是B1，所以说对于第一个embedding，它对应的就是前向的F1和反向的这个BE，它组成的一个结果组成，在它最终这里这个T1啊，是咱们的F1和我们的B1进行了一个拼接。

放到了T1这个位置啊，那这个位置的一个输出值，代表的就是我们的这个embedding，经过了我们的模型提取了一定的一些特征之后，得到的对应的一个词的一个embedding，假设这里是词是W1啊，W1。

那这里这个embedding，实际上是经过了我们这样的一个embedding matrix，也就是类似于咱们的这个word vector，对吧的那样的一个矩阵，好得到了我们这里这个一一啊。

一一经过我们的双向LSTM，分别得到我们的F1和B1，再把这两者进行一个拼接，得到我们的T1，那T1表示的是什么呢，表示的就是我们W1这个词它的一个输出值，你也可以理解为W1对应的一个什么词的一个。

Embedding，一个向量，一个向量，好这就是整个这样的一个耳膜的一个模型，但是我刚才有说啊，ERO这个模型它是一个什么，它是一个预训练的模型，预训练模型又是什么意思呢。

也就是说这个模型啊我们再去使用它的时候，它的一个权重啊并不是随机初始化的，而是它在海量的这样的一个文本数据上，已经进行了一个训练，也就是说他自身已经具备了一定的收敛的，比较好的一些权重。

那他这个群众是怎么得到的呢，或者说他这个预训练是怎么做的呢，其实很简单啊，举个简单的例子啊，假设这是我们的一个耳膜，那正常来说啊，我们实际上是会有很多的，这样的一些文本数据的对吧。

假设我这里有一条文本数据，哎我就以这条数据为例啊，ERO采用的是双层的双向LSTF，那我就可以把这句话啊输入给我们的耳膜，我把这句话啊作为输入给到我们的耳膜，然后呢。

我们让我们的耳膜这个模型来预测一下这句话，他的下一个字是什么，下一个字是什么，当然啊，这个过程肯定是一个字一个字进行预测的，举个例子啊，假设我现在输入的是ERO采用的啊，我们就输前面这一段这里啊采用。

然后呢我们要让我们的hero，也就是LSTM，它最后的一个位置输出D这个字，输出D这个字，那输出完之后呢，我们再把D这个字啊再给到我们的耳膜，也就是给到我们这个双向的LISTM。

再让他把士这个字进行一个输出，哎这个时候各位同学可能就发现了啊，那这个过程它实际上是一个什么，是一个无监督的一个过程，只要你有文本，那你就可以来进行这样的一个训练对吧，有文本你就能训练。

那它就是在海量的一个文本的一个基础上啊，去做了这样的一个预训练的一个任务，那训练完成之后呢，它就会自身已经具备了一些权重了对吧，那当你去使用ERMO的时候呢，你只需要把这个权重给加载进来，加载进来。

这个时候你就可以在这个已经训练过的一个，模型的一个基础上再去做一些所谓的什么微调，就可以去适应你自己的一个任务，那对于我们的这个文本相似度来说啊，其实就是可以直接使用它的一个权重。

那只要我们有了这样的一个权重，那我们最终这里实际上就可以得到每一个词，它对应的一个embedding对吧，也就是这里这个所谓的T，那我们再对每一个T去求，刚才这里说的这样的一个加权平均的一个值。

就可以得到我们最终的一个什么句子的，embedding对吧，所以各位同学可以发现一个问题啊，我们刚才说我们的那个模型使用的是what vector，对吧，What to vector。

然后这里呢我们换成了这样的一个arm，不管你使用什么样的一个模型啊，我们最终的这个整个这样的一个流程啊，它是不会变的，它是不会变的，唯一改变的就是我们这里这个模型对吧，唯一改变的就是这个模型。

包括我们最终生成的这个句子的一个embedding，对吧，你这个句向量该怎么生成，哎也是和我们这里说的这个方式啊也是一样的，毕竟我们最终这里得到的也是一个一个的词的，一个embedding对吧。

词的embedding好，这就是我们的这个ERO这个模型啊，这个模型好，接下来呢我们再来看一下啊，如何去对我们的这个啊前向语言模型，和我们的反向语言模型去进行一个建模啊，好我们来看一下啊。

这里呢假设啊我们现在有这样的一个句子，这个句子呢有N个词，也就是说从T1到TN，那我们要对这个句子去进行建模的话，实际上就是求每一个词它的一个联合概率分布，也就是咱们的P从T1到TN对吧。

最终呢我们会得到这样的一个累成的一个公式，哎为什么是这样的一个形式呢，其实啊这个公式是怎么得到的呢，我们来看一下啊，那对于PT1到TN这N个词来说，那如何去得到这样的一个概率分布呢。

实际上啊假如假如每一个词它是相互独立的，假如每一个词它是相互独立的，那它实际上就等于PP1，一直乘乘到PTN对吧，但对于我们的文本来说，每一个词肯定不可能是相互独立的嘛，对吧啊，例如像啊啊吃饭诶。

这两个字可能会大概率在一起诶，蝙蝠这两个字可能大概率会在一起，你不可能说啊吃福哎，那这是啥东西对吧，所以说词和词之间啊，或者说字和字之间它不可能是相互独立的好，那既然它不是相互独立的。

那这个肯定是不对的对吧，那我们该怎么去求这个啊概率分布呢，那这个时候啊我们就可以这么求啊，首先呢我们先看前面的一些词好，这时候实际上就等于PT1乘以P1，这个啊T2给本T1好，那这两者进行相乘之后呢。

我们得到的是什么，我们是不是得到的是PT1T二对吧，我们得到的是这个东西啊，得到这个东西，那我们可以继续再往下面乘啊，那我们可以再乘这个P这个啊，这个这个T三T1TR好。

那我们再把这一项和这一项进行一个相乘，那我们拿到的是什么，是不是PT1T二T三，所以啊只要我们一直沉下去一直沉下去，那我们乘到最后一项对吧，我们实际上啊，整个的一个联合概率的一个分布啊。

就是这样的一个公式，就这样的一个公式好，这是我们的一个前向语言模型，那对于反向语言模型来说其实就是一样的啊，我们就把我们的这个啊，从T1换成了咱们的一个TN对吧，就重复从后往前来啊，从后往前来。

那对于一个双向的语言模型，我们该怎么做呢，理论上来说啊，我们应该把这两者就前向和反向进行一个什么，进行一个相乘对吧，进行一个相乘，但是呃各位同学可以考虑一下啊，理论上来说，这里这样的一个概率值。

其实计算出来已经非常小了，这里这个概率值通常会怎么去求呢，你可以去采用一个词平的一个形式去求解，但是求解出来大家可以发现啊，这个概率值已经非常小了，你再采用一个相乘的一个形式的话。

那这个值就会变得更小了，所以呢我们通常啊会取一个log，取个log，取完log之后呢，我们就可以把我们相乘这个过程啊，变成一个相加的一个过程，相加的一个过程啊，然后我们这个累乘啊啊。

也变成了这样的一个累加累加啊，这就是一个双向语言模型啊，双向语言模型，OK那理解了这个建模的一个思路之后啊，我们再来回到我们的这个耳膜啊，回到我们的耳膜，那arm这样的一个模型呢。

其实啊他想去得到每一个词的这样的一个，向量表示的一个方式啊，是有很多种的，有很多种，那第一种形式呢，就是去取我们第二层的LSTM的输出，也就是咱们刚刚说的，我我直接去取这里这个T1直接去取这个T1。

来作为我们最终的一个输出的一个结果，当然啊还有一些其他形式，也就是说我们给每一层它一个权重啊，去取它的一个加权的一个平均，什么意思呢，好我们还是回到这里啊，这里有我们的这个啊，有我们的一个一对吧。

这个是经过咱们这个embedding matrix，得到的这样的一个向量好，那对于第一层的LISTM来说，我们实际上也可以得到这样的一个输出值，假设我用H来表示H1，它也可以得到这样的一个输出值。

那对于第二层来说，哎我们这里也可以得到对吧，H2而这里呢我们又得到了一个TT好，那这个时候啊，我们就可以把这里这个T，这里这个H这第一层的H，还有这里这个啊一进行一个加权啊，加权加权求和也是可以的啊。

也是可以的，哎这个时候可能各位同学会发现，哎怎么好像和我们去求那个句子，embedding会有点像对吧，所以说啊这些方式啊其实都是类似的，都是类似的，那这些呢其实都是他的一个paper当中啊。

说明的说明的好，这就是我们的这个耳膜啊，来得到这样的一个embedding的一个形式，那最终得到embedding之后呢，怎么做呢，啊就还是像刚才的对吧，把它转换成一个句子的embedding啊。

就OK了就OK了，好，这就是我们这个ERO这个模型，如何去得到它的一个embedding啊，得到embedding，好，这里呢啊也给大家提供了一下，如何去使用这个ERO这个模型。

当然啊你可以自己去做这样的一个预训练，是完全OK的，但是呢这边其实是有一些啊，别人已经训练好的这样的一个耳膜的一个模型，大家如果有足够的一个数据，你有足够的一个算力，那你可以自己去预训练。

这样的一个耳膜的一个模型，但是呢我还是建议大家就去使用这样的一个，开源的啊，就足够了好吧，使用开源的就足够了，嗯这有点慢啊，有点慢好，大家就去这边来使用这样的一个开源的啊，开源的。

包括他这里也提供了不同语言的一个版本，让大家来这里下载一个中文版就OK了啊，下载中文版，那这里下载下来呢是什么呢，是模型的一个权重啊，模型的一个权重，那如何去使用呢，啊使用的地方。

我们在这边已经给大家进行了一个说明啊，啊这里也简单说一下啊，啊一首先呢要有以下几步啊，第一步的话，肯定是要去安装我们的这个PYTORCH啊，PYTORCH这里也简单说一下啊，我们在之后的课程当中呢。

所涉及到的一些模型的一个开发啊，我们都会采用这个拍套，只有个框架好吧，都会使用PY套式这个框架，然后呢我们需要去安装我们的这个康达啊，CONDA安装好之后呢，我们需要去安装一些这个啊，刚才说的啊。

这个arm这个我们要把这个尔摩这个啊，用这个pip的一个形式啊去进行一个安装，或者说呢你直接把他的这个源码啊给clone下来，也就是说大家只需要去执行这几行命令啊，这几行命令。

那它就会自动把我们的这个耳膜啊，安装在我们的这个本机里，本机里，当然啊大家记得要把这个权重下载下来，你如果不去进行一个下载，那你使用的这个权重就是随机初始化的，你随机初始化的一个权重。

那最终你得到的这个文本的一个embedding对吧，文本的embedding肯定就是效果不理想的啊，效果不理想的好，这边呢也有一个啊如何去使用啊。

如何去使用，大家到时候就自己来看，然后这边呢我给大家简单演示一下啊，啊其实在我们的这个代码当中啊，我也把它放进来了。

大家如果不去，大家也不需要去clone它的这个代码啊，大家直接把我的这个克隆下来就OK了好吧。

或者说你去下载这个压缩包，那打开之后呢，大家会看到这里有这样的一个文件夹啊，会看到这里有这样的一个文件夹，好，那这样的话大家就可以去使用这样的一个模型。

然后大家需要注意一下啊，大家去下载这个权重之后啊，这边去进行一个权重的下载之后呢，需要把权重啊放在我的这里。

这里有一个，有一个叫做pre model的一个目录啊，我会把这个arm这个模型啊，这就是一个它的一个权重，还有一些它的一些配置文件啊，会把它放到这个文件夹下，大家去拉我的代码的时候。

会发现没有这个文件夹啊，你要去自己创建一个文件夹，然后把这个模型下载下来，放到这个文件夹下，然后呢你就可以去使用这个ERO这个模型了，好我们来看一下啊，这边呢我已经就几行代码啊。

就可以去调用这个arm的一个模型，好我们简单看一下，首先呢把arm这个进行一个import啊，然后呢我们导入一下结巴分词好，第一步是我们的句子，然后把句子进行分词，然后初始化一下我们的URL这个模型。

然后调用一下他的这个sentence to ero，这个方法啊，然后把我们的分词的一个结果传递进来，最终就可以得到我们这个句子的embedding，好，我们可以执行一下这个代码啊。

好这边是一个分词的一个结果啊，OK最终啊我们可以看到他输出了这样的一个啊，一个这样的一个张量啊，这样的一个张量哎，那为什么它输出的是这样的一个张量呢，因为他这里最终输出的是什么。

是每一个词的一个embedding。

每一个词的in bedding，我们还需要去求个均值好吧。

要转换成句子的embedding的话，你就需要去求均值好吧。

或者说你去做个加权平均都是可以的啊，就是咱们刚才这里说的对吧。

好，这就是如何使用咱们的这个hero这个模型啊，来生成我们的embedding，好这里呢最后再额外说一点啊，额外说一点啊，对于这个sentence to ero这个方法来说啊。

它里面有一个参数叫做output layer，那这个参数是什么意思呢，我们来这边看一下啊，他有这样的一个解释，output layer如果是零的话，它实际上输出的就是WARENCODER的一个值。

也就是它经过咱们的这个embedding，matrix的一个结果，也就是这里这个图当中的这个黄色的这个一一，这样的一个结果啊，如果你输入的是一一的话，它实际上得到的就是第一层的LSTM的一个。

Hidden state，Hidden layer，它的一个输出值啊，hidden layer的一个输出值，如果是二，就是第二层的LISTM的一个，hidden layer的一个值，如果是一哎。

可以看到如果是一的话，输出的是这三层的一个什么一个均值啊，一个均值哦，对我刚才这里弄错了啊，啊，这里这个T啊，实际上已经是我们第二层的，LISTM的一个输出值了啊，它表示的是第二层的一个输出值。

所以说这个T和这里这个H2啊是一样的，是一样的，只不过这里这个H2和T1唯一的区别在于，它没有进行一个拼接，好吧，这里我纠正一下好，最后如果你输的是二的话，他就会把这三层的一个结构啊都进行一个输出。

那如果三层结构都进行输出的话，你可能要做一些加权啊对吧，那你就自己按照你自己的想法来啊，就OK了，当然默认它是一啊，默认是一，也就是取这三层的一个均值。

好如果大家想更改的话，就是在这个方法当中啊，把这个参数进行一个修改就OK了，好吧好，这就是使用咱们的这个arm这个模型啊。

来生成我们的这个句子的embedding，好吧，生成句子的embedding，好这里我们再稍微停一下啊，看各位同学对于ERO这一块还有疑问吗，所以说最关键的点啊。

还是在于如何去找到一个合适的一个模型对吧，如何找到一个合适的一个模型，不管是咱们的word to vector，还是咱们这个ERO，又或者说我们今后会给大家讲的这样的一个BT，一个模型。

其实都可以用来生成这样的一个句子，的一个embedding对吧，好各位同学有疑问吗，看来是都没有欲望啊。

好OK那咱们就啊继续下面的内容了。

好吧好，那我们进入到我们的这个啊第三部分啊，关于这个匹配模型的一个相似度啊。

那刚才呢我们给大家聊的是，采用这个embedding的一个形式，也就是说哎我们把这个句子，提前转换成一个向量的形式，来计算这样的一个embedding，那接下来呢我们要给大家讲第二种方式啊。

就直接采用模型的一个形式，也就是说哎我这里有这样的一个模型，你直接把你的两个句子输入进来，比如咱们的A和咱们的BA输入给我们的模型，我们的模型呢最终输出一个值来决定，或者说来告诉你A和B这两个句子。

它到底是不是这样的一个同义句，或者说输出它最终的一个相似度，那对于这样的一个模型来说啊，我们通常会怎么做呢，实际上就是在我们的结尾啊，做了一个所谓的二分类，二分类，我要让它输出一个0~1之间的一个值。

0_{1之间的一个值，那这个0}1之间的值越接近于一，就说明A和B这两个句子它越相似，大家也可以认为哎只要它大于0。5对吧，大于0。5，我就认为它是同一句，如果小于0。5，它就不是同一句。

就是以这样的一个思路啊来做好，那对于这样的一个模型来说，我们该怎么去构建它呢，好我们来看一下啊，而文本相似度的一个模型的一个结构呢，通常啊都会采用一个孪生网络的一个结构。

are u也就是咱们的一个双塔结构啊，什么意思呢，就是说啊我们这个模型啊，它其实分成了两个部分，两个部分哎，这边一个部分，这边一个部分，这两个部分呢一边输入我们的A，一边输入我们的B两个模型。

那这两个模型呢，有时候呢他会去做这个所谓的权重共享，也就是说我们的模型一，它的一个权重和我们的模型二它是相等的，它是相等的，那有时候呢它也可以不相等，它也可以不相等，好当然啊这种结构他能做的一些事情呢。

更多啊是把我们的这边输出一个所谓的VA，这边输出一个所谓的vb，那最终再把这两个向量啊，去经过一些类似于我们的全连接层，或者说我们的SIGMOID的层，再来做一个所谓的二分类。

然后得到我们最终的这个零一之间的，这样的一个值好，那除了这样的一个结构以外呢，其实啊我们可以还有一些其他的一些结构，还有什么结构呢，好这就需要看到这里啊，我们的相似度模型可以分为两种情况啊。

一种情况呢是这里说的这种外交互的一个形式，也就是这个图啊，这个图也就是我们的第一种形式，第一种形式，那还有第二种形式啊，一个内交互的一个形式，那内交互的一个形式又是什么样子的呢。

它也可以是一个这个啊双塔的一个结构，也就是说唉我这里输出之后，我和我的M2这边的一些输出，做了一些这样的一些交互的一些处理，做了这样的一些交互处理，这个交互处理有什么呢。

可能你去做了一些attention，然后可能你去做了一些磁化，你做了一些拼接，总之你去做了一些相互的一些交互，然后呢，再给到我们接下来的一些其他的一些结构，例如LSTM或者其他的一些类似的。

这样的一些结构，这是一个所谓的一个内交互的一个形式啊，甚至诶我这里这个模型就只有一个模型，它不是一个双塔的一个结构，那我把A和B1起做了一个拼接对吧，做了一个拼接给到了我们的模型。

我们的内部去做了一些交互，然后最后进行了一个R分类，这是我们的第二种结构，第二种结构内交互的一个形式，当然啊也有外交互加内交互，也就是说哎我先去做一些内交互，我再去做一些外交互的一个形式。

所以说啊文本相似的模型，它的一个结构啊是非常多的非常多的，当然啊大家只需要注意到这里，这个所谓的一个内交互和外交互就OK了，好吧，还有这里说的这样的一个双塔的一个结构啊。

你可以让这两个模型它的一个权重不同，也可以相同，但是大部分的情况啊，双塔结构的模型它的权重都是相同的，也就是说所谓的权重共享好吧，权重共享，呃尔某英文模型的词典都是26字母哦，不是啊。

不是英文的一个分词，它是怎么做的呢，第一种方式啊，它是就把这个分成一个一个的英文的一个词，分成英文的词，但是分成英文词，它实际上也会存在于这个OV的问题，也会有OV的问题，OV什么意思呢。

就是out of vocabulary，就是没有在我们的词典当中，所以说啊这个时候也会去做一些所谓的word piece啊，这个东西我们之后放到BT再给大家讲好吧，所以说这里不是分字母啊，不是分字母。

那对于中文来说，我们有两种方式，第一种方式呢我们可以分字分字，它的优势在于不容易出现OV的问题，因为常用的汉字也就那么多，可能11万2万，基本上就覆盖了大部分的这个汉字了，就很难出现OOV的问题了。

第二种形式呢是分词，分词的话，你中文的词就非常多了，那这种时候的话就可以，就容易出现这个OV的问题，所以说啊分子和分词各有优缺，各有优缺，还有一点啊，那对于啊分词来说，它能对语义表示的更合理一些。

对于分字来说，那大家都知道吗，那对于中文来说，这个啊一个字它有很多个意思对吧，可能要和其他的字组合成一个词之后，才能真正的知道它到底是什么意思，这就是字和词它各自的一个啊优缺好吧，好我有说明白吧。

这位同学，OK行好，那我们回到我们的这个文本相似度模型，这一块啊，啊还是哦关键还是那两点啊，一个是内交互，一个是外交互好吧，然后这边也在还有这个双塔结构啊，大部分是这个所谓的权重共享，权重共享。

权重共享的意思就是说模型结构是一样的，然后权重它是进行一个，你看着它好像是两个模型，但实际上它结构和权重都是一样的，如果你的权重不共享，那它的结构也是一样的，只是说权重不一样，好吧好，然后呢。

我这边呢有啊有这样的一篇博客啊，这个是我很久以前写的一篇博客啊，这边呢我整理了很多的一些这样，文本相似度计算的一些小模型啊，然后这些啊这边有个表格，大家可以看一下啊，它的一个输入有字向量啊。

有这个词向量，然后好像还有静态词向量和动态词向量，我觉得这个应该是在之前的那个录播课里面，讲过了对吧，然后啊还有对应的一个论文的地址，那每一个模型呢，我这边也有博客去讲解，每个模型是什么样的一个结构。

它是怎么用的，大家如果对这些模型想了解的更多，就一个一个来看好吧，一个一个来看，当然啊，我们今天课程上也会带着大家去看一些，比较重点的一些模型，好吧哦对，还有一点啊，我这边也有对应的一个源码。

也有对应的源码，但是这个源码呢它是这个啊，TENSORFLOW的一个版本好吧，TENSORFLOW的一个版本，大家也可以来自己看一下好吧，自己来看一下，尔某一般是直接用还是自己重新训练一个。

如果你想用ERAL来生成这样的一个，句子的embedding，那你就直接去加载它的权重，进行使用就可以了啊，但是如果你想让这个生成的句子的embedding，效果更好，那可以怎么做呢，举个例子啊。

假设你现在是一个这个医疗领域的一个场景，那可能尔某它是一个在通用领域进行，预训练的一个模型，那你就可以把你医疗领域的这个啊数据啊，你的文本数据拿过来去做一个预训练，预训练，预训练完之后呢。

再直接用这个训练好的模型，来生成这样的一个embedding，好吧，当然你也可以啊，不进行预训练啊，就直接去使用它的这个预训练，好的权重也是可以的，好吧，这位同学两种方式啊，你想要效果更好。

你就在你自己领域的数据再做一下预训练，当然啊这个通用领域的数据也是可以用的，只是说可能效果会稍微欠缺一点点好吧，好啊，这边呢我们还有这样的一个图啊，讲解了，说明了一下咱们这个内交互和外外交互啊。

我们来分别看一下这四个图啊，首先呢是第一个图啊，第一个图呢啊这边啊实际上它使用的是这样，BT这样的一个模型的一个结构，而BERT这个模型它结构到底是什么样子呢，没关系啊，这个没关系。

我们主要是看一下它的这个叫做对于这个bird，它最原始的计算文本相似度的一个形式呢，实际上就是把两句话啊拼接在一起，黄色的是A，绿色的是B，可以看一下啊，它中间会有很多的一个交互对吧。

明显的它是一个内交互的一个形式，好我们再来看一下第二种形式啊，第二种形式A这边是A这边是B，他有两个两个模型对吧，两个模型这两个模型呢还是像刚才说的，他可以做这个啊，共享也可以不做共享。

然后再把输出结果对吧，这里可能输出了一个VA这边输出了一个vb，然后计算了一个分数值，那这几个分数值你可以去算余弦相似度，你可以去啊搞个全连接层，做个二分类对吧，这就是什么典型的外交互嘛对吧。

好我们再来看下这个，那这个的话对于这篇模啊，对于这个模型结构来说啊，他是对于我们之前的这样的一个BT，一个模型做了一些改进啊，可以看到他这里有这样的一个啊内交互，也有一个所谓的外交户对吧。

那对于最后这个结构来说也是啊，只是说他的这个外交互的一个结构，稍微做了一些改改动对吧，做了一些改动，好，这就是我们的这个所谓的文本相似度，的一个模型啊，模型，通用领域的基础上进行训练吗。

也可以也可以好吧也可以啊，我这边再给大家总结一下啊，假设你现在是一个特定领域，你是特定领域，那你可以用特定领域的数据进行啊，通常叫做post train啊。

进行post train也就是做一个后后训练啊，那这样的话，你特定领域的这个embedding效果就会提升，效果就会提升，当然啊你的这个post train，E f。

EFA也可以使用通用领域的数据进行训练，好吧，两种形式都可以，但是我我的想我的建议是通用领域，实际上你没有必要了，你自己去你自己的领域上，用自己的数据进行post train就可以了，好吧，这位同学。

但是啊你还是需要去加载他的预训练权重好吧，就是说你在你自己的领域上去训练一个模型，你还是需要去先把他的那个权重权重啊，给加载一下，你还是要把他的权权重给加载一下，为什么呢，因为他这是在全领域训行训练的。

它可能是一个泛化能力比较好的，但是对于你的领域，你想让你的领域效果更好，但是你不能说诶，我只在我自己的领域上面效果好，你一些通用的一些场景，你效果就不好，那肯定是不行的对吧，所以呢你应该先加载它的权重。

然后再在你特定领域的一个数据上，进行一个post train，好吧，这位同学好，我有解释清你的问题吗，这位同学，OK啊，然后这位同学说这里这个EXP，你是指这里这个CLS吗，还是啥。

这位同学是指这里这个cl s吗，还是啥，还是这里这个哦这个吗，E x p，这里这个EXPE哎，这个我还真不太确定它是什么意思啊，这个我还真不太确定他这个exp是什么意思啊，但是我这里简单说明一下啊。

首先呢这里这个cl s还有像这里这个SEP啊，表示的是BT这个模型当中带的这样的一个，特定的一个啊标记位，标记位，那这些标记位有什么用呢，到时候讲BT的时候会去给大家去讲啊，那这里这个EXP1啊。

我这里也不太清楚啊，到这个可能需要去看一下这个CORPOR的这篇paper，它里面的一个应该也是一个特定的一个标记位，需要去看一下这篇paper，他对这个EXP的一个解释好吧。

啊这个东西我下来帮各位同学看一下啊，看完之后，到时候我在群里再同步，各位同步给这位同学好吧，好那我们继续啊，好啊，刚才我们有说到这个哦，文本相似度这一块啊，那文本相似度有内交互，有外交互，当然啊。

我们还是得，虽然这里说了一些比较复杂的一些结构啊，但我们还是得那个从一些简单的模型来入手，毕竟只有简单的大家都弄清楚了，你的这个复杂的模型你才能了解的更好，好吧好，那我们就先来看一下文本相似度。

它的一个可以算是开山鼻祖的一个模型啊，咱们的DSSM这个模型，它的一个结构其实是非常简单的啊，非常简单的，首先呢输入的就是这样的一个，每一个这样的一个词的一个音，这个vector vector。

然后呢他会去做一个所谓的word哈，希那这个可以不做啊，可以不做，然后呢这边会有一些多层的非线性的一些变换，简单点就是咱们的全连接层，加上我们的激活函数，最后啊再去进行我们的这个相似度的这个计算。

哎你可以看到啊，他这里采用的是也是这样的一个cos similarity，对吧，Cos similarity，最后呢再去做一个分类，做一个分类好，那我们哎这个是，啊这是他就是一个整体的一个结构啊。

整体的一个结构，那这个结构我们先不看后面啊，我们不看后面这一块，我们就看前面这里这个Q和这里这个D，从这里就可以看到啊，它实际上它是什么，它就是一个双塔的一个结构对吧，这就是双塔模型它的一个来源啊。

它的一个来源就是来源于咱们的这个DSM，可以看到啊，这边有一个类似于塔的一个结构对吧，这边也有一个类似于塔的一个结构，简单点看呢，就是说哎我这边升啊，输入了一个句子的这样的一个输入了一个句子。

经过了我们的这个embedding matrix，得到了我们的embedding，然后经过我们的这个全连接层，要经过我们的激活函数对吧，最后进行一个相似度计算，然后来进行所谓的一个二分类。

这就是我们最原始的一个，双塔结构的一个模型啊，那后面为什么还有一些其他的塔呢，他的意思就是说，哎我这里可能会有多个document对吧，多个document，然后我这一个query。

要和这些document都进行一个相似度的一个计算啊，所以看着好像有多个它那塔和塔之间呢，大家可以去做一些所谓的权重的一些共享，权重共享，这样的话它的结构就是一样的，它的值也是一样的。

我们就只需要一个模型，一个模型好，这就是我们的DSSM这个模型啊，整体来看模型结构非常简单对吧，但是呢这样的一个模型啊，是我们的文本相似度或者说相似度，计算它的一个比较重要的，一个。

所谓的一个里程碑式的一个这样的一个模型啊，好，那接下来呢，我们就来看我们今天啊的一个重点模型啊，重点模型叫做ESIM这个模型啊，那我们会一起带着大家从理论到实践的层面啊，把ESIM这个模型给实现一下。

好吧嗯这样子啊我们刚好啊稍微休息一会好吧，我们休息5分钟，休息5分钟啊，接下来呢内容不多了啊，主要就是对ESIM这个模型的一个讲解，包括如何去把ESIM这个模型进行一个复现啊，这是我们接下来下半节课。

要给大家讲的一个内容，好吧好，那我们就啊稍微休息一会啊，我们休息5分钟，当然啊对于我们上半节课讲的这些内容，大家如果有什么疑问，就把它打到这个公屏上好吧，打到公屏上呃，待会呢我们进行统一的一个解答啊。

进行统一的解答好，我们稍微休息一会儿啊，好各位同学都回来了啊，我们准备继续后面的内容了，好那接下来我们就来看这个ESIM这个模型啊，ESIM这个模型，那ESAM这个模型为什么要给大家讲这个模型呢。

对于刚才说的这个DSSM这个模型，它是算是这个开山鼻祖对吧，那为什么要讲ESIM这个模型呢，首先呢ESIM这个模型啊，它是基于这个LSTM来的，那也顺便带着大家去复习一下这个AISTM，其次啊。

ESIM这个模型，相比于其他的文本相似度的计算模型来说呢，它的效果和速度都还是不错的啊，都还是不错的好，那我们就一起来看一下啊，ESIM这个模型呢它有两种版本啊，一个呢是基于这个双向ISTM。

就和刚才给大家讲的这个arm，它的一个结构是一样啊，双向的AISTM，第二种结构呢是基于这个TRAISTM，就是基于一个树形结构的LISTM，那如果要使用这个trail i s t m呢。

首先呢需要去构建这样的一个啊预存数啊，去做所谓的语句法分析，把它转，把句子转换成一个树形的一个结构，再给到我们的这个TRISTM，那这一步呢，首先啊就需要你的这个句法分析的这个过程，效果足够好。

不然的话你可能会出现一些错误对吧，所以呢啊我们这边啊，主要还是给大家去讲解，这个基于普通版本的这个LSTM，好吧好，那普通版本的这个LSTM呢，我们来看一下啊，它主要有四个部分。

第一个部分的话是这个input encoding层，它其实就是这个LSTM的一个结构，第二层呢是这个local influence modeling，那这一层呢它实际上是去做了一些啊内交互啊，内交互。

但是他这个内交互怎么做的呢，待会我们详细来看哈，那再后一层是这个influence conversation啊，这一层可以看到啊，它也是一个LSTM对吧，然后最后呢就是做一些所谓的池化操作。

咱们的平均池化层，最大池化层最后再做个soft max，也就是说你可以做个二分类对吧，这就是ESIM整个模型的一个结构啊，整体来看它其实就是我们的LISTM。

加上这里的这个local influence，做了一些所谓的内交互对吧，所以我们重点啊更多是放在这里，这个local influence modeling这一个部分好吧，重点会放在这个部分好。

那接下来呢我们就来把这四个部分啊，分别来看一下啊，首先是我们的这个input encoding层，可以看到啊，它这就是一个LSTM层，这个LSTM层呢，大家可以看到它这里包含了两个部分啊。

也就是包含他的这个hao size和他这个premise啊，他这两个部分呢啊，大家可以简单的要看成对应的，就是输入的两条文本，那对于ESIM这个模型来说啊，他实际上当时提出来的时候是去做什么呢。

他做的是NLI，就自然语言推理啊，就我有一个啊有一个前提，然后我要和它的一个假设，这两者它之间到底是什么样的一个关系，他是做这样的一个NLI的，他是一个矛盾的一个关系，还是能进行毫无关系。

或者说他是一个能相互推出来的一个关系，所以他是一个啊，他这个H和P分别表示就是这个hal size，和咱们的premise，它的一个前提和他的一个假设啊，那我们还是可以利用它的一个，这样的一个结构啊。

我们这边就输入A这条文本，然后这边输入B这个文本，要进行一个相似度的计算就OK了啊，所以它也是能达到这样的一个作用的好，那对于这里来说啊，我们可以看到我们不管是我们的H还是P。

它实际上啊他这里都只有一个模型，都只有一个LST，这里大家需要注意一下啊，他这里只有一个SLSTM，这里看似好像是两个对吧，但实际上它是一个，说白了它就是一个双塔的一个模型，他就是一个双塔的模型。

并且他的这个模型的权重啊，它是进行了一个共享的，它是进行了一个共享的，好共享之后呢，额这边需要大家注意一点啊，他这里是一个双向的对吧，他这里是一个双向的双向的一个输出，结果我们刚才说过啊。

我们会做什么处理呢，我们会把双向的结果进行一个拼接对吧，双向的拼结果进行拼接，这里是最关键的点啊，最关键的点，那拼接之后好，我这里说一下啊，假设我的输入维度啊，我这个LSTM的输出维度是64。

那因为是双向的对吧，我拼接之后维度就变成了128，这里大家需要注意一下好吧，默认是拼接在一起的这个东西，待会也会在我们的代码当中啊，有所体现好，这是他的第一层input encoding。

接下来我们来看第二层，第二层呢叫做local influence modeling，那名字好像挺长的，但实际上啊他实际上做了一个事情，叫做attention，Attention。

什么是attention呢，attention啊，它实际上它不是所谓的一个结构啊，它更适合叫做一种交互的一种方式，它不是一个模型好吧，它不是一个模型，那attention是什么意思呢，好我们来看一下啊。

首先呢他还他是首先做了第一个事情啊，他把这里这个H和P做了一个相乘，他把H和P做了一个相乘，Ok，H和P进行一个相乘，也就是说把两个向量进行了一个相乘，好我们提个问，两个向量相乘表示什么。

它有什么样的一个意思，这里这个H啊也不能叫向量啊，应该叫做H这个代表的这个张量，和P代表的这个张量，这两个张量进行一个相乘，它到底有什么样的一个作用，来各位同学，啊，我们把这里这个H和P的一个维度。

进行考虑一下啊，这个H和P它的一个维度啊，实际上是三个部分，第一个部分呢是我们的bech size，Besize，第二个部分呢是我们的序列的长度，第三个部分呢是我们的这个维度啊，een size哦。

我用size来表示吧，Size ok，那H和P它的维度都是这个样子的，它的BESIZE是一样的，它的这个size也是一样的，唯一可能是序列长度不一样，因为一个是我们的H，一个是P嘛。

那对应到我们这边可能就是一个是A，一个是B那它的长度可能不一样对吧，那这两者基因相乘表示的是什么呢，各位同学，你们觉得表示的是什么，来有同学知道吗啊，大家说一下自己的想法就可以了。

并不是说一定要是对的对吧，大家有什么想法，相似度，其他同学觉得呢，这位同学觉得是什么，我看这位同学应该是有一定的一个基础的啊，这位同学觉得是什么，好那我来解释啊，这位同学其实说的基本上就是对的啊。

基本上是对的，为什么可以说它是一个相似度呢，回忆一下啊，刚才我们的这个余弦相似度是怎么做的，是不是A乘以B除以A的模，B的模，除模是在做什么呀，在做归一化嘛对吧，除以模，我们的目的是在做归一化。

那如果不做归一化，我们就是A乘以B，那这个东西是不是，就可以看成一个所谓的一个相似度，只不过啊我们这里因为有一个序列长度，这个维度，也就是说哎我们这里实际上是有很多个词，哎这边是W1W2W三。

然后这边可能是啊Z1Z2哎，这里的得到的结果是Z1W1，这里得到的是Z1W2，这里得到的是Z1W3，这里是Z2W1Z2W2Z2W3，那这里我们得到的这个东西，它是什么呢。

它是每一个词和词之间它的一个相似度，大家也可以理解为它之间的一个权重，也就是说，Z1这个词和W1这个词它的一个相关性，好Z1这个词和W2这个词它的一个相关性，Z1这个词和W3它的一个词的一个相关性。

你也可以看成它的一个相似度，那相似度越高，那说明它们的相关性就越高对吧，这就是这里这个矩阵它的一个实际的含义，说白了就是词和词之间它的一个相似度，或者说相关性，我们得到这样的一个矩阵之后呢。

我们把这个矩阵去做一个所谓的soft max，做完soft max之后呢，说白了啊，就是对这一行我们去做了一个所谓的规划对吧，那可能就是诶这里是啊0。7，这里是0。2，这里是0。1。

那这样的话就等于我们就得到了Z1这个词，相对于W1这个词来说，它的一个相关性是0。7，Z1相比于像W2来说，它的相关性是0。2，Z1相比于相对于W3来说，它的相关性是0。1，那有了这个权重之后呢。

我们就可以做一个什么，做一个加权求和嘛，我们把这里这个0。7乘以我们W1，再加上0。2乘以W2，再加上0。1乘以我们的W3，那这个东西是啥，这个东西说白了就是用我们的W来表示。

我们的Z也就是说我们用对应的这些词，它的一个加权求和的一个结果，来表示Z1这个词，这就是一个attention啊，attention呃，TENTION就是我先进行一个相乘，得到一个所谓的权重。

得到权重得到这个东西，它是一个权重，再把这个权重分别和我们的A和B再进行相乘，就可以得到加权之后的一个结果，加权之后的一个结果好，这里呢我们就把我们的哦，我这里有写的是Q啊，我这里应该写H的好。

我们这里把P和Q相乘之后，得到了我们的权重矩阵对吧，得到权重矩阵之后呢，我们再分别和原来的两个句子进行加权之后呢，就可以得到加权之后的P和Q，也就是这里的P1撇和Q1撇好，这是原P，这是原Q和加权。

和我们的权重矩阵进行相乘之后，得到加权的P1撇和Q1撇，那这个时候实际上就是在做一些交互处理，交互处理，最后啊我们把这里这个P1P1撇，P减P1P乘P1撇进行一个拼接啊，进行一个拼接。

对于Q来说也是哎也是一样啊，进行一个拼接，进行一个拼接，拼接完之后，再把整体啊作为一个这样的一个输出值，输出值好，这就是我们的这个啊，Local influence model，零层好吧。

local influence mode0层好，这里我们停一下啊，我们停一下，因为这个东西是今天的一个重点啊，今天的一个重点，看各位同学对于这一块还有没有什么疑问啊，再总结一下啊，A和B相乘。

得到了这样的一个所谓的相似度，或者说相关性的一个矩阵，然后做所谓的soft max，soft max的目的在于让它变到一个零一之间，做了一个所谓的归一化，那也做了归一化之后，再做一个加权求和的一个过程。

这样的话我们就可以针对于Z1这个词，得到Z1的一个加一个替代品对吧，替代品也就是这里的P对应的P1撇，好这里我们稍微停一下啊，各位同学有疑问吗，这里这个地方是ESIM模型的重重中之重啊，重中之重。

后续当我们学到BERT这个模型的时候，你会发现它里面的核心点也是attention，也是attention，如果这里这个腾省大家弄明白了，到时候来学BERT的腾省的时候。

大家就会觉得哎和这个特产人差不多嘛，没什么区别，大家就会学起来就会很简单啊，就很简单，好还有疑问吗，各位同学，好如果都没有问题，我们就继续往下了好吧，OK那我们上一步是把PP1撇，还有一些P1减P1撇。

P乘P1撇，拼接在了一起对吧，那拼接完之后呢，我们接下来啊就会给到我们的这个influence，conversation层，这一层也是一样啊，就是我们的双向的LSTM给进去就OK了。

最后就是我们的输出层啊，输出层有这个最大池化层，平均池化层加上我们的soft max层，当然啊，这里这个平均池化层和最大池化层的一个输出，结果啊，我们会进行这样的一个拼接拼接，拼接完之后呢。

再给到我们的这个分类层去做一个分类好吧，好，这就是整个我们的ESIM这个模型的一个结构啊，ESIM模型的结构好，那到这里之后呢，我们的模型结构也就讲完了啊，那这里我们再给大家补充一个额外的知识点啊，好。

那对于我们刚才提到的这个文本表示的，一个方式，和我们的这个基于模型来计算，相似度的一个方式，大家觉得这两种形式各有什么样的优缺呢，大家觉得各有什么优缺，来各位同学，大家觉得刚刚说的。

表示学习和我们基于模型来计算，相似度的一个方式，大家觉得各自有什么优缺，OK那还是我来说吧，其实最大的问题在于嗯啊，这位同学说表示更简单一些啊，也不能这么说啊，其实表示学习也会很复杂，也可以很复杂。

但是感觉信息不多，表示模型直接相加好，我来我来解释一下啊，其实对于表示学习的一个形式呢，只是说他使用的时候速度会更快一些，为什么这么说呢，假设啊我们现在啊我们以检索场景为例。

我们现在有很多这样的一个document，有D1呃，D 2d3，一直到DN，如果是表示学习会怎么做呢，我们提前有一个离线的一个操作，把每一个document转换成一个向量对吧。

V d 1v d2 v d 3v d n，那当用户输入了一条query之后呢，我们只需要把用户的这一条query转换成VQ，然后再把这个VQ和我们这边这个去计算，我们的什么余弦相似度，选一下速度。

它的计算量非常小，我们只需要用模型，把用户的query生成一个向量，然后和这些存储起来的document的向量去计息，计算余弦相似度就OK了，它最大的优势在于什么，在于速度快，速度快，耗时小。

那如果是我们的基于模型的一个形式，你想啊我们这里有N个document，然后有一条用户的query，那我们是不是需要把用户的query，还有D1先给到我们的模型对吧，哎计算一遍得到了我们的一个相似度。

得到了S1好，我们还需要把用户的问题和我们的第二个document，给到模型，得到SR，那好我们一共有N个对吧，最后我们就会得有一个SN，那我们就等于我们需要把这N，N个结果都计算出来。

也就是说我们需要用模型计算N次，计算N次，那这种情况下呢，实际上啊是非常耗时的，非常耗时的，但是基于模型的一个形式，它的效果肯定是好于基于表示学习的对吧，这是不用想的嘛，你用模型实时计算出来的。

那它的效果肯定是会比这种embedding的一个，形式来的更好一些啊，更好一些，所以说啊在这样的一个基础上呢，我们就引入了所谓的一个流程，叫做召回，然后排序read rank，重排序什么意思呢。

我们可以使用我们的这种，embedding的一个形式啊，也就是咱们这样的一个表示学习的一个形式，embedding的一个形式，进行一个召回，我embedding一个形式。

每次只需要计算这个一次embedding，然后算相似度就行了对吧，也就是说我的这个计算量非常小，所以啊我让他来做召回阶段，那可能我一开始库里面有1万个document好。

那我采用这样的一个表示学习的一个形式，然后我取出top20，Top20，我把top20最相似的20个document给取出来，D1到这个D20把它取出来，然后我再进入到我的RERANK阶段。

我把这20个文档和用户的这个query，给到我们的这个排序模型，给到我们的相似度的模型，给到我们相似度模型，这样的话我们只需要计算20次，最后再把相似度最高的这个结果啊排在第一位，或者说你就按相似度。

从大到小进行一个排序对吧，按相似度进行一个salt就OK了就OK了，这样的话我们兼具了效果，那个时间的同时啊，也兼具了一个效果，也兼具了一个效果，这就是目前比较主流的一个，文本检索的一个流程，好吧。

当然啊这里到底应该选择top几，就自己大家就自己来决定了好吧，你可以选top20，你可以选top5，top10都可以好吧，当然你这里选的top的数量越少越越少，那你这里啊。

后续的这个RERANK的一个时间就越短，但是你这个召回的数量少了，那这边可能对最终的结果可能会有一些负面的，一些影响也是有可能的，好吧好，这就是我们今天要给大家讲的，这个文本相似度了啊。

文本相似度包括它的一个应用好吧，好这里我们稍微停一下啊，看对于这一块大家有没有什么疑问的，啊如果没有什么疑问的话，我们就要进入到我们今天的这个实战环节了，啊，实战环节有疑问吗，各位同学，OK行。

那我们就进入到我们代码环节啊，进入到代码环节。

呃代码这一块的话，大家嗯建议大家啊，自己下来一定要动手去写一遍哈，写一遍啊，这边我们，啊我们也重新写一个啊，我们重新写一个，我们先把代码给删了啊，我们再来重新写一个，啊，首先第一步呢。

肯定是要把我们这个PYTORCH给进行导入啊，啊我们在使用PYTORCH这个框架的时候，我们在之前的一个录播课有讲过啊，首先呢我们要使构建一个模型的时候，需要去继承一个类对吧，继承一个类啊。

这个你可以先自己去取个名字啊，这个类的名字你就自己取，我们就叫EC好吧EC好，然后呢他需要继承这样的一个类，继承什么呢，NN导mode对吧，这是我们最关键的啊，最关键的。

然后呢我们需要去实现它的两个方法啊，一个是我们的这个啊构造方法，这是一个是我们的一个构造方法啊，那构造方法是用来干什么的呢，有同学还记得吗，构造方法是用来干嘛的，有同学还记得吗，构造方法是用来干嘛的。

对诶这位同学是新来的吗，好像一直没有看你说话，对构造方法啊，它就是用来初始化咱们的layer的，包括一些参数，初始化layer参数啊，好然后呢我们还需要重写一个方法啊。

叫做咱们的这个for word方法对吧，for的方法，然后是我们的一个输入值，输入值呢我们就按照我们的这个啊，这个和咱们之前的这个分类啊，还不太一样，分类我们刚才说了，他就一条文本。

那对于我们的这个ESIM模型来说，我们是计算的是文本相似度，那就需要两条文本对吧，两条文本啊，那我们就用我们的我们用PQ来表示啊，用我们的P和Q来表示好，OK这是我们的啊for的方法。

forward的方法是做什么的，就是前向传播对吧，选项传播，OK那接下来我们就来看一下啊，我们的这个构造方法需要用到哪些层。

需要用到哪些层，呃，我们来到来到这里哈，我们看一下啊，需要用到哪些层，首先呢这边有一个LSTM层，然后这边是咱们刚刚说的attention，Attention，好像也没有什么额外的权重对吧。

只有一个权重矩阵，所以这里应该是local influence，这一块的话，应该是用不到我们的一些额外的层的，然后这里也是我们的LISTM层，最后呢就是一个啊平均池化层和最大池化层。

还有一个分类层对吧好。

当然啊，最开始这里这个输入啊，还有一个embedding层，embedding层，也就是把我们的这个一个一个的词，转换成对应的一个embedding对吧，好，那我们就首先呢来定义一下。

我们的这个embedding层，embedding层呢它有两个参数啊，第一个参数是我们词典的大小，for capsize啊，你的这个词典的这个大小呢，我们可以从外面传递进来啊，我们从外面传递进来好。

第二个维度呢是这个embedding size，也就是说你的这个embedding层啊要输出到维的，如果你想输出100维的，那你这个参数就填100，好吧好，这是我们的embedding层。

embedding层完了之后呢，我们看一下啊，是这个input encoding这一层是什么。

LISTM嘛对吧，ASTM好，那我们就来写一下我们的这个LSTM啊，我们叫做input encoding，Input a input encoding，LSTM好，那LSTM这个模型呢我们来看一下啊。

它有哪些参数，他这边有一些参数介绍啊，我们来看一下input呃，首先哦不是这个啊，应该是这个地方，首先呢有input size，有hidden size，有input size的话。

就是说你输入的这个数据啊，它的一个维度，hidden size的话就是hidden size，应该不用解释了吧，然后number layer的话，就是说你的这个LSTM是多少层的。

然后还有一个参数叫BIOS，也就是说你要不要添加这个偏移项，batch first的话，意思就是说，你要不要把你的bech size放在第一个维度，通常是为了加速啊。

batch size放在第二个维度速度会更快一些，但是我们默认喜欢把bch size放在第一个维度啊，所以待会我们需要把这个参数改成这个true，然后还有一个常用参数呢是这个drop out。

就如果你给这个drop out一个值啊，它就会再做一些DP out，然后这里还有比较重要的参数啊，就是这个啊，By dictionary，如果你填为true的话，它就是一个双向的LISTM好吧。

所以说对于PYTORCH框架来说啊，使用是非常简单的好，第一个为第一个参数是我们的input size，那对应的就是我们的embedding size对吧，上一层输出的维度是多少。

那我们这个input size的维度就是多少，然后呢我们需要给他一个hidden size啊，Hidden size，那这个hidden size我们要从外面传递进来好吧，传递进来好。

然后我们有一个叫做number lay的呃，我们和论文当中保持一致啊，它是一层对吧，它是一层，那我们就写一层，然后呢它是一个双向的，那我们就有也也改，也弄成双向的啊，也弄成双向的。

然后还有刚才说的一个比较重要的参数啊，Bh first，比如说我们的这个把ch size放在第一个维度啊，那我们就把这个参数设置为true好。

这是我们的这个input encoding层，那这里这个local influence modering层没有权重，那我们就不需要准备啥对吧。

接下来就是这个influence conversation层啊，我们再来定义一下这个啊，Inference，那这里其实是一样的对吧，首先是input size，那就是embedding size。

然后是这里这个hidden size，这个hidden size到底哦不对不对啊，啊我先这么写吧，这里其实有有一个问题啊，我们待会再来说，我们待会再来聊，后面就保持一样啊，我们这里也是true。

然后beside beach first true，好啊，这里我先留一下啊，大家也可以考虑一下，这里这个input size到底应该填什么。

这里这个input size填embedding size对吗，到底应该填什么，这里大家考虑一下好吧，考虑一下好。

我们先继续往后啊，我们继续往后啊，然后呢，我们是需要平均池化层和最大池化层对吧。

平均池化，这里我们采用两种方式啊，第一种方式呢我们先来搞个最大池化层啊，Max co，好我们定义一个Mac book啊，然后呢它需要有一个序列的最大长度，好我们把它从外面传递进来啊。

那这个参数呢实际上就是它的一个啊kernel啊，他的一个kernel size，Kernel size，这是他的一个kernel size啊，啊这是我们的最大池化层次好。

然后是我们可以定义两个全连接层啊，呃电11吧，诶，LINU好，OK那这里又有一个问题了，我们这个linear的第一个维度到底应该填多少好，我先写一个BESIZE好吧，好我们的输出是BESIZE。

要第二个DDX3A，好最后我们输出两个值啊，我们输出两个值，两个值为什么输出两个值呢，这里因为我们需要用到的是交叉熵损失函数啊，所以我们这里输出两个值，那最后我们再加个drop pop，给个0。

2的叫port率，OK这样的话我们初始化的一些layer啊，就准备好了，准备好了，那接下来我们来看一下我们的这个前向传播，前向传播这个首先第一步啊，啊我们去要得到我们的这个哎。

等一下等一下这里忘记说了啊，我们这里初始化的这些layer有一个点啊，有一个点。

我们实际上只初始了一套对吧。

在这个图当中它是有两个LST，但是在我们这里实际上就一个LST。

那一个LSTM怎么达到他两个的一个效果呢。

那就是说你调用两次，这样子的话，实际上就等于做了所谓的权重共享好，我们来看一下啊，首先呢我们得到P的embedding，那就self点embedding层把P传递进来。

然后Q的embedding也是一样啊，我们把Q传递进来，这样我们就得到了P和Q，它对应的一个embedding，然后我们去调用我们的LSTM，叫做local inference是吧，还要啥哦。

Input encoding，input encoding好，我们把我们的p embedding放进来，这样的话，我们就可以得到我们的LSTM的一个输出值，但这个输出值好有点讲究，我们来看一下啊。

它的一个输出值包含了两个部分啊，一个是输出值，一个是这边一个元组，这个元组里面放了hidden state和cell state，我们要的是输出值，这两者he hidden set我们是不需要的啊。

不需要的，所以呢我们就可以啊这么写啊，我们可以写叫做啊，哦我们就还是用个embedding表示吧，P embedding，然后下划线就等于等于这个，这样的话，我们就只拿到了我们的LSTM的一个输出值。

hidden state我们就不要了啊，不要了，而对于Q来说也是一样啊，我们还是用这样的一个形式去拿诶，额这里我们换一种形式啊，上面是把它取出来对吧，那这里的话我们换种形式，我们取零零是什么意思。

零的话就是取前面嘛，取前面对吧，所以说两种形式啊，两种形式都可以好，那接下来呢我们去这里做个drop out吧，好吧，我们做个dropout呃，Q100好。

这样的话我们的这个input encoding层啊，就完成了完成了。

接下来我们来看我们的这个local influence这一层。

首先第一步还是做我们的什么相乘嘛，对吧，我们要把P和Q进行一个相乘好，我们来乘一下啊，touch点matt ma好，我们把这两个进行相乘啊，首先是我们的这个啊P的embedding。

p embedding好，再和q embedding进行相乘，那和Q的embedding进行相乘的时候，这里就需要做一个transpose啊，Transport，这个transport是什么意思呢。

意思是说啊，我们要对Q的embedding的第一个维度，和第二个维度去做一个转制，为什么要做一个转置呢，好我们来看一下啊，对于P的embedding来说啊，它的维度实际上是啥，它的一个维度是。

Besize，然后序列长度，然后是我们的这个啊hidden size对吧，Hidden size，那对于Q的维度来说，它其实也是这个，那这个张量和这个张量是没有办法去做乘法的。

所以我们需要把这两个维度啊做一个调换，调换之后呢，Q1就变成了Q的embedding的维度啊，就变成了这个样子，变成了这个样子，这样子的话我们就可以进行相乘，因为这个维度等于这个维度嘛对吧。

所以呢我们Q和哦，这里写我们这个P啊，和Q就可以进行一个这个相乘的一个处理了，好吧好。

乘完之后呢，我们呢再来做一个加权的一个处理啊。

加权的一个处理嗯，好，那我们首先第一步还是需要先对这个一啊，做这个所谓的一个soft max，soft max呢我们需要有一个维度啊，我们对第二个维度进行soft max，然后还是一样啊。

我们还是去做这样的一个矩阵的一个，或者张亮的一个乘法，然后把这个QUEMBEDDING传递进来好，也就是说这个部分是得到我们加权。

并且规划的一个结果，也就是这里这个0。70。20。1，它的一个权重。

然后有了权重之后呢，再和Q进行一个这个啊加权啊。

这样的话就可以得到我们的啊p hat，也就是我们这里的这个加权之后的一个结果啊。

好那对于我们的Q来说也是一样啊，我们去做一个处理啊，这里我们去做这个soft max的时候，这里大家需要注意一下啊，维度要改变一下，改变一下，其次呢我们需要对我们的soft max这个一啊，做一个转置。

因为它的维度不对啊，他没办法和我们接下来的这个啊，p p embedding进行一个矩阵乘法啊，所以我们要把这里这个也做一个转制，还是把第一个维度和第二个维度进行，交换一下啊。

OK这样的话我们就可以得到我们的Q，他加权之后的一个结果啊，P加权之后的一个Q。

好那我们得到了，就等于是得到了P1撇和Q1撇，接下来是什么，接下来就是拼接嘛，对吧。

接下来就是拼接好，那我们来把它做一个拼接啊，啊我们的PEEMBEDDING，然后是我们的这个p hat，然后是p embedding，减掉p head，然后，p embedding乘以p hat对吧。

OK那对于Q来说也是一样啊，Q embedding，Khat kill embedding，减掉KHAT然p embedding，乘以我们的pi是吧，OK这样的话我们就全部拼接在了一起啊。

当然这里还需要注意一下啊，我们是要以最后一个维度作为一个拼接对吧，这里大家需要注意一下好拼接完之后呢，下一步是什么，是给到我们的influence嘛对吧，Inference。

OK我们把p cat给进来啊，这里我们直接取取零了啊，这里就是得到我们的P，然后Q也是一样啊，Q然后这里是q cat，OK这里我们稍微停一停啊，稍微停一停，刚才我们说这里这个influence。

这里这个东西是有问题的对吧，因为这个input size我们不知道是多少，那这个input size到底是多少呢，好我们来看一下这个input size应该是多少。

首先我们输入的是in vocalf size，然后得到embedding size，Embedding size，经过我们的LSTM，因为它是一个双向的，所以这里的LSTM的一个输出值。

也就是说这个地方它的一个输出值，它的一个维度啊，已经变成了embedding size，乘以二对吧，已经变成了乘以二，哦这里写错了啊，这里写错了，好检查一下啊，QQQQ好，写错了啊，这个地方好。

这边已经乘以二了对吧，乘完了二之后呢，我们这边呢又去做了什么，做了四次的一个拼接，所以这个时候啊就又变成了embedding乘以二，再乘以什么，再乘以四，因为一共有四个嘛。

所以啊这里这个influence层啊，他的这个维度就应该是hidden，hidden size乘以什么乘以88，好我们继续往下啊，我们的这个啊influence层完了之后是啥，这是我们的预测层了啊。

预测层了，好那我们首先拿一下这个啊p max啊，我们就掉下我们的最大池化层，把我们的这个P啊给传递进来，然后呢我们需要把中间的这个维度给去了啊，那对于Q来说也是一样啊，好，这样的话。

我们就可以得到我们最大池化层的一个结果，然后呢我们再去做一下平均池化层，平均池化层的话好，我们可以直接用touch打min啊，直接用touch打min，然后把我们的P传递进来，还是一样啊。

我们这边啊这边需要注意一下啊，这里是要根据我们的这个中间这个维度去取平，均好吧，这里大家不要弄错了，也就是这个序列长度的那个维度啊，好，这样的话我们就得到了最大池化层的结构，和平均池化层的一个结果。

最后我们再做一个事情啊。

把它做一个什么，做一个拼接，也就是这里说的。

我们要把结果做个拼接，对吧好。

那我们把结果拼接一下，P max，Q max，还有PMQM，好最后我们再调用一下这个dropout，好这里我们需要有一个输出值，啊啊我们用out，OK最后的话再给到我们的这个啊分类层啊。

分类层先给到dance1好out，然后我们可以加一个这个激活函数，激活函数啊，我们加个tench激活函数，好我们再经过一下我们的这个drop pot吧，我们最后再经过我们的这个啊DX啊。

然后把结果进行返回，OK整个模型啊我们就写完了，然后这里这个dance以及大家需要注意一下啊，我们这里是不是就应该也是hidden size，1en size再乘以多少呢。

因为这里也是一个四部分进行一个拼接对吧，然后刚包括刚才这里是一个双向的，所以啊我们这里应该也是乘以八，好这就是我们整个ESIM模型的一个结构了啊，结构接下来呢我们来跑一下啊。

我们在我们的train方法里啊，train方法呢和我们之前的那个分类是一样的啊，分类是一样的，然后我们这边嗯改一下啊，我们从我们刚才写的这个里面进来，It seem to，然后我们看一下啊。

work help size是不是一样的，Embedding size，Hidden size，max ell啊，都是一样的，好，OK我们把模型跑一下哈，啊我这里先取1000条数据好吧，我们速度快一点。

不然比较耗时啊，数据量大的话比较耗时，我们来看一下会不会报错啊，诶好像是报错了啊，啊这里必须是用一个long的类型啊，那我们在进行FORWORD的时候啊，我们可以把它转换成一个浪的一个形式。

然后下面也是一样啊，我们做验证的时候也是一样，那训练代码呢和我们之前讲的，TAXN的一个训练代码是一样的啊，我们就啊不再重复说了啊，简单看一眼啊，简单看一眼，这边呢去加载数据对吧，加载数据也不说了啊。

然后这边是我们的初始化我们的一个模型啊，初始化我们的模型，然后放到我们的GPU上，然后优化器定义我们的cross entrop损失函数，然后这边是循环五个epoch。

然后以batch size的形式去取数据对吧，前向传播要计算loss梯度归一，反向传播更新权重好，这些都是我们之前说过的了啊，之前说过的呃，正常是跑起来了啊，因为我这里就取了1000条数据。

就取了1000条数据啊，没有全部跑，所以效果可能不太好，大家到时候就下来自己去跑这个好吧，我们先简单看一下第一个epoch呢，我们的训练集的准确率是57，验证集是49，然后变成了59的64。

然后65的53诶，这个法案效果是降低了一点点对吧，不过这个大家可以把这行代码啊，把这个改了，让它去跑一个全量的一个数据啊，全量的一个数据，整体来看模型是持续在收敛的啊，持续在收敛的，没有什么问题。

没有什么问题，验证集的效果也是在持续提升的啊，好那整体来看代码应该是没什么问题啊，没什么问题，那细节的话啊，各位同学就自己下来看了好吧，但整体和我们上节课那个录播课里的TXCNN啊。

他的这个流程是一样的一样的，关键还是在于模型的一个结构好吧，模型结构一点是，这里的双向LSTM需要额去乘以二，维度要乘以二，其次呢我们这里做了一个拼接对吧，有四次的拼接，所以呢二还要乘以四。

所以我们第二个AISTM它的一个输入值啊，就是hidden size乘以八，这里是非常重要的一个点啊，大家需要注意一下，包括这里的这个linear层也是一样的啊，因为我们这里也是做了这样的一个拼接对吧。

也是做了这样的一个拼接，所以这里也是要乘以8×8好，这就是我们整个ESIM这个模型啊，整个ECM的一个模型，那训练细节的话，大家就自己下来去看代码了好吧，这种重复的代码我们就不带着大家去看了。

OK那咱们今天的一个课程内容啊，基本上就给大家讲到这里了好吧，什么时候需要drop out啊，drop out的又作用呢是用来防止模型过拟合的。

基本上呢你经过了一层全连接层，或者说经过了一层这样的一个AISTM层，你就可以去添加上这样的一个draw out，好吧，我们可以看一下啊，啊我们这里embedding，然后LSTMASTM经过之后呢。

我做了个drop out，然后这里因为没有权重嘛对吧，没有权重，attention层是没有权重的啊，所以我没有做drop out，然后啊腾讯之后做了拼接，又给到了我们的这个啊LSTM层。

然后做了石化和这个这个啊啊，平均池化层和最大池化层，那这两个地方也是没有权重的，对吧，然后我是拼接完之后又做了一个drop out，好经过这第二个这第一个全连接层之后呢，我又做了一个drop po。

所以你经过了有权重的层之后，你就可以考虑去做一下drop out，好吧，这位同学。

OK行，其他同学还有问题吗，如果没有什么问题的话，咱们今天的一个课程内容啊，基本上就给大家讲到这里了，好吧啊。

今天内容还是挺多的啊，总之大家下来要多花点时间去复习一下啊，包括这个表示学习和这里的这样的一个，匹配式的一个模型啊。

最重要的点在这里啊，在这个attention这一块，这个是非常重要的好吧，OK如果没有什么问题，那咱们今天的一个啊课程内容，咱们就到这边了好吧，各位同学下来就好好复习，然后下来之后呢。

自己要把这个ESIM这个模型做一个复现，然后URBO那一块要学会如何去使用好吧，OK那咱们今天的课程内容就到这边，大家有什么疑问的话。

就在群里和我再沟通就OK了啊。

【七月在线】NLP高端就业训练营10期 - P5：1.基于Attention机制的Seq2Seq任务_ev - IT自学网100 - BV1uxT5eEEr6

OK那我们准备开始啊，这个给大家聊一下，关于序列到序列任务当中的注意力机制呃，关于这部分内容呢，我先简单的说明一下，为什么要选择这么一个题目，首先呢我们先看一下关于注意力机制啊。

这个对深度学习可能有所了解的同学啊，大家应该清楚啊，所谓的深度学习取得很好成绩的，一个很重要原因，就在于所谓的端到端的一个表征，学习的能力很强啊，简单点说，就是以前由人工所完成的一些特征提取的工作。

现在我们可以通过构建深层的网络，把特征通过自动化的方式提取出来，然后再进行所谓的分类也好，回归也好等等的各种各样的工作任务，所以就是说，深度学习最核心的，其实就体现在对特征的提取上。

那么过提到特征提取呢，就不得不讨论另外两个，关于特征提取的方法或者框架，一个呢就是所谓的CNN网络啊，以CN网络为代表性的所谓的空间特区，空间特征提取的这种框架对吧，我们的图片或者图像啊。

方向取得了非常好的一些成绩，人脸识别现在已经是非常非常成熟的一个工作，包括目标检测，包括啊像这种啊生成对抗的网络的这种工作，都是非常好的工作，那么其实大家可以看到其基础性的功能。

其实就在于对图片这种空间特征的提取的能力，越来越强，这是关于这个空间特征的提取，那么另外一个非常重要的框架呢，就是所谓的呃循环神经网络啊，以循环神经网络为代表的，在时间序列上的特征提取对吧。

我们有了一个呃序列，然后呢在序列维度上我们可以通过呃RN网络，然后通过LSTM提取它的空间，这个时序特征啊，时间上的序列特征，那么通过这两方面的不断的突破啊，我们又取得了很多很很好的一些工作。

那么这和注意力机制又有什么关系呢，那么从现在啊，2019年年底这个视角上去看的话，可以这么说，注意力机制呃，今后一定会成为啊，不能说比像CNRN这么啊还要优秀的一个工作。

但至少啊这三者作为特征提取的框架，至少这三者是比肩的一个一个一个一个位置，因为今后啊因今后大家在深度学习方向上，在提到特征提取的时候啊，空间特征的CN实际特征的RN呃，可能越来越多的模型啊。

可能就会使用到所谓的注意力机制，来提取各种各样的特征，其实如果对NLP方向相对了解一些的同学，可能就会注意到啊，以BT模型为主的啊对吧，各种各样的这种嗯预训练模型，也取得了非常好的工作。

那么其实往往核心的内容上去看的话，你会发现transformer的核心，其实就是所谓的注意力机制，就是后面我们会讲到的自注意力机制对吧，所以从这个角度上去看啊，所以今后啊注意力机制一定会成为啊。

很多工作的基础性工作，所以在这方面上花上一部分的精力去学习，和了解，对今后的发展是很有帮助的，这是关于注意力机制的选择，那么再往前看呢，我们还可以看到，叫做序列到序列任务当中的注意力机制。

为什么不是直接就讲注意力对吧，不是直接讲attention，而是讲序列到序列任务当中的注意力呢，其实这就牵扯到另外一个原因，就是一项技术的发展啊和突破啊，甚至是突破，他一定不是从石头缝里蹦出来的对吧。

他一定不是凭空想出来的，作者肯定也不是凭空琢磨琢磨，哎，睡个觉啊，就把这个事解决了，肯定不是这样，那是什么样的，那一定是在特定的应用场景，或者一定是在特定的呃之前的工作的基础上。

至于之前之前工作的一些不足，缺陷和问题进行了补充改进或者是优化，提出了新的方法，那么它一定是有一个发展的脉络和这个规律的，可循的啊，一定是一条线对吧，哎除了模型AA呢有问题。

针对A的问题进行了改进和调优，得到了模型B然后在B呢肯定还会有问题，然后才是C这是技术发展本身的规律嘛，一定是有一个阶段性的，或者有一定是有一个基础性工作的，那么注意力机制就是在序列到序列。

这种任务当中啊，针对之前传统方法或者之前方法当中的不足，或者缺陷提出了改进，引出了所谓的attention机制，当然在此基础上也进行了高度的抽象和泛化啊，以适应不同的应用场景。

所以呢今天就起到这么个题目，叫做序列到序列任务当中的注意力机制，一方面核心还是希望能够给大家介绍一下，Tension，另外一方面呢也是希望借助这个分析的过程，能够把脉络梳理清楚。

像在我们呃实训营或者就业班的课程当中，我们一定一直在和同学们强调这么一个概念啊，就是学习不能一眉毛胡子一抓一把抓对吧，他一定是一个发展的脉络啊，有了A才有B有了B才有C啊，B的问题是什么。

C的改进在哪里啊，你只有了解了这过程以后呢，你把视角放放长远一些，你会发现哦所有的模型的发展啊，原来是这么一个逻辑，那你说这东西有什么用啊，那这东西不当吃不当喝是吧，当你占到了一定的前沿位置的时候。

你就可以有针对性的，或者你就可以很很自然的去考虑到，它发展的一个方向到底在哪啊，如果你对之前的发展没有了解的话，对未来一定是毫无所知的对吧，所以说啊一定是要梳理成，我们会梳理成很多的这种呃脉络。

克脉络的发展方向啊，沿着不同的脉络啊，就像研究生我们在做选题的时候，说，开题的时候，老板肯定啊，导师肯定会问很多的一些问题吧，你为什么选这个原因是在哪，然后未来的研究方向是什么。

这个时候你站在了某一个脉络当中的节点上啊，你就会很清晰的知道你现在在哪儿，你要去哪，你所面临的问题是什么，别人解决的方案是什么，你提出的优越性在哪会一清二楚，对今后的发展也是非常有帮助的啊。

关于题目哈有这么一个引入，那么我们看一下内容啊，我们看一下内容，今天的内容呢其实相对比较多哈，这个鉴于时间原因可能有针对性的侧重吧，就给大家这个介绍，那么三方面，第一个方面呢叫做序列到序列任务当中的。

编码器，解码器架构，第二个呢是就是所谓的序列到序列任务当中的，注意力机制，第三个呢就是注意力机制本身，这个呢其实也是有原因的，就是呃decoder decoder架构，编码器。

解解码器架构本身是可以解决一系列的问题，其中在sequence to sequence，就是序列到序列任务当中呢，起到了一定的这个作用，但是啊就从传统的这种encoder，decoder架构本身呢。

其实还是有一个问题的，就像刚才我们所说的，你对已有工作哎进行了一个分析啊，发现它是有问题的，或者有有可改进的，那么就针对这一点可改进的地方，就可以很自然地引出了所谓的注意力机制啊，后面我们就是第二部分。

那么有了在序列到序列，任务当中的注意力机制以后呢，我们可以做一个更高层的抽象，我们把可以从一个特定任务当中解放出来对吧，数学或者说是呃就这么一个优点是吧，我们不断的在做抽象。

把一些更普世的规律能够把握住啊，为什么要这样做呢，其实还有第四部分啊，就是你抽象出来的这个注意力机制，那么怎么样再结合着其他的任务进行使用，那就是应用的部分，这也符合我们呃，不管是科学也好，技术也好。

本身的发展规律对吧，从我们一个实验实践性的应用开始啊，发现它的问题，然后抽象出一个逻辑和抽象出一个理论，然后用这套逻辑和理论来指导新的应用，那么在新的应用过程当中又发现有问题。

那么再改再抽象再改进嘛对吧，这也是符合我们事物发展一般规律的，那么从以上三点啊，那么第一点我们就把聚焦在第一部分，就是关于序列到序列任务当中的编码器，解码器架构，我们看一下之前的工作是怎么做的。

然后呢自然而然你就会体会到这个工作的意义，以及它可能存在的问题啊，这是我们第一部分的原因好了，那么include decoder的架构呢，其实我们第一部分就是所谓的网络架构，网络架构啊。

在这个地方再多说一点啊，在学习过程当中啊，我一直给同学们说，就是学习呢是有套路的，就是你你可能有些同学这个花了很多的精力，时间效果不理想，为什么就是你没有达到一个统一，什么叫统一呢，我一直在强调啊。

就是学习一个新的网络模型，或者新的工作的时候，你一定从三个方面，或者多个方面去对它进行考察，比如说我们在当前的这个encoder decoder架构，哪三个方面，第一个是图啊，读论文。

读paper的时候，我们也可以看到大量的图示，这些网络架构图，对一去理解这个工作本身的含义，是非常有价值的，因为图示嘛非常的直观对吧，你通过图示的理解，能够大体的去了解到他工作的一个逻辑，是什么样的啊。

这是图示本身的含义，那么第二个方面呢就是关于公式部分啊，关于公式，一会我们再讨论细节啊，公式，那么公式呢，这种数学上的表述是无二一性的是吧，它在形式化的图的基础上，这样的话呢。

他两个之间分别起到了哎不同的作用，图很直观啊，一清二楚，可以说你看起来就非常的啊清爽是吧，图示本身就是这么起到这么一个作用，但是很多的细节在图示上你是看不清楚的啊，或者说你在图示上表示不出来。

那这个时候结合着公式部分啊，把这两个部分进行一个对应映射啊，通过数学公式，你能够在更细节的啊，甚至比如说我们用标量表示是吧，用标量表示的时候，甚至每一个符号，每一个运算过程。

其实我都是可以在数学公式上看得到的啊，这两者之间就起到了一个相辅相成的工作啊，图示更直观，但是没有细节，数学公式展示了所有的细节，但是很显然嗯，大家天然的，好像对数学公式本身。

有一个有一个消化的过程是吧，他俩之间要需要结合起来，但是这把还没完，因为最终我们的目的不是为了画图，也不是为了写公式，最终的目的是为了能够解决一些实际问题，能够使我们的呃程序能够run起来。

所以第三部分一定是什么，一定是代码部分啊，一定是代码，就是说这三个啊，这三个维度啊讲的其实是一回事对吧，比如说你当前的我们encoder，decoder这个架构为例啊，它就是这么一种模型架构。

那么从图上是怎么展示的，从数学公式上是怎么展示的，从代码上是怎么展示的啊，这三者啊一定要统一起来，你才会发现OK啊，也就是说其实最后做评估的时候，你会发现啊，图看懂了公式，明白了，代码忘起来了。

那这个事我觉得就可以告一段落了，我们可以继续往下走对吧，你是你不能上来就就就划水，不行啊，千万不能划水，因为我看到太多的同学好像啊面试的时候也好，还是交流的时候也好，好像懂一点。

但是你往细节上一问就卡壳了，为什么，因为都是很多的信息都是从图上得到的，一到了细节上你全蒙了，为什么你公式上不理解啊，那这个时候我怎么预期你的代码能写，对啊对吧，特别是现在很多的工具啊。

TENSORFLOW啊，PYTORCH这种东西很难说，你你到了一个到了一个抽象程度，这么高的一个过程，你你今后面临新的问题，你怎么去做啊，这也是一个问题，OK多说这么些啊，我们就以啊图先看一下啊。

你图看一下，其实你会发现encode以后这架构非常简单，就是一就是两个就是两个循环，你看就是两个RN嘛，循环循环网络是吧，你会发现从左往右一个从右往左，无非就是两个循环神经网络，但是不同的地方在哪里。

我们看一下在编码器阶段啊，encoder阶段我们的输入是X1XT，很显然我们知道T是时间不是吧，第T个时间维度上从一到大T啊，每一个时刻都有相应的输入进来，输入进来呢很显然这一部分是隐藏层是吧。

隐藏每一个隐藏的都向前，对向下一个时间部进行一个输出啊，换句话说，每一个隐藏层，它既啊在当前时刻接收当前时刻的输入，还接收上一个时刻的隐藏的一个输入对吧，这是标准的RN网络，关键就在于所谓的编码。

到底把这些输入信息编码成了谁，编码到了哪儿，图上，其实很显然就在最后一个时刻T的时候，我把前面所有的输入信息X一一直到X大T，所有的信息都编码到了C这个状态当中了，记住在最后一个时刻。

把前面所有的状态信息都编码到了，最后一个状态上，C那么有了C这个编码信息以后，它理论上来说，好像应该包含了从X1到X1的所有信息，然后有了这个编码信息以后，在decoder阶段啊。

在decoder解码阶段，就把编码之后的这个C信息作为我sequence to，Sequence，能序列到序列任务当中，的一个非常重要的输入内容，因为你输入的是X我都编到C当中了，再进行向外输出的时候。

那C的价值就在整个过程当中体现出来了，每一个隐藏层状态，这个地方我们可以看到每一个隐藏层状态，在进行向外预测的时候，比如说Y2向外预测的时候，其实你会发现它要输入很多信息。

比如说在decoder架构当中的，上一个时刻的隐藏层状态对吧，这是很显然需要输入的上一个时刻所对应的，实际输出Y以及我们所谓的输入信息，所编码的向量，C都作为当前这个时刻的输入信息。

然后才对当前时刻进行一个预测输出Y，那大家其实可以看到，这个预测输出应该是相对比较靠谱了的，为什么，因为他的输出，不光是依赖于上一个时刻的隐藏状态对吧，不光是依赖于你上一个时刻的，上一个时刻的输出。

还包括我前面所有时刻的所谓的编码信息，那这样的话，我对当前时刻的预测应该是相对比较靠谱的，当然同样你可以看到啊，每一个时刻的输预测输出的时候，都是上一个时刻的输出，以及上一个时刻的隐藏状态。

以及所谓的编码信息，C都在整个的过程当中起到了作用啊，这就是在呃论文当中，encoder decoder所设计的一个网络架构啊，这是图示上所表示出来的一个所有信息。

其实大家可以看到最核心的一点就在这个地方，就是我们在所有的时间簿上，把所有的时间部信息，是所有时间布上的输入信息，都编码到了C当中去了啊，用C在整个的预测过程当中，起到一个非常重要的输入信息的内容啊。

这是图，那么公式其实啊我们可以看到啊，我们可以看到，首先我们知道RN网络，我预期大家可能对比如说像RN这种网络，其实应该有一个了解对吧，在一开始的隐藏的状态，我们用零进行初始化，这个也很自然。

那么再往下你会发现在DTT这个时刻当中的，每一个隐藏层状态的神经元的输出啊，它其实是由两部分组成的，其实在这个地方，Z起到了一个所谓的开关的一个作用，它起到了要在上一个时刻的H。

以及上一个时刻的所谓的two的H当中，进行一个选择的一个工作啊，就像一个开关一样，我到底是选择让上一个时刻的H出去，还是上一个时刻，还是当前时刻的HT的出出去啊，作为一个选择。

然后呢重要的是在我们的计算HT的当中，你会发现在整个的计算过程当中啊，我们就是一个完整的这个呃，呃这个呃循环神经网络是吧，然后我们继续往下看下图啊，看下图我们可以看到其实刚才所说的啊。

那个Z其实就起到了一个开关性的作用啊，我在H啊，上一个时刻的H，还是在当前时刻的h two的之间做一个选择，其中还有一个R啊来作为所作所谓的重置门啊，其实一个标准的JRRU网络啊。

就是我我当前时刻的HT的，需要在H当中保留多少信息，通过R重置门来进行一个标准，所以你会发现整个的就是一个完整的一个，ERN网络，其实最重要的在后面我们可以看一下，在最后一个时间步N上啊。

在最后一个时间步N上，我把所有的信息都编码的编码到了向量C当中，大家可以看到啊，就是原文本最后的第N个时刻，编码器的隐藏状态，计算完成原文本的定长向量表示为C，就是我不管你前面到底有多少步。

因为你说有多少信息，我把所有的信息都表成了表征为这个C向量，然后呢这是encoder过程，那么看一下decoder啊，在decoder过程当中，一开始在解码器状态的T0时刻，我把这个C进行一个解码啊。

把它输出到H1撇二零当中啊，第零个时刻的解码器的隐藏层状态，那这样的话哎这个信息就被保存下来啊，进行使用，那么再往下下面的第T个时刻的过程当中，我们还是其实网络结构是一样的啊。

其实就是一个标准的GRU网络，只不过在整个的网络过程当中的计算每一个呃，这个隐藏层状态的时候，你会发现它都使用到了，刚才所说的那个定长向量C啊，就是我们上一个decode。

encoder过程当中的那个编码信息，C保存了所有输入信息的那个状态对吧，那你会发现哎这个地方也使用到了C，这个地方也使用到了C，每一个应，每一个状态其实都和我们上一个啊。

encoder过程当中的那个所有的信息相关，有了这个以后，我们其实还是进行一个循环网络对吧，最后再进行一个预测输出啊，对我们所有的啊，比如说我们这是sequence to sequence啊。

每一个符号的一个输出进行一个概率计算，那么这个概率最大的那个，当然就作为那个符号的输出就可以了啊，细节部分，有兴趣的同学可以课下的时候再看一遍，其实就是个soft max，一个一个多分类而已对吧。

然后呢我们看下代码啊，看下代码部分，代码部分呢这个呃呃单词啊，这个呃字典，然后语料库这个就不多介绍了啊，这个也也很简单，大家会看一下就可以了，我们中间看encoder和decoder两个架构啊。

凝固的过程当中其实没什么问题啊，其实就是个标准的RN网络啊，这是这个没用可解释的呃，看下decoder关键核心在这个地方，你会发现decoder呢其实也没什么太大问题啊，也其实也是一个标准的RN网络。

但是核心就在这个地方，就像刚才我们所说的啊，核心就像我们所说的，我们在使用decoder这个RN的时候，它的初始状态不是啊不是随机设置的，也不是零值设置的，而是使用到了encoder states。

就是encoder的那个状态，我们看一下这个encoder这个st在哪，在这就是我们encoder的输出嘛，对吧，encoder整个结构的一个输出，也说就像刚才我们在代码，我在数学公式上可以看到的。

我把encoder过过程当中，所有的输入信息都进行了一个编码，编码到了最后一步的隐藏层状态上，那么在decoder阶段，我用一这个编码的所有信息的状态，进行一个对网络的一个encode。

decoder网络的一个初始化，那这样我认为唉，我所有的信息都已经保存到了啊，所有的输入信息都已经在抵扣的过程当中，进行了一个使用啊，这其实就是核心代码就这么一步，剩下的就是整个的一个训练过程。

这个没有什么太大可解释的是吧，这是关于代码部分啊，关于代码包部分好了，刚才那就关于这个呃，encoder decoder做了一个介绍，那么回过头来啊，回过头来看一下，我们分析一下这个问题在哪啊。

其实通过刚才的介绍，其实我觉得大家能够有意识的就发现唉，问题有哪儿有问题啊，就在这个地方，为什么在这个地方呢，我们看一下这个C样是怎么来描述的，RNE或者decoder神经网络架构呢。

使用循环神经网络进行学习，就是刚才我们所说的，它是将变长的原序列X，就像刚我们所说的X1直到XT，其实这个XT是不定的对吧，就像我们比如说做一个自然语言里面，比如我们一个翻译对吧，我们把中文翻译成英文。

因为我们知道每一个语言，他们的这种表达能力其实是不太一样的，所以你是同样输入一个语义上一样的一个句子，可能中文短，英文可能长，当然也可能有相反的方向，所以这个时候他是个不定场的输入。

那么这个时候呢在include decode架构当中，我就是将这个不定长的原始信息，X编码成为一个定长的向量表示C，特别是在最后一步上啊，其实不光是定查，而且是我只是在最后一步放上有输出，这也很好理解。

就是我要保证在所有的输入都完成以后，将所有的啊，理论上来说是把所有的信息都编码到了，这个定长表示C当中，然后啊将这个定方表示C呢，解码成我们的变长的序列Y，这是刚才我们所说的核核心问题就在这个地方。

你这个定长表示的向量C嗯，有没有这种语义上的存储能力，能够把所有的输入信息，这个变长的输入信息，所有的语义信息都进行一个编码，这个编码的效率和，是怎么样的对吧，效率是怎么样的，这个程度是怎么样的。

都是有大大的一个问号，那这就是问题吗，好了那基于这个问题，那么大家想一下有什么可改进的思路吗，就是说问题现在已经提出来了，就是关于变长的信息的定长表示，很显然是有信息丢失的对吧，那怎么办。

那我们无非一个很朴素的想法，就是我无非就是把这个定长表示，改成不定长就可以了啊，那其实就是等于每一个都有输出了，那这又牵扯到另外一个问题啊，牵扯到另外一个问题就不经济了，就是效率上可能就是。

另外你你虽然说那还不如直接把X1到XT，直接输入到decoder架构当中去了，是吧，嗯这就不经济，那怎么办，那那我们是不是可以这样想，就是我最后的这次信息的这个学习，一定是和前面的所有的信息都是相关的。

这是肯定的啊，只不过这个定长表示呢不太嗯嗯容量太小对吧，信息表达能力容量太小，那怎么办，我是不是可以再进行这个特征选择的时候，我都在前面的若干个隐藏层状态当中，都进行特这个呃学习，只不过呢有侧重不同啊。

是离我近的，可能会学的多一点，离我远的可能学学的少一点，当然这只是举个例子，也就是说我根据不同的权重进行学习，这是一方面，另外一方面呢，我不再仅仅是只是拿着最后一个C啊。

你会发现在decoder过程当中，每一个状态都只使用到了C这一个变量，那我是不是可以有针对性的，比如说在这个Y2所对应的引状态当中，我是不是可以学习一个C，那么在Y1所对应的引状态当中。

我学习另外一个C，那这样的话每一个特征，它所对应的这个学习的表达能力，肯定是不一样的，对吧，那这是一个问题的提出，以及可可可能的一种解决方案，那我们看一下，那么我们再看一下这个图。

我觉得大家应该是能够理解，刚才所说的那个含义了，就是我们所说的序列到序列，任务当中的注意力机制，真正的引入了所谓的attention机制，那到底怎么回事呢，其实我们可以看到啊。

呃其实还是分为encoder和decoder两个网络啊，还是一个encoder decoder架构，那么在encoder过程当中啊，看看不同在哪，还是不定还是一个变长的X1直到XT啊。

首先我们先不不管这个双向RN啊，其实这个也很好理解，RN本身通过双向机制，我们可以更好的表征这个序序列能力是吧，但是呢我们先不管这个东西，我们先看上面其实就是一个RN对吧。

只不过我们就会发现原来只有最后一个in状态，进行了一个定场C的一个学习，现在呢不是这样的，哎，你会发现前面所有的隐藏层状态，都有一个输出对吧，都有一部分信息进行了输出，然后把所有的信息进行一个综合啊。

学习到一个啊编码信息，但是更重要的在于你会发现啊，更重要的在于，这个编码信息并不是每一个decoder过程，当对，不再是每一个解码过程当中都使用这一个信息，而是你会发现有针对性的。

当前在decoder是第T个时间步上，我就学习当前这第T个时间步上，所对应的输入信息的一个编码，那么很显然，那么在T减一个步骤，那么学习DT减一个步骤的信息编码，DT加一个步骤。

学习DT加一个P维度的提几遍码，每一个时间维度上我都重新学习一遍，有针对性的重新学习一遍，那么大家这样可以想象得到这种学习到的信息，对我当前时刻的预测输出的帮助，肯定是要远远大于对吧。

所有时刻都使用一个信息的效果啊，这就是一个很很朴素的一个想法，那么通过符号上我们再看一下，从H一一直到HT啊，是encoder架构当中的隐藏层状态，每一个隐藏层状态都有一部分信息可以看到啊。

这里的AT1T21231直到大T，很显然对应了这里的一到大T个隐藏层状态，更重要的是什么，更重要的是前面这个T的含义，前面这个T的含义，对应的是我们在decoder阶段啊，在进行解码阶段。

那个隐藏层它所对应的时间不是小T，那么就像刚才我们所说的啊，就像刚才我们所说的，随着这个小T的变化，小T从T减一变成了T，所以我学的是DT步的第一个，第二个，第三个一直到大七个啊，隐藏层状态的信息。

那么随着这个小T再往下到了T加一，那么很显然我学习的是T加一部的第一个，第二个，第三个遇到大T隐藏成状态的信息，这样就更有针对性了，不光是那不光是提取了所有的输入的，隐藏层特征。

而且针对每一个输出层的时间维度，进行了一个重新学习啊，这就是这其实就是attention了啊，这其实就是attention结构了啊，现在特别是在sequence to sequence问题当中。

我们所使用的很显然就从图上你可以看到，从刚才的分析也可以看到我们再朴素的想法哎，可以确实应该是这样对吧，以前就是个定场，表示C在每一步上都是使用的一个量，现在呢我每一步上都重新学习一遍，这是第一点。

而且重新学习的这一个，不是只是在最后一个状态上有输出，而是在每一个时间，在每一个encoder过程当中，时间维度上都有一部分信息进行了学习，这很显然有针对性，对这次在我再预测输出。

这个BT很显然就靠谱很多对吧，这图啊看图一图胜千言，但是这个千言你也得看，就是这个盛出来的这个千岩，你得知道他剩在哪是吧，我们可以看一下这个公式部分，其实公式部分呢，以后的过程其实没什么太多可说的。

就是其实标准的一个RN，只不过他是个双向的啊，双向的其实和单向的也没什么区别，就是一个前项，一个后项，只不过输入输入顺序反过来就可以了是吧，这没什么可以多说的，重点其实还是在解码阶段啊。

还是在解码阶段那个每一次的解码信息啊，到底是包含哪些信息，这是需要特别需要注意的，可以看到啊，其实从整个结构上，我们通过这个式子其实可以看到每一个解码，每一个解码器的这个隐藏层状态。

其实和我们之前其实还是一样的，还是个标准GRE，但是不同的地方在哪，看后面啊，看后面只有同学式子上和刚才那个差不多，90%都是一样的，甚至你可以说99%都是一样的，哪儿不一样，看后面哎。

C还是我们前面刚才所说的那个呃，信息的一个全值矩阵啊，这个就不管了，重点在这个地方，C你这不上面也有C吗，不一样的地方在哪啊，仔细看一下啊，看下这式子前面都不用看，你看这个CCCCC对吧，往下看。

先找找找找找找啊，要不这都是CCCCC吗，哪儿不一样，有没有同学注意到啊，这个地方的C是不带下标的，换句话说这里的C就是那个C，就是那个所谓的定长，表示C不带下标，那这个地方和时间维度上是没有关系的。

他所有的时间维度都是那个C对吧，看这个地方不同在哪，这个地方是带下标，而且这个下标是和我们的抵扣的所对应的，隐藏的状态，那个时间维度是相对应的啊，这个这个I就是这个地方的I，就是第二步那个I。

所以很显然，当我在第I步进行隐藏层计算的时候，我要一个单独的特殊的对应，我当前时刻的那个C哪个C看下面的计算啊，看下面的计算C是怎么得到的，就CIDI步上是怎么得到的，这个C它呢其实你可以看到啊。

刚才我们所说的，这里的I就是我们在decoder过程当中的，第I步是吧，第I个时间步，那么这第I个时间步呢他是怎么得到呢，刚才我们说过，他是在输入维度上，就那个encoder过程当中所有的时间维度上。

这从一开始一直到TX输入的第替补，最后那一步，所有的时间输入的，所有时间维度上进行一个累加加，谁加的就是我们所有输入当中的隐藏层状态，当然这个隐藏层状态每一步的多少，是需要进行一个全职计算的。

就是说我并不是非常啊粗暴的，把所有的隐藏层状态进行了一个直接累加，而是有针对性的进行了调减啊，重要的我多讲啊，这个权值就比大不重要的就少加甚至不加啊，不起作用都可能，那么前面很显然就是一个全职。

对应着每一个输入时间簿上的，隐藏层状态的一个权重啊，然后我们在输入时间簿上，进行一个所有隐藏层状态，这个领加得到当前输出时间不上，所对应的那个所谓的编码信息，CI好吧，这就是刚才我们的图。

你得映射成代码，还映射成公式，有了公式，其实我觉着你看公式，它画出图来不就那样吗，我有些同志，有些同学啊，这也是一个要求啊，我说这也是一个技能，什么技能啊，就是你看别人画出一个网络架构图。

你是不是能够把图示当中那些隐藏了的，甚至是有意模糊了的数学公式细节写出来，这是一个能力，另外一个能力是什么，你看到一个公式的时候，你能不能把它通过一个图示化的，形象化的方式把它展示出来，这也是一个能力。

我觉得这个两个能力啊和这两个工具的使用，对今后的学习一定是有很大帮助的，因为后面的给大家说一下，后面其实挺沮丧是吧，也不能说沮丧，事情发生都是这样，从简单到复杂对吧，从一般到特殊。

那这个时候你怎么去处理这么复杂的问题，我觉得借助图也好，借助公式也好，对大家的学习都是有帮助的，那好了，那么下面的核心问题就变成了哎，你这个全值是怎么计算得到的，对吧，你这个全值怎么计算得到。

无非就是计算一个全职嘛，全职你用soft max不很好嘛对吧，我就计算一下当前EIG的一个指数，然后除以一个在整个输入时间簿上的一个，指数占比就可以了，那核心就在于这个EIG怎么算。

后面我们可以看到这个EIG做评分，那EIG怎么这个评分怎么算呢，但是通过这么一个复杂计算得到的，后面我们会介绍啊，这个评分的计算方式有很多种，其中这是其中的一种啊，还有很多啊，但我们看下这个评分的计算。

还是使用到了上一个时间步上的啊，上一个decoder是时间簿上的输出状态，隐隐藏层状态以及DJ步当前DJ步的啊，当前DJ步输encoder过程当中的deject，时间步上的一个隐藏层状态进行了个学习。

其中的W和U网都是可学习的参数啊，都是可以自动学习到的，那么这样再往下，其实还是和我们前面讲到的一样，我们通过soft max进行一个多分类就可以了，好吧，那么我们看一下代码上哈。

代码上代码上重点就体现在刚才所说的啊，就是那个评分以及权重的计算啊，评分以及全值的计算啊，先计算评分，计算全职，然后呢在最后的代码当中啊，在最后的代码当中，我们看一下在哪，在这啊。

encoder其实就看了，其实就是整个的一个循环过程，那decoder过程当中在向外输出以后哈，在向外每一个状态向外输出以后，我们知道啊，我们知道在进行预测输出的时候都是都是什么。

都是我们不仅仅是和我们上一个，隐藏层状态相关，还和什么相关，还和我们当前这一个时间簿上的所对应的，那一系列的encoder啊，所有时间布上的那个隐藏层状态的，那个那个全职和相关。

所以这个时候你会发现我们还需要每一步啊，每一步提取出它的一个全值啊，每一步提取出全值，进入全职以后，把我们当前的全职和我们当前时刻的输出，作为一个上下文啊，在下一次进行下一个时刻进行预测的时候。

那起到一个输入信息的一个作用，就是说我下一个时刻进行预测输出的时候，不光是和我上一个时刻的隐藏层状态相关，而且更重要的是，我还加入了所谓的所有的啊，当前时刻，所有的在encoder过程当中的。

所有时间簿上的隐藏层信息啊，这是在代码上还是这么来处理的啊，这个地方多说一点啊，这个地方多说一点啊，多说一点什么呢，就是刚才所说的三个工具啊，就是除数学代码和数学公式和代码，这三者之间。

往往是就是核心原理上是统一一致的，但是在具体实现细节上，有的时候可能是千差万别的，在这在某些论文当中啊，甚至某些google的论文当中体现的非常要命，什么意思呢，就是图哎画的很好，没问题。

数学公式呢好像说的就不是那么回事了，有些细节地方好像和图就对应不起来嗯，但是呢还问题不差不太差不太大，更要命的是，有的时候他放出了源代码，你一读它的源代码，就会发现这八竿子打不着这两回事啊。

那图是一个事儿，数学公式是一个事儿，那代码又是另外一回事啊，你你你经常会碰到这种问题，但是呢这个时候你静下心来慢慢的去分析挖掘，你会发现它代码上所进行的修改也好，调整也好，甚至是呃变化也好。

其实是隐含了大量的原因的啊，只不过这些原因呢在有限的论文章节当中，显示的不是那么的突出啊，所以这个时候怎么办呢，比如有些开源论文和开源实现啊，多和作者进行沟通和交流啊，多提一些问题啊。

其实你需要达到的最终目的还是刚才所说的图，数学公式代码统一起来，那不统一怎么办，那想办法把它们统一起来，肯定是有原因的啊，这个你碰的多了，可能就就就就就解决的就比较直接了啊。

但是这种现象希望能给大家提个醒，好吧好了，那刚才所说的呢是在sequence to sequence当中，我们是提取出的attention这种这种结构。

那我们下一步呢就是关于这个attention架构本身，我们能不能进行一个呃更高层次的一个抽象，对吧，到底啊tension到底是个什么东西是吧，那是个什么东西呢，有很多种解释哈。

不同的视角可能得到的就是不太一样，但是我们我们往下看啊，就是注意力其实有很多种啊，比如说最简单的或者说最常用的，或者刚才我们看到的一种叫soft extension，就是所谓的柔性主义的机制。

它是怎么说的啊，他是这样来说的，就是有关系啊，就是第三部分和第二部分是有关系的啊，但是关系呢是一个抽象的关系啊，你需要对应回去啊，现在我们做一个抽象，现在我们假设我们有一个输入信息X1，一直到XN。

这是我们的输入信息，然后呢所谓的注意力机制呢是这么来计算的，首先在输入信息上计算注意力的分布，然后呢，根据注意力分布，计算输入信息的一个加权求和啊，这个地方加权求和可能更好一更好理解。

加权平均呢其实也没问题，只不过数学上表示的可能，更多的是加权求和的一种形式，那其实就是这两步啊，其实就是这两步，第一步计算注意力分布，第二步进行加权求和啊，就像其实你刚才看到啊，结合图我们可以看到。

第一步计算他的注意力分布啊，计算每一个所对应的注意力分布，当前时刻的注意力分布，然后把注意力分布进行一个加权求和啊，就作为我们当前的一个特征提取嘛，刚才我们所说过啊。

tension的核心其实就是个特征提取对吧，为后续的工作进行一个啊特征的准备，那特征原始信息在哪儿，原始信息不就是你的输入信息吗，所以这个地方你就对应起来了。

在sequence to sequence的tension当中，H一一直到HT，就是刚才我们把它抽象出来，就是作为我们的输入信息原始信息对吧，就是刚后面刚才我们所讲到的就是X11，直到XN嗯，没问题吧。

就是我们要在输入信息上进行特征提取，那特征提取怎么特怎么提取，做两步计算，第一步计算注意力分布啊，就是计算一下你每一个输入信息，到底啊占比是多大，靠不靠谱啊，有些信息可能就被忽略掉了。

有些信息可能很重要，这个占比就可能很大，先计算注意力分布，有了第一步，有注意力分布了，第二步其实就是一个加权求和，按照注意力分布的全职把进行一个累加计算，那你就不就把输入信息的特征提取出来了吗。

这就是attention嘛，所以呢我们看一下啊，我们看一下下面这个具体的一般化的描述，就像刚才我们所说的啊，输入信息就是H一一直到HT啊，我就想从这些信息上进行特征的提取，怎么做呢，两步计算。

第一步注意力分布，第二步加算求和加权平均，我们看一下，核心就在于你这个注意力分布怎么去计算是吧，注意力分布怎么去计算，看下面给定一个和任务相关的查询向量，Q，用注意力变量。

Z表示当前某一个信息被检索的那个位置啊，就是下标啊，就是下标，当Z等于I时，表示当前的第I个信息，第I个位置上的信息被选中啊，其中查询向量Q呢可以是动态生成的，也可以是可学习的参数，这个地方又引入了一。

另外一个所谓查询相关的问题，很多同学一开始学习的时候就就就又懵了啊，刚把这个X搞定了啊，就是H这个地方怎么蹦出一个Q啊，那好了，回过头去你想想在刚才的那个语境当中，这个Q是谁，它是和查询。

和我们当前这个特征提取任务相关的一个变量，Q嗯，我们先看往下看吧，好吧，有了这个Q以后呢，我们就可以首先第一步计算注意力分布了啊，在给定输入信息X和查询变量Q之下，选择第二个输入信息的概率。

阿尔法I对吧，再给你X和Q的条件之下，Z等于I吗，刚才我们所说Z就是你的下标，下标等于I就是第I个信息被选中的概率，我们用阿尔法I来表征，这是个条件概率啊对吧，已知XQ。

然后呢求一下Z等于I的概率是多少，不就条件概率嘛是吧，其实就是个概率，那概率我们用soft max嘛，这个做个哎做概率计算不就完了不就可以了吗，重点呢，其实你会发现我们需要给出当前每某一个。

每一个位置的一个所谓的评分啊，就就是S这个打分也好，评分也好，都是一样，有了这个评分以后，我们做一个soft max多分类其实就可以了啊，就可以计算出每一个类别当中的概率，那个那个比值就是概率嘛。

我们就可以这样认为，其中阿尔法I被称之为注意力分布，就像刚才我们所说的就是注意力分布，那么其中S我们称之为是打分函数，我们稍微一放，先解决刚才那个问题，Q到底是谁的问题，这个地方呢在抽象以后。

这个Q仅仅是说的是和当前任务相关的一个，查询向量，那回到刚才那个图示当中哈，回到刚才的图示当中来，你看看谁是Q对吧，这是X刚才我们所说的输入信息，你特征提取的对象，这是刚才我们所说的那个评分。

那注意力分布是吧，注意力分布，现在呢我们还需要在计算注意力分布过程当中，需要有一个评分函数，这个评分函数呢，一定是当前任务相关的一个所谓的量，那那你会发现当前任务相关的量是哪个量，S对吧。

这里的S就是刚才后面所说的那个查询向量Q，或者说后面那个长向量Q，就是在当前语境下的那个S，你会发现不就对应起来了吗，你看看看这这是XX都对应的注意力分布对吧，这其这就是那个谁，这就是那个阿尔法。

这个阿尔法其中需要有一个评分函数，评分函数看下面来看下面评分函数，平分函数是不是那个虽然函数挺复杂啊，但是不管反正是你给我自变量，我给你个输出对吧，那评分函数的自变量是谁。

首先是X就是那个in encoder的那个隐藏层状态，另外这个S不就是和当前任务相关的，一个查询向量，不就是那个Q吗，没问题吧，OK嗯在哪呢，到到这了，OK到这了是吧，就像刚才我们所说的啊。

就解决第一个问题，就是这个Q是和当前任务相关的一个查询向量，至于具体是哪个是Q，需要根据当前的问题进行逐一的进行分析啊，确确定这个Q是谁，我们再回过头来看一下，有了X有了Q啊，有了输入信息。

有了和当前任务相关的查询向量，我们就可以根据这个计算，得到我每一个输入信息的啊，那个所谓的概率值啊，概率值，当然核心就变成了这个评分函数，到底是多少的问题，评分函数选择非常有技巧性啊。

就是核心技能循环这些东西都是死的啊，都是写的都是可以写死的地方，唯一不太一样的地方，就是所谓的评分函数或者打分函数的地方，有很多种选择哈，比如说有加性模型，点乘模型，缩放模型和双线性模型。

其中每一种模型它都有都有不同的这个，这个侧重点，这个今天的时间有限啊，就不再简单，这个说明一下，比如说后面我们讲到嗯，比如说bird模型当中，其实使用到的就是就transformer里面啊。

使用到的可能就是缩放，点击模型，就是他需要做一个规划，你可以认为就是他的平，它的这个方差很大啊，就是我们可要把它就类似于所谓的规划一样，但是不太一样啊，就把它方差。

把它约束到一个相对小的一个范围当中去好了，有了所谓的这个注意力分布以后，再往下的加权求和或者加权平均，我觉得就没什么太大问题了是吧，因为有了全职，那我每一个全值乘以一个所对应的输入信息。

就是当前这个输入信息多少能够被提取出来，然后呢在所有的时间步上进行一个累加，就完了就完了啊，其实如果你把这个比值往前提，认为是N分之一，那不就是个加权平均嘛是吧，一样啊好了。

这是刚开始通过公式上的分析啊，那么图对吧，还是有了公式，看个图，看下图，这个图，我觉得现在来看是不是觉得就一目了然了，输入在哪，输入不就在这个地方吗，X，但是X首先需要和Q进行一个评分函数的计算。

打分函数的计算，有了打分函数，计算注意力分布啊，计算注意力分布，有了注意力分布以后哎，注意注意力分布，再和输入信息进行一个一对一的相乘，才是当前布上的一个特征提取的内容。

然后把所有的时间步上进行一个累加，是当前的特征提取内容啊，也就是说其实你会发现在当前的这个呃，soft tension当中啊，这个X起到了两个作用，第一个作用是，首先它需要和查询Q计算平分函数。

计算注意力分布，这是一这是一条线是吧，从底往上这一条线，另外一条线呢它本身还作为一个特征提取对象，我特征提取的就是X，他还需要和我们的注意力分布进行一个相乘，然后决定我当前X的哪些部分被提取出来。

然后进行一个累加啊，所以X在这个地方起到了两个作用，一方面需要计算注意力分布，另外一方面还需要进行一个呃，它本身的特征提取，那其实你会发现有了这个概念以后，那怎么办，不断的改进嘛是吧，是你这个任务太太。

你就是你的职责太太太太太太多是吧，那就把它分开啊，该计算注意力分布的，你就去计算注意力分布，该进行特征提取的，你就进行特征提取不就完了吗，说你这个X从一个变成两部分，从一部分变成两部分。

那就是下面的所谓的键值对注意力机制，那就这么来的嘛，键值对数，注意力机制的输入信息不再是一个X，而是一个KV啊，就是由键值对所组成的一个向量啊，KV对啊，那其中其实就是各司其职嘛，K干什么。

K作为键用来计算分布啊，计算注意力分布，你会发现这个地方是由K和我们的这个，查询向量Q来计算注意力分布，有了注意力分布以后，再和我们的V值进行一个注意力的一个计算啊，比如说其实你会发现。

在图上其实很体现的很明显，就是在进行注意力分布的时候，我只是用到了尖锐度当中的K值啊，那么在注意力分布计算完成以后，再进行特征提取的时候，我只是在值上进行特征提取啊，这两部分是不相关的啊。

不是不是不相关的，就这两部分是分开的啊，各司其职啊，你计算注意力的计算注意力，你进行特征提取的，进行特征提取好吧，这是这一部分，那这这个时候呢你会发现哎这仅仅是进行了，你会发现进行了个累加嘛。

就是发现进行了维度压缩是吧，那不得压到一个里面去了，本身是N个嘛对吧，N个向量出来，你压到一个里面去了，这个信息还是丢失了，那怎么办，多投注意力嘛，这个地方你你你你觉得一个不过瘾是吧。

一个一个一个一个MV的不过瘾，你这N个MV的对吧，你最后进行一个拼接嘛，这个现在不就是大力出奇迹嘛是吧，也是一个方向是吧，你觉着哎你为什么搞呀，本来是是是是N个是吧，N个向量出来你都不能累加到一块围度。

不巧了吗，那怎么办呢，多头嘛就整成M个，把它拼一块，那还是啊信息不更多了吗，更充分了吗，这是关于这个多头注意力机制啊，重要的啊，最重要的是，今天最后一部分就是关于这个自注意。

自注意力模型就是soft attention啊，它是非常重要的，因为在博尔特模型里面其实就是用这个东西，就是transformer的面，就是用这个东西它是怎么说呢，就是我们输入序列X还是那个输入。

然后呢通过线性变换得到三个向量，就是QKZ哎，这个时候啊就开始就开始乱了，很多同学读原始论文的时候，你看啊啪出来一个soft extension，啪就出来一个QKV3个向量就懵了，就没有欲望就读下去了。

那QKV是啥嗯，别管它是什么东西，通过公式上你会发现，它无非就是XXX上的特征提取全职嘛，你不不同的维度上全值不一样，你提取的值不就不一样了，就是你可以认为是个线性变换对吧，你就是个线性变化。

那这个WQWKWV怎么来的，学习来着，我也不知道怎么来的，一开始初始化随着梯度的计算进行，越来越收敛不就完了吗，这个从这个角度上你会发现，QKV就是三个从X上进行不同的线性变换。

得到的三个矩阵就可以了对吧，有了QQV以后干什么哎该干啥，赶紧看Q5K类取名字取的都很有意思啊，K是谁，K在前面我们讲到过K啊，K在哪来着，来K嘛，V嘛，Q马能明白什么意思了吗。

这一下子就解决了我们刚才三个关键量的问题，其实刚才其实应该有同学就提出来了，你KB怎么来，Q怎么来，就一直没解决，现在一下子通过soft的城市全解决了，都是通过不同的线性变换，从一个输入信息上得到。

从一个X你就像刚才所说的啊，你现在就可以画，除了脑子里面自己脑补是吧，X是我的输入怎么就来了，K怎么就来了，V怎么就来了，Q其实只不过就是三个全职相乘，进行线性变化就得到了，对吧好了有了QKV怎么办。

那QQV就QKV吧，按照刚才我们所说的，第一步干什么，第一步计算概率分布，第二步进行累加求和不就完了吗，只不过呢刚才我们可以看到啊，这个地方是用的，就刚才我们说的用的缩放点击。

我们把这个方差按到一个小空间当中去是吧，其实就是一个k soft的，身上是KV2tension的特例，PYI特性是你可以认为是SOFTENSION的一个特例，对吧，其实就是不断的一个特殊化的一个过程。

其实没什么东西，最后啊最后我想说的就是在这个东西啊，我们看一下整个式子，我们做个替换啊，做个替换，首先我们看一下输出，输出呢就像刚才我们所说的，是做了一个soft max对吧。

每一个维度上进行了一个概率值的计算，这个SOFTMAX呢，是通过我们刚才所说的那个评分函数，进行了一个概率值的计算，然后呢成了一个V矩阵，就是那个在位上嘛，就是那个value是吧，进行一个特征提取。

按照前面这个比值进行特征提取，但是不要忘了啊，我们V是通过一个WV的一个线性变换，得到的啊，在X上进行一个线性变换得到的，那么展开以后呢，是得到这个式子，这个式子给我们一个什么启示啊。

这个式子你看我们从X你看这不过就是映射吗，我们输入X以后，先通过一个线性映射乘以W，然后再乘以前面这一坨，我们知道前面这一坨是个so是个是个soft max对吧，是个概率值，那什么意思呢。

你可以发现先进行一个线性变换，再乘以一个概率值，我们先不管前面啊，其如果假设如果假设前面这一部分不存在，我们不就是通过一个X进行一个线性映射，得到H吗，进行得到输出吗，如果没有前面这一部分。

这就是个什么东西，那么大家想一下，我我我我假设各位同学们可能对，比如说像全链接的神经网络都比较熟悉了，我们的全连接神经网络不就是这么个东西吗，输入乘以全值得到输出，你就会认为飞行应该就是一全是映射。

各去了不就可以了，那换句话说看下面这个图啊，看下面这个图输入是X一一直到XN，输出是H一一直到H5HN啊，HM也可以啊，这个维度不不不需要对应起来是吧，如果没有前面这一坨，我们是不是。

就是看到了一个从X向H的一个全链接输出，其实你会发现就是每一个都有都有连接嘛，就这个全职都都都有值嘛，而且每一个值是可学习的，但是前面加上这个全值，加上这个概率值以后，你会发现是什么意思。

我不光是进行了全链接的学习，而且学习到的那个全职，他还对应了一个概率，也就是说其实你会发现为什么是虚线，这个地方能大家能体会到吗，实线就是有有连接，一个一个的有连接，并且每一个连接上都是带全职的。

现在呢也是有连接，上面也是带全值，只不过这些全职呢还需要再乘一个概率，那这个概率是从0~1嘛对吧，那就说当前这个连接的强度，不光是通过全职来确定，而且还更进一步的得到了一个什么那个概率。

比如说在全连接网络的基础上，我们不光是用全职来描述它们的连接关系，而且更进一步的用概率进行了一个加强，这就是attention啊，这就是特征提取，而且呢这个原理上的告诉我们，这个计算是可以完全并行化的。

这就为我们改进啊，特征提取的这种性能带来了很大的帮助，因为我们现在GPU越来越便宜是吧，这个我们原来这个RN不太合适，就在于它的这种序列上的时间，特征提取的能力，受限于所谓的这个时间维度对吧。

他的这种嗯模型的这种时间维度上，比如说嗯梯度爆炸的问题啊，或者梯度缩缩小的问题，那这个时候我们不太合适用啊，变形化很困难对吧，因为他的这个循循环神经网络嘛，它一直在依赖于上一个时刻。

那现在attention没有这种问题啊，啊TENTION没有这种问题，他是个并行能力很强，而且啊他这种特征提取能力也加强了，所以说啊后面你会发现大量的一些工作。

不管是图像方向还是不管是CV方向还是LP方向，甚至其他方向，越来越多的特征提取，使用到了腾讯机制来进行特征提取功能，好吧O啊，总结一下啊，稍微总结一下，总结两句，就是今天我们讲到了。

就给大家聊了一句所谓的attention，只不过这个tension呢，我们是从序列到序列任务当中引出来的啊，就是刚才我们首先介绍了encoder decoder架构。

发现了它的这种定长特征表示的这种局限性，在此基础上，我们很朴素的讲，你不是经常表示不充分吗，那我们就把它展开展成一个不定场，展成一个所有时间维度上都相关的，一个通用表示，而且在时输入维度上。

每一个输入维度上都重新计算一下，那就是所谓的最朴素的一个在sequence to sequence，问题上的一个soft attention的一个应用对吧，然后我们把这个应用。

从一个应用场景当中抽象出来，就是所谓的呃SATENTION，抽象出来之后，所谓的就两步，第一步概率计算呃，我们的分步计算，第二步加权平均啊，加加权求和啊，输入型，这个时候一定要对应好了，谁是输入对吧。

谁是所谓的和查询和当前任务相关的Q对吧，然后呢在此基础上，我们又讲到了所谓的KV减值对的问题对吧，呃因为你这个X在soft的分数当中，既计算概率分布，又计算特征提取啊，一人两角不太合适。

那就拆成KV嘛是吧，然后呢自注意力机制呢更更直接啊，你必无非在进行到真实当中，你需要有Q需要有K需要有V那QQK怎么来，反正是有X那通过X不同的线性关线性映射，我就得到相应的Q相应的K相应的位。

然后通过刚才一系列的注意力机制计算，得到起到特征提取的一个目的，最终通过公式的这种分析，我们会发现，所谓的沉水机制，其实就是在全链接的特征提取的基础上啊，更进一步的进行了一个概率值的一个计算，仅此而已。

并没有其他的，而且只不过呢，这种方式起到了特征提取的能力啊功能，而且它的变形能力还非常的优秀啊，算的快啊，又算得好啊，所以今后在大量的工作当中，也建议同学们可以使用一下腾讯机制，作为特征提取的一种模块。

好了，今天呢我们时间正好是一个小时，后面我们还没还有嗯，其他部分的直播，我的内容就在这啊，当然上述的内容也讲的很快啊，我们没有那么多时间好了，就这样。

谢谢同学们。

【七月在线】NLP高端就业训练营10期 - P6：2.Seq2Seq任务—机器翻译与本文摘要_ev - IT自学网100 - BV1uxT5eEEr6

首先给大家看两张图，就是机器翻译确实很重要啊，为什么重要呢，因为人们确实使用机器翻译，比如说你看到这个餐厅，它也翻译成translate server error，这个明显是啊。

不知道发到什么什么那个啊，比如说用了个什么翻译系统，然后结果人家给你给你出个translate server error，下面啊下面也是另一个translate server error。

我都不知道这个他是故意写错，拿来娱乐大众的，还是真的就这个写错的啊。

比如这个时尚烫染造型会所，他给你出一个出个什么，could这个叫发源地潮流前线，他说could not connect to translator service啊。

这些图都比较搞笑啊，再比如这个香烤鱿鱼，全barbecue wikipedia，我都不知道这个翻译究竟是怎么出来的，那这些呢是我们可以看到的，像前面那些很明显都是一些机器翻译的错误啊。

那就说明人们确实是用这个机器翻译的，那我们首先知道，现在大部分的机器翻译模型都是由数据驱动的，事实上不仅是机器翻译模型，整个AI领域大家都已经默认就是aching learning了。

实际上我们知道AI是一个很大的领域，他还有有一些人是做一些别的AI方面的领域的，有的人认为这些AI的系统可能应该是人造的，或者是有一些人为定义的弱可以衍生出来的，可以去证明一些东西，其实我之前也不了解。

我就是在嗯参加一些会议的过程中，听别人听别人讲，有的人他们确实是不做machine learning的，他们是做那些什么AI theory，然后说他们那个可能才是正确的AI path，实际上我们不知道。

但是很早以前就一直有这样的一套争议啊，哦我不知道大家有没有听说过一个笑话，就是说好像是说每次IBM他们如果fire a linguist嗯，Their machine。

Their uh machine translation system，什么improves by什么one percent什么啊，这里打错了很多东西。

machine translation就有一个大致这样的笑话，就是说啊曾经可能说在30年前，人们做翻译系统的时候，并不是像我们今天这样子，应该说有两派人，一派人呢，他们是认为你这个机器翻译系统。

应该是基于一些rule，基于一些grammar，基于很多很多的啊各种各种规则定义出来的，你必须要有一个dictionary，能够知道单词与单词之间的那种，一一对应的翻译，那后来另外一派呢是。

他们认为我们应该是基于数据来学习，这个机器翻译模型，那这两套理论从今天的角度来看，应该说我们都认为基于数据的，是更加好的一个系统，那曾经应该说在在我们没有那么大量的数据，没有这么大量的计算资源之前。

人们其实是不知道的，所以两派都有各自有自己的支持者，那既然今天我们都是由数据驱动的，现在这些机器翻译系统啊，主要是用什么数据来训练的呢，比如说可以用新闻对吧，很多新闻网站都是有中文跟英文版本。

或者说不同语言的版本，比如公司的网页可能会有中文，英文以及各种其他语言，比如说法律专利文件，这种一般都是中英双份的是吧，任何一个国家一般都会至少有一份英文的，再比如还有各种电影电视字幕嗯。

还有更多的比如说那些嗯，其实有一个很大的数据，就是联合国那些document对吧，联合国documents，就有很多这样的数据，是可以用来做机器翻译模型的，嗯对于机器翻译呢。

我们一般都希望使用双语的有对应关系的数据，然后大部分的数据呢是由文档级别的匹配，我们一般很难拿到句子级别的匹配啊，当然有一些unsupervised的算法，也可以帮你生成出来一些非呃，从文档级别的对应。

能够能够找出句子级别的对应方法啊，这种算法其实我了解的也不多，但是大部分其实是有一些UNSUPERVISE的方法，可以大致通过统计学的方法得出哪一句话，大概率跟哪一句是对应的，哪一句。

那大概率大概率又跟另外一句话是对应的，很多的公司现在他们做翻译呢，都是手头有非常大量的翻译数据的，呃，具体有多大量的数据呢，我也不知道啊，就是我我通过一些跟人交流的这个经验得出。

大部分这些大公司的做文本翻译的那些组，里面的人啊，都跟我说，他们公司内部有非常大量的翻译数据，然后我说有多少，然后他们说这是个商业机密，不能告诉你，但是总之是非常非常大，可能比你想象的都要大啊。

所以现在的数据呢，现在大部分这些做文本翻译的公司，他们都有很大量的这些数据，这些数据呢，嗯有一些可能是可能是通过各种渠道得过来的，有一些可能有人为的标注，有一些可能又没有人为的标注。

但总之就是现在人们的一种共识，就是你的数据量是越大越好，那在讲这些模型之前呢，我们先跟大家探讨一个问题，就是你怎样去评估一个翻译模型，如果我现在已经有了一个，我说我给你一个翻译模型，你只要给我一句英文。

我就可以给你翻译一句中文，那我怎么样去评估这个翻译模型好不好呢，嗯最直观最好的方法自然是人工评估，如果我每造一个模型都可以让人去评估一下，这样是是最方便的，他因为人的判断总是比较准确。

但是呢这样非常的费时费力，比方说我现在一家公司里面，我可能每天就要新出一个翻译模型，因为现在啊计算资源比较多了，人们可能训练这些模型都比较快，那我如果每天出一个模型。

我是不是每天都专门有一个组要来评估一下，我这个模型好不好呢，啊这样就比较的费时费力吧，所以一直以来人们就希望去找到一些比较好的，自动评估这个模型好坏的方法啊，注意这个问题呢，其实是一个开放的研究问题。

就他是一个非常有价值的研究问题，就这个问题并不是说已经被人们解决了，我们其实现在也不知道到底怎么样去评估，你生成的语言到底好不好，不仅仅是翻译任何别的生成的问题，比如说这个文本摘要啊。

或者说是聊天机器人啊，其实我们都不知道怎么样去评估它，就现在我们有手上，有的评估手段都是非常有限的，那在翻译里面呢，我们最常用的评估手段叫做blue，什么叫做blue呢。

他叫BLINGU160以上的study，而是一篇paper，来自于2002年的这个人啊。

那这篇论文我们可以我们也不用看了，但blue呢它它本主要是一个什么什么问题呢。

啊blue它主要是做什么的，它其实是，其实是这样的，就是我我还是拿这个，拿这篇文章里面的例子来看好了，就是你看到我们是这样假设的，就是你比如说我现在给你一句英文啊，给你一句中文，然后你把它翻译成了英文。

那你英文呢你这个系统输出了一句话，那我现在想要知道这个系统输出的那句话，好不好，我就需要拿它去跟正确的翻译做对比，那比如说下面这是两个正确的翻译吧，啊这里有两个candidates对吧。

It is a guide to action，Which ensures that the military always abbeys，The commands of the party。

It is to ensure the troops forever，Hearing the activity，Guidebook that partly direct。

你发现这两句话其实是一个意思对吧，就反正说这个军队必须要服从党的命令，那啊，但是会有不同的表示方法，所以这个就告诉我们，你的翻译呢实际上并不一定说是唯一的，你可以用各种各样不同的话来翻译同一个句子。

他们可能都是非常make sense的啊，Sorry，我这里是讲了两个candidate，那下面呢是reference，这三个reference呢就是说呃我告诉你。

这三个reference是比较完美的翻译，它可能是由人写出来的，那上面两个呢可能是由机器翻译出来的，下面呢是由人写出来的，那现在我们要做什么事情呢，就是呃这个blue score，他的工作呢。

就是他要去对比我这里的单词有哪一些出现了，出现在了reference当中，然后我是跟三个reference都去做对比，比如说我们看到it is a guide to action。

Which ensures that the military always abbeys，The commands of the party，那我们就希望它里面的，我们要数一数。

它有哪些单词出现在了我的reference当中，那非常自然的，如果出现的单词越多呢，一般来说就表示我这个翻译越准确对吧，就至少我把该提的都给提到了啊，然后如果出现了一些单词。

它没有在reference当中，那可能我那个翻译是有问题的，所以blue它是做什么呢，就是他就是要把这一些所有出现在reference当中的，单词的数量给数出来。

然后再除以它candidate当中的总单词数，然后我们看到这里有一个例子啊，这边他告诉我们说in example one啊，我们看一看他说了啥啊，这里有一个说in example one。

就是example one，就是我们刚刚看到的这个example one对吧，这里的example one当中呢，你就看到说啊。

Candidates one achieves a modified unigram，position of17over十十八什么，那就是说这18个单词当中，有17个都出现在了reference当中啊。

这个是我们评价翻译的一个主要的指标，就是这个precision有多高，事实上呢我们不仅仅关心one gram，像我刚刚说的都是单词对吧，就是如果你是只看一个单词，这个我们叫做new unigram。

那实际上我们还要考虑别的啊，比如说BIGRAM跟TRIGRAM，也就是两个单词和三个单词的词组，我们要看这些词组，它出现的precision究竟有多高。

大家可能还记得precision record跟f one对吧，就precision是表示的是嗯在我翻译的单词当中，有哪些单词是正确的，就这个是precision。

所以blue score呢它主要看的其实是，啊当然他还有一些别的别的细节，就这个分数其实并没有那么简单，它实际上还要综合考虑到啊，若干个他既要考虑precision，然后呢。

他还是一般来说我们真正在使用的过程当中，这个precision呢有这个unit gram的precision，然后有这个diagram precision，有trigram precision。

有fogram precision，一般来说呢我们是把这四种，当你看到说是blue for的时候呢，同学们会看到有很多blue for这样的分数，其实上面那个四种分数的平均就是。

The average of the uh four，Kinds of of grams，就是把这些gram给平均起来，那这里还有一个小问题在于说，就是你可以看到这个example to。

你看example to里面，他这个什么得得得得得重复了这么多遍，那你会发现这个precision其实是100%，因为它每一个the都出现在了reference1当中，那这样是不是正确的呢。

这样其实是不对的，就是你不能把一个单词直接重复那么多遍，所以在这里呢他的precision实际上只有啊2over7，因为在你的reference1当中，最多只出现了两个the。

所以他这边多余的the就不会被考虑进去，让我们看看还有没有什么重点的地方啊，基本上呢就是这么个思路，就是这个这个AGRAM呢，基本上他就是这么一套一套思路，然后在实际上实现的过程当中。

我们看到他还有如果你有嗯若干个candidate，什么，他会他会有这种加权起来啊之类的，会有一些细节的变化，但总的来说呢，blue它就是一个基于precision的这样的，一套评价系统。

那这套系统到底好不好呢，嗯我认为应该说是你你一眼望过去，其实感觉是不太好的，因为好像他其实并没有说完整的，能够评估所有可能的情况，但实际上同在人们的这个这么多年的实验下来。

应该说这是2002年的一篇论文，到现在已经是快要20年了，然后我记得blue好像是某一年的某一个conference，上面的，就是那种相当于是杰出贡献paper，因为他们大概每每隔10年会评估一下。

有哪一篇论文，对于我们的过去的研究产生了重大的影响，然后这篇论文其实当年是得过一个奖的，所以说啊它看起来非常的简单，好像你觉得这个分数没有什么了不起的，但是他确实对于这个评估啊。

计算机生成语言的这个评估方面，产生了比较重要的影响，人们发现它跟人类的认知和人类的评估的，相关度还是相当之高的，因为我们我们思考一下，你如果要设计一套好的指标，你最关键的是希望你的这一套指标。

要跟人类评测的相关度足够的高啊，就是这样它才可以代替人类的嗯，人类的功能啊，所以这个就是blue这个跟大家说一下啊，我们一般常用的是blue for，或者有些用blue three也是有的。

就同学们其实可以大致思考一下啊，我我如果只是用uni gram去评价这个precision，你会发现这个分数可能是很不完备的，但是一旦你用上了unit gram，Bigram。

Three gram for gram，如果两句话，在这么多严苛的考验底下，他依然可以达到一个比较高的blue score的话，实际上说明这句话跟那一句话，应该大概率是长得非常像的。

嗯就是有这么一个问题好，那我们评估就讲到这里，然后我们来讲一下你要怎么样去建造一个模型。

来做翻译这一项工作，我们来看一下这个这一位嗯。

比较有名的人讲的一句话，他说one naturally wonders，If the problem of translation，could conceivably by treated啊。

Be treated as a problem in cryptography，就他说啊，翻译这个问题，是不是可以当做是一个密码学问题呢。

When i look at an article in arabbit，I say，This is really written in english。

But it has been coded in some strange symbols，I will now proceed to decode，他就说啊，我们当你看到一篇英文文章的时候。

你可能会想这个是不是呃，当你看到一篇阿拉伯语的这个文档的时候，你可能会想这个语言呢它其实是用英文写的，只不过是有一套很奇特的编码方式，把这个英文字母编译成了一堆乱码，我我现在呢就要想办法。

把这个密码给破译出来啊，这个呢应该说是我们统计翻译模型的一个，基本思路，就是编码解码，所以这一套所谓的同学们经常看到这个encoder，decoder模型，这种这种名字的命名方法。

其实就是来自于这个朴素的思想，就是我们认为这是一个密码学问题，当你看到另一种奇特的字符的时候，你能不能把它recover回来，变成正常的字符啊，这里有一张图。

这张图呢嗯就是我们整个现在的statistical，machine translation的一个基本架构，我们在做翻译的时候，我们一般是用这样一个叫做noisy channel model啊。

为什么要叫noisy channel，其实我不是完全确定啊，同学们可以思考一下，为什么它要叫noisy channel model，那我们基本上是这样的啊，我们是，认为有一个source，有一套语言。

然后他经过嗯，他经过怎么样呢，我还是直接看下面这个公式吧，就是假设我现在给你一堆语言，它是来自于啊X对吧，就是我我们一般是认为他的语言，比如说这个Y呢是我们最终要翻译成的语言。

我们假设就是英文和中文好了，我们就假设X是英文，然后Y呢是中文，那我我们可以可以认为说，本来呢这个语言它应该是中文的，但是呢这个中文经过了一套noisy channel嗯，应该是这么个意思。

就是你这个因你这个中文呢Y本来是中文，这个中文经过了这个一套noisy channel之后呢，他就被被这个密码给编码起来了，他就编码成了一堆X，这个X呢它是一个observe system input。

就这个东西我们其实不认识啊，但它其实是英文，那我们希望就建造一个decoder，让这个decoder呢能够把这个啊，这一套X能够给给解码回来，那这个解码的过程我们要怎么样做呢。

我们就是要寻找最有可能对应X的那一个Y，所以这是一个conditional probability，我们希望能够找到P嗯，y given x就这个是我们要构建的一个模型。

X呢是你看到的那一堆noisy input，X呢其实是noisy input，然后我们希望能够输出一个Y啊，怎么样去输出这个Y呢，你看到这里用了一套贝叶斯公式对吧，这个p y given x呢。

这个这个贝叶斯公式大家应该是能够看懂的，P，given x等于P我们可以一起复习一下，PXY除以PX对吧，这个是conditional probability，然后我们知道PXY呢又是等于PX。

given y乘以PY，然后再除以P的X，那回到这里，我们知道X其实已经不重要了，PX是不重要的对吧，这一项是没有用的，因为我们最终是是需要找到arg max的哦，of那个p y given x。

所以他也就等于arg max的这个部分对吧，arg max the y given这个，那我们观察一下这个公式，你就会发现这一串公式啊，它其实跟PX没有任何的关系，因为我需要arg max y。

所以你可以把这个PX给扔掉，所以我们需要的是什么呢，我们我们需要的这个公式就是PX平方，Y乘以PY，那这两个部分这两个函数包含两个什么部分呢，从这个理论的角度来看，它其实包含一个是你要找到这个X。

这个X能够跟Y尽量的接近，另外呢你要你希望这个Y能够尽可能的通顺啊，这个是我们的一套基本的思想，希望这个PY尽可能的通顺，然后呢，p p x given y要尽可能的可能性要足够高。

这个是啊很多模型的基本设计思想，那我们现在的比较好的模型呢，一般来说都是基于一套叫做encoder decoder模型，所谓的encoder decoder模型呢，嗯实际上可能并不完全。

符合我们刚刚谈的这样的一个framework，但是我们可以来啊，过来看一看，这个encoder decoder模型是怎么样做的，这里的啊，encoder decoder模型。

最早呢是由这一篇文章提出来的，是这个qing control，我们这节课，我们这门课的有一本教材，是来自于这一这一位作者，我不知道大家有没有去看过这一本书，就是这位作者第一作者KONROO。

他是纽约大学的一个教授，然后他有一本我认为非常好的教材啊，大家可以花时间去看一下，那这一篇文章呢就提出了一个基本的这个，基于神经网络的，基于循环神经网络的一个机器翻译模型的架构。

它是假设你有一个encoder，一个decoder，这个encoder和decoder呢都是两个循环神经啊，是两个不同的循环神经网络，encoder的作用呢是，它会把你输入的语句给编码起来，给编码起来。

就假设说我现在给你一句话啊，我给你一句中，给你一句中文X吧，然后你需要把它翻译成英文Y，你怎么样去做这个翻译呢，我是先用这个RNN模型把这个X给输进去，然后呢他会给我一个C，这个C呢是一个vector。

我认为这个vector呢就表示了整一个句子的信息，然后下面我要做的是conditioned on c，就是你把C输进去之后，我现在要把Y给生成出来，就这是这个模型的基本思路，我们可以来对比一下。

他跟刚刚的这一套模型是不是一致的呢，它是p y given x跟PY，实际上跟我们的这个是不太一样的，就是这是一种，其实这是一种generative mode的方法。

我们这里的方法呢是一个直接做decoding的方法，这是一个偏DISCRIMINATIVE的一套一套模型，训练方式，但是这个啊先其实不是特别的重要，我们先来思考一下，为什么这个模型可以可以work。

呃为什么这为什么会设计这样一个模型呢，其实他的思路非常的直观，就是你你如果有一段中文进来，我希望先把这个中文给编码了，那我的目标呢是希望C能够完全包含，整个句子的，信息对吧，然后呢。

其实你的整个模型的bottle neck，就在于，就看你这个C能不能够包含整个句子的信息，其实这个你不知道有可能有可能可以包含，有可能不可以包含，那我们具体来看一下这个模型，它是怎么样做的呢。

嗯X1到XT进来，最后一个hidden state变成了C，这个没有什么问题啊，就是一个recurrent neural network，那出去之后呢，你看到他的C实际上是他的C是作为输入。

输入进入每一个decoder的hidden state，就是这个decoder里面呢，它C作为啊C作为输入进入每一个decoder，Decoding step。

就它并不是仅仅作为第一个hidden state传进去，它是作为每一个decoding step啊，为什么要这样做呢，实际上是肯定是因为如果你不传进去的话，它的这个C的信息很快会被你的模型忘掉。

因为你的因为我们知道recurrent neural network，其实挺容易忘记之前的事情，所以他可能发现必须要把这个C传进去，然后你看到啊，这边呢你看到他其实在输出，就是生成每一个单词的时候。

他也是把C给传进去的，我们可以仔细的看一下这些箭头，这个箭头其实挺关键的，它们它的这个C不仅进入的进入了每一个UI，And the decoding step，它也进入了生成单词的那一个step。

就是这样的一个过程，那这个模型呢它的训练它的模型是两个RM对吧，模型的参数就是两个recurrenneural network，训练方式是什么，就是损失函数是什么。

实际上他的训练方损失函数肯定是cross entropy，loss对吧，他的训练方式就像一个language model，应该说它其实就是我们作业一当中的，同学们可以思考一下。

它其实很像我们作业一当中的那一个build on，broader context的那个东西，作业一中的context模型对吧，他很像我们做一档context的模型啊，同学们应该刚刚前两天看看过。

我们的那个视频当中啊，我们有一个拍拓时的课，是怎么样写一个这个机器翻译模型啊，这个翻译那那个课应该还是比较重要的啊，同学们尤其特别注意一下，我们的那一些直播课啊，不是就是那个录播课啊。

就是那些实训的课里面，最重要的是看我讲的那些内容，就是如果你发现那个课是我讲的，一般来说都是比较重要的，呃那些代码呢同学们都去学一下，就是你要做到我在课上写过的代码，你也要能够写出来。

我觉得基本上如果我写的那些项目啊，就是隋唐的那些项目，你如果能够全部完整的写下来的话，嗯你去去做这个编程的工作，应该问题不是太大了，就是那些项目已经基本上涵盖了啊。

各种各样的application的情况，当然现在各种啊framework的版本更新都比较频繁，所以里面如果有一些版本落后的同学们，就把它改成新版本的那种写法就可以了。

Cross entropy loss，然后训练方式那肯定是SGD对吧，或者是SGD的一些变种，有这样的一个模型，那这篇论文里面呢，这篇论文里面还有一个比较新的东西，是他这篇文章是提出GU的那一篇文章。

所以最早的那个轱辘。

是来自于这一篇文章里面的，可以给大家看一眼啊。

就是这里有一张图是讲的，这个就是grougated recurrent unit啊，这个大家可以考虑记一下，其实就是两个gate对吧，它是有一个re叫做reset gate。

有一个update gate，然后呢你的hidden state一定是上一个hidden state，再加上现在新产生的这个hidden state，然后新产生的这个hidden states呢。

它又是一个这样的，这样的做法是reset gate跟这个hidden呃，跟这个hidden state做了一些点乘啊，Element wise multiplication。

然后做了一些变换和一个activation，变成了一个新的candidate n state，这个是这一篇文章啊，我们还是可以看一眼，他这个文章里面最后有没有报一些什么数字啊。

他一般会报一些blue score之类的，然后你就会看到啊，这个这个我不太确定它是哪一个数据集，一般来说你会发现这些文章，他们都是有一些比较标准的数据集，作为对比的啊。

你我们就大致看到这个blue score，是是这样的一些分数吧，但是我不确定这个是什么语言之间的blue score，大部分人都会报GERMAN或者是french。

有没有GERMAN的还是french啊，应该是french，然后他是w mt14的这个english french，French translation，这些分数我们大致有个概念。

一会我们看到别的文章的时候，就可以跟他对比一下，那后面呢很重要的一个概念是attention机制，我们现在已经学过attention is all you need，所以这个基本上也就不用多讲了。

但是啊上一篇paper是2014年发的，在2015年的时候呢，就有了有了这样的一些paper，是他们引入了attention机制，为什么需要attention机制，这个非常简单，因为我们上一个模型呢。

他的最大的难点在于，这个C能不能够包含整个句子的信息，就这个是很困难的，因为我们相当于是认为说我把一句话，用一个单词给encode起来了，像我之前跟大家讲过skip thought这样的模型。

它其实有4096位，就是skip thought，是我们上一节之前的课当中讲的句子向量，你为了编码一个句子向量，大概需要4096个维度，所以说啊这个C能够包含整个句子的信息。

它本身就是一个值得怀疑的问题，就很难，你不一定能做到这个事情，那怎么有什么办法可以降低这个C的压力呢，人们就想到，我并不一定非要把这个责任留给一个C，我可以把每一个hidden state都作为输入。

传入到解码器当中去，所以你看到的这一张图就是这张图里面呢。

我们看到右边啊，这张图我简单跟大家解释一下，右边的下面部分是你的encoder，这个X呢是你的输入，比如说中文翻译成英文呢，这个X就是中文，或者说啊对对，如果是中文翻译英文，那X就是中文。

那我们先把这个X跑一个双向LSTM啊，这篇文章应该用的是LSTM，所以它是一个双向LSTM，然后呢我希望把每一个hidden state都留下，那如果这是个transformer的话。

那你就不需要LSTM了，反正就是transformer那些layer，直接套上来就可以了，那我现在就希望把每一个hidden states都留下，然后decoder的时候呢，我的每一步解码都是依据啊。

所有hidden state的一个加权平均，我们看到这里，他右边是有一个加权平均的操作的，这个跟transformer其实是一样的对吧，就你的transformer在做decoding的时候。

也是用到了encoder hidden state的所有的加权平均，这一套加权平均是怎么来的呢，是根据我上一步的decoding step，你看到左边的这三个公式，这张图。

左边的那三个公式表示的是你怎么样做decoding，做decoding的时候呢，我我的这个CI，这个C其实是源自于上一篇文章当中，那个context vector。

那这个context vector它不是固定不变的，而是会随着你解码的步骤进行，而发生动态的变换，它永远都是你所有encoder hidden state的加权平均，我们看到这里的加权平均。

它是阿尔法IJA乘以HJ，然后求一个求个和，那这个阿尔法AJ是哪里来的呢，他他告又告诉你，这个阿尔法IJ是经过一部soft max来的，总之就是有一套EIJ，那这个EIJ又是哪里来的呢。

他告诉你这个EIJ是呃，SI减一和HJ之间的一个分数，也就是说我为了知道当前我要关注哪一个部分，我就需要通过我上一步的那个decoder hidden state，对于每一个位置都要做一个计算。

呃事实上这种类似这样的模型在当年有很多啊，就是2015年的时候有很多这样的模型，那这种模型呢，它在本质上其实都是，希望让你的训练变得更简单，我们在做呃，因为有很多做NOP的人，他们都是造模型的。

有的人可能是在研究NOP里面，一些别的问题啊，但对于造模型来说，其实我们本质都是希望让你的模型更加符合，整个机器学习，他学习的一个比较自然的过程啊，你的这个模型造的越符合它的那个自然的状况。

可能就能够让它收敛的越快，嗯所以有很多人就尝试在这个模型里面，相当于加各种线，你如果可以嗯，就你其实可以造各种模型啊，比如说这里他只用到了SI减一，你可不可以用SI减二，可不可以用SI减三，用SI减四。

就是你可以想办法加更多的context，嗯有一些有一些步骤可能是有用的，有一些呢可能又是没有用的。

就这些都是需要做实验才可以知道，那这是一篇一篇文章。

当时呢同年代还有另外一篇文章。

那这篇文章是来自于，来自于这个斯坦福的一个组。

chris manning的那一个组，然后呢他们也是做了这样的一个attention based，seek to seek模型，那这篇文章他们有一些什么不同之处呢，我们看到他这里我们刚刚那个E呀。

刚刚这张图里面有一个函数叫做E。

大家还记得对吧，这个E呢，它代表的是它是计算SI减一，跟HG之间的相关性有多高。

那后面的这个LEON这一篇文章呢。

他们就尝试了不同的scoring function，这个scoring function它告诉你说我可以用dot product，他这里的啊，那个notation有点不太一样。

他这个hidden state有HT跟HS嗯，大家可以理解一下，它的HT表示的是你的解码器的那些hidden state，它的HS呢表示的是你的encoder里面的。

应该是encoder里面的hen state，所以它有两套不同的写法啊，他告诉你说你可以用dot product，你可以用这个by linear form，他这边把它叫做general对吧。

实际上就是一个hidden state乘以一个矩阵，然后再乘以另一个hidden state，这样呢出来也是一个数字，下面呢还有一个简单的神经网络啊，一个应该是两层的神经网络对吧。

可以能够帮你计算出一个，两个新的state之间的分数，他就告诉你说他们尝试了一些不同的方法，然后啊其他的操作呢还是一样的，那一个attention的，这个它本质上还是一个weighted sun对吧。

所以别的方面应该基本上是一样的，呃他告诉你是HT和CP啊，就是你有一个ct，有一个HT，然后拼到一起，然后再做一个输出，同学们看这张图的时候，其实这些图都很容易理解。

你只要看这张图里面他各种实线和虚线的连接，你大概就可以知道它，这个attention是怎么样算出来的，就是那些实线呢一般都表示是有一个输入的，虚线是什么意思呢，虚线是什么意思。

就要根据它具体的情况来判断。

啊这个就是这样的一篇另外一篇文章，那在这个之后呢，就有一篇比较重量级的文章。

是这个google neural machine translation，他们的这个这篇文章呢。

应该也是后来他们立快立刻就上线了的，一个模型，就现在你用google，你用google做翻译，或者包括国内的一些什么百度翻译啊，或者是别的翻译，可能用的都是跟google差不多的这样一套模型。

啊有同学提了个问题啊，他说上一个是HT减一，这一个是HT嗯，应该它指的都是根据上一个来预测。

下一个就是他的HT还是T减一，应该只是他们在写的时候，在图的表示上面不太一样，就是你你在HT知道HT之前。

你是不可能用HT来计算分数的，因为它它它应该本质还是用当前的计算，下一个就这个下标，同学们可以自己理解一下，就是你一定是用上一个来算下一个。

但那两篇文那两篇文章其实长得很像，他们是同时期的作品，那这个google neural machine translation呢，当时就是把这些市面上的模型做了一个，就是大一统。

把那些能够用上的方法全都用上，然后就搞了这样的一个搞了这样的一篇论文，诶，说到这里，我刚刚说到要跟大家一起分享一下，看看后面的文章，有没有在blue score上面有一个提升。

我们看到他有没有w mt14，一般来说他们都会用WMT14，这个数据集来算算blue score呃，我们看一下他报的blue score，像比如这种MOSES，这个MOSES是之前比较早的一个那种。

统计翻译系统，所以他应该是，但是你看他表现其实还是不错的，我们来看看他有没有报blue score，他应该有一张表格，报一下分数吧，啊他都没有没有报分数的吗，好奇怪啊，如果没有的话就算了。

嗯应该是这个这个应该没错，Blue score of the train model，Computed on test set，然后你看到它是啊，No unk，NO unk应该就是没有考虑UNK的部分。

那有时候其实你也不太知道到底该怎么比，但是从这个分数来看，应该是还可以的，我相信应该是用最后两个column来对比啊，你看这里有36，这边是这边是34码，应该说还是有一点提升。

然后我们后面再看更多的文章，应该就会有更多的感受，那这个google neural machine translation做了什么呢。

这google neural machine translation，它的其实用这张图来看就可以，就可以看出来它呢主要的特点是它叠了好多层，你看到他有这个，他告诉你他这边有八个layer，有八层对吧。

这张图左边有八层，然后他告诉你decoder也有八层，那这个模型实际上长得已经，很像那个transformer模型了，所以其实他们也是啊，把同样的架构在不同的模型上面去尝试。

那所以你看到他还有一些实线连接，这些都是residual connection对吧，有一些是跳跳跃性的，这个connection呢都是residual connection，那这个也是啊。

后面的transformer也是继承了这个模型，所以说它是八层的，你看到它的第一层是一个双向的LSTM，然后后面呢你看都是单向的LSTM，但是他这个单向的LSTM都是带了。

Residual connection，然后最后他经过这个attention之后，在输出层这边又是一个八层的decoder，LSTM啊，这个模型呢，其实就是那个之前的那些路网和那个巴达now。

那两个人的两篇paper的增强版，他们可能都只做了一层，那这个文章呢是做了八层，我们可以看一下他的数字有多少，嗯他这边有一些详细的解释啊，有这个一个是啊residual connection。

就是这个这里他们说加上residual connection，可以让你的模型训练更稳定，因为我们知道一般来说你这个模型生了之后，都会需要有这个residual connection。

才能保持它训练的比较稳定啊，这边是第一层的BIOS t m，其实在今天看来都没有什么特别的，估计同学们都已经习以为常了，那我们可以看一下啊，他这里还有一些重要的，他用的word peace model。

这个东西，也是后来在在transformer里面被沿用至今的啊，就是我们现在一般都用word peace model，这个还是比较新的，可能之前大家没有想到用word piece来取代这个问题。

因为有了word piece之后，你就没有这个UNK的问题了，我就不会出现有不认识的单词，然后我们看一下它的lose score，这个blue score为什么分数这么低呢。

我其实不确定为什么这些分数这么低啊，31。2，因为我们看到之前的几篇文章，实际上这些blue score你是不能直接对比的，因为你知道他这里的blue score是有什么UNK，有没有UNK，所以啊。

我也不确定你到底应该跟左边比还是右边比，就这些实验的setting如果不完全一样的话，你就很难完全直接的做对比，然后他这边还有各种调参数，就是不同的参数下的blue score，30一点几额。

应该说我确实不知道怎么样，Interpret，它就他的要取决于他的实验设定，是不是完全一样，就是你知道这里的他的啊单词也是不一样啊，这边的blue sc又变得更高了。

这里这里的blue score就有30几了啊，三十七三十八三十九了，但我们大致有个概念啊，就是同学们之后一般来说呢，就是它如果在一个表格里出现的行，肯定是可以比的。

就是你肯定是呃比较公正的这一些评判方式，所以这个是google new romachine translation，然后在这篇文章出来后不久呢，就是我们大家喜闻乐见的呃transformer模型啊。

在transformer模型之之前讲一下，这个这个也是个很有趣的实验，Zero of short translation，什么叫做zero shots translation，就同学们知道有一些单词。

而有一些语言，他们的翻译是比较常见的，比如说中文，英文，法语，德语，就这种联合国常任理事国语言，肯定都是你到处都可以找到文档啊，用的人也非常的多。

但是有一些语言之间呢，可能你就找不到他们之间的pair，然后呢他们啊google就做了这样的一系列实验，就是比如说你现在有有二三十种语言，然后有一些语言之间，两两之间它们是有对应的pair的。

有一些语言呢两两之间没有啊，举个例子，比如说举个什么例子呢，比方说阿拉伯语跟德语，他们可能没有太多的翻译，可能有一些，但是数量远远比不上中文跟英文来的量这么大，可能说阿拉伯语跟英文的量也非常的大。

可能德语跟中文，德语跟英文的量也非常的大，但是比如说阿拉伯语跟啊英语啊，跟德语可能没有这么大，那这个时候我有没有办法，利用别的语言的一些信息去帮助你，训练那一些比较少见的语言呢，那他们就提出了一个方法。

其实他们提出了其其实曾经有人做过很多方法，就是你可以想象，每一个语言可以有一个自己的encoder，每一个语言可以有一个自己的decoder，然后你有没有办法把这个encoder decoder。

它们纵横交错在一起啊，比如说你有你有100种语言，那你只需要100种encoder，100种decoder，它们可以互相叠加一起训练对吧，就思想其实是这样的，那如果你用比较蠢的方法来做。

其实有100100个pair，等于说你这个模型要训练1万个encoder，1万个decoder，100×100吧，啊当然应该是100×99除以二，但是同学们不要在意这些细节，就是你会有非常大量的啊。

那些encoder decoder pair，但是这个zero shot mt的想法是什么呢，他们嗯就是有有的，有的人说是encoder decoder可以共享，那这篇文章就更加的厉害。

他就直接把所有的语言都混成一团了。

就是我的输入只要在前面加一个特殊字符，比如这个two e s表示two s8new啊，翻译成西班牙语，然后他说hello，How are you，后面就变成了这个我也不会读啊。

什么HOLA什么什么东西啊，就是这个呢就是他们的他们的这个模型的做法，他把所有的语言都混在了一起，就是每一个语所有的语言都共享一套单词表，当然应该都是word piece，这个是google惯用的做法。

把它全都转成word piece，然后你只需要在你翻译的句子之前，加这样一个特殊符号，告诉他你要翻译成什么语言，他就会把你翻译成另一种语言啊。

他们就是用了一个很大的encoder，decoder模型来做这样一个工作，然后发现能够取得比较好的效果啊，具体的细节我们就不讲了，但是跟大家说一下这个思路，然后嗯我今我记得我去年去NUO。

就是那个会议的时候，看到google有一些很多这个新版本，他们他们之前的这些版本是基于啊。

基于那些LSTM的，就现在我看到他们有一有一篇文章好像叫什么，massive zero short and mt啊，有一篇这样的paper，这个是2016年，他们应该有一个2019年的吗。

毛T邻国new roversion，这是2017年，就是他们后面每年都会有这样的文章出来，然后我记得最近呢最近我看到的一篇文章，他们是有103种语言啊。

所以这个应该应该既是一个很有趣的研究问题，也是一个他们本身就要产品化的问题，因为确实对于一些大公司，像google这样的来说。

他们内部需要支持可能上百种语言的翻译，那有一些语言，可能确实是没有办法买到这么多数据集，就是你有钱，你也买不到这么多数据，他们就比较难做啊，所以就会尝试用这些zero shots的方法。

看看能不能做到同样的效果，可能就会在一些比较罕见的语言当中去上线，那最后跟大家快速提两句，transformer模型，transformer大家已经比较熟悉了，我们讲过birds，讲过GPT。

你就知道我们的encoder呢，就是一个transformer的encoder，我的decoder呢就是一个transformer decoder，其实你只需要这样的一个模型就可以了啊。

这个encoder这个decoder，然后生成这样的模型，我们可以把模型的部分给略过，但是我们看一眼，这篇文章的实验结果是什么样子的，好我们来看一下attention is all you need。

他们的实验结果是什么样子，我的印象中，他们他们主要是跟当时那一篇叫做cf seek，做了一些比较，那应该也会跟啊，LSTM之类的模型做一个比较，我们可以看一下他这里有transformer模型啊。

你看到这里他们也是english to french对吧，有english to french和english to german，As fraction of the training cost。

那这个到底是法语还是还是德语呢啊，他对他这边有法语，这边有德语，这边有法语，那你会看到他法语的分数，基本上就都在40以上了吧，就至少我们之前看到的那些分数，好像都是在30几到40这么一个区间啊。

你看他下面是德语，上面是法语，这个是google machine translation，是26~40这样的一个区间，那这边呢他都可以达到，41。8和28。4，所以比之前的模型又有了一定的提升啊。

所以这个是啊，也就是这一篇文章当时可以火的原因，扔掉了这个LSTM之后，可以达到比以前更好的效果，这个是啊machine translation，那今天应该说我们主要的主流的模型。

都是基于transformer的了，不管是不管是做实验啊，还是还是做产品，大家一般都会做transformer base模型，所以说这个啊这个模型非常重要，大家如果还有一些不了解他细节的同学。

就课后要认真的去读一读这个transformer模型，那还有一个问题需要跟大家提一下的呢，是我们之前的训练，估计大家都已经没有什么太大的问题了，就是你只需要知道这个模型它是给定X。

然后经过了一个model，这个model可能是一个encoder decoder model对吧，因为这个transformer也是一个encoder decoder model。

然后经过这个model之后，你出来的是一个Y，然后我们训练的时候呢，一定是cross entropy loss of y hat，其实应该是我就用这个应该是这样的，就是y hat对应Y。

所以它其实输出的应该是y hat对吧，y hat就是表示说这是一个预测，那真正的那个Y呢是以以标准答案，等于说我们需要算这样一个cross entropy loss。

然后你要对这个cross entropy loss不断的做优化，这个是我们训练的时候做的事情，那事实上你的你在做这种文本生成类的任务啊，因为我们translation本质上是要生成一段文本的。

它的他在做model inference的时候，跟你做training是不一样的，有什么不一样呢，有一个很明显的不一样啊，就是你在做你在做训练的时候，它是一个language model。

当你在做language not model的时候，我们知道你是你会一直计算这样一个东西，P y i given x and y1，一直到YI减一，那这里的Y1到YI减一，在你训练的时候训练的时候。

我们知道这个Y1到这个YI减一对吧，但是在预测的时候，就当你真正训练完这个模型，你去把这个模型部署上限的时候，我们是不知道不知道这个东西，你不知道Y1到YI减一是什么，所以当你在预测YI的时候。

你的信息量其实比你训练的时候要小，这个怎么办呢，呃这个其实说白了没有非常好的解决方法，就是目前的方法都是一些权宜之计，大家现在呃有很多新的工作在做这个方面，就是有很多人在研究怎么样统一训练，和测试嗯。

我之前我前两天刚刚还看了一篇文章是嗯，也是也是这个方面的，就是希望在训练的时候能够引入这个，引入这个预测的一些一些信息啊，他们有各种什么global，什么global deal。

global energy function啊，什么就是有有各种各样的方法，但这种应该说到目前为止，我们没有一个非常好的解决方案，那这些权宜之计是什么呢。

我今天权宜之计其实就是这个beam search，这个是目前用的应该说用的比较多的一套方法，什么叫做beam search呢。

这being search我们可以借助啊这个QINGRO的lecture。

跟大家看一下什么叫做being search，就是这个人他的这个lecture notes是2015年的，虽然有点老了啊，在他的94页有介绍这个beam search，所以我直接拉到94页给大家看一下。

什么叫做beam search啊，beam search的思想就是在讲冰search之前，我们先要讲什么是greedy search，就是我们刚刚讲说你的，你在做翻译的时候，我给定了你一个句子。

那你有一个encoder，有一个decoder，我先什么都不想，我可以先先把这个encoder给跑一遍对吧，encoder因为是给定你的，所以肯定没有问题，你肯定可以拿encoder来做。

所以说当我给你一个句子之后呢，比如说我喜欢自然语言处理，那你可以先把这个encoder给跑了，当然不一定是IN啊，我我不应该写IN，我应该写encoder，你可以先把这个encoder给跑了。

然后他给你了一堆这个hidden states对吧，然后我现在decoder，啊sorry，拉到拉过头了，那encoder他给你一堆hidden state，我们用C来表示吧，当然这个C可能是很多个C。

那你可以把这个C传进来，他就可以，他应该会能够给你Y1对吧，然后理论上你再拿这个decoder和C和Y1，你再可以生成Y2，就其实我们是不断的在做这一步操作，当你拿到这个Y2之后呢，你就可以拿Y3。

然后这样循环往复，一直到你到了一个end of sequence为止，那就表示这个decoding结束了，那如果你是做greedy search，如果你做greedy search。

那我可以每次都挑arg max，也就是说我每次都做arg max of这个啊，其实Y1他会给你一堆candidates对吧，就是你可以在那一堆候选的答案当中，选那个分数最高的。

这个是greedy search，greedy search好不好呢，应该说人们发现其实是不太好的，就是grad search，你有时候比较容易进入到一个，比较奇怪的状况里面去。

就比如说呃我记得有一些例子说，他总是很容易出现什么，i don't know啊啊，或者它容易出现循环往复，就是会不断的循环一些词嗯，当然具体是什么原因，我们也也不分析了。

但反正人们发现gree search有点问题，那另外一套方法呢叫做being search，什么叫做beam search，Beam search，就是我们绕一个beam，什么叫做bean bean。

其实是衡量就很衡量额衡量，或者说是其实就是这么样一个东西，就是你讲它是一个固定宽度的一个东西，这个叫做一个be，一种固定宽度的额装置，就这种我们一般把它叫做beam。

所以beam search呢就是我们固定一个search的宽度，然后搞一个搞一个可以拿来测试的东西，那这个算法具体是怎么样的呢，他这边有一个例子啊，beam search啊。

比方说我们现在要开始生成一些单词了，他告诉你给定这个X，然后他会给你一个PY1等于w for ow in v，然后呢如果我我我首先为了做这个beam search，你要设定一个beam size。

比如说beam size是K，如果你的beam size是K呢，表示我每一步decoding的时候，我都要选从选出最有可能的K歌hypothesis，所以我从我把这个W，我从W1里面呢选出W1到WK。

就这K个单词是概率最高的，剩下的那些概率太低，我就不要了，然后呢啊我们看到这里，他说我们用的是上标来表示，我们用下标来表示，Hypothesis and，他怎么他好像打错了。

应该是superscript来表示还啊，应该是subscript表示hypothesis，然后superscript来表示的是time step，所以这里是第一步，然后有K个单词。

然后呢嗯这样你就有了K个候选单词，然后当你在预测Y2的时候呢，你就要对每一个啊每一个之前的单词，因为之前有K个不同的情况，你都要算一个分数，这样你就会得到K乘以K个可能的情况啊。

理论上是K乘以V个可能的情况，因为你有每一个单词，它后面都后续可以接V个不同的单词，所以你是K乘以V个单词，然后针对这K乘以一个单词呢，你再直接找出最有可能的K个单词，比如说他这里有一张图。

如果你的beam size是三呢，他第一步嗯，你看是个单词表对吧，它会找出三个最有可能的单词，然后剩下的单词我就不用管了，为什么为什么要做这样的一套妥协呢，同学们可可能会想到。

我为什么不直接把所有的单词给搜索一遍，就是我直接把V个单词全搜一遍不就好了，那理论上你确实可以这样干，但实际上这样的复杂度是很高的，如果你要搜索V1个单词，一般我们的V。

我们知道都是至少是35万起步的对吧，那你3万×30000乘以3万，你直接如果搜索十部的话，就有3万的十次方，这是一个你永远都算不完的数字，所以这个beam beam search呢，其实它是一个妥协。

就是你每一步我只保留最有可能的三个单词，然后下一步你看到从这里出来呢，它应该有三种啊，他应该又有V1种不同的情况，所以你你又得到了三乘以V1种不同的情况，然后你在这里挑选出最有可能的啊。

分数最高的那三种情况，然后每一步你都保留三个，这样呢你的算法复杂度应该只有啊，应该只有V乘以三，再乘以那个sequence length，对吧，那这个复杂度呢是你可以接受的。

他这个decoding的速度应该不会太慢，所以说这个是beam search，我们可以再看一下，uh among the k乘以v candidates。

We choose k most likely candidates，你永远都是选出K个最有可能的那些句子，那同学们可能会想一个问题啊，同学们可以思考一个问题。

这个being in search是不是一定比greedy decoding好，啊同学们可以思考一下，这个being search是不是一定比grady decoding好，然后我们休息8分钟。

8分钟之后我们回来接着讨论这个问题，好我们回来了啊，我们刚刚在离开之前，最后提的一个问题是说，我的beam search是不是一定比greedy的，比greedy search生成的结果好啊。

所谓的结果好是什么意思啊，就是probability，probability足够高对吧，因为我们知道这其实是一个概率模型，那这个概率模型呢在我们搜索概率的时候，你你本质上最终应该是希望。

你最终是希望这个py given x，应该是得到最大值是吧，你需要找出这个arg max of y given啊，Of p y given x，你是希望找到这一个arg max的结果。

但实际上啊我们讲到说要不是grady decoding，要不是用这个beam search，那大部分情况下呢，beam search确实会好一点，尤其是你调这个beam search的size。

一般可能人们会找到呃，会把beam size，调到33~20之间的数字都比较常见，那是不是这个beam size越大越好呢，因为grady search本质上是beam size等于一对吧。

你把这个beam size这个K设成一，那就是一个grady search是不是一定好呢，实际上是不一定的，我们可以看一下，这里有一个有一个例子啊，我们首先知道如果你把K调调到正无穷。

可以调到正无穷的话呢，这就是一个exact search，你一定可以找到全局最优解，那当K等于一的时候呢，它是grady search，那是不是啊，K越大越好呢，我们他是这里有一个例子啊。

就比如说在第一步，第一个单词pa啊是0。5，PB是0。15，PC是0。5，那你知道如果K等于一的话，那你就会把这个0。5留下，就是A如果K等于二呢，你会把A和C留下对吧。

那现在假设给定A作为第一个symbol，那你就会我们就又要开始搜索了，P a given a，p b given a p c given a都有三个分数，那如果K等于一的话呢。

你会把这个p a given a留下对吧，因为它是呃它是最大的，那0。5×0。4，就是0。2这样的一个概率，那我们现在再看一下，如果K等于二呢。

我们可能要check pa given c p b given c p c given c，然后有这三个分数，那这个时候你要留下什么分数呢，你应该要把它们给乘起来，你知道这个应该是相当于是0。5×0。

4，0。2，这个是0。15对吧，这个是0。15，那这边呢是0。45×0。45对吧，0。45×0。45，所以应该是个这是多少，4545是不是二二百多啊，反正是比0。2大的一个数字就对了，应该额乘以0。4。

0。0。8对，肯定是个比0。2大的数字，所以这两个呢都比0。2大，所以如果K等于二呢，你最终会留下的是ca和CB，就是并不存在并不存在这个AA这个选项，所以如果K等于一的时候呢，你会留下AA这个选项。

但是它的概率呢其实比不上这两个，有可能被你扔掉的就是K等于啊，应该应该怎么说，这个是K等于we have discarded a a，那greedy search eny。

competing the last conditional probabilities啊，他这他这面下面还有一个啊，第三步啊，就是给定AA之后呢，他可能给你这三个不同的选项。

然后这个AAA的probability就是0。50。4，乘以0。9等于0。18，然后比方说K等于二，如果啊因为你知道K等于二，有CA跟CB，然后如果在这些情况下的，他就会告诉你说有多少。

Due to its higher problem，Ity than cbc c a a is finally chosen。

就是你会看到c a a is finally chosen in this case，然后你会看到这个CIAA呢是来自于beam size，等于二，那这个beam size等于二呢。

它的probability其实会比你的啊，bem size1的那个problem的要小，就是你看到这个PAA呢是0。8，这个是你用grady search做出来的，然后beam size等于二呢。

你可能会找到一个并不是最优解的情况，当然这种例子，你其实可以通过自己造一些example把它编出来，就是你只要确保他两部或者三部，beam search并没有留下最好的那个结果就行了。

就其实beam search并不是说一定会比greedy search好，就是greedy search，它每一步都虽然只留下了最优结果嗯，但但就是因为因为你这个其实是iterative。

一步一步往后走，就是你前几步留下的结果啊，比如说bem size，你设的大，你可能找到了一个你认为比较优秀的结果，但是当你一步一步抵扣的过去，可能后面反而会导致你。

你前面留下来好的sample是差的情况，就这种是很容易自己造一个example来，来表明这种情况，所以就说beam search呢，其实并不是一个完美的解决方案，但是人们现在主要尝试的方法。

一般都是基于beam search，就是当你在做这些translation的时候，我们还是会做research，应该说是一个权宜之计吧，就是现在有很多的研究者是在研究。

怎么样更好的做这个decoding的工作，可以把可以让你生成的文本更好啊，所以这是一个open question，但是啊beam search应该说是一个compromise。

可能面试的时候也会有人问你，什么是being in search，那你大概要跟他讲清楚，这就是一个这就是一个啊一种greedy search的方法，但是instead of找最好的结果。

你是找top k的，结果其实是一个top k的search对吧，那讲完了这个机器翻译之后呢，嗯如果有同学对机器翻译比较感兴趣的话呢，一个呢是大家把，啊让我让我来看一看。

有同学说那要计算所有一小于K小于K，就是你其实其实你要找到最终最好的结果，应该你还是要做一个全局的搜索啊，有一个同学说是他提了一个方案，我们来看一下，就是有个同学说要计算所有K1小于K。

小于K的结果应该就好了吧，呃事实上，事实上，Beam search，就是计算了所有一小于K小于K的结果吧，我不确定我有没有，我有没有理解错，你的意思就是been search。

相当于是我每次我每一个decoding step的时候，我都保留K个结果，在each decoding step我都保留K的结果，然后下一步的时候呢，你是找出所有的K乘以V的结果。

这个V是个cabulary size对吧，然后在这个K乘以V的结果里面呢，你找出top k的结果，就是你每一次呢都是这样循环，循环往复的找top k，但是它并不保证你找到的一定是最好的结果，为什么呢。

因为实际上你每一步找出了top k，并不代表别的单词，它后续的结果是差的，比如说嗯很简单的例子，当你说啊，可能你就说，然后然后你要把它翻译，你要翻译一下，那可能可能第一个出来的是因为某些原因啊。

比如说AMERICAN出来的这个结果比较低，可能出来的是什么AMERICA，我我就随便举了个胡扯的一个例子，或者你随便出来一个united states u s好了，US跟美国非常完美的匹配啊。

啊比如说前面的几个例子是us s跟这个united跟，就这两个吧，然后我的BESIZEK是等于二，如果K等于二，我可能把这两个单词留下来了，然后这两个单词留下来之后，你翻译着翻译着你可能发现不对。

就是实际上第一个单词应该是AMERICA，那这个单词你当时没有留下来，你就再也找不回来了，所以就可能会出现这种问题嗯，就是这么个这么个情况，就是实际上你这个K那可能有的同学会想，我把K稍微调大一点。

是不是比较好，那其实理论上你把它调的很大，应该说是啊，我这个例子好像讲反了，我这个例子是不是讲反了，对就是嗯但是同学们可以理解一下，就是你有的时候可能像像我刚刚讲的，那个是K太小了。

就是你没有把迈尔肯留下来，另外比如说有的时候啊，比如说AMERICAN他排在了第一吧，假设AMERICAN现在排在了第一，然后本来本来好端端的啊，如果你这个K等于一的话呢，这个M2肯就留下来了。

现在非要把K设成三，结果还出现另外两个candid，然后可能因为某些原因，你下一个出现的单词，结果又又把这个AMERICAN给丢掉了，就是这个being设置太大的一个缺点。

就是有时候会把一些top rank的单词给扔掉，嗯就是有这么一个有这么一些情况好，我们就讲到这里吧，然后同学们课后可以自己来思考一下，这个beam search是个什么样的问题。

但总之如果你有办法可以把K调到无穷大，如果这个K是无穷大，那这个问题一定解决了，就是你把所有的可能的情况都搜索一遍，但是我们知道这样是很困难的，因为K如果是无穷大的话，它实际上的搜索空间是V的啊。

sequence length次方，如果这个V是5万，sequence length是十，那就是五五的40次方对吧，五五的十次方乘以十的40次方，这个数字就非常大，你是根本搜索不完的。

所以这个beam search呢是一个啊，可以是一个很难很难的问题，它其实就是一个很难的问题，人们并不知道怎么样去解决它，那后面跟大家讲几个开源的项目，就是如果你要你想要做。

想要做一些跟翻译有关的项目呢啊，你可以考虑以这些开源的项目开始做啊，一个呢是我们之前课上我的那个实实训课里面，我给大家用PYTORCH，实践过一个translation的模型，那个模型你可以去啊。

至少把我的代码全部都理解，然后如果你全部都理解之后呢，你可以尝试一些更加复杂的项目，比如说我可能会比较推荐这个fair seek，虽然我从来没有用过fair seek。

但它是由facebook research开源的一个facebook air，air research开源的一个sequence to sequence模型啊，因为现在的很多的主要的研究。

好像都是由这个研究院做的，所以他们的这个framework应该是比较值得研究的啊，他们这边实现了各种各样的模型呃，他们这里应该有一个list，有一些是他们发的模型。

比如说啊你看有什么transformer的模型啊，有这个现在他们做很多nauto regressive，Transformer，什么叫做nauto regressive，我我刚刚跟大家讲的那些模型。

就是我们之前学的那些decoder，都是基于之前的单词预测下一个单词，然后他们现在在做一些不是从左往右decoding，就是有一些别的structure来做decoding啊。

这方面我懂的其实不是特别的多，所以我在课上就没有讲啊，应该说他们发现可以达到跟非auto aggressive，差不多的效果，但是应该来说人们用的现在还是比较小。

你看到他有这个CONFIONNET的模型，有这个transformer的模型，有LSTM的模型啊，就是各种模型都有，然后他们应该封装的也比较不错的，有这个啊，用这个torch hub load。

直接load这个模型进来，你应该就可以拿到这个模型，然后你就可以translate，同学们可以去试一下，比如我想他们应该有中文的模型，你可以加载中文的模型进来啊，如果你要做一些实验的话呢。

比如说要改他们的代码，或者做一些你自己想做的任务，你可能就要研究一下，怎么样去改它们里面的代码，因为这些模型的代码基本上其实都是给你的，比如说这种fair thick fire sick嗯，应该是有。

就是你需要花一点时间去研究一下，怎么样改他们的代码，另外还有我之前用的比较多的是这个tensor，To tensor，这个是来自google开源的一个项目。

这个library是来自于transformer那一个模型的作者，他们开发的一个一个一个library，所以啊attention is all you need。

这一篇paper的官方实现就是这个rapper，所以你如果想要出，浮现那个transformer模型的效果，你可以用这个library，就这些library其实都是一个比较高级的封装。

他帮你把那些底层的细节都实践好了，所以你只需要把数据feed进去，他就可以帮你训练你想要训练的模型，就有同学如果想要做一些啊，你自己想做的translation，比如有一些比较。

其实各种实验同学们都可以尝试的那种，什么从语言翻译成代码，从代码翻译成注释啊，从什么log生成那些什么，就是各种seek to seek的问题，你都可以考虑用我这边讲的这些framework来做。

因为他们封装的都比较好，你只需要把那个输入的数据改掉之后，可以用他们的模型帮你训练呃，一般来说会比你自己写的效率也要高，然后结果也会好一些，然后这个tensor to tensor呢。

它我知道他们作者是现在已经不更新了，你看到他们都是两年3年几个月之前更新的，所以现在好像大家都，他们应该是不怎么维护这个framework了，我感觉然后他们有一个新的framework。

叫这个叫这个tracks，我自己还没有用过这个tracks，但是据说是他们的那一个组，现在打算把他们的代码都搬到这个地方来，然后是支持tensor flow to，因为TENSORFLOW2。0之后。

可能有一些老的代码不太好维护，他们就把它搬到这个新的地方来了啊，就是这些都是我建议，感兴趣的同学可以去尝试的，就是因为你最终都会需要掌握一些这种，比较好的开源的库，然后他可以帮助你节省你将来做项目的。

写代码的时间，就是很多时候如果人家已经造过的这个轮子，你可能不需要再造一遍，你可能需要知道它的原理，通过我们这个是上课的这个过程，你知道了它的原理，你做了一些作业，然后你也大概知道他是怎么做的。

但是具体里面有很多实现的细节，你可能就不需要自己再全部猜，踩一遍那个坑，因为这个可能太费你的时间了，那如果你能掌握这样一两套的这个true kit呢，你就可以很快的上手一些项目，那这个就讲到这里。

然后呢，下面我们还有一点时间来讲一下文本摘要，文本摘要这个任务，当你做完翻译之后，你其实大概就会知道，文本摘要是一个什么样的任务，其实文本摘要呢他。

它也是一个sequence to sequence的问题，因为他这个任务就是说我给你一段长文章，你需要你需要生成一个比较短的文章，这个短的文章可以覆盖整篇文章的信息，那文本摘要有什么用呢。

你可以用它来生成新闻的标题啊，你可以用它来自动生成新闻的摘要啊，或者我还看到过有有人做这种生成会议摘要，比如说你开了一个会有很长的会议记录，然后自动生成一个会议摘要，就是有很多这种任务。

你可以通过啊自己想办法去自己想一想，有哪些地方可以用到文本摘要的这个技术，那文本摘要呢啊按照任务的定义，大致可以分成两种，一种是抽取式的文本摘要，所谓是抽取式的文本摘要呢，就是你这篇文章本来很长。

有100个句子，我现在想要把它压缩成五个句子，然后呢你就做一堆分类问题，把最重要的那五个句子给抽出来啊，这希望这五个句子可以涵盖到整篇文章，所有的信息啊，并且是一些关键的信息，然后另外一种呢。

那我们知道这种抽取式的模型呢，其实大部分是一些啊，大部分都是一些分类任务，就是我我其实是给定你100个句子，然后这100个句子你希望做一些分类，这个每一个句子都是一个二分类任务，这个句子留下这个句子。

不留下这个留下这个不留下啊，当然你可以做各种比较啊，你在去做模型的时候，可以让这些句子之间能够互相知道对方的存在，就比如这个句子跟那个句子在一起，然后他们有多少啊，概率能够有有有多少概率能够被留下。

有多少概率不会留下，那这个是抽取式，另外一种呢是生成式啊，深成式呢其实就比较像我们的文本翻译了，就是我给你一段文字，你还给我生成另一段文字，这一段文字呢它能够高度总结概括，这111个长文本的这个信息啊。

他是要比较精炼，但是要能够概括的内容，概括这个文章内容，相当于是说我用自己的话复述一遍，这一个长文本，那这种模型呢一般来说就比较依赖于，像我们刚刚讲的seek to seek这样的模型，在讲这两个。

那那我估计我讲完之后呢，大家其实有一定的概念了，就是我即使不讲具体怎么做这个事情，大家可能也能够自己猜一猜，如果我给你这样一个任务，你要怎么样去做它这种生成式的非常简单对吧，就是你就把我们。

比如说你直接把这个transformer啊，直接上transformer，其实直接上transformer模型，好像也没有什么问题啊，我认为是可以值得尝试一下，就同学们可以试试做这些实验。

直接上transformer怎么样，然后抽取式的呢，那反正就是个二分类任务，二分类任务啊，大家做文本分类也做的很多了，就是唯一的区别在于，你可能需要重新设计一下你的model architecture。

怎么样把整一个文档的信息全都能够包含进去，因为你不希望独立的分类一个一个句子，你还是希望知道句子和之间的，句子和句子之间的关系，那在具体讲怎么样完成这两个任务之前，我们还是来讲一下你怎么样评估文本摘要。

为什么要评估啊，因为这个这个问题的本质，跟我们的translation是一样的，你还是很难去评估，我现在的文本摘要到底好不好，因为一般来说我们会有一些叫做gold standard。

我们之前讲过什么叫做gold standard，什么叫做ground truth，Gold standard，Gold standard，就是你可能会花钱请人来做一个文本摘要，我给你一篇长文本。

我我先花钱请个人过来给我写一个文本摘要，那我现在的系统呢输出了另一段文本摘要，这一段文本摘要是不是错的呢，其实不一定是错的，就是呃就是如果你这个文本摘要，长得跟人写的不一样，是不是一定是错的呢。

不一定是错的，就是呃这个摘要是一个非常非常free的一个task，你有很多种不同的方法可以总结同一篇文章，包括翻译也是一样的，就一句话你有各种不同的讲法。

所以你都不能够直接说跟gold standard去对比，说一样的，就留下不一样的，就是错的，就这个东西不存在对错，只存在好坏，你怎么样评估好坏呢，在文本摘要里面，我们常用的一个评估手段是Rush。

Rush是不是一定是最好的，也不一定是最好的，就是说它是一个目前非常popular的一个一个，评估的分数，这个分数怎么算的呢，我下面给大家一个例子啊。

就他其实Rush呢是我们刚刚讲过这个blue score，它是基于precision的一套评估手段，它是要评估我这个句子啊，我我这个单词里面有几个，是在reference里面出现过的。

当你生成一个candidate时候，我要看有几个在reference里面出现过，然后我的candidates一共有多长，有多少是出现的这样的一个precision，是你的blue score计算的内容。

那ROUTSCORE呢计算的是你的record，什么叫做record，record就是我有一段reference，我有一段啊，这个是输出，应该叫candidates。

candidate summary对吧，给定一个candidate，给定你一个reference呃，我现在就是要看这个candidates里面有哪些单词，是出现在reference里面的。

那你就看到the cat was under the bed，它这里面有六个单词出现在了reference里面对吧，The cat was under the bed。

这个found没有在reference里面出现，所以说这个例子里面呢，如果你要看他Rush one，所谓的Rush one就是他的UNIGRAM，就是我只看一个单词，一个单词出现了。

你会发现它的Rush score应该是一，就是全部都在里面了，就是所有的我所有的这个单词，都出现在reference里面，Rush score就是一那啊，事实是。

事实上呢我们一般会看Rush e one和Rush two，因为我还要看两个单词是不是出现在里面，那Rush e two怎么看呢，你就是找diagram，就是the cat。

还有cat was was found found under under the和the bed，所以你一共有六个六个BIAGRAM对吧，这六个by agram里面呢。

这个reference里面是五个diagram，The cat cat was was under under the the bed，那这里有哪一些是你就要数。

有有哪一些candidate出现在了reference里面，然后你发现the cat是的，cat was是的，was found不是found under，不是under the是的。

the bad是的，所以一共有四个出现在了reference里面，一共有五个BIGRAM出现了四个，所以他的Rush two就是4over five啊，这是两个常用的Rush score。

当然实际上我们在真正用这些Rush score，的时候呢，它会有一些变化啊，因为你可能会有几个candidate，有几个reference，然后可能会有一些什么各种加权平均之类的呃。

但是他的核心思想呢都是基于这个record，算了一系列的分数，你Rush one，Rush two，Rush three，Rush four，其实都是可以的，就他是一些它是一些基于record算的分数。

我们可以想一想为什么为什么呃，翻译的时候人们一般用blue，然后这个作文本摘要，人们一般用Rush的，其实我觉得主要是因为摘要这个事情，人们比较重点关注，他有没有把该找到的单词给找到。

比如说有一些单词是非常重要的，但是你没有留下这个就比较不好啊，差不多是这么样一个原因，然后其实你知道所有的这些AGRAM就是有Rush two，Rush three，AGRAM呢。

很多是为了保证保证你这个句子的通顺性，就有的时候虽然Rush one分数分数很高，就是你该找的单词都找到了，但是你这个句子如果一塌糊涂的话呢。

他的Rush two跟Rush three这些分数还是会很低的，那还有一个特殊的Rush叫做Rush l，Rush l是什么呢，它其实是要找到longest common sequence。

什么是longest common sequence，The longest common subsequence，对longest common subsequence是什么意思呢。

嗯这个我觉得是一道很好的面试题啊，就是我给你两个sequence，一个是S啊，比如给你这两个两个句子，一个是S，一个是P吧。

然后P然后你要找到它的longest some common subsequence，这个词，什么叫longest common subsequence，就是你要找到它们，但当中的子序列。

并且它们的顺序是一样的，那这里就是什么呢，The cat was under the bed，这个就是the longest comments of sequence，就他要服从它的顺序。

并且这些单词要在两个，在两个句子当中以同样的顺序出现，并且都出现过了，就这样的叫做longest common subsequence。

所以你会看到这里的longest common subsequence呢，是等于六，就是有六个单词，这个是最长的，Subsequence，最长的最长的子序列。

然后你要算这个子序列的record跟precision，然后再算他的f one，我们知道precision是啊，也就是6/6，因为这个precision一共有六个长度吧。

然后这个呃record应该是67，因为一共有七个单词，但是只有六个被找到了啊，是这样是吧，reference里面有个the cat was under，The cat was found，好像我写反了。

precision是六七分之六，record是66，然后你的f one score呢，就是这两个数字的harmonic mean对吧，那个叫什么harmonic mean，和谐平均吗还是什么。

就是这个harmonic mean，就是两个数字的倒数相加起来求个平均，然后再求个倒数，这个是啊入世L就是具体的实现方式，各种toolkit会稍有不同，但是论文里的核心思想。

就是这个这个Rush score呢，他就是各种算record和f one的这种方法，拼接起来的，那一般来说就这样的，同学们将来自己在看到一些论文的时候，你看到他们打的分数，你大概有一个概念。

就是这个分数呢一般来说是越高越好，就blue score也是越高越好，rues score也是越高越好，他应该都是给你一个0~100之间的分数啊，这样的一个结果，然后我们下面啊跟大家快速的讨论。

两篇或两篇论文。

告诉大家一下怎么样做text summarization，这篇文章呢叫做text summarization with。

Pre trained encoders，发表在去年的EMOP上面啊，这篇文章看起来非常的简单，但是呃应该说很明显，肯定是当前能找到的比较好的效果的文章，因为他用上了BT这样的模型。

他直接用上了BERT，所以你用BT训练出一个啊地训练出一个模型。

那肯定是比较好，我们快速看一下它的abstract，他们就是we show how bird can be usefully applied in text，To。

Summarization and proposed a general framework for both，Extractive and ababstractive models。

就是两种情况他都讨论到讨论到了，一种是抽取式的，这种是抽取式的，这种是生成式的啊，然后他说we introduce a novel，Document level。

encoder based on bird啊，这个其实不是都都不是很重要，就是他们一般都会说自己的模型很NOVE，然后然后他就说我们的extraction model is built on。

Top of this encoder by stacking several intersentence，Transformer layers，然后他这个是extractive model。

就是一个分类模型对吧，对于这个ABSTRACTIVESUMMARIZATION呢，他们是fine tune的一个transformer模型，因为你知道transformer的encoder就是就BT。

其实就是transformer encoder对吧，所以你只要有BT在的话呢，啊你就可以嗯，你就有了transformer的一半了，你只要把剩下另外一半训练一下就可以了，那我们直接看一张图。

你就大概知道他的模型是怎么怎么样做的，这边呢是左边是BERT模型，大家知道BT是长得跟左边这样的，对吧啊，BT有他有啊，就左边就是个BIRT嘛，就是它有三个三个embedding。

一个token embedding，一个segment embedding，一个position embedding，然后呢右边呢是他们的这个bird summarization模型。

这个bird summarization模型是怎么做的呢，这里他首先要做的是一个嗯，就是对于你看到他这边有三个句子对吧，你看它左边其实只有一个句子，它只有一个c o s token。

右边它其实这张图里面表示的是有三个句子，所以如果你的文档里面有很多个句子呢，它只需要把每一个句子前面都加上一个CLS，就可以了，你发现这边有很多的CLS对吧，有很多的CLS，那如果有这三个句子。

然后你如果要做一个抽取式的那个摘要模型呢，你只需要把这样的一整个模型塞进BERT里面，然后把这些c o s token拿出来做二分类，然后你就可以找出哪一些句子应该被留下，哪些不被留下好。

这就是一系列的二分类问题，那你想这个模型为什么啊，为什么这个模型可以work呢，因为其实它下面的transformer encoder，做了很多的工作，就这个transformer layer。

这里下面可能比如说BT有12层对吧，已经过了12层BT之后，他们其实互相之间是知道对方的信息的，就是我每一个c o s token，我既能看到自己句子的信息，我又可以看到别人句子的信息。

所以他们都是知道别的句子在讲什么，并且他们有这个positional embedding啊，这里有这个position embedding，还有这个segment embedding。

就他知道自己是哪一个句子，他也知道自己在句子的哪一个位置，然后他也知道别的句子讲了一些什么，所以他可以判断我这个句子应不应该留下，嗯是这样的一个任务，所以这是一个看起来很简单。

但是我认为应该说是一个非常有效的模型，然后ABSTRACTIVESUMMARIZATION怎么做呢，我们刚刚讲的是extractive对吧，我们还是看一眼这个。

他讲的有没有什么特殊的地方，啊这也是related work。

然后你看到extract，Extractive summarization，它其实就是把这些sentence全都给拼到一起，然后嗯一起做了一个BT，然后最后来做一个做一个分类啊，应该就没什么特别的。

那obstructive summarization，他是怎么说的呢，他也是um is the pre trained bird sun，And the decoder is a six layer。

Transformer，Initial randomly，所以这其实就是一个翻译模型，但是它的encoder呢是基于bird，它的decoder呢是从头训练，然后他告诉你他们有一些特殊的地方是什么呢。

他们的嗯，encoder跟decoder的那个应该用，用了两个optimizer，他说we use two item optimizers。

然后with different warm up steps and learning rates，用了不同的参数来训练encoder和decoder，那这个呢应该是。

因为你的encoder是一个训练的比较完整的模型，因为BIRT这个模型已经训练的相当强了，可能可能你不希望对BIRT做太大的改动，如果你的learning rate太大，你可能会把你的BIRT给搞破。

搞破坏了，就是这个BIRT，我们知道birt find two的模型，一般那个learning rate都是很小的，大家如果自己做过一些实验。

就会发现birth那个调参数的那个learning rate，一般我都调的很小，是十的五次方那种级别或者十的六次方啊，十的五次方和十的六次方，就你不希望把BT那个改动太大，但是。

啊有同学说生成式模型的输入结构是什么，我认为应该也是这么个结构，我觉得应该是嗯，这是一个好问题，我们可以看一下他是怎么做的，我个人怀疑，你可能直接把句子给扔进去就可以了，就是你都不需要做任何的操作。

Uh the encoder is the pre trained bird sun and the decoder，我们看一下什么是bird sun，他可能还介绍了什么是bird，Sok。

我们看一下啊，我们看一下SUMMARIZATION，Encoder，Fine tuning its application to。

Summarization is not as straightforward，Since birt is trained on a mask language model。

The output factors are grounded to token，Instead of sentences，Most words。

Although segmentation embedding represents，Different sentences in birth。

they only apply to sentences inputs啊，他的意思是说，how we他他的意思应该就是这个bird sun。

他跟你说figure one的这个这种架构叫做bird sun，所以figure one是这个这个叫做bird sound是吧，Bird for summarization，然后你看到他告诉你说。

ABSTRACTIVESUMMARIZATION也是由bird sun作为encoder，所以说明ABSTRACTIVESUMMARIZATION用的也是这张图，就他应该也是它跟抽取士用的是同样的架构。

用这个bird sun模型，那然后他告诉你，decoder就是一个transformer，Decoder，encoder呢你就用那个bird，但是中间加了一些额外的c o s token。

那个是跟普通的bird不太一样的一点，因为普通的BIRT你只有一个COS，他这边有很多个，这个其实是他整篇文章唯一做出的一点修改，然后他告诉你两他要用两个ADAM来做fine tuning。

嗯这个模型我就讲到这里吧，然后最后还有20分钟时间，我想跟大家讲另外一个我认为非常有趣的模型，这篇文章虽然有一点老是2017年的，但是呢它里面的这个思想我认为非常的重要。

叫gets to the point summarization with pointer，Generator network，也是来自于斯坦福的一篇文章啊，这篇文章呢在讲之前顺便跟大家说一下。

就是我们我一般会要求同学们，就是自己去想办法做一些实验，写一些文章，然后嗯上一届就是上一期的这个NOP就业班，有一位同学就写了这样的一篇博客，我认为写的还是不错的。

就是他相当于学习他这个pointer generator work，然后自己去跑了一些实验，然后展示了一些结果啊，他前面是介绍了一下这篇文章嗯，是一些介绍进制的，然后介绍了一下这个代码是怎么样写的。

然后展示了一下他的训练，训练的这个learning rate啊，这个是什么loss loss的这个改变情况，然后最后有一些这个英文的，英文的生成和英文的摘要，然后还有一些他还用中文去训练了一些数据。

然后生成了一些中文的摘要啊，有一些例子啊什么，比如说原来的标题，血管就是这么一天天被堵死的，别再默默喂养血栓了，生成的标题嗯，就是生成的标题也挺好玩的对吧。

就是这些sequence to sequence，模型生成生成的这些结果，其实有时候会比较奇怪嗯，但他这边展现了一些例子，我觉得还是不错的，就是他这个项目都做了一些，把自己这些项目都整理下来啊。

我也会建议这个班的同学也是啊，就是你们看到一些自己特别感兴趣的模型，就是不一定是要非常非常高级的，就是做出来你觉得这个事情非常的novel，非常的创新，我觉得大家就把这个当做一个学习的机会。

然后去尝试在各种不同的数据上面做一些实验，然后看看能不能出来一些比较有趣的结果啊，像因为我们知道有一些任务，像什么分类啊，这种任务或者是搜索啊，这种任务是比较容易拿来做成产品的，其实这些生成模型。

有时候你生成的句子的质量是不那么好的啊，确实比较难做成产品可以上线，但是可以可以给你一些感觉吧，就是让你对于这些模型都有一些，更加深刻的理解，当然我们知道像翻译这样的模型，现在已经是比较成熟的了。

因为我们其实很多时候模型之所以效果不好，都是因为缺数据，你真的训练的数据足够大了之后，我相信还是可以就这些生成问题，至少文本摘要应该还是可以做的比较不错的，尤其是那些啊抽取式的摘要。

那些分类问题应该是不会太难，对你们可以参考一下，然后这篇文章为什么我非常喜欢这篇文章呢，因为它比较好的啊，他做了它里面引入了一个叫做copy mechanism，什么叫做copy mechanism。

就是我们知道，很多时候你在做摘要这种问题的时候，你并不需要真的自己去生成一个单词，你只需要把本来文章中出现的单词给抄过来，就可以了，那这篇文章呢它的核心思想就是，我怎么样可以把这些单词给抄过来。

就是有的时候我要抄过来，有的时候我不要抄过来，这个是这篇文章的一个基本思想，这个叫做pointer generator network，所谓的point generator就pointer。

就是我的手指指着这个单词，把它这个单词直接抄过来，generator就是啊不用抄了，我自己生成一个新的单词，所以这个这个模型叫做pointer generator模型。

那这篇文章呢它是基于seek to seek模型啊，就是seek to seek加attention，这里有一张图，这张图画的也比较漂亮，我觉得就seek to seek啊，是这篇文章。

因为是在transformer之前，所以还没有transformer，它就是一个LS双向LSTM，然后加context vector，然后生成这样的单词，这样的一套模型啊，同学们现在应该比较容易看懂。

我现在这张图里面的模型，左边是一个encoder对吧，有一个双向LSTM，然后出来的这个出来呃，一套加权平均得到一个context vector，然后传到右边生成那个单词对吧。

这是一个呃比较标准的seek to seek模型，然后我们看一下它这里的他这边总结一下，总结了一下这个seek to seek模型，seek to seek模型是怎么样来的呢。

他告诉你说有一个attention distribution at是这样计算的，这个是来自于巴德now那篇文章，就是这个HI呢应该是我们看看hi是什么。

HI应该是它的encoder hidden state，我们看到HI是encoder hidden state，然后这个ST呢是decoder hidden state，所以你的这个分数呢。

他们就是这个当前解码器，对于编码器的那个权重，应该是由这样的一个两层神经网络构成的啊，这个里面是一层对吧，然后加个ten h，外面再是一层，就这样可以得出来一个分数。

然后他告诉你这个分数你过一个soft max，你就可以得到一套权重了，然后这条权重得到了之后呢，呃你的hidden state就是就是encoder，hidden state的加权平均。

然后你把这个HT star跟你的s st拼到一起，再过两层神经网络，就可以得到一个vocabulary的probability，这个是你要预测的下一个单词对吧，这个是解码器预测的下一个单词。

然后他告诉你的PW呢，就是这个就是这个就是你要生成下一个单词，就是由这个P和cap定义的，那这个是一个标准的模型啊，一个标准的encoder decoder加attention模型。

这个模型呢还有啊他在训练的时候呢，就是用这个叫做cross entropy loss，或者叫做log loss啊，这个就是你的训练的方法，然后pointer generator要做什么事情呢。

就像我刚刚讲的，我们刚才这一个模型啊，它的生成是由你的hidden state决定的，就是你你每一步生成的下一个单词，反正都是一个都是一个概率分布，但实际上有的时候，我们的模型不需要自己生成一个单词。

你可以去文本里面抄一个单词过来，怎么样可以做到抄这个动作来，就是直接抄一个单词过来，那这里呢这个point generator，他就要做这么一件事情了。

然后我们看一下这个pointer generator要怎么样做呢，他告诉你说，我的这个我要先定义一个特殊的generation probability，就是你有两种情况，就他认为有两种模式。

一种叫做generation，一种叫做啊pointer，或者让他copy所谓的generation probability，就是告诉我在有一有这么的这么大的概率，我要生成一个单词了，还有另外一定的概率。

我是要抄一个单词的，那这个generation probability怎么做呢，他告诉你是来自于这个sigmoid of，这个是我们之前这个HT，还是之前的这个HT啊。

就是啊hidden states的平加权平均，然后呢这个是你的decoder state对吧，这个XT呢应该是你的XT是什么，XT他之前有提到吗，XT看起来像是，他真没讲XT是什么吧。

嗯让我来简单看一眼这个XT是个什么东西，他怎么突然冒出了一个XT来，XT看起来像是一个单词的词向量，是decoder input吗，非常感谢这个同学，我可能在哪个地方漏掉了XT，如果这位同学没说错的话。

那应该是decoder input，那我们就啊应该是因为这个T表示的是decoder，那应该是个decoder input啊，OK就在公式上一行吧啊对decoder input，非常抱歉。

同学就是我我漏掉了这个decoder input啊，这个是decoder input，然后呢这个B呢是一个参数，那就没有什么多说的，那这个P呢它首先就表示了他你看到什么。

P gen is used as a soft switch to choose，Between，Generating a word from the vocabulary by sampling from vivo。

Cab or copying a word from the input，Sequence by sampling from the attention distribution。

就是他说我现在这个P卷，可以决定我是要生成一个单词，还是直接去去encoder的，就是输入里面去抄一个单词过来对吧，那然后你现在就有了这个pg，每一步你都有了个P卷。

我们看到这个图里面它的P卷是怎么样生成的，你看到这里有一个PG对吧，是generation probability，然后呢他会说啊，那这个PW我们知道在原来的seek to seek里面。

这个PW就是p vocab w，那在这个copy在这个pointer generate network里面呢，它就不等于p vocab了，它是P如果是个生成的呢，就是这个P正比如说这个0。5，那有0。

5的概率，他要从这个单词表里生成，另外剩下的那0。5的概率呢，这个0。5是我乱编的一个数字啊，可以是0。40。8，它是来自于你的attention的那些分数，这个A是哪里来的。

这个A我们刚刚看到你的A其实是由啊，由这一套东西算出来的对吧，就是有一定的概率呢，它是由从那个hidden state，从那个attention分数里面去sample，我可以从呃。

从我的输入的那个句子里面去抄一个单词过来，所以你这个p gen呢，就表示了我应该要生成一个单词，还是去抄一个单词，然后他说这里还有一个额外的好处，是有了这个copy net之后。

其实copy net是另外一篇文章，但是啊这种pointer network跟copy net都是，有一段时间还是挺火的，就是它它可以解决out of vocabulary的单词，有一些单词。

如果你的单词表里面没有，但是在文本里面有，那你这个generator，你这个考generator啊，不是就是你那个叫什么啊，应该叫做pointer，还是可以把它抄过来的，然后他这里还做了一些。

应该还做了一些改变啊，就是你看到他这边还有一个应该有一个ct，哪里有一个ct啊，就是它有一个coverage loss，就刚刚这一个模型其实已经到此为止了，就是你他只是做了这么一个改变。

就是当我在我的解码器，在解码下一个单词的时候，有一定的概率呢，我是从我的文文本里面去啊，从我的单词表里生成出来的，有另外一定的概率呢，是从我的encoder里面去抄出来的。

那这个PW呢它最终还是一个生成的单词对吧，所以你训练的时候，还是可以用你的cross entropy loss，因为这个PW它还是可以直接传到这个地方去。

可以当做当做你的cross entropy loss来训练，这个模型，就是还是用公式六来训练它，唯一的区别就是我的生成途径其实有了两条，那还有哪些地方要改变呢，就这篇文章还有一个很重要的一个概念是。

Coverage mechanism，其实当然也不是这篇文章提出来的，但是它把它很好的拼接到了一起，什么叫做coverage mechanism，因为我们知道我们在做解码器，用解码器做解码的时候。

实际上你是你的attention，分数是时时时刻刻在变的，比如说当你在预测第一个单词的时候，你可能是啊主要的注意力是在第一个单词上面，在当你在解码第二个的时候呢，你可能会往后面移动一下。

就是有这样的一个动态的解码的attention，变换的这个过程，那在我们原始的这个模型里面，你没有任何机制保证，你的这个attention会不会永远都在看第一个单词。

当然实际上你如果训练的模型训练的比较好，这个AT应该是会动态移动的，但是你并没有很强力的保证，说这个at一定会往后移，就是他的attention应该会移动。

它可能attention会总是重复的翻译同一个单词，那这样就不是我们希望看到的情况，然后他这里就引入了一个ct。

这个ct呢是他说is the sum of attention distribution over all，Previous decoder time steps，就是到目前为止。

我已经比如说解码了十个单词了，那我已经拿到了十套attention的这个distribution，我要把这十套attention distribution全部都加起来，变成一个新的c ct。

然后他告诉你这个ct是一个anommalized distribution，Over the source document words，那我们想一想这个ct有什么用啊，ct肯定是有用的对吧。

就是你你这个ct如果有一些单词，我已经前面关注了很多次了，那后面你就不希望再关注到了，有一些单词如果我还没关注过，他的关注度还接近于零，那那个单词你就应该拿出来多看一看。

所以他这边就把这个CT当做模型的一部分，传入到计算你这个attention的分数里面去，就是当我算出c ct之后，我下一个下一个attention的分数，就要由ct作为一部分的输入来决定。

那你看到这个ct它肯定是一个多少维的参数啊，ct应该是一个，首先这个AT它应该是句子长度的一个vector，所以CT看起来也像是一个句子长度的vector，Same length as we。

OK就是他只需要保证这个WC，可以把这个东西转成一个啊，跟V1样长度的vector就可以了，嗯this should make it easier for attention mechanism。

让我来让我来想一想，我都还不一定确定是不是一定搞得清楚，这个SHA，那这个我们可以课后再想，但总之它就是这个ct呢，是要作为参数传到你的计算，下一个attention分数的那个那个参数要传进去。

那这个是attention的这个机制，要要做这样的一个修改，然后他们还加了另外一个loss，叫做coverage loss，就是他会他定义了这样的一个loss。

minimum of a t c t是coverage loss，这个是什么意思呢，啊我们会看到如果ATCT太大的话，因为它是个损失函数，所以你当然是希望它越小越好，如果这个损失函数太大的话呢。

表示说有一个单词可能被看的次数太多了，是这样的，我这个解读有没有问题，就是这个cf loss，如果如果他啊大于，如果他是大于一的话呢，他告诉你说is bounded in particular。

这个应该是小于等于一，为什么小于等于一，因为你这个a at它其实是一个attention distribution，它是被soft max过的，所以它最大就是一，所以这个东西它理论上应该会是一个啊。

小于等于一的数字，然后他这边应该就是要保证你不可以让啊，你不可以，你不可以让你，你你尽可能是希望这个嗯这个loss要要比较小，那说明的是什么呢，你不希望某一个单词上面被看太多次。

就是不能不希望在任何一个单词上面，放太多的attention，这个为什么有效呢，呃其实我也不完全确定为什么有效，但是至少它说明你，你不，你不希望在任何一个单词上面放太多的注意力，然后他告诉你说。

In mt，We assume there should be roughly one to one translation，Racial。

Accordingly the final coverage vector is penalized，If it is more or less than one，啊。

就是他是希望这一个coverage loss能够尽可能小的，原因是因为如果之前这个单词已经被哦，应该应该是这样解读的，我我认为这样解读应该没有问题，就说一个单词，如果他之前已经被放过attention。

因为这个ct是你的cumulative attention对吧，c ct是你的cumulative attention，如果他在之前已经被看过了，那他现在就应该尽量不要，不要放太多的注意力在他上面。

如果他之前没有被看过，那他才有才有能力才被允许多看一眼，那如果他之前被看过，现在没被看，那他应该会接近于零，如果他之前没被看，现在被看了，那他应该其实还是接近于零，所以这个minimum应该无论如何。

都是一个接近于零的数字，所以这个是他的，我觉得是这个loss函数的一个一个解释，然后呢有了这一整套loss之后，你看到上面的一部分呢，就是你的啊单词生成的这个loss，第二部呢。

第二部分呢是你的coverage loss，有这两个部分，那我们在我不确定我讲的有没有过于混乱啊，就是可能我再花，我再花几分钟时间再把这个思路过一遍，以确保大家明白我说了些什么东西。

就是这个point generator呢，它本质上服从的还是一个seek to seek模型，你看到他还是左边是encoder，右边是decoder，但是唯一不同的一个点呢。

在于它有一个generator这样的一个mechanism啊，有一个generator的这样的一个一个相当于一个阀，一样的啊，这是一个0~1之间的数字，有一定的概率，你的单词是从你的整个单词表中生成的。

另外一点概率呢，它是根据你的注意力机制的那个distribution，直接从encoder里面抄过来的，我可以从source document里面抄一个单词过来，那这里这里呢这个PJEN呢。

它就是来自于它来自于哪些信息呢，他告诉你是来自于这个hidden state，来自于你当前的呃，来自于你的encoder hian state，来自于你的decoder hian state。

来自于你的decoder input，这三个部分决定了我，我下一个单词应该是有多大概率是抄过来的，有多大概率呢是自己生成出来的，然后这个批卷拿到手之后呢，你就可以从两个不同地方去生成单词了。

一个是从你的单词表里面生成出来，一个呢是从你的，我看到右边这个vocabulary distribution，是从你的单词表里生成出来，左边呢它是由啊有这个source document里面去抄过来。

那这个是P卷，这个其实就是最核心的，这个就是为什么这篇文章要做做pointer network，要做pointer，Generator network，因为他有这样的一个pointer。

跟generator的这两套机制，然后因为有这个机制的存在呢，啊它里面还做了一些别的修改，比如有这个coverage mechanism，为什么需要这个coverage mechanism。

我们刚才已经讲过了，因为有一些单词你不希望它重复，他之前已经被翻译，已经被总结过了，你就不要再总结一次，那这个是怎么样确保完成的呢，你只需要把你的attention分数给accumulate起来。

就可以了，然后你希望这个attention分数，作为你的下一个attention机制的一部分，能够传进去，并且你还专门定了这个coverage loss，希望每一个单词他不能被重复关注，这个单词。

如果之前被关注过了，他后面就不应该被被被关注，他之前如果没被关注过，他后来才应该被关注，这个呢是作为一个loss，可以确保你不会重复关注同一个单词，就这个是这篇文章的一个主要的核心思想啊。

然后如果同学们，我觉得同学们也可以看一看，我这个之前这位学员写的这篇文章，他他应该自己这个博客里面也写了不少文章，就是我们的我们上课的过程当中啊，讲到的一些内容，他有不少都把它写成了这个博客的文章。

我认为同学们可以学习一下他的这种做法，就都我都不应该说是推荐了，就是我认为每个同学都应该去尝试做一下，因为这样呢可以保证你做的这些工作，它是落到纸上的，因为很多时候你的工作，如果没有被记录下来的话啊。

你的工作其实就跟没有做是一样的，就是你必须要把你做的工作变成实，变成了一个实质的这个产出，你可以把它写成文章，你也可以把它写成代码放放到一些平台上面去，就这样可以让你的这些你的工作是公开的啊。

这样呢你把它写到简历上面会更有说服力一点，有同学提到说，文中提到的可以用out of vocabulary单词预测，用的是id吧，unk id不是固定吗，他怎么处理UNK计算loss的准确度。

这是一个好问题，我来看一下他是怎么样解决这个问题的，我们来看一下它的PW呢，他这边应该告诉你说，这个w is an if w is out of vocabulary。

Then p w is zero sing similarly，if w does not appear in the source document啊，其实他是这样的。

就是它的这个单词表应该是他有这个p vocab，它还有另外一套别的东西，就是它的单词表应该是两个单词表的集合啊，我不记得他是在哪里讲过的，我记得他的单词表示有拼在一起的。

我们来看一下它的vocabulary是怎么处理的，他说for each document，Let the extended vocavocabulary，Denote。

The union of the vocabulary，And all words appearing in the south document，它应该是每一个document会自己创建一个额外的。

Extended dog vocabulary，也就是说在训练的时候，你那你那个vocab vocabulary是被扩充过的，然后在预测的时候，其实你也同等扩充就可以了，因为在预测的时候。

你也同样会预测他，要不然要不然是来自于啊，那个fixed the vocabulary，要不然是来自于这个copy，就是在预测的时候，他不是一个问题，在训练的时候呢，我看他的意思是。

每一个document他都专门扩充了一下这个词汇表，那实际上同学们可以想象一下，如果你把这一套体系用到transformer，或者word peace的模型里面，其实没有这个问题。

因为word piece可以handle所有的vocabulary，但是你还是可以把copy mechanism留下，因为嗯你还是可以说，我这个地方是copy还是generate，虽然单词表是一样的。

但是其实还是可以把两套都放到一起，其实当年的文章特别喜欢强调OOV的问题，我觉得现在其实有了那个word peace之后，大家认为OOV好像都不是一个问题了啊，至少对于英文来说是这样的。

我不知道中文如果有一些特别奇怪的单词，其实中文一般常用的词也是比较固定的，就是那些真的不常用的，大家好像一般也就不管了，我觉得是这样的，啊大家还有没有什么问题，我们可以再讨论一下。

我稍微总结一下今天这节课的内容啊，我觉得今天这节课的主要内容是啊，主要就是机器翻译和文本摘要，机器翻译里面呢，其实最重要的就是transformer这个模型，没同学们一定要非常了解。

transformer的所有细节，然后嗯知道下beam search，beam search也比较重要，就至少你得知道它，然后这种什么attention机制，其实也有很多面试官会问这些问题。

让你讲一讲什么是attention啊，然后我记得我之前还有学员被问到过，说让他对比一下这个attention，就是这个button now的attention。

跟这个transformer的attention有什么不一样，然后说让他对比一下，说这个attention为什么，为什么这个transformer的速度会比较快啊，就这些问题大家都可以思考一下。

都是要很有可能会被问到啊，然后这些开源的项目呢，是我认为对于同学们对于这些项目感兴趣的，你肯定是花时间把这些开源项目怎么样运作，去了解一下，就这个它其实是一些to，就是可以帮助你将来做各种各样的实验。

做各种各样的项目啊，文本摘要的部分呢，这个tt some我估计大家会比较容易了，比较容易学会，因为他就是一个啊用BT加分类的一个任务。

然后这个这个pointer generator generator模型，我也建议大家去了解一下，如果你要做SUMMARIZATION，我觉得你必须要了解这个模型是怎么样works的。

因为那些生成模型其实比较容易，生成一些比较奇怪的话，另外其实有一篇很相似的文文，文章叫做copy that啊，叫做incorporating，copy mechanism to什么什么的。

这篇文章跟那个其实比较相似。

跟pointer generator比较相似，也是同时期的一篇文章。

就有兴趣的同学可以自己去看一看，就这几篇文章呢是啊在翻译和文本摘要的领域，影响力都比较大的几篇文章，是都可以了解一下，嗯embedding层你是可以变的呀，就是你在写代码的时候，有同学问了个问题啊。

他说预测的时候扩充了词表，embedding层没有变，out of vocabulary单词怎么样，embedding的，让我来想一想这个问题，我认为在embedding层的时候。

你其实还是可以用UNK，就是你你总你总归是有一个UNK的，就是我我们就讨论，如果必须有UNK存在的情况下，因为其实如果你有用word piece，可能不存在UNK的问题，但假设有UNK的话。

你的embedding还是可以用UNK的，只是你在预测的时候，你应该是可以用那个attention来直接表示，我现在要预测的一个某一个位置的单词，就是那个预测其实是不需要你的词汇表的。

因为我们最终要预测的并不是一个embedding，我们最终要预测的是一个相当于LOGI和probability，一样的东西，你只需要能够得到那一个单词的probability，就可以了。

他并不一定非要被embedding吧，就是我呃，我明白这个同学的意思应该是啊，就是那个embedding应该是你在encoder，就是你的encoder在编码那个单词的时候。

你会把单词呃embedding一下，但是那个我认为直接用UNK就可以了，对有同学说要用attention的位置再反查真实id，让我来想一想这个问题，你在做，你拿到了attention的位置。

然后你就得到了对，应该是的，我觉得这位同学说的没有错，你确实应该要从根据attention的位置，来反查这个id，就相当于你最终是要生成，你最终还是一个，我们就看这篇文章里面。

我再拉回去看一下那个分数里面，你最终是要得到这样的一套分数对吧，这个PW是这两个部分，第一个部分比较简单，就是P站某一个常数乘了一个p vocab，第二个部分是基于这个attention。

那这个attention呢它实际上应该也是，就是你确实得根据每一个位置，知道每一个位置的，它它的那个单词是哪一个维度上面的，它应该是一个vocabulary size。

加就是extended vocabulary size维度的一个向量，可能是一个，就是你得知道它每一个attention位置，对应的是哪个单词，嗯那要不我们今天的课就讲到这里了，然后我们明天再明天再聊。

明天我们还是会讲一些跟文本生成，比较相关的任务，然后我们再把作业一讲一下，这个是我们明天的计划啊，那我们今天就讲到这里，谢谢大家了。