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

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

1447-七月在线-机器学习集训营15期 - P11：5-机器学习简介、广义线性模型（线性回归、逻辑斯蒂回归）精髓速讲 - 程序员技术手札 - BV1ASste6EuZ

嗯OK啊。

如果没有问题的话，我们就准备开始，好吧啊，非常高兴啊，能够呃和大家一起啊，从今天开始呢，我们一块把这个机器学习当中的，一些主要的内容利用，咱们差不多一周多的时间，两周的时间呢我们嗯做一个学习和讨论。

嗯先做一下自我介绍啊，我是那个咱们企业在线的那个陈亮呃，在课程群里面呢，我也在啊，如果有什么问题的话呢，包括我还有其他的老师，还有咱们的助教老师都在课程群里面啊，包括咱们课程当中的一些问题。

也欢迎大家在课程群里面能够啊及时的提出来，我们也一块进行一个讨论和学习，那么在今天开始之前呢，先和我们大家介绍这么一个内容，就是关于我们嗯机器学习的若干个模型之，间的一些模型关关联关系。

这个内容呢可能呃和很多很多接触过的同学哈，可能会有一些印象，就是在我们整个机器学习模型的学习过程当中，我们会逐渐的越来越深入的接触，越来越多的模型和算法，那么呃很多的同学啊。

都花了大量的时间在这个方向当中，非常努力地进行学习，但是很遗憾的是啊，有的时候会出现一个问题，就是当我们学得越多的时候，会发现这些模型和算法啊，有些没有章法和没有逻辑啊，就说我们每天都在学很多新的东西。

但是回过头来一看，好像学了很多，但是好像又没有一个呃能够梳理清楚的脉络呃，我觉得这是非常重要的一个问题，就是当我们在进行学习的时候，会发现啊，特别是到了深度学习领域哈，就是我们再进一步的向后学习。

你会发现整个的工作的方向会非常多呃，工作的一些技巧也很多，那怎么去高效率的把它掌握，我觉得还是很重要的，那么今天呢就先通过一个就是关于模型脉络，图案和大家试图通过这么一种方式。

能够使得大家在今后的学习过程当中，能够把这些模型和脉络啊进行一个梳理啊，当你知道了你在哪个位置上，就是你掌握了哪些模型，然后碰到了一个呃新的工作啊，你不了解的时候，你可以发现啊。

你可以寻找一下你之前的工作，是不是和她有所关联关系，或者说新的工作啊，一定是在之前的工作的基础上，进行了某些方面的改进和提高或者是优化，所以这个时候你会发现你要清楚的知道你在哪，你要到哪儿去。

中间才能把任务进行一个分解啊，这样的话效率可能更高一些啊，举个例子啊，比如说呢我们这啊两周的时间，可能要介绍若干个呃机器学习领域的模型，那么这些模型之间啊，肯定是相互之间是有关联关系的，比如说啊。

以今天我们要介绍的，线性回归和逻辑回归为例啊，啊这两个模型啊解决的是不同的问题，一会儿我们会介绍一个呢线性回归，解决的是我们的回归问题，而我们的逻辑回归呢，解决的是我们的分类问题啊，两个不同的问题。

但是呢这两个模型之间是有一个密切关系的，换句话说啊，我们在线性回归模型的基础上进行相应的改造，就可以直接得到相应的逻辑回归模型，这两个例子啊，或者这两个模型啊啊，更重要的一个作用是为我们后续的工作。

比如说啊在逻辑回归的基础上，我们可以通过横向和纵向啊，把我们的逻辑回归模型进行一个扩展和堆叠，就可以直接得到人工神经网络，而人工神经网络又是我们进入到深度学习领域，的一个非常重要的开始啊。

各种各样的神经网络啊，比如后面的CNRNGEN啊，更复杂的模型，还有的是，那么这些模型呢，都是以人工神经网络作为它的模型基础的啊，来进行改造得到的，而人工神经网络呢又是以基本的逻辑回归。

作为它的基础单元来构建的，从这个角度上去看的话，你会发现再复杂的深度学习模型啊，最终落脚到基础单元当中，也是以逻辑回归为基本单元的，那么再往前回溯，你会发现它就是简单的线性回归模型的改进。

所以从这个角度上去看的话啊，那是今天或者这周需要介绍的这些模型啊，其实都是为了我们今后的工作啊，为了今后更复杂的工作做了一个基础啊，它的重要性可能更多的也体现在这儿，你说这些模型本身能够解决哪些问题吗。

啊当然能够解决一些问题，但是呢它的效果很显然，已经不会像深度学习领域的那么多的模型的，效果好了，但是你不能轻视它啊，重要性就体现在刚才我们所说的，它是后续工作的一个基础啊，嗯特别是在面试的过程当中啊。

我们也在不断的面试一些新的同学，一些基础的内容的掌握嗯，很不扎实啊，比如说像逻辑回归这种基础的单元，甚至神经网络的反向回馈，这种这种误差传播还会有很多问题，所以希望大家能够在这两周的时间当中。

引起足够的重视好吧，这是一方面就是关于这个模型之间啊，还是有些关联关系的啊，这是第一个希望大家能够接受和理解的内容，那么第二部分呢就是通过这个图呢，我们也简单的说明一下，我们这两周的主要的工作好吧。

那么今天呢我们一方面需要完成的是，机器学习原理部分的一个介绍啊，另外呢我们会介绍线性回归和逻辑回归，这两个模型，刚才已经说明了它的重要性，那么在周三啊，我们会介绍决策树模型啊，这三个D3C4。

5和cut数，可能会包括一点boosting啊，这个看时间上的一个安排啊，这两个工作哈，这两个工作数模型和集成模型会直接退到出差，g boost啊，这个可能同学们或多或少的有了解是吧，在现在的这个啊。

特别是各种各样的比赛当中，他g boss的模型啊是应用非常广泛的模型之一啊，它解决回归问题和分类问题，都取得了非常好的效果啊，但是呢你会发现往前倒它的前序工作啊，其实还是有很多啊，我我看到过很多同学啊。

这个啊在xg boss的画画了很多的工作啊，但是搞得一头雾水，为什么，就是因为他的前序工作没搞明白啊，数模型还不清楚怎么回事，什么是数模型，数模型怎么去定义是吧，它的核心到底是什么啊。

然后boosting方法是怎么能够，在基础模型的基础上进行性能的提升，然后才是BDT的问题，然后才是GBDT的问题，才是梯度，才是梯度提升的问题，你是在函数空间还是在参数空间里面，学习的问题。

这些一系列的前序工作，如果你还有问题的话，嗯对超级boss的学习呃困难会很大啊，所以说上这也说明了刚才我们所说的学习呢，你需要有一个过程，你需要有一个积累的过程，特别是有章法啊，你不能什么都这个一把抓。

那个效率还是比较低的，但是这是这两部分啊，这是关于这个数模型，那么呃第三次课呢，我们会集中介绍这个所谓的支持向量机啊，这个也非常重要啊，这个重要性呢我就不做的，不做过多的介绍了。

然后呢后面会讲到这个hmm和cf啊，这两个概率图模型呃，这是我们这两周的主要内容的介绍，那么嗯这些内容哈会逐渐的感觉是越来越复杂，当然这个复杂并不体现在模型本身有多么复杂，因为相对于深度学习部分的模型。

这些模型还都属于基础模型，它的复杂性主要体现在，可能呃学习的坡度比较高，因为一开始啊同学们可能不太能够呃，就是之前没有一些基础内容，可能对这些内容呢这个接触起来会有些困难啊，这个很正常。

也给大家提前说明一下啊，你也不能寄希望通过两周的时间就把这么，这可能是啊，几十年甚至更早时期的一些专家们，总结出来的经验，你通过两周都掌握，这也不现实，那么怎么办，那就只能是不断的啊。

根据我们这两周的内容啊，呃课前最好是能有能够有一个预习，然后呢课上呢能够跟得上，课下如果有问题及时的在我们课程群里提出来，我们一块来通过我们的其他老师，还有助教老师一块我们一块讨论和学习，呃。

这些内容呢也不完整，就是即使是这张PPT里面的内容，也只是一个大体的框架图啊，它也并不完整，如果还有同学希望更系统的啊。

更全面地进行一个学习和掌握呢，那么下面呢给大家有一个这个就是参考资料。

也作为我们这两周的主要内容的参考资料，做一个介绍，那么上面这三本书都是中文啊，都是中文内容啊，可能对同学来说也比较，这个就是嗯可能认识的比较多了是吧啊，中间这本书啊是李航老师的统计学习方法。

统计学习方法啊，它也是让我们这两周课程的主要参考材料啊，嗯当然我们没有办法把这两门呃，通过这两周哈，把这一门书里面的内容全部介绍清楚，但是主干内容还是比较完整的啊，这本书的一个特点呢。

就是公式推导部分还是比较详细和完备的啊，嗯非常不错的一本书，那么另外一本书呢可能更这个呃，更被大家知道哈，是我们这个周志华老师的机器学习啊，就是西瓜书啊，俗称西瓜书，那么这本书的一个特点呢。

就是覆盖面比较广一些啊，覆盖面广一些，这两本书啊，是现在作为我们同学们可以入门的时候，可以作为参考的两本非常重要的教材，当然根据各自的不同情况啊，这个有的同学说这个都要看吧，最好是都看啊。

当然这个没什么可说的，但是如果说你时间和精力有限，那选择其中的一本也可以，如果从现在这个时间点呢，嗯没有好坏和优劣之分啊，就是你选一本都可以啊，看个人情况，如果说非要这个选一下的话呢。

李航老师的这本书呢就是呃怎么说，每一个模型介绍的推导过程都非常的详尽啊，呃深度也还好，呃周老师的这本呢就是广度很不错啊，覆盖到了方方面面啊，讲的也非常详细啊，所以还是那句话吧，这两本书反正都很不错。

第三本书呢是那个邱吉鹏老师的这个，神经网络与深度学习啊，当然这本书的重点就不再是机器学习部分，而是我们在这个深度学习部分，作为一个这个原理性涵盖非常广的一本教材啊，他在里面讲到了从深度学习神经网络。

就是人工神经网络开始逐步的介绍到CNRN啊，这个以及后续的一些改进啊，每一个模型的这个原理部分，公式推导都非常的详尽啊，这本书也是非常不错的，特别是有志于啊在这个方向当中，继续深入学习的同学啊。

这本书还是非常推荐的，那么剩下的四本书啊，这个都是呃老外写的啊，在这个之前哈，不像现在咱们的中文材料也非常丰富了是吧，之前我们上学的时候没有中文材料，就全都是老外的书，那只能是硬啃。

比如这本哈可能大家也非常熟悉啊，PRML是吧，MLAPP以及这个EIESL啊，这是我们就是啊以前所说的三大金刚了啊，这个你反正是每一本书都得啃一下啊，这个作为入门，当然现在不需要了。

有兴趣的同学可以作为一个参考啊，扩展啊扩展呃，这个多说两句话啊，刚才忘提醒了，就是关于这个统计学习方法一定要注意啊，这本书出了两版，第一版和第二版，一定要注意哈，就是一定要买第二版啊，一定要买第二版。

第二版在第一版的基础上，补充了大量的这个无监督学习的模型啊，为什么想起这个来了，就日本这个ESL也是出了第二版了啊，也是出了第二版了，所以说如果有有兴趣的同学，一定要买最新版啊。

啊最后一本书呢这个花书啊，这个也不用再做过多介绍了，这本书也是神经，就是深度学习部分关于神经网络的一些介绍啊，作为一个怎么说，就是如果上面这三本都都OK了，没问题啊，那么下面这四本呢。

作为一个继续深入学习的一些推荐教材，也给大家推荐，那么以上呢就是关于就是呃我们这两周吧。

一个基本的一个安排。

以及做了一个集推荐的教材的一个介绍啊。

看看这部分还有什么问题吗，嗯好西瓜书根本看不懂这个呃还好吧。

嗯这个对看不懂是有原因的，为什么一会儿我们正好也会借此机会啊。

和大家有一个介绍，如果没有什么问题的话，我们就继续好吧，刚才有同学啊直击问题的要害，看不懂为什么看不懂，总是有原因的是吧，原因在哪儿啊，当然并不一定就是和你的原因是相同啊，但是在这么长的时间当中呢。

我们也不断的和同学们进行沟通和交流，总是有原因的，那我们就看看可能会有哪些原因，造成了我们这个看不懂的问题好了，我们就顺着我们的内容啊，就第一部分内容，就是关于机器学习的基础介绍啊。

包括我们的一些术语的使用啊，这是非常重要的一个内容，为什么这么说，我相信啊，可能刚才那个同学说看不懂的一个原因之一，可能就是一些术语的理解不理解不掌握啊，不仅仅包括咱们初学的同学哈。

甚至很多号称是已经嗯，号称是已经在这个方向工作多少年的同学，有一些专业术语的使用都不准确，有同学会较真啊，不准确就不准确呗，能干活不就完了吗，当然这没问题啊，但问题在于你不光是需要自己干活。

还需要和你同组里的同学进行交流和沟通，甚至你还需要发不发paper是吧，如果积分我我我不发paper是吧，我就自己干活，你是不是还需要给你的领导汇报工作，在这个过程当中，你一定要怎么说呢。

对你的工作可能很理解，但问题是你需要准确的把你的工作介绍给别人，那么这个时候就牵扯到另外一个问题，就是刚才所说的属于使用的问题啊，你如果对你的工作本身的这种术语的理解，不能够和大家达成共识。

就很让人困惑，那反过来你看别人的工作也会出现类似的问题，看了一页书都是中文啊，好像每一个汉字都认识，连在一块儿，不知道他在说什么，其中一个很重要的原因，就是这些专业术语或者或者名词的使用。

可能理解的不是那么的透彻，或就压根就没理解，就划水过去了啊，这可能是一个很重要的原因，不只是这个原因，那么另外更重要的原因呢，还不是这些术语的使用，更重要的原因是一些数学符号的使用啊。

我相信大家可能或多或少的都是一些体会，我们这个方向的工作啊，说明一个问题，最直接的办法还是看公式是吧，你把问你把公式一写啊，大家都或多或少的知道你在说什么，或者你在表达什么。

但问题就在于这些数学符号的使用嗯，能不能标准或者规范的使用，也是一个很大的麻烦，当然这不怪同学啊，或者不怪我们怪谁呢，怪那帮嗯做数学的工作的同学啊，他们在符号的使用过程当中就比较随意。

学数学的同学嘛对吧，大家都知道这个想法有很多啊，比较的灵动啊，所以他们不太愿意出一些约束啊，所以说体现在这个符号的使用上就会发现诶，他说呃他和其他人的符号可能就不一样了对吧。

或者大家使用的符号或多或少都有区别，那这个时候你就需要明确一下，在当前你的语境当中，你所使用的数学符号是怎么规定的嗯，怎么体现出来，就是刚才那些书里面啊，回到刚才那个话题哈，就是你为什么看书看不懂啊。

我有一个问题就在于你看这本书的时候，有没有注意过你看没看过这本书的符号表啊，这个问题可能也就只有你自己知道了是吧，看过就是看过，没看过就是没看过，有同学说符号表什么是符号表对，如果你还有这个问题。

我觉得你相信哈，你后面的困惑一定会越来越多啊，符号表就说明了当前这本书当前这篇论文是吧，当天当前这份资料，它的使用的符号的一个说明啊，啊比如说举个例子啊，向量啊，我们在后面的这个模型学习的过程当中。

会大量的使用到的向量矩阵，甚至后面深度学习里面我们会使用到张量，高维的张量，那么这个时候就出现问题了啊，形状的定义啊，数据结构的形状定义是行优先还是列优先啊，有人说这个不都是行优先吗，谁规定的是吧。

有些教材里面它就列优先，你怎么办啊，你说这个他不说吗，人家有的时候就不说，或者说的时候说的符号表里面，那个时候你看了吗对吧，所以这一系列的问题造成了你说有些东西啊，特别是我们结合着我们本身上实事求是讲。

这个方向本身的工作还是有些困难的，或者有一些难度的啊，所以造成了大家的学习上有些嗯嗯有些问题，所以也就是啊这个结合这些问题，我们一块来这个进一步的来进行梳理和学习，好吧，啰嗦这么多哈。

我们看一下这个具体内容，结合具体内容啊，你再理解一下好吧，第一部分关于基础基本术语的使用，那首先第一个问题就是关于机器学习，什么是机器学习，当然没有一个明确的定义啊，这不是个定义，只是一个描述性的说明。

那么我们理解机器学习呢，它首先是利用经验，通过计算构建模型来改善系统自身的性能，首先说一下什么是经验，一般在机器学习领域，我们一提到经验，它指的就是数据啊，经验这个数据，比如说啊呃我们基于经验的学习。

其实直接一点就是基于数据的学习，为什么，因为所有的经验都体现在你的数据上，当然这些数据一方面可能是机器学，机器本身生成的数据，也可能是人为生成的数据啊，但是不管怎么样。

我们认为这些数据当中包含了我们要学习的，所谓的经验的内容啊，这是关于经验的问题，通过计算这个就没什么可说的了啊，通过计算机的计算，那么这个计算是怎么来完成的，一定是通过模型来完成的啊。

这里的模型就是我们今后工作的一个重点，就是我们的工作，就是在数据上构建模型来完成计算，但问题是这个模型的具体形式啊，一会儿我们会给出来啊，就是在我们语境当中，什么是模型的问题啊，啊不同的语境哈。

或者不同背景的专家，对模型的使用是不一样的啊，比如经济学里面也有模型是吧，很显然那个模型和我们的模型就不太一样啊，啊这个地方一定要搞清楚具体的表示形式，那么最后构建模型进行计算结果是什么。

结果是要改善系统的性能，那什么是系统的性能，在我们这个地方，所谓的机器学习里面的性能讲的就是预测啊，我们一定要解决的是，我们对未知的趋势的一个分析和结论啊，就是预测预判啊，这种对未知结果的一个计算。

那么这个时候一定要把机器学习的问题，和我们一些数据分析的问题区别对待，为什么这么说呢，因为嗯很多的时候的工作哈，我们进入公司以后，很多的数据分析的工作，都是一些描述性的分析啊，就这些数据是什么啊。

比如在均值方差是吧等等，类似啊，仅仅是举例，因为这种工作解决的是数据是什么的问题，我觉得这堆数到底是什么样的，我们大体的通过描述性的分析得到一定的结论，但是这不是机器学习所要解决的核心问题。

机器学习的核心问题是基于现有的数据，我构建这个模型，一定要是对未来进行一个判断啊，比如说我根据这一堆数据啊，这堆数据是一个比如说最简单的例子啊，天气预报是吧，我们根据已有的数据，天气预报的数值信息。

怎么样得到明天天气情况的一个描述对吧，比如说在商业里面，我们根据历史的这种销售，销售数据能不能构建一个模型，得到未来两个月对吧，一段时间当中我在销售的一个规模的描述啊，对未来是怎么样。

我们得到一个预期的一个判断，这是我们的核心的工作，好吧嗯不要把我们自己的工作搞得怎么说呢，就是呃显得那么的啊，本来我们是个有技术含量的工作，搞着搞着搞成和别人一样了，我觉得那意义就不大了是吧，好了。

这是再回过头来看一下啊，所谓的机器学习，你今后一定要知道，首先你得有数据是吧，这些数据里面是我们的学习对象，然后呢通过计算啊，现在我们的计算一般都是分布式的是吧，分布式计算机在扔到集群里面。

那么这个计算过程一定是基于模型的，我们需要构建各种各样的模型啊，这个后面随着学习的不断的深入，大家掌握的模型会越来越多，那这个时候呢通过数据构建模型进行计算，得到的。

得到的是关于未来或者未知情况的一个描述啊，这才是我们最核心的价值的体现，那么下面一个术语呢或者一组术语呢，是所谓的属性或者叫特征，他描述的是事物在特定方面的表现，或性质的事项，哎这就出现问题了。

你看啊这一句话都这这这一句话组成的，这这这个语句啊，每一个汉字我相信大家都都认识啊，甚至都好像都理解，但是你会发现走到一块儿，他在说什么，就莫名其妙是吧，什么叫描述事物在特定方面的表现或者性质的。

还实现了呢啊，这个地方就需要看一个例子哈，刚才我们在前面也已经讲到过了，关于数据的问题，就是我们一定是先有数据后有模型是吧，你一定是先根据数据构建相应的模型，得到对未来的一个分析结果。

那这个数据怎么体现出来，具体的数据的表示形式，往往往往啊我们的数据到我们的工作实际当中，就是一张表格啊，当然大概率是这样啊，并不一定百分之百是这样，还有一些非结构化数据，都是一些就不是结构化吗。

就我们一般把这种二维表格，认为是结构化数据啊，带着结构横行横着是行竖是列是吧啊，表格啊，表格数据，那么这个表格数据呢，嗯拿到以后我们就有个问题，就是这个表格数据是怎么组织起来的啊。

我不知道大家有没有这个这个印象，就是你拿到一个表格里面，你怎么去看这个表格数据啊，内容很多很丰富啊，比如说哈我们现在手头上是一张学生表，student表，在这张表里面很显然有一横行。

我们把它称之为什么这个表头表头，什么叫表头，表头当中标明了当前这个表格当中，所有的属性啊，所有的属性，比如说举个例子啊，当前这张学生表里面有姓名，性别年龄身高体重各科成绩，那么这样的话表述里面的每一步。

每一步每一部分，比如说啊首先是什么，首先是学号是吧，首先是学号ID，然后呢姓名name呃，性别，然后身高啊，体重啊，各科成绩等等等等，有了这个表头作为一个规范化的数据结构以后。

我们再根据表头的信息向里面进行填充，比如说学号零幺，姓名是张三呃，性别是男啊，身高是1米8零，体重是100kg对吧，各科成绩语文二十一八十一，数学90啊，这个外语70啊等等等等吧，今年是举例子。

那么这个时候就有个问题了，那回头来看一下，看一下什么属性，刚才已经说了，属性是描述事物在特定方面的表现，或性质的事项，结合着刚才那张student表，你会发现这个属性就是描述的事物，描述的是什么。

描述的是学生在特定某些方面的表现，比如说我的姓姓名啊，比如说我的性别，比如说我的学号，比如说我的各科成绩，在某些特定方面的表现的一些事项，这被称之为是属性啊，这被称之为是属性。

那么属性呢就有它所对应的值称之为是属性值，比如说就像刚才那个例子里面，比如姓名这个属性啊，性别这个性别这个呃，这个姓名这个属性他就可以取张三是吧，这个属性值是张三，那么同样比如说再举一个例子。

还有个同学学号是零二李四同学啊，性别呢是女，然后呢这个身高体重各科成绩等等等等，那么很显然有一个属性啊，有一个属性就有对应的，当前这个属性的可能的取值，比如说性别这个属性具有男女是吧等等等等。

其他同学的这个这个性别属性，身高体重也是等等等等，各科成绩也是等等等等，所以说哈属性描述的就是事物在特定方面啊，一个属性描述一个事物的一个特性是吧，表现或者性质的一个事项属性。

每个属性都有属这个属性当前对应的一个取值，那么下面一个下面一个术语啊，被称之为是属性空间或者叫做输入空间，这是什么意思呢，看一下它的描述，属性的所有可能取值所构成的集合啊。

啊属性的所有可能取值所构成的集合，这个呢以我们性别属性哈为例，以性别这个属性为例啊，我们这个性别呢，一般情况下我们就是取男和女这么两个值啊，取男和女这两个值，那么由男和女这两个值构成的一个集合。

就构成了当前性别这个属性啊，它的属性空间啊，它只能取这两个值啊，这两个值就构成这个集合，就构成了当前性别这个属性的输入空间，那么再举个例子啊，比如说我们的这个学号学号，因为我们可以看到刚才那是个序号。

编号是从零一开始编的是吧，0102等等等等，比如说当前我们这个班级一共是60名同学，那么最后一名同学的学号是60啊，六零，那这个时候你会发现我们可以通过0102，一张六零啊。

这60个取值所组成的一个集合，构成了学号这个属性的输入空间啊，输入空间，那么同样啊，比如说你这个姓名啊，这个身高体重啊，各科成绩啊，也都可以通过他的取值的不同，来构成不同的输入空间啊。

或者叫做属性空间好吧，那么以上哈以上三个部分啊，是我们今天见到的非常重要的一组这个术语，属性简单点讲啊，属性简单点讲就是一张二维表格当中，以表图里面的每一个字段都对应一个属性。

那么每一个属性都会有一个属性上的取值啊，每一个属性都会有一个值，那么由每一个属性上，所有可能的取值构成的集合，我们把它称之为是输入集合好吧，那么有了属性这个名词以后。

我们继续往下另外一个我们把它称之为记录啊，我们把它称之为记录，是要记录呢，也被称之为样本或者叫实例，就是一个具体事物的属性描述，有属性向量来表示啊，有属性向量来表示什么意思呢，就像刚才啊我们可以看到。

当我们在学生这张表里面用来记录一位同学啊，比如说张三这位同学，你会发现张三这位同学的表，里面的信息还是相当充分的，相当丰富的是吧，包括张三这个同学的学号，姓名性别身高体重各科成绩都包含了，需要注意的是。

这么丰富的信息标识的是张三这个同学的啊，一种一种状态，一种特性是吧，那么看下面一个李四同学，那么李四同学又有李四同学的学号，姓名性别身高体重各科成绩，所以你会发现，当我们描述一个具体的事物的时候。

有组成具体或者组成当前这个事物的，若干个属性，构成了当前这一个事物对吧，当前这个同学就是由它所对应的学号，姓名性别啊，身高体重，各科成绩所组成的，那么这所有的这些信息对应的就是这一名同学。

所以说你会发现一个具体事物的属性描述，它是由属性向量来表示的，我们知道标量和标量和向量的一个区别是吧，标量是只有一个值，而向量向量是有一组值所组成的，那么就像刚才我们看到比如说XG他代表的哈。

他代表的就是张三那个同学啊，张三那个同学，张三这个同学有哪些信息啊，有他的学号，我们用X1G还有什么姓名X2G年龄，身高体重各科成绩依次向下向下排列啊，向下排列用上标来加以表示啊。

一就被定义为是对应的是序号二，对第二个特征哦，第二个属性对应的就是他的姓名，第三个X3对应的就是他的性别，X4就是他的年龄，身高等等等等，依次向下排啊，有多少个属性，你这个地方N就取多少好吧。

那这个时候你会发现，当我们构建出这个向量以后，也就表示了当前这个张三同学的所有的信息，在16段的表里面，所有的信息都已经表示出来了，所以说哈你拿到的数据，其中一个信息或者一个实体啊。

它是由若干个属性所组成的啊，那么这若干个属性组成一个向量，用来表示当前这个实体啊，而注意我们细节上刚才是一个内容的表述啊，我们的这个符号细节，这就是刚才我们所说的，你怎么样把你的这个符号。

和我们刚才所描述的这些信息对应起来，一般情况下我们的向量用黑体的X来表示啊，黑体的这个英文字符来表示，它用以和标量加以区别，刚才我们说过，标量是只有就是单个数值组成的量啊。

我们一般也是用这种正常的这种啊，正常的这种这种这种呃这个表示，那么向量我们是用黑体的小写字母来表示啊，当你看到小写黑体的时候，OK这是一个向量啊，当你看到普通的字母的时候啊，这就是个标量好吧。

然后呢我们一般用下标来表示当前的呃，这个记录是哪一个啊，就像刚才啊啊比如说这个地方，我们按照刚才我们的编号啊，零幺同学，零二同学，那这个X1对应的就是零一同学，X2对应的就是零，就是零二同学啊。

通过下标来表示你是哪个同学，然后呢把这个向量展开以后，我们这个向量由若干个维度所组成是吧，它的第一个维度对应的就是这个表里面的，第一个属性，第二个维度对应的就是第二个属性，依次向下类推，所以你会发现。

当我们看到比如说这个地方XIG的时候，它说明的是什么，它说明的是student表里面，编号为G点的那个同学，他的第二个属性啊，这是整个XIG的信息的一个解释啊，同样XNG它所说明的是什么。

他所说明的是编号为G的那个同学的，第N个属性啊，第N个属性，那这样的话从X一G1直到SNG，就组成了当前的这个同学，他所有的信息啊，由这些所有的信息组成的一个向量，来表示当前这个同学啊。

那么下面有同学马上就会有疑问，有什么疑问呢，哎这个这个地方怎么还带着一个，带着一个小T啊，这个时候我们线性代数告诉我们啊，线性代数大家都应该接触过是吧，线性代数告诉我们，这个地方这个T的含义是什么。

转置啊，向量的转置为什么这么说呢，因为我们知道哈向量分行向量和列向量是吧，什么是行向量，哎这就是哎不对，不能这么说，X11X22X一二点点X1N啊，这样写的话就是一个明显的行向量是行向量，除了行向量呢。

我们还有列向量的形式，就是你把所有的线维度把它竖着排列，称之为列向量，那么在记住哈，在我们机器学习领域啊，在我们机器学习领域，大概率你看到的所有的向量都应该是列向量啊，都应该是这样好吧，记住哈。

这是第一步，或者说这第一句啊都应该是列向量是没问题的，但是呢如果你每一个向量都写成列向量的形式，你会发现它太占地方，因为列向量要竖着写啊，一页纸里边写不了几行就写满了，那这个时候怎么办。

往往我们会把这个列向量，往往我们会把这个竖着的这个列向量，写成行向量加转置的形式，写成行向量加转置的形式，就把它拧一下，从横从竖着的，竖着的列拧成行，但是很显然他俩就不相等了，怎么样才能让他俩相等呢。

再加上一个转置，所以说啊，你会发现你看到的这一条数学表达式啊，数学表达式它的含义就是我们刚才所说的，这是一个向量啊，这是我们机器学习里面，用来表示某一个事物，或者某一个记录的一个向量。

这个向量它它就是一个列向量啊，它就应该是个列向量，只不过呢列向量不方便，所以我们才把它表示成行向量加转置的形式，所以说啊你在看大量的材料的里面看到的，但凡是行行向量，一般它的右上角都会加上一个转置符啊。

转置符把它转制成一个列向量来加以运算，有的同学说诶，我看到的资料里面好像就没有这个转制，这也是不排除的一种情况，所以才像刚才我们所强调的，你一定要看一下他这本教材里面怎么规定的啊，大概率是列向量。

但是不排除会有一些作者啊，我就用行向量也无所谓啊，那这个时候你需要看一下它具体的符号的使用，为什么要强调这个，因为后面我们要做向量和向量的计算，向量和矩阵的计算，矩阵和矩阵的计算，矩阵和张量的计算。

以及张量和张量值的计算，这个时候你会发现它的计算逻辑，是和它的形状有密切关系的对吧，这个时候你需要非常仔细的或者非常清楚的，知道当前你的数据结构是什么样的，如果你不清楚，你需要确认啊。

非常准确的去确认它到底是什么，这个不能一点不能含糊，否则就会出现刚才有些同学的那种情况，什么情况看不懂，好像看懂了诶，嘿应该没问题，但是呢脑子里面就是一团浆糊啊，这很这很正常，首先这很正常。

为什么原因就就基本上会出现在这里好吧，当然这仅仅是举例啊，仅仅是举一个例子啊，你需要把那个符号表里面的每一个符号，都核对一下，核实一下，看一下是不是和你理解的那个那个那个符号，是一样的啊，和你一样的。

当然就没问题了，那还有和你不一样的呢，你需要时时刻刻提醒自己啊，再举一个例子，那本那个西瓜书，西瓜书李航老师，那不是那个那个周志华老师那本西瓜书，你看一下它的行向量和列向量的定义，就非常的有意思。

它的行向量没问题哈，行向量是用逗号加以区隔的啊，负分割的啊，它的列向量不是几，它的列向量不是在行向量的基础上加转置，它的列向量是通过分号分割，就它在形式上你一看还是一行，但是呢它中间是用分号分割的啊。

它是用分号分割来表示列向量，但是呢他又用行向量的形式，但是人家在符号表里面说的很清楚啊，我就是这样做，你能怎么着对吧，所以说这就造成了很多的时候，在后面进行各种各样的计算的时候，就全乱套了啊。

这个提醒一下大家好吧好了，回到我们这个内容当中来啊，那么这个时候一定要注意啊，XG对应的是我们student表里面的一个实体啊，或者一条记录啊，一条记录，那我们继续往下，那么继续往下呃。

当有了属性和记录这两个概念以后，当有了属性和记录这两个概念以后，下面有个问题啊，问下大家嗯，属性和记录都是我们二维表格当中的一部分，对吧，都是我们二维表格当中的一部分，那么下面有个问题。

就是这个属性在二维表格当中，对应的是行还是列啊，记录这个术语，在二维表格当中对应的是行还是列啊，这个能分清楚吗，就属性在二维表格里面，你怎么去找他，记录你的二维表格里面怎么去找他啊。

这个我相信大家应该能够分清楚是吧。

大家有什么问题吗，属性是列对，没问题啊，属性是列，当然相对应的记录就是什么记录就是行是吧，记录就是行横行竖列对，所以说啊这个一定要脑子里边很清楚啊，这个你如果不清楚，这个就比较麻烦，你们刚才说行向量。

行列向量的数据结构没有区别。

肯定是有区别的啊，这个你后面做内积计算，行向量和列向量转置还是不转职，肯定是不一样的，对吧好了。

我们再继续往下继续往下，下面一个术语叫做标记，标记，标记描述的是事物某个特性或结果的事项啊。

又是莫名其妙的一句话，但是呢对应表格里面就比较容易理解了，再举一个例子啊，还是刚才的student的表呃，当前这个表里面呢有一列，非常非常特殊的一列啊，非常特殊的一列，这一列呢就是描述了。

当前这个同学是否是三好学生，是否是三好学生这么一列啊，当然比如举个例子，我们用零来表示否，一来表示是啊，零是否一是四等等等等，那么这个时候这一列数据啊就非常有意义，为什么非常有意义呢。

它起到了一个决定性的作用，什么决定性的作用，看一下，就是他描述了事物的某个特性或结果的事项，对吧，是个结论性的，就当前这个同学是不是三个学生啊，是我就用一来表示，不是我就用来零来表示。

那么这啊这一类所谓的这个数据呢，我们一般把它称之为标记啊，标记取到一起到这种决定性结论的数据，我们一般把它称之为标记，那么其实是标记，就对应的是标题上的一个取值啊，标记上的一个取值。

就像刚才我们所定义的是吧，是否是三好学生这一列啊，这个标记列我们就可以取值为零，或者是取值为一啊，用零和一不同的取值来表示它是否是三好学生，不同的含义，那么这个时候呢类似的啊，就像我们的属性空间一样。

类似的，我们就得到所谓的什么标记空间，标记空间或者叫做输出空间，所谓的标记空间，就是标记当中所有取值的集合啊，周取值所构成的集合称之为是标记空间，比如说就像刚才这个我们说到过的，我们是否是三好学生。

这个A列数据我们就可以取零和一啊，那这个时候由零一所构成的一个集合，就是所谓的标记空间啊，或者叫做输出空间，那么这个时候啊回了回来，我们看一下，作为一张表格哈，我们逻辑上啊。

我们逻辑上可以有考这种分法对吧，第一种分法，那我们就可以通过刚才我们所说的，前面这一部分，就是记录了由若干个属性所组成的，属性的一个序列啊，属性的一个序列来表示，当序列当中取值以后。

用来表示一个一个的什么记录，那么另外一个另外一些刚才所说的，非常特殊的数据呢，我们把它称之为是标记标记序列标记，那么这是一种通过我们的这个纵向的视角啊，从纵向的视角上可以把数据这样来分。

那么横向的视角上呢，刚才也可以怎么分呢，就是刚才我们说过有什么有表头，表头记录的是属性是吧，表头上记录的是属性，然后呢横行啊，除了表头之外，一行行一行行，对应的就是一条一条的什么记录是吧。

一条一条一条的记录，所以说这张二维表格你一定要非常的清楚，你手头上这一定是基础数据啊，就是在数据上来构建模型啊，所以这张表格上也是非常要清楚的。

那么当我们有了标记以后啊，当我们有了标记以后，我们就可以进一步的把我们的数据啊，进一步的把我们的数据进行扩充，那么组成所谓的样例啊，组成所谓的样例就是拥有了对应标记的记录啊，拥有了对应标记的记录。

由记录标记对来进行表示，什么叫标记对啊，就是由一条记录以及这条记录所对应的标记，构成了一个所谓的样例，那么它在形式上可以这样来写，就是把刚才我们的记录，黑体的XG和这条记录所对应的标记Y。

组成一个所谓的记录标记对啊，我们把它称之为是一个什么样例，把它称之为样例。

其实哈标记哈也是我们二维表格当中的一列啊，标记也是我们二维表格当中的一列，只不过这一列呢它起到了一个结论性的作用啊，所以呢我们把它单独拿出来啊，把它单独拿出来构成所谓的记录标记，对呃，为什么要这样做。

其实刚才已经说明了哈，就是因为前面的这一部分数据，或者前面这部分的信息，前面的这一部分的属性决定了我的标记啊。

就像刚才说的，比如说01号的张三同学，男身高体重各科成绩来，发现他是不是一个三好学生，02号的李四同学女对吧，身高体重各科成绩哎，她是个下游学生，再往下03号的张三，李四王五同学男身高体重，各科成绩哎。

他也是个三好学生，你会发现有我们的这种所谓的记录和标记，所组成的这个记录标记对，就有了一个所谓的你可以认为是一个对应关系，通过输入相应的数据，我就可以得到它是不是三好学生的一个结论，这就是所谓的规律性。

这也就是我们试图通过模型啊，试图通过模型在我们已知的数据集上进行计算，所得到的对未来的一个预测，比如说今天啊我们班新学期开学，新转来了一个同学啊，新转来了一个同学叫什么名字啊，比如说他是61号啊。

