标签：这个 在线 一个 模型 笔记 公开课 概率 序列 我们

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

【七月在线】NLP高端就业训练营10期 - P7：3.基于Luong Attention的机器翻译_ev - IT自学网100 - BV1uxT5eEEr6

那我们这节课主要的聊天，主要的讲课内容就是关于用sequence to sequence，做做这个机器翻译，以及训练一个聊天机器人，那我们快速的回顾一下sequence to sequence模型。

首先在2014年的时候，这个q on cho发了一篇论文，叫learning phrase representation。

Using isnencoder decoder for statistical，Machine translation，在这篇文章之前呢，实际上也有人发过比较类似的一些哎一篇文章。

但是之前的那几个人做出来的效果不好，所以现在大家只记得这一篇文章，就是encoder decoder模型，这个模型的基本思路非常简单，就是啊比如说我要把中文翻译成英文，我们把这个中文用X来表示。

把这个英文用Y来表示，然后呢，嗯我的我的做法就是把这一段中文啊，都先做个embedding，然后过一个recurrent neural network，他们在这里用的是一个特殊的recurrent。

Neural network，叫做groove，叫做或者叫做gated recurrent unit，然后呢当你跑完这个gated recurrent unit之后，你会拿到一个vector。

这个vector c我们可以认为它表示了整一段啊，整一段话里面的信息，然后呢我们再用这个vector c1步一步的啊，做这个trans，把它把它传到这个呃。

decoder就是第二个recurrent neural network里面，这个recurrent neural network的功能呢，是把一段话翻译成啊，把一段话解码成英文。

然后我们就拿到这样一个encoder decoder模型，啊这个模型大家有没有什么问题，我们啊我们只是很快的回顾一下这个模型，一会儿我们会实现一下，这个模型可能会跟他稍微有点出入。

然后他的训练呢也是采用cross centrplos，跟语言模型非常类似，因为我们几乎可以认为这个模型它就是一个啊，就是一个语言模型，唯一的区别，它是conditioned on这个vector c。

然后做了一个语言模型，那后来呢，在2015年还是2014年底的时候，这个but now它发了一篇文章，是在这个模型的基础上加了一个attention机制，用它来做这个机器翻译。

然后发现有了这个更好的效果，那他跟之前的那篇文章的区别呢是这个encoder，首先它是一个双向的recurrent unit，A recurrent neural network。

然后呢嗯有这个双向双向的network之后呢，他并没有只拿一个hidden vector，作为这个句子的表示，他认为这里每一个hidden vector，都都是这个句子表示的一部分。

然后他就加了一个这个叫做attention的极值，然后在解码的时候呢，我要输入的，我会把当前的context vector用一个weighted sum of the，hidden states传进去。

传到这个Y，所以就是每一个位置呢，我都我都算了一个weighted sum of the input，Hidden representations，然后把它作为解码器的一部分进行解码啊。

那怎么算这个怎么算这一个weighted sum呢，首先我们要有一个我们要知道每一个hidden vector，它有多少的weight，你怎么知道它的权重呢，它的权重是啊，用这个阿尔法IJ来表示。

我们看到这个阿尔法IG它又是一个soft max，那这个soft max是基于里面的分数，EIJ怎么知道EIJ呢，其实你只需要知道这个SI减一，跟HJ之间的关系是多少。

SI减一呢是上一个输出字符的hidden vector，那这个HJ呢是所有的encoder，The hidden states，等于说你要用这个YT减一的这个s st减一，跟每一个HG都算一个分数。

然后用它来做soft max就可以作为你的weight啊，这个是比较有名的一篇paper，就他告诉我们怎么样用在里面加retention机制，然后就用这个attention机制，来提高这个模型的效果。

那同时期呢或者稍微晚了一段时间，有一篇啊，有一篇paper叫LEON，有一篇paper是一个叫LON的人发的，他是STANFORD1D，他介绍了另外一种非常类似的做attention的方法。

那他跟前面的一个bottom of paper，唯一的区别是他介绍了几种不同的，不同的那个scoring function，我们看到这个这个weight呢也是用了这个soft max function。

所以跟前面的跟前面的button out paper几乎是一样的，它唯一的另外一个区别呢是他算hidden states的时候。

是把这个context vector跟前一个hidden state拼到一起，然后算了一个这个WC的转化，再加了个teenage，这是你新的hidden state，这个是一个微小的区别啊。

我们看到上一篇上一张slides，它这个他的hidden state呢，其实只是context vector跟这里的YT减一，然后这个LON呢他把这两个hen state拼到一起，再做了一个线性转化。

又做了一个NACTIVATION，其实就是给你这个模型稍微加了一点参数，并且呢它的scoring function用了一些其他的做法啊，一个是我们这节课会给大家用这个第二种啊。

它是一个blinear function，当然你也可以尝试用它别的方法，就一个是dot product，一个呢是把它拼到一起之后做了一个线性变化，加了个teenage。

再做了一个跟某个parameter做了一个点击，有同学问我，我有没有用过ROSA框架，我不太了解这个框架，所以我就不讲这方面内容，好那我们呃对于模型大家有没有什么问题。

因为我就简单的把这几个模型介绍到这里啊，因为我想大家是有一些深度学习的基础，所以我就不再过多的介绍了，那我们后面就开始给大家写一段代码嗯。

今天这节课的代码其实还挺挺多的，而且比较容易写错，所以我要稍微仔细一点啊，如果到时候出现了什么问题呢，同学们也不要太意外啊，那我们这节课呢就给大家尝试复现一下，这个LON的TENTION模型。

用他的这个bina function，那由于我们的数据集比较小呢，所以训练出来的模型的效果，可能并不会非常的好嗯，如果大家想要训练出一个比较好的模型呢，可以参考下面我这里附上了很多资料。

就是包括三篇论文，是我刚刚那三张slides的内容啊，我应该把第三篇放到第一个位置才对，就是这是这是最早的一篇文章，然后后面才有了巴特纳，我跟跟路网的两篇论文课件。

大家可以看这个stanford cs r s d，是那个也是这个叫卢旺的人讲的课，所以他讲了他的slide做的也是不错的，然后网上同学们可以找到一些比较好的，PYTORCH的实现。

做这个sequence to sequence，我认为最好的一段代码应该是open m，MTPY的啊，它的实现，并且大家做研究的时候，很多时候经常用open and i m TP y。

它里面是实现了各种你能见到的，sequence to sequence的模型，大家都可以用来学习，然后sequence to sequence，模型里面其实有很多别的微小的细节，我们这节课不会涉及到。

比如说beam search啊，还有一些啊别的别的一些比较细节的内容，同学们可以自己在课后再去，感兴趣的同学可以自己去学习，那我们就开始讲今天的代码，我首先呢import1些库。

然后我这里的数据预处理我都已经写好了，就我们import的库呢主要就是都是一些啊，主要是torch的这些库，然后这个NTKNLTK，我们一会儿是用来把英文做分词的啊，另外就是还有一些别的常用的库。

那我这里呢有一些呃给大家看一下这个数据啊。

如果我去啊，Pytorch，Notebook，我这里有一些数据ENCN，我给大家看一下我的def点TXT啊。

我的数据大概是长这个样子，他们。

它里面的数据的格式就是一句英文加一句中文，一句英文加一句中文，并且它是应该是一些繁体字，这个数据呢不是非常长，它的训练文件只有1万4000多句话。

所以可能不会训练出一个非常好的模型，但是还是一个也可以用它来做一些做一些实验，那我们就先把啊。

因为它是由tab隔开的，所以我先把它读进来啊，读的方法就是比较标准的套路，我们先打开这个文件，然后一行一行的读，把这一行用tab分开，然后第一句话呢是英文，所以我们用NLTK的word toise。

把它给把它给分成一个个的单词，然后我们在每句话的前面加上一个boos，表示beginning of sentence，最后加上一个EOS表示end of sentence，对中文呢我们做同样的操作。

但是中文我就不做分词了，其实同学们也可以自己尝试一下，用一些你知道的分词软件，比如说结巴作为一个分词，看看会不会使得这个模型的训练效果更好，我想应该会取得一些更好的效果，但是我当时偷了个懒。

就直接把它按照这个按照一个一个的字分开了，所以你拿到的是一个一个的字，而不是一个一个的一个词组词语，然后我们就把这个train跟deaf给读进来，然后给大家看一下这个train。

train跟def长什么样子，这个train呢首先它是它应该是一个list，然后我们看到train e m啊，每一个句子呢，大概都是每一个句子都是这样的一个list啊。

比如说how about another piece of cake，然后把它都变成了小写的单词，就是为了让单词的量不要太大，那我们有train也有啊，deaf1眼可以看一下def1N是长这个样子。

然后def cn呢是啊是这个样子，有同学说对于中文来说，词词向量好还是词向量好，一般来说肯定是词向量会稍微好一点，尤其是对我这种只有1万多个单词啊，1万多句话的训练样本来说，所以同学们可以自己尝试一下。

我这里我这里先不做演示，其实你们可以用import结巴，然后直接结巴点cut，把它给cut成一个list，然后你们就可以拿到一些词向量，应该是一个很基本的操作，但我为了防止在课上出现意外的事故。

就按照原来的方法来写，嗯那这边我们就有这个def1N和def def cn，他们是一一匹配的，那下面呢我要根据我的语言来构造一些单词表，构造单词表的做法呢，就是我要把这个句子里面的单词。

一个一个的取出来，并且数一下它出现了多少次啊，你可以用一个counter的object，来数一个单词出现了多少次，然后我们把其中最常见的一些单词留下来，作为我们的单词表啊，我在单词表示。

在这些单词之外额外加了一个叫做AK，一个叫做pad，实际上我们这节课当中不需要pad这个词，但有时候啊有时候做一些别的任务的时候，经常会需要一个pad的token，所以我也把他我也把它留下来，然后呢。

我们就用同样的function来构建中文和英文的单词表，我们可以看一下这个英文的单词表嗯，首先我们看一共有多少个单词，一共有5000多个单词，然后看一下这些单词表里面有一些什么东西啊，它有BOSES。

然后有这个句号啊，I am the to you，就这些都是高频词，然后到最后呢应该是有一些啊，这个比如说indict ark应该就是等于零，然后head应该是等于一，就有这样一些词。

然后CN呢也是一样的，你可以看一下CHINESE，它的高频词应该也是一些，比如我的你他这些是比较高频的单词，你这个是中文和英文的单词表，然后呢下面我要做的一些事情是，我要把中文和英文都转换成。

从他的单词转换成数字，因为最后我们训练的时候，我是用这些数字来做训练，就是我要把它encode成他们单词的index，所以我现在就做这一步操作，我要把这个英文的英文句子，英文单词，英文字典，中文字典。

然后我还要做一步，就是把它SBYL，为什么要thought by length呢，因为到时候训练的时候，我希望一个batch里面的句子是差不多长度的，所以我就把它sort一下，那我们看到我要死啊。

其实它的做法就是，我把这个英语句子里面的每一个句子都拿出来，并且用这个英语的字典把它给encode成它的单词，它如果不存在，那我们就把它写成零啊，这个是英语句子，然后还有这个中文的句子，然后呢。

下一步我们要做的是，把句子按照英语句子的长度做一个排序，排序的做法呢是你首先做一个sort，就是把我们的嗯把你每一个每一个句子的，我们按照这个句子的顺序啊，这个sequence x点length。

length的sequence x来做一个排序，然后呢，我们其实是把零到N减一个句子的，这个index做了一个排序，然后当你拿到这个index之后呢，我们再用这个index句子做一个排序。

因为我们到时候要把这个中文和英文，按照同样的顺序排序，这里是把中文和英文按照同样的顺序排序，然后这样排序完之后呢，你就会拿到train em跟train cn，我们可以看一下train em长什么样子。

首先它应该还是一个list，这个list还是有这么长，然后我们可以看一下，比如前十个句子，他都已经是把最短的那些英文句子放在一起了，我们注意这个二是beginning of sentence。

三是end of sentence，所以它都是由二开头，由三结尾的，那这个train train cn呢啊，就也已经被排序成你想要的样子了，然后如果你想把这些句子解码回程，它原来的样子。

我们可以用刚刚我们得到的这个in edict，这个是从index到到word的这样的一个匹配，所以你可以直接用，比如说for i in train，第零个句子，然后我们直接把它这样转回去就可以了。

这样他就会告诉你，U we learned，啊我们再看一下一是什么呢，它是yesterday weeks，Big，这些句子是不是有点，这些句子看着稍微有点奇怪，看看有没有什么，是不是有没有出什么问题。

You chinese play du，哦这边应该是用for i in train sentence，好像感觉哦这是我打错了，应该是易安，所以才会感觉这么奇怪啊，就是刚刚刚刚我把这个英文打成了中文。

所以这些句子现在都是看起来很自然的，就是run，然后goodbye这样，然后如果你想要看CN，那我们就把这两个地方都改成CN，你就看到什么，这是祝贺你啊，这是等等，所以我们可以把这个。

我们也可以把中文跟英文留着匹配的，看EMEM然后我们可以把这个K留下，解K等于二，就是啊congratulations所把print出来，点join，因为到时候我们做完了这一系列处理之后呢。

你还是会希望把这些句子打出来看一下，所以我们就先把这个步骤给做了，就是你看congratulations，然后是祝贺你，然后这里说的是weight，是等等，四是这个再见goodbye。

比如我们可以看一下第1万个，他来这里的目的是什么，For what purpose did he come here，就是这个这些都没有什么问题，我们就拿到了已经被你编码好的，英文和中文的句子。

下一步操作呢，我是要把这些句子全都分成一个一个的batch，因为当你训练的时候，你是要用一个一个的batch来做训练，那我们这里就定义一些function嗯，这个Gemini batch呢是吧。

是拿到一些一些部分，就是我们把啊，我们把一些一系列的index改成mini batch，所以其实整个function主要是在jan examples，就是你把英文跟中文的句子都传进来。

然后呢我把mini batch那些index给拿到，拿到之后呢，注意我，我把这个mini batch index，他其实就是把NN是什么东西，N传进来的，是一共有多少个句子。

然后呢我把他的index给拿到，就这样，你相当于是拿到了一个012，一直到N的N减一的这样的一个一个list，或者一个n d a ray，然后呢我把这个啊，If shuffle。

其实我应该把shuffle写成force，然后呢我们在啊就不做shuffle，然后我们把这个index in index list。

然后把这些啊index list里面的从index到index加mini batch，size的那些mini batch拿出来，这样你就可以拿到拿到一系列的mini batch。

我们可以看一下这个Gemini batch，究竟做了些什么事情啊，我直接我可以写Gemini bats，Get many batch，然后我们写一个1万啊，我写个小一点的数字，比如说100跟15。

你就可以看到它就可以把你的这个啊，把这些index都变成mini batches，你就可以拿到一个mini batch index，然后有这些mini batch index之后呢。

我们就可以拿到这个mini batch index，然后把它英文和中文都啊，英文跟中文都拿到，基本上就是这个样子，然后我们看一下，如果你把shuffle变成true会怎么样呢。

我们如果把shuffle变成true啊，那它就会稍微打乱一下嗯，其实我们应该留下这样一个打乱的句子，所以我们我们应该用这个打乱的，这样一种mini batches。

然后拿到这个mini batch之后呢，你可以用每个mini batch index把他的句子给拿到，这样就拿到了一个一个一个mini batch index，并且我把句子的长度留下。

因为到时候我们做训练的时候，需要句子的长度嗯，然后我们就把这个mini batch的，这个英文和英文的长度，中文和中文的长度都留下，这样你就拿到了这个train data跟跟deaf data。

这个时候我再给大家看一下，这个train data跟deaf变成了什么样子，比如说deaf d它变成了一个它还是一个list，但是每个list里面呢其实是一个batch。

所以如果拿你拿第零个batch出来呢，你会看到它的第一部分其实是英文，然后是英文，句子的长度都是七的长度和八的长度，因为我们已经把它按照按照长度排序过了，然后我们看到下面是中文的翻译，最后都是零。

因为它都是padding啊，我其实用AK来做padding了，但是因为我们到时候会用句子的长度，所以这个padding并不重要，你就是任何padding都可以，然后最后呢是这些中文句子的长度。

就这是一个你拿到的这个数据，数据的这个格式，然后train呢也是一样的，都是一样的格式，train跟death，好现在我们有了train和def，我们所有的东西都做完之后呢。

下面我们就可以啊用它来做一个，用它来做我们的模型训练，来构建我们的sequence to sequence模型，那我这里呢想先给大家训练一个没有attention的。

一个非常简单的encoder decoder模型，那我们想这个时候你要做什么事情，来回顾一下我们刚刚的slides。

这个encoder decoder模型，就是要把先把它给encode起来，再把它decode出去。

所以你其实只需要两个recurrent，neural network就可以了，那我们来尝试一下，把它给写出来啊，我可以先写一个class encoder，Class encoder。

And then the module，然后我们呃写这个initialized function，我们需要传递的参数呢，首先你需要知道一共有多少个单词，Vocabulary size。

然后你需要知道embedding the size，然后你需要知道encoder hidden state，需要知道encode hen st嗯，我们把它稍微简单一点，我们就需要知道这么多复杂的参数。

我们假设所有的什么embedding size啊，什么呃，Encoder hidden state，还有encoded hidden state，全都是hidden size啊。

我们把它叫做plane encoder，因为一会儿我们会训练一个，稍微复杂一点的encoder，然后我们加一个drop out，所以等于0。2，drop out是一般用在词向量的那个那个后面。

然后呢我们super plane encoder，点in it initialization，然后我们定义一个embed function等于NN点。

embedding for capsize跟hidden size好，我们再写self点N等于NN点，GP就是current neural network。

后面有hidden size跟hidden size，就是从hidden size直接传到hidden size，batch first等于true self点drop out等于N点。

Drop out，Drop out，这个就是我们的所有的模型，我们就一个一个embedding层，一个recovering neural network，再加一个drop out。

然后呢我们要定义forward forward，它需要传进来哪些参数呢，我首先需要传进来self，然后我还需要知道啊，X是我的输入的那个batch的单词，这个bash的单词呢，我们想象一下。

你要对它做一个embedding，然后再做一个recurrent neural network，第三个参数呢，我们需要知道这个batch里面，每一个句子有多少长度，因为我们最后做这个模型的时候。

我要把他最后一个hidden states取出来，作为我的context vector。

所以你需要需要知道这个句子有多长，那这里后面呢呃有一些小的技巧，就是当我跑一个recurrent neural network，然后我每个batch里面的，每一个句子的长度是不一样的，时候呢。

如果你想要拿到他的最后一个hidden vector，我们一般会做会做这样一个操作，就是你首先要把这个batch里面的，把batch里面的sequence按照长度排序，所以你就是要做一个排序。

怎么排序呢，其实在PYTORCH里面，你可以直接用length salt啊，0descending等于true，这样呢它会把你从呃descending，就是从长从长往短了牌。

然后就可以拿到sorted l和sorted index，这两个参数是什么呢，第一个是你把这些长度按照，把这些句子按照长度排序的，第二个呢你是把这些句子的index也给留下来了。

就是第一个句子本是本来的第几个句子，第二个句子是本来的第几个句子，然后呢你就要把这个句子都给它排个序，sorted等于sorted index，然后呢，这个这样呢你就把这些句子按照长度排序了。

这句子已经按照长度排序，下面呢我们就可以做embedded等于self drop out，Self embed exported，这样我们就把这些句子都embed embed，成一个个的词向量。

下一步我们就可以做这个self n了，就是我们要做self n啊，Pan embedded，但是呢这里我们又要做一步操作，因为因为我到时候，因为这些句子的长度是不一样的，这句子的长度不一样呢。

它最后一个hidden states的位置是不一样的，就如果你直接写self点IN呢，嗯这里前面比如说写out，记得，等于HIIT等于这样，这个hidden states的位置实际上是错的，为什么呢。

就是它默认会把你最后一个hidden state给留下来，但比如说我的batch size，比如说我整个batch的句子都有十个单词的长度，但我当前的句子其实只有七个单词。

那你并不希望把第十个位置取下来，而是希望把第七个位置取下来，所以说这样写呢它是有问题的，那PYTORCH提供了一个比较简单的方法，可以帮我们来处理这些啊，不同程度的问题的这个IN，你要做的事情呢。

就是用这个N点UTILS点pack headed sequence，什么叫pack padded sequence，就这些句子本来是padded，就它的长度是不定长度的啊。

我现在的作用是我要把它给pk到一起，我要把那些pad的地方给扔掉，然后呢就这是这个会导致就是这样写，写代码会保证你的PYTORCH代码比较高效，因为如果你的，如果你当前的整个batch的。

每一个句子的长度都是100，但是你其实只有七个单词，后面93部recurrent neural network都是白跑的，所以你把他pk完之后呢，他那些不会跑就会快很多，所以你可以写embedded。

然后我们把把这些length给传进来，就是你这个sorted length，必须要作为一个作为一个参数传进来，并且它还必须要求你传一个啊npd array，所以我只能这样写成一个当pad array。

然后不要忘了写batch first等于true，因为我们这里的batch first都是等于true，这样你就可以拿到啊，Heat embedded，然后这个embedded呢就已经被你pk过了。

然后我们拿到packed output，然后这个hidden呢就是正确的hidden states，就是你的句子有多长，它就拿哪个位置的hidden state，然后因为我前面已经pk过了。

所以后面我要把它pad回来，就安安点UTILS，点PAPACKED啊，这里少写了一个RN点，R n m d pack pad tacked sequence。

你看到这两个function其实只是名字换了一下，就pack padd和pad packed嗯，然后我的作用是把pout，然后写batch，first等于true，如果大家不太理解这一段代码在写什么呢。

其实你只需要知道他可以把变长度的那些，recurrent neural network给高效的处理掉啊，第二个参数我们就不需要了，因为它应该是sequence的一些长度之类的信息，那现在在做完之后呢。

嗯我注意啊，我最前面的时候把把这些句子按照长度排序了，为什么要排序，就是因为这个function，它必须要求你是传排序的句子进来啊，这一点可能是PYTORCH没没没处理好的地方。

就是他其实不应该让user做这样一些复杂的操作，但是我相信他们以后可能会把这个API给改了，但是暂时我们只能这么做，然后呢我们就是要把这个sorted index。

这个sorted index再把它排序回原来的样子，所以我们可以写sorted index，点salt啊，descending等于false，就是我们从从第零个开始往上找。

那它的啊original index我就可以把它拿去拿出来，然后呢我就把out变成out的original index点，Long，点contiguous，大家还记得contiguous。

是为了把那些不连续的内存单元给连到一起，因为我这样选取了之后，它的内存单元可能就不连续了，然后注意这个HIIT也要变成hi，最后呢我们就是要return out hiit。

HIIT呢我想把一这一层给拿出来，为什么呢，因为HIIT它的它的shape实际上是一个，我们给大家看一下PYTORCH，点OG里面的recurrent，neural network是怎样定义的。

我应该应该给大家看的是GU啊，我们给大家看一下GU究竟是怎么定义呢，因为GU它他返回值里面呢，我们看一下它的返回值啊，它的返回值有一个H0，H0。

Is of shape number of players，Train，Number of directions，chi batch乘以hidden size，所以啊他前面其实还多了一个维度。

所以我要把它的一，就表示最后一层的那一个hidden state拿出来，当然我这个模型里面一共只有一层，但是你可以想象你这个GU，如果number of layers有若干层的话呢。

那你其实是希望把最后一层的hidden state拿出来，所以我就把out跟hidden state给拿出来，那这个就是我的play encoder模型，那写完plane coder之后呢。

我还要写一个plain decoder，A class playing decoder，这个play decoder是nd module。

然后我们再写def init self for capitalize，hidden size dropout等于0。2，然后再写super plane，Decoder，Self bin it。

那我的decoder要做一件什么事情呢，我们如果再看这张图。

你就会发现decoder它实际上是，这里他有很多箭头啊，就是这个C它其实传到每一个位置里面去，但是我当时写的时候，我没有把它传到每一个位置去，但是差距应该也不会很大，就是我们可以用啊，用C把它传到。

但是我现在想临场把它给加上去，我就把这些C都传到每一个位置里面去，然后写一个写一个decoder。

那我们可以怎么写呢，呃我们首先还是要写一个in bed等于等于N点，Embedding，for capiticize和hidden size，然后我在self i m等于GW啊。

其实我现在要写两个hidden size，大hidden size，然后在batch first等于true，然后我要写一个self out，是我的output linear function。

这个linear呢应该是从从hidden size，其实也是两个hidden size，因为我是把context vector在家传到这个vocab size，这个是输出层，有同学说我有同学问了个问题。

说句子为什么要按照长度排序，这个是PC，就是这个function pack padded sequence，它必须按照要求你这个句子按照长度排序，所以并不是我想按照长度排序。

而是这个function要求你这么做啊，将来PYTORCH新版本出来之后，有可能会取消这个限制，那你就不需要你就可以把这几行代码都给删掉，就是这两行这里的三行代码，将来你有可能可以删掉。

但是现在必须要写，所以这个就暂时大家只要记住就可以了，然后我们三点drop out等于drop out，等于NN点，Drop out，Drop out。

然后再写def forward self y wlength，这个呢就是比如说你要把英文翻译成中文，你把这个中文的这些Y和y length，跟他第一个hidden state。

这个是其实是我的context vector，就是我的第一个hidden state，那我现在就可以写sorted l啊，这里其实又要做刚刚一样的操作了，就是我必须要把这些代码都拿过来。

我其实可以直接把这些代码给抄了，我先把这些代码全都给抄过来，因为它也是一个recurrent neural network，所以基本上干的事情差不多，唯一的区别你是要把这个length改成y land。

然后呢你要把sorted改成y sorted，然后in bed呢，你要把why sorted in bed啊，这个跟刚刚一样，然后另外呢注意这个地方head head也要做HD啊。

Sorted index，然后做了一个embedding，然后做完embedding之后呢，你要把也要做，刚刚我做的所有的这个packing bed的，注意，这些都是因为句子的长度不一样。

所以你才要做这样的TD啊，然后我们看看有什么要改的，就是这个embedded直接变成embedded，然后啊packed embedded是packed embedded。

然后我们再把pact embedded和head传进来，因为recurrent neural network，它如果你默认不传head呢，它就是传零向量进去，但你传head进去。

它就会把你的这个hidden state给传进去，那我们注意这里的embedded，因为我们看到刚刚这一张图片对吧。

就是我要把这个C也传到这个啊，传到每一个hidden states里面去。

所以我这里其实应该要把这个head给，can catch it到啊，in bed上面去，所以我这里可以写啊，我应该怎么做呢，head等于，hit点on squeeze0，然后我再写点expand as。

Why sorted are embedded，嗯然后我再做torch点cat，Are embedded，和这个hidden state给它拼到一起，就是我要把两个部分一起。

作为作为embedded传进去啊，这一段代码我先这么留着，但是待会如果报错了，我就不敌bug，我就直接把它删了，这里是新的embedded，然后我们把embedded传进去之后。

注意这里有hid ebpack embedded，然后我们把embedded给传进去之后呢，你就拿到packed out啊，我再把packed out拿出来之后，变成原来的out。

变成原来的out之后呢，再把它original index拿出来，然后我们再把这个original index跟out处理掉，变成一个新的out。

最后我们再把hidden state也变成原来的hidden states，的顺序，那最后呢最后我要注意一下，其实这些地方的shape我要注意把它留下来，就是这个地方。

比如说embedded shape，应该是batch size乘以LN，就是YL再乘以hidden size对吧，那这个地方呢我把它给contestant之后呢，他应该是21等size。

那这边呢呃这个out呢，因为它recurrent neural network，它是hidden size，所以它又变成BSITE乘以violence乘以hidden size。

这个hidden呢其实就是batch size乘以啊，Hidden size，注意前面还有一个一，因为我一共有一层一层的这个group，那最后这个decoder还要做一件什么事情呢。

你得把这个output给map，到他的vocabulary size上面去。

嗯然后因为这张图的关系啊，我们每次解码的时候都把C传进去，所以我要把C再跟CSLT上去。

所以我又要做一部这个很类似的事情，我得把这个out，把这个out跟跟这个音，把这个out和这个hidden state拼到一起嗯，这个HD其实这个HD的名字变了。

所以我应该把这个HIIT改成叫做new hit，所以我把这个HIIT改成new hi，这样就没有问题，那这样我就把原来的这个head拼到这个out上面去，最后呢我再转一个做一个linear的变换。

我写out等于self点out，我想把alt名字改成FC，这样表示fully connected layer点FC，然后out，这样我拿到了一个什么什么样的形状呢，我应该拿到了一个batch size。

乘以Y乘以y length，再乘以vocabulary size，有没有问题，应该没有问题，就这样变成了vocabulary size，最后呢，最后我还想做一件事情。

我想把它做成log soft max，Log soft max，其实这个就是soft max加一个log，因为到时候我算log lost的时候，我可以直接用这个logs of math。

所以我们就把这个out传出来，然后再把new kid也传出来啊，new kid传不传开，其实都无所谓，因为到时候我们也不需要了，所以我们就还是需要的，所以我们把这个new kid给传出来。

好这样我的decoder也写完了，这里比较tricky的一点，大部分地方跟encoder差不多，比较不一样的一点呢是我把做了一些CONCINATION，这两个concatenation嗯。

因为我之前的代码不是这么写的，我有点担心他现在可能会出bug，但是我们先给他留着，然后最后我再写一个啊，Sequence to sequence model。

就是你encoder decoder都写好了，我就可以写plane seek to seek，然后我们写N点module，Deema self encoder，Decoder。

那其实我们就是写super plane sequence to sequence，Self than in it，然后写self点encoder等于encoder。

self点decoder等于decoder，就是我只需要一个encoder decoder，我的forward function呢就是要把X跟x lb，然后再把Y跟YL都放到一起。

然后我们写encoder out等于encoder out，hidden等于self点encoder xx length，然后我们再把啊在写cf点抵扣的人，decoder要传递什么呢。

就是Y等于其实就是传Y传wide length，然后再传hid，这样你就可以拿到output和HIIT对吧，最后呢我要返回一个output，啊我这里还想返回一个NB，因为到时候我们写代码。

写另一段代码的时候，这里需要返回一个attention的东西，所以我这里把NN给返回了，那这个是你的play sequence to sequence模型，那我就先写到这里。

然后我们看一下这个模型能不能被定义出来啊，基本上都写完了，那下一步呢我们就开始定义这个模型，我们首先写device，torch device啊，could的，if touch点，coda点。

Is available，就如果有哭的，那我就用KA，如果没有CUDA，那我就不用k else CPU，定义drop pos等于0。2。

然后我们有我们刚刚其实有这个dictionary the size，到时候需要留下，有这个total n total words跟cn total words，那我们就啊待会定义单词表的时候。

用这个东西，n total words跟cn total words，所以我现在可以写encoder等于claim，Encoder，vocab size等于total e n words。

是不是叫total e n words，好像1n total words，所以是e n total words，然后我的hidden size等于啊，我们把hidden size都定成100。

所以hidden size等于hidden size，然后我来drop out等于drop out，decoder等于plane，decoder啊，vocab size等于。

应该是cn total words，这是decoder的单词表，然后hidden size呢也是等于hidden size，Rop out，那我也定等于dropout，我们就用比较一致的一致的这个参数。

然后我们写一个model等于plane，Seek to seek encoder decoder，这样你就拿到了一个model，model等于model点to device，如果他是KA。

那我就变成一个CUDA的model，然后这个criterion就是这个loss，我这边定义的一个比较新起的loss啊，也不是一个很新奇的loss吧。

其实这个就是嗯其实它是一个cross entropy loss，但是呢我自己写了一个cross entropy loss，因为它上面有一个mask，所以所以我这边用mask定义了一个特别的loss。

就是他会把一些非就是mask掉的一些部分，给你忽略掉，所以我这边它的它的参数就是input target和mask，他的做法也很简单，实际上就是把input变成一个嗯。

变成一个它的长度乘以它的vocabulary size，然后呢这个targets呢就表示每一个位置，它的单词是哪一个，然后你用啊，用mask，把一些非就是非输出的那些部分给mask掉。

这个就是language criteria loss嗯，所以我们就可以写cra criterion，或者叫做loss function。

loss function等于language model criterion，为什么叫做language model criterion，大家可能会觉得比较奇怪，但是实际上实际上啊这个。

实际上这个sequence to sequence，模型的loss和language model loss是基本上是一样的，optimizer等于torch optim，点ADAM啊。

model点parameters，好，这样我就把这个模型定义，我们看看出了什么错误，他说hidden size这个参数不存在，Hidden size，应该是这个hidden size。

这边是hidden size，然后我们再看一下现在模型能不能被初始化，现在还有一些错误，他说guru is not defined，因为我忘了写一个NN点GU，NN点GU上面有没有写，上面没忘记写。

那我们再看还有没有出错，他又报了一个错，他说hidden is not defined，因为我这里少写了一个hidden size，好现在这样这个模型应该已经被定义好了，那模型被定义好了之后。

