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

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

【七月在线】机器学习就业训练营16期 - P12：在线直播：3-图像与文本基础_ev - IT自学网100 - BV1Z9T5ewEKL

呃各位同学大家晚上好，然后我们今天呢就给大家讲解，我们的文本和图像基础啊，嗯这个呢就是很多同学比较关心，因为我们现在很多的一个呃岗位呢，上网工程师的岗位呢都是跟要不跟文本相关，要不就跟图像相关对吧。

所以说很多同学在嗯，就是说也是呃，非常建议可以，提前把我们这节课给好好学习一下，呃我们现在一个就业啊，就是说算法工程师对吧，我们的算法工程师，算法它里面是分方向的，不是单纯的就是算法工程师。

我们在上节课，其实上次直播也就是前两天直播的时候，我们也说了啊，因为我们具体任务它是分任务的，所以说这个地方我们的算法呢，也是分具体的一些方向，AP搜索额推荐系统，还有我们的搜索，还有我们的CV。

还有这种结构化的，不同类型的一个算法工程师，他的一个要求的技能是不一样的，所以说我们在学习的时候。

你肯定是要分专分方向的进行学习的，我们首先呢给大家看一看，我们今天所讲的这个啊，我们今天的内容分为四部分，第一部分呢是我们的一个数据的类型的介绍，然后这个部分呢，其实在上节课我们也给大家介绍了。

然然后呢我们这个地方呢再给大家介绍一下，然后第二部分呢做一个文本处，文本数据处理的一个基础，第三部分是图像处理，数据处理的一个基础，然后第四部分是我们的实践案例，好我们首先来看第一部分数据类型呃。

我们今天的课程呢就主要是给大家嗯，讲这些具体的一些呃，就是说知识点啊，然后有一些具搭配一些具体的代码，然后我们的PPT呢可能会稍微简单一些，我们的具体的一个数据呢。

其实在我们在上节课上次直播时候给大家说了，我们的具体的一个问题，以它的一个其实跟我们的数据相关的，我们有这种结构化的数据，半结构化的数据和非结构化的数据，那么在这个地方呢，我们具体的一个数据集呢。

它的一个类型其实是跟我们的任务强相关的，一般而言我们在做一个呃任务的时候呢，首先是把它划分成结构化的数据和，非结构化的数据，结构化的数据就是表格类型的，非结构化的数据，就是不适合这种表格类型的嗯。

结构化的数据就是这种啊，就是说你可以用这种pandas的库，来进行很好的读取的对吧，我们在之前的课程也给大家讲了，我们具体的这个pandas的一些基础操作，然后呢。

我们的一个相当于是嗯这个嗯非结构化的数据，文本图像视频，文本图像视频好，这些呢都是在我们的，就是嗯他的一个非结构化的数据，那么这个地方呢，我们今天给大家讲这个文本或图像啊，当然这个视频呢。

其实它就是我们的一个多帧图像所组所组成的，那么如果是将我们的一个图像，加上我们的一个音频对吧，AUDIO就等于我们的视频等于video对吧，所以说这个视频呢从两部分啊，一个是我们的图像。

一个是我们的一个音频，那么这个地方呢就需要大家可以思考一点，提前思考一下，就是说我们在做一个分类任务的时候，在做分类，这种时候图片分类和文本分类有什么异同点吗，图片分类和E呃。

文本分类它其实都是分类任务，但是呢它的拥有的一个具体的一个数据，是不一样的，那么接下来我们的一个具体的一个嗯，就是嗯所产出的一个模型啊，以及我们的侧重点就不一样对吧，第二个文本分类和租房热度预测。

它有什么异同点，这个做房热度预测，就是我们上次直播给大家讲的这个，two sigma的一个嗯房屋热度预测，那么文本分类，它是一个典型的一个非结构化的数据，我们讲的住房热度预测，它是一个结构化的数据。

所以说这两个虽然说都是分类任务，但是它一个是非结构化的数据，一个是结构化的数据，自然它的一个解决方法也不一样，所以说呢我们在遇到一个问题之后呢，首先拿到我们的一个具体的一个嗯问题，然后就看他是什么数据。

然后就可以找到他具体的一些方法了，好那么我们就开始先看我们的文本，数据处理，对于文本而言，就是说在我们的英文里面，它叫natural language processing，简称ARP嗯。

自然语言处理啊，自然语言它这个地方的一个语言呢不是任何的，不是编程语言，它是一个自然的语言，自然语言就是说我们的一个人与人之间沟通的，这种语言，就是我们的自然语言，就是自然场景下的嗯，或者说英文。

或者说任何人与人之间沟通的这种啊，就是自然语言，那么我们的一个在日常生活中，我们写代码，这种Python，我们的C加加，我们的c#，其实它都是编程语言，它跟自然语言是不一样的。

编程语言它是有规定的一个语法，你不按照他的语法写，它就会错误，但是自然语言它是不会的啊，自然语言就是说如果老师在发音的上面，或者说说错了某些单词，其实不影响主体内容对吧。

所以说自然语言其实它是非常难的一件事情，也被称作叫做人工智能技术的皇冠啊，其实非常难的一件事情，那么咳咳咳，在我们的这个非结构化的数据集里面呢，文本是非常常见的非常常见的，那么在这个地方呢。

我们的互联网上面的一个具体的一个，80%以上的一个信息，都是由文本给出来的，就是说我们去嗯你去聊天啊，或者说在互联网上冲浪，其实很多的一些具体的一个数据，一些信息啊，都是由我们的一个文本所给出来的。

对于我们的文本呢，一个算法工程师，他其实嗯基本基本任务啊，或者说基础的时候呢，都是做一些语言理解的任务，语言理解就是AIU语言理解能力，就是说我们给定一个文本，能不能理解出这个文本中间的一个核心的一个。

关键点，这是第一个第一内容，第二内容呢自然语言生成，这个地方的一个生成是前者，U呢是一个understanding，对吧，庞德斯登顶U呢，呃这个地方的G呢就是generation。

生成生成就是说我们能不能给定一个文本，你去产生它的回答，或者说你知道这含义的情况下，你能够组织这个语言，就是文本生成对吧，这个呢其实机器人很难有这个生成任务，生成的能力的。

因为机器它是没有这种逻辑思考的对吧，在我们的大部分场景下，我们的一些任务呢都是这种NLU的LU的，那么我们在这个自然语言处理，这里面到底有哪些任务呢，其实嗯我们待会会给大家介绍啊，嗯自然语言处理呢。

其实它的一个难度是非常大的，嗯在我们的日常生活中呢，你会看到很多的一些bad kiss啊，就是说这种错立我们看这个啊，就是说一个一男一女在进行相亲的时候，然后男生就发了他的一个名字叫普通对吧。

然后让女生给误会了，然后就是嗯把他拉黑了对吧，其实这个男生他就是叫普通对吧，女生就觉得他是呃，他以为就是说他说呃自己的名字很普通对吧，然后呢这个地方我们再看这个例子，就是说我们的一个具体的一个文本。

在进行嗯理解的时候呢，它在不同的句子里面，它的一个含义是存在不同的，比如说我们的一个有一个新闻，德国最大连锁百货进入破产，然后呢微博他在进行嗯，就是说识别的时候呢。

大家就看哎这个最德国最大连锁百货这个地方，他在做一个判断的时候，就是认为大连的用户都在关注这个新闻对吧，其实这个并不是说，这个地方并不是一个城市对吧，那只不过这两个单词把它组合到一起。

就变成了这样一个情况，嗯那么这个地方其实我们第一次看到这个例子，觉得哎微博的技术是不是很难啊，嗯是的啊，就是我有好多同学之前在微博实习啊，以及工作微博，他们在做一个自然语言理解的时候。

很多时候都没有上模型，都是人工去增加这些关键词，如果去人工去用城市的关键词做一个匹配，就很容易匹配成这种情况对吧，他没有做分词，在我们的一个自然语言的场景下呢，其实它是非常难的一件事情。

因为语言它是一个没有任何规律的，自然语言是没有任何规律的，而且是错综复杂的，语言是可以开放的，它是非常开放的，可以进行组合得到新的单词，这个呢就是如果是英文呢，其实更更严重一些。

我们在英文的一个每年度的牛津词典里面呢，它都它都会新增一些单词，就是我们的一个英文的单词，它是由我们的一个英文的字母所组成的单词，但是呢对于我们的中文而言，其实中文也会出现新词对吧。

我们在今年或者说去年都每年都会在产生一些，互联网上的一些新的单词对吧，所以说这个地方我们的一个机器，他想要不断的去理解这些新的单词，那么他就需要具备这种持续学习的能力。

好语言呢它在有一个上下文的关系的情况下，以及有环境知识的情况下，它的含义是不一样的，就是说一个单词在有上下文的情况下，有环境的情况下，它的含义也是不一样的，好，所以说自然语言处理其实是非常难的一件事情。

在我们的自然语言处理里面呢，我们有到底有哪些常见的任务呢，到底有哪些常见的任务呢，就是说我们常见的啊就是有这个垃圾邮件识别，情感识别和意图识别，这个就是我们的一个基本上，就是一个文本分类的任务。

聊天机器人和智能客服，在我们的之后的课程可能会讲到，其实他是一个对话的任务，语音识别和语种识别，其实这是类似于我们的一个语音相关的，一些任务，机器翻译和魔幻生成，这是其实是一种生成的任务好。

那么在这个里面呢，我们在前面三类就是一个NLU的一个任务，后面一类呢这个是一个n lg的任务，因为因为他是有一个生成的啊，有生成的，那么有同学可能还不太理解，这个地方的NLU和LNG它到底有什么区别。

这个AIU呢，它只关注我们如何理解我们的一个文本，那么在这个地方呢，我们基本上你可以用这样一个公式来白起，我们输入一个文本，然后把它做一个类别的分类，这个就是我们的一个NIU的任务。

lg呢就是说我们输入一个文本，我们试图要产生一个新的文本，这个新的文本和我们的一个原始的文本，是不相同的，或者说是不同不同语言下面的，这样你就可以理解对吧，我们的AIU呢基本上是一个降维的过程。

但是lg呢其实它不是一个单纯的降维的过程，在我们的LP里面呢，我们有两种实践方法啊，就是说传统的机器学习方法，以及我们的这个具体的一个嗯，基于我们的一个深度学习的方法，那么如果是用深度学习的方法呢。

那么自然而然他就是嗯，就是不需要有很多的特征工程，只需要我们把数据集给它处理好就行好，那么我们在做一个文本处理的时候呢，其实这个地方就有一些小小的一些细节，首先呢对于文本而言啊，我们的不同语言下的文。

他的文本，比如说我们的中文文本和我们的英文文本对吧，它就存在我们的一些区别，对于中文而言，我们是没有这种我们的字，我们的句子是由我们的单词所组成的，每个单词又是由我们的字所组成的。

那么我们在这个英文里面，英文就是它的一个句子里面，就是我们的一些一个单词，这个呢就是有一个很典型的区别，就是说对于中文而言，我们如果想要识别到单词的话，我们是需要做一个分词对吧。

但是呢对于我们的一个英文而言，其实我们不需要做分词，这个地方呢我们如果是做一个分词，或者说把它划分到词源，我们一般情况下把它叫做一个token nizer，这个token ize。

或者说token ize这样一个操作，就是把它做一个分词，当然我们在这个文本里面，其实还有一些其他的一些基础知识，比如我们在文本里面有这种形容词，有这种单词的一个词性对吧。

这些呢都是在我们的一个自然语言处理的，一些基础的一些教程或者说课本里面都会讲到，那么如果我们嗯基本上这些啊，前面这些都是我们的一个文本的清洗，文本的预处理，然后后面这些比如我们的这个。

它就会包含到我们的一个句子基嗯，基于我们的句子或者说单词的一个理解，然后下面第三部分，这个呢就涉及到我们的一个句子，相似度的一个计算好，那么基本上就是说，如果你对这些AMP感兴趣呢。

你可以将这些具体一个单词，这个呢就是我们的一些具体的一些距离，计算公式，你直接在百度上搜索，就可以得到一些具体的一些嗯答案啊，都是有一些啊，或者说一些教程都非常方便，对于我们的文本而言。

其实在我们在进行建模的时候呢，是需要特殊对待的，需要特殊对待的，然后呢我们的一个具体的一个文本呢，它在进行特殊，就是说嗯为什么要特殊对待呢，因为我们的文本其实它本质就是一个list，这是第一个单词。

这是第二个单词，然后这是第三个单词等等等等，你这个这是一句话，然后这个地方我们的一个嗯，就是说这一句话里面，他的这个相当于是一个word对吧，这是一个word这个地方我们的一个list，它是不定长的。

不定长的，然后呢我们再进行嗯，就是是处理的时候，我们的模型其实是不能接受这种list的类型的，一个输入的对吧，我们在进行上节课嗯，在对这个to西格玛比赛嗯，那个数据集做处理的时候。

我们对于list类型的一个数据，我们其实很简单的统计了一下，它的一个具体的一个长度对吧，就是说直接提取一个特征，提取它的长度，我们没有做其他的操作对吧，因为这个地方如果做其他的操作。

就涉及到我们本节课的知识啊，我们就没有展开讲这个list，来做一个处理的时候呢，你可以提取它的一些特征，比如说你把这里面的每一个单词做一个编码，比如说我们提取一个特征，就是说是否，包含某个单词对吧。

如果是包含某个单词，我们就把它置为一，如果不包含某个单词，就置为零对吧，你可以相当于是人工去提取一些特征，这个都是可以的，但是呢这个地方需要注意的是，就是说我们一般情况下，这个文本呢它是不定长的。

它是不定长的，那么这个不定长呢，我们就是在做处理的时候，你是需要知道我们的一个具体，就很容易得到一个系数的数据，因为句子不定长的情况下，而且这个句子里面是有很多word的情况下。

那么这个具体在进行处理的时候，你如果都是做这种类似的特征，你得到的一个具体的数据呢就是非常稀疏的，当然对于文本的一个处理，你可以参考类别特征的编码，比如label encoder。

或者说count in content，encoder等等等等，这个是可以参考的好对在对于文本而言呢，其实这里面有非常多的一些知识啊，因为文本它的一个发展是非常非常完备的。

这个呢就是我们传统的自然语言处理，里面的一些具体的名词，比如我们的语法术啊，比如我们的word rank啊，我们的一些呃LDA呀，我们的一些具体的一些名词，在自然语言处理里面，其实就是说非常多。

当然这个并不是说全部都需要大家掌握，这个值得给大家看一下，在自传统自然语言处理里面，其实包含的知识点是非常多的，如果是跟我们的深度学习相关的，就是我们的基于深度学习的资源源处理呢。

这里面就大部分是模型的构建，你比如说BT模型啊，我们的xl net啊，或者说我们的transformer attention啊，或者说我们的CNN啊等等，那么在深度学习的一个自然语言处理里面呢。

就比较关注于我们的模型搭建嗯，以及我们的具体的一个数据的处理，然后这个部分有这个地方，有一个我们的一个LP的厂，就是比较全的任务的一个名词啊，比如说这种哦我们的NNER嗯，实体抽取啊。

我们的这个文本翻译啊，Machine transtranstranslation，如果你感兴趣的话呢，可以把这一部分的一些嗯具体的任务啊，可以在下下面在下课后呢，把我们的一个任务给大家了解一下。

因为我们这个这节课啊，只会把我们的自然语言处理和CV呢，大致给大家过一遍，基础不会给大家讲很深，那么我们在学习的时候呢，可以你可以先这样一个思考，就是说我们在进行一个嗯学习的时候呢。

首先是看一看你的一个具体的一个嗯文本，它能够在什么地方出现，也就是设想一下我们的日常生活中，哪些任务是跟我们的文本打交道的，嗯或者说你到底是想要学习哪一类文文本任务。

或者说你在学习的过程中会遇到什么问题，你都可以提前来了解一下，因为嗯我按照我的一个经验啊，就是很多初学者在学习机器学习的时候，如果你基础不好的话，你学NLP的一些具体的任务，会很难很难很难上手啊。

嗯或者说你可能调试几天，都很难调试出这个代码，嗯那么在这个地方，你就首先不要想着把我们刚才这两页的一些，知识点都全部学会，嗯对于初学者而言，你是绝对不可能学完的，所以说呢你要一定要弄清楚。

你自己到底想学什么，然后再去聚焦到这个任务上面，然后这个地方呢也对于NP任务呢，也有一个具体的一个公开课啊，嗯是斯坦福大学的一个cs嗯，224和CNS22cs。

24N和CSR24U这两个课呢都是比较经典，而且每年都在更新的一个呃公开课，如果你想要去面试AARP的算法工程师，这两个课一定要刷一下啊，就是看完因为很多的一些前沿的一些模型。

在两个在在这两个公开课里面都有讲到好，那么我们再开始啊，对于我们的一个自然语言处理里面呢，我们比较基础的LP，里面有我们的NLG和LU对吧，那么比较推荐大家先学一下AU。

因为AU呢还是一般情况下的任务都比较简单，在NLU里面呢，我们比较推荐大家先学习一下文本分类，文本分类呢这个跟我们的一个图像分类，其实本质一样啊，这个地方我们输入一个文本。

我们需要输出一个具体的一个类比，这就是一个文本分类，在做文本分类的时候呢，其实文本分类有非常多的一些应用场景啊，我们再翻到前面，比如我们的垃圾邮件识别对吧，输入一个邮件，我们判断它到底是不是垃圾邮件。

我们情感识别输入一段文本，对他的情感做一个判断对吧，他的情感是正向的嗯，负向的或者说中立的意图识别，就是说这个具体的一个文本，它包含是不是有什么意图，以及具体的一些关键词是什么对吧。

都是可以从分类的角度来完成的，那么对于文本分类呢，它的一个完整的流程是呃，文本预处理特征提取，文本表示以及分类器在这个地方呢，我们在做文本预处理的时候呢，我们的不同类型，不同语种的文本。

它其实是需要做不同的一个预处理的，也就是我们比较典型的英文的，它是不需要做分词的，而中文是需要的好做预处理呢，其实是需要将我们的一一个，也是需要将我们的一些文本里面的一些呃。

就是说垃圾啊这种信息给它剔除掉嗯，比如这种嗯无效的信息啊，都是需要把它剔除掉的，那么这个呢可能是也是需要大家掌握一下，正则表达式相关的一些啊，就是说知识呃，后面的这个特征提取和文本表示呢，其实是这样的。

我们的原始的文本呢，它并不是说所有的文本都是有效的，我们是需要将文本里面有效的一些信息，给它提取出来，并把它表征为我们的一个呃，机器学习模型能够识别的对吧，我们各位同学现在应该对机器学习的一些模型。

应该有一定了解的，那么我们的机器学习模型，其实它本质很多情况下，都是只能输入我们的数值对吧，所以说我们是需要把它转成我们的一个，具体的数值，好这个呢就是说我们特征提取。

我们表示是将我们的文本处理为我们的模型，能够识别的格式，这文本预处理特嗯，特征提取和文本表示这个呢可以放在模型之外，比如说我们这一部分我们用Python来做写。

然后后面的分类器呢我们加一个x g boost，或者说加一个逻辑回归都行好，那么我们继续对于我们的文本而言呢，其实这个地方有一个非常关键的一个点，就是我们对于文本其实有一个叫做AGRAM的，这个呃。

就是说概念AGRAM呢，就是说我们是可以将我们的一个呃，它其实是一种语言模型啊，是一种基于统计方法的一种语言模型，它的一个操作呢，就是说我们利用我们的一个滑动窗口，在这个窗口内的一个具体的一个呃数值。

它的一个统计量，来统计我们具体的一个字符的频率啊，举一个非常简单的一个例子，就是我们的AGRAM在给定一个句子的情况下，我们n gram分别取值为123的情况下。

我们输出的结果and gram取值为一的时候，其实本质就是this is a sentence，This is a sentence，每个单词每个单词分开，这个呢又叫做unit gram。

n gram取值为R的情况下，就是this is is a a sentence，这样一种取值对吧，这样一种情况，那么它就是一个AGRAM取值为R，它窗口为二，我们叫做big gram。

然后N个N取值为三，N取三的时候，就三个单词的时候，This is a is a sentence，这种的它叫又叫做一个TRIGRAM，好，这个呢就是一个叫做我们的一个n gram，的一种语言模型啊。

嗯他在做什么呢，ANGRAM的语言模型，其实本质是在统计两个单词组合的情况下的，就是说你可以理解把它组合成了一个新的单词，这样呢其实是可以保留这个单词与单，词之间的一个次序好，那么对于文本做处理呢。

其实有一个非常基础的知识呢，叫一个contractor，convector呢它是将我们的一个文本进行一个编码，并并进行一个统计，它出现的次数好啊，那么这个地方呢CONTROVECTOR它嗯又叫一个。

又叫做一个turn frequency term for greener，这个term就是我们的一个单词的意思，或者说这种嗯如果n n gram n取一的话，就是每每个单词N取二的情况下。

就是两个单词的组合，这个叫做一个term，那么这个contractor，其实在我们的SKN里面也有具体的实现啊，我们待会可以看一下，我们输入一个句子S嗯，contractor在做什么呢。

它本质就是首先构建一个word index的一个词典，在这个词典里面呢，我们将这个this把它编码为一啊，this is编码成零，然后呃is编码成1good2bad三对吧，类似的。

然后呢将得到这个词典之后，这个词典其实本质就是，将我们的一个具体的一个单词编码成一个数值，然后接下来我们是把它转换成这样一个向量，每个句子把它转换成这样一个向量，这个向量它是仍然是一个表格类型的。

有行行的维度就是我们的一个样本样本，就是我们的一个句子列，就是我们的一个字段，这个字段呢就是表明这个单词，它出现的一个频率，什么意思呢，在这个句子里面，我们包含的单词是this is good。

This is good，那么在对应的位置大家都是取值为一的，那么在下面一个句子，第二个句子this is bad，那么在这对应的位置，它就是取就是取值为一的这个地方的control vector呢。

它是做一个次数的统计，就是说如果第一个句子是this is good，Good，Good，Good good，假如说有五个good的情况下，那么这个地方我们的这个位置就是取值为五的。

那么这个CONTROVECTOR这是他在做什么呢，Contributor，它本质就是统计，我们这个单词在这个句子里面出现的一个次数，它有什么样一个作用呢，就是说不管你是多长的句子。

我们都是把它转换到一个相同的一个维度，下面这个字段的这个维度，就我们的度有多少列呢，我们的列的个数是由我们的word index所决定的，它里面到包到底包含了多少个单词，也就是我们多少列。

比如说这个地方我们是五个单词，我们的列就是五个对吧，如果我们是六个单词的情况下，我们就是六列，那么这个地方不管你是任意长度的一个句子，都是可以把它转换成一个相同维度的一个vector。

这个vector的一个维度，就是由我们这个所有单词的个数所决定的，好我们刚才所讲的呢就是一个turn frequency，其实本质就是一个contact or。

那么CONTROVECTOR其实本质在统计，它本质在统计什么呢，它本质在统计这个单词，在这个句子里面出现的一个次数，但是呢这个单词在所有句子里面出现的次数，我们是没有考虑的对吧。

那么这个地方我们就是给大家介绍一个叫做，I d f inverse document fency，逆文档词频，它是什么含义呢，就是说我们提取一个提出一个统计值，这个统计值呢去衡量一下。

这个单词在所有句子里面出现的频率的倒数，相当于是我们的一个具体的分子，就是我们的所有句子的个数，二分母呢，就是这个单词在所有句子里面出现了一个次数，比如说这个地方我们的this is。

这个单词在所有的句子里面都出现了，且它的一个我们的一个句子，的个原始的个数就是二，那么这个地方this他的IDF就是log1，log1是多少，就是零，就是表明这个地方我们的一个。

这是在所有句子里面都出现过的，那么它的一个重要性对吧，他就是零了，所有人都有的对吧，那么你相当于是你没有，就是说没有独特性了对吧，也没有什么任何的信息量了，那么在这个地方end end呢。

我们只在一个句子里面出现过的，那么它的一个取值就是log2，那么他就是非银的好，那么计算得到之后呢，其实本质就是我们在做这样一个计算，我们将这个位置和这个位置进行相乘，15乘以log1。

log1等于零五分之一乘log，一等于零五分之一乘以log2，得到这个位置，零乘以log2等于零五分之一乘log2，在这个位置对吧，进行一个基于元素级别的一个相乘，然后得到了我们这样一个矩阵。

这个矩阵里面呢，它就是一个TF和IDF进行相乘得到的，那么这个地方呢，我们把它简称叫做一个TFIDFTFIEF，那么TFIDF呢，它在这个地方本质是由两部分所组成的，Term procreate。

Term frequency，以及我们的inverse document frequency，前者是统计我们这个单词，在这个文档里面的出现的次数，后者呢是统计一下这个单词在所有文档里面。

出现的次数的一个导数，就相当于是它的稀缺性，前者是在这个文档里面的重要性，后者是在所有文档里面的稀缺性，两者进行相一样进行考虑啊，一起进行考虑，就得到我们这样一个TFIDFJFIDF呢。

在SKN里面也有具体的一个，直接就可以使用的啊，我们待会来看一下好，那么我们就继续，TFIDF分成两部分，一个是TF，一个是IDF，那么这个计算的方法，我们待会也刚才也给大家讲了好，然后呢。

我们就看一看这个具体的一些文本的，一些代码的实践，我们可以打开一下second nn的一个官网，然后呢在他的一个API的一个界面，我们可以搜索得到一个CONTROVECTOR，我们在学习的时候啊。

一定要将我们的一个呃课件的一些一些知识，如果是能够直接在一些Python的一些包里面，能够找到对应的一个实现，这样是最好的，也就是说当你学了这个理论之后，然后再去到我们的一个库里面能够用起来。

这样才是非常非常好的一种方法啊，嗯不然你学了知识之后，你不会用这个就哦非常糟糕了，那么这个地方呢如果我们想要用contractor呢，我们是怎么进行使用的呢。

我们from sk learn点feature extraction，点text模块，然后嗯import controvector，这个呢就是嗯我们在做一个具体的，CONTROVECTOR的一个操作啊。

嗯我们的一个CONTROVECTOR呢，我们在进行一个具体的一个使用的时候呢，嗯SKN啊，我们在上节课，其实嗯我们跳过了SKN啊，嗯SKN呢，它是呃就是说最为流行的机器学习的库嘛。

然后呢这个地方contract，这个地方它是首字母大写的，就表明它是一个class，它是一个类，这个类呢我们就是需要将它一个实例化，然后进行使用我们实例化我们的contractor实例化。

然后对它进行一个fit，fit呢就是我们用我们的crops这些文本来构建，我们的word to in index的一个词典，然后我们的transform呢，就是将我们的文本进行转换转换的。

得到的就是这样一个矩阵，这个矩阵呢就是这样的啊，this is the first document对吧，这个对应的位置就是它单词出现的一个频率，比如说这个第二个句子。

This document is the second document，这个地方document出现了两次，那么在这个地方是二对吧，正好我们的一个次序，在这个位置就是表明的是document对吧。

那么其他的位置都是零，那么这个就是我们的一个contractor的一个，基础的使用，那么CONTROVECTOR呢它不仅仅是这样来进行使用的，它还可以分非常方便的。

可以加我们跟我们的AGRAM进行一个结合，在这个地方呢CONTROTOR它默认的一个AGRAM呢是一，默认的情况下是一，也就是统计单个单词的，如果我们设置agram range呢。

我们可以把它设置为2~22，那么这个地方就相当于是统计它的一个呃，两个单词的组合，那么我们得到的就是这样的，End this document，is first document这些单词的组合。

那么他是怎么得到的呢，我们来缩小一下啊，把这网页缩小一下，然后再来看一下啊，稍微缩小一点点，好，我们再来看啊，这个地方他怎么得到的啊，你看一下啊。

This is is the the first first document，就是这样滑动的得到的，然后你会发现它其实就是得到了我们的这些，相当于是在这个word index的词典里面。

它包含的是两个单词的组合，把它当做一个新的单词，那么在这个地方呢，我们ANGM的range呢其实是2~2，相当于是我们的n gram等于一等于二的情况，我们的这个地方的agram range呢。

其实可以设置的相当于是一个1~2，这样呢我们的AGRAM呢就是一二，就是它既包含一也包含二，这个其实是可以一起来进行提取的，就是说我也我既包含单个单词的组合，也包含两个单词的组合。

这样呢其实是相当于是我们的统计的一个统计，单词的窗口不同，那么在我们ANGENT取值为不同的情况下，我们的word index的一个词典大小不一样，我们提取得到的一个数据的一个维度也不一样。

特别是我们的列，它的维度也不一样好那么这是我们的一个CONTACTOR，在SQL里面都是可以很方便的进行使用的，from s k n n n点feature extraction点TXT。

在我们的SKN点特征提取模块的TXT模块，然后import我们的control vector，好在这个模块里面呢，还有两个跟TFIDF相关的，一个是t f i d f transformer。

一个是t f i d f vector，那么这两个是分别有什么作用呢，我们先一步一步给大家讲啊，先看的呢是我们的一个t f i d f vector嗯，T f i d f vector。

它其实是一个一步到位的一个操作，我们的刚才也讲了，我们的TFIDF，其实它是由TF和IDF两部分所组成的对吧，TF就是我们的CONTROVECTOR对吧，那么假我们假如不想分开进行提取。

我们想要一步到位，在我们的这个库里面一步到位，提取它的一个TFIDF怎么做呢，就是from as as client点facture extraction，点TXT模块。

import我们的t f i d tf i d f vector，然后对它进行实例化，然后进行fit transform，然后就可以得到我们这个单词的这个这些句子，的一个展示。

这个地方呢TFIDF它所包含的哪些，在废弃的时候，他在做什么呢，这个地方嗯就是说也是一些常见的一些面试点，就是说我们在做面试的时候，可能会从这个具体的一些嗯语法呀，他在做什么啊，就是说考察。

你就是说具体对这个原理是不是有了解，GFIDF其实他首先要做一个tf contractor，那么它其实本质要构建一个word to index的这个东西，对吧，word to index的东西。

另一部分呢它计算一个DFDF，其实是计算好了就统计他统计好了就不变了，就相当于是我们提前算一次就不变了，所以说这个地方其实本质也要统计一下，这个单词的所有句子里面的例文档自评对吧。

其实这个地方的一个IDF，其实就是一个一乘以N的这样一个向量，这个N呢就是所有单词的个数，那么这个地方其实本质TFTF，IDF要做两件事啊，在feature部分，一个是构建watch index。

一个是计算IDF好，这个是TFIDF，它是一步到位的，那么在这个地方呢，还有一个t f i d f transformer嗯，它是既对我们的TFIDF进行一个转换，它怎么做转换的呢。

其实这个地方我来这样来看，给大家看一下，你就清楚了啊，其实tf i d f transformer，其实本质就是将我们的一个TF的一个turn，FRACY的一个计算结果。

也就是我们的contractor的一个计算结果，然后进行一个进一步的转换，来进一步转换，就是说基于我们的TF的一个结果，然后计算我们的一个IDF，然后做一个转换。

也就是说对我们的一个contractor的结果进行转换，这个就是我们的一个TFIDF纯transform，你可以这样理解，就是contractor，再加上tf i df transformer。

就等于tf i df vector对吧，也就是我们这个地方，这个加上我们的这个等于我们的，直接一步到位的tf i d vector好，这个就是我们在s kn里面的，具体的一个使用啊。

当然你可以自己下课后啊，可以直接使用一下啊，嗯这个地方有同学可能会有问题，就是说呃我们在进行举的一个例子的时候，这些例子里面其实本质都是我们的一个嗯，我们的一个英文的案例，英文的对吧。

那么我们在进行一个具体的一个操作的时候，如果我们是想要对中文来做一个处理，怎么做呢，如果是对中文怎么做呢，有没有同学知道的，有没有同学知道，如果这个地方我们想要对中文的一些文本，做一个处理。

我们怎么做的，就是说如果这个地方我们想要计算一些嗯，五个或者四个中文句子的一个嗯CONTROVECTOR，我们怎么做，有没有同学知道的，对嗯手机用户520906同学以及CLARK同学。

知不知道我们如果是对于中文而言，我们怎么做呢，如果是对于中文而言，这个地方其实如果你直接将中文输入进去，我们的一个它是可能会报错，也有可能是没办法成功提取它的一个control or。

这个地方呢我们的一个英文，它是根据我们的一个空格来分隔，得到我们的不同单词的，那么这个地方我们如果是对于中文而言，其实我们就是很难得到我们的具体的一些，相当于是这些嗯单词的。