这是学号，姓名叫什么呢，张三李四王五陈六吧，好吧啊陈六，然后呢，他是个男同学啊，身高体重各科成绩哎，这个时候呢我不知道他是不是三好学生，但是我可以通过我们历史上已经拿到了。

这张学生表里面关于同学们的这些基础信息，以及这些基础信息所对应的这个标记，三好学生的这个结论我就可以构建一个模型，当这个模型在数据里面已经完成学习以后，再有一个新的同学来了，输入他的姓名。

身高年龄体重各科成绩是吧，我就可以得到他在学期末是三好学生呢，还是不是三好学生的一个大概率的一个结果啊，这是最朴素的一种想法，至于这个模型怎么构建，我们有很多种方法来完成啊。

今天我们会介绍线性回归就可以做这个工作，是吧啊，逻辑回归也可以做这个工作，是不是，所以说啊，这就是我们为什么要把数据本身要分析的，这么清楚的，目的，就在于你今后的工作，就是在这二维表格上来完成工作啊。

你对数据不了解，我很难去理解。

你怎么对你的模型有深入的理解啊，那么更进一步的注意这些具体符号的使用。

黑体的XG对应的是一条记录，它是由若干个属性所组成的啊，每一个属性的取值，在当前记录上都是非常准确的，它是一个列向量，然后呢由记录和标记组成的样例，完成了记录和标记的对应关系啊。

那么这个时候随着下标的不断的变化，这从12345，一直到大N组成了你的数据集合，注意哈，这是一条记录啊，注意这是一条记录，当你写成这样的时候，这就是一个数据集合是吧，这个就是一组数据。

一组数据就是一张二维表格了是吧，所以啊这个希望大家能够理解，那么继续往下下面一个数据呢，就是所谓的数据集，数据集，当我们拿到的数据集是记录的集合的时候，什么是记录啊，只有只有样本啊。

只有我们的这个属性集合的时候，我们把它称之为是无监督的学习数据集啊，无监督的学习数据集，对应的，当我们拿到的是样本或者是样例的集合，的时候啊，样例的集合的时候，我们拿到我们称拿到的数据集。

为有监督的数据集啊，你什么是有监督，什么是无监督，这个监督怎么体现，体现的就是带不带标记啊，带不带这个标记，带着这个标记啊，你就有一个对应关系，那么这就是所谓的有监督的，那么不带这个标记啊。

不带这个标记，那这个时候你就是一个啊只有属性不凡啊，那被称之为是无监督的啊，这是非常重要的两个概念啊，就是有的时候会问你啊，这个模型是个有监督的模型，还是无监督的模型啊，其实他问的不是这个模型本身。

而是问的是这个模型基于的数据是什么样的啊，呃如果你说这个模型使用的数据是样例数据，那很显然就是一个有监督的模型，如果当前的模型使用的是记录数据，那它使用它就是一个无限度的模型。

好吧，那么如果是有监督的模型啊，如果是有监督的模型，就是他带着带着带着标记啊，带着标记，我们进一步的根据这个有监督的数据集里面，标记的不同的取值，进一步的进行划分，比如说比如说如果我们的标记啊。

在有监督的学习当中，如果我们的标记为连续值，什么叫连续值啊，就是我们的这个标记啊是个连续值，举个例子，比如说我们拿到的是一个天气预报啊，天气预报的记录对吧啊，有各种精度数据，纬度数据是吧，还有海拔数据。

各种各样的气象指标来得到当前这个区域，它明天的一个气温32度啊，平均气温32度，哎你像这种值就是所谓的连续值，为什么这个位置上可能是32度，可能比如说呃这个济南是吧，32度，可能北京啊就是27度啊。

这个上海可能就是25度，你看这种数值是连续值，我们把它称之为是回归问题啊，回归问题在连续值上的回归问题，那么相对应的啊，相对应的刚才那张学生表里面的标记，它只有两个取值，分别是三好学生和不是三好学生。

你像这种离散取值对吧，他离散值的时候，我们把它称之为是分类问题啊，分类问题，那么在分类问题当中啊，进一步的进一步的，我们根据分类问题的这个类别的多少，把问题进一步的分为，二分类问题和多分类问题啊。

就像刚才那个三好学生，那个就是一个典型的二分类问题，是不是的问题是吧，是三好学生还是不是三好学生，就两个类别，二分类问题，那么还有什么多分类问题啊，多分类问题，比如说我我们的这个学科成绩啊。

除了可以是连续值之外，我们有的时候还有什么优良中差是吧，这种时候就是一个多分类问题啊，优良中差你是在哪个区间里面啊，这是一个多分类的问题嗯，那么再往下呢还是关于数据呢啊这个就对，了解一下就可以了。

往往我们可以进一步的把数据进行，这样的划分啊，就是所谓的训练集，验证集和测试集，所谓的训练集呢就是用来训练的数据集，用来训练模型的时候的数据集，我们把它称之为是训练集，那么还有对应的呢称之为测试机啊。

测试机，那么就是在有了模型以后啊，有了模型以后，我要对当前这个模型加以测试的时候，使用的数据集称之为是测试机啊，称之为测试集，举一个例子啊，不太合适，但是呢这个仅仅是举例吧。

就是比如说这个呃我们在构建模型的时候，是构建模型的时候，我们有基础数据来完成模型的训练和构建，那么这个时候构建完成以后，我需要判断一下当前这个模型性能好不好啊，性能好不好，如果当前我还用训练的时候。

那些数据集很显然就不太合适了啊对吧，因为我就是在这堆书里面学出来的啊，对于当前这个数据集一定是非常好的一个模型，但问题在于唉，他在测试集上的表现才是我们最关心的，所以这个时候你会发现。

往往我们的训练数据集和测试数据集，不是同一个数据集啊，这两个数据集分的是非常清楚的，训练集就是训练集啊，训练完了以后再用测试及做测试，这样才比较公正是吧，这样的结论才比较比较比较可信是吧。

你不能说哎我再训练几章，训练完了再再测试测试吧，这个意义不大啊，这个意义不大，一会儿我们会讲，讲的话是非常一个非常关键的问题啊，非常关键的问题，这个这两个集合啊，训练集和测试集。

但是呢哎中间还差了一个叫做验证集，验证集，什么叫验证机呢，它是在模型的训练过程当中，未来为了选择所谓的最优参数，来使用的一个集合，数据集合嗯，一会哈会讲到这个模型参数的问题啊。

模型参数选择是个非常非常重要的内容，那么你选择好的模型参数，你这个模型可能性能上就很好啊，嗯差的模型参数，这个模型就很差，所以呢往往我们会单独的再拿出一部分数据，来去寻找那个所谓的最优参数啊。

这个时候的数据集就被称之为是验证数据集，但是呢说明一点啊，这是一般理想情况，但是这个验证集呢，这个以两我们的数据集往往就很有限啊。

数据集本身量就很小，那么你想刚才我们所说的。

你一共就60来个同学是吧，一共就60来个同学，我们拿出40个同学做训练，20个同学做测试就已经很不错了，已经很难哈，再拿出再拿出数据来做验证啊，这就很困难了，所以说啊这40个同学就也做训练，也做验证啊。

这个问题倒不是特别大啊，问题倒不是特别大，只要你能够严格的把训练过程和测试过程分开。

就OK了啊，所以说啊这种情况呢是一种呃。

经常呢我们可以看到你的数据集，分成训练几个测试集就OK了，验证集呢往往以默认啊就是训练集，我们这一做验证就可以了。

好了以上哈，以上这一部分就是关于基础术语的部分，看看大家有什么问题吗。

有同学说属性为行应该也可以吧，可以这个事情肯定是可以的，但是呢你要这样用呢，你必须要加以说明，这是你的义务，因为大家都不这样用，好吧啊对啊。

标签上就是标题就是标签啊。

没问题，咱们继续哈，前面这些术语部分回去好好的再理解理解。

那么下面就是关于假设空间与参数，空间的问题啊，这是个好问题啊，首先我们看一下啊，回到我们刚才讲到过有监督的学习，就是在于我们要学习一个，从输入空间到输出空间的映射，什么叫输入空间和输出空间的映射。

输入空间刚才我们讲讲到过啊，输入空间就是我们所有属性的集合啊，所有属性集合的所有取值的可能，这被称之为是输入空间，还是回到刚才那个表格里面对吧，每一个属性它都有它的取值可能。

那么每一个属性的取值可能和其他属性的取值，可能就可以进行多个的排列组合，那么这些所有的排列组合的，所有可能情况构成的空间或者构成的一个集合，就被称之为输入空间，同理，输出空间呢。

就是刚才我们所说的那个标记或者标签啊，标签也是一个各种可能取值，都可能取到的一个空间，那么这个空间呢我们把它称之为是输出空间，刚才我们说到过啊，模型的一个最核心的作用。

就是当你在输入空间里面作为输入值以后，要找到它所对应的输出空间的值，就像刚才我们所说的，转学了一个新同学对吧，转学了一个新同学，他的学校也有姓名也好，也有这个身高体重，各科成绩都有。

我现在把它输入进来以后，需要判断一下他是不是一个所谓的三好学生，那不就是从输入空间，向输出空间的一个什么映射啊，这就是机器学习最本质的一个含义啊，就学习啊，什么叫学习啊，学习本质上就是一个映射。

就是你给我输入，我向输出的一个映射过程啊，这就是所谓的映射或者叫学习，那么除了这种方式呢，我们还可以通过所谓的概率分布的方式，这个不太好理解啊，大家需要回忆一下，我们上高数的时候讲到过这个概率论。

是概率论里面讲到过条件概率分布，条件概率分布说的是什么含义，条件概率分布，说的是两个随机变量之间的关系是吧，两个随机变量，两个随机变量，一个随机变量是X，另外一个随机变量是Y，条件概率分布。

说的是当随机变量X已知的条件之下，随机变量Y的概率分布的问题，那么这被称之为条件概率，那么很显然是因为X被确定了，Y才能取不同的值的概率啊，这就是条件概率，那这个时候他和我们刚才所说的邮件。

这个学习的关系在哪呢，就像刚才我们所说的，这里的X就是我们的输入空间里面的取值啊，你你你你把你的这个呃新同学的各科成绩是吧，年龄身高体重，各科成绩都输入进来，确定以后。

我去判断一下他是三好学生的概率是多少，他不是三好学生的概率是多少，用来确定他当天到底是不是三好学生，你会发现条件概率给出的并不是一个确定的，当前的一个确定性结论啊，就是说你你这个陈丽同学是吧。

嗯各科成绩输进来以后，我得到的是他随机变量Y是个变量啊，它可以取两种不同的值对吧，它的输出空间是零幺取值啊，既可以是零，也可以是一，那么它的概率是多少，我才得到的是，当前陈六同学不是三好学生的概率。

10%，对应的它是三好学的概率是90%，那我问你，他到底是不是三好学生，你应该回答的是，他的90%的概率上是三好学生，但是同样他在10%的概率上不是三好学生，这就是用条件概率分布来表示的。

所谓的有监督的学习，今后啊这两种形式我们大概率都会碰到，就是我们都会见到这两种方式，哪种方式啊，第一种方式就是直接从输入空间，向输出空间的一个映射，那么另外一种形式呢，就是从输入空间已知的条件之下。

得到的是输出值的一个条件概率分布啊，这两种形式呢都是我们后面构建模型时候，需要使用到的，那么对应的相对应的根据两种不同的形式呢，我们可以得到另外两种所谓的模型的形式，第一种形式称之为是决策函数啊。

决策函数决策函数呢也被称之为非概率模型啊，它和我们的条件概率分布是一个对应关系，角色函数，什么叫角色函数，角色函数就是从输入空间花X到输出空间，花外的一个映射啊，就是个映射，你给我一个X，我给你个Y。

你给我一个学生的信息啊，学号姓名性别年龄，身高体重，各科成绩，我就可以得到他当前这个学生，是不是他的学生啊，就是通过一个映射来完成的，就是个函数，那么这个时候我们把哎，但是需要注意啊这个这个概念哈。

希望大家能够理解，画X是一个一个的XX1X二X三点点，一个XN花Y呢是一堆的YY1Y二，这点一直一直到YN，我们这个映射，F就是从花X向花外进行的一个映射，我相信啊这一点是没有问题的啊。

我相信这一点是大家都能够理解的，问题在哪，问题在于，这个从花X向花外的这个映射并不唯一啊，这个我可能会对有些同学就是产生一些困惑，但是我觉得这个也好理解，就是你拿到了一堆X以及它所对应的一堆Y。

我们知道从X向Y是有关系的，所以我需要构建一个模型F，来完成从X向Y的映射规则映射关系，但是呢这个能够从X向Y的映射，满足这个从X到Y的映射并不是唯一的，也就是说有若干个FF1F二点。

一点点都可以完成从X向Y的映射，再举一个例子，比如说你要从北京到上海啊，这是你要从完成的，从输入的是北京到的是上海，但是你会发现你从北京到上海有多种方式，你可以坐高铁，你可以坐飞机，实在不行。

你还可开车，再实在不行，你骑个自行车也能到，当然就是费点时间，但是你会发现，这若干个F都是能够从完成X向Y的映射，那么这个时候看下面由这些啊，由这些能够完成从X向Y的映射的，这一系列的F啊。

这一系列的F我们刚才所说过，每一个F都能完成从X向Y的映射，那么有若干个F，你说这I若干个F又构成了一个集合，又构成了一个集合，花F这个花F称之为是假设空间，也称之为是函数空间。

一般情况下我们这样来表示，那么就是所谓的假设空间的含义啊，假设空间的含义，其中X是定义在输入空间X上的变量，X属于画X，Y是定义在输出空间花外上的变量，Y是属于Y。

他们能够完成的是从X通过映射F得到Y啊，这么一个条件之下，所有的这样的F构成的集合被定义为花集合嘛，就是由元素组成的，每一个F都能完成从X向Y的映射啊，好了，现在哈梳理一下，到目前为止。

我们手头上有几个空间了，三个空间分别称之为是输入空间X，输出空间Y以及函数空间或者模型空间F，它们三者之间的关系是输入空间X啊，到输出空间外就是一个映射关系，而能够完成从输入空间X向输出空间外映射的。

这个映射有若干个F1F2，那这些若干个能够完成从X向Y映射的，这些模型，就构成了所谓的模型空间，模型空间，那好了，我问一下大家，那你想想在此基础上，你今后的目标是什么，如果说我能够从北京到上海。

有多条方式进行选择的话对吧，多个方多个模型都能完成从X向Y的映射。

那你觉得你登录了是什么，你的工作是不是就应该在若干个F里面，找一个所谓的最优的F，最优的F。

我把它称为F星，这就是你的工作，你要在这一堆F里面，这一堆能够从X向Y的映射里面找到一个F星，你说这还用找吗，你从北京到上海，你当然坐飞机了，那可不一定啊是吧，看你的这个看你的这个目标是什么。

比如说你要快对吧，你刚才有同学说我要坐飞机，是因为坐飞机最快时间上最节省，但是相应的比较贵，所以说我的目标是什么，我的目标是省钱，那这个时候你可以这么考虑一下，你比如说你可以做呃，更经济的方式对吧。

有人说我要找一个性价比最高的一个方式，唉这个时候你会发现，只要你定义好了规则或者定义好了你的目标，或者定义好你的策略，那剩下的问题就是在在这一堆可选项里面，找一个符合你的那个策略的最优解。

如果你的策略就是最快，那很显然你找到那个方法就是坐飞机哎，如果你要找的是那个最经济，那你好好想一下什么样的方式更加的经济，如果说你要性价比最高对吧，既要快还要省钱。

那这个时候你看看哪种方式能够达到这个目标，所以说你会发现啊，通过这三个空间哈，通过这三个空间其实就可以概括一下哈，我们在有监督的学习过程当中，的主要工作和目标就是一堆X1堆Y。

在这一堆F里面找到一个你的策略上最优的解，同样同样刚才我们说的是这个决策函数的形式，但是呢实际工作当中啊，嗯不那么的理想，为什么不那么理想呢，回到刚才我们的这个模型空间里面，来这一堆F哈。

这一堆F我们决定当前F的不是F本身啊，一般情况下不是F本身，而是由一堆的参数来决定，举个例子啊，比如说我们知道平面，直角坐标系里面的一条直线，二维平面啊，我们用二维平面来表示Y等于ax加B啊。

这是我们知道二维平面里面的任意一条直线，但是你会发现当呃决定当前这条直线的，是由它的斜率和截距来表示的是吧，我们二维平面里面的一条直线，这是斜率对吧，这是截距，所以你会发现确定当前直线的是斜率和截距。

这两个参数，你给我一个斜率，给我一个截距，我就能确定一条直线，同样换一下这个斜率和截距，我又得到另外一条直线，所以说这个F1F2点点，这不干个F决定这些F的是它的所对应的参数。

这个参数我们一般用C它来表示啊，这里面的A1B1对吧，A 2b2 a 3b3，一直到aw bw啊，这么一堆参数，你会发现现在我们引入一个新的空间，叫做参数空间，就是所有的参数可能的取值问题就转化成了。

我们要完成从X向Y的映射的最优函数寻找，而最优函数的寻找呢，又退化成了在最优参数的一个寻找过程，你会发现刚才一条直线它就用ab来决定，这还是直线方程是吧，如果你是个抛物线的三个参数是吧。

所以你更高次更高次的曲线，它的参数越来越多，所以说呢我们一般情况下是在，看这里嗯，嗯我们的假设空间化，F通常是由一个参数向量来决定的，函数足什么叫参数向量所组成的函数组合，在这个地方F呢一般加下标啊。

一般我们的参数用W或者C它来表示啊，W和CA来表示，就是说这一系列的函数啊，这系列的函数是由它所对应的参数来决定的啊，就像刚才Y等于ax加B它是由ab来决定的，AB的不同取值。

决定了当前这个函数的不同的形态，当前函数不同的形态，完成了从X向Y的不同的映射，决定了当前这个性能的好和坏，所以呢这个时候我们的参数向量用了W表示，这个时候是W11得到WN，细心的同学。

你会发现它和我们X的维度是对应的。

注意到了吗，我们刚才讲到过X在哪来着。

X在这看到了X1X2，一个XN，一般情况下我们会对会为每一个参数啊，会为每一个属性给它一个对应的参数啊，这里是X1属性1X2属性二，遇到XN属性N那么它对应的就是W，W一W二dd2，一直到WN。

这是我们的参数向量啊，参数向量我们用黑体的W来表示参数向量。

注意这个地方也加转置啊，所有的向量都是列向量。

那么同样同样刚才我们介绍的是函数形式哈。

是它的函数形式也叫做非概率模型，那么下面的非函数形式也就是概率模型呢，同样的刚才已经介绍了，假设我们的空间花F啊，也可以定义为条件概率分布啊，定义为条件概率分布，就像刚才我们所说的，通过我们的条件。

概率分布在已知随机变量X的条件之下，随机变量Y的取值概率也是我们的集合，也是我们的集合，我们知道这样的概率分布也不唯一啊，这样的概率分布就像我们的函数一样，也不是唯一的，所以由若干个满足条件概率分布的。

这个分布来组成的一个分布集合，我们把它称之为设假设空间画F啊，逻辑上是一样的，只不过在形式上不再使用函数形式，而是用的是条件概率分布的形式，那么其中X是定义在输入空间画X上的，随机变量。

Y是定义在输出空间花外上的随机变量啊，他用的是条件概率分布来表示我们的模型，那么同样的我们的假设空间化F呢，通常也是由一个参数向量来决定的，概率分布也是由参数向量来表示的，那么这个时候也类似。

我们已经不再直接找的是我们推荐概率分布。

而是在参数空间里面找到最优参数，把最优参数带入到我们的推荐概率分布里面，来来完成从X向Y的映射。

嗯这些内容啊。

这个也是非常重要的啊，也是非常重要的，为什么这么说呢，这和后面我们要讲到xg boss的时候会有关系啊，今天我们会讲到两个模型，线性回归和这个逻辑回归，都是按照我们现在的这套逻辑啊。

都是按照我们现在这一套逻辑先构建一个模型，这个模型呢不唯一从参数空间里面，找到最优参数带回到模型里面来，得到从X向Y的映射啊，这是我们最常用的一个套路，但是呢不要忘了啊，但是不要忘了我们的参数空间啊。

我们的参数空间不是必须的啊，不是必须的，一旦我们能够构建出一个不带参数的模型啊，不带参数的模型，我们可以直接在模型空间里面加以学习啊，在模型空间里面加以学习呃，讲到这个xg boss的时候。

你的体会会越来越深刻好吧，但是这个地方留留这么一个有这么一个念想啊，知道从哪儿啊，这个问题是从哪导出来的。

就是从我们第一堂课导出来的好吧，看这一部分有什么问题吗。

找到最优的那个F，就是假设空间当中的一个是啊。

刚才我们说过啊，我们的假设空间啊，就是所有满足从X向Y的映射里面的F，你找的一定是在这个画F里面去找啊，只不过呢这个F1不唯一，所以你就不知道哪一个F可能最好，这个时候通过你的策略定义啊。

通过你定个定个规则是吧，按照这个规则我去找就可以了啊，就像刚才我们所说的，你从北京到上海啊，有有好几种方法可以到哪种方法最好啊，你自己心里定个标准，按照这个标准去找就可以了啊。

这就是我们的这个一般的一个一个，一个一个一个逻辑。

那下面那下面马上就回到刚才那个问题，那怎么定义一个所谓的好的策略是吧，什么什么样的策略才是好的策略，不同的视角或者不同的定义会得到不同的结论，那这个时候有没有一个呃可参考的一些内容呢。

有就是所谓的损失函数啊，就是所谓的损失函数，什么叫损失函数呢，损失函数是用来度量模型预测错误程度的函数，注意哈注意损失函数是用来度量模型，预测错误程度的函数，被称之为是损失函数，它是用来度量错误程度的。

也就是说你的错误越多，函数值越大，你可以简单的这么理解对吧，错误越多，损失函数越大，相应的你的错误越少，损失函数的值就越小啊，它是模型预测输出，模型的预测输出FXF是映射吗，是预测吗。

是预测输出和实际输出Y的非负实值函数，大于等于零，非负实值啊，非负实值函数大于等于零，用L来表示loss损失啊，loss损失用L来表示，注意这里的损失函数，你需要知道它的模型预测值。

FX以及模型的以及它所对应的实际值，由这两个值我就可以计算出当前的损失的大小，那什么叫模型的预测值，就像我们的天气预报，比如说我们预测啊今天是多少号啊，今天30号啊，呃昨天29号的时候。

这个气象台发布预测啊，啊明天30号，比如说气温30度，这是它的预测值，但是呢到了30号以后，我是不是可以实际测量一下今天的气温啊，发现今天的实际气温是31度，举个例子，那么很显然。

我的预测值30度和我的实际值31度之间，是不相等的，那这个时候就存在了或者产生了什么损失，那这个时候，当我把30预测值和31，实际值输入的L之后，就得到了一个当前的损失的大小的描述。

那这个时候有同学会问诶，这个损失是多少呢，你需要根据具体的L的定义来计算得到，来看一下有多种的损失函数定义方式，最简单的一种啊，最简单的一种称之为是零幺损失，什么叫零幺损失啊。

零幺损失看一下他是这么来定义的，当我的预测值FX和实际值不相等的时候，一旦我预测的不对，我就认为产生了损失，并且损失值是一啊，损失值是一，那么相对应的，如果我的预测值和我的实际值相等啊。

意味着我预测对了，那这个时候我认为就没有产生损失，我的损失值是零啊，这被称之为是零幺损失，按照零幺损失啊，按照零幺损失，你会发现哎刚才那个例子也正好啊，这个可以进行损失计算了是吧，实际值是30多嗯。

预测值是30度，实际值是31度，不相等不相等，意味着怎么样产生的损失，零幺损失呢就被复制为一啊，如果我预测对了，就没有损失吧，零幺损失就为零啊，这被称之为零幺损失。

零幺损失呢是不是很显然是一个呃分段函数，你需要进行一个判断啊，这个时候呢，往往我们也采用了，采用这种所谓的指示函数的形式，I哈I称之为指示函数啊，指示函数它是这样来定义的啊。

当括号里面的条件成立的时候返回一啊，当条括号里面的条件成立的时候，Y不等于FX的时候，它返回一，否则返回零，所以说啊，通过指示函数，也表示了损失函数的一种定义形式啊，这个只是形式上的一点不同而已。

最核心的还是领养损失的一个概念。

好吧，有同学有问题吗，看看嗯。

好问题啊，有这个问题，有这个后面我们再说嗯，到哪了，这是零幺损失，那么零幺损失啊，有个问题，有没有同学发现了零幺损失的问题，零幺损失啥问题，零幺损失只记录了有没有损失，比如说还有天气预报，太大了嗯。

怎么去理解这个太大，还是天气预报啊，还是天气预报，这个比如说我天气预报预测这个三明天啊，明天31号我预测哈，因为下雨啊，明天的气温是15度啊，我的预测是15度，但是呢我这个预测就错了，等明天到了31号。

他根本就没下雨，还是艳阳高照啊，还是31度，那按照零幺损失啊，你会发现我预测的是15度，但是呢实际值还是31度不相等，按照零幺损失，那返回的就是一对吧，返回的就是一，那么只有到什么时候啊。

只有到我的预测值和实际值相等，完全相等的时候，我才认为是没有损失，所以说啊你会发现零幺损失只度量了，有没有损失啊，有不相等，那就是有损失，相等了就是没损失，它只度量了有没有损失。

并没有度量损失的什么程度是吧，你会发现30号，31号两天的预报很显然都都错了哈，严格一点说都预测错误了啊，一个是预测30度，实际是31度啊，另外一个呢预测是15度，实际温度也是31度，但是很明显的是。

第一天的这个预测虽然预测错了，但是它仅预测错了一度对吧，一摄氏度，而后面这个预测了预测16℃，很显然这两天的预测的程度是不一样的，所以说啊零幺损失呢，仅啊仅仅是预测了有没有啊，并没有预测程度是什么样的。

那怎么办，看下面最常用的一种方式，称之为平方损失，他那就很好了，他做的是Y和FX啊，预测输出和实际输出之间的那个差值啊，这个差值呢再加上一个平方，把它变成非负的啊，变成非负的，那么很显然按照平方损失。

我们就可以得到一个很好的度量，为什么呢，就像刚才我还在那两个例子，30度减去30啊，31度减30度，只有一度，一平方还是一，但是你会发现31度减去15度，再平方那个程度是不是就更大了。

所以说啊平方损失既度量了有没有损失，也度量了损失的大小，或者叫做损失的程度啊，啊这是平方损失，也是最常用的一种损失，还有其他的其他损失函数啊，比如说绝对值损失，绝对值损失也很容易理解是吧。

Y减FX取绝对值就可以了啊，但是呢我们知道这个这个这个嗯绝对值函数哈，它不太好的一点在于他连续，但是不是处处可导的啊，在这个在这个地方不可导，所以它的数学性质上呢就不如这个平方损失啊，处处连续。

处处可导，这个东西就就比较比较好用是吧，对付自然函数啊，后面我们讲到这个嗯这种概率分布的时候，就条件概率分布模型的时候我们再介绍好吧，就这样你会发现哎这就是刚才我们所说的，你的这个损失函数。

损失函数有多种定义形式，你取不同的定义形式，得到的所谓的最优模型可能就会不一样啊，这个就是怎么去定义你的损失函数的问题啊，啊这个也非常的有技巧啊，特别是到了深度学习领域，你定义不同的损失函数啊。

得到的那个模型就是一个新的模型啊。

他这种论文也很多啊，这种论文也很多，啊不一定啊，这和数据标签的离散成这个是没关系的啊，它仅仅是记录了损失已损失的大小，所以说函数和惩罚函数的区别是什么啊，你现在啊包括什么损失函数，目标函数。

惩罚函数这些东西你可以认为是一样的，就OK了啊，不要在现阶段也分不这么细啊，当然会有严格上的区别，但是呢呃你现在认为是一样的就OK了啊，包括什么目标函数，损失函数。

惩罚函数对吧，继续往下哈，继续往下好了，有了这一堆损失函数以后啊，有了这一堆损失函数以后，看下面，损失函数，损失函数是能够度量一个数据，它的损失问题是我们拿到的可是数据集啊，我们拿到的数据集是吧。

那这个数据集上的损失怎么来定义啊，就是刚才你会发现，刚才我们的损失函数，仅仅度量的是一次预测是吧，一次预测损失有没有损失的大小的问题，那这个时候你拿到的可是数据集，数据集里面是有一堆的数。

那这个时候怎么来定义呢，看下面当我们拿到数据1D啊，当我们拿到数据1D，它的由它是由X1Y1X二Y2XNYN啊，这若干个样例啊所组成的，那这个时候我们要计算它的什么平均损失啊，计算它的平均损失。

数据集上的平均损失，数据集上的平均损失就是把LYI和FXI啊，就是把每一个元素啊，数据集里面的每一个元素，分别带入到我们的损失函数里面去，来计算它的损失值，然后呢把这损失值进行一个累加啊，进行累加。

然后再除以我们的元素的个数，得到的就是所谓的平均损失啊，平均损失，那好了，当我们有了平均损失以后啊，这个平均损失啊，也被称之为是经验风险或者这个经验损失啊，还记得什么是经验了吗，有对他有印象吗。

什么是经验，经验就是数据是吧，经验损失就是数据损失，就是我们的数据集里面，通过我们定义的损失函数，来计算出来的平均损失啊，这就是经验损失或者经验风险，那么好，这个式子啊。

你可以看到你还是需要对符号零理解啊，这是一个元素的损失，然后进行累加求和，得到的是所有数据集上所有元素的损失，然后再除以N啊，除以元素个数得到的就是数据集上的平均损失，我们用REMPF来表示啊。

那下面有个问题啊，那下面有个问题，那这个时候你怎么去选择最优的这个F，损失放在这了，损失给你了，你怎么选择这个最UF，这个左右F看下面那个式子，这个式子说的是什么。

这个数字说的是我所谓的最优F就是F星啊，最优的那个F1定是在经验风险上最小的，那个F是最优的F啊，这个这个数学表达式啊，这个数学表达式说的就是这么个意思，你这定义的是经验风险，我要找的是最UF。

这个最优F1定是在经验风险上取得，最小的那个F作为我最优的F，大家想想这个是不是很自然的一个策略，你不是有损失吗，你不是有实际输出和预测输出的不同吗，我要这个不同，或者让这个损失尽可能的小。

尽可能的小的，这个F是不是就可以作为我的JUF，理想情况下我仅仅说的是理想情况下，理想情况下，就是这个所谓的每一个数据上的这个损失，都等于多少，都等于零，累加之后呢还等于零，当然求平均值后也是零。

那意味着我的经验损失就是零值，那这个时候你会发现哎我让所有的损失都是零，那这个F是不是意味着所有的输入和输出，输入和输出，输入和输出我都很好的，X号位，我通过这个F型都完成了一一的一个映射。

或者说一一的一个对应，这不是一种理想情况吗，当然这太理想了是吧，那么我们知道实际情况下这个都等于零，就就就太太苛求了，但是我只要让他怎么样，让它尽可能的小，所有的损失都尽可能的小。

那这个时候我们得到这个F型，一般也不会差到哪去是吧。

零是极端情况。

或者说理想情况是这个时候最好的模型啊，最好的模型就是使我们的经验，风险最小的那个模型啊。

这是我们的一种理想情况，好了，我们知道啊，往往这个理想很很丰满，现实很骨感是吧。

如果我们按照这个经验风险最小的这个策略，来去找这个F星啊，会出问题，什么问题呢，看下面三张图哈，这个图非常重要啊，这个图非常重要，他解释了一个很重要的现象，叫做过拟合欠拟合的现象，什么问题呢。

看这个图啊，你今天一定要把这个图这这这这这三个图啊，把它搞明白，看第一个图啊，第一个图说的是这么回事，怎么回事呢，你能看到啊，首先我们首先有一条曲线，正弦曲线啊，正弦曲线，然后呢还有一些若干个数据点。

还有若干个数据点，那么你会发现这若干个数据点，在大体上是符合正弦曲线规律的对吧，先上升后下降，再上升，大体上是符合正弦曲线数据规律的，但是呢他又不是严格的，按照正弦曲线来生成的数据，为什么，是。

因为这些数据是在正弦曲线的规则上进行采样，但是采样的过程当中，因为种种原因啊，比如说你的误差，比如说你的采样错误，比如说你的采样精度等等等等，各种各样的原因，你得到的一些数据点是不精确的，不准确的。

甚至是错误的，比如说可能会出现某些样本点跑到这儿来，这都是很有可能的啊，这是我们实际数据的基本情况啊，就是说我知道我的数据规律是正弦曲线，但是我在采样过程当中往往会出现踩不准啊。

不是往往你你就绝对是踩不准啊，这没跑啊，没得跑，所以说你会发现啊，第一幅图说的是什么，第一幅图说的就是，我在正弦曲线的基础上进行数据采样，踩到了若干个样本点啊，踩到了若干个样本点，换句话说。

我知道这些样本点就是按照正弦曲线的规律，来进行采集的，但是因为各种各样的原因，我踩不准啊，这是我们实际的数据情况好了，在当前这种情况下，如果我们再按照刚才所说的损失啊，所说的经验损失最小化的这个策略。

去找我们最优的F，你看看会出现什么情况，看这个左上角这低幅错，这幅图你自己看看说明的是什么意思啊，说明一下，你会发现正弦曲线还在按照正弦曲线去找的，那些数据还在这条红色的线是我们构建的模型，构建的模型。

这个模型是F等于零，F等于零，有同就会有有有困惑，F等于零或者FX等于零啊，都可以，我问一下同学们，FX等于零是不是个模型，别吵闹竞猜。

FX等于零是个模型是吧，有没有不同意见，有的人就会很困惑，FX等于零怎么是个模型呢。

我们前面刚讲过，模型就是个映射是吧，你给我X，我给你一个输出就OK了，但是很显然当前这个映射呢把所有的X，你不管你输入什么X，我都把它映射到哪去了，都把它映射到零那去了。

很显然有同学说这个这个模型太不准了，这个模型怎么能这样来做呢，但是准不准是一回事，但是你不妨碍人家也是个模型，所以你会发现啊，你来看这就是那条红线啊，这条红线就是那个FX等于零，就是他把你所有的输入啊。

他把你所有的输入都映射到零里面去了，当然我们知道这个模型的预测，预测的性能很差，因为我们知道我们所有的数据都是正弦曲线，它是一个非线性的，你用一条平坦的FX等于零，性能当然很差，这是左上角。

OK我知道了，我们变化一下，比如说我们令FX等于ax加B，ax加B，很显然，ax加B对应的是我们平面，这个平面直角坐标系里面的任意一条直线，任意一条直线对吧，它是直直的一次的是吧，直线。

只不过呢我们可以通过斜率和截距，来固定当前的这条直线，当然还是如果按照它是一条直线的规则，我在数据集上按照经验风险最小化进行学习，你再怎么学啊，你这个斜率和截距再怎么调整，你也是一条直线。

可以看到这条红的这条直线模型，要比这条平行的直线性能上要好多好多了，为什么，因为大家可以看到哎，他试图去尽可能的尽自己最大的努力，去怎么样去拟合我这个数据增长，下降增长的这个规律性。

但是只限于它本身就是个直线，你不可能要求他把这么好的数据规律，表现出来是吧，人家已经尽力了好了，我们再努力一下，怎么在努力，比如说我们令FX等于ax3次方，加BX方加CX加D。

很显然它的最高次幂已经变成三次曲线了是吧，FX是不是还可以继续啊，比如说ax4次方加上BX3次方，加CX方加DX再加一，你会发现随着X的幂次的增加，随着X的幂次的增加，我当前这条模型啊，当前的这个模型。

它的重力和线性模型，就变成了所谓的非线性模型，你会发现哎当随着这个幂次的越来越高，你会哎是不是已经很好的啊，这当然是在按照我们的经验，风险最小化，已经很好地去尽可能的去拟合，我数据本身所蕴含的这个。

正弦曲线的规律了是吧，这是第三幅图好了，按照这个策略啊，按照这个策略，我们继续增加我们的模型，幂次FX等于ax9次幂加BX的八次幂，直接加大，继续往后面不写了，哎这个时候当打磨性达到九次幂以后。

你会发现看再看这条红色曲线，你发现了一个什么问题吗，有没有同学发现，模型严格地穿过了我们的样本数据好了，模型严格的穿过样本数据意味着什么，意味着我在数据集上所学习到的这个模型，它的预测结果。

在每一个样本点上都和实际结果相等，按照我们的经验，风险最小化，我们知道每一个点上的损失值都是几，我说你看严格的一一穿过嘛，有一说在这个点上，在这个点上，在这个点上，我的输入值和输入的预测值和。

输出的预输出的实际值是完全相等的，意味着这里的FX和这里的Y是相等的，我不管用的是什么损失函数，它的值都是几零，在每一个点上都是零，加起来还是零除以N还是零，哎这是刚才我们所说的那种极端情况。

就是在整个数据集上，我们构建的当前这个九次幂的模型，严格的一一的穿过了样本点，每一个样本点上的损失都是零，在整个数据集上的损失也是零，经验风险就是零损失最小的，按照刚才我们所说的经验风险最小化的结论。

我们知道在FX等于零，FX等于ax加B，FX等于ax方加bx加C，以及FX等于ax的四次幂加BX，三次幂加CX方加DX加一，一直到FX的九次幂模型里面，问一下大家，如果严格按照我们的经验。

风险最小化的话，你认为这12344个模型。

哪个模型是最优的，按照经验风险最小化，我们得到的结论是。

九次幂的模型是最优的，但是。