我们就可以写我们的训练代码，跟我们的测试代码，那我们先把训练代码一写，看这个程序能不能跑起来，如果要写信任代码，我们可以写death train啊，Model data number of epox。

等于默认写30个EPOX，那我们可以写for epoch in range number of epox，每个EPOX开始之前，我先写model点train表示进进入这个训练模式。

然后我们就写for iteration，我们他其实这里有啊，就是英文的这个batch，还有这个英文的长度，然后还有中文的batch，中文的长度，In enumerator，Enumerate data。

那我们就可以写啊，后面我们要做一些基本的操作，就是原来这个MBX它是一个南派array，所以我要写torch点from npm b x点，Two device，点乱，然后他的length也都是浪。

所以这里我就全都copy一下b x length，然后下面呢是把这个Y也都变成，也都变成Y，这个是length，但是我们注意这个Y的length呢，实际上是要稍微做一些改动的。

就是啊你的MBY其实它是有input和output的，就这个Y实际上它的，input其实是wide的，到第一个单词就是从BOSES前面那个单词，这个是你要你要预测的这个啊是是你的输入。

它的output呢，实际上是从你的第一个位置到最后一个位置。

什么意思呢，就是我们回到这张图啊，就是它的前面的这些单词都是当做输入，然后你要预测的其实是下一个单词，就是Y2，是最后一个YT是后面这个EOSY1，那是这个圆圈呢。

其实相当于是BOS嗯，就是我们要预测的是下一个位置，所以这边然后包括你这个y line就得给他减个一，然后为了防止有些，其实应该是不会出这个错误的，但是为了防止boss出现一些奇怪的错误。

我们把啊y length小于等于零的，全都把它变成一，就表示你至少有一个一个句子，然后我们就可以用md pride啊，这个是attention，我们现在没有attention，但是我们可以把它同时写上。

因为我这里我当时在这个model model这个地方，我永远给他返回了一个N啊，所以这个attention它其实一定是个now，我们既然可以不用管它，然后这里有n b x nb x lab啊。

b input跟MB y length length，然后我们再写nb out mask，什么是个mask呢，就是我要知道这个句子里面，究竟有哪一些是真的句子，哪些不是句子。

建一个mask的方法也很简单，我先写个a range，大家知道南派a range，我先把这个batch里面的长度，最长的那个数字给留下来，点max点item，这个是最长的长度。

然后device呢我放到device上面，这样它就出现了一些零到max长度减一的一个list，然后呢我给他前面加一个维度，None，这是表示batch size，然后小于MBY，这里后面加一个维度。

这样你就会拿到一个batch size，乘以乘以长度的这样的一个mask，这个mask呢这个mask因为他说是小于它，只要是小于这些位置，他就会给你一个大于这些位置，就会给你一个零。

然后n b out mask等于嗯n b out mask，点float，把它转换成一个float，最后我再写loss等于criterion啊，lost等于loss function啊，B pride。

然后MB out，然后是MB out，mask表示mini bashed out mask，最后呢我就可以把这个number of words给我，还要需要知道一些内容。

就number of words有多少等于等于a total，loss等于零点，然后我要把number of words加的torch点，sun啊，B y length。

就是把这些y length求个和，在求个和，就是我知道这个batch里面一共有多少个单词，然后这个total loss呢，我应该要加个loss点item乘以number of words。

这样我知道一共有多少个loss，然后total word，Number of words，就等于应该要加等number of words。

这个是我到时候要算training loss来用total loss，Total number of words，这个叫做total number of words吧，嗯后面我就是更新模型。

大家应该知道更新模型的主要方法就是，Optimizer zero grade，然后loss点backward，然后写个optimizer点step就可以了。

注意写recurrent neural network，唯一需要注意的一点是，你要做一个gradient clipping unties，点to lip grade nm，就是为了防止它的模型的啊。

模型的这个gradient太大，所以你就把把它clip掉，那我们再写一下，if iteration除以100等于零呢，我们就写个print epoch啊，是epoch，Iteration。

Iteration，Loss lost，点IDO，然后我们在每一个epoch，都给他打一些信息出来，Print epoch，Epoch，然后我们再写training loss。

Total loss to total number of words，这就是你的loss，然后我们看一下这个，这样可以训练，我不确定有没有写出什么bug来，但是我们先尝试一下train model。

train data啊，Number of epox，就number of epox，先写个等于二吧，啊果然有一些bug，我们看这是什么bug。

他说这里少写了一个uh take four positional actors，我觉得我可能是这边少写了一个self，然后我们看一下能不能跑起来还是有错，现在这现在的错是好吧。

我最讨厌的就是这个这个错误，这个错误是ka device side triggered，就应该是某一个地方index出错了，一般这个错误啊，就这种错误其实很难debug，因为你看不出来错的错是什么。

但是我知道一般来说是index超出了范围，然后他告诉你出错的地方是在啊encoder xx l，然后是啊，在这个地方出错了，我想先尝试一下吧，把这些二乘以什么地方都给它去掉。

因为有可能是因为这些部分出错，所以我先把这个地方给删了，看看能不能啊，然后我再run all看看能不能跑起来，嗯他还是device side，Device side，这个这个问题啊。

不太确定具体是出了什么问题啊，但是我在课上也不太想再重新debug，所以我就直接把我之前写好的代码copy过来，然后啊我们就让这个科技是能往下讲下去，但是啊这个代码呢，基本上大家应该已经啊看着我。

看着我把这些代码给过了一遍，应该是应该是我在某一个地方，打错了一些一些小细节，但是它出现了这样一个bug，不太好debug，我就不再花时间去写稿了，我直接把我之前写好的代码给copy过来就可以了。

这里有一个encoder，有一个decoder，有encoder decoder，然后有这个plain sequence to sequence，并且呢。

我原来代码里面还有这样的一个translate function，这个translate做的是什么呢，它就是你把你给我传一个hidden state进来，然后我能够啊。

就是你给我传X跟x length进来，并且给我传这个Y的第一个单词，Y的第一个单词一般是BOS，然后我就可以给你进入一个循环，然后不断的用decoder来做decode。

然后把这个hidden state留下来，然后预测一个Y，然后再用这个Y预测下一个单词啊，就这是一个预测的模型，Sorry，我应该把run on，然后我们看一下现在这个模型能不能跑起来啊。

现在错误是nb out is not defined，至少现在错了一个跟之前不一样的错误，那我们的nb out是因为nb output，我们看一下，现在是number of words。

Reference，Number of words，应该是total number of number of words吗，应该是number of words等于，然后我们看一下。

现在出的错误是playing sequence to sequence，Has no parameter，这里应该应该是parameters对吧，好那我们看到这个模型已经可以开始训练起来。

我只训练了两个epoch嗯，但是我们现在稍微多训练，多训练几个epoch，然后我让大家看一下，这个模型究竟干了干了些什么事情，我们训练20个epoch，然后然后你如果没有问题的话。

你应该会看到这个loss，Sorry，这里应该写20，你会看到这个loss应该会往下降嗯，但是我现在还没有evaluate，实际上我可以把，就是我没有在def上面做evaluation。

所以你其实并不知道，他在DEV上面的效果怎么样，所以我们现在这里再写一段代码，叫做def啊，叫做evaluate，evaluate做什么事情呢，evaluate实际上就是你不需要知道多少个by。

多少个epoch，因为你只需要一个epoch就够了，然后呢你希望把这个train改成evaluation，并且你希望啊我们我们这里就不需要这些地方，也不需要更新这个模型。

但是你还是需要知道total number of words，跟total total loss还有一个区别呢，你要写with torch，No grade，因为你不需要更新模型。

所以你不需要知道gradient，那我们再把它indent一下，这个就是你的evaluate evaluate的代码，然后我们可以在train的每一个epoch后面嗯。

每过几个epoch evaluate一下，我们可以写if epoch divided by five等于零，你就evaluate一下model跟div data，然后我们重新训练一把这个模型。

先把160给sorry，Sorry，这个是train啊，我们先把160给跑上，然后我们再开始训练这个模型啊，我看出了什么问题，E park is not defined。

就是因为我们这里不需要知道epoch，我只需要知道这是evaluation loss，然后我们重新定义，重新定义一个模型，然后开始train这个模型啊，你就看到这个evaluation loss。

它从4。8，然后后面一直会往下降，同学们可以呃，如果想要休息的话，可以休息一下，我会继续在这里讲课，但是我觉得大家可能有点累啊，而且而且我确实写了很多代码，这这这一块地方。

我们会看到这个loss一直往下降下来，Evaluation loss，但是evaluation loss，eventually应该会降不下来，然后呢，我们可以把我们可以让它随便翻译一个句子，看一看。

就如果你现在想要翻译一个句子出来，看看它长什么样子呢，我们可以简单的写一个，简单简单的写一个句子出来，我们可以随便拿一些160sentence出来，就比如说我们可以从def里面。

def里面随便拿一个句子，比如说def延龄，这是一个句子对吧，这个句子我们前面已经讲过，如果你想把它变成一个句子，你可以写um in e n d t i for i in啊，我不写，我不写I吧。

我写word w表示word，那你这是我们的EMS等于点join，这是一个一个em sentence，然后我们可以print english sentence，好然后呢。

我们可以再把再把它的中文句子给找出来，你叫它cn sentence a def cn cn，然后我们可以在print一下啊，点join cn sentence，这样你就可以拿到中文的句子。

然后我们可以再把他的这个，把刚刚我们的sent给拿出来，说是def0，这是我们这是我们要的那个句子，然后我们的我们可以把它变成我们的B，X等于tn等于零，你可以写torch点from npine。

这样你就拿到了一个句子，然后我们可以把它写成M，啊reshape1一点，Long，点出device，这样就可以把它变成我们的啊，变成我们要传入模型的这些这些内容。

然后我们MB length是表示这个句子的长度，那我们可以把它的长度也给他留下来，它的长度应该就是def0的length对吧，def0的length，然后外面要给它包一层，这个表示batch size。

然后我就可以写translation等于translation，attention等于model点，Translate nb x nb x lab，然后我要把boos传进去。

注意boo s token呢，我可以直接写torch tensor啊，Dict，点get cn dict的BOS，这就是我的b o s token，然后我们再写它点long，点two device。

然后我们再写啊，注意这个translation出来它是一些index，所以我可以写translation等于啊，For i in translation，点data，点CPU，点number派。

点reshape-1，然后我写e n in cn，Dict i，这个就是我的translation，然后我可以直接print一下这个translation，我们看一下啊，这里出现了一个问题。

Has no resha，这个是因为我的戴夫零，他不是一个南派点艾瑞，所以我必须把它变成NPYHY才可以，啊我都要把这些外面一定要加上囊派点2R，然后你就看到啊，他出来其实有点奇怪，他说四处看看。

他翻译成了下雪了，但是我们可以把你看到后面有很多的EOS，其实碰到EOS之后，我就可以停下来了，所以我可以写trans等于等于一个list，然后可以写forward in translation。

嗯if word不等于US的，我们就把trans点append word，else呢我直接break掉，然后我再print点join，Trance，这样我们看一下，就是他四处看看，现在翻译全都看起来。

好像还好像还比较有道理啊，我们可以把它translate更多的句子来看一下，我们可以写写一个function deaf，translate deaf表示translate第二个句子。

然后我把这里所有的零都换成第二个句子嗯，零都换成I，还有哪个地方要换成I，这个地方这个地方都要换成I，然后我们来看一下，如果我写translate，比如说第二个句子啊，Translate death。

第二个句子他就会告诉你继续努力，他给你翻译了一个继续，第三个呢他说拿走吧，他说别人第五个，他说快点快要一点，就是你看看着感觉好像还还可以，我感觉还可以，我可以写个for loop。

For i in range，比如说100~120，然后我translate第二个句子，他说啊，我这里在print空格一下，我们可以看一下，就是你的皮肤真好，你有很好，你不分正确，你是个好人。

每个人都佩服他的勇气，他的分数就是，他好像有几个句子翻译的其实还可以，但大部分句子翻译的都有点奇怪，有人在看着你的眼睛是你的，就是有人在看着你，他把看翻译成了眼睛，我喜欢流行音乐，我喜欢电视。

他们没有孩子，他们不喜欢，就是这个是一个一个简单的爱爱，能encoder decoder可以翻译出的一个模型，然后我们把我们刚刚删掉的那个部分，再给它加上去，看看能不能好一点。

就是我刚刚一直想把那个concatenation给加上去，对吧，就是我想我想做的一件事情，是我一直想把这个why sorted，why sorted等于touch点，Cat。

why sorted跟这个HD，嗯对就是我想把他这个hidden，Yeah，Expand as why sorted，第一个位置，这个是y sorted，我想把它can catch。

把把它跟这个hidden state can catch到一起，然后out呢我也想把它跟hiit can catch到一起，output等于，然后我说我要把这个head全都变成new hi。

然后我想把output变成torch cat output，Kid，点expand as output，然后再把它第一个维度加上来，然后我想把这个hidden hidden size全都变成二乘以。

Hidden size，让我们看一下，这样能不能让模型效果变得更好一些，当然我们现在其实评估不了模型的效果，因为完全是我现在完全是在靠肉眼看这个模型，并没有太多的，我们看一下现在出了什么错。

应该是一些shape上面的错误，他说是六十四十七，就是这个问题是我应该把它，我的shape出了一些问题，为什么shape会出问题呢，因为这个地方我要把他的，我应该要把它给点transpose。

一零我给他transpose一下，应该应该就可以把把这个bug fix掉，然后现在的错误是他说，Transpose，Take two positional transpose。

我刚刚多打了一个parameter，这个transpose是不需要传，第二个位置进来了，我应该多传了一个transpose parameter给他，这边是一零，好吧，我有点想放弃这个部分。

Input size for you must be equal to，这个是在哪个地方出错的，就是我现在如果暂时fix不了，我们就忘掉这个部分，因为啊我知道这里的head出现。

这里的head错在哪里了，但是我想我们就先不管它了，因为因为这个并不是非常的关键，只是只是我想本来想照样复现，那个QM用错的代码，但是我们其实并不一定，完全要按照他的模型来做，因为我们我们刚刚这个模型。

基本上也已经可以work了，所以我们就可以满足了，就用刚刚的这个模型来来作为我们的，作为我们的baseline，就是可以直接一个一个直接的简单的encoder，decoder模型来做这个事情。

我就发现他嗯你训练的时候，如果能看到这个loss降下去，并且它翻译出来的句子是比较像样的，大概率就应该没有什么问题，然后你可以啊，因为我们的句子数量比较少，所以它翻译出来的这个效果不是非常的好。

但是如果你的训练数据够大，然后训练的时间够长的话，其实一般的这些translation的模型，训练的时间花的是很长的，一般做一次实验可能要花两个星期左右，就如果你有一张GPU。

你要训练出一个就是像比如说google，比如说像google translation那种效果的一个模型，你可能得花两三个星期左右才能训练出来嗯，像我们这种一分钟训练出来的模型，大概就长这个样子。

然后有很多cory kiss会take不了，同学们有没有什么问题，因为我知道我刚刚讲了很多东西，可能有的同学已经有点混乱了，我们休息啊，休息8分钟时间，然后在这个过程中，同学们有任何问题。

我都会坐在这里跟大家回答一下，然后我会带着这个，我会用这些时间简单再给大家看一下这个代码，其实这个这个模型呢，同学们不知道loss function是怎么定义的。

我来给大家解释一下loss function，首先这个loss function做了一件什么事情呢，它其实就是个mask的cross entropy loss。

所以你可以认为它是个cross entropy loss，只是加了一个mask，为什么我是怎么样加mask的呢，首先input的shape是什么样子，input它是一个batch size乘以啊。

sequence length乘以啊，Vocabulary size，然后呢我直接给他view乘-1vocabulary size，所以就会把前面两个地方直接拼起来，变成vocabulary size。

然后呢output呢，这个target呢实际上它是batch size乘以一，这个一是哪来的，一就是表示是第几个位置的index呃，就是第几个单词，然后呢我用这个gather这个function呢。

它可以直接把啊，input里面的某一个特定的那一个loss，给那个log probability给取出来，因为我前面算output的时候，我算了个log soft max。

所以这个log soft max就是你要算的这个log loss，我们一般其实这个log loss或者negative log loss，或者说什么啊，Negative log likelihood。

就这些loss其实都是一个loss，包括cross entropy loss，Cross entropy loss，大家知道entropy是P乘以log那个什么Q，所以它其实也是个log loss。

所以这些都是一个loss，然后呢我只是把这些loss都取出来之后，乘上的一个mask，就是把mask的位置给max掉啊，干的就是这样的一件事情，然后还有还有一个同学问说。

encoder的输出有一个output，还有一个hidden，对，为什么我要输出hidden呢，嗯大家知道这个encoder的这个out跟HIIT，究竟有什么区别呢，啊我这边看GU的时候。

你们看到这个output实际上它是of shape sequence，length乘以batch size乘以number of directions乘以hien size，当然我是在batch在前面。

所以你拿到的是batch size乘以sequence less，乘以最顶上那一层，什么意思呢，就是当你跑一个RN的时候，他的第一个输出其实是最顶层的。

所有的输出就是最顶层每一个那些output vector，HM呢，它表示的是最后一个最后一个hit state，就是比如说你的长度应该是sequence lc长度。

它是把最后一个hidden state给拿下来了，并且这个hidden states它是有number of layers，乘以number of directions。

就比如说你的你一共有五层LSTM呢，他会拿到五层的这个hidden state，但是你这个output呢，它永远只把最上面那一层拿下来了，并且把每一个位置都取出来了。

而这个h m net只把最后一个hidden state留下了，然后同学们encoder的输出有个output，还有个hidden，hidden的维度是多少，是最后一层的hidden。

还是每个IN的hidden，是其实是每个rand hidden，但是呢我在输出的时候，我只把最上面一层能给取出来，所以这个hidden的最后一个就是，如果你写HM的一呢。

其实应该跟output的一是一样的，在我们这个特定的情况下，所以我在这里啊，我不做这个实验了，但是如果你直接把out out的那个一给拿出来，应该是同一个东西啊，你让我想一想，应该是这样。

这样拿到的应该是同一个东西，因为第一个是batch size，而这个hidden呢，第一个其实是hidden，表示的是layer，所以这两个应该是一样的效果，所以我们看到这个encoder呢。

实际上是个recurrent neural network，唯一fancy一点的地方是我做了一堆pack，就这个pack我觉得其实是拍拖是没设计好的地方，就他要你各种调这个pad。

有同学说为什么不用全部hidden，我们一会儿就会用全部的hidden，因为这是一个简单的recurrent neural network啊，这是一个简单的encoder decoder模型。

所以我们只用最后一个hidden states，来作为这个decoder的开头，但我们后面下半节课，我们会把所有的hidden state都用上，这个是啊，就是你需要用到attention的机制。

让我们看到decoder呢它的做decoder，它的功能就是拿到你的hidden state之后，根据你当前的hidden state，它其实跟encoder唯一的区别是。

他的hidden state是被你输入进来的，而不是一个零的hidden state，这个是decoder，然后sequence to sequence，就是把这两个模型给串起来就可以了。

好那因为时间有限，我们就赶紧开始讲下半节课的内容，那我们这里已经有了个encoder啊，我们这个encoder是可以继续拿来利用的，我们先把，把encoder给取出来，我这里再定一个encoder啊。

然后sequence to sequence，就在最后的sequence to sequence，然后我们想办法把这个模型改一下，首先我把plane给删掉，因为这是我要新定义的一个encoder。

这个encoder跟play encoder有什么区别呢，它唯一的区别是啊，我稍微写的复杂一点，就是encoder hidden state。

还有一个embedding size in bed size啊，我们有encoder hidden state，还有decoder hidden state。

所以你进来的是一个embedding size，然后再从embedding size变成encoder hidden state，然后呢我要定义一个。

然后我的这个啊recurrent neural network，要变成一个by directional recurrent，by directional等于true。

因为我现在要实现一下那个LON的那个模型，所以我要用一个directional ion，drop out还是drop out，然后我们要把self点FC呢。

应该是等于N点lr encoder hidden state，hidden size乘以二到decoder hidden size，为什么呢，因为我要把啊最后的那个hidden encode。

The hidden states，我要把它转成跟decoder hidden size相同相同，然后再传到我的decoder里面去，然后这边都是一样，没有问题啊，pack out这些都没有问题。

然后呢，因为我现在它是一个双向的recurrent neural network，所以我现在当前的hidden state应该是等于hi啊，二，因为双向呢，所以你的一表示的是一，表示的是那个反向的。

我忘了一负二哪个是反向，哪个是正向，但它表示的是复反向的最后一个hidden state，跟正向的最后一个hidden state，然后你可以写torch cat。

把这两个hidden state拼到一起，dimension等于一，这样你就可以拿到一个新的hidden state，然后我们可以写HIIT等于torch点ten h啊，self点fc he。

大家还记得这个on squeeze0。

然后把他的hit传进去，大家还记得我们这个是怎么来的吗，就是我这个LON的这张图片里面，注意这个hidden hidden size，它是把T跟HT拼到一起。

然后再乘了一个WC，再成了一个ten h，所以这里是为什么我要写tan h f c这个HT hit，然后而且HD是把两个HIIT给拼到一起，其实我还应该把一个啊。

但whatever这个是我们我们要的这个hidden hidden size啊，我们看一下这个代码有没有问题，应该应该问题不大，如果有问题，我们再回过来debug，这是我们的encoder。

然后呢我们要写我们的attention function，注意attention function干的是什么事情呢，实际上他是要做的是。

也要实现的是，我们这个就是我得把这套function都给实现出来，就这个scoring function跟这个soft max。

那我们这里就开始写一下class attention，And the module def，Init self encoder，hidden size跟decoder hidden size。

我这个attention做的事情呢，实际上就是把给我一个context vector，给我一个output的这个vector，给我一些mask，然后我要帮你把，帮你把它一个一个的位置给算出。

这个attention sun出来，那我们就可以做啊，首先还是super attention，我现在考虑我要不要写这个代码，要不我就不写了，我直接给大家讲这个代码。

因为因为我一个是我怕自己写这个代码很长，我怕里面出现bug，浪费大家的时间，另外一个呢时间也比较紧，我就直接给大家讲算了，就这个attention呢啊它的模型主要是主要是这样。

就是你有一个encoder hidden size，有一个decoder hidden size，然后你的输入呢是，你这个forward function呢是我要拿到一个output vector。

首先这个output它是batch size乘以output，length乘以decoder hidden size，然后这个context呢它其实是batch size，Context。

length和encoder hidden size，这个是哪里来的，这个其实是我刚刚encoder的时候，这个out function，这个out就是我的啊。

这个out就是我的encoder里面的output，然后我们知道他应该是啊，应该是encoder，应该是batch size乘以sequence，length乘以encoder hidden size。

这样你就可以拿到这一堆out，然后我要做的是什么呢，首先我要实现的是这个scoring function。

就是我要把每一个decoder的hidden state，跟每一个encoder的这个啊hidden state，做一个这样的scoring function。

然后我要我现在要做的是这个binia function。

你怎么实现这个百里IFUNCTION呢，实际上我的做法就是直接用这个linear in，并且把bias设成false，这样就是一个线性变换，就是不是一个fine transformation。

是一个纯的纯的一个matrix multiplication，然后我直接把这个二乘以hidden size，转成decoder hidden size。

所以你看到我直接把context变成这个context in啊，然后再用这个这个torch的这个BNN，就是batch matrix multiplication，我直接用这个output。

因为因为这是什么呢，就是我我当我做完这些，我应该把它过来，就是当我这样做完之后呢，我会把嗯就原来它是batch size乘以output，length乘以encoder hidden size。

其实是二乘以encoder hidden size，然后呢我会我会直接把它转换成decoder hidden size，用一个这样的linear变换，然后呢拿到这个之后呢，我们就可以做BM。

就是用这个用用下面这个啊，就是当你用这个output，output做乘上这个context in之后呢，他就会帮你转换成这个contact这样的一个形状，这个是怎么样转换的，我稍微跟大家讲一下。

就是这个首先我们知道context in它已经是，已经是这个shape了对吧，然后我们的context，然后这个output呢又是这样一个shape。

所以如果你写context in点transpose之后呢，如果你写点transpose之后，它的decoder hidden size会到前面来。

所以你算batch matrix multiplication之后呢，它就会变成batch size乘以乘以这个output，length乘以，乘以output length。

然后乘以这个应该是input length，Context length，就是它本来是batch size乘以啊，context lab乘以dog hidden size，这样点击完之后呢。

它就会变成batch size乘以output length，乘以context length。

这个呢就是我们我们在这张图片里面，想要拿到的这样一个啊一个matrix，因为我们知道这个score HT s，这个HT呢表示的是输出的这个输出的长度，而这个HS呢表示的是输入的长度。

所以你最终会拿到这样一个matrix，是一个输出长度乘以输入长度的matrix，然后你再对它做一个soft max。

所以我们在这里后面我就做了一个啊，点soft max dimension等于to，这样他就会把这个context less，这个第三个维度给给啊。

normalize成一个provision distribution，然后在做这个之前呢，就是必须要做一个啊，这个为什么要做mask f呢，因为有一些位置它其实不是句子，有一些位置是mask。

所以mask你必须要把那些其实不是句子的，那些其实不是单词的位置，你得给它mask成一个非常小的值，就这我这是负的啊，10万这是-100万，好像对，这是-100万，就是一个-100万呢。

就是几乎不会影响你的soft max，因为soft max它是要E的这个次方，E的这个-100万次方基本上就是个零，所以它不会影响你的soft max，然后这样我拿到了，拿到了这个content。

然后我再用这个attention去乘上这个context呢，你就会拿到waited sum of the context，就这个waited some of the context呢，就是你的啊。

就是你的新的这个context variable，然后你把context跟原来的output拼到一起，然后用这个teenage加linear out。

就是我们这里的slides里面讲到这个ten linear。

然后再做个concatenation，这样你就可以拿到啊，你想要的这个attention跟这个output，然后我快速总结一下，就这里attention究竟干了些什么事情，其实就是这这一段代码来实现的。

就是我这个slides里面要做的这个HTWA，H s，然后注意HT呢是表示output length的长度，HS呢是context of length长度，所以你其实拿到的是一个matrix。

并且前面还多了一个batch，所以你看起来代码会会非常的复杂，就是有一个batch，然后还得后面有一个output。

length和context length啊，就是用这个BM，如果你没有batch的话，那你就是一个torch点matrix motiplication，但是因为这里有一个batch。

所以你还得做个BM，然后你得把他的一些一些masking的位置，给mask掉啊，最后再做一个拼到一起之后做一个线性变换，就拿到了这个模型，然后最后呢。

我们把这个decoder也写成一个带mask的decoder，带mask decoder的，它的特殊之处在哪里呢，就是首先我们得把，首先的一个区别就是你得把这个什么in bed，Encode。

Hidden state，Decode，Hidden state，全都写上来嗯，然后把这个batch first写成true，然后注意它还是一个单向的LS单向的GROO，而不是一个双向。

然后另外一个区别呢就是写一个create mask function，就是根据X的长度跟Y的长度，建一个XL乘以YLAN的长度，就是mask of size of shape，XLN乘以YLAN。

就你得需要这样一个mask，一会用来做那个attention的操作，然后呢这个forward function呢大部分是一样的，唯一的区别就是啊，你的这个output不是像我们原来的那个output。

是直接一个就是这里的output就是你的output，但是加了这个attention之后呢，你这个output必须用这个attention function来计算。

这个attention function，就是用我原来的output sequence，跟我的context matrix来算一个算一个output，然后我们知道这个啊，刚刚有同学问说。

为什么不用全部的hidden，这个context就是全部的hidden，我们看一下这个context是从哪里来的，就是我在我在传入的时候会从啊，我会从别的地方。

就是从encoder里面把所有的hidden states都拿进来，所以我最后的这个sequence to sequence模型呢，我会把呃就这个plain sequence to sequence。

改成sequence to sequence之后呢，我会把所有的encoder output全都当做context传进去，然后length呢还是x length，然后Y呢就是还是Y的部分。

就是这个decoder的部分，就会变成是一个所有的所有的这个encoder output，而不只是把最后一个hidden传进去，当然hidden还是传进去，当做第一个hidden state。

然后我们可以看一下啊，有了这样一个模型之后，它的效果会什么样子，然后我就可以，我们这里要先定义一个模型，就是这个新的模型应该是encoder。

a embed size等于hidden size等于100啊，虽然我这里现在多了很多参数，但是我还是把这些encoder等于等于encoder market size，直接把这个。

把前面的那个模型给copy下来就可以了，主炮还是没有变，然后这里多一个in bed size，等于这个bad size，然后我们就可以写embed size等于in bed size。

然后我们的encoder hidden state等于这个，然后我们的decoder hidden state呢也等于这个，然后我们把这三个部分全都这样传进来。

注意这个decoder和encoder都不是plane的encoder，Decoder，然后sequence to sequence也不是一个plane，Sequence to sequence。

这样基本上啊我们看一下encoder hidden state，Invalid syntax，应该是我这里少加了一个逗号，Decoder is not defined，可能是我刚刚少跑的这个模块。

这样你就拿到了一个比较复杂的模型，然后我们就可以开始吹，然后然后你就会发现这个啊，这个这个其实是attention attention的encoder，decoder模型，他训练的速度应该会慢一些。

因为主要是attention的那个计算会慢一些，让我们看一下，我们一会可以再把这个translate给拿下来了，这个是前面的这个translate的模型。

然后我们这里可以再translate1些句子出来，看它会不会有更好的效果，我们这里训练了多少，我这里训练了30个epoch，我还想说，上面其实训练了20个epoch，这样好像不是很一致。

但是问题也不大嗯，差了十个亿炮可能还是有一些影响，然后我们稍微看一下，就是你部分正确，他的袋子多少时间是什么，我今晚有空啊，这个翻译的非常好，我今晚有空，这是你的书，这个也不错，他们在午餐。

然后她很美的脚，多多年轻的她会有训练，别被肤浅，有人有人看你，有人在看着你，我喜欢音乐，汤姆没有照顾孩子，汤姆在做了继续，下周下一步我做了一件事，我犯了一个错，所以这个其实也不是特别好。

但是感觉也还可以吧，然后我来看看同学们有没有什么问题，有个同学说mask到底是怎么工作的啊，如果你问的是这个是attention，这里的mask是怎么工作的呢，嗯我可以跟大家说一下。

就是我们知道你的你的context呢，首先这个context它其实是一个fetch size乘以context，length乘以二乘以hidden states对吧，但是呢这个它其实里面有好几个位置。

是mask掉的，就这context length的最后几个单词，可能不是真的单词，然后output呢它是output life，但是它也有几个位置不是output，所以当你把它乘除，当你相乘之后。

做这个batch matrix，multiplication变成batch size乘以output，length乘以应该是BTX乘以context，less乘以document乘以这个啊。

batch size乘以decoder size乘以context length呢，到底是哪个地方，我是不是讲错了，output是啊啊，我想讲的是这个就batch size，Output，Lth。

Context length，就这个部分呢实际上有好几个位置，它是它是错的，就是那些出来的数字是没有意义的，就是那个score，我希望把它mask成一个无穷小的数字。

所以我才会在这里做了一个master fill啊，就是那些那些假的位置，那些masking的位置，他应该会拿到一个零的attention score，他如果得到0detention score呢。

那你最后做这个，你做waited sum的时候，他的那些位置也会得到一些，无论是encoder还是decoder，他都会拿到一些非常小的这个权重，所以会拿到一个接近零的一个vector。

呃这个是mask，然后另外就是在decoder的时候，我要create这个mask，create mask的方法，跟刚刚那个一维mask的方法基本一样，实际上我是先建一个x max。

再建一个y mask，两个mask都建好之后呢，我把它给乘起来就好了，实际上就是这两个之中只要有一个是零的话，它就是零，所以你就把那些地方给标出来就可以了，就是你给它相乘之后。

如果有一个地方它是它是mask的话，它就会变成一个零的这样的一个mask，嗯那我要不代码部分我就讲到这里，因为啊我昨我昨天晚上，就昨天上传的代码里面有几个bug，然后我现在已经修复掉了。

我到时候会重新上传一下这个代码，然后大家可以在看着我这个代码学习一下，然后呢因为因为我前面已经讲过了，就是这个代码我会建议大家自己尝试一下，用对中文做一些分词啊，你们可以写，我来这里写一下。

就是to do尝试建议同学尝试对中文进行分词，就是我不知道这样会不会，让这个模型的效果更好，我没有做过这个实验，但是大家可以尝试分词之后试一下，能不能能不能解决它啊，能不能让模型的效果更好。

然后有同学说感觉这次代码好难理解，其实是挺难理解的，很多时候大家都不会写，就是嗯很多时候大家一般不会自己写，Sequence to sequence，因为有很多细节在里面，有很多要调的地方。

所以大家一般经常跑实验的时候，会直接用别人的代码，比如你可以用open m m t t y嗯，具体的怎么用我就不讲了，但是实际上它的这个documentation里面非常的简单。