我们是需要提前将我们的一些具体的一些文本，把它相当于是把它分割成我们的，这这样一种形式，我们的一个单词，一个中文的成语，或者说一个单词中间用一个空格进行分开，这样输入到我们的一个模型里面。

把它输入到CONTROVECTOR里面，我们的模型才能够成功的进行识别啊，才能够成功进行识别好，如果是对于中文而言，就是说你提前将我们的中文进行处理好，然后进在进行输入到我们的一个呃。

contractor里面就行，那么在我们的中文中文的一个处理里面呢，其实它的一个基础操作，就是说你如果把它做了一个分词之后，然后再把它用空格拼成拼接到一起，其他的操作啊都是完整，不做任何改变就可以好。

那么我们接下来讲一个基础的文本，文本分类的一个例子啊，我们来看一看嗯，这个例子呢主要是对于呃，我们的一些英文的文本做一个分类，就是有一些文本呢是啊一个虚假的文本，有一些文本呢是这个真实的文本。

就是本质是一个文本二分类的一个案例啊，读取进来的就是一个嗯有这些字段啊，Keyword，Location，Text or tarage，这个text呢就是我们需要建模的文本。

TARGAGE呢就是我们的一个标签，这个keyword和location啊，这两个字段我们可以把它丢弃丢弃掉啊，我们不用额，因为这个keyword和location，里面是包含了非常多的一些缺失的啊。

我们就不用这两个字段，只用这个text字段，我们在做一个具体的一个嗯，text字段的一个分析的时候呢，其实是可以做这样一个统计的，我们可以统计一下，标签为零和标签为一的这两类的文本。

它的一个具体的一个句子的一个嗯，就是说首先可以看一下这整体的类别的分布，就是我们可以将我们的target进行一个value counts，我们嗯零类的一个样本是4342个，一类的样本是3270一个。

这是我们的两类样本，它的一个具体类别分布，那么我们还可以呃做一个具体的一个key，word的一个嗯，展示，这个keyword就是我们的原始数据集里面的keyword列，然后这是原始的数据集。

它所给的一个keyword啊，我们在使用的时候，我们不做具体的使用，那么我们在做一个处理的时候呢，其实我们是可以将我们的一个在location列，我们是可以将它它里面的一些缩写呢，进行一个转换。

这个地方呢，其实location那个，它其实本质就是我们的一些具体地理位置，的一个缩写啊，那么这个就是我们在做预处理的时候，可以将我们的一些文本它的一些缩写符啊，嗯或者说他的一些具体的一些位置啊。

把它做一个转换好，那我们可以发现大部分的文本呢，都是发发布在USA啊，当然也有一些其实不是在USA的本土好，那么我们接下来该做什么呢，我们接下来就主要对我们的文本做处理，对于文本做处理呢。

我们首先嗯是需要将我们的文本，可能是需要把它做一个转统一，把它转成小写，然后剔除我们的文本的噪音，然后把它做一个分词，然后把它做一个具体的一个形容词的剔除，当然了，我们或许也可以做我们的一个词性的变换。

或者说词干的一个提取，词性的变化呢，就是说我们这个单词，其实它是有不同的一个时态的，单词是有不同的时态的对吧，比如我们的现在时态，过去时态或者说正在进行时的时态对吧，我们都可以把它进行一个统一统一。

这个相当于是一个磁性的一个体，然后呢我们的一个具体的一个形容词呢，它在进行，我们有这个good和better对吧，其实在这个地方，我们其实其实把它可以把它进行统一的转换，把它可以把它转换成相同的单词。

这样呢，嗯都是有助于我们的一个模型来进行建模的啊，现在于是将我们的word to index的一个空间，给它缩小了，在我们具体的一个清洗文本的时候呢，我们也可以考虑用正则表达式。

将我们的一个数据集里面的一些这种呃，UII啊，把它进行一个剔除掉，这些呢都是嗯我们的在做预处理的时候，可以做可以做的啊，好如果我们把文本把它处理好之后呢，就是非常规整的，都是小写的啊，都是小写的好。

然后呢我们也可以画一个云图，就是我们的一个嗯两类样本，它们分别就是说比较热门的一些单词是什么啊，比较热门的一些单词是什么，那么接下来呢我们可以做一个具体的一些token，token呢。

这个地方就稍微嗯有一点点细节啊，因为我们的token at的其实本质就是一个分，分词器或者说词源的提取器，我们的资源提取器呢，如果是按照不同的一些方法提取得到的，这个token呢。

其实它也是存在一定差异的啊，比如我们是用空格进行提取的，那么就是用空格进行分隔的，如果是用tree bank呢，它就会将具体的一些嗯，比如说二后note对吧，这些缩写把它分开。

这个地方其实就是基于我们的这个呃，单词的一个匹配啊，当然还有一些其他的啊，基于正则表达式方法的匹配啊，然后这些都是可以来做的好，那么对于形容词的一个剔除呢，其实这个就非常方便了，因为在英文里面。

我们的这个stop words和我们的中文里面，我们的这stop stop words都是非常清晰的啊，Stop boards，形容词，我们是可以将我们的一个具体的一个stop wards，做一个筛选。

就是说如果这个具体的一个单词在stop words里面，我们就把它丢弃掉啊，如果不在stop words里面，我们就把它保留下来，那么我们对于我们的token token呢，我们可以把它做些规划。

就是做一个我们的一个磁性的提取，或者是词干的提取对吧，嗯我们的一个单词一个句子对吧，fish cs wolves wpk对吧，我们在做一个具体的一个提取的时候，其实就是把它具体的一个时态啊。

一些单复数啊，嗯以及它的嗯具体的一些词嗯，词性啊都把它剔除掉，然后把它还原成最原始的一个形态，当然啊这个地方这些这两个操作steam号和lab啊，其实他做不做都行啊，做不做都行。

比较关键的就是把它转成大小写，然后把它分词就可以了，好然后呢，我们这个地方呢其实把它处理好之后呢，你也可以额这个地方的分子器呢，我们是用这个基于正则表达式的分词啊，你可以用其他的分子器，这个都是可以的。

提取完成之后呢，我们接下来就可以把它嗯就是说做一些特征啊，这个特征呢我们就是用CTRACTOR先来做一个操作，CTRACTOR呢我们对于我们的文本输入我们的文本。

然后用content vector进行转换，其实它转换得到的就是一个嗯零或者非零的，这样一个具体的一个矩阵，当然如果我们想要用这个tf i d tf d f vector，其实也是很方便。

我们设置一个我们的一个t f i d vector，然后设置一下我们的agram range，然后这个地方呢我们可以设置取的参数，MDF和我们的max df，这个地方它是什么含义呢。

这些含义在我们的这个具体的一个文档里面，其实都是有的对吧，我们来看一下这个地方，其实都是讲的我们具体的文本，他的这些形态的含义啊，嗯命DF是什么意思，命DF就是说我们在进行一个嗯提取的时候。

如果我们一些单词不满足我们的一个条件，我们可以把它进行一个剔除掉，就是说有一些比较稀疏，就是出现次数比较少的一些单词，我们可以把它剔除掉，next df呢，就是说我们如果一些单词。

它是出现次数比较多的对吧，嗯那么我们也可以把它考虑剔除掉，这些都是我们在做t f i d f vector的时候，其实本质做一些嗯，我们的一些token级别的筛选，我们可以设置一下好。

然后接下来呢我们就可以通嗯，用我们的一个机器学习的模型来进行一个训练，然后进行一个验证的对吧，我们这个地方首先能用逻辑回归，然后对我们的一个数数据集进行一个礼盒，这个地方呢我们首先呃。

这个地方是用cross valization score，cross validation score呢，这个地方它其实就是一个交叉验证啊，交叉验证cross validation。

这个呢其实我们在上节课也给大家讲了，Cos valization，就是说我们把它划分成五折，然后其分析其中一折呢，当做我们验证集循环五次啊，这样循环五次，然后呢我们就得到五份五份计算结果，五份计算结果。

那么这个地方我们来看一看啊，首先呢我们来计算得到在我们的一个CTRACTOR，一个输入的数据，然后通过五折交叉验证得到的我们的结果，这个分别是五，我们相当于是五五个，我们的验证集的一个F1score。

然后我们也可以使用我们的TFIDF，来做一个操作，TFIDF输入进去，然后仍然是五折，然后得到我们的结果，然后这个地方你会发现嗯，contract的结果，基本上是比TFIDFY的结果会好一些对吧。

这个是嗯可能大家没有想到的，就是说为什么这个TFIDF反而没有，没有这个嗯TF有效，嗯这个呢是存在的啊，特别是在一些文本分类里面，是存在这样的情况的，也就是说这个地方我们的IDF项。

对我们的最终的分类呢是没有效果的啊，没有用的，或者说起反作用的，那么类似的我们可以用这个贝叶斯，普斯贝叶斯的模型来做一个分类，我们的用普斯贝叶斯，然后做一个五轴的交叉验证。

在我们的content vector的下面的一个，精度会稍微高一点啊，基本上是0。6左右，然后我们这个地方在我们的TFI点vector上面，精度仍然是稍微差一点啊，比这个control or会差一点。

然后呢我们也可以用x g boost，x g boost这个地方定义我们的x g boost classifi，然后对我们的xd boost进行一个训练，也是5日交叉验证。

然后叉g boost的一个模型的一个结果，会是是在我们三个模型里面是最差的，对吧好，那么这个呢就是我们的一个AARP的一个，基础的一个代码，在这个地方呢，其实呃我想给大家表达。

表达的一个非常重要的一个信息呢，就是你可以看一下这三个模型，它的一个精度啊，这个地方我给大家写一下，我们的一个精度呢，其实就是嗯逻辑和规是零点呃，大致写一下0。56啊，然后呢我们的一个朴素贝叶斯是0。

63，然后我们呃我们的tg boost是0。38对吧，这三个模型在相同输入的情况下，其实它的一个精度差异蛮大的，差异蛮大的，那么这个地方其实为什么这个x g boos。

它的一个精度比这个前面两种差很多了，x g boost不是很强大吗对吧，我们在学到他的理论之后，x g boost有这种带有集成学习的一个数模型，它有带有这种什么呃我们的这个特征筛选啊。

以及我们具体的一些呃，这个嗯模型继承的思路啊，为什么它的精度反而差一些呢，这个呢就是我们的不同的机器学习的模型，其实它是存在一些偏好的，x g boost的这种树模型呢。

它比较适合用在一些带有类别数据的场景下，面，这个类别数据呢就是指category的这种，类别类型的数据，但是呢我们在这个地方提取的一个卡，TF或或者说TFIDF这两类的一个特征。

其实它大部分情况下都是数值的，它不是类别的，它都是一个数值的对吧，那么在这个情况下，我们是比较适适合用线性模型，或者说我们的一个朴素PS来做一个分类的，所以说呢我们的不同的数据。

在不遇到不同的一个呃模型的情况下，他的表现也不一样，那么在之之后的一个运用过程中啊，或者说在之后的一个学习过程中，也希望各位同学从这样一个角度来做一个思考，就是说什么样的数据适合用什么样的模型好。

我们稍微休息5分钟到九点钟，然后我们继续好不好，然后我们稍微休息一下啊，稍微休息一下，好大家如果有问题呢，也可以在我们的一个具体的一个，聊天框里面打字，让我知道啊，好我们休息一下，好额怎么怎额。

中文如果是嗯有同学问中文，如果每个词分隔开也采用英文一样的处理方法，结果会怎么样呢，结果就跟英文的一样啊，就是效果很好啊，每个字哦，你基于字级别的也行也行，这个其实也是可以的，就是也可以。

就是不基于单词级别，基于字级别这个也行，这个也是可以的，嗯这个地方呢，就是我这个地方还留了一个额外的一个额，具体的一个嗯代码啊，这个代码就稍微会有难度啊，我只大致给大家讲一下嗯。

我们在做一个英文的一个啊对，不管是英文还是中文的一个文本做处理的时候，其实是需要嗯做我们的一个单词或者文本的，一个相似度的一个度量，如果是做一个相似的相似度的一个度量，这个地方我们是可以有很多。

这些相似度量的方法，比如我们可以度量一下，这个字符串与字符串的一个边际距离，字符串与字符串的一个编辑距离啊，这个编辑距离，其实在我们的一些刷题的一些网站上面都有啊，编辑指令好，然后呢我们这个边界距离嗯。

这个地方大家可以下去看，这个地方我们是直接呃，我们我们这个地方的边界距离，我其实是可以再用这个edit distance来做啊，当然也可以统计一下两个句子，它共用单词的一个比例啊，共用单词的一个比例。

当然也可以统计一下两个句子，它们之间在通过TFIDF转换之后，它的一个具体的一个相似度啊，相似度就是直接把两个句子，通过一个TFIDF嗯，在一个具体的一个转换之后，然后通写他们的一个嗯。

就是说嗯他的一个具体的一个相似度啊，这个相似度呢，我们就是直接用一个dot来做一个嗯相似度，一个计算就行了，DOCH呢就是本质啊，这个地方我是为了做计算加速。

用这个PYTORCH来做一个嗯嗯GPU加速啊，就是做一个矩阵乘法，就是计算两个向量之间的一个，具体的一个相似度，当然我们在做的时候呢，也可以用，不仅仅用TFIEF，也有其他的一些改进方法，就是BM25。

就是基于TFIDF的改进方法，也可以用BM25来做，都很多啊，做的方法很多，好这个那我们就是说讲AP的部分，讲到这啊，就是说后面部分就是我们CV部分啊，AIP部分还有一个非常关键的概念。

就是说我们是可以把这个单词，把它转成一个向量，用what to director这种嗯词嵌入的方法来做，嗯那么这个呢在我们的之后的课程啊，我们的赛文老师和我们之后的老师呢，都会给大家详细的讲解啊。

也不用担心好，然后如果各位同学提前改，对我们的这个具体的一个嗯，案例比较感兴趣的话，你可以下去拿到我们这个代码好不好，可以看一看啊，主要的呢你可以嗯优先去掌握这个LP入门。

这个LOTUBOOK和CV入门这个逻辑book好，我们接下来开始我们的CV部分啊，就是图像的这个部分嗯，对于图像而言，其实他的一个嗯就是说叫做计算机视觉，computer vision简称CV对吧。

CV呢它是能，它的目的呢是让我们的机器能够理解这个视频，或者理解我们的图像，并进行我们的一个具体，也就是说对这个呃视觉有一定的理解，那么这个地方呢计算机视觉呢，它其实这是一个非常大的一个呃领域啊。

我们在计算机视觉里面我们有这个额，就是说数字图像处理啊，数字图像理解啊这些具体的一些分支，我们在做一个具体的一个学习计算机视觉呢，首先要学我们的一个嗯就是说我们的数据，数字图像如何进行存储的。

以及数数字图像如何进行提取特征的，因为我们的一个图片啊，它其实本质就是一个矩阵，它其实本质就是一个矩阵，就是说1match matrix啊，一个矩阵，我们的图片呢，它假如说是一个900×900像素的。

那么他就是拥有对吧，相当于是81万个具体的一个数值来表示的，我们在这个地方，就是说机器它本质只能是对我们的一个，具体的一个数据呢进行一个处理，它并不具备一个理解的一个过程啊，就是说在这个地方。

如果我们想要让我们的一个模型，拥有我们的一个理解的能力，这个地方我们就需要我们的一个具体一个，计算机呢能够理解我们的视觉，理解视觉的数据啊，好，那我们来看一看，对于我们的一个具体的一个计算机。

视觉的那一个任务呢，它其实的一个学习路径也是蛮复杂的，因为呃是呃也是一个比较大的一个学科啊，也是比较大的学科，那么如果是大家来进行学习呢，其实是可以按照这样一个步骤来进行学习啊。

首先呢在第一阶段可以学习一下，计算机视觉的基础，比如我们的一个数字图像处理啊，数字图像处理的一些基础啊，以及计算机视觉的基础，然后第二部分呢再看学习一下机器学习的基础，以及深度学习的基础。

第三部分呢就学习一下，以及具体应用，然后第四部分和第五，第五部分就是具体的一些深度学习的应用技巧，比如目标跟踪啊，语义语义分割啊等等等等，好如果各位同学先学习基础的话。

就学习第一阶段和第二阶段的内容就行了，我们在做一个图像的一个处理的时候呢，其实如果我们只是对一个图片提取它的特征呢，我们就是做一个图片级别的一个特征。

提取image的一个feature extraction对吧，对图片进行一个提取特征，这个地方的图片呢我们进行提取特征的时候呢，我们刚才也讲了，其实本质它就是一个矩阵是吧。

如果是彩色图片是900×900乘三三，是三通道的意思，对于图片特征呢我们在进行提取的时候呢，首先我们是需要根据特定的任务，提取它的一个特征的，因为图片它里面包含的数据是非常多的。

我们在做一个特征提取的时候呢，你可以参考图像处理的一些领域知识，比如说图片的一些边缘信息呀，以及图片的一些具体的一个嗯就是形状信息啊，这些都是可以来进行一个处理的，我们对于图像特征呢。

我们可以提取它的一些底层特征，比如它的颜色信息啊，边缘信息啊，关键点信息啊，这些都是可以的，嗯我们也可以提取它的一些高层特征，比如说CNN特征啊，我们的一些语义标签特征啊。

当然也可以提取一些基于文件的特征，比如说文件的创建时间啊，以及文件的MD5啊，这些都是可以提取的好，那么我们的一个具体的一个图片啊，它在运用的时候，或者说在应用的时候啊，其实是也是根据任务来进行驱动的。

我们不同的任务呢它的一个具体完成的一个呃，就是说目标也是不一样的，我们常见的任务就是有这种呃，分类分类就是我们的给定一个图片，我们输需要输出这个图片，它的一个具体就是主体的一个类型，主体的一个类型。

那么这个地方我们还有一个，我们的一个具体的一个主体分类加定位，就是说把我们的这个主体的一个目标，给它定位出来，我们的目标检测，相当于是把我们的这个图片里面的一些目标，它的一个类比，把它一把它识别出来。

以及具体的位置语义分割，是把这个具体的一个像素级别的进行分类，就是这些是背景，这些是狗，这些是猫，这些是狗对吧，我们常见的接机视觉的里面的任务，就是由分类目标检测与分割这些所组成的，在这个地方呢。

就是这些这个地方我们这一部分啊，下面这一部分就是基础任务，这些基础任务学好了之后呢，你再去看一些嗯自计算机视觉的一些领域，任务就非常简单了，比如说这种行人虫检测raid任务。

其实本质就是一个分类加检索红绿灯识别对吧，我们给定一个图片里面给定一个图片，想让你识别出里面到底有没有红绿灯对吧，那么就是一个物体检测的任务，所以说你把这个基础的一些任务学好了。

然后再去看一些具体的一些比较难的任务，就非常简单了，那么学习这个我们的一个自然呃，学习这个嗯计算机视觉，就不得不学习这个深度学习，你如果学习这个自然语言处理，你也不得不学习深度学习。

因为现在在这个非结构化的数据集里面，深度学习的一个精度实在是太好了，深度学习呢在他其实有很多种分支啊，深度学习这个地方的分支呢，我如果说的比较简单一点，就是它的具体有一些层的差异，层的差异啊。

就是说具体的网络结构啊，这些层比较常见的层，我们有全连接层，有卷积层，还有我们的RN这种循环神经网络，我们在这个图片的这种数据下面呢，我们用卷积层比较适合用卷积神经网络，那么如果在文本的下面呢。

我们就是用这种RN循环神经网络对吧好，那么我们在做一个学习的时候呢，我们不同的一个领域的任务，其实它的一个侧重点也是不一样的啊，好深度学习其实是机器学习的分支，深度学习也是一种表征方法。

然后这个地方具体如何提取特征，就是我们具体的每一层如何进行设计呢，我们是可以用我们的一个嗯，不同的层来提取特征的，我们来看一个典型的一个例子啊，就是给定一个图片，我们需要识别出这个图片。

这个地方输入的是人脸，我们是需要识别出这个人脸的一些，具体的一些类别对吧，那么这个地方我们在进行，就是说不管是全连接网络，还是我们的一个卷积神经网络，它在进行不断的进行建模的时候。

这是我们的输入input，这是我们的输出，Output，我们的输入的数据在不断进行一个计算，不断进行表征，然后不断的一个计算之后，他其实在浅层计算得到的一个输出，是提取得到这个图片的一个边缘信息。

然后逐步深入提取得这些我们的人的一些啊，相当于是这个鼻子啊，眼睛啊，嘴巴这些部位的信息，然后再更深的相当于是提取到这些嗯，嗯就是说比较相似的一些嗯，由我们的一些鼻子，嘴巴它组合得到这些人脸信息。

所以说深度学习，其实它是一种对特征进行表征的方法，不断进行进行一个表征，这个地方我们的具体的特征提取的方法，你可以用全连接层，也可以用我们的一个卷积层，这个都是可以的，深度学习的一个特点。

就是它是可以来自己提取特征的啊，就是说我们在做一个具体建模的时候，我们不需要人工去提取特征，我们提取特征的方法是，放在我们的这个网络结构里面的，深度学习，它是需要根据不同的数据做不同的数据扩增。

以及需要做特定的正则化方法的，在我们的之后课程呢我们也会展开讲，给大家讲解好，然后呢对于我们的图片呢，我们给大家给大家看一个典型的案例啊，我们就给大家看一个，就是图片分类的一个案例啊。

然后这个地方我们给大家讲一讲，嗯对于我们的一个图片分类的一个案例呢，我们其实是呃，我首先呢给大家用深度学习的框架，给大家实现一下，然后呢也用这个机器学习的框架，也就是我们的SKN给大家实现一下啊。

嗯这个地方呢就是说如果学习深度学习，其实是要学习深度学习的一些框架的，deep learning的一个framework就是深度学习的框架，这些框架呢它其实就是做一些具体的一些网络。

搭建的一些嗯就是说一些操作，以及我们现在机器上不是有GPU吗，GPU呢我们自己去操作GPU其实是蛮复杂的，那么这些深度学习的框架呢就是很方便的嗯，帮助我们去操作这些GPU啊。

我们现在学习深度学习的框架呢，主流的是PYTORCH和TENSORFLOW，然后TENSORFLOW基于TENSORFLOW的有cares，cares呢。

它是一个基于TENSORFLOW的一个高层的实现，我们这个代码呢是基于chaos来写的啊，是嗯chaos2，也就是基基于，基本上是基于TENSORFLOW2来进行一个展开的。

我们首先呢来我们这个地方的一个案例呢，就是一个MINNEST的一个分类，m list就是从0~9，然后是十个数值，我们做一个分类，就相当于是手写数字啊，这是一个分类，我们首先呢读取我们的一个手写数字。

这个地方cares点DATASET点，Eminist load data，读取我们的一个具体的一个图片，它读取的是我们的训练部分和我们的测试部分，然后呢我们需要对我们的一个图片呢，把它做一个归一化。

这个归一化呢我们的一个原始图片，它是以一个呃这个非浮点数啊，我们是需要把它转成浮点数，我们这个地方的图片呢，一般情况下是在一个颜色空间内，就是0~255的空间内，我们把它除以L5。

就把它转到一个从0~1的一个空间内，这个呢其实也是必要做的一步，额，为什么必要呢，因为我们的原始的X这个地方是X，假如说是我们的图片，它的一个取值范围不能太大，不能太大，也就是说这个地方的规划。

其实本质就是我们在之前的课程给大家讲的，一个min max scanner对吧，Mean max max min max scanner，其实本质在做这样一个操作，就是对我们的具体的一个数据集。

把它规划到一个指定范围内好，那么我们接下来做什么呢，我们对我们的数据集呢，把它做一个增加一个维度，也就是说原始的数据集呢，它是一个我们的一个，66万×25，28×28，这个是我们原始的维度。

这个原始的维度呢就是6万，是我们的样本个数，样本数数据，五二十八乘28呢是我们的一个原始图片，它的一个尺寸，这个地方的一呢是我们的通道数，通道数单通道就是表明它是一个灰度图，单通道就表明它是一个灰度图。

好我们把我们的一个图片，把它转为一个6万×28乘，28×1的这样一个维度，我们的一个测试集呢仍然也是类似的啊，测试集的一个维度，就是一个我们的一个1万×28乘，28×1的一个维度，这是我们样本数量好。

然后呢，我们还需要对我们的一个标签做一个转换，标签呢这个地方其实chao unities to category，其实这个操作其实本质就是在做一个one hot操作，把我们的原始的一个标签。

把它转成这种one horse的一个形式，好，然后接下来我们搭建一个模型啊，这个模型可能稍微有一点点复杂，嗯我这个地方不会给大家展开讲啊，嗯这个是卷积神经网络的一个模型的搭建，我们只给大家看一下。

就是说搭建一个网络模型其实是非常简单的，输入我们的一个模型啊，输入我们的数据，这个数据呢就是一个28×2，18×1的一个尺寸，然后呢我们构建几个卷积层啊，一个卷积层，两个卷积层的一个操作。

两个卷积层分别设置，我们的卷积核的大小是多少，卷积核的个数是多少，我们的激活函数是什么，然后中间层有个池化层卷积，这是我们的convolution，2D是我们的卷积，这个你不用担心啊。

在我们的之后的课程，我们的seven老师会给大家讲的啊，我们的max prin呢就是一个池化，对我们先给大家做一个感性的一个认识啊，好我们用卷积层提取特征，然后进行磁化，磁化就是max spin。

就是保留2×2的范围内里面的最大值，把它有效的信息保留下来，然后进行卷积，然后进行池化，然后一个flatten，flatten就是把它从一个多维的情况，把它转为一个二，转成一个二维的情况。

然后加一个dropout随机丢失，然后做一个全连接层，最终得到我们的一个类别个数，这个类别个数就是十，类别个数是十，好我们来看一看这个维度的变化，你就清楚了啊，我们的原始的一个输入的数据是一个28乘。

28×1，然后通过一个卷积的操作之后，它的一个输出，这是它的一个我们的一个尺寸啊，尺寸从28×28，把把它降低到26×26啊，卷积的操作其实是为，就是说图片的长和宽的一个下降。

卷积的操作其实本质是图片的长和宽和下降啊，也就是说我们的原始的输入是H乘W乘C，图片的长和宽，然后这个C呢是通道数，通道数其实是上升的，通道数，32个对吧，32个，然后通过一个max pin之后。

把两个范围内的一个图片的尺寸里面，提取它的最大值对吧，我们的维度继续下降对吧，我们通通道数是不变的，然后再通过一个卷积维度继续下降，通道数上升，然后通过一个flatten。

flatten就是把它的一个维度把它拉平了，拉平的就是5×5乘64，就等于1600，把它转成1600的，因为我们的一个全连接层，它本质只能接收这种二维的一个输入，他去或者说在进行一个计算的时候。

其实本质是用矩阵乘法实现的，那么它其就是一个二维的输入，权利阶层，其实本质就是接受这种一，就是一个vector的输入啊，他不能接受这种矩阵的形式对吧，我们把它拉平，然后再把它通过一个全连接层。

把它转到一个十维，这个十维就是我们最终的一个概率的输出，我们最终的类别个数是十，好那么我们这个地方深度学习的一个训练呢，我们设置这个训练15轮，15呢，就是让让它在我们的数据集上迭代15次。

然后我们可以看一下我们的一个模型，在训练集上的一个准确率，以及我们模型在验证集上的准确率对吧，然后我们训练到最后，模型在训练集上的准确率是0。99，然后在验证集上的准确率也是0。99，也是0。99，好。

这个地方呢，我们你如果是对这部分觉得有疑问的话，你就是说你可以大大可不不必焦虑啊，这部分其实是在我们之后的课程，会给大家详细讲解，这个要我只是给大家初步讲解一下，我们搭建模型，然后进行训练。

这是基于KOS的，然后呢，我们当然也可以用我们的一个SKN来搭建，一个卷积，是搭建一个全连接的一个网络啊，我们这个地方是用s clan的一个neural network，然后从这个模块里面。

import我们的一个MRPCLASSIFI，这个地方的一个m r p classifier，就是一个全连接网络啊，全连接网络，然后这个地方的全连接网络呢，它默认是有一个是就是说网络结构的啊。

我们的网络结构它在进行搭建的时候呢，其实首先的就是我们有输入的一个维度，以及我们的一个输出的维度，我们根据我们的一个输入的维度，和我们的输出的维度，就可以得到我们的一个具体的一个网络结构啊。

这个地方其实是用我们的一个全连接网络，来做一个计算，然后呢SKN呢，其实你可以自己定义它的一个每层的一个，就是说呃他的一个嗯就是嗯到底有多少层啊，以及具体的一些层的一些细节。

当然这个地方我是没有没有直接手动，手动实现啊，直接是让它自动来进行一个推测，然后呢我们是进行一个score，score呢就是进行一个预就是打分啊，我们的一个feature呢就是一个进行一个训练。

然后呢我们的一个score呢，就完成一个具体的一个预测，当然啊这个地方我们的一个全连接网络，它得到的计算，得到的一个精度是0。977711，然后它的一个精度应该是比卷积神经网络，低一些的对吧。

它的一个具体的一个精度是低一些的好，然后呢我们当然也可以用这个呃rage classifi，就是我们的一个线性模型，线性分类器，然后呢我们用线性分类器来进行一个训练，然后进行一个预测对吧。

线性分类器的一个模型的一个精度是0。86，0。86对吧，然后这个地方我们的一个模型的一个精度，是比全连接的一个模型的精度会更低一些对吧，你就可以很清楚的可以看到，我们的这个深度学习的一个模型。

它的一个强大之处对吧，我们并没有做任何的操作，直接进行训练，就比我们的一个呃，就是呃线性模型的一个精度高很多高很多好，然后呢我们再继续啊，对于我们的一个图片呢，其实我们也可以提取一些相关的一些特征啊。

这个地方我们就展开给大家讲解一下，然后呢，嗯也给大家就是说打一下，我们的计算机视觉的一些基础，对于图片而言，其实它原始呢其实是一个矩阵，我们的一个图片呢其实是本质是一个矩阵。

这个矩阵呢就是一个H乘W乘C这边的长和宽，然后乘一个C，这个C就是一个china，就是由这样的一个三通道的一个，如果这个地方我们是灰度图，那么这个地方呢一个C就是一对吧。

其实本质就是一个三通道所组成的一个矩阵，那么对于一个图片而言，我们提怎么提取它的一些特征呢，其实这个地方我们的一个图片呢，如果它的尺寸是900×900乘以三三通道，RGB3通道的情况下，那么这个地方。

其实我们本质包含了多少个数值啊，900×900，80，1万乘三二百四十万个数值，240个W，我们一个图片900×900像素，下面它拥有240个W的具体的数值对吧，那么这个地方其实它的维度是非常非常高的。

那么在这个地方，我们如何提取这个具体的一个图片，的一个特征呢，这个地方这个问题就非常关键，对于一个提取图片的特征呢，其实有很多种方法啊，我们这个地方一一给大家讲，首先呢是这个图片的一个哈希值。

哈希值哈希值呢就是说对于一个图片而言呢，嗯我们是用一个哈希的方法，来做一个具体的一个特征的一个提取哈希，这个哈希呢可能很多同学之前就已经知道啊，哈希呢其实本质有点像类似于这种哈希table。

相当于是我们把一个具体的一个数值，或者说一个取值，把它映射到一个对应的范围内，一个比较典型的MD5，MD5呢，其实就是将一个文件把它转成一个字符串，一个文件的内容把它转成一个字符串对吧。

如果两个文件的一个MD5它是字符串相同，那么它的一个具体的内容就是相同的，那么这个地方的一个嗯image hash，我们的一个图片的哈希值也是类似于这种思路，它是将我们的一个图片的一个内容呢。

把它进行一个缩放，左边的内容把它进行缩放，比如说缩放到8×8的一个范围，然后呢，再根据我们的具体的像素的取值，是不是大于某个，比如说是不是大于128，跟他做一个比较。

然后呢就可以得到一个true of force的一个矩阵，这个矩阵呢每一个取值就是我们的对应的位置，是不是大于某个，就是说像素或者大于均值对吧，然后呢我们就本质就可以把一个图片把它降。

把它转换到一个8×8的一个矩阵上面，零一的矩阵，那么这个零一的矩阵呢，我们进一步可以把它转换成这种，16进制的字符串，把转换成16进制的字符串，那么就得到了我们的一个具体的一个哈希值。