嗯你同学会困惑，你这个四啊。

你这个四是你看出来的对吧，你这个40你看出来，但是严格的按照经验风险最小化，人家可是这个损失为零的，是最好的模型对吧，这个时候你会发现，我们现在是在知道人家是一个正弦曲线的，前提条件之下，你加以判断。

说这个四次幂的这个模型是最优模型，因为有人说哎，你不这不正正好符合身上升后，下降后后上升的这个规律吗，但问题在于，这是你知道人家这是正弦曲线，你如果你不知道呢，你不知道。

你只能按照刚才所谓的经验风险最小化去找，当天这个模型按照只按照经验风险最小化，你会发现你找到的是这个九次幂的模型，很显然我们又知道我们又又又又上帝视角是吧，又知道这个模型很显然不是我们要的正弦曲线。

能问题出在哪，他最后一个图啊，他最后一个图这个图里面哈，先看坐标系，横坐标横坐标横坐标是模型的幂次啊，横坐标是模型的幂次，从零次幂，二次幂，四次幂，六次幂，八次幂，九次幂。

模型的幂次纵坐标是我们的损失啊，是我们的经验风险啊，你可以认为是我们的经验风险就可以了，那么我们现在要得到的是模型的幂次和损失的，经验和经验损失之间的规律性，先看这条蓝色的线啊。

这条蓝色的线我们是在训练数据集上来完成的，模型的训练，刚才我们说过数据集分成两部分，一部分是训练数据集，一部分是测试数据集，我们现在在训练数据集上进行模型的训练，在训练集中进行模型的训练。

这条蓝色的曲线告诉我们，随着我们数据，而随着我们模型的miss的越来越高，随着模型的miss的越来越高，我整个在训练数据集上的损失在依次下降，你看到了吧，依次下降，就像刚才我们所说的零次幂的时候。

它是一条平行直线，这个它性能很差，唉一次幂上好了一点了，二次幂30米，40米的时候越来越好，一直到90米的时候，严格的穿过了样本点，这个时候他的损失为零，所以说你会发现在训练集上。

我们得到了一条严格下降的这么一条曲线，它说明的是在训练数据集上，我们训练的模型会随着幂次的增加，损失会越来越小啊，这是一条直线，这这这这条曲线，那么刚才我们所说的，我们的数据集不光是只有训练数据集。

还有测试数据集，很明显训练几个测试集是不相同的数据对吧，当你训练完成以后，我在这些非训练集的测试集里面，就是和你们训练过程没关系的一堆数里面，再拿出一个新的数据，来拿到你模型里面来个试试。

当然测试集里面的这些数据，也是按照正弦曲线的规律来选取的，只不过呢他可能在这儿这儿这儿这儿这儿啊，甚至包括可能还在这啊，包括一些错误的点是吧，哎这些新的在测试集的数据。

再拿回到你这个训练之后的模型当中来，验证一下你的训练结果到底怎么样，那么一开始的时候，随着你这个模型的幂次的增加，而损失也是减少的，这个我们知道，因为在最初的时候，是因为你的模型的性能本身。

限制了你的预测精度，就是你这个模型啊本身这个能力就太差对吧，但凡是能够好一点，你这个性能就马上就下降很多啊，马性能就马上提升很多，损失下降就很快，但是但是当达到一定程度的时候，你再增加这个幂次啊。

再拿着测试集在更高幂次的模型上进行测试，你会发现损失非但没下降，反而增加了，为什么，因为你高次幂的这些模型的精度，高次幂的这些模型，它严格地穿过了一个一个的样本点，已经不能够再反映正弦曲线的规律。

而我们知道测试集上的数据，是按照正弦曲线的规律来产生的，这就造成了你这些测试及新的测试及数据，在这些高次幂里面，就反映不出来这些正弦曲线了，能明白什么意思了吧，所以你会发现损失非但没下降，反而增加了。

那这个时候我们就说啊，当出现这种情况的时候，我们就说当前这个模型出现了什么，出现了过拟合，什么过拟合，就是你过分的去拟合了样本数据，而这些样本数据并不一定是按照。

并不一定严格地按照我们的数据规律来生成的，他可能是就是因为误差，就是因为采样的方法错了啊，甚至就是一些随机的扰动啊噪音，那这个时候你反而是这些高次幂的模型，反而可能学习到的就是这些采样的误差。

错误采样的随机噪音，那这个时候你想想你拿到一个新的样本数据，再来进行测试的时候，你怎么能测得准呢是吧，那这个时候怎么办，这就是过拟合现象啊，过拟合现象看下面啊，所谓的过拟合就是学习啊。

学习的时候选择的模型过于复杂，它所包含的参数过于多啊，你幂次太高，当当然啊，当然幂次高仅仅是模型参数过多的一种表现啊，并不是唯一的表示啊，以至于当出现已知语言出现了，对已知数据预测的很好啊。

你训练的时候就是已知数据拟合的很好，但是对于未知数据预测很差的一种情况，很差的一种情况，这被称之为是过拟合现象，过拟合现象，过拟合现象怎么办。

过拟合现象的产生，是因为你这个模型太复杂是吧，模型太复杂，那我们在模型复杂的基础上。

我尽可能的使这个模型看着，是不是这一段区间里面的模型是比较合适的，我的训练啊，训练集上的损失和测试集上的损失，都还可以接受是吧，都还可以接受，那这个时候这几个模型是比较不错的。

我们能够能不能把这些模型选出来啊，那以什么样的策略加以选择呢，刚才我们已经分析了我们的策略，问题就出现在我们按照经验风险最小化，这个策略进行模型选择的时候，我这个只考虑到了损失函数尽可能小的问题。

没有考虑到模型的复杂程度，而我们知道模型的参数过多，会造成所谓的过拟合现象，换句话说，在我一边追求损失尽可能小的时候，我还需要考虑到模型的复杂度啊，我需要考虑两个因素啊，嗯大方向不能变啊，损失还要小。

但是呢你不能过分小，还需要考虑什么，考虑到模型的复杂程度，那这个时候怎么办，来就在原经验风险最小的基础上，再加上一个所谓的正则画像啊，正则化，像所谓的正则化项就是用来表示模型的复杂度。

用来表示模型的复杂度，而我们知道你精度越来越高，一定意味着模型的复杂度越来越大，是这样吧，如果我们把模型的精度，也考虑到我们的策略当中去的时候，我们再看一下，如果我们希望使整个的损失小啊，整体的损失小。

那么当然我们一定是希望，我们的经验风险尽可能的小，而我们又知道经验风险尽可能的小，造成的结果就是模型怎么样相应的复杂，那么正则化像这个部分的取值就增加了，而你会发现这个时候就可以啊。

起到对抗我们经验风险最小化的那种冲动，是这样吧，现在我们要使的是整个他俩的和尽可能的小，这个活尽可能的小，一方面我的经验风险要尽可能的小啊，损失吗，损失要尽可能的小，这是没问题的。

但是呢损失的小到一定程度以后，会造成我的模型的过分的复杂，复杂度就上去了，而这个时候模型的尽可能的小，和复杂度增加之间的这个和的这种对冲。

就使得唉，当前这个模型就不会出现所谓的太复杂，但是呢性能又不错的一种情况，这就是所谓的结构风险最小化，所谓的结构啊，所谓的结构就是在经验风险的基础上，再加一部分啊，再加一部分构成整个画像。

这被称之为结构风险最小化，好吧。

结果风险最小化，那这个时候的这个复杂项啊，复杂程度的这个复杂项怎么来进行定义，这个复杂项呢一般我们有多种选择啊，比如说L2范数也可以，L1范数也可以，L2范数呢是这么来定义的。

这是等于二分之1W的二范数的平方啊，W的二范数的平方之类的，W是模型参数，模型参数，模型参数呢刚才介绍过，就是W1W二一直到WN，那么这个向量的二范数就被定义为分量啊，分量W1的平方加上W2的平方。

一直加到N的平方，开根号是二范数，然后呢，二范数的平方加上平方项平方和根号，就嗯消掉了是吧，消掉以后就变成了二分之1W1的平方，加W2的平方一直加到N的平方啊，这是我们的L2正则画像最常用的这种方式。

L1正则画像呢也用啊也用，但是用的少，你知道就可以了。

那么大家看看关于这一部分，从损失函数定义开始啊，零幺损失平方，损失绝对值，损失对数损失，有了损失函数。

我们就可以定义我们的第一个规则啊，或者第一个策略就是经验风险最小化。

但是它会出现过拟合现象，这个时候我们通过正则化项。

来定义所谓的结构风险，结构风险最小化，就可以取到那种尽可能损失小模型，又尽可能的不复杂的这么一类模型啊。

作为我们的最优模型，然后呢嗯细节上给出它的L2范数的形式，这部分看有什么问题吗，没问题，咱们继续啊，啊可以，那下面有个问题啊，就是当我们定义了结构风险以后对吧，当我们定义完了结构风险以后。

我们怎么去找这个结构风险最小的，那个还是N模型啊，怎么去找这个模型嗯，找这个所谓的最优的模型，刚才我们已经说了啊，不管你是一个几次幂的这个模型啊，它也是定义在参数空间上的对吧，定义在参数空间上的。

所以呢就变成了一个在结构风险最小化的策略，基础上，找最优模型的问题呢，变成了找最优参数的问题啊，找最优参数的问题，那么怎么才能找这个最优参数呢，看一下我们这个问题呢，把它图石化一下，横坐标是什么呢。

横坐标是参数，纵坐标呢是我们的结构风险啊，结构风险，那这个时候呢，一般情况下我们可以把这个结构风险函数啊，认为是一个所谓的凸函数啊，大体上呢是这样的，当然并不一定是二次的啊，并不一定并不一定是二次的啊。

它可能是多次的，但是呢往往我们可以认为它是个凸的形状的，那这个时候呢，问题在于找这个函数的最小值所对应的W，那么如果我们看一眼啊，那当然这个W就在这，但问题是我们怎么能够找到这一点。

才是个麻烦的问题是吧，一般情况下呢，我们采用所谓的迭代方式，什么叫迭代方式呢，我们在所有的取值空间上，我不是可以从这从这个区间上任意取值吗，我可以在这个区间上任意取值，比如说我在这个地方取消W1。

那么W1所对应的损失在这，所以这个点就是我们的起始点好了，我找到这儿了，这个点是我随机取的，那我要从这个点到这个点移动，怎么移动，哎好在我们在这个高等代数啊，这个告诉我们。

按照他的梯度的负方向就可以找到我的最低点，函数的最低点啊，呃这个就类似于我们啊就是嗯我们在山顶是吧，我们要我们要下山，那么从四面八方都可以下山，当然我们最高的效率呢就是找一个坡，最陡的位置。

那所谓的坡度走的位置呢，就是我们的梯度负方向啊，就可以尽快的能够下到山顶，那这个时候的所谓的梯度就是求导吗啊求偏导，我们对参数求偏导就可以了，比如说哎按照这个方向我都是这个点，这个点是W2。

然后到这个到了W2这个点呢，我们需要判断一下是不是到了山顶了，还没到山底，那这个时候怎么办呢，再继续收敛哎，比如说这是W3，还不行，再往下啊，1W比如说到WNWN和这里的这个W星，它俩的差值呢非常小了。

非常小以后就哎他俩就差不太多了，就认为啊已经在这个W星的附近了，那这个时候W星就是使得我们的结构，风险尽可能小的那个参数W，那么很显然，这里的W是通过一个迭代方式来完成的。

所谓的迭代方式呢就是不断的使用我们的结果，风险对我们的参数求偏导，求完偏导以后得到的就是我们的负梯度方向，负梯度方向在原有的W的基础上进行一个计算，就得到我的新的参数，新的参数在用我们的这个结构风险。

对新参数进行求偏导，再和我们的原W进行一个计算，得到一个更新的参数，一次反复的计算，就像刚才一次反复的计算，我们就可以收敛到一个和这个W星啊，所谓的最优解非常非常接近的一个位置，也就可以了啊。

我们精度上一般并不严格的，要并不严格的要求相等，也没必要，一般情况下我们也也做不到啊，只要它小到一个啊，一个一个阈值也就OK了，好吧，这就是我们的优化算法，当然这只是一个怎么说呢。

这只是一个就是框架性的描述，具体问题你还需要给出具体的结构风险函数，结构风险函数里面你需要具体的给出损失函数，不同的损失函数对W的偏导的计算是不相同的，这个应该没问题是吧，你如果是个你使用的是平方损失。

你平方损失求偏导，如果你使用的是一个呃绝对值损失，绝对值损失求偏导对吧，如果你使用的是一个其他损失，那其他损就具体的损失形式，对参数求偏导就可以了，好吧，这是关于优化算法部分，这一部分呢是比较抽象。

因为它的具体形式没有给出，当有了具体函数形式以后，你需要根据具体的损失函数形式，对你的参数进行偏导计算好了。

当我们有了一个模型以后，我们希望对生成的模型加以评估，当前这个模型到底嗯怎么样，靠谱还是不靠谱啊，所以这个时候呢，我们需要给出所谓的性能度量与评估方法啊，性能度量与评估方法。

当然这里的性能多样和评估方法，和我们的损失函数呢非常类似啊，基本上呢我们也是拿相对应的损失函数来进行，最终的性能评估啊，性能评估啊，看一下训练误差啊，训练误差，训练误差当然是训练数据集上是吧。

训练数据集上模型Y等于FX，关于训练数据集的平均损失，就构成了所谓的训练误差，所谓的训练数据集的平均损失，就是拿我们在训练数据集上的预测输出，和实际输出进行损失计算，这是数据集上的误差。

当然测试集上也同样可能会进行一个评估，在测试集上来完成损失的平均计算，得到的就是所谓的测试集上的测试集上的误差，但是这两个误差哪个更有用啊，当然很显然是测试集上的误差更有用啊，这是这是很显然的。

因为我们前面已经讲到过，你不可能哈在训练集团完成训练，再用训练集上的数据做训练集上的测试误差，计算算出来意义不大啊，这个值一般要远小于啊，远小于这个测试误差，因为我们知道测试数据集是不参与训练的。

而这种新的数据集才能更好的去测试，我当前模型的性能啊，这是关于这个训练误差和测试误差，如果在特殊的情况啊，损失函数是零幺损失的时候，这个时候的误差啊，就是所谓的误差率啊，它只计算误差了多少。

就是误差率的问题，他没有测试上误差的大小啊，这个知道就可以了，当然呃测试集上的准确率呢，就是在测试集上完成相对应的计算就可以了，这是关于这个呃，你会发现这都是我们的这个损失上的计算，损失的计算。

那么如果我们面临的是一个分类问题啊，如果我们面临的分类问题，因为前面所有的工作啊，前面所有的工作基本上都是回归问题啊，都是回归问题，都是在实数集上的回归问题，如果我们面临的是分类问题呢。

我们稍微不太一样啊，稍微不太一样，那区别在哪呢，因为分类问题是离散的是吧，就像刚才我们看到的零幺，那个三好学生和非三好学生那个问题，它的它的取值是零散零散的，那这个时候怎么办，看下面的规定哈。

先给出四个定义啊，给出四个定义，第一个定义呢称之为是真正力，什么叫真正力啊，真正力就是张将正类预测成了正类，什么叫正类预测成了正类啊，比如说我们刚才那个例子，如果你是三好学生啊，你是三好学生。

这是大前提，即使你是三好学生，因为我这个模型啊也是时灵时不灵是吧，模型的也不一定百分之百都能预测对，所以就会出现两种情况，哪两种情况呢，就算你是三好学生啊，我也可能会把你预测成三好学生，这好像是废话。

但是呢这是一种情况，另外一种情况呢就是即使你是三好学生，我也不排除把你预测成非三好学生的情况，所以说其中你是三好学生，把你预测成了三好学生，这种情况就被称之为是真正理啊，真正的当然如果你是三好学生。

就把你预测成了非三好学生，这被称之为是将重力预测为负利，称之为是假复利，同样如果你不是三好学生，也有两种情况，一种情况呢就真的把你预测成了非三好学生，另外一种情况呢就是把你预测成了三好学生。

那同样将父类预测为正类，称之为是假证类，将父类预测为父类，称之为是真父类，所以你会发现哈，以我们两个取值真假为这个取值空间啊，然后根据预测的不同情不同情况，我们可以分为四类不同情况，这四类分别为真正力。

假复利，假正立和真父类这四种情况，那好了，你说这种情况以后再往下，有两种指标啊，P值和R值，P值和R值，来分别评估当前分类的这个性能指标，其中呢我们看一下这个精确率哈，精确率我更喜欢使用这个查准率。

查准率，因为我觉得查准率啊，这个这个更容易理解，你自己理解理解什么叫查准率啊，什么叫查的准不准，怎么理解这个准查准率，你再看看它的定义哈，定义的分子分子是什么，分子是TPTP就是正样本分别成了正样本。

就是你本来是三好学生，又把人家预测成了三好学生，这样的预测对了的啊，把正样本预测对了的，样本元素的个数统计成TP，如果它是分子，那么怎么体现出所谓的查准率，看看准不准，那分母又是谁呢。

TP是所有的正样本，预测成了正样本的元素个数，那分母分母呢是由两部分组成，分别是TP，就是人家本来就是正样本，你也把人家预测成了正样本，还有一部分是FP，FP是谁，FP称为是假正义。

就是人家本来是负样本，你把人家预测错了，预测成了正样本，是哪一部分，是这部分看到了吗，这一部分是FP，那你看看TP加FP是什么，TP加FP是不是从预测角度的，这个从预测结果的这个角度上。

我们看到就是把所有的预测为正样本的，这个元素的个数进行了统计，分母上分母上是你在预测里面，但凡是预测为正样本的，我都拿出来统计一下有多少个，然后呢，我知道在这所有的预测为正样本的元素当中。

有一部分是预测对了的，就是TP，我们把TP作为整个预测为正样本的比值，称之为是P值，你看看是不是所谓的查的准不准呢，是不是查的准不准，你正样本有有三个，但是呢你查出来所有的重量本是四个，那很显然。

查准率是43，当然如果你说查准率是3/3，意味着我原来只有三个人正样本，你查出来的三个正样本，那就是3/3就查准率吗，来看一下啊，另外一个称之为是查全率，查全率，查全率的分子还是TP啊。

查全率查全率的这个分子还是TP，不同的分母上分母是谁，分母上还是TP还是TP还是TP，FN是谁，FN知道FN在哪，FN在这，FN称之为将正类预测为了父类，也就是说我还我本来是正类，但是我预测错了。

预测成了父类，就是这一部分，这一部分你可以发现啊，分母是所有本来是正样本的元素的个数，只不过其中有一部分预测错了，我看的是我真样本个数占就查出来的，真样本个数占所有样本正正样本个数的比值。

这被称之为是茶全绿，查的全部全在所有的正向本里面，我查出来是不是把所有的正本都搞出来了，这被称之为查全率而止啊，这两个值呢是在分类问题当中啊，用来进行性能测性能度量的两个指标非常重要。

当然下面也有调和调和指标F1F1值啊。

这个看一下就可以了，好了好了，以上哈，以上是我们今天关于呃术语部分的一个介绍。

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

下面呢会有一个例子，这个例子呢嗯不作为一个重点内容，为什么呢，因为这里面的这个代码部分，我们需要到下一个阶段啊，下一个阶段啊才能讲到啊，这个地方呢仅仅是把这个例子放在这儿啊，放在这个地方。

有兴趣的同学呢，你可以顺着敲一遍啊，感受一下啊，这是刚才我们所说的啊，就是刚才那个过拟合现象的那个问题啊，嗯不做要求啊。

有兴趣的同学可以做一下啊，这部分有什么问题吗，嗯这个我觉得今天我们讲到的所有的内容啊。

都是希望大家必须要记住了，这个没什么可说的，都是一些最基础最基础的内容，除了原理就是概念，除了概念就是一些基本描述啊，这些东西是作为我们这个方向最基础的内容，所以今天这些内容务必啊，希望大家全部搞明白。

全部能够理解好吧，这个阶段没有任何的可商量的余地，OK好。

没问题，咱们继续哈，因为我们后面还有两个模型。

有了这些作为基础以后，我们再看模型的学习呢，我觉得就相对。

看啊两个模型，这两个模型呢分别是线性模型，线性回归和我们的这个逻辑回归，这两个模型呢，都被称之为广义线性模型当中的一类啊，它都是线性的啊，都是线性的啊，所以说性能上呢并不是多么的突出。

但是你会发现根据这些模型，我们可以进行扩充扩展，来构建非常非常复杂的模型，所以说呢，这些模型还是很有必要进行学习和了解的好吧，我们看看第一个线性回归模型，首先看一下数据集，数据集DX一Y1XNYN。

这个没有太多可以介绍的是吧，首先X是N维的向量啊，X是N维的向量，Y呢是我们的连续实值啊，连续实值，所以它是被称之为是什么问题啊，回归问题啊，从RN向R的一个映射啊，RN向R的一个映射。

那这个时候多元线性回归的形式被定义为，FX等于W内机X加BW内积X加B，其中X是一个RN的向量，RN的向量，那么W呢也是一个RN的向量，就是前面我们讲到的啊，它就是对应的模型的参数啊，对应的模型的参数。

很显然这里的X是N维的，这里的W也是N维的两个内积，两个向量做内积，我们应该知道它就是对应维度的值进行相乘，然后进行求和，所以展开之后是sum i从一到N，因为你有N个维度，WI乘以xi。

这里的W和X分别是向量和向量X，对应的维度啊，每一个都是标量，然后再加上一个偏置B，这被称之为是多元线性回归模型，有问题想不明白这到底是怎么回事，如果你想不明白呢，我们可以把问题简化一下。

怎么简化一下呢，令令这里的N等于二啊，如果如果实在是有问题，你令这里N等于一啊，我们先从N从一开始好吧，令N等于一，如果令N等于一，你看看这个模型退化成什么样子，退化成了FX等于就是WX加B。

因为这里的W和X都退化成什么，退化成了标量，化成了标量，那这个时候就变成了什么，变成了这是X，这是FX，然后就变成了一个平面下面的平面直角坐标，下面的线性回归模型，我相信这个问题在我们初中就解决过是吧。

初中就解决过，那随着这个N比如说等于二，N等于二，就变成了X1，再加上一个维度X2，那么很显然这就不再是一个平面的问题，而变成了一个什么，变成这个三维空间的问题的学习是吧，当然这个地方N等于三。

我们在空间里面就画不出来了，但是我们知道不管怎么样，他同样的逻辑还是每一个X对应一个，它所对应的全职，然后把X和全职进行相乘以后，把所有的维度进行累加，最后加上偏置B这就是多元线性回归模型。

由专业线性回归模型以后呢，我们做一个简化啊，做一个简化，什么简化呢，因为你会发现啊，短信微模型里面有一个偏执B啊，有一个偏执B它在这个地方嗯，形式上比较难处理，那怎么办，我们化做一个化简，怎么化简呢。

下面就考验啊，当看一下刚才同学们关于这个行向量，列向量有没有有没有搞清楚的问题了，来看下面令啊，注意令令什么，令这个w hat等于WB的转置，利用这个x HT等于X1的转置，然后呢用完以后呢。

我们就我们就可以把上述的FX等于WX加B，转化成了FX hat等于w hat，内机x hat为什么能这样去做，为什么令完这样以后得到下面这个式子，而下面这个式子和原式是相同的，看看啊，把它写全了啊。

把它写全了，按照刚才我所说的，这是一个什么向量，这是一个加转职啊，加转职之后它是个列向量，所以它应该是长这样，W b，还记得W长什么样了吗，W本来是个列向量，所以是W1W2点点，遇到WN不要忘了。

这都是列向量做WN，然后呢，再加上这个b w hat，等于这样看下x hx hat等于X1X1的转置，所以是X1等于什么，等于X1X2。0，一直到XN最后加上一个一啊，XX长这样。

你看看如果x w hat是这个形式，x hat是这个形式，你算一下w hat内积x hat等于什么，按照我们这个呃内积计算，就是对应的维度相乘求和吧，就是W1乘以X1，加上W2乘以X2对吧。

然后点点一直乘到WN乘以XN，不要忘了最后这个地方还有个BB乘以几，B乘以一，加上一个B乘以一，那么前面是SUI从一到NWI乘以一个xi，再加上一个B乘一，是不是等于B，所以你会发现他最后的标量形式。

和这里的标量形式是不完全相同的，所以说啊这种方式啊称之为是这个增广特征，向量和增长权重，只是为了形式上简化一些，为什么要写在这儿，其实差的意义不在这个具体形式上，我相信这个同学可能都比较清楚。

他在放在这个地方的最突出的一个目的，就是希望大家能够习惯一下，这些向量的表示形式啊，仅此而已好了，模型有了以后，很显然我们知道这里的所有的参数都是未知的，是吧，所有参数都是未知的。

我们学习的目标也就是找到所谓的最优的参数，这个W星，而我们知道你要找这个W型，就需要给出什么，给出你的策略啊，给出你的策略，那给出策略你就需要先定义什么，先定义损失，所以看下面损失函数呢。

我们使用平方损失啊，使用平方式损失，所以是Y减去FX的平方啊损失，然后呢我们看一下经验风险啊，经验风险就被定义为数据集上，所有的损失函数求和，然后呢求平均啊，这被称之为是经验风险。

那有了经验风险的定义以后，我们下面的模型选择，就可以按照经验风险最小化来进行选择，最优参数就是最优的w hat星啊，最优的w hat星被定义为所有的损失函数啊，所有的函数的损失数据。

以上所有函数的损失最小的参数啊，最小的参数作为我们的最优参数，这个没什么问题吧，把这里的FX hat展开，就是w hat乘一个x i hate啊，差值求平方，然后sum的加求和。

然后呢其实是有两种方式啊，这一种方式呢我们可以做的解析解，就是所谓的最小二乘法啊，我们看一下啊，最小二乘法告诉我们的是什么呢，就是我们我们上面这种标量形式，可以写成向量和矩阵的形式啊。

就是上面这个式子啊，上面这个式子等于下面这个式子啊，这两个式子是等价的，等待着什么呢，我们重新定义一个这个矩阵啊，这个矩阵是由X1X2U到XN，所有数据的转置，以及和一啊进行组成的一个呃增光矩阵。

这个矩阵和我们这个Y也写成一个向量形式啊，Y也写成一个向量形式，就把从它的标量形式上展成它所对应的向量，矩阵形式，写成这种矩阵形式以后，我们要进行求偏导还是刚套路是一样的。

只不过形式上变成一个标量矩阵形式的偏导啊，这个需要看一下矩阵论里面的相应知识，这个问题也不大，如果我们对W求偏导，这个时候我们可以得到它的解析解是2x hat，这里的X是刚才那个矩阵乘以XW。

height减去Y减去Y，这个时候我直接就可以通过矩阵计算，因为，让这个式子等于零以后，我直接就可以把相应的W解出来了，这个时候我只需要组成一个X组成一个X，然后呢，这个时候X和x HT。

就我们知道转职之后就为标啊，就为我们单位矩阵了是吧，有了单位矩阵以后，我就可以把W表示出来了，这个时候我们可以看到啊，写一下啊，这个时候是呃X的对xxx，然后是w hat减去一个XY等于零。

然后移项之后是这样，然后再把它取一扔过去时，这个时候WH等于，xx转置的逆矩阵，然后是XY，看看这个时候热，对，因为过了之后还要加一个转置，是这样，那可发现我们可以得到一个关于啊。

这个W的一个解析解的一个形式啊，这种形式呢嗯非常的怎么说呢，因为正好是用最小二乘法得到它的解析解，这不是一个大概率的情况，就是我们后面再模型学习的过程当中，往往接触到的都是近似解，所谓的近似解啊。

就像刚才我们所说的，就是求偏导等于零就可以了啊，这个时候的求偏导等于零，因为它都是只有一次幂啊，这个形式上也非常容易理解啊，就是我们的X的转置，然后乘以XWH减去Y啊，只是它的偏导值，然后乘以阿尔法。

这个阿尔法是我们把它称之为是一个学习率，是不是叫学习率呢，刚才已经说过啊，就是我们在进行，负梯度球完球完之后的负梯度啊，仅仅是个方向啊，是个方向，我们需要决策的是，按照这个方向向前迈多大的步伐啊。

就像我们下山那个例子一样啊，我们要从山顶下山，我们的负梯度仅仅是告诉了我们，某一个方向是下山最快的方向，但是按照这个方向，我们要下山的话，需要决定当从当前位置向前迈多大一个步子啊。

有同学说当然迈的步子越大越好啊，不一定，因为有的时候步子越大，可能就找到一个很差的一个位置是吧，这个时候呢步子小呢，反而是相对更好的一个策略，但是步子小呢就嗯怎么说呢，就更耗费计算次数。

所以这个时候这个阿尔法，或者说这里的这个学习率就非常重要啊，这就被称之为超参数啊，这被称之为超参数，这个超参数的选择，就是使用我们的那个验证集里面的数据，来进行选择啊，就说那验证集数据干什么呢。

验证集数据是选择最优的阿尔法的这种超参数，就决定这种不长啊，决定我们的这种学习率的这种参数，那不管怎么样，我们这个时候只要使得我们的初始位置等于零，不断的进行迭代，就可以得到近似的最优解W星啊。

这个时候呢找到的就是我们的最优解，当然以上是按照我们的经验，风险最小化来完成的，下面的同样我们也可以通过结构风险最小化，就加上我们的正则画像啊，加上我们的正则画像，如果我们的正常画像。

使用的是所谓的L2范数啊，那么L2范数，那这个时候就是就是使用的，W的二范数的平方啊，W2范数的平方，这种呢我们也把它称之为是领回归啊，如果你使用的是L2范数，也被称之为是领回归。

当然我们同样也可以使用L1范数，L1范数被称之为是套索回归，还有一种呢是既使用L1也使用L2啊，使用L1和L2的一个中和，这里称之为弹性网络回归啊，这个都是常用的不同的这个回归的一种方式啊。

根据他的正则化项的不同，来体现出他们的模型的不同，你会发现你会发现这三个不同的这种方式啊，不同的策略选中了那个W可能也是不相同的啊，可能也是不相同的，当然虽然嗯看数据啊，也看数据啊，数据集的这种情况。

也影响他们的这种精度的情况，好吧，这是多元线性回归的一种形式，下面呢同样有一个例子啊，下面同样有一个例子，大家看看有什么问题吗，关于断性回归这一部分。

累积xx是个行向量吧。

看看啊，x hat是抗向嗯，你看啊x hat在这是吧，x hat同样也是个列向量，我们前面说到过啊，行向量的转置不就是个列向量吗，X还是个列向量，X是列向量，行向量的转置回顾一下重点啊，还是你要。

你需要对这个多元线性回归的这个模型定义啊，模型定义回去以后好好的再理解一下，实在你觉得这个多线性回归有问题，你就把它退化成一条直线啊，对换成N等于一的时候一条直线，这时候我觉得还好理解一些好吧。

有这个模型定义以后，你会发现你要找的不就是这里W和这里的B吗，有我们的斜率和截距确定一条直线了，当然如果你扩展一下，这里的斜率就变成了斜率向量W是吧，截距还是那个截距就变成了断线性回归。

那个时候很显然这里的W我是不知道的啊，这里的这个B我也是不知道的，下面你需要确定这个W和B那怎么确定呢，下面其实我们已经很清楚的知道，我们需要定义损失函数，有的损失函数，注意啊。

这里的损失函数L对这里的L确定下来了，就是Y减去FXY减去FX2，我们知道FX刚才已经被定义为w hat内机XH，所以这里面看一下这个式子，这个式子里面的Y已知还是未知，问一下同学们。

这个Y是已知的还是未知的，已知的，这里有W已知的还是未知的，未知的啊，X已知的还是未知的已知的，因为这里的X和Y都是我们数据集里面的，XY好吧，只有W是不知道的，所以你找的是那个最有W啊。

换句话说你在下面这个计算过程当中啊，不管你是用最小二乘法还是用那个迭代法，你脑子里边符号有很多，你必须要清楚的知道哪些符号对应的是什么值，每一个值是已知还是未知的啊，有的时候不要认为这个YY。

不认为Y不就是不知道的吗，是不是Y在我们这个数据集里面，XY都是一致的，反而是你定义的这个模型参数W是未知的，你找的就是这个模型参数W是吧，用的最多的就是我们的迭代方式啊，就是求偏导数等于零。

求出这个式子以后负的偏导值啊，就是我们的下降方向乘以学习率，然后呢在原值上进行一个迭代，就得不到新值，这个过程需要反复的进行计算，最终就收敛了我们的最优解啊，然后呢。

结构风险最小化也是根据不同的这个正多画像，你是L2还是L1好吧，还是L1和L2的综合使用，好了我们继续啊，有线性回归以后呢，我们需要讲到保罗的回归，其实啊很简单，为什么这么简单呢，看一下啊。

我们把刚才那个问题回过头来看一下，这是X这是Y，当然这是在平面直角坐标系里面，我们知道这个这个这个模型是Y，Y等于ax加B，很显然我们这里的X是属于R的，Y呢也是属于R的，我们是从实数集空间。

X向实数集空间Y进行了映射，所以呢我们得到的是从R向R的一个映射，我们知道这是个典型的什么问题，典型的回归问题对吧，只不过呢我这个回归规律是一条直线而已啊，这是从一个R实数集向另外一个R的映射。

所以是R从R的映射好了，这是好，现有回归，看下面一个问题，下面呢我们要通过对线性回归的改造啊，通过对线性回归的改造，把它从一个回归问题啊，把它从一个回归问题，把它改造成一个分类问题。

把它改造成个分类问题，分类问题呢，我们知道分类问题就不再是一个RR的映射了，而是R到分类标签这个映射，比如说就像刚才我们前面举的那个表，里面的例子，它就是一个从实数集R对吧，你你输入你的年龄，身高体重。

各科成绩输出的是一个是不是三好学生就不在，你看看下面有个问题，你看看这是回归问题，这是分类问题，你想想有没有办法通过对回归问题的改造，把它改造成分类问题对吧，我从输入空间映射到了R。

我从书空间映射到了零幺，很显然这俩是不一样的，那怎么办，有没有想法猜一下也可以是吧。

啊回答以上两个问题啊，矩阵求导有公式吗，啊有故事啊，在矩阵论，矩阵论里面有，但是呢这不是我们这个地方的核心，因为这里的最小二乘法呢，一我们基本上不会碰到那么恰好的情况。

所以我们用的更多的是这个迭代方式啊，迭代方式呃，二这个决定论，有兴趣的同学呢会给大家一些参考资料啊，看一下就可以了，也没什么复杂的，其实如果你觉得呃矩阵求导搞不明白。

把所有的矩阵和向量计算展开展开成标量，标量求导就一目了然了好吧，这不是核心矛盾，只是形式上的一种嗯，形式上的一种简化方式而已，好吧，第二个问题啊，这个超参数怎么选择哎超参数怎么选择。

只能是刚才不是说有验证数据集吗，在验证数据集上，你把你的超超参数的可能的取值，找到几个比较典型的值啊，根据不同的这个呃，根据不同的取值空间，找几个比较典型的值，在这些典型值上一个一个的试一下。

看一下哪个可能更好啊。

好了，回到我们刚才的问题啊，刚才我们已经已经已经知道了，线性回归是R到R的，现在我们碰到了另外一个问题，是一个分类问题，是R到零一的，你怎么办，其实已经告诉大家了，如果我们能够完成从R到R。

如果我们能够完成一个从R到零一的映射，是不是就解决这个问题了，但问题在于R到零一的问题，本身就是个R到零一问题的一个这个这个问题，那不是个这不是多此一举嘛是吧，这个怎么能完成R到零一。

才是最核心的一个矛盾，好看下面给出个工具，就西格玛的函数这个函数形式哈，你自己看一下啊，这是它的它的这个解析式啊。

它的解析式最重要的是这个函数，它的函数形函数形状是这样长，这样看下它的取值空间啊，横坐标在这，横坐标在这，横坐标就在纵坐标在这，纵坐标在这，这是零值，这是一只，这是一，这是零，然后呢这是纵轴。

它的形状是长这样，这个点呢很显然是横坐标是零，纵坐标是0。5对吧，这是一，这是零，那你看看这个函数有什么有什么特点吗，这个函数是不是就是输入是个R他到零一区间，这是一这是001区间的一个映射对吧。

这是首先我们从函数的形状上分析，得到的一个结论，再从它长的样子上哈，你看看你是不是能够来看看他俩这是零。

这是一点点，你想想啊。

我如果啊如果有这么个工具啊，有什么工具呢，有一个类似于这个什么，类似于那种那种用门板啊，两个门板，一个门板从上往下，一个门板从下往上，这两个门板呢平行的往中间挤压，挤压的过程当中。

你想想是不是就可以把一条，比如你想象中那一条钢管是吧，随着两个门板从上往下平行的往上挤压，这个钢管是不是就受力于它，就变成了大体上就可能会，当然这个地方可能还是直的，但是在这个位置上。

当我上面这个钢板压到一，下面这个钢板压到零的时候，是不是大体上就变成这种形状了，但是这个分段函数是吧，如果我们把这个分段函数把它平滑一点，是不是就可以得到类似于下面这个式子，下面这种形状，换句话说。

如果我们在多元线性回归的基础上，我们知道多元线性回归是R到R的是吧，是个从输入，从输入空间向食指的输出空间，进行映射的一个模型，然后如果我能够在此基础上把这个输出值。

再从你看我本来是个X是从R到R的一个映射，X向Y嘛是R到R的映射，如果我们能在此基础上把这个输出的结果，再通过一个西格玛的函数，把它压缩到零一空间里面去，我完成的是不是就是从一个输入向输出。

零一的一个映射，这就是逻辑回归，为什么要在这个多元线性回归后面要介绍原因，其实就在这这两个模型之间的逻辑关系，就在于你看一下，当我们有了一个S函数以后，就sigma的函数以后，我只需要在这个位置看了吗。