就是你只需要把把你的输入和输出，调成他需要的格式，然后你直接用训练数据已经在已经在群里面了，你直接用他们给你要求的格式处理好之后，来来做这个训练就可以了，所以一般常用的一个是open mt。

就是我一般做各种实验，如果训练到sequence to sequence，我一般不会自己写，而是用比如OOMT的代码，或者说另外一个我还没有用过alan and lp啊，M m m n lp。

他们也提供了一些toolkit，我不确定他们有没有有没有sequence to sequence，Sequence to sequence，我的感觉是。

他们应该会有一些sequence to sequence的部分，可以帮你做这个事情，我们可以看一下他的models里面有没有sequence to。

但他有什么encoder decoders，然后有simple sequence to sequence。

就是有一些现成的代码可以直接拿来用，我没有用过NLP，但我知道他们做的很好，就是论文发了非常多，然后实现了非常多的功能，然后open n m t呢是比较常用的，常用的这些东西，然后有有同学说。

能不能提供一下做NER的代码，其实我可以上网，直接帮你们找一个比较好的open source代码，你们就直接拿人家的代码来用就行了。

一般来说我知道NNNNLP。

提供了各种你想要的功能，我怀疑他也有MER的代码，我们来看一下他有没有N1啊，Correference resolution，Encoder，Decode，Semantic passing。

一般这种什么c i f tiger，这种就是可以用来做NER的，但是可能你还要自己做一些操作，其实同学们直接上网随便搜各种代码，可以搜到很好的那种代码。

named entity recognition啊，Pytorch，一般来说你找那些大数非常高的就可以，就这个是LSTM加CRF的，我看一下他star高不高，其实100一般这种149赞的就可以啊。

这种149赞的基本上问题不大了，就是你可以可以拿来跑，就是我一般是怎么样找代码的，可以跟大家说一下，就是你上来之后先看一下这个赞数高不高，赞数够高的，一般来说就是质量还可以。

那你看一下他这个医术有没有一堆问题，如果如果比较活跃的话，一般就会比较好，然后你这些close，你就说如果你看到这里有超多的这个bug，在里面的代码，可能你到时候自己跑起来也全是bug。

如果这里的那个医术比较少的话，那可能就会比较好一些，然后你可以直接直接下载人家代码跑一下，但应该还会有更好的，因为我知道PYTORCH的tutorial里面就有个，PYTORCH的。

它的tutorial里面就有个NER的模型，就拍拖视点，OG的tutorials里面有一个NER，如果我没有记错的话，大家可以在操作上面找一下，应该会有一些NER的问题，如果不是的话。

那应该是CRF还是conditional，好吧，我可能记错了，但是我记得是看到过具体tutorial的同学，可以直接抄啊，然后现在还有什么要说的，就是这些sequence to sequence的代码。

同学们都可以看，就是如果你刚开始入门，可以看这些tutorial，然后然后我建议可以用这个open mt，点PY来做这个事情，然后NER其实还有更好的，那我觉得NER我觉得更好的实现是。

直接用ELONER，就是ELO里面我记得他有example是named entity，如果找不到的话，对他这里有一个ELO的NER实现。

但我不知道这里有个n e RL o g on net for details，所以说它这个里面也有也有NR的实现，就是ELO的效果应该是最好的，基本上除非BT，有人说。

BT的安妮亚的效果达不到paper里实现的效果，所以可能ELO是最好的啊，就是ello fighting的一个模型做NER，然后我要找一下他这个究竟在哪里，同学们可以自己去这个repository。

找一下他的NER的模型在哪里，就是应该是他在这个里面，我记得应该是有的嗯，因为有同学问到了安妮亚，我就把它写在这，对就是BT的paper里面的效果可能声声明的更好，但是据我所知。

好像大家都复现不出来那个实验，所以就可以暂时不管它，然后我们下一节课会讲一下，稍微详细的讲一讲，这个ELOBT跟g p t two这三个模型，以及以及这个阅读理解的问题，嗯啊对。

最后我们这节课还要简单的讲一讲，这个聊天机器人啊，为什么为什么把聊天机器人在这一节课讲呢，因为因为就前两年出现了很多paper，讲，怎么样用sequence to sequence模型来做聊天机器人。

然后比较有名的一篇配比较有名的一系列work呢，都是有一个叫李继伟的人发了很多paper，李他发了，他发了很多这个关于dialogue generation的paper。

这个dialogue generation呢，就他大家可以随便打开一篇，比如他引用量最高的一篇，Deep inforcement learning for dialogue generation。

这一篇文章呢，呃他的这些大部分文章的思路都是在sequence to，sequence上面做一些优化，比如说加reinforcement learning啊，加一些别的特别的reward。

用game来做啊，然后然后就可以做这些对话，但这些对话呢，实际上实际上啊都没有办法用来做产品，就是这些只能说是玩一玩这个模型，就是你真的拿来做各种任务的时候，这个模型它是不reliable的。

因为我们知道sequence to sequence，这种generation有很多randomness在里面，就是你任何事情都有可能发生，你很难control，但是不妨碍它这是一个很好很有趣的实验。

所以感兴趣的同学大家可以，我这里放了一系列的，就是大家可以去看的数据集，就有什么self dialogue，还有这个movie script，就是这个电影对白的一个CPUS。

还有you want to这个数据集稍微有点奇怪，因为全都是讨论you want to这个系统，讨论各个电脑问题的，然后还有一些同学整理的dialog datasets，同学们可以直接把它下载下来。

然后用这个sequence to sequence那个来来实现它，然后有同学问google的dialogue flow，用的什么实现方法呀，其实我也不知道，就是一些公司里面内部是怎么实现的，我也不知道。

就是我了解的东西，大部分都是通过那个网上能读到的代码去看啊，网上能读到的代码和读到的那个论文去看的，就公司里面大部分，虽然我不知道他们具体怎么实现的，但是我知道大部分的这个公司里。

实现的聊天机器人的架构跟有一个比赛。

不知道大家知不知道，叫做alexa price嗯。

这个是亚马逊每年搞的一个，做聊天机器人的比赛，然后呢他们这个做的是一个open domain，就是闲聊的机器人，他没有任何的任务，因为我们聊天机器人基本上你可以分成两类啊，就一类是有特定任务的。

比如你打个电话去餐馆订订饭嗯，订订一个饭店的位置之类的，然后呢那种是有一个特殊任务的聊天机器人，它的他的聊天内容非常局限嗯，就那种任务型的聊天机器人是一种类型。

另外一种类型它是一种open domain的，跟你随便闲扯的这种聊天机器人，但实际上他也做不到跟你很好的闲扯，所以他还是有一个限定在里面的，他总是只只是讲一些他知道的东西。

那这种聊天机器人一般是怎么做的呢，就是这张图是082018年的这个ALEXAPRISE的，这个这个冠军，他的这个架构，它的主要的做法呢就是啊分成这样几个模块，一个是就是user讲一句话进来。

这个ASR叫acoustic speech recognition，就是把你的语音翻译成文字，那翻译成文字之后呢，他就首先第一步叫做natural language understanding。

它会是一些很传统的，你可以用neural network，但是都是一些偏分类的问题，和命名实体识别的问题，他就把里面的句子的这个这个主题是什么啊，他的这个情感是什么，然后他有哪些命名实体啊，它有哪些啊。

它有哪些这个信息都给你关键词都给你抽出来，然后给你整理成一些key value pairs，然后呢传进到一个叫做dialogue management，这个dialogue management里面呢。

就是做了一些什么intense classification，就是数字，就是user，你要了解这个user到底想干什么，就他是想跟你聊这个，他是想跟你聊天呢，还是跟你提问呢，还是在想要转换一个话题呢。

还是想要让你重新重复一遍你的上一句话呢，然后呢你在这dialogue management里面呢，它留下了很多，它其实是存下了一堆你想要的关键信息。

虽然这是一个open domain dialogue chat bot啊，但是如果你想想，如果你是一个订饭店的机器人呢，它里面可能就会留下，说你你要订的饭店在哪一个地理位置，你想要定几点钟。

你想要订什么，就是你把你每收集到一个关键信息，你就存在你的这个dialogue manager里面，把这些信息给存下来，存下来之后呢，下一步再根据你，比如说你是个定犯的机器人呢。

你就会决定下一步我想要比如说咨询问这个user，要更多的信息，那你就会再进入到这个natural lank generation，这个generation呢大部分时候是template。

based和retrieval base，就是那些sequence to sequence这样的模型，在大部分的这个工业生产的环境下，其实不太用得上，因为因为做不到生成那种很自然的语言。

所以大家一般都是定义了超多template，你想你想象一下，如果我开了一家公司是google，我可以请很多人帮我写很多很多的template，就是然后然后呢就是这样，你就可以根据不同的这个intent。

根据不同的topic，根据不同的sentiment，就根据各种各样的condition，然后来给你决定你生成哪一个template，然后这个template里面呢可能有一些值是Missing的。

比如说这个用户的名字，它可能是miss掉的，但是呢你可以根据你的dialogue manager里面的信息，把这些该填的地方都填进去，然后生成一句你想要说的话，那生成出来之后呢。

你再传到这个TTS叫做的一些库存，就比如有些knowledge base啊，有一些你收集来的新闻啊，有一些额外的template，就是你可以从外面去搜，或者question answering。

它就包括这个bi的这样的一个库，能够帮你解答一些问题嗯，就这个是一般来说造的一个比较复杂的，聊天机器人的架构，就是啊如果是一般那些比较大的公司，他们的他们的做法，其实就是在这个框架上面不断的填东西。

就是你一个一个pipeline填。

然后呢你其实有很多的pipeline，这个就像就像我现在用google搜索的，比如说我说who won the world cup，2018。

他就会告诉你friends national national football team，这个是什么原因呢，是因为google背后其实有很多的pipeline，同时在处理你的这个文字。

就它有纯文本搜索，你如果拉下来有一些这种什么world cup，2018就是who one world cup的这种，就是一个纯文本的搜索，从网页里面的文字去搜，但是像像上面这种呢。

其实是另外一个pipeline，它是有一些这个question，answering component在里面，所以你做transpose呢有一个简单粗暴的做法。

也就是不停的加pipeline，你每进来一句话之后，我后面有各种不同的不同的SUBTRANSPORT，小的transport帮你处理你的语句，然后给你返回，他认为是应该返回的阈值。

然后呢你后面还可以有一个ranking model，就是把这些所有可能的回复做一个排序，把分数最高的那个排序输出来，作为你的真正的回复，因为这个是啊，设计聊天机器人的一个基本的套路。

然后讲了主要的component有这个自然语言处理，自然语言理解的一些部分，还有这个聊天内容的管理，就主要是涉及到这个聊天状态的一些存储，可以知道我之前已经聊过什么，有哪些问题是需要聊的呢。

就是用这个语言生产来提取一些句子，然后填充这个template，当然你也可以用神经网络来生成，神经网络的生成，一般来说是不那么靠谱的嗯，然后最后是对可能的回复做做一个排序。

好那这是这三个模型，这三个模块就是大家只要尤其把这个，mask的部分给搞清楚了，就没有什么问题，然后同学们知道，即使你不做这些max，肯定也能训练一个reasonable的模型。

就是因为因为那些被mask的部分，大部分都是padding，就是padding，你如果直接给他一个special token叫做padding，然后来做呢，你大概率也能训练一个可以用的模型。

但是效果会差一些，同学们自己课后都可以试一试这种，所以就如果你看不懂这个mask在做什么，你也可以把mask给扔掉，然后呢就是实际上在工作啊，或者是什么自己做项目的时候。

我不太建议同学们自己写这样一个复杂的模型，就直接用用人家开源的模型就行了，然后这个open nm t上面有很多的component啊，就这个translation，还有一些很多的细节问题我都没有提。

就同学们可以课后去学去了解一下，就是有一些常用的一些变变换，比如说有这个pointer network，大家可以自己去上网查一查，就是这个pointer network copy mechanism。

就是能够直接从原来的这个输入当中，去copy1些内容过来，就是我们可以想象它可以用在什么地方，就比如说有一些语言，有一些单词英文翻译成中文是翻译不好的，你可以直接从那个地方copy过来。

然后就这些sequence to sequence的模型，也经常被用到这些，什么文本摘要之类的问题上面，就所以这个时候用copy mechanism就非常有用，包括这个point network。

其实是跟copy mechanism非常像的一个东西，然后还有一些常用的是coverage ross，Coverage loss，就是嗯有一些东西我已经翻译过了，我不想再翻译一遍。

因为翻译的时候经常会出现重复的翻译，就有个有个单词我翻译过了，我又翻译了一遍，然后这个coverage loss，就可以保证你那个已经被翻译过的东西，尽量不会再被翻译一次。

然后还有一些常用的变化是什么呢，啊还有一些啊，我想到了可能在家，但就是这些这些内容都是我没有提到的，但是对于翻译非常关键的东西，但是一般这个比如open mt已经帮你处理好了，这个事情。

然后还有一些常用的，就是还有一些我没有讲到，就是其实有一些有confsk to seek，然后现在最火的其实是transformer模型，因为因为transformer啊，这个模型是比较好，会快很多。

然后呢尤其是因为最近BT这么成功，大家对transformer就更感兴趣了，但是transformer这个模型呢也比较难训练，就我自己训练的，我自己训练transformer的模型。

一般都会比普通的seek to seek要差一些，可能是我训练的方法不对，但是就是如果自己写的，肯定就更训练部队，就是我用后背mt做transformer的，效果也不是特别好。

但是有一个有一个模型叫做tensor to tensor，它是用猜测flow写的，就是这个这个模型你直接下载下来之后，这个代码直接下载下来，可以跑出非常好的效果。

是的就是我一般写代码都是从人家的代码上改，就是自己从头开始写的话，你可以当做一个练习，但是有时候有一些很细节的地方你可能不知道，然后你写了一点小小的问题，可能让你的模型效果变得非常差。

然后你就会怀疑是不是自己哪里写错了，可能是你没有写错，只是某一个地方一个很细节的地方，你没有注意到之类的，尤其是刚开始初学的时候，可能就可以直接直接先先用别人的代码好，那我们这节课就给大家讲到这里了。

然后我会把更新好的课件发到群里，嗯那我们就这样了。

【七月在线】NLP高端就业训练营10期 - P8：4.隐马尔可夫模型原理_ev - IT自学网100 - BV1uxT5eEEr6

好。

按照我们课表的安排，然后这一周我们用两次的时间，和大家一起学习一下两个非常重要的模型。

一马可夫模型和条件随机场，那么在开始之前呢，嗯我们先大体上了解一下这两个模型，在整个器学习方向它的一个位置啊，为什么要介绍这个内容啊，因为我们之前的课程当中，或者说我们后续的课程当中。

都会介绍到大量的模型，包括机器学习的内容，包括深度学习的内容啊，我希望大家能够理解的就在于，模型和模型之间其实有很强的这种关联关系，也就是说一个模型的工作，一定是在之前的工作的基础上。

进行了不断的改进和调优，然后呢以此为基础，可能在此基础上再改进和调优，又得到新的一些工作的成果，呃，所以说啊，这个模型和模型之间其实并不是孤立的，而是有密切联系的，那么今天我们要开始介绍的HMM和cf。

他们大体上是啊，位于我们称之为是概率图模型当中的一部分，非常重要的内容啊，概率图模型，那么这两部分这两个模型的前序工作哈，嗯会有大量的所谓的概率计算的内容啊，特别是让我们可能啊，有些同学之前了解过。

关于朴素贝叶斯的内容是吧，以此为一个基础啊，你会体会得到在这些工作当中，大量的使用到了概率计算啊，这也是我们今天非常重要的一部分内容，那么除此之外呢，我们今天在求解以马可夫模型当中的，若干问题的时候。

还会使用到期望最大啊，em算法啊，这个时候呢这个就不得不啊，再补充一些关于em算法的内容啊，当然有些同学可能说，那我可能之前比较了解，但是呢我们也做一个回顾，所以说你可以看到一个模型的内容啊。

牵扯到其他的相关的一些知识啊，也就是说在这些知识补齐之前啊，你可能对他的了解可能不是那么的充分啊，这也是啊给大家呃做一个铺垫，在以后的学习当中啊，你比如说再举一个例子啊。

可能我们可能会大家了解关于charge boost是吧，大家可以看到啊，这个工作的前序工作有非常多的工作啊，当你说啊我的前序工作不太了解的时候，我很难相信啊。

大家对charge boost本身有一个充分的理解啊，不管是在面试的过程当中啊，还是在今后的工作过程当中，可能你都需要把前期的工作有一个，相对比较充分的一个了解。

那么回到马口模型好吧，刚才也提到了，IMAX模型呢，是我们概率图模型当中的一个非常重要的工作，特别是在我们NLP方向当中啊，自然语言处理当中，在深度学习之前的呃，那个阶段，hmm和cf啊。

这两个模型可以说是起到了，非常非常重要的工作啊，当然哈啊有了深度学习以后，也不是说这两个模型就不重要了啊，后面可能大家会随着学习的深入，不断的去了解，比如说我们会把循环神经网络，作为一个特征提取器啊。

通用特征提取器在这两个模型之前，对我们的语料库做一个特征提取啊，特别是对我们的这个单词进行一个所谓的binding，就是一个向量化是吧，然后以他作为向量化之后的数据，再进行我们模型的训练，后续在挂机上。

像cf这样的模型，就是说前面是一坨LOSTM啊，或者说其他的一坨循环神经网络，做通用的特征提取，然后呢作为班里以后，然后挂上一个cf在做各种各样的这种。

各种各样的一些计算呃。

声音和视频没有问题是吗，可能我这里信号应该是没有问题啊。

如果有问题的话，我们及时这个啊反馈回来好吧。

刚才讲到哪了，讲到了这个in玛克夫模型和hmm嗯，这个和cf这两个模型，其实到了现在深度学习阶段，其实也是非常重要的工作啊，就刚才所说的前面就挂上一坨深度学习的模型。

比如说transformer bbt，各种各种各样的这种预训练模型是吧，把它们搬了以后，然后再对后面挂上一个cf啊，这是非常现代的一种范式啊，就大家都这样来做，所以呢从这个角度上去看的话。

那么大家也可以看到啊，对于这两个模型的学习，还是需要大家花一定的时间和精力，来做一个了解，那么画再往前分析，你会发现它既然是所谓的概率图模型，就需要牵扯到大量的概率计算啊。

那么概率计算呢其实你说的复杂吧，可能相对来说符号比较多一些，但是再复杂，可能也就是这两条规则的一个反复的使用啊，这两条规则啊，在我们这个概率论里面有非常呃，这个直接的一个介绍啊，我们简单回顾一下。

今天包括我们下一次上课的内容，可能大量的就是这两条基本规则的反复使用啊，刚才有同学说了，也提到了，说是推公式啊，其实在推公式的过程当中，你需要有一些依据对吧，就不能说是从A到B啊，你需要有一个支撑。

那这个所谓的依据就是一些公理定理，或者说一些假设，那么其中哈这两条规则是使用最频繁，那么其中一条呢我们把它称之为是加法规则，就是PX啊，随机变量X的边缘概率，PX只有一个随机变量，那么它等于什么。

它等于联合概率，PXY两个随机变量的联合概率，那么这个时候呢，我们需要把它在Y上进行一个全概率累加，这条规则呢其实你可以简单的理解为啊，左边是一个随机变量的概率计算啊，右边呢是两个随机变量的联合概率。

那么很显然，如果单纯从边缘概率和联，合概率的角度上去看的话，其实他俩并不相等，换句话说，本来只有一个随机变量的不确定性，这个时候呢右侧是两个随机变量，那这个时候你需要把另外一个新加入随机变量。

Y的不确定性还原掉，那这个时候我们进行一个SUV就可以了啊，当然这只是一个简单的理解啊，数学让你不能这样去证明是吧，但是呢不管怎么样，在后面的这个呃推导过程当中，但凡是看到了一个随机变量啊。

这个时候如果说哎不太好进行推导了，那这个时候你可以把它啊，通过这种加法规则的方式，把它拆成联合概率求和的形式啊，这是加法规则，那么另外一条规则是称之为乘积规则，他说的是随机变量XY的联合概率。

等于PY条件之下的X的条件概率乘以PY，那就是条件概率乘以边缘概率的形式，同样如果从单纯的从等号的左右两边去分析，我们会发现左边是联合概率，两个随机变量的联合概率，右边呢第一部分是一个条件概率。

是在Y作为一个条件已知的情况之下，随机变量X的条件概率，那么很显然单纯从联合概率，条件概率的啊分析上会发现还是不相等，不相等的，原因就在于随机变量XY是两个随机变量，而是在这个地方的条件。

概率是Y作为已知条件，被确定了以后的条件概率，那么很显然呃，随机性或者不确定性又不相等了，那不确定性的不行，消失在于这个随机变量Y是一个已知量，那这个时候我们只需要把随机变量。

Y的不确定性或者概率乘进来，又还原回两个随机变量的联合概率，好吧啊，这两条规则哈，这个你可以大体上按照上述的理解去这么想，那么用的时候呢既可以从左边到右边啊，同样也可以从右边到左边，因为它是个等式啊。

它是个等式好了，做了以上铺垫以后呢，正式的开始，我们今天的内容就是关于hmm，首先看一下定义啊，就是定义上是怎么说的，1mark模型啊，是关于时序的概率模型啊，首先呢它是一个概率模型。

会进行大量的概率计算，后面我们会体现得到更重要的，它是一个所谓的时序模型，它有一个序关系，就是前序和后序的这么一个关系，那么从这一点上呢就可以啊，能够理解到，但为什么适用于我们自然语言处理方向。

因为我们的自然语言处理一个句子是吧，一个句子，句子当中的每一个单词和每一个单词之间，是有一个前后关系的，那么这个前后关系，就可以使用我们的一马克模型来进行捕捉啊，或者说进行建模。

来分析我们整个的语料库里面的句子，句子和句子之间的这种计算关系好吧，所以它是一个时序模型啊，非常重要，它描述的是由一个乙马可夫链随机生成的，不可观测的状态序列，再由各个状态生成一个观测。

从而产生观测随机序列的一个过程，呃这这里面有很多的一些概念或者名词啊，大家需要特别特别注意，首先第一个就是所谓的呃状态序列啊，首先要你明确一马可夫模型里面，首先需要有一个状态序列。

这个状态序列有一个特点，它叫做不可观测啊，就是这个这个序列我是这个状态序列，我们是看不到的啊，或者说我们不能够直接观测到，那除了这个状态序列之外，我们还有一个序列称之为是观测序列，而这个观测序列很显然。

通过名称我们也知道它是可观测到的，那么这两个序列之间有什么关系吗，关系就在于观测序列当中的每一个观测，都是有所对应的状态所生成的，也就是说我们有两个序列，这两个序列呢一个是状态序列。

另外一个呢是观测序列，状态序列决定了观测序列，但是呢状态序列我们不可见，而观测序列是可见的，那这个时候呢这个我们需要你把它画一下图啊，就是你把它简单的会想象一下，因为是这个序列哈，所以我们往往加上箭头。

所以说你会发现这里是一个圆圈，一个圆圈对应的就是我们的状态啊，一个状态，一个状态，每一个状态，因为我们说它是序列，所以状态是有前后关系的，我们用箭头来表示这种前后关系，除了状态序列之外。

我们还有一个序列，我们称之为观测序列，注意啊，关键词序列它也是一个序列，但是我们知道观测序列的决定并不是由序列，观测序列之间来决定，而是由它所对应的状态来决定，所以说大体上。

你可以把in Mark服模型认为是这么一个结构好吧，就是以后啊你脑子里面再提到一马可夫模型，那到底这个模型长什么样，就长这样好吧，上面一个状态序列，状态序列之间是一个严格的线性关系，或者持续关系。

一个状态产生下一个状态，再产生下一个状态，才能产生这样一个状态，产生下一个状态的同时，当前这个状态又产生它所对应的观测，所以说哈，虽然说观测序列不是由前一个观测所生成的，或者决定的。

但是你会发现观测序列也是一个顺序关系啊，虽然说我们不是说是一种生成关系，但是他们也有前后的顺序，而这个前后顺序是由它所对应的状态所对应的，好吧嗯一会再说什么是一马可夫链的问题啊。

看下面要隐隐藏的马尔可夫链，随机生成的状态序列，我们把它称之为是就是状态序列，就是上面这个就是所谓的状态序列，每一个状态所生成的观测啊，而由所有观测所产生的，我们把它称之为是观测序列啊，观测序列嗯。

序列的每一个位置又可以看作是一个时刻啊，就是不管是状态也好还是观测也好，每一个位置我们都可以把它认为是一个时刻，这就是所谓的伊拉克模型，好吧，嗯有同时隐藏的就是状态不对啊，是这样看上面哦。

OK你可以这样认为啊，隐藏的是状态，就是我们的状态都是不可见的啊，倒不是一定是隐藏，因为这个地方的银码可夫模型，并不是隐藏的含义，它只是一个不可见的概念啊，后面我们会把它还原回来。

就是计算它的一些计算啊，就通过一些可见的结果去把它还原回来，那么既然有所谓的状态序列，那么状态序列的每一个状态，就有一个取值的范围或者取值的一个空间，我们把这个取值的范围呢，把它称之为状态的集合啊。

状态集合，那么状态集合呢我们用Q来进行表示啊，状态集合用Q来表示，其中呢Q1Q二一直到QN，表示所有的状态可能的取值啊，所以说你会发现Q是个集合哈，Q是个集合，这个集合里面的所有的元素或者每一个元素。

都是我们的状态可能的取值范围啊，它可以取Q1，也可能取QN啊，这是关于状态集合，有了状态集合之后呢，我们还有所谓的观测集合，观测集合用V来表示，是从V一一直到VM。

那么其中的每一个元素对应的是我们的观测啊，每一个时刻的观测可能取值的范围，观测的取值范围，注意这个地方啊，QN到VM啊，其中的Q的绝对值，对应的是我们整个状态集合中元素的个数是N。

而V的绝对值或者是范数啊，我把它称之为N等于M，是我们状观测集合里面的元素个数啊，这是两个集合啊，所以是大括号的集合，有了这两个集合以后，我们就可以构建所谓的状态序列和观测序列了。

所以你会发现状态序列被定义为I啊，状态序列被定义为I，它等于I1I2，IT一直到I大TI大T，这里注意这里的I1I二一直到I大T的下标，标明了当前每一个状态的序号啊。

或者说是前后的那个序位置的一个标识啊，I1就是第一个时刻的状态，I2是第二个时刻的状态，IT是D小T这个时刻的状态，I大T是大T这个时刻的状态，那么这个在序列当中的每一个状态。

和我们状态集合里面的每一个元素之间，什么关系呢，或者说和这个状态集合之间什么关系呢，是一个IT属于大Q这么一个关系，IT是什么T你可以认为是DT时刻，或者说任意一个时刻的状态序列当中的状态。

它是我们Q集合里面的一个元素，因为刚才我们说了，Q集合是我们的状态集合，所有的时刻的状态都取决于我们的状态集合，好吧，这应该能理解是吧，既然有了状态序列，那么就有所对应的观测序列。

观测序列呢我们用大O来表示啊，大O来表示是O一O2OT一直到O大T嗯，同样啊，这里的下标12T，一直到大T都是我们的时刻的标识，具体是哪一个时刻，第一个时刻的观测就是OED，大T个时刻的观测就是O大T。

那么同样在这个观测序列当中的，每一个观测都是我们观测集合当中的一个元素，所以说OT是属于大卫的，OT是属于大卫的，这个地方呢就有个问题啊，就一个问题，刚才我们一直在说，状态集合中的元素个数是N。

我们观测集合里面的元素个数是M，所以很显然这里的N和M是不相等的，也就是说我们状态集合里面的元素可能有多个，我们状态可以取N个状态之一呃，观测集合里面的元素有M个，所以观测呢可以取M个观测之一是吧。

但是你会发现这里的状态序列和观测序列，它的下标都是从一个大T一一直大T，那么这个地方有没有同学有困惑，为什么会这样，或者说为什么都是到大T，很显然都是从时刻一开始，这个开始应该问题都不太大是吧。

那为什么一直都是到大T这个地方比较有困惑，因为前面刚才已经说到过，在1M可夫模型当中的一个条件在于什么，就各个状态生成一个观测啊，每一个状态都对应的生成一个观测，所以说既然有大剃个官的状态。

那么每一个状态都生成它所对应的观测，所以同样那么也应该有大T1个什么观测是吧，所以说这个不要有什么这个问题是一一对应，很好啊，关于这部分模型的分析或者是介绍，有什么问题吗。

对观测序列和状态序列的长度是一致的，因为一个状态生成一个观测，一个状态生成一个观测，很显然是一一对应的，对吧啊，这个地方呢再简单说明一下啊，特别是呃很多这个同学啊，就是有些模型因为确实很复杂。

包括像后面越来越多的复杂的一些模型，有的时候很很困惑是吧，这些模型它它它怎么就啊，按照我们的程序代码就开始运算起来了，这其实我能够充分理解大家的困惑的地方，到底在哪，在哪呢，一方面我们的这个文字描述哈。

我们的文字描述和我们的这个嗯，数学符号的描述，大家特别能够把它们能够什么对应起来啊，也就是说其实哈我们的文字描述，和我们的数学符号描述其实是一回事是吧，是逻辑上是一致的，只是呢呃使用的方式不太一样啊。

我们的自然语言描述，当然就是通过文字性质对吧，一个个都没解释清楚，而数学符号的特点就在于它非常的简练，通过符号表示符的含义啊，简练的精确的把这个含义给你解释出来，但是他俩之间还是有一些呃侧重点。

或者有有有有侧重点吧，你看自然语言可能比较容易理解是吧，他就是一句话你都不把它理解起来呃，但是呢数学符号呢有的时候就不是那么的明确，问题就在于，你需要把整个数学符号当中的每一个符号。

都进行仔细的一个分析啊，比如说这里的Q到底是什么，它是个集合啊，既然是集合，我们数学上有明确的定义，它是由元素构成的是吧，但是呢元素之间是没有顺序关系的啊，它只是个集合而已，而且序列就不一样啊。

序列呢是由更强调它的顺序性，那么这个时候就需要用我们的下标，来严格的标识顺序之间的严格关系，那么这个时候每一个符号，比如说N和M，它们仅仅代表着两个不同集合里元素的个数。

而这里的T严格说明了两个序列当中所生成的，每一个状态之间的先后关系，而这里的答题，很显示整个序列当中的最后一个位置，所以说一定要把这种文字描述，和我们的符号描述之间能够相应的对应起来。

当然中间还有一个工具，就是这里的图形啊，其实你会发现加入图形以后，文字描述，数学，符号描述和图形描述，三者在逻辑上是完全一样的，你需要做的工作就在于理解文字描述啊，能够还原回我们的数学，数学符号描述。

然后呢通过一个简便的，或者说你能够形形象化的理解的图形，把它把它把它印象化好吧，这是他三个之间还是有关联的，好了，上述是我们的一马克模型，下面呢还没有完，有了这些结构以后呢，看下面。

既然我们有所谓的状态序列，既然状态和状态之间是有严格的顺序关系的，那我们就需要有一个疑问，什么疑问呢，那状态之间的转移是怎么来构建的，比如说我怎么从一个状态生成，或者跳转到下一个状态。

你这有很明显的顺序关系吗，而这些信息有所谓的状态转移矩阵来表示，他称之为是状态转移矩阵，状态转移矩阵呢，我们用A来表示这个状态转移矩阵，A当中，定义了我们任意两个状态之间的跳转关系，那下面问题就来了。

回来看一下我们的状态集合里面有多少元素，有N个元素对吧，那么A矩阵试图要记录状态集合当中，这N个元素之间任意两个之间的这种转换关系，或者说是转换规则，那下面就有一个问题，我们需要一个什么样的数据结构。

才能够保证能够把N个元素，任意两者之间的跳转关系能够建立起来，那么很显然是一个什么，很显然我们需要一个矩阵对吧，很显然是个矩阵，既然是个矩阵，我们就需要去处理两点内容，哪两点呢。

第一点就是这个矩阵的结构啊，就是这个矩阵是一个几行几列的一个矩阵，第二点才是处理这个矩阵当中，每一个位置上的那个值，所以说首先我们可以看一下状态转移矩阵，这个矩阵是一个N乘N的，这个应该没有问题对吧。

刚才已经分析了，矩阵A是要描述或者记录所有状态里面啊，我们的状态集合里面，任意两个状态之间的调整关系，所以他一定是个N号N列的啊，从一个Q1跳转到Q2Q3Q四，一直到QNQ2。

调整了Q一Q三Q41到QN对吧，所以说你会发现，很显然是N行N列的一个一个一个矩阵，那么下面一个问题啊，就是这个AIJ的问题，就是里面每一个N乘以N的矩阵，里面的这个AIJ这个元素怎么被定义的问题。