这个呢就是我们的一个突变哈希值的方法，那么这个图片哈希值呢，其实它不同的哈希值的提取方法，它计算得到的哈希值也是不一样的，嗯比如说我们这个地方有这个嗯。

orange hash和p hash和我们的d hash，其实它计算得到的一个字符串是不一样的啊，嗯但是呢这个基本上是这样的，就是说如果两个图片它是相似的，那么它计算得到的哈希值也是相似的。

嗯我们是可以做一个小小的一个实验，我们读取两张相比较相似的图片，然后分别计算它的一个对应的哈希值，那么我们可以看到啊，这个地方三张图片，它的一个有很多的一些字符都是相似的对吧。

我们的后半部分的这些字符都是相似的，那么就表明这两这三幅图片，其实它本质它的内容就有很多相似之处，那么有同学可能就会问到，老师会不会存在两个图片，它的哈希值相同，但是它的内容不一样，是存在这种情况的。

但是这种概率很小啊，概率很小，好我们继续，我们对于图片而言呢，其实我们还可以提取这个图片，它的一个具体的一个像素的，一个嗯统计的一个信息啊，就是类似于这种颜色直方图的一种方法。

我们对于我们图片呢可以提取它的一个，我们的一个图片原始，假如说他是一个三通道的RGB的，那么我们可以提取一下每个每个通道下面，它具体颜色取值的一个直方图，这个直方图是什么含义呢，比如我们分别是RGB。

在这个地方，就是说RGB分别取值为49的情况下，那对应像素点的个数，也就是说统计了一个出现次数的一个，直方图或者柱状图，这个地方其实是一个柱状图啊，然后他为了画的比较好看，他是把它用连线连接起来的。

那么这个地方其实它统计的是一个全局信息，也就是说它只是统计了这具体RGB像素点的一个，出现的一个次数，他没有考，并不会考虑这个具体像素的位置，他是统一把这个图片的像素的取值，来作为一个统计。

取值为49的像素分别是多少，取值为100的像素，RGB空间分别取值为100的像素，RGB分别是多少对吧，个是多少，分别取值为150的，它是多少，所以这个地方颜色直方图呢，它是一种全局的特征。

它是将图片的一个整体的一个信息，进行一个计算，然后统计了一下颜色的取值，那么这个地方的颜色直方图呢其实他是很好的，可以很好的度量一下，两张图片在颜色空间下面是不是相似的。

这个地方我们如果提取图片的一个颜色，直方图的一个信息呢，我们直接是读取一个CORE his，就是直接用open CV这个库，然后可以提取它的一个颜色直方图的一个信息。

然后这个地方我们首先是将这个图片的一个，具体的信息呢，我把它首先是把它提取成这个灰度图的灰度图，就是说它默认嗯只有一个通道，所以说我们绘制得到的一个图片，就是就是相面是只有一条曲线啊。

然后呢我们可以看一下这两张图片，两张相似的图片，如果我们把它就是说分别提取它的一个颜色，直方图，你会发现他的一个及得到的一个直方图，其实是非常相似的，非常相似的对吧。

基本上这两个具体的一个曲线就是重合的，就是重合的，那么有同学可能就会问到老师，这个地方这两个曲线也不是说完全重合，那么我们怎么做判断呢，这个地方的一个判断其实是嗯，你可以直接是用这两个直方图。

它的一个嗯欧式距离就可以作为判断，这个地方我们其实本质得到了两个vector，vector1和vector2，我们本质做得到两个vector，在这两个vector类呢。

我们其实是直接计算一下它的一个距离就行了，对吧，其实这个地方是一个展示得到的结果，那么我们直接计算它的一个距离，就可以得到它的一个相，相当于是它的一个相似度，那么这个地方嗯。

颜色直方图它会不会也存在一个一个差，就是说它会不会存在它的一个具体一个缺点呢，其实呃颜色直方图，其实它也会存在它的一个具体的缺点，它的一个缺点就是说我们的一个图片，如果两张图片是比较相似的。

但是呢某一个部位，某一个位置发生了一个颜色的变化，那么这个地方的情况下，我们的具体的一个颜色直方图，它就会嗯就相当于是形态就发生了较大的变化，这个地方其实我们读取了两张比较相似的图片。

但是呢就是它整体你会发现啊，我们把图片放大一点，我们其实是有张图片，它的一个具体的颜色相当于是往，放大一点啊，你可以看一下，有一条也有一条图片的一个曲线，整体是往右偏了，为什么要往右偏呢。

因为他的一个具体的一个颜色，相当于是更加，相当于是这个地方是靠近255了对吧，靠近5255，应该是更加偏向于我们的白色对吧，所以说呢这个地方我们的一个具体的一个。

如果一个图片它的一个颜色发生了整体的变化，那么它的整体的一个额，就是说形态也是发生了一个呃，就是说我们的一个整体的一个形态的变化好，那我们接下来继续对于我们的图片呢。

其实我们还可以做一些其他的一个特征提取啊，这个特征提取呢我们就可以做一个嗯，关键点的一个检测，关键点呢其实是这样的啊，我们的一个关键点呢就如图所示啊，这个图可能有点密集恐惧症的这种感觉啊。

关键点就是说我们对于一个图片呢，它可能是存在一些比较关键的一个信息，这个信息呢，就是说我们是从可以从这个关键点的一个位置，来得到的，那么这个地方的关键点的一个位置呢。

就是如图我们的一个这个小圆圈的位置啊，这个有点密集恐惧症啊，对嗯我我我倒没有啊，如果各位同学有的话，可以稍微忍受一下啊，这个地方的一个关键点的一个位置呢，就是说我们的一个具体的一个操作呢。

我们其实是可以将具体将这些关，具体的一个位置给它提取出来，这些位置呢就是我们的一些关键的一个位置，那么有同学可能就会问到，老师这个关键的一个位置到底是什么位置，是比较关键的，这个呢就是这样的啊。

我们这个关键的位置呢，就是你可以理解，就是它其实是包含了比较多的一个边缘信息，就是它的一个颜色变化是比较丰富的，这些位置啊只是边缘位置，那么这个地方的边缘位置，我们如果把它嗯提取到之后。

我们把它识别出它的具体位置之后，我们能够做什么呢，我们其实是可以计算得到，用一个向量用来表征这个边缘，或者说这个关键点一个信息的这个地方呢，我们把它叫做一个关键点检测的一个，就是说具体的操作啊。

关键点检测我们对于图片而言，其实我们是拥有非常多的一些关键点检测的，一些嗯特征提取的方法，这个地方呢我们是有这个shift shift呢，其实是里面非常非常经典的一个关键点。

特征提取以及关键点的一些一个检测的方法，它可以很有效地提取我们的关键点信息，那么这个地方的shift呢，它还有一个非常重要的一个特性，就是说我们的一个图片，如果我们把这个图片旋转了。

那么这个关键点会不会发生改变呢，其实是不会的，也就是说一个图片，如果一个图片他这个关键点信息他是，经过旋转之后，这个图片旋转之后，这个关键点不会变化，他是不会变变化的，那么这个地方是关键点的一个。

这种方法的一个优点，他的一个优点啊，就是说你可能会感感觉到很惊奇啊，一个图片旋转之后，这个关键点为什么没有变化，因为这个地方的关键点它的一个提取方法，特征提取方法它不是说是很简单的嗯。

利用这种啊这个什么加减乘除啊，或者说这种计算，它其实是用到了这个尺度的一个信息，所以说它是跟我们的旋转，这种旋转的操作无关的，它是这种尺度不变的啊，就是说不管你是图片，它怎么进行缩放以及怎么进行旋转。

它的关键点一般是不做发生改变的，我们在这个地方呢，我们其实是可以将我们的一个具体的一个，关键点啊，把它做一个嗯匹配，这个匹配呢其实本质有点类似于这种含义啊，就是我们的一个具体的一个嗯操作呢。

我们就可以将我们的一个具体的一个语言，就是说这个地方我们其实是计算一下，两个关键点，它的一个具体是不是距离比较相等，具体距离是不是比较相等的，那么这个地方的距离是怎么计算的呢，这个地方的距离。

这个可能就稍微有点细节啊，我们每个关键点其实就是一个一乘，128的一个向量，这个地方我们的一个具体的一个关键点，他的一个信息就是一个1×128的，一个向量好，那么有了这个向量之后，我们能够做什么呢。

我们就是可以计算一下，我们的具体的一个关键点，他的一个相当于是他的一个具体的一个距离，对吧，我们第一张图片如果是由五五十个关键点，那么它本质就是一个，50×128的一个矩阵。

第二个图片如果是有50个关键点，那么它本质也是一个50×100，28的矩阵对吧，那么当然如果这个关键点的个数不一样，那么得到的一个矩阵的大小也不一样，在这个地方呢，我们其实本质是计算。

是需要计算一下我们的一个具体的一个关键点，他的一个相似度相似度对吧，那么如果这两个相似度它比较相似的话，那么我们就可以把它的一个具体的一个关键点，给它匹配上，然后匹配上对吧好。

那么这个地方我们的关键点匹配呢，就是将这些关键点从第一张图片里面找到，跟第二张图片里面的关键点的一个，具体的一个就是说距离啊，给大家计算一下它的距离，好这个地方我们可以看一下这两张图片。

这些关键点的一个位置，我们是能够匹配得到的啊，匹配成功的，也就是这些关键点，我们是认为它是能够匹配上的啊，能够匹配上的，那么这个地方我们会会发现，大部分的关键点其实是成功匹配的啊。

比如说这个角的位置对吧，这个角的位置，然后这个鞋子的位置对吧，那么这个地方其实有一些是匹配错误的，有些人匹配错误的，这个对吧，我们很明显的看到，这个相当于是有交叉的这种情况，他其实是匹配错误的。

那么这个地方匹配错误呢，他是为什么匹配错误呢，因为这个地方它其实本质在做匹配的时候，是做一个距离的计算，如果这个距离，就是说这两个关键点的距离是足够近的话，那么他其实就是匹配错误了，对吧好。

那么这是关键点一个信息，那么有同学可能就会问了，老师这个关键点信息他是全局的还是局部的，关键点的一个信息呢，其实它是一个局部信息，也就是说他其实本质是呃，描述了这个局部的图像，局部的一个特征。

它是描述的图像的局部特征，它跟这个颜色直方图不一样，颜色直方图是描述的图像的一个，全局的一个信息，好，图像的一个全局信息好，然后我们继续对于图片而言呢，其实我们还有比较关键的一个，就是我们的一个好。

我们看这个例子啊，我们的一个图片我们在经过缩放之后，其实他也是有成功匹配的一个关键点的啊，也是有成功匹配的关键点的好，对于我们的一个图片而言呢，其实还有一类比较关键的一个特征，就是我们的一个卷积特征。

卷积特征就是我们基于卷积神经网络，它提取的特征，这个呢可能就对吧，学习这个计算机视觉，你逃不过这个深度学习对吧，那么这个地方也是大致给大家讲一下啊，卷积神经网络呢我们刚才也给大家讲了。

其实本质就是由我们的卷积核，然后搭配我们的一个具体的一些层，然后完成一个计算的操作，那么这个地方呢其实在进行卷积的时候呢，卷积层其实本质是在做一个特征提取，本质是在做一个特征提取好。

那么我们的卷积神经网络呢，它其实本质也是一个就是说网络模型嘛，然后呢，他是经常可以用来做我们的一个分类的，分类的啊，就是说是一个有监督的一个分类，就是我们最终的分类的结果是一个类别，是一个类别。

那么这个地方其实如果是分类的话，那么我们的一个图片其实你会发现，其实它原默认的话也是一个维度降低的过程，也是一个维度降低的过程，首先我们输入的一个图片，假如说是64×64的，那么我们的输出的结果。

可能就是一个类别的一个概率的一个向量，类别的概率向量好，那么我们在做一个图片，做一个特征提取的时候呢，我们首先可以做一些相关的一个预处理，这个预处理呢，就是说在做一个图片的一个特征提取的时候。

首先呢预处理呢，我们是可以做一个图片的一个缩放，统一的一个缩放，这个缩放在做什么呢，也就是说，我们可以将图片把它缩放到一个，相同的一个尺寸，这个尺寸我们是把它缩放到一个512乘，512的一个尺寸。

在这个尺寸内，我们的一个图片它是相同维度的啊，就是所有的图片不管是任意大小小于512的，我们把它放大到512，大于五二的，我们把它缩小到五二，就是这样一个操作，然后呢我们缩放之后呢，就是这样。

这个操作是缩放啊，Reset，然后我们还做什么呢，我们还需要把它做一个归一化规划，就是我们需要把它转，从我们的一个具体的一个颜色的一个空间，把它转成我们的一个具体的一个像素空间。

或者说把它转成一个tensor的空间，在这个tensor的空间内呢，我们的一个图片，它的一个相当于是是在一个比较规整的，一个范围内，在一个零一的范围内，相当于是做一个min max的一个规划。

然后做一个NOMINIZE，这个罗MINIZE做什么呢，就是做一个减去均值，除除以方差的一个操作对吧，减去均值除以方差，这个地方的一个减去均值和除以方差，方差和均值从哪得到的。

这个方差和均值就是我们的原始的数据集，我们提取得到的一个数据集的一个平，均值和方差，这个地方我们有三个通道，分别是什么样什么样的一个含义呢，这个三个通道分别代表的是我们的三个通道的，一个均值和方差。

也就是我们有RGB3个通道对吧，然后分别统计三个通道的一个均值方差，我们按照这个通道的维度来做一个减去均值，除以方差的操作，好，这是PYTORCH来写的啊，然后他其实就是定义我们DATASET。

然后然后从我们的DATASESSION里面，定义我们的data loader好，然后呢，这个地方如果我们想要从我们的一个图片里面，提取特征呢，我们是非常建议从预训练的模型提取特征的。

这个地方就是说我们的一个提取得到的特征啊，其实他是希望尽可能有用的有效的对吧，那么这个特征呢应该尽可能的是呃有意义的，有意义的，那么这个特征呢它的一个提取方法，其实是跟我们的模型强相关的。

也就是说这个地方我们可以用一个预训练模型，Pretrain model，然后做一个预训练，这个地方的预训练呢，其实我们现在有非常多的一些预训练的，一些模型，我们直接可以拿来进行使用。

我们这个地方呢是用一个叫做RESONNET，18的一个网络模型，然后是它已经预训练好了，也就是说这个地方，它的一个网络结构已经定义好了，它的参数也定义好了，我们直接将它拿过来，然后提取一个特征就行了。

我们这个地方的提取特征呢，我们是呃只需要它提取特征啊，我们不需要它做一个分类的操作，也就是我们需要将它的一个最终的网络结构呢，剔除掉它的最终的全连接层，然后只让它提取我们的一个CN的特征好。

也就是说我们在这个地方将它的网络结构呢，稍微做了一点点修改，稍微做了一点点修改，然后接下来做一个提取特征，提取特征其实本质就是一个正向传播，对于我们的深度学习就是提取特征的操作啊，正向传播就是提取特征。

提取完特征之后，然后我们就可以对我们的图片，计算特征与特征之间的相似度，这个地方的特征与特征值之间的相似度呢，就是我们的图片在特征空间，如果这个图片在resident18提取完的特征。

它如果是一个维度是512的，那么我们就计算两个向量，512维度乘以512，就是一个向量是512，然后另一个向量也是512，然后计算这两个向量之间的相似度就行了，好这就是我们的一个图片特征提取。

图片特征提取，那么图提取完这个特征之后，其实本质这个计算你直接用这个dot，就是我们的一个内积距离就可以算它的相似度，算它的相似度了，好那么这就是我们的一个图片特征对吧。

我们有这个嗯图片的一个哈希值颜色直方图，关键点，以及我们的一个深度学习的特征，那么这个地方其实呃有同学可能就会想到，我们不同类型的特征，我们到底怎么进行选择呢，其实是这样的啊。

我们刚才也在PPT里面给大家讲了，我们的不同类型的一些特征呢，其实它的一个呃就是在做使用的时候呢，我们有图片哈，希值有颜色直方图，有这个shift的关键点对吧，还有CN它其实用途不一样，用途不一样。

图片哈，希值呢比较适合用在图片的一个驱虫的任务，就是说如果想要从百万，就是说从图片的数据库里面，找到我们的具体的一些相似的图片，相似的图片，那么我们用图片哈希值是比较适合的，是比较适合的。

那么我们的图片颜色直方图呢，如果我们想要从这图片里面找到，颜色比较相似的，颜色比较相似的，那么用颜色直方图比较好，那么shift的关键点呢，shift的关键点其实是这样的。

shift的关键点它比较适合用在局部相似，局部相似，这个局部相似，它就跟前面的这三种这三种不一样哈，希值颜色直方图以及CN都是全局，这个是局部，这个是局部，它其实是存在一个差异的。

存在差异的shift的关键点，它其实本质一个图片提取得到100个关键点，其实本质假如每个文件的维度是128位，如果每个关键点的一个维度是128位，那么它提取到的就是一个，100×128维的矩阵。

另一个图片如果是200个关键点，那么它基基本上提取得到的是，200×128位的矩阵对吧，所以说这个地方，其实本质我们得提取得到的一个特征呢，其实是不一样的啊，不一样的局部关键点。

其实本质就是提取得到的关键点信息，那么关键点信息它用在什么场场景呢，就是如果是用在版权检索，版权检测的一些任务上面，局部关键点是比较比较适合使用的好，那么这种卷积神经网络其实也是一种全局特征。

也是一种全局特征好，那么就看不同的一个应用场景啊，那么我们的今天给大家讲解的一个实践案例，就是呃对于图片分类呢，你可以用我们的一个TFIDF，提取我们的特征，然后用机器学习的模型完成一个建模。

如果是我们的一个具体的一个图片分类呢，你可以用嗯CNN搭建我们的一个网络模型，然后对我们的一个图片进行一个建模，然后呢我们也给大家讲解了一下，图片提取特征和文本提取特征的，两个进阶的notebook。

如果各位同学感兴趣啊，你可以下去将这两个进阶的LOTUBOOK进行，好好看一看，然后呢我们这节课其实是给大家嗯，就是说过了一遍图片和文本，我们在进行操作的时候，我们如何提取特征啊。

以及这这两个领域它的一个具体的一些关键点，需要注意的是，就是我们不同类型的数据呢，我们需要不同的处理方法，并没有绝对的一个银弹，就是说所有的数据啊，我们都是用相同的一个操作来做处理的。

并不会存在这样的一个，完完全全的一个通用的方法，其次呢我们的不同类型的数据呢，其实我们的建模方法也不一样对吧，我们刚才很清楚的给大家看到不同的数据，我们的建建模具体的模型也不一样。

那么我们的一个这个到底用什么模型呢，我们遇到一个数据到底用什么模型呢，这个就是我们需要就是说学习的，也是我们的一个领域知识，就是对于我们的一个呃算法工程师，其实本质就是在我们的一个得到。

我们的一个数据的情况下，我们如何去构建一个模型，这个模型是需要嗯跟我们的一个呃，就是额数据完全匹配上，然后能够更得到我们的一个具体建模结果的，这个其实就是算法工程师的一个核心能力啊，就是拿到一个数据。

我们能不能就是说进行一个解决，第三个呢，就是说ALP和CV都是非常好的一个应用方向啊，然后再做一个具体应用的时候呢，嗯你可以选择你你自己想要的一个，就是说领域啊想要的一个领域，然后进行一个实现呃。

你会发现呢我们具体的一个网络模型呢，它在进行实现的时候，可能在网络模型的一个角度啊会存在一个差异，但是呢我们在嗯机器学习的一些基础上面，其实是相通的，也就是说虽然说这不同的数据。

我们得到的一个模型不一样，但是呢我们的一些比较基础的知识都是相通的，比如我们的模型，我们如何划分训练集和验证集，我们的模型如何判断它是不是一个过滤盒的，这些知识都是我们在机器学习的一个基础的。

一些理论步骤给大家讲的，这些都是相通的，也就是说模型不同，但是这些基础都是相通的，这些基础就是相通的，这些基础的一些理论知识都是相通的，而且是跟我们的结构化的数据是也是一样的啊，也是一样的。

好那么以上呢就是我们这节课的一个内容嗯，同学们有什么问题吗，如果有问题的话呢，可以提出来好不好对。

呃我们的手机用户906同学，以及我们的clock同学有没有问题啊，对嗯通过这节课，希望两位同学以及我们的看录播的同学，能够把嗯CV和NLP啊做一个基础的入门对，然后这些库啊都是一些积累啊，比如SKN啊。

以及这个KOS啊，以及呃这个PYOR器啊，对你可以先去了解啊这些库的一些技术使用，特别是我们的LP入门，这个notebook和CV入门，这两个notebook啊是一定要掌握的。

然后还有这个图片特征和文本特征，这两个都是不可能，是可能稍微有有一点点的难度，你可以优先去学习一下CV入门这个逻辑，book和LP入门入门这两个逻辑不，呃两位同学有问题吗。

对我们待会呢会把这个look tebook呢，上传到我们的一个QQ群啊，我们的代码具体上传到我们的QQ群，有问题吗，同学们，我之前遇到过数模型，好像不支持binary的一个特征，是我操作有误吗。

呃这个地方嗯应该是你操作有误，数模型是支持的，就是数模型肯定是支持这种数值的一个输入的，他肯定是支持的，应该是你操作有误啊，你可以你待会拿着我们的一个代码，你再跑一下好不，好还有问题吗。

好那么如果没有问题，我们今天的一个直播就到此结束，好不好，然后大家如果还有问题呢，也可以在我们的一个QQ群里面进行提问，我在稍等，稍等大家一分钟啊，看大家还有没有问题，好。

那么我们今天的直播就到此结束啦，好的谢谢大家啊。

【七月在线】机器学习就业训练营16期 - P13：在线视频：4-基于SQL的机器学习流程和实践_ev - IT自学网100 - BV1Z9T5ewEKL

嗯哦行行好，那我们就稍等一会了，就开始，大家之前学习过circle吗，有学习过，有之前已经学习过，有基础对circle有基础的同学吗，有没有同学，我看群里面已经有有同学在问circle的。

其实嗯如果大家之前对SQL有一定基础的，可能这节课会稍微好一点，学过啊，哦那好看来还是有同学学过的，大家对我们之前的课程有问题吗，或者说有什么问题吗，我们其实我们每次留给大家一个实训的一个。

这就是说作业并不是特别难，主要是考虑到有些同学他的基础啊不太好对，如果大家觉得实训太简单了，也可以在群里面艾特我，然后我也会给一些更加深入的一些资料，给到大家，那么有没有同学之前学过spark的。

或者说学过大数据相关的，应该是有应该有同学学过，嗯好我们再看嗯，我们再等12分钟，因为还有同学没进来，只知道大数据的概念好，那么我们今天就是给大家介绍一下啊，这这些特别是spark的。

那么我们就开始我们今天的内容啊，我们今天内容呢是基于circle的一个，机器学习流程，那么我们在之前的课程呢，其实都是讲解Python环境下的一个机器学习流程，但是呢其实circle也是非常重要的概念。

非常重要的概念啊，就是说其实也是呃很重要的，那么我们今天的一个课程内容呢，其实偏向于具体的一些案例和工具的一个语法。

语法讲解，我们呢今天的一个就是说课表是课程呢，就是第一个是circle的一个基础和大数据开发，我们在会在这一部分呢，讲解SQL的一个基础和大数据开发这个岗位嗯。

第二部分呢我们会讲解spark的一个介绍和使用啊，第三部分呢我们会讲解spark socl的使用案例，第四部分呢我们会看这个spark的机器学习的案例，好的，那么我们就开始我们今天的一个内容啊。

首先呢是第一部分，我们的一个SQL与大数据开发，那么SQL呢可能之前大家已经学习过一点，我们就简单介绍一下circle呢，它是用于访问我们数据库的标准的计算机语言。

它能够完成我们的数据插入查询更新和删除，而且能够完成所有的跟数据库相关的控制，那么呢我们现在的一些常见的一些数据库软件，比如说MYSQL这个server或者说oracle他们的一个交互呢。

都是说是SQL语言的，所以说大家在学习数据库的时候呢，其实也是就是说学习这个SQL的语法，那么SQL呢有同学在群里问了，说是不是我们这个消防工程知识，或者说是不是大家需要掌握的，其实是这样的。

SQL呢是其实可以视为一个额，就是说计算机的一个基础，因为数据库也是，基本上所有的计算机专业的同学呢都会学，所以说呢也是需要大家掌握的，也是我们大数据开发的一个必备的技能。

那么这个图呢就画的是我们的所有的编程语言，其实呢它的一个交互呢，都是通过一个circle的一个语言对吧，我们这个在这个地方的HTTP，通过我们的HTTP发送，我们的具体SQL语言跟我们的啊。

再通过我们的circle的一个软件，再跟我们具体的一个数据库进行交互，那么这个呢就是说我们其实每一种，我其实说这个circle的一个语言呢，它其实是独立于所有的编程语言，它其实是跟数据库强强相关的啊。

强相关的，那么这个地方呢就是说呃我们嗯还是建议大家，如果之前没有学习过SQL的，是需要学一下，它是对所有数据库管理的一个语言，而且SQL并不是很难嗯，就是说它是非常简单易懂，学习成本低的数据库呢。

我们对吧，如果大家是转行的，我稍微介绍一下，数据库是用来查管理和查询数据的，一个关系系统，那么常见的关系型数据库呢有mysql sex server，那么还有一些非关系型的数据库。

那么数据库呢可以用来帮助我们，很简单的进行一个数据的一个插入修改查询，而且呢数据库的一个存储结构是非常稳定的，能够保证我们的数据进行一个有效的存储，数据库呢它还是这种它是多用户的啊。

就是说我们那个用户的权限是隔离的，是可以支持并发操作的，而且数据库是可以支持回滚和保持时间的，原则性啊，呃这个地方呢，就是说我们呃，如果大家就是对数据库没有一一定的了解啊，可以稍微就是说记一下。

就是说数据库其实我们它是现有的，有生活中我们一般的嗯这种订单啊，密码，用户密码，或者说嗯这种比较重要的一些信息啊，都是存在数据库里面的，那么我们有在前面的课程呢，其实已经讲解了pandas对吧。

其实在或多或少用到了pandas，那么有同学说老师这个地方呢啊，ANDAS和我们的circle其实是不是一样的，其实不不能说完全不同啊，他们其实是有很多相似之处，那我们pandas的一个本质操作呢。

和circle的一个操作其实是相同的，只是一有就是说有一个具体的一个实现，是就是说不同的，比如说我们的pandas可以完成数据筛选，pandas as可以完成数据展示。

pandas as可以做一个数据删除，那么pandas也可以做数据的分组聚合，分组统计也可以做多表聚合对吧，这也是我在我们的pandas里面都可以用的，那么circle能不能用这些呢。

其实circle也可以完成这么多对吧，额那么有同学说SQL只知道增删改查，不知道实际工作中怎么用的啊，我举一个例子，就是大家嗯就是说嗯举一个很简单的例子啊，就是电商电商。

你就是说最开始我们在登录这个账号的时候，他会做一个校验对吧，我们的用户名和这个密码进行校验对吧，一般情况下呢，就是说这些公司呢他会把这个用户名对吧，相当于是大家登登录的账号和具体的密码。

密码可能是加密后之后的啊，把它存在数据库里面，然后呢通过这个数据库对吧，我们能查询出来这个用户的一个用户名和密码，是不是匹配的对吧，这就是说是根据查询来找到，就是说具体具体的逻辑。

那么在电商里面还可以这样做，就是说我们统计这个用户，他这一个月来或者这一年来，这个所有的订单的一个总金额，就开销总金额对吧，大家的支付宝账单对吧，呃年度支付宝账单，年度京东账单对吧。

其实他也是用到数据库的，就是说select，就是说查询我们2020年的这一年度的，所有的订单的一个消费的金额对吧，所以说呢呃circle，如果大家只知道这个具体的一个增删改查。

其实只知道就是说基本上知道这个语法，但是呢其实在我们的实际过程，实际业务中呢，其实就是说它存在一个从业务的一个逻辑，到我们实际数据查询的逻辑的一个落差，这是有一个落差的啊。

那么我们其实作为一个程序员对吧，程序员其实嗯有人说他是一个circle boy，circle boy就是天天写circle的人，那么circle boy，就是说，我们其实很多时候都是在做数据的一个查询。

那么这个查询就是说我们要理解程序员，理解理解这个产品经理的需求，然后把这个具体查查询的逻辑呢，用SQL的语法来完成，就说实现出来，那么我们首先来看一看pandas，as和这个SQL的一个语法的区别。

那么右边这个啊在SQL里面呢，这个它的一个具体的就说，我们用用逗号来分隔我们的列来进行选择，比如说我们用心呢表示的是选择我们所有的脸，那我们来看这个语法啊。

Snack total betips tip smoker time，这是呢四列我们选择的四列，然后呢from tips，这是我们的表明表明，然后limit5。

就是说我们只要就是说从这个tips表格里面，选择这四列，然后只选，就是说只展示前面五行好，这是circle的一个写法，那么在pandas里面是怎么样的，pandas就是说tips选择我们这个四点啊。

它是用于我们的一个索引的方法，索引出来之后呢，然后head5他是这样的啊，他是这样的，那么这样呢，就是说其实pandas本质和circle实现是差不多的，本质就是说实现跟SQL实现差不多的。

而且这些语法上其实都是很相似的，那么我们再来看一看，其实有同学说老师我为什么要学习SQL，其实是这样的，Circle，第一个是这个基础的一个技能，第二个呢其实在很多的一些面试里面。

非就是经常会会被问到啊，就是面试题，不管是当面试题还是当一个技能，很很可能会问到，而且呢我们的大公司，一般的这种就是说互联网的一些公司呢，他们招的算法工程师，并不是说纯的Python环境下的。

他很有可能就是说是一个具体的一个呃，就是说就是大数据平台下面，这个是很正常的，据我了解就是说叫阿里，阿里基本上就是说他们的开发，基本上都是写circle的，没有没没有环境给你写Python。

没有环境给你写牌子，就是说在大公司里面，单机的开发其实是很少的，就单机可能就只是用用来训练很小的模型，很小很小，一般情况下，就是要不就是在我们的一些大数据平台上，写SQL的语法，然后再做一个具体部署。

所以说大家去找一些上网工程师的岗位啊，你去看这些招聘简历，其实很多都是要求这个大数据开发，不管是spark flink等等相关的一些大数据工具啊，这是很现实的，那么大数据开发呢。

我这个地方列举的就是它有三类岗位啊，第一个是大数据开发的一个平台和管理，这个呢主要是数据仓库的工程师，比如说数据运维储藏工程师，那么第二个呢就是大数据平台的一个数据分析，挖掘，机器学习等相关技能。

这个呢可能是大家比较感兴趣或者想应聘的，就是说是这个数据开发工程师，那么这个呢其实也是在大公司里面，又可以称为叫做算法工程师，第三个呢就是大数据分析的一个结果及展示啊，这个呢主要是一个数据分析式的。

那么我们还是希望大家能够关注一下，第二个技能，第二个方向啊，就是大数据平台下面的一个，机器学习和数据应用的技能对，那么其实呢就是说大大部分的大公司啊，特别是bat级别的大公司。

或者说额就是拥有海量数据的一个大公司，其实他们的一个上网工程师，也是数据开发工程师，那么circle的技能和spark的技能也是需要掌握的，那么就是说大基本上大数据开发。

它的一个整体的一个薪资也是偏高的啊，比这个软开是高一些的。

那么在我们进行具体讲解spark之前呢，我们首首先带着大家稍微稍微熟悉一下，我们的一个circle的一个和PENAS的一个。

具体的一个对比，那么我们来看一看啊，circle呢，其实我非常建议大家，基本上花一天的时间就可以把它完整的学习完，就是SQL它用到的一些语语法基本上很简单啊，基本上很简单。

就是说基基本上就是一些简单的名词，简单的名词呃，就是说大家可以按根据这个教程，基本上刷一遍就行了，刷一遍你就可以把大致能记住啊。

基本上一天就能刷一遍，一天一天就能刷一遍，那么我们就看一看circle。

它和pandas as对吧，pandas大家都熟悉，那么我们看一看circle和pandas as，它具体的一个对比对吧好，那么额我们如果把这个数据集对吧，这是这个就是说我们方块。

这个是在IPYTHON环境下的，那么我们看一看这个pi Python环境下的一个数据集，其实它读取完成这个pandas之后，就是个data frame对吧，那么我们再来看一看呢，具体的对比。

其实我们刚才也对比了对吧，这是select，这是circle select，这是pandas的一个数据选择，circle的一个语法，就是说我从里面选择什么列，从，然后具体的表格是什么。

