<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>知予AI</title>
    <link>https://knove-ai.github.io/</link>
    <description>Recent content on 知予AI</description>
    <generator>Hugo</generator>
    <language>en-us</language>
    <lastBuildDate>Sun, 01 Jan 2017 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://knove-ai.github.io/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>机器学习基础</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml1-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E5%9F%BA%E7%A1%80/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml1-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E5%9F%BA%E7%A1%80/</guid>
      <description>&lt;h3 id=&#34;人工智能&#34;&gt;人工智能&lt;/h3&gt;&#xA;&lt;p&gt;&lt;b&gt;智能(intelligence)&lt;/b&gt;是现代生活中很常见的一个词，比如智能手机、智能家居、智能驾驶等。在不同使用场合中，智能的含义也不太一样。比如“智能手机”中的“智能”一般是指由计算机控制并具有某种智能行为的意思。这里的“计算机控制”+“智能行为”隐含了对人工智能的简单定义。&lt;/p&gt;&#xA;&lt;p&gt;简单地讲，&lt;strong&gt;人工智能(Artificial Intelligence, AI)&lt;/strong&gt; 就是让机器具有人类的智能，这也是人们长期追求的目标。这里关于什么是“智能”并没有一个很明确的定义，但一般认为智能(或特指人类智能)是知识和智力的总和，都和大脑的思维活动有关。人类大脑是经过了上亿年的进化才形成了如此复杂的结构，但&lt;strong&gt;至今尚未完全了解&lt;/strong&gt;。虽然随着神经科学、认知心理学等学科的发展，人们对大脑的结构有了一定程度的了解，但对大脑的智能究竟怎么产生的还知道的很少。我们并不理解大脑的运作原理，以及如何产生意识、情感、记忆等。因此，&lt;strong&gt;通过“复制”一个人脑来实现人工智能在目前阶段是不切实际的&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;1950年，阿兰·图灵(Alan Turing)发表了一篇有着重要影响力的论文“&lt;em&gt;Computing Machinery and Intelligence&lt;/em&gt;”，讨论了创造一种“智能机器”的可能性。由于“智能”一词比较难以定义，他提出了著名的&lt;strong&gt;图灵测试(Turing test)&lt;/strong&gt;：“一个人在不接触对方的情况下，通过一种特殊的方式，和对方进行一系列的问答。如果在相当长时间内，他无法根据这些问题判断对方是人还是计算机，那么就可以认为这个计算机是智能的”。图灵测试是促使人工智能从哲学探讨到科学研究的一个重要因素，引导了人工智能的很多研究方向。因为要使得计算机能通过图灵测试，计算机必须具备理解语言、学习、记忆、推理、决策等能力。这样，人工智能就延伸出了很多不同的子学科，比如&lt;strong&gt;机器感知(计算机视觉、语音信息处理)，学习(模式识别、机器学习、强化学习)，语言(自然语言处理)、记忆(知识表示)、决策(规划、数据挖掘)&lt;/strong&gt; 等。所有这些研究领域都可以看成是人工智能的研究范畴。&lt;/p&gt;&#xA;&lt;p&gt;人工智能是计算机科学的一个分支，主要研究、开发用于模拟、延伸和扩展人类智能的理论、方法、技术及应用系统等。和很多其它学科不同，人工智能这个学科的诞生有着明确的标志性事件，即&lt;strong&gt;1956年的达特茅斯会议&lt;/strong&gt;。在这次会议上，“人工智能”被提出并作为本研究领域的名称。同时，人工智能研究的使命也得以确定。John McCarthy提出了人工智能的定义：&lt;strong&gt;人工智能就是要让机器的行为看起来就像是人所表现出的智能行为一样&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;目前，人工智能的主要领域大体上可以分为以下几个方面：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;感知&lt;/strong&gt;：即模拟人的感知能力，对外部刺激信息(视觉和语音等)进行感知和加工。主要研究领域包括语音信息处理和计算机视觉等。(2) &lt;strong&gt;学习&lt;/strong&gt;：即模拟人的学习能力，主要研究如何从样例或与环境交互中进行学习。主要研究领域包括监督学习、无监督学习和强化学习等。(3) &lt;strong&gt;认知&lt;/strong&gt;：即模拟人的认知能力，主要研究领域包括知识表示、自然语言理解、推理、规划、决策等。&lt;/p&gt;&#xA;&lt;p&gt;人工智能的&lt;strong&gt;发展简史&lt;/strong&gt;如下：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200415145435022.png&#34; style=&#34;zoom:45%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;统计学习&#34;&gt;统计学习&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;统计学习(statistical learning)&lt;/strong&gt; 是关于计算机基于数据构建概率统计模型并运用模型对数据进行预测与分析的一门学科。统计学习也称为&lt;strong&gt;统计机器学习(statistical machine learning)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;统计学习研究对象是&lt;strong&gt;数据(data)&lt;/strong&gt;。它从数据出发，提取数据的特征，抽象出数据的模型，发现数据中的知识，又回到对数据的分析与预测中去。统计学习&lt;strong&gt;关于数据的基本假设：同类数据具有一定统计规律性&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;统计学习方法可以概况如下：从给定的、有限的、用于学习的&lt;strong&gt;训练数据(training data)集合&lt;/strong&gt;出发，&lt;strong&gt;假设数据是独立同分布产生的&lt;/strong&gt;；并且假设要学习的模型属于某个函数的集合，称为&lt;strong&gt;假设空间(hypothesis space)&lt;/strong&gt;；应用某个评价准则，从假设空间中选取一个最优模型，使它对已知训练数据及未知的&lt;strong&gt;测试数据(test data)&lt;strong&gt;在给定的评价准则下有最优的预测；最优模型的选取由算法实现。这样，统计学习方法包括模型的假设空间、模型选择的准则以及模型学习的算法。其称为统计学习的三要素，简称为&lt;/strong&gt;模型(model)、策略(strategy)和算法(algorithm)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;实现统计学习方法的一般步骤如下：&lt;/p&gt;&#xA;&lt;p&gt;​    (1) 得到一个有限的&lt;strong&gt;训练数据集合&lt;/strong&gt;；&lt;/p&gt;&#xA;&lt;p&gt;​    (2) 确定包含所有偶可能的模型的&lt;strong&gt;假设空间&lt;/strong&gt;，即学习模型的集合；&lt;/p&gt;&#xA;&lt;p&gt;​    (3) 确定模型选择的准则，即学习的&lt;strong&gt;策略&lt;/strong&gt;；&lt;/p&gt;&#xA;&lt;p&gt;​    (4) 实现求解最优模型的算法，即学习的&lt;strong&gt;算法&lt;/strong&gt;；&lt;/p&gt;&#xA;&lt;p&gt;​    (5) 通过学习方法&lt;strong&gt;选择最优模型&lt;/strong&gt;；&lt;/p&gt;&#xA;&lt;p&gt;​    (6) 利用学习的最优模型&lt;strong&gt;对新数据进行预测或分析&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;统计学习研究包括&lt;strong&gt;统计学习方法、统计学习理论以及统计学习应用&lt;/strong&gt;三个方面。统计学习方法的研究旨在开发新的学习方法；统计学习理论的研究在于探求统计学习方法的有效性与效率，以及统计学习的基本理论问题；统计学习应用的研究主要考虑将统计学习方法应用到实际问题。&lt;/p&gt;&#xA;&lt;p&gt;以一个生活中的例子来介绍机器学习中的一些基本概念：包括样本、特征、标签、模型、学习算法等。假设我们要到市场上购买芒果，但是之前毫无挑选芒果的经验，那么我们如何通过学习来获取这些知识？&lt;/p&gt;&#xA;&lt;p&gt;首先，我们从市场上随机选取一些芒果，列出每个芒果的特征(feature)，包括颜色、大小、形状、产地、品牌，以及我们需要预测的标签(label)。标签可以是&lt;strong&gt;连续值&lt;/strong&gt;(比如关于芒果的甜度、水分以及成熟度的综合打分)，也可以是&lt;strong&gt;离散值&lt;/strong&gt;(比如“好”“坏”两类标签)。这里，每个芒果的标签可以通过直接品尝来获得，也可以通过请一些经验丰富的专家来进行标记。&lt;/p&gt;&#xA;&lt;p&gt;一个标记好特征以及标签的芒果可以看作是一个&lt;strong&gt;样本(sample)&lt;/strong&gt;。一组样本构成的集合称为&lt;strong&gt;数据集(data set)&lt;/strong&gt;。一般将数据集分为两部分：训练集和测试集。&lt;strong&gt;训练集(training set)&lt;/strong&gt; 中的样本是用来训练模型的，也叫训练样本(training sample)，而&lt;strong&gt;测试集(test set)&lt;/strong&gt; 中的样本是用来检验模型好坏的，也叫测试样本(test sample)。我们通常用一个$d$维的向量$\boldsymbol x=[x_1,x_2,\cdots,x_d]^T$表示一个芒果的所有&lt;strong&gt;特征&lt;/strong&gt;构成的向量，称为&lt;strong&gt;特征向量(feature vector)&lt;/strong&gt;，其中每一维表示一个特征。而芒果的&lt;strong&gt;标签&lt;/strong&gt;通常用标量$y$来表示。假设训练集由$N$个样本组成，其中每个样本都是&lt;strong&gt;独立同分布(identically and independently distributed, IID)&lt;/strong&gt; 的，即&lt;strong&gt;独立地从相同的数据分布中抽取的&lt;/strong&gt;，记为：&lt;/p&gt;</description>
    </item>
    <item>
      <title>深度学习概述</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl1-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E6%A6%82%E8%BF%B0/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl1-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E6%A6%82%E8%BF%B0/</guid>
      <description>&lt;h3 id=&#34;表示学习&#34;&gt;表示学习&lt;/h3&gt;&#xA;&lt;p&gt;为了提高机器学习系统的准确率，需要将输入信息转换为有效的特征，或者更一般称为&lt;strong&gt;表示(representation)&lt;/strong&gt;。如果有一种算法可以自动地学习出有效的特征，并提高最终机器学习模型的性能，那么这种学习就是可以叫做&lt;strong&gt;表示学习(representation learning)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;表示学习的关键是解决&lt;strong&gt;语义鸿沟(semantic gap)&lt;/strong&gt; 问题。语义鸿沟问题是指输入数据的底层特征和高层语义信息之间的不一致性和差异性。比如给定一些关于“车”的图片，由于图片中每辆车的颜色和形状等属性都不尽相同，不同图片在像素级别上的表示(即底层特征)差异性也会非常大。但是我们人理解这些图片是建立在比较抽象的高层语义概念上的。如果一个预测模型直接建立在底层特征之上，会导致对预测模型的能力要求过高。如果可以有一个好的表示在某种程度上可以反映出数据的高层语义特征，那么我们就可以相对容易地构建后续的机器学习模型。&lt;/p&gt;&#xA;&lt;p&gt;在表示学习中，有两个核心问题：一是“什么是一个好的表示”；二是“如何学习到好的表示”。&lt;/p&gt;&#xA;&lt;h4 id=&#34;局部表示和分布式表示&#34;&gt;局部表示和分布式表示&lt;/h4&gt;&#xA;&lt;p&gt;一般而言，一个好的表示具有以下几个优点：&lt;/p&gt;&#xA;&lt;p&gt;(1) 一个好的表示应该具有&lt;strong&gt;很强的表示能力&lt;/strong&gt;，即同样大小的向量可以表示更多信息。&lt;/p&gt;&#xA;&lt;p&gt;(2)  一个好的表示应该&lt;strong&gt;使后续的学习任务变得简单&lt;/strong&gt;，即需要包含更高层的语义信息。&lt;/p&gt;&#xA;&lt;p&gt;(3) 一个好的表示应该具有&lt;strong&gt;一般性&lt;/strong&gt;，是任务或领域独立的。&lt;/p&gt;&#xA;&lt;p&gt;在机器学习中，我们经常使用两种方式来表示特征：&lt;strong&gt;局部表示(local representation)和分布式表示(distributed representation)&lt;/strong&gt;。以颜色的表示为例，二者之间的区别如下：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200415201105676.png&#34; style=&#34;zoom:30%&#34;&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;局部表示通常可以表示为&lt;strong&gt;one-hot向量&lt;/strong&gt;的形式(只有一个维度为1，其他维度为0)。局部表示具有很好的解释性，方便人工进行特征总结，并通过特征组合进行高效的特征工程。通过多种特征组合得到的表示向量通常是稀疏的二值向量，当用于线性模型时计算效率非常高。但局部表示有两个不足之处：(1) one-hot向量的维数很高，且无法扩展。如果有一种新的颜色，就需要增加一维来表示；(2) &lt;strong&gt;不同颜色之间的相似度为0&lt;/strong&gt;，这样丢失了所有语义信息。&lt;/p&gt;&#xA;&lt;p&gt;和局部表示相比，分布式表示的表示能力要比局部表示强很多。分布式表示的向量维度一般都比较低，我们只需要用一个三维的稠密向量(例如RGB)就可以表示所有颜色。并且分布式表示也很容易表示新的颜色名。此外，不同颜色之间的相似度也很容易计算。&lt;/p&gt;&#xA;&lt;p&gt;我们可以使用神经网络来&lt;strong&gt;将高维的局部表示空间映射到一个非常低维的分布式表示空间&lt;/strong&gt;。在这个低维空间中，每个特征不再是坐标轴上的点，而是分散在整个低维空间中。在机器学习中，这个过程也称为&lt;strong&gt;嵌入(embedding)&lt;/strong&gt;。嵌入通常指将一个度量空间中的一些对象映射到另一个低维的度量空间中，并尽可能保持不同对象之间的拓扑关系。比如自然语言中词的分布式表示，也经常叫做&lt;strong&gt;词嵌入&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200415201736468.png&#34; style=&#34;zoom:30%&#34;&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h4 id=&#34;表示学习-1&#34;&gt;表示学习&lt;/h4&gt;&#xA;&lt;p&gt;要学习到一种好的高层语义表示(一般为分布式表示)，通常需要从底层特征开始，经过多步非线性转换才能得到。&lt;/p&gt;&#xA;&lt;p&gt;一个&lt;strong&gt;深层结构&lt;/strong&gt;的优点是可以&lt;strong&gt;增加特征的重用性&lt;/strong&gt;，从而&lt;strong&gt;指数级地增加表示能力&lt;/strong&gt;。因此，表示学习的关键是构建具有一定深度的多层次特征表示。&lt;/p&gt;&#xA;&lt;p&gt;在传统的机器学习中，也有很多有关特征学习的方法，比如主成分分析、线性判别分析、独立成分分析等。但是传统的特征学习一般是通过人为地设计一些准则，然后根据这些准则来选取有效的特征。&lt;strong&gt;特征的学习和最终预测模型的学习分开进行&lt;/strong&gt;，因此学习到的特征不一定可以提升最终模型的性能。&lt;/p&gt;&#xA;&lt;h3 id=&#34;深度学习&#34;&gt;深度学习&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;深度学习(deep learning, DL)&lt;/strong&gt; 通过学习算法来让模型自动学习出好的特征表示(从底层特征，到中层特征，再到高层特征)，从而最终提升预测模型的准确率。&lt;strong&gt;所谓“深度”是指原始数据进行非线性特征转换的次数&lt;/strong&gt;。如果把一个表示学习系统看作是一个有向图结构，深度也可以看作是从输入节点到输出节点所经过的最长路径的长度。&lt;/p&gt;&#xA;&lt;p&gt;深度学习是将原始的数据特征通过多步的特征转换得到一种更高层次、更抽象的特征表示，并进一步输入到预测函数得到最终结果。这些学习到的表示可以代替人工设计的特征，从而避免“特征工程”。&lt;/p&gt;&#xA;&lt;p&gt;和“浅层学习”不同，深度学习需要解决的关键问题是&lt;strong&gt;贡献度分配问题(credit assignment problem, CAP)&lt;/strong&gt;，即一个系统中不同的&lt;strong&gt;组件(components)&lt;/strong&gt; 或其参数对最终系统输出结果的贡献或影响。&lt;strong&gt;目前深度学习主要以深度神经网络模型及反向传播算法为基础&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;下图展示了机器学习与深度学习数据处理流程的不同：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200415202513840.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200415202541853.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;在一些复杂任务中，传统机器学习方法需要将一个任务的输入和输出之间人为地切割成很多子模块(或多个阶段)，每个子模块分开学习。比如一个自然语言理解任务，一般需要分词、词性标注、句法分析、语义分析、语义推理等步骤。这种学习方式有两个问题：一是&lt;strong&gt;每一个模块都需要单独优化&lt;/strong&gt;，并且其优化目标和任务总体目标并不能保证一致。二是&lt;strong&gt;错误传播&lt;/strong&gt;，即前一步的错误会对后续造成很大的影响。这样增加了机器学习方法在实际应用的难度。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;端到端学习(end-to-end learning)&lt;/strong&gt;，也称端到端训练，是指在学习过程中不进行分模块或分阶段进行训练，直接优化任务的总体目标。在端到端学习中，一般不需要明确地给出不同模块或阶段的功能，中间过程不需要人为干预。端到端学习的训练数据为“输入-输出”对的形式，无需提供其它额外信息。因此，端到端学习和深度学习一样，都是要解决贡献度分配问题。目前，大部分采用神经网络模型的深度学习可以看作是一种端到端的学习。&lt;/p&gt;&#xA;&lt;h3 id=&#34;神经网络&#34;&gt;神经网络&lt;/h3&gt;&#xA;&lt;p&gt;随着神经科学、认知科学的发展，我们逐渐知道人类的智能行为都和大脑活动有关。人类大脑是一个可以产生意识、思想和情感的器官。受到人脑神经系统的启发，早期的神经科学家构造了一种模仿人脑神经系统的数学模型，称为&lt;strong&gt;人工神经网络&lt;/strong&gt;，简称&lt;strong&gt;神经网络&lt;/strong&gt;。在机器学习领域，神经网络是指由很多人工神经元构成的网络结构模型，这些人工神经元之间的连接强度是可学习的参数。&lt;/p&gt;&#xA;&lt;h4 id=&#34;人脑神经网络&#34;&gt;人脑神经网络&lt;/h4&gt;&#xA;&lt;p&gt;人类大脑是人体最复杂的器官，由神经元、神经胶质细胞、神经干细胞和血管组成。其中，&lt;strong&gt;神经元(neuron)&lt;/strong&gt;，也叫&lt;strong&gt;神经细胞(nerve cell)&lt;/strong&gt;，是携带和传输信息的细胞，是人脑神经系统中最基本的单元。人脑神经系统是一个非常复杂的组织，包含近860亿个神经元，每个神经元有上千个突触和其它神经元相连接。这些神经元和它们之间的连接形成巨大的复杂网络，其中神经连接的总长度可达数千公里。&lt;strong&gt;我们人造的复杂网络，比如全球的计算机网络，和大脑神经网络相比要“简单”得多&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;早在 1904 年，生物学家就已经发现了神经元的结构。典型的神经元结构大致可分为细胞体和细胞突起。&lt;/p&gt;&#xA;&lt;p&gt;**细胞体(soma)**中的神经细胞膜上有各种受体和离子通道，胞膜的受体可与相应的化学物质神经递质结合，引起离子通透性及膜内外电位差发生改变，产生相应的生理活动：兴奋或抑制。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;细胞突起&lt;/strong&gt;是由细胞体延伸出来的细长部分，又可分为树突和轴突。**树突(dendrite)**可以接收刺激并将兴奋传入细胞体。每个神经元可以有一或多个树突。&lt;strong&gt;轴突(axons)&lt;/strong&gt; 可以把自身的兴奋状态从胞体传送到另一个神经元或其他组织。每个神经元只有一个轴突。&lt;/p&gt;&#xA;&lt;p&gt;神经元可以接收其它神经元的信息，也可以发送信息给其它神经元。神经元间没有物理连接，中间有20纳米左右的缝隙。神经元之间靠&lt;strong&gt;突触(synapse)&lt;strong&gt;进行互联来传递信息，形成一个神经网络，即&lt;/strong&gt;神经系统&lt;/strong&gt;。突触可以理解为神经元之间的链接“接口”，将一个神经元的兴奋状态传到另一个神经元。一个神经元可被视为一种只有两种状态的细胞：&lt;strong&gt;兴奋和抑制&lt;/strong&gt;。神经元的状态取决于从其它的神经细胞收到的输入信号量，及突触的强度(抑制或加强)。当信号量总和超过了某个阈值时，细胞体就会兴奋，产生电脉冲。电脉冲沿着轴突并通过突触传递到其它神经元。下图给出了一种典型的神经元结构。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200416101819316.png&#34; style=&#34;zoom:25%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;一个人的智力不完全由遗传决定，大部分来自于生活经验。也就是说，人脑神经网络是一个具有学习能力的系统。在人脑神经网络中，每个神经元本身并不重要，重要的是神经元如何组成连接。不同神经元之间的突触有强有弱，其强度是可以通过学习(训练)来不断改变的，具有一定的可塑性。&lt;strong&gt;赫布理论(Hebbian theory)&lt;/strong&gt; 提出，如果两个神经元总是相关联地受到刺激，它们之间的突触强度增加。这样的学习方法被称为赫布型学习(Hebbian learning)。赫布认为人脑有两种记忆：&lt;strong&gt;长期记忆和短期记忆&lt;/strong&gt;。短期记忆持续时间不超过一分钟。如果一个经验重复足够的次数，此经验就可储存在长期记忆中。短期记忆转化为长期记忆的过程就称为凝固作用。人脑中的&lt;strong&gt;海马区&lt;/strong&gt;为大脑结构&lt;strong&gt;凝固作用的核心区域&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h4 id=&#34;人工神经网络&#34;&gt;人工神经网络&lt;/h4&gt;&#xA;&lt;p&gt;人工神经网络是为模拟人脑神经网络而设计的一种计算模型，它从结构、实现机理和功能上模拟人脑神经网络。人工神经网络与生物神经元类似，由多个节点(人工神经元)互相连接而成，可以对数据之间的复杂关系进行建模。不同节点之间的连接被赋予了不同的权重，&lt;strong&gt;每个权重代表了一个节点对另一个节点的影响大小&lt;/strong&gt;。每个节点代表一种特定函数，来自其他节点的信息经过其相应的权重综合计算，输入到一个&lt;strong&gt;激活函数&lt;/strong&gt;中并得到一个新的活性值(兴奋或抑制)。&lt;strong&gt;从系统观点看，人工神经元网络是由大量神经元通过丰富和完善的连接而构成的自适应非线性动态系统&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;虽然我们可以比较容易地构造一个人工神经网络，但是如何让人工神经网络具有学习能力并不是一件容易的事情。早期的神经网络模型并不具备学习能力。&lt;strong&gt;首个可学习的人工神经网络是赫布网络&lt;/strong&gt;，采用一种基于赫布规则的无监督学习方法。感知器是最早的具有机器学习思想的神经网络，但其学习方法无法扩展到多层的神经网络上。直到 1980 年左右，&lt;strong&gt;反向传播算法&lt;/strong&gt;才有效地解决了多层神 经网络的学习问题，并成为最为流行的神经网络学习算法。&lt;/p&gt;&#xA;&lt;p&gt;人工神经网络诞生之初并非用来解决机器学习问题。人工神经网络可以看作是一个通用的函数逼近器，两层的神经网络可以逼近任意的函数，因此人工神经网络可以看作一个可学习的函数，并应用到机器学习中。理论上，只要有足够的训练数据和神经元数量，人工神经网络就可以学到很多复杂的函数。人工神经网络模型的塑造任何函数的能力大小可以称为&lt;strong&gt;网络容量(network capacity)&lt;/strong&gt;，与可被储存在网络中的信息的复杂度以及数量相关。&lt;/p&gt;&#xA;&lt;h4 id=&#34;神经网络的而发展历史&#34;&gt;神经网络的而发展历史&lt;/h4&gt;&#xA;&lt;h5 id=&#34;第一阶段模型提出&#34;&gt;第一阶段：模型提出&lt;/h5&gt;&#xA;&lt;p&gt;第一个阶段为1943~1969年，是神经网络发展的第一个高潮期。在此期间，科学家们提出了许多神经元模型和学习规则，例如Alan Turing提出的&lt;strong&gt;B型图灵机&lt;/strong&gt;(1948)、Rosenblatt提出的&lt;strong&gt;感知机(perceptron)&lt;/strong&gt;(1958)等。&lt;/p&gt;</description>
    </item>
    <item>
      <title>线性代数</title>
      <link>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math1-%E7%BA%BF%E6%80%A7%E4%BB%A3%E6%95%B0/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math1-%E7%BA%BF%E6%80%A7%E4%BB%A3%E6%95%B0/</guid>
      <description>&lt;h3 id=&#34;向量和向量空间&#34;&gt;向量和向量空间&lt;/h3&gt;&#xA;&lt;h4 id=&#34;向量&#34;&gt;向量&lt;/h4&gt;&#xA;&lt;p&gt;&lt;b&gt;标量(scalar)&lt;/b&gt;是一个实数，一般用斜体小写字母$a,b,c$来表示。&lt;b&gt;向量(vector)&lt;/b&gt;是由一组实数组成的有序数组，一个&lt;em&gt;n&lt;/em&gt;维向量$\boldsymbol a$由&lt;em&gt;n&lt;/em&gt;个有序实数组成，表示为$\boldsymbol{a}=\left[a_{1}, a_{2}, \cdots, a_{n}\right]$，其中$a_{i}$称为向量$\boldsymbol{a}$的第$i$个分量(第$i$维)。&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# numpy库常用于实现线性代数中向量和矩阵的基本操作&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;numpy&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;as&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;np&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# numpy中向量的定义&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;v_1&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;np&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;array&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;([&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;3&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;4&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;])&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;v_2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;np&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;array&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;([&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;5.6&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;4.6&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;3.6&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2.6&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1.6&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;])&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h4 id=&#34;向量空间&#34;&gt;向量空间&lt;/h4&gt;&#xA;&lt;p&gt;&lt;strong&gt;向量空间(vector space)&lt;strong&gt;也称&lt;/strong&gt;线性空间(linear space)&lt;/strong&gt;，是指由向量组成的集合，并满足以下两个条件：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;向量加法封闭性&lt;/strong&gt;：向量空间$\mathcal V$中的任意两个向量$\boldsymbol a$和$\boldsymbol b$，它们的和$\boldsymbol a+\boldsymbol b$也属于向量空间$\mathcal V$；&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# numpy实现向量加法&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;v_a&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;np&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;add&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;v_1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;v_2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;v_a&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;v_a&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;  &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 结果为向量&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;(2) &lt;strong&gt;标量乘法封闭性&lt;/strong&gt;：向量空间$\mathcal V$中的任一向量$\boldsymbol a$和任一标量$c$，它们的乘积$c\boldsymbol a$也属于向量空间$\mathcal V$。&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# numpy实现向量与标量相乘&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;k&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2.0&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;v_k2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;k&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;v_1&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;v_k2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;v_k2&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;  &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 结果为向量&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\left[a_{1}, a_{2}, \cdots, a_{n}\right]+\left[b_{1}, b_{2}, \cdots, b_{n}\right] &amp;=\left[a_{1}+b_{1}, a_{2}+b_{2}, \cdots, a_{n}+b_{n}\right] \\&#xD;&#xA;c \cdot\left[a_{1}, a_{2}, \cdots, a_{n}\right] &amp;=\left[c a_{1}, c a_{2}, \cdots, c a_{n}\right]&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;&lt;strong&gt;线性子空间&lt;/strong&gt;：向量空间$\mathcal V$的线性子空间$\mathcal U$是$\mathcal V$的一个子集，并且满足向量空间的条件。&lt;/p&gt;</description>
    </item>
    <item>
      <title>自然语言处理概述</title>
      <link>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp1-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86%E6%A6%82%E8%BF%B0/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp1-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86%E6%A6%82%E8%BF%B0/</guid>
      <description>&lt;h3 id=&#34;自然语言与编程语言&#34;&gt;自然语言与编程语言&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;自然语言处理(natural language processing, NLP)&lt;/strong&gt; 是一门融合了计算机科学、人工智能以及语言学的交叉学科(interdisciplinary field)。这门学科研究的是如何通过机器学习等技术，让计算机学会处理人类语言，乃至实现最终目标：&lt;strong&gt;理解人类语言或人工智能&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;自然语言处理同义词：注重语言学结构的学者喜欢使用&lt;strong&gt;计算语言学(conputational linguistics)&lt;/strong&gt;，而强调最终目的的学者则更偏好&lt;strong&gt;自然语言理解(natural language understanding)&lt;/strong&gt; 这个术语。&lt;/p&gt;&#xA;&lt;p&gt;完全理解和表达语言是极其困难的，正确的语言表达也没有精确并完备的特性。&lt;/p&gt;&#xA;&lt;p&gt;虽然自然语言和编程语言都称为“语言”，但二者有极大差异。自然语言和编程语言之间的不同：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;词汇量&lt;/strong&gt;：编程语言的关键词数量有限且确定，而自然语言的词汇量是无尽的、可创造的。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;结构化&lt;/strong&gt;：自然语言是非结构化的，而编程语言是结构化的。&lt;/p&gt;&#xA;&lt;p&gt;(3) &lt;strong&gt;歧义性&lt;/strong&gt;：自然语言含有大量歧义，这些歧义根据语境的不同而表现为特定的义项。语言中的歧义问题是自然语言难以处理的原因。&lt;/p&gt;&#xA;&lt;p&gt;(4) &lt;strong&gt;容错性&lt;/strong&gt;：自然语言具有很高的容错性，人们可以猜出有错的句子的含义；编程语言的拼写必须保证绝对正确，语法必须保证绝对规范。&lt;/p&gt;&#xA;&lt;p&gt;(5) &lt;strong&gt;易变性&lt;/strong&gt;：编程语言的变化缓慢温和，而自然语言的变化迅速嘈杂。&lt;/p&gt;&#xA;&lt;p&gt;(6) &lt;strong&gt;简略性&lt;/strong&gt;：人类语言往往简洁干练，我们经常省略大量背景知识或常识。&lt;/p&gt;&#xA;&lt;h3 id=&#34;自然语言处理的任务&#34;&gt;自然语言处理的任务&lt;/h3&gt;&#xA;&lt;p&gt;(1) 语音、图像和文本的处理&lt;/p&gt;&#xA;&lt;p&gt;自然语言处理系统的输入源有语音、图像和文本。其中文本占主要地位，语音和图像受制于存储容量和传输速度的限制，它们的信息总量不如文本多。通常进行**语音识别(speech recognition)&lt;strong&gt;将语音转化为文本，使用&lt;/strong&gt;光学字符识别(optical character recognition, OCR)**将图像转化为文本。&lt;/p&gt;&#xA;&lt;p&gt;(2) 词法分析&lt;/p&gt;&#xA;&lt;p&gt;这三个任务都是围绕词语进行的分析，所以统称&lt;strong&gt;词法分析(lexical analysis)&lt;/strong&gt;。词法分析的主要任务是：将文本分隔为有意义的词语，即&lt;strong&gt;分词(segmentation)&lt;/strong&gt;；确定每个词语的类别和浅层的歧义消除，即&lt;strong&gt;词性标注(part-of-speech tagging)&lt;/strong&gt;；并且识别出一些较长的专有名词，即&lt;strong&gt;命名实体识别(named entity recognition, NER)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;(3) 信息抽取&lt;/p&gt;&#xA;&lt;p&gt;词法分析以后，文本已经呈现出部分结构化的趋势，计算机看到的不再是一个长字符串，而是有意义的单词列表，且每个单词还附有自己的词性及其他标签。根据这些单词与标签，可以利用&lt;strong&gt;信息抽取(information extraction)&lt;strong&gt;技术来抽取文本中的有用信息，从简单的&lt;/strong&gt;高频词&lt;/strong&gt;到高级算法提取出的&lt;strong&gt;关键词&lt;/strong&gt;，从&lt;strong&gt;公司名称&lt;/strong&gt;到&lt;strong&gt;专业术语&lt;/strong&gt;，其中词语级别的信息已经可以进行很多的抽取。我们还可以根据词语之间的统计学信息抽取出关键短语乃至句子，更大粒度的文本对用户更加友好。&lt;/p&gt;&#xA;&lt;p&gt;(4) 文本分类与文本聚类&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;文本分类(text classification)&lt;/strong&gt; 任务可以判断一段话是褒义还是贬义、分析一句话的感情是积极还是消极、判断一封邮件是否是垃圾邮件等。**文本聚类(text clustering)**任务可以将相似的文本归档到一起、排除重复文档等，在信息检索等领域有着广泛的应用。&lt;/p&gt;&#xA;&lt;p&gt;(5) 句法分析&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;句法分析(syntactic parsing)&lt;strong&gt;将零散词汇信息进行分析，得到&lt;/strong&gt;词语间的关系&lt;/strong&gt;。问答系统、搜索引擎和机器翻译等系统中，句法分析都是很重要的。&lt;/p&gt;&#xA;&lt;p&gt;(6) 语义分析&lt;/p&gt;&#xA;&lt;p&gt;相较于语法分析，&lt;strong&gt;语义分析(semantic analysis)&lt;/strong&gt; 侧重语义而非语法。它包括&lt;strong&gt;词意消解&lt;/strong&gt;(确定一个词在语境中的含义)、&lt;strong&gt;语义角色标注&lt;/strong&gt;(标准组句子中的谓语与其他成分的关系)乃至&lt;strong&gt;语义依存分析&lt;/strong&gt;(分析句子中词语之间的语义关系)。&lt;/p&gt;&#xA;&lt;p&gt;(7) 其他高级任务&lt;/p&gt;&#xA;&lt;p&gt;除了上述任务以外，还有很多综合性的任务，与终端应用级产品联系更加紧密。比如：&lt;strong&gt;自动问答(QA)&lt;/strong&gt;、&lt;strong&gt;自动摘要(summarization)&lt;/strong&gt;、&lt;strong&gt;机器翻译(machine translation)&lt;/strong&gt; 等。注意，一般认为&lt;strong&gt;信息检索(information retrieve, IR)&lt;/strong&gt; 是区别于自然语言处理的独立学科。虽然二者具有密切的联系，但&lt;strong&gt;IR的目标是查询信息，而NLP的目标是理解语言&lt;/strong&gt;，二者的目标具有本质上的区别。&lt;/p&gt;&#xA;&lt;h3 id=&#34;自然语言处理的知识域&#34;&gt;自然语言处理的知识域&lt;/h3&gt;&#xA;&lt;p&gt;计算机分析所接受声音信号，并且把单词序列转换成声音信号，分别需要&lt;strong&gt;语音学&lt;/strong&gt;和&lt;strong&gt;音系学&lt;/strong&gt;的知识，这样的知识可以帮助我们建立词如何在话语中发音的模型。&lt;/p&gt;</description>
    </item>
    <item>
      <title>微积分</title>
      <link>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math2-%E5%BE%AE%E7%A7%AF%E5%88%86/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math2-%E5%BE%AE%E7%A7%AF%E5%88%86/</guid>
      <description>&lt;p&gt;&lt;strong&gt;微积分(calculus)&lt;/strong&gt;是研究函数的&lt;strong&gt;微分(differentiation)&lt;/strong&gt;、&lt;strong&gt;积分(integration)&lt;/strong&gt;及其相关应用的数学分支。&lt;/p&gt;&#xA;&lt;h3 id=&#34;微分&#34;&gt;微分&lt;/h3&gt;&#xA;&lt;h4 id=&#34;导数&#34;&gt;导数&lt;/h4&gt;&#xA;$$&#xD;&#xA;f^{\prime}(x_{0})=\lim _{\Delta x \rightarrow 0} \frac{f(x_{0}+\Delta x)-f(x_{0})}{\Delta x}&#xD;&#xA;$$&lt;p&gt;&#xA;存在，则称函数$f(x)$在点$x_0$处可导，$f^{\prime}(x_0)$称为其&lt;strong&gt;导数(derivative)&lt;/strong&gt;，或&lt;strong&gt;导函数&lt;/strong&gt;，也可以记为${\text d f(x_0)}/{\text d x}$。在几何上，导数可以看做函数曲线上的切线斜率。下图给出了一个函数导数的可视化示例，其中函数$g(x)$的斜率为函数$f(x)$在点$x$的导数，$\Delta y=f(x+\Delta x)-f(x)$。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/1/image-20200509113346911.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;下表中给出了几个机器学习领域常见函数的导数：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/1/image-20200509113448001.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;&lt;strong&gt;高阶导数&lt;/strong&gt;：对一个函数的导数继续求导，可以得到高阶导数。函数$f(x)$的导数$f^\prime(x)$称为一阶导数，$f^\prime(x)$的导数称为&lt;strong&gt;二阶导数&lt;/strong&gt;，记为$f^{\prime\prime}(x)$、$f^{(2)}(x)$或$\text d^2f(x)/\text d x^2$。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;偏导数(partial derrivative)&lt;/strong&gt;：对于一个多元变量函数$f:\mathbb R^d \rightarrow \mathbb R$，其偏导数是关于其中一个变量$x_i$的导数，而保持其他变量固定，可以记为$f_{x_{i}}^{\prime}(\boldsymbol{x})$，$\nabla_{x_{i}} f(\boldsymbol{x})$或$\partial f(\boldsymbol x)/\partial x_i$。&lt;/p&gt;&#xA;&lt;h4 id=&#34;微分-1&#34;&gt;微分&lt;/h4&gt;&#xA;&lt;p&gt;给定一个连续函数，计算其导数的过程称为&lt;strong&gt;微分(differentiation)&lt;/strong&gt;。若函数$f(x)$在其定义域包含的某区间内每一个点都可导，那么也可以说函数$f(x)$在这个区间内可导。如果一个函数$f(x)$在定义域中的所有点都存在导数，则$f(x)$为&lt;strong&gt;可微函数(differentiable function)&lt;/strong&gt;。可微函数一定连续，但连续函数不一定可微。例如函数$|x|$为连续函数，但在点$x=0$处不可导。&lt;/p&gt;&#xA;&lt;h4 id=&#34;泰勒公式&#34;&gt;泰勒公式&lt;/h4&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;f(x)=f(a)+&amp; \frac{1}{1 !} f^{\prime}(a)(x-a)+\frac{1}{2 !} f^{(2)}(a)(x-a)^{2}+\cdots \\&#xD;&#xA;&amp;+\frac{1}{n !} f^{(n)}(a)(x-a)^{n}+R_{n}(x)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中$f^{(n)}(a)$表示函数$f(x)$在点$a$的$n$阶导数。上式中的多项式部分称为函数$f(x)$在$a$出的$n$阶泰勒展开式，剩余的$R_n(x)$是泰勒公式的余项，是$(x-a)^n$的高阶无穷小。&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# sympy实现自动微分&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 使用diff()函数来计算导数&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Symbol&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#39;x&amp;#39;&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;f1&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;**&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;4&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;3&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;6&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;f1_&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;diff&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;f1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;f1_&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;f2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;sin&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;f2_&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;diff&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;f2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;f2_&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 计算偏导数&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Symbol&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#39;y&amp;#39;&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;f3&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;**&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;3&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;**&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;4&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 分别计算函数f3对于变量x和y的偏导数&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;f3_x&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;diff&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;f3&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;f3_y&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;diff&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;f3&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#39;partial derivative of x: &amp;#39;&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;f3_x&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#39;partial derivative of y: &amp;#39;&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;f3_y&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 链式法则&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Symbol&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#39;x&amp;#39;&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;u&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;sin&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;v&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;u&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;**&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;sympy&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;diff&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;v&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;x&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;积分&#34;&gt;积分&lt;/h3&gt;&#xA;&lt;p&gt;积分(integration)是微分的逆过程，即如何从导数推算出原函数。积分通常可以分为&lt;strong&gt;定积分(definite integral)&lt;strong&gt;和&lt;/strong&gt;不定积分(indefinite integral)&lt;/strong&gt;。&lt;/p&gt;</description>
    </item>
    <item>
      <title>神经网络</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl2-%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl2-%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</guid>
      <description>&lt;p&gt;&lt;strong&gt;人工神经网络(artificial neural network, ANN)&lt;/strong&gt; 是指一系列受生物学和神经科学启发的数学模型. 这些模型主要是通过对人脑的神经元网络进行抽象，构建&lt;strong&gt;人工神经元&lt;/strong&gt;，并按照一定拓扑结构来建立人工神经元之间的连接，来模拟生物神经网络。在人工智能领域，人工神经网络也常常简称为&lt;strong&gt;神经网络(neural network, NN)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;神经网络最早是作为一种主要的&lt;strong&gt;连接主义模型&lt;/strong&gt;。20世纪80年代中后期，最流行的一种连接主义模型是&lt;strong&gt;分布式并行处理(parallel distributed processing, PDP)模型&lt;/strong&gt;，其有3个主要特性：(1) 信息表示是分布式的(非局部的)；(2) 记忆和知识是存储在单元之间的连接上；(3)通过逐渐改变单元之间的连接强度来学习新的知识。&lt;/p&gt;&#xA;&lt;p&gt;连接主义的神经网络有着多种多样的网络结构以及学习方法，虽然早期模型强调模型的&lt;strong&gt;生物可解释性(biological plausibility)&lt;/strong&gt;，但后期更关注于&lt;strong&gt;对某种特定认知能力的模拟&lt;/strong&gt;，比如物体识别、语言理解等. 尤其在引入误差反向传播来改进其学习能力之后，神经网络也越来越多地应用在各种机器学习任务上。随着训练数据的增多以及(并行)计算能力的增强，神经网络在很多机器学习任务上已经取得了很大的突破，特别是在语音、图像等感知信号的处理任务上，神经网络表现出了卓越的学习能力。&lt;/p&gt;&#xA;&lt;p&gt;目前受到关注的是采用&lt;strong&gt;误差反向传播&lt;/strong&gt;来进行学习的神经网络，即作为&lt;strong&gt;一种机器学习模型&lt;/strong&gt;的神经网络。从机器学习的角度来看，神经网络一般可以看作是一个&lt;strong&gt;非线性模型&lt;/strong&gt;，其基本组成单元为&lt;strong&gt;具有非线性激活函数的神经元&lt;/strong&gt;，通过大量神经元之间的连接，使得神经网络成为一种&lt;strong&gt;高度非线性的模型&lt;/strong&gt;。神经元之间的&lt;strong&gt;连接权重&lt;/strong&gt;就是&lt;strong&gt;需要学习的参数&lt;/strong&gt;，可以在机器学习的&lt;strong&gt;框架&lt;/strong&gt;下通过&lt;strong&gt;梯度下降&lt;/strong&gt;方法来进行学习。&lt;/p&gt;&#xA;&lt;h3 id=&#34;神经网络的基本结构&#34;&gt;神经网络的基本结构&lt;/h3&gt;&#xA;&lt;p&gt;神经网络的基本组成单位是&lt;strong&gt;神经元(neuron)&lt;/strong&gt;，如下所示：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200428203202172.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;z &amp;=\sum_{d=1}^{D} w_{d} x_{d}+b \\&#xD;&#xA;&amp;=\boldsymbol{w}^{\text T} \boldsymbol{x}+b&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中$\boldsymbol{w}=[w_{1} ; w_{2} ; \cdots ; w_{D}] \in \mathbb{R}^{D}$是$D$维的&lt;strong&gt;权重(weight)&lt;strong&gt;向量，$b\in \mathbb R$是&lt;/strong&gt;偏置(bias)&lt;/strong&gt;。净输入$z$在经过一个非线性函数$f$后，得到神经元的&lt;strong&gt;激活值(activation)&lt;/strong&gt;$a=f(z)$，其中非线性函数$f$称为&lt;strong&gt;激活函数&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;与&lt;strong&gt;感知机(perceptron)&lt;strong&gt;相比，神经元的激活函数通常是&lt;/strong&gt;连续可导的函数&lt;/strong&gt;，而感知机的激活函数仅仅是在$x=0$处不可导的阶跃函数，用于将输出值进行二分，不需要进行反向梯度计算。&lt;/p&gt;&#xA;&lt;p&gt;到目前为止，研究者已经发明了各种各样的神经网络结构。目前常用的神经网络结构有以下三种：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;前馈网络&lt;/strong&gt;：前馈网络中各个神经元按接收信息的先后分为不同的组。每一组可以看作一个&lt;strong&gt;神经层&lt;/strong&gt;。每一层中的神经元接收前一层神经元的输出，并输出到下一层神经元。整个网络中的信息是朝一个方向传播，没有反向的信息传播，可以用一个有向无环路图表示。前馈网络包括&lt;strong&gt;全连接前馈网络&lt;/strong&gt;和&lt;strong&gt;卷积神经网络&lt;/strong&gt;等。前馈网络可以看作一个函数，通过简单非线性函数的多次复合，实现输入空间到输出空间的复杂映射。这种网络结构简单，易于实现。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;记忆网络&lt;/strong&gt;：也称反馈网络，网络中的神经元不但可以接收其他神经元的信息，也可以接收自己的历史信息。和前馈网络相比，记忆网络中的神经元具有记忆功能，在不同的时刻具有不同的状态。记忆神经网络中的信息传播可以是单向或双向传递，因此可用一个&lt;strong&gt;有向循环图或无向图&lt;/strong&gt;来表示。记忆网络包括&lt;strong&gt;循环神经网络&lt;/strong&gt;、&lt;strong&gt;Hopfield网络&lt;/strong&gt;、&lt;strong&gt;玻尔兹曼机&lt;/strong&gt;、&lt;strong&gt;受限玻尔兹曼机&lt;/strong&gt;等。记忆网络可以看作一个程序，具有更强的计算和记忆能力。为了增强记忆网络的记忆容量，可以引入外部记忆单元和读写机制，用来保存一些网络的中间状态，称为&lt;strong&gt;记忆增强神经网络(memory augmented neural network, MANN)&lt;/strong&gt;，比如&lt;strong&gt;神经图灵机&lt;/strong&gt;和&lt;strong&gt;记忆网络&lt;/strong&gt;等。&lt;/p&gt;&#xA;&lt;p&gt;(3) &lt;strong&gt;图网络&lt;/strong&gt;：前馈网络和记忆网络的输入都可以表示为向量或向量序列。但实际应用中很多数据是图结构的数据，比如知识图谱、社交网络、分子网络等。前馈网络和记忆网络很难处理图结构的数据。图网络是定义在图结构数据上的神经网络。图中每个节点都由一个或一组神经元构成。节点之间的连接可以是有向的，也可以是无向的。每个节点可以收到来自相邻节点或自身的信息.&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;图网络是前馈网络和记忆网络的泛化&lt;/strong&gt;，包含很多不同的实现方式，比如&lt;strong&gt;图卷积网络(graph convolutional network, GCN)&lt;/strong&gt;、&lt;strong&gt;图注意力网络(graph attention network, GAT)&lt;/strong&gt;、&lt;strong&gt;消息传递神经网络(message passing neural network, MPNN)&lt;/strong&gt; 等。&lt;/p&gt;&#xA;&lt;p&gt;三种网络结构示意图如下所示：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200428224849253.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;激活函数&#34;&gt;激活函数&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;激活函数(activation function)&lt;/strong&gt; 的作用是为神经网络的传播过程增添非线性因素。为了增强网络的表示能力，激活函数需要具备以下几点性质：&lt;/p&gt;</description>
    </item>
    <item>
      <title>线性回归</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml2-%E7%BA%BF%E6%80%A7%E5%9B%9E%E5%BD%92/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml2-%E7%BA%BF%E6%80%A7%E5%9B%9E%E5%BD%92/</guid>
      <description>&lt;h3 id=&#34;线性回归模型&#34;&gt;线性回归模型&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;线性回归(linear regression)&lt;/strong&gt; 是机器学习和统计学中最基础和广泛应用的模型，是一种对自变量和隐变量之间关系进行建模的回归分析。自变量数量为1时称为&lt;strong&gt;简单线性回归&lt;/strong&gt;，自变量数量大于1时称为&lt;strong&gt;多元线性回归&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;从机器学习的角度看，输入就是样本的特征向量$\boldsymbol x\in \mathbb R^d$，其每一维对应一个自变量(数据的特征)；输出是标签$y$，这里$y\in \mathbb R$是连续值(实数或连续整数)。假设空间是一组参数化的线性函数$f(\boldsymbol x;\boldsymbol w;b)=\boldsymbol w^\text T \boldsymbol x+b$，其中&lt;strong&gt;权重向量&lt;/strong&gt;$\boldsymbol w$与输入$\boldsymbol x$维度相同，&lt;strong&gt;偏置&lt;/strong&gt;$b$是一个标量，二者都是&lt;strong&gt;可学习的参数&lt;/strong&gt;。令$\boldsymbol x$再拼接一个常数$1$，$\boldsymbol w$再拼接一个偏置$b$，线性模型就可以更简洁地用$f(\boldsymbol x;\boldsymbol w)=\boldsymbol w^\text T \boldsymbol x$来表示。&lt;/p&gt;&#xA;&lt;p&gt;线性回归的示意图如下：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200416113414181.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;线性回归经验风险最小化&#34;&gt;线性回归经验风险最小化&lt;/h3&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\mathcal R(w)&amp;=\sum_{n=1}^{N}L(y^{(n)},f(\boldsymbol x^{(n)};\boldsymbol w))\\&#xD;&#xA;&amp;=\frac{1}{2}\sum_{n=1}^{N}(y^{(n)}-\boldsymbol w^\text T \boldsymbol x^{(n)})^2\\&#xD;&#xA;&amp;=\frac{1}{2}\|\boldsymbol y-X^\text T \boldsymbol w\|^2&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;X = \begin{bmatrix}&#xD;&#xA;x_1^{(1)} &amp; x_1^{(2)} &amp; \cdots &amp; x_1^{(N)} \\&#xD;&#xA;x_2^{(1)} &amp; x_2^{(2)} &amp; \cdots &amp; x_2^{(N)} \\&#xD;&#xA;\vdots &amp; \vdots &amp; \ddots &amp; \vdots \\&#xD;&#xA;x_d^{(1)} &amp; x_d^{(2)} &amp; \cdots &amp; x_d^{(N)}\\&#xD;&#xA;1 &amp; 1 &amp; \cdots &amp; 1&#xD;&#xA;\end{bmatrix}&#xD;&#xA;$$$$&#xD;&#xA;\frac{\partial \mathcal R(\boldsymbol w)}{\partial \boldsymbol w}=\frac{1}{2}\frac{\partial \|\boldsymbol y-X^\text T \boldsymbol w\|^2}{\partial \boldsymbol w}=-X(\boldsymbol y-X^\text T \boldsymbol w)&#xD;&#xA;$$&lt;p&gt;&#xA;令该导数值为0，即可得到最优参数$\boldsymbol w^*=(XX^\text T)^{-1}X\boldsymbol y$。这便是线性回归最优解的矩阵表示形式。这种求解线性回归参数的方法也称为&lt;strong&gt;最小二乘法(least square method, LSM)&lt;/strong&gt;。&lt;/p&gt;</description>
    </item>
    <item>
      <title>词向量</title>
      <link>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp2-%E8%AF%8D%E5%90%91%E9%87%8F/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp2-%E8%AF%8D%E5%90%91%E9%87%8F/</guid>
      <description>&lt;h3 id=&#34;词向量概述&#34;&gt;词向量概述&lt;/h3&gt;&#xA;&lt;p&gt;在自然语言处理领域，词的&lt;strong&gt;表示(representation)&lt;/strong&gt; 是一个核心问题。我们希望将单词通过某种嵌入的形式表示，以捕获词的&lt;strong&gt;含义(meaning)&lt;strong&gt;以及词和词之间的&lt;/strong&gt;关系(relationship)&lt;/strong&gt;。一个解决方法是，使用wordnet(a thesaurus containing lists of &lt;strong&gt;synonym sets&lt;/strong&gt; and &lt;strong&gt;hypernyms&lt;/strong&gt;)，如下所示：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200426111111921.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;然而，wordnet存在着许多问题，例如新词汇含义的缺失、上下文无关以及对人类劳动力的需求过大等。&lt;/p&gt;&#xA;$$&#xD;&#xA;w^{\text {aardvark}}=\left[\begin{array}{c}1 \\0 \\0 \\\vdots \\0\end{array}\right], w^{a}=\left[\begin{array}{c}0 \\1 \\0 \\\vdots \\0\end{array}\right], w^{a t}=\left[\begin{array}{c}0 \\0 \\1 \\\vdots \\0\end{array}\right], \cdots w^{z e b r a}=\left[\begin{array}{c}0 \\0 \\0 \\\vdots \\1\end{array}\right]&#xD;&#xA;$$&lt;p&gt;&#xA;即&lt;strong&gt;每个向量中只有一个位置为1，其余位置为0，为1的位置的下标对应单词的id&lt;/strong&gt;。这样的词表示存在两个问题：(1) 没有给出两个单词之间的相似性，即任何两个向量的余弦相似度为0，这样会丢失语义信息；(2) 当词汇表很大时，每个单词对应的向量是一个高维稀疏向量。&lt;/p&gt;&#xA;&lt;p&gt;因此，或许可以尝试降低维度，使用一个&lt;strong&gt;子空间&lt;/strong&gt;(维度为$N$，$N\ll |V|$)来表达单词。在传统机器学习方法中，可以利用**奇异值分解(single value decomposition, SVD)**实现该过程。&lt;/p&gt;&#xA;&lt;p&gt;首先遍历一个很大的数据集，统计词的共现计数矩阵$X$，然后对矩阵$X$进行奇异值分解得到$USV^\text T$，然后我们使用矩阵$U$的行来作为字典中所有词的词向量。$X$矩阵有两种选择的方式：(1) 统计每个单词在每个文档中出现的次数，生成&lt;strong&gt;单词-文本矩阵(word-document matrix)&lt;/strong&gt;，这种方式称为&lt;strong&gt;潜在语义分析(latent semantic analysis)&lt;/strong&gt;；(2) 计算每个单词在感兴趣单词的&lt;strong&gt;附近特定大小的窗口&lt;/strong&gt;中出现的次数，生成&lt;strong&gt;基于窗口的单词-单词共现矩阵(window based co-occurence matrix)&lt;/strong&gt;。以下为该方法的示例(假定窗口大小为1)：&lt;/p&gt;&#xA;&lt;p&gt;(1) I enjoy flflying.&lt;/p&gt;&#xA;&lt;p&gt;(2) I like NLP.&lt;/p&gt;&#xA;&lt;p&gt;(3) I like deep learning.&lt;/p&gt;</description>
    </item>
    <item>
      <title>卷积神经网络</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl3-%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl3-%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</guid>
      <description>&lt;p&gt;&lt;strong&gt;卷积神经网络(convolutional neural network, CNN)&lt;/strong&gt; 是一种具有局部连接、权重共享等特性的前馈神经网络。&lt;/p&gt;&#xA;&lt;p&gt;卷积神经网络最早是主要用来处理图像信息。在用全连接前馈网络来处理图像时，会存在参数太多、局部特征不变形等缺陷。卷积神经网络利用&lt;strong&gt;局部连接、权重共享以及汇聚&lt;/strong&gt;三大结构上的特性，使得数据具有一定程度上的平移、缩放和旋转不变性。和前馈神经网络相比，卷积神经网络的参数更少。&lt;/p&gt;&#xA;&lt;p&gt;卷积神经网络主要使用在图像和视频分析的各种任务(如图像分类、人脸识别、物体识别、图像分割等)上，其准确率一般也远远超出了其它的神经网络模型。近年来卷积神经网络也广泛地应用到自然语言处理、推荐系统等领域。&lt;/p&gt;&#xA;&lt;h3 id=&#34;卷积&#34;&gt;卷积&lt;/h3&gt;&#xA;&lt;h4 id=&#34;一维卷积&#34;&gt;一维卷积&lt;/h4&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;y_{t} &amp;=1 \times x_{t}+1 / 2 \times x_{t-1}+1 / 4 \times x_{t-2} \\&#xD;&#xA;&amp;=w_{1} \times x_{t}+w_{2} \times x_{t-1}+w_{3} \times x_{t-2} \\&#xD;&#xA;&amp;=\sum_{k=1}^{3} w_{k} \cdot x_{t-k+1}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;y_{t}=\sum_{k=1}^{m} w_{k} \cdot x_{t-k+1}&#xD;&#xA;$$&lt;p&gt;&#xA;写作&lt;strong&gt;向量形式&lt;/strong&gt;：$\boldsymbol{y}=\boldsymbol{w} \otimes \boldsymbol{x}$，其中$\otimes$表示卷积运算。当滤波器$w_k=1/m,1\leqslant k \leqslant m$时，卷积相当于信号序列的简单&lt;strong&gt;移动平均(moving average, MA)&lt;/strong&gt;，窗口大小为$m$。&lt;/p&gt;&#xA;&lt;p&gt;一般情况下滤波器的长度$m$远小于信号序列的长度$n$。下图为一维卷积的示意图：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200508144946346.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h4 id=&#34;二维卷积&#34;&gt;二维卷积&lt;/h4&gt;&#xA;$$&#xD;&#xA;y_{i j}=\sum_{u=1}^{m} \sum_{v=1}^{n} w_{u v} \cdot x_{i-u+1, j-v+1}&#xD;&#xA;$$&lt;p&gt;&#xA;下图给出了二维卷积的示例：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200508145402520.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;&lt;strong&gt;均值滤波(mean filter)&lt;/strong&gt; 就是当前位置的像素值设为滤波器窗口中所有像素的平均值，也就是$w_{uv}=1/mn$。&lt;/p&gt;&#xA;&lt;p&gt;在图像处理中，卷积经常作为&lt;strong&gt;特征提取&lt;/strong&gt;的有效方法。一幅图像在经过卷积操作后得到结果称为&lt;strong&gt;特征映射(feature map)&lt;/strong&gt;。下图给出在图像处理中几种常用的滤波器，以及其对应的特征映射。图中最上面的滤波器是常用的&lt;strong&gt;高斯滤波器&lt;/strong&gt;，可以用来对图像进行&lt;strong&gt;平滑去噪&lt;/strong&gt;；中间和最下面的滤波器可以用来&lt;strong&gt;提取边缘特征&lt;/strong&gt;。&lt;/p&gt;</description>
    </item>
    <item>
      <title>数学优化</title>
      <link>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math3-%E6%95%B0%E5%AD%A6%E4%BC%98%E5%8C%96/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math3-%E6%95%B0%E5%AD%A6%E4%BC%98%E5%8C%96/</guid>
      <description>$$f(\boldsymbol{x}^{*}) \leqslant f(\boldsymbol{x})$$&lt;p&gt;(最小化)；或者$f(\boldsymbol{x}^{*}) \geqslant f(\boldsymbol{x})$(最大化)，其中$\mathcal D$为变量$\boldsymbol x$的&lt;strong&gt;约束集&lt;/strong&gt;，也叫&lt;strong&gt;可行域&lt;/strong&gt;；$\mathcal D$中的变量被称为&lt;strong&gt;可行解&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h3 id=&#34;数学优化的类型&#34;&gt;数学优化的类型&lt;/h3&gt;&#xA;&lt;h4 id=&#34;离散优化和连续优化&#34;&gt;离散优化和连续优化&lt;/h4&gt;&#xA;&lt;p&gt;&lt;b&gt;离散优化(discrete optimization)&lt;/b&gt;问题是目标函数的输入变量为离散变量，比如为整数或有限集合中的元素。离散优化问题主要有两个分支：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;组合优化(combinatorial optimization)&lt;/strong&gt;：其目标是从一个有限集合中找出使得目标函数最优的元素。在一般的组合优化问题中，集合中的元素之间存在一定的关联，可以表示为图结构。典型的组合优化问题有旅行商问题、最小生成树问题、图着色问题等。很多机器学习问题都是组合优化问题，比如特征选择、聚类问题、超参数优化问题以及&lt;b&gt;结构化学习(structured learning)&lt;/b&gt;中标签预测问题等。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;整数规划(integer programming)&lt;/strong&gt;：输入变量$\boldsymbol x \in \mathbb Z^d$是一个整数向量。常见的整数规划问题通常为&lt;b&gt;整数线性规划&lt;/b&gt;。整数线性规划的一种最直接的求解方法是：1. 去掉输入必须为整数的限制，将原问题转换为&lt;strong&gt;一般的线性规划问题&lt;/strong&gt;，这个线性规划问题为原问题的&lt;strong&gt;松弛问题&lt;/strong&gt;；2. 求得相应松弛问题的解；3. 把松弛问题的解&lt;strong&gt;四舍五入到最接近的整数&lt;/strong&gt;。但是这种方法得到的解&lt;strong&gt;一般都不是最优的&lt;/strong&gt;，因为原问题的最优解不一定在松弛问题最优解的附近。另外，这种方法得到的解也不一定满足约束条件。&lt;/p&gt;&#xA;&lt;p&gt;离散优化问题的求解一般都比较困难，优化算法的复杂度都比较高。&lt;/p&gt;&#xA;&lt;p&gt;&lt;b&gt;连续优化(continuous optimization)&lt;/b&gt;目标函数的输入变量为连续变量$\boldsymbol x \in \mathbb R^d$，即目标函数为实函数。机器学习中的优化问题主要是连续优化问题。&lt;/p&gt;&#xA;&lt;h4 id=&#34;无约束优化和约束优化&#34;&gt;无约束优化和约束优化&lt;/h4&gt;&#xA;&lt;p&gt;在连续优化问题中，根据是否有变量的约束条件，可以将优化问题分为无约束优化问题和约束优化问题。&lt;/p&gt;&#xA;$$&#xD;&#xA;\min _{\boldsymbol{x}} \ \ f(\boldsymbol{x})&#xD;&#xA;$$&lt;p&gt;&#xA;其中$\boldsymbol x \in \mathbb R^d$为输入变量，$f:\mathbb R \rightarrow \mathbb R $为目标函数。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;约束优化(constrained optimization)&lt;/strong&gt; 问题中变量$ \boldsymbol x $需要满足一些等式或不等式的约束。约束优化问题通常使用&lt;strong&gt;拉格朗日乘数法&lt;/strong&gt;来进行求解。&lt;/p&gt;&#xA;&lt;h4 id=&#34;线性优化和非线性优化&#34;&gt;线性优化和非线性优化&lt;/h4&gt;&#xA;&lt;p&gt;若目标函数和所有的约束函数都为线性函数，则该问题称为&lt;b&gt;线性规划(linear programming)&lt;/b&gt;问题。相反，如果木变函数或任何一个约束函数为非线性函数，则该问题为 &lt;b&gt;非线性规划(nonlinear programming)&lt;/b&gt;问题。&lt;/p&gt;&#xA;$$&#xD;&#xA;f(\alpha \boldsymbol{x}+(1-\alpha) \boldsymbol{y}) \leq \alpha f(\boldsymbol{x})+(1-\alpha) f(\boldsymbol{y}), \ \ \forall \alpha \in[0,1]&#xD;&#xA;$$&lt;p&gt;&#xA;凸优化问题是一种特殊的约束优化问题，需满足目标函数为凸函数，并且等式约束函数为线性函数，不等式约束函数为凸函数。&lt;/p&gt;</description>
    </item>
    <item>
      <title>概率统计</title>
      <link>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math4-%E6%A6%82%E7%8E%87%E7%BB%9F%E8%AE%A1/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math4-%E6%A6%82%E7%8E%87%E7%BB%9F%E8%AE%A1/</guid>
      <description>&lt;h3 id=&#34;概率统计的基本概念&#34;&gt;概率统计的基本概念&lt;/h3&gt;&#xA;&lt;h4 id=&#34;样本空间与随机事件&#34;&gt;样本空间与随机事件&lt;/h4&gt;&#xA;&lt;p&gt;&lt;strong&gt;样本空间(sample space)&lt;strong&gt;是一个随机试验&lt;/strong&gt;所有可能结果的集合&lt;/strong&gt;。例如，如果抛一枚硬币，那么样本空间的集合就是{正面, 反面}；如果抛一个骰子，那么样本空间就是{1, 2, 3, 4, 5, 6}。随机试验中的每个可能结果称为&lt;strong&gt;样本点&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;一般称试验$E$的样本空间$S$的子集为$E$的&lt;strong&gt;随机事件&lt;/strong&gt;，简称事件。在每次试验中，当且仅当这一子集中的一个样本点出现时，称这一事件发生。&lt;/p&gt;&#xA;&lt;p&gt;有些试验有&lt;strong&gt;两个或多个可能的样本空间&lt;/strong&gt;。例如，从52张扑克牌中随机抽出一张，样本空间可以是数字(A到K)，也可以是花色(黑桃, 红桃, 梅花, 方块)。如果要完整地描述一张牌，就需要同时给出数字和花色，这时样本空间可以通过构建上述两个样本空间的&lt;strong&gt;笛卡儿乘积&lt;/strong&gt;来得到。具体选用什么样的样本空间，由任务需求来决定。&lt;/p&gt;&#xA;&lt;h4 id=&#34;计数原理&#34;&gt;计数原理&lt;/h4&gt;&#xA;&lt;p&gt;&lt;strong&gt;计数(counting)&lt;strong&gt;是样本空间的基本概念。计数的基本原理是&lt;/strong&gt;加法原理(sum rule)&lt;strong&gt;和&lt;/strong&gt;乘法原理(product rule)&lt;/strong&gt;。加法原理指的是：做一件事情，完成它有$n$类方式，第一类方式有$m_1$种方法，第二类方式有$m_2$种方法，以此类推，第$n$类方式有$m_n$种方法，那么完成这件事情共有$m_1+m_2+\cdots+m_n$种方法。乘法原理指的是：做一件事，完成它需要分成$n$个步骤，做第一 步有$m_1$种不同的方法，做第二步有$m_2$种不同的方法，以此类推，做第$n$步有$m_n$种不同的方法。那么完成这件事共有$N=m_1 \times m_2 \times \cdots \times m_n$种不同的方法。&lt;/p&gt;&#xA;&lt;h4 id=&#34;排列与组合&#34;&gt;排列与组合&lt;/h4&gt;&#xA;&lt;p&gt;下图为&lt;strong&gt;排列(permutation)数&lt;/strong&gt;、&lt;strong&gt;组合(combination)数&lt;/strong&gt;以及将物体放入桶中问题的计算方法：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/1/image-20200603225257471.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# scipy实现阶乘和组合数的计算&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;math&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;scipy&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;special&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;scipy&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;stats&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 计算阶乘&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;math&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;factorial&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;20&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 计算组合数&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;special&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;binom&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;3&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h4 id=&#34;概率的公理&#34;&gt;概率的公理&lt;/h4&gt;&#xA;&lt;p&gt;将事件$E$发生的概率定义为$P(E)$，全集为$S$，则概率$P(E)$满足如下三条公理：&lt;/p&gt;&#xA;&lt;p&gt;(1) $0 \leqslant P(E) \leqslant 1$；&lt;/p&gt;&#xA;&lt;p&gt;(2) $P(S)=1$；&lt;/p&gt;&#xA;&lt;p&gt;(3) 若事件$E$和事件$F$无交集，即$(E \cap F=\varnothing)$，则$P(E \cup F)=P(E)+P(F)$。&lt;/p&gt;&#xA;&lt;h4 id=&#34;概率的推论&#34;&gt;概率的推论&lt;/h4&gt;&#xA;&lt;p&gt;设事件$E$的对立事件为$\bar E$，概率存在以下三个基本的推论：&lt;/p&gt;&#xA;&lt;p&gt;(1) $P(\bar E)=1-P(E)$；&lt;/p&gt;&#xA;&lt;p&gt;(2) 若$E \subseteq F$，则$P(E) \leqslant P(F)$；&lt;/p&gt;&#xA;&lt;p&gt;(3) $P(E \cap F)=P(E)+P(F)-P(E \cup F)$。&lt;/p&gt;</description>
    </item>
    <item>
      <title>语言模型</title>
      <link>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp3-%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp3-%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B/</guid>
      <description>&lt;h3 id=&#34;n元语法&#34;&gt;N元语法&lt;/h3&gt;&#xA;&lt;p&gt;N元语言模型可以用来&lt;strong&gt;预测一个句子的下一个单词的概率&lt;/strong&gt;，或者&lt;strong&gt;计算一个句子的概率&lt;/strong&gt;。该模型常用于语音识别、拼写检查以及语法检查等领域。&lt;/p&gt;&#xA;&lt;p&gt;首先，&lt;strong&gt;一个句子“its water is so transparent that”后出现某一单词“the”的概率&lt;/strong&gt;为：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200715204336846.png&#34; style=&#34;zoom:20%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;但是由于语料的多样性以及巨大的数量，许多句子不会在语料中出现，并且计数过程会消耗大量的时间。同样，对于&lt;strong&gt;一个句子的概率&lt;/strong&gt;进行计算，有：&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;P(X_{1} \cdots X_{n}) &amp;=P(X_{1}) P(X_{2}|X_{1}) P(X_{3}|X_{1}^{2}) \cdots P(X_{n}|X_{1}^{n-1}) \\&#xD;&#xA;&amp;=\prod_{k=1}^{n} P(X_{k}|X_{1}^{k-1})&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;P(w_{1}^{n}) &amp;=P(w_{1}) P(w_{2}|w_{1}) P(w_{3}|w_{1}^{2}) \cdots P(w_{n}|w_{1}^{n-1}) \\&#xD;&#xA;&amp;=\prod_{k=1}^{n} P(w_{k}|w_{1}^{k-1})&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;P(w_k|w_1^{k-1})=P(w_k|w_{k-1})&#xD;&#xA;$$&lt;p&gt;&#xA;二元语言模型的假设也称为&lt;strong&gt;马尔可夫假设&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;P(w_{1}^{n}) \approx \prod_{k=1}^{n} P(w_{k}|w_{k-1})&#xD;&#xA;$$$$&#xD;&#xA;P(w_{k}|w_{k-1})=\frac{C(w_{k-1} w_{k})}{C(w_{k-1})}&#xD;&#xA;$$&lt;p&gt;&#xA;在实践中，常常使用&lt;strong&gt;三元语法模型(3-gram language model)&lt;/strong&gt;，甚至四元、五元语法模型(当数据量充足时)。实现时，往往对概率取log，将乘法变为加法，提升运算速度。&lt;/p&gt;&#xA;&lt;h3 id=&#34;评估语言模型&#34;&gt;评估语言模型&lt;/h3&gt;&#xA;&lt;p&gt;语言模型的评估分为&lt;strong&gt;外部评估(extrinsic evaluation)&lt;/strong&gt; 与&lt;strong&gt;内部评估(intrinsic evaluation)&lt;/strong&gt; 两种。在外部评估中，语言模型被某个应用使用，对语言模型的评估体现在外部应用任务性能的提高上。然而&lt;strong&gt;运行外部NLP系统需要很大开销&lt;/strong&gt;，因此&lt;strong&gt;使用内部评估对模型快速进行评估，通常是将语料库划分为训练集和测试集，在训练集上训练语言模型，然后在测试集上进行内部评估&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\operatorname{PP}(W) &amp;=P\left(w_{1} w_{2} \cdots w_{N}\right)^{-\frac{1}{N}} \\&#xD;&#xA;&amp;=\sqrt[N]{\frac{1}{P\left(w_{1} w_{2} \cdots w_{N}\right)}} \\&#xD;&#xA;&amp;=\sqrt[N]{\prod_{i=1}^{N} \frac{1}{P(w_{i}|w_{1} \ldots w_{i-1})}}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\operatorname{PP}(W)=\sqrt[N]{\prod_{i=1}^{N} \frac{1}{P(w_{i}|w_{i-1})}}&#xD;&#xA;$$&lt;p&gt;&#xA;根据上式，&lt;strong&gt;最小化困惑度就是最大化测试集的概率&lt;/strong&gt;。&lt;/p&gt;</description>
    </item>
    <item>
      <title>近邻算法</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml3-k%E8%BF%91%E9%82%BB%E7%AE%97%E6%B3%95/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml3-k%E8%BF%91%E9%82%BB%E7%AE%97%E6%B3%95/</guid>
      <description>&lt;h3 id=&#34;boldsymbol-k近邻算法原理&#34;&gt;$\boldsymbol k$近邻算法原理&lt;/h3&gt;&#xA;&lt;p&gt;$k$近邻($k$-nearest neighbor, $k$NN)算法是一种常用的监督学习方法。其基本思想为：给定一组数据，基于某种距离度量找出训练集中与其最靠近的$k$个训练样本，然后基于这$k$个邻居的信息来进行预测。通常，在&lt;strong&gt;分类任务&lt;/strong&gt;中可使用&lt;strong&gt;投票法&lt;/strong&gt;，即选择$k$个样本中&lt;strong&gt;出现最多的类别标记&lt;/strong&gt;作为预测结果；在&lt;strong&gt;回归任务&lt;/strong&gt;中可使用平均法，即将$k$个样本的实值输出标记的平均值作为预测结果。该算法属于“&lt;strong&gt;惰性学习(lazy learning)&lt;/strong&gt;”方法之一，没有显式的学习过程。相应的，那些在训练阶段就对样本进行学习处理的方法，称为“&lt;strong&gt;急切学习(eager learning)&lt;/strong&gt;”。&lt;/p&gt;&#xA;$$&#xD;&#xA;y=\arg\underset{c_j}\max \sum_{x_i\in{N_k(x)}}\mathbb I(y_i=c_j),i=1,2,\cdots,N;j=1,2,\cdots,K&#xD;&#xA;$$&lt;p&gt;&#xA;其中，$x_i$为实例特征向量，$y_i={c_1,c_2\cdots,c_k}$为实例的类别，$N$为实例总数，$N_k(x)$为$x$在训练集总最邻近的$k$个点，$\mathbb I$为指示函数。&lt;/p&gt;&#xA;&lt;p&gt;$k$近邻算法的特殊情况是$k=1$的情形，称为最近邻算法。&lt;/p&gt;&#xA;&lt;h3 id=&#34;boldsymbol-k近邻算法的参数&#34;&gt;$\boldsymbol k$近邻算法的参数&lt;/h3&gt;&#xA;&lt;p&gt;$k$近邻算法有&lt;strong&gt;三个基本的超参数(super parameter)&lt;/strong&gt;：距离度量、$k$值的选择以及分类决策规则的决定。&lt;/p&gt;&#xA;&lt;h4 id=&#34;距离度量&#34;&gt;距离度量&lt;/h4&gt;&#xA;$$&#xD;&#xA;L_p(x_i,x_j)=(\sum_{l=1}^{n}|x_i^{(l)}-x_j^{(l)}|^p)^{\frac{1}{p}}&#xD;&#xA;$$&lt;p&gt;&#xA;在二维空间中的Minkowski距离的等距线示意图如下：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200417170351526.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200417170411153.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;当$p=2$时，称为&lt;strong&gt;欧氏距离(Euclidean distance)&lt;/strong&gt;；当$p=1$时，称为&lt;strong&gt;曼哈顿距离(Manhattan distance)&lt;/strong&gt;。不同的距离度量确定的最近邻点不同。&lt;/p&gt;&#xA;&lt;h4 id=&#34;boldsymbol-k值的选择&#34;&gt;$\boldsymbol k$值的选择&lt;/h4&gt;&#xA;&lt;p&gt;$k$值的选择会对$k$近邻算法的结果产生重大影响。如果选择较小的$k$值，就相当于用较小的邻域中的训练实例进行预测，预测结果会对邻近的实例点非常敏感。如果邻近的实例点是噪声，预测就会出错。换句话说，$k$值的减小意味着整体模型变得复杂，容易发生&lt;strong&gt;过拟合&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;如果选择较大的$k$值，就相当于用较大邻域中的训练实例进行预测，使模型变得简单。如果$k=N$，那么无论输入实例是什么，都将简单地预测它属于在训练实例中最多的类。这时，模型过于简单，完全忽略训练实例中的大量有用信息，是不可取的。通常$k$一般取一个较小的数值，通常采用&lt;strong&gt;交叉验证法&lt;/strong&gt;来选取最优的$k$值。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200416180052685.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h4 id=&#34;分类决策规则&#34;&gt;分类决策规则&lt;/h4&gt;&#xA;&lt;p&gt;$k$近邻算法中的分类决策规则往往是&lt;strong&gt;多数表决&lt;/strong&gt;，即由输入实例的$k$个近邻的训练实例中的多数类决定输入实例所属的类别。分类决策规则也可以&lt;strong&gt;按照距离加权&lt;/strong&gt;，即赋予每个邻近实例点一个权重，距离给定实例更近的邻近点的权重更大。这样做考虑到了多数表决时距离带来的影响。&lt;/p&gt;&#xA;&lt;h3 id=&#34;boldsymbol-kboldsymbol-d树&#34;&gt;$\boldsymbol k\boldsymbol d$树&lt;/h3&gt;&#xA;&lt;p&gt;实现$k$近邻算法时，主要考虑的问题是如何对训练数据进行快速$k$近邻搜索。这点在特征空间维数大及训练数据容量大时尤为重要。&lt;/p&gt;&#xA;&lt;h4 id=&#34;构造boldsymbol-k-boldsymbol-d树&#34;&gt;构造$\boldsymbol k \boldsymbol d$树&lt;/h4&gt;&#xA;&lt;p&gt;实现$k$近邻算法时，对数据集进行线性扫描是非常耗时的，$kd$树是一种高效的训练数据存储方式。$kd$树是&lt;strong&gt;二叉树&lt;/strong&gt;，表示对$k$维空间的一个&lt;strong&gt;划分&lt;/strong&gt;。构造$kd$树相当于用垂直于坐标轴的超平面将$k$维空间切分，构成一系列的$k$维超矩形区域。$kd$树的&lt;strong&gt;每个节点&lt;/strong&gt;对应一个$k$维&lt;strong&gt;超矩形区域&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;构造$kd$树的方法如下：构造根结点，使根结点对应于$k$维空间中包含所有实例点的超矩形区域。通过下面的递归方法，不断地对$k$维空间进行切分，生成子结点。在**超矩形区域(结点)**上选择一个坐标轴和在此坐标轴上的一个切分点，确定一个超平面，这个超平面通过选定的切分点并垂直于选定的坐标轴，将当前超矩形区域切分为左右两个子区域(子结点)。这时，实例被分到两个子区域。这个过程直到子区域内没有实例时终止。在此过程中，将实例保存在相应的结点上。&lt;/p&gt;&#xA;&lt;p&gt;通常，依次选择坐标轴对空间切分，选择训练实例点在选定坐标轴上的中位数为切分点，这样得到的kd树是平衡的，但平衡的$kd$树搜索时的&lt;strong&gt;效率未必是最优的&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;构造平衡$\boldsymbol k \boldsymbol d$树的算法&lt;/strong&gt;：&lt;/p&gt;&#xA;&lt;p&gt;输入：$k$维空间数据集$T={x_1,x_2,\cdots,x_N}$，其中$x_i=(x_i^{(1)},x_i^{(2)},\cdots,x_i^{(k)})^\text T，i=1,2,\cdots,N$。&lt;/p&gt;&#xA;&lt;p&gt;输出：$kd$树。&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;开始&lt;/strong&gt;：构造根结点，对应包含$T$的$k$维空间的超矩形区域。选择$x^{(1)}$为坐标轴，以T中所有实例$x^{(1)}$坐标的中位数为切分点，将根结点对应的超矩形区域切分为两个子区域。切分由通过切分点并与坐标轴$x^{(1)}$垂直的超平面实现。由根结点生成深度为1的左、右子结点：左子结点对应坐标$x^{(1)}$小于切分点的子区域，右子结点对应坐标$x^{(1)}$大于切分点的子区域。&lt;/p&gt;&#xA;&lt;p&gt;将落在切分超平面上的实例点保存在根结点。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;重复&lt;/strong&gt;：对深度为$j$的结点，选择$x^{(l)}$为切分，$l=j(\text{mod}k)+1$，以该结点的区域中所有实例的$x^{(l)}$坐标的中位数为切分点，将该结点对应的超矩形区域划分为两个子区域。以此类推。&lt;/p&gt;&#xA;&lt;p&gt;(3) &lt;strong&gt;直到两个子区域没有实例存在时停止&lt;/strong&gt;，从而形成$kd$树的区域划分。&lt;/p&gt;&#xA;&lt;p&gt;下图为构建$kd$树的实例。数据集为：$T={(2,3)^\text T,(5,4)^\text T,(9,6)^\text T,(4,7)^\text T,(8,1)^\text T,(7,2)^\text T}$。首先选择$x^{(1)}$轴(共两个维度，$x^{(1)}$即为第一个维度)，6个数据点的$x^{(1)}$坐标的中位数是7(6是中位数，但是$x^{(1)}=6$上无数据点)，以$x^{(1)}=7$将空间分为左右两个子矩形(子结点)；接着，做矩形以$x^{(2)}=4$分为两个子矩形，右矩形以$x^{(2)}=6$分为两个子矩形，如此递归，最终得到如右图所示的$kd$树。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200417194932684.png&#34; style=&#34;zoom:40%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;三维空间内$kd$树的构造如下所示：&lt;/p&gt;</description>
    </item>
    <item>
      <title>seq2seq与attention</title>
      <link>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp4-seq2seq%E4%B8%8Eattention/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp4-seq2seq%E4%B8%8Eattention/</guid>
      <description>&lt;h3 id=&#34;序列到序列模型&#34;&gt;序列到序列模型&lt;/h3&gt;&#xA;&lt;p&gt;许多单输出问题得以解决，比如命名实体识别、单词预测等。然而许多任务的输出是一个&lt;strong&gt;序列&lt;/strong&gt;，比如机器翻译、对话系统以及自动摘要等。这种问题应当使用seq2seq实现。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;序列到序列，或者seq2seq&lt;/strong&gt;，是一个比较新的模型，在2014年被提出用于&lt;strong&gt;英语-法语翻译&lt;/strong&gt;。在更高的层面上，seq2seq是一个&lt;strong&gt;由两个循环神经网络组成的端到端模型&lt;/strong&gt;：&lt;/p&gt;&#xA;&lt;p&gt;(1) 一个&lt;strong&gt;编码器(encoder)&lt;/strong&gt;，将模型的输入序列作为输入，然后编码固定大小的“上下文向量”。&lt;/p&gt;&#xA;&lt;p&gt;(2) 一个&lt;strong&gt;解码器(decoder)&lt;/strong&gt;，使用来自解码器生成的上下文向量作为从其生成输出序列的“种子”。&lt;/p&gt;&#xA;&lt;p&gt;因此，seq2seq模型通常被称为“&lt;strong&gt;编码器-解码器模型&lt;/strong&gt;”。其示意图如下：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200717100127147.png&#34; style=&#34;zoom:40%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;首先，编码器将输入句子编码为一个&lt;strong&gt;隐含层向量&lt;/strong&gt;作为整个输入句子的嵌入向量，然后将该向量作为解码器的&lt;strong&gt;初始隐含层向量&lt;/strong&gt;，输入一个&amp;lt;START&amp;gt;特殊标记，通过&lt;strong&gt;自回归&lt;/strong&gt;的方式不断生成单词，直到生成&amp;lt;END&amp;gt;符号，或者达到长度限制为止。以上decoder生成(测试)句子的方式为&lt;strong&gt;greedy decoding&lt;/strong&gt;，即&lt;strong&gt;每次选取输出softmax值最大的单词&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;greedy decoding的缺陷是无法undo decision，即&lt;strong&gt;一步错，步步错&lt;/strong&gt;。解决方案是&lt;strong&gt;beam search&lt;/strong&gt;，即explore several hypotheses and select the best one。On each step of decoder, keep track of the k(beam size) most probable partial translations。beam search相当于&lt;strong&gt;全局搜索的剪枝过程&lt;/strong&gt;，其不保证找到最优解，但是效果更好。beam size为2的情况如下：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200717100806251.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;注意力机制&#34;&gt;注意力机制&lt;/h3&gt;&#xA;&lt;p&gt;当人们听到句子“the ball is on the field”，人们不会认为这6个单词都一样重要，而是首先会注意到“ball”，“on” 和 “field”，因为这些单词是人们觉得最重要的。类似的，Bahdanau等人注意到&lt;strong&gt;使用RNN的最终状态作为seq2seq模型的单个“上下文向量”的缺点&lt;/strong&gt;：&lt;strong&gt;输入的不同部分具有不同的重要程度&lt;/strong&gt;。再者，&lt;strong&gt;输出的不同部分甚至可以考虑输入的不同部分“重要”&lt;/strong&gt;。例如，在翻译任务中，输出的第一个单词是一般是基于输入的前几个词，输出的最后几个词可能基于输入的后几个词。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;注意力机制(attention mechanism)&lt;/strong&gt; 的核心思想：on each step of the decoder, focus on a particular part of the source sequence。&lt;/p&gt;&#xA;&lt;h4 id=&#34;认知神经学中的注意力&#34;&gt;认知神经学中的注意力&lt;/h4&gt;&#xA;&lt;p&gt;注意力是一种人类不可或缺的复杂认知功能，指人可以在关注一些信息的同时忽略另一些信息的选择能力。在日常生活中，我们通过视觉、听觉等方式接收大量的感觉输入。但是人脑还能在这些外界的信息轰炸中有条不紊地工作，是因为人脑可以有意或无意地从这些大量输入信息中选择小部分的有用信息来重点处理，并忽略其他信息。这种能力就叫做&lt;strong&gt;注意力(attention)&lt;/strong&gt;。注意力可以作用在外部的刺激(听觉、视觉、味觉等)，也可以作用在内部的意识(思考、回忆等)。注意力一般分为两种：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;聚焦式注意力(focus attention)&lt;/strong&gt;：有预定目的、依赖任务的，主动有意识地聚焦于某一对象的注意力。&lt;/p&gt;</description>
    </item>
    <item>
      <title>循环神经网络</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl4-%E5%BE%AA%E7%8E%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl4-%E5%BE%AA%E7%8E%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</guid>
      <description>&lt;h3 id=&#34;序列数据和语言模型&#34;&gt;序列数据和语言模型&lt;/h3&gt;&#xA;&lt;p&gt;全连接神经网络和卷积神经网络只能单独处理一个个的输入，&lt;strong&gt;前一个输入和后一个输入是完全没有关系的&lt;/strong&gt;。但是，某些任务需要能够更好的处理序列的信息，即前面的输入和后面的输入是有关系的。比如，当我们在理解一句话意思时，孤立的理解这句话的每个词是不够的，我们需要处理这些词连接起来的整个序列；当我们处理视频的时候，我们也不能只单独的去分析每一帧，而要&lt;strong&gt;分析这些帧连接起来的整个序列&lt;/strong&gt;。这时，就需要用到深度学习领域中另一类非常重要神经网络：&lt;strong&gt;循环神经网络(recurrent neural network)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;RNN是在自然语言处理领域中最先被用起来的，比如，RNN可以为语言模型来建模。例如我们可以和电脑玩一个游戏，我们写出一个句子前面的一些词，然后，让电脑帮我们写下接下来的一个词。比如下面这句：&lt;strong&gt;我昨天上学迟到了，老师批评了__&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;语言模型是对一种语言的特征进行建模，它有很多很多用处。比如在&lt;strong&gt;语音转文本(STT)&lt;strong&gt;的应用中，&lt;strong&gt;声学模型输出&lt;/strong&gt;的结果，往往是若干个可能的候选词，这时候就需要语言模型来从这些候选词中选择一个最可能的。当然，它同样也可以用在&lt;/strong&gt;图像到文本的识别中(OCR)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;使用RNN之前，语言模型主要是采用&lt;strong&gt;N-gram语言模型&lt;/strong&gt;。N可以是一个自然数，它的含义是，假设一个词出现的概率只与前面N个词相关。N-gram模型的缺陷是，&lt;strong&gt;当处理任意长度的句子，N设为多少都不合适&lt;/strong&gt;；另外，&lt;strong&gt;模型的大小和N的关系是指数级的&lt;/strong&gt;，4-gram模型会占用海量的存储空间。&lt;/p&gt;&#xA;&lt;p&gt;与传统语言模型不同的是，循环神经网络理论上可以往前看(往后看)任意多个词。&lt;/p&gt;&#xA;&lt;h3 id=&#34;网络结构&#34;&gt;网络结构&lt;/h3&gt;&#xA;$$\boldsymbol x_{1:T}=(\boldsymbol{x}_{1}, \boldsymbol{x}_{2}, \ldots, \boldsymbol{x}_{t}, \cdots, \boldsymbol{x}_{T})$$$$&#xD;&#xA;\boldsymbol{h}_{t}=f(\boldsymbol{h}_{t-1}, \boldsymbol{x}_{t})&#xD;&#xA;$$&lt;p&gt;&#xA;其中$\boldsymbol h_0=0$(&lt;strong&gt;即RNN隐藏层的初始值为0&lt;/strong&gt;)，$f(·)$为一个&lt;strong&gt;非线性函数&lt;/strong&gt;，也可以是一个&lt;strong&gt;前馈网络&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200715160758686.png&#34; style=&#34;zoom:25%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;循环层的基础结构如上图所示。循环神经网络可以看成一个&lt;strong&gt;动力系统(dynamic system)&lt;/strong&gt;，指&lt;strong&gt;系统状态&lt;/strong&gt;按照一定的规律&lt;strong&gt;随时间变化&lt;/strong&gt;的系统。具体地讲，动力系统是使用一个函数来描述一个给定空间中所有点随时间的变化情况。因此，隐藏层的活性值$\boldsymbol h_t$在很多文献上也称为&lt;strong&gt;状态(state)&lt;strong&gt;或&lt;/strong&gt;隐状态(hidden state)&lt;/strong&gt;。&lt;strong&gt;理论上，循环神经网络可以近似任意的非线性动力系统&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\boldsymbol{z}_{t}&amp;=U \boldsymbol{h}_{t-1}+W \boldsymbol{x}_{t}+\boldsymbol{b} \\&#xD;&#xA;\boldsymbol{h}_{t}&amp;=f\left(\boldsymbol{z}_{t}\right)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\boldsymbol{h}_{t}=f(U \boldsymbol{h}_{t-1}+W \boldsymbol{x}_{t}+\boldsymbol{b})&#xD;&#xA;$$$$&#xD;&#xA;\boldsymbol{y}_{t}=V \boldsymbol{h}_{t}&#xD;&#xA;$$&lt;p&gt;&#xA;其中$V$是隐含层与输出层之间的连接权重。如果我们把每个时刻的状态都看作是前馈神经网络的一层，循环神经网络可以看作是&lt;strong&gt;在时间维度上权值共享的神经网络&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200715161457977.png&#34; style=&#34;zoom:25%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;&lt;strong&gt;循环神经网络的通用近似定理&lt;/strong&gt;：一个有&lt;strong&gt;足够数量的sigmoid型隐藏神经元&lt;/strong&gt;的循环神经网络，可以以任意的准确率去近似任何一个非线性动力系统。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;循环神经网络的图灵完备性&lt;/strong&gt;：所有的&lt;strong&gt;图灵机&lt;/strong&gt;都可以被一个由使用sigmoid型激活函数的神经元构成的全连接循环网络来进行模拟。因此，一个完全连接的循环神经网络可以近似解决所有的可计算问题。&lt;/p&gt;&#xA;&lt;h3 id=&#34;循环神经网络的应用&#34;&gt;循环神经网络的应用&lt;/h3&gt;&#xA;&lt;p&gt;根据不同的任务特点，循环神经网络的应用可以分为如下几种模式：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;序列到类别模式(文本分类、情感分析等)&lt;/strong&gt;：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200715161712903.png&#34; style=&#34;zoom:25%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;(2) &lt;strong&gt;同步的序列到序列模式(序列标注等)&lt;/strong&gt;：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200715161731143.png&#34; style=&#34;zoom:25%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;(3) &lt;strong&gt;异步的序列到序列模式(机器翻译、对话系统等)&lt;/strong&gt;：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200715161812090.png&#34; style=&#34;zoom:25%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;循环神经网络的训练&#34;&gt;循环神经网络的训练&lt;/h3&gt;&#xA;&lt;p&gt;循环神经网络的参数可以通过梯度下降方法来进行学习。&lt;/p&gt;&#xA;$$&#xD;&#xA;\mathcal{L}_{t}=\mathcal{L}(y_{t}, g(\boldsymbol{h}_{t}))&#xD;&#xA;$$$$&#xD;&#xA;\mathcal{L}=\sum_{t=1}^{T} \mathcal{L}_{t}&#xD;&#xA;$$$$&#xD;&#xA;\frac{\partial \mathcal{L}}{\partial U}=\sum_{t=1}^{T} \frac{\partial \mathcal{L}_{t}}{\partial U}&#xD;&#xA;$$&lt;p&gt;&#xA;即每个时刻损失$\mathcal L_t$对参数$U$的偏导数之和。&lt;/p&gt;</description>
    </item>
    <item>
      <title>感知机</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml4-%E6%84%9F%E7%9F%A5%E6%9C%BA/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml4-%E6%84%9F%E7%9F%A5%E6%9C%BA/</guid>
      <description>&lt;h3 id=&#34;感知机算法&#34;&gt;感知机算法&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;感知机(perceptron)&lt;/strong&gt; 由Frank Rosenblatt于1957年提出，是一种广泛使用的线性分类器。感知器可谓是最简单的人工神经网络，只有一个神经元，是对生物神经元的简单数学模拟，有与生物神经元相对应的部件，如&lt;strong&gt;权重(突触)、偏置(阈值)及激活函数(细胞体)&lt;/strong&gt;，输出为+1或-1。&lt;/p&gt;&#xA;$$&#xD;&#xA;y^{(n)} \boldsymbol{w}^{* \mathrm{T}} \boldsymbol{x}^{(n)}&gt;0, \quad \forall n \in[1, N]&#xD;&#xA;$$$$&#xD;&#xA;\boldsymbol{w} \leftarrow \boldsymbol{w}+y \boldsymbol{x}&#xD;&#xA;$$$$&#xD;&#xA;\mathcal{L}(\boldsymbol{w} ; \boldsymbol{x}, y)=\max \left(0,-y \boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}\right)&#xD;&#xA;$$$$&#xD;&#xA;\frac{\partial \mathcal{L}(\boldsymbol{w} ; \boldsymbol{x}, y)}{\partial \boldsymbol{w}}=\left\{\begin{array}{ll}&#xD;&#xA;0 &amp; \text { if } \quad y \boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}&gt;0 \\&#xD;&#xA;-y \boldsymbol{x} &amp; \text { if } \quad y \boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}&lt;0&#xD;&#xA;\end{array}\right.&#xD;&#xA;$$&lt;p&gt;&#xA;具体的感知机参数学习算法如下所示：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200421193100436.png&#34; style=&#34;zoom:40%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;下图给出了感知机参数学习的更新过程，其中红色实心点为正例，蓝色空心点为负例。黑色箭头表示权重向量，红色虚线箭头表示权重的更新方向。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200421193247291.png&#34; style=&#34;zoom:50%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;感知机算法的收敛性&#34;&gt;感知机算法的收敛性&lt;/h3&gt;&#xA;&lt;p&gt;Novikoff证明对于两类问题，&lt;strong&gt;如果训练集是线性可分的，那么感知器算法可以在有限次迭代后收敛&lt;/strong&gt;。然而，如果训练集不是线性可分的，那么这个算法则&lt;strong&gt;不能确保会收敛&lt;/strong&gt;。&lt;/p&gt;&#xA;$$\mathcal{D}=\left\{\left(\boldsymbol{ x }^{(n)}, y^{(n)}\right)\right\} _{n=1}^{N} $$$$(\boldsymbol{w}^{*})^{\mathrm{T}}(y^{(n)} \boldsymbol{x}^{(n)}) \geq \gamma$$&lt;p&gt;。可以证明，假设$R$是训练集$\mathcal D$中最大的特征向量的模，即$R=\underset n\max |x^{(n)}|$，如果训练集$\mathcal D$线性可分，二分类感知机参数学习算法的权重更新次数不超过$\frac{R^2}{\gamma^2}$。&lt;/p&gt;</description>
    </item>
    <item>
      <title>信息论</title>
      <link>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math5-%E4%BF%A1%E6%81%AF%E8%AE%BA/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/1-%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/math5-%E4%BF%A1%E6%81%AF%E8%AE%BA/</guid>
      <description>&lt;p&gt;&lt;strong&gt;信息论(information theory)&lt;/strong&gt; 是数学、物理、计算机科学等多个学科的交叉领域。信息论是由Claude Shannon最早提出的，主要研究信息的量化、存储和通信等方法。这里，&lt;strong&gt;“信息”是指一组消息的集合&lt;/strong&gt;。假设在一个噪声通道上发送消息，我们需要考虑如何对每一个信息进行编码、传输以及解码，使得接收者可以尽可能准确地重构出消息。在机器学习相关领域，信息论也有着大量的应用。比如&lt;strong&gt;特征抽取、统计推断、自然语言处理&lt;/strong&gt;等。&lt;/p&gt;&#xA;&lt;h3 id=&#34;熵&#34;&gt;熵&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;熵(entropy)&lt;/strong&gt; 最早是物理学的概念，用于表示一个&lt;strong&gt;热力学系统的无序程度&lt;/strong&gt;。在信息论中，熵用来衡量一个随机事件的不确定性。&lt;/p&gt;&#xA;&lt;h4 id=&#34;自信息和熵&#34;&gt;自信息和熵&lt;/h4&gt;&#xA;&lt;p&gt;&lt;strong&gt;自信息(self information)&lt;/strong&gt; 表示一个随机事件所包含的信息量。一个随机事件发生的概率越高，其自信息越低。如果一个事件必然发生，则其自信息为0。对于一个随机变量$X$(取值集合为$\mathcal X$，概率分布为$p(x)$)，当$X=x$时的自信息$I(x)$定义为：$I(x)=-\log p(x)$。在自信息的定义中，对数的底可以使用2、自然常数$e$或是10。当以2为底时，自信息的单位为bit；当以$e$为底时，自信息的单位为nat。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;H(X) &amp;=\mathbb{E}_{X}[\mathrm{I}(x)] \\&#xD;&#xA;&amp;=\mathbb{E}_{X}[-\log p(x)] \\&#xD;&#xA;&amp;=-\sum_{x \in \mathcal{X}} p(x) \log p(x)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;熵越高，则随机变量的信息越多；熵越低，则随机变量的信息越少。如果随机变量$X$当且仅当在$x$时$p(x)=1$，则其熵为0。也就是说，对于一个确定的信息，其熵为0，信息量也为0.如果其概率分布为一个均匀分布，则熵最大。&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;math&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 计算不同概率分布的熵&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;p1&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.3&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.6&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;p2&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.33&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.33&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.34&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;p3&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;def&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;entropy&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;):&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;ent&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.0&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;for&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;i&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;in&lt;/span&gt; &lt;span style=&#34;color:#204a87&#34;&gt;range&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;len&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)):&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;if&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;i&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;!=&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;:&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            &lt;span style=&#34;color:#000&#34;&gt;ent&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;+=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;i&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;math&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;log2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;i&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;])&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;if&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;ent&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;!=&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;:&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;ent&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;else&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;:&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.0&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;entropy&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;entropy&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;entropy&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p3&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;假设一个随机变量$X$有三种可能取值$x_1,x_2,x_3$，不同概率分布对应的熵如下：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/1/image-20200526195633003.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h4 id=&#34;熵编码&#34;&gt;熵编码&lt;/h4&gt;&#xA;&lt;p&gt;信息论的研究目标之一是如何用最少的编码表示传递信息。假设我们要传递一段文本信息，这段文本中包含的符号都来自于一个字母表$\mathcal A$，我们就需要对字母表$\mathcal A$中的每个符号进行编码。以二进制编码为例，&lt;strong&gt;我们常用的ASCII码就是用固定的8bits来编码每个字母&lt;/strong&gt;。但这种固定长度的编码方案不是最优的。一种高效的编码原则是，&lt;strong&gt;字母的出现概率越高，其编码长度越短&lt;/strong&gt;。比如对字母$a, b, c$分别编码为0*,* 10*,* 110。给定一串要传输的文本信息，其中字母$x$的出现概率为$p(x)$，其最佳编码长度为$-\log_2p(x)$，整段文本的平均编码长度为$-\sum_{x} p(x) \log _{2} p(x)$，即底为2的熵。&lt;/p&gt;&#xA;&lt;p&gt;在对分布$p(x)$的符号进行编码时，熵$H(p)$也是理论上&lt;strong&gt;最优平均编码长度&lt;/strong&gt;，这种编码方式称为&lt;strong&gt;熵编码(entropy encoding)&lt;/strong&gt;。由于每个符号的自信息通常都不是整数，因此在实际编码中很难达到理论上的最优值。**霍夫曼编码(Huffman coding)和算术编码(arithmetic coding)**是两种最常见的熵编码技术。&lt;/p&gt;</description>
    </item>
    <item>
      <title>神经网络的优化</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl5-%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E7%9A%84%E4%BC%98%E5%8C%96/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl5-%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E7%9A%84%E4%BC%98%E5%8C%96/</guid>
      <description>&lt;h3 id=&#34;网络优化的难点&#34;&gt;网络优化的难点&lt;/h3&gt;&#xA;&lt;h4 id=&#34;网络结构多样性&#34;&gt;网络结构多样性&lt;/h4&gt;&#xA;&lt;p&gt;神经网络的种类非常多，比如卷积网络、循环网络等，其结构也非常不同。有些比较深，有些比较宽。不同参数在网络中的作用也有很大的差异，比如连接权重和偏置的不同，以及循环网络中循环连接上的权重和其它权重的不同。由于网络结构的多样性，我们很难找到一种通用的优化方法。&lt;strong&gt;不同的优化方法在不同网络结构上的差异也都比较大&lt;/strong&gt;。此外，网络的超参数一般也比较多，这也给优化带来很大的挑战。&lt;/p&gt;&#xA;&lt;h4 id=&#34;高维变量的非凸优化&#34;&gt;高维变量的非凸优化&lt;/h4&gt;&#xA;&lt;p&gt;低维空间的非凸优化问题主要是存在一些局部最优点。基于梯度下降的优化方法会陷入局部最优点，因此低维空间非凸优化的主要难点是如何选择初始化参数和逃离局部最优点。深度神经网络的参数非常多，其参数学习是在非常高维空间中的非凸优化问题，其挑战和在低维空间的非凸优化问题有所不同。在高维空间中，非凸优化的难点并不在于如何逃离局部最优点，而是如何逃离&lt;strong&gt;鞍点(saddle point)&lt;/strong&gt;。鞍点的叫法是因为其形状像马鞍。鞍点的梯度是0，但是在一些维度上是最高点，在另一些维度上是最低点。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200613202435836.png&#34; style=&#34;zoom:25%;&#34; /&gt;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;在高维空间中，局部最优点要求&lt;strong&gt;在每一维度上都是最低点&lt;/strong&gt;，&lt;strong&gt;这种概率非常低&lt;/strong&gt;。假设网络有10,000维参数，一个点在某一维上是局部最低点的概率为$p$，那么在整个参数空间中，局部最优点的概率为$p^{10,000}$，这种可能性非常小。也就是说&lt;strong&gt;高维空间中，大部分梯度为0的点都是鞍点&lt;/strong&gt;。基于梯度下降的优化方法会&lt;strong&gt;在鞍点附近接近于停滞&lt;/strong&gt;，同样很难从这些鞍点中逃离。&lt;/p&gt;&#xA;&lt;p&gt;深度神经网络的参数非常多，并且冗余性很高，这使得每个参数对最终损失的影响都比较小，这导致了损失函数在局部最优点附近是一个平坦的区域，称为&lt;strong&gt;平坦最小值(flat minima)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200613202647979.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;目前，深度神经网络的参数学习主要是通过梯度下降法来寻找一组可以最小化结构风险的参数。在具体实现中，梯度下降法可以分为&lt;strong&gt;批量梯度下降、随机梯度下降以及小批量梯度下降&lt;/strong&gt;三种形式。除了在收敛效果和效率上的差异，这三种方法都存在一些共同的问题，比如&lt;strong&gt;如何改进优化算法、如何初始化参数、如何预处理数据等&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h3 id=&#34;优化算法&#34;&gt;优化算法&lt;/h3&gt;&#xA;&lt;h4 id=&#34;小批量梯度下降&#34;&gt;小批量梯度下降&lt;/h4&gt;&#xA;&lt;p&gt;在训练深度神经网络时，训练数据的规模通常都比较大。如果在梯度下降时，每次迭代都要计算整个训练数据上的梯度，这就需要比较多的计算资源。另外大规模训练集中的数据通常会非常冗余，也没有必要在整个训练集上计算梯度。因此，在训练深度神经网络时，经常使用&lt;strong&gt;小批量梯度下降法(mini-batch gradient descent)&lt;/strong&gt;，即&lt;strong&gt;仅在训练集中选择一个较小的子集来更新梯度&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;影响小批量梯度下降法的因素有：(1) 批量大小$K$；(2) 学习率$\alpha$；(3) 梯度估计。为了更有效地训练深度神经网络，在标准的小批量梯度下降法的基础上，也经常使用一些改进方法以加快优化速度，比如如何&lt;strong&gt;选择批量大小&lt;/strong&gt;、如何&lt;strong&gt;调整学习率&lt;/strong&gt;以及如何&lt;strong&gt;修正梯度估计&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h4 id=&#34;批量大小选择&#34;&gt;批量大小选择&lt;/h4&gt;&#xA;&lt;p&gt;在小批量梯度下降法中，&lt;strong&gt;批量大小(batch size)&lt;/strong&gt; 对网络优化的影响非常大。一般而言，&lt;strong&gt;批量大小不影响随机梯度的期望，但是会影响随机梯度的方差&lt;/strong&gt;。批量大小越大，随机梯度的&lt;strong&gt;方差越小&lt;/strong&gt;，引入的噪声也越小，训练也越稳定，因此可以设置&lt;strong&gt;较大的学习率&lt;/strong&gt;。批量大小较小时，需要设置较小的学习率，否则模型会&lt;strong&gt;不收敛&lt;/strong&gt;。学习率通常要随着批量大小的增大而相应地增大。一个简单有效的方法是&lt;strong&gt;线性缩放规则&lt;/strong&gt;：当批量大小增加$m$倍时，学习率也增加$m$倍。线性缩放规则往往在批量大小较小时适用，当批量大小非常大时，线性缩放会使训练不稳定。&lt;/p&gt;&#xA;&lt;p&gt;下图给出了从epoch(回合)和iteration(更新次数)的角度，批量大小对损失下降的影响：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200613203340367.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200613203411932.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;从epoch图可以看出，可以看出，&lt;strong&gt;批量样本数越小，适当小的批量大小会导致更快的收敛&lt;/strong&gt;；从iteration图可以看出，&lt;strong&gt;批量大小越大，下降效果越明显，并且下降曲线越平滑&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h4 id=&#34;学习率调整&#34;&gt;学习率调整&lt;/h4&gt;&#xA;&lt;p&gt;学习率是神经网络优化时的重要超参数。在梯度下降法中，学习率的取值非常关键，如果&lt;strong&gt;过大就不会收敛&lt;/strong&gt;，如果&lt;strong&gt;过小则收敛速度太慢&lt;/strong&gt;。常用的学习率调整方法包括&lt;strong&gt;学习率衰减、学习率预热、周期性学习率调整&lt;/strong&gt;以及一些&lt;strong&gt;自适应调整学习率的方法&lt;/strong&gt;，如&lt;strong&gt;AdaGrad、RMSprop、AdaDelta&lt;/strong&gt;等。自适应学习率方法可针对每个参数设置不同的学习率。&lt;/p&gt;&#xA;&lt;h5 id=&#34;学习率衰减&#34;&gt;学习率衰减&lt;/h5&gt;&#xA;&lt;p&gt;从经验上看，学习率在一开始要保持大些来保证收敛速度，在收敛到最优点附近时要小些以避免来回震荡。简单的学习率调整可通过&lt;strong&gt;学习率衰减(learning rate decay)&lt;strong&gt;来实现，也称为&lt;/strong&gt;学习率退火(learning rate annealing)&lt;/strong&gt;。不失一般性，衰减方式设置为&lt;strong&gt;按迭代次数进行衰减&lt;/strong&gt;。假设初始化学习率为$\alpha_0$，在第$t$次迭代时的学习率$\alpha_t$，衰减率一般用$\beta$表示。常见的衰减方法有以下几种：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;分段常数衰减(piecewise constant decay)&lt;/strong&gt;：每经过$T_1,T_2,\cdots$次迭代将学习率衰减为原来的$\beta_1,\beta_2,\cdots$倍，其中$T_i和$$\beta_i$为根据经验设置的超参数。分段常数衰减也称为&lt;strong&gt;步衰减(step decay)&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;\alpha_{t}=\alpha_{0} \frac{1}{1+\beta \times t}&#xD;&#xA;$$$$&#xD;&#xA;\alpha_{t}=\alpha_{0} \beta^{t}&#xD;&#xA;$$$$&#xD;&#xA;\alpha_{t}=\alpha_{0} \exp (-\beta \times t)&#xD;&#xA;$$$$&#xD;&#xA;\alpha_{t}=\frac{1}{2} \alpha_{0}\left(1+\cos \left(\frac{t \pi}{T}\right)\right)&#xD;&#xA;$$&lt;p&gt;&#xA;下图给出了不同衰减方法的示例(假设&lt;strong&gt;初始学习率为1&lt;/strong&gt;)。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200613204216218.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h5 id=&#34;学习率预热&#34;&gt;学习率预热&lt;/h5&gt;&#xA;&lt;p&gt;在小批量梯度下降法中，当批量大小的设置比较大时，通常需要比较大的学习率。但在刚开始训练时，由于参数是随机初始化的，梯度往往也比较大，再加上比较大的初始学习率，会使得训练不稳定。为了提高训练稳定性，我们可以&lt;strong&gt;在最初几轮迭代时，采用比较小的学习率&lt;/strong&gt;，等梯度下降到一定程度后再恢复到初始的学习率，这种方法称为&lt;strong&gt;学习率预热(learning rate warmup)&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;\alpha_{t}^{\prime}=\frac{t}{T^{\prime}} \alpha_{0}, \quad 1 \leq t \leq T^{\prime}&#xD;&#xA;$$&lt;p&gt;&#xA;&lt;strong&gt;当预热过程结束，再选择一种学习率衰减方法来逐渐降低学习率&lt;/strong&gt;。&lt;/p&gt;</description>
    </item>
    <item>
      <title>贝叶斯分类器</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml5-%E8%B4%9D%E5%8F%B6%E6%96%AF%E5%88%86%E7%B1%BB%E5%99%A8/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml5-%E8%B4%9D%E5%8F%B6%E6%96%AF%E5%88%86%E7%B1%BB%E5%99%A8/</guid>
      <description>&lt;h3 id=&#34;朴素贝叶斯的学习与分类&#34;&gt;朴素贝叶斯的学习与分类&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;朴素贝叶斯(naive Bayse)&lt;/strong&gt; 算法是基于&lt;strong&gt;贝叶斯定理&lt;/strong&gt;与&lt;strong&gt;特征条件独立假设&lt;/strong&gt;的分类方法。设输入空间$\mathcal X \subseteq \mathbb R^n$为$n$维向量的集合，输出空间为类标记集合$\mathcal Y={c_1,c_2,\cdots,c_K}$。输入为特征向量$x \in \mathcal X$，输出为类标记$y \in \mathcal Y$。$P(X,Y)$是输入空间和输出空间上的随机变量$X$和$Y$的联合概率分布，训练数据集(含$N$个数据)由$P(X,Y)$独立同分布产生。朴素贝叶斯在数据集上学习&lt;strong&gt;联合概率分布&lt;/strong&gt;$P(X,Y)$。具体地，先学习以下先验概率分布及条件概率分布：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;先验概率分布&lt;/strong&gt;：$P(Y=c_k),k=1,2,\cdots,K$。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;条件概率分布&lt;/strong&gt;：$P(X=x|Y=c_k)=P(X^{(1)}=x^{(1)},\cdots,X^{(n)}=x^{(n)}|Y=c_k),k=1,2,\cdots,K$。&lt;/p&gt;&#xA;$$&#xD;&#xA;P(X=x | Y=c_{k})=P(X^{(1)}=x^{(1)}, \ldots, X^{(n)}=x^{(n)} | Y=c_{k})=\prod_{j=1}^{n} P(X^{(j)}=x^{(j)} | Y=c_{k})&#xD;&#xA;$$&lt;p&gt;&#xA;朴素贝叶斯算法实际上学习到生成数据的机制，属于&lt;strong&gt;生成模型&lt;/strong&gt;。条件独立性假设等于是说用于分类的特征&lt;strong&gt;在类确定的条件下&lt;/strong&gt;都是条件独立的。这一假设使朴素贝叶斯算法变得简单，但会牺牲一定的分类准确率。&lt;/p&gt;&#xA;$$&#xD;&#xA;y=f(x)=\arg \max _{c_{k}} P(Y=c_{k}) \prod_{j=1}^{n} P(X^{(j)}=x^{(j)} | Y=c_{k})&#xD;&#xA;$$&lt;p&gt;&#xA;朴素贝叶斯将实例分到后验概率最大的类，这&lt;strong&gt;等价于期望风险最小化&lt;/strong&gt;。假设使用0-1损失函数：&lt;/p&gt;&#xA;$$&#xD;&#xA;L(Y, f(X))=\left\{\begin{array}{ll}&#xD;&#xA;1, &amp; Y \neq f(X) \\&#xD;&#xA;0, &amp; Y=f(X)&#xD;&#xA;\end{array}\right.&#xD;&#xA;$$&lt;p&gt;&#xA;式中的$f(X)$是分类决策函数。这时，&lt;strong&gt;期望风险函数&lt;/strong&gt;是为$R_{\exp}(f)=E[L(Y,f(X))]$ 。&lt;/p&gt;&#xA;&lt;p&gt;此期望是对联合分布$P(X,Y)$取的。由此取&lt;strong&gt;条件期望&lt;/strong&gt;：&lt;/p&gt;&#xA;$$&#xD;&#xA;R_{\exp }(f)=E_{X} \sum_{k=1}^{K}[L(c_{k}, f(X))] P(c_{k} | X)&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;R_{\exp}(f)&amp;=E[L(Y,f(X))]\\&#xD;&#xA;&amp;=\int_{\mathcal X \times \mathcal Y}L(y,f(x))P(x,y)\text dx \text dy\\&#xD;&#xA;&amp;=\int_{\mathcal X \times \mathcal Y}L(y,f(x))P(y|x)P(x)\text dx \text dy\\&#xD;&#xA;&amp;=\int_{\mathcal X} \left( \int_{\mathcal Y} L(y,f(x))P(y|x)\text dy \right)P(x)\text dx\\&#xD;&#xA;&amp;=E_{X} \sum_{k=1}^{K}[L(c_{k}, f(X))] P(c_{k} | X)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;f(x) &amp;=\arg \min _{y \in Y} \sum_{k=1}^{K} L(c_{k}, y) P(c_{k} | X=x)\\&#xD;&#xA;&amp;=\arg \min _{y \in Y} \sum_{k=1}^{K} P(c_{k} \neq Y | X=x) \\&#xD;&#xA;&amp;=\arg \min _{y \in Y} \sum_{k=1}^{K}(1-P(c_{k}=Y | X=x))\\&#xD;&#xA;&amp;=\arg \max _{y \in Y} \sum_{k=1}^{K} P(c_{k}=Y | X=x)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;f(x)=\arg \max _{c_{k}} P\left(c_{k} | X=x\right)&#xD;&#xA;$$&lt;h3 id=&#34;朴素贝叶斯的参数估计&#34;&gt;朴素贝叶斯的参数估计&lt;/h3&gt;&#xA;&lt;h4 id=&#34;极大似然估计&#34;&gt;极大似然估计&lt;/h4&gt;&#xA;$$&#xD;&#xA;P(Y=c_{k})=\frac{\sum_{i=1}^{N}I(y_{i}=c_{k})}{N}, k=1,2, \cdots, K&#xD;&#xA;$$$$&#xD;&#xA;P(X^{(j)}=a_{j l} | Y=c_{k})=\frac{\sum_{i=1}^{N} I(x_{i}^{(j)}=a_{j l}, y_{i}=c_{k})}{\sum_{i=1}^{N} I(y_{i}=c_{k})}\\&#xD;&#xA;j=1,2,\cdots,n;\quad l=1,2,\cdots,S_j;\quad k=1,2,\cdots,K&#xD;&#xA;$$&lt;p&gt;&#xA;式中，$x_i^{(j)}$是第$i$个样本的第$j$个特征，$a_{jl}$是第$j$个特征可能取的第$l$个值，$I$为指示函数。&lt;/p&gt;</description>
    </item>
    <item>
      <title>预训练模型</title>
      <link>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp5-%E9%A2%84%E8%AE%AD%E7%BB%83%E6%A8%A1%E5%9E%8B/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp5-%E9%A2%84%E8%AE%AD%E7%BB%83%E6%A8%A1%E5%9E%8B/</guid>
      <description>&lt;h3 id=&#34;elmo&#34;&gt;ELMo&lt;/h3&gt;&#xA;&lt;p&gt;预训练词向量(如word2vec和GloVe等)通常只能为一个单词产生一个特定的词向量，而忽略了该单词的&lt;strong&gt;上下文(context)&lt;/strong&gt; 关系，因而无法解决&lt;strong&gt;一词多义&lt;/strong&gt;或&lt;strong&gt;一义多词&lt;/strong&gt;的问题。&lt;strong&gt;ELMo(embeddings from language models)&lt;/strong&gt; 本质上是一个深度双向LSTM模型，用于为一个句子中的每个单词生成上下文相关的词向量。将这些上下文相关词向量编码了单词的深层次语义和句法信息，因此当ELMo应用到许多NLP任务中，这些任务的效果相对于使用静态的词向量往往能得到很大的提升。&lt;/p&gt;&#xA;$$&#xD;&#xA;p\left(t_{1}, t_{2}, \cdots, t_{N}\right)=\prod_{k=1}^{N} p\left(t_{k} | t_{1}, t_{2}, \cdots, t_{k-1}\right)&#xD;&#xA;$$&lt;p&gt;在ELMo之前的语言模型通常为第$k$个位置的单词(通过embedding等方式)计算出一个上下文无关的词表示$\mathbf x_k^{LM}$，然后将其送入一个$L$层的前向LSTM。在每个位置$k$，每一层LSTM会输出一个上下文相关的表示为$\overrightarrow{\mathbf h}&lt;em&gt;{k,j}^{LM}$，其中$j=1,2,\cdots,L$。最顶层的LSTM输出$\overrightarrow{\mathbf h}&lt;/em&gt;{k,L}^{LM}$在下游任务被用来预测下一个标记(通过sottmax层等方式)，即$t_{k+1}$。&lt;/p&gt;&#xA;$$&#xD;&#xA;p\left(t_{1}, t_{2}, \cdots, t_{N}\right)=\prod_{k=1}^{N} p\left(t_{k} | t_{k+1}, t_{k+2}, \cdots, t_{N}\right)&#xD;&#xA;$$&lt;p&gt;&#xA;因此在第$k$个位置，第$j$层LSTM的输出表示为$\overleftarrow{\mathbf h}_{k,j}^{LM}$。&lt;/p&gt;&#xA;$$&#xD;&#xA;\sum_{k=1}^{N} (\log p(t_{k} | t_{1}, \cdots, t_{k-1} ; \Theta_{x}, \overrightarrow{\Theta}_{LSTM}, \Theta_{s})+\log p(t_{k} | t_{k+1}, \cdots, t_{N} ; \Theta_{x}, \overleftarrow{\Theta}_{L S T M}, \Theta_{s}))&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;R_{k} &amp;=\{\mathbf{x}_{k}^{L M}, \overrightarrow{\mathbf{h}}_{k, j}^{L M}, \overleftarrow{\mathbf{h}}_{k, j}^{L M} | j=1, \cdots, L\} \\&#xD;&#xA;&amp;=\left\{\mathbf{h}_{k, j}^{L M} | j=0, \cdots, L\right\}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中，${\mathbf h}&lt;em&gt;{k,0}^{LM}$代表$\mathbf{x}&lt;/em&gt;{k}^{L M}$，${\mathbf h}&lt;em&gt;{k,0}^{LM}=[\overrightarrow{\mathbf h}&lt;/em&gt;{k,j}^{LM};\overleftarrow{\mathbf h}_{k,j}^{LM}]$。&lt;/p&gt;</description>
    </item>
    <item>
      <title>自然语言处理应用</title>
      <link>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp6-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86%E5%BA%94%E7%94%A8/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/4-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86/nlp6-%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86%E5%BA%94%E7%94%A8/</guid>
      <description>&lt;p&gt;自然语言处理的应用（即NLP任务）分布非常广泛。本章节以任务的形式进行划分，主要介绍三类具有代表性的自然语言处理应用，包括文本分类（序列-编码-类别）、文本摘要（序列-编码-解码-序列）、以及机器阅读理解（序列-编码-同步序列）。每个部分首先介绍了应用的概念及挑战，然后介绍了一些具有代表性的论文工作。&lt;strong&gt;注意，从接触一个领域的具体任务开始，已经初步进入到了对该科研领域的探索之中。每个领域都有一些具体的任务，而确定一个任务往往就是着手开展一项研究工作的第一步。&lt;/strong&gt;&lt;/p&gt;&#xA;&lt;p&gt;本节介绍的相关工作均为大语言模型流行之前的工作范式。&lt;/p&gt;&#xA;&lt;h3 id=&#34;文本分类&#34;&gt;文本分类&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;文本分类(text classification)&lt;/strong&gt; 在自然语言处理领域有着广泛的应用，例如&lt;strong&gt;垃圾邮件检测(spam detection)&lt;/strong&gt;、&lt;strong&gt;情感分析(sentiment analysis)&lt;/strong&gt;、&lt;strong&gt;语言识别(language id)&lt;/strong&gt; 以及&lt;strong&gt;新闻类别标注(news classification)&lt;/strong&gt; 等。文本分类有着非常多的实现方法，每种实现方法中文本的表示也存在着很大的不同。但总的来说，文本分类是一个&lt;strong&gt;监督学习问题&lt;/strong&gt;，需要数据样本以及其对应标签。&lt;/p&gt;&#xA;&lt;p&gt;分类问题又可以分为&lt;strong&gt;二分类&lt;/strong&gt;、&lt;strong&gt;多分类&lt;/strong&gt;以及&lt;strong&gt;多标签分类&lt;/strong&gt;等类型。其中的&lt;strong&gt;多标签分类&lt;/strong&gt;指的是为每个数据标定数量不相同的标签，其由于类标签数量不确定、&lt;strong&gt;类标签之间可能有相互依赖&lt;/strong&gt;、多标签的训练集比较难以获取等原因，难度是分类问题中最大的，因此也称为了分类问题的研究热点。目前主流的多标签分类的实现方式有如下几种：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;不考虑标签之间的关联性&lt;/strong&gt;：将每个标签的出现与否视为二分类任务。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;考虑标签的关联性&lt;/strong&gt;：分类器链、序列生成任务、通过**标签共现(组合)**的方式转换为多分类任务。&lt;/p&gt;&#xA;&lt;p&gt;对于基于神经网络的分类器，实现多标签分类，只需&lt;strong&gt;将输出层的softmax激活函数改为sigmoid激活函数&lt;/strong&gt;，对每个类别进行二分类即可。在这个过程中，每个标签之间不是独立的，其关联性也会被神经网络学习到。&lt;/p&gt;&#xA;&lt;p&gt;分本分类通常用**准确率(accuracy)、召回率(recall)、精准率(precision)和F1(又分为micro和macro)**等指标进行评价。&lt;/p&gt;&#xA;&lt;h3 id=&#34;基于朴素贝叶斯算法的文本分类&#34;&gt;基于朴素贝叶斯算法的文本分类&lt;/h3&gt;&#xA;&lt;p&gt;朴素贝叶斯算法是一种生成模型，其实现简单，常常用于&lt;strong&gt;文本分类的baseline&lt;/strong&gt;。在朴素贝叶斯算法中，文本常用词袋模型进行表示，即每个文档表示为一个大小为$|V|$的向量，其中$|V|$为词汇表的大小，每一个维度表示对应下标的单词在文档中出现的次数：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200417082234463.png&#34; style=&#34;zoom:35%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;朴素贝叶斯分类器是一个概率模型，其理论基础是贝叶斯定理，“朴素”一词指的是&lt;strong&gt;条件独立性假设&lt;/strong&gt;。对于文档$d$，朴素贝叶斯算法预测使得后验概率$P(c|d)$最大的类别$c\in C$。&lt;strong&gt;朴素贝叶斯算法的过程如下所示&lt;/strong&gt;：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200417082740628.png&#34; style=&#34;zoom: 40%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;基于卷积神经网络的文本分类&#34;&gt;基于卷积神经网络的文本分类&lt;/h3&gt;&#xA;&lt;p&gt;与朴素贝叶斯算法等这类传统机器学习方法不同，使用卷积神经网络(CNN)进行文本分类需要将词使用&lt;strong&gt;词向量(例如Word2Vec)&lt;/strong&gt; 进行表示。CNN最初是针对图像设计的，其利用卷积核(convolving filters)来提取图像的局部特征。然而CNN也可以用于文本的特征提取，其通常被称为&lt;strong&gt;TextCNN&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;Yoon Kim在论文《Convolutional Neural Networks for Sentence Classification》中提出了如下CNN网络结构用于文本分类任务：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200417084853983.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;整个网络仅使用了一个卷积层、一个池化层和一个全连接层。输入层为词向量，其可以一开始将词向量矩阵随机初始化，并在训练的过程中进行学习(作为实验的baseline)，也可以一直&lt;strong&gt;保持静态&lt;/strong&gt;(即使用其他语料训练完成后便不再改变)，还可以预训练后在该网络训练的过程中进行&lt;strong&gt;微调&lt;/strong&gt;(在实验中能够取得更好的效果)。该论文还将输入设置为两个通道，其均为词向量，但&lt;strong&gt;其中一个通道保持静态，另一个通道可以在训练过程汇中进行微调&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;另一篇关于TextCNN的论文提出了如下所示的网络结构：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/4/image-20200417095418695.png&#34; style=&#34;zoom:50%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;该论文进行了&lt;strong&gt;大量的实验&lt;/strong&gt;来优化TextCNN中的参数，其中比较重要的一些&lt;strong&gt;结论和建议&lt;/strong&gt;如下：&lt;/p&gt;&#xA;&lt;p&gt;(1) 预训练word2vec或GloVe效果好于one-hot编码形式。&lt;/p&gt;&#xA;&lt;p&gt;(2) 卷积核大小对实验结果有较大影响，一般取1~10，文本越长，可设置卷积核大小越大。&lt;/p&gt;&#xA;&lt;p&gt;(3) 卷积核的数量对实验结果有较大的影响，一般取100&lt;del&gt;600 ，一般使用Dropout比率为0&lt;/del&gt;0.5。&lt;/p&gt;&#xA;&lt;p&gt;(4) 选用ReLU和tanh作为激活函数优于其他的激活函数。&lt;/p&gt;&#xA;&lt;p&gt;(5) 1-max pooling在该实验中优于其他pooling策略。&lt;/p&gt;&#xA;&lt;p&gt;(6) 正则化对实验结果有相对小的影响。&lt;/p&gt;&#xA;&lt;p&gt;(7)当评估一个模型的性能时，考虑模型的方差是必要的。因此，评估模型时应当使用交叉验证，同时考虑模型每次结果的方差以及范围。&lt;/p&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# Tensorflow实现用于多标签文本分类的TextCNN结构&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;def&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;TextCNN&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;seq_len&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;token_num&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;embed_dim&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;out_dim&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;model_img_path&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;None&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;embed_matrix&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;None&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;):&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#34;&amp;#34;&amp;#34;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;    TextCNN模型&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;    1. embedding layers&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;    2. convolution layer&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;    3. max-pooling&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;    4. softmax layer&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;    &amp;#34;&amp;#34;&amp;#34;&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;x_input&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Input&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;max_seq_len&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;if&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;embedd_matrix&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;is&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;None&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;:&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#000&#34;&gt;x_emb&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;layers&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Embedding&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;input_dim&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;token_num&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;                                          &lt;span style=&#34;color:#000&#34;&gt;output_dim&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;embed_dim&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;                                          &lt;span style=&#34;color:#000&#34;&gt;input_length&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;seq_len&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;x_input&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;else&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;:&lt;/span&gt;  &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 加载预训练好的词向量矩阵&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#000&#34;&gt;x_emb&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;layers&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Embedding&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;input_dim&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;token_num&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;                                          &lt;span style=&#34;color:#000&#34;&gt;output_dim&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;embed_dim&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;                                          &lt;span style=&#34;color:#000&#34;&gt;input_length&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;seq_len&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;                                          &lt;span style=&#34;color:#000&#34;&gt;weights&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;embed_matrix&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;],&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;                                          &lt;span style=&#34;color:#000&#34;&gt;trainable&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;True&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;x_input&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# x_embed shape: (batch_size, seq_len, token_num)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;pool_output&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[]&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;kernel_sizes&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;3&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;4&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]&lt;/span&gt;  &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 设置多种卷积核&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;for&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;kernel_size&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;in&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;kernel_sizes&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;:&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# Conv1D input shape: 形如(samples, steps, input_dim)的3D张量&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# Conv1D output shape: 形如(samples，new_steps，nb_filter)的3D张量&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#000&#34;&gt;c&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;layers&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;kerasConv1D&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;filters&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;100&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;kernel_size&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;kernel_size&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;strides&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;x_emb&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;layers&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;MaxPool1D&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;pool_size&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;int&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;c&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]))(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;c&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#000&#34;&gt;pool_output&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;append&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;pool_output&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;layers&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;concatenate&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;([&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;for&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;p&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;in&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;pool_output&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;])&lt;/span&gt;  &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 将多个池化结果进行拼接&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;x_flatten&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;layers&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Flatten&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;()(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;pool_output&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# output_dim个sigmoid输出，是多标签分类的实现方式，实质上是对每个标签的二分类&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;layers&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Dense&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;output_dim&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;activation&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#39;sigmoid&amp;#39;&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;x_flatten&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;model&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;tf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;keras&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;Model&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;([&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;x_input&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;],&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;outputs&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;])&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#000&#34;&gt;model&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;summary&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;()&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;model&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;基于fasttext的文本分类&#34;&gt;基于FastText的文本分类&lt;/h3&gt;&#xA;&lt;p&gt;Armand Joulin等人提出了如下FastText模型，可用于快速的文本分类， 并且准确度接近state-of-art模型。&lt;/p&gt;</description>
    </item>
    <item>
      <title>自编码器</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl6-%E8%87%AA%E7%BC%96%E7%A0%81%E5%99%A8/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl6-%E8%87%AA%E7%BC%96%E7%A0%81%E5%99%A8/</guid>
      <description>&lt;h3 id=&#34;自编码器&#34;&gt;自编码器&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;自编码器(auto-encoder, AE)&lt;/strong&gt; 是通过&lt;strong&gt;无监督&lt;/strong&gt;的方式来学习&lt;strong&gt;一组数据的有效编码(或表示)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;假设有一组$d$维的样本$\boldsymbol{x}^{(n)} \in \mathbb{R}^{d}, 1 \leqslant n \leqslant N$，自编码器将这组数据映射到$p$维的&lt;strong&gt;特征空间&lt;/strong&gt;得到每个样本的编码$\boldsymbol{z}^{(n)} \in \mathbb{R}^{p}, 1 \leqslant n \leqslant N$，并且希望&lt;strong&gt;这组编码可以重构出原来的样本&lt;/strong&gt;。自编码器的结构可分为两部分：&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;编码器(encoder)&lt;/strong&gt;：$f:\mathbb R^d \rightarrow \mathbb R^p$；&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;解码器(decoder)&lt;/strong&gt;：$g:\mathbb R^p \rightarrow \mathbb R^d$。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\mathcal{L} &amp;=\sum_{n=1}^{N}\|\boldsymbol{x}^{(n)}-g(f(\boldsymbol{x}^{(n)}))\|^{2} \\&#xD;&#xA;&amp;=\sum_{n=1}^{N}\|\boldsymbol{x}^{(n)}-f \circ g(\boldsymbol{x}^{(n)})\|^{2}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;如果特征空间的维度$p$小于原始空间的维度$d$，自编码器相当于是一种降维或特征抽取方法。如果$p \geqslant d$，一定可以找到一组或多组解使得$f \circ g$为&lt;strong&gt;单位函数(identity function)&lt;/strong&gt;$I(x)=x$，并使得重构错误为0。然而，这样的解并没有太多的意义。但是，如果再加上一些附加的约束，就可以得到一些有意义的解，比如编码的稀疏性、取值范围，$f$和$g$的具体形式等。如果我们让编码只能取个$k$不同的值($k &amp;lt; N$)，那么自编码器就成为一个$k$类的&lt;strong&gt;聚类问题&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;最简单的自编码器是如下图所示的两层神经网络。输入层到隐藏层用来编码，隐藏层到输出层用来解码，层与层之间互相全连接。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20200806104330514.png&#34; style=&#34;zoom:25%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;我们使用自编码器是为了得到有效的数据表示，因此在训练结束后，&lt;strong&gt;一般会去掉解码器，只保留编码器&lt;/strong&gt;。编码器的输出可以直接作为后续机器学习模型的输入。&lt;/p&gt;&#xA;&lt;h3 id=&#34;稀疏自编码器&#34;&gt;稀疏自编码器&lt;/h3&gt;&#xA;&lt;p&gt;自编码器除了可以学习低维编码之外，也能够学习&lt;strong&gt;高维的稀疏编码&lt;/strong&gt;。假设中间隐藏层$\boldsymbol z$的维度$p$大于输入样本$\boldsymbol x$的维度$d$，并且让$\boldsymbol z$尽量系数，这就是&lt;strong&gt;稀疏自编码器(sparse auto-encoder, SAE)&lt;/strong&gt;。稀疏自编码器的优点是有很高的可解释性，并同时进行了&lt;strong&gt;隐式的特征选择&lt;/strong&gt;。通过给自编码器中隐藏层单元$\boldsymbol z$加上稀疏性限制，自编码器可以学习到数据中一些有用的结构。给定$N$个训练样本${\boldsymbol{x}^{(n)}}_{n=1}^{N}$，稀疏自编码器的目标函数为：&lt;/p&gt;&#xA;$$&#xD;&#xA;\mathcal{L}=\sum_{n=1}^{N} \| \boldsymbol{x}^{(n)}-\boldsymbol{x}^{\prime (n)}\|^{2}+\eta \rho(Z)+\lambda\| W \|^{2}&#xD;&#xA;$$&lt;p&gt;&#xA;其中$Z=[\boldsymbol{z}^{(1)}, \cdots, \boldsymbol{z}^{(N)}]$表示所有训练样本的编码，$\rho(Z)$为稀疏性度量函数，$W$表示自编码器中的参数。$\rho(Z)$可以定义为一组训练样本中每一个神经元激活的概率。&lt;/p&gt;</description>
    </item>
    <item>
      <title>逻辑回归与最大熵模型</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml6-%E9%80%BB%E8%BE%91%E5%9B%9E%E5%BD%92%E4%B8%8E%E6%9C%80%E5%A4%A7%E7%86%B5%E6%A8%A1%E5%9E%8B/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml6-%E9%80%BB%E8%BE%91%E5%9B%9E%E5%BD%92%E4%B8%8E%E6%9C%80%E5%A4%A7%E7%86%B5%E6%A8%A1%E5%9E%8B/</guid>
      <description>&lt;h3 id=&#34;逻辑回归模型&#34;&gt;逻辑回归模型&lt;/h3&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;F(x)&amp;=P(X\leqslant x)=\frac{1}{1+e^{-(x-\mu)/\gamma}}\\&#xD;&#xA;f(x)&amp;=F&#39;(x)=\frac{e^{-(x-\mu)/\gamma}}{\gamma(1+e^{-(x-\mu)/\gamma})^2}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;式中，$\mu$为未知参数，$\gamma&amp;gt;0$为形状参数。其分布函数$F(x)$以点$(\mu,\frac 1 2)$为中心对称。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;P(Y=1|x)&amp;=\frac{\exp(w\cdot x+b)}{1+\exp(w\cdot x+b)}=\frac{1}{1+e^{-(w \cdot x+b)}}\\&#xD;&#xA;P(Y=0|x)&amp;=\frac{1}{1+\exp(w\cdot x+b)}=1-P(Y=1|x)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;P(Y=1|x)&amp;=\frac{\exp(w\cdot x)}{1+\exp(w\cdot x)}=\frac{1}{1+e^{-(w \cdot x)}}\\&#xD;&#xA;P(Y=0|x)&amp;=\frac{1}{1+\exp(w\cdot x)}=1-P(Y=1|x)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;w\cdot x&amp;=\log \frac{p(Y=1|x)}{1-p(Y=1|x)}\\&#xD;&#xA;&amp;=\log \frac{p(Y=1|x)}{p(Y=0|x)}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中，$\log$中的形式称为&lt;strong&gt;几率(odds)&lt;/strong&gt;，指一个事件发生与不发生的比值。&lt;/p&gt;&#xA;&lt;p&gt;逻辑回归采用&lt;strong&gt;交叉熵(cross entropy)&lt;/strong&gt; 作为损失函数，而&lt;strong&gt;交叉熵损失函数可以直接利用极大似然估计推到得到&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;L(w)=\prod_{i=1}^{N}[\pi(x_i)]^{y_i}[1-\pi(x_i)]^{1-y_i}&#xD;&#xA;$$$$&#xD;&#xA;LL(w)=\sum_{i=1}^{N}[y_i\log\pi(x_i)+(1-y_i)\log(1-\pi(x_i))]&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\frac{\partial \mathcal{R}({w})}{\partial {w}} &amp;=-\frac{1}{N} \sum_{i=1}^{N}\left(y_i \frac{\pi(x_i)(1-\pi(x_i))}{\pi(x_i)} {x}_i-(1-y_i) \frac{\pi(x_i)(1-\pi(x_i))}{1-\pi(x_i)} {x}_i\right) \\&#xD;&#xA;&amp;=-\frac{1}{N} \sum_{i=1}^{N}(y_i(1-\pi(x_i)) {x}_i-(1-y_i) \pi(x_i) {x}_i) \\&#xD;&#xA;&amp;=-\frac{1}{N} \sum_{i=1}^{N} {x}_i(y_i-\pi(x_i))&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;从上式可知，逻辑回归的风险函数是关于参数$w$的连续可到的凸函数。因此除了梯度下降法之外，逻辑回归还可以用**高阶的优化方法(比如牛顿法)**来进行优化。&lt;/p&gt;</description>
    </item>
    <item>
      <title>支持向量机</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml7-%E6%94%AF%E6%8C%81%E5%90%91%E9%87%8F%E6%9C%BA/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml7-%E6%94%AF%E6%8C%81%E5%90%91%E9%87%8F%E6%9C%BA/</guid>
      <description>&lt;h3 id=&#34;线性支持向量机与硬间隔最大化&#34;&gt;线性支持向量机与硬间隔最大化&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;支持向量机(support vector machine, SVM)&lt;/strong&gt; 是一个经典的机器学习二分类算法，其找到的分割超平面具有更好的鲁棒性，因此广泛使用在很多任务上，并表现出了很强的优势。&lt;/p&gt;&#xA;&lt;p&gt;给定一个二分类数据集$\mathcal{D}={(\boldsymbol{x}^{(n)}, y^{(n)})}_{n=1}^{N}$，其中$y_n \in {+1,-1}$，如果两类样本是线性可分的，即存在一个超平面$\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}+b=0$将两类样本分开，对于每一类样本都有$y^{(n)}(\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}^{(n)}+b)&amp;gt;0$。&lt;/p&gt;&#xA;$$&#xD;&#xA;\gamma^{(n)}=\frac{\|\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}^{(n)}+b\|}{\|\boldsymbol{w}\|}=\frac{y^{(n)}(\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}^{(n)}+b)}{\|\boldsymbol{w}\|}&#xD;&#xA;$$$$&#xD;&#xA;\gamma=\min _{n} \gamma^{(n)}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\underset{\boldsymbol{w}, b}\max \ \ &amp; \gamma \\&#xD;&#xA;\text { s.t. } \ \ &amp; \frac{y^{(n)}\left(\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}^{(n)}+b\right)}{\|\boldsymbol{w}\|} \geq \gamma, \forall n&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\underset{\boldsymbol{w}, b}\max \ \ &amp; \frac{1}{\|\boldsymbol w\|} \\&#xD;&#xA;\text { s.t. } \ \ &amp; {y^{(n)}(\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}^{(n)}+b)} \geq 1, \forall n&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\underset{\boldsymbol{w}, b}\min \ \  &amp; \frac{1}{2}\|\boldsymbol w\|^2 \\&#xD;&#xA;\text { s.t. } \ \ &amp; {y^{(n)}(\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}^{(n)}+b)} \geq 1, \forall n&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;这就是支持向量机的基本型。下图展示了分割超平面、支持向量以及间隔之间的关系。&lt;/p&gt;</description>
    </item>
    <item>
      <title>深度生成模型</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl7-%E6%B7%B1%E5%BA%A6%E7%94%9F%E6%88%90%E6%A8%A1%E5%9E%8B/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl7-%E6%B7%B1%E5%BA%A6%E7%94%9F%E6%88%90%E6%A8%A1%E5%9E%8B/</guid>
      <description>&lt;h3 id=&#34;概率生成模型&#34;&gt;概率生成模型&lt;/h3&gt;&#xA;&lt;p&gt;概率生成模型，简称&lt;strong&gt;生成模型(generative model)&lt;/strong&gt;，是概率统计和机器学习中的一类重要模型，指一系列用于&lt;strong&gt;随机生成&lt;/strong&gt;可观测数据的模型。假设在一个连续的或离散的高维空间$\mathcal X$中，存在一个随机向量$\boldsymbol X$服从一个未知的数据分布$p_r(\boldsymbol x),\boldsymbol x \in \mathcal X$。生成模型是根据一些可观测的样本$\boldsymbol x^{(1)},\boldsymbol x^{(2)},\cdots,\boldsymbol x^{(N)}$来学习一个参数化的模型$p_\theta(\boldsymbol x)$来近似未知分布$p_r(\boldsymbol x)$，并可以用这个模型来生成一些样本，使得&lt;strong&gt;生成样本和真实样本尽可能地相似&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;自然情况下， 直接建模$p_r(\boldsymbol x)$比较困难。&lt;strong&gt;深度生成模型&lt;/strong&gt;就是利用&lt;strong&gt;深度神经网络可以近似任意函数&lt;/strong&gt;的能力来建模一个复杂的分布$p_r(\boldsymbol x)$。假设一个随机向量$\boldsymbol Z$服从一个简单的分布$p(\boldsymbol z),z \in \mathcal Z$(例如标准正态分布)，我们使用一个深度神经网络$g: \mathcal Z \rightarrow \mathcal X$，并使得$g(\boldsymbol z)$服从$p_r(\boldsymbol x)$。&lt;/p&gt;&#xA;&lt;p&gt;生成模型一般具有两个功能：&lt;strong&gt;密度估计&lt;/strong&gt;和&lt;strong&gt;样本生成&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;给定一组数据$\mathcal D={\boldsymbol x^{(i)}}, 1 \leqslant i \leqslant N$，假设它们都是独立地匆匆相同的概率密度函数为$p_r(\boldsymbol x)$的未知分布中产生的。**概率密度估计(probabilistic density estimation)**是根据数据集$\mathcal D$来估计其概率密度函数$p_\theta(\boldsymbol x)$。在机器学习中，概率密度估计是一种非常典型的无监督学习问题。如果要建模的分布包含隐变量(如高斯混合模型)，就需要利用EM算法来进行密度估计。&lt;/p&gt;&#xA;&lt;p&gt;生成样本就是给定义一个概率密度函数为$p_\theta(\boldsymbol x)$的分布，生成一些服从这个分布的样本，也称为采样。对于一个概率生成模型，在得到两个变量的局部条件概率$p_\theta(\boldsymbol z)$和$p_\theta(\boldsymbol x|\boldsymbol z)$之后，我们就可以生成数据$\boldsymbol x$。具体地，首先根据隐变量的先验分布$p_\theta(\boldsymbol z)$进行采样，得到样本$\boldsymbol z$，然后根据条件分布$p_\theta(\boldsymbol x|\boldsymbol z)$进行采样，得到$\boldsymbol x$。因此，在生成模型中，&lt;strong&gt;重点是估计条件分布&lt;/strong&gt;$p(\boldsymbol x|\boldsymbol z;\theta)$。&lt;/p&gt;&#xA;&lt;h3 id=&#34;变分自编码器&#34;&gt;变分自编码器&lt;/h3&gt;&#xA;&lt;p&gt;假设一个生成模型中包含隐变量，即部分变量不可观测，如下图所示，其中观测变量$\boldsymbol X$是一个高维空间$\mathcal X$中的随机向量，隐变量$\boldsymbol Z$是一个相对低维空间$\mathcal Z$中的随机向量。例如，对于手写数字识别任务，$\boldsymbol X$是数字矩阵(28*28维)，而$\boldsymbol Z$是数字的具体值(10维)。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20211227111340078.png&#34; style=&#34;zoom:40%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;该生成模型的联合概率密度函数可以分解为：$p(\boldsymbol{x}, \boldsymbol{z} ; \theta)=p(\boldsymbol{x} | \boldsymbol{z} ; \theta) p(\boldsymbol{z} ; \theta)$。其中$p(\boldsymbol{z} ; \theta)$为隐变量$\boldsymbol z$先验分布的概率密度函数，$p(\boldsymbol{x} | \boldsymbol{z} ; \theta)$为已知$\boldsymbol z$时观测变量$\boldsymbol x$的条件概率密度函数，$\theta$表示两个密度函数的参数。一般情况下，我们可以假设这两个概率密度函数为某种参数化的分布族，例如正态分布，然后通过最大似然估计得到参数$\theta$。&lt;/p&gt;</description>
    </item>
    <item>
      <title>决策树</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml8-%E5%86%B3%E7%AD%96%E6%A0%91/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml8-%E5%86%B3%E7%AD%96%E6%A0%91/</guid>
      <description>&lt;h3 id=&#34;决策树模型&#34;&gt;决策树模型&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;决策树(decision tree)&lt;/strong&gt; 是一种基本的&lt;strong&gt;分类&lt;/strong&gt;与&lt;strong&gt;回归&lt;/strong&gt;算法。决策树呈树形结构，在分类问题中表示基于特征对实例进行分类的过程，它可以认为是&lt;strong&gt;if-then规则&lt;/strong&gt;的集合，也可以认为是定义在特征空间与类空间上的&lt;strong&gt;条件概率分布&lt;/strong&gt;。其主要优点是模型具有可读性，分类速度快。学习时，利用训练数据，根据损失函数最小化的原则建立决策树模型。预测时，对新的数据，利用训练好的决策模型进行分类。&lt;/p&gt;&#xA;&lt;p&gt;分类决策树模型是一种由&lt;strong&gt;结点(node&lt;/strong&gt;)和&lt;strong&gt;有向边(directed edge)&lt;/strong&gt; 组成的树形结构。结点有两种类型：&lt;strong&gt;内部节点(internal node)，表示一个特征或属性；叶结点(leaf node)，表示一个类&lt;/strong&gt;。用决策树分类，从根结点开始，对实例的某一特征进行测试，根据测试结果，将实例分配到其子结点；这时，每一个子结点对应着该特征的一个取值。如此递归地对实例进行测试并分配，直至到达叶结点。对吼将实例分到叶结点对应的类中。&lt;/p&gt;&#xA;&lt;p&gt;决策树可以看成一个if-then规则的集合，满足&lt;strong&gt;互斥并且完备&lt;/strong&gt;的性质。决策树根结点到叶结点的每一条路径中，路径上的内部结点的特征对应着规则的&lt;strong&gt;条件&lt;/strong&gt;，而叶结点的类对应着规则的&lt;strong&gt;结论&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;决策树还表示给定特征条件下类的条件概率分布，这一分布定义在特征空间的一个&lt;strong&gt;划分(partition)&lt;strong&gt;上。将特征空间划分为互不相交的&lt;/strong&gt;单元(cell)&lt;strong&gt;或&lt;/strong&gt;区域(region)&lt;/strong&gt;，并在每个单元定义一个类的概率分布就构成了一个条件概率分布。决策树的一条路径对应于划分中的一个单元，决策树所表示的条件概率分布由各个单元给定条件下类的条件概率分布组成。假设$X$为表示特征的随机变量，$Y$为表示类的随机变量，那么该条件概率分布可以表示为$P(Y|X)$。$X$取值于给定划分下单元的集合，$Y$取值于类的集合。各叶结点(单元)上的条件概率往往偏向某一个类，即属于某一类的概率较大。决策树分类时将该结点的实例强行分到条件概率大的一类去。&lt;/p&gt;&#xA;&lt;p&gt;决策树学习的本质是从训练数据集中归纳出一组分类规则。与训练集不相矛盾的决策树(即能对训练数据进行正确分类的决策树)可能有多个，也可能一个都没有。我们需要的是一个&lt;strong&gt;与训练数据矛盾较小的，同时具有很好的泛化能力的决策树&lt;/strong&gt;。从另一个角度看，决策树学习是由训练数据集估计条件概率模型。基于特征空间的类的条件概率模型有无穷多个，我们选择的条件概率模型应该不仅对训练数据有很好的拟合，而且对未知数据有很好的预测。&lt;/p&gt;&#xA;&lt;p&gt;决策树的学习算法通常是一个递归地选择最优特征，并根据该特征对训练数据进行分割，使得对各个子数据集有一个最好的分类的过程。这一过程对应着特征空间的，也对应着决策树的构建。大致过程如下：&lt;/p&gt;&#xA;&lt;p&gt;开始，构建根结点，将所有训练数据都放在根结点。选择一个&lt;strong&gt;最优特征&lt;/strong&gt;，按照这一特征将训练数据集分割成子集，使得各个子集有一个在当前条件下最好的分类。如果这些子集已经能够被基本正确分类，那么构建叶结点并将这些子集分到所对应的叶结点中去；如果还有子集不能被基本正确分类，那么就对这些子集选择新的最优特征，继续对其进行分割，构建相应的结点。如此递归地进行下去，直至所有训练数据子集被基本正确分类，或者没有合适的特征为止。最后每个子集都被分到叶结点上，即都有了明确的类。这就生成了一棵决策树。&lt;/p&gt;&#xA;&lt;p&gt;以上方法生成的决策树可能对训练数据有很好的分类能力，但对未知的测试数据却未必有很好的分类能力，即可能发生过拟合现象。我们需要对已生成的树自下而上进行&lt;strong&gt;剪枝&lt;/strong&gt;，使树变得简单，从而使其具有更好的泛化能力。具体地，去掉过于细分的叶结点，使其退回到父结点，甚至更高的结点，然后将父结点或更高的结点改为新的叶结点。通常，&lt;strong&gt;层数越多即越深的决策树的复杂性越高，层数越少即越浅的决策树的复杂性越低&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200428151625612.png&#34; style=&#34;zoom:50%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;h3 id=&#34;特征选择&#34;&gt;特征选择&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;特征选择(feature selection)&lt;/strong&gt; 是决定用哪个特征来划分特征空间。特征选择在于选取对训练数据具有分类能力的特征，以提高决策树的学习效率。通常特征选择的准则是信息增益或信息增益比。&lt;/p&gt;&#xA;&lt;h4 id=&#34;信息增益&#34;&gt;信息增益&lt;/h4&gt;&#xA;$$&#xD;&#xA;H(X)=\sum_{i=1}^{n}p_i\log p_i&#xD;&#xA;$$$$&#xD;&#xA;H(p)=\sum_{i=1}^{n}p_i \log p_i&#xD;&#xA;$$$$&#xD;&#xA;P(X=x_{i}, Y=y_{j})=p_{ij},\ \ i=1,2,\cdots,n;\ \ j=i=1,2,\cdots,m&#xD;&#xA;$$$$&#xD;&#xA;H(Y|X)=\sum_{i=1}^{n}p_i H(Y|X=x_i),\ \ p_i=P(X=x_i),\ \ i=1,2,\cdots,n&#xD;&#xA;$$&lt;p&gt;&#xA;当熵和条件熵中的概率由数据估计(特别是极大似然估计)得到时，所对应的熵与条件熵分别称为&lt;strong&gt;经验熵(empirical entropy)&lt;/strong&gt; 和 &lt;strong&gt;经验条件熵(empirical conditional entropy)&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;g(D,A)=H(D)-H(D|A)&#xD;&#xA;$$&lt;p&gt;&#xA;一般地，熵$H(Y)$与条件熵$H(Y|X)$之差称为&lt;strong&gt;互信息(mutual information)&lt;/strong&gt;，决策树中的信息增益等价于&lt;strong&gt;训练数据集中类与特征的互信息&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;信息增益表示由于特征$A$使得对数据集$D$的分类的不确定性减少的程度。显然，对数据集$D$而言，信息增益依赖于特征，不同的特征往往具有不同的信息增益。信息增益大的特征具有更强的分类能力。根据信息增益准则的特征选择方法是：对训练数据集(或子集)$D$，计算其每个特征的信息增益，&lt;strong&gt;选择信息增益最大的特征&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;设训练数据集为$D$，$|D|$表示其样本容量。设有$K$个类$C_k,k=1,2,\cdots,K$，$|C_k|$为术语类$C_k$的样本个数。设特征$A$有$n$个不同的取值${a_1,a_2,\cdots,a_n}$，根据特征$A$的取值将$D$划分为$n$个子集$D_1,D_2,\cdots,D_n$，$|D_i|$为$D_i$的样本个数记子集$D_i$中属于类$C_k$的样本集合为$D_{ik}$，即$D_{ik}=D_i \cap C_k$，$|D_{ik}|$为$D_{ik}$的样本个数。&lt;/p&gt;&#xA;&lt;p&gt;信息增益算法如下：&lt;/p&gt;&#xA;&lt;p&gt;输入：训练数据集$D$和$A$；&lt;/p&gt;&#xA;&lt;p&gt;输出：特征$A$对训练数据集$D$的信息增益$g(D,A)$&lt;/p&gt;&#xA;$$&#xD;&#xA;H(D)=-\sum_{k=1}^{K}\frac{|C_k|}{|D|}\log \frac{|C_k|}{|D|}&#xD;&#xA;$$$$&#xD;&#xA;H(D|A)=\sum_{i=1}^{n}\frac{|D_i|}{|D|}H(D_i)=-\sum_{i=1}^{n}\frac{|D_i|}{|D|}\sum_{k=1}^{K}\frac{|D_{ik}|}{|D_i|}\log \frac{|D_{ik}|}{|D_i|}&#xD;&#xA;$$$$&#xD;&#xA;g(D,A)=H(D)-H(D|A)&#xD;&#xA;$$&lt;h4 id=&#34;信息增益比&#34;&gt;信息增益比&lt;/h4&gt;&#xA;&lt;p&gt;以信息增益作为划分训练数据集的特征，存在&lt;strong&gt;偏向于选择取值角度的特征&lt;/strong&gt;的问题。使用信息增益比(information gain ratio)可以对这一问题进行校正，这是特征选择的另一准则。&lt;/p&gt;</description>
    </item>
    <item>
      <title>注意力机制与外部记忆</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl8-%E6%B3%A8%E6%84%8F%E5%8A%9B%E6%9C%BA%E5%88%B6%E4%B8%8E%E5%A4%96%E9%83%A8%E8%AE%B0%E5%BF%86/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl8-%E6%B3%A8%E6%84%8F%E5%8A%9B%E6%9C%BA%E5%88%B6%E4%B8%8E%E5%A4%96%E9%83%A8%E8%AE%B0%E5%BF%86/</guid>
      <description>&lt;p&gt;根据通用近似定理，前馈网络和循环网络都有很强的能力。但由于优化算法和计算能力的限制，在实践中很难达到通用近似的能力。特别是在处理复杂任务时，比如需要处理大量的输入信息或者复杂的计算流程时，目前计算机的计算能力依然是限制神经网络发展的瓶颈。&lt;/p&gt;&#xA;&lt;p&gt;为了减少计算复杂度，通过部分借鉴生物神经网络的一些机制，我们引入了局部连接、权重共享以及汇聚操作来简化神经网络结构。虽然这些机制可以有效缓解模型的复杂度和表达能力之间的矛盾，但是我们依然希望&lt;strong&gt;在不过度增加模型复杂度(主要是模型参数)的情况下来提高模型的表达能力&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;神经网络中可以存储的信息量称为&lt;strong&gt;网络容量(network capacity)&lt;/strong&gt;。一般来讲，利用一组神经元来存储信息时，其存储容量和神经元的数量以及网络的复杂度成正比。如果要存储越多的信息，神经元数量就要越多或者网络要越复杂，进而导致神经网络的参数成倍地增加。&lt;/p&gt;&#xA;&lt;p&gt;人脑的生物神经网络同样存在网络容量问题，工作记忆大概只有几秒钟的时间，类似于循环神经网络中的隐状态。而人脑每个时刻接收的外界输入信息非常多，包括来自于视觉、听觉、触觉的各种各样的信息。单就视觉来说，眼睛每秒钟都会发送千万比特的信息给视觉神经系统。人脑在有限的资源下，并不能同时处理这些过载的输入信息。大脑神经系统有两个重要机制可以解决信息过载问题：&lt;strong&gt;注意力(attention)&lt;/strong&gt; 和&lt;strong&gt;记忆(memory)&lt;/strong&gt; 机制。注意力机制通过自上而下的信息选择机制来过滤掉大量的无关信息；记忆机制引入额外外部记忆，优化神经网络的记忆结构来提高神经网络存储信息的容量。&lt;/p&gt;&#xA;&lt;h3 id=&#34;注意力&#34;&gt;注意力&lt;/h3&gt;&#xA;&lt;h4 id=&#34;认知神经学中的注意力&#34;&gt;认知神经学中的注意力&lt;/h4&gt;&#xA;&lt;p&gt;注意力是一种人类不可或缺的复杂认知功能，指人可以在关注一些信息的同时忽略另一些信息的选择能力。在日常生活中，我们通过视觉、听觉、触觉等方式接收大量的感觉输入。但是人脑还能在这些外界的信息轰炸中有条不紊地工作，是因为人脑可以有意或无意地从这些大量输入信息中&lt;strong&gt;选择小部分的有用信息来重点处理&lt;/strong&gt;，并忽略其他信息。这种能力就叫做注意力。注意力可以作用在外部的刺激(听觉、视觉、味觉等)，也可以作用在内部的意识(思考、回忆等)。注意力一般分为两种：&lt;/p&gt;&#xA;&lt;p&gt;一种是&lt;strong&gt;自上而下的有意识的注意力&lt;/strong&gt;，称为&lt;strong&gt;聚焦式注意力(focus attention)&lt;/strong&gt;。聚焦式注意力是指有预定目的、依赖任务的，主动有意识地聚焦于某一对象的注意力。&lt;/p&gt;&#xA;&lt;p&gt;另一种是&lt;strong&gt;自下而上的无意识的注意力&lt;/strong&gt;，称为&lt;strong&gt;基于显著性的注意力(saliency based attention)&lt;/strong&gt;。基于显著性的注意力是由外界刺激驱动的注意，不需要主动干预，也和任务无关。&lt;strong&gt;如果一个对象的刺激信息不同于其周围信息，一种无意识的“赢者通吃”(winner-take-all)或者门控(gating)机制就可以把注意力转向这个对象&lt;/strong&gt;。不管这些注意力是有意还是无意，大部分的人脑活动都需要依赖注意力，比如记忆信息、阅读或思考等。&lt;/p&gt;&#xA;&lt;p&gt;一个和注意力有关的例子是&lt;strong&gt;鸡尾酒会效应&lt;/strong&gt;。当一个人在吵闹的鸡尾酒会上和朋友聊天时，尽管周围噪音干扰很多，他还是可以听到朋友的谈话内容，而&lt;strong&gt;忽略其他人的声音(聚焦式注意力)&lt;/strong&gt;。同时，如果未注意到的背景声中有重要的词(比如他的名字)，&lt;strong&gt;他会马上注意到(显著性注意力)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;聚焦式注意力一般会随着环境、情景或任务的不同而选择不同的信息。比如当要从人群中寻找某个人时，我们会专注于每个人的&lt;strong&gt;脸部&lt;/strong&gt;；而当要统计人群的人数时，我们只需要专注于每个人的&lt;strong&gt;轮廓&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h4 id=&#34;人工神经网络中的注意力&#34;&gt;人工神经网络中的注意力&lt;/h4&gt;&#xA;&lt;p&gt;用$X = [\boldsymbol x_1, \cdots, \boldsymbol x_N]$表示$N$组输入信息，其中每个向量$\boldsymbol x_i$都表示一组输入信息。为了节省计算资源，不需要将所有信息都输入到神经网络，只需要从$X$中选择一些和任务相关的信息。&lt;strong&gt;注意力机制的计算可以分为两步：一是在所有输入信息上计算注意力分布，二是根据注意力分布来计算输入信息的加权平均&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;(1) 注意力分布&lt;/p&gt;&#xA;&lt;p&gt;为了从$N$个输入向量$X = [\boldsymbol x_1, \cdots, \boldsymbol x_N]$中选择出和某个特定任务相关的信息，我们需要引入一个&lt;strong&gt;和任务相关的表示&lt;/strong&gt;，称为&lt;strong&gt;查询向量(query vector)&lt;/strong&gt;，并通过一个&lt;strong&gt;打分函数&lt;/strong&gt;来计算&lt;strong&gt;每个输入向量和查询向量之间的相关性&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\alpha_{i} &amp;=p(z=i | X, \boldsymbol{q}) \\&#xD;&#xA;&amp;=\operatorname{softmax}\left(s\left(\boldsymbol{x}_{i}, \boldsymbol{q}\right)\right) \\&#xD;&#xA;&amp;=\frac{\exp \left(s\left(\boldsymbol{x}_{i}, \boldsymbol{q}\right)\right)}{\sum_{j=1}^{N} \exp \left(s\left(\boldsymbol{x}_{j}, \boldsymbol{q}\right)\right)}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中$\alpha_i$称为&lt;strong&gt;注意力分布(attention distribution)&lt;/strong&gt;，$s(\boldsymbol x_i,\boldsymbol q)$为注意力打分函数，可以使用以下几种方式来计算：&lt;/p&gt;&#xA;&lt;p&gt;加性模型：$s(\boldsymbol{x}&lt;em&gt;{i}, \boldsymbol{q})=\boldsymbol{v}^{\mathrm{T}} \tanh (W \boldsymbol{x}&lt;/em&gt;{i}+U \boldsymbol{q})$；&lt;/p&gt;&#xA;&lt;p&gt;点积模型：$s\left(\boldsymbol{x}&lt;em&gt;{i}, \boldsymbol{q}\right)=\boldsymbol{x}&lt;/em&gt;{i}^{\mathrm{T}} \boldsymbol{q}$；&lt;/p&gt;&#xA;&lt;p&gt;缩放点积模型：$s(\boldsymbol{x}&lt;em&gt;{i}, \boldsymbol{q})=\frac{\boldsymbol{x}&lt;/em&gt;{i}^{\mathrm{T}} \boldsymbol{q}}{\sqrt{d}}$；&lt;/p&gt;</description>
    </item>
    <item>
      <title>图神经网络</title>
      <link>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl9-%E5%9B%BE%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/3-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/dl9-%E5%9B%BE%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/</guid>
      <description>&lt;h3 id=&#34;图神经网络概述&#34;&gt;图神经网络概述&lt;/h3&gt;&#xA;&lt;p&gt;近年来，深度学习领域关于&lt;strong&gt;图神经网络(graph neural network, GNN)&lt;/strong&gt; 的研究热情日益高涨，图神经网络已经成为各大深度学习顶会的研究热点。GNN处理非结构化数据时的出色能力使其在网络数据分析、推荐系统、物理建模、自然语言处理和图上的组合优化问题方面都取得了新的突破。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20211229201804200.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;随着机器学习、深度学习的发展，语音、图像、自然语言处理逐渐取得了很大的突破，然而语音、图像、文本都是很简单的序列或者网格数据，是很结构化的数据，深度学习很善于处理该种类型的数据。然而，现实世界中并不是所有的事物都可以表示成一个序列或者一个网格，例如社交网络、知识图谱、论文引用网络等，也就是说很多事物都是非结构化的。非结构化的数据可以使用 &lt;strong&gt;图(graph)&lt;/strong&gt; 这种数据结构进行表示，其特点包括：&lt;/p&gt;&#xA;&lt;p&gt;(1) 图的大小是任意的，图的拓扑结构复杂，没有像图像一样的空间局部性；&lt;/p&gt;&#xA;&lt;p&gt;(2) 图没有固定的节点顺序，或者说没有一个参考节点；&lt;/p&gt;&#xA;&lt;p&gt;(3) 图经常是动态图，而且包含多模态的特征。&lt;/p&gt;&#xA;&lt;p&gt;图神经网络是对图进行表示，并将深度学习扩展使得能够建模问题和数据，以完成各类基于图的任务的神经网络结构。其所能够完成的常见任务包括结点分类、社区发现以及链接预测等。&lt;/p&gt;&#xA;&lt;h3 id=&#34;图神经网络中的矩阵&#34;&gt;图神经网络中的矩阵&lt;/h3&gt;&#xA;&lt;p&gt;以如下所示的图结构为例：&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/3/image-20211229203152876.png&#34; style=&#34;zoom:40%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;一个图$G$的定义为$G=(V, E)$，其中$V$为结点集，结点数量$m = |V|$；$E$为边集，边数量$n = |E|$。通常用一些矩阵来刻画图结构：&lt;/p&gt;&#xA;$$&#xD;&#xA;\boldsymbol A=\left[\begin{array}{llllll}&#xD;&#xA;0 &amp; 1 &amp; 1 &amp; 1 &amp; 0 &amp; 0 \\&#xD;&#xA;1 &amp; 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;1 &amp; 1 &amp; 0 &amp; 0 &amp; 1 &amp; 1 \\&#xD;&#xA;1 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 &amp; 1 \\&#xD;&#xA;0 &amp; 0 &amp; 1 &amp; 0 &amp; 1 &amp; 0&#xD;&#xA;\end{array}\right]&#xD;&#xA;$$$$&#xD;&#xA;\boldsymbol D=\left[\begin{array}{llllll}&#xD;&#xA;3 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;0 &amp; 2 &amp; 0 &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;0 &amp; 0 &amp; 4 &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;0 &amp; 0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 \\&#xD;&#xA;0 &amp; 0 &amp; 0 &amp; 0 &amp; 2 &amp; 0 \\&#xD;&#xA;0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 2&#xD;&#xA;\end{array}\right]&#xD;&#xA;$$$$&#xD;&#xA;\boldsymbol P=\left[\begin{array}{cccccc}&#xD;&#xA;0 &amp; \frac{1}{\sqrt{3} \cdot \sqrt{2}} &amp; \frac{1}{\sqrt{3} \cdot \sqrt{4}} &amp; \frac{1}{\sqrt{3} \cdot \sqrt{1}} &amp; 0 &amp; 0 \\&#xD;&#xA;\frac{1}{\sqrt{3} \cdot \sqrt{2}} &amp; 0 &amp; \frac{1}{\sqrt{2} \cdot \sqrt{4}} &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;\frac{1}{\sqrt{3} \cdot \sqrt{4}} &amp; \frac{1}{\sqrt{2} \cdot \sqrt{4}} &amp; 0 &amp; 0 &amp; \frac{1}{\sqrt{4} \cdot \sqrt{2}} &amp; \frac{1}{\sqrt{4} \cdot \sqrt{2}} \\&#xD;&#xA;\frac{1}{\sqrt{3} \cdot \sqrt{1}} &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;0 &amp; 0 &amp; 0 &amp; \frac{1}{\sqrt{4} \cdot \sqrt{2}} &amp; 0 &amp; \frac{1}{\sqrt{2} \cdot \sqrt{2}} \\&#xD;&#xA;0 &amp; 0 &amp; 0 &amp; \frac{1}{\sqrt{4} \cdot \sqrt{2}} &amp; \frac{1}{\sqrt{2} \cdot \sqrt{2}} &amp; 0&#xD;&#xA;\end{array}\right]&#xD;&#xA;$$$$&#xD;&#xA;\boldsymbol L=\left[\begin{array}{cccccc}&#xD;&#xA;1 &amp; \frac{-1}{\sqrt{3} \cdot \sqrt{2}} &amp; \frac{-1}{\sqrt{3} \cdot \sqrt{4}} &amp; \frac{-1}{\sqrt{3} \cdot \sqrt{1}} &amp; 0 &amp; 0 \\&#xD;&#xA;\frac{-1}{\sqrt{3} \cdot \sqrt{2}} &amp; 1 &amp; \frac{-1}{\sqrt{2} \cdot \sqrt{4}} &amp; 0 &amp; 0 &amp; 0 \\&#xD;&#xA;\frac{-1}{\sqrt{3} \cdot \sqrt{4}} &amp; \frac{-1}{\sqrt{2} \cdot \sqrt{4}} &amp; 1 &amp; 0 &amp; \frac{-1}{\sqrt{4} \cdot \sqrt{2}} &amp; \frac{-1}{\sqrt{4} \cdot \sqrt{2}} \\&#xD;&#xA;\frac{-1}{\sqrt{3} \cdot \sqrt{1}} &amp; 0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 \\&#xD;&#xA;0 &amp; 0 &amp; 0 &amp; \frac{-1}{\sqrt{4} \cdot \sqrt{2}} &amp; 1 &amp; \frac{-1}{\sqrt{2} \cdot \sqrt{2}} \\&#xD;&#xA;0 &amp; 0 &amp; 0 &amp; \frac{-1}{\sqrt{4} \cdot \sqrt{2}} &amp; \frac{-1}{\sqrt{2} \cdot \sqrt{2}} &amp; 1&#xD;&#xA;\end{array}\right]&#xD;&#xA;$$&lt;p&gt;&#xA;(5) &lt;strong&gt;结点特征矩阵&lt;/strong&gt;$\boldsymbol X \in \mathbb R^{n \times f}$，其中$f$为特征维数：GNN中每个结点通常有一个特征，而结点特征矩阵便用于记录每个结点的特征。为简便起见，下图中用one-hot向量作为每个结点的特征向量。通常会将结点特征矩阵和图结构矩阵融合进行学习。&lt;/p&gt;</description>
    </item>
    <item>
      <title>集成学习</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml9-%E9%9B%86%E6%88%90%E5%AD%A6%E4%B9%A0/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml9-%E9%9B%86%E6%88%90%E5%AD%A6%E4%B9%A0/</guid>
      <description>&lt;h3 id=&#34;个体与集成&#34;&gt;个体与集成&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;集成学习(ensemble learning)&lt;/strong&gt; 通过构建并结合多个学习期来完成学习任务，有时也被称为&lt;strong&gt;多分类器系统(multi-classifier system)&lt;/strong&gt;、&lt;strong&gt;基于委员会的学习(committee-based learning)&lt;/strong&gt; 等。&lt;/p&gt;&#xA;&lt;p&gt;集成学习的思路如下：首先产生一组&lt;strong&gt;个体学习器(indicidual learner)&lt;/strong&gt;，再用某种策略将它们结合起来。个体学习器(基学习器)通常由一个现有的学习算法(基学习算法)从训练数据中产生，例如决策树、BP神经网络等，此时集成中只包含同种类型的个体学习器，例如“决策树集成”中全是决策树，这样的集成是&lt;strong&gt;同质的(homogeneous)&lt;/strong&gt;，同质集成中的个体学习器亦称为&lt;strong&gt;基学习器(base learner)&lt;/strong&gt;。集成也可以包含不同类型的个体学习器，此时称其为&lt;strong&gt;异质的(heterogenous)&lt;/strong&gt;，相应的个体学习器一般不称基学习器，而是称为&lt;strong&gt;组件学习器(component learner)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200429101621224.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;历史上，Kearns和Valiant首先提出了&lt;strong&gt;强可学习(strongly learnable)&lt;strong&gt;和&lt;/strong&gt;弱可学习(weakly learnable)&lt;/strong&gt; 的概念。他们指出：在**概率近似正确(probably approximately correct, PAC)**学习的框架中，一个概念(一个类)，如果存在一个多项式的学习算法能够学习它，并且正确率很高，就称这个概念是强可学习的；一个概念，如果存在一个多项式的学习算法能够学习它，学习的正确率仅比随机猜测略好，就称这个概念是弱可学习的。后来Schapire证明强可学习和弱可学习是等价的，也就是说，&lt;strong&gt;在PAC学习的框架下，一个概念是强可学习的充分必要条件是这个概念是弱可学习的&lt;/strong&gt;。集成学习便是研究如何将弱学习算法提升为强学习算法的理论。&lt;/p&gt;&#xA;&lt;p&gt;集成学习通过将多个学习器进行结合，常可获得比单一学习器显著优越的泛化性能。这对&lt;strong&gt;弱学习器&lt;/strong&gt;尤为明显，因此集成学习的很多理论研究都是针对弱学习器进行的，而基学习器有时也被直接称为弱学习器。但需注意的是，虽然从理论上来说使用弱学习器集成足以获得好的性能，但在实践中，&lt;strong&gt;往往会使用比较强的学习器进行集成&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;在经验中，如果把好坏不等的东西掺到一起，那么通常结果会是比最坏的要好一些，比最好的要坏一些。集成学习要获得比最好的单一学习器更好的性能，个体学习器应“&lt;strong&gt;好而不同&lt;/strong&gt;”，即&lt;strong&gt;个体学习器要同时具备准确性和多样性&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;根据个体学习器的生成方式，目前集成学习方法大致可分为两大类，即个体学习器之间存在强依赖关系、必须串行生成的&lt;strong&gt;序列化方法&lt;/strong&gt;，以及个体学习器间不存在强依赖关系，可同时生成的&lt;strong&gt;并行化方法&lt;/strong&gt;。前者的代表是&lt;strong&gt;Boosting&lt;/strong&gt;，后者的代表是&lt;strong&gt;Bagging和随机森林&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h3 id=&#34;集成学习的误差分析&#34;&gt;集成学习的误差分析&lt;/h3&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\mathcal{R}(f_{m}) &amp;=\mathbb{E}_{{x}}[(f_{m}({x})-h({x}))^{2}] \\&#xD;&#xA;&amp;=\mathbb{E}_{{x}}[\epsilon_{m}({x})^{2}]&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$&#xD;&#xA;\bar{\mathcal{R}}(f)=\frac{1}{M} \sum_{m=1}^{M} \mathbb{E}_{\boldsymbol{x}}[\epsilon_{m}({x})^{2}]&#xD;&#xA;$$$$&#xD;&#xA;F({x})=\frac{1}{M} \sum_{m=1}^{M} f_{m}({x})&#xD;&#xA;$$&lt;p&gt;&#xA;对于投票法的误差，有如下定理：对于$M$个不同的模型$f_1(x),\cdots,f_M(x)$，其平均期望错误为$\bar{\mathcal R}(f)$。基于简单投票机制的集成模型$F(x)$的&lt;strong&gt;期望错误&lt;/strong&gt;位于$\frac{1}{M}\bar{\mathcal R}(f)$和$\bar{\mathcal R}(f)$之间。证明如下：&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\mathcal{R}(F) &amp;=\mathbb{E}_x\left[\left(\frac{1}{M} \sum_{m=1}^{M} f_{m}({x})-h({x})\right)^{2}\right] \\&#xD;&#xA;&amp;=\mathbb{E}_x\left[\left(\frac{1}{M} \sum_{m=1}^{M} \epsilon_{m}({x})\right)^{2}\right] \\&#xD;&#xA;&amp;=\frac{1}{M^{2}} \mathbb{E}_x\left[\sum_{m=1}^{M} \sum_{n=1}^{M} \epsilon_{m}({x}) \epsilon_{n}({x})\right] \\&#xD;&#xA;&amp;=\frac{1}{M^{2}} \sum_{m=1}^{M} \sum_{n=1}^{M} \mathbb{E}_{{x}}[\epsilon_{m}({x}) \epsilon_{n}({x})]&#xD;&#xA;\end{aligned}&#xD;&#xA;$$$$\mathbb{E}_{\boldsymbol{ x }}[\epsilon_{m}({x}) \epsilon_{n}({x})]$$$$\forall m \neq n, \mathbb{E}_{{x}}[\epsilon_{m}({x}) \epsilon_{n}({x})]=0$$$$&#xD;&#xA;\bar{\mathcal{R}}(f) \geq \mathcal{R}(F) \geq \frac{1}{M} \bar{\mathcal{R}}(f)&#xD;&#xA;$$&lt;p&gt;&#xA;即集成模型的期望错误大于等于所有模型的平均期望错误的$1/M$，小于等于所有模型的平均期望错误。因此模型之间的差异性对于提升模型集成效果是十分重要的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>EM算法</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml10-em%E7%AE%97%E6%B3%95/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml10-em%E7%AE%97%E6%B3%95/</guid>
      <description>&lt;h3 id=&#34;em算法的引入&#34;&gt;EM算法的引入&lt;/h3&gt;&#xA;&lt;p&gt;概率模型有时既含观测变量，又含隐变量。如果概率模型的变量都是观测变量，那么给定数据，可以直接用极大似然估计法，或贝叶斯估计法估计模型参数。但是，当模型含有隐变量时，就不能简单地使用这些估计方法。&lt;strong&gt;EM算法&lt;/strong&gt;就是&lt;strong&gt;含有隐变量的概率模型参数的极大似然估计法&lt;/strong&gt;，或&lt;strong&gt;极大后验概率估计法&lt;/strong&gt;。我们仅讨论极大似然估计，极大后验概率估计与其类似。&lt;/p&gt;&#xA;&lt;h4 id=&#34;三硬币模型&#34;&gt;三硬币模型&lt;/h4&gt;&#xA;&lt;p&gt;假设有3枚硬币，分别记作$A, B, C$。这些硬币正面出现的概率分别是$\pi, p, q$。进行如下投掷试验：先掷硬币$A$，根据其结果选出硬币$B$或硬币$C$，正面选硬币$B$，反而选硬币$C$；然后掷选出的硬币，掷硬币的结果，出现正面记作1，出现反面记作0；独立地重复$n$次试验(这里$n=10$)，预测结果如下：1, 1, 0, 1, 0, 0, 1, 0, 1, 1。&lt;/p&gt;&#xA;&lt;p&gt;假设只能观测到掷硬币的结果，不能观测掷硬币的过程。问如何估计三枚硬币分别出现正面的概率，即三硬币模型的参数。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;P(y|\theta) &amp;=\sum_{z} P(y, z|\theta)=\sum_{z} P(z|\theta) P(y|z, \theta) \\&#xD;&#xA;&amp;=\pi p^{y}(1-p)^{1-y}+(1-\pi) q^{y}(1-q)^{1-y}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中，随机变量$y$是观测变量，表示一次试验观测的结果是0或1；随机变量$z$为隐变量，表示&lt;strong&gt;未观测到&lt;/strong&gt;的硬币$A$的结果；$\theta=(\pi,p,q)$是模型参数。这一模型是以上数据的生成模型。注意，随机变量$y$的数据可以观测，随机变量$z$的数据&lt;strong&gt;不可观测&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h3 id=&#34;em算法过程&#34;&gt;EM算法过程&lt;/h3&gt;&#xA;$$&#xD;&#xA;P(Y|\theta)=\sum_Z P(Z|\theta)P(Y|Z,\theta)&#xD;&#xA;$$$$&#xD;&#xA;P(Y|\theta)=\prod_{j=1}^{n}[\pi p^{y_j}(1-p)^{1-y_j}+(1-\pi)q^{y_j}(1-q)^{1-y_j}]&#xD;&#xA;$$$$&#xD;&#xA;\hat \theta=\arg\max_\theta \log P(Y|\theta)&#xD;&#xA;$$&lt;p&gt;&#xA;这个问题没有解析解，只有通过迭代的方法求解。EM算法就是可以用于求解这个问题的一种迭代算法，下面给出针对三硬币问题的EM算法：&lt;/p&gt;&#xA;&lt;p&gt;EM算法首先选取参数的初值，记作$\theta^{(0)}=(\pi^{(0)},p^{(0)},q^{(0)})$，然后通过下面的步骤迭代计算参数的估计值，直至收敛为止。第$i$次迭代参数的估计值为$\theta^{(i)}=(\pi^{(i)},p^{(i)},q^{(i)})$。EM算法第$i+1$次迭代如下：&lt;/p&gt;&#xA;$$&#xD;&#xA;\mu^{(i+1)}=\frac{\pi^{(i)}(p^{(i)})^{y_{j}}(1-p^{(i)})^{1-y_{j}}}{\pi^{(i)}(p^{(i)})^{y_{j}}(1-p^{(i)})^{1-y_{j}}+(1-\pi^{(i)})(q^{(i)})^{y_{j}}(1-q^{(i)})^{1-y_{j}}}&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\pi^{(i+1)}=\frac{1}{n} \sum_{j=1}^{n} \mu_{j}^{(i+1)} \\&#xD;&#xA;p^{(i+1)}=\frac{\sum_{j=1}^{n} \mu_{j}^{(i+1)} y_{j}}{\sum_{j=1}^{n} \mu_{j}^{(i+1)}} \\&#xD;&#xA;q^{(i+1)}=\frac{\sum_{j=1}^{n}(1-\mu_{j}^{(i+1)}) y_{j}}{\sum_{j=1}^{n}(1-\mu_{j}^{(i+1)})}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;可以算得，如果取初值$\pi^{(0)}=0.4,p^{(0)}=0.6,q^{(0)}=0.7$，那么得到的模型参数的极大似然估计中，三者的值分别为0.4064, 0.5368和0.6432。&lt;strong&gt;EM算法与初值的选择有关&lt;/strong&gt;，选择不同的初值可能得到不同的参数估计值。&lt;/p&gt;&#xA;&lt;p&gt;一般用$Y$表示观测随机变量的数据，$Z$表示隐随机变量的数据。$Y$和$Z$连在一起称为&lt;strong&gt;完全数据(complete data)&lt;/strong&gt;，观测数据$Y$又称为&lt;strong&gt;不完全数据(incomplete data)&lt;/strong&gt;。假设给定观测数据$Y$，其概率分布是$P(Y|\theta)$，其中$\theta$是需要估计的模型参数，那么不完全数据$Y$的似然函数是$P(Y|\theta)$，对数似然函数$L(\theta)=\log P(Y|\theta)$；假设$Y$和$Z$的联合概率分布是$P(Y,Z|\theta)$，那么完全数据的对数似然函数是$\log P(Y,Z|\theta)$。&lt;/p&gt;</description>
    </item>
    <item>
      <title>聚类</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml11-%E8%81%9A%E7%B1%BB/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml11-%E8%81%9A%E7%B1%BB/</guid>
      <description>&lt;h3 id=&#34;聚类的基本概念&#34;&gt;聚类的基本概念&lt;/h3&gt;&#xA;&lt;p&gt;在&lt;strong&gt;无监督学习(unsupervised learning)&lt;/strong&gt; 中，训练样本的标记信息是未知的，目标是通过对无标记样本的学习来揭示数据的内在性质及规律，为进一步的数据分析提供基础。聚类(clustering)任务是一种常见的无监督学习方法。&lt;/p&gt;&#xA;&lt;p&gt;聚类试图将数据集中的样本划分为若干个不相交的子集，每个子集称为一个&lt;strong&gt;簇(cluster)&lt;/strong&gt;。通过这样的划分，每个簇可能对应于一些&lt;strong&gt;潜在的概念(类别)&lt;/strong&gt;。这些概念对聚类算法而言事先是未知的，聚类过程仅能自动形成簇结构，簇所对应的概念语义需由使用者来把握和命名。&lt;/p&gt;&#xA;&lt;p&gt;聚类既能作为一个单独过程，用于寻找数据内在的分布结构，也可作为分类等其他学习任务的&lt;strong&gt;先驱过程&lt;/strong&gt;。例如在一些商业应用中需对新用户的类型进行判别，但定义用户类型对商家来说却可能不太容易，此时往往可先对已有用户数据进行聚类，根据聚类结果&lt;strong&gt;将每个簇定义为一个类&lt;/strong&gt;，然后再基于这些类训练分类模型，用于判别新用户的类型。&lt;/p&gt;&#xA;&lt;h4 id=&#34;相似度或距离&#34;&gt;相似度或距离&lt;/h4&gt;&#xA;&lt;p&gt;剧烈的核心概念是&lt;strong&gt;相似度(similarity)&lt;strong&gt;或&lt;/strong&gt;距离(distance)&lt;/strong&gt;。有多种相似度或距离的定义。因为相似度直接影响聚类的结果，所以其选择是聚类的根本问题。具体哪种相似度更合适取决于应用问题的特性。&lt;/p&gt;&#xA;$$&#xD;&#xA;\operatorname{dist}_{m k}(x_{i}, x_{j})=(\sum_{u=1}^{n}|x_{i u}-x_{j u}|^{p})^{\frac{1}{p}}&#xD;&#xA;$$&lt;p&gt;&#xA;当$p=2$时，称为&lt;strong&gt;欧氏距离(Euclidean distance)&lt;/strong&gt;；当$p=1$时称为曼哈顿距离(Manhattan distance)；当$p=\infty$时称为&lt;strong&gt;切比雪夫距离(Chebyshev distance)&lt;/strong&gt;，即取各个坐标数值差的绝对值的最大值。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;马哈拉诺比斯距离(Mahalanobis distance)&lt;/strong&gt;：简称马氏距离，也是一种常用的相似度，考虑各个分量(特征)之间的相关性并与各个分量的尺度无关。给定一个样本集合$X=(x_{ij})&lt;em&gt;{m \times n}$，其协方差矩阵记作$S$。样本$x_i$与样本$x_j$之间的马哈拉诺比斯距离$d&lt;/em&gt;{ij}$定义为$d_{ij}=[(x_i-x_j)^{\text T}S^{-1}(x_i-x_j)]^{\frac{1}{2}}$。当$S$为单位矩阵时，即样本数据的各个分量相互独立且各个分量房差为1时，马氏距离等价于欧氏距离。因此马氏距离是欧氏距离的推广。&lt;/p&gt;&#xA;&lt;p&gt;(3) 样本之间的相似性度量还有&lt;strong&gt;相关系数&lt;/strong&gt;、&lt;strong&gt;夹角余弦&lt;/strong&gt;等。&lt;/p&gt;&#xA;&lt;h4 id=&#34;类或簇&#34;&gt;类或簇&lt;/h4&gt;&#xA;&lt;p&gt;通过聚类得到的类或簇，本质是样本的子集。如果一个聚类方法假定一个样本只能属于一个类，那么该方法称为**硬聚类(hard clustering)&lt;strong&gt;方法；如果一个样本可以属于多个类，那么该方法称为&lt;/strong&gt;软聚类(soft clustering)**方法。其中，硬聚类方法较为常用。用$G$表示类或簇，用$x_i,x_j$表示类中的样本，用$n_G$表示$G$中样本的个数，用$d_{ij}$表示样本$x_i$和$x_j$之间的距离。类或簇有多种定义：&lt;/p&gt;&#xA;&lt;p&gt;(1) 设$T$为给定的正数，若集合$G$中任意两个样本$x_i$和$x_j$满足$d_{ij} \leqslant T$，则称$G$为一个类或簇。&lt;/p&gt;&#xA;&lt;p&gt;(2) 设$T$为给定的正数，若对集合$G$中任一样本，必存在另一个样本$x_j$，使得$d_{ij} \leqslant T$，则称$G$为一个类或簇。&lt;/p&gt;&#xA;$$&#xD;&#xA;\frac{1}{n_G-1}\sum_{x_i \in G} d_{ij} \leqslant T &#xD;&#xA;$$&lt;p&gt;&#xA;其中$n_G$为$G$中样本的个数，则称$G$为一个类或簇。&lt;/p&gt;&#xA;$$&#xD;&#xA;\frac{1}{n_G(n_G-1)}\sum_{x_i \in G} \sum_{x_j \in G}d_{ij} \leqslant T&#xD;&#xA;$$&lt;p&gt;&#xA;则称$G$为一个类或簇。以上四个定义中，第一个定义最为常用。类的特征可以通过不同角度来刻画，比如&lt;strong&gt;类的均值&lt;/strong&gt;、&lt;strong&gt;类的直径(diameter, 任意两样本样本之间的最大距离)&lt;/strong&gt;、类的样本散布矩阵以及协方差矩阵等。&lt;/p&gt;&#xA;&lt;h4 id=&#34;类与类之间的距离&#34;&gt;类与类之间的距离&lt;/h4&gt;&#xA;&lt;p&gt;类$G_p$与类$G_q$之间的距离$D(p,q)$，也称为&lt;strong&gt;连接(linkage)&lt;/strong&gt;，有多重定义：&lt;/p&gt;&#xA;&lt;p&gt;(1) &lt;strong&gt;最短距离或单连接&lt;/strong&gt;：$D_{pq}=\min{d_{ij}|x_i \in G_p,x_j \in G_q}$，即两类样本间的最短距离。&lt;/p&gt;&#xA;&lt;p&gt;(2) &lt;strong&gt;最长距离或完全连接&lt;/strong&gt;：$D_{pq}=\max{d_{ij}|x_i \in G_p,x_j \in G_q}$，即两类样本间的最长距离。&lt;/p&gt;</description>
    </item>
    <item>
      <title>降维</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml12-%E9%99%8D%E7%BB%B4/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml12-%E9%99%8D%E7%BB%B4/</guid>
      <description>&lt;h3 id=&#34;主成分分析&#34;&gt;主成分分析&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;主成分分析(principal component analysis, PCA)&lt;/strong&gt; 是一种最常用的数据降维方法，使得在转换后的空间中数据的方差最大。如下图所示的二维数据，如果将这些数据投影到一维空间，选择数据方差最大的方向进行投影(蓝轴)，才能最大化数据的差异性，保留更多的原始数据信息。&lt;/p&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200528202055368.png&#34; style=&#34;zoom:30%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;假设有一组$d$维样本$\boldsymbol x^{(n)} \in \mathbb R^d, 1 \leqslant n \leqslant N$，我们希望将其投影到一维空间中，投影向量为$\boldsymbol w \in \mathbb R^d$。不失一般性，限制$\boldsymbol w$的模为1，即$\boldsymbol w^\text T \boldsymbol w=1$。每个样本点$\boldsymbol x^{(n)}$投影之后的表示为$z^{(n)}=\boldsymbol w^\text T \boldsymbol x^{(n)}$。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;\sigma(X ; \boldsymbol{w}) &amp;=\frac{1}{N} \sum_{n=1}^{N}(\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}^{(n)}-\boldsymbol{w}^{\mathrm{T}} \bar{\boldsymbol{x}})^{2} \\&#xD;&#xA;&amp;=\frac{1}{N}(\boldsymbol{w}^{\mathrm{T}} X-\boldsymbol{w}^{\mathrm{T}} \bar{X})(\boldsymbol{w}^{\mathrm{T}} X-\boldsymbol{w}^{\mathrm{T}} \bar{X})^{\mathrm{T}} \\&#xD;&#xA;&amp;=\boldsymbol{w}^{\mathrm{T}} \boldsymbol{S} \boldsymbol{w}&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中，$\bar X=\bar{\boldsymbol x} \boldsymbol 1_d^\text T$为$d$列$\bar{\boldsymbol x}$组成的矩阵，$S=\frac{1}{N}(X-\bar{X})(X-\bar{X})^{\mathrm{T}}$是&lt;strong&gt;原始样本的协方差矩阵&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;\max _{\boldsymbol{w}} \boldsymbol{w}^{\mathrm{T}} S \boldsymbol{w}+\lambda(1-\boldsymbol{w}^{\mathrm{T}} \boldsymbol{w})&#xD;&#xA;$$&lt;p&gt;&#xA;其中$\lambda$为拉格朗日乘子。对上式求导并令导数为0，可得$S \boldsymbol{w}=\lambda \boldsymbol{w}$。&lt;/p&gt;</description>
    </item>
    <item>
      <title>特征选择</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml13-%E7%89%B9%E5%BE%81%E9%80%89%E6%8B%A9/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml13-%E7%89%B9%E5%BE%81%E9%80%89%E6%8B%A9/</guid>
      <description>&lt;h3 id=&#34;子集搜索与评价&#34;&gt;子集搜索与评价&lt;/h3&gt;&#xA;&lt;p&gt;给定属性集，其中有些属性可能很关键、很有用，另一些属性则可能没什么用。对当前学习任务有用的属性称为&lt;strong&gt;相关特征(relevant feature)&lt;/strong&gt;，无用的属性称为&lt;strong&gt;无关特征(irrelevant feature)&lt;/strong&gt;。**特征选择(feature selection)**是一个重要的数据预处理过程，指从给定的特征集合中选择出相关特征的子集的过程。特征选择能够减少维数灾难问题，同时降低学习任务的难度。&lt;/p&gt;&#xA;&lt;p&gt;如果我们想从特征集合中选区一个包含了所有重要信息的特征子集，如果我们没有任何先验知识，那么就只能遍历可能的子集，这会带来很高的计算复杂度；可行的一种做法是先产生一个“&lt;strong&gt;候选子集&lt;/strong&gt;&amp;quot;，评价它的好坏，然后在此基础之上产生下一个子集。这里涉及到两个关键环节，一是如何根据评价结果选择下一个候选子集，二是如何评价子集的好坏。&lt;/p&gt;&#xA;&lt;p&gt;第一个环节是&lt;strong&gt;子集搜索(subset search)&lt;/strong&gt;，给定特征集合${a_1,a_2,\cdots,a_d}$，可以将&lt;strong&gt;每个单独的特征&lt;/strong&gt;看作一个候选子集，对这$d$个候选单特征子集进行评定，假如${a_2}$最优，那么我们就把${a_2}$作为第一轮的选定集；然后，在上一轮选定集中加入一个特征，构成两个特征的候选子集，我们假定${a_2,a_4}$最优且优于${a_2}$，那么我们就得到了新的候选子集，以此类推。这是一种&lt;strong&gt;前向搜索&lt;/strong&gt;。我们也可以从完整的属性集合开始，每次去掉一个无关特征，这样的方法叫&lt;strong&gt;后向搜索&lt;/strong&gt;。还可以将前向和后向搜索结合起来进行&lt;strong&gt;双向搜索&lt;/strong&gt;。显然，&lt;strong&gt;该策略是贪心的&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;\operatorname{Gain}(A)=\operatorname{Ent}(D)-\sum_{v=1}^{V} \frac{\left|D^{v}\right|}{|D|} \operatorname{Ent}\left(D^{v}\right)&#xD;&#xA;$$$$&#xD;&#xA;\operatorname{Ent}(D)=- \sum_{k=1}^{|\mathcal Y|}p_k\log_2p_k&#xD;&#xA;$$&lt;p&gt;&#xA;信息增益越大，意味着特征子集$A$包含的有助于分类的信息更多。于是，对每个候选特征子集，我们可基于训练数据$D$来计算其&lt;strong&gt;信息增益&lt;/strong&gt;，以此作为评价准则。&lt;/p&gt;&#xA;&lt;p&gt;更一般地，特征子集$A$实际上确定了对数据集$D$的一个划分，每个划分区域对应着$A$上的一个取值，而样本标记信息$Y$则对应着对$D$的真实划分，通过估算这两个划分的差异，就能对$A$进行评价。与$Y$对应的划分的差异越小，则说明$A$越好。信息熵仅是判断这个差异的一种途径，其他能判断两个划分差异的机制都能用于特征子集评价。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;将特征子集搜索机制与子集评价机制相结合，即可得到特征选择方法&lt;/strong&gt;。例如，&lt;strong&gt;将前向搜索与信息熵相结合，这与决策树算法非常相似&lt;/strong&gt;。事实上，决策树可用于特征选择，树结点的划分属性组成的集合就是选择出的特征子集。其他的特征选择方法未必像决策树特征选择这么明显，但其&lt;strong&gt;本质上都是显式或隐式地结合了子集搜索和子集评价机制&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;常见的特征选择方法大致可分为三类：&lt;strong&gt;过滤式(filter)、包裹式(wrapper)和嵌入式(embedding)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h3 id=&#34;过滤式选择&#34;&gt;过滤式选择&lt;/h3&gt;&#xA;&lt;p&gt;过滤式方法先对数据集进行特征选择，然后训练学习器，&lt;strong&gt;特征选择过程与后续学习器无关&lt;/strong&gt;。这相当于先用特征选择过程对初始特征进行过滤，再用过滤后的特征来训练模型。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;Relief&lt;/strong&gt;是一种著名的过滤式选择方法，该方法设计了一个“相关统计量”来度量特征的重要性。该统计量是一个向量，其每个分量分别对应于一个初始特征，而特征子集的重要性则是由子集中每个特征锁对应的相关统计量分量之和来决定。于是，最终只需指定一个阈值，然后选择比该阈值大的相关统计量分量对应的特征即可；也可指定欲选取的特征个数$k$，然后选择相关统计量分量最大的$k$个特征。&lt;/p&gt;&#xA;$$&#xD;&#xA;\delta^j=\sum_i -\operatorname{diff}(x_i^j,x_{i,nh}^j)^2+\operatorname{diff}(x_i^j,x_{i,nm}^j)^2&#xD;&#xA;$$&lt;p&gt;&#xA;其中，diff体现了两个样本对应属性的差异性，&lt;strong&gt;对于离散属性，我们可以取0/1，对连续属性，我们可以作差取绝对值&lt;/strong&gt;。我们可以看到，如果同类样本越近，异类样本越远，向量对应位置的值的统计量分量越大，也就是这个属性对分类越有用。&lt;/p&gt;&#xA;&lt;h3 id=&#34;包裹式选择&#34;&gt;包裹式选择&lt;/h3&gt;&#xA;&lt;p&gt;与过滤特征选择不考虑后续学习器不同，包裹式特征选择&lt;strong&gt;直接把最终将要使用的学习器的性能作为特征子集的评价标准&lt;/strong&gt;。一般而言，由于包裹式选择的直接性，它一般比过滤式的特征选择性能更好；但另一方面，由于在特征选择过程中需要多次训练学习器，因此包裹式特征选择的计算开销通常比过滤式特征选择大得多。&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;LVW(las vegas wrapper)算法&lt;/strong&gt;是一个典型的包裹式特征选择算法。它在拉斯维加斯算法(las vegas method)框架下使用随机策略来进行子集搜索，并以最终分类器的误差作为特征子集评价准则。该算法的具体做法是：&lt;/p&gt;&#xA;&lt;p&gt;(1) 设置初始最优误差$E$为无穷大，目前最优特征子集为属性全集$A$，重复次数$t=0$；&lt;/p&gt;&#xA;&lt;p&gt;(2) 随机产生一组特征子集$A&amp;rsquo;$，计算使用该特征子集时分类器的误差$E&amp;rsquo;$；&lt;/p&gt;&#xA;&lt;p&gt;(3) 如果$E&amp;rsquo;$比$E$小，则令$A&amp;rsquo;=A,E&amp;rsquo;=E$并重复(2)(3)步；否则$t++$，当$t$大于等于停止控制参数$T$时跳出循环。&lt;/p&gt;&#xA;&lt;p&gt;LVW算法简单明了，但是由于是使用随机子集筛选，并且每次筛选都要重新计算学习器误差，若$A$和$T$很大时，算法可能会长时间都达不到停止条件。即若有运行时间限制，则可能会得不到解。&lt;/p&gt;&#xA;&lt;h3 id=&#34;嵌入式选择与boldsymboll_1正则化&#34;&gt;嵌入式选择与$\boldsymbol{L_1}$正则化&lt;/h3&gt;&#xA;&lt;p&gt;在过滤式和包裹式特征选择方法中，特征选择过程与学习器训练过程由明显的分别。与此不同的是，&lt;strong&gt;嵌入式特征选择是将特征选择的过程与学习器训练过程融为一体&lt;/strong&gt;，两者在同一个优化过程中完成，即在学习器训练过程中自动地进行了特征选择。&lt;/p&gt;&#xA;&lt;p&gt;常用的正则化方法如$L_1$范数(LASSO回归)和$L_2$范数(岭回归)都有助于降低过拟合风险，但$L_1$范数还会有一个额外的好处：它比$L_2$范数更易于获得稀疏解，即它求得的$w$会有更少的非零分量。&lt;/p&gt;&#xA;&lt;p&gt;注意到$w$取得稀疏解意味着初始的$d$个特征中仅有对应着$w$的非零分量的特征才会出现在最终模型中，于是，求解$L_1$范数正则化的结果是得到了仅采用一部分初始特征的模型。换言之，基于$L_1$正则化的学习方法就是一种嵌入式特征选择方法，其特征选择过程与学习器训练过程融为一体，同时完成。&lt;/p&gt;&#xA;&lt;h3 id=&#34;稀疏表示与字典学习&#34;&gt;稀疏表示与字典学习&lt;/h3&gt;&#xA;&lt;p&gt;不妨把数据集$D$考虑为一个矩阵，&lt;strong&gt;其每一行对应一个样本，每一列对应一个特征&lt;/strong&gt;。特征选择锁考虑的问题是特征具有稀疏性，即矩阵中的许多列与当前学习任务无关，通过特征选择去除这些列，则学习器训练过程仅需在较小的矩阵上进行，学习任务的难度可能有所降低，设计的计算和存储开销会减小，学得模型的可解释性也会提高。&lt;/p&gt;&#xA;&lt;p&gt;考虑另一种稀疏性：$D$对应的矩阵中存在很多零元素，但这些零元素并不是以整行或整列的形式存在的。现实中有很多这种情况，比如文档分类任务中，若一个文档用词袋模型进行表示，矩阵的每一行都有大量的零元素，而对于不同的文档，这些零元素出现的列往往很不相同。&lt;/p&gt;&#xA;&lt;p&gt;然而，当样本具有这样的稀疏表达形式时，对学习任务来说会有不少好处。例如&lt;strong&gt;线性支持向量机之所以能在文本数据上有很好的性能，恰是由于文本数据在使用上述字频表示后具有高度的稀疏性，使大多数问题变得线性可分&lt;/strong&gt;。同时，稀疏性样本并不会造成存储上的负担，因为稀疏矩阵已经有很多高效的存储方法。&lt;/p&gt;&#xA;&lt;p&gt;那么，若给定的数据集$D$是稠密的，可以将其转化为适度的**稀疏表示(sparse representation)**形式，从而享有稀疏性带来的好处。&lt;/p&gt;&#xA;&lt;p&gt;显然，在一般的学习任务(例如图像分类)中并没有字典可用，我们需要学习出一个字典，为普通稠密表达的样本找到合适的字典，将样本转化为合适的稀疏表示形式，从而使学习任务得以简化，模型的复杂度得以降低，这个过程通常称为&lt;strong&gt;字典学习(dictionary learning)&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h3 id=&#34;scikit-learn实现几种特征选择方法&#34;&gt;scikit-learn实现几种特征选择方法&lt;/h3&gt;&#xA;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 1. 去除低方差特征&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.feature_selection&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;VarianceThreshold&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;],&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;],&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;],&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;],&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;],&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;[&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;]]&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;sel&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;VarianceThreshold&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;threshold&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;.8&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;1&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;-&lt;/span&gt; &lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;.8&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;sel&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;fit_transform&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;))&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 2. 单变量特征选择&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.datasets&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;load_iris&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.feature_selection&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;SelectKBest&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.feature_selection&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;chi2&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;load_iris&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;return_X_y&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;True&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;X_new&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;SelectKBest&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;chi2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;k&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;2&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;fit_transform&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X_new&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 3. 基于L1正则化的特征选择&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.svm&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;LinearSVC&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.datasets&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;load_iris&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.feature_selection&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;SelectFromModel&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;load_iris&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;return_X_y&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;True&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;lsvc&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;LinearSVC&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;C&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;0.01&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;penalty&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#4e9a06&#34;&gt;&amp;#34;l1&amp;#34;&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;dual&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;False&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;fit&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;model&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;SelectFromModel&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;lsvc&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;prefit&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;True&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;X_new&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;model&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;transform&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X_new&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#8f5902;font-style:italic&#34;&gt;# 4. 基于树结构的特征选择&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.ensemble&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;ExtraTreesClassifier&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.datasets&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;load_iris&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;from&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;sklearn.feature_selection&lt;/span&gt; &lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;import&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;SelectFromModel&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;load_iris&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;return_X_y&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;True&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;clf&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;ExtraTreesClassifier&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;n_estimators&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#0000cf;font-weight:bold&#34;&gt;50&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;clf&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;clf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;fit&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;y&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;clf&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;feature_importances_&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;model&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;SelectFromModel&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;clf&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;,&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;prefit&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#204a87;font-weight:bold&#34;&gt;True&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#000&#34;&gt;X_new&lt;/span&gt; &lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#000&#34;&gt;model&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;transform&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#204a87&#34;&gt;print&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;(&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;X_new&lt;/span&gt;&lt;span style=&#34;color:#ce5c00;font-weight:bold&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#000&#34;&gt;shape&lt;/span&gt;&lt;span style=&#34;color:#000;font-weight:bold&#34;&gt;)&lt;/span&gt;&#xA;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;参考资料&#34;&gt;参考资料&lt;/h3&gt;&#xA;&lt;ul&gt;&#xA;&lt;li&gt;周志华. 机器学习. 北京: 清华大学出版社, 2016.&lt;/li&gt;&#xA;&lt;/ul&gt;</description>
    </item>
    <item>
      <title>话题模型</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml14-%E8%AF%9D%E9%A2%98%E6%A8%A1%E5%9E%8B/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml14-%E8%AF%9D%E9%A2%98%E6%A8%A1%E5%9E%8B/</guid>
      <description>&lt;h3 id=&#34;单词向量空间与话题向量空间&#34;&gt;单词向量空间与话题向量空间&lt;/h3&gt;&#xA;&lt;p&gt;&lt;strong&gt;潜在语义分析(latent semantic analysis, LSA)&lt;/strong&gt; 是一种无监督学习方法，主要用于文本的话题分析，其特点是通过&lt;strong&gt;矩阵分解&lt;/strong&gt;发现&lt;strong&gt;文本与单词之间基于话题的语义关系&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;文本信息处理中，传统的方法以&lt;strong&gt;单词向量&lt;/strong&gt;表示文本的语义内容，以&lt;strong&gt;单词向量空间的度量&lt;/strong&gt;表示&lt;strong&gt;文本之间的语义相似度&lt;/strong&gt;。潜在语义分析旨在解决这种方法不能准确表示语义的问题，试图从大量的文本数据中发现&lt;strong&gt;潜在的话题&lt;/strong&gt;，以话题向量表示文本的语义内容，以话题向量空间的度量更准确地表示文本之间的语义相似度。这也是&lt;strong&gt;话题分析(topic modeling)的基本想法&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;p&gt;LSA首先将文本集合表示为&lt;strong&gt;单词-文本矩阵&lt;/strong&gt;，对单词-文本矩阵进行&lt;strong&gt;奇异值分解&lt;/strong&gt;，从而得到&lt;strong&gt;话题向量空间&lt;/strong&gt;，以及&lt;strong&gt;文本在话题向量空间的表示&lt;/strong&gt;。&lt;/p&gt;&#xA;&lt;h4 id=&#34;单词向量空间&#34;&gt;单词向量空间&lt;/h4&gt;&#xA;&lt;p&gt;信息检索、文本数据挖掘等领域的一个核心问题是对文本的语义内容进行表示，并进行文本之间的语义相似度计算。最简单的办法是&lt;strong&gt;向量空间模型(vector space model)&lt;/strong&gt;：用一个向量表示&lt;strong&gt;某一文本的“语义”&lt;/strong&gt;，向量的每一维对应一个单词，其数值为单词在文本中出现的频数或权值。如此一来，文本集合中的每个文本都表示为一个向量，存在于一个向量空间，文本间的内积表示文本相似度。&lt;/p&gt;&#xA;$$&#xD;&#xA;X=\left[\begin{array}{cccc}&#xD;&#xA;x_{11} &amp; x_{12} &amp; \cdots &amp; x_{1 n} \\&#xD;&#xA;x_{21} &amp; x_{22} &amp; \cdots &amp; x_{2 n} \\&#xD;&#xA;\vdots &amp; \vdots &amp; &amp; \vdots \\&#xD;&#xA;x_{m 1} &amp; x_{m 2} &amp; \cdots &amp; x_{m n}&#xD;&#xA;\end{array}\right]&#xD;&#xA;$$&lt;p&gt;&#xA;其中$x_{ij}$表示&lt;strong&gt;单词&lt;/strong&gt;$w_i$在&lt;strong&gt;文本&lt;/strong&gt;$d_j$中再出现的频数或权值，&lt;strong&gt;矩阵的一列对应一个文本&lt;/strong&gt;。由于单词的种类很多，而每个文本中出现单词的种类通常较少，因此该矩阵是一个&lt;strong&gt;稀疏矩阵&lt;/strong&gt;。&lt;/p&gt;&#xA;$$&#xD;&#xA;T F_{w}=\frac{\text {给定词} w \text {出现的次数}}{\text {文章的总次数}} \quad I D F_{w}=\log \left(\frac{\text {语料库文章的总数}}{\text {包含关键词} w \text {的文章数量}+1}\right) \quad TF-IDF=TF \times IDF&#xD;&#xA;$$&lt;p&gt;&#xA;直观上，&lt;strong&gt;一个单词在一个文本中出现的频数越高，这个单词在这个文本中的重要程度就越高&lt;/strong&gt;；&lt;strong&gt;一个单词在整个文本集合中出现的文本数越少，这个单词就越能表示其所在文本的特点，重要度就越高&lt;/strong&gt;。TF-IDF是两种重要度的积，表示综合重要度。&lt;/p&gt;</description>
    </item>
    <item>
      <title>概率图模型</title>
      <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml15-%E6%A6%82%E7%8E%87%E5%9B%BE%E6%A8%A1%E5%9E%8B/</link>
      <pubDate>Sun, 01 Jan 2017 00:00:00 +0000</pubDate>
      <guid>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/ml15-%E6%A6%82%E7%8E%87%E5%9B%BE%E6%A8%A1%E5%9E%8B/</guid>
      <description>&lt;h3 id=&#34;概率图模型概述&#34;&gt;概率图模型概述&lt;/h3&gt;&#xA;&lt;div align=&#34;center&#34;&gt;&#xD;&#xA;&lt;img src=&#34;https://knove-ai.github.io/images/2/image-20200818114353404.png&#34; style=&#34;zoom:40%;&#34; /&gt;&#xD;&#xA;&lt;/div&gt;&#xD;&#xA;&lt;p&gt;&lt;strong&gt;概率图模型(probabilistic graphical model, PGM)&lt;/strong&gt;，简称图模型(graphical model, GM)，是指一种&lt;strong&gt;用图结构来描述多元随机变量之间条件独立关系的概率模型&lt;/strong&gt;，从而给研究&lt;strong&gt;高维空间中的概率模型&lt;/strong&gt;带来了很大的便捷性。&lt;/p&gt;&#xA;&lt;p&gt;对于一个$K$维随机向量$\boldsymbol X=[X_1,X_2,\cdots,X_K]^\text T$，其联合概率为高维空间中的分布，一般难以直接建模。假设每个变量为离散变量并有$m$个取值，在不作任何独立假设条件下，则需要个$m^K-1$参数才能表示其概率分布，当$m$和$K$很大时，参数量远远超出了目前计算机的存储能力。&lt;/p&gt;&#xA;$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;p(\boldsymbol{x}) &amp; \triangleq P(\boldsymbol{X}=\boldsymbol{x}) \\&#xD;&#xA;&amp;=p\left(x_{1}\right) p\left(x_{2} \mid x_{1}\right) \cdots p\left(x_{K} \mid x_{1}, \cdots, x_{K-1}\right) \\&#xD;&#xA;&amp;=\prod_{k=1}^{K} p\left(x_{k} \mid x_{1}, \cdots, x_{k-1}\right)&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;其中$x_k$表示变量$X_k$的取值。如果&lt;strong&gt;某些变量之间存在条件独立&lt;/strong&gt;，其参数量就可以大幅减少。&lt;/p&gt;&#xA;$$&#xD;&#xA;p(x_{2} | x_{1}, x_{3})=p(x_{2} | x_{1}) \\&#xD;&#xA;p(x_{3} | x_{1}, x_{2})=p(x_{3} | x_{1})&#xD;&#xA;$$$$&#xD;&#xA;p(x_{4} | x_{1}, x_{2}, x_{3})=p(x_{4} | x_{2}, x_{3})&#xD;&#xA;$$$$&#xD;&#xA;\begin{aligned}&#xD;&#xA;p(\boldsymbol{x}) &amp;=p(x_{1}) p(x_{2} | x_{1}) p(x_{3} | x_{1}, x_{2}) p(x_{4} | x_{1}, x_{2}, x_{3}) \\&#xD;&#xA;&amp;=p(x_{1}) p(x_{2} | x_{1}) p(x_{3} | x_{1}) p(x_{4} | x_{2}, x_{3})&#xD;&#xA;\end{aligned}&#xD;&#xA;$$&lt;p&gt;&#xA;是4个局部条件概率的乘积。如果分别用4个表格来记录这4个条件概率的话，只需要1 + 2 + 2 + 4 = 9个独立参数。&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