那么大家回过头来再看一下这个图啊，再看一下这个图，这个图上说的是从一个元素或者一个状态，跳转到另外一个状态，那么既然是从一个状态跳转到另外一个状态，很显然在这个跳转过程当中。

就牵扯到了一个从谁跳到谁的问题，你是从谁跳到谁，所以说你会发现这里的元素AIJ的下标，IJ很明显的是告诉我们我们在跳转过程当中，到底是从谁跳到谁，看它的具体描述啊，到底是从谁跳到谁。

AIG在T时刻处于状态QI的条件下，再T加一时刻，转移到状态QG的概率被定义为AIG，再看一下这段文字描述哈，在T时刻，那么这个T很显然是可以，在我们整个状态序列当中任意取值，所以是就意味着是任意时刻。

那么在任意时刻状态QI的条件下，再比如说啊，比如说举个例子，这是T这个T时刻，这个题时刻是处于状态QI的条件下，注意看下面的描述，在T加一时刻转移到QG，如果这个时刻是T时刻。

那么很显然下一个时刻就是所谓的T加一时刻，转移到哪个状态，转移到状态QG，那么这个时候我们用AIJ来表示，那么既然是在某一个状态条件下，跳转到另外一个状态，那么这个跳转过程很显然就是一个条件概率。

那么谁已知谁未知，刚才我们说过已知的是在T等于QI，你会发现IT第七个时刻的状态，等于QI的条件下，DT加一时刻的状态等于QG，这个条件概率被定义为是AIJ，那有了AIJ以后啊，我们再看一下下边啊。

对应一下关系，关系在于这里的I对应的是已知的IT，这里的G对应的是下一个时刻的QG啊，所以是从I跳到G啊，是从I跳到G，所以是AIG啊，这个下标很重要，顺序很重要，因为一会儿我们会会做一个公式推导。

那个推导公式啊，经常会同学就搞混了，好吧啊，这个时候你会发现，当我们有了AIJ以后，我们就可以定义任意时刻，任意一个时刻从QI跳到QG的转移概率，那么这个时候你会发现，当我们把整个Q集合当中的。

所有的元素都遍历完成以后，构建起这个A矩阵以后，那么这个A矩阵里面是不是就定义了啊，在任意时刻从一个状态跳转到另外一个状态的，什么跳转概率啊，这就是说A矩阵解决的是状态的跳转，谁跳到谁啊。

那你分析分析清楚前后关系就可以了，一定是从QI跳到QG啊，在QI已知的条件之下，我跳到QJ，所以是AIJ好吧，这个矩阵呢我们把它称之为是状态转移矩阵啊，状态转移矩阵。

既然我们说状态和状态是可以进行跳转的，那么下一个问题很显然就在刚才，我们在一马克模型介绍里面，我们还知道，当我们跳转到某一个状态以后啊，它不光是可以跳转到下一个状态，还需要根据当前这个状态生成什么。

生成一个观测对吧，在已知当前状态的条件之下，他要生成一个观测，那么这个时候很显然，马上有同样能够反映出来了，我们又需要有一个数据结构啊，用来记录所有的状态，跳转到观测的所有的可能性。

那很显然我们看一下所有的状态有N种状态啊，所有的观测有M个观测，那么这个时候我们同样是需要有一个矩阵，来记录从状态，所有的可能状态，跳转到所有的可能观测的这么一种跳转方式。

那么这个时候这个矩阵的数据结构的行和列，其实类比于我们刚才的转移矩阵，你会发现它一定是一个什么N乘M的，任意一个状态都可能跳转到M中观测里面去，那有多少个状态，N种，那一定是N乘以M的一个矩阵。

所以说啊下面一个矩阵，我们把它称之为是观测概率矩阵啊，观测概率矩阵，观测概率矩阵，它描述的是从状态生成，或者从状态跳转到观测的概率，同样刚才已经介绍了，他是个N号M列哈，N号M列。

那么里面的元素呢我们用BJK来表示，那BJK说明这是什么，BGK说明是在T时刻处于状态QI的条件下，生成观测位key的概率，再重复一遍啊，在T时刻还是任意时刻状态处于QY，在T时刻状态除以QI的条件下。

我跳转到我的观测处于什么VK，那么这个概率我们把它定义为是BJK，那么同样可以看到啊，是在第七个时刻的状态为Q的条件下，然后我跳转到相对应的T，这个时刻的观测为VK的条件，概率为BJK啊。

V b g k，那么同样当我们对这里的key和G都进行遍历，完成以后，就生成了刚才所对应的那个N行M列的矩阵，就是这里的B矩阵，观测概率矩阵B，那么这个时候大家可以看到，当我们有了这里的状态。

转移矩阵和观测概率矩阵以后，我们就能够在整个一马可夫链上啊，就在可以在整个一马可夫模型上进行跳转了，你可以看到你只要给我一个时刻T啊，当然这个时刻T是个任意时刻是吧，你给我这个任意时刻。

你所在的状态我就可以干两个事情，哪两个适配性呢，根据已知的这个QI这个状态，我就可以生成它所对应的观测，根据谁来完成，根据我们的观测概率矩阵啊，那个BGK来完成，当生成了它所对应的观测以后。

同样我可以根据当前这个时刻的状态，再根据我们的什么那个状态，转移矩阵A来生成下一个时刻的状态，那么同样这个过程我们还可以到了下一个时刻，同样来完成，因为那个T是任意时刻是吧，那到了下一个T加一时刻。

同样可以生成T加一时刻的什么观测，再根据T加10克的状态，生成T加20克的状态，那点点点啊，这个马尔可夫模型就可以生成下去，但是呢有没有同学有疑问什么疑问呃，我不知道大家玩过没玩过那个多米诺骨牌是吧。

多米诺骨牌其实有非常类似的一个过程对吧，当我们啊有一张多米诺骨牌倒下去以后啊，根据我们的这种推导的关系，它就可以生成或者推倒了下一个多米诺骨牌，但问题就在于，谁是处理第一个骨牌。

倒下去的那个上帝之手是吧，有同学问AIG里面的I取值怎么是一到M，啊这里是N啊，这是N啊，因为你只能从状态到状态跳转N，刚才我们说过说到当我们矩阵A和矩阵B以后，我们需要处理的是第一个时刻的那个状态。

生成的问题，那这个时候呢我们看下面，我们需要单独去处理一个特例，就是在时刻T等于一的时候，我们需要处于状态QI的概率，那这个时候因为这个时刻被唯一固定下来了，他就是T等于一那一个时刻。

在这一个时刻可能取值的状态，就是我们这M个状态啊，所以说它一定是一个什么结构，它一定是一个向量是吧，因为你这一个时刻被固定了啊，时间不转移了，而且呢我需要确定在第一个时刻，我所有的状态的可能性。

那么很显然是一个MV的一个向量哈，所以呢这个时候呢，我们用初始概率向量来进行描述，初始概率向量我们用派来表示，那么既然是向量里面的每一个元素，我们用pi来表示，说明的是在T等于一的一个时刻处于状态。

QI的概率啊，注意啊，这不是一个条件概率了，因为它不需要转移，他定义的就是那一个时刻，一个时刻的概率关系，所以这时候明确的表示的是我派I啊，定义的就是在第一个时刻处于相对应的状态，QI的那个概率啊。

就是用pi来表示，那这个时候呢有了我们的状态转移矩阵，A关，在概率矩阵B，和我们的这个初始概率向量派以后啊，我们的银马可夫模型在形式化上就可以定义为，lambda等于ab派啊，这是逗号。

形式上就是由三三元组组成AB和派啊，有了这三部分信息以后，你会发现整个银马克和模型当中，所有的这种信息都已经是完整的了是吧，你从派，我们刚才定义的那个初始概率向量派里面，就可以生成第一个时刻的状态。

有了第一个时刻的状态，根据我们的观测概率，矩阵B就可以生成第一个时刻的观测，再由我们的状态转移矩阵A生成，第二个时刻的状态，同样生成第二个时刻都观测依次上升下去。

我们的整个一个马克分模线就可以构建完成了。

那我看看就第一部分关于马克模型的定义部分，看看大家有什么问题吗，我再强调一点的，可能就是这两个条件概率的定义问题啊，状态转移是在IT等于QI这个状态的条件之下，我在下一个时刻跳转到QG的概率值是AI。

同样啊，这里的观测概率矩阵，也是说的是在IT这个时刻等于QG的状态，已知的条件之下，生成，它所对应的那个IOTDT时刻的观测的值为，VK的条件概率为BJK啊啊初始概率向量，就像刚才所说的。

他是第一个时刻的那个初始向量，那么大家看看这一部分有什么问题吗，定义部分，嗯是这样哈，状态是不可观测的，但是我们知道这个状态的组成就有哪些，这里的不可观测，说的是这个序列不可观测。

就是这个顺序是不知道的，但是这个组成这个序列当中的每一个元素，我们是知道的啊，就是这里的隐码和服模型啊，这个隐隐藏或者隐含的含义，说的是这个序列不可观测啊，组成序列的每一个状态的取值我们是知道的。

有同学问啊，这个派的值是怎么来的，其实这个问题啊，不光是派的值是怎么来的，你会发现这里的A的值是怎么来的，B的值是怎么来的，其实我们都没有给出明确的一个定义，只是说这个AIJBGK。

包括这里的pi是在满足条件的时候的概率，但是这个概率值是多少，我们并不知道，那这个时候就回回回回应刚才这个同学的问题，那么这些概率值到底是多少，那么这个问题交给你的话，你怎么来完成，或者你怎么去确定。

注意啊，这里的AB和派都是概率的吗，都是概率，那我们概率论里面可以告诉我们，一个很简单的处理方式，如果有足够多的数据的话，你可以用数据集的频，数据集里面的频率值来近似我们的概率值，不是不是随机初始化。

注意这里不是随机数化，是使用我们的数据集里面的频率值，来近似代替我们的概率值，或者说你的频率值就是用就是我们的概率值吗，是吧，如果说你是初随机初始化，有一种方式，你可以使用什么。

你可以使用我们的呃呃什么那个贝叶斯方式，贝叶斯一个方法是吧，你可以使用我们的数据集，在随机初始化的基础上，给他不断的增加不断的证据，新的证据啊，使这个毕业方式来趋近于我们的概率值。

这是两种这个呃很好的实现方式啊，很好的实现方式，第一种方式就是频率派，频率派就是用计数对吧，我用百分比来计数来表示我们的概率，另外呢就是我随机初始化完成以后，我通过一个贝叶斯方式。

用新的证据去不断的去调整我的这个概率值，也是一种方式，哎有同学会问啊，为什么要加状态是吧，对你为什么要搞这么一个模型啊，这是个很好的问题啊，就是嗯你讲了半天是吧，一般考试模型是这个没问题。

但为什么是这个嗯，举个例子啊，就这个银行客服模型到底到底怎么用，回到我们这个ALP方向，回到我们的NP方向，还是那个问题，你如果带着这个背景，那你觉得我们在这个NLP自然语言处理方向。

可以怎么用这个模型，嗯或者说你你你你想象一下，你你联想一下，或者你联联系一下，在我们自然语言处理方向当中有没有序列，刚才其实已经提出来了，有很多的序列关系，比如说我们的自然语言的一个句子啊。

这个句子里面的每一个单词，很显然都是一个一个的单词序列是吧，单词序列，那么有同学就会问，单词序列不就是一个序列吗，那我们这个时候啊，怎么出现这么复杂的一个所谓的你你状态序列，还有这么复杂的一个观测序列。

是这样吗，好了，除了我们说我们拿到的这个语料库里面，那个句子所组成的这个呃句子序列之外，那么你想想你还有什么样的一个序列，是你所关心的，比如说，嗯比如说啊呃我们回回回忆一下这个分词啊，我们的分词呃。

英文分词其实不是问题，因为英文里面有非常明确的那个空格对吧，作为它的单词和单词之间的一个呃，一个一个区分的标识，但是你像中文这种这种没有这种明显的词和词，之间的标识区分的这种语言当中。

分词是一个非常重要的问题，那么你联想一下，比如说有同学这个时候就会问，就会就会联想一下，比如说我们的一个一个句子是吧，我爱中国，那么我呢其实是一个名词，爱是个动词，中国其实也是一个名词。

那这个时候我们又要分词啊，分词啊，我是一个单词是吧，I是一个单词，中国是一个单词，所以说你会发现我们要如何处理，是分词任务的话，我们需要在我的后面加上一个斜杠对吧，把它分开嘛，A的后面加上一个斜杠。

这个时候中国当然自然就被分开了，你会发现这里的两个斜杠是不是也是一个什么，是不是也是一个序列，那这个时候就有了一个所谓的隐藏序列，或者和一个观测序列的问题，那谁是隐藏序列，谁是观测序列。

那么很显然我们这个句子啊，是我们可以观测到的，语料库里面实实在在存在的，它可以显示我们的观测序列，你说刚才我们那两个斜杠啊，那两个斜杠的位置是我们不知道的，我们想得到的那就是我们的隐藏序列。

所以这个时候你会发现呃分词这个问题啊，就是那个切分位置其实就是我们的隐藏序列，我们的整个句子就是我们的观测序列啊，这是我们的分词任务，还有什么，还有词性标注人物是吧，就像刚才说的，我是一个名词。

爱是个动词，中国也是个名词，那同样我们需要对它所对应的这个单词的词性，加以标注，那么同样也是两个序列，可观测和不可观测的，后面我们所解决的计算问题啊，那其实就是在解决这种带有不可观测的，这种序列的时候。

我们怎么样通过概率计算，把他们的这个最大概率计算出来的问题，好吧，那我们就继续啊，当然呃，在以上的马尔可夫模型的定义完成以后呢，呃其实已经可以计算了，但是你会发现我们碰到的最大的麻烦就在于。

单词之间的序关系是非常强的依赖关系，换句话说，我当前这个单词或者当前这个状态，不仅仅是依赖于前驱状态，因为前序状态还依赖于他的情绪状态，那么它的前驱状态，间接的也影响了它的后续的后续。

所以这个时候如果在此模型上进行计算呢，我们会进行大量的这种概率计算，那这个时候我们不得不为了便于简化，引入两个非常强的假设关系，称之为是一马可夫模型的基本假设啊，这两个基本假设呢。

第一个基本假设称之为齐次马尔科夫性假设，七次Mark分析假设都是在任意时刻T啊，在任意时刻T的状态依赖，并且只依赖于T减一时刻的状态，回到刚才那个图啊，我前面刚才说到过，因为它是一个顺序关系。

所以说啊越往后越往后的状态，影响这个状态的因素就越多，按照我们这个模型本身的定义，你会发现影响最后一个状态的，前面所有的状态都会影响到它对吧，这很显然对我们的计算有很大的麻烦。

所以说七次马尔克分析假设说的是什么，说的是状态之间的影响关系值依赖于它的前序，这一个状态和其他的状态都没有关系，这被称之为七次马克思假设啊，这个这个假设其实也也也比较呃，怎么说呢，也可以理解是吧。

也可以理解，那我看看它的形式化的定义，就像刚才我们所说的，影响当前一个时刻的状态，有很多因素包括哪些呢，可能包括IEOE啊，I252，直到IT减一，OT减一，即使当我们知道了那么多信息的时候。

作为已知条件来决定当前T时刻的状态的时候，它仅仅等于什么，仅仅等价于或者等于在T减一这个时刻，作为已知条件的情况之下，IT的条件概率啊，这对我们的计算啊，后面我们的公式推导带来很大的便利啊。

换句话说后面再说啊，带着一个很长串的已知条件的，一个什么什么条件概率的计算的时候啊，你看看是不是这里符合就七次马克分假设，注意啊，这里说的是对于状态的一致，只受限于它的前序状态啊。

这状态和状态之间的关系啊，被称之为其次马克分析假设，第二个呢我们称之为观测独立性假设，观测独立性假设说的什么意思呢，任意时刻T的观测啊，只依赖于它所对应时刻的状态啊，回到图上面，我们可以看一下。

同样按照刚才的逻辑啊，状态影生成或者影响了这里的观测，那么换句话说，观测也受他之前所有的状态和所有的，观测的影响，那这个时候呢还是很复杂，所以这个时候我们也马上做一个简化，当前时刻的观测。

当前时刻的观测，仅受它所对应时刻的状态的影响，和其他时刻的状态观测一概无关好吧，所以形式化上被定义，为什么定义为决定T时刻的观测，可能有很多的数据，包括OEIEOR一直到等等等等。

这些已知条件都已知的时候，决定了OT那么这个时候我们把问题简化一下，简化为什么简化为T时刻的观测，仅受T时刻的状态的影响，和其他的统统无关，同样在后续的公式推导过程当中啊，你会使用到这条规则好吧。

这被称之为是观测独立性假设啊，这两条假设啊完全是为了计算方便啊，没有其他的原因好了，有了前面的这些描述以后呢，我们看一下一个基本的算法，被称之为是观测序列的生成算法啊，这个这个算法没什么太大意义啊。

只是帮助我们理解一下这个模型而已啊，OK既然叫做观测序列的生成算法，很显然这个算法是为了什么生成观测序列的，换句话说观测序列是怎么被生成的，那么这个算法当中的输入，需要输入的是我们的整个页码可控模型。

lambda啊，我们的转移矩阵A，观测矩阵B和我们的初始向量派啊，啊除了模型之外，还需要一个长度T啊，你需要生成多长的一个所谓的观测序列啊，T也是我们的输入，那输出呢输出当然就是我们的观测序列了啊。

从O一一直到O打T按照长度生成就可以了，那怎么生成我们这个基本策略啊，我们那个基本策略就是根据我们的ab派里面，取生成概率最大的那个来进行我们的观测生成，因为我们知道这里的AB派都是概率。

前面两个条件概率，后面一个是一个是一个边缘概率是吧，都是变率，那我们一个基本策略，就是按照那个生成当前这个观测的，那个概率最大值来进行生成，好吧，这基本策略，那么第一步第一步是什么。

由初始概率向量派来产生我们的状态I1，注意啊，这里下标是那个一，我们前面已经讲到过，第一个状态由谁来生成，或者由谁来决定，由我们的初始概率向量P来决定，因为我们初始概率象派里面可以看一下。

他回过头来看这里的pi啊，注意啊，派是个向量，它是由派一派二一直到派大N来生成的呃，来组成的，那么其中的每一个派爱啊，生成每一个第一个时刻，可能的状态都是由概率来描述的啊。

呃比如说生成第一个时刻有三种情况，每一种情况可能是1/3，1/3，1/3，当然这个时候你就随机随机选一个呗，但是也可能是什么，也可能是不同的概率分布，那这个时候我们就按照其中I1等于QI。

那个概率最大的那个去决定当前的IE的状态，QI好吧，那么有了这个第一个时刻的状态以后，那么下面就开始进行一个什么提顿一，下面就开始设生成就可以了，怎么生成，既然有了第一个时刻的状态。

我们下一步就可以根据I1，来生成所谓的什么观测，根据谁呀，根据我们的观测概率矩阵B来生成BGK嘛，来生成所对应的OE是吧，有了IE和OE以后，那么下面有我们的I1，根据我们的状态。

转移矩阵A来生成下一个什么I2是吧，来生成I2，生成了I2以后呢，T加一啊，因为你已经到了第二个状态了吗，判断一下这里的二是不是小于你的T啊，如果小于你的T意味着你还没生成完，没生成完怎么办。

转移到第三步继续生成呗对吧，继续生成生成它所对应的观测啊，生成完观测以后再生成它所对应的状态，再判断一下是不是生成完了，还没生成完，继续生成，直到怎么样指导条件不满足，生成完了所有的观测。

整个算法就可以结束了啊，这其实这个所谓的观测序列生成算法，没有太大的啊功能性含义啊，只是为了让大家能够体会一下，整个的这个ab派的使用逻辑好吧，那这一部分应该没有什么太大问题吧。

就是两个基本假设和一个上升算法是吧，看下面好了，以上呢仅仅是铺垫啊，以上仅仅是铺垫啊，知道野马可夫模型到底是个什么东西而已，那么它的功能是什么啊，看下面这是非常重要的一点，就是这部分你其实。

今天最重要的其实是这三个问题啊，你把这三个问题弄明白了，其实你才能说把EMAKO模型理解清楚了，就是到底1max模型能够干什么，看下面解决三类问题，第一类问题呢我们把它称之为概率计算问题啊。

概率计算问题他说的是什么，当我们已知道拉姆达ab派以后啊，当我们知道了ab派以后，并且呢还知道了一个观测序列啊，并且我还知道了一个观测序列，这个时候我们可以通过概率计算，计算出在已知当前模型的条件之下。

出现当前观测的那个概率是多少啊，这是一个概率计算问题啊，他说的是模型我已经知道了啊，模型我已经知道了，这个观测序列我已经知道了，在已知模型和已知观测序列的推荐之下，我能够把在模型之下。

出现这个观测序列的概率计算出来，那么在这个计算过程当中，很显然不牵扯谁，很显然不牵扯我们的状态序列是吧，我不知道状态序列，因为状态序列是姨妈是隐藏的嘛，啊姨妈可夫模型本身所规定的。

但是你只要告诉我这里的模型啊，我就可以把出现观测的概率计算出来，当然需要说明一点的是，概率计算问题不仅仅限于这一个计算逻辑啊，或者不仅仅限于这一个计算问题，它还有大量的概率计算。

概率计算问题的含义或者意义，是为后续两个工作来提供中间计算结果的，就是说啊，其实后面两个问题，才是我们需要重点解决的问题，但是呢，后面这两个问题需要牵扯到大量的概率计算，在这大量的概率计算当中。

往往会频繁的使用到一些中间结果，而这些中间结果，就需要通过第一个问题进行解决，其中最具有代表意义的就是刚才所说的，在已知拉姆的条件之下，大O的条件概率，还有一系列的概率计算结果啊。

都是需要中间需要预处理的，好了解释，解释完这个概率计算问题以后呢，我们看下面两个问题，第二个问题呢我们把它称之为学习问题，学习问题说的是什么，学习问题说的是我已知观测序列O啊，并且我只知道观测序列五啊。

其他的我一概不知，学习就是在我们的观测序列O已知的条件之下，把那个时出现观测序列，最大概率的模型构建出来啊，这是一个很重要的一个问题是吧，再强调一下，就什么你已知什么已知观测。

就是在刚才的1max模型里面，你只能看到观测，毕竟它是观测序列嘛，你是已知的，其他的你应该不知道啊，什么A什么B什么拍你你都不知道。

就在这个基础之上啊，我们所谓的第二个学习问题，就是把出现观测序列，概率最大的那个模型找出来，构建里面的AB和派啊，这被称之为学习问题，很很很重要很重要，就是你只要观测就可以把模型搞出来，这不很厉害吗。

第三个问题，第三个问题看什么，当我已知模型并且还知道观测的时候啊，这个时候我知道了模型，知道了观测，我就可以把在当前模型和观测已知的条件之下，把那个隐藏的状态序列构建出来，当然是根据出现状态序列的概率。

最大值的约束的条件之下，把那个状态序列构建出来，看看第三个问题。

我们把它称之为预测问题，预测问题需要知道什么，需要知道观测序列，需要知道我们整个的模型，在这两个条件之下，我能够把这个状态序列能够还原回来啊，这个就更厉害了是吧，更厉害了，好了好事啊。

刚才介绍完了这三个问题啊，是三个问题，但是大家想一下它其实是一个问题，哪个问题啊，联想一下我们是NLP方向是吧，上面这这这三个问题，你怎么和你的这个资源，自然语言处理的问题当中的任务能够对应起来。

咳咳咳，其实我们刚才已经分析过这个问题了，比如说我们还是以这个词性标注问题为例，词性标注是吧，就是你给我一个句子，这个句子我需要为每一个单词，都给出他一个词性的一个标注啊，它到底是名词，形容词。

动词还是副词对吧，那这种这种问题你会发现我们只知道什么，我们只知道这里的观测序列，我们只知道观测序列就是你的语料库啊，就是你的一些文本是吧，你只知道文本通过这些已知的文本，你就可以构建什么。

构建出现当前文本的那个概率最大的模型，这个模型就是你的语言模型啊，当然这个语言模型是根据你的语料库，来进行构建的，有了观测序列，又有了你的语言模型以后，看下一个任务模型，你刚刚已经学习出来了。

观测序列是你的语料库已知的，这个时候你就可以把什么构建出来，在观测序列和模型已知之下啊，就是你的语料库和你的语言模型已知之下，把那个出现隐藏啊，出现隐藏状态的概率最大的那个状态序列，构建出来。

那你想想你这个状态序列，就以刚才我们的词性标注为例，不就是刚才你所对应的每一个单词，的词性序列吗，对吧，我爱中国，你得到的就是什么，你得到的就是名词，动词名词是吧，这就是其实啊。

当然在上述两个任务的计算过程当中，会使用到大量的中间计算，结果就是概率计算需要解决的问题，所以你会发现虽然是三个基本问题，但是其核心其实就是最后的预测问题，预测问题就是要计算的。

我这个隐藏的看不见的状态序列，而这个隐藏的状态序列需要根据什么，需要根据我的观测序列和我们的模型来构建，模型在哪儿，模型是可以根据我的观测序列来进行构建的，或者进行学习的啊。

那这个时候你会发现整个问题就退化成了什么，当我有了这个观测，我就可以计算出模型，当我有了观测模型，我就可以把那个隐藏的状态序列构建出来，而这个状态序列是我们希望得到的，另外一个序列。

这个时候你会发现整个任务退化成了，从一个序列得到另外一个序列的问题，从观测序列O得到隐藏序列I，换句话说，当你能够把你所有的问题转换成，从序列到序列的映射问题的时候。

都可以使用所谓的姨妈客户问题来进行解决，好吧，这部分有什么问题吗，嗯前向反向的意思，我们不太理解这里的前向和反向什么概念，嗯这是个好问题啊，刚才有同学说过什么，先解释一下。

这里的同学提到了所谓的二阶二阶马克思，二阶码可夫，其实就是我们的马尔可夫性啊，在这里这里有个很强的所谓其次马可福星七次，马可福星说的是，当前时刻只受上一个时刻的状态影响啊，就是说状态之间啊。

就状态我只受上一个时刻的状态，你会发现这是一个很短视的，这个呃一种一种假设是吧，我只是我的上一个时刻，至于上一个时刻之前是谁，我不关心啊，这是被称为七次或者一个一次马尔科夫性假设，刚才所说的二次呢。

就是说哎我能不能假设当前时刻，受上一个时刻和上一个时刻的时刻来决定，这被称之为是二阶马尔可夫，当然你会发现你可以构建N阶马尔可夫，当然理论上来说，恩杰马可夫模型要比，其次马可夫模型的性能要更好啊。

这是理论上没问题的，因为毕竟你你你你这个信息更充分了嘛，但是呢实践当中啊，实践当中呃，先说结论，性能上有提升，但是提升非常非常有限，换句话说，你得到的这个性能的提升的代价会很高，不经济啊。

所以说呢大约大约啊你使用七次马尔可夫假设，或者一次马尔克附加模型就足够了啊，当然你说我就是为了那小数点以后，三位的性能提升，我要用二次甚至N次的，可不可以，当然可以。

但是你的计算成本会非常非常大的增加好吧，这是个好问题啊，因为你还就是咱们还没有进入到计算过程啊，你看一下，你先体会一下在其次假设之下，我们所碰到的问题的困难程度，那么你可以联想一下，如果你N次的时候。

你的复杂程度会几何级数的增加更困难好吧，不太一样，N管模型呢是一个本身它就是个语言模型，这个语言模型呢他说的是你会发现啊，嗯我明白大家的困惑在哪，N挂模型说的是一个序列对吧，应该这个同学提到了。

除去隐藏状态嘛，他和N挂模型是不是近似了，如果说你要是硬出去了，隐藏状态。

硬出去了隐藏状态，那剩下的其实就是观测序列，那观测序列就剩下一个序列，那这个时候你会发现它就成了，序列和序列之间的关系的问题，当然你说它和n gram是不是非常类似的，其实有很多相似的技法。

但是需要大家注意的就在于，1max模型本身就是一个带着隐藏序列的模型，你把它这个特点去掉了以后，它其实就没啥意思，能明白什么意思吧，就是说一面可服模型本身需要处理的，就是序列到序列的那种映射问题啊。

他处理的就是这类问题啊，它的核心就在这儿，好吧，那我们继续好吧，那根据以上三个问题呢，我们就需要一个问题一个问题的去逐一解决啊，逐一解决，先看第一个问题，第一个问题当中啊，我们已知什么求什么。

这个时候你需要脑子里非常清楚哈，这三个问题第一个问题是模型已知的ab派，已知还知道什么观测序列一致，你要求什么，求在模型拉姆达条件之下，出现当前观测序列的概率值啊，他求的是概率啊，就在这个概率值。

那是个条件，概率是已知模型求观测的概率值，这个概率值呢首先我们需要引入另外一个量，也是个中间结果，这个中间结果呢称之为前项概率啊，前向概率先给出它的定义啊，先给出它的定义，前向概率阿尔法TI啊。

注意这是阿尔法，这不是A阿尔法TI等于什么，阿尔法TI等于他也是个概率啊，前项概率他也是个概率值啊，概率他是这个概率是哪个概率呢，是在已知拉姆达条件之下啊，O1O二一直到O小T。

并且呢在I小T等于QI的联合概率，我们用阿尔法TI来表示，再看一下这个阿尔法TI的定义，阿尔法TI是在已知模型的条件之下，O1O2O小T1，这个I小T等于QY的联合概率嗯，不知道在哪就找找图嗯。

我们知道这是I1，这是O1，点点假设这个是，ITI小T是吧，那么这个呢就是偶小T，那么阿尔法TI说的是什么，阿尔法TI说的是O一O2OO小T，并且在I小T等于QI的联合概率，就这么多东西啊。

就是O1O二一直到O小T嘛，然后呢再I小T等于QI的联合概率，有人说这个QY到底是多少啊，你先别管他到底是多少，他说的是，很显然是O1到OT以及IT等于QY啊。

这些变量啊，这些随机变量构成的一个联合概率，这个联合概率呢被定义成什么，这个联合概率被定义成是阿尔法T2，阿尔法TI看看他说的是什么，在给定模型啊，在给定模型条件之下，时刻T的部分观测序列啊。

时刻T的观测序列O一一直到OT，并且呢状态为QI的概率啊，同样是在T时刻嘛，状态为QI，所以是O一一直到OT，并且呢IT等于QI的联合概率，被定义为阿尔法，TI这个东西呢被称之为前向概率啊。

就这么这么个概率值被称之为前向概率，那这个前项概率它有什么用，看下面啊，这是重点啊，这就是个重点，咳咳前项概率的递推计算啊，前项概率递推计算，我们可以看一下，通过前向概率的定义，以及在添加概率定义之上。

我们可以推导出一个什么样的结果，而这个结果会被我们的问题的解决，带来一些什么样的帮助，好吧，后面的这些递推计算会频繁的使用到，我们前面刚介绍到的一些工具，你手头上有哪些工具，第一个工具加法规则。

成绩规则，我们前面已经补充了是吧，加法规则规则，第二个工具就是这里的七次Mark分假设和观测，独立假设，你手头上也有这些东西了是吧，看看有这些东西，你能够得到一些什么样的结论好吧。

首先看这里阿尔法TI啊，那下面的每一步每一步你从一个等号啊，左右两边怎么相等，你需要给出充分的依据是根据什么啊，左右两边才相等，那么从第一个等号开始啊，这个等号的左右两边相等是根据定义来的啊。

这不是很显然的是吧，这个定义的形式嘛，然后呢从这个等号到这个等号是怎么来的呢，是通过一个符号简化啊，两个地方做了简化，哪个地方呢，第一个，因为这里的模型已知呢是一个大前提是吧，他肯定是知道了模型。

我们才能计算这个出现当前概率的出现，当当前观测概率的概率值，所以呢后面啊这个条件就省略了啊，为了就是为了少写啊，这是第一个简化，第二个简化前面是个O1U的O小T，这里呢用O1T啊。

通过上下标来进行标识啊，一呢就是从O1开始到T呢就是到OT结束啊，所以这个是上下标来进行一个简写，但这里的IT等于QI还在这没问题吧，这个是定义这个是简写符号好了，这个这个先说明一下。

下面开始从这一步到这一步是怎么来的，你用了哪条规则啊，或者依据得到的，你看看我们分析一下，本来是从O1到OTIT等于QY的，联合概率是联合概率，这里这里有多少个变量，这里有T加一个随机变量啊。

构成的一个联合概率，把下面这个式子，下面这个式子就很麻烦了，这里多了一个SUG，从一到N求和，然后呢随机变量变成了多少，变成了IT等于QIIT等于QY的，这这里是O1到T减一，再加上个OT。

很显然把这里的TG拆成两部分，这倒也问题不大，还多了一个啊，多了一个IT减一等于QJ，从这一步到这一步是哪条规则啊，有同学们想想吧，如果你想不清楚，你可以把这里的联合概率，认为是一个随机变量啊。