然后最终那个显示的一个结果是什么，这是很简单的，就是说select from limit，然后呢如果我们想要加逻辑筛选，其实也是可以加的，在SQL里面都是可以加的。

select新新式表示我们筛选所有的列，From tips，where time等于dealer，就是说我们从这个tips表格里面筛选得到time，等于dinner的行，然后呢我们只选择前面五行。

那么在pandas里面是这样写的，这个是我们的一个逻辑对吧，这是我们的筛选的逻辑，然后这个tips是我们表格，然后进行索引，然后head5大家可以看到就是说这个circle，它这个这个最终的一个展示。

其实它也是在最后来进行的，就是说limit最终进最后进行的对，那么a circle呢它这个语法也可以完成多个啊，就是说逻辑的操作，比如说time等于jinner and tip等于大于五。

就是说我用两列来完成筛选，一个time等于deer n n的T不大于五，这是两列来进行逻辑筛选，好我们往下翻，那么哦circle呢，其实也是可以支持数据的一个什么空值查询的，这也是可以的，这也是可以的。

那么SQL也可以做一个分组聚合，那么这个地方是需要注意的，就是说而我们的一个分组聚合，其实grop by对吧，那么它的一个操作逻辑，其实就是说把我们的数据集进行分组。

然后八就是说统计每个组里面的一个平均值，或者说求和，那么在circle里面它也叫GRPB对吧，其实这个地方你看到，其实在circle里面的很多的一些单词，和我们在一个呃pandas里面。

用的这些单词都是一样的，只不过它就是一个具体的语法不一样，那么在这个地方其实它的一个就是说操作，但是他这个语法有点有点不一样，我们来看一看啊，我们对tips这个表group by sex。

按照这个sex这一列来分组统计，分每个分组下面的一个大小好，他是这样写的，那么我们看一看circle select sex，逗号count新tips from tips group basics。

那么这个地方大家可可能看着就有点迷糊，这个操作的就是说这个到底是什么含义，我们其实在大家我们前前面这个地方，网上最最上面啊，嗯我们这个地方select新，就是表示的是我们选择所有的列出来对吧。

那么我们假如说想要选择我们想要的列，那么我们就就是说把这个想要的列名，把它写出来，那么在这个地方我们的group by对吧，那么这个地方是什么含义呢，第一列是我们的sex，就是我们的分组的取值。

第二个能力就是count型，count性就是说我们分组之后，它每个分组下面的一个取值的一个个数，是这样的啊，就是所有，所以呢在这个地方它的一个呃，每列的一个就是说计算得到的逻辑呢。

可能还跟我们的group by跟跟他有关系好，那么我们的一个额就是说呃GRPBG呢，我们分组之后呢，还可以统计这些，具体的就说我们group by smoker grp bad day这两列。

然后统计它这两列对吧，其实你可以看到如果把它们做group ban，其实他就是当我们的一个音，在pandas里面加一个index对吧，通过这个index来进行一个分组聚合，那么就是写这是一个独立的。

就是它是一个独立的，然后后面的呢就是说是这个分组里面的，聚合的情况对，那么这就是说select，按照我们smoker和day这两这两列，对其他的值进行一个分组聚合做统计好。

那么呃呃就是说呃在circle里面呢，还可以做这种聚合，我们假如说用这个呃pandas做句号，那就是merge对吧，我把这个第一个表和第二个表，用这个key这一键用K这一列来做一个呃，就是说内内联聚合。

那么我们就是说在这个circle里面怎么写呢，Select 7from d f d f1，Inner join def2，然后on这个呢就是说设置，我们具体的就是说它的聚合的一个呃。

就是嗯它的一个就是列名它怎么相等的，这个地方呢，就是说我们相当于是嗯简写了，就相当于是DF1的额，第一个表格的key和第二个表格的key是相等的啊，既然是缩写的，那么当然我们也可以就是说做复杂的。

比如说我们到底是左边连接还是右边连接，还是呃就是说外连接，都是可以用这个SQL来进行实现的好，那么大家呃课后呢，可以把这个基本上你你可以把这个Python的一个。

pandas的语法和这个SQL的语法大致你对比一下，你就知道其实呃circle和pandas有很多，基本上pandas就是用这个一个函数来实现，circle的一一个语句，那么呃有同学可能会问到老师。

这个circle和这个具体pandas，它到底有什么呃区别呢，或者说SQL在具体的一个场景它到底是什么呢，就是pandas啊，我们现在大家学习的这个pandas。

我们在切到PPT，其实说我们学习到的这个pandas呢。

其实大部分都是一个单机开发，那么circle呢它可能是涉及到了一个多机开发，就是说有可能是分布式的啊，我们的一些数据库呢它是支持分布式的，那么而且是支持支持这种远程连接的，也就是也就是说。

我们可以把一个circle的一个语句，就是我们数据库部部署在远端，然后我们在客户端查这个，用这个SQL语句去连接数据库，那么pandas其实对吧，我们其实它是默认不支持这些操作的。

而且SQL它是比较安全的，比较安全的好，那么我们就来开始我们的一个spark，那么首先呢需要注意的是啊，就是spark可能大家学习起来是有点困难的，spark呢我们首先给大家进行一个简单的介绍。

是spark它是大数据的一个，就是说啊，就是说现在比较流行的大数据的计算框架，斯spark呢它是我们的加州伯克利大学啊，伯克利是大家应该也知道，就是嗯美国呃，美国的一个非常出名的。

非常牛逼的一个计算机的学校，然后呢，他是嗯基于这个内存的一个并行计算框架，那么spark它的一个优点主要有以下几点啊，它的一个运行速度是非常快的，由于它是基于内存的啊，它的一个速度呢。

基本上是哈杜普的一个十倍以上，sparkle呢它的一个易用性比较好，它支持的语言有SCALA，有java有Python有R就是说我们用多种语言都可以，就说调用spark这个引擎都是可以的。

而且spark它的一个生态比较完善，就是说它可以支持spark circle，spark streaming这种牛式的一个计算，你可以支持这种我们的spark的机器学习库ml lib。

或者说spark的一个graph x就是我们的呃，就是说图的一个机嗯，机器学习的库，这都是可以支持的，i e spark呢它可以支持，就是说数据来源有很多，我们可以从CSV里面读取。

也可以从我们的一个呃，呃就是说MYSQL或者说从have里面读取数据呃，这是非常非常方便的，那么如果大家之前没有学过18，可能稍微给大家解释一下，就说呃我们spark其实是这种第二代的一个。

就是说计算框架了，第三代应该是FLINK的呃，spark它的一个操作是把中间数据放在内存里面，效率会更高，那么spark它底层的一个实现呢，其实还是跟参考的好多部分参考好多好都不。

那么斯spark他的一个就是说，他怎么就是说他这里面就有可能会涉及，涉及到一些面试题，那么就是说spark和哈德夫的对比，那么斯spark它就是第一个，它的一个计算呢是把中间数据放在内存里面。

效率会更高，第二个呢就是spark它这个容错性更好，它是引入了这种RDD的一个概念，那么第三个呢就是spark它的一个操作会更多，而是支持这种复杂的操作函数，比如说map filter，Flat。

map嗯，Grp key group group by，然后union join thought，这种就是说spark这些操作都是可以支持的，那么在HODP里面呢。

可能你要自己写这种map reduce来完成好，那么我们这是它的一个对比啊，这个可能就是说嗯，是需要大家下去看一下一些具体的资料，那么spark它的一个适用的场景是什么呢。

spark它是适用于复杂这个地方，我们先把这个具体的一个概念，给大家快速的过完啊，然后看一些基础的操作，spark呢是支持三种场景，比较正支持三种场景，第一个呢是负担的一个批处理，就是说时间跨度比较长。

就是通常是呃就是数10分钟到几个小时，这种是离线的一个查询，离线的一个处理，那么这种呢，一般在我们做这个数据报表的情况情况下呢，是非常非常常见的，自spark呢还支持这种基于历史数据的交互的查询。

就是说它可以spark是支持这种，像IPATHON那种运行环境一样，就是跟Python环境下这种可交互的一种这种查询啊，这也是支持的，那么它的一个时间呢，通常是在这个呃十秒到数10分钟之间。

spark呢还支持这种流流式的一个数据处理，流式数据处理，就是说我们的数据它有可能是源源不断的来的，就说我们的数据集它有可能是源源不断来的，那么我们也可以根据这个流失的数据处理，来进行一个具体的操作。

那么这个呢可能spark它是用这个spark streaming的一个，操作来做做的啊，这个速度呢有可能是呃，就是说从几百毫秒到数秒之间，那么呃这个呢，就是说我们现在在大公司里面用到的呢。

嗯主要是第一种和第三种比较多，第一种主要是这种离线任务，那么spark的第三种场景呢，就是说这种实时的任务，那么有同学可能不太理解我们的第三种，这种数据流失的任务啊，我给大家举个例子。

就是我们的一些用户他的一个购买行为，比如说我们在这个淘宝上的一个额用户，点击用户点击对吧，基本上大家可以体验一下，就是我点击了某个商品之后，基本上10分钟以内，或者说几秒钟以内。

我再打开另一个商品的时候，其实他已经马上就给我推荐相似的商品对吧，那么这个呢其实它背后也肯定会用到这种spark的，流失的数据处理的操作啊，就是说流失呢就是说我们的数据流，这个数据呢它是源源不断的来的。

就相当于我们这个淘宝的用户行为数据，它的训练就是说他那个测预测集呢，或者说这个用户的行为是源源不断来的，不是说我们只把这个数据集导成这个CSV文件，然后进行预测，不是这样的啊，就是说它是源源不断来的。

这个呢现在也是有很大的应用场景啊，现在第三代的这个呃大数据与框架就是FLINK啊，也是基于这种流失的一个处理，那么需要注意的是就是spark的这种流式处理呢，基本上也是基于B期处理的。

也基于批量的一个处理的，那么spark呢我们再看一看啊，把这页PPT讲完，我们就看一看它的一个代码，spark呢它有就是说我们现在一般情况下呢，说的是他的一个比较建议学习，他的一个就是2。0的版本。

就是比较高的版本啊，那么这个地方呢就需要注意的一个点，就是我们的一些概念呃，那么spark呢从2。0就是说或者更高的版本呢，就是支持这个叫spark session的一个嗯操作。

spark session呢它是呃就是说是各种不同，就是说context这个组合，那么通过spark session呢，我们可以就是说操作以下的啊，比如说创建和操作RDD的。

我们如果原始的呢是用这个spark spark context，那么我们用spark session也可以操作啊，比如说我们操作1streaming的，或者说我们操使用circle的。

或者使用have的啊，这些呢我们都是可以从spark session里面进行一，一起操作啊，一起来操作，那么这个spark session呢它怎么进行一个，就是说呃一个定义呢，就是说我们直接把。

如果把这个这个下面的代码是这个py s spark啊，就是Python就是spark的Python接口啊，那么我们如果把这个spark给它安装好了之后。

我们直接从这个那这个语法里面from py s spark，The circle，Import sps，Sparks session，或者说你创建了一个PYSPARK的一个环境呢。

它会默认就是说引入这个spark session啊，那么通过这个spark session呢，我们可以构建我们的具体的一个嗯，就是说这个具体的一个实例环境，你怎么构建的呢。

smc session点BDERBEARDER，就相当于是我把它创建一个环境，然后我们设置一下我们这个环境的一个app name，以及我们的一个CONFIG，CONFIG呢，就是这个app name呢。

是我们这个相当于是这个app的一个名字啊，你这个应用程序的名字，然后呢我们就是说具体做一些配置，比如说这个地方是，其实是一个KV的一个配置啊，然后呢go or create相当于是创建一个好。

那么我们来实践一下啊。

来实践一下，我们再切一下屏幕，好拖上去了啊，呃大家看一看我这个地方我有一个notebook啊，这个notebook呢我们其实我已经在我这个本地环境，已经把他的一个呃就是说spark环境给它安装好了。

大家如果自己安装了，直接是呃就是说应该是这个呃，就是派app in install e呃，install e spark就行了啊，如果他在安，就是说安装等你安装之后呢，遇到什么问题呢。

可以就是说咨询一下注销，或者说网上查一下，都有一些解决方案好，那么我们这个地方呢，spark session它到底是它的的功能是什么呢，我们在PPT里面给大家讲了，spark session呢。

基本上就是说我们上，就是说他能够操作很多事情对吧，比如说我们的一个have查询RDD的，或者说streaming的都可以做，那么我们在创建它之后怎么创建呢，我们上面讲解的代码对吧。

然后这个呢就是创建了我们的一个具体的一个，呃就是说呃spark session，然后呢我们当然这个spark session呢我们创建之后呢，也可以就是说用我们这个原生的一个spark context。

这个呢就是说我们先操作啊，先实操，那么我这个呢就是创建一下啊，比如说我们把这个代码运行一下，他这个第一步可能还稍微有点慢啊，三秒钟三秒钟创建完成之后呢。

我们接下来需要注意的一需要讲一个点的，叫一个RDD，RDD呢，我们其实是我们spark里面非常重要的一个概念啊，但是呢它是偏概念的啊，我首先就是说给大家把这个讲清楚，RDD呢是spark里面基础的一个。

基于内存的一个操作啊，基于内存的操作，那么呃就是说我们如果大家之前没有学过，这个RDD呢，可能第一次接触是稍微有点复杂，稍微有点复杂的，那么RDD呢，也是这个spark里面的一个核心的一个特性啊。

核心的特性特性，那么这个RDD，你就是说，其实它它其实基本上，就是把我们的一些基础的操作，或者说数据转换的操作，我称为RGD，然后呢spark他还把这些具体的操作呢，用一个叫DV啊。

这个DAG就是说是一个有效无环图的，这个操作呢，把一些RDD把它那个就是说串起来了，比如说我们从一个数据，把它从最开始的创建到筛选到map到这个呃，就是说具体的操作，然后到最终的把它做聚合等等等。

等到再到最终的我们的最终的数据，就是说我们从最开始的数据，到我们的最终的数据，其实我们的代码，其实就是说这些变量的一个变化，我们或者说这些操作，我们可以把它构建得到一个有向无环图吧对吧。

那么我们这个数据它应该是没有环的，如果有环，那就有问题了对吧，有环境有问题了，那么这个通过这个呃，这种就是说我们的这种嗯DAG呢，其实能把我们的一个数据的操作呢，把它进行一个串联起来。

那么我们的spark呢，会根据我们的这个RDD的一个他的一个操作，能来把我们这个具体的一个哦，就是我们的操作在我们内存里面进行优化，而且呢它会告诉我们的具体的数据，怎么进行分片，怎么进行优化。

那么这个地方呢，我们大家再回过头来这个地方看这个叫spark session，swag session呢，其实大家之后如果学习这个TENSORFLOW。

那么你就会发现TENSORFLOW里面也有叫session in pin，那么这个地方这个地方我们通过第一句。

可以把这些数据把它串联起来之后，有什么优点呢，那么这个第一个优点就是说，我我这个可以一起来进行优化我们的一个流程，而且呢假如说我们的流程啊，就是说他有这种跳接，或者说中间有这种嗯。

就是说我们的可以优化的点啊。

我们的模型可以帮我们来进行优化的，那么哦我们就是说这个IDD怎么进行创建呢，其实在这个spark里面它都可以帮我们创，就是说直接写这个函数就行了啊。

比如说我们这个地方用我们这个地方创建的spark。

Context，然后创建我们的一个range，一个14，这个14呢就相当于是我们创建一个额，0~13的一个列表，然后呢我们让他分组啊，相当于是分成四片。

然后我们这个地方呢我们它RED呢就叫partition，partition呢相当于是一个分片的概念，然后呢我们就可以直接得到这样的一个呃，就是说一个RDD，那么这样一个数据呢，其实在spark里面呢。

我们还直接对它进行操作就行了，这个地方我们比如说把这个原始的数据，从0~13的对吧，我们想让它进行一个平方，进行一个平方，然后就是说从零对吧，零的平方，零一的平方，一二的平方，二三的平方三。

那么一直到13的平方169，那么需要注意的是，就是说这个这个操作到这，并不是说我们一下就计算了，并不是说一下就计算的，它是就是说我们的spark其实是一个lazy的，就是相当于是一个懒加载的一个概念。

或者说它并不是说我们这一行就直接计算的，它是到最终我们假如说你的result有康有收集，或者说显示的得到我们的一个结果的时候，他才会把我们的这个操作所执行。

也就是说，我们在定义我们这些RDD的一个流程之后呢，这个DAG并不是说马上就把，我就是说完成这个计算，它会根据我们记得到的这个有向有向无环图呢，来进行一个得到我们的一个额。

就是说这个计算逻辑，然后并不是说马上计算的啊，就是有可能就是说到你需要进行计算的时候，才进行计算好，这是一个RDD的操作，待会我们也会演示更多的操作啊，演示更多的操作。

那么我们再来回到我们的一个PPT啊，这个这节课呢主要的是一个实操。

我们再回到PPT，那么我们刚才讲的这个RDD这个概念呢，它其实就是对于我们spark的最底层的一个，内存的一个封装，那么呃有可能有同学说老师这个地方嗯，我们假如说学习rd d。

还需不需要学习一些其他的一些东西，其实在spark里面啊，就是说我们现在你如果想要学的比较底层，或者说比较深入呢，那么RDD是需要的是需要的，那么我们在学习spark这种circle的时候呢。

其实嗯还是比较常见的，就是直接这种data frame，data frame呢其实在spark里面呢，它也是这种表格形式的啊，表格形式的，那么嗯表格就是一个二维的数据表，二维的数据表，那么二维的数据表。

它本身提供的，我们每一列带有一个单独的名称，和具体的一个类型，那么这个地方呢，就是说我们就相当于是我们创建了一个表格啊，得到一个表格，那么这个地方我们就多了一个信息，叫一个schema信息。

这个schema呢你可以理解，就是我们这个列名的名称和具体类型，这具体类型，这个呢有同学可能之前就就觉得，这个data frame和我们的一个列表就没什么关系，其实很有关系啊，大家可以设想一下。

我们在使用pandas的时候，其实这data frame它的每一列都是有一个类型的，d tab d tape对吧，所以说我们的一个data frame呢，其实是我们所有的表格的每一列。

它的一个取值或者它的类型都是固定的啊，固定的，那么呢我们的，但是呢data frame，它底层其实是用RDD为基础的一个呃，进行操作的，而且data frame底层的一个操作其实是基于啊。

data frame的底层操作其实是基于RDD啊，那么其实是对RDD进行一个封装的，那么这是我们的一个data frame和rd d，那么我们就开始我们的具体的一个实操啊。

具体的实操，那么就跟着我们的一个notebook啊。

这个notebook我们待会儿课后就会分享给大家，那么呃在我们的一个呃RDD的操作的时候呢，其实很多就是你直接这个呢就是直接是P嗯，这个嗯就是说spark的一个语法了，py s spark的语法。

比如说我们想得到这个RDD这个呃data的，它的一个所有的一个取值，这个地方呢，如果你如果啊我给大家执行一下，我执行的这样一行啊，好，我在执行这个rd d，大家可以看一下，他其实并没有。

直接把我们的一个数据给展示出来，这个地方它只就是说只是展示了我们的RCD，一个具体的一个信息对吧，具体信息，那么你如果想要把它一个取值给它取出来，其实就是RDD点connect i d d的可能。

那么这样呢才是把我们的所有的一个取值给他，数据给他取出来，那么如果我们想要把我们的一个这个数据的，一个首个的元素来取出来，那么我们就是说first first，如果我们想要取这个头部的五个，头部的五个。

那么我们就take5，那么我们如果你想要取值，这个相当于是最大的三个对吧，那么我们就top top3，当然你如果想要就是说把我们的一个呃，就是说take order，就是说用一个某一个次序来进行一个取。

比如说我们把它进行一个拉姆达变换，然后再做一个降序的一个取值，这也是可以的对，然后呢，这个IDD不仅仅是支持这些基础的操作，还可以支持这种，就是说这个IDD还可以做一些统计，比如说我们做一个基础的统计。

就是说STATES对吧，比如说统计这个数据里面有多少个count，就是总共取值的个数，它的平均值方差最大最小，这个其实就是我们在pandas里面的一个，describe函数对吧。

那么比如说这个下面我们的count sumin对吧，这些都是跟我们的差不多的，跟我们的Python的语法差不多的对吧，然后呢我们假如说RDD想就是说取这种啊，就是说分桶或者分组吧对吧，这也是可以的。

这也是可以的好，那么RDD呢，其实它创建呢就是说我们创建，就是说直接从这个是Python的一个list对吧，我们就是说用它啊，这个嗯spark的一个context的一个PANONIZE。

就是从这个list把它转成一个RDD，那么RDD呢其实它可以作证，我们上面这个地方讲解的是RDD，它一个具体的一个呃，就是说统计操作，那么RED，其实它也可以做这种逻辑的一个筛选，那么怎么做呢。

比如说我们这个地方创建的一个list是额，这个data是从1~5对吧，那么我们首先对这个RDD做一个map map呢，就是说我们让他就是乘二，就是说这个地方原始12345就变成了二四，六八十对吧。

那么我们把它作为一个转换之后，乘二之后呢，我们再做一个筛选，筛选呢，我们就是用匿名的一个函数，那么达嗯，如果看这个，就是看这个元素是不是大于五的对吧，然后我们数据它大于五的对吧。

好我们看一看就是说他是六八十对吧，那么当然这个就是spark呢，这个RDD其实也是支持，就是我们的一个字符串啊，字符串也是可以的，那么如果你是字符串呢，其实上面讲解的有一些函数。

它就有可能是就是说不能执行的，因为字符串其实没办法统计一些嗯，什么平均值等等对吧，那么嗯其实这个呃spark呢，它其实还支持一些高阶的操作啊，比如说我们这个地方的一个呃，呃字符串是一个list对吧。

Hello back，Hello world，hello world对吧，那么我们把它转成RDD之后呢，这个地方有一个叫flat map，flat map呢其实是呃非常非常重要的一个概念。

在我们的呃spark里面，那么它的一个操作是怎么样的呢，他的一个操作是怎么样呢，就是说我们的，我把这个每个元素把它进行一个，按照空格来分隔开，空格来进行分隔开，然后把它拼接到一起，比如说这个hello。

它最终转变成了hello spark，Hello，Hello，Hello world，Hello hello world，他是把每个元素把它分隔开，然后把它拼接到一起，然后其实这个操作就是说。

我把每个元素把它拆分，然后把它拼接到一起，是这样的啊，有同学问到这个这里的数，这里的数据0123也是可以，一个文件还是数据流吗，是可以的，我待会会演示他怎么读取文件的啊，怎么读取文件的好。

那么我们再看一看一个高阶的例子，高阶的例子，那么比如说我们还是用这个data，data还是这个字这这些字符串，然后然后呢我们把它用PANIZE呢，把它转成这个RTD，然后呢我们还是看着啊。

这个其实我们的一个RDD，这些这些这些函数呢其实是可以进行一个，相当于是直接在后面点，然后直接继续增加的操作也是可以的啊，就是说我们把它换成两行也可以的，就是说我们再点一下，然后继续操作也是可以的。

这个RDD这个flamaflat map呢，我们上面已经讲了，上面已经讲了，就是说他得到的是这样的，然后呢我们把它做一个map操作，map呢就是说我们把map其实是一个KV的操作，对吧。

我们在之前已经嗯就是说可能看到过一些例子，map呢就是一个KV的操作，我们把每个X把它转成一个top x，比如说hello变成变成了hello1对吧，那么我们看一看它转变变成了什么。

变成了我们原始的是hello spark，Hello world，Hello world，那我们变成这样的，Hello one，Hello，1spark1 hello，一word1hello。

1word，一对吧，好他转变成这样，那么我们转变成这样的呢，我们还可以做一个操作，我们就是说我们把它做一个呃，就是说reduce by key，reduce呢就是说它也是我们spark里面的一个概念。

它其实是可以把我们的元素进行一个，累加累加的，那么我们这个地方我们是按照我们的一个，就是说，我们统计我们所所有单词的一个出现的个数啊，其实本质是这样的，那么我们就reduce by key，然后呢。

我们by我们就是说，相当于是根据我们的一个单词进行一个分组，然后统计它出现的次数，那么我们最终统计的结果就是hello，出现了三次，spark是一次，word是二两次啊，当你大家可以看。

就是说他其实定义的操作其实是非常非常，就是说可能跟之前大家接触到的一些嗯，就是说操作不太一样，但是它其实是非常有效的，这个地方其实本质就是统计的一个word count对吧。

统计的所有单词的一个出现的次数，那么如果但如果我们想要做这个具体的一个，就是说这种集合在我们的一个spark里面，RDDE其实也是可以的，A这个I额data和B的data。

我们求这个具体的一个就是它的一个并集对吧，我们unit a u n b connect对吧，这也是可以的，然后呢我们假如说想他抢，就是说求并集之后呢，再取它就取它它的独立元素的个数是吧。

distinct对吧，其实我们在这个嗯SQL里面，其实也是这种distinct的一个语法对吧，好对吧，我们就得到了1234，把这个重复的元素给它剔除了，那么这个呢，就是我们的一些RED的一些基础操作啊。

当然这个只是带着大家简单的过了一遍，那么如果大家自己掌握呢，从头学起呢，还是需要有一定时间的，需要有一定时间的好，那么如果我们上面呢，其实这是RGE的基础操作，那么我们其实这些操作呢也可以用这个呃。

就是说其实我们这个地方其实本质对吧，我们这些语句，本质就是说对这个数据进行最原始的一个操作，比如说对它求对吧，求这些统计啊，求最大最小，或者或者说把它求转化，那么我们接下来就是说我们基于这个呃。

spark的一个data frame来进行讲，那么我们在创建这个spark session之后呢，我们就可以从这个应用程序里面，从从一个已已有的RDD，或者说从已有的表格。

或者说从文件里面读取一个我们的一个data frame，那么这个地方呢，我们读取的是一个我们本地的一个JSON文件啊，在我们本地放好的，在我们本地这个呃目录下面呢。

我放了一个叫people点JASON啊，那么这个文件里面就是这样的啊，是一个JSON文件啊，是个JSON文件呃，那么这个JSON文件呢，也不是说完完全全是一个合法的JSON文件。

这其实每一行就是一个KV的一个对吧，那么我们用这个spark read点JASON就是读取这个JSON文件，我们把它读取一下，读取完成之后呢，我们就不一样，这个地方就是它是data frame呢。

那么它的一个语法点show，我们就把这个表格给他展示出来，好就是长的这样的，那么大家可以看一下这个地方，我们的一个数据集，他其实有的地方还是缺失了对吧，我们的第一个人他没有A级，这就是没有A级字段对吧。

我们这个地方是缺失的是吧，那其他的我们的这些字段，其实读取的都是很正常好，那么data frame呢，其实它的这些语法其实在呃scanner，或者说嗯java或者说R语言或者Python语言。

都是可以一起操作的，就是说这些函数都差不多，那么这个地方的data frame，和我们的pandas的data frame其实是非常类似的，其实非常类似的。

我们可以根据这个地方的data frame的一些语法，其实可以参参照的，你你实现一下我们的呃pandas里面的data，data frame的语法。

比如说我们在Python里面可以通过这个DF点edge，对吧，我们ten pandas there就是DF是一个表格，DF是一个表格，A级是一列对吧，我们可以通过DF点A级。

这个是啊pandas或者说DF括号A级，这样来选择pandas列对吧，就是说这样呢其实是我们的一个具体的操作，但是呢在我们的一个嗯就是说嗯sparkle，py spark里面呢。

其实也是嗯可以这样做的好，那么我们来看一看，在嗯就是说这个py s spunk里面，怎么进行操作，那么首先注意一下，就是说我们就是创建一个具体的一个data frame，之后呢。

其实就是创建了一个SK嘛，那么有同学还是不理解，这个schema是什么含义啊，这个schema呢其实就是表明了，就是说我们这个表格的具体的格式，店名，及他是不是缺失，或者说我们这个呃这些列。

它到底是怎么按照什么形式来进行存储的，这些呢都是我们这个data frame来，就是说需要需要，就是说在创建这个表格的时候呢，需要进行操作的。

那么我们如果用这个PYSPARK的prince schema呢，就可以把这个schema的一个把它打印出来，那么我们就看一看，就是说edge呢是用none，然后冒号。

然后呢我们name是一个string对吧，然后呢在我们的p s bk里面呢，我们其实选择某一列的某一列的进行展示，它是这样的点select，他不是说是我们的，在嗯跟pandas as语法不一样啊。

跟pandas as语法不一样，其实你看着差不多，它语法就是语法的差不差别，点select点show好，这是选择这一列，当然我们如果选择多列对吧，d f d d select输入输入一个列表。

然后点show好，那么我们这个地方在这个地方大家可以看一下，这个就跟我们的一个circle有点类似，select我嗯D嗯DF点select df name以及DFH加一，那么这个地方呢。

就是说我们在筛选这个列的时候呢，还把这个A级给他加上一呢，加上一了啊，加上了，那么你这两种就是说DF呃，就是说select和DF呃，这个具体的name啊，这这两者都是可以通用的，你可以都进行通用的。

那么在我们的一个具体的一个呃，PYSSPG的操作呢，它其实这些操作都是根据我们的一个呃，就是说首先加了这个函数啊，比如说我们的具体逻辑选择，就是说DF点FA filter呢。

我们的就是说具体的一个筛选逻辑，然后点show对吧，然后呢，我们假如说想要根据我们的A级来进行分组，来进行统计对吧，我们的grop by it，然后点count点show，就是说这个具体的一个。

它只是在一个具体的一个语法上不一样啊，其他的情况上呢都是相同或者相似的，DFGIE可以不更改列名吗，可以的，这个可以的，这个可以不更改列名的，这个只是在这个地方，他是把我们的嗯。

就是说就是它默认把这个操作逻辑，就把它匿名改一下，可以不更改命名的对，那么我们也给大家准备了一个具体的一个额，PDF啊，我不知道就是大家能不能看清楚啊。

我把再把它投一下屏，我投一下屏啊，稍等今天准备的一个内容，主要是各个文分布在各个文件里面啊。

大家可以看到这个这个这个PDF吧，那么这个P其实很在spark学习的时候呢，就是很多的一些这个呢是一个呃RDD的一个，就是嗯一个操作，那么这个操作呢，就是你基本上我们常见的一些操作。

就是基本上我们这个PDF里面展示的，比如说我们创建我们的数据，创建我们的数据，我们可以从这个具体的一些呃，就是我们的list里面进行创建，也可以从range里面进行创建，然后呢。

我们也可以从我们的具体的文件里面进行创建，这也是可以的，我们从text file，或者说我们的一个，就是说具体的一个路径进行创建也是可以的，那么这个RDD创建之后呢。

我们就可以把它作为一个具体的进行一个统计，或者说基础的一个信息对吧，我们的count control value，然后我们的求some，然后比如说我们判断它的一个，最大最小平均值对吧。

这是基础的一些统计，然后呢我们这IDD也可以作为一些，那就是说这叫函数，比如说我们前面讲的这种拉姆达函数对吧，然后我们的一个就是说flat map对，然后这个具体的一个采样筛选，或者说我们的一个就是说。

我们这个IDD也可以写函数啊，写函数也可以具体操作的对，然后就是说嗯我们这些RDD的操作呢，基本上就是涵盖了这些基础的一个数据的操作，比如说把它求和做分组，做统计等等等等啊。

一直到最后我们的一个输出输出，这个地方呢你可以输出到一些文件。

这都是可以的啊，这都是可以的，好，那么就是说我们这个R这个这个只是把RD。

RDD这个语法给大家介绍啊，RDD语法就给大家介绍，然后呢我们待会还有还有一些其他的，我们待刚才讲的这个呃p y spark的这些语法呢，我们待会还有一个PDF给到大家好，这是这个啊。

我们就继续我们的一个PPTT，那就是我们的一个实操的内容。

看一下我的网页，在这。

好那么接下来呢我们就到我们的一个这个，其实我们前面这部分其实是一个data friend的操作，那么我们接下来呢可以就是说用一个嗯spark circle，Spark circle。

其实这个里面就细节非常多呢，就是说呃很容易遇到一些女同学，就说老师这个spark circle和就是说我们的data frame，它具体有什么区别。

或者说我们它这个spark circle和具体的一些circle，有什么区别，这个呢就里面有很多的一些细节和很多的内容，那么呃就是说spark呢现在大地学习啊，就是说如果要学好，可能要去花个spark。