这个是Z，这个Z是作为我们SIGMOID函数的输入，但是如果我利用这个Z等于什么，等于Y，利用值这个Z等于YY呢，就是刚才我们那个FX等于那个WX加B的时候，你会发现啊，这个。

自由贸易的函数变成了WX加B，本来是多元线性回归的输出，再作为西格玛的函数的输入，就把一个你看看这一部分是个R，然后呢通过这个mod就把它压缩到哪去了，压缩到了零一空间里面去，没问题啊。

加速到零空间里面去，有人问这有什么用吗，这个时候的用处就在于，零幺空间里面的这个取值，如果我们能够判断判断什么，它是大于0。5的，我就认为它取值为几，取值为一，如果它是小于0。5的，这个取值就为几。

取值就为零，这样的话我就完成了一个，你看X是R，通过我的WX加B把它映射成了R，再通过西格玛Y的函数，把它压缩到零一空间里面去，是不是也完成了一个，从R的X向零一空间里面的一个映射。

这就是所谓的逻辑回归，看一下，再把它画一下，画一下他们的关系是什么，首先我们有一个Y等于WX加B的线性回归，然后呢我们再通过线性回归的输出，把它作为贸易函数的输入，然后把这个Y从R空间。

再映射到零一空间里面去，完成从X向零一空间里面的一个映射，好吧，这就完了，其实如果把这个解释清楚以后，逻辑回归也就到此结束了，只不过呢细节的地方在于看下面，七级的地方在于这个函数啊。

我们需要因为后面牵扯到求导是吧。

我还是老套路吗，你定义损失要求导之后的函数求导哎。

这个地方给出CPY函数的求导，等于原函数乘以一减去减函数啊，就是它的就拍它它的求导啊，用的时候直接拿过来用就可以了好了，下面做一个介绍，第一它的概率分布啊，它的概率分布分两种情况，当X输入以后。

Y等于一的概率，就是刚才我们所定义的在线性回归的端，线性回归输出的基础上，进行S函数的一个压缩和映射，在形式上就是一加上E的负WX，加B次幂分之一啊，就刚才我们所说的，把那个Z。

把那个Z替换成多元线性回归的输出就可以了，当然因为他有两种取值嘛，刚才定义的是Y等于一的情况，那么Y等于零的情况，就是一减去Y等于一的情况，因为它只有逻辑值零和一对吧，你逻辑一的这个概率出来以后。

你用一减去逻辑一的概率，就是逻辑零的概率，形式上得到下面这个式子好吧，那么同样啊同样为了进行这个呃简写，对它进行增广向量的扩充啊，增广向量的扩充得到下面两个形式，这两个形式上如果还有问题的话。

再想想刚才我们讲到的那些内容，那好了，继续往下，有了刚才那个那个用以后，项目按照套路应该定义损失了对吧，按照套路应该定义损失了，只不过这个时候的损失我们用的是自然函数啊，这是我们概率论里面告诉我们的。

我们可以通过自然函数的最小化，来完成我们的模型学习啊，那么虽然函数怎么定义的，就是刚才我们所说的啊，虽然函数呢其实就是把在数据集上，所有的概率分布进行垒成啊，把数据集上所有的概率分布进行尾成。

数据集上是从X1到Y1，所以这里是pi从一到大N啊，进行垒成里程的时候呢，会碰到一个技术上的一个难点，技术上的难点在哪呢，在这个地方，我们知道这里的Y的取值有两种情况，一种是Y等于一，一种是Y等于零。

如果按照这个里程进行展开呢，我们需要分别讨论，在不同的取值的情况下的式子是不一样的，我还需要判断一下这里的Y到底是一还是零，对吧，嗯是比较麻烦的，那这个时候呢看一下，从这个式子到这个式子。

是逻辑回归里面最嗯不太好理解的地方，这一点如果突破了就没问题了，这一点呢其实就是一个小的技巧，技巧体现在哪呢，就是因为刚才我们分析了这个地方，它有两种不同的情况，一种是Y等于一，一种是Y等于零。

我们怎么样加以区别，这里的区别呢，就是把这里的Y的取值形式，放到了指数次幂的位置上，因为知道哈我们这里的Y的取值要么是零，要么是一哎这个零一取值啊，就很有很有这个特色，为什么。

因为我们知道任意值的零次幂都是零对吧，任意值的一次幂都是一，所以呢你会发现哎看这里当你想想啊，当Y等于零的时候啊，当Y等于零的时候，意味着你是负样本是吧，你是负样本，看下面这个式子，当Y等于零。

现在我们分两种情况讨论啊，Y等于零啊，如果Y等于零，带入到下面这个式子，你会发现Y等于零的话，前面这个式子的零次幂，这个式子是不是就是一，因为我们刚才说过，任意值的零次幂都是一嘛。

而后面这个式子等于什么，而后面这个式子是一减去YY等于零，1-1就是一得到的，是不是下面这个式子就是原式，就得到了原式，而你看看这个原式是不是恰好就跑哪去了，这个原式是不是恰好就是Y等于零的那个。

表达式对吧，正好保留的啊，就是前面这个式子变成一一乘以原式，是不是还是原式部分，而这一部分恰好就是Y等于零的那个条件，概率分布，哎这是一部分，如果Y等于一呢，如果Y等于一，我们看啊，如果Y等于一。

Y等于一，1-1是零，所以这部分是任意值的，零次幂都是一，那一呢一如果这个地方是一，那这个时候保留的是原式，而这一部分是不是恰好又是Y等于一的时候的，条件概率分布的表达式。

所以说不管你是Y等于零还是Y等于一，通过上数这个式子，我都可以很技巧性的把你表示成下士，也就是说我通过你的幂次的不同的取值，你是一的时候，我保留的就是一的表达式啊，条件概率分布为一的表达式。

如果你是零的时候，我保留的线概率分布为零的时候的表达式，但是你俩之间都可以通过这一统一的形式，把你这两种情况加以统一的表示，好吧，就是一点是比较技巧性的，有了这一点以后，下面其实就是对付自然估计啊。

就是我们的对手自然函数，你说对付自然函数以后，我们用其他自然估计就可以了，这个自然估计就是把累乘变成累加，累加式变成这个形式，然后呢对最大自然就是求自然函数最大的时候，那个最优解啊。

那这个时候我们不就仅需要在对数，自然上对W求偏导是不是就可以了，而这个式子再看一遍啊，Y是已知的未知的，已知X是已知的未知的，已知W是已知的位置的位置，求的就是对W求偏导。

这个式子呢看下面虽然函数对W求偏导啊，仔细一点啊，这个时仔细一点，求偏导呢，比如说我们以这个分量来表示一下，第一步对这个式子求偏导，我们知道YI是常数项，所以在这个地方保留，然后呢对这个式子求偏导。

log阿尔法求偏导，那是阿尔法分之一，所以你会发现应该是w height乘以x height分之一，但是我们知道w heat乘以x hat是不是外害，所以啊这个地方，虽然这个外号之一就是它的求偏导。

然后呢C呢WHXH的求偏导，还记得刚才说过那个西格玛Z等于它的一导，等于西格玛Z乘以1-4个MZ，所以你会发现分子部分是这样的，然后呢w xi再对W求偏导是W是xi是这一部分。

所以说以这个分项为势啊为例啊，对WX对W求偏导仔细一点啊，应该没问题，后面类似哈，回去回去之后自己算一下，后面一项复杂一点，在这儿其实也也不复杂，一减YI就在这儿。

你对这一项求偏导是一减去c w hat分之一，不就是一减y hit嘛对吧，然后呢再对这个负的Z2分之一求偏导，负的注意是负的，你需要在清楚取个负号，你说负号跑哪去了，负号在这是吧，然后呢他就偏了。

还是X还是xx啊，稍微整理一下就得到下士，有了这个梯度的负方向以后，我们就可以进行迭代了，就可以迭代，注意啊，这是负的，所以负的负的就是正的，好吧，嗯OK这样的话我们就可以得到W的最优解了。

回过头来看一下这个从。

S函数啊，你知道S函数引入以后，他的工作就是进行压缩他的工作，S函数的工作就是从R就是从R压缩到零幺，那至于这个R从哪来，这个R是从前面那个多元线性回归理念，得到那个输出，再把它压缩到零幺里面来。

这样的话，你会发现我们就可以建立，建立多元线性回归。

和我们的逻辑回归之间的关系，其实在形式上我们可以看到啊，看一下，你看看形式上，就这个这个式子是不是就是把刚才那里的，这不就是那个Y等于WX加B是吧，这个式子就是那个负的负Y，啊有了这个cm函数以后啊。

他做的工作就是把这个多元线性回归的输出，再压缩到零一空间里面去来完成分类啊。

最大的一个策略点就是刚才那个自然函数，定函函数的定义上啊，有了这个自然函数以后就偏导就可以了，同样下面这个例子也仅仅是作为一个呃实例，仅供大家参考，好吧。

好了，那么今天呢我们就完成了。

可以说是三部分的内容是吧，嗯包括我们的这个。

好我们看看我们今天完成的内容，这一部分的基础介绍，我们算是介绍完了，今天呢我们介绍完了线性回归和逻辑回归，啊啊这是我们今天的内容，那么下此刻呢我们需要介绍决策树，好，会把资料提前发给大家。

有时间的话看一下，好吧啊，今天的内容大家看还有什么问题吗。

OK那么如果没有什么问题的话，我就今天到这吧，这个公式的推导也需要记忆吗，嗯我是这样觉得啊，这个公式的推导啊，你现在觉得需要记，是因为你很显然没记住，这不是废话吗，但问题在于啊。

我理解就是你没有把这个逻辑理顺了，如果你把这个逻辑理顺了以后，你觉得他不是在记了，什么意思呢，就是哎下面你说是不是看懂了就可以，当你看懂的时候，我认为其实你已经把它记住了，反过来啊，如果说你说你没记录。

你能看懂了，有的时候是这样，就这些公式这些东西啊，逻辑上如果你理解了，其实基本上你也已经把它记住了，否则的话我不认为你能把它看懂了，好像有矛盾，但是实际上可能就是这样，特别是我们学数学的时候。

你会发现有一个公式，你说你需要死记硬背吗，如果但凡是到了死记硬背的基础上，你八成是没把它弄懂，你说你一条物理定律或者一条物理公式，你说你理解了你还要背吗，他不是那样嘛是吧，所以说现在这个问题是。

因为你现在很显然今天的信息量，我们每一堂课的信息量都会非常大，是你还完全没有完全把它接受，所以你会发现有些东西我不理解，我是不是先把它记住啊，但是我觉得这没意义，如果你真的把它理解了。

哪怕你理解完之后马上把它忘了，其实也没问题，但是你会发现你想用的时候，顺一下逻辑就能想起来也就OK了是吧，OK我们今天就到这，我们的时间啊，给大家提个醒，嗯八成会拖堂。

所以说呢把大家的时间尽可能的留充分一点，好不好，今天我们就到这。

1447-七月在线-机器学习集训营15期 - P12：06-NLP-2-意图识别与文本匹配 - 程序员技术手札 - BV1ASste6EuZ

好啊，今天是我们这个智能问答的第二次课啊。

第二次课，那我们先来看一下，今天要给大家讲的一个内容啊，啊今天要给大家讲的有三点啊，第一点的话是，因为我们这是一个啊智能问答机器人嘛，会涉及到一些NLP方面的一些深度学习的模型。

所以呢今天第一点的话就要带着大家去看一下，如何从零啊，从零去搭建这样的一个NLP的一个模型，因为各位同学可能之前更多是去接触这个啊，机器学习的模型对吧，更多使用的是这个CCLEAR。

那对于深度学习这一块呢，我们该怎么去构建这样的一个模型呢，然后今天第一部分叫给大家讲解一下啊，了解一下，那知道了如何构建一个NLP模型，那我们就来看第二部分啊，就关于这个文本分类模型啊。

因为我们在上次课的时候给大家介绍过，我们会做这样的一个意图识别，就判断用户到底是一个闲聊，还是一个专业领域的一个问题对吧，所以呢我就会涉及到一个文本分类啊，文本分类。

那这个分类的话就需要用到我们第一部分讲的，这个构建NRP模型的一些知识啊，当然这边也会带着大家去看一些比较经典的，这样的一个文本分类的一些模型，然后第三部分的话，会带大家来看一下一个模型啊。

目前L2P必须掌握的一个模型啊，叫做transformer，这个模型呢其实是有一定难度的啊，然后这边的话，我们也会尽可能把它讲的详细一些，让各位同学都把这个模型给掌握好吧，毕竟这个东西的话啊。

啊transformer这个东西你要说复杂的话，其实还稍微有一点点复杂啊，也是这个面试当中必问的啊，必问的好，那我们就先来看我们的这个第一部分啊，如何从零去搭建这样的一个NERP的模型。

那我们可以考虑一下啊，那对于一个模型来说，对于一个N2P的一个模型来说，我们输入的内容应该是什么呢，其实如果之前有简单接触过的同学啊，或者说之前如果没有用深度学习，用机器学习的模型去做过文本分类的同学。

我相信肯定有了解过啊，就是说我们可能更多还是会把这个文本，转换成这个embedding的一个形式，然后输入给这样的一个模型对吧，把这个文本转换成一个embedding的形式呢，就包括了这个字向量。

或者说是词向量对吧，咱们的一个字词向量啊，字词向量这个东西也是在咱们上节课的时候，给大家介绍过一部分啊，介绍过一部分，那除了这个字词向量呢，其实我们还可以引入一些额外的先验特征，那什么是先验特征呢。

大家可以简单的理解为，就是各位同学在做这个机器学习的时候啊，做的这个所谓的特征工程，比如我要判断两个句子它是不是同一句，那我们可以去把这个句子的一个长度，对吧啊，它有没有相同的一个字。

有没有相同的一些词，而这些特征啊，都作为一些人工提取出来的一些特征，然后把它加到我们的模型当中，那这些东西的话，就被称为这样的一个经验特征啊，经验特征啊，除此之外呢，其实对于我们文本来说。

有时候呢还会考虑到一个语序的一个问题对吧，语序的一个问题，那对于我们一个普通的一个模型来说，如果你没有去考虑这个语序，那这个时候其实我们应该把它的一个位置信息，也传递给模型对吧。

像我们常用的一些基础模型啊，像这个CN或者说RNN，那对于RN这个模型来说，它是这样的一个创新的一个结构啊，创新的一个结构，那它自带了这样所谓的一个位置信息，也就是位置特征对吧。

但是对于CN这样的一个模型来说，它实际上并不是这样的一个时序的一个模型，并不是一个序列的一个模型，所以呢对于这样的一个模型啊，我们有时候就需要考虑，是否需要把它的这个位置信息给传递进去。

因为每一个词在这个句子当中，它的这个位置不一样的话，对这个句子的一个语义是会有一定的影响的，比如我喜欢你和你喜欢我肯定是两个意思，对吧好，这就是啊先验特征啊，检验特征，Ok。

那接下来的话我们就来详细说一下，前面这里提到的这个自向量和这个词向量啊，自向量和磁向量，那自向量和磁向量它各有什么优缺呢，我们可以看一下啊，我们先来看自向量，自向量顾名思义啊，就是分字嘛对吧。

我们拿到一个句子之后，我们先对这个句子把它一个一个的字给分出来，那分字它有什么样的一个优势呢，分字最大的优势就在于啊，我们的词典会特别小，对吧啊，可能我们常用的一个中文可能就啊2万个字。

2万个字左右对吧，2万个字，但是如果是词常用的词，那这个就会特别多了，我们通常2万个词啊，2万个字，那这个词典就OK了对吧，2万，那如果是词的话，我们可能就要衍生到10万甚至20万对吧，就会很多。

那这个词典很多会出现什么样的一个问题呢，就像上节课提到的啊，首先呢如果我们要把它转换成这样的一个，one hot的一个形式呢，其实就会很吃你的显存对吧，这对你的资源来说是比较损耗也比较严重的啊。

所以呢字向量啊，这就是它的一个优势，词典比较小，但是字向量它虽然词典小，那他也有自身的一些缺点嘛对吧，就是他的这个啊表述能力啊，或者说他的这个语义表达能力，肯定会略逊于这个词向量对吧。

这个是毕竟你的这个啊词，通常都是由两个字或者说三个字来组合成，这样的一个词的对吧，所以呢单纯的使用这个字向量啊，他的一个表达能力可以使略逊于这个词向量好，接下来我们再说一下这个词向量啊。

那词向量的话它的优势就很明显了嘛，就是他的表达能力，表述能力会稍微强一些对吧，但是它也有它的一个缺点啊，首先就是受分词的一个影响啊，你分词的时候，你通常都会去调用一些三方的一些包对吧。

那你这个分词分的好坏，其实对你最终的结果是会造成一定的一个，影响的对吧，这是一点啊，其次呢就像刚刚说的啊，我们如果要分词，那这个词典就可能会很大，甚至会你分完词之后，当你来了一个新的一个句子啊。

你可能会在这个词典当中找不到对吧，就容易出现一个OV的一个问题啊，卡吗会卡吗，呃我这边应该是稍等一下啊，我看一下，稍等一下啊，我这边先停一下，稍等一下，好我们再看一下，现现在会卡吗。

我这边掉帧是正常的哦，掉帧是零，应该这位同学要不要刷新一下看一下好吧，你刷新一下看一下，我这边网速应该也是没有什么问题的啊，好我就继续了啊，我就继续了，如果有什么问题的话，你再提出来。

好刚才说到这个词向量啊，磁向量它会受这个分词的一个影响，其次呢容易出现这样的一个OV的一些问题啊，所以说这个字词向量它其实是各有优缺啊，各有优缺，那接下来的话简单说一下。

这个动态支持向量和这个静态支持向量啊，还有这个所谓的随机字词向量，那通常我们再去构建这样的一个，深度学习的一个模型的时候，那通常第一层实际上我们都会有这样的一个，embedding层对吧。

就对一条文本信息啊进行一个embedding编码，然后再给到后面的一个模型，再给到后面的一个model，那这里这个embedding层，其实就存在一些初始化的一些方法啊。

啊例如我可以预先去训练这样的一个向量，就像我们昨天那节课给大家讲过的这个词向量，对吧，我可以提前把它给训练好，训练好之后呢，我再用那个词向量啊，来初始化这里的这个embedding层。

初始化这个in bedding层，然后呢我们在BP的过程中啊，我们在BP的一个过程中，在不停的去更新这个embedding matrix，这就是所谓的一个动态支持向量，那静态这次向量什么意思呢。

还是使用刚才我们预先训练好的，这个字词的一个音，那个word word vector那样的一个向量，来初始化这样的一个emmanding matrix，但是啊我们在BP的过程中并不更新。

这个embedding matrix，只更新后面的模型部分啊，前面这一层我们是不更新的，不更新的，这是一个静态支持向量啊，那随机支持向量就很好理解了啊，就是我们每次并不会预先去初始化。

这个embedding match matrix，而是随机初始化的啊，随机初始化的，然后我们再模型更新的一个过程中呢，也会去更新这个embedding matrix，好，这就是我们这个字词向量啊。

字词向量，当然啊我们在使用这个字词向量的一个过程中，大家也可以同时去把这个字向量和词向量，结合在一起，输入到后面的一个模型都是OK的好吧，例如我这里可以啊，搞两个这样的一个embedding层。

两个embedding层啊，这个是try embedding，这个是WAREMBEDDING，那这边其实就会输出这样的一个char embedding，对吧，这边是输出的对应的一个。

左边是输出的一个字的embedding，右边输出的是一个词的引白点，那你可以对两者进行这样的一个相融合，相加的一个操作，或者说你可以做一些拼接的一些操作，都是OK的，好吧好，这就是我们的这个字词向量啊。

字词字词向量好，我们继续往后啊，这边的话再简单说一下这个先验特征啊，其实刚才也简单提到了，其实说白了就是咱们的人工提取的一些特征，对吧，这个就是在机器学习当中比较多啊，例如我刚才举的这个例子啊。

我们要去做这个文本匹配，那我们可以去判断一下，两个句子当中有多少相同的一个词对吧，文本的长度相差多少，那通常如果两个句子它是同意的话，他可能这个句子的长度会比较接近对吧，那啊在文本匹配当中呢。

是否会包含一些特定的一些关键词呢对吧，这些都是大家可以去尝试挖掘出来的，像再举个例子啊，我们如果要做这个情感分析，那你做情感分析的时候，实际上有时候可能也会有一些，比较关键的一些词。

你会认为啊只要出现这样的一些词，就一定认为他就是这样的一个负样本对吧，那你可以把考虑把这些词作为这样的一个特征，给加到模型当中对吧啊，这就是所谓的一个先验特征啊，所以先验特征。

大家就可以把它理解为所谓的一个特征工程啊，特征工程，那这一块相信各位同学啊，应该已经非常熟悉了啊，好那接下来的话我们再来介绍一个概念啊，叫做这个词典的一个构建词典的一个构建啊。

之前我有一直在说这个词典词典，那如何去构建这样的一个词典呢对吧，那通常我们去构建一个NLP的模型的时候，第一步都会去构建这样的一个词典，因为你如果没有词典，你就没有办法把你的字或者是词。

转换成这样的一个one hot的一个形式对吧，所以呢我们就要先去构建这样的一个词典啊，构建词典，那构建词典的第一步呢，大家需要先确认一下，你的一个输入形式到底是什么样子的，是要分词呢还是要分字啊。

如果你要分词，那你这个构建词典的时候，你就应该按照啊分词的一个形式去做，你不能说你构建词典的时候在分词，让你后面训练的时候去分词，那肯定是不行的对吧，其次呢对于这个分词的一个过程啊。

你在构建词典的时候和你后面训练的时候，用的分词器一定要是一样的，这样才能保证你分词分出来的一个，结果是一样的，好吧，千万不能混用，你说哎你前面构建词典的时候，你用的是A分子期，后面进行模型训练的时候。

你要用的是BE分子器，那这样肯定是不行的，这里必须保证这个分词器啊是一样的，那啊，假如我们现在是在用分词的一个方式，来构建这个词典，那首先第一步呢，肯定就是把我们的这个语料，读到我们的内存当中。

然后进行分词，分完词之后呢，我们通常会根据这个词频啊，进行这样的一个排序啊，排序把这个词频比较高的就放到前面，词频比较低的啊，就放到后面啊，放到后面，那在我们进行训练的一个过程中啊。

就可以直接从这个词典当中就可以获取，每一个词它对应的一个下标啊，我们可以简单看一下啊。

啊我们这边有一个有个词典啊，这里有一个词典呃，这个词典大家可以看一下啊，第一个啊，这边这两个我们先不看了，像这些的话就是我们一个一个这样的一个词啊，什么保险是你什么对吧。

这些呢就是按照这样的一个词瓶的一个顺序啊，我做了一个啊从大到小的一个排序啊，就全部排在了这个位置，这就是我们得到的这样的一个词典啊，词典，那我们把这个词典，同时也把它加到内存当中对吧。

当我们来一个句子的时候，我们分完词，就可以从这个词典当中拿到每一个词，它对应的一个下标对吧，然后它的下标。

啊这就是我们的一个词典啊，词典，OK那在词典当中呢，我们通常其实还会有一些比较常见的一些，标记位啊，标记位，然后这里呢给大家介绍四个比较常见的标记位，首先第一个呢是一个这样的一个啊补充位啊，补充位。

他这是干什么的呢，举个简单的例子啊，就假如我现在啊有一个句子，这个句子的一个长度呢，它假如是五，而现在我还有另外一个句子，这个句子的长度是八，好我接下来还有一个句子啊，这个句子的长度是十。

那这个时候其实我们要把这三个句子作为一个，batch size对吧，同一个batch它给到我们的模型，让模型去训练这一批数据，但现在如果直接给到模型，其实是有一定的一个问题的，什么样的一个问题呢。

就是它的一个长度是不一样的嘛，它的一个数据大小是不一样的对吧，我第一个句子有五个词，第二个句子有八个词，第三个句子有十个词，那我这个模型没有办法去处理，这种所谓的一个变长的一个数据啊，那该怎么办呢。

我们通常呢就会做这样的一个补偿的一个，炒操作啊，假如我们令我们这个句子的最大长度是十是十，这个时候呢，我们就会给这个长度只有五的这个句子，去添加一个pad way，添加一个这样的一个pad way。

就一直加啊，加五次加五次，直到它的长度变成十，那这个时候其实这个pad为。

我们其实已经在刚刚这个次我们这个词典，自定义的这个词典当中已经看到了对吧，我会把它放在第一个位置啊，第一个位置，然后我们进行转换的时候呢。

就会把这个pad y啊，用零的这个下标把它转换出来，零的下标转换出来，这就是pathway啊，主要是用来补常用的补偿用的，那对于八这个来说，长度为八的这个句子也是一样的啊，那我们就补充两个就OK了。

补充两个就OK了，就这个意思啊，然后呢我们这边再给大家介绍一个标记为，叫做这个UNK，这个UNK什么意思呢。

其实表示就是未知的一个词啊，还是看一下这个词典啊，这个词典一共是有400多个词嘛，就很小的一个词典对吧，很小的一个词典，那就400多个词，就很容易出现一个所谓的OOV的问题。

也就是说我们这个词可能不在这个词典当中，那如果不在这个词典当中呢，我们就用这个UNK来表示啊，用UUNK来表示。

也就是咱们的一个未知词未知词啊，然后这边的话还有两个标记位啊，一个是起始词，一个是终止词，那这两个标记位主要是用来干什么的呢，其实这两个标记尾啊，更多是用在我们的这个序列生成的一个任务。

例如我们这里有这样的一个sequence，sequence的一个模型对吧，上节课简单给大家提到过啊，它的一个结构就是有一个encoder，一个decoder，那通常呢我们就会在起始位置啊。

输入一个起始符，然后告诉我们模型啊，我们现在这是起始位置啊，起始位置，那同时我们在啊这边进行一个输出的时候，我们这边模型会输出这样的一个结束符啊，结束符表示就是哎我当前是最后一个位置了。

我后面不需要进行继续输出了，就这样的一个意思啊，好这是几个比较常见的标记位啊，然后在我们的这个BT这个模型当中，BTBT这个模型当中呢，它也有自己定义的一些标记位，像cl s s e p。

那这些标记我也是干什么的呢，到时候我们给大家啊，后面如果介绍到BT的时候，我们再给大家简单提一下这两个标记位，好吧，这里就啊不再展开讲了啊，最关键的就是这两个啊，首先第一个是head的标记位。

另外一个是咱们的一个NA好吧，这两个是比较关键的啊，这两个比较关键，好这是我们的一个词典的一个构建啊，词典的构建，好，我们接下来看一下，关于这个输入长度的一个统一啊，其实这个东西刚才也有说过。

一部分就关于这个pd标记位，对吧啊，我们刚刚是这么说的啊，如果是五的句子，长度是八的句子，还有个长度是十的句子，如果我们要统一成长度是十的，那我们就添加这个pad way对吧，Pad way。

那现在有个问题啊，啊假如我的某某某一条句子特别长，我这个句子可能长度是啊200或100，或者说200对吧，但是这样的一个句子可能就一两条，如果全都把它补充为200的一个长度，实际上是没有必要的嘛对吧。

那这个时候我们就会去做一些截断的一些处理，比如我们设置我们的这个啊最大长度是八，那对于比较短的，那我们就去补这个pad way，补拍的way啊，那对于长度是五的，那我们只需要补三个pad位就OK了。

那对于这一个比较长的来说，我们就会把它给截取啊，把最后两个词给截掉，让它的长度变为八，就是这样的一个意思啊，就这样的一个思，那补偿的话其实有两种补法啊，一种是补前面我们也可以后面啊。

那截取其实也是一样啊，你可以去截前面，也可以去截后面，那到底应该是截前面还是截后面，大家其实可以去分析一下，你自自己的这个具体的一个数据，如果你的数据你去分析完之后，你发现很多比较重要的信息。

会集中在前面的部分对吧，那你在进行截取的时候，就可以去截前面，如果你的信息比较重要的是在后面的位置，那你也可以去截后面的一个位置啊，还有一种情况啊，那假如啊我现在这个啊，假如我的最大长度是嗯。

假如我说个100好吧，100，而现在呢我有个有个句子啊，这个句子它可能是150啊，你这个时候分析之后，你会觉得哎呀，我我也不知道到底应该截前面好还是后面好，那还有一种方法啊，你可以去取前面0~50。

再把后面的，就是你取前面的50，再取后面的50，然后把它给拼接在一起，就以这样的一个形式啊，也是OK的，好吧啊，这是一些常用的截取的一些方法啊，方法对，Ok，接下来的话再给大家简单介绍一下。

这个生成器啊，生成器，那通常啊我们在训练一个模型的时候呢，我们这个语料有时候会特别多对吧，那如果你一次性把所有的这些语料都给它，加到这个内存当中，你的内存可能是放不下的啊，放不下的。

毕竟啊我们这个语料有时候可能一两万，有时候可能几10万对吧，都是有可能的，那这个时候我们应该怎么处理呢，那通常我们在训练这个机器学习的，模模型的时候呢，都是以一个背驰，一个背驰的一个进行一个训练对吧。

那我们在读取数据的时候，实际上也可以以一个背驰，一个背驰把这个数据给读取出来对吧，没必要一次性全部给读取出来，那这个时候呢我们就可以而使用啊，咱们拍套是当中的这个啊。

TENSLDATASET和这个data loader来组成，或者说来生成这样的一个生成器啊，生成器，那我每一次就可以取出一个被ch size的一个数据，然后给到我们的一个模型啊，给到模型。

然后我们这边呢这个所有的这个模型呢，接下来都会用这个PYTORCH来教大家写好吧，用PYTORCH教大家写啊啊这是一个生成器，那这里可能啊我单纯这么说，可能说的不是特别清楚啊。

然后待会待会我们在那个代码当中，我们也会详细的来看一下这个啊，TENSLDATASET和这个data loader好吧，到时候我们再具体来看这个东西到底该怎么用，好，说完生成器，我们继续往下啊。

我们简单来说一下，关于在这个PYTORCH当中，我们该如何去构建一个模型，而这个时候有的同学可能会说，我之前完全没有用过这个PYTORCH啊，现在就直接让我来构建这样一个模型，会不会难度太大呢对吧。

其实呢PYTORCH这个包呢，在构建模型的一个过程当中是非常简单的啊，非常简单的，它是如何去构建一个模型的呢，首先呢如果我们要构建一个模型，就需要自定义一个类啊，自定义一个类。

然后继承自这个NN导MODUNN达mode，继承完了之后呢，我们需要重写一下这个构造方法，和咱们这个符号的方法，那构造方法是干嘛的呢，通常就是去初始化一些参数对吧，初始化一些参数。

相信这个学计算机的同学，这一块应该是很清楚的啊，而第二个方法呢是这个forward的方法，这个for的方法是在干嘛呢，大家可以理解为，它就是在做我们的一个前向传播好吧，前向传播，额这里这个构造方法啊。

除了刚才说的初始化一些值，那通常呢我们还会在我们这个构造方法，能知道啊，去提前就是定义好我们需要的一些layer，例如我现在需要这样的一个卷积层，对吧，我需要池化层，或者说我需要这个LISTM层。

那我就会把这些模型给在这个构造方法当中，提前构建好，然后呢我们在我们的for word方法，也就是前向传播的这个过程当中呢，就把构造方法当中构建好的这些雷影啊，一层一层的拼接在一起。

就完成了我们的这个前向传播的一个过程啊，for word方法就是前向传播，把定义好的layer全部串起来啊，全部串起来，这就是这个PYTORCH，构建模型的一个使用过程啊，其实是非常简单的非常简单的。

待会呢我们也会带着大家使用这个PYTORCH啊，从零来构建这样的一个深度学习的一个模型，然后当你走一趟的时候，你就会发现其实很多东西你就清楚了好吧，待会我们再来详细的去写这个代码啊。

好啊，这就是我们的这个第一部分啊，第一部分啊，关于这个啊如何从零去搭建一个NLP的模型。

好简单的说一下啊，其实首先第一点呢就是我们需要去确认一下，我们到底是应该以这个字向量作为输入呢，还是此向量作为输入对吧，其次要考虑一下，你要不要去加一些额外的一些经验特征啊，或者之类的。

其次呢我们考虑好新上上述这一点之后呢，你就可以去构建这样的一个词典对吧，构建完词典之后呢，你要去做一些数据的一些预处理，包括去做一些长度的一些统一，你要去补pad way。

或者是做一些这样的一些截取对吧，呃，下一步的话就是去构建我们的这样的一个模型，模型构建好了，那你就可以训练模型啊，整个流程大概就是这个样子，好吧好，我们这边先停一下啊。

看各位同学对于这一块有没有什么问题，有问题吗，各位同学，都没有问题是吧。

好没问题的话，我们就继续啊，继续我们来看我们的这个啊。

本节课的第二部分啊，也就是我们的这个常见的文本分类模型啊，那这一节课的话，实际上我们是要给大家讲解这样的一个，分类模型的啊，这一这一部分其实在上节课的时候，也给大家提到过啊，也就是在这个意图识别这一块。

印度识别这一块，也就是说当用户的问题输入进来之后呢，我们会经过一个这样的一个，意图识别的一个模型，说白了他就是在做一个文本分类对吧，我们会判断一下啊，他到底是这样的一个闲聊呢。

还是这样的一个封闭域的一个问题好，如果封闭的话就走，我们昨天给大家介绍的这个检索式这一块对吧，检索时这一块好，那接下来的话我们就来详细看一下，对于这里这个意图识别这个分类模型，我们到底该怎么做啊。

怎么做额，首先这个是这边可以给大家简单看一下啊，这边我这边有一个这样的一个，闲聊的一个语料啊，闲聊的一个语料啊，大家也可以过去，把这个闲聊的这样的一个语料给加载一下啊，他这个闲聊语料其实很多啊。

很多各种杂七八杂八的其实都有啊，都有，那我们的一个训练集它是什么样子呢，我们可以看一下这边啊，就等于我是把这个数据齐给拿了过来。

然后呢，再和我们的昨天给大家讲的那个，保险的那个数据啊，把它合在了一起，那合在一起之后呢，哦我们看一下啊，是这个啊这个数据这个数据合在一起，那对于他是这样的一个保险类的问题呢。

我就会把它设置为零这个类别啊，零这个类别，如果他是闲聊，我就会把它设置为一这个类别好吧，一这个类别，好这是我们的一个数据集啊，数据集整体来说其实对于这个分类来说，难度不高啊，难度不高，好。

这是我们的一个数据集。

然后大家下来的话，也可以自己去构建这样的一个数据集，闲聊的部分的数据集，你就往这边去取就OK了，然后把它设置为一个类别，然后咱们昨天的那个啊这个数据对吧，拿过去把它作为我们的另外一个啊类别，就OK了啊。

OK了好，这是我们的语料啊，语料我们继续往下好，那有了我们这样的一个训练语料之后呢，我们看下面啊，那接下来的话就给大家介绍一下，咱们的这个几个比较常见的这样的一个，文本分类的一个模型好吧。

那首先是咱们的一个输入输入，刚才已经说过了啊，就是咱们的一个字词向量，你可以用自向量，也可以用这样的一个词向量，你甚至可以用语言模型来进行，这样的一个初始化的一个方式啊，好，然后第二部分的话是。

我们就来详细说一下，这样的一个文本分类的一个模型啊，呃文这里文本分类的模型呢，我给大家总结了五个模型啊，五个模型，那这五个模型的话，希望大家下来都能掌握好吧，而在我们的这个课程当中呢。

我们只会去讲这个TXCNN啊，也不是只会讲这个模型啊，是主要去带着大家去写这个模型，而其他模型，我希望各位同学下来，自己花时间去了解的更深入一些，然后自己去把这些模型给实现好吧，理解起来其实都很简单啊。

都很简单好，我们就看一下，为什么我会给大家说这介绍这五类模型呢，首先第一个模型是这个fast text，这个模型它结构特别简单啊，特别简单，简单到什么程度呢，它实际就是把咱们的一个文本啊，文本text。

然后给到这样的一个embedding层，embedding层，那给到这个embedding层之后呢，最后再给到我们这样的一个分类层啊，分类层你可以是一个soft max，你可以是一个SIGMOID对吧。

就给到这样的一个分类层，就能得到我们的一个分类的一个结构啊，这是fast text，那这样的一个模型呢，它比较适合用于，就特别明显的那样的一个分类场景，而且它比较适合短文本啊，短文本就特别特别明显。

分类及特别明显短文本的一个场景，大家可以使用这个force text好吧，然后呢是我们的啊，这个TXCNNTTCN，这个东西呢比较适合去做这个，短文本的一个分类。

那为什么tag cn只适合做短文本分类呢，因为我们这里使用的是这样的，CNN的一个模型，那CN其实通常没有办法去捕获这个太长的，这样的一个特征的一个依赖，所以呢通常比较适合用于处理这样的一个，短文本啊。

短文本，而对于我们的这个数据集，其实大家可以看一下，其实也属于一种比较短的一个文本对吧，都是比较短的，可能就十几20个字的样子啊，比较短。

所以呢我们就今天也主要给大家介绍这个tag森，这个模型，然后如果是长文本呢，推荐大家可以去尝试使用这个，HAN这个模型啊，那HAN这个模型它啊，底层其实是一个LSTM的一个结构好。

然后呢是一个比较通吃的一个模型啊，这个模型呢你可以去处理短文本，也可以去处理长文本都是OK的，也就是一个双向的LSTM，再去加上这样的一个attention的一个机制啊，attention的机制。

那这个attention是什么东西呢，这个东西我们待会给大家讲好吧，LSPM我相信各位同学应该有一定的了解过，可能了解的不深啊，各位同学也可以下来，多花点时间，再去看一下。