当然是一个随机向量了是吧，这如果是一个随机向量的话，那很显然这就是这是一个嘛是吧，这就是一个本来只有一个，现在又多了一个对吧，多了这一个你通过一个什么形式啊，本来只有一个，你现在硬夹硬生生加上一个。

那这个时候我们可以通过概率累加，来把它的随机性去掉是吧，这套规则是用的是加法规则。

想不清楚看一眼对吧，PX等于什么，等于sum p x y啊，你加上了一个Y，这里只有一个，你加上一个随机变量，那前面你需要用sum求和。

看是不是什么东西，本来是对吧，从OE到TT，你这里呢O1到TIT都在，你增加一个IT减一，那么等于QG那前面再加上一个sum g，从一个N就可以了，那么再往下从这一步到，这一步呢我们看看啊。

更复杂了是吧，你先自己看一分钟，找找都是谁的，谁拖一拖的，嗯唉反正是挺麻烦你先自己看一分钟吧，sum求和一直在在是吧，我们就先把它管不看了，里面呢其实你会发现分成了四部分，12344个随机变量是吧。

那么这四个随机变量既然等于下面这个符号啊，等于下面这一长串，我们就需要看看都变成了谁到谁，首先可以看到啊，这个T减一到O1到OT减一在这啊，他在这IT等于IQI哦不对，IT等于QA在这，然后呢。

IT等于QA在这，好了，通过下面这个条件概率啊，你会发现上面这个联合概率的四部分，分成了两两组是吧，一组呢变成了条件，另外一组呢变成了前面的随机变量，那这个时候你会发现。

我们就可以把这两组认为是两个随机向量是吧，两个随机向量既然有了一个部分做成了条件，条件就变成了已知的量啊，已知的了，那么已知很显然和上面的联合概率就不相等了，那这个时候怎么办。

它的随机性可以通过后面这个式子，你会发现这两部分是不是都在这儿，都在这，所以这是哪条规则，这是哪个乘积规则。

再看一眼上面PXY，PXY两个随机变量的联合概率等于什么，等于其中一个作为条件以后的另外一部分X啊，这是个条件，概率再乘以十。

再乘以PY，那么同样刚才我们看到的是不是就是挪动项，当然这是四部分，我们把它两两分组是吧，一组呢作为条件，一组放在前面，既然是作为条件已知了，你需要把它还原回来，那这个时候就再乘以它就可以了。

很显然是个乘积规则是吧，看从这一步到这一步，这个式子这个式子啊，其实已经很明确的告诉我们了，这个很重要的一些信息哈，这个式子高考就这是IT减一等于QJ，这是O1到T减一，回想一下刚才的前项概率计算哈。

前项概率计算的定义，他说的是阿尔法TI等于O1到OT，然后是IT等于求I，现在我们得到了一个表达式，O1到T减一，然后呢是IT减一等于QJ上面那个图找找。

如果这是OT是T那么OT减一肯定是这个，IT减一肯定是这个，那我们现在得到了一个表达式，是不是这个东西，这一部分这一部分和刚才那一部分，你会发现都是谁啊。

是不是都是前项概率，只不过前向概率的位置不一样，我们在前面定义的是阿尔法TITTQY，你会发现这里是TT减1T减一到QG，所以不就是阿尔法T减1G吗，所以从从他到他啊，从这一步到这一步是定义啊。

定义只不过需要仔细的分析一下啊，其实就是定义，那看看从这一步到这一步是怎么来的，就是从这一步到这一步，本来前面有两项是吧，IT等于QIOT，IT等于QIOT，很显然前面没有变，但是条件部分呢原来有两项。

IT减一等于QG，这是O1到T减一哎，这里IT减一等于QJ啊，这没问题，那你后面这个条件跑哪去了，没了飞了飞哪去了，为什么能够飞飞走啊，为什么哪个同学能分析一下吗，嗯嗯他是作为条件突然被消失了是吧。

条件被消失了，我们前面有没有可借鉴或者使用的地方，很显然有啊，哪个什么，其次马克杯假设和这个棺材独立性假设，意味着什么，意味着我们看前面啊，其实后面有没有，主要看前面我们前面讲到过IT等于QI。

很显然是T1个时刻的状态，我们前面已经有要求第T个时刻的状态数，并且仅数T减一时刻的状态，所以这个条件是不能够去的，换句话说，你前面有IT，你后面这个T减一就不能去，因为后面的IT减一决定了前面的IT。

所以这个条件是不能去的，看看这里的O1到OT减一，既然IT仅受IT减一的影响，那么很显然它就不受O1的OT减一的影响，所以这个时候很显然这里的O1到OT减一，不会对这部分产生的问题。

我们看一下OTOT前面我们说过啊，观测独立性假设告诉我们，OT仅受谁的影响，gt仅受它所对应的那一时刻的IT的影响啊，很显然OT也不受你这个OE的，OT减一的影响，所以这个地方既然你这个条件不能够决定。

前面的任意一个随机变量，那你这个条件就可有可无吗，所以就没有了，所以从这一步到这一步，应用的就是我们的观测独立性假设，和我们的七次马克分假设，好吧，那继续从这一步到这一步又是怎么来的呢。

嗯这个阿尔法T减1G还在这阿尔法T1G，所以这个是照搬下来的那一部分是吧，那前面这一部分又怎么能，前面这一部分是一个，在IT减一等于QG的条件之下，IT等于QIOT的一个条件概率啊。

很显然这一部分被拆拆拆成两部分，而又被怎么拆开的，或者说又是因为什么被拆开的，嗯嗯看一下呃，首先啊可以看到啊，这里的IT减一等于QG，在这里IT减一等于QJ，和这里IT减一等于QJ都是存在的。

这个条件啊，这个条件是呃没有发生变化的啊，这个条件都没发生变化，就这样，我这，那么看前面啊，重点开始看前面，前面是由IT等于QY和OT，组成的一个联合概率，那这个时候呢从上面到这一步。

你会发现哎it到这儿来了，它的位置发生了变化啊，从联合概率的位置上跑到了什么，跑到了条件概率的位置上，前面已经讲到过啊，联合概率要拆成条件概率的形式的时候，那你后面这个IT等于QI的随机性。

你必须要把它乘回来，所以这个地方是IT等于QY，所以啊从这一步到这一步，很显然使用的是我们的成绩规则，成绩规则，然后呢继续往下吧，这一步是怎么来的呢，这里的阿尔法T减1G。

在这还在阿尔法T减1G看这个式子，这个式子是最容易出错的地方，看这里这个式子，你再仔细看看它到底讲的是什么，这个式子说的是T减一那个时刻T减一在哪，IT减一是在这等于QJITIT在哪，T在后面，谁在前。

谁在后，明显是IT减一在前，T在后是吧，谁是I16GIT等于，IIT减一等于QG，所以你会发现前序的状态决定了后续状态，这是没有问题的，那么很显然需要使用到谁，使用到那个状态转移矩阵A。

但是呢你会发现这里是谁，上一个时刻是QG，下一个时刻是QI，所以那个状态转移矩阵里面一定是什么，一定是AGI好吧，这个地方特别需要注意一下啊，很多同学有疑问，这个地方是不是印刷错误啊。

因为前面的定义都是AGI，你这什么是AI呃，前面都是AIJ，你这个地方为什么是AGAIAJI，就是因为这里的原因啊，一定要特别仔细啊，再往前那又回到刚才那个问题，这是关于OTOT仅受谁的影响。

OT仅受IT的影响，它不受你这IT减一的影响，所以你这个条件可有可无，那么变成了在IT等于QY的条件之下，OT的条件概率，这是谁啊，已知道状态求观测的概率，这不就是那个观测概率矩阵里面的B吗。

注意的是它是在T时刻等于QI啊，那所以是bi观测是谁观测是OT，所以是BIOT啊，所以说这一部分这一部分是定义啊，这一部分是定义，那这一部分使用到了我们的这个观测独立性。

假设观测独立性假设就得到了下面这个式好了，从上面到下面这这这这个推导过程啊，就得到了我们最后的这个结果啊，就得到了我们最后的结果，那么得到这个最后结果之后怎么用，或者这个最后这个结果什么含义啊。

中间这个过程哈你都可以把它去掉了啊，就可以你知道啊，或者你相信这个结果啊，或者这个最后的结果是没有问题的，那这个结果有什么用，我们看一眼，呃教科书上很少会把这个推导过程，展开来讨论啊。

都是直接给出一个阿尔法TI，等于后面这个递推式的啊，这是当年上学的时候老师留的一个，算是一个作业吧，也不是个作业，就是一个练习啊，啊目的其实也是希望和大家分享一下，就是后面的概率计算。

基本上都是需要有这么一个推导过程啊，当然你说我相信之前的工作是吧，我也不推了，当然也没问题，但是你需要了解一下整个的推导过程的，这种感觉是怎么样的啊，好吧，看一下我们得到的结果是什么。

我们得到了除了前项概率定义本身之外，的另外一个表达式对吧，另外一个表达式在得到的这个新的表达式当中，我们分析一下这里的BIOT，这里的BIOT，如果当我们已知了拉姆达的条件之下的时候。

你会发现这里的BIOT是已知的，因为我们知道了模型模型里面就有B啊，那个观测概率矩阵，那么同样这个AGI当我们已知模型的时候，AJI也是已知的啊，这个B和A都是已知条件，那看下面这个式子最重要。

下面这个式子说的是什么，下面这个说的是阿尔法T减1G阿尔法T减一，很显然是T减一时刻的前向概率，而这个前向概率出现在了，第七个时刻的前向概率里面，换句话说，当我们希望计算第T个时刻的前项概率的时候。

我们需要知道谁需要T减一时刻的前项概率，有人说这T时刻你都不知道，T减一时刻你更不知道了，如果T减一时刻不知道，那怎么办，那这个时候你会发现根据这个递推过递推公式，我是不是可以把阿尔法T减一。

写成关于阿尔法T减二的一个表达式，可以吧，好了，阿尔法T减二，你也不知道，那怎么办，那求一下阿尔法T减三吗，你还不知道阿尔法T减四吗，你还不知道，那这个时候换句话说，如果我知道了谁。

如果我知道那个阿尔法一以后，我代入阿尔法一，我就可以计算出阿尔法二，有了阿尔法，它就知道阿尔法三，有阿尔法三，我就可以计算到阿尔法T减一，有了阿尔法T减一，我就可以计算到阿尔法T是这样吧。

所以说递推公式的核心在于，我当知道了相邻两个时刻的，前项概率的关系式以后，再加上如果我知道了阿尔法一的时候，那么任意时刻的前向概率是不是也已经一致了，那么下面问题就转化成了什么。

那我能不能得到阿尔法一的问题，换句话说嗯，这个递推过程能不能计算计算出结果的问题，这是第一个问题，第二个问题，当我已知了，或者说我相信我能够计算出了，这个前行概率的时候，能够对我们有什么帮助是吧。

看下面回到我们的目标，我们的目标要干什么，不要忘初心，我们的目标是什么，我们的目标是在已知拉姆的条件之下，计算出现当前观测序列的那个概率值，按照刚才我们的简写符号，就是已知了拉姆达以后一到O大T是吧。

继续拆哎，看下面从这一步到这一步，还是刚才的符号简写啊，这个没什么太大意义，看下面从这一步到这一步的，呃依据吧，为什么，还是刚才啊，这是个O1的OTORT是一个随机变量啊，你可以认为是一个随机向量是吧。

这时候再加上一个I大T等于QI，I大T等于UY很显然他俩之间就不再相等了，多了一个随机变量嘛，那这个时候把随机变量进行全进行累加，求和就可以了，所以使用的还是什么加法规则好了，看下面这个式子啊。

看下面这个式子，下面这个式子说的是O10的O大T，在I大T等于QI的联合概率，这个式子其实就是谁根据前面的前后概率计算，这个地方是O11OTOEEO大TI，大T的QI。

所以这个地方就是阿尔法大TI阿尔法大ti，当然你前面还有前面有一个求和，这个时候你会发现哎，我们的求解目标在已知模型的条件之下出现，当前观测的这个概率计算，通过上述的计算，我们可以发现。

就是对D大T时刻的倾向概率的一个累加求和，换句话说，当我知道了阿尔法大ti的时候，那这里的P也就知道了，那阿尔法大ti怎么计算，哎我们这个地方递推公式就已经有了，阿尔法大TI。

是关于阿尔法大T减1I的一个表达式，那么刚才的递推过程告诉我们，当我们知道阿尔法一以后，就知道了阿尔法二，那么进而得到可以得到阿尔法大T，把这个阿尔法大T进行全概率求和，就可以得到这里的P5，好吧。

那下面解决了前项概率的作用啊，当它能够进行低配计算的时候，我们可以把我们的这个PO的计算，写成关于前项概率的求和的形式，那它的作用就起在这个地方，那么这个计算是关于大T时刻的前沿概率。

那大T时刻呢又需要第一个时刻的形象概率，那下面的问题就聚焦到阿尔法1I，怎么来求解的问题其实很简单啊，你想想按照刚才我们的定义，阿尔法1I应该等于什么，阿尔法EI就是第一个时刻呗是吧。

阿尔法1I就已知了O1O2都没有，还知道谁还知道了，I1等于QY不是这么个东西吗，是吧，那这两部分你看看O1和I1等于QI，很显然这是一个联合概率，联合概率可以等于什么来着，还有同学有没有印象。

联合概率可以写成条件概率，乘以边缘概率的形式，这个地方稍微注意一下，谁是条件概率是边缘概率就可以了，PO1在IE等于QI，然后再乘以一个什么，再乘以一个P这个时候作为条件，你还需要还原回来，I1等于Q。

哎这是乘积好吧，那么这个式子你看看是谁啊，IEOE不就是B1吗，这个I1等于QY不就是派吗，第一个时刻是吧，所以你会发现阿尔法1I是可以得到的，就通过bi乘以派I来得到，有了阿尔法EI以后。

我们就可以递推，通过递推公式得到阿尔法T加1I，换句话说任意时刻的阿尔法我都可以知道了，任意时刻的阿尔法知道以后，我就可以计算到阿尔法大T，把阿尔法大T进行求和就可以得到P5，好吧。

看看这一部分有什么问题吗。

就第一个问题啊，我们就这样来解决了，解决了，可能有些同学还没反应过来是吧，很正常啊，嗯里面的这个计算逻辑其实也不复杂，只是符号多一点而已，嗯但是呢也不寄希，也不可能寄希望于通过你，你一次就能够全部了解。

当然如果你的前面的基础还不错的话，其实我觉得也没什么难的是吧，那问题是怎么办啊，就是还有问题怎么办，第一步回去以后找一张白纸啊，找一张白纸，找一支笔啊，把这些逻辑里面的这些符号手写一遍啊。

要比你看上两个小时还管用啊，可能你手写一遍，可能最多半小时就完成了，它的作用远比你从那里瞪眼看俩小时管用很多，嗯第二个在我们的不管是微信群也好，还是我们的QQ群也好，有什么问题随时提问好吧。

那些符号不清楚了，为什么是这样的啊，随时提问，这第二个，第三个不光是我们今天客户啊，嗯后面的课程特别是模型会越来越复杂，如果你还希望把推导过程了解的话，这个过程是不可避免的啊。

呃现在呢很多的材料都是电子版的啊，稍微吐槽一下这个电子版的材料，你光看一点用没有，或者作用不大啊，一定把它，如果你希望了解的更多，或者了解的更充分一些，一定把它写出来啊，手写出来好吧，啰嗦两句。

看看还有什么问题吗，就是关于我们的概率计算问题。

好没有啊，很好继续，好了嗯，这样啊，这个刚才已经说了，这个概率计算问题呢，它是一组问题，或者说若干个问题啊，刚才解决的只是其中的一个啊，后面还有很多回去以后呢，有时间就看一下好吧，但是呢如果没时间呢。

你就把它直接拿到作为中间结果用就可以了，那我们解决第二个问题，第二个问题是啥来着，学习问题，也就是说我们现在已知的是O啊，现在已知的是O，我们需要把这个lambda构建出来啊。

这个是一个无中生有的过程啊，就你想象一下，你只知道观测序列嗯，下一步呢你需要把这个模型构建出来，这个事怎么办，嗯刚才已经说过了啊，在解决这个问题的过程当中。

我们会使用到em算法啊，所以呢这个先把em算法做一个简单的。

算是回顾或者了解吧，好吧，当然可能有些同学。

这可能有些同学这个之前可能比较了解的。

比较充分了，这个我们就简单的做一个回顾好吧，em算法，em算法不是个模型啊，它仅仅是一个求解，含有隐变量的这么一类问题的一个求解步骤，或者求解算法而已，当然我们在一马可夫模型当中，就包含所谓的隐变量啊。

或者隐藏变量是吧，或者隐含变量，那么很显然啊，这个模型啊，以马可夫模型当中的一些问题，可以使用期望最大算法来进行求解，当然嗯我们需要做的就是需要把隐变量啊，和观测变量或者引状态和观测状态。

进行一个对应就可以了，为什么这么说呢，因为在em算法当中啊，嗯我们的观测随机变量是用Y来表示的啊，那么在我们的IMAX模型里面观测是用什么，是用O来表示的是吧，em算法里面的隐藏变量是用Z来表示的啊。

在我们野马可夫模型里面的隐藏变量，是我们的状态I啊，所以就是说啊这里的Y就是我们的O，这里的Z就是我们的I啊，这个问题对应起来以后，下面如果我们能够把求解啊，还有这里的隐变量Z的关于观测变量Y的啊。

这个这么一个类问题能够解出来的时候，那么关于我们的状态序列，I和观测序列O的问题就可以求解出来了，明白什么意思了吧，啊不过做一个符号替换就可以继续往下，那这里就我们就不管O和I了啊。

这里只有Y和Z了好吧，当我们还有隐变量Z的概率模型的时候，那我们的目标很显然就是我们的目标很简单，就是极大化我们的观测变量Y，因为我们知道Y嘛对吧，那么既然我只知道Y，我就尽可能的找。

使我们的那个可观测的那个那个那个Y，能够使模型尽可能极大化的那个目标，那么这个时候呢我们用丢了三来解决这个问题，那这时候呢，就是使我们的对手自然函数尽可能的极大化，当然我们是在啊。

使我们的那个观测的外变量的概率，尽可能大的时候啊，构建我们的对手自然函数啊，这是我们的求解目标啊，求解目标很显然这里面只有观测观测变量Y，但问题在于这个问题本身又不可避免的。

但毕竟是还有那个隐藏的变量Z，所以还需要把那个Z呢考虑回来啊，看下面既然还需要把Z考虑回来呢，从这一步到这一步，很显然用的还是我们的什么加法规则是吧，只有一个随机变量变量概率。

现在呢我们把它拆成联合概率的乘积的形式，联合概率的形式，那我要求和求和呃，写成联合概率形式以后，看下一步，从这一步到这一步呢，一个就是我们乘积规则是吧，联合概率，条件概率和边缘概率的乘积规则好了。

下面问题就变成了，我要是LC塔最大化，就是下面这个式子最大化啊，下面这个式子最大化，很遗憾的事呢，下面这个式子本身就挺麻烦啊，又有联合概率，有条件概率有变化，概率还是个求和，家人们这个log更麻烦的是。

这里的这个Z呢还是隐变量啊，更更观测不到，所以这个时候的LC它的直接极大化，使得这个对数函数极大化，这个目标很难去完成，那怎么办呢，我们看一下，我们退而求其次，我们假设哈，因为你这是LC。

它是这个我们的最终的求解目标呃，考虑一下我们的迭代计算过程啊，假设哈我们在某一次迭代之后，得到了关于LC它的一个中间结果，就是这个LCI，特别注意啊，这里商标I的含义。

是在某一次迭代或者某一次中间计算过程之后，得到的关于L的值，那很显然这个L不是我们的最终目标，但是呢知道了一个中间结果是吧，那这个时候呢我们看一下我们的最终目，比如LC塔和这里的LSI它的差值的形式。

我们看看有没有用好吧，那么从这个等号到这个等啊，从这个等号的左边到右边啊，其实就是一个啊替换是吧，LC它呢用这个式子啊，用这个式子来替换LC它I呢还是表，还是用他的标准形式啊，并没有展开啊，并没有展开。

这是没问题的是吧，那下面一个问题从这一步到这一步是怎么来的，我们分析一下啊，啊这里的log p c ti条件之下，Y的条件概率还在这啊，放在这不变，减它还在这减它右边这个logo还在那。

下面这个式子很显然从一个sum求和，变成了后面这么一坨式子，我们再分析一下这里的PZC的条件下的Y，ZC的条件之下的Y和这个PC的条件下，是ZPC的条件下是Z还是S好，在分子部分上。

分母部分上多了一个PCIY条件之下的Z哎，这个地方多了一个PICTI天选之下的Z，很显然就是在上市当中啊，在上市的sum求和当中，分子分母分别成了这么一个式子，分子分母分别成了这么个式子。

所以这个从这一步就是，分子分母成了一个概率值而已，从这一步到这一步呢是比较麻烦的，为什么这么说呢，在这个过程当中，你会发现就不再是个等式的替换啊，它是个不等式啊，比如上面这个式子要大于等于后面那个式子。

那这个不等式呢，我们借助的是所谓的琴声不等式啊，啊七成不等式有很多种形式，有很多种形式，这里用的是它其中的一种形式，说的是什么，说的是哎，我们只从形式上去去去看一下这个不等式啊，至于这个不等式的证明。

我们就不管了啊，有兴趣的同学可以，你可以找一下其他资料看一下，这个地方我们就直接拿过来用了，这种形式的七成不等式说的是什么，说的是呃，我们就只看形式哈。

log求和拉姆达Y大于等于求和lambda log y啊，至少形式上是这么说的是吧，那怎么用呢，套用一下刚才上面那个式子，log求和拉姆达Y4部分都在，那么很显然按照新成果等是大于等于什么。

大于等于sum lambda log y能能理解吧，所以这一步到这一步其实就是用的进程不等式，大于等于号保持不变，好了麻烦就麻烦再到从这一步到这一步，从这一步到这一步呢，你会发现前面这一坨还在啊。

前面这一坨还在，在这后面减去一个log PCI调下的Y啊，这一项没有了啊，这一项没有了，跑哪去了，跑到跑到分母上去了，你会发现这里的PCIY在这PCYI在这，他怎么就从一个地从一个被减式子。

跑到了这个分母上去了，这个看看什么原因，考虑一下前面啊，考虑一下前面，考虑一下前面，这里有个sum z p z c i y i y的一个条件，概率。

有没有同学看一下，啊说明一下哈，这个地方是这样嗯，嗯考虑到这个式子前面有这么一项，那我是不是可以在这一项的前面，也增加这么一项，就加上一个sum求P，Z y，因为我们知道啊，如果单纯从这一项上来看的话。

他就是对PZ的求和，我不管已知条件，我不管你已知条件，我只是对P的变量求和嘛，那我不知道如果仅看这一项的话，它概率求和就等于一嘛是吧，该是求和六一，当然为什么你说如果他一为什么还有这一项呢。

因为后面这个乘积项，因为因为因为你需要这样看，应该的乘积项是在这，所以后面还有Z，所以很显然呃我们只看这一项，它是等于一没问题，但是后面你还需要考虑到乘积项，很显然这个式子就萨马求和。

这个式子就不等于一，但是你会发现仔细，你会发现这里的后面这个log p在后面，这里不管是条件上还是从这个边缘概率上，他都没有Z，都没有Z吧，都没有Z，所以这个时候我们可以把这个一。

就展成这个sum求和的形式，这没问题吧，这个应该没问题是吧，既然咱们求分式了以后，这个时候我就可以把他俩往前凑了，他俩往前凑出来以后，这个地方的减去log不就跑到了log。

减log不就跑到了分不分上去了吗，明白什么意思了吧，仔细一点就可以了，这个也问题不大，好了，那，问题在于我们得到了这么个式子，就是LC大减去LC大I的中间结果是这么个式子，又是挺复杂的一个式子啊。

我们先不管，先放在这，放在这再说，我们现在做这个工作，做什么工作呢，我把这个等式的左右两边，左右两边同时加上一个lc ti啊，这边加上一个LC3I，那这一项就没有了，也就是说从他的跑到这边来。

变成L谁T，那么你会发现我们得到了一个关于LC，它的表达式，就是下面这个式子啊，我看看啊，我们得到了得到了L关于LC的表达式，然后呢我们利用这一部分，等于BC大C大I啊，BC塔C大I。

考虑到这里的不等号啊，到这里的不等号，我们就得到了关于LC的I是大于等于这个式子，加上一个lc ti的，也就是下面这个式子，下面这个式子呢，我们利用这一部分呢等于BC的C大I。

那么得到了关于LC的I大于等于BC的C的I，这个结论，换句话说哈，我们得到了一个LC它的一个下界函数，因为它永远比B大吗，永远比B大，所以呢这个时候你会发现，如果我们直接对LC塔的最大化完成不了。

或者很难完成的话，我们下面的目标是需要把它的下界函数进行，可能的大啊，这是一个策略啊，就是我们经常会这样去做是吧，我们的这个极大化的目标很困难的时候，我们是通过这种不等式哈，去找到它的一个下界函数。

那么我们的目标是尽可能的不断的最大化，下界函数啊，不管是从这个em算上，还是从这打上模型，还有迭代尺度法里面，我们经常会使用这种策略啊，那好了，下面的工作，就变成了什么，就变成了对LC的极大化问题。

转化成了对B函数的极大化的问题啊，那么B函数的极端化呢，我们可以看一下，它就等于LC大I加上刚才那个式子啊，加上刚才那个式子，这个时候呢特别有意义的意思的地方在于，这个地方是关于CA和CAI的函数。

但是呢对它的极端化，得到的是关于CAI加一的函数，因为我们知道通过迭代计算吗，就说我在L在C塔C塔I已知的条件之下，构建了这个B函数，它的极大化，或者它的下一步的极大化的结果是DI加一轮的，那换句话说。

在第二轮的这个LC塔以及其中的表达式当中，对我DI加一轮的计算是已知的，再重复一遍哈，这里的B函数里面是关于CA和C，AI的函数啊，关于CA和CAI的函数，当然我们的目标是要通过呃B函数的极大化。

得到关于LC的极大化，但问题在于这是个迭代过程啊，迭代过程当中LC大呃，这里的C大和C大I是要极大化的，结果得到的是第I加一轮的西塔，那么换句话说，在DI加一轮的C他的那个结果当中。

你前面的第二轮的theta，对我第I加一轮的西塔都是已知的，这个没问题吧，那既然对我第I加一轮的C大是已知的，那么我所有的中间计算结果都是已知量，对于极大化目标没有影响，所以这个时候你会发现啊。

LC大I是个已知量，既然不管它是789十还是还是还是1。5，8。9，那哪个它都是已知的嘛，对我的其他化过程是没有帮助的，所以他就可以去掉，当然同理，我们还可以把你可以发现这里的分母部分啊。

把分母都是带着c ti的，都可以把它去掉了，得到了下面这个式子，得到下面式子，得到下面这个式子以后，你会发现下面这个式子就变成了，注意啊，这个地方是条件概率和边缘概率的乘积的形式。

那这个时候还原成我们的联合概率啊，还原会还原成我们的联合概率，就变成了对第21轮C塔极大化，转化成了对下面这个式子的极大化，下面这个式子很显然就不再等于B函数了，因为B函数是带着LC大I的。

所以我们重新定义一下，下面这个式子被称之为Q函数，QQQ在这Q函数Q函数在形式上，或者说这个式子的形式上，其实就是数学期望啊，求和sum z对Z的求和，Z呢是在PZ上的概率值。

后面这个表达式就是我们的期望对象是吧，所以你会发现，其实就是对于我们log p y z的一个，数学期望计算，当然这里的Z是在PZ的概率上，进行一个数学期望，计算好Q函数啊。

所以你会发现问题又进一步的转化了啊，对于B函数的极大化，通过刚才的分析，我们又得到了关于Q函数的极大化，换句话说还有隐变量啊，关于隐变量的问题的最优化过程啊，最终转换成了它所对应的Q函数的最大化过程。

注意啊，这个Q函数还是挺复杂的，你需要看清楚啊，虽然复杂哈，就是期望对吧，求和概率，期望对象是吧，三部分分析清楚就可以了好了，有些人就会疑问你这个这个东西怎么用啊，怎么用啊，你会再回过头来。

我们一开始上课的时候，就一开始讲到em算法的时候的一个问题，核心问题什么问题，这个ZZ这个Z不就是我们的I吗，这个Y是谁，这个Y不就是我们的O吗，那你看看我们要极大化，11我们要极大化那个LC。

它就是我们在当前那个PY的最大值，PY是谁，PY不就是我们的那个POY是我们的什么，看看Y是我们的观测变量嘛，毕竟是我们的PO嘛，P是我们的PO极大化的LC塔，如果这个结果能够得到的话。

那个模型不就是我们在已知的观测变量之后的，LAMBA模型吗，啊这是血气旺，而这个过程对LC的极大化，转换成了对B的极大化，B的极大化又转换成了对Q的极大化，那下面我们就需要把这个式子求出。

这个极大化过程，这个极大化的结果就是我们的模型lambda。

啊em算法有什么问题吗，我们先不先不说它的使用，em算法本身，我没问题的话，我们就继续画到这学习问题来看一眼上面吧，还是有些同学可能还是分不清楚学习问题啊，学习问题，学习问题在这一日。

O这里的O就是我们的观测变量，就是我们em算法里面的是Y，有了Y以后我们要得到什么，我们要得到PY极大的时候的那个模型，拉姆达PY极大的模型就是PY极大化的LSA，对吧，把那个theta找出来就可以了。

这个M大的theta，你知道O要求那个lambda啊，学习算法弄好了，将观测变量作为呃，将观测序列作为观测数据，将我们的状态序列作为隐藏数据I，那么英法可模型呢，就是含有隐变量的一个概率模型。

那么POLAMBA啊，就像刚才我们说的PO就是PY嘛，PO等于什么，PO就等于sum IP i条件下，O的条件概率乘以pi，这个没问题吧，这是用到了我们的乘积规则和加法规则，把PO展开了吗。

把它PO展开了，那么完全数据就是OI吗，那么我们的完全数据的对数三函数，就刚才我们所说的log p o i嗯，那么Q函数啊，Q函数仔细一点，Q函数就是一个数学期望谁的数学期望。

就像刚才说的p o y log p o y log p o y，然后呢I是谁，I是刚才我们那个呃那个那个概率是吧，PO圈下I的概率，就像刚才我们所说的，这个时候的Q函数的定义。

它就是数学期望把对应的式子对应好了，符号展开就可以了，那下面的问题呢转变成了对这个式子啊，对这个式子的极大化过程，哎呀这个式子的极大化呀又挺麻烦，怎么办，对他的极大化嗯，分母上这一项拉姆达拔啊。

我们就不不考虑它了，同样他是在上一个模型已知的条件之下的，拉姆达啊，所以它是已知量，那么很显然，还是要对分子部分的部分进行一个极大化，分子部分的核心还是对这个联合概率的最大化。

那么联合概率呢我们先把它展开看一下，因为是POY啊，又有和联合钙，又有这个观测变量，又有这个隐变量，但是呢不妨碍，因为这里的联合概率呢，其实就是我们刚才所说的那个呃，生成算法过程啊。

所谓的生成算法过程不就是因为有有OUI吗，你先生成谁先生成I1I1，根据谁来完成派来完成，有了I1生成谁O1O1由谁来完成，BIEOE来完成，有了O1就可以就可以生成什么I2啊，当然不是不是依赖关系啊。

就可以根据IE什么A2由谁来完成AIEIR，那当然有了I2就可以生成O2，有了O2我们就可以依次往下，最后生成O大T，所以说这类的联合概率，就是刚才我们所介绍的生成算法好吧。

那么把它斩成一个这么样的这个累积的形式，好在前面还有一个log啊，这个时候问题就进一步的转化了，转换成了什么呢，我们对Q函数的极大化所对应的lambda啊，就等价于对刚才所说的那个，数学期望的最大化啊。

数学期望最大化，而刚才那个数学期望当中，这里的联合概率PI啊，根据刚才的分析就是一个累积过程，恰好前面在这个logo还就还有个求和，不要忘了是吧，那这个式子就可以进一步的展开。

展开成什么展开求和的形式啊，求和展开成求和呢，我们把它归归项啊，归归项归成哪一项项呢，你可以看到这里的BB对吧，然后呢这里还有B这些作为一项，然后呢这里的AA作为一项，当然前面还不要忘了还有个兰姆达。

所以说呢我们可以把这里的求啊，这个累积log之后呢变成三部分的求和啊，哪三部分呢，刚才看到了啊，Sami log pi，然后呢，不要忘了后面还成了一个POI拉姆达啊，这是第一项。

第二项p o i lava8，前面是关于A的部分啊，A呢因为是I1哈是通过派来生成的，所以嗯生成A2啊，是从A2开始是根据A来生成的，所以这个地方T从一的话一直到大T减一啊，这个大T减一怎么来的。