要学好，他可能要花个至少两三个月才能完全从头学好，那么我们只能说，把这个基础知识和一些常见的用法给大家较好，然后呢，有同学可能说，老师为什么spark不就这么这么多函数，本来都记住不就行了吗。

嗯不是这样的啊，我们写spark并不是说把它写完就OK了，有时候我们还需要就是说把它写快，把它写快啊，好那么我们接下来就看一下spark circle啊，呃那么这个circle呢。

其实这个spark session呢也可以支持这种circle的，spark circle的这种方式来进行数据的查询，那么首先呢我们把原始的，我们这个people这个数据集呢。

把它转变成一个我们的一个tempo view，然后相当于是把它转成一个，就是说能spark circle能够查询的形式，然后我们来看一看，其实在这个地方下面，我们的spark circle就可以执行了。

Select circle，select新from people，然后点show，这个地方就和我们前面就是筛选得到的edge和name，这两列同时筛选得到的是一样的，是一样的好，那么下面呢我们就讲。

就是说这个这个下面呢是讲这个从RDD，怎么把它转成这个data frame啊，我们先把他留住啊，先把他留住，先讲一些更多的例子啊，可能大家听得还不过瘾，那么这个spark呢。

其实大家自己如果把这个环境安装好之后呢，学习起来其实是非常简单的，非常简单的，比如说我们还看一些更多的例子，就是说我们假如说创建一个更呃，就是说复杂的一个表格对吧。

我们有l class language mass啊对吧，就这这些列都是一些数字啊，这些数字，然后呢我们如果把它创建之后呢，这个是没有显示好啊，这个最后这个数据集呢，我们设置了他的一个数据。

还有他一个列名，然后呢，这个地方，我们这个地方上面也是创建了一个spark session啊，Spark session，当然这个你取自己的一个名字就行了，或者是不取也是可以的啊。

我们的CONFIG文件你可以取，也可以不取，把它创建好之后呢，我们也这个地方也支持DETEMPS，或者说你用这个print schema，也可以看这些列名的一个类型好，那么我们这个这些逻辑。

大家我们前面已经讲了啊，就select select的逻辑好，往下翻，讲了的，我就我就是说跳过啊，刚才讲了的我就跳过，那么我们刚刚才不是就是说有同学问这个，具体的一个就是说列名吗，对吧。

我们其实是可以把这个列名，就是说把它在circle里面叫alliance对吧，circle里面叫alliance，在我们的py s spark里面也是可以类似的啊，把它取的，把它取做一个别名也是可以的。

也是可以的，就是说我们的py s spark呢，它其实这也是支持这种，就是说类似，就是说这个地方其实跟我们的circle执，执行差不多的操作，比如说class等于一的线线得出来。

或者说我们的class like like呢，就是说让它是一开头的一开头的好，我们接下来就看一看sparkle一个circle啊，主要是看这个就是这个地方呢，我们其实是创建了一个临时的一个表啊。

从这个就是原始的这个test data frame0，把它创建得了一个test df，这个地方呢我们把它创建了一个临时表，然后可以用so SQL来进行查询对吧。

我们sparks circle它是这样写的啊，Spark circle，然后这个后面是我们的一个执行的语句，select是count新number count from test df。

那么大家可以看到，其实这个和普我们前面讲的这个circle的语法，其实是非常类似的，非常类似的，只不过它有一些细微的不一样啊，细微的不一样对吧，我们这个地方假如说count就是说心，就是说我们的心。

然后我们number count from我们的DF，其实就是得出我们的这样一个data frame，它是返回的是一个data frame，然后假如说我们想要把我们的数据，把它做一个排序也是可以的。

也是可以的好，那么spark呢也是支持这种缺失值的处理啊，缺失值处处理，我们就直接spark我们创建了一个呃，就是说我们这个地方呢，我们其实是从pandas data frame。

把它就是说转成了inspect data frame，然后这个地方就是说，我们首先创建了一个pandas的data frame啊。

然后把它从spark create data frame把它进行一个转换，然后呢我们转换之后呢，这个数据集原始的是有这种缺失值的，我们其实就直接把，就是说其实直接把它，尤其是值进行一个删除就行了。

删除就行了，然后呢spark的这些语法，它其实也是跟我们的一个circle也是差不多的，circle的也差不多的，就是说但是跟那个pandas的一个操作，其实是不一样的。

跟pandas as的操作可能还有点不一样，比如说我们group by我们的key，然后求每个分组下面的一个统计，或者说我们想要求更加复杂的，就是说我们group by某个key，然后求这每个分组下面。

比如说这个分组下面那个language的这个最大，以及我们的这个分组下面的一个language的平均，这也是可以的，其实这个我们用这个circle也是很方便，可以写的好啊，我们先休休息10分钟吧。

休息休息10分钟，我们继续，我们休息到九呃，九点钟继续啊，休息一会儿，我这个地方主要是嗯演示一些基础的一个语法，没有，就是说查数据库，查数据库也是直接在我们创建数据的时候嗯，连接数据库就行了。

就是说后面的语法是一样的，我这个机器上没有装数据库啊，对好那么我们继续啊继续，那么呃对于spark呢，它不仅仅是支持我们的一个数据的一个呃，就是说嗯一个操作还支持这种数据的一个转换。

spark的一个转换，就是说数据转换呢主要就是需要大家知道，一，就是说我们从RDD怎么把它转成一个data frame，或者说这两者之间的一个交互，第一种方法呢，就是说我们通过就是它有两种方法。

第一种呢就是说通过一个反射推断来去推断，我们的包含类型的RED的EXCEA，这个地方呢，就是说是在我们创建这个具体RD1的时候呢，需要指定它这个类型，让我们的代码，我们就是说知道我们的SK码的类型。

第二个呢就是说我们是显示的，去构建一个schema，这个呢就是相当于是我们第二个例子啊，就是说显示的构建一个scheme，然后从我们的IDD数据来进行一个编码，然后呢这种情况呢它是呃会繁琐一点。

因为我们这个CHEMA是你手动要编写的，那么常见的就是说一般情况下呢，可能第一种就是说这种反射推断，可能会更加方便一些，更加方便一些，那么首先呢我们看一看我们的数据集。

我们数据集呢是这个本地文件的这个people，我们cat一下它，也是跟我们原始刚才那个JS文件差不多啊，只不过这个地方是个TXT，那么我们从spark里面呢把它读取出来，读取出来，然后呢。

我们把它这个读取的出来的，是一个RDD的类型的啊，那么我们把它做一个map，这个地方呢map我们就把它做一个分隔啊，就相当于是用客户进行分隔，然后呢，这个地方我们就说接下来我们是显示的指定的。

用一个肉肉呢，其实也是就是说对RDD的一个，就是说一个封装，只不过这个地方的封装呢，它是呃没有data frame那种，就是说表格的形式肉一般只是一个向量，或者说一个类似一个list存类型的。

那么如果我们把这个把它转成正一，一个就是说呃把我们的一个pass呢，把它转成两个肉组合的一种形式呢，那么我们再从这个people里面把它，就是说从我们的people这个2DD。

把它转成Mark的一个data frame呢，他会做一个就是说类型的一个推，就是说反射推断，反射推断，它会根据我们的原始的这个两两列里面的，一个具体的取值去推断它到底是什么类型的，来创建它的一个列名。

和他具体的一个列的类型好，那么我们再看一看在这个地方，我们的一个转换之后呢，我们的一个好听，就是说这个地方已经转成我们的data frame之后，然后我们再从这个地方来进行查，来进行查。

然后我们你可以看一下这个地方，我们往下翻啊，他会把我们的一个就是说这个D1D0年，也就是说我们的name念，会比会解析成我们的一个string类型，第二类呢会把它转解析成int类型。

就是它是会自动解析的，解析完成之后呢，我们就可以从中进行一个查询文件进行查询啊，这个地方我们的这个spark circle呢，它执行的返回的也是一个data frame，也是个data分。

这是第一种方法，就是说根据我们的一个类型进行一个反射推断，第二种方法呢就是我们这个地方说的，我们显示的构造一个schema，那么在这我们在构建一，我从我们的RDD数据把它转，手动把它转成一个呃。

就是说data frame的时候呢，我们可以就是传递一个呃就是说strut time，然后哦这个struck tap呢，其实嗯就是呃就是显示定义了，我们这个schema的一个类型。

就是说嗯我们每一列到底是什么类型的，比如说我们的一个在就在这儿啊，我们的呃就是说具体的列名是什么，然后我们通过这列名，通过它进行一个解析，解析之后呢，我们就可以把它的一个具体的一个就是说呃。

P结构把它做一个显示的定义，这样呢就是他没有进行一个反射的推算，他就直接是从我们的一个呃，就是说定义的一个struct tape里面进行一个呃，就是说这样转换的，我们还把这个scheme把它转换进去。

把它传入进去，对这是两种转换方法啊，比如我们的一个pandas呃，这些呢其实也是呃，就是说空位可以从我们的RDD进行转换的好，那么这是一个数据的一个处理，那么我们接下来呢就讲这个具体的一些。

就是说在spark里面的一些呃机器学习的案例，那其实spark它的一个优点呢，不仅仅是它集成了这些很高效的数据操作啊，它还有这种很广泛的用途，非常广泛的这种嗯机器学习的。

不就是说支持了这种机器学习的算法，那其实spark的它支持的一些机器学习算法，基本上嗯它没有它支持的一些机机器学习算法，没有SKN里面全啊，但是呢它也是基本上是在这种分布式的呃。

就是说大数据框架里面支持的比较好的，支持比较好的，那么我们就来看一看啊，我们首先呢是看一看用spark，如何用它来完成一个文本分类的一个案例，文本分类的案例啊。

然后我们首先呢创建一个spark session啊，需要注意的是啊，我们这个地方你一个spark呢你可以创建，就是说我们这个地方是多个notebook同时运行的啊，我好几个LOTUBOOK同时运行。

这都是可以的，他跟GP这个地方呢它主要是受限于你的一个，就是说我们的一个嗯具体的内存啊，就是说它不是说我们只能创建单独的一个session啊，好，那么我们已经把数据集给大家，传到我们的网上啊。

大家直接w git下载下来好，首先呢我们这个原始的数据集长的什么样的呢，长什么样呢，我们从这个spark csv把它读取进来，这个原始的是一个TXT啊，原始的一个TXT，我们呢让我们的spark呢。

它是自动去推断我们的一个CHEME，推断我的类型，然后设置一下我们的一个分隔符，其实这个和我们的一个pandas的那个呃，具体的语法差不多对吧，那点，额有两列，第一列呢是我们的一个邮件的一个。

就是到底是不是垃圾邮件的一个类别，第二列呢是我们的具体的这个呃词图上啊，就是邮件的，那么我们对于这个呃data frame呢，其实我们可以把它那个列名做一个转换。

这个呢就是说with column relam，就是说把这个C0把它转成，就是取另取个名字叫class，把他名字转一下啊，然后我们把这个C1把它转成那个叫ticket好，转成完成之后呢。

我们的数据集长这样的啊，好，那么接下来呢，我们需要可以把我们的数据集做一个，具体的一些处理，那么这个地方啊，其实spark嗯，对，我现在卡了吗，有没通，我刚才卡了一下嗯，大家能听到声音，能看到屏幕吗。

我现在哎喂，大家能看到声音和听到屏幕吗，OK是吧，我刚才这个地方显示它连接断了啊，真的没问题是吧，刚才应该是卡了一下，刚才应该是卡了一下好，那么我们首先呢把我们的数据集，做一个具体的处理，做一个处理。

那么其实这个地方啊，我们这些我们首先呢好统计一下我们这个字符，这个字符的具体的一个长度，我们就是这样这样写的啊，其实这个地方大家可以看一下，我们这个地方不是select啊，这个地方不是select不。

我们直接取一个名，取一列名字叫对吧，with conn就是新增一列，这里新增一列呢叫length，他是怎么得来的呢，就是说求我们这个TXT这一列的，具体的就是说它的一个长度，具体长度。

那么求问它长度之后呢，就是我们把它原始的一个data frame给它覆盖了啊，覆盖了，那么我们就新增了一列，新增了一列，那么新增一列之后呢，其实我们接下来就可以算一算对吧，我们其实也是可以统计一下对吧。

我们grp by class，然后算新增页的内，具体的呃，就是说不同类别的下面的一个平均的一个，就是说我们的一个字符的一个个数对吧，arrangements grove by mean对吧。

其实这个语法跟pandas其实是一样的好，那么接下来呢就是我们TFIDF的吧，这个其实在我们前面的课程已经给大家讲了，但是呢在这个地方其实它是基于spark下面的，可能他的一个语法上有点不一样啊。

那么其实但是呢它的一个基础的流程，也是一样的，首先做我们的token，然后或者说做分词对吧，做完分词之后呢，然后做我们的一个具体去数形容词，然后我们的CONTROVECTOR对吧。

然后算我们的一个TFIDF，然后就是说做我们的这个地方啊，string index其实就是一个嗯label encoder的操作，就是把我们的一个，而class呢把它转成一个具体的一个呃。

就是说原始的是一个字符串，两个字符串我们把它转成一个数值好，那么我其实我们其实它其实非常简单非常简单，那么这个地方就是我们把我们这个地方，我们其实在这个地方其实是没有操作的啊，在这个地方其实没有操作的。

看一看他在哪啊，他其实是在我们这个地方前面值定义的，这些具体的操作，具体token就是我们input的列名，以及我们output列名，然后他这个地方是没有具体操作的，在哪呢。

在这个地方这个地方大家看起来有，是不是有点熟悉，在我们的SK里面也有叫pipeline的，在我们这个地方也也也有叫pipeline对吧，我们首先把我们的这个我们的HMHPAM。

这个地方是就我们这个地方定义的，上面所定义的对吧，我们的一个label encoder就是把我们的类别，我们类别把它转成一个具体的编码，好，转了之后呢，我们做一个分词分词对吧，嗯分词分词之后呢。

我们去除提容词，然后统计做一个CONTROVECTOR，然后做我们的一个IDF，然后再做一个clean up对，然后clean up呢，就是相当于是我们具体选择的是哪些列好。

这个呢我们定义呢我们的一个嗯，流水线或者pine之后呢，它可以直接就是说整体的对我们的数据集，进行FE条transform，这个其实和我们的s kn其实本质差不多的，流程差不多的。

那么在我们的spark里面呢，其实也是支持常见的机器，常见的一些机器学习算法啊，常见常见的一些机器学习算法，就是说我就是说他的一些，基础的一些机器学习算法，就是说包括什么普兹贝叶斯逻辑回归树模型。

随机森林这些他都是支持的啊，这些他都是支持的，比如说我们这个地方把这个PSBUKM2classification，里面的嗯，普斯变叶斯把它引put就行了，然后我们直接使用的是默认的这些嗯。

就是说配置默认的配置好，那么我们把我们的数据集把它转换好之后呢，我们选择我们想要的列，那么我们的列就转成这样的啊，这个就是我们选就是得到的这个列the列，然后就是说这两列，然后label已经把它装好了。

features也把它装好了，然后我们就送这个地方呢，我们把数据集把它按照hold out的方法，就是70%的数据集，当做我们的一个训练集，30%的呢当做我们的测试集好，然后呢。

把我们的训练集送入到普斯普斯贝叶斯里面，进行一个训练，然后我们这个地方把我们的一个呃，就是说测测试型，把它这就是说做一个打分，然后受大家可以看，基本上就是说得到了我们最终的概率。

一个情况以及我们最终的一个概率值对吧，那么基本上就是说，这个这个普斯贝斯得到的算法，这个算法呢并不是说很准确啊，并不是很准确，但有一些还是没有预测得到的，比如说真实的内部是这个地方应该预测错了。

但是呢这个notebook基本上是演示了这个，py s spark的一个基础啊，p s bk的技术，就是说我们怎么从原始的文件里面，把它一步一步的把它进行一个转换，然后输入到训练里面的。

然后有同学可能说老师，我们这个地方就是说我能不能我我不用pipeline，不用这种pipeline的操作，我直接就是说一步一步把它转化，就是相当于是我们用这个嗯，就是说你用嗯spark circle。

或者说psl spark内置的这些函数来进行转换，然后再送入到我们模型来训练，其实这两者都是一样的啊，两者是一样的，然后我给大家解释一下，为什么这种PAPINE其实是非常有优势的啊。

在SQUN里面呢也有这种pipeline是吧，在py spark里面也有这种排pine，pipeline的一个优点，就是说其实他是就是说我们的这个pipeline呢。

它是基本上是他的pipeline原生的一个含义，就是说是一个流水线流水线流水线的翻译，翻译是吧，那么sparks里面的pipeline，和这个SKN里面的pipeline，其实在实线上啊有点类似。

有点类似，因为我们的这个原声的这个呃，就是说我们的具体的一个操作呢，就是说他其实是有可能是有这种间隔的，那么如果用pipeline呢，它可以就是说我们的一个4spark的排布呢。

它可以帮助我们来优化这个具体的一个操作啊，优化的具体的操作对，而且呢我们的一个spark pipeline呢，它可以就是说我们定义好了这个pipeline之后，我们就不需要写。

就是说相当于是定义了一个函数啊，定义了一个管道，一个函数，那其实可以帮助我们，就是说直接对我们的数据进行一个处理，直接对我们的数据进行处理，那么这个地方呢，嗯pipeline。

它不仅仅是支持了我们这个地方的，fit和transform啊，他假如说我们在这个PAPINE里面，加入了我们的一个评估器，就是说加入到我们的一个额，就是说你在这个PAPON里面，也可以加入我们的模型。

在后面把我们的模型加入进去也是可以的，也是可以的，pipeline的一个管道，就是说我们可以把这些具体的操作传入到我们，pipeline里面，然后这个这个呢，可能也不是说所有的操作都能传输进去啊。

也不是说所有的操作都能传输进去，这是这样一个知识点好，那么在我们工业界里面，其实弄到PAPI的一个情况也是非常多的，也是非常多的，因为你假如我们从头就是说把这些token哪个呃，就是说具体的操作做分词。

然后写代码呢可能会写的非常多，就是说可能嗯就是说写的，就是说代码行数非常多，如果用PELINE也会更加整整洁一点，然后有同学可能会问到，就是说我们这个地方我们这些具体的一个操作。

就是说我们到底是为什么不能用SQL来实现呢，就是我们刚才不是用这个p spark circle，ark SQL也能实现，就是说就是说这些数据处理啊等等等等对吧，其实是这样的啊。

就是py s spark呢，它spark它是提供了，就是说你可以用嗯，就是说SQL来进行具体的数据处理，也可以用这些函数来操作也是可以的，就是说看哪种更方便啊，哪种更方便嗯。

就是说也是看它内置了有哪哪哪一种，有具体的这种我们想要的功能，然后我们再去进行继续的具体的选择好，那么这是一个文本分类的案例，那么我们接下来呢看我们还是讲这些，就是之前讲过的这个泰坦尼克号的一个案例。

泰坦尼克号对吧，大家还记不记得，就是说是预测，根据这个乘客的一个信，就是基本信息来预测这个乘客是不是幸存，我们已经帮大家把数据集已经给他下载好了啊，然后我们就来看一看这样，那么在spark里面呢。

其实如果我们想要手动，对我们的数据集进行处理，当然也是可以的啊，也是可以的，比如说我们就是说这个我们首先得到，我们把我们数据集读取进来，然后呢我们得到我们的第一行，第一行得到之后呢。

假如说我们不想读第一行对吧，我们把第一行给它剔除掉是吧，把它剔除掉好，然后呢，如果我们想要手写这种什么字符串的一个转，换的一个映射，这都是可以的，就是说我们这种就是手写的，这个把我们的mail映射成一。

然后把FMMAIL映射成零对吧，这living encoder其实你手写也是可以的，也是可以的对，然后呢我们也可以把这些具体的我们的呃，就是这个数据呢把它进行一个拼接，然后把它进行一个转换。

在我们的一个spark里，也是可以具体的用这些函数来进行实现，执行完成之后呢，我们还是用我们的windows split把它进行一个分割，分割成70%的呃，训练集有30%的一个测试期喝一点水。

然后呢我们这个地方是就是说从这个m l lip，也是p y s spark内置的机器学习的模块，然后import我们的随机森林，当然在我们的随机森林这里面呢，其实这些设置的一个超参数。

和我们SKN里面的一个超参数是可以共，就是通用的啊，只不过他的一个取名不一样而已，然后呢我们把它定义好之后，然后就可以进行一个具体的一个训练和预测了，预测完成之后呢，我们就可以把我们的预测结果用嗯。

它里面的一些评估函数，比如说这个地方呢，我们是定义这个二分类的一个准确率对吧，然后我们就可以看一看塔里啊，这个地方不是1/2准确率，这个地方它应该是可以计算更加清楚的，比如说这个地方的一个PR。

以及它的具体的AUC都可以计算出来对，那么这个的操作呢，基本上如果是在我这个机器上呢，是12核的一个情况下呢，训练起来是非常快的，训练起来是非常快的对，那么我们嗯就是说这些数据处理呢。

我们也可以从就是说用这个具体的，不用我们上面这些操作，也可以用这个具体的呃，这些我们刚才讲的这个select语法来操作，这也是可以的，比如说我们把数据集读取进来，然后筛选我们想要的列。

然后把我们的具体的这个地方的cast，其实是做一个类型转换，把它转换成一个我们的一个float类型的，然后呢把我们的一个数据集，把它就是说剔除我们的一个缺失值，缺失值剔除完之后呢，把我们的数据集。

按照我们的一个比例来进行一个具体的拆分，然后呢我们这个地方啊，就是说你如果不想就是说从pipeline写，其实也是可以的，这个地方的一个string index呢。

就是说把我们的这一列把它做一个label encoder，就是说把它从这个字符串，把它转成一个我们的一个数值，然后在n spark里面呢也是支持这种常见的这个网，就是数据处理。

比如说one hot encoder也是可以的，也是可以的，那么如果我们把我们的数据集转换好之后呢，我们还是可以用这个呃，我们的一个额Z40来进行一个训练，然后训练好之后。

然后把我们的一个就是这个地方transform呢，其实是把我们的训练集的一个，就是说做一个预测啊，把我们的训练集做一个预测，然后可以看一下他的一个预测结果呢，其实和我们的真实标签其实是嗯差不多的。

这种写法呢其实是没有pipeline的一个方法，那么我们也可以把PAPINE加上，Pamine，加上呢，就是我们把这些操作并不是说直接来完成，只不过是在这个pipeline这个地方，就是说来完成的。

我们那用pipeline来进行fit，用它来进行transform，那么如果是在这个地方呢，大家可以看一下，是在每一行每一行后面来进行一个操作的，如果说pipeline呢，其实就写的更加简洁一些。

直接在最后啊，直接在我们最后这个地方来进行一个，Fit transform，这是一个pipeline，好，那么我们PYSPARK呢，就是说还是需要大家自己下去进行一个练习啊。

当然就是说如果大家之前没有接触过的呢，可能稍微了解起来会有一点就是说懵逼。

或者说不熟悉啊，我们再给大家看一个，就是说我们的一个准备的一个PDF，就是说我们的一个spark circle的啊，切一下屏，找一下好，大家能看到屏幕吧，哎没拖上去好。

拖上去了，那么我们还给大家准备了一个，具体的一个速查表，这个速查表呢就是展示了我们这个呃，就是说p s spark和spark circle，它具体的一个就是说操作。

首先呢就是创建spark session啊，就是说大家我非常建议大家自己来试验一下啊，就是说自己跑一遍这些代码都可以直接跑的，直接直接就跑了，就是说我们首先呢创建一个spark session。

然后呢我们从spark session，然后就是set成他的app name以及的他的CONFIG，然后呢我们这个spark呢其实它是可以自己的，就是说做一个我们前面讲的就是做一个音。

我们的一个类型的一个反向推断，这是可以的，就是从我们的具体的一个字符，字段的一个类型来做一个转换，或者说做一个我们的显示的一个类型的定义，就是我们定义好我们的一个具体的一个schema。

具体的SCHE码呃，就是说我们从那个struck，struck field里面定定义我们的一个CHEMA的，它的一个操作，然后呢我们的一个呃spark呢，它是可以从就是说常见的呢。

主要是从这个就是说从JASON或者说从TXT里读取，也可以从我们的数据库读取啊，我们在周五的课程呢给大家演示一下，从数据库读取，因为我本地是没有数据库的，我本地因为我自己在家里面啊，不是在公司里面。

所以说本地没有数据库，那么如果从spark呢，我们其实就可以从它里面读粤语的点CSV，也可以从spark里面点read，点JASON都是可以的，都是可以的，或者说从TXT都是可以读取的。

那么spark呢它这个语法就是这个语法呢。

其实和SQL的语法其实是很类似，很类似的，那么只不过呢他这些操作啊，就是说有可能同学说老师这些操作，他跟那个circle相比，它的效率哪一个高，其实两者差不多，两者差不多，就是看你自己写的一个逻辑。

就是说就是说可能啊就是说你写的高不高效呢，有可能你SMARK写的不好的情况下呢，可能就是会比较慢对，那么比如说我们想要选择某一列对吧，select某一列嗯，select是两列对吧。

Select first name is last name，比如说我们想要选择对吧，我们的额多列，然后呢或者说做某列的一个具体运算对吧，我们前面也给大家演示了，或者说根据我们的具体的一个逻辑。

来进行一个筛选，我们的列以及我们的行都是可以的对，然后呢这些具体的逻辑操作，其实是可以进行一个呃就是说并联的啊，具体具体并联的对，那么这个地方就是说spark呢其实也是支持，就是说写一些常见的。

比如说like这个呢NIKE就是说我们它是用嗯，这个last name呢是以史密斯开头的，或者说他是呃就是说first呃，或者说以什么什么结尾的啊。

就是说start with或者说end with都是都是可以的，都是可以的，或者说我们取取这个first name的，就是说从中间那个字符或者嗯中间字符之后呢，我们再把它叫一个单独的名字对吧。

这些在spark里面都是可以的，都是可以做的，那么有同学就是还是可能会有疑问，就是说这个地方我们用这些操作来写，和我们用circle写哪一个更加就是说方便，或者说为什么我在这个地方是这样写的啊。

其实是这样的啊，就是说如果是用circle呢，我是建议就是说circle它不太嗯，就是说怎么说呢，circle也可以用circle，也可以用这种语法也都是可以的，就看你自己的一个习惯，看你自己的习惯。

那么如果是用这种呢，其实我们是可以把中间结果给它保存下来，而且你可以随时点show，可以把它啊，就是说呃就是说上传一下啊，嗯有同学说可以把这个课后上传一下吗，可以的，我上完课马上就把我们的课件上传一下。

对就是说有同学有同学就可能会有疑问，就是我们这个用这种语法和我们的一个呃，就是circle，其实它的一个具体的就是说我们哪种比较优，其实是都是可以的，都是可以的，只不过我们用这种函数式的一个写法呢。

vs bug技法呢，我们可以随时把中间中间变量把它打印出来，这样呢是非常方便调试的，你如果是用circle呢，其实就不太方便了，不太方便了对，那么如果我们想要增加一些列对吧。

我们就用vs color vs column，如果我们想要更改这个列名对吧。

更改匿名，我们就是呃这个地方呢，它其实是呃with column relame，就是我们更改我们的列名对。

然后呢如果我们想就是说drop啊，drop就是说相当于是我们删除我们的细节。

这都是可以的对，然后大家可以看发现这个地方我们的一对吧，我们上面讲的讲了一个叫L，这个地方其实是一个在SQL里面叫个取别名啊，取别名它跟我们下面这个不一样啊。

这个呢相当于是永久性的，就是说改改变这个alliance呢。

相当于是我们的一个取的一个别名，就是临时性的，临时性的好，那么我们的这个py s spark呢，我们刚才也讲了，他是支持这种grp by分组，然后做聚合的，这也是可以支持的啊。

其实它跟就是说你可以理解它就是一个data frame，然后做这些具体的操作，然后呢呃我们如果是做这种逻辑呢，你可以在这个嗯select里面就是说做也可以，先我们做filter里面做也是可以的。

然后呢，我们这个py s spark也是支持这种排序的啊，就是说按照某个某种方式做排序。

然后呢，p s spark也是支持我们的一个缺失值的填充，和我们的缺失值的一个具体的一个操作，那么需要注意的是啊，它默认可能只是支持这种常见的缺失值，填充方法，你如果想要比较复杂的，确实是填充方法呢。

可能就需要有一些其他的操作，可能就需要一些其他的操作了，对，那么这些其他的操作呢，就是需要就是你可以写函数来做啊，就是你可以写这种具体的一个函数来做的，我们的这个缺失值填充。

就是说我们这个也是可以写函数的。

也可以写函数的好，那么我们假如说用这个，就是说把它注册成我们的临时表，然后从SQL里面进行查询对吧，我们把它呃就是说转转变成临时表，然后呢从我们的circle里面进行查询好。

这个呢都是可以的，然后假如说我们把它具体的数据，就是说我们把我们的data frame，把它转成RDD对吧，或者说把我们的data frame，把它转成我们的pandas啊，就是说转成我们的panda。

就是说嗯Python下面的pandas的一个data frame嘛，都是可以的，或者说把它嗯to jason to我们的TXT都是可以的。

而且呢这这种情况，这种啊并不是说只能写文件啊，当然也可以写数据库，你可以写数据库的，就是说我们把它就是说就是按照我们的MYSQL，或者说某种搜，就是数据库这个逻辑，把它写到我们数据库里面也是可以的，对。

那么需要注意的是，就是说大家可以在自己自己的一个机器上，或者说在我们的给定的这个环境上面，就是说试试验一下这个嗯，就是说我们的一个呃，spark的这些语法基本上都不难。

而且我们给的这些例子啊都是可以直接跑通的，可以直接跑通的好，那么我我们在嗯继续我们的PPT的一个内容。

PPT的内容，那么我们这节课呢，基本上就是嗯想让大家了解这些spark的一个，它的一个特性啊，一些基础操作啊，就是说理论上呢并不是想要让大家掌握很多，因为一节课其实讲不了很多理论啊。

主要是想把我们这些实操的一部分呢，给大家讲完，那么我们其实刚才也讲了两个，具体的一个机器学习案例，当然spark里面还支持一些其他的，比如说我们的spark里面也，现在spark高级高版本呢。

也是在慢慢把这个GPU的集成里面，也可以加进去啊，GPU集成也可以加进去，就是说也可以使用GPU的嗯，那么spark也可以支持聚类的好。

那么我们接下来呢还有一个表格，其实就是呃就是说我们如果是呃，就是说不想用spark，那么我们其实在现实生活中呢，还有这种have have呢，其实他其实跟spark长得有点类似。

就是跟spark的circle长得有点类似。

但是呢他跟我们的一个嗯，其实have呢其实是跟我们的一个circle长得差不多，但是呢它其实是一个have的一个查询语言，那么have呢它其实一般情况下，我们不是说是一个数据库啊。

不是就说很简单的库数据库，它是一种分布式的一个存储，那么我们的一个就是我们其实是可以，用我们的一个呃，spark这个环境去查have里面的数据的，当然也可以直接从我们的一个嗯。

have的一个web ui去做具体的一个查询，具体查询好，那么我们看一看他这个基基础语法，其实其实have的语法和我们的一个SQL的语法，其实大体上差不多，大体上差不多，只是有细微的一些差别。

那么就是说你学习这个SQL，基本上记住这样一个逻辑，或者说这个SQL的一个次序，这个啊就是说这是我们的一个，就是我们的一些标，就是说关键的一个语法单词对吧，Select from where grp。

Grp by heaven cluster，或者说我们的一个SBY，然后limit，然后呢大家在我们写have的时候呢，或者说写SQL的时候呢，就需要把我们的具体的一些，这个这个次序不能乱啊。

有同学说老师我们这个地方是，其实是是不是我们这些单词的一个次序，是嗯嗯不能乱，就是说能不能乱续写，就是说把我们的select和from from把它换换个位置，其实不能的啊，其实是不能的。

就是说呃我们这个就是这些单词的一个次序，就是要按照这个次序写，不能把它按一个，不能把他的一个次序把它一个转换，不能把这次序做一个转换啊，那么我们的select呢其实是主。

主要就是给出我们想要选择的哪些列名和哪些，我们的数据集，就是说我们的列名，然后我们的from呢主要是我们的，就是说具体的这个数据的来源，where呢是我们做这个VR这个地方。

