<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>2-机器学习 on 知予AI</title>
    <link>https://knove-ai.github.io/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/</link>
    <description>Recent content in 2-机器学习 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/2-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/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/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/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>感知机</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/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/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/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/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>