应该清楚了吧，当然你调整一下符号也可以写成从二到大题啊，这都没问题，那么第三部分啊就是通过谁啊，通过那个啊B啊，B呢因为是从B1从那个O1O二一个O大T，所以这个地方是从O1T从一到大题。

不要忘了后面还有一个POIM的吧，嗯三部分的累加个极大化，我们就可以分别进行极大化是吧，分别进行极大化，而这个地方呢需要注意一点啊，这里的sum pi是等于一的啊，前面我们没有强调这一点啊。

但是应该能够分析清楚是吧，pi啊，是DI啊，是QI的概率啊，第一个时刻我可以从Q一一直到求到Q大N，那么这些概率的累加和一定是等于一的啊，这个没有问题，那对前面这一部分的最大化，带上这个约束条件。

就变成了一个带条件的最大化问题，那么下面很显然是拉格朗日乘子法啊，这都是老套路了，拉格朗日乘子法啊，就是构建，首先构建我们的拉格朗日函数，拉格朗日函数原函数在这加上我们的条件。

条件呢写成等于零的形式是吧，把一减到左边来啊，是SY从一到N派减一等于零，然后前面加上一个拉格朗日乘子GA啊啊，这样的话拉格朗日函数就有了，因为拉格朗日函数以后呢，我们可以对pi求偏导啊，求导嗯。

对外派求偏导呢，这个地方呢仔细一点啊，稍微仔细一点就可以了，嗯前面的你注意啊，是对pi啊，这不是对特定的某一个派进行求偏导，而是对派I啊，可以是任意一个求偏导，所以这里面的sum求和里面的展开以后。

在当前这个拍的求导过程当中，只有一项是包含派I的啊，其余项都是零啊，其余项都是零，所以呢这是sum求和就没有了，然后呢log pi那就是pi分之一嘛是吧，派分之一，然后呢这是分子啊，因为这里面没有派。

然后再加上一个伽马杯的乘以一啊，刚才已经强调过了，这里派只有一项，所以派对派就偏到一，这常数项就没有了，那这个时候呢就变成了拉姆达分之一，那么大分支这一部分加上一个伽马等于零是吧。

然后呢把这一项移过去啊，把这个派移过去以后调整一下啊，乘以派啊，移过去调整一下，就变成了POI1等于I兰姆达八，加上一个伽马派等于一啊，这样的话呢我们再做一个求和啊。

做一个求和求和相求和项的目的是在这个地方，我们把它还原成一，因为这个地方SAMI从一到大N改派是等于一嘛，左边变成了伽马，而这个时候呢，哎我们得到了关于伽马的优表达式，有伽马等于负的P兰姆达八五。

那这个时候呢我们把这个伽马再带回去之后，就可以得到关于派的一个表达式，就是下面这个式子得到派的式，那这个时候pi就有了啊，派对啊，注意啊，这是在我们已知了隐变量的Q函数以后。

对lambda的极大化过程当中的第一部分的求解，这一部分的求解呢，是带着约束条件的极大化问题，通过构建拉格朗日函数对求偏导，我们得到了关于pi的一个表达式，这个pi的表达式我们看看它的分子部分啊。

它的分子部分OI1等于I，很显然我们可以通过什么来完成，通过我们的乘积规则把它展成什么，展成条件概率和这个边缘概率的形式，下面这个PO注意啊，这个PO看到了吗，是我们第一步。

在我们这个概率计算部分已经处理得到的结果，所以说分子分母都是已知的，pi也是已知的，同样的道理啊，同样的道理，我们依此处理，第二部分和第三部分稍微仔细一些啊，符号稍微有点多，但是呢套路都是一样的。

套路没什么复杂的，所以这个地方的分子分母部分，同样是在我们第一步当中的中间计算结果啊，关于一些cos伽马的一些中间计算结果拿过来，我们直接用就可以了，那么通过以上的方式，通过以上的方式和步骤。

我们就解决了第二个问题，关于学习问题，学习问题，其实你会发现，就是一个em算法的使用过程就可以了，我们要对嗯PO所出现的那个函数的，对数三函数进行极大化来解除我们的模型。

那其实就是转变成了对Q函数的一个，极大化过程，Q函数你只要稍微仔细一下就可以，为什么这里可以使用这个Q函数呢，因为这里的联合概率，它的其实就是我们的模型的生成过程，累成过程恰好前面呢是对数自然。

所以我们把它变成U里程变成累加累加以后呢，我们归归类啊，归归类以后呢是三项啊，每一项都有我们的最大化目标，所以我们把整体的优化目标问题，转化成了对这三项的局部的最大化问题啊，其中的第一部分的极端化。

我们可以解除pi，第二部分和第三部分，可以分别解除我们的A和B，那这样的话我们的整个模型派ab就都有了。

第二次迭代的对数似然不太离谱。

到在哪，是在em里面还是在求解过程里面，嗯em里面是吧，嗯我们我们先不管em了好吧，我知道这个问题在哪了，我们在QQ群里或者微信群里，我们解决这个问题好吧，因为那就是在烟部分，我们先看这吧，还有问题吗。

关于这一部分，好最后一个问题预测问题啊，来这个预测问题了啊，看看最后一个问题，预测问题都在干啥，预测问题到底在干什么，嗯在这好了，还是我们已知观测啊，我们的语料库是已知到的，然后呢我们的拉姆达。

我们的模型，语言模型通过刚才第二部已经构建出来了，现在我们要干什么，我们要把那个隐隐序列I构建出来啊，这个时候就想回到刚才我们的问题啊，不管是词性标注还是我们的这个呃分次啊。

都是从序列到序列嘛啊从一个已知序列，我们要得到另外一个序列，当然这个序列和序列的映射呢，我们还需要知道模型啊，怎么办，这是个挺麻烦的事，看下面，这个时候呢我们还引入了另外一个呃。

以另外一个量就是delta delta t i，但是ti呢它也是一个递推公式啊，你会发现它也是个递推公式，它的这个递推过程啊，非常类似于我们前面讲到那个阿尔法，那个前向概率，当然不一定不是不同啊。

可以显示不同，但是这个逻辑是非常类似的，什么逻辑呢，就是首先给出德尔塔TI的定义，所以呢TTTI啊，它被定义为IT等于IIT减一等等等，I1OT等等等等O1，换句话说就是说我知道了从O1到OT。

还知道I1到IT减一，并且呢在IT等于I的这个条件，这个这个概率啊，这个概率里面，所有可能的概率值的最大值，被定义为德尔塔TI，注意啊，这里的IT等于I，因为随着这里的I的不同啊。

随着这里I的取值的不同，当然IT减一也是哈，随着IT减一的取值的不同，它是有多个概率值的，在这多个概率值里面，我取那个概率值最大的，把它放到这里的德尔塔TI里面呃，那德尔的TI等于多少呢，我们不知道。

到至少到现在我只知道它一个定义形式而已，是吧，好了看下面啊，那么德尔塔TI，我们看一下德尔塔T加1I等于什么，德尔塔T加1I，按照刚才的公式，只是多了一个IT加一那么一项而已啊，就多了那么一项等于I嘛。

因为前面都是一样的，通过前通过使以下的计算啊，通过以下的计算，我们可以得到它的递推公式，是下面这个式子中间的过程啊，回去自己看下面这个式子什么结果又有哪些，包括这里的BIOT加一，因为是T加一个时刻。

OT加一我们是已知的是吧，那么很显然BIOT加一也是已知的，因为查一下B就可以，这个阿尔法JI也是已知的啊，查一下A就可以，那么前面的阿尔法TJ注意啊，这是在T加一的时候。

得到了关于阿尔法T加TG的一个表达式，那么很显然有了阿尔法TJ，就可以得到阿尔法T加一，那么同样阿尔法TG是多少也不知道，那我只需要知道阿尔法T减一，就可以得到阿尔法T得得20题是吧。

同样是个递推过程啊，这个递推过程，那这个递推过程的计算过程当中，我们每一次都把这里的德尔塔T减一，G乘以阿尔法GI这个结果最大值的那个节点，保存到中间结果里面来，就是说你会发现啊。

在前面的德尔塔的计算过程当中，它计算的是概率的最大值，是概率的最大值哈，至于这个概率的刚才我们说过啊，至于这个概率的最大值是哪个值给他的，他DA是不记录的，他只是记录的概率值。

中间结果计算的是产生那个概率最大值的，那个状态，因为不要忘了我们的初心是什么，我们的初心是要计算的一个状态序列是吧，看这里我们的初心是要计算的一个状态序列，你那个德尔塔只是记录了出现那个状态。

概率极大值的概率值是多少，没有计算序列位置，那这里的中间结果我们是用来计算它的，具体位置的好了，那这个东西有什么用啊，这个地方使用会使用到了那个二次规划问题，二次规划问题的结论告诉我们。

当我们按照上述的计算过程进行计算以后啊，得到的这里的中间结果，就是我们的中间路径结果啊，因为我们每一次的计算都是在上一次的基础上，再加上一个A加一对吧，再加上一个A加一，再加上一个A加一。

当我计算到了I大T的时候，很显然这个德尔塔就计算结束了，当我们得到了德尔塔大T的时候，那么这里的中间过程也就记记录，完成了一个一个的节点就计算完成了，当计算完这里的德尔塔大T以后。

那么中间计算结果里面所有的路径节点，就是所谓的预测路径，呃，这是计算过程啊，计算过程，至于为什么你需要再找一本啊，呃理论讲vs规划的理论书再去解决这个问题了，也不在我们今天的讨论范围当中了，好吧，嗯好。

以上呢，是今天我们关于伊马尔可夫模型的一个介绍啊，嗯我们简单回过头来看一下好吧，第一个问题，R可服定义所谓的姨妈可夫模型，两个序列的映射规则啊，两个序列的映射啊，就这么个东西，一个序列呢是隐藏序列。

一个序列呢是观测序列啊，就是这两个序列之间的映射过程，但是很显然有很强的要求啊，状态序列只受上一个时刻的状态影响，观测序列只受当前时刻的状态影响，这是文字上的描述啊，形式化的描述需要理解的状态序列。

观测序列更重要的是怎么生成，状态序列和观测序列，很显然都是通过我们的矩阵和向量，来加以描述的，其中状态转移矩阵啊，描述的是状态和状态之间的转移，观测概率矩阵描述的是状态观测之间的转移。

处理掉的向量描述是第一个时刻的状态生成啊，这其实有了ab拍以后，我们的模型就已经构建完了三个问题啊，中间计算结果的概率，计算学习是通过O生成模型，预测是通过模型和O生成我们的隐变量，其实你会发现。

我们的最核心的目标还是在以隐变量上，就是我们的隐藏序列I上啊，怎么把这个I序列找出来，是我们最核心的问题，比如说从一个序列O生成另外一个序列I，这就是sequence to sequence啊。

从序列到序列任务啊，当然我们的深度学习模型里面，有很多的模型都是解决这一类问题，但是1max模型怎么解决的，刚才我们已经完成介绍了，好吧，看大家还有还有什么问题吗，当然我记得刚才那个同学的问题啊。

就是你关于em算法，因为中间计算过程里面我们使用了em，但是呢这只是一个工具而已是吧，这个问题我们后面再解决的，就关于hmm部分还有什么问题吗，OK嗯嗯当然嗯这个不是结束哈。

反而是刚刚开始有个有什么问题，我们在微信或者QQ群里及时在沟通，好吧好，今天我们就到这吧。

【七月在线】NLP高端就业训练营10期 - P9：6.命名实体识别与CRF应用 - IT自学网100 - BV1uxT5eEEr6

OK如果没有问题的话，我们就准备开始好吧，那么今天我们的内容呢是关于这个呃序列标注，还有我们这个cf模型的使用的内容，那么在这些内容讲解之前呢，我们可以看到啊，这个这一次的课程也是作为我们这个阶段呃。

一系列相关模型，特别是啊银马尔可夫模型和CRF模型的一个呃，简单的回顾，以及在我们自然语言处理方向的应用的一个，总结性的内容，那么我们分两个部分啊，第一部分呢是介绍一下。

伊马尔可夫模型以及序列标注任务啊，第二部分呢我们再介绍一下啊，我们CRF在LP方向的使用的内容，首先我们先看第一个问题啊，就是关于这个序列标注与中文分词呃，首先我们聚焦到序列标注方面呃。

sequence to sequence啊，就是序列到序列，是一类我们在呃机器学习方向非常重要的任务，他的描述呢是这样来给定的，关于序列标注，首先是给定一个序列XX一一直到XN。

他需要计算出每一个已知序列当中，元素所对应的标签，得到相对应的标签序列YY1Y二一直到YN，这里有两点需要特别注意，第一点我们是一个所谓的序列标注任务，所以我们的已知序列和我们的标签序列，都重点是序列。

这和我们之前所介绍过的数据集的概念，特别是数据集的集合的概念是不一样的，序列强调是有顺序的数据集，这里你可以看到下标一二到N啊，是一个严格的先后次序关系，包括这里的标啊，标签的一到N啊。

都是严格的次序关系啊，这是和我们之前的数据集是完全不同的啊，强调它的顺序性，所以它不是个集合哈，是一个序列，这是第一点，第二点呢，就是已知序列和标签序列当中的元素啊，已知序列和标签序列当中的元素。

我们在这个地方啊，首先你可以认为是一一对应的啊，元素是一一对应的，我已知一个X一一直到XN，我要得到的是Y1到YN，也就是说但凡是啊，但凡是从一个序列到另外一个序列的映射。

这种任务都是所谓的序列标注任务，然后呢在求解序列标注问题的时候啊，这个时候我们把求解的模型，称之为是序列标注器啊，序列标注器通常模型是从一个标注数据集，XYXY啊，从我们的输入和标签的对应关系啊。

组成的序列标注集当中学习相关的知识以后，再进行预测，这个时候就需要特别注意，这里的标注数据及XY它又是一个集合，有同学这个时候就会有困惑，你刚才不一直在强调序列，标注任务当中的XY都是序列吗。

怎么到这个地方呢，XY又变成了集合了呢，这两者之间是完全不同的，注意一下啊，在刚才强调的XY啊，在刚才强调的，XY是我们数据集当中的一个数据，对小X小Y注意，这都是黑体的。

有大K的这样的小X小Y所组成的数据集啊，标注数据集是我们用来进行模型训练的，换一个角度啊，换一个角度，我们可以看到在这个地方的序列X1到XN啊，这里的序列由X1到XN组成，所以我们这个时候你可以看到。

这里的X是一个向量啊，用黑体表示的向量，这里的Y1到YN组成的Y也是一个向量，由大K个这样的向量对所组成的结构，就变成了一个集合对啊，变成了一个矩阵所组成的集合对啊，所以这个时候啊。

嗯这和我们之前啊在不管是嗯普通的啊，机器学习模型当中，碰到的数据集是不太一样的啊，是不太一样的，这一点希望大家能够引起重视，然后呢可以看到序列到序列标注任务啊，就是序列标注任务是一个非常抽象的任务。

也就是说但凡是我已经知道一个序列，要求一下它所映射得到的序列啊，这类任务一般情况下，我们都认为是序列标注任务，那在自然语言处理这个特定方向当中，这种所谓的序列标注任务具体又体现在哪呢。

我们可以看到在自然语言处理当中，这里的X啊，这个所谓的已知的序列，通常是字符序列或者是词语系序列啊，要么是字符序列，要么是词语序列啊，要么是一个一个的单词啊，一个一个的单词，要么是一个一个的单字啊。

这样的话就构成了我们的第一个已知序列，那么相对应的我们得到的映射标签，Y则是待预测的组词角色，或者叫做磁性啊等等的标签儿，呃这就需要和当前的你选，你所解决的任务密切相关，比如说如果是一个词性。

什么是词性，我们在学语文啊，英语的时候都啊学到过啊，单词是有词性的，名词副词，形容词，介词连词等等词性是吧，这个时候很显然，如果我要得到的标签是一个单词，一个单词所对应的词性的话。

那么反过来我们也就可以确定已知的序列，X里面的每一个元素都是一个什么词语是吧，这个时候你会发现，当我们要进行所谓的词性标注的时候啊，要为我们的每一个单词标注词性的时候，那么很显然这里的X就是以词语。

好像是以单词作为我们的已知序列，而对应的标签就是每一个单词所对应的词性啊，这是刚才我们一种方法，一种这个X组织形式，是以单词的形式来组织起来的，X，那么有同学会问，有没有以单字所组成的这个呃已知序列呢。

有这类任务呢，比如说我们可以看到，后面还有一个叫做组词角色，什么叫做组词角色呀，比如看下面啊，比如说我们一个单词啊，比如说我们一个单词，单词我们认为是由一个一个的单字所组成的。

而这一个一个的单字在词当中的位置，其实是啊有特殊的标识的，比如说在一个词语当中啊，在一个词语当中，有些单字啊是出现在这个单词的首位置啊，我这个时候呢，我们就可以给他一个所谓的手标记啊。

就是这个单词的开始单子，那么当然有首标记就对应着有伪标记，当前这个单词的最后一个单字所在的位置，有首标记为标记以后，那么中间的单子啊，当前这个单词的增中间的单字，我们也可以给他一个所谓的词中标记啊。

词中标记当然还有特殊情况啊，有一些词是单字词啊，单一个字所组成的单词，它不分啊首尾和中间因为只有一个字嘛，所以之后这个时候呢我们把它称之为单字啊，成词标记，那么取这些具体位置的首字母啊。

英文单词的首字母，所以组成了BMES啊，这么一个所谓的分词标注集，分词标数题用来干什么呢，很显然是用来解决分词问题的，呃把问题聚焦一下，举一个例子啊，比如说我们现在有一个文本序列。

叫做序列标注与中文分词，这么一个序列很显然是我们的已知序列，这个时候我们要完成的是，将这个序列进行所谓的分词，就是将这一个由字所组成的序列，分成若干个组啊，每一组组成一个单词啊，分词吗。

分词就是这样来做的，那这个时候很显然我们就需要为每一个单字啊，对应的得到他所对应的那个什么，在单词当中的具体位置，当然我们啊大脑其实也是一个分类器是吧，我们这个时候可以看到。

我们认为序列啊可能是作为一个单词标注呢，认为是一个单词，语是一个单词，中文是一个单词，分词是一个单词，如果按照刚才我们所谓的分次标注集当中的，这个规定啊，分别要为这些单词当中的每一个字啊。

给出一个所谓的分词标注的话，那么很显然续我们应该给的是B列呢，应该给的是E，因为一个开始一个结束，同样标注呢也是一个B1个E，雨是个我们认为是个单字词，所以是个S同样这是BE，BE啊。

因为这个稍微特殊一点，他没有多字词是吧，只有两个字的单词最多是，所以这个时候呢我们就可以看到，当我们已知得到了这个序列标注与中文分词，这个输入的X序列以后，那么我们通过人脑的这个所谓的分类器。

得到的分词标注集就是BEBESBEBE啊，这就是得到了一个我们分词的这么一个模型，那么当然啊这仅仅是举了这么一个例子，我们需要通过大量的数据集啊，大量的数据集去训练一个啊机器学习的模型。

或者深度学习的模型来完成，刚才我们通过人脑来完成的工作，这就是所谓的分词任务，通过上述的一段描述啊，通过上述的一段描述，我们可以现在啊，我们可以知道我们的任务目标是什么了，抽象了一点。

我们要完成的任务目标就是序列标注任务，已知一个序列得到一个它所对应的序列啊，这就是我们最抽象的一个，关于序列标注任务的描述，但是这个抽象任务对应到具体任务领域当中，比如说我们对应到自然语言处理任务当中。

它的形式又是很多种，在这个时候我们仅仅是举了两种啊，仅仅是举了两类任务，一类是所谓的词性标注任务，一类是所谓的分词任务啊，大家其实可以看到，即使是这两类任务，他们也是差别很大的。

在我们的词性标注任务当中，因为我们的目标是要对单词进行标注，它到底是什么样的词性，所以这个时候就要求，我们所构成的数据集当中的X是以词语，或者是以单词所组成的数据集，而刚才所说的这个分词任务。

在分词任务当中，我们需要对每一个单词当中的每一个单字，在词当中的具体位置进行标识啊，就是刚才所谓的分词标注集嘛，进行标识，那这个时候我们要求我们的输入X就必须要是，一个字一个字所组成的序列。

所以啊通过以上的描述，首先我们建立了我们要解决的问题是什么，第二呢希望大家能够清醒地认识到，当把这个抽象任务应用到具体问题领域当中，还是有很多的细节需要具体问题具体设计啊，当然这还仅仅是两类任务。

还有很多非常其他的多的任务，后面我们会看到还有命名实体识别对吧，我们也会讲到，所以这个啊逻辑一致，就是逻辑的流程是完全没有问题的啊，但是呢你需要在实施的过程当中，那么有了上述的问题以后。

我们看一下相对应的模型，是怎么解决以上问题的，当然序列到序列这类任务哈，这是一类任务，解决这类任务的模型有多种啊，比如说隐马尔可夫模型，能不能解决序列到序列的任务，可以啊，条件随机场模型能不能解决。

序列到序列任务也可以，其他的模型能不能，比如说我们的encoder decoder模型，比如说我们的这个transformer模型，都是可以解决这类任务的模型之一啊，希望大家能够明确哈。

就是你的任务是任务解决任务的模型，是解决任务的模型，两者有联系有区别啊，你不能把这个任务和模型搞混了好吧，当然以后可能还有其他的新的啊，发现的模型，解决同样的序列到序列的标注任务对吧。

那么我们看其中的一种以马尔可夫模型，在以马尔可夫模型当中啊，我们可以看到他也是要解决两个序列的联合，分布哈，来构建它的一个一个概率模型啊，in码尔可夫模型啊，是一类概率模型，既然是序列到序列的任务。

就免不了有两个序列啊，我们在以马可夫模型当中，分别称之为是I序列和O序列，I序列呢不可见啊，I序列不可见，称之为是状态序列啊，首先可以看到I等于I一I2IT到I大T啊，是一个状态的序列。

再强调一下是有严格的顺序性，状态序列当中的每一个状态，是在我们的状态集合当中啊进行选取的，这里我们引出了状态集合，状态集合是由Q1Q2，一直到QN这么种N种状态所组成的，也就是说在我们状态序列当中的。

每一个时刻的状态，都来自于状态集合当中的元素啊，这是所谓的I序列啊，隐藏序列，另外一个对应的序列呢是O序列，O序列呢也被称之为可见序列或者是观测序列，同样他也是以勾序列。

也是一个O1到O大T所组成的序列，其中观测序列当中的每一个观测OT，都是来自于我们的观测集合位，观测集合VV呢是由YV1V二，一直到VM所组成的，好吧，这个时候呢有同学就会嗯有些困惑。

就在于呃序列OK没问题，序列和集合的关系是什么样子，那么因为他都带下标嘛，很多时候就会搞混了，这个时候的下标非常重要，他带的信息在于，既然I是我们的所谓的状态序列，强调所谓的先后顺序关系。

那么这里的下标定义的就是这种顺序性，I一一定在I2之前啊，I二一定在I3之前，I大T1定是最后一个元素啊，下这里的下标定义的是顺序，而在集合当中的Q1Q二一直到QN，因为它是集合，就没有这种顺序关系。

这里的下标，仅仅是用来区分集合当中的两个元素，同理在我们的观测序列和观测集合，也有类似的情况，好吧，这个时候一定要搞清楚啊，一定要搞清楚，后面我们会通过例子来举例，但是我相信啊。

到现在为到现在这个阶段了，同学们应该有这种抽象能力是吧，好了有了我们所谓的状态序列和观测序列啊，状态集合和观测集合以后，我们下面就需要定义状态转移矩阵啊，状态转移矩阵什么意思呢。

就像刚才我们所说的状态序列是个序列，所以有的时候呢，我们可以通过这样的一种图示啊，简单的将我们的状态序列加以描述，首先这些点呢这是第一个时刻的状态I1，这是第二个时刻的状态I2。

这是第N个时刻的状态i in啊，这是最后一个时刻的状态I答T，那么有了状态好，12341直答题以后，那么顺序性我们一般用箭头来表示啊，顺序性一般用的箭头来表示点点点，然后呢指向它。

然后指出去下一个应该是IN加一对吧，再往后最后最后一个是I打T，这样就表明了啊状态序列之间的顺序关系啊，状态序列之间的顺序关系，哎这个时候马上有个同学说，哎状态既然是个序列啊。

有I1I二一直到I大T的这种顺序关系，那那个你那个观测是不是也可以这样画呀，当然可以，但是我们不这样画，为什么呢，以后后面我们会说好吧，一会会介绍，我们现在先聚焦到这个状态啊，状态序列上。

既然我们知道第一个时刻是I1，第二个时刻是I2啊，那这个下面就有个问题，那么这两者之间是要进行一个状态之，间的转换的啊，由状态I1时刻的状态，转换为I2时刻的状态啊。

由I2时刻的状态转换为下一个时刻的状态，也就是说在这个状态序列当中，相邻的两个状态之间是需要进行转换的，既然相邻的两个时刻的状态之间进行转换，我们就有必要啊，我们有就有必要，因为每一个时刻的状态取值。

都可能是状态集合当中的任意一个状态，所以我们应该可以预估到啊，这大七个时刻相，任意相邻两个时刻之间的状态转移，就应该必须要给出，状态集合当中的任意两个状态之间的转移情况，都要描述清楚。

这个时候我们用到啊，在序列的时候，用到的时候直接拿过来用就可以了，这就是刚才我们所讲说到的状态转移矩阵，既然是个矩阵啊，既然是个矩阵，而这个矩阵又是又又是用来记录。

我们状态集合当中任意两个状态的转移关系，首先第一个我们需要确定的是，这个矩阵的形状啊，既然是个矩阵嘛，就是个几行几列的，那么很显然要将我们状态集合当中的，这N个状态，任意两者之间的转移关系都要进行定义。

很显然这个矩阵是一个N行N列的一个矩阵啊，N行N列的矩阵啊，这是特别需要强调的啊，以后在后面的学习过程当中，特别是牵扯到各种数据结构向量，那这个向量是个行向量还是列向量，是个矩阵，是一个几行几列的矩阵。

是个张量，是一个几乘以几乘以几乘以几的矩阵，每一个维度上的数据啊，表示了当前这个数据结构的形状，是非常重要的内容，它要比啊这个数据结构里面的数值是多少啊，其实有的时候更重要啊，因为其中的数值。

我们是通过数据集的优化算法啊学习得到的啊，但是这个结构是你需要在事前人工设置的，设置错了啊，整个的算法肯定都是错的，那么有了这个结构以后，它又是用来存储任意两个状态之间的，转移关系的。

所以下面我们需要定义其中的，矩阵里面的元素值，那么我们在T时刻处于状态QI的条件之下，在T加E时刻转移到状态QG的概率啊，这个时候注意啊，既然是任意两个状态都需要都可能出现转移，这两个状态之间。

很显然也是在序列上发生的状态转移，所以也有一个什么顺序关系，从谁转到谁，从谁，从T时刻处于QY转移到T加一时刻为QG，这里的T和T加一很显然是一个先后关系，已知的是T时刻。

IT等于QIT加一时刻为QG的转移关系，用条件概率来表示啊，定义为AIGAIJ，注意这个下标IJ啊，注意I时刻啊，I啊，这里的I是it等于QI的那个状态的时候的状态，这里的G是IT加一时刻。

等于QG的时候的状态好吧，这里的I是从一到N，G呢也是从一到N啊，这是N啊，因为这是状态到状态好吧，那么有了这个状态转移矩阵以后，那么同样我们还可以给出啊观测概率矩阵，观测概率矩阵说的是。

当我们发现了相对应的状态以后，状态所对应的观测啊，状态所对应的观测，所以你会发现啊，这里的箭头不再是从左往右指，而是从下往后呃，从上往下，也就是说我看到一个状态，就可以得到一个当前时刻状态所对应的观测。

所以这个时候的O1O2，这是ON这是O大T他们每一个观测啊，都是根据状态对应的状态得到的啊，这是因马尔可夫模型的这个基本啊，基本的一个要求或者基本的一个规定，那这个时候既然我们是从状态得到观测。

也就是说你可以认为是从状态转换到了观测，那么按照刚才我们在状态转移，矩阵当中的分析逻辑，那么这个时候我们也应该用啊，一个矩阵结构来存储，任意状态到任意观测之间的什么转换，所以这个时候同样我们是一个矩阵。

这个矩阵是N乘以M的，N代表了我们状态集合当中的元素，M代表我们观测集合当中的元素，那么从N个状态可能转移到对应的M个观测，所以这是一个N乘M的矩阵，那么有了这个矩阵结构以后。

其中所定义的值是这样来规定的，在T时刻处于状态QI的条件之下，生成观测VK的概率，在第二个时刻，假设在第T时刻啊，这个时候我们假设这是T时刻，小T时刻，小T时刻等于QI的条件之下。

同样在小T值时刻等于VK的概率，定义的是这个转移概率，我们把它用条件概率进行定义啊，然后是得到BGK呢是对应的是我们的观测，所以是从一到MJ呢是对应的是我们的状态，所以是E从N那这个时候你会发现啊。

当我们有了所谓的状态转移矩阵和，观测转移矩阵呃，这个呃观测概率矩阵以后，你会发现在这个in马尔可夫模型的，现在这种情况之下，我们就可以从另一个位置啊，比如说从I1开始，我从案例一。

就可以根据刚才我们所得到的状态转移矩阵，状态转移矩阵得到谁，I2通过I2查一下状态转移矩阵，我就可以得到I3I4I五一直到I大T，同样当我们知道I1这个状态的时候，查一下刚才所定义的观测概率矩阵。

我就可以跳转到谁，O1在I2我就可以跳转到O2，从IT我就可以跳转到OT对吧，所以这两个数据结构规定了，在我们状态和状态之间的调整关系，以及状态和观测之间的调整关系，但是呢这个时候好像还有个问题。

什么问题啊，如果我们把刚才的这个结构认为是类似于什么，多米诺骨牌是吧，多米诺骨牌一直推导下去就可以运行了吗，我们的第一个状态由谁来决定，这又是个问题对吧，这个时候呢我们进一步的规定，叫做初始概率向量啊。

初始概率向量，那现在呢很显然它就变成了一个什么结构啊，向量结构为什么是个向量结构呢，因为初始状态I1啊，它没有所啊，它就是一个可以取任意一个状态集合，当中的状态的一个初始状态。

所以这个时候我们只需要为Q1Q2，一直到QN啊，这大N种状态，每一个状态给他一个什么初始概率就可以了，所以构成的是一个向量，这个向量是个一行N列的啊，所以呢我们可以看到初始概率向量派等于派I。

它规定的是在时刻T1处于状态QI的概率，注意这里是时刻T1T等于一样，是一个标准的第一个时刻啊，在当前标准的第一个时刻处于QI的概率啊，就是刚才所谓的初始概率，那初始概率呢被用一个啊边缘概率来定义啊。

定义为pi就看可以了，那么有了上述三个数据结构，也就是所谓的初始概率向量pi，以及我们的状态转移矩阵啊，转移状态，转移矩阵A以及观测概率矩阵B啊，这三个结构就构成了所谓的一马尔可夫模型啊。

构成了一马尔可夫模型，那么在伊拉可夫模型的定义完成以后呢，其实我们可以看到在刚才的定义过程当中，其实我们使用到了两个非常重要的。

in马尔可夫模型，为了计算的简便，我们定义了两个非常重要的假设，第一个假设呢就是所谓的，其次马尔可夫性假设啊，其次马尔可夫性假设。

其次马可费用假设说的是在任意时刻，T的状态只依赖于时刻T减一的状态，回到刚才这个图当中，我们会发现刚才我们一直在说的是从T1啊，从I1调整到I2，从I2调整到I3，那么反过来。

其实我们可以发现这个箭头的单向性啊，以及一个箭头的指向性，告诉了我们在任意时刻，比如说I2啊，I2的状态只取决于谁，只取决于I1和O1有没有关系，完全没有关系，因为这个图当中就没有从O1。

指向I2的这么一条边对吧，这其实是一个有向图哈，我们通过有向图来表示的一马一马可的模型，在这个有向图当中，我们其实也可以看到，刚才所谓的七次Mark分析假设就是每一个状态啊。

每一个状态只依赖于它前一个状态啊，这被称之为是齐次马克飞行假设，这种假设的主要目的啊，这种假设的主要目的就是用来简便后面的逻辑，计算的啊，就这么一个目的好吧，有人说你这样做简化以后计算是方便了。

那是不是性能上就要降低了呢，很显然是这样的啊，我们是用嗯受用一定的顺性能的损失啊，来提升计算的便捷性啊，呃这是在经常会采用的一种策略，但是呢当我们的数据样本足够大的时候，这点损失呢其实是可以接受的。

这是齐次马克飞行假设，那么下面一个呢，下面一个假设是所谓的观测独立性假设，观测独立性假设说的是任意时刻T时刻的观测，只依赖于同时刻的状态，同样在我们的图当中说的也很明显。