其实是可以做我们的具体的一个逻辑，而且呢也可以做具体我们表格做聚合的时候，对吧，这个表格的某个键和另一个表格的某个键，做一个连接，grove band呢其实是做我们的一个分组，就是我们从哪一列来做分组。

heaven呢，就是说我们在这个地方就是说heaven，我其实前面没有讲到例子，就是说heaven，其实是在做完我们的分组聚合之后再做一个呃，就是说逻辑的操作，就是我们这个地方。

其实where其实是对原始的表格，做我们的逻辑的操作，heaven呢其实是对group by之后的数据，做一个逻辑操作，然后这个下面呢是我们具体的具体操作，完成之后，然后做一个具体排序啊等等。

然后这些都执行完成之后，再再才到了我们的limit，这个limit就是最终我们展示的时候，它默认是多少，默认是多少，就是说默认是五个默认五行，或者说默认十行对，那么其实是这样的。

就是说我们的一个呃have的语法，其实或者说secret语法其实是这样的，就是说这个关键词不能乱，关键词不能乱好，那么嗯have呢其实在这里面呢其实也是可以做，我们有同学说的这个地点啊。

其实也是可以做的，嗯但是呢但是其实一般情况下，我们在呃公司里面这些DDI的权限会帮我们，就是说他是会帮我们的一个做回收啊，他会把我们的一些权限做回收，我们就是说在我们通过web ui。

或者说py s spark这些呃写这些代码的时候呢，他其实会就是原始的表格，一般情况下都不都不能让我们操作的，我们一般情况下呢是把我们的数据数据集，把这个数据集把它进行操作，然后写到一个临时表。

或者说把它做一个输出，我们一般情况下我在做上班的时候，其实没有直接改原始的表格，这个其实很危险，而且我一般情况下，也没有原始表格的一个权限啊，没有也没有原始表格的权限。

一般情况下就是做一个数据的一个ETL，对于数据的疑点，当然啊这个地方嗯就是说有同学说老师嗯，我我们自己能不能做这个，具体的就是数据的一个定义啊，其实我不建议你去学这个，我们怎么创建这些表格。

或者说你学习一下第一范式，第二范式，第三范式或者说数据库这些方式，其实你不建不建议你去，因为我们现在大家主要还是找这个，数据开发相关的哦，就是说我们算法工程师相关的，或者说想在大数据平台下。

掌握这些具体数据和算法，或者数据处理的一个工作的岗位啊，所以说这些数据数仓呢，这个呃知识点呢其实可以跳过，我还是建议你就是说做一些，比如我们前面讲的这个spark的一些操作。

或者说这些have它这里面怎么做数据查询，怎么做聚合，怎么做group by这些操作才是大家需要掌握的啊，对那么这个我们的一个我们的notebook，这个PDF呢也会发给大家，也会发给大家对。

那么就是说我们在现实生活中，就是说在大公司里面啊，就是我现在在公司里面，其实have和我们的一个呃spark呢，都用have a spark都会用到，但就是看个人的一个习惯啊，就是说我现在比较习惯是用。

那就是说我们的spark，spark里面提供的一些机器学习算法可能会多一些，对，那么我们今天的一个就是说是提供了，再回过头来看一下，就是说一个是我们的spark的一个呃，基础的一个RDD的一个操作。

这个RDD，大家现在可就是说应该是有一点认知的，我们其实是个RDD，他根据我们的一个操作呢是构建了一个有无，就是说有向无环图啊，这个具体的操作，可能这些RDD之间的连接，是根据具体的一个我们的一个函数。

来进行连接的，然后呢，这个我我们就是说这个RDD的一个操作呢，其实也是影响了很多的一些机器学习框架啊，就是说影响了很多的机器学习框架，我们讲了这个IDD之后呢，还把我们的一个具体的一个嗯。

data frame的一个语法进行了一个讲解，以及我们的一个就是说我们的spark circle的一个，具体的操作，以及我们RDD和这个具体data frame的一个交互，对这些进行讲解。

然后呢给大家讲了两个，我们的一个嗯，4spark的一个具体的一个机器学习的案例，当然这个地方我们两个这个机器学习的案例啊，并不是说只有这两个啊，并不是说只有这两个。

我们还有一些其他的都是就是说可以给大家，可以给大家演示，但是呢由于时间原因，我没办法把所有的东西给大家展示，那么我们在实际的工作过程中呢，其实我们这个地方，他其实就是说我们在工作过程过程中呢。

其实这个原始的输入呢，很有可能是我们从数据库，或者说我们从对吧，这个地方其实是读取的是CCV，其实也是可以从我们的一个数据库，或者说从一个嗯临时表进行读取的，呃现在我自己做的一些呃模型的训练呢。

一般都是离线的啊，离线的居多呃，线上的呢可能是这种嗯就是说线上的呃，就是说使用这种嗯线上的预测，牛市预测嗯也会很多，就是说是离线的训练和在线的预测，是这样是组合的。

所以说呢大家就是学习一下spark的一个基础语法，然后能够把这个跑通啊就够了，因为我们大家之前如果没有学习过我们的circle，可能学习这个可能会有点困难对，那么我们再就是说我回到我们的一个PPT啊。

就说最后一页啊。

就是进行了稍微的一个总结啊，今天主要是一个实操啊，讲完了就没有了。

讲完了就没有了就业，就是说其实circle呢是我们的一个基础，不管是学不学计算机的啊，就是说你如果之后想就业，跟计算机就业相关的啊，都是需要掌握SQL的，而且呢也是大数据开发的基础啊。

SQL呢不仅仅是嗯，就是说数据库主管理管理的这种SQL have，里面呢也有这种SQL的语法，而且呢其实我们刚才讲的这个pandas circle home spark，它其实本质对数据的一些操作。

比如说统计聚合分组以及他的比如说这种map啊，或者说匿名函数啊，其实本质操作都有很多语法都是差不多的啊，只是在我们的函数的名称里面，或者说有一些区别，第嗯这是第二点，第三点呢就是说spark。

它是我们比较成熟的一个，大数据的处理和训练框架，是建议大家掌握的，但是如果大家是嗯就是说想找这种，就是说我们纯算法开发的啊，就是说可能这部分就是说稍微欠缺一点，是可以的。

但是如果大家想找跟这种ETAL相关的啊，这部分是非常建议大家掌握的，那么有同学说，就是说我们学习的今天这部分内容，其实是不是就够了，我跟你这样说啊，今天这个只是一个引子啊，抛砖引玉。

只是还有很多的一个内容，是需要大家进行学习的，我们在spark里面呢，这个我们的RDD，它里面有具体的一个操作逻辑对吧，那么RDD里面怎么做，我们我们算计算的一个优化，以及我们RDD怎么做。

我们的一个就是说我们的网络优化，和我们的计算优化，这里面有很多细节和很多内容啊，我而且呢我们也嗯也没办法给大家讲，所谓的例子啊，这个地方有一个链接，就是spark的一个头推二，它里面讲解的所嗯。

基本上一些高阶的IDE的一个操作，如果大家感兴趣呢，也可以看一下，嗯好的，那么我们今天的一个内容呢就这么多，同学们有什么问题，额同学有同学说老师是不是三种数据处理工具，只掌握一两个就够了。

我再给你举个例子啊，为什么circle有Sol，为什么要有有circle之后还要要有spark呢，其实是这样的，spark里面的RDD它可以实现复杂的操作，就是说RDD我们其实是可以实现复杂的操作。

但是SQL呢其实是没办法实现这种复杂的操作，这个就是看这个不同工具它的一个场景不一样，不同工具的场景不一样，然后嗯就是我们需要用到的工具不一样，然后你说是不是要掌握一两个结构，这个我不敢保证。

就是说你具体要掌握多少个，这个你要找的一个工作，其实也就是说你找的工作的岗位，其实也跟我们具体学的技能也是相关的，你可以假如说你想找哪个公司的岗位，你去看一下他们的岗位里面，假如说要有bug的话。

其实很有可能就需要你掌握spark，其实这种情况不是说我只掌握一两种就可以了，对嗯pandas我建议大家应该是掌握的差不多了，SOCL和spark呢我建议还是掌握一下的，非常容易考到啊。

这个也是常见的一些面试题，对，还有没有同学有问题，那么我们下节课呢就讲这些基于pandas的这种，或者说Python环境下的哦，这种高阶的机器学习的案例啊，可能在之前的过程过程中呢。

给大家讲的这种是这种简单的经济学家案例，对，还有同学有问题吗，那么我们待会会把这些所有的课件和PDF，马上就上传到我们的QQ群啊，我们今天呢就理论讲的很少啊，主要是讲一些实操啊，因为就是应该怎么练习呢。

我们我们明天的实训，明天的实训就是把我们的一个给了一个没，就是说大家的一个环境啊，就是说应该可以安装spark，你可以直接在上面，我们明天的就是明天的实训内容，就是有一个spark的很很简单的一些例子。

然后看大家掌掌没掌握这些具体的一个呃，就是说这些函数对我们有实训的一个作业嘛，对，然后其实其实有同学还是对这个spark不不够重视，其实我觉得因为我们的课程安排，只安排了一节课啊，我没办法讲很多。

因为之前我讲个例子，就说我一同学在在阿里，他其实每天都是在写4spark，就是说算法工程师每天都在写4spark，其实基本上都是这样，所以你不是说不是说spark不重要啊，可能你骗被骗进去之后。

你就没办法了，对好嗯，明天的一个就是实训是spark的一个基础啊，基础的一些例子，看大家有没有掌握，还有同学有问题吗，好那么如果没有问题，我们今天的课程就到此结束了。

【七月在线】机器学习就业训练营16期 - P14：在线直播：5-机器学习实践案例高阶_ev (1) - IT自学网100 - BV1Z9T5ewEKL

好啊，各位同学大家晚上好啊，然后我们今天的一个直播的内容呢，是机器学习的高阶实践，那么我们在之前的课程呢，其实各位同学已经学习了很多的，机器学习的一些算法，以及我们的一些相关的一个实践的基础。

但是呢可能各位同学呃，在具体遇到一个问题之后呢，可能还是要解决好这个问题，我们还需要做一些更深入的一些理解，那么我们这节课呢，就主要是展开我们的一个高级实践里面的。

一些步骤，主要是对我们的这个一方面，是对我们的可视化做一个深挖，另一方面呢我们是需要对特征筛选方法，然后做一个展开，然后呢也是需要给大家讲一讲，我们的机器学习的一个案例，我们如何进行一个迭代。

然后呢我们也会以金融风控的一个具体的一个，实际的一个场景下的一个业务数据啊，给大家进行讲解，我们如何进行解决的好，我们首先来看第一部分啊，可视化EDA，EDA呢这个地方EDA它的一个它这个是缩写啊。

Eda，那么这个地方呢，我们在做一个具体的一个数据挖掘，数据建模的时候呢，其实数据分析它是我们一直要做的一件事情，数据分析呢其实它的一个具体的一个，它是理解数据的一个最好的一种形式。

有很多同学可能不太理解，就是我们很多的一些程序员，不管是呃做开发的啊，还是做算法的，去一些互联网公司，就是国内的这种互联网公司啊，不管是国内的还是国外的啊，不管不管是阿里啊，百度啊，或者是说腾讯啊。

甚至在国外的这种FACEBOOK谷歌，你去了之后，很多时候的一个算法工程，真的不是说是直接让你进行建模，它不是让你进行建模，这个其实建模是一种一一件很简单的事情，建模我们只要有数据。

我们传入到我们的一个具体的结构package里面，我们的一个模块里面，然后它进行一个训练就行了，我们这个地方是需要算法工程师，去构建这个数据，也就是说我们的数据呢他可能是原始，可能是非规整的，不存在的。

或者说算散布在多个表格里面，比如说我们有table1，我们用table2，甚至有N个表格，我们在进行建模的时候，我们是需要将这多个表格的一个数据，进行一个汇总，然后得到一个汇总表。

然后以此来得到我们的一个最终的一个结果，也就是说我们在进行建模的时候，我们的数据呢其实是我们人工需要进行，构建得到的，而且在这个构建过程中呢，是需要有一定的业务知识的，我们在构建这个数据的过程中呢。

我们如何去理解我们的数据呢，数据分析是最好的一种形式，这个地方的数据分析呢，它就是我们嗯想要从一种统计或者可视化的方，法去理解我们的数据，我们的数据分析呢，嗯常见的数据分析有有几种形式啊。

第一个呢就是我们的一个嗯，探索性的一个数据分析，验证性的数据分析和描述性的数据分析，嗯我们就展开进行讲解一下啊，一般情况下数据分析呢他其实是一个岗位对吧，我们有有些时候呢你去应聘的时候嗯。

在互联网公司他有这个数据分析师这个岗位，那么这个地方的数据分析呢，其实他跟数据分析师，他所做的其实在工作内容上是非常相似的，但是呢我们算法工程师，他所做的一个数据分析的步骤呢是更深入的。

我们做数据分析的时候呢，一般情况下，首先明确一下我们的分析目的和思路，然后我们有了我们的分析的目的和思路之后，接下来我们就是去收集我们的数据，这个地方收集我们的数据呢。

就是我们想要分析一个场景下的一个分布，或者说场景下的一个数据，那么我们接下来就去需要收集，这对应场景下的数据，然后去做一个数据的一个统计，然后做一个分析和可视化，然后最终形成我们的一个报告。

这是比较传统的一个数据分析，它最终产生的产出的是一个报告，相当于是一个可视化的报告，但是呢在我们进行建模的时候，其实我们的一个嗯数据分析呢，不仅仅是去就是说最终是一个报告。

我们想要得出一些更加深入的一个结论，我们在进行一个数据分析的时候呢，我们不仅仅是需要撰写报告，可能呢我们还是需要做一些建模，这个地方呢，我们可以将我们的一个数据分析的过程呢，加入到我们的建模过程中。

我们可以将我们的数据分析呢，把它加入到统计学，就是说如如下的步骤啊，就是说如果是用传统的一个统计分析步骤，应提出问题，准备数据，收集数据，统计数据，建模分析得出结论，这个地方的建模呢。

就是说我们可以构建一个线性模型，线性模型这个线性模型呢就是说我们可以啊，我我提前假设一下，我们的数据它是如何进行分布的，那么我们就可以提前构建这个模型，然后再去分析一下模型它的一个预测的结果。

这这个呢其实他主要关注在我们的事后，就是说我们建模之后，你们我们去分析我们的一个模型的预测结果，它跟我们的一个真实的结果，是不是存在有一些偏差，在我们的做数据分析的时候呢。

其实可以把我们的一个分析的步骤呢放在事前，事前呢就是说我们在建模之前，我们就做一次数据分析，建模之前就做一次数据分析，或者说做多次，为什么这么说呢，我们数据分析，其实他是想要挖掘出我们数据的一个。

内部的分布规律，然后这个分布的规律呢能够帮助我们进行建模，能够帮助我们进行建模，因为我们在进行一个分析的过程中，其实能够找到很多的一些嗯具体的一些信息啊，我们在具体的建模的过程中呢。

数据分析它以及数据的清洗，数据的处理，应该是占占据了70%以上的，一个算法工程师的一个工作时间，也就是说70%的时间都是在做，跟数据相关的，而且它是我们在建模中最耗费精力的环节。

以是嗯能够挖掘出我们关键信息的一个环节，我们的一个具体的一个测谎工程师呢，他的一个就是说在做一个实践的过程中呢，为什么这个不同的人在进行建模的时候，得到的精度不一样，这个呢举举举个例子啊。

就相当于是我们在参加一个比赛，这个比赛呢，每个选手都是给了一个相同的一个data，以及我们现在这个Python环境下的model，这些模型都是现成的对吧，我们给定了一个现有的数据，现有的模型。

那为什么有的一个同学，他得到的一个模型的精度比较好，有的同学他得到的一个模型的精度就比较差呢，这个关键就在于，你的一个模型，是不是能够有效地对数据进行拟合，以及你有没有对数据集进行一个有效的理解。

所以说这个地方我们在进行建模的时候呢，数据分析它其实是可以帮助我们进行建模的，那么有同学可能就会问到老师，我们在做一个数据分析的时候，我也不知道到底怎么做啊，那么就可以看右边这个图啊。

EDA探索性数据分析就是我们这个地方探索型，探索型就是exploring对吧，E大写的E就是这个嗯就是这个缩写啊，那么我们在做数据分析的时候呢，就是按照这些步骤来进行展开，首先呢我们可以读取我们的数据。

并分析一下数据的质量，这个数据的质量呢你可以看一下我们的数据集，它是不是规整的，就是说如果读取的是这种二维的一个表格，那么我们可以看一下我们数据集是不是规整的，以及我们的数据集里面是不是存在噪音啊等等。

那么我们的这是，你可以首先呢从整体的表格来进行看，看完之后呢，然后接下来深入每个变量去看，就相当于是我们之前先看整体的这个二维的，然后接下来再去看每一列的每一列的这种情况，这个地方我们的一个每个列呢。

每个变量我们其实是能够分析很多东西的，我们分析的东西呢，可以就是说我们的每列它是什么类型的对吧，这个类型呢就是它的一个d tab对吧，它的一个类型其实会影响到我们如何进行建模。

也就是说我们的一个具体的一个变量，我们如何进行编码对吧，这个其实是会影响到我们的一次，其次呢我们的一个变量是不是有缺失值。

是不是有Missing numbered的或者Missing value的这种情况，这个呢其实也是在我们的现实生活中，非常非常常见的，我们的数据集呢，他可能是存这一列存在这种缺失值的情况。

那么如果是存在缺失值呢，那么额我们会将我们的一个具体的一个额，数据集啊，以及我们的一个变量做一个相关的处理对吧，然后呢，我们也会看一下我们的变量是不是有异常值，这个异常值呢就是我们的一个具体的变量。

它的如果是嗯数值类型的对吧，那么我们可以通过sin西格玛，就是我们相线图可以找出它的一个异常值，如果是有这种我们的一个类别类型的，那么我们也可以看一看他是不是有这种出现，次数比较少的一类对吧。

也是我们的一个异常异常值，然后呢，我们可以看一下我们的一个变量，是不是有重复值，就就是我们的一个变量，虽然说它是一列的一个，就是说它是一个列向量，但是呢这里面的每个取值，它可能并不是完完全全不重复的。

你可以看一下是不是有重复值，以及它具体的一个取值空间，这个我们都可以分析一下，其次呢我们在做一个具体分析的时候呢，我们还可以看一下我们的变量是不是均匀的，就是说我们的变量的整体是怎么分布的，这个呢。

其实这样对我们的建模也是非常关键的，那么我们当我们拥有了这么多信息之后，然后接下来就可以得出一个结论，就是说这个变量到底是类别类型的，还是数值类型的，还是文本类型的，它有没有缺失值。

它整体的分布是怎么样的，它有什么特点，它也没有重复值，那么我们有了这些信息之后，我们就需要决定我们的在进行建模的时候，这一列是不是需要做一个转换，我们在进行原始建模的时候呢。

我们假如说原始的一个data，它是一个10K乘以20的这种情况，10K乘以20的这种情况，20呢是我们的列，这也就是我们的一个具体的一个字段，10K呢是我们的一个样本个数，那么这个地方呢我们的20。

这个又又可以把它叫做变量啊，就是我们具体的每一列，那么我们这个20呢在我们进行建模的时候呢，其实并不是说所有的20，都要输入到我们的模型，我们有可能呢去选择我们的数据集里面的，有效的数据。

比如说选择得到了9K乘15，我们这个地方我们选就是相当于是有五列，我们把它剔除掉了，这五列，我们把它剔除掉了，还有我们的1K样的，我们也把它剔除掉了，我们这个呢就是说从我们的一个数据分析。

我们可以筛选得到啊，有效的一个数据，有效的数据好，那么有同学可能就会问了，老师我们怎么筛选啊，怎么筛选啊，其实这个筛选呢，这个其实就也是我们在做数据处理的过程中啊，在在这个数据的清洗的步骤啊。

可以得到的，我们在这个具体的一个缺失值的这一部分，就可以进行一个筛选，就是说如果这个字段，它的一个缺失值的一个比例，高达99%对吧，那么我们就可以考虑把它进行剔除掉。

因为它可能包含的一个信息就非常少了对吧，如果他的信息量就是他这个取值空间，就是完完全全是他的所有的一个字段，都是重复值对吧，那么我们也可以考虑把它进行剔除掉，因为他没有什么信息量好。

那么这个呃是我们的一个列列向量的一个筛选，那么对于行向量呢，行向量我们也可以看一下，是不是我们的样本是不是有重复的，我们的样本，它是不是呃也存在这种大量缺失的这种情况好。

这是针针对我们的单个变量的一个分析，那么我们的一个具体的一个分析呢，就是说不仅仅是分析这个我们单个列，他的一个情况，我们也会尝试去分析一下我们的一个变量，与我们的一个标签的一个关系。

假如说我们呢有了一个额，仍然是一个10K乘20维的一个数据，我们还有一列是我们的target对吧，这是我们的target，这个地方的20呢是我们的每列的一个，就是说20个字段啊，20个变量。

那么这个地方呢就是说我们的一去，需要做一个分析，就是我们的一个变量和target，我们的或者说和我们的label，是不是存在一个逻辑上的一个关系，对，那么这个地方呢也是对我们建模非常有关键的。

非常非常有作用的，那么如何如何进行分析呢，其实很很简单，就是看一看它们之间有没有相关性，算一算它的计算它的相关性的一个系数，比如算它的一个PR性系数，就可以很很简单的可以计算得到它的相关性，对吧。

当然如果我们提前知道这个变量，和我们的一个标签的一个含义，我假如提前知道它的含义的话，我们就直接可以看一看，他之间是不是存在什么业务逻辑对吧，这个也是非常非常有效的。

那么如果我们想要看一看这个标签与变量之间，它存在业务逻辑的情况下，我们怎么进一步做一个分析呢，我们在这个地方呢，就是到我们的这一步，我们在做一个具体的一个分析的时候呢，我们假如说有两列啊。

X1和YX1是我们变量，Y是我们的标签，我们想要分析这两者之间的一个相关性，我们在进行建模的时候，其实在建模的时候，其实如果我们从相关性的系数能够找到，它们之间是相关的，那么接下来怎么办呢。

接下来要做的一件事情，就是做一些统计的分析或者画图，做做一个统计分析或者画图嗯，我们举个例子啊，假如说我们这个地方的X1，它的一个是一个嗯类别类型的，它的一个取值是012，我们的标签呢是数值类型的。

它的一个取值范围是从0~100的，一个取值范围，X1是一个类别类型的标签，是一个数值类型的，如果我们从这个相关性的系数计算得到，这两者之间是强相关的，那么我们怎么做一个分析呢。

我们直接可以做一个统计对吧，我们group by，我们的一个X1，然后统计一下我们的标签，它的一个具体的一个均值对吧，也就是说对我们的一个具体的一个X1，进行分组。

在我们的一个样本X1取值为零的分组下面，他对标签的均值类似的，在一取值情况下的标签的均值，以及二取值下面的标签的均值，这样呢就可以进行一个分组的统计，然后做一个可视化，那么你就可以很清楚的可以看到。

在我们的X1它具体取值的情况下，我们的标签是如何进行一个分布的，也就是说我们的X1的具体取值如何影，影响我们的标签的这个地方呢，就是有会有一些细节，就是我们的一个变量。

如果这两个这个地方其实是我们的一个变量，和我们的一个标签，当然我们也可以以此类推，我们的变量与变量之间，是不是能够算一算它的相关性，然后做一个具体的分析呢，这个也是可以的啊，这个也是可以的。

我们在做一个分析的时候呢，这个地方就有一些细节，就是我们可以分析一下，连续型变量和连续性变量之间的一个关系，离散型变量和离散型变量之间的关系，以及变量之间它之间分布是不是有正态性好。

这些分析呢都是可以做的啊，那么这个分析的一个过程呢，其实就是按照这样一个逻辑啊，首先呢看一看数据质量，数据质量，这个质量是我们从整体行和列都可以看质量，这是第一步，第二步是看一下我们的每一个变量。

它的一个具体的一个取值，它的类型，看他单个变量的一个情况，然后接下来就看一看多个变量，两个变量之间他们是不是存在这个相关性，那么我们分析了这么多之后，是不是要得出一个结论呢，当然是的，我们得出一个结论。

就是如下的一系一系列的结论，首先呢我们的这个变量是不是要做筛选，是不是要做一个替换，以及清洗这个具体的一个字段，它是不是是有信息的，以及它的信息量，是不是跟我们的标签是强相关的。

这些呢我们都是可以做一个再做一个分析之后，我们得出的，其次呢我们这个变量是不是需要做转换的，他如果是类别类型的，我们怎么对它进行一个编码呢，好然后呢，我们的一个变量之间是不是可以做一个交叉。

它们之间是不是需要做一个演变，得到一个新的特征呢，然后我们的变量是不是需要做一个采样呢，这些都是可以做一个具体的一个分析的过程啊，做一个具体分析的过程，然后得到这些结论，得到这些结论好，我们继续。

那么在我们做一个具体的数据分析的时候呢，它不仅仅是我们算法工程师要做的啊，当然在一些具体的一些数据挖掘的竞赛里面，都是要都是可以做的，我们通过这个数据分析呢，我们可以得到最最重要的，可以得到这些结论。

第一个呢我们通过这个数据分析，我们可以得到我们在做这个建模的时候，我们使用什么样的模型，我们现在有非常多的一些模型，逻辑回归啊，SVMSVM啊，然后我们的树模型啊，然后深度学习的模型啊等等等等。

应该细数下来，应该就是说十几种上百种都是有的对吧，那么我们到底选择哪一个模型呢，这个呢就是说嗯可以这样做一个总结，如果我们的一个数据，它里面大部分是类别类型的，类别类型的就是类别类型的一个表格的数据。

那么我们用数模型会比较好，如果这个数据里面大部分情况下是数值类型的，我们用线性模型，或者说用我们的神经网络会比较好，数模型它其实对我们的类别类型比较友好对吧，然后他在做一个处理的时候。

也不需要对我们的数据集做一个one hot的处理，那么数值类型的数值类型，就是说它的一个每列的一个取值空间非常大，我们用数模型在数值类型比较多的一个，数据集上进行训练呢，训练的一个成本会比较高。

每列的一个搜索空间非常大，得到的效果也不会特别好好，这是第一个啊，就是说我们可以得到我们到底使用什么模型，第二个呢就是说我们可以得到，我们如何对我们的数据集做一个处理，这个做一个处理。

就是说我们的数据集怎么对它进行编码，怎么对它进行一个具体的一个就是说嗯转换，第三个呢，就是说我们能不能挖掘出一些新的特征，原始的一个特征，假如说是20个，我们其实可以做把它编码为40个。

50个甚至100个都是可以的，这些新的一个特征，其实在我们的原始空间内是不存在的，我们是可以通过一系列的方法把它编码得到，那么我们再做一个具体的一个嗯，数据分析的时候呢。

嗯我们是可以得到一些相关的一个结论的，我们仍然是以啊，上周各位同学学过的一个案例进行看一看啊，就是我们在进行一个需要根据这个房子的一个，具体的信息来预测一下房子它的一个热度。

或者说房屋的一个它的一个具体的价格对吧，那么在这个数据集的下面，那么我们拥有的数据，是这个房屋的一个基本信息，房屋的一个地理位置信息对吧，以及房屋的一个中介的信息，那么我们需要预测一下我们的房屋。

它具体的热度，那么在这个地方我们怎么做呢，我们在在这个地方做的时候呢，我们其实你可以只以这个房屋，它现有的信息做一个建模，但是呢其实我们是可以做这样一个思考，我们的这个房子它跟同小区的一个房子。

它的价格对比怎么样，这个房子跟相同中介的价格对比怎么样，这个房子在同和同等同等配置下面的价格相比，还是怎么样的，所以说这个这些具体的一个具，相当于是这些字段呢，都是会影响到我们租房的对吧。

这些字段也都会影响到我们具体的标签，这个思考逻辑呢有点像人的这种货比三家，这种逻辑对吧，那么在这个地方呢，我们这些逻辑其实它都是可以用，我们的pandas的这种group band来做一个实现。

pandas的group by怎么做呢，就是说，group by我们的一个小区对吧，然后算一下它的price它的一个平均值对吧，平均值这是我们的同小区的一个平均值。

那么我们再用我们的一个当前小区的一个价格，当前房子的价格减去这个平均值对吧，样本的一个字段减去这个平均值，就可以计算得到它的差价，那么类似的如果我们想要计算一下相同manager的。

就是group by manager，然后算一算它的价格的一个平均值对吧，如果是同等配置的，我们就对配置做分组，然后算下他们的价格，这些呢都是非常常见的，就是我们右边这种形式，对原始的数据集进行分组。

然后做一个具体的一个聚合好，那么在这个地方呢，就是说我们做一个数据的一个分析呢，它不仅仅是需要大家从这种思，这种思维方法来进行思考啊，就是说你可以作为这种特征，然后你去做了这种特征之后呢。

你可以做这样一个尝试啊，我举个例子，房子与本小区的价格相比，就是有两种情况呗，一种是高了，一种是低了对吧，这个房子与同小区它的价格相比，肯定是它的平均值相比，肯定是两种情况，高了或者低了对吧。

那么我们继续看一下，在这个房子比同小区价格高了的情况下，它的一个具体的标签的一个取值是怎么样的，以及这个房子与同小区价格低了的情况下，它的标签的一个取值是怎么样的，我们是通过这种方法。

你可以得到一个新的一个字段，然后再去看一看这个新的字段，和我们的一个label，它们之间的关系对吧，这个是很直接的，你的一个验证，我们的思路就可以通过这种数据分析的方法，直接去验证一下。

我做一个可视化或者做一个统计，就可以得到我们的这个房子和盆，小区价格高的情况下对吧，比本小区平均价格的价格更高的情况下，我们标签是怎么样的，我们如果跟我们本小区的价格相比，它更便宜更低的情况下。

我们的标签是怎么样的，这个就很直观啊，很直观，我想表达的意思就是我们通过这些思路，我们就可以进行一个数据分析，做完数据分析之后呢，我们就可以得到一个结论，这个结论呢就可以帮助我们。

就是说去验证我们具体的一个思路，那么这个地方呢就需要思考一下，就是我们的一个特征啊，在进行一个编码的时候，我们到底哪些我们的一个模型是如，他能够学习到呢，以及我们的哪些特征他是学习不到的。

嗯这个地方呢第一个我们特征如何进行编码，模型是能够快速进行学习的，这个呢是这样的啊，我们的一个特征呢其实它有很多种编码方法，额数值的我们的一个嗯嗯类别类型的，还有文本类型的等等等等。

这些具体的一个我们的一个特征呢，它是有很多种编码方法的，那么是不是每一种我们都是要尝试呢，嗯这个不是的啊，我们是需要根据具体的一个数据的一个分布的，一个就是字段的一个分布的规律啊。

然后再做一个进行得到一个结论，嗯这是第一点，第二点呢，就是说我们的哪些特征模型能够学习到呢，这个我们之前给大家稍微提到一点啊，哪些特征模型模型学习不到呢，比如说这个地方房子和本小区的一个价格对比。

这个模型能够学习到吗，对吧，其实这个模型是学习不到的，所以说呢这个地方我们是需要做这样一个思考，就是我们的一个具体的一个模型，它跟我们的能学习到什么特征，以及不能学习到什么特征。

那么如果我们在做一个具体构建特征的时候，我们是不是可以将人工，就是人工将这些模型学习不到的特征，把它构建得到对吧，把它构建得到，所以说我们在进行数据分析的时候呢，其实本质就是去挖掘我们的一个具体的字段。

它内在的一个规律以及它内在的含义，因为我们的一个数据其实他是不不会说话的，但是呢我们仍去是能够去挖掘我们具体的数据，它内在的一个规律的，所以呢我们在进行具体的一个分析的过程中呢。

我们其实就是需要将我们的具体的一些字段，进行一个具体的一个建模，然后呢我们可以对单个变量进行分析，对于我们的变量和我们的标签进行分析，以及进行我们的标签与标签之间，进行一个分析啊。

这个变量与变量之间做一个分析好，那么这个地方如果我们想要做一个数据分析呢，其实有很多种的一个具体的一个可视化方法，比如说我们嗯就是可以用来做一些呃，嗯比较类型的一个分析，以及我们的趋势类型的分析。

分布类型的分析，构成类型的分析以及联系类型的分析，这个地方呢我们就是从不同的一个可视化方法，然后做一个展示啊，因为我们的一个具体的一个，我们想要分析得到的一个结果是不一样的。