这个双向的LSTM到底是什么样子的好吧，那最后的话再给大家提供一个终极方案啊，也就是咱们的预训练的语言模型叫BT，来做这样的一个微调啊，BERT做微调，就是说你在实际的一个工作过程中。

你可以先去使用上面这几个模型去尝试一下，效果怎么样，那如果尝试出来效果不是很理想，那你就可以直接上BT，那贝尔特最大的优点就在于它效果很好，但是它也有一定的一个缺点，就是速度比较慢啊，速度比较慢。

那假如我现在已经在用这个text c n，我这个效果已经能达到98%对吧，99%已经可以打，满足上限的一个要求了，那你实际上就没有必要去上这个bird对吧，毕竟我们这个TAXN速度会快很多啊，快很多。

咳咳好，这是额五个模型啊，然后我们就分别来看一下啊，分别来看一下，首先说一下这个fast text，fast text其实刚刚也和大家简单说过嘛，对吧，也和大家简单说过。

它其实结构和咱们这个word vector当中那个CBL，其实结构会很类似啊，cl结构很类似，那SB模型是什么样子呢，就是输入咱们这样的一个上下文对吧，输入咱们的一个上下文，然后去预测这样的一个词。

那不同的地方是什么呢，就是fast text，它其实预测的它不是中间的这个词啊，不是中间的这个词，而是这是T减二对吧，这是WT减一，这是WT，然后WT加一，这是wt加R啊。

他把这几个词啊给到了我们的这个模型，然后最后再来进行这样的一个分类啊分类，所以说force text和我们的一个SL结构会很像啊，其实可以看到啊，非常简单对吧，真的非常简单，非常简单好。

这就是fast text，那这个因为实在太简单了，其实带着大家写代码的话，其实意义也不是很大啊，不是很大，好我们继续往下啊，嗯接下来说一下这个比较重要的一个模型啊，这个模型也是今天课程当当中呢。

会大大带着大家一起去写的这样的一个模型，也就是我们的这个TXCN好吧，TAXN这个模型呢这边有两篇论文啊，这两篇论文我都建议大家下来去自己阅读一下，好吧，最好是把两篇阅论文都阅读一下。

这两篇论文其实都是讲用这个CN来做这样的，文本分类的啊，文本分类，那他的一个思想是什么呢，其实它关键就在于啊，他会利用这样多个不同大小的，这样的一个kernel啊，来提取句子中的一些关键信息。

他的这个思想是什么呢，就是说啊我们一个句子对吧，我们X1X2X三，假如我们有这样的一个句子啊，这个句子由五个词组成，那假如我们的kernel大小是一，那每次就等于是提取了一个词的这样的，一个特征对吧。

也就是所谓一个词的一个特征，那如果我们的kernel是R呢，它实际上每次要提取的是两个词的一个特征，那我们kernel大小是三，它实际提取的就是三个词之间的，这样的一个特征，所以这样的一个思想。

就类似于多个窗口大小的这样的一个，n gram的一个思想，或者说我同时提取了一个字的特征，词的特征，甚至短语的特征，甚至段落的一个特征对吧，但段落说的有点过了啊，更多还是词的特征和这个短语的一些特征。

从而呢我们让这个模型啊，从不同的一个力度去捕捉文本的这些特征，或者说它的这样的一个相关性好吧，这是这个模型的这样的一个思路啊，思路好，我们就接下来就详细看一下这个模型，它的一个结构是什么样子的啊。

嗯首先是我们的这个第一层啊，第一层第一层的话就是最左边这个啊，最左边这个他这个音我们可以看一下，1234567，一共是七个词对吧，那这里就等于是一个七行五列的这样的，一个举证啊，七行五列的一个矩阵。

那七的话表示就是我们这个词的一个个数，五的话表示的就是咱们这个，embedding的一个维度，我们这里因为是一个图嘛，就写的比较简单啊，就是一个五维，也就是说我们每个词。

它有五维的一个这样的一个向量好吧，但实际上我们在构建模型的时候，肯定会把这个维度设置的稍微大一点点啊，稍微大一点点，那大家也可以简单的把这个这个东西啊，就看成是我们这样的一张图片。

看成是这样的一张图片啊，OK那接下来呢我们就会去按照刚才的一个思路，是什么，去定义这样的一个不同大小的，这样的一个kernel嘛，对吧，我们可以看一下啊，这里实际上呢就定义了三种。

不同大小的一个kernel啊，首先第一个kernel我们可以看一下，他这个kernel实际上是一个1234，就是一个4×5的对吧，一个4×5的一个克隆，这个深红色的和这个浅红色的啊。

这两个是4×5的一个克隆，那这两个绿色呢它是一个3×5的克隆，到最下面这个黄色的，就变成一个25的一个KERO，那这个25的kernel，大家就可以理解为我这里提取的就是两个词，两个词的一个特征对吧。

然后这边的话绿色的大家可以理解为，我每次提取的就是三个词和三个词之间的，这样的一个特征，也就是一个短语的一个特征嘛，那这边也是同理对吧，提取出来这样的一个短语的一个特征啊，呃大家这里需要注意一下啊。

就每一个大小的一个kernel，我其实是有两个对吧，就这里这个深红色4×5，我们这里还有个浅红色的，也是一个4×5，那为什么需要两个kernel呢，其实用一个kernel也可以。

但是一个kernel它可能提取出来的特征，他没有那么多，所以呢我们通常都会搞多个坑的，你甚至这里搞十个，搞100个科隆都是OK的，好吧，嗯CURREN越多的话，你提取的特征也会越多一些，当然了啊。

这个实际上属于的是这个超参数啊，超参数大家要根据实际情况去进行一个调整，那如果你的KO太多的话，就可能也会出现一些所谓的这个训练时间过长，或者甚至出现一个过拟合的情况，也是很容易出现一些过拟合的情况。

也是可能的对吧，所以我们这kernel到底应该选多少，你可以去根据你自己的一个情况，去进行这样的一个调整，好吧好，这是我们的一个，这个kernel啊，kernel好，那我们定义好这个kernel之后呢。

就会可就可以把我们的这个kero kernel啊，作用在我们原来的这个7×5的这个，embedding上面对吧，我们先用这个深红色的去做这样的一个，卷积的一个操作啊，卷积的一个操作。

那就可以得到一个4×1的一个结果，卷积之后的一个结果对吧，4×1的一个卷积之后的一个结果啊，这边我简单问一下，对于这个卷积的一个操作，各位同学了解吗，这个卷积的操作就是这个卷积。

为什么这个7×5和47×5的原始数据，有一个45的一个kernel，进行一个卷积计算之后，为什么是得到一个4×1的一个结果，这个东西大家清楚吗，这个清楚吗，各位同学有没有不明白的同学，这里需要讲解吗。

都是知道的是吧，大家有问题一定要及时提出来好吧，一定要及时提出来，我们这个嗯还是需要讲一下是吧，好我们看一下啊，我们看一下这个卷积操作它是在做什么呢，我们这边简单画个图啊，假如我们的原始数据是这样子的。

它是一个2×2的，那如果我们的这个卷积核它也是这样的，一个2×2的卷积核，那这两者作为一个卷积操作，它是怎么做的呢，实际上啊就是把这个位置的值啊，我用我这边用O1来表示吧，好吧，这是O2。

这是O3是O4，然后这边我用啊K1谁呀，谁3A4，这个卷积操作是怎么做呢，其实就是一个对位相乘相加，那最终就是O1乘以K1加上O2乘以A2，加上O3乘以K3，加上O4乘以K4。

这就是我们卷积之后的一个结果啊，卷积之后的一个结果好，那我们看这里啊，我们看这里，那如果我们用这个4×5的作用，在这个7×5的上面，我们可以看到啊，它实际上就会把这些位置给遮住对吧，这些位置给遮住。

这个时候呢我们计算出来的是一个值对吧，这个值就是放在这个位置，就放在这个位置这里没问题吧，那这个时候其实下面还有三块，它实际上是没有计算到的嘛，这个时候呢我们会把这个卷积核往下面平移，一个位置。

平移一个位置，那平移之后呢，就变成了这个位置，也就是变成了这样的一个位置啊，我们就等于是在这个位置当中又进行一次卷积，就是对位相乘相加，然后得到这样的一个位置的一个值。

而接下来呢我们又往下面进行一次平移，再平移一次呢，就变成了这个位置对吧，我们在对这个位置啊，做一次这样的一个卷积的一个操作，而得到的结果在这里同理啊，我们再往下面平移一次，最后得到的结果就是在这个位置。

所以这里最终得到的一个是一个，4×1的一个结果啊，我有说明白吧，这位同学我有说明白吗，这就是一个卷积的一个操作啊，卷积的一个操作，就是一个对位相乘相加的一个操作，然后进行一个平移。

把所有的这个都给计算一遍，好OKOK那啊对于第一种大小的这个卷积核，我们计算完之后呢，我们再看一下绿色的这个卷积核啊，那对于绿色的这两个卷积核，一个深绿色的，一个浅绿色的。

其实和刚才的这个计算方式也是一样的啊，只不过这个大小是三对吧，那我每次计算这个卷积的时候，就是取三行来进行一个计算，所以它最终的一个输出的一个结果是5×1啊，5×1，所以大家需要注意一下，是5×1。

那同理啊，对于下面这个黄色的，它是一个2×5的一个卷积核，那我们每次在进行卷积操作的时候，取的就是两行，所以最终计算出来的一个结果啊，就是一个6×1的一个结果，6×1的一个结果好。

这就是我们卷积层卷积层，OK那卷积层结束之后呢，我们通常都会在卷积层之后，去跟一个这样的一个池化层了啊，这里尺的使用的是这样的一个最大池化层，最大池化层是在干什么呢，就是取一个最大值。

你看我们这里不是有四个值嘛对吧，那我们就取这四个值当中的一个最大值，然后把它取出来，这里也是一样啊，四个值取个最大值取出来，然后下面也是一样的，这五个值这五个值取最大值取出来，下面这个黄色也是一样啊。

同理最后呢我们实际上就会得到六个值对吧，这里两个红色的，这里两个绿色的，这里两个黄色的纸，然后我们把这这分啊，这这六个值啊，把它给拼接在一起，拼接在一起，那对于这个这个值呢，它实际上就是一个啊。

长度为六的这样的一个向量对吧，这个向量表示的就是我们最终句子的，这样的一个特征向量，我们再把这个句子特征向量啊，给到我们后面的一个分类层，分类层来做我们的一个多分类，或者是一个二分类，二分类的话。

那你搞个SIGMOID，如果多分类的话，你就搞个soft max就OK了，好吧，这就是我们整个这样的一个taxi，taxi其实结构也是非常简单的对吧，结构非常简单，但是这个结构可以让大家学到很多东西啊。

首先是我们的这个池化层这一块，然后其次我们的啊这个好，首先是我们的卷积层，要是我们的池化层，要到最后我们的这个分类层对吧，那这个模型呢，它整体来说网络结构是非常简单的，而参数也很少可以。

各位同学可能在使用的时候，在自己的笔记本上就可以简单啊跑起来了，甚至你用CPU跑都是完全没有问题的啊，完全没有问题的，那这个模型的话啊，除了它计算量比较小之外呢，它其实本身这个效果还是不错的啊。

还是不错的呃，待会我们也会详细带着大家啊，把这个代码给写一下，好吧好，这就是我们的这个TAXZN啊，也是我们今天的一个重点啊，重点好，那说完TXN，我们再来说一下这里这个HAN这个模型啊。

HAN是干嘛的，还记得吗，是用来处理这样的一个长文本的对吧，长文本好，我们来看一下这个模型是干嘛的啊，嗯这边也是一样啊，我们这边会有一个论文的地址，各位同学可以去看一下这篇原论文好。

首先是我们来看一下这个模型啊，这个模型它其实是分为了啊四个部分啊，首先第一个部分是我们这个WARENCODER，这个部分是在干嘛呢，实际上我们就等于啊，我们这里是每一个这样的一个词的一个。

embedding对吧，一开始我们实际上输入的是这样的一个one hot嘛，one hot呃，经过了这样的一个embedding层之后呢，拿到每一个词的这个word embedding对吧。

然后WARENCODER这一层呢它是一个GRU的模型，GRU这个GRU是什么模型，它其实也是一个LSTM的一个变体啊，是一个LSLSTM的一个变体，它相比于LSTM来说，他做了一些这样的一个改进啊。

大家也可以把它就看成是LSTM，他搞了一个这样的一个双层双向的，一个这样的一个GRU的一个模型，然后对我们输入的这个词，进行这样的一个特征提取啊，特征提取提取完之后呢，他会在把这个提取出来的一个特征。

去做这个所谓的一个attention的一个操作，这个attention是什么东西呢，好我这边简单说一下啊，什么是attention，而TENTION的意思就是说。

我们要对每一个这样的一个这里的这个输出值，给他一个权重，理论上来说我们一个句子对吧，每一个词它应该有自己的一个对应的一个权重，就像各位同学去理理解一一个句子的时候，这个句子肯定是有些词它是比较重要的。

有些词它实际上是不重要的，它可能是些废话对吧，那对于那些比较关键的词，我们就会给它一个比较大的权重，对于一些无关紧要的一些词，我们就给他一个比较小的权重，从而有了这些权重之后呢。

我们就可以对我们的这个每一个词的这个vector，去做这个所谓的加权求和，就这样的一个意思啊，也就是说我们这里啊对于每一个词，我们都会拿到这样的一个权重，拿到这样的一个权重。

我们会把这个权重呢和对应的这个词的一个，向量表示做一个相乘的一个操作，最后再把它给相加起来，相加起来，最后我们就会得到这样的一个，句子的一个embedding，句子的embedding。

其实这个东西和上节课我们也简单说过嘛，我们上节课要在做句子，embedding的时候是怎么做，是求的平均吗，求平均，它其实也是也可以理解为一种腾省，只是说这个腾省的权重它都是一样大对吧，都是一样的啊。

那只是说这里啊，我们这个要用一些额外的一些方法，把这个每一个词它的一个权重给计算出来，然后得到他一个加权之后的一个结果，那加权结果出来之后呢，实际上表示的就是这几个词组成的一个句子。

的这样的一个embedding啊，Embedding，那接下来的话我们再来看这一层啊，这一层是叫做sentence encoder，这里其实各位同学可以看到，它其实是有一个一个的一个句子。

这样的一个embedding，然后又给到了这样的一个GRU层，GRU层其实结构和下面这里是一样的啊，经过加U层之后呢，再把每一个句子的这个embedding，进行了这个特征提取。

再经过这样的attention的一个处理，再做一个加权求和，就得到了我们整个段落的这样的一个embedding，最后再给到我们的分类层啊，分类层，所以说对于HAN这个模型来说，他思路到底是什么呢。

实际上就是先把词进行特征提取，然后加权求和对吧，然后得到一个一个的句子的一个embedding，再把这个句子的一个embedding，给到我们的这个GRU，然后再得到它的一个权重，进行加权求和。

得到我们段落的一个embedding，最后给到我们的一个分类层，这就是HAN这个模型啊，HAN这个模型，所以说H这个AN这个模型啊，是用来处理长文本的，只有长文本你才会有多个句子嘛对吧，多个句子。

那每一个这个句子，其实它也是会有同样的一个结构嘛，那这一块的一个结构，其实和这一块的，和这个东西的一个结构是一样的，好吧一样的，其实这个时候可能各位同学就会想，哎，那既然如此，我是不是可以这么做啊。

我不要上面这一部分，就上面这一部分啊，我不要了我不要了，我只考虑下面这一部分，那我下面这一部分是不是就等于是一个双向的，加U加上一个attention对吧，那我是不是就可以得到句子的embedding。

我把这个句子的embedding再给到我们的分类层，是不是就可以做短句的一个分类了呢，是的啊，完全是可以这么做的，那这也是我这里提到的这个双向的LISTM，加腾什么对吧，加藤上啊。

只不过这里说的是一个GRU对吧好，这就是我们的一个HAN这个模型啊，HAN这个模型，OK那模型这一块的话就给大家说到这里啊，接下来的话我们就要进入到这个啊编码过程了，好我们先停一下啊。

然后bird这一块我们之后再说好吧，bird这一块，后面我看应该会花点时间给大家简单补充一下，bird这一块，好吧好，我们这里先停一下啊，啊对于这里的模型，大家有没有什么疑问。

Force text tt cn，还有HAN这三个模型，大家有没有什么疑问，有疑问的话就及时提出来，好这边我额外再说一点啊，就关于这里这个attention这个权重该怎么计算。

那这个attention其实有很多种attention啊，attention只是一个总称，实实际上呢有很多这个TENTION，有dollar的tension。

dollar product的tension，还有一些run和腾省，很多很多很多腾省啊，这个东西的话，我们后续再给大家介绍好吧，这都是一些计算权重的一些方法哈，好看各位同学有没有什么我没有讲明白的地方。

可以及时提出来啊，有问题吗，有问题吗，好行，那我们继续啊啊，然后接下来的话就简单说一下，这个作业这一块啊，作业这一块的话就是大家自己去写代码，去实现这个tag nn模型，然后把它集成到我们的项目当中去。

完成我们这里说到的这个意图识别这一块好吧，意图识别这一块，然后呢啊进阶作业的话，就大家自己去微调一下咱们这个BT这个模型啊，然后并替换咱们这个分类模型，或者说我们之后会涉及到这个匹配模型。

你都可以去进行这样的一个替换，好吧好，那接下来我们就一起来写这个代码啊，接下来一起来写代码，我们稍微休息一会吧，稍微休息一会，然后大家啊对于这里这个啊TTIN或者是JN，如果有什么问题的话。

也可以打到公屏上，我们统一解答好吧，我们待会统一解答啊，我们重点还是放到text text cn好吧，因为待会我们写代码，也是写这个TXN的代码好，我们稍微休息一会啊，休息5分钟，好啊，我们继续上课啊。

继续上课啊，接下来我们来写代码啊，写代码大家都没有什么问题是吧啊，我们这稍微停一下吧，顺便对于上节课的内容，大家看有没有什么疑问啊，如果有什么疑问的话，也可以一起提一下好吧，都是没有什么问题的是吧。

如果都没有什么问题，那我们就来写代码咯，啊我们先把这个给删了吧，好那我们来啊写这个代码啊，写代码，啊第一步的话肯定是，嗯把NN也可以导一下，好第一步还记得什么吗，好定义一个类对吧，我们就叫TAXN。

而这个tag n呢需要继承于NN导module对吧，NN导module m u m o d u，有人打model嗯好，那继承完n n w module之后是要干什么，我们可以看一下啊。

是要写我们的构造方法和符号的方法对吧，在哪里来着，去重写我们的构造方法和我们的符号的方法。

对吧，好这是我们的啊构造方法，然后呢是我们的这个啊for尔的方法对吧好。

word方法好，那写了我们的构造方法和这个word的方法之后呢，我们再看一下构造方法是在干嘛，是初始化一些值对吧，然后并定义好我们会用到的一些layer啊，Layer，那flow方法是干嘛呢。

就是做我们的前向传播对吧。

前向传播好啊，我们先来写我们的这个啊，我们先来学我们的构造方法啊。

构造方法我们可以回到这一页PPT啊，我们可以看一下啊，那对于这一页PPT来说，我们可以考虑一下啊，我们会涉及到哪些层，会涉及到哪些层呃，其实这边已经写了啊，首先第一个是咱们的embedding层嘛对吧。

Embedding，Ok，那我们就先来定义我们的这个embedding层，embedding层啊，其实定义embedding层也很简单啊，就是NN导embedding。

就可以定义好他的这个embedding层，那这个embedding层第一个参数是是什么呢，实际上是词典的一个大小啊，词典的一个大小啊，这个这个这个参数，我们实际上是可以从外面传递进来的啊。

我们可以从外面传递进来啊，我们就叫做VOCABULAN吧，我们把这个参数从外面传递进来啊，传递进来，那第二个参数呢，实际上就是我们那个embedding size啊。

我们这个embedding size也可以从外面传递进来，好我们可以给个默认值啊，假如我们就给个100好吧，100好。

这就是我们的第二个层数，embedding size好，这样的话我们就可以把我们的这个embedding层，embedding层啊，就定义好了，定义好了，OK那接下来的话我们来定义我们的这个啊，卷积层。

卷积层啊，卷积层有三种不同的卷积层对吧。

那我们就定义三个嘛啊come on，就NN导好，CD好，这就是我们的一个卷积层啊，卷积层，那卷积层呢，首先是我们的它有一个参数叫做in channel。

就是输入的这个channel它是几维的，那对于我们这个文本数据来说，它实际上就是他这个数据是一维的嘛对吧。

它不像我们的图像，它是RGB有三个通道，那我们这里in china就是1R1，也是我们的这个output channel。

output channel呢，也就是说我们这里会有输出多少个。

这样的一个channel的一个值，那我们这里会应用两个KERL对吧，那我们就可以就可以定义一个啊啊好，我们和这边保持一致好吧，和这边保持一致好，最后是我们的这个kernel size啊。

Kernel size，那这个kernel size啊。

对于我们的第一个kernel来说哦，我们这边写的是234对吧。

234啊我们可以看啊，我们这边我们可以1234来，也可以稍微大一点点，都OK好吧。

嗯我们这边就我们我们啊我们取个345好吧。

我们取个345好啊，第一个维度就是三，第二个维度的话，就是其实就是咱们的这个embedding size啊，Embedding size，嗯我们用元组来写，好我们用元组来写好。

这是我们的一个kernel size啊，第一个那对于第二个来说，我们的第二个卷积，还有第三个卷积，那就从我们原来的这个啊，或者我们跟这个保持一样好吧。

我们还是用234，我们和这边保持一样啊，234有两个三个四个好。

OK行好，那接下来的话啊，我们这个。

卷积层定义好了是吧，三个卷积层定义好了，接下来我们要定义什么，是不是池化层对吧，纯化层哎，这时候有的同学会问哎。

这不是一共六个卷积核吗，应该是六个呀，为什么是三个，因为这里output channel是R嘛对吧，output china是R，所以我们这里啊定义三个就OK啊，定义三个就OK好。

那接下来我们来看我们的池化层啊，池化层我们next put，我们的最大池化层啊，next p嗯，首先定义我们的这个kernel size啊，kernel size好，我们接下来要考虑一下啊。

我们这个kernel size，它的一个大小大小是什么样子的，我们可以看一下。

那对于第一个卷积核来说，它的这个大小是，对于这个卷积核来说，它的大小是4×5对吧，然后我们输入的文本是这个7×5，那我们这个输出值它的一个大小是怎么算的，实际上啊就是用七减掉这里这个四，然后加一。

那下面这里也是一样啊，七减掉三是四嘛对吧，然后再加一就是五呃，对于黄色这个也是一样啊，七减掉二是五五，再加一就是六啊，就是这样的一个情况来计算出来的，那这个时候，实际上我们就需要知道一个序列的一个。

最大长度对吧，我们需要知道这个序列的最大长度好，那我们这里就把这个序列的最大程度，从外面给传递进来啊，这个我们EXCELL啊，我们这个先给个默认值吧好吧，excellent默认是十。

那这边的这个最大大小是怎么算呢，是不是就是max l减掉，我们的第一个kernel的一个卷积核的大小，是二对吧，那就是减二，然后再加一，就这样形式就是这样子啊，好我们一共设有三个最大触化层，123好。

那这边就变成了啊234对吧，没问题啊，没问题，OK这样的话，我们的这个卷积层和我们的一个石化层啊，就都OK了啊，OK了啊，然后这里我们可以再搞一个DP out，那这个dropout层是干嘛的呢。

其实啊大家可以简单的理解为，它就是类似做了一个这样的一个减脂的操作，它可以防止模型过拟合好吧，它可以防止模型过拟合，他的思路，有点像数模型当中的这样的一个，减脂的一个处理。

它实际上就是随机的把某些节点给断开连接啊，断开连接，当然这个东西只会在这个训练的过程当中，是生效的，好吧呃最后我们再来啊，定义一下我们这个全连接层，我们叫dance吧啊，全连接层LINU啊。

LINUX层，那这个linear层它的一个输出维度是什么样子呢，这里这个输出维度是什么样子的。

我们可以回过头来看一下啊，这里是两个，这里是两个，这里是两个，加起来是六个对吧。

所以我们这里这个应该是六个节点，所以这里应该就是六啊，六那最后我们因为做个二分类嘛，我们可以在结尾去接一个这样的一个，SIGMOID的啊，所以我们这里可以输一好。

这就是我们需要准备的一些这个layer啊，我们的一些层好，基本上就是这些啊，就这些啊，我们这里稍微停一下啊，看各位同学这里有没有什么问题，包括这里为什么是六，没问题吧，这里为什么是六，有问题吗。

这里为什么是六，各位同学知道了吧，然后还有包括为什么这里是减2-3减四，为什么这里要加一这些清楚吗啊，都是明白的是吧，好OKOK行好，这是我们的这个for word啊，这个构造方法啊，构造方法。

那构造方法OK了之后呢，接下来啊我们就来看我们的前向传播，前向传播，那前向传播第一步，是不是就是把我们的这个，首先我们要有一个输入值啊，我们可以给他一个输入值，这个钱江传播肯定要把这个文本给进来嘛。

对吧，给进来好，那接下来呢，我们应该第一步是拿到我们这个embedding，拿到embedding的话，实际上就是执行我们的embedding层嘛，对吧，embedding层，然后把我们的X传递进来。

这个输入值实际上是一个one hot一个表示啊，一个one hot一个表示啊，也不是一个完好的一个表示啊，实际上就是他在这个词典当中的一个下标，好吧，你输入的就是每一个词它的一个下标啊。

下标它会自动去转换成一个问号的形式，然后去跟这个embedding matrix进行相乘，拿到我们这个embedding好吧，拿到我们embedding好，拿到embedding之后呢，我们这里啊。

因为我们这里是个卷积核，这个卷积操作它是一个二维的一个卷积，那在我们图图像领域啊，我们的CV领域如果是这样的一个二维卷积，它其实需要你的是四维的，四维的啊，所以呢我们这里实际上可以对我们那个。

embedding做这样的一个维度的一个啊扩展啊，扩展，我们给它加一个这样的一个维度，加一个这样的一个维度好，加了一个维度之后呢，它实际上就变成了什么样子呢，第一个维度就是我们的h size。

可以算一下第二个维度就是以，而第三个维度的话就是我们的序列长度啊，呃最后一个维度的话就是我们的这个，Embedding size，那之前的话不加的话是它实际上是这样子，是这样子这样子。

那我们因为我们这里有个in channel嘛，这个是设为的是一，所以我们需要给他额外加一个维度啊，好这里就变成这个样子啊，变成这个样子，好OK那embedding处理完了之后呢。

啊我们接下来就进入到了石化那个卷积层，对吧，卷积层点击层，我们先来执行第一个卷积层，我们的come one come one，然后给到我们的这个embedding embedding。

好这个embedding啊，我们就叫做啊，come one e out吧，好吧，Come on e out，然后接下来是二，然后是三，这边是第二个卷积，第三个卷积，那这个卷积之后呢。

我们其实需要去做个简单的一个处理啊，我们要把这个维度可以降一降，我们把最后一个维度给去除啊，最后一个维度给去除，因为这个时候最后一个维度实际上是一样啊，维度最后一个维度是一，那这个时候我们在执行这个。

我们这里是个最大池化层，实际上是一个一维的嘛对吧。

一维的我们就可以把最后这个维度给去了啊，我们可以看下这边啊。

那实际上这里是个4×1的嘛，那我们把最后这个维度给去了对吧，没有必要保留，要去直接执行这样的一个一维的一个石化，石化层，OK那磁化我们就可以啊，直接来执行啊，好我们把我们的这个卷积。

第一层的结果给给D给进来，然后是E啊，后面都是一样啊，好好啊，三第二个池化层，第三个池化层，这是第二个卷积层的输出值，表示第三个卷积层的一个输出值，对吧啊，这样的话。

我们就拿到了我们的这个池化层的一个结果啊。

池化层的一个结果，那拿到池化层的结果之后呢，我们需要把这个池化层的结果给拼接在一起，对吧，拼接在一起啊。

这里怎么拼接呢，我们可以用touch点cat方法啊，我们就可以把我们的alt1alt2，还有我们的out3，把它给拼接在一起啊，拼接在一起，然后这个的话是一个维度的意思啊。

欧码按照第二个维度进行这样的一个拼接。

那拼接完了之后呢，实际上我们还可以。

他还是会有最后一个维度嘛，对吧，我们可以把最后一个维度给去除啊，去除好，这是我们最终的一个输出值，那这个输出值我们还可以简单做一些处理啊，例如调用一下我们刚才的这个drop pot层，然后执行一下好。

OK最后呢我们再给到我们的这个啊dance，这也就是我们的全连接层啊，全连接层，我们把我们的这个维度是六的，这个向量给到我们的全连接层，然后得到一个一个值对吧，得到一个单独的一个值。

然后最后我们可以调用一下，我们这个SIGMMOID的方法，SIGMOID的方法，然后把alt值输入进来，然后最后这里啊需要降个位啊，好这就是我们最终的一个输出值啊。

输出值OK我们再把这个输出值return，把这个输出值给返回好就OK了啊OK了，这就是我们整个这样的一个啊模型模型，那我们这边模型定义好了之后呢，就可以来好这个模型啊，好我们这边稍微停一下啊。

对于for word方法这一块有没有哪里有问题的，其实整体结构还是很清晰的对吧，都是使用我们在构造方法当中定义的好的，这些层把每一层给拼接在一起对吧，拼接在一起，你看前一层拿到了输入值，然后把结果输出。

再把这个输出值给到下一层对吧，然后分别输出，就按照我们这边的这个PPTT当中的，这样的一个结构，把这个模型给组合起来，就OK了哈就OK了，好我们稍微停一下啊，看各位同学有没有什么问题，这里，有问题吗。

好那我们就继续往下啊，继续往下啊，接下来的话我们来看一下这个，词典处理这一部分啊，词典处理这一部分啊，首先呢我们这边有一个方法啊，叫做这个嗯beautiful CAB这个方法。

这个方法实际上就在构建我们这样的一个词典，我们可以看一下啊，首先第一步呢，我把这个我们这个数据啊给读取出来，这个数据也就是刚才给大家看的那个啊，嗯这个数据啊就闲聊是一。

然后如果是我们的那个保险类的问题的话，那分类就是零，我们把这个数据给读取出来，然后做这样的一个分词的一个处理，我们可以看下这个token ize这个方法啊，这里是用了这个结巴啊，来进行了这样的一个分词。

然后把结果返回那分完词之后呢，我们会对这个每一个词做这样的一个便利对吧，然后去统计它的一个词评，可以看一下啊，这是遍历每个句子，这是遍历每个句子当中的每一个词，要去统计它的词平，然后根据它的词瓶。

我们做了一个排序，做了一个排序，然后呢我这边会去啊创建这样的一个文件，再把这个文件的这个pad和这个UNKA，先写进去，写进去之后呢，我们会去便利这个排序，排好序的这个啊词典啊词典。

然后呢我们会把这个词典的这个值啊啊，也就是它的一个value，也是它的次数去做一个判断，如果这个如果这个次数呢是大于了，我们这边的这个这个数，我们就会把这个词典啊，就把这个词写到我们词典当中。

所以说这里其实是有个参数嘛，其实和昨天我们去讲那个word vector，那个参数是一样的对吧，对于词频比较低的一些词，我们就不把它加到词典里啊，不加到词典里，我这里写的是一个五五，大家也可以换一个啊。

你换个二换个三都是OK的好啊，这样的话我们就等于是把每一个词，按照他的一个词评，就写到了我们的这个词典当中，最终呢我们就拿到了这样的一个文件啊，这样的一个文件，这就是我们的一个词典的一个构建好吧。

词典的一个构建，这些都是一些逻辑代码啊，很简单很简单啊，然后呢我们再看一下这一段啊，这一段实际上就是去判断了一下啊，如果这个文件存在的话，我们就会把这个词典给读取出来对吧，读取出来。

这个词典实际上就是这样的一个键值对嘛，他的一个key对应的这样的一个value，它的value呢其实就是它一个词典的一个下标对吧，下标好，这就是我们的一个词典的一个构建啊，词典的一个构建，词典的构建。

OK那我们这边词典构建讲了。

模型构建也讲了，而接下来我们就来看一下训练代码啊，训练代码，啊我们这边，嗯这里我应该是分的好，我们先不看这个啊，这个词典是433，好，那我们这边这个词典大小要改一下啊，这里要进行重新改一下。

我们也可以把这个代码给跑一下，我们这里可以稍微设小一点，设个三吧，我们把这个词典重新构建一下啊，OK我们这个词典重新构建好了，然后一共是有600多个词是吧，600多个词嗯，我们可以看一下啊。

一共是638，然后我们这边可以改一下这个参数啊，638，然后我们把模型重新导入一下啊，我们的模型是在TXN2对吧，TXN啊应该没问题吧，OKOK行，那接下来的话，我们我们先把这个代码给跑一下啊。

看一下能不能跑起来，好稍等一下啊，这边模型已经在跑了啊，我们这边一共是跑了十个e pk啊，十个e Poke哦，可以看一下啊，我们跑了十个一破壳之后，他这个测试集的准确率已经到99了对吧。

99加了效果已经非常好了非常好了，我们可以看看下前面啊啊，在我们第一个EPOKE的时候，他已经70级的准确率，然后慢慢就开始收敛对吧，最终十啊，第十个epoch啊，这是第九个，我们从零开始的。

那所以这就是第十个epoch是吧，第十个EPOKE它已经0。99了啊，准确率很高了，准确率很高了，好我们接下来就详细来看一下这个训练代码啊，训练代码啊，我们从某种方法开始看，他这里调用了这个tr方法啊。

这个处方法数方法，第一步呢，就是去实例化我们这样的一个模型对吧，那这个TXN的话，就是我们刚才定义的这个TXN对吧，定义的text n，而我们实例化这样的一个嗯对象啊。

然后传入我们刚才啊需要的那两那两个参数，一个是我们词典的这个大小，还有个是embedding size对吧，你也可以传递一下这个序列的最大长度啊，我们序列的最大长度默认是十好吧。

我们这边在做数据处理的时候，我们这个序列的序列的最大长度，我们设置的也是十，OK啊，我们这边再加一下这个参数啊，叫做MAXINE，是十好，OK接下来呢我们这边有一个TRILO，这个TRALOADER。

也就是我们训练集的一个loader。

那这个是我们刚才说的这个，生成器啊，生成器我刚才有说我们数据都是一个batch，一个batch进行一个训练对吧，所以呢我们数据都会以一个背驰，一个背驰的数据把它给取出来。

那取的时候该怎么取呢，就涉及到了我们刚才这里提到的这个，通过data set和data loadad啊，我们可以详细看一下这个load date，这一块怎么做的啊，首先呢我们也是一样啊。

先把这个classification这个文件的数据给读取出来，它有两列啊，一列是sentence，一列是label，好读取出来之后啊，我们做了这样的一个切分啊，做了这样一个切分，这个切分之后呢。

就是把它切分出了训练集和验证集好吧，训练集和验证集，大家也可以用塞西论带自带的那个方法，也可以进行切分，都是OK的啊，然后呢我们这边会去执行这个heading sequence，这个方法啊。

我们看一下这个方法，这个方法是在做什么呢，实际上是在去统一我们的一个长度啊，然后我们设置的最大长度是十，我们可以看一下啊，这个里面是在干什么啊，额，首先呢我们这边是有一个这样的一个循环对吧。

for x in x大的大写的X啊，也就是说我们这边进行输入之后，我们会对你的输入进行一个循环，这个输入的话肯定是啊一个背驰，一个背驰的一个数据嘛对吧，就是你有很多数据，你可能这里有100条数据对吧。

那100条数据，我要对，每每一条数据都去进行一次这样的一个循环，然后循环出来之后呢，我这边会做一个判断，如果你的这个长度是小于最大长度的好，那我们就会去做一个拼接，你看我这边是拼接的一个零对吧。

把这个max ln减掉当前的长度，假设你当前的长度是六，然后我们这个最大长度是十十，减二六的话就是四对吧，也就等于我再给你拼了四个零上去，那为什么拼的是零呢，因为我们的pad way是零对吧。

那如果我们的pad位在这个位置是一呢，那这里就要改成一了好吧，这里要改成一了好，这样的话左边就是拼接，那如果啊这个LNX它是大于这个max论的，然后那就是执行这一块嘛对吧，就等于是取零到最大长度啊。

这边就等于是在做截取，这边是在做我们的补偿好吧，这就是截取和补偿好，这是统一长度啊。

统一长度也就是PPT当中的这一部分啊，统一长度。

好我们再回到我们的训练代码这一块啊，好这是我们的这个输入的X啊，接下来呢我们会把我们的这个X，还有我们的YY的话，就是我们的label嘛对吧，也就是我们这里对应的是个零和一啊，零和一。

额这里对应的我们的X和Y好，会给到我们这个tensor data set啊，这个tensor data set呢需要传递两个这个啊，TENSL进去啊，Tensl，那TENSL怎么定义呢。

我们就可以直接调用这个touch到from non pie，就可以把这个npre ray就是number派的数组啊，转换成这样的一个tensor tens探索。

那只需要给到我们这个TENSLDATASET，我们就可以能拿到啊，把我们的训练数据，就包装成了这样的一个TENSLDATASET，然后呢我们再去实例化这样的一个data loader，这样的一个对象。

这个data loader呢首先呢需要传入一个DATASET，对data set一个对象，也就是我们这个东西啊，这个东西，然后呢可以去定义一下它的这个BESIZE是多小，还有你可以去把这个顺序给打乱。