每一个时刻的观测仅依赖于同时刻的状态，和其他时刻的状态和观测依旧没有关系，同样这个所谓的观测独立性假设，也是为了计算方便，也就是说上面这两条假设啊，上面这两条假设啊，当我们后面进行所谓的概率计算的时候。

当出现了啊，这种所谓的依赖于很多条件的一个状态和条件，关于状态的条件概率的时候，通过这样的化简就可以化简到这种啊情况之下，好吧好了，以上呢是关于我们对啊，以马尔可夫模型本身定义部分的一个介绍啊。

这和我们前面的视频当中应该也有所，这个说明了这一部分有没有问题，没问题是吧，哦不是OK不好意思啊，有没有问题啊，因为，有没有问题，同学们没有问题的话，我们就继续哈，那刚才呢我们是通过原理。

特别是通过呃嗯数学公式的方式，以及画了一个有向图的方式，来描述了一马可夫模型，下面呢我们把它映射成代码，然后看一下具体的这个执行的嗯，一种啊代码上的一个方式，那么实现的方式啊，代码实现的方式有很多种啊。

当然你可以自己手写一个，然后呢我们更常更常用的方式，可以通过调包的方式来实现是吧，我们下面呢是使用的是这个含LP啊，这么一个包来这个来调用一下它的in Mark服模型，首先呢给出状态定义啊。

就是状态集合嘛，你首先得有状态是吧，现在呢有两种状态，健康状态和发烧这么两种状态，然后有了状态集合以后呢，有所对应的什么这个呃观测啊，三种观测啊，正常发冷和这个发抖啊，三种状有三种观测。

那么有了状态和观测集合以后，我们就可以定义什么，定义我们的状态转移矩阵啊，观测概率矩阵嗯，那么状态之间的这个嗯概率呢，我们可以给出给出一个定义，就是直接给出一个啊，你人工人工设置的一个值哈，健康是0。

6，然后呢这个发烧是0。4，那么这个时候的状态转移的这个概率呢，我们可以看到由健康转移到健康是0。7，由健康转移到发烧是0。3啊，从发烧转移到健康是0。4，从发烧转移到发烧是0。6啊，这是概率值。

这个时候呢啊我们先看完了啊，那么有了这个状态转移矩阵以后，观测矩阵我们可以看到，由健康转移到正常是0。5，由健康转移到发冷是0。4，由健康转移到这个额头晕是0。1，由发烧转移到健康是0。1。

由发烧转移到发冷是0。3，然后由发烧转移到这个额头晕是0。6，这就像刚才我们所这个介绍的是吧，刚才我们所介绍的这又是一个是这个矩阵，就是刚才的状态转移矩阵，它是一个N乘N的，你的状态有两种。

所以它是一个2×2的一个矩阵，同样你的观测矩阵啊，是一个从状态到观测的局这个矩阵，那么这时候应该是一个N乘以M的，是个2×3的，所以是一个两行三列的矩阵，好吧，这和这刚才我们所这个理论部分的介绍。

是完全一样的，这个时候呢这个需要说明一下，就是呃在课前有一同学提出了一个很好的问题，什么问题呢，就说你的这个状态集合也好，还是观测集合也好，里面那个QQ，还有那个V到底是一个什么样的结构啊。

它到底是一个，因为你可以看到在这个地方，你这里的Q也好，V也好，是通过一个字符串的给出的是吧，通过一个给字符串给出的，那那是不是就意味着我后面要使用的时候，需要为每一个状态和每一个观测。

都给出一个字符串呢，其实不是这样的，因为我们可以看到这里的字符串，很显然是带着我们的语义信息啊，就是它实际上是一个什么样的状态，健康状态也好，发烧状态也好，但是我们应该清楚的是。

这种语义信息在我们具体的in马可夫模型，计算的过程当中，其实是没有价值的，就这个到底是健康还是所谓的发烧，就健康，发烧只是区别这两种状态就可以了啊，也就是说只要我们嗯给出一种所谓的编码方式。

能够能够区别是这个是这个是Q1状态，这个是Q2状态就可以了，至于Q1状态是健康还是Q2状态是发烧，其实在计算过程当中是没有没有没有必要的啊，没有必要记录这个信息的。

所以你会发现当我们得给出了语义信息以后，下面其实就是个编码，就是要把我们刚才所定义的矩阵里面的信息，通过编码的方式啊，通过编码的方式进行一个抽象啊，只要我知道啊，这是Q1，这是Q2就可以了，这是V1。

这是V2，这是V3就可以了啊，具体的信息我们还可以通过查表是吧，查结构把它查出来，但是呢这个时候我们只需要给出一种编码方式，把他们编程我们所希望的数据结构就可以了，我不知道这一块啊。

我我表述的足够不足够清楚好吧，也就说我们的问题啊和我们的计算过程，有的时候是啊是两个不同的步骤，好吧，当我们有了这个呃编码方式以后，我们就得到了相对应的数据结构啊，相对应的数据结构。

有了这些数据结构以后，我们就可以构造啊，刚才所谓的AB派三个数据结构，然后把它统一的设置成我们的马尔可夫模型，里面作为参数就可以得到相对应的模型结果，这个时候呢需要注意啊。

嗯这个地方叫做一阶马尔可夫模型啊，一阶马尔可夫模型，那什么叫一阶马尔可夫模型，或者说这里的一阶到底是什么含义，就需要回到刚才我们所做的两个假设当中的，第一个就是齐次马克复性假设，这个齐次马克复性假设啊。

也就是所谓的一阶马尔可复性假设，这里的马可这个一阶也好，其次也好，就像刚才我们所说的一个时刻的状态，只与他前一前一个时刻的状态相关的话，这被称之为是一阶马尔可复性假设，如果我们把这个条件稍微宽松一点儿。

也就是说任意一个时刻的状态啊，仅依赖于他的前两个状态的话，这被称之为是二阶的一马尔可夫模型，当然你也可以把它扩展成啊，一个N阶的一马尔可夫模型，回到刚才我们的图示当中哈，回到刚才我们的图示当中。

如果是个二阶的话，那也就意味着如果这个地方是个I3啊，如果这个地方是个I3，如果他直接只依赖于I2，在图上只有一个从I2指向I3的，这条边的话啊，这被称之为是一阶模型啊，一阶一马普模型。

如果还有一条边从I1也指向I3，也就是说I3依赖于I1和I2，两个状态的时候，那这就被称之为是二阶一马尔可夫模型，当然还可能有三阶四阶N阶的，好吧嗯这个时候呢随着你的阶数的提升啊，随着你接触的提升。

你依赖的信息越来越多，那么这那么这个时候很显然，模型应该会越来越精确啊，这是显而易见的额，但是计算量成倍甚至呈几何倍数增长，你的性这个性能的提升的这个程度远远没有啊，你计算量所带来的这个程度的增加。

所以这个时候呢是得不偿失的，经验上也证明哈，经验上，经验上也证明，一阶一马可夫模型，当数据量足够大的时候，其实性能已经足够好了啊，所以没有太大的必要啊，来调用更高阶的模型结构。

当然你说我试试二阶的可不可以可以，后面我们会可以看到啊，可以看到当我们完成了模型定义以后啊，这仅仅是第一步，你只是通过数据的设置啊，只是通过问题的分析是吧，你只是通过问题的分析抽象出的模型结构。

并且为模型结构当中的数据结构，给出了相应的概率值，只是这个模型有了，你得让这个模型能够起到它所对应的作用，那么下面以马可夫模型的基本问题，他解决什么的问题，这是最重要的啊，这才是最重要的。

你说你你到底能干什么，就刚才你这个这个结构图是吧，你刚才这个结构图还是现在看，还是稍微有一点复杂性的，那这搞这样的一个复杂模型，你到底能够解决什么问题，有同学可能马上就反应过来哎。

他需要解决的就是所谓的序列标注问题对吧，序列标注问题，或者说是序列标注问题当中的具体的，比如说像分词问题，比如说像词性标注问题啊，这很好，但如果你需要用这个结构去做的时候，就需要分清楚啊。

需要严格分清楚到底哪些，因为这里面也有I1I序列，状态序列和O序列观测序列，那现在我就问同学们，你在现在的银马可夫模型里面的，I序列和O序列，你能不能对应到刚才我们序列标注任务里面的，X序列和Y序列。

那么下面有问题，我再准确一点，就是这里的X和Y对应的是I和O，或者是O和I是哪一个，这个现在有没有啊，能够回答这个问题的同学问题很问题，应该很清楚了是吗，因为up普模型我们模型定义结束了是吧。

又是A又是B又是派是吧，又是转什么状态，转移什么观测矩阵这么复杂这个东西，那很显然它需要解决序列标注问任务，这是没问题的，但是序列标注任务里面也有两个序列啊，已知序列和标记序列XY。

那么这个地方呢也有一个I序列和O序列，状态序列和观测序列，那么谁是谁啊，就这么简单的问题，I是X还是Y，O是X还是Y，或者反过来X是I还是O，Y是I还是O，X可见Y不可见。

唉这倒是一个很好的分析问题的角度对吗，我不知道，当然这还不是最终的答案，因为可见不可见，在这里刚才不是我的问题的一部分，但是这个分析问题的方法角度是非常，就是这个方法对了啊，但是不是最终答案。

但是通过这个方法你可以得到最终答案，没问题吧，再精确一点，X是我们的已知序列，很显然是我们要得的事实，我们啊可见的一个序列，Y呢是一个标记序列吗，你要得到这个标记序列，它是一个不可见的序列对吧。

那谁是可见的，谁是不可见的，O当然是我们的观测序列嘛，你O是个观测序列，所以很显然这个时候按照刚才那个分析对吧，那这个时候X就是我们的O序列啊，X序列是我们的O序列。

那么相对应的Y序列就是我们的标签序列，所以你会发现啊，所以你会发现为什么要强调这一点，因为你会发现这和模型的时候，如果我们不分析这个问题，你会发现模型本身这种所谓的依赖关系。

好像暗示了我们一个什么样的关系，好像暗示了我们一个，因为I是我们的状态，勾是我们的观测，好像暗示了我们啊，好像是暗示了我们是I对应生成了O，所以按照这个逻辑的话，I应该是XO应该是Y，但这不对对吗。

正啊正确的分析的这个问题的一个角度，就是根据X和Y的可见和不可见，这个角度去分析对吧，因为X是已知序列对应的，当然就是应该是可见序列，谁是可见序列，O是可见序列，Y是我们要得到的标签序列。

而标签序列要得到吗，很显然是不知道的，在我们的模型里面，I是我们的不可见的序列状态序列，所以它应该是Y，你会发现这个我们是通过X得到Y，但是在模型里面是我们假设的，是从状态得到的O观测。

这个这个嗯应该给大家解释清楚了，是这样吗，OK咳咳咳很好啊，这个有的时候呢嗯需要有一点分析的过程啊，和分析的逻辑是吧，那我们就继续哈，那好了，刚才我们仅仅是通过嗯朴素的分析啊。

得到了这么一些相相对有用的结论，但是我们正式啊，看一下伊马尔可夫模型的三个基本问题啊，三个基本问题，第一个问题呢，我们把它称之为是样本生成问题啊，简单点说就是已知谁已知模型。

已知模型意味着我已经知道了状态转移矩阵A，观测概率矩阵B以及初始概率向量派啊，这三个数据结构我都知道了以后，我就可以得到谁可以得到相对应的样本序列啊，因为可以看到啊，根据刚才我们所介绍的这个模型啊。

刚才我们所介绍的这个模型，你会发现我只需要首先查一下谁，查一下那个初始向量派啊，因为那个派定义是第一个时刻的状态生成概率，我就可以得到谁I1啊，开天辟地，第一下有了以后，我通过I1再查一下谁观测矩阵。

我就可以得到谁O1由I1，再通过状态转移矩阵，我就可以得到谁I2，再插一下我们的观测矩阵，我就可以得到O2I3O3I4O四，最后的I大TO大T，这样的话你会发现通过AB派，我就可以生成一系列的I。

生成一系列的O样本集合，就鬼优了啊，这一类任务呢是可以啊，通过我们啊所谓的样本生成任务解决的，但是呢你很显然这不是我们的核心啊，核心问题啊，这不是核心问题，那么另外一类任务呢。

我们把它称之为是学习任务啊，学习任务，所谓的学习任务呢就是我们已知观测序列啊，观测序列刚才我们说过，他是观测嘛，是可见的是吧，已知观测序列O我们要干什么，那这次就很厉害了，我们要通过观测序列紧。

根据观测序列，我要把谁还原回来，或者计算得到，要把整个在当前已知状态序，这个观测序列O的情况之下，使得当前观测序列出现，概率最大的那个lambda啊，把它构建出来，注意这个按lambda是三个数据结构。

状态转移矩阵A，观测概率矩阵B初始概率向量排，那你只要证明你现在手里只有谁，你手里的牌只有装，只有观测序列O，你需要通过O把AB和派都构建出来，这也是被称之为是学习任务，通过O学习得到模型啊。

这是第二类任务，一会儿我们这个看一下啊，一会我们可以看一下第三类任务呢，我们把它称之为预测任务，也被称之为是编码任务，什么意思呢，我们是通过已知这个时候啊，已知谁，这个时候我们是已知了兰姆达啊。

已知了这个拉姆达模型，有了模型以后，还知道了谁，还知道了我们的观测序列O，然后把谁构建出来，把在当前观测以及当前模型拉姆达条件之下的，那个概率最大的状态序列构建出来，这被称之为是预测任务。

如果我们先暂时不考虑第一个任务，你想一下这第二个任务和第三个任务怎么用，能不能结合一下啊，或者说他两个任务之间的逻辑关系，应该是怎么样的，你注意到了吗，首先我们看一下学习任务只有一个O。

我们就可以得到谁得到拉姆达，那这个时候再由这个O和得到的这个兰姆达，再根据第三个任务，你就可以把谁也还原回来，I也还原回来，回下头回到回到上面，我们看下图，上面那个图有告诉我这个图说明的是什么呢。

我们不知道派，我们也不知道转移矩阵，我们也不知道观测矩阵，我们现在只知道谁，我们现在只知道一个观测序列，或者说只知道观测序列，只知道观测序列，按照第二个任务，我就可以把派A和B，那个兰姆达给你构建出来。

有了兰姆达，再加上这个勾，我就可以把什么，我就可以把所对应的概率出现，最大的I也还原回来，你会发现我们得到的就是一个纯O到谁的映射，过程，到I还有我们这个O是个什么什么结构，是个序列，I呢也是个序列。

这不就是刚才我们所说的什么任务，序列标注任务了吗，能不能啊理解，那么有没有问题，啊这三个任务当中啊，后两个任务其实是，你可以认为是一个任务的两步啊，一个任务的两步，第一步我们仅通过O得到模型，第二步。

通过已知的O和刚刚构建的模型，去得到我们概率最大的I，而这个过程就是一个从O到I的映射过程，O就是我们的已知序列，观测序列，I就是我们的标签序列状态序列，这就完成了序列到B序列的任务。

再进一步的往前推啊，再进一步的往前推，怎么推，再对应到NLP问题当中，我们看一下英拉可夫模型到底在做什么工作，好吧，英拉可夫模型，比如说我们要解决所谓的刚才那个，词性标注任务好吧。

词性标注任务就是我们现在知道什么，我们现在知道的是一串，公序列观测序列，观测序列，就是刚才我们所说的那个在自然语言文本当中，就是谁，就是我们的X，我们能够得到的自然语言文本序列就是谁。

就是我们的嗯语料库啊，就是我们的语料库，这里的X就是成千上万本书，以及成千上万本书当中，这成千上万篇文章里面，这呃成几10万几亿，十几亿上百亿的这种句子语句对吧，这就是我们的语料库吗。

由这些语料库或者说这里的勾，首先我们要构建什么，可以通过语料库，我们可以干什么，可以得到刚才所谓的拉姆达，还记得吧，这是根据那个第二任务完成的啊，就是构建里面的AB派。

然后再由这个语料库和刚才构建的这个lambda，我们就可以得到一个所对应的什么，所对应的I序列，这个I序列就是我们的磁性序列，就可以完成所谓的磁性标注的任务，词性标注的任务，当然在这个过程当中。

最核心的问题很显然是构建这里的lambda，而这个拉姆达是由我们的语料库来构建的，一般情况下，我们把这个lambda是我们的，称之为是我们的语言模型，语言模型哈，因为你会发现这个兰姆达其实告诉了我们。

就是什么，当我们已知啊，当我们已知这个磁性的时候，注意啊，这是个兰姆达模型啊，兰姆达模型里面的AB派，是由状态到观测的序列啊，就词性和词性之间的转换，以及词性到单词的映射，但是呢这个过程啊。

这个过程其实是隐含了我们刚才所说的，语料库信息里，语料库当中的所有的文本信息，这个文件信息之所以可以使用，就是刚才我们所说的，一旦有了这个信息以后，再加上我们刚才所谓的这个可观测的语调完。

然后我们就可以完成相对应的，最大概率的I序列的构建，而这个I序列就是一个一个的磁性序列，就是刚才我们需要完成的次序标注任务，好吧，这个问题呢，就是说通过刚才我们所定义的in max模型对吧。

引出了伊拉可夫模型的三个任务啊，三个任务当中的两个任务，其实是解决我们最终自然语言处理问题里面，或者说解决我们序列到序列问题当中的，这个问题的两个步骤，第一个步骤通过我们的观测得到我们的模型。

通过观测和模型再得到我们的状态序列啊，从一个序列映射到了另外一个序列，这不就是我们的序列到序列标注任务吗，再把这两个序列根据特定的任务进行来设计，J就是我们的语料啊，E1段呃，这个时候应该是啊111句。

哎呀你可以是用句子啊，你可以用段都可以，然后这个地方呢是其实就是我们都要得到的，词性标注的序列，就完成了词性标注任务，那么下面的问题哈，下面的问题啊，这这部分有问题吗，有没有问题，如果没有问题的话。

你会发现下面的问题就是怎么去解决，刚才只是从目标或者从目的上啊，去分析了这两个任务能够解决什么问题，但是具体的解决步骤并没有给出啊，这也不是我们这堂课的核心内容，因为之前的啊视频里面啊。

应该有相应的这个呃介绍部分，如果啊还有同学说，我还希望更进一步的去了解一下这两个问，这两类任务的解决啊，还是那样给大家做一个推荐，就是李航老师的那本统计学习方法啊，现在叫做机器学习方法是吧，新版本啊。

机器学习方法，然后呢这个有比较完整的详细的步骤介绍啊，有兴趣的同学呢可以看一下好吧，那么下面呢我们还是通过一个例子啊，通过一个例子做一个简单的一个说明好吧，做一个简单的说明，那么同样呢我们还是啊。

根据刚才啊那个模型构建完成以后啊，根据刚才的模型构建完成以后，你会发现第一个任务就是一个序列生成啊，就是一个文本序列的生成呃，这个不是文本序列，就是一个序列的生成过程，通过我们的模型。

我们可以得到相对应的序列啊，这个应该都问题不大，那么第二类任务呢其实我们就可以看到，那当我们有了模型以后啊，这个地方呢我们还是定义了一阶模型啊，可以通过模型的训练，我们有了以后。

我们就把它可以转换成所对应的这个呃，呃概率形式啊，相对应的概率形式，然后呢下面呢我们再通过我们的矩阵转换，得到我们最终的这个额预测结果啊，最终的预测结果，这是按照刚才那个呃。

就是疾病正常的那个模型的这个介绍，下面呢就看一下中文分词哈，中文分词其实也是类似的啊，前面两大步，主要部分其实就是构建我们的数据集语料库啊，构建数据集语料库，在这个含LP当中呢。

有啊常用的一些基本语料库哈，你把它呃这个可以看到有基本的语料库，这个直接下载下来啊，直接下载下来解压就可以使用了，然后呢，我们可以在基本语料库上进行模型的构建，这个时候你会发现。

我们可以定义一阶段和二阶的两类模型啊，定义两类模型，比如这两类模型构建完成以后，我们就可以在语料库上进行学习，学习完这个模型，我们就可以进行所谓的啊序列标注了啊，这个时候呢我们要做分词啊。

以商品经济社会的特点是商品流通为例，通过一阶和二阶的模型的分词，你会发现结果是相同的，因为这种句子比较简单啊，没有太大的问题，通过在大量的数据上的一个呃性能的检测呢，你会发现其实非常接近啊。

其实有有差距，但是已经非常接近了啊，而且呢很显然，一阶的性能就是计算的效率要比二阶的效率高，性能上可能会有相应的一点损失，已经足够了，当然这仅仅是举了一个例子哈，这个有兴趣的同学可以从这个RLP当中呢。

还有很多的例子可以看一下，关于第一部分啊，关于第一部分嗯，以马尔可夫模型与序列标注问题啊，这部分还有没有问题，有没有问题，那么如果没有问题的话，我们就进入到下一部分好吧，那这样我们休息5分钟到九点钟。

我们正式开始好吧，这个我倒点水喝，有问题的话，这个可以在这段时间嗯，留一下问题，我们一会可以讨论一下好吧，嗯HMCLF面试会让直接推到全部计算，我觉得应该概率不是特别大。

因为你的面试时间应该没有那么长时间吧，即使是笔试也更多的可能会是一些编程的题目，如果让你直接在HMM3F上做推导，我觉得目前来看可能性不是特别大啊，这只是啊我的一点想法。

当然这种可能性当然一直都会存在对吧，了解一点总是有好处的，特别是推导过程当中，对你今后在一些概率模型的学习过程当中，会有一定的帮助，这是我的另外一点看法，特别是一些相对比较复杂的概率计算。

还是在这个过程当中，能够体现出来他的计算逻辑的，OK那咱们有问题就继续嗯，没有问题的话，我们开始下面的内容哈，那第二部分呢，我们要介绍的就是命名实体识别啊，啊，这部分呢我们用的模型呢。

是这个双向的LSTM和CRF模型的集成啊，这么一类模型啊，这一类模型呢以及是双向的，LSTM加上四点F啊，这种集成方式的模型已经成为哈，已经成为我们在自然语言处理方向啊。

解决这类问题的一种标准范式啊之一吧，不能说是呃这个非常重要的一类啊，是非常重要的一类，那么当然嗯在我们课程当中，大家也可以看到，后续的我们还有这个transformer。

以及基于transformer的BERT模型，以及呃在此基础之上构建的更复杂的，其他的模型，那么这嗯呃这类模型呢，也是可以解决所谓的命名实体识别任务的啊，呃所以说啊，这个模型的发展是不断地进行下去的。

然后呢嗯一个阶段有一个阶段的主要工作啊，我们这个阶段呢会重点介绍一下，双向的LST和CRF模型的这个结合使用啊，结合使用来解决所谓的命名实体识别任务，那么首先呢，我们介绍一下这个双向的LSTM啊。

做一个介绍双向的LSTM呢就是在单向的啊，长短期记忆神经网络的基础上，通过两个方向正向反向，两个方向的训练，充分的啊去挖掘啊，我们这个文本数据的这种顺序特点，来构建的一类模型啊。

那么他也是在单向的基础上嘛，所以我们先介绍一下LSTM，首先是我们的输入向量，输入序列啊，输入序列X1X2，一直到XN啊，XN然后呢其中XT是属于RM的，为T时刻的输入向量，这个地方呢稍微有一点不同啊。

这个地方稍微有一点不同，在刚才我们这个就是啊HMM模型里面，我们每一个时刻输入的是一个标量，对应的是一个字或者是一个词的编号，但是很显然哈这种情况非常少见，我们更多的是将每一个单词。

或者每一个单词的这个编号，通过干hot编码的方式来进行这个输入，这是一种方式，那么现在越来越流行的另外一种方式呢，就是通过embedding啊，通过词嵌入的方式来进行输入。

那么不管是外号的方式还是embedding方式，都是通过词或者字的向量形式来进行输入的，所以这个地方的X1X二一直到XN啊，每一个对应的要么是一个单字，要么是一个单词啊。

在我们这个语料库当中的embedding啊，所以他也是一个向量哈，同样输出就是标量啊，就像刚才我们所说的，你到底是一个如果是一个词性标注任务，那这里的Y1Y2就是每一个磁性的啊，词性编码按N代表的是。

比如说是呃这个名词是吧，V代表的是动词是吧，类似所以这个时候的Y是标量，而X每一个都是所谓的向量啊，就是EMINE向量啊，这是输入和输出啊，这里的YT呢是一到K是我们的输出嗯。

那么LMSTM的结构呢是比较嗯，相对比较复杂啊，相对比较复杂，因为它是在我们传统的RNN的模型的基础上，来构建得到的，RNA模型的基础上来构建得到的，那么我们知道啊，通过前面的学习，我们应该清楚啊。

RA模型的有个问题，就是关于我们的这个呃时间维度上啊，我们要进行一个误差的反向传播啊，就是当前时刻的隐藏层状态，不光是受当前的输入的影响，还受上一个时刻的隐藏层，当然因为这种递推关系是吧。

上一个隐藏层还会受上上一个隐藏层的影响，所以你会发现这个时候我们一旦在隐藏层当中，如果积累或者消除了过多的梯度的时候，这个训练是不能够继续完成的，那么通过分析啊，我们会发现。

就是我们的线性部分和非线性部分啊，造成的不同的累积特性，造成了这种学习上的困难，那怎么办，其实问题也分析到了，也处理起来相对比较简单了，就是将我们的线性部分和非线性部分，进行分别的处理啊。

进行不同的处理呃，关于这本这一部分的论述呢，有兴趣的同学可以看一下那个邱奇峰老师的，深啊，神经网络与深度学习那本书里面的介绍好吧，那么重点呢很显然就是改造了我们的隐藏层啊，改造了我们的隐藏层单元。

我们可以看一下啊，这是我们的隐藏层单元H啊，这是我们的隐藏层单元H同样输入部分是XT，这是没问题的啊，输入部分当前的输入XT是没有问题的，那么除了当前时刻的输入XT之外。

我们还输入了另外两个非常重要的信息，一个是HT减一啊，一个是HT减一，这一部分，我们认为是上一个时刻的非线性部分啊，非线性部分另外一部分呢是CT减一，我们认为是上一个时刻的线性部分。

为什么说CT减一是线性部分呢，我们先顺着CT减一到CT，因为很显然CT是要输入到下一层吗，啊输入到下一层，所以你发现从CT减一到CT，经过了哪些计算呢，我们可以看到首先经过了一个相乘啊。

向量的相乘乘法运算是线性的是吧，我们认为是线性的，还经历了一个相加，我们也认为相加运算也是线性的，所以你会发现在这个计算过程当中啊，这个计算过程当中仅使用到了线性计算部分，所以我们认为啊。

从ct减一到ct是我们完成的是线性部分，线性部分的处理，那么非线性部分就很复杂了，我们可以看到非线性部分呢，从HT减一输入进来以后，首先他需要和T加呃，TIXT进行一个加法运算啊，来保证我们的输入啊。

既包括HT减一，也包括XT相加，完成以后啊，通过这这部分还是线性的是吧，这部分还是线性的相加完成以后，你会发现后面的处理就比较复杂了，首先通过一个SIGMOID的函数，我们得到了FT。

很显然我们可以知道啊，前面的学习，我们知道这个呃SIGMOID的函数是一个压缩函数，是个非线性性的压缩函数，它的压缩空间是0_{1啊，压缩到0}1这个空间里面去，得到了FT。

我们会发现同样的零一压缩还在IT和OT啊，这么FTIT和OT，使用的都是我们的西格贸易的压缩函数，压缩到零一空间里面去，那为什么在这个地方必须严格使用，西格MOY的函数呢。

因为我们知道西格MOY的函数的这个压缩空间，零幺对应的是我们的一个概率空间，就是我们的概率为零，概率为一啊，零幺空零幺这两个值啊，对应的是我们的两对应的是概率空间。

而这里的ft t i t和OT的逻辑意义，都表明了一种所谓的门或者是门控机制，所谓的门控机制，说的是我通过这三个门来对应的，打开和关闭的不同的状态，对应它所提取的信息的多少，比如说以FT为例。

FT通过刚才的非线性压缩，压缩到零一里面去以后，我们可以通过这个零幺值，用来和我们的CT减一相乘，那么很显然通过ft t这个门开闭的大小，就决定了当前C7-1有多少的信息，进行到了下一步的运算当中去。

这是ft t ft t呢，也被称之为是我们的这个遗忘门，为什么叫遗忘门呢，因为很显然，这里的CT减一是上一个时刻的线性部分，通过ft t我们开开大了，开小了，开大了，冲过去的信息又多，开小了。

过去的信息又少，决定了我要把上一个时刻多少的sat部分，进入到下一个时刻里面去，所以他被称之为是遗忘门，那么相应的我们可以看到这里的OTOT呢，我们把它称之为是输出门，因为他是到了最后的输出部分。

来决定信息的输出的多少，同样这个IT我们称之为是输入门，因为你会发现这里它所对应的tie的CT啊，tie的c ct是通过我们的输入信息，经过一个test函数来得到的。

而我们知道这个test函数也是一个非线性的函数，不同的是它的压缩空间是-1~1啊，是关于我们原点对称的一个函数，这个函数呢一个呃性能就在于它的压缩空间啊，关于原点对称啊，两边啊两边是对称的啊。

这个性质性质上好一些，图就是因为这个数学生的性质好呢，所以后你会发现这里探测函数才是真正意义上，在我们的输入，XT和HT减一上进行信息的提取，得到这的till的CT，而这一部分till的ct。

可以认为是我们所有的输入信息的非线性部分，因为通过了一个探索性说法，非线性输入的非线性部分，在CTLT里面进行了存储，这个时候再通过输入门i it，决定在输入的非线性部分。

c tell的T里面提取多少非线性信息，这就是我们输入门和非线性部分的操作，打开还是关闭，这个时候呢我们得到一部分非线性部分，这个时候再和我们前面的CT减一相加，得到最终的ct部分。

ct部分呢可以认为是我们通过上述的处理啊，上述的处理得到的包括了C部分，包括了H部分，包括了X部分的所有信息，然后再通过一个所谓的非线性压缩啊，作为我们当前的非线性部分，然后再和我们的OT门相乘。

来得到相对应的HT相对应的HT非线性部分，这就是我们啊LSTM部分啊，LSTM部分，我们对于我们的隐藏层单元，所做的一个相对比较复杂的一个处理，其中LOSTM引入了门控机制，来控制信息传递的一个路径。

三个门分别为遗忘输入和输出门，取值呢通过我们的C跟VOY函数都在开区间，零幺之间表示以一定的比例通过相应的信息，其中1万门ft t啊，1万门ft t控制上一个时刻的内部状态，CT减一需要遗忘多少信息。

因为它和ct t减一相互操作，输入门IT控制当前时刻的候选状态，那个TT要保存多少信息，it也是门嘛对吧，同样输出门OT控制当前时刻的内部状态，c ct需要输出多少信息给外部状态，HT给为外部状态。

HT你会发现哎，我们通过OT在TCT的非线性部分，我们得到HT，那么刚才是通过这个图形的形式啊，通过文字的形式对这三个门进行了描述，那么门控运算呢我们可以看到啊，通过数据方式XT输入完了以后。

和我们的WF啊全值相乘，加上HT减一，和我们的全职UF相乘，再加上一个偏执BF，通过co mol函数哎，就到了这个部分，再通过S函数就得到了ft t，同样的i it啊。

同样的i it也是通过XT乘以WI，加上HT减一乘以UI加上bi也通过一个，S函数得到i at，同样OT是通过WXT和WO相乘，HT减一和UO相乘，加上BO再进行一个西格玛映射，就在这里。

得到相对应的OT，其中CMOID为我们的logic函数，输出的是零幺空间，XT为当前的输入，也是体检一为上一个时刻的外部状态，那么这个时候很显然，因为XTHT减一和CT减一都是已知的啊。

唯一不知道的就是谁，就是那个跳的题，那那唯一不知道的就是这个tie的c ct是吧，TIOCT呢就是候选状态等于什么，等于XT乘以WC，加上一个HT减11个UC加上一个BC。

再通过一个TX函数的映射得到TT，所以这个地方在这，就得到了我们的候选状态，这个候选状态在和我们的IT相乘，就得到了我们，啊在CT减一部分里面过来的信息，相加之后的CT值就这样可以运算得到了。

我们看下面对吧，就像刚才我们说所说的T减一和FT啊，遗忘门和ct相乘之后就到这个位置上了，然后呢加上谁加上IT和CT的T，IT和TL的CT到这个位置上了，他们两个再相加就得到了最后的CT值。

只有c ct值，然后同样HT呢是在我们的c ct的基础上，进行一个探索映射，c ct的基础上进行一个探索映射到这，然后再乘以我们的OTN最后得到了HT，所以说你会发现啊，图示也好，公式也好，文字也好。

其实说的都是一个事，只不过呢每一种工具所描述的事情的方式啊，形式是不一样的，但是逻辑是完全一致的，你通过图公式就可以写出来了，看公式啊，就可以把图画清楚了，有了公式，有了图。