以及我们在做一个可视化的时候，而我们的一个元素构成是不一样的，比如说这个地方我们的一个嗯折线图，其实它的一个折线图呢X轴就是一个时间，X轴是一是是是一个时间，Y轴呢可能就是一个具体的取值，随着这个时间。

我们的一个具体的取值是如何变化的对吧，柱状图呢其实它是没有这种时间的概念的，我们的X轴可能就是每一类啊，每一类，那么这个地方我们不同的一个嗯，可视化的一个图表呢，它的构成元素不一样。

它想要体现的一个信息也不一样，那么这也是我们算法工程师要了解的啊，就是说我们拿到数据的情况下，我们怎么去做一个可视化，在我们的Python环境下呢，其实是拥有非常多的一些可视化的工具啊。

比较嗯就是说常见的是这个MATTPLEAVE，当然也有con嗯和boss啊，这个boss这个呢其实我也是用的比较多，但是我最常用的是matter pleap，当然也有一些比较高阶的啊。

就是说可以支持这个和我们的这个浏览器，做这种嗯交互的，比如说PY一下啊，Proxy，这些呢都是可以跟我们的浏览器做一个交互，也就是我们的一个鼠标呢，可以做跟我们的浏览器做一个就是说拖动啊。

然后进行一个汇总，然后做一个交互动态的这种绘图，当然还有这种跟我们的地图进行相关的，这种可视化方法，那么我们刚才呢就是讲了一下，我们的一个具体的一个嗯可视化方法，就是这个数据可视化。

其实嗯也是非常非常重要的，非常非常重要的，那么我们接下来第二部分，就是看一看我们的一个特征筛选方法，额特征筛选呢，其实是呃非常非常关键的一个环节啊，也是嗯在我们进行呢，就是说对于初学者而言。

这一部分其实可能会嗯有有一定难度，因为我们的特征筛选呢，其实他在做一个特征筛选的时候，假如说有20个特征，我们可能是只选择其中的十个特征参与训练，可能有十个我们就把它丢弃掉，那么在这个地方呢。

我们进行一个具体的一个嗯建模的时候呢，我们如何进行筛选，这十个特征可能就是我们的一个特征筛选方法，那么有同学可能就会有疑问，就是我们的一个特征呢，我们筛选之后模型的精度有变化吗，其实是这样的。

我们的一个特征筛选呢，它对我们的模型的精度是有争议的，是有争议的啊，我们先把这个PPT这一页给大家讲完，我们在做一个构建特征的时候呢，其实我们的特征它可能是存在有一定的一个，贡献性的问题，共线性的问题。

就是，他们之间可能是存在一定的一定的一个相关性，那么这个地方呢，我们可能是需要将我们的一个相关性啊，把它作为一个剔除对吧，但是呢这个可能是跟我们的一个模型，像模型有关啊，就是说我们的模型不同的情况下。

我们的这个操作也不一样，呃如果我们是用这种线性模型，那么我们就可能是需要考虑一下，我们的具体的一个共线性问题，但是呢如果我们使用的一个是数模型啊，我们就可能就不需要去考虑这种共线性的问题。

那么这个共线性问题呢，其实他是嗯就是说根本原因呢，就是因为我们的特征与特征值之间，是存在相关性的，那么如果你想要我们的用模型是完全可解释的，那么就需要去解决一下贡献性，但是呢在我们现实生活中建模啊。

现实生活中建模的时候，其实贡献性的，我们一般情况下不太会过多去考虑啊，因为我们现在呢可能用到是直接用到，线性模型的这种场景会比较少啊，那么我们在进行具体的一个特征筛选的时候，有没有一些具体的一些啊。

就是说方法呢，其实在我们的SKLN里面，都有一些具体的一些库可以进行使用啊，比如在s kn的一个feature selection的模块，就可以很方便地完成我们的一个，特征筛选的一个步骤。

当然这个下面也就是我们的具体的一些代码，实践的这个链接啊，我们待会也可以给大家演示一下，那么我们再回到我们的刚才那个问题，我们有20个特征的情况下，原始的特征是20个，我们可以构建得到很多特征对吧。

比如说我们grow by a求B的一个均值，对吧，或者说求B的一个最大值对吧，我们就是说grp by a求B的一个最小值，最大值平均值对吧，这些都可以得到一个新的特征对吧。

那么这样呢我们得到的特征其实20个，我们可以演变得到几百个甚至上千个都有可能，但是这些特征变多了，我们的一个模型精度一定是上升吗，这个不是的，我们的特征呢它变多了，他可能的精度会下降，可能精度会下降。

这是第一点啊，第二点呢，就是说我们如果这个特征的个数增变多了，我们的一个具体的一个模型，它的一个训练的速度会变慢，训练速度会变慢，因为我们在进行训练的时候，其实啊我们的这个机器的一个内存啊。

以及我们的一个资源是受限的对吧，那么在进行一个建模的时候，我们可能是需要用有限的一个特征进行训练，那么我们在进行建模的时候，首先呢就是关注第一点，就是我们尽可能的不需不要去产生很多特征，一方面呢。

我们在之前的一个one hot的一个知识点的时候，给大家讲了，我们在具体产生特征的时候呢，尽可能把这个维度啊，把它嗯就是把它压缩到一个范围内，不要产生很多的一些特征控制维度。

其次呢我们如果之前就已经有很多特征呢，我们就可以通过一系列的方法，去筛选其中的一些特征，一个很典型的，我们假如有原始有20个特征的情况下，我们可以筛选得到其中的16个特征。

或者说十几个特征或者几个特征参与建模，那么这个地方的特征筛选的这个步骤，其实它是一个很难的一件事情，为什么很难呢，原始的一个特征是20个，我们需要从中筛选16个，那么这个地方就是一个C二十十六的一个。

搜索空间，有这么多排列组合的一个就说特征，我们需要相当于是从20个里面进行一个，无放回的一个采样对吧，无放回的一个抽样抽样得到16个，这个地方其实这个数数值对吧，其实是非常大的对吧。

其实本质就是一个C24，这个是有几百甚至上千种可能性对啊，那么我们这个地方其实就是需要进行一个嗯，就是说搜索空间就是非常大的，那么我们在进行操作的时候啊，就是说有很多种特征筛选方法。

然后呢我们就给大家进行嗯简单的讲解一下，因为这里面其实是包含的一些知识点是蛮多的，我们在做一个特征筛选的时候呢，在我们的一些教材里面，其实他会讲到有我们的三种特征筛选方法，在我们的一个西瓜书嗯。

就是周志华写的一个西瓜书里面呢，其实他写的我们有三种特征筛选方法，第一种呢是基于我们的一个统计信息的，比如我们统计信息，就是说基于我们的一个方差，或者说我们的一个信息商。

或者说基尼指数这个字段的经理指数，这是基于统计信息的，第二种呢是基于基于我们模型的嵌入，这种嵌入式的嗯，嵌入embed，就是我们在这个具体的一个使用的时候呢，我们可以用这个具体的一个模型。

它输出的一个特征的重要性来做一个特征筛选，特征重要性对吧，然后呢还有一种是包裹式嗯，或者说是种迭代的方法，迭代方法跟我们的建模的过程中是比较类似的，就是说我们可以判断一下，我们有两个没加特征的时候。

我们的一个精度准确率可能是0。96，加了这个特征之时，我们的一个精度是0。97，我们的一个精度是不是有什么变化，它是上升呢还是下降呢对吧，那么在这个地方，我们其实就是可以做一个，通过这种方法来确定一下。

我们是不是保留这个特征，如果他加了之后，模型精度上升保留，如果模型精度下降，我们就把它丢弃掉对吧，当然这是比较常见的三类我们特征筛选方法，当然我们在现实生活中呢，可能嗯用到的一些方法。

就是说也会用到这三类中间的一些，当然我们也会用我们这个地方，PPT所展示的这些方法好。

我们就翻到我们的一个代码实践的这个过程中。

我们仍然是呃用这个特征工程的这个notebook，进行继续，我们在之前呢其实嗯给大家说了，我们的一个给大家讲了，我们的一个具体的一个特征重要性的这个东西，特征重要性呢其实它的一个具体的一个含义呢。

就是我们的一个feature，它的英文名字啊叫feature importance，特征重要性，那么这个特征重要性它是什么含义呢，我们来找一下啊，在原始文档里面，在我们的SKN我们可以搜索一下。

在它的API这个地方，我们可以搜索到所有的他的一个，具体的一个模型，我们找一下随机森林好，然后找到这个之后呢，我们再找到它的一个呃，他的attributes。

他的一个feature importance，对，那么这个地方呢，就是说我们在做一个fishing importance的时候呢，我们可以翻译一下，这个翻译其实也是蛮准的。

嗯在这这个地方呢就是它的一个feature importance，你可以理解就是一个激励指数，或者说一个具体的一个信息增益，在我们的一个具体分裂的过程中，如果用了这个字段做一个具体分裂，我们的一个标签。

它的一个纯度是不是有具体的一个变化，是不是有一个具体的变化好，那么这个地方呢，feature importance呢就是在数模型里面啊，我们就是用这个feature importance来衡量一下。

我们的一个具体的一个字段，它的一个重要性，那么我们在这个地方，其实在所有的所有的数模型里面，我们都是可以用这个feature importance，来做一个具体的一个操作的啊。

嗯这个地方其实它输出的就是一个重要性，那么类似的这是我们的一个LAHGBM，这个是我们的差距boost，那么我们在做一个特征筛选的时候，我们可以很很简单的就是说。

我们只保留我们的一个facial importance，里面最重要的他的两个特征对吧，重要性最高的这两个特征保留下来，把其他的给他，就是说丢弃掉这个其实是可以的，是可以的好。

那么我们就看一看具体的一些feature，importance的方法啊，在我们具体建模的时候呢，我们可以首先呢利用这些具体的一些信息量，来做一个筛选，嗯首先呢可以利用我们的一个具体的一些方差。

这个方差呢就是我们的一个可以统计一下，我们这个地方其实是一个呃多列啊，这就就是相当于是我们的一个我们的六列啊，六行三列，六行三列，在这个地方呢我们用六行三列的情况下呢，我们呢其实可以统计一下这每一列的。

它的一个就相当于是每一列它的一个方差，然后呢用这个方差去做一个筛选，如果这一列的一个方差，它是小于我们的excess后的，那么我们就可以把它进行一个丢弃掉对吧，这个呢就是说我们利用方差来做一个筛选。

这些呢都是在我们的一个SPN里面，有具体实现啊，当然你可以，你也可以直接用Python来做一个手动的一个计算啊，这个都是可以的，当然我们也可以利用一下我们的一个相关性，这个相关性呢就是我们可以计算一下。

我们的一个具体的一个字段，和我们的一个标签的一个相关性啊，这个相关性嗯你可以看一看，在这个地方，其实有很多的相关性的一些评价方法，嗯看一看SKN的官官网，对我们的离散离散的互信息，连续变量的互信息对吧。

然后通过这些具体的一些相关性，或者说我们的嗯，这个线性单变量的线性回归测试，通过这些相关性呢，可以计算得到我们的具体的一个变量，和我们的标签它是如何进行，就是相关的，那么在这个地方。

你会发现我们的一个RM字段和LSTAT字段，其实跟我们的一个具体的一个标签是强相关的，那么在我们的上面我们得到了一个feature importance，数模型的FISHORT。

其实这个结论其实和我们的一个相关性，也是匹配上的啊，也是匹配上的，那么我们也可以利用线性模型，它的一个具体的一个，就是拟合的时候的一个具体系数，我们可以来看看这个地方的系数呢。

你可以理解就是我们呃具体的一个权重啊，每个字段它计算得到的具体的权重，那么我们也可以看到这个线性模型，它得到的一个相关性啊，重要性啊，特征的重要性其实也是跟我们的一个数模型的。

feature importance是气候的，那么我们在进行建模的时候呢，我们也可以做一个迭代的一个剔除，就是我们在做一个具体的一个剔除的时候呢，我们可以把它通过我们的一个啊模型，把它进行迭代啊。

就是说把它这个具体的一个字段把它加入之后，或者把它删除，然后看一看我们的一个具体的一个特征，它所带来的一个精度的变化，好我们还可以做一个排列的重要性，这个排列的重要性呢其实是这样的啊。

他叫我们的譬如promutation importance，它其实是一个非常非常有效的一个方法，我们在进行一个具体的一个嗯评价的时候呢，我们往往是比较建议，从我们的一个精度去做一个评价。

就是说从我们的一个模型的精度，他的变化做一个评价，排列重要性呢就是说我们的原始的一个字段，我们原始字段，假如说它原始的字段都是有序的啊。

这个地方我把一个画图的软件给大家打开啊。

我们有一个字段，这个字段假如它原始的一个次序是12345，这是有序的，那么我们可以在这个有序字段的情况下，计算得到一个精度，假如他的一个准确率是0。83，那么我们接下来呢可以对这个这一列，做一个打乱。

把他的一个次序呢把它转成一个32154，把它打乱之后，然后看它的一个精度的变化，比如它的精度可能是把它变变到0。80了，这个精度其实是下降的对吧，从0。83下降到0。80的，那么这个其实是什么含义呢。

我们在做一个具体的一个统计的时候呢，我们可以看一下我们的这个特征，它打乱之后，我们的一个精度有什么变化，把这个把这这一列打打乱之后，然后看一看它的精度变化，如果他的一个具体的一个精度变化太大的话。

下降很多，那么就表明这个字段其实是有效的对吧，这些是有效的，也就是说我们通过这个精度的变化，其实是可以得到我们的一个具体的一个，重要重要性的一个额衡量的，这个呢我们叫做一个排列重要性啊，排列重要性。

那么在我们具体的一个做的时候呢，其实是可以很方便的，对这些你可以自己去计算一下这些重要性啊，当然呢我们也可以直接是用这个s kn里面的，一些具体的一些重要性的一些计算方法。

来得到我们的一个重要性都是可以的好，然后呢我们回到PPT啊，这个地方呢我们的一个呃mean in decrecy impurity，就是我们的一个类似于经济指数，我们的这是我们的排列重要性啊。

然后呢这三个呢都是我们在呃，也是一些具体的一些重要性的一些计算方法，当然我们在课程中间呢，我们由于时间原因，我们就不做展开讲，你可以从下面这些链接，找到他的一些具体的一些呃，就是说讲解。

我们再给大家讲一个特征重要性的筛选呢。

叫做一个line importance，Line importance，NIMPORTANCE呢，其实啊这个地方是我们刚才所列举到的一些，重要性的一些计算方法。

它的一个原理和它的优缺点嗯，大家可以下去看一下啊，看一下，一般情况下我们就是这个drop calcullum importance，就是呃把这一列丢弃丢弃掉，或者说把它进行加入之后，然后看它的精度变化。

我们的排列重要性，就去看一下它的一个具体打乱之后，然后看它的精度的向量好，那么这个地方呢我们还有一个就是LIMPORTANCE，LIMPORTANCE呢其实跟我们的一个排列重要性。

其实是呃非常非常类似的，呃就是思路类似的一种方法，他的这种方法呢，其实就是对我们的一个具体的一个，建模的时候呢，我们可以将这个具体的一个数据集，把它进行计算，这个特征。

它的一个feature importance，我们的一个模型，数据加上我们的一个模型，就可以得到一个重要性的一个取值，就是得到一个value，那么如果我们把这个数据进行打乱，打乱打乱一次。

我们可以得到一个新的重要性，打断两次，我们可以得到第二个重要性，那么这个LIMPORTANCE它其实是什么含义呢，它就是这样一个意思，我们的这个地方的一个红色的这个柱子呢，是原始数据的一个情况下。

我们的一个具体的一个特征的重要性，我们的这个柱状图呢是我们把这个数据，或者说把我们的标签打乱之后，然后再看一看我们的一个重要性，这个为什么是一个柱状图啊，因为他这里面其实计算了很多次，我们的一个重要性。

然后把它绘制的一个柱状图了，他是有多次的，那么这个图怎么看呢，其实这个图这是一个特征啊，这是一个特征，这分别左边的呢是一个分裂重要性，这是一个基尼指数的重要性，这都是一样啊，都是一样的。

那么这个地方嗯就是说左边的图，这一幅和GF是用同一个指标计算得到的，GF和GF都是用同一个指标计算得到的啊，只不过这一个是一个特征的啊，这是一这是一个特征的，我们可以看到左边这个特征。

他其实打乱之后的一个特征，重要性比打乱之前还高对吧，整体还高，或者说他们没有什么变化，但是我们看右边这个特征打乱之后的一个特征，重要性比他打乱之前正常的低很多，低很多，其实这个才是有用的特征。

这个特征就没有什么信息量，为什么呢，我们把这个数据给它打乱之后，这个特征的重要性仍然很高，那么就说明这个数据它是不是有序的，对我们的一个具体的一个，就是说最终的一个精度，或者说重要性是没有影响对吧。

其实我们其实在进行建模的时候，如果这个数据有序的话，那么我们尽可能的我们的模型呢，它可能就会去使用，得到这个真实的一个数据的里面次序，反而呢就是说如果这个次序打完之后。

他的特特征重要性呢就可能是这种随机的对吧，随机的，那么这个呢就是一个LIMPORTANCE的思路，那么我们怎么怎么实现的，这个思路呢其实也非常简单啊，我们首先能得到一个具体的一个呃，就是写了一个函数。

叫做get feature importance的这个函数，在这个函数里面呢，我们传入数据，传入我们标签以及传入一个SHUFF的命令，这是SHUFF的一个参数，然后呢控制一下我们是不是打乱。

然后呢这个地方我们这个如果是shuffle呢，我们就对对我们的标签进行杀普啊，这个地方我们不是对这个列做杀F，我们是对标签做一个杀破这个shuffle呢，为什么对标签做一个SHUFF呢。

就是把标签打乱呢，因为我们如果是打乱一列的话，那么我们接下来就说我们如果打乱一列，而不是打乱标签的话，我们只是得到就是他的思路，是跟排列重要性是类似的，但是如果我们打乱标签的话。

其实是可以得到所有的一个数特征的，一个重要性的对吧，可以得到打乱之后这所有的一个特征的重要性，它跟排列重要性其实非常类似，但是其前者是打乱数据，后者是打乱我们的标签。

那么我们首先呢记录一下我们的原始数据集，原始的数据和原始的标签，在没有打乱之前，它的重要性就是我们的红色的一个柱子，然后接下来呢我们就可以对我们迭代40次，把我们的一个具体的一个标签呢打乱40次。

这个地方我们设置一下，我们的一个shuffle为true，循环40次，打乱40次，也就是说每次的都是一个把我们的标签，随机把它打乱啊，这个地方把它SHUFF一下，那么打乱之后呢。

我们就可以对我们的一个具体的一个记录一下，打乱之后我们的一个特征，它的一个具体的一个FASHIIMPORTANCE，那么这个地方我们训练得到了40个模型，然后就有40个我们的一个嗯。

打完之后的一个重要性，然后就可以绘制得到类似的一个图片，这个红色的一个柱状，柱子是我们的原始的一个特征的重要性，这些就是我们打乱之后的对吧，这个地方我们很明显的可以看到这个红色的，它的一个重要性。

原始的重要性是比他打乱之后的一个特征，重要性高很多的，就表明这个特征其实是有用的，那么我们就再来看这个打乱之后的重要性，反而比他打乱之前的重要性更高对吧，我们去表明这个特征其实是没有什么用的。

好这个呢就是一个lie importance的一个方法啊，其实也是非常非常有效的一种方法，额那么我们稍微休息一下啊，我们休息到九点钟，然后我们继续好不好，对我们休息一下啊，这个手机用户679415同学。

对我们休息一下啊，如果大家有问题啊，也可以进行一个提问，好，嗯然后我们继续啊，然后呢我们在第三部分呢，我们就看一看机器学习的一个，具体的一个案例流程，其实我们在做一个具体机器学习的，一个建模的时候啊。

我们是根据数据不同啊，我们的一个建模的一个流程是不一样的，但是呢我们整体而言，其实嗯大部分情况下呢，我们是可以划分成如下几个步骤啊，首先呢是我们进行一个具体的，根据给定数据的情况下。

我们需要理解一下我们的背景，理解一下我们具体的任务，以及理解一下我们具体的一个评分方法，和我们的赛题时间，然后呢，我们这个具体的一个，就是说我们的时间轴背景任务，然后了解到这个具体内容之后呢。

然后接下来就对我们的数据集进行嗯，一个就是说理解，那么这个地方的一个，就是说数据集的一个理解呢，就是我们是可以对应我们的数据集，看一下数据分析，数据理解，然后看一看我们的数据集，是不是需要做一个处理。

然后第三步呢是对我们的数据做一个特征工程，这个特征工程呢，我们是需要对我们的具体的数据集呢，看一看是不是需要对它进行一个转换，以及是不是对我们的数据集进行一个构建，以及具体的特征筛选的方法。

然后第四步是我们构建模型，我们的模型呢，我们是看是要看一下我们的具体的数据集，是不是呃就是说啊怎么构建模型，然后怎么训练模型，怎么验证模型，然后以及怎么进行一个模型的调参。

然后接下来做一个我们的一个预测，其实我们的完整的建模流程，其实是按照这样一个思路来进行的，那么我们在进行展开的时候呢，这个地方其实是有非常非常多的一个嗯，一些案例啊，比如我们这个地方，如果各位同学比较。

就是说想要深入学习一下结构化的数据挖掘，这个地方都是有一些在开关上面，有一些具体的一些比赛啊，然后呢这些都是结构化的一些具体的一些案例，然后你可以进行一个学习，那么我们直接到我们的第第四部分，好吧。

我们第四部分呢就是讲一个具体的一个，金融风控的一个具体的一个案例，这个呢也是一个结构化的一个数据啊，结构化的一个数据，结构化，那么这个非结构化的数据呢，就是说文本和这个我们的一个额。

这个图片的类型的数据啊，他不是我们今天所讲解的一个重点啊，当然我们待会呢也会有一个具体的一个案例，给大家展开，我们在这个具体的一个嗯实践案例里面呢，我们是以这个利民的一个金融风控的一个比赛。

来进行展开讲解啊，这个是一个真实场景下面的，一个具体的一个比赛，那么在这个比赛里面呢，他是这样的一个问题嗯，基于这个消费金融以及小额现金贷，也就是一个PDP，PDP的一个贷款的一个场景。

我们需要构建一个准确的一个风险控制模型，分析和评估用户的一个信用状况，这个地方的一个用户的信用状况呢，就是说我们是需要预测一下他是不是违约，用户本质上就是对我们的UU用户，把它做一个分类。

他在进行这次贷款之后，他会不会就是说有违约的一个行为，会，或者说会不会嗯，是正常进行一个额还款的这种行为对吧，那么这个就是是不是违约的这个判断，这个其实是一个二分类二分类的一个问题。

然后呢是采用这个AABC值来进行衡量，我们的一个结果，UC值越高，然后他就是表明我们的一个模型的一个，精度越高，那么这个地方我们在进行一个建模的时候呢，我们的一个具体的一个数据呢。

其实它是非常非常呃难的难的一件事情，因为数据呢可能是有以下一些难点，然后呢我们的数据的维度它可能是嗯比较高的，总共原始的一个数据呢可能是有几百维，然后呢这个原始的数据集里面呢。

有可能有一些数据是这个类别类型的，有一些数据呢可能是这个数值类型的，量纲是不统一的，其次呢这个数据呢是匿名的，匿名的一个意思呢，就是说它的一个数据呢，嗯这个字段是不知道它的含义的。

是不知道它的一个含义的，那么这个地方呢嗯在我们进行一个建模的时候，我们如果不知道这个字段的含义，那么我们其实很难对它提取一些新的特征，而且呢我们在进行建模的时候呢，我们也不知道我们的一个数据的一个特征。

它如何进行验证是比较有效的，比较有效的，那么在进行一个建模的时候呢，我们是需要考虑这些问题的，金融风控，其实它本质是对人，或者说对用户做一个具体的一个二分类，零一的一个判断对吧，违约还是不违约。

在这在这个地方呢，我们在进行一个建模的时候，我们是需要考虑一下我们的原始数据集里面，它是存在有哪些我们的一个嗯字段，以及这些字段跟我们是哪些，就是是我们的一个具体的一个，跟用户相关的一个字段。

那么我们也需要考虑一下这个特征，它的量纲就是它的单位啊，它的单位和它的具体的类型，以及它们之间是不是有相互关系的，这些呢都是需要考虑的啊，我们在进行建模的时候，这些都是要考虑的，而且我们是需要考虑到。

我们这个特征到底是有效的还是无效的，也就是说我们是需要考虑一下我们这个特征，它保留下来比较好，还是把它剔除比较比较好对吧，这些都是需要考虑的，我们在进行建模的时候，如果我们不去考虑这些信息啊。

都会对我们最终精度有影响，所以说在进行数据挖掘，数据建模的时候，核心的关键点在于能不能找到数据里面，它核心的这些字段，把它进行进行转换，也就是找到我们数据集里面，它有效的一个具体的一个数据。

剔除无效的一个数据，然后把我们的数据转成它最有效，最有效的一个表现形式，这个地方我们是需要人工进行参与的，也就是人工特征工程，人工特征工程，那么这个地方呢，我们在进行一个具体建模的时候呢。

我们就只需要做这样一些操作啊，关键是在于数据的一个理解，那么我们接下来看就一步一步啊，看一看我们怎么理解这个数据的，我们在这个地方呢，我们首先呢可以做一个缺失值的一个分析，缺失值啊。

就是这个Missing value的一个分析，缺失值的分析，这个缺失值呢就是说他在分析的时候呢，我们这个地方来绘制的一个图片，就可以进行绘制，我们的一个训练集和我们的一个测试集。

看一看它的一个具体的一个相关性，这个地方呢，我们把会训练集的一个缺失值的一个情况，和我们的一个测试集的一个缺失值的情况，然后给进行了一个可视化，在这个可视化的过程中呢，我们可以看到啊，这个地方。

我们训练集的X轴，其实是我们的一个500多个特征，Y轴呢是我们的一个具体的一个嗯，就是说这个字段它缺失缺失的一个比例啊，我们这个地方把它绘制得到的一个折线图的，那么这个地方我们来看一看，这个是上面的。

这个是训练集的所有特征的一个缺失的情况，下面呢是我们的一个测试集的一个，缺失值的一个情况，那么我们可以看到在这个地方呢，训练集和我们的测试集，它整体的一个缺失的一个情况啊，从这个缺失比例的一个情况来看。

他整体是比较一致的，就是我们的训练集和测试集，数据上是比较一致的，是比较一致的，第二个呢就是说我们的这个数据集里面，从缺失值的一个情况呢，我们可以看到他有一些字段是严重缺失的，在这一部分。

这部分呢是在特征呢500多个特征的特征字段，500多的时候，它的一个缺失是嗯基本上接近于一的，那么在这个地方我们是可以考虑啊，去把它剔除掉，因为他缺失值实在是太大了。

它主要集中在第三方征信的一些特征字段上面，我们首先呢通过这个缺失值，是可以得到一个两个结论啊，训练集和测试集同分布，以及我们的原始字段里面，存在了较多缺失值的一个具体的一个情况。

那么这个地方其实有一个一个，非常关键的一个点啊，训练结构测试集同分布，这个其实是我们在建模的时候，一个非常关键的一个点，我们在进行建模的时候，其实我们是在一个训练集上进行训练模型。

然后再到我们的测试集上面做一个预测对吧，这是我们的一个训练和我们的一个预测嗯，我们的机器学习的一个模型呢，它在有一个在进行建模的时候呢，有一个前提，也就是我们的一个训练集和我们的一个测试集。

它是整体同分布的，我们接下来得到了一个几嗯，具体的一个预测才是比较呃有效的，因为我们的一个具体的一个训练集和测试集，如果它的一个数据是整体同分布的，那么我们在训练得到训练集。

得到的一个模型才是在我们的测试集上面，有可能是有效的，有可能是有效的好，那么我们在进行建模的时候呢，我们怎么进行分析它是不是同分布呢，这个地方我们是从我们的一个缺失值的情况，来看一看。

训练集和测试集是同分布的，当然也可以从其他的一些角度啊，比如说嗯这些字段它的一个各自的一个平均值，然后绘制得到类似的图片，就是说做一个可视化，然后可以得到类似的结论。

那么如果这个训练集和测试集是同分布的，那么我们的一个具体的进行建模的时候嗯，他的一个是比较好的，我们的构建得到的模型才是比较好的，那么有可有同学可能就会有嗯，问到。

就是说如果训练集和测试集他不同分布怎么办，如果不同分布的话，我们可以对我们的训练集做一个采样对吧，尽量可以采样得到给我们测试集，分布比较一致的，分布比较一致的好，我们接下来呢可以对我们的一个原始的一个。

数据集呢做一个额这样的一个分析啊，这个分析呢，就是我们可以将我们的一个具体的一个数据呢，把它对它的一个每部分的一个特征呢，进行一个嗯相关性的一个分析，这个相关性的一个分析呢其实就是这样的啊，就是这样的。

就是我们可以把这原始特征把它拆分为，基础信息，通话信息和第三方信息这几部分，然后呢可以看一看这每一部分的一个特征之，间的一个相关性，一个相关性嗯，这个呢是所有所有特征的啊，所有特征是包含基础特征。

通话信息和第三方征信，这三部分信息的一个具体的一个特征的啊，那么我们看一看这个所有特征的，在所有特征的这一部分，其实你们可以看到这个有一些这个地方，其实就是一个热力图啊。

叫做一个hmp h mp的这种热力图颜色越深，就表明这个地方是零啊，这个地方是正一，这个地方是一，正相关负相关颜色越靠近一就是正相关的啊，靠近于一就是一个负相关的。

那么这个地方呢我们在进行一个建模的时候呢，其实本质就是需要考虑一下我们的基嗯特征值，特征之间相关性，然后这个地方其实是一个对角矩阵啊，对角矩阵沿着我们对角线，它是一个对角矩阵。

这个地方呢我们的一个基础信息，我们来看一看他们之间，这个这个基础信息应该只有十几维啊，十几维，那我们看一看基础信息和基础信息之间，它是有强相关的，通话信息，通话信息就是一个电话。

电话就是你的电话的一些记录啊，电话的一些日常的信息啊，那么电话信息之间也是有相关性的，第三方征信里面也有很多强相关性的一些特征，而且他们是分组出现的啊，比如说这个地方是一组，这个地方是一组。

这个地方是一组，很明显啊，很明显，然后在这每组里面，其实有这些小的相关性，很小的一些相关性，那么我们通过这些可视化，可以得到一些什么结论呢，首先我们的这个特征呢它是分成三部分的，分成三部分的。

那么在这三部分中间呢，特每一部分的特征，他们基础信息和基础信息是强相关的，有些字段通话信息和通话信息，有一些是强相关的，但是这两者之间是没有强度相关的，我们从这个可视化的图里面可以看到啊。

这两种两类特征之间其实是没有强相关的，是没有强相关的，那么在这个地方呢我们可以得到两个阶段，第一个就是同类特征之间是存在，可能存在一些强相关性的情况，第二个呢就是说我们的一个原数据集里面。

是很多特征是完全重复的，因为他的一个颜色啊，这个地方的颜色是非常非常高的，颜色非常非常高的好，那么我们就继续，那么我们通过刚才的一个分析呢，就是可以对我们的数据集做一个相关的处理啊。

就是对我们的一个具体的一个数据集，把它作为这样一个处理，首先呢我们对这个数据集呢，把它的一个通过这个数据呢，可以剔除它的一个嗯无效的一些信息，信息量比较小的以及分布不一致的一些信息。

比如说我们在进行剔除的时候呢，我们可以对我们的一个具体的数据集嗯，做这样一些操作，我们剔除一下它的一个缺失值，它的一个列确实比例大于0。97的，大于0。97的这个情况对吧，这些列都是可以进行一个剔除掉。

其次呢我们可以找出我们的一个数据集里面，它的一列里面方差比较小的，方差比较小的，这个方差比较小的，就是我们可以进行一个嗯把它统计一下，一列它的一个信息量，算它的信息差，或者说算它的方差。

就可以直接得出它到底哪些特征，是信息量比较小的，然后可以剔除一下分布不一致的特征，分布不一致呢其实是这样的，就是我们一个特征呢，在训练集上的一个取值分布，和我们在测试集上的一个取值分布。

假如说他在训练集上的一个取值是零一，然后呢在测试集上的一个取值呢是013，那么这个这个字段呢，我们就可以考虑将它剔除掉，因为这个地方其实呃，我们这个地方有三的这个取值，在我们的训练集里面是没有见过的。