OK接下来呢我们就可以拿到这样的一个data loader，那这个data loader我们就可以去便利，这个data load loader，每次去便利的时候呢。

就可以取出batch size的一个数据，假如我们这个batch size设置的是32，当你去便利这个it loader的时候，每次就可以取出32条数据好吧。

这就是我们的这个tensl data set，结合我们这个data loader，来获取我们的训练数据的一个过程好吧，好这就是我们加载数据的一个过程啊，加载数据的一个过程。

OK那我们再回到这个主流程当中，这边的话就等于我们数据已经加载好了啊，加载好了啊，这是我们的一个验证机验证机，而这边的话是如果你需要使用GPU的话，你需要把这个模型啊放到我们的这个GPU上。

要把我们的数据啊也换到我们的CPU上，OK接下来的话，我们来定义一下我们的这个优化器啊，这里我们使用的是ADAM这个优化器，ADAM这个优化器，然后学习率给了一个0。01啊，0。01。

然后这个这个参数的意思，就是说这个哪些参数需要更新，因为是我们整个模型的参数都需要更新对吧，那我们就把所有这个模型的所有参数，传递给这个优化器就OK了啊，然后呢这边呢我们去定义这样的一个啊。

二分类的一个交叉熵损失函数啊，Final across entrop，Ok，接下来的话，我们就可以来进行我们的这样的一个训练了啊，训练的过程我们是这么做的啊，我们这边有十个epoch，十个epoch。

然后接下来呢在每个epoch当中呢，我们都会去进行这样的一个去迭代，我们这里这个trade loader对吧，也就是我们这里拿到的train data loader，但他有说我们每次进行迭代的时候。

都可以取出一个bech size的一个数据，对吧好，这样的话我们就可以把这个数据取出来，取出来之后呢，给到我们的模型这里，这个X实际上啊就是我们的这个下标，这个文本转换成词之后的一个下标。

我们这个数据从哪里来，从这个data loader来，这个data load loader是看这里读取出来的嘛对吧，这里读取出来的好一，好接下来呢我们就把这个东西给到我们的模型。

当我们去执行这个方法的时候呢，他就会去调用我们的模型的这个for word方法，也就是前向传播这个方法，他就会去执行这一串代码，这样的话我们就可以拿到我们的一个输出值，也就是说我们就可以拿到这里。

这个SIGMOID之后的这样的一个值，我们再把这个值啊，这个输出值和我们的真实外真实标签，我们的真实的外标去计算我们的loss function。

就根据我们这个binary across entropy，去计算我们的这个loss啊，OK那这个loss计算出来之后呢，我们需要把我们的优优化器啊，优化器显的梯度先至零。

然后呢我们去执行一下loss点back word方法，这个方法就等于是在去做反向传播，好反向传播做完之后呢，我们再去调用我们的这个优化器的step方法，就可以去更新我们权重，更新我们的权重好吧。

这边反向传播是拿到梯度，这边呢就是更新每一个参数的一个选中了啊，就把每一个参数进行一个更新，根据我们的梯度进行一个更新好吧，然后最后这边呢我们是每隔了20步，我们会去做一个这样的一个验证啊。

其实啊我们可以可以放到外面去写也OK啊，就是你可以跑完一个e Poke，你再去做一次验证也是可以的啊，好我们再看一下验证验证的过程是怎么做的啊，也是一样的啊，我们去执行了一下这个模型。

把验验证集的一个数据给到模型，然后得到输出值，输出值的话，我们这边去判断一下啊，他如果是啊大于0。5对吧，那我们就认为它是一个正理啊，然后最终得到我们的一个预测值，然后去计算我们的准确率啊。

计算我们的准确率，这东西应该这些代码应该大家都很熟悉了，就和机器学习里面那一套是一模一样的嘛对吧，然后这边的话我做了一个很简单的一个判断啊，我会保留一个最优的一个准确率啊。

只有当前我训练出来的这个准确率，大于于我们的最优的准确率的时候，我就会把模型进行一个保存好，整个流程就是这个样子好吧，那最后我们再来看一下啊，我们的一个输出结果，你看保存模型有准确率，0。994对吧。

我们也会把模型给保存下来啊，保存下来，这就是我们的这个训练过程，训练过程，好我们这边稍微停一下啊，对于训练过程，各位同学有没有什么疑问呢，等到时候各位同学也可以自己下来去跑，完全没问题好吧。

然后大家跑代码的时候，如果发现没有这个词典这个文件，你可以先去执行一下这个data process这个脚本好吧，执行一下这个beautiful cap这个方法，把词典先给构建出来，你词典构建出来之后呢。

你再去执行我们的这个处理方法啊，好对于训练这一块，各位同学有没有什么问题，有问题吗，各位同学，好那我们继续啊继续，那这边处理完之后训练训练好了对吧，那接下来就是一个预测的过程啊，预测的过程。

那我们来看一下这边的这个预测的一个代码啊，预测的一个代码，预测的一个代码怎么做呢，其实也很简单啊，首先呢我们调用一下我们这个touch load方法啊，把这个模型给加载出，加载到内存当中。

然后呢我们一定要执行一下这个嗯，AF这个方法啊，这样的话我们能够drip out才会置零，一定要执行一下这个方法啊，不然你每次这输出结果可能会不一样啊，这个方法要执行一下。

OK这样的话我们模型就加到内存当中了，然后我们看一下这里这个预测是怎么做的，首先呢这是我们输入的一个句子对吧，输入的一个句子，输入这个句子呢。

我们首先会执行一下这个sequence to index这个方法，这个方法是在干嘛，就是先去做分词，分完词之后，我们会去把这个每一个词转换成一个下标对吧，完成这样的一个下标好，要转换成啊。

根据这个下标呢，我们再去执行执行这个heading sequence这个方法，做这样的一个补偿的一个操作对吧，其实这里额取一个最大长度就OK了啊，好OK我们继续啊，那补偿完之后呢。

把它转换成这个tensor对吧，然后给到我们的模型，给到我们模型，也就是执行我们的模型的一个前向传播啊，前向传播执行完前向传播之后呢，把我们的结果进行一个输出就OK了啊，就OK了，然后真实的情况的话。

我们只需要做一个判断嘛，看大于0。5还是小于0。5对吧，我们可以执行一下啊，我们这边随便找一句话，啊第一次可能会有点慢啊，他就输出这样的一个概率值对吧，0。34还是说他是一个物理啊。

物理也就是对应我们的，因为小于0。5嘛，那小于00。5，他输出的就是零对吧，我们也可以随便看一个看一个闲聊的一句子啊，闲聊的句子它是大于0。5的，那最终输出结果就是一个一对吧。

一好这就是我们的一个啊预测阶段啊，这边我们也可以打断点进来，看一下每一个他的一个结果是什么样子啊，好我们随便输入一句话啊，好啊，输入进来的话我们可以看到啊，这里实际上是一是一是一句话嘛对吧。

然后呢我们先执行了这个sequence dex，这个方法，就等于是把这句话啊做了一个分词之后呢，转换成了这样的一个下标对吧，763471好吧，分成了四个词，然后转换成了一个下标，好。

这边是把它转换成了这样的一个啊，先做了这样一个补偿的一个操作对吧，做了一个补偿的操作，然后转换成了这个tens啊，转换成了通索，然后给到了我们的模型，然后模型最好把这个结果进行一个输出。

我们也可以把断点打到这个for word方法里面，进来看一下啊，我们走好，这边是我们的一个下标对吧，下标先拿到我们的一个embedding，好，我们那个embedding。

这是我们那个embedding，Embedding，是一个啊1×10乘以100的这样的一个维度，所以我们这里先把第一个维度给去，把那个维度给扩展一下嘛对吧。

把那个sequence sequence练那个维度，就BASIZE和sequence，量之间的那个维度给扩展出来对吧，扩展出来之后呢，我们这边的维度就变成了一个一一十的，100对吧。

好这边就进行了一些卷积的操作啊，我们就啊就不一看了，我们直接跳到这里来是吧，好，我们这边每一个的话就是一个啊，1×2乘以一的这样的一个维度对吧，让我们进行一个拼接，拼接完之后把最后一个维度给去除。

那我们就是一个1×6的这样的一个维度对吧，好16这样的一个维度要进行DP part，要经过全连接层，然后经过SIGMOID，最终的话我们就拿到一个这样的一个哇，他这个值是一哈，这是一好。

这就是我们的输出值啊，输出值输出值最后一句话就到这个地方啊，就进行了一个输出，然后把结果返回我们这边进行了一个打印，对吧好，就是这样的一个流程啊，那预测这一块OK了的话呢，那接下来的话。

我们就可以进行这样的一个集成啊，进行这样的一个集成啊，我们可以看一下啊，这是我们昨天写的一个代码嘛对吧，那我们这边就可以做这样的一个判断啊，用户输入了一个问题啊，这边输入了一个问题啊，意图识别。

意图识别啊，意图识别，那我们先把这个predict是好，我们导入一下啊，我们从我们的这个text classification呃，点predict，我看下这方法叫啥啊。

叫做classification predict，对吧好，那我们把这个方法导入之后呢，我们就可以在这里啊调用一下这个方法，调用一下这个方法，然后先把用户输入的这个text传递进来对吧。

这样的话我们就会拿到一个输出值，out一个值啊，因为我们这个最容易输出值是一个list，那我们取第一个值好，接下来我们做一个判断啊，如果这个值它是大于0。5的，大于0。5，那是什么情况，大于0。5。

那就是闲聊嘛对吧，我们就可以啊说出一句话啊，闲聊这是闲聊，这是闲聊，然后否则我们再走下面的对吧，我们再走下面，OK因为我们现在闲聊还没有讲到，如何去做这种生成式的闲聊啊，所以我们这里先简单输出一下。

这是闲聊好吧，让我们把代码执行一下啊，然后我们这边随便随便输一句话啊，稍等一下啊，这边需要去加载一些模型，所以启动的时候会稍微有一点点慢，我们稍微等一下，好我们输入一下。

然后第一次执行的时候也会有一点麻啊，这是一条闲聊对吧，这是一条闲聊，然后我们去再找一条这样的一个，专业领域的问题啊，专业领域的问题，Ok，他又走到了我们的这个专业领域的，这个类别当中，对吧啊。

我们再随便输一，你好啊，他又说这是限量对吧，然后再输入一条专业领域的问题，他又进行了专业领域的一个回答对吧，好这就是我们的这个意图识别这一块啊，意图识别这一块，额可以看到啊。

其实整个流程把它加进去是非常简单的对吧，就两行两三行代码就OK了啊OK了，所以今天的重点的话，更多是在我们的模型构建这一块好吧，模型构建，还有我们的这个模型训练这一块啊，模型训练这一块。

然后各位同学也就是要下来得多花点时间，去把模型训练和这个构建这一块弄清楚好吧，毕竟主流程这一块是很简单的啊。

很简单的好，我们再回过头来啊，回过头来额，最后我们再看一下作业啊，作业作业的话就是大家自己去实践一下，这个tag c n，然后并集成到我们的这个项目当中，然后进阶作业的话就是刚才说的啊。

去微调一下我们的这个BT啊，这个如果各位同学有基础的话，就去做一下，如果对bird这一块也没有什么了解的话，就先暂时不做，之后我们也会给大家花点时间讲一下，好吧好啊，接下来的话我们就来进入下一个部分啊。

这个transformer，Transformer，transformer这个内容今天应该是嗯讲不完啊，讲不完，然后会给大家讲一小部分。

讲一小部分啊，这个模型的结构是非常重要的啊，非常重要的，接下来在我们去做这个这个叫啥啊，闲聊生成的时候啊，我们也会涉及到这个transformer的一部分的，一些内容啊，所以这边会啊做一些补充。

做一些补充好，我们简单看一下transformer这个模型啊，transformer这个模型呢，它其实和我们之前提到的这个sequence，sequence模型结构是一样的啊。

它包括了encoder和我们的这个decoder啊，encoder和decoder，而左边这个部分呢就是我们的这个encoder，右边这个部分呢就是我们的这个decoder啊。

我们这边着重来看我们的encoder，encoder部分，它其实主要有两个部分嘛，一个是啊，咱们这里有一个叫做mari head attention，哎，有同学就会发现哎这里是一个attention啊。

那是不是和刚才讲的attention差不多呢，确实啊，确实他这个也是一个加权求和的一个过程啊，那这个attention结束之后呢，它这里会有一个残差模块，然后给你做了一个这样的一个类啊。

layer normalization啊，Layer normalization，OK那做完这些之后呢，会给到下一层，这里有个fit for word，大家可以简单的理解为。

它就是简单的两层的这个全连接层啊，全连接层，那做完之后呢，又做了这样的一个残差模块和一个layer，Normalization，残差模块，各位同学不知道有没有了解过啊，他其实是ARESNET当中。

一个比较经典的一个结构啊，就是如果你的网络结构太深的话，容易出现一些所谓的一些啊，模型效果会出现退化的情况，就是关键点就在于它的这个梯度啊，没有办法很好的传递，所以呢就已提出了这样的一个残差模块。

就来让这个梯度啊传播的就是更顺畅一些啊，更顺畅一些，然后我们今天的重点会放在这一块啊，就是这个multi head attention好吧，Monty hall tension。

然后decoder这块我们也简单说一下啊，其实没什么区别嘛，也是有一个mari head tention对吧，然后这边FEEDFORWARD只说下面这一块。

多了一个叫做musket moni head tention，这个什么东西呢，我们之后再说啊，之后再说，我们先来看我们的encoder部分，啊我们直接直接来看这一块啊。

叫做mari head attention，这个mari head attention是什么意思呢，它其实这个money had attention全名啊。

其实应该叫做mari head self a tention，我们先不看这个mari head，我们先看这个内部的tension，他是怎么做的啊，那常用的attention呢有两种啊。

一种叫做additive attention，一种叫做dot product attention啊，两者的效果都差不多，那这个dota product tension就很简单了，他是怎么个简单法呢。

就是说假如我现在有有A和B对吧，A和B如果我想知道他彼此的一个权重，我可以怎么做呢，我可以就让A和B进行这样的一个相乘，那为什么相乘就可以拿到这样的一个，所谓的一个彼此的这样的一个权重。

我们可以考虑一下啊，我们昨天在去计算这个余弦相似度的时候，我们是怎么算的，是不是A乘以B除以A的模，B的模，那除以A的模和B的膜有什么作用呢，规划那如果不除这个东西呢，是不是就是A乘以B对吧。

所以说A乘以B，实际上就可以拿到彼此之间的这样的一个，所谓的一个权重啊，权重，那对于这个cf和attention，它是什么意思呢，意思就是说我的这个A和这个B啊，它是相等的，就假如我现在有一条文本对吧。

text有一条这样的文本，我想知道这条文本当中哪些词是比较重要的，那他就会去做一个所谓的一个self attention，让自身和自身进行一个相乘，自身和自身进行一个相乘。

也就是在这个self attention当中呢，它引入了两个参数啊，一个叫做Q，一个叫做K，那这个Q和K它其实啊就是原来的这个text，他把这个Q和K只是用两个不同的符号来表示，这个text啊。

然后呢让这个Q和K进行相乘，就拿到了所谓的一个权重，然后除以了这样的一个因子，这个因子是什么，我们待会再说啊，然后再求这个soft max，soft max的目的啊。

是在于把这个权重缩放到这个零一之间嘛对吧，然后最后再和这个V相乘，这个V是什么，V其实也等于text，所以QKV它其实是相等的啊，就是因为相等，所以它叫做self attention。

那前面这一块呢实际上啊就是在求我们的权重，在求我们的权重，求出权重来之后呢，我们把权重和原来的值进行相乘，实际上就是在一个加权的一个结果对吧，这就是一个cf tension啊。

cf attention好，我们这边把它展开看一下啊，展开看一下，就假如我们现在有一条文本啊，叫X1X2X3X4好，这是我们的一个句子啊，我们这个句子我们简单画一下啊，X1X2X3X4好。

这边也是X1X2X3X4好，这是我们的，这是我们的一个Q，这是我们的一个K好，我们Q和K进行一个相乘对吧，这里进行一个这样的一个相乘的一个操作，那这里实际上就是X1乘以X1。

这里是X1X2X1X3X1X4，这里是X2X1，好我就不全部写了，好吧，我就不全部写了，最后这里就是X4乘以X4，好我们再来看一下彼此相乘表示什么，表示的就是X1这个词和X1X2X3X4。

它的一个相关性，或者说它的一个权重，甚至你可以理解为咱们所谓的这个余弦相似度，没有做过优化，之前的一个结果，对于第一行结果来说，对于第一这是咱们的第一行对吧，对于第一行结果来说。

是X1这个词和其他所有的词的一个权重嘛，对吧，那对于第二行是不是X2，这个词和其他所有词的一个权重，而第三行是X3和其他所有词的一个权重对吧，没有问题吧，那最终呢我们就会得到这样的一个matrix。

这样的一个矩阵对吧，这个举重这个举证啊，这个举证就是我们的一个权重啊，我们用阿尔法来表示啊，这是我们的一个权重，就是我们的权重，这个权重表示，就是每一个词和其他词之间的一个，你可以理解为相似度。

一个重要程度都是OK的，都是OK的，好吧好，这就是一个权重的一个举证，那这个矩阵呢我们通常会去做这样的一个soft max，那做完soft max之后就等于做了一个归一化嘛。

例如啊我们X1和X1它是强相关的嘛对吧，他毕竟是完全一模一样的一个词，那可能可能权重会比较大一些，那X1和X2，X3X它都会有这样的一个权重对吧，那我们会把这一行去做soft max。

就等于做了一个归一化，最后可能这里就是一个0。4，这里是0。1，0。2，这里是0。3对吧，那我们加起来是等于一的等于一的啊，好，最终的话就等于做了这样的一个，规划的一个处理啊，做了一个规划的处理。

那为什么要除以这里这样一个根号DK呢，如果不除这个根号DK，这里这个Q和K相乘，如果变得特别大的时候，这个soft max就会容易出现一些善意的一个情况，就是你计算这个soft max的时候。

没有办法计算出来，其次啊，soft max可能会引起一些梯度消失的一个情况，所以我们通常会除以这个根号DK，这个DK表示的是什么呢，表示的是你这个Q或者说这个K，它的一个维度啊，维度啊。

我这里再说一下啊，这里的这个X1是一个向量好吧，是一个vector，是一个vector，它可能是100位的，是768位的，或者是什么样的一个维度啊，这里的X1和X1相乘。

实际上就是这个向量和这里这个向量，进行一个相乘好吧，好那这样的话我们就拿到了这样的一个矩阵，也就是说我们前面这个部分，啊我们前面这个部分啊，就是我们的这个阿尔法对吧，就是我们的阿尔法好。

有了这个阿尔法之后呢，我们在和我们的这个V进行一个相乘，再和我们的V进行相乘，那和V进行相乘是什么呢，是不是等于是把权重和每一个词的一个，embedding进行一个相乘，最后就变成了一个加权的一个过程。

这就是我们的这个CATTENTION，下巴特上啊，我们这边可以再简单看一下维度啊，因为我们Q是等于K的，也等于V的嘛对吧，那QKV它的维度是什么呢，首先第一个维度是batch size。

第二个维度是序列长度对吧，这第啊三个维度的话就是embedding size，我们用一来表示它是这样的一个维度嘛对吧，那我们的Q和K进行相乘的时候，Q和KQ和K进行相乘。

它的维度是不是就变成了besides，然后序列长度的序列长度，然后呢我们再和这个这个值，我们再和咱们的这个V进行相乘对吧，你取soft max除以根号DK维度是不会变的对吧，最后再和我们的V进行相乘。

乘完之后呢，维度实际上又变回了咱们的big size，序列长度，embedding size啊，这就是我们最终的一个结果啊，啊这个是我们加权之后的一个结果啊，这就是咱们的一个sl attention。

好吧，Sf for tension，好看这一块，这个cf tention，各位同学啊，我有说明白吗，各位同学，只要按照我这个思路啊去理解这个self attention，那你这个公式是不可能记错的好吧。

我其实有时候面试的时候就会去问一下，这个self attention这个公式，如果你连这个公式都记不住的话，说明你完全没有理解这个attention这个思路啊。

好这就是我们的一个self attention，好吧，看各位同学对于这里有没有什么问题，有问题吗，各位同学，那像我刚才提到的那里，我们在做这个文本分类的时候。

这里不是有这样的一个word attention吗，或者说这里这个sentence attention，这里sentention sentence attention。

这里有个word attention对吧，大家都可以把它换成这个self of attention来做啊，都是完全没问题的，完全没问题的好吧，没问题的，好self attention讲完之后呢。

我们再回到我们这个mari had tension啊，mari head attention的意思就是说，哎我这个做一次腾讯特征得到的有点少嘛对吧，那我们为什么不像卷积神经网络那样。

我们多搞几个kernel对吧，它卷积神经网络可以搞多个kernel，那我们MARI的腾讯，我们也可以搞多个多个这样的一个腾讯嘛对吧，所以呢我们每次啊就可以把这个Q和KQKQ，KV啊，啊。

这里这个QKV和，去添加一个这样的一个权重矩阵，权重矩阵啊，权重矩阵，让这个QKV和这个权重矩阵进行一个相乘，相乘完之后呢，我们就可以多得到多个这样不同的一个QKA，Q k v，从而达到多个头的目的啊。

这就是我们的这个money，I had a tension，好吧好，这是我们MARI的tension，最后我们来看一下它整个流程啊，整个流程啊，这是我们的这里有一个有个句子啊。

叫做thinking machine啊，他这是我们的一个一开始的一个embedding对吧，embedding好，这个embedding呢，会和我们这样的一个权重矩阵，进行一个相乘对吧。

权重矩阵进行相乘相乘之后呢，就可以拿到我们的这个这样改变之后的，这样的一个QKV对吧，我们再把Q和K进行相乘，除以根号DK取soft max，在和我们的V进行相乘，就得到了加权之后的一个结果啊。

加权之后的一个结果，这就是加权之后的一个结果，啊这是啊一个头的一个情况啊，我们说我们再来看一下多个头的一个情况，多个投的情况，实际上就等于，我们最终会有多个这样的一个结果嘛，对吧。

我们一个头拿到一个结果，那多个头的话就会有多个结果之后，我们再把每一个头的一个结果啊，把它拼接在一起，拼接在一起，再和这边这样的一个矩阵进行一个相乘，这个矩阵进行相乘的目的是在于什么呢。

是在做一个维度上面的一个变换啊，把维度又变回了我们原来的这样的一个维度，好吧，这就是我们整个mari head，self attention的一个计算过程啊，计算过程好。

这是整个合在一起的这样的一个流程图，我这边就不再重复说了，好吧好行，那基本上啊，我们要给大家讲的这个encoder部分的，这个mod head的self attention就给大家讲到这里好吧。

这里这个MONTI的腾讯就给大家讲到这里，然后transformer其他部分的一些内容的话，我们在之后的一个课程内容再补充给大家，好吧好，最后的话看各位同学还有没有什么问题啊，代码是在哪里下载，代码之。

昨天昨天那节课不是有翻到那个PPT里面吗，啊这边有啊，这边有啊，已经放到这个GITHUB上面，这位同学去GITHUB上面去拉一下这个代码就好了，好吧，啊我告诉你怎么用啊啊如果没有用过GITHUB的同学。

我简单说一下啊，有两种方法，第一种方法你可以点一下这里这code，然后点一下这个download data，你也可以去把这个get命令给复制一下，然后在你本地的这个命令行去执行一下，get到LCK。

好吧啊，各位同学就直接去点这个download，把这个代码放下载下来就好了好吧，点击这个啊，点击这个就可以把代码下载下来了，啊我这边我这边下一下吧，下一下，我待会把他发到群里。

我先待会把那个代码发到群里好吧，好其他看了各位同学还有什么问题吗，没有什么问题，那咱们今天的课程基本上就到这边了，好吧，然后接下来的话就是一周的时间啊，一周的时间，希望各位同学啊，下来把这个代码这一块。

就还是要自己去写一下的好吧，因为各位同学，今后如果要去从事NLP方面的一些工作，那我们这个项目就是一定要去做的啊。

一定要去做的，因为我们这个项目其实涉及到NLP方面，很多的东西，包括分类模型，然后检索，然后匹配模型，然后生成模型对吧，虽然这个项目看起来好像结构挺简单，但是实际上涉及到的东西会很多啊，很多好。

那咱们今天的课程就到这边，然后大家有什么问题的话，再在群里面找我就OK了，然后待会我会把那个代码发到QQ群里，好吧好，那咱们今天的这个课程就到这边好，各位同学也早点休息。

1447-七月在线-机器学习集训营15期 - P13：07-NLP-3-智能问答机器人中的闲聊 - 程序员技术手札 - BV1ASste6EuZ

开始今天的内容好。

我们还是一样啊，先来看一下，今天要给大家讲的一个内容是什么啊，今天的话主要有三个部分啊，三个部分啊，第一个部分的话是我们的这个文本相似度，的一个计算模型啊，计算模型也就是说这一个部分呢。

我们是要对这个检索那一块啊做一个补充，做一个补充啊，之前的话我们只是简单的用这个word vector，去算一下它的余弦相似度对吧，那我们算出来余弦相似度之后呢，我们就会选这个相似度最大的这个答案。

返回出来，那这个时候呢，其实有时候就会出现一些不准确的一些情况，对吧，那这个时候我们要进一步啊，进一步我们先使用word vector召回一部分答案，再使用一个文本相似度的一个模型啊。

来判断我们最终的答案是什么，好这是我们今天要给大家讲的第一部分啊，文本相似度计算的一个模型啊，第二部分的话，我们要给上节课的这个transformer啊，再做一系列的一个这样的一个补充，补充完之后呢。

我们这边会给大家简单介绍一下啊，基于这个BT这个模型的一个，embedding的一个生成啊，就我们之前更多是使用的是这个word vector对吧，但是word vector这个其实是啊。

很多年前的这样的一个技术了，那目前比较火热的这个预训练模型，讲bird这样的一个模型，如何来生成这样的一个embedding呢，这就是我们第三部分要给大家讲的一个内容啊。

好那我们就先来看我们的第一部分啊。

关于这个文本相似度计算的这个模型啊，我们可以先回顾一下之前的一个内容啊。

我们简单回顾一下。

哎我们的结构图呢啊这个地方啊好，那我们之前的话给大家讲了，这个意图识别这一块对吧，然后也在第一次课当中也讲了，这个检索式模型啊，检索式模型，那举个例子啊，假如我们现在用户来了一个问题。

那我们库当中假设有1万个问题，那1万个问题，这个时候呢，用户的问题会和这1万个问题，进行一个相速度的计算，找到这个像素最高的，然后把答案返回出来对吧，那现在呢我们要换一种思路啊。

比如说当用户的问题来了之后，我们会先和这1万个问题进行一个召回，一部分之前的话，我们是直接把最相似的给进行返回对吧，那这一次呢我们可能会返回top k好，OK那可能是十个对吧，也可能是20个。

我们就把这个基于word vector，最先是四的top k个，把它给返回，返回回来之后呢，我们这边会使用这样的一个，文本相似度的一个模型，再用这个模型来算一下，用户的这个问题和这top k个问题。

哪一个是最相似的，那前面找到top k的这个过程就叫做召回召回，那我们把用户的这个问题，和我们召回的这个问题再进行一个模型的使用，模型来进行相似的计算，这个过程呢我们称为金牌。

也就是说我们先要把这个范围给缩小，再使用模型来进行这样更细的一个运算，那可能有同学会问，为什么我不一开始就使用这个模型来进行，这个相似度的一个计算呢，也是可以的，但是各位同学可以考虑一下啊。

如果我们一开始就使用模型来计算，这个比较精细的相似度，那这里我需要让这个模型计算1万次，那这个是其实是比较耗时的对吧，比较耗时的，所以呢我们就先采用之前的这样word vector，一个方式。

把这个范围给缩小，有1万个问题啊，变成top k个问题可能是十个，可能是20个，再把这十个问题或者20个问题，给到我们的相似度模型，这样的话其实只需要计算十次或者20次，就能拿到我们最终的一个结果了啊。

这就是我们的这个相似度模型的一个意思啊，好那有了这样的一个概念之后呢，我们再回过头来啊，我们回过头来啊，我们继续回到今天的这个PPT，那这边的话我们会给大家先看几个啊，相似度模型啊。

啊我们先简单说一下啊，那相似度模型是在干什么呢，那文本相似度模型啊，主要是用来判断两个句子，它是否是同义句，那它的结构呢一般都是这样的一个孪生网络啊，什么是孪生网络呢，什么是网孪生网络呢。

它其实是这样子啊，就是我这边有一个mode1，然后这边有一个mod2，那这里这两个模型它其实是相等的啊，是相等的，这个权重也是共享的，说白了它就是一个模型，只是说我每次这边输入的是第一条文本text1。

这边呢我输入的是这个text2，然后啊，M1这边呢会输出它对应的这样的一个vector，这个t text1这个这样的一个vector对吧，那对于L2这边呢。

它其实也会输出一个针对于text2的这样的一个，Vector v2，然后呢我们再把这里这个V1，而这里这个VR进行一系列的这样的一些，相关的一些运算，再把这个的一个输出结果啊，给到我们这样的一个分类层。

一个分类层，最后来输出一个0~1之间的一个值，所以呢其实这里啊，我们通常都是这样的一个二分类的一个层，或者是一个SIG格MOID的层，最终把这个值输出出来，这就是我们的一个孪生网络啊，孪生网络。

它这个孪生的意思就是说我有两个部分，但是这两个部分呢它是一模一样的啊，那我们在构建模型的时候，实际上啊只需要构建一部分啊，也就是说我只需要构建一个，只需要做构建一个，构建完之后呢。

我把这两条文本分别给到这个模型，我要给两次，给两次啊，给两次，这样分别就能得到我们的V1和V2，好吧，这就是我们的一个暖生网络的一个结构啊，那孪生网络结构的内部，它的这个内部又是什么样子呢。

我们可以看一下啊，这个是我很久之前写的这样的一篇博客啊，一篇博客呃，大家可以，啊大家可以自己来这边看一下啊，我这边其实介绍了很多这样的一个，文本相似度的一个模型，我看啊，2461共有七个这样的一个。

文本相似度的一个模型啊，包括它的一个输入其实也是有区别的，你看有输入这个字向量的，有输入这个词向量的对吧，又分这个静态词向量和动态词向量的，其实这些东西我在这个上上次课的时候，也给大家讲过。

什么是动态词向量，什么是静态词向量对吧，还有最后这个模型它不但有静态的，还有这个动态的，甚至还有一个额外的这样的一个经验，特征对吧，这也是上次课给大家讲过的，是否有相同的一个词啊，相同的词。

而这边呢我使用这些模型啊，使用这些模型在这个啊有一个数据集上啊，这个在这个cure covers上面，进行了一个这样的一个测试啊，这边也是有这样的一个结果的，有这样的一个结果的。

那我们今天呢主要会拎出其中的一个模型啊，ESIM这个模型来给大家进行一个，详细的一个介绍啊，那其他模型我这边呢都会有对应的一个解析，还有这个论文的一个地址，大家假如对于这个AABCN比较感兴趣对吧。

那你可以去看一下我这边写的这个啊，博客其实都基本上讲的很清楚了啊，讲的很清楚了，那你也可以点进去去看一下他的这个原论文，好吧，原论文，然后我们这边课堂当中呢，我们会详细给大家介绍一下。

这个ESIM这个模型啊，ESIM这个模型，那为什么要给大家介绍这个模型呢，首先呢这个模型相比于其他几个模型来说，它会稍下面这几个模型啊，它会稍微简单一点点啊，其次呢这个模型因为会涉及到咱们的这个。

L s t f，然后之前的内容当中呢，我们给大家讲的是这个CN对吧，并没有涉及到这个LSTM，所以呢这次课的话我们就基于这个模型啊，顺便给大家去看一下，我使用这个PYTORCH去如何编写这样的一个啊。

LSTM的一个模型啊，其次啊对于ESIM这个模型来说，它其实整体结构呢它不会很复杂啊，不会很复杂，效果也还不错，那如果像对于啊这边的这个，像BIMPM这样的一个模型，它其实结构是还是挺复杂的啊。

各位同学写起来的时候也会比较费劲，并且这个模型它收敛的话会稍微有一点慢啊，所以呢，我们更多会去使用一些比较简洁的一些模型，并且效果还不错的一些模型给到大家，其次对于BIMPM这样的一个模型。

因为它本身结构简单，所以呢更适合在线上使用啊，所以大家对于工业场景来说，你也可以直接去上这样的一个模型好吧，完全没问题啊，完全没问题，要考虑到有些同学可能啊也没有GPU对吧，然后就一直用的笔记本。

那你用自己的笔记本，用CPU的话也是可以跑这样的一个模型的好吧，这就是我们这样的一个啊，ESIM这个模型的这样的一个优势啊，优势，好那我们再回到PPT当中，那接下来的话我们就来详细看一下。

这个ESIM这个模型，它的一个结构是什么样子啊，啊那今天的内容还是和之前的内容是一样啊，我们先来讲原理，讲完原理之后呢，我们再带着大家来写代码好吧，好啊，我们就先来看我们的这个ESIM这个模型啊。

那ECM这个模型的话，它本身的一个结构比较简单，速度也挺快的，我们来详细看一下这个图啊，那ESIM的话它其实分为两个部分啊，可以看到左边这个部分和右边这个部分，那左边这个部分呢它是基于这个啊。

B i l i s t m，也就是这样的一个双向的LISTM，那右边这个呢，它基于的是这样的一个TRISTM，也就是说它是一个树结构的一个LSTM，那我们先简单给大家说一下这个TRLSTM啊。

那这个TRLSTM是什么意思呢，就是说首先啊如果我们要使用这个TRASTM，我们需要对我们的句子去做这个句号分析，依存句法分析，然后得到这样的一个啊依存数啊，得到这样的一个预存数。

例如我现在有个句子叫做猴子喜欢吃香蕉，那我需要需要去做这样的一个句法分析，然后把它生成出这样的一颗啊依存树啊，预存数，然后我再以这样的一个，其实这个时候他已经成为了这样的一个，竖的一个结构对吧。

然后呢我再把这样的一个数据结构啊，给到我们的这个TRLST，那这个TRLSTM，其实啊它你本质上它是一个STM，只有他的一个输入的一个形式啊，我们要以这样的一个数结构来进行一个输入。

但其实这种情况其实就很麻烦对吧，首先呢你需要保证，你这个聚宝分析是没有什么误差的，如果有误差的话，就假如你这个构建你的这个依存数的时候，你有一些错误，那最终其实对你的结果会造成一定的一个影响，对吧。

所以呢我们在自己我们这边写代码的时候，我们更多还是以这个啊双向LSTM为主好吧，双向的LSTM为主，那这个LSTM它的它是什么样的一个模型呢，它其实也是RN的一种变体啊，只是说他对RN进行了一些优化。

那RN这个模型又是什么样子呢，它其实是一个创新的一个结构啊，进行这样的一个输入，而这里可能是我们的第一个X1好，这是我们的X2，然后一直这样的一个创新的一个输入啊，到我们的这个XN。

那它每个节点呢其实都会有这样的一个啊，输出值啊，我们用O吧，用O来表示O1来表示表示output，同时呢它这边也会有一个这样的一个hidden state啊，要给到下一个节点。

那下一个节点呢它会有两个输入，首先是咱们的X1个输入，还有上一个节点的hidden seit，这最后进行一个输出，这就是我们的一个RN的一个结构啊，那这里拿到的就是HN减一对吧，在这里输出的就是ON好。

这是我们的一个RN的一个结构，但是对于RN的这个模型来说，它最大的问题在于什么地方呢，它容易出现一些就当你的序列比较长的时候啊，啊那咱们这个序列X这个序列比较长的时候呢。

它就容易出现一些梯度消失的一些情况，那出现梯度消失的话就会出现一个问题啊，那首先是咱们模型更新不充分嘛，那你就会导致当你的序列过长的时候，你前面这些信息其实在对于后面的节点来说，它是补充不到的啊。

也就是说这种长距离依赖的效果是比较差的，好这是RN，那LSTM呢，就在RN的基础上去添加了一些，所谓的一些门的一些机制，来，尽可能来缓解这个所谓的一个梯度消失的，一个问题啊。

大家可以简单的把这个STM就看成这样的一，个RN的一个结构好吧，然后LSTM里面，具体的一个结构是什么样子呢，那就各位同学自己花点时间下来看一下好吧，如果我们这边再来详细讲LISTM的结构呢。

我们这边可能课程内容就有点讲不完了好吧，那各位同学呢就自己下来就花点时间，把这个AISTM的一个内部结构，自己看一下好吧，那这个BRISTM又是什么呢，它其实啊也就是在我们这个RN的一个基础上。

那我们RN是单向的吧对吧，那如果是一个双向的，他是什么样子呢，其实就是他有一个这样的一个，反向的一个结果啊，就正常我们是从左往右对吧，如果是双向的话，它还添加了一个从右往左的一个，这样的一个情况啊。

最终的话我们的一个输出值，其实就有两个部分对吧，一个前向的一个反向的那一个前项和一个反向，我们最终拿到结果的时候，就需要把这个前项的结果和这个反向的结果啊，要给拼接在一起。

其次啊我们可以从这个图当中可以看到啊，他这里这个结构其实是两层的对吧，它是两层的，那这个两层的结构我们又该怎么处理呢，就假如这个是第一层，我往下面画啊，我往下面画，那第二层的话。

它其实就是说这里咱们会有一个alt值对吧，接下来呢我们这边还会有一层，还会有一层，也就是说我们把这里这个O作为了这个节点，第二层的一个节点的一个输入值啊，输入值本来我们之前输入的是X1对吧。