你逻辑你通过自然语言的方式描述清楚，不就完了吗，所以说啊这个刚才有一个同学问啊，就面试的时候会不会嗯要求你对吧，把一马可夫模型甚至CRF模型，甚至包括这里的LSTR模型，这个公式让你推一遍啊。

嗯你说完全不可能嘛，这个可能性总是存在的啊，但是呢你掌握了这些内容以后，你说啊你先说哎呀，这个公式我真的忘了，但是图我会画，你画出图来以后啊，和我觉得和那个公式的逻辑应该是保持一致的。

其实你说你画你图会画不会写公式，其实我不太相信啊，因为逻辑都是一样的嘛，对吧好了，这是关于这个LSTN部分啊，就是基本的单向的长短期记忆神经网络啊，这个有什么问题吗，嗯没有问题是吧，好了没有问题的话。

我们就继续看一下这个应用是吧，你这个模型有了以后还是需要用，我们以这个图为例，这个图已经描述清楚了，我们关于单向的LOSTM怎么去使用，这一个问题，你会发现嗯，单向的LSTM也是能够解决。

序列到序列的标注任务是吧，序列到序列的映射任务，因为你会发现我只要在输入层，每一次输入一个相对应的单词啊，每一次输入一个相对应的单词，那我们就可以得到同一个时刻所对应的一个，不管是分词的符号也好。

还是一个词性的标注也好，都是一个序列到序列的一个映射，这是没有问题的，而且因为它是一个所谓的循环神经网络，的一个很重要的改进，所以他依次使用到了前向的输入信息对吧，这是单向的LSTM。

那么双向LSTM是怎么样的，双向的LSTM，你会发现其实就是将我们的训练顺序啊，训练顺序进行了转变之后，其实是训练了两个网络，一个网络是什么，一个网络就是刚才我们所训练得到的前项啊，前向的网络。

它的输入顺序就是按照我们的文本顺序，相一致的输入啊，就是就是前面我们的LSTR，这是第一个网络，那么第二个网络呢其实本质上也是一样的，逻辑的，L s t m，唯一不同的是。

训练反向网络的LSTM的时候的，这个输入数据的输入顺序是相反的，是和我们的语料库里面的信息的语料顺序，相反的顺序，你会发现刚才的数自然语言的顺序的逆向顺序，作为我第二个IOSTM模型的训练好吧。

有同学这个时候就有困惑了，有什么困惑呢，哎不对呀，哪儿不对，你从左往右是按照我们自然语言的语序输入，这是没有问题的对吧，这是没有问题的，因为你这和我们正常的说话的顺序一致吗，你的语料库有这些信息。

我就是按照这个顺序信息输入来训练模型，这是没有问题的，但问题在于我们的自然语言里面，可从来没有说反着说的，当然除了有种特例咳，叫做倒背如流是吧，倒背如流，但是那只是传说而已，或者说只是一种特例而已。

我所有的语言顺序都是顺序型的，你这种倒叙顺序有什么作用吗，哎就是刚才所谓的倒背如流，大家想一下所谓的倒背如流体现的是什么，体现的是所谓的熟练程度，当然这里不是所谓的熟练程度啊，也就是说。

倒背其实也蕴含了某种语言的顺序特征，这个大家想想是不是也是这样的，而有的时候这种倒叙的语言特征，可能就包含了顺序语言特征当中没有的，或者是忽略到的信息，大家想想是不是这么个逻辑。

但是即使是倒叙的这些语言顺序，它也是我们顺序特性的一种特殊的表现形式，因为顺序语料是存在的，顺序语料的逆序同样是根据顺序语料所得到的，所以它同样也蕴含了顺序，语料里面的所有的信息。

同时反向的这个序列可能还蕴含了一些，我们只通过顺序序列而忽略了，或者学不到的一些信息，所以说哈这个逆序或者反序的序列，对我们模型的学习是有帮助的，这是第一点，第二点就刚才所说的，可是我自然语言过程里面。

可我从来不会说倒着说一句话，你后面的模型使用的时候怎么样，你还需要因为我们知道这个人说话是顺序的，你后面的单词一定是，在前面单词说完了以后才说的，你倒叙你没说，你怎么有数据呢，对吧，这是第二类问题啊。

第二类问题，这类问题呢其实也是很好的一个问题，但是呢可能有点想多了，为什么想多了呢，因为大家想想，我们的模型训练和模型使用其实是两个阶段，而模型使用一定是你积攒了大量语料库以后，才进行模型的训练。

你已经积攒了大量的语料库，那么说你现在已经积攒的这些语料库，里面的信息其实已经是存在的信息，所以也就无非只是在顺序上，是从左往右的一个线性顺序，但是你这个时候你一定知道了，哎。

这个时刻的下一个单词或者单字是什么呢，那么到了使用的时候，因为你的模型已经根据了语料库里面的数据，训练完成了，所以你在使用的时候，你只需要输入顺序信息，他就可以根据在顺序和逆序两个方向，学习的内容。

再得到它所对应的标签了，是不是这样，所以啊这个时候有点有点稍微做点分析，你会发现两个问题啊，第一个问题有没有用，一定是有用的啊，逆序肯定是有很重要的信息的，这是第一点，第二点，额就是怎么用的问题啊。

你会发现训练和使用是两个阶段，训练的时候你已经已知库是已知，所以顺序用逆序用你都可以用对吧，用完了以后模型已经训练好了，使用的时候你只需要顺序输入它，就应该将相相对应的信息输出出来了。

好吧这个多说两句吧，这是这个图上看到的信息，那么看一下具体实践当中，那么这个时候就像刚才所所说的训练，其实训练两个模型，第一个模型是HT啊，正向的HT，第二个模型呢是逆向的HT啊，反向的HT。

那这个时候呢我们的双向的LOSTM呢，在T时刻呢，就是将我们的顺序的HT和逆序的HT，进行了一个向量相加，直接加起来就得到了当前时刻的HT，当前时刻的HT最终，然后再通过一个权重V矩阵。

得到最终的输出YT就可以了，好吧，关于这一部分啊，LSTM部分，以及双向的LSTM部分有没有问题，好没有问题的话，我们就继续哈，那么双向LOSTMM完成以后呢，下面就是和条件随机场模型的一个结合。

使用的问题了，那么我们可以还可以看到啊，首先介绍一下条件随机场模型，条件随机场模型其实和我们的英拉普模型，在我们的这个图示方面上其实还是比较相似的，嗯但是呢需要注意一点的是。

CRM模型是一个无向图表示的啊，它没有顺序性啊，它不像我们的HMM里面，状态序列和观测序列啊，状态之间和状态观测之间的这种顺序关系，它是定义在无向图的之上的，但是结构上也是分这么一个啊。

一个我们的这个呃两个序列啊，两个序列其中也是构建了一个无向图结构，那么其中呢我们可以看到cf模型呢，是一个条件啊，是一个条件概率模型啊，是个条件概率模型，这个条件概率模型呢，是定义在两个特征函数之上的。

其中一个特征函数呢我们把它定义为是TK啊，TKTK特征函数定义的，定义的是我们的边上的啊，定义的是我们的边上的特征函数，既然是定义在边上的特征函数，那么很显然这里的边就需要两个节点来表示。

两个节点来表示哪两个节点YI减一和YI，如果这个是YI减一的话，这个是YI减一，那么这个就是YI节点，所以这两个节点之间的边上的特征函数，就是刚才我们所说的T函数，TK函数，这是一类特征函数。

另外一类特征函数呢，是定义在节点上的特征函数啊，既然是定义在节点上的特征函数，那么节点嘛就是当前节点，所以它只有一个Y相关好吧，这是两个不同的这个特征函数，有这两个特征函数以后。

前面是每一个特征函数所对应的全值系数啊，全职系数兰姆达K和缪5L兰姆达K和ml，将我们所有边上的特征函数，乘以它所对应的全值系数，加上所有节点的特征函数，乘以它所对应的特征系数啊，作为分子部分啊。

作为分子的指数的呃，作为自然指数部分，然后呢除以我们这个规划因子，得到的就是条件概率，得到了谁的，条件概率是当已知输入X作为条件之下，Y的条件概率为什么叫条件随机场，这个地方的条件随机场。

随机场说的是我们的商量部分，这一部分是条件随机场，而且呢其实准确点说应该叫做线性链，条件随机场线性链条件随长，因为所有的节点都严格依赖啊，都是一一对应的啊，这被称之为线性链模型啊，线性链条件随机场。

在线性变平行式离场的基础上，我们再加上条件，下面这个是我们的条件，X就是这是X序列，这是我们的Y序列，X序列是作为一个条件序列存在的，Y序列是我们作为一个要得到的标签序列，存在的啊。

这被称之为条件随机场，那这个时候呢，我们就可以得到相对应的条件模型啊，条件概率模型，有了条件概率模型以后呢，按说哈这个看一下这个条件概率模型，条件概率模型，哎我现在问一下同学们。

就是嗯大家在学习模型的时候，我们说机器学习模型，机器学习模型是吧，那什么是机器学习模型，我们一般认为机器模型，机器学习模型可以有两类，第一类模型就是FX对吧，我们直接通过输入X以后。

我们直接得到我们对应的输出Y等于FX嘛，做函数，我们标准函数模型啊，这是一类模型，另外一类模型呢，我们可以认为它是一个概率模型，我们Y等于什么，我们Y是，要在所有输入X条件之下。

得到Y的那个概率最大的Y值，作为当前的标签输出，这是模，这是概率模型是吧，所以说你会发现，当某一个模型已经可以得到所谓的X条件之下，Y的条件概率的时候，其实已经可以认为当前的模型怎么样了，已经得到了。

你给我一个X，我给我给你个Y，你给我一个X，我给你个Y啊，你给我一个X，我给你一个Y的概率值，你给我一个X，我给你个Y的概率值，在所有的Y的概率值我都已知的情况之下。

我只需要求一下当前概率值最大的那个Y，作为我当前输入X所对应的标签，是不是就可以了，这是概率模型吗，如果说从这个角度上去看啊，如果说从这个角度上去看的话，你看一下，你想一下。

那CNF和我们的LSTM可以怎么用啊，就是这个图啊，就这个图，清楚问题了吗，我把问题再表述一下啊，就是条件随机场模型，其实就是以X作为输入条件的之下，你所得到的标签外的这么一类模型啊。

并且呢我们可以看到从它的定义形式上，他得到的是一个条件概率模型，条件概率模型得到的是已知X输入之下，每一个标签的概率值，我只需要通过扫描一下，所有标签在X之下的概率值的多少大小。

把那个大的最大的概率值所对应的标签，就是当前我对应的输出标签嘛，所以你会发现这就是那个模型本身，你给我一个X，给你个Y啊，概率值，你给我一个X，给你个Y概率值，那个Y直接就可以通过这个概率值直接得到了。

就直接得到了相对应的标签了，如果从这个角度上讲的话，我的问题在于它和CRF，他和那个LSTM怎么结合使用，因为毕竟我们现在要把他们两个模型，结合起来嘛，就这个图啊，这个图好像一目了然。

又好像不是特别的一目了然嗯怎么结合的，关键在哪，关键在这个地方，就是关键在这个这个往上指的这一部分，为什么这么说呢，如果说我们把这个地方哈认为在这，你看看如果把这个这个图稍微改造一下。

就我不管你这个你你你这个这个部分啊，你对于这个cf来说啊，对于cf来说，我不管你这个X条件是怎么得到的，你是LSTM也好，你还是什么什么其他的模型也好，我就把它哎，我就把它作为一个条件输入嘛。

我就把它作为一个条件输入进来，然后直接上面再挂上一个CRV模型，是不是就可以了，因为CRM，sin f模型本身就是一个概率模型嘛，我就可以得到一个，你当前我不管你怎么输入进来的一个X以后。

我给你一个对应的输出，是不是就完成了这最朴素的一种想法，将我们的LOSTM和我们的cf模型，进行结合的一种方式是吧，我看看同学有什么问题，额不是发射概率嗯嗯我大约能够感受感，我能感受到你你的一个意思。

但是稍微不太准确，其实你和你和下面所介绍的这个这个这个内容，是我认为是相一致的是吧，也就是说你这个X是作为已知条件，就先F列条件随机场嘛，你得有条件啊，条件谁要条件就是X啊，你这个X怎么来，我不管你。

我不关心你是吧，你是通过直接的一个硬编码给我的，还是通过完后的编码给我的，你还是通过什么其他的模型，embedding给我的，我不管对吧，你只要给我一个X，然后我通过条件随机场模型。

我就可以给你一个对应标签的概率值，你再扫描一下标签大小，你就可以知道对应的标签是谁了，从这个角度上讲的话，其实CRF和LSTM的这个使用是相当，这个直接的，就是直接将什么，将LSTM模型的输出作为条件。

随机场的输入是不是就可以了，没问题吧，只不过稍微复杂一点，那我们现在将这个LSTM改成一个双向的，L o s t m，其实问题也不大，没问题吧，就简单一点儿，最朴素或者最简单的一种啊。

将我们的LSTM和CRF结合使用的方法，就是把LSTM的这个输出，作为CRF的输入就完了，这也是我们最朴素的一种方式，没问题吧，但是呢遗憾的是呢，问题总不是那么的简单，问题啊总不是那么的简单。

那么看下面啊，带着这个问题啊，我们看看到底他两个是怎么进行结合的好了，在介绍完这个cf模型的定义的时候呢，还给出一个所谓的叫做转移得分的，这么一个结果啊，注意啊，他叫做转移得分。

转移得分呢被定义为下面这种方式啊，被定义为下面这种方式，这个方式呢是YI减一，YI减一在哪儿，你得找找啊，YI减一，那YI减一在这是吧，YI减一在这它作为条件啊，它是作为一个已知条件，条件概率嘛。

它作为条件之下YI的概率值，YI的概率值，哎你看他这个所谓的所谓的转移得分啊，是他俩之间的条件概率啊，通过我们嗯，之前应同学们应该知道这个加法模型，这个这个概率模型，这个他的加法计算公式。

和这个乘积计算公式是吧，条件概率嘛，条件概率我们可以啊，通过我们的联合概率除以边缘概率的形式，来得到，这个没问题吧，什么意思呢，联合概率PAB，联合概率等于什么，等于P。

B条件之下的A的条件概率再乘以谁，再乘以PB吗，现在我们要一个条件概率，我只需要把PB怎么样，把PB是不是除过来就可以啊，除到这来，P b，对吧，这就是我们的条件概率在这，然后呢。

我们用联合概率除以这个边缘概率就可以了，嗯这个东西呢被定义为是转移得分啊，转移得分，那么我们再看看分析分析这个转移得分啊，分析下转移得出，我们会发现转移过Q里面的联合概率。

联合概率呢我们在cf里面是可以计算得到的啊，cf里面是可以计算得到的，是通过阿尔法贝塔比上1ZX得到，然后另外一部分呢这个Y2-1啊，y 2-1，我们也额Y1-1呢，我们也是可以通过额我们的这个计算。

我们可以得到的呃，这是X输入直线的Y，我想看这是额X输入之下的YI，OKX输入值下的Y的，这这是那个联合概率啊，这是那个联合概率，这是两个概率啊，YI呢是在X条件之下的，Yi。

我们可以通过计算得到这个YI减一和YI呢，是联合概率，是在X趋向之下的联合概率，我们也可以通过阿尔法M贝塔以ZX计算得到，这两部分呢我们计算得到以后，把它带回到转移得分公式里面去。

在这这个在这里我们就可以得到一个所谓，转移得分的这么一个结果，我们分析分析这个转移得出的结果啊，首先这个转移得出结果里面，使用到了我们的X条件之下的Y，就是刚才我们的CR模型的输出啊，cf模型的输出。

第二个呢还使用到了什么，还使用到了YI减一和Y的联合概率，还使用到他们的两个的联合概率，注意啊，这个联合概率意味着我当前要得到YI的时候，使用到了上一个时刻YI减一的信息，好吧。

上一个是个YI减一的信息，那么有了这个转移得分以后怎么用，看下面，如果你读一下这个双向的STM和CRF，模型的这个论文的时候，你会发现它呢是这样来使用的，看一下。

首先我们先来训练我们的双向的LSTM模型，有了双向的LST5模型之后呢，我们可以得到一个数，所谓的输出分支矩阵，这个输出分支几阵呢，其实就是刚才我们啊，就是刚才我们通过LSTM得到的，你在当前输入之下。

为第二个单词所对应的，第几个标签的一个分数啊，就是一个其实也是就是一个，你可以认为是个概率值啊，这是第一部分，注意这一部分是通过双向的LSTM得到的啊，这是一部分，另外一部分呢就叫做转移分值矩阵。

转移分值矩阵就是刚才在哪，在这这不是转移分值吗，转移分值是个条件，概率是个已知YI减一的条件之下，YI的条件概率，非常类似于我们前面讲到的那个呃，HMM模型里面的状态转移矩阵，因为它牵扯到了两个时刻的。

任意状态之间的转移啊，所以他应该也是个矩阵啊，记住了任意两个状态之间的转移关系，这个呢被称之为是转移得分矩阵，用A来表示，注意为什么是个K加二乘以K加二呢，因为这个地方呢稍微注意一下。

是因为第一个状态他前面没有，所以这个时候呢我们给他一个凭空造一个，然后呢最后一个状态呢后面也没有，所以我们也凭空造一个，所以这个时候如果中间是个K的话，那么加上两头，所以就变成了一个K加二的。

然后呢他既然是个矩阵，所以就变成了一个K加二乘以K加二的啊，这个说明一下，好了有了这两个矩阵以后啊，有了这两个矩阵以后，看下面那么模型的分支注意吗，这个是LSTM的模型输出的结果。

这个呢是我们CRF模型啊转移分值的结果，然后呢整个模型是不是整个模型就是双向的，LSTMCRF模型，我们认为它是整个模型的结果是什么，是这么一个东西，就是我们要将我们A矩阵里面的值。

和P矩阵里面的值进行相加，也就意味着你可以简单的认为啊，就是P加A，你会发现这和我们刚才所想到的第一种，那个朴素的方法是不是不太一样，我们刚才那个朴素方法是怎么得到的，是直接将LSTM输出完了。

结果直接扔给我们的CNF再进行训练，因为刚才我们说过，这就是个模型吗，你这个X怎么来，你爱怎么来怎么来，你可当然可以通过一个LSTM输入进来，然后我再训练一个CRF。

但是呢在论文里面的实现确实这样来实现的，也就是说它的模型的结合的方式，其实是使用了两个模型，在分别训练完成以后，将结果进行了融合，而不是将过程进行了融合，我不知道这个啊能不能分清楚哈。

有了P加A的结果以后啊，有了P加A的结果以后，我们通过S函数来表示，然后呢，我们只需要啊，生成一个相对应的输出概率就可以了，而这个值呢我们把它进行一个soft max的一个呃，概率概率化就可以了。

E的X乘以XY次幂，比上一个规划因子就得到了，当前在输入X条件之下，Y的输出概率，当然我们可以定义相对应的对数sin函数，然后呢只需要将最大的那个函数值取出来啊，就可以了，啊这就是我们对啊。

双向的LSTMCR5模型的一个介绍，看看有没有问题，其核心话就是你分析一下，你要将两个模型进行混，就是结合使用的时候的，结合方法其实有多种方法啊，有些方法呢是过程融合，有些方法呢是结果融合，各有各的嗯。

侧重点吧是吧，这个你需要分清楚就可以了，这一部分有没有问题，没理解这个就嗯嗯，嗯因为这个CRF模型和这个LSTM模型，包括上面的hmm模型啊，其实在我们呃视频资料里面都应该有介绍了，是吧。

这不是我们的重点，重点呢，其实我们需要第一个需要解决的是，模型的融合问题，就这两个模型怎么样能够结合去了，结合起来去解决问题，第二个呢是解决什么问题的问题，那么先看怎么结合，如果我们先看图说话嘛对吧。

先不管这个cf和这双LSTM的，这个呃细节的计算逻辑部分对吧，我们我们就就看这两个图，你会发现其实只从图上来看的话，给我们一个非常直接的一个启示，就这两个模型的结合其实就很直接，为什么很直接呢。

因为我们可以看到这个cf，而通过最后的模型定义，你会发现我是可以得到当前的条件概率的，有同学说，和谐就不动，哎我们就看图嘛，我们就看图好吧，你先看看就是CNF模型的这个结合啊。

这个这个这个定义告诉了我们，是你就是在已知X条件之下Y的输出概率值，所以你也就是说我最终的目标就是已知X给我，Y只有cf，我不管你到里面什么特征函数边上的，还是节点上的，还是这那的，我都不管。

我就是得到的是一个从X到Y的映射对吧，你给我X我给你Y就是cf的工作，那么LSTM是干什么，LSTM其实也很简单，也是你给我一个，你给我一个输入，我给你一个映射对吧，我们看上面哎，你给我一个输入。

我给你个映射，你给我一个输入，我给你一个输出，这两个模型啊都能完成从输入到输出的映射，但问题是这个时候呢我们稍微等一下，稍微等一下，现在我们要做的是什么，现在我们要做的是八尺量这两个模型啊。

结合起来怎么结合的问题，从这两个模型本身的这个咳咳这个结构上，其实我们可以看到，如果说我现在训练一个双向的LOSTM啊，训练一个双向的LSTM，然后呢把这个双向的LSTM的输出结果，输出结果作为L呃。

作为CRNF模型的输入进去，再训练一个相对应的CRF模型，可不可以就说如果现在我一刀切在这下面，我怎么得到的这些输入，你一个也别管，当然我知道我是通过一个双向的LO，STM来的嘛，然后呢。

我就把这些输入再把它输入给一个cf模型，完成CRF模型的训练，以CRF模型的输出作为我整个模型的输出，可不可以，当然是可以的，所以从这个角度上来看的话，其实这两个模型的结合是非常嗯直接的啊。

就是一个的输出，作为一个的输入嘛，这也符合我们之前所讲到的，那个所谓的端到端的学习方式，到这没有问题吧，就是你通过训练啊得到了两个模型，这两个模型呢我们要不要整到一块去，怎么整一块去，也很简单。

把其中一个模型的输出，作为另外一个模型的输入嘛，就说我们前面在啊，你应该是这个，这个我我给大家应该是第一次这个上课啊，在我我在咱们这个网站上有很多我的视频，大家可以看一下。

特别是我们现在还有一个这个秋季鹏老师那种，神经神经网络与深度学习的课程，其实那里面我们把这个模型的训练，其实你会发现所谓的n turn的是吧，端到端的学习就是一个模型的输出，作为另外一个模型的输入。

现在只不过我现在是要继承两个模型，一个是LSTM，一个是cf，我现在就把LSTM作为输出，把输出之后的结果作为cf的输入，再输入训练一个cf可不可以，当然可以，这最直接的结合两类模型。

训练性性能的一种方式，这是非常直接的呃，但是哈如果有兴趣的同学，你读一下那个4S那个双向LTMCRF，那篇论文啊，就是最原始就是不是最原始的，就是当时的那个发出来那个论文的工作。

你会发现他不是这样做的啊，他不是这样做的，它的结合呢是这样来结合的，首先这个P矩阵就是刚才我们所说的那个L，STM的输出啊，这个是没有问题的啊，这个是没有问题的，麻烦就麻烦。

它里面是要得到一个叫做转移分值的矩阵，那就是转移分值矩阵，转移分布矩阵这个概念啊，在那个L在那个cf里面没有直接的给出啊，其实是没有直接给出的，通过公式分析我们会发现所谓的转移得分啊，所谓的转移得分。

就是从YI减一到YI的转移概率啊，就是从YI减一到YI的转移概率，其实也好理解啊，他说的是从谁到谁的转移，从YI减一，到YI的转移吗，大家想一下这是什么意思，也就是说哈我们以这个词性标注为例啊。

以词性标注为例，如果我知道的我的前一个单词的词性是动词啊，是那个动词的话，那么你想一下，是不是也对决定当前单词的词性，有很大的帮助啊，为什么呀，因为如果前一个单词是动词的话，很显然有些词性你是不能用的。

比如说介词，动词后面不能跟介词吧是吧，动词后面可以跟什么动词，后面可以跟名词对吧，表对象啊，你可以加上，也不能加形容词了是吧，你不能动词后面用形容词对吧，然后你会发现也就是说啊，作者考虑的更多的是什么。

作者考虑的更多的是当我在cf模型当中啊，前面一个输出结果，对我后面一个输出结果一定也是有影响的，所以他使用的是所谓的转移得分儿，而在转移得分的计算过程当中，我们又会发现转移得分当中使用的两个概率。

联合概率和边缘概率，特别是其中的这个边缘概率啊，特别是其中这个边缘概率其实就是cf模型本身，我已知X要得到Y嘛，而是可以通过直接计算得到的，另外一个概率就是联合概率，也是在已知X条件之下的联合概率。

我也是可以直接计算得到的，换句话说啊，这个转移得分当中即包含了模型的输出，已知X得到Y的模型的输出，也包含了什么，也包含了上一个时刻的输出，对当前时刻输出的影响，所以说作者这样的设计。

其其实是还是蛮有道理的对吧，如果我们仅从这个啊，如果我们仅从这个CRF模型本身来看的话，其实也是很有道理的对吧，我我我要得到的这个转移得分啊，其实它既包含了我当前输入，对我当前输出的影响。

也包含了我上一个时刻的输出，对当前时刻输出的影响，所以这个转移得出里面的信息，蕴含的是非常非常多的信息，而在进行两个模型融合的时候啊，而在进行两个模型融合的时候，并不是用啊这个LSTM的输出。

作为我cf的输入，而是直接将两个模型的输出结果进行了相加啊，直接进行了相加，相加之后得到了一个所谓的模型分值，然后使用模型分值在soft max上进行概率化，得到了每一个输入X之后。

所对应的标签输出的概率值，同样我只需要查一下概率值哪个大，作为当前的最优输出就可以了，对是这样的，你会发现啊，特别是到了后面讲到那个什么，讲到那个encoder，Encoder decoder。

就是那个编码器解码器的时候，特别是在解码器阶段，你注意注意那个解码器阶段的那个输入，就很有意思，那个解码器接那个解码器阶段的输入，直接就将上一个时刻的那个输出，作为当前时刻的那个那个那个输入的一部分。

对吗，是这样的，就是因为因为我们其实最后的输出的，也是个序列对吧，既然这个序列，这个序列除了严格依赖于当前时刻的输入之外，他肯定也和上一个时刻的输出是密相关的，因为上一个时时刻输出。

就是我上一个时刻的前面那个那个那个输出嘛，对我应该是序列，因为是序列，就是顺序性，也一定程度上影响了我当前时刻的输出对吧，OK那这个时候OK那就那就完了嘛，那就将这两者作为一个嗯完整的信息。

来进行一个概率化，得到相对应的概率分布，最后得到相对应的标签就OK了，下面还有一个啊，下面还有一个实例啊，其实先说明一下，就是刚才我们所说的那个任务啊，任务就是说所谓的这个命名实体识别。

命名实体识别其实核心就是实体识别，实体识别，就是你当前句子里面有什么样的实体啊，这是在我们NLP方向啊，这是图谱的构建里面非常重要的一步操作啊，就是构建当前呃实图谱当中啊，有哪些实体啊。

实体呢其实主要是以名词啊，作为这个主要的构成对象的是吧，呃介词都不是啊，就是名词啊，就是但是呢在这些名词当中呢，你还必须要给出一些命名的实体，所谓的命名实体呢就是一些重，就是看你怎么去定义了。

比如说人名啊，地名啊，实体这个实体的概念，这个你需要你这个需要根据你语料库里面的，这个这个情况来进行自己定义的啊，比如你给出相应的命名的这个范围对吧，人名地名组织名对吧，相应的还有其他的名称。

这个是完全看你的训练集的情况，然后呢下面呢我们举了一个例子是吧，根据这样的样例集啊，根据这样的样例集，比如说里面使用到了组织名称对吧，人名那职业是不是也是一种名称，这个都是需要看你数据集的情况。

当前数据集里面的情况，将组织名人名啊，把它找出来了啊，所以这个时候呢，同样我们通过LSTM训练一个模型，然后呢再和呃cf呢进行一个结合就可以了，最后就可以得到我们相对应的模型输出了。

但是呢呃这个地方说明一下啊，就是理论和实践部分，有的时候的差距是非常大的啊，理论是理论，实践是实践啊，刚才说的那些呢，也仅仅是某些论文当中所反映出来的内容，它不一定是最优的是吧。

也可能在其他的模型结合方式的基础之上，可能得出一些更好的结果，这也是可能存在的啊，所以说这些内容呢只是介绍了这些内容啊，我们做一些事实上的描述，至于价值判断啊，是不是这些模型就一定好或者一定是最好的。

这个需要根据实际的情况加以分析，好吧大家看看还有什么问题吧，我们在一块回顾一下我们今天的这次内容，啧呃如果有兴趣的同学啊，你回去的时候可以看一下，在姨妈可夫模型里面呢，这两类问题的计算啊。

就是学习问题和预测问题的计算，学习问题呢倒稍微还好一点，因为最多就是一些稍微复杂一点的概率计算啊，稍微复杂一点的概率计算，然后呢预测问题呢我们是用的那个维特比啊，这个呢稍微其实就是个动态规划。

也没有什么太太太太大的问题啊，稍微仔细一点，特别是这些符号能搞清楚了，就应该问题不大了啊，剩下的工作呢其实有了这些基本概念以后呢，剩下的结合着特定的嗯语语言包啊，你直接调用就可以了，这是HMM部分。

CRM部分呢其实也是类似啊，也是类似，特别是一些具体的这个嗯啊这个地方多说一句，这个cf里面的这个模型表示哈，其实是个挺挺，那个重要的一点，就是怎么样表示当前的CRF模型，我们有咳。

因为里面特殊就特殊在这里面的特征函数啊，特征函数有边上的特征，有节点上的特征，这个时候你需要特别注意到，因为嗯边上的特征函数和节点上的特征函数额，有区别，也有联系，因为边N是由节点构成的。

两个节点决定一条边对吧，这个时候呢在形式上，我们可以通过在节点上的特征函数，增加一个无用的标识，来将我们的边上的特征和节点上的特征，统一起来啊，这样可以在形式上啊。

形式上简化我们的这个cf模型定义形式啊，可以由这个呃标量形式转成向量形式，由向量形式转成矩阵形式啊，所以你会发现下面的计算，我们都是在向量和矩阵上来进行完成的，前向向量，后项向量加上我们的M矩阵啊。

就可以完成绝大多数的计算的结果啊，那这时候这些结果的使用，就看你怎么进行模型的设计了，呃是这样啊，这个，排头这部分呢是调用实验过程，这个呢不是作为我们这次课的主要核心，讨论的地方，如果要讲这部分内容呢。

我们需要非常细节的展开，整个的反向传播计算逻辑，就那个自动微分部分，就是我们需要看一下，就这是其实是个好问题，就是嗯呃我不知道你们前面的课程内容啊，就是关于LSTM部分之后。

ls s部分LTM部分的反向传播部分，你们是怎么去介绍的，这个时候呢麻烦就麻烦了，你还需要和CRF搞到一块去，这个时候的反向传播怎么去微分计算，其实是个挺麻烦的事情啊，所以这部分。

这不是我们这一次课能够展开讨论的内容，好吧，如果我们聚焦的话，稍微聚焦到我们就是模型部分，可，这样说吧，既然你的前辈都已经动用了BT模型了，那这时候的cf模型，其实已经意义上不是特别大了。

其实我觉其实你会发现嗯，波尔特模型本身的强大的学习能力，已经足够的应付当前的这个什么，就是呃当前的问题的解决了，已经没有必要在后面非要再挂上一个cf了，因为他已经起不到太大的功能的，性能上的提升了。

反而是不是有些画蛇添足的意味对吧，啊最后说说一说一点吧，因为嗯咱们这个方向是自然语言处理方向，然后呢其实从这个方向来看的发展趋势，大家可以体会的到。

以transformer就是以TENTION机制为基础的，transformer架构，在这个方向的工作，起到的作用是越来越突出的啊，刚才这位同学也说到了是吧，以transformer为基础的BT模型。

以及以这类模型为基础的一系列的模型的发展，所以呢我非常建议大家能够沿着这个方向啊，沿着你应该自己能够梳理出啊，能够梳理出这个方向的一些核心模型的，演进过程和演进流程。

因为我们知道每一个模型都是在前序模型的基，础之上改进优化得到的，所以这个路径哈你自己应该构建出来对吧，当然你可以参考很多的资料，但是这个工作呢我觉得还是有一定意义的，如果你构建构建出来以后呢，啊。

特别是应付一些什么面试呀对吧，这种方这种这种问题，可能相对来说就就就简单容易一些，当然这仅仅是一部分啊，还需要进行大量的实践的操作部分才可以好吧，那今天我们的内容呢就是这些，如果有什么问题的话。

我们可以在群里再集中讨论，好不好。

OK谢谢大家。

标签：这个,在线,一个,模型,笔记,公开课,概率,序列,我们
From： https://www.cnblogs.com/apachecn/p/18498037