那么如果将这个特征进行建模呢，其实很有可能就会影响到我们最终的精度啊，影响到我们最终的精度，这个是我们的特征维度的一个分布一致性，那么通过这个清洗啊，其实我们是找到有效的特征啊，这个特征呢它是有效的。

其次呢它是能够保证我们的特征嗯，在训练集和测试集的一个维度上面，是很同分布的，其次呢我们在进行一个嗯进行筛选的时候呢，我们其实是将有效的一个信息，信息量比较大的一个特征，把它保留下来了，把它保留下来。

当然我们在进行一个统计的时候呢，也可以做一些数据分析，可以找到我们的一个具体数据，它的一些很原始的一些类型啊，就是说我们的一个特征一和特征，14是一个金额相关的特征特征，二是工资类型的特征特征。

12是年龄类型的特征，然后有同学可能就会问到老师，你怎么得到，就是说我们的一个特征，它的一个具体的一个含义的，其实是这样的啊，嗯我举一个例子啊，就是说我们的年龄，这个年龄呢就是说我们这个具体的一个信。

就是说信贷贷款的一个时候呢，他肯定是要大于18岁吧，然后呢他一般情况下可能是小于60岁吧对吧，所以说呢如果发现一个字段，他的一个取值呢，大部分情况下在大于18岁，以及在60岁以内的范围内。

那么我们我们就可以推推断，他其实是一个我们的一个年龄类型特征对吧，那么如果是工资的工资，我们一般情况下就是上千的对吧，上千类型的，那么这是我们的一个上千类型的一个，具体的一个呃字段。

那么我们是可以相当于是啊，推断它是一个金额相关，当然还有一些字段是我们的一些文文字类型的，比如我们的这个具体里面，假如我们发现它里面到底是有跟职位相关的，对吧，那么我们就可以我要推算推导。

或者说推算他是一个嗯就是跟我们的一个额，就是职位相关的，当然还有一些跟我们的地理位置相关的啊，地理位置相关的好，那么通过这些具体的一些特征构建完成之后呢，我们可以得到一些具体一些嗯就是结论啊。

就是说我们是勾可以得到这个具体的一个用户，他的一个具体地理位置信息，那么通过这个地理位置信息呢，我们其实可以提取一个更高阶有效的特征，就是这个地理位置的特征，因为我们的这个具体的一个有。

我们可以推导得到，它到底哪些字段是跟着我们的地理位置相关的，对吧，那么我们就是可以进行一个可视化，我们可以计算一下我们的一个具体的用户，它到底是呃位于什么省份，那么我们可以得到这个信息之后呢。

然后可以计算得到我们的一个具体的一个用户，他这些信息，比如他在我们的一个具体的一个嗯具体的省份，它的一个编码，以及它在城市上面的编码，那么通过这个呢我们可以得到这样一个热力图。

这个热力图呢就是我们可以进行得到每个省份，它的一个违约的比例，然后按照全国做一个编码，这个其实是基于省份的一个target encoding，基于省份的一个TK型库里，就是grp by我们的。

然后统计一下我们的一个具体的一个标签，他的一个平均值对吧，那么这样呢就是说相当于是也是做一个targeting，encoding啊，好那么通过这些信息呢，我们就可以对我们的一个具体的一些字段啊。

把它作为一个具体的一些，相当于是将这个地理位置信息把它编码进来，那么有同学可能就会问到老师这个地方啊，为什么这个四川和这个山东颜色比较红啊，这个呢是它的数据集分布的啊，我们有我们有地理歧视的一个意思啊。

这个地方呢由于这个是复嗯，就是说是这种金额放贷啊，或者说跟这种金额相关金，或者说跟金融相关的金融呢，它可能是这种嗯有这种诈骗团伙啊，或者说有这种区域内部的这种联系啊。

可能说他跟我们的一个地理位置志强相关的，所以说呢我们在这个地方其实是嗯，非常建议可以将我们的地理位置信息，把它加入进去，或者说按照经纬度把它聚类到一些具体的一个，区域范围内好，那么其次呢。

我们也可以将我们的一些具体的特征呢，做这样的处理，比如我们可以将这个特征呢，把离离散的特征呢把它连续化，或者说把连续的特征把离散化，离散的特征进行连续化呢，就是我们是可以把它嗯。

通过这种类似于embedding的操作，把它进行连续化，连续特征进行离散化呢，就是类似于这样的啊，我们是可以将这个特征，这个地方的X轴呢是一个order，把它排完序之后啊，排完序之后。

所有的一个order y轴呢是它具体的取值，也就是说我们把这一列把它排完序之后，然后从小到大画一个散点图，X轴是它具体排完序之后的一个次序，Y轴是它对应的一个取值好。

那么这个地方呢我们通过这样的方法就可以画，绘制得到这样一个散点图，我们很清楚的可以看到，在这个含点散点图里面是分分成三层的，这是第一层，这是第二层，第这是第三层对吧，分成三层的。

那么我们可以提前将这个特征，把它编码为123，对我们123对吧，按这样进行一个分箱其实也是非常非常有效的，那么我们还可以做什么呢，我们还可以做一个交叉特征，交叉特征呢。

就是说我们可以对这两个特征进行一个交叉，然后得到一个新的特征，然后呢我们的交叉特征它在做什么呢，交叉特征，其实这个地方其实本质上就是有了一个特征，A和一个特征B，我们是需要构建一个新的特征。

这个地方我们关键的点就是，我们的一个交叉特征，我们如何进行提取，以及我们的一个提取之后，我们如何对这个加拉特征进行一个选择，我们的一个交叉特征呢，其实我们进行提取的时候呢。

优先去通过数据分析看一看这两个特征，他们之间值不值得交叉，以及它们之间的交叉是不是存在有意义的啊，我们可以做这样一些可视化，我们左边的呢是一个嗯，这是我们的训练集，这是我们的测试题。

然后分别是我们的特征一和我们的特征，14的绘只得到一个散点图啊，这个具体的X轴是我们特征一，Y轴是我们的特征，14左边的小图是我们的训练集，右边小图是我们的一个具体的一个好sorry。

这个地方应该说错了啊，这是我们的一个标签为零的，NEO为零的啊，就是说我们的label为零的，这是我们的label为一的，就是说这是我们的不同标签情况下，的一个散点图，我们可以很清楚的可以看到。

就是说我们标签为一的情况下，标签唯一的一个情况下，它的一个散点，它的样本分布大部分分布在两条直线上面，我们标签为零的这个样本，它不仅分布在这两条直线上面，还有一些是不在我们这两条直线上面的对吧。

所以说呢，这个地方我们其实就是嗯可以得到这个结论，就是说我们的标签零和标签一，这不同类类型的样本，其实它在我们的一个具体的一个两个特征特征，一和特征14的一个笛卡尔级的空间内，是可以把它分开的。

那么我们有了这个结论之后呢，我们就可以将这个两个特征把它构建，得到一个新的特征对吧，我们可以将这个特征特征一，特征14除以特征一，然后得到一个新的特征，V1除以特征14，构建一个新的特征。

这个特征有什么含义呢，就是衡量一下这个节点，他在不在我们的一个具体的两条直线上面，通过这个斜率来进行一个表示对吧，类似的，我们可以看到这个特征六和特征12，这两个分布其实也是在这个散点图。

也就是说我们笛卡尔级空间内，它也是分布不一致的，那么我们就可以通过优先，可以通过这个具体的数据分析，然后又可以可可以得到具体的这些信息啊，那么接下来就可以得到，我们具体是不是需要将这些特征做一个交叉。

那我们就可以看一下，就是说我们做的这些我们最终精度如何，其实我们在做一个嗯特征筛选的时候，其实不仅仅是可以从这个特征重要性，以及拿importance做一个筛选，我们有很多种筛选啊。

比如说我们可以通从这个特征的一个，具体的一个嗯分裂次数，它的一个具体的一个激励增益，以及这个特征它是不是被使用，以及这个特征，它的一个叶子节点的一个样本的数量，等等的一些维度来做一个具体的特征筛选。

这些都是一些筛选的一些方法，那么我们在做一个具体嗯筛选的时候呢，其实我们带来的精度也是非常高的，我们的原始的一个特征的维度是533位，那么如果我们是将这个533维的一，个特征，把它进行一个筛选筛选。

这个地方的筛选呢，我们是用这个x g boost嗯，以及我们的方差，以及我们的一个具体的一个缺失值的一些方法，来做一个筛选，筛选得到的其中的一个300多维特征，我们的一个精度其实是上升很多的，从0。

75上升到0。847，其实是上升很多的，因为我们的一个原始的一个额特征，它可能并不一定是有效的，我们这样的筛选呢，其实是将有效的特征把它保留下来，然后接下来我们可以将一些具体的一些特征呢。

做一些编码和它做一些预处理，做了之后呢，我们的一个精度也依然是会上升，上升了一个七个千分点，然后呢我们再做一个具体的一个编码之后呢，然后可以加入我们的一些地理位置的特征。

这些地理位置的特征呢也可以做一个进，具体的在精度上有些增高，然然后呢也可以做一些交叉特征对吧，然后可以做一些分析和排序的这些特征，这些呢都是可以就是一步一步，对我们的一个模型的精度有增加的。

所以说我们的一个具体的一个，模型的一个评价啊，他从我们的精度来看，其实是非常非常直接直观的，我们的每一步都会带来我们的模型的精度增加，那么有同学可能就会问到老师，我们把这个顺序把它调调嗯，调换一下。

我们先做特征的预处理，然后再剔除特征行不行，这样也行，但是呢其实我非常建议你先做剔除特征，因为这个地方的剔除特征呢，我们是用一些常见的一些指标嗯，缺失值啊，方差以及分布不一致，这些指标来得到的这些方法。

它得到的一些操作呢，可能会更就是说得到的一些操作嗯，得到的一些特质量都是非常稳定的，所以说它会更加有效一些，你也可以看到最终的一个精度的增益，是最大的啊，是最大的，好。

我们就来看一看这这个具体的一些一个实践啊，他的代码是怎么写的，嗯这个代码呢我们待会也会发给大家啊，这个地方的原始数据呢，就是一个嗯CSV给定的啊，一个训练集和我们的一个测试集，然后我们的训练集呢是呃。

有我们的一个534列，有一列是我们的target式，然后我们也给定了一个具体的一些字段，的一个类型啊，他到底是类别类型的还是一个数值类型的，那么我们可以可以看一下我们的这个代码。

嗯我们在做一个具体的一个建模的时候呢，我们我这个地方是呃一个写代码，我这个是我之前啊写的一个具体的一个参加的，这个嗯项目的这个代码，然后呢在写的时候，你可以参考自己的一个写法啊。

然后或者说一些你的一个习惯来去清洗啊。

我把它打呃，在本地打开可能会更加清晰一点，人家写的时候呢，你我非常建议你的代码呢，可以把它按照这种函数的形式，把它进行一个呃整理整理起来啊，然后这样整理起来呢就是非常直观啊。

非常直观，我们就一步一步啊，首先呢是读取数据啊，这前面是定义函数啊，嗯以及导入模型啊，首先读取数据，读取数据呢，这个地方其实就是你把我们的数据值，数据集呢直接用pandas as把它读取进来啊。

这pandas把它读取进来，当然这个地方，我们是把训练集和我们的一个测试集呢，把它拼接到一起，如果把它拼接到一起呢，接下来我们就是只用处理一个表格就行了啊，只用只用处理一个表格就行了，然后接下来呢。

我们对我们的数据集做一个预处理，预处理，在这个预处理的函数里面呢，我们可以做这样一些操作，我们可以统计一下，我们的具体的一些缺失值的一个比例对吧，缺失值的一个比例，然后呢嗯这个缺失值的比例呢。

就是啊它的一个具体的一个比例，大于0。97对吧，然后我们就可以考虑把它进行一个剔除，然后呢我们在这个具体操作的时候呢，我们也可以考虑一下把它剔除，他的一个具体的一些嗯从方差的角度嗯。

可以考虑把它剔除对吧，然后呢你可以考虑你从我们的一个嗯，就是说分布是不是一致的这种情况下，然后可以把它剔除，这个剔除呢就是看它的一个具体的一个每一列，它的取值的个数对吧，他是不是一致的。

训练集的一个取值个数，和我们的测试集的一个取值个数是不是一致的，都可以进行一个剔除，当然这个地方我们是我是没有做，这个就是说离群点的一个处理啊，离群点的处理是没有的，然后呢。

我们就可以对一些具体的一些字段规，做一个归并哦，可以把这个这样可能会稍微直观一点啊，作为规避呢，就是说我们的一个原始的一个列，假如说这一列是一个职业信息的这一列，假如说这一列是一个职业信息的这一列。

我们其实是可以可以对这一列呢做一把，它的一个取值呢，把它做一个归并，如果他是嗯公务员或者说军人，我们可以把它划分为国企事业员工对吧，这样呢把它作为规避呢，其实是可以将他的一个具体的一个。

然后取值空间把它变小，取值空间把它变小之后呢，我们的一个具体的一个嗯，就是说列的一个就是说取值会变小，那么它可能会更加有意义啊，会更加有意义，因为原始的一个列的一个字段呢，可能是非常大的啊。

它可能是原始的一列，它的一个取值空间非常大，但是呢它的一个太大了，并不一定是嗯一定是有效的，我们是可以将它其中的一些字段，把它做一个合并对吧，嗯这个地方什么私企员工，这些其实都是私企员工对吧。

我们把它做一个合并，其实这样呢是更加有意义的好。

然后接下来呢我们就是做一个特征工程，这个地方的特征工程呢其实没有做很多啊，首先呢是对我们的一个地理位置做一个编码，地理位置呢这个地方其实是需要嗯，就是说嗯就是把他的一些到底是事嗯。

然后还就是说它到底是县，以及它的一个具体的地理信息，你把它进行一个提取，这个地方它原始的一个数据呢是一个字符串的，我们就去解析一下它自转的一个取值，是不是嗯，就是说我们的一个啊。

就是说现存不存在相关的一个情况，然后呢，我们接下来可以对我们的一个具体的一个城市，做一个编码，这个城市呢我们这个地方是将啊，这些相关的城市，一线城嗯，一线城市，二线城市，三线城市等等。

这地方是啊随便额选择了一个，就是说城市的分类比例啊，分隔的一个标准对吧，北上广深，然后天津把它划成一线城市，那么这样呢，我们是可以将我们的一个具体的一个城市，把它做一个编码，然后对我们的城市做一个分级。

然后呢，我们也可以计算一下这个城市的一个经纬度啊，城市的一个经纬度，然后接下来对这个经纬度呢把它做一个具，当做一个具体的一个特征，然后接下来是构建一些交叉特征，特征，30除以特征，50特征。

26除以特征113对吧，这些都是交叉特征，然后有加减乘除啊，这些特征都是非常非常基础的，加减乘除的好，然后呢我们还可以做一个text encoding，Target encoding。

这个地方其实本质在做的时候，其实就是用这种GRPB，然后求我们的target的命，然后求一个具体的一个结果，然后把它进行进行一个具体的编码，这就有一个target encoding。

我们在做target encoding的时候呢，我们可以对我们的特征三特征是一特征，19特征，24这些相关的一些特征做一些tag00扣理，那么我们还有一些特征呢，我们是类别的。

那么我们可以把它进行one hose对吧，然后还有一些特征，如果他是字符串的，我们就可以把它进行一个剔除好，那么整体就是这样啊，就是说基础的就是对我们的数据集，进行一个特征的筛选。

然后对我们的特征做一个编码即可，那么通过这样呢，我们就是可以将我们的一个具体的数据集，一步一步的进行建模，然后得到一个比较好的一个模型。

在我们进行建模的时候呢，我们也可以将我们的一个啊就是查g boss，它的一个超参数，把它单独写成一个dict，写成一个DX值的一个优点呢，就是我们这样呢我们的一个具体的一个模型呢，就是可以进行一个啊。

他的一个参数和我们的模型是分离分分开的啊，分开的，这样呢我们的一个超参数进行修改的时候，我们的代码其实变化不不需要太大对吧。

然后呢，我们这个地方其实定义了一个呃，get o f的这个函数，这个get o f的函数，其实一个含义就是我们通对我们的数据集划分，得到我们的一个训练部分，和我们的一个验证部分。

然后呢通过五折交叉验证的一个思路呢，然后可以得到我们的一个模型对我们的测试集，他五次的一个预测结果，然后可以将这个地方我们有一个prediction train。

以及我们的prediction text text对吧，就是我们的一个啊一个模型，对我们的一个训练集的预测结果，和我们的一个测试集的预测结果，然后呢我们在进行训练完成之后呢，我们对每个训练集。

将它的一个预测结果加到我们的prediction text上面，然后我们最终的一个预测结果，其实是这个的一个均值对吧，我们训练得到五个模型，那么我们的五个模型，对我们的一个测试集预测五次。

我们接下来可以将我们的一个模型的一个结果，把它进行啊，就相当于是把它保留下来啊，就是说求一个均值，那么这个代码呢大家下去也可以好好看一下，其实嗯你看完之后，就是对你的一个嗯就是呃个人的一个能力啊。

成长都是非常非常有帮助的，好然后呢我们再来看一个其他的一个案例啊，嗯接下一个案例呢，我们就来看一看这个QUORA的一个，重复文本的一个呃检测啊，那么我们这个地方呢。

嗯有同学可能会对这个文本会比较感兴趣啊，嗯就是说ALP类型的，那么对如果是AP类型的的话，那我们就看一看这个文本额，我们的文本呢其实就是我们在进行一个，处理的时候呢，在这个任务里面。

我们是做一个文本匹配的一个任务，文本匹配的任务呢就是说我们给的两个句子，给了两个句子，然后给了两个句子的一个情况下，我们是需要判断一下它，这两个句子它是不是匹配的，判断一下这两个句子是不是匹配的。

这是这个是我们的一个具体任务，那么我们在进行建模的时候呢，其实我们是需要看一看这个两个句子，他是不是匹配，这个其实是在IP里面是一个text matching的，一个就是文本匹配的一个任务啊。

我们在进行建模的时候呢，其实是用嗯可以用深度学习的模型，当然也可以用传统的机器学习的模型进行建模，但其实本质是一个二分类的啊，本质是一个二分类的，我们首先要读取我们的数据集，我们的训练集和我们的测试集。

然后呢我们可以做一个分析，我们分析的时候呢，如果是对于文本而言啊，我们做分析呢嗯其实很简单，统计一下我们的文本的长度就行了，或者说它的字符个呃，字符个数或者单词的个数，我们可以看一下我们的训练集。

和我们的一个测试集，它的总共所包含的一个字符的个数的，一个嗯密度分布的一个直方图对吧，很清楚的可以看到，就是说我们的训练集和我们的测试集，整体的分布是比较一致的对吧，然后呢。

我们可以看一下它的一个单词的整体的分布，对吧，可能从单词的一个分布来看呢，其实是更加比较比较啊，就是说一致的我们也可以绘制得到这种云图，云图就是我们的之前已经给大家讲过啊，我们的一个具体的一些云图。

然后呢我们可以看一下我们的一个情感分析，就是说我们的这个句子它里面是不是包含问号，以及它是不是包含我们的这些latex符号，就是说这种呃特殊字符，以及它是不是包含我们的一些啊。

就是说额首字母大写的这种比例啊，以及它里面是不是包含数字的，这种比例都是可以统计得到的，那么我们这个地方，其实本质在做一个什么样的任务，完成什么样的任务呢，我们这个地方其实本质嗯是这样的。

我们是给定了一个句子以及第二个句子，我们需要判断一下这两个句子是不是重复的，是不是相同的一个含义，它原始的一个背景呢是在CORE上面，QUORA呢就是国外版的一个知乎，国外版本的一个知乎。

然后呢在这个呃背景下面呢，我们是需要嗯识别一下，在我们的网站里面是不是有重复的问题，如果他提问相同，那么它的一个具体的一个内容就是相同的，我们这需要识别一下，他是不是有这种重复的问题，那么在这个地方呢。

我们就是说给定两个句子，我们是需要识别一下他是不是重复的，那么这个地方呢我们在做一个统计的时候呢，我们是可以统计一些相关的一些特征啊，比如说统计一下这两个句子，他们共有的单词的个数。

就是说他们如果两个句子，它的一个就是含义相同，它如果是匹配上的，那么可很可能它的一个具体的一个，我们共有单词的个数就很多对吧，那么我们可以写一个函数，可以统计一下我们的两个句子。

它共有单词的一个比例是多少对吧，这个地方其实是很简单的一个计算，那么我们可以看一下这个地方，我们如果两个单词，如果两个句子它的一个这个是地方，是它的共有共有单词的一个比例啊，如果两个句子。

它的一共有单词的比例比较多的情况下对吧，它很有可能就是一个duplicates是一个重复的，如果两个句子，它的一个共有单词的比例不太多的情况下，那么它很有可能就是一个不重复的对吧。

这个很明显就可以得到这个结论，那么当然我们也可以计算一下它的一个TF，I d f，这个地方呢TFIDF呢就是对我们的两个句子，把它进行一个进行一个TFIDF的一个输出，然后算一算它的一个TFDF的空间。

内的一个相似度，这个呢可能会更加直观一点啊，可能会更加直观一点，对啊，我们的不相似的句子和我们的相似的句子，它们之间的一个TFIDF的距离好，那么我们在进行建模的时候，其实是很简单啊，很简单。

我们就是对我们的数据集呢，统统计一下这相关的具体的一些特征啊，统计一下它的一个共有单词的个数，以及它的一个具体的TFIDF的相似度对吧，就直接用这两个特征，然后再加入一些具体的一些其他特征。

这些其他特征呢就是编码一下，它到底是不是包含我们的一些问号啊，是不是包含这些我们的一些嗯特殊符号啊，以及是不是包含这些数字啊，把这些特征当做一个就是说新的列，然后可以训练一个模型的。

这个模型呢我们是直接用charge boost，对嗯好，我们继续啊，刚才应该掉了一下啊，刚才应该掉了一下，应该不影响好，这是我们的第一个思路啊，第一个思路就是说人工提取特征。

然后用我们的一个数模型进进行一个建模，然后我们继续，那么对于我们的这个具体的一个呃，这个是我文本匹配的一个任务对吧，那么我们也可以用深度学习的一个模型，进行一个展开，如果是用深度学习的模型呢。

我们就是嗯这样一种思路，我们对于深度学习的模型呢，其实本质是需要进行一个嗯，嗯对我们的文本首先做一个处理的，我们首先呢对我们的文本把它进行一个token，IZED的处理。

这个token ize呢就是把我们的原始的文本，把它转，每个单词，把它转成一个具体的一个数值，把它从字符串把它转成一个数值，然后呢把它从原始的一个所有的一个字符串，把它转成这种数值的一个序列。

叫text to sequence，就是我们的原始的单词，可能就是由一个个单，就是说一个个word所组成的，Word 1word2，Word3，我们是把它转成一个具体的数值，101103104。

具体的数值来代替，转换完转换完成之后呢，我们接下来还要做一个page sequence，这个page seconds呢就是说我们的原始的一个句子，它可能包含的一个个数是不一样的。

有可能有的句子是包含30个单词，有可能有的是20个，有可能有的是40个，那么在这个地方呢，我们的一个单词个数是不一样，那么我们假如说想要搭建一个，深度学习的模型呢，我们就需要将这个单词的一个个数啊。

把它作为一个规整，也就是说把所有的单词呢，所有的句子里面的这些啊长度啊，把它填填充啊，或者截断啊，到一个统一的一个长度下面，那么我们在进行建模的时候呢，其实本质就是用这样一种思路。

我们对于一个句子呢把它表征为一个矩阵，第二第二个句子呢我们也把它表征为一个矩阵，然后算一算这两个句子，或者说这两个矩阵它们之间的一个相关性，算一算这两个矩阵的一个相关性，这个就是我们基于这种深度学习的。

这种啊思路的这种建模啊，深度学习的思路，这种建模，也就是说我们直接计算一下，这两个矩阵的一个相关性，就可以得到我们的一个具体的一个啊，就是啊两个句子的一个相关性的一个结论好，那么我们怎么做的呢。

其实本质这个地方是使用到了，一个叫做磁向量的一种方法，此向量呢就是我们有预训练好的一个呃，此向量的一个空间，在这个空间内呢，它其实本质就是一个KV的一个矩阵啊，KV的矩阵嗯，就是说我们就是说。

我们是可以将我们的一个额word，把它进行转成一个vector，把它转成一个vector，这个地方呢其实本质就是一个嗯，离散化的一个处理，离散化的一个处理，额我们是可以将这个具体的一个单词，这个地方。

我们是把它转换成一个300维的一个向量，300维的向量在这个向量里面，其实它本质就是一个KV的矩阵，KV的矩阵，每个单，每个某个单词把它转成一个具体的一个向量，这个地方呢我们是借助于额一个预训练好的。

glow的这个词向量，这个词向量，其实本质就是我们刚才的这种形式啊，一个word我们有对应的一个vector，这种形式有一个对应的vector，这个就是我们的一个具体的一个哦，具体的一个形式啊。

有word一个vector，它就是一种KV的形式，那么我们在进行建模的时候呢，其实本质就是构建一个深度学习的模型，这个模型在做什么呢，这个模型其实本质就是做一个匹配，我们首先呢输入两个句子。

这两个句子是我们刚才处理好的，把它进行转换成数值，然后把它进行截断好相同长度长度的，然后接下来通过我们的一个embedding layer，把它进行了一个转换，转换成这种序列的。

然后接下来通过我们的HTM层，或者说用gr u层对我们的具体的，我们的每一个输入的句子进行一个特征提取，然后完成它们之间的一个交叉，这个交叉呢就是我们计算一下它的一个句子，一和句子二之间的一个相关性。

句子一和句子二之间相之间的相关性，那么这个地方我们就是可以对嗯，就是说它们之间的一个矩阵，计算一下它的一个相关性，计算一下它的减法，计算它的一个加法，然后整体把它拼接起来，然后拼接起来之后呢。

然后再送到我们的一个全连接层，全连接层，然后最终得到我们的分类分类呢，这个地方我们用SIGMMOID，就是我们的一个二分类，做个二分类，那么其实整体的网络结构就是有两个输入。

两个输入分别输入的是啊40个，每个句子最多40个单词，每个句子最多40个单词，然后通过我们的embedding把它转成每个单词，是得到一个300位的一个向量对吧，那么其实本质得到了一个句子。

就得到了一个三四十乘300位的一个矩阵，然后接下来我们通过HT m进行一个映射，把它映射到一个128位，然后呢，我们就对这两个128位的一个向量，做一个加法减法，然后把它拼接到一起。

然后再通过全局杰森最终得到我们的分类结果，这个呢是一个基于深度学习的写法，他可能是没有做很多的特征工程对吧，只需要对我们的数据集，通过这种embedding的操作，把它进行一个转换。

然后再构建一个模型就行，但是呢如果我们用这个embedding的这种思路呢，嗯基于我们的这种深度学习的一个思路呢，其实它的一个模型的一个精度其实是非常高的，它的一个模型的精度呢会比基于这种统计。

再加上数模型的一个精度会高很多，会高很多，也就是说，我们这个地方其实是给大家讲了两种思路啊，两种思路嗯，我们的第一种思路呢，对于这个文本匹配啊，我们其实讲了两种解法。

我们这需要识别这两个文本是不是匹配的，第一种思路呢，是基于特征，人工特征，再加上数模型，数模型，第二种思路呢，是我们直接用词向量，what vector进行对我们的数据集进行表示。

然后再向深度学习的模型neural network进行建模，那么这两种都是非常有效的，但是呢可能第二种的模型，它可能的精度会更高一些，因为我们的第二种它进行建模的时候，他可能会用。

他可能会用到的一些一系列的一个信息啊，会更多，我们在进行建模的时候呢，嗯其实呃我们的一个数据啊，我们其实是嗯你在做一个特特征提取的时候，你是很难把这个所有的特征把它提取到的对吧。

文本它里面其实是有很多的一些呃信息的，而且信息量是非常大的，在这个地方我们其实如果人工去提取特征，人工提取特征，你可能是需要考虑很多东，很多的角度才能把这个T特征提取完备。

但是如果我们直接是借助于深度学习呢，我们就是不去做这个特征工程，让我们的模型去做这个特征工程，然后呢我们的一个深度学习，它是非常适合用在这种场景啊，就是说如果我们很难去做特征工程的。

我们就可以去借助于深度学习的这种模型，来做一个特征的好，也就是说前者是我们啊人工做特征，然后进行建模，后者呢是直接对数据做一个处理，然后进行建模，当然这个地方我们还给大家留了一个案例啊。

呃这个案例呢是也是一个呃，就是数据集的一个建模的，我们是需要给定嗯这个商品的一个呃一些物，物品信息，品类品牌的信息，然后预测一下它是不是它的具体的价格啊，就是相当于是一个二手的一个商品的一个，价格预测。

我们其实本质是需要做这样的一个呃任务好，那么这个地方其实我们也是，首先对每一列做一个数据分析，然后对我们的价格字段，也是需要做一个分析分析，然后分析一下我们的每个字段，和我们的价格之间的一个差异性。

也就是说我们的字段跟我们的标记，跟我们的一个具体的一个嗯价格，它们之间是是不是存在某种相关性。

然后呢我们进行建模呢。

其实本质啊这个地方这些都是一些可视化，就是统计一下我们每个字段和我们的一个标签，是不是有什么相关性，统计完成之后呢，其实我们是嗯也是呃这个数据集，其实里面也有蛮多的一些文本信息的啊，其实在这个地方呢。

我们本质也是啊对我们的数据集呢，把它提取的一些特征，这些特征呢其实在做的时候呢，本质提取的特征就是对我们的一些字段，做一个截断，以及做一个具体的编码，我们那些品牌呢，他可能这个就是商品的品牌的。

取值空间是非常大的，我们其实是可以对它进行一个截断的处理，这些都是我们在之前也讲了，讲过了，如果他的取值空间非常大，我们可以考虑把它做一个截断的处理，以及我们可以将我们的具体的一些字段呢。

可以把它进行一个编码，这个呃as as type category，其实这个操作就是一个啊，就是一个label encoder的操作啊，就是把它做一个具体的编码，编码完成之后呢。

我们就还有还有一些可以对我们的文本，计算一下它的一个CONTROVETOR，就是计算一下他的一个TFIEF好，计算完TFIDF之后呢，然后把它整体的特征把它拼接到一起，然后用一个NHGBM就可以得到。

就是说可以进行训练的，所以说我们的一个数据啊，它如何进行建模，以及如何使用什么样的模型啊，这可能是不同的数据呃，问题我们用到的模型和数据，处理方法都是不一样的，我们是需要进行仔细分析啊，仔细分析。

那么这节课我们给大家整整理了三个，具体的一个案例啊，然后如果各位同学感兴趣呢，也希望各位同学在我们课后啊好好可以啊，下去自己可以看一下，那么我们就来进行总结一下啊，就是说我们在进行一个特征工程的时候呢。

其实呃我们是需要思考，就是说我们的数据集，我们如何确定一下它到底是不是一致的，如果它不一致，我们怎么办，这是第一个，第二个呢，就是说我们如何构建得到一些交叉的特征，这些交叉特征呢我们怎么进行一个得到啊。

以及我们怎么进行啊分析嗯，这些分析方法呢，就是说我们首先可以看一下数据的分布，然后呢看一看这个字段，它是不是跟我们的一个嗯模型是不是相强，相关的，也可以看一下我们的这个字段，它在可视化的时候。

是不是通过可以通过加减乘除，得到一些新的特征，对这个交叉测试呢，这个可能就比较难啊，这可能就考，就是说需要嗯我们做一个数据分析，才能够得到的一些具体的一个呃，就是说一些结论的对。

嗯那么以上呢就是我们这节课的一个内容。

各位同学有问题吗，对我们的一个手机用户663946同学嗯，有问题吗，嗯我们今天的一个直播的一个内容就到这嗯，663946同学嗯，有问题吗，好对如果有问题的话，可以在我们的一个聊天框里面打字啊，好嗯对。

暂时没有啊，你可以把我们的一个课件和我们的一个代码，在课后可以好好的拿着再看一下，好不好对，好嗯也可以在如果有问题，也可以在我们的QQ群里面进行提问，好那么我们今天的一个直播就到此结束好吧。

然后呢我们待会儿我马上就把代码上传上去，然后如果各位同学嗯想深入学习呢，也可以结合我们的代码进行展开，好的那么我们今天的一个直播就到此结束啦。