那现在只是说从咱们的这个X1，变成了咱们的这个OE，然后再进行一个输出，就这个意思啊，就这样的一个意思好，这样的话我们就构建出了一个所谓的一个哦，这里也是一样啊，都是双向的双向的。

这样的话我们就构建出了一个所谓的一个，双向的YASTM好吧，双向的双向的两层的这样的一个LISTM，咱们就构建好了啊，构建好了，好，这就是我们的这个啊，双线的ASTM和我们的这个TRAE，ISTM好。

我们更多还是以这个啊双向的AICM来好吧好，那我们继续往下啊，啊往下的话我们就分别来看一下它的这四个词，这四层好吧，这四层我们先简单这里看一下啊，它第一层是这个input encoding层。

然后第二层的话是这个local influence modeling层，第三层的话是influence composition层，最后的话是一个预测层啊，这就是他们的一个分类层。

好我们还是先看我们的第一层input encoding层，啊啊这个就很简单了对吧，输入的话首先呢我们还是这样的一个下标，然后经过我们的这个embedding embedding层。

然后就给到我们的这个啊input in co顶层，那input in co顶层的话，就是刚才说的这个双向的LSTM，双向的两层的LSTM好，这是我们的这个input encoding层啊。

input encoding层啊，然后我们继续看下面啊，下面这个是我们的这个啊local influence modern层啊，那这一层是在干什么的呢，它其实啊是在对我们的两个句子哦。

我们假设那现在输入了两个句子，一个是咱们的一个P，一个是咱们的一个Q，因为我们是一个孪生网络嘛对吧，我们是孪生网络，对于这边的话我们可以拿到一个这样的一个P，那对于这边的话。

我们也我们可以拿到这样的一个Q啊，这是我们的暖生网络对吧，所以我们这边是假设拿到的是P和Q好，那对于这个local influence modeling，这一层是在做什么呢。

它其实啊他会做这样的一个attention的一个处理，attention的一个处理，大家可以就把这一层啊，理解为他做了一个attention的处理，得到了这样的一个权重，那得到这个权重之后呢。

就可以对咱们的P和Q去进行这样的一个，加权的一个处理对吧，加权之后呢，我们就可以得到我们新的这个P1撇，和咱们的一个Q1撇啊，这个TENTION的时候，我们在上一节课的时候。

给大家简单介绍过这个self tention对吧，Cf tention，咱们这个CR和TENTION，那这个cf tention的话，其实啊和这里这个TENTION是比较类似的，比较类似的啊。

这个我们待会说啊，那既然我们对这个P和Q做了腾讯之后，拿到了我们的P撇和QQ撇对吧，这个时候我们实际上就会有四个值，一个P1个Q有个P1撇，还有个Q撇，接下来呢我们会对这四个值啊，做一系列的一些处理。

第一个处理就是我会用P来减掉pp，第二个处理是用P乘以P撇，那第三个是Q减掉PQ撇，最后一个是Q乘以Q撇，以这样的一个形式啊，我们就会得到一些这样的一些交互值，大家就可以把这个部分啊。

看成这个所谓的一个交互值，好吧，这样的一个交互值，最后呢我们再把这个斜PQ还有P撇，Q撇和这些所谓的一些交互值啊，再把它拼接在一起，拼接在一起，这样的话我们就成了这样的一个。

我们最终需要达到的这样的一个结果，好这就是我们的这个local influence mode0层啊，而接下来的话，我们简单看一下这一层的这个attention啊，这边的话我们可以把这里。

这里这个所谓的一个AB，看成我们刚才的这个啊这个P和Q好吧，P和Q我们看成P和Q，OK那他的思路和我们上次课讲的那个cf attention，是很类似的啊，计算我们的权重的时候呢。

他是直接把这个P和Q进行了相乘，也就是这里这个A和B啊，他直接进行一个相乘，A和B直接进行相乘，还记得是什么意思吗，上节课给大家讲C或TENTION的时候，给大家讲过对吧。

它实际上就是得到这样的一个所谓的，一个权重的一个矩阵，那这个矩阵呢，它可以理解为就是A和B它的一个相关性，或者说它的一个相似程度对吧，或者说它的一个依赖程度，所以这样的话我们就可以得到AB之间的。

这样的一个权重矩阵，但是我们要做SALA，做这个所谓的TENTION之前，肯定是要对他去取这个soft max的对吧，来取这个soft max，那取soft max的时候呢。

啊我们就是以这样的一个形式啊，来取我们的一个soft max，但是这里大家需要去注意一下啊，如果我们要得到A的这样的一个值，那我们就需要去对B进行一个加权对吧，那这个时候我们选下标的时候。

就需要注意一下啊，这边可以看一下啊，这里下标是取的是J的一个下标，这边这个下标取的是I的一个下标，这个下标千万不要弄错了好吧，分别这边就对应的是B和，这边对应的是IA，那我们对B进行一个加权之后。

才能得到A的一个结果，对A进行一个加权之后呢，才能得到B的一个结果，这里大家需要注意一下好吧，这个下标不要弄错了啊，不要弄错了好，这就是我们这个attention的一个过程啊，啊腾审的一个过程。

其实只要理解了上节课讲的这个self a tension，那这里的这个TENTION理解起来应该是啊，很简单的啊，很简单的好，这是我们的这个local influence modeling这一层啊。

那呃下一层的话就很简单了啊，influence concomposition层，那这一层的话，就是把我们刚才的那一层的一个输出值，再给到我们这样的一个双向的，双层的这样的一个LISTM好吧。

所以说还是一个LSTM嘛，还是一个LSTM，最终我们就拿拿到我们的这样的一个输出值啊，输出值好，这是我们的influence conversation层，很简单啊，和刚才的我们的那个第一层是很类似的啊。

我们这边就不再说了，最后我们来看我们的最后这一层啊，那这一个预测层呢会把上一层的一个输出值，作为一个所谓的一个ping操作，那一个ping操作是什么意思呢，ping操作，其实啊就是你可以简单理解为。

它就是在去取它的均值或者是最大值最大值，那为什么我们要做这样的一个ping操作呢，我们各位同学可以考虑一下啊，其实对于最后一个分类层来说，我们实际上输入给我们最终的这个，分类层的时候。

理论上来说应该是一维的对吧，那那是对于我们的LSTM来说，因为它有很多这样的一个节点嘛对吧，他这个时候可能会有很多个这样的一个输出值，有O1有O2，有O3，它有很多这样的一个输出值。

那这个时候我们到底应该用哪一个尺来作为，我们最终的一个句子的一个最终的向量呢对吧，那通常的话我们可能会使用这样的，average的方法取平均，那这个取平均的方法的话，就叫做这个平均池化层啊。

那如果你取最大值的话，那就叫做最大池化层，就这样的一个意思啊，好那这里的话就等于说我们要取这个最大值，然后取这个均值之后，最后把这个结构啊，然后再把它给拼接起来。

送入我们的这个全连接层和我们的这个soft max啊，这就是我们的这个predict层，predict层好吧，非常简单啊非常简单啊，这个是我们整个ESIM这个模型啊，ESIM这个模型，Ok。

那我们接下来就带着大家一起来，把这一块的这个代码给过一下。

好吧，啊，不知道各位同学对于上节课的代码，有没有什么问题啊，大家如果对之前的代码如果有什么问题的话，也可以及时提出来好吧，然后我们也可以给大家啊，简单的讲一下，咱们的这个上节课的一个代码的一个情况啊。

大家有问题就及时提出来好吧，好，那接下来的话，我们就带着大家来把这个ESIM，这个代码给复现一下啊，复现一下啊，我们这边把先把这个代码给删了，还是一样啊，我们先把我们的这个touch给导入进来啊。

啊然后我们可以把那个，把NN也导入一下，OK还记得我们构建这个PYTORCH的模型的时候，第一步是怎么做呢，是实现这样的一个类对吧，然后这个类呢需要继承于NN导锚点是吧，嗯那么就这个类好。

那接下来呢我们来学我们的这个构造方法啊，构造方法构造方法还记得是在做什么呢，是不是去初始化一些必要的一些参数，还有初始化一些我们需要用到的这样的一些层，对吧好。

我们就简单回顾一下PPT我们有哪些层了啊，这个我先关了，好我们一层一层来看，首先是我们的input encoding层啊，那对于这一层来说。

我们首先会有一个embedding对吧，那我们就先来构建我们的embedding层啊，呃先构建1BEI层，好，而embedding层第一个参数还记得是什么吗，我们的一个词典大小对吧。

这个东西我们上一节课的时候也给大家说过啊，说过，那既然要词典大小的话，我们这边就可以定义一下啊，我们的这个词典大小啊，VOCABUL好，那第二个参数的话是我们的这个啊，embedding的一个维度对吧。

我们又叫做embedding size，嗯嗯bein size好，我们给一下我们的这个词典的一个长度，还有我们的这个binding size，Ok，这样的话我们就构建好了。

我们的这个embedding层啊，embedding层好，我们接下来看一下这个input encoding层的话，它是一个双向的双层的LICM对吧。

好啊，我们构建这个，双层双向的LSTM，我来看一下啊，Input encoding，这个叫做input encoding层，OK那我们还是一样啊，我们就来叫做我们的input in input点SK。

这个也很简单啊，还有一个我们要构建STM层，怎么构建呢，直接执行这个NN导LSTM就OK了啊，好我们来看一下对于这个ASTM来说，它有什么样的一些参数啊，我们可以嗯。

我看上面这里啊，好他有一个这样的一个呃input size，Input size，这个input size，就是说我们的一个输入值的这样的一个维度啊，输入值的一个维度。

然后第二个参数是这个hidden size，这个hidden size什么意思呢，就是当刚才给大家这里介绍的这个咱们每一层，咱们每一个这样的一个ISTM，结果这个节点他都会输出这个这样的一个。

hidden state对吧，那这个hidden state它维度是什么样子呢。

就是这里的这个een size来决定的，好吧啊，然后这个呢是我们的一个层数啊，就是说啊你需要去构建哦，占dog dog层啊，保存，好这里是他的一个vs，就是说你是否需需需要添加这样的一个啊WIS。

然后这里它还自带了这样的一个drop pod啊，Drap，然后最后这里有一个这样的一个啊，Be reactional，就如果我们把这个参数设置为true，那它就是一个双向的AISTM。

否则的话它就是一个单向的，那对于我们这里来说，我们肯定是需要一个双向的对吧，那我们就需要把我们的这个video action这个参数啊，设置为true。

然后最后的话我们再给大家说一下这个bitch first，这个参数啊，那如果我们把这个参数设置为false和true，那它的一个输入值和输出值的维度就是一个，第一个维度就是BESIZE。

第二个维度是序列长度，第三个维度的话，就是我们的一个特征的一个维度，但是啊这个参数它默认是false，所以说如果如果大家想保持，我们比较常规的这样的一个维度啊，那我们就要把这个参数设置为false。

如啊这个true如果在大家默认使用的false的话，那他的这个维度是序列长度是摆在这个维度的，BESIZE是摆在第二个维度的，好吧，这里大家需要注意一下啊，注意一下，那我们为了方便一些的话。

我们就把这个参数就改为这样的一个true，好吧好，那我们来写一下啊，首先是我们的input size啊，Input size，Input size，因为我们要从我们的这个embedding层。

去拿到我们这样的一个值对吧，所以呢我们这边就是embedding size，没问题吧，好然后是我们的这个hidden size，hidden size啊，hidden size的话，我们这边可以啊。

也它其实也是这样的一个参数对吧，参数那我们可以在边把它定义成一个超参数啊，啊我们就叫做uh input pen size a等于三思好，啊，也就是我们的这个第一个LSTM的一个，Eden size。

OK那这个我们再来看一下我们的这个number layers。

这个时候我们应该是要去再看一眼啊，number of recurrent layers等于二的话，Which means taking two ls s tm together to form a stated。

L s t m，那默认的话它是一对吧，那对于我们这个来说其实是一个两层的啊，两层的哎，不对不对不对，呃，我这里好像弄错了哦，我们这里实际上是一层的啊，一层的啊，这里我要解释一下，我刚才可能弄错了啊。

我把这里看成两层了，实际上它实际上他这里是一层的，只是说这里是P1，这里是输入的是H对吧，也就是我们的这个孪生网络啊，孪生网络啊，这个是我的失误，我的失误啊，这里并不是两层，并不是两层。

这里就一层好吧，这里就一层啊，既然一层的话，那我们这边就是一就OK了对吧，一就OK了，好那这边这个参数的话是是否是一个双向的，然后我们把这个参数设置为true。

然后最后一个是咱们的一个batch first对吧，我们把这个参数设置为true，OK这样的话我们就啊，拿到了我们这样的一个输出值啊，拿到了我们的一个输出值，好我们这边可以简单看一下啊。

首先我们的输入值它的一个维度是什么样子，第一个维度是BESIZE，第二个维度是序列长度对吧，然后第三个维度的话，就是我们这里这个embedding size，那经过我们的这个ISTM之后呢。

我们的维度变成了什么样子呢，首先第一个维度还是我们的BESIZE，第二个维度还是我们的序列长度对吧，但是第三个维度这里大家需要注意一下啊，就变成了我们的这里这个T这里的这个hidden size。

但是但是因为我们是这样的一个嗯双向的对吧，双向的那双向的话，它默认会在最后面进行这样的一个拼接，最后这里是维度就会乘以二啊，乘以二，待会我们来详细看一下这里这个维度变化好。

这就是我们的这个input encoding层。

input encoding层，那input encoding层做完之后呢，好我们再来看一下还有什么啊，接下来是这个local influence modern1层，那这一层的话看一下啊。

好像没有涉及到什么参数对吧，只是来计算这样的一个权重矩阵，那这一层的话是不需要用到任何的这些，初始化的层的啊，然后最后就是我们的第三层，这个influence composition层，那这一层的话。

其实也是我们的这个ISTM对吧。

好我们来构建我们这一层嗯，叫做influence com，什么来着，Conversation，CONSTATION层好，这一层也是我们的双向的LISTM啊啊，我们叫做influence a s t m。

还是一样啊，首先是我们的这个啊input size，input size好，那这里这个input size是多少呢，各位同学觉得这里这个input size应该是多少，来直播间的小伙伴嗯。

大家觉得这里这个input size是多少，有同学知道吗，好我们可以回过来看一下PPT啊。

在我们的这个input encoding层之后呢，我们会到这个local influence modering这一层，这一层的话，我们去做了一系列的这样的一个，attention的一个处理。

然后最终我们得到了P1P撇对吧，还有这个Q和Q撇，然后呢，我们会对这个P和Q进行一系列的一些，这样的一些处理对吧，比如用P减掉P撇，P乘以P撇，然后最后再把这个加工之后的值和原来的值啊。

进行这样的一个拼接，所以最终拼接在一起的值，它实际上是有八部分的对吧，它实际上是有八部分的对的，我们最终的一个输入值，实际上就是在每一个这样的一个维度上，再乘以八，那每一个这样的一个值，它的维度是多少。

是不是这一层的这个LSTM的pen size对吧。

Pen size，所以这里啊也就是咱们的这个啊input hidden size，再乘以我们的八好吧，乘以八好，这里比较重要啊，这里比较重要，嗯这里简单注释一下啊，啊因为我们有P与Q并且，得到了。

经过一系列的，啊八个值啊，所以我们这里要乘以八啊，然后是我们的这个hidden size啊，Hidden size，那hidden size的话啊，我们也可以从外面传递一下啊。

哦我们这叫做influence hidden size，好下一个的话是我们的啊，还是我们的number雷影，我们还是一层一层就OK了啊，然后是双向的，把birth face first改成true，好。

这样的话我们的这个influence conversation层呢，就构建好了啊，构建好了好，那接下来我们再来考虑一下啊，那除了这个啊，我们的这个这一层之化。

我们还有些什么东西呢，看一下啊，下一层的话就是我们的这个池化层。

和我们的这个soft max和一些全连接层了。

对吧好，那我们这边可以来定义一，个这样的一个池化层啊，我们叫做predict层。

predict层，这边是self点next to，啊我们还是用二维的啊，还是用二维的，那对于这一层来说的话，我们可以考虑一下啊，那这个池化层，我们的一个他的一个kernel的一个大小是什么呢。

那实不实际上啊，就是我们的一个序列长度嘛对吧，那我们这边可以考虑，把这个序列长度也传递进来啊，max word n好，我们可以进来看一下它的这个，还有一个参数是我们的一个kernel size对吧。

kernel size好，我们实际上就是要给这个quernel size，进行复制啊，好那我们给这个corona fes估值，也就是我们的MAXINE，那第二个维度的话就是一就OK了啊。

啊这是我们的这个最大池化层啊，最大池化层好，接下来的话，我们来定义一下我们的这个全连接层啊，全连接层啊，dc1呃，叫NN导LINUX层，LINUX层，那这一层的话。

我们又得考虑一下他的这个输入的这个size了，我们这个输入的EXSIZE是什么呢，实际上还是我们的这个input hidden size对吧，然后乘以咱们的一个八。

然后第二个的话我们可以给他一个输出维度，输出维度的话，那我们就给他一个，呃和这个保持一致吧，influence1等size啊，这是我们的这个啊，第一层的这样的一个LINUX层对吧，LINU层好。

然后我们是第二层，我们在我们可以考虑再加一层啊，再加一层，然后这边的话，第一个维度的话肯定就是这个嘛对吧，那第二个维度的话我们就给一啊，给一最后还是老样子啊，我们加个dropout层，嗯给个0。

2的一个这样的一个，drop的一个值好，这样的话我们基本上就哦准备好了啊，准备好了，这就是我们需要准备的一些内容啊，那接下来我们就来写我们这个for word方法啊，for word方法。

for word方法还是一样啊，首先呢我们要把我们的输入值给进来，但这个时候其实和上节课的内容还不太一样啊，这里的话因为我们是孪生网络对吧，孪生网络，所以呢我们这边会有两个这样的一个输入值。

一个是我们的一个P，一个是我们的一个Q，一个是P，一个是Q，好吧，好那我们先来看我们的第一层，肯定是embedding层，那啊我们用用这样吧，吸引该领，好，把这个皮写前面好一些。

好我们用我们的embedding层，把我们的这个P给进去，然后是我们的q embedding，把我们的Q给进来，OK这样的话就得到了我们的这个P的embedding，和Q的embedding。

各位同学可以看一下啊，我们这里虽然是这样的一个，孪生网络的一个结构，但实际上我们调用的层是一样的对吧，我们这里只定义了一层一层啊，并没有说它是孪生网络，我们要去定义两层。

所以这就达到了一个所谓的一个权重共享的，一个目的啊，好接下来的话我们就经过我们的这个啊，LSTMLSTM啊，这个叫做叫啥来着，input AI s t m啊，好input l s t。

然后把我们的这个啊p embedding给进去啊，给进去，这样就会拿到我们的啊，这样的一个输出值输出值，但我们可以这里来看一下啊，他这个输出值它是什么样子啊。

好他这里有个输出值啊，他这个输出值它其实是什么样子呢，它其实有一个所谓的一个啊output，还有一个HN和一个CN，那这里这个output，就指的是我们这里占的一个输出值，这里这个输出值。

那这里HN表示的是一个hidden state，因为它会有一些中间值嘛对吧，hidden state也就是这里有个值。

它还有一个CNCN表示的是sales state，大家可以简单的理解为，这个sales state和这个hidden state是类似的一个东西，好吧，更多细节的话。

大家下来自己去看一下LSTM内部的结构，看完之后你就知道这个cl state是什么东西了好吧，那我们更多的话是使用这个所谓的一个输出值，对吧，输出值，所以我们这边就给他一个输出值就OK了。

然后第二个我们再看一下啊，我们再看一下这边这个它有两个返回值对吧，两个返回值，我们只要前面的后面这个我们是不需要的啊，那么后面这个就用一个下划线来表示就OK了啊，好就以这样的一个形式。

我们就能拿到我们的这个经过input a s t m的，这样的一个输出值好吧，好接下来的话我们再来给我们的第二个啊，Q embedding，好，这样的话就拿到了我们的Q的这样的一个值啊，这样的一个值。

然后我们这边可以做一个drop out一个处理啊，但实际上我们可以在这个里面对吧，它自带了一个，我们看一下啊，刚才有看到他这里有一个自带的啊，如果设置为呢introduce a drop out哦。

如果设置为非零，它就会有一个这样的一个drop out on the output of，Each h l s t m layer，除了最后一层对吧。

With drop up for our or two，默认是零，就是说如果你把这个drop out，设置为非零的一个数值啊，它就会在它的一个输出层去做这个所谓的一个，Drop out。

那但是啊它是除了这样的一个最后一层了，那我们可以使用这个参数，然后我们这边因为这边我们有自己去定义，这样的一个dropout层对吧，那我们也可以，也可以用我们自定义的这样的一个转炮的好吧。

我们就用我们自己自己定义的啊，我们用我们自己定义的额，这个圆就是以P对P做了一个这样的抓part，让我们再对Q来做这样的一个状ORT好吧好，这样的话我们就能得到我们的这个P和Q好吧，P和Q好。

接下来的话，我们来做我们的这个attention的。

这样的一个处理啊，也就是我们的下一层咱们的这个，local influence modeling这一层啊，主要关键就在于咱们的这个attention，这里的一个计算对吧好。

那我们就直接来算我们的这个一，我们来算一下我们这里这个一啊，一，那一的话，其实就是来做这样的一个矩阵乘法对吧，那左边的话就是我们的p in白点啊，右边的话啊，我们要对我们的这个q embedding。

去作为一个这样的一个转制的一个处理啊，那这里的话我们可以用有一个这样的一个，transpose方法，我们把我们的q in bin传递进来，然后我们是要对我们的第一个维度，和第二个维度进行一个交换对吧。

那qq embedding它的一个维度是什么样子，是这个样子吗，那我们要对它的这个维度和这个维度，进行一个交换对吧，我们base size这个维度是保持不变的啊，所以我们是把第一个维度和第二个维度。

进行这样的一个交换，这样的话，我们就可以进行一个矩阵的一个乘法了。

好最终就拿到了我们的这这里这个权重啊，这个一这个权重有了这个权重之后呢。

我们再把这个权重和我们的这个分别，和我们的这个啊，P和Q进行一些加权的一些计算，对吧好，那我们接下来就把这个啊咱们的所谓。

咱们这边的这个所谓的一个。

加权之后有一个结果去拿到一下啊，我们首先去求我们的P，我们用cat吧啊还是一样啊，这边肯定是做这样的一个矩阵的一个乘法啊，好那相乘的时候呢，我们可以考虑一下，我们是不是，首先第一步。

我们要去要去做这个所谓的一个soft max对吧，soft max好，这是一，那对于我们的P来说，我们应该考虑的是他的一个第二个维度对吧好，然后这边的话我们和我们的一个P的话。

是要和Q进行一个相乘嘛对吧，P和Q进行一个相乘，OK然后是我们的这个QQ啊，Q也是一样啊，我们，这边也是取soft max，但是围度的话就是一这个维度，然后适合P进行一个相乘。

这样的话我们就分别拿到了我们加权之后的P，和我们加权之后的这样的一个Q好吧，嗯然后我们这边可以简单的把这个我一对，待会再说吧，待会再说，Ok，那接下来的话，我们就可以。

根据我们刚才PPT里面的一个内容啊。

我们这边会去做这样的一些呃处理之后。

再把它拼接起来对吧好，那我们就做这样的一个处理啊，我们叫做cat吧，嗯touch到cat好，我们首先会把我们的这个p in bedding拼接起来，然后p hat对吧，P hat。

然后是我们的相减的一个处理，相减的一个处理，还有咱们的一个相乘的一个处理对吧，相乘的一个处理，然后我们这边呢，是需要把最后一个维度拼接起来啊，我们根据最后一个维度进行拼接就OK了，好这样的话我们就。

得到了我们拼接之后的一个值，然后呢，我们再把这个Q的一个拼接值也是一样啊，我们进行这样的一个拼接，那就是QUEMBEDDINGKHEAD，然后q embedding减掉QHD。

然后q embedding乘以q head对吧，啊，这样的话我们就P和Q的一个拼接值就OK了啊。

OK了，最后我们再来看一下啊，我们下一层，下一层是我们的influence conversation层对吧，influence conversation啊。

也是一样啊，我们来调用一下我们的这个influence influence，I s t m，然后把我们的这个P给进去啊，p cat去给进去给进去，这样的话我们就能得到我们的这个，PD的一个输出值对吧。

呃Q也是一样啊，我们这边就是q HQ cat，好，这样我们就分别得到了我们的，我们的这个P和Q啊，P和Q呃，P和Q我们这里可以做一个DP out啊，我们可以在这里做个DP out哦，我们等会再做吧。

我们可以先把它处理完之后再做好，那接下来的话我们来取一下我们的这个均值啊，我们来取一下我们的应该说下一层了。

这一层已经结束了对吧，那下一层就是我们的predict，有池化层和我们的这个平均池化层，和我们的最大池化层对吧。

好我们来做我们的石化石化操作，那首先我们就拿到我们的提命吧，那我们就直接取个均值就OK了，直接取个均值，然后我们再，第一个维度也就是序列长度，这个维度我们去取个均值，那对于Q来说也是一样的啊。

我们要取这样的一个均值，然后这是我们的平均池化层，然后我们再来看我们的最大尺化层，最大值的话，那我们就直接调用我们的max po，这个最大触化层啊，然后把我们的P给进来。

还是在这个序列长度这个维度来做对吧，然后是我们的gill max，还是一样啊，调用我们的最大池化层Q维度，是我们的序列长度，这个维度啊，大家一定要注意一下啊，虽然我们是孪生网络。

但是我们所有的这个模型只定义了一层，一遍对吧，并不是说你要定义两遍，只定义了一遍啊，只定义了一遍，不管是石化层LISTM对吧，都是定义了一遍啊，都是定义了一遍，这个大家千万不要弄错了，千万不要弄错了好。

那有了这些值之后呢，我们再把这些值去做这个所谓的一个拼接啊，我们把我们的啊pmp Max-Q max好，我们先把T的拼进来吧，拼命，然后q Max-Q me，好，这样的话我们就拿到了。

我们最终的这样的一个值，我们用X来表示吧，我们再把这个值去做一个所谓的一个drop out，叫跑，好OK那到这里之后呢，我们就可以去做下面的这个，给到咱们的一个分类层啊，或者什么之类的啊。

甚至你可以也可以去引入一些所谓的一些，激活函数对吧，比如我可以在这里去加个ten h，这样的激活函数，加个ten h的一个聚合函数啊，哦我们先经过LINUX层吧，好吧，我们刚才有定义这个dance好。

我们先经过dance吧，这样点dance1，我们把我们的X给进来，然后得到我们的这样的一个值，再给到我们的这个激活函数这一层，然后再调用一下我们的dance2这个层，把它转换成一个维度的啊。

好最后我们可以执行一下我们的这个SIGMOID，Sigmoid，然后让他输出一个零一之间的一个值对吧，然后最后啊我们可以把X进行一个输出啊，输出呃，我看一下啊，这里应该是要降个降个位，好我们这样讲过。

把最后一个维度给去了啊，好整个我们的模型的一个构建啊，就OK了好吧OK了，好我们来训练一下我们的这个模型，哦哦对我这里都没有说啊，那对于这样的一个模型，我们的一个输入数据应该是什么样子呢。

我们那个输入数据其实这边也给大家准备好了，有这样的一份数据集啊，这个LCKMC这份数据集是干什么的呢，它其实就是用来判断两句话它是不是同一句，如果两句话它是同一句，那他这个标签就是一。

如果这两句话它不是同一句，那他这个标签啊就是零，我们可以看一下啊，这里有两句话它是同一句，那他标签就是一，这两句话哎不是同一句，它标签就是零，好吧，这是这样的一个数据集啊。

那我们给到我们的模型也是一样啊，我们把这份数据集给到我们的这个模型。

给到我们的模型，然后最终我们的标签就是这里的这个零和一，好吧，零和一这样的一个数据集很多啊，像我这边的这个博客里面，其实就是用的这个QACOPUS好吧。

但这个数据结合这份数据和这个AI is，这个LCTMC都是这个哈工大开源的啊，OK好那我们知道了数据集的一个结构之后呢，我们就来把这个代码给跑一下啊，TRA呃，我们可以看一下啊，Ec，BC啊。

这边参数可能名字要改一下啊，因为这个名字不太一样嗯，我看下叫啥啊，首先是词典大小，词典大小，然后是embedding size，Embedding size，Input，Hidden size，这个。

应该是这个吧，Input hidden size，然后是influence hidden size，hidden size好，OK我们把参数给改过来啊，要是词典大小这边的话。

我们可以看一下这个词典有多大啊，这个是做了一个这样的一个分字的一个处理啊。

因为我们这边嗯这篇我们去看一下这边啊，我们的ESIM它是论文当中是做的分字好吧。

那我们这边也就分字啊，我们这边也分字，我们这边也分字，然后我们可以看一下这个词典的一个大小啊，一共是3966对吧，3966，那我们这边就是3966，然后我们这个embedding size的话。

我们就取个100维的，然后hidden size的话用128，Influence，Hidden size，我们也用128，然后序列的最大长度我们设置为十好吧，设置为十。

也就是说这个句子的最大长度我们设置为十啊，设置为十，行，那接下来的话我们就先把这个代码给跑一下，看一下我们的模型有没有什么问题，好吧，看一下能不能一次成功啊，这个模型可以明显的发现。

是比咱们上次课讲的模型会稍微复杂一点点，对吧，嗯这边是有报错啊，我们看一下是哪里报的错，嗯没有这个DIEM这个参数吗，这个是我们的，看一下啊max po，应该是没有这个参数的啊，没有这个参数。

嗯我看啊我们这里应该是有哦，这里是二维的，我们已经指定了这个E了是吧，OK行呃，我们可以看一下这里这个维度是什么样子啊，打拉拉进来进来看一下啊，OK我们先看一下我们石化这个平均池化层。

这里应该是没有什么问题的对吧，这个应该是没有什么问题的，然后这里之后得到的是一个啊，500以上好，我想想啊，这里应该进行拼接的时候有没有问题呢，啊我们这边也是没有维度的，理论上来说。

我们应该给它加上一个维度才对，我们应该给它加上一个维度，我们先看下上面啊，这里直接是512，我们拿的是我们最终的一个输出值，好我们再看看上面啊，嗯看上面有没有什么问题啊，我们可以刚好吧。

我们就带着大家一起来看一下这个维度上面啊，有没有什么问题，好我们先看我们的这个这里啊这里啊，这里一共是512的十对吧，我们看一下我们的这边load date，我们这边设的是512，还挺大的啊。

RESI维赛多改成了512，我们这边可以稍微设小一点，改小一点吧对吧，28，which which size没有设置，没有必要设置这么大啊，稍微改小一点点，然后也方便各位同学跑起来啊，有些可能。

稍微改小一点点好，稍等一下，好那这边的话我们先看一下啊，那他的维度就是一个128的一个十，这里是没有问题的对吧，128的十，然后经过我们的这个embedding层之后。

我们这个embedding它是100维的对吧，那就是128的100对吧，啊一百二十八十的100对，因为我们每个他的每一个位置，它都有一个词嘛对吧，我们一开始输入的是128的十。

而经过embedding层之后，是128的十的100啊，没问题没问题好，那我们继续往下啊，经过了我们的这个LSTM层，LSTM我们的这个中间的这个可以看一下啊，这边这个是我们刚刚输的是也是128吧。

也就是说我们从十变成了128对吧啊，从100变成了128，好我们看一下，好哎，那这里为什么是256呢，不应该是128吗，双向的对吧，所以这里就是256好吧，这就是R6好。

这里经过咱们的一个drop out，这里经过drop out是不会变的啊，我们继续往下要到了这个位置啊，这个位置的话，我们首先呢会把我们的这个ky embedding，把这个256的换到十十。

这个维度和256进行一个交换对吧，最后就可以得到一个which size，然后序列长度的序列长度，也就是128的十的十，没问题啊，没问题好，那接下来我们再把这里进行这样的一个啊，加权的一个处理对吧。

看一下我们的P啊，P的话还是t heat就变回来了嘛，还是原来的一百二十八十的W56对吧，然后q hat应该也是一样啊，一样的，OK接下来的话我们进行进阶进阶啊，我们是根据最后一个维度进行拼接啊。

那它的序列长度是不会变的，最后就变成了128的十的1024对吧，1024，好那接下来的话我们就是influence这一层，那influence这一层，我们可以看到我们这里就是input。

hidden size乘以八对吧，也就是这里的128×8，也就是等，也就是我们咱们这里的这个1024是吧，这里的1024好，那就经过我们的这个influence层，好拿到我们的一个输出值。

我们再看一下这里有个输出值啊，就是一百二十八十的256，没问题吧，256为什么是256，因为这里也是双向的嘛，所以是256对吧好，大家有什么问题及时提出来好吧。

OK接下来的话我们是在序列长度这个维度上面，去做池化层对吧，那我们就等于序列长度那个维度就没了，就变成128的256啊，没问题，而这里做我们的一个石化处理，石化完之后呢，我们看一下啊。

一百二十八一到W不，哎那这里没有办法去进行这样的一个拼接，维度不一样对吧，那所以这里我们得把那个维度啊给去了，别去了，我们把第一个维度给去了啊，把第一个维度给去了，那下面这里也是一样的。

我们把第一个维度给去掉，我们继先继续往下面跑啊，这里肯定会报错啊，这就报错了嘛，因为它维度不一样对吧，那就说这里维度不一样啊，一个是二，一个是三好，那我们重新跑一下，好OK那我们到这里之后呢。

我们看一下啊，我们先让他走到这好，把它进行一个拼接，拼接完之后呢，就变成了一个128的1024啊，1024，把这四个值的拼接在一起了吗，没问题吧，没问题，好做个drop out。

然后这里就是第一个全连接层，然后得到了128的128，如果没记错的话对吧，第二个维度是128嘛，我们这边输出值是influence hidden size，也就是128对吧。

好在经过我们的ta h之后呢，经过dance第二层，经过sign moid来进进行输出，好没有没有问题啊，整个我们模型就跑起来了跑起来了，好这边已经在进行一个训练了啊，进行训练了，我们可以简单看一下。

啊这个模型的话肯定会比上节课，这个模型慢一些啊，慢一些，可以稍微等一下啊，然后大家就到时候就自己下来，就自己去跑一下这个代码好吧，我们需要到时候需要用到这个模型，需要用到这个模型啊，可以看到啊。

模型是正在收敛的，正在收敛的，啊这个整个代码就是咱们的这个ECM，这个模型了，那模型构建好之后呢，下一步的话就是把我们的这个模型给应用到，我们的这个主流程当中了对吧，好我们这边再跑一小会啊。

再跑一小会啊，这样吧，我们也刚好就稍微休息一会儿好吧，我们稍微休息一会儿，我们休息5分钟，现在11点是我们啊11。107108的样子，然后我们上课好吧，休息5分钟，刚好这边模型也要跑一会。

然后大家有什么问题的话，就把问题打在公屏上，我们统一解答啊，统一解答，好我们继续上课啊，继续上课，诶，哦没有往下拉，我还以为卡住了，那差不多最好的效果就是0。85左右了啊，0。85左右。

好我们这边先停啊，我先先停，呃大家也可以自己下来去，把这个模型给优化一下啊，包括这些超参数的一些调整对吧，你也可以把它换成这个词向量，理论上来说词向量应该效果也挺好的好吧，好那这个模型构建好了之后呢。

呃我们回顾一下啊，我们刚才说的是，我们先会对原始的数据做这样的一个召回，而再去做这样的一个金牌，那这里这个代码到底该怎么写，各位同学也可以考虑一下好吧，考虑一下，好，那我们这个文本匹配模型就给大家。

先讲到这里啊，讲到这里，然后接下来的话我们啊回到PPT啊。

回到PPT，然后我们接下来还有一些其他的内容。

今天要给大家讲啊，然后今天的话大家就下来，自己把这个文本匹配的模型给自己实现一下，好吧，然后其他内容，我们明天上午的课程再继续给大家讲，好啊，我们来进入到我们的第二部分啊。

关于transformer的这样的一个补充，那上周的时候，上周最后一节课，我们是给大家讲了一下transform的encoder部分。

对吧，encode部分当然除了encode部分的话，其他地方我们是没有讲的啊，没有讲到，所以今天要把这个transformer后面的一些部分，给大家补充一下，那为什么要去讲这个transformer呢。

那如果不讲transformer的话，那对于BT的一个内容，还有咱们最后一节课使用这个来生成，闲聊的时候，那它的一个网络结构啊，都是和这个传送门有关系的啊，所以这个东西需要给大家进行这样的一个补充。

好啊，那我们就先来详细的看一下，他关于这个encoder部分，它的一个内部结构的一个详细构造啊，那上次课的话，我们主要给大家说的是这一块嘛对吧，cf for tention这一块。

然后其他地方是没有说的啊，好那我们就接下来就来看一下啊，嗯好首先呢我们先说一下输入啊，输入除了咱们这个embedding，它其实还会有就这个这个所谓的一个position，Encoding。

就是一个所谓的一个位置编码，那为什么需要这样的一个位置编码呢，那对于我们普通的这个RN模型来说，它实际上是一个创新的一个结构对吧，它是一个创新的一个结构，那我是一个创新的结构。

那我是按顺序进行一个输入的，所以呢它就会有一个所谓的一个，自带位置属性的这样的一个情况对吧，自带了一个所谓的位置信息，那对于我们transformer这个模型来说。

它并不是这样按顺序进行一个一个的一个输入，所以说他在进行和腾审的时候，大家也可以看到吧，在进行和腾审的时候，假这是A这是B啊，这是这也是A，因为是self乘什么对吧，我们用Q来表示啊，用QKV来表示。

我们这Q和K进行矩阵去运算的时候，它实际上它所有的位置都是，这这个值是可以计算出来的对吧，所以它是一个并行的一个处理啊，并行的一个处理，那既然是个变性的处理，那我们就应该考虑一下。

我们是否应该把他的这个位置信息给加进去，毕竟每一个词它的一个位它在的位置不一样，那可能这个语语句的这个意思是不一样的对吧，所以呢我们就要把这个位置信息给考虑进去啊，这个位置信息它是怎么做的呢。

就是和和咱们这个embedding啊相加在一起，相加在一起，就能得得得到我们这样的一个给到encoder层的，这样的一个输入值啊，输入值好，那这个输入值呢再给到我们这个self attention。

The potension，这个上节课给大家讲过啊，给到sela tension之后呢，就拿到了我们加权之后的这样的一个值对吧，这两个啊，这里这个Z1和这里这个Z2。

就是咱们经过了self attention之后，加权之后的一个结果，OK那接下来呢他还会做所谓的一个layer，Normalization，和我们的这里这个所谓的相加的一个操作。

那这个相加的操作又被称为这个残差模块，残差模块，也就是说他首先经过这个残差的一个处理，然后呢再经过这个layer NO alization啊，好那经过完之后呢，再给到这个fade for word层。

这个fade for word层，大家就简单看成全连接层就OK了啊，那这层经过完之后呢，还会再经过这个所谓的参差，和这个layer normalization，Ok，接下来我们就详细看一下。

这里这个残差模块和这个layer normalization，是干什么的啊，好我们先来看我们的残差啊，就凭我们自己的一个直觉来说啊，如果一个网络层数比较深的网络，理论上来说。

应该会比较比这种层数比较浅的网络，效果会更好对吧，这是我们的一个理论上的一个感觉啊，但实际上呢，呃实际上就是当网络层数特别深的时候，它实际上会出现一个所谓的，一个退化的一个问题，一个退化问题啊。

我们可以看一下这边这个图啊，这个红色的这根线是一个56层的，这样的一个啊，基于CN的一个网络，有黄色这根线的话，黄绿色这根线的话是一个20层的啊，20层的可以看到啊，随着我这个啊迭代的一个过程啊。

那对于这个56层人来说，他的这个训练的这个训练集的这个错误率，它实际上是比这个黄色的这个要高一些的对吧，高一些的，包括右边这个图啊，这是测试局的一个错误率，也可以看到他这个56层的。

反而他这个错误率会更高一些，那这就是所谓的一个退化问题啊，那实际上，就当我们的这个网络变得特别深的时候，它靠后的这些网，这些，即使啊我们这个网络就等于变的，训练难度变大了，那训练难度变大之后。

有些层可能训练的就不够好，那特别是当我们网络层数比较深的时候，就很容易出现一些所谓梯度可能传递的不够好，或者说出现一些梯度消失，梯度爆炸的一些这样的一些情况，那只要你出现梯度消失的一个情况。

那你网络其实更新的时候，就会出现一定的这样的一个效果，不理想的一个情况吧，对吧好，那既然会有这样的一个情况发生，就有人提出了这样所谓的一个残差网络啊，残差网络，那这个残差网络呢。

就能一定程度去解决这个所谓的一个，退化问题啊，那这个残差到底是怎么做的呢，我们来看一下啊，残差其实就是让我们的训练变得更加简单，我们可以看一下这边这个图啊，呃首先呢我们这边有个输入值。

这个X这样的一个输入值，而会经过我们这边这样这样这个weight layer，这一层，然后又经过我们REU层，又经过这样的一个weight layer这一层，大家就可以简单的理解为。

它就经过了这样的一个网络层啊，我们用这个FX来表示好，那正常情况也就是说我们输入X，我们最好拿到我们的FX对吧，那这个时候其实如果我们这个网络很深的话，它最终这个值就会出现一些所谓，梯度消失的一些情况。

对吧，那我们这里会怎么做呢，也就是说我一方面啊我得到了这个FX，其次啊，我会把这里这个X的一个输入值直接给过来，直接给过来直接给过来，也就是说我这边的一个输出值，我不单单只要你这个经过FX的一个值。

我还需要你的原始值，也就是说我最终的一个输出值，一方面有经过网络的一个结构的一个值，还有一方面是保留了原来的一个值，那我在进行BP的过程当中，实际上啊，我们这个梯度就会变得更加顺滑流畅一些啊。

从而缓解这个所谓的一个梯度消失的一个问题，这就是我们所谓的一个残差模块啊，残差模块，那在我们的这个transformer当中也是一样嘛，理论上来说啊，他标准的一个transformer啊。

他的这个encoder部分是有六层，进行了这样的一个叠加，那对于我们的一个bird，这样的一个预训练语言模型，它有12层的这样的一个叠加啊，它是这个encoder内部是叠加了12层，那所以呢。

他这边就引入了这样的一些残差模块啊，你看我这里有一个这样的一个X对吧，我经过了这个self a tension之后呢，我会把这个啊Z1，这个Z1的话就可以看成刚才的这个FX对吧，FX然后呢。

我就会把这几个Z1，和我们一开始输入的这个X啊，进行这样的一个相加，进行一个相加，这里就是我们的一个残差模块啊，残差模块好，那经过了残差模块之后呢。

会去做这个所谓的一个layer normalization好，接下来我们就来看一下这个normalization啊，那layer normalization到底是个什么东西呢。

它其实属于normalization的一种啊，这个name normalization呢，它其实又有很多种，但normalization的目的啊，实际上就是把它转换成这个均值为零。

方差为一的这样的一个数据分布对吧，因为那为什么要把它转换，为什么会说，为什么要去做这样的一个归一化的一个处理呢，我们考虑一下啊，通常我们都会把这个其实这一层，我们的一个输出值去给到这样的一个激活函数。

去引入了一些这样的一个非线性的变换对吧，但是啊我们的这个激活函数我们举个例子啊，就拿我们的这个SIGNIMOY的激活函数来看，它实际上当我们这个值过大或者过小的时候啊，它的这个梯度实际上都会特别小对吧。

会特别小啊，那这种情况就会出现一些所谓的一个，梯度消失的一个情况啊，那这下面这个图就是我们的这个啊，SIGMOID的它的一个那个啊梯度的一个图啊，我们可以看一下啊，只要我们的这个值大于5。0。

要小于负的，就大于五或者小于五的时候，他这个梯度就会变得越来越趋近于零对吧，到十的时候你看已经基本上就等于零了，这个梯度这边也是啊，到十的时候基本上已经等于零了，而这边这个是ten h的这个。

激活函数的一个梯度啊，所以说如果我们不去做这个归一化，那我们最终的这个值就可能会在十，甚至大于十的这些位置，这些位置啊就会落在这些位置，那你落在这些位置的话，就会让我们的梯度变得特别小对吧。

我们的梯度就会变得特别小，梯度特别小，那就会容易出现一个梯度消失的一个情况，那我们网络更新的时候，可能更新的就不够好对吧，所以说这个时候呢，我们就会采用一些normalization的一些方法啊。

做一些规划，把它的均值尽可能控制在均值为零，方差为一的一个数据情况上，就控制在这一个部分对吧，控制在这个部分，控制在这一个部分，这样的话我们就可以拿到一个梯度比较大的，这样的一个值啊，总结一下啊。

目的就是为了让我们的一个数据不要落在，这些所谓的激活函数的这个饱和区域，好吧，好那normalization呢我们常用的啊，又分为这个beta normalization。

和这个LANORMALIZATION啊，还有一些其他的normalization，这里就我不展开说了啊，我们主要说一下这个BHOMALIZATION，和这个LAMALIZATION的一个区别啊。

RHONALIZATION呢，它不太适合使用这个处理文本啊，然后batch normalization呢，也不适合那个batch size太小的一个情况，那LIONALIZATION的话。

还有BATIONALIZATION，最大的区别就在于bh normalization，它是在BH那个维度上进行一个处理的，而layer normalization，是在每一条数据上进行一个处理的啊。

我们可以简单给大家介绍一下啊，假如我们现在有这样的一条数据，这是啊，假如我们叫X1，嗯X11吧，X11X12X一三好，这是我们的一条数据，那接下来我们还有一条数据，这是我们的这个X21X22X二三好。

我们现在还有个X31X32X33X34好，这是我们的三条数据啊，三条输入数据，那这三条数据它的一个长度是不一样的啊，前两条的长度是三，那最后一条数据它的长度是四，我们考虑一下啊。

这个batch normalization它是怎么做的，batch normalization它是在这个维度啊，我们换个颜色，它是在这个这个维度上面做的，他是在这个维度上面去做这样的一个。

所谓的一个which honalization的，那我们考虑一下啊，如果对于文本来说，如果我们现在要做一个补偿的一个处理，那这里就是零，这里就是零对吧。

然后我们按这个维度来做BH的h normalization，做过异化的一个处理，那归一化我们需要去求均值，求方差，那这个时候这些地方都是零对吧，那我求出来这个均值和方差实际上是不准的，不准的。

而且啊如果我们bt size比较小，就拿这里举例啊，我们这个BH3是三，那这个时候我们求出来的均值和方差，其实是也是比较不合适的对吧，所以rationalization啊。

更适合使用在这个文本和那个图像领域啊，并不适合我们这样的一个NLP的一个领域，那layer normalization它是怎么做的呢，layer normalization是在这个维度啊，是在这个维度。

是在这个维度，它是以这样的一个句子的维度，来做这样的一个所谓的一个求均值求方差，你看这个维度的话，我们就无所谓啊，你管你有几条这个序列长度对吧，我都可以方便来求我的均值和方差，就这样的一个思想啊。

这就是lo normalization和rh normalization，好，最后我们再来看一下这两个计算方法啊，那正常的一个归一化的方法的话，可能就就减掉均值，然后除以方差就OK了对吧。

但这里呢他bch normalization和这个layer，Normalization，它引入了两个超参数啊，一个是咱们的一个阿尔法，还有咱们这样的一个贝塔啊，其次呢他会这在这里加上这样一个FC龙。

那就是为了防止你的这个方差是零啊，方差是零，所以这里会加上一个FFC6，这个值的话是一个非常小啊，接近于零的这样的一个值，OK那这一块我相信各位同学都能理解啊，也就是减掉它的一个均值除以一个方差。

这一块，各位同学肯定是理解能理解的，那为什么要去又添加了两个超参数，一个是阿尔法，一个是贝塔呢，这两个参数大家可以简单的看成，就是两个权重啊，我们在BP的过程中会去更新这两个参数啊。

那这两个参数的作用是什么呢，是这样子啊，就我们做了这样的一个规划的一个处理之后呢，我们的一个数据啊，可能会改变原始的这样的一个分布，就唉我现在已经学出来了这样的一个分布了，你强行去卷均值，去除以方差。

把我的这个分布也改变了对吧，那我模型岂不是白学了，所以这个时候呢我们又会额外引入两个参数啊，让我们这两个参数再把它给拉回，我们原来学出来的那个数据分布上啊，这就是这两个参数的一个作用，好吧好。

这就是layer normalization，和我们的bash normalization，那对于我们的这个transformer来说，因为我们基本上都是处理的这个文本信息嘛，对吧。

所以我们这里属于使用的啊，是我们的这个雷音normalization，好吧，雷诺MALIZATION好，这就是我们的这个transformer啊，那下面这里也是一样啊，对于这一块的这个参差模块来说。

和这个LAOMALIZATION来说，就和刚才是一模一样的了好吧，一模一样的啊，这就是我们这个transformer的encoder，一个补充啊补充，那接下来的话我们就来给大家再简单介绍一下。

这个BT这个模型，那这个模型的话注意啊，这个模型它是transformer的encoder层，它不是transformer，它只是transformer的encoder层，我再说一遍啊。

BT这个模型它的结构是transformer的encoder层，encoder层好吧，encoder层，好，然后这边的话给了大家，BERT这篇论文的一个啊地址啊，大家可以去看一下，好。

那我们知道了BT这个模型，它的模型结构就是transformer的encoder层，那它这个encoder是什么样子呢，实际上啊他就是base版本的一个BT呢。

它实际上就是transformer的encoder，堆叠了12个好吧，堆叠了12个，堆叠了12个，OK然后呢我们来说一下BT这个模型，它的一个预训练的一个阶段啊，那BT这个模型呢被称为预训练模型。

预训练模型的意思就是说，我会把这个模型，在这样的一个海量的一个数据上，先作为一个这样的一个预训练预训练，然后各位同学在使用的过程中呢，直接把这个模型拿过来，做一个所谓的一个微调微调。

也就是说这个模型啊已经训练好了，已经训练好了，你只需要在自己的场景上去进行，这样所谓的一个针对你自己的一个数据集，进行微调就OK了，好吧，那BERT这个模型呢，它会包含两个这样的一个预训练任务啊。

一个是叫做musk language model，另外一个是叫做next cellence prediction，好，我们来分别看一下这个mask language model。

这个预训练语言任务是在干什么，因为我们是在海量的数据上去进行一个训练，对吧，这个时候我们实际上就等于是没有标签的，所以通常我们需要去找到一个所谓的一个啊，非监督的一个训练的一个过程对吧。

那或者说他一个自监督的一个这样的一个训练，余额构成，那对于BT这个模型来说，它的这个musket language model，实际上就是一个非监督的啊，他是在做什么呢，大家可以简单的理解为。

它就是在做一个所谓的一个完形填空啊，例如我现在有这样的一个句子，X 1x2 x 3x4，那我就可能把X3这个词给遮住，我mask住，然后呢我再用X1X2和X4这三个词啊，我来预测一下X3这个词是什么。

就以这样的一个形式啊，来进行我们的一个预训练，那他这个预训练的一个过程呢，是随机mask了15%的一个词啊，15%的一个词，例如这里有一个句子啊。

my dog is henry让他把这个HENRY给mask住了，然后用my dog is来预测这个词是什么啊，这就是我们的这个mask language model啊，但是这个预训练任务啊。

它实际上是有一定的缺点的，就是说他会mask15%的词，也就是说100个词，你会mask15个对吧，100万的话，mask了15万，他这个数量其实是非常高的，那就会出现一个问题啊，那如果我在预训练阶段。

把这15%的词给mask住了，那这些词可能就得不到训练对吧，这些词你被你mask住了呀，我们永远不会去看到这些词，它到底是什么东西，那这些词可能训练的就不够充分，就会导致我们训练阶段和微调阶段。

其实看到的东西是不一样的，那我们微调阶段有些东西就等于是不知道的，像这个词我们被mask住了，那我们可能微调阶段根本就没有拿到这个词，很好的这样的一个训练好的一个权重对吧，所以呢BERT这篇论文当中呢。

就提出了一些优化方式啊，首先这15%mask的词，其中80%采用的是mask，然后10%呢是随机取一个词来代替mask，因为我把这里这个harry换成了apple，还有是10%，它是保持不变的啊。

保持不变的，然后这里也再给大家解释一下啊，有些同学可能会说啊，你这里10%随机替换一个词，来代替mask的词，那这里会不会引入一些负面的一些噪音呢，确实会，但是呢论文当中认为啊，因为是15%。

然后你又取了10%，那最终就是1。5%的概率，这个概率很低，他就把他给忽略不计了啊，忽略不计了，但实际上这种方法，其实我自己觉得并不是一种比较优雅的方式，好吧啊，Mask language model。

mask language model好，我们再来看他的第二个预训练任务啊，叫做next sentence prediction，实际上啊，就是他的意思就是说我现在有两个句子，一个A1个B。

如果这个A和B这个两个句子，它是一个上下文的一个关系，也就是说B这个句子，它是跟在A这个句子后面的，那它就是一，如果B这个句子它没有跟在A这个句子后面，那就是零，那我们构建这样的一个训练样本也很简单嘛。

我们要从我们海量的一个这样的一个，文本数据当中，去抽抽这样的一个上下文的一个句子，然后标为一，然后我再随便抽一个句子，然后再随机采样一个句子，这样的一个情况我标为零就OK了对吧。

然后我就以这样的一个形式啊，去再做一个所谓的一个二分类，二分类，这就是BT的一个预训练的一个任务啊，两个预训练任务，然后呢这里大家需要注意一下啊，在输入给模型的时候，如果是两个句子。

中间会以这样的一个SEP这样的一个分隔符，然后分割一下啊，这是第一个句子，这是第二个句子，好吧，会有这样的一个句分隔符，有起始符啊，它也会有一个所谓的起始符，用CLS来cl s来表示起始符。

而最后终止符的话也是用这个SEP来表示，啊这就是我们的这个BT一个预训练任务啊，接下来的话我们来简单看一下BT一个输入啊，输入，BT一个输入的话是包括三个部分啊。

一个是这个token embedding，一个是segment embedding，还有一个叫做opposition embedding，token embedding的话。

就是咱们的word vector这样的一个值啊，这个就不说了，the position embedding的话，刚才在讲transformer的时候也给大家讲过对吧，就是这样所谓的一个位置编码啊。

位置编码呃，最后要说一下这个segment embedding，Segment embedding，那这个segment embedding是什么东西呢，就是这里这个啊，因为我们有两个句子嘛对吧。

我们有两个这样的一个句子，那如何去区分这两个句子呢，我怎么知道哪个句子是第一个句子，哪个句子是第二个句子呢，这就是我们的这个segment embedding啊，那对于第一个句子来说。

对于第一个句子来说啊，他会有这样的一个segment in be，第二个句子有一个这样的一个segment embedding，那这个sigement embedding是怎么计算出来的。

它其实也会有这样的一个SIGNMENT，embedding的一个embedding metrics，那对于我们第一个句子啊，我们就会数以零来表示，就是对于第一个句子的segment，我们用零来表示。

然后给到我们的embedding，然后对于第二个段落啊，我们用E来表示，然后再给到我们的这个segment embedding matrix，说白了啊，就是就等于我现在这个词典只有两个值，一个是零。

一个是一，那对于第一个句子，那我就把它全部转换成一个one hot的一个形式，就是零对吧，然后那对于第二个句子，我转成one hot的形式的时候，就是对应的是一就以这样一个形式啊。

来去训练我们的这个segment embedding matrix，最终拿到我们segment embedding，好吧，就是这样的一个思路，然后最后我们再来说一下关于这个position。

Embedding，这个position embedding，在BT当中和transformer当中还不太一样啊，transformer当中的一个位置编码呢，它是去计算了这样的一个正余弦的一个函数。

而来得到它的一个位置编码，但是在BT当中呢，它并不是以这样的一个形式啊，它也是更新出来的啊，它也会有这样的一个所谓的一个position，Embedding metrics。

也是这样的一个embedding matrix啊，然后呢在BT当中啊，因为我们序列的最大长度是512，也就是说你不管你这个序列怎么查，你最多只支持512，然后呢，我们会把每一个位置都会转换成这样对应的。

512的一个下标嘛对吧，这里是零，这是一，这是二，这是三，然后把这个东西给到我们的position embedding matrix，就可以得到我们最终的position embedding，好吧好。

就以这样的一个形式啊，我们就能拿到我们的token embedding，Segment，embedding和position embedding，最后再把这三个部分的内容给加在一起。

再给到我们后面的encoder层，好吧，encoder参数，这就是我们的一个BT，一个输入好吧，BERT一个输入，嗯最后的话给大家啊，罗列了一些这个关于BT的一个使用啊，bot一个使用，然后首先是这个。

啊首先是harking face这个transformers啊，然后这也是我最推荐大家使用的啊，这个是啊封装的比较好的一个，那这个库的话也是GITHUB上面这个star，增长最快的一个库啊。

然后我很推荐大家去使用这个transformers好吧，推荐大家去使用这个东西，R可以同时支持这个TENSORFLOW和这个PYTORCH，那TENSORFLOW的话只支持2。0的一个版本啊。

啊然后然后是谷歌官方这一套，谷歌官方这一套的话是基于这个TENSORFLOW，1。0写的啊，这也是最原始的版本的，然后我这边的话也有两个版本啊，第一个版本的话是对谷歌官方1。0。

这一套的一个封装就是个BLIOTEARS，然后第二套的话，我这里还有一个写了一个TENSORFLOW，2。0版本的一个vert啊，然后我现在自己的话其实也不怎么使用啊，TENSORFLOW这一套的。

我现在也基本使用的是这个PYTORCH，基于transformers的这个PYTORCH啊，我现在更多使用的还是好in face提供的这一套啊，然后大家也可以根据自己的一个需求去选择。

想看哪一块的一个代码好吧，大家可以自己去看一下啊，嗯然后这就是这个TRANSFORMANCE这一块啊，很推荐大家来看一下啊，推荐大家来看一下，好他现在还出了一个简体中文的一个这样的，Read me。

可以啊，好详细就详细的一个内容，就大家就自己来看好吧，就关于怎么使用它，其实这里已经讲的很清楚了，然后大家如果啊有什么问题的话，到时候也可以在群里面和我沟通，好吧好这是关于BT的一些原理和一些使用啊。

那接下来我们来讲我们的第三部分啊，讲我们的第三部分，就关于这个基于BERT的一个文本embedding啊。

我们先看一下我们的这幅图啊，啊这里有一个，这样的一个对比图啊，啊这里有这样的一些数据集，这个数据集的话。

大家可以把它理解为，就是我们刚才代码当中的这个ARCQMC。

这样的一个数据集类型是差不多的啊，只不过它是英文版的，我们可以看一下啊，他这里对比了一下这个globe这个词向量，这个东西大家可以简单理解为就是what vector啊。

他对比了这个glob vert取平均，这是GLB取平均，然后bird取平均，然后还有一个BTCLS，这个CLS什么意思呢，就是我们的这个bird输入的时候。

不是会输入一个c i is的这样的一个标记位吗，他用这个CIS来表示我们的一个具向量，局向量好，要做到对比了一下效果啊，发现如果我用这个BTCIS来作为具向量的话，其实效果特别差，就16。5对吧，16。

5，那对于这里这个glob的话是58，然后BT取平均的时候效果也也没那么理想，甚至不如这个blob的一个词向量对吧，毕竟这种东西它是一个静态的，理论上来说，你一个静态的词向量效果。

应该没有所谓的一个语言模型生成的效果，好啊对吧，那为什么会出现一个这样所谓的一个，效果不理想的一个情况呢，这是为什么，这就是值得我们思考的一个问题啊，好我们就来看一下，我们考虑一个问题啊，考虑一个问题。

那通常呢我们去计算一个两个向量的一个，相似度的时候呢，我们通常都是计算的，这个所谓的一个余弦相似度对吧，那这个所谓的一个余弦相似度，就是说我们在计算这个余弦相似度之前，有没有什么假设呢。

或者说满足什么样的一个条件，我们才能去计算这个余弦相似度，那这个余弦相似度，计算出来的值才是有意义的呢，我们可以考虑一下啊，那对于我们计算与余弦相似度的时候，我们首先第一步。

需要去计算两个向量的一个内积对吧，那他这个内积是怎么算的，实际上就是各自的一个模长，乘以它们的一个夹角的余弦值对吧，那余弦相似度就是两个向量的内积，然后还要除以咱们的这样的一个模长对吧，模长。

那这是我们的一个余弦相似的一个计算公式啊，但是啊我们在计算这个余弦相似度的时候，必须是标准的一个正交机，必须是标准的一个正交集啊，标准的一个正交集，也就是说咱们这个夹角的余弦本身。

是有非常鲜明的这样的一个几何意义的对吧，也就是说如果我们要去计算我们与心相似度，必须在我们的这个标准的一个正交基上面，但是对于我们BT生成的这样的一个embedding。

它是在所谓的一个标准正交基上面吗，不一定啊对吧，这个谁知道呢，哎他是他是一个760这个bird啊，它默认bird它生成的这个向量，它是768位的啊，768位的，那么问题来了，我们并不知道BT。

它到底符不符合这个所谓的一个标准成交机，对吧，那这样我们来算出我们这个余弦相似度之后，得到的这个指标肯定是会有一些问题的对吧，那效果可能就不好，效果就不好，那这个时候怎么办呢，我们是不是可以考虑一下。

能不能把BD生成的这个具向量，把它转换到一个所谓的一个标准正交基上，对吧好，这是一种思路啊，然后接下来的话我们再，啊这是一个所谓的一个定性的分析啊，我们在定量的一个分析来看一下啊。

啊这边有这样的一个表格，这个表格我们先看第一行啊，第一行表示的是一个词瓶，就是说我这个bird当中，这些词它出现了一个频频次啊，他的这个是一个是一个等级啊等级。

所以这个0_{100表示他等级就是0}100，这个等级里面啊，这个表示表示表示的意思是啊，持平比较高啊，磁频比较高，然后越往右边的话，他这个磁平是越低的好吧，越低的啊，这个时候我们来看一下这个表格啊。

这个表格首先看这一行，这一行的意思就是说，如果在BT生成的这个向量空间内的，每一个词的一个词向量，它距离原点的一个距离，一个L2距离啊，我们可以看一下啊，那对于一些词平比较高的一些词。

它其实距离原点距离会比较近，会比较近，那对于一些词频率比较低的一些词，它距离原点是比较远的，也就是说越接近原点的词，它的这个词频是越高的啊，越高的，然后我们再来看一下下面下面的这些值啊。

下面这个意思就是说，也就是说每三个词，每三个词它之间的一个相互这样的一个距离，然后取了一个均值，取了个均值可以看一下啊，那对于距离原点就是它磁平比较高的一些词，它这个词的一个间距趋势是会稍微小一点点。

如果持平比较稀疏，那这些词相互之间的一个间距是会比较大的啊，比较大的，这是一个L2的一个距离啊，下面是一个点乘的一个一个值，点乘的话你就可以看成一个相似度嘛对吧，然后最后就会我们就可以得出一个结论啊。

那越远离原点的词呢，它分布的就会越松散对吧，这是距离原点比较近的，也就是说磁平比较高的，那磁平高的就是距离原点近嘛对吧，因为也就是说磁平越高，它距离原点越近，然后它会分布的越紧密，磁平越低。

它的距离远点就会越远，它会分布的越松散，嗯我们这边简单画个图啊，他大概就是这个样子的，它可能距离这是一个三维的啊，那持平比较高的磁就距离在原点附近，并且磁和磁的一个间距啊，它会比较小。

对于磁瓶比较大的一些词啊，它就会远离原点，并且这些词的词，这些词的间距啊会比较大，大概就是这样的一个分布的一个情况啊，分布的一个情况好，那我们我们考虑一下啊，那对于这样的一个分布情况来说。

假如我们现在取的是一个，这个词啊它有些词它可能封他词频比较低对吧，这个词词频比较低，我可能选到了这样这里这个词，然后其他词呢我可能子平比较高，它可能在这个位置，然后最后我去取它的一个均值。

那最后均值求出来，可能这个值是在这个位置，那这个位置它实际上对于这一块来说啊，它有很多这个所谓的一个空洞，那这一块这些空间它其实因为分布的很散，那你并不能用这一点就说这一点的这个值啊。

它并不能很完美的表示出，你的这个值到底有什么样的一个意义啊，好这就是这样的一个，这是为什么BD生成的这个计算量，效果不好的一个原因啊，好我们这边进行了一个这样的一个啊，定性的一个分析。

觉得他可能不是一个标准的正交集，而这边呢又做了一个定性定量的一个分析，觉得他可能会出现一些所谓的一个，像磁平持平的一个关系，会引起它的这个效果不好的一个情况是吧，那有了这两点的一个分析之后呢。

我们这边就来看一下有什么样的一些解决方案，首先第一个解决方案呢是这篇论文啊，叫做word flow这样的一个模型，它的一个思路是什么呢，就是说既然如此啊，那我就把BT生成的这样的一个embedding。

转换到这样的一个所谓的一个，高斯分布的这样的一个空间，那我之之前你的那个BT那个分布，我不知道是什么样子嘛对吧，那我就转嘛，转换成这样的一个高斯分布的这样一个空间内，要从而能满足我们所谓的一个标准。

正交基的一个情况啊，呃具体的一个情况我们这边就不详细说了，各位同学可以去看一下这篇论文，好吧好，论文当中也有开源的代码可以给大家看好，我们继续往下啊，除了这个所谓的一个bird flow这个模型呢。

我们这边还有一种方法啊，就是一种基于监督学习的一个方法，监督学习的一个方法，那基于监督学习的一个方法，肯定会对于bird flow这样的一个方法来说的话，它是一个非监督的一个方法，那监督学习的方法的话。

相比于这种非监督的方法的话，肯定效果会有一定的一个提升，好吧好，那我们来看一下这个这种方法啊，这篇呢这个方法的话叫做sentence bt啊，他的思路是什么呢，那既然我们现在要计算这个余弦相似度对吧。

那我们不如在微调的时候，我们直接把我们的损失函数，就朝着咱们的这个余弦相似度来嘛对吧，也就是说我们这里这个思路啊，和我们给大家介绍的这个文本匹配模型，的一个结构会很类似。

也就是这样的一个孪生网络的一个结构啊，然后我们这边输入一个句子，经过咱们的一个bird，而这边是另外一个句子啊，经过咱们的一个bird，最后拿到了我们的两个句子的一个向量对吧。

我直接去计算这两个句子的一个余弦相似度，那这个余弦相似度，最终它的这个值是在-1~1之间对吧，那我们其实际上啊是有我们的真实标签的，我们真实标签有一和零，我们可以把零映射为咱们的一个一真实数据。

就是这个嘛这本数据对吧，这本数据，然后呢我们再把这个数据啊，这是我们的真实的Y标嘛对吧。

这是我们真实的Y标，这是我们的一个输出值，我们再把经过余弦相似度拿到的一个结果，和我们的真实外标，计算，我们的平方损失函数，来作为我们最终的一个损失值，就以这样的一个形式啊来进行我们的微调。

最终我们微调出来的这个这里，这个U和这里这个V实际上就可以用来，表示这样的一个真实的一个具象量了啊，好，这个就是今天要给大家讲解的，这个BT生成具向量这一块的一些内容了，好吧，然后啊这边我也说一下啊。

那对于BT生成具向量这一块的话，实际上也属于一些进阶的一些内容，然后我希望各位同学下来呢啊，就能把BT这一块就自己再去花点时间，再把课堂上我讲的这些东西对吧，自己再去看一下，多花点时间把它深入理解。

其次呢你再去了解一下，如何去使用这个sentence bt对吧，Sentence bt，再去看一下啊，如何去做咱们这个sentence bt，那如果你这一块做好了呢。

你就可以把我们代码当中的这个啊，我们代码当中不是有一个这一块吗，sentence vector对吧，我们之前是用的，我们的这个JENSM生成的一个词向量，那你可以用BT那个BT的具向量。

把这一块给替换了好吧。

可以把这一列这一块给替换了，其次啊，咱们今天不是还给大家讲了这个匹配模型吗。

对吧，匹配模型，那匹配模型我们现在构建好了。

但是我们还没有加到主流程当中对吧，主流程这边还是把那个相似度最高的，给返回回来，那我们现在可以考虑一下，我把相似度前十的或者说前20的给返回出来，再用我们的匹配模型对吧，我们的这个匹配模型去算一下。

这找回的20个或者十个，哪一个相似度是最高的，再把那个相似度最高的答案给返回出来好吧，这是我们希望大家自己去实现的啊。

然后BT这一块的话，就属于这个进阶的一个作业啊，进阶的作业大家可以不做，但是还是建议大家去做，然后相似度模型这一块的话，一定要自己下来去动手，把这个模型给实现好吧，给实现好，这就是今天的一些内容了啊。

一些内容了，然后大家还有一点我要说明一下啊，因为咱们这个是机器学习班嘛。

所以我们有些BT方面的东西，可能没有花那么多时间去讲的那么深入啊，但各位同学，如果今后想去从事NLP方面的一些工作的话。

BD这一块还是要去掌握的好吧，一定要花时间去掌握，一定要花时间去掌握啊，这是非常非常重要的啊，非常重要的，包括这个文本的这个embedding，也要花时间去把它给掌握了，好吧好行。

那咱们今天的内容基本上就到这边了啊，最后看各位同学有没有什么问题，有问题吗，各位同学，没什么问题的话，咱们今天的这个课程就到这边了，好吧，LSTM结构就是sell，为什么要这样子构造。

嗯这样子构造的原因，就是他引入这个所谓的一个门的，这样的一个机制，啊啊这样子吧，我可以看一下我们之前写的这个，好我们看这个图啊，我们看这个图，我们可以看一下这个图，看这个图，那对于这个图来说。

我们可以简单理解一下啊，这首先，好我们看一下这个，首先呢这边它会有这样的一个SIGMOID的，那这个SIGMOID的啊，就是说哎我这里进入输入值对吧，我进行一个SIG格MOID的，我做一个判断啊。

这边会输出一个0_{1之间的一个值嘛对吧，0}1之间的一个值，这里其实就是所谓的一个门一个门，然后呢这是上一轮给过来的这个sales sit对吧，我会因为这里是个0~1之间的一个值嘛。

我会把这个0~1真的值，和上一层的这个值进行一个相乘，这里的意思就是我会判断一下到底有多少的值，就是上一轮有多少的值会保留上保留下来，就假如我这里是一个0。7，也就是说，我会把上一轮70%的值保留下来。

如果这里值是零，也就是上面上一轮的值，我觉得没有什么用，那我就全部丢弃了，那这里我相乘之后，这个值就是零，就是这这里就是这个意思啊，这里是这个意思，然后我们再来看下面啊，下面这里是一个所谓的一个嗯。

也是一个门的机制啊，也是输入输出一个0~1之间的一个值，然后这边呢我会把当前的一个值进行一个，非线性的一个变换，然后这里这个门，其实和这一个门的一个思路是一样的，我就是要告诉我当前这个模型。

我接下来要进行一个输入了对吧，那我输入的时候，我应该保留当前的这个XT，经过的这个ten h之后多少的值，假如我这里是0。7，那就等于是把经过ten h，70%的值留下来，然后和上一轮保留下来的值。

进行一个相加的一个处理好，那相加之后呢，我们再往后面往后面之后，这边又进行了先进性，先经过这个ta h处理，经经过tan h之后呢，这边又有一个门，这个门呢又输出一个0~1之间的一个值。

这个值再和这里这个值进行一个相乘，也就是告诉模型，我当前应该输出百分之多少的一个值，如果这里是0。4对吧，也就等于我接下来的一个输出值，我只保留我这一部分的40%，就是这个意思啊，就是这个意思。

那为什么会以这样的一个形式来弄，我们考虑一下啊，那假如我们之前的内容意义不大，那意义不大，那对于第一个门来说，它可能就输出的一个0。1或者0。2对吧，那我上一轮的这个值可能就只有0。1的一个。

结果进行了一个保留，那我们接下来给到后面的时候，可能觉得啊，我这一这个时间节点这个词比较重要对吧，那这个时候可能我这里这个输出门的时候，可能就是一个0。8或者0。9，就保留更多的一个内容给到后面。

就是这样的一个思路，好吧啊，我有说明白吗，这位同学，其实你只需要把这个门的这个机制弄清楚了，你整个结构就很清楚了，额有理论上的一个证明其实是这样子啊，我们可以额，这个我在N2P小班的时候给大家讲过。

就主要那为RN是这样子啊，RN它的这个计算过程呢它容易是这样子啊，我这边也简单说一下啊，RN的一个计算过程是这个样子嘛对吧，那这边会有最终的一个输出值，我用o on来表示啊。

那如果这个o on要对这个节点的这个啊权重，进行求梯度的话，那这个时候如果序列长度太长，那就会容易出现梯度的梯度消失的一个情况，为什么呢，因为你去看他的那个求梯度的一个公式。

你会发现它是一个累成的一个情况，并且他这个累乘的每一项啊，每一项他都是一个0_{1之间的一个值，那假如这这个序列长度特别长，假如有100的一个序列长度，那这个梯度就是一个0}1之间的一个值。

然后的100次方对吧，那这个值实际上是趋近于零的，就会容易出现一个所谓的梯度消失的一个情况，那对于LSTM来说，它并不是一个累成的一个情况啊，这个求解梯度的一个过程，并不是一个累成的一个情况。

它最终会有一些累加的，像累加的话，那就让他尽可能不会出现这个所谓累乘100次，趋近于零的一个情况，因为他有些累加的价，从而就防不能说繁殖啊，应该说缓解了这个所谓的一个梯度消失好吧，因为你缓解了梯度消失。

所以你这个长期记忆就是有效的，你这个RN的话，你这个很容易梯度消失嘛，所以你这个尺就没有办法做到，这个所谓的一个长期记忆，而LSTM的话就有这样的一个优势好吧，但是LSTM并不是说。

它就完全不会出现梯度消失，它只能缓解，OK吗，这位同学，是的是的，改善了只能说改善啊，只能说改善就是改善，改善或者说缓解啊，其他还有什么问题吗，你说的经验是指什么，你是想问什么经验，工作经验呢，还是。

学习方法，那就是其实这个东西怎么怎么说呢，其实对于新人来说还不太一样，新人的话可能啊也不太适合去看一些paper吧对吧，那你就去看一些比较基础的一些内容，那对于啊像我们这种工作很多年的来说。

可能就是每天去看这些新的paper，然后去总结一些新的一些方法，一些优化的一些方法好吧，还是不一样的啊，对于你们这些初学者来说，更多还是去学习一些基础的内容，那对于我们来说。

可能就是去啊追踪一些前沿的一些技术，去学习一些新的新的一些paper，LSTM的cell的初始值是隐藏层H0吗，啊初始的时候这里还会有这样的一个值啊，就这里假设是第一个节点啊。

他这边假如假如这个是第一个节点啊，那实际上这里还会有一个HT减二嘛，那这个值它是随机初始化的啊，好还有问题吗，好行，那咱们今天的内容就到这边好吧，如果还有什么问题的话，到时候在群里面找我就OK了，好行。

那咱们今天的内容就到这边。

我们就明天再见啊，明天再见。