分类器的作用：常规任务是利用给定的类别、已知的训练数据来学习分类规则和分类器，然后对未知数据进行分类（或预测）。逻辑回归（logistics）、SVM等常用于解决二分类问题，对于多分类问题（multi-class classification），比如识别手写数字，它需要10个分类，同样也可以用逻辑回归或SVM，只是需要多个二分类来组成多分类，但这样容易出错且效率不高，常用的多分类方法有softmax。 
 
分类算法：划分为了两类
 
1.基于概率密度的方法和基于判别函数的方法。
 
基于概率密度的分类算法通常借助于贝叶斯理论体系，采用潜在的类条件概率密度函数的知识进行分类； 在基于概率密度的分类算法中，有著名的贝叶斯估计法、最大似然估计，这些算法属于有参估计，需要预先假设类别的分布模型，然后使用训练数据来调整概率密度中的各个参数。另外，如 Parzen窗、Kn邻近等方法属于无参估计，此类方法可从训练样本中直接估计出概率密度。 基于判别函数的分类方法使用训练数据估计分类边界完成分类，无需计算概率密度函数。
基于判别函数的方法则假设分类规则是由某种形式的判别函数表示，而训练样本可用来表示计算函数中的参数，并利用该判别函数直接对测试数据进行分类。此类分类器中，有著名的感知器方法、最小平方误差法、SVM法、神经网络方法以及径向基(RBF)方法等。
2.根据监督方式划分分类算法，分类学习问题可分为三大类：有监督分类、半监督分类和无监督分类。
 
有监督分类是指用来训练分类器的所有样本都经过了人工或其他方式的标注，有很多著名的分类器算法都属于有监督的学习方式，如AdaBoost[51]，SVM，神经网络算法以及感知器算法。
无监督分类是指所有的样本均没有经过标注，分类算法需利用样本自身信息完成分类学习任务，这种方法通常被称为聚类，常用的聚类算法包括期望最大化（EM）算法和模糊C均值聚类算法等。
半监督分类指仅有一部分训练样本具有类标号，分类算法需要同时利用有标号样本和无标号样本学习分类，使用两种样本训练的结果比仅使用有标注的样本训练的效果更好。这类算法通常由有监督学习算法改进而成，如SemiBoost、流形正则化、半监督SVM等。
Softmax分类
 
Softmax 函数的定义如下所示：
 
 
其中，Vi 是分类器前级输出单元的输出。i 表示类别索引，总的类别个数为 C。Si 表示的是当前元素的指数与所有元素指数和的比值。Softmax 将多分类的输出数值转化为相对概率，更容易理解和比较。
 
使用softmax激励函数作为输出层的多层感知机，卷积层和池化层每个的输出代表高级特征，目的是用这些特征进行分类。加入全连接层也是学习特征之间非线性组合的有效办法。卷积层和池化层提取出来的特征很好，但是如果考虑这些特征之间的组合，就更好了。
 
Softmax函数把任意实值的向量转变成元素取之0到1且和为1的向量。将多个神经元的输出，映射到（0,1）区间内，可以看成概率来理解，从而来进行多分类。
 
 

  
 
logistic分类器
 
以Bernoulli（伯努利） 分布为模型建模的，顾名思义，逻辑分类，是一种二分类法，能将数据分成0和1两类。logistic分类的流程比较简单，主要有线性求和，sigmoid函数激活，计算误差，修正参数这4个步骤。前两部用于判断，后两步用于修正。
 
线性求和以及sigmoid函数 
 
假设有一个n维的输入列向量 x，也有一个n维的参数列向量h， 还有一个偏置量b， 那么就可以线性求和得到z
 
 
此时因为z的值域是[−∞,+∞] ，是无法根据z来判断x 到底是属于0还是1的。因此我们需要一个函数，来将z的值映射到[0,1]之间， 这就是激活函数。激活函数有很多种，这里的激活函数是sigmoid函数。
 
 
sigmoid函数形状为
 
 
可以看到它是介于0~1之间。那么在判断的时候，首先对之前得到的z代入sigmoid函数
 
 
当 a 大于0.5的时候，我们判定x应属于1类，如果小于0.5，则属于0类。这样，就完成了判断的工作 。
 
详细过程：https://www.cnblogs.com/yinheyi/p/6131262.html
 
误差计算以及参数修正 
 
上面完成的判断过程中用到了参数向量h和偏置量b。 可以说，h和b的值直接关系到logistic判断的准确性。那么这两组参数是如何获得的呢？这就涉及到了参数的修正。在最开始的时候，h中的值是随机的，而b的值是0. 我们通过不断的训练来使得h和b能够尽可能的达到一个较优的值。
 
那么如何训练呢？假设我们期望输入x的判定是y，而实际得到的判定值是a，那么我们定义一个损失函数C(a,y)，通过修正h和b的值来使得C最小化，这是一个优化问题。在凸优化问题中，可以通过
 
 
来直接算得h和b的最优解。然而在某些情况下，例如数据规模很大，或者非凸优化问题中，则不能这么做，而是用迭代的方法来得到局部最优解。
 
 
其中 η 表示学习率。在这里，损失函数定为平方损失函数，即
 
 
那么可以得到
 
 
这样，就能够得到每次迭代的参数更新公式为
 
 
将logistic扩展到多分类 
 
从之前可以看出，普通的logistic只能进行二分类，即只能够分为0或者1。那么如果这些样本属于多个类该怎么办呢？人们想了很多办法，例如一对多法，依次把某个类别的样本归为一类，其他剩余的样本归为另一类，这样k个类需要构建k个分类器。还有一对一法，在任意两类样本之间设计一个分类器，k个类需要k(k-1)/2个分类器。
 
在这里，我们将输出由一个值更改为一个向量。例如有3个类，那么输出就是一个长度为3 的列向量，对应项的值为1，其他为0。即
 
 
分别表示第0,1,2个类。 也可以看成是原来若干个logistic分类器组合在一起。对应的某个分类器只对该类输出1，其他情况都输出0.从这一点上来讲，这个做法有点类似于一对多法。此时，由于输出从一个数成为一个向量，之前的公式都要加以修改。首先，原来的y,a,z,b变成了列向量， 向量hh变成了矩阵W。这样，判断部分的公式变为
 
 
此时的 σ 函数表示对向量中的每一个元素单独做运算。即
 
 
得到的a向量中，其最大值所在的位置索引即为判断出的分类。 参数修正部分的公式也是类似的，
 
 
注意有些向量之间是进行点乘的。 
 
Boosting
 
顾名思义，是提升的意思。弱分类器转化为强分类器---原理即三个臭皮匠，赛过诸葛亮一样。把很多分类准确率很低的分类器通过更新对数据的权重，集成起来形成一个分类效果好的分类器。
 
它是一种框架算法，先从初始训练集训练出一个基学习器，再根据基学习器的表现对训练样本分布进行调整，使得先前基学习器做错的训练样本在后续受到更多的关注，然后基于调整后的样本分布来训练下一个基学习器；如此重复进行，直至基学习器数目达到事先指定的值T，最终将这T个基学习器进行加权结合。
 
一般来说，找到弱学习算法要相对容易一些，然后通过反复学习得到一系列弱分类器，组合这些弱分类器得到一个强分类器。Boosting算法要涉及到两个部分，加法模型和前向分步算法。加法模型就是说强分类器由一系列弱分类器线性相加而成。一般组合形式如下：
 
 
其中，h(x;am)是一个个的弱分类器，am是弱分类器学习到的最优参数，βm是弱学习在强分类器中所占比重，P是所有am和βm的组合，这些弱分类器线性相加组成强分类器。
 
前向分步就是说在训练过程中，下一轮迭代产生的分类器是在上一轮的基础上训练得来的。也就是可以写成这样的形式：
 
 
由于采用的损失函数不同，Boosting算法有很多不同的类型，其中比较经典的有AdaBoost，其损失函数为指数损失的。
 
Adaboost
 
Boosting有一个重大缺陷，即该算法要求事先知道弱分类算法分类正确率的下限，这在实际问题中很难做到。
 
Adaptive Boosting，自适应增强。它的自适应在于：前一个基本分类器分错的样本会得到加强，加权后的全体样本再次被用来训练下一个基本分类器。同时，在每一轮中加入一个新的弱分类器，直到达到某个预定的足够小的错误率或达到预先指定的最大迭代次数。
 
Adaboost 迭代算法分为3步：
 
初始化训练数据的权值分布。如果有N个样本，则每个训练样本最开始时都被赋予相同的权值：1/N；
训练弱分类器。具体训练过程中，如果某个样本点已经被准确地分类，那么在构造下一个训练集中，它的权值就被降低；相反，如果某个样本点没有被准确地分类，那么它的权值就得到提高。然后权值更新过的样本集被用于训练下一个分类器，整个训练过程如此迭代地进行下去；
将各个训练得到的弱分类器组合成强分类器。各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，使其在最终的分类函数中起着较大的决定作用，而降低分类误差率大的弱分类器的权重，使其在最终的分类函数中起着较小的决定作用。换言之，误差率低的弱分类器在最终分类器中占的权重较大，否则较小。
算法流程
 
给定一个训练数据集T={(x1,y1), (x2,y2)…(xN,yN)}，其中实例，而实例空间，yi属于标记集合{-1,+1}，Adaboost的目的就是从训练数据中学习一系列弱分类器或基本分类器，然后将这些弱分类器组合成一个强分类器。
 
算法流程如下：
 
1.初始化训练数据的权值分布。每一个训练样本最开始时都被赋予相同的权值：1/N。
 
 
2.进行多轮迭代，用m = 1,2, ..., M表示迭代的第多少轮
 
a.使用具有权值分布Dm的训练数据集学习，得到基本分类器（选取让误差率最低的阈值来设计基本分类器）：
 
 
  b.计算Gm(x)在训练数据集上的分类误差率
 
 
   由上述式子可知，Gm(x)在训练数据集上的误差率em就是被Gm(x)误分类样本的权值之和。
 
  c.计算Gm(x)的系数，am表示Gm(x)在最终分类器中的重要程度（目的：得到基本分类器在最终分类器中所占的权重）：        
 
 
   由上述式子可知，em≤1/2时，am≥0，am随em减小而增大，分类误差率越小的基本分类器在最终分类器中的作用越大。
 
  d.更新训练数据集的权值分布（目的：得到样本的新的权值分布），用于下一轮迭代。
 
                  
 
  使得被基本分类器Gm(x)误分类样本的权值增大，而被正确分类样本的权值减小，重点关注或聚焦于那些较难分的样本上。
 
    其中，Zm是规范化因子，使得Dm+1成为一个概率分布：
 
                                                          
 
3.组合各个弱分类器
 
 
从而得到最终分类器，如下： 
 
 
实例
 
有如下的训练样本，我们需要构建强分类器对其进行分类。x是特征，y是标签。
 
 
令权值分布D1=(w1,1,w1,2,…,w1,10)
 
并假设一开始的权值分布是均匀分布：w1,i=0.1，i=1,2,…,10w1,i=0.1，i=1,2,…,10
 
现在开始训练第一个弱分类器。发现阈值取2.5时分类误差率最低，得到弱分类器为：
 
 
当然，也可用别的弱分类器，只要误差率最低即可。这里为了方便，用了分段函数。得到了分类误差率e1=0.3。
 
第二步计算G1(x)在强分类器中的系数
 
 
第三步更新样本的权值分布，用于下一轮迭代训练。由公式：
 
 
得到新的权值分布，从各0.1变成了:
 
 
可以看出，被分类正确的样本权值减小了，被错误分类的样本权值提高了。
 
第四步得到第一轮迭代的强分类器：
 
 
以此类推，经过第二轮……第N轮，迭代多次直至得到最终的强分类器。迭代范围可以自己定义，比如限定收敛阈值，分类误差率小于某一个值就停止迭代，比如限定迭代次数，迭代1000次停止。这里数据简单，在第3轮迭代时，得到强分类器：
 
 
的分类误差率为0，结束迭代。
 
F(x)=sign(F3(x))就是最终的强分类器。
 
SVM
 
借鉴博客：https://blog.csdn.net/mm_bit/article/details/46988925
 
线性核SVM：一般应用于多分类，分类的结果（如3分类）最后会给出（约等于）1、2、3的值代表第1、2、3类
非线性核SVM：一般应用于二分类问题上
support vector machines，支持向量机，是一个二分类的分类模型（经改造后也可用于多分类，但比较复杂）。分类的思想是，给定给一个包含正例和反例的样本集合，其目的是寻找一个超平面来对样本根据正例和反例进行分割，寻找一个超平面，使得离超平面比较近的点能有更大的间距。也就是我们不考虑所有的点都必须远离超平面，我们关心求得的超平面能够让所有点中离它最近的点具有最大间距。
 
优点：
 
在解决小样本、非线性及高维模式识别中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中。
 
如下面3个图，分类图1中的两类球，很简单，用一根棍子即可；但图2中一条直线貌似不能完成分类的任务，可以想象就像武侠片的大侠一样，拍下桌子，球飞到空中。然后，大侠抓起一张纸，插到了两种球的中间，如图2右边的部分；从直观的角度看这些球像是被一条曲线分开了，如图3。其中这些球叫做【data】，棍子叫做【classifier】, 最大间隙trick叫做【optimization】， 拍桌子叫做【kernelling】，那张纸叫做【hyperplane】。
 
 
 
 
如果一个线性函数能够将样本完全正确的分开，就称这些数据是线性可分的，否则称为非线性可分的。线性函数在一维空间里就是一个点，在二维空间里就是一条直线，三维空间里就是一个平面，如果不关注空间的维数，这种线性函数叫做超平面（Hyper Plane）。在样本空间中，划分超平面可通过如下线性方程来描述：
 
                                                              
 
假设它已经完成了对样本的分隔，且两种样本的标签分别是{+1，-1}，那么对于一个分类器来说，g(x)>0和个g(x)<0就可以分别代表两个不同的类别，+1和-1。
 
但光是分开是不够的，SVM的核心思想是尽最大努力使分开的两个类别有最大间隔，这样才使得分隔具有更高的可信度。而且对于未知的新样本才有很好的分类预测能力（在机器学习中叫泛化能力），SVM让间隔最大的办法是：让离分隔面最近的数据点具有最大的距离。为了描述离分隔超平面最近的数据点，需要找到两个和这个超平面平行和距离相等的超平面：
 
                                                    H1: y = wTx + b=+1 和 H2: y = wTx + b=-1
 
 
在这两个超平面上的样本点也就是理论上离分隔超平面最近的点，是它们的存在决定了H1和H2的位置，支撑起了分界线，它们就是所谓的支持向量，这就是支持向量机的由来。
 
由两个超平面就可以定义上面提到的间隔（margin）了，二维情况下 ax+by=c1和ax+by=c两条平行线的距离公式为：
 
 
可以推出H1和H2两个超平面的间隔为2/||w||，即现在的目的是要最大化这个间隔。所以support vector machine又叫Maximum margin hyper plane classifier（最大间隔超平面分类器），等价于最小化||w||，为了之后的求导和计算方便，进一步等价于最小化  。
 
假设超平面能将样本正确分类，则可令：
 
 
 
两个式子综合一下有：
 
 
 
这就是目标函数的约束条件。现在这个问题就变成了一个最优化问题：
 
 
而且这是一个凸二次规划问题，一般的解决方法有两种1是用现成的优化工具包直接求解，2是使用Lagrange Duality找到一种更有效的方法求解。
 
 实例
 
svm的输入是一组向量以及每个向量对应的分类：
 label，一般是-1或1，表示种类；
 index：value， 向量值，如 1:0.78, 2:1, 3:-0.52, 4:-0.35, 5:0.56, 一般用一个一维数组表示
 数据准备成上述格式，随机分成2份，一份用来训练模型，一份用来测试模型的准确性，以便根据测试结果调整训练参数。在线性不可分的情况下，使用RBF核效果比较好，现在很多软件可以自动完成这个对比、选择过程。

 比如用svm进行垃圾邮件识别，大概步骤如下：
 对邮件进行打标，垃圾邮件标为1，非垃圾邮件标为-1。对邮件内容进行分词，对每个词计算特征权重，然后通过归一化转化成-1到1之间的值，选择一个svm实现lib或软件，将准备好的这些向量和label带入训练，调整参数得到效果满足要求的模型。
 
 

 
 
贝叶斯推理提供了一种概率（主要应用条件概率）学习手段，根据以往数据的概率分布和已观察到的数据进行推理判断。对数据量大的问题十分适用，在云计算和大数据时代再次成为研究热点。贝叶斯分类器分成两个部分，第一部分对基础知识、贝叶斯决策论、极大似然估计、朴素贝叶斯分类器和半朴素贝叶斯分类器进行介绍，第二部分对贝叶斯网进行详细介绍。本文是对周志华老师的《机器学习》第七章贝叶斯分类器，进行了学习和分析，相当于一篇学习笔记，因此引用了的部分不再进行标注，在文章的最后给出了本文的参考文献。由于作者水平有限错误之处在所难免，望批评指正。
 
 
0. 基本知识
 
为了能更好的理解贝叶斯分类器，本节首先讲述有关概率的基础知识，为后面概率的推到打下基础。
 
加法公式 
 对于任意两个事件$A，B$，有 $P(A\cup B)=P(A)+P(B)-P(A\cap B)$ 
 加法公式的示例如图0.1所示，图0.2将$AUB$分成两两不相容的三个事件$I、II、III$，则有， 
 $A\cup B=I\cup II\cup III,$ 
 $A = I\cup II ,$ 
 $B = II\cup III,$ 
 于是，
   $$P(A\cup B)=P(I)+P(II)+P(III)=P(A)+P(B)-P(A\cap B).$$  
  
 图0.1 两个事件的并事件 
  
 图0.2 $A\cup B$分成两两不相容的三个事件
乘法公式与条件概率 
 事件$A，B$ 同时发生的概率是： 
 $P(A\cap B)=P(A)P(B|A)=P(B)P(A|B)$ 
 公式中的 $P(A|B)$是指在事件$B$条件下事件$A$发生的概率，又称作条件概率。 
  
 图0.3 两个事件的交事件
贝叶斯法则 
 由$P(A\cup B)=P(B|A)P(A)= P(A|B)P(B)$立得, 
 $P(B|A) = \frac{P(A|B)P(B)}{P(A)}$ 
 在机器学习中我们通常写为： 
 $P(h|D) = \frac{P(D|h)P(h)}{P(D)}$ 
 用$P(h)$表示在没有训练数据前假设$h$拥有的初始概率。$P(h)$被称为h的先验概率。先验概率反映了关于h是一正确假设的机会的背景知识。 
 机器学习中，我们关心的是$P(h|D)$，即给定D时h的成立的概率，称为h的后验概率。
全概率公式 
 设S是实验E的样本空间，$B_{1},B_{2},...,B_{n}$是E的n个两两不相容的时间，且有$B_{1}\cup B_{2}\cup ...\cup B_{n} = S$，也就是说S划分成n个两两不相容的时间：$B_{1},B_{2},...,B_{n}.$ 
 又若A是实验E的任一事件，则有
   $$A=AS=A(B_{1}\cup B_{2}\cup ...\cup B_{n})=AB_{1}\cup AB_{2}\cup ...A\cup B_{n}$$  
 其中 
 这样就将A分成n个两两不相容的事件：$AB_{1},AB_{2},...,AB_{n}.$设P(B_{i})>0(i=1,2,…,n)，就有
   $$P(A)=\sum_{i=1}^{n}P(AB_{i})=\sum_{i=1}^{n}P(A|B_{i})P(B_{i})$$ 我们称上述公式为全概率公式。 
 
 
1. 贝叶斯决策论
 
有了第0节的基础概率知识之后，本节开始介绍贝叶斯决策论（Bayesian decision theory）。贝叶斯决策论是概率框架下实施决策的基本方法。 
 设有N 种可能的类别标记，即$Y={c_{1},c_{2},...,c_{N}}$，则基于后验概率$P(c_i|x)$可获得将样本x分类为$c_{i}$所产生的期望损失（也称条件风险）为： 
 
 $$R(c_{i}|x)=\sum_{j=1}^{N}\lambda_{ij}P(c_{j}|x)\tag{1.1}$$ 其中

$\lambda_{ij}$是将一个真实标记为

$c_{j}$标记成为

$c_{i}$产生的损失. 

 我们的目的是寻找一个方法使得条件风险最小化。为最小化总体风险，只需在每个样本上选择哪个能是条件风险

$R(c|x)$最小化的类别标记，即

 $$h^{*}(x)=\arg{min}_{c\in Y}R(c|x)\tag{1.2}$$ 这就是贝叶斯判定准则（Bayes decision rule）。 

 若目标是最小化分类错误率，则条件风险为

 $$R(c|x)=1-P(c|x)\tag {1.3}$$ 其中

$\lambda_{ij}$为0/1损失函数。 

 所以，最小化分类错误率的贝叶斯最优分类器为

 $$h^{*}(x)=\arg{max}_{c\in Y}P(c|x)\tag {1.4}$$ 也就是对每个样本x，选择能使后验概率

$P(c|x)$最大的类别标记。 

 通常情况下

$P(c|x)$很难直接获得，根据我们已知的条件概率知识对公式1.4进行化简得

 $$\\h^{*}(x)=\arg{max}_{c\in Y}P(c|x)=\arg{max}_{c\in Y}\frac{P(x|c)P(c)}{P(x)}
=\arg{max}_{c\in Y}{P(x|c)P(c)}\tag {1.5}$$ 其中P(c)为
先验概率，

$P(x|c)$为样本x关于类别c的条件概率。这就是后验概率最大化准则。这样一来，根据期望风险最小化原则就可以得到后验概率最大化准则。 

 在某些情况下，可假定Y中每个假设有相同的先验概率，这样式子1.5可以进一步简化为公式1.6，只需考虑P(x|c)来寻找极大可能假设。

 $$h^{*}(x)=\arg{max}_{c\in Y}{P(x|c)}\tag {1.6}$$  

 综合以上讨论，当前求最小化分类错误率的问题转化成了求解先验概率P(c)和条件概率（也称似然概率）

$P(x|c)$的估计问题。对于先验概率P(c)表达了样本空间中各类样本所占的比例，根据大数定理，当训练集包含充足的独立同分布样本时，P(c)可以通过各类样本出现的频率进行估计。整个问题就变成了求解条件概率

$P(x|c)$的问题。
 
2. 极大似然估计
 
极大似然轨迹源自于频率学派，他们认为参数虽然未知，但却是客观存在的规定值，因此，可以通过优化似然函数等准则确定参数数值。本节使用极大似然估计对条件概率进行估计。 
 令$D_{c}$表示训练集D中第c类样本组成的集合，假设这些样本是独立同分布的，则参数$\theta$（$\theta$是唯一确定条件概率$P(x|c)$的参数向量）对数据集$D_{c}$的似然函数是
 $$P(D_{c}|\theta )=\prod_{x\in D_{c}}P(x|\theta )\tag {2.1}$$  

 对2.1求对数似然函数

 $$L(\theta )=logP(D_{c}|\theta )=log\prod_{x\in D_{c}}P(x|\theta )=\sum_{x\in D_{c}}logP(x|\theta )\tag {2.2 }$$  

 因此求得

$\theta$的极大似然估计

$\hat{\theta }$为

 $$\hat{\theta }=\arg{max}_{\theta }L(\theta )\tag {2.3}$$  

 使用极大似然估计方法估计参数虽然简单，但是其结果的准确性严重依赖于每个问题所假设的概率分布形式是否符合潜在的真实数据分布，可能会产生误导性的结果。
 
3. 朴素贝叶斯分类器
 
从前面的介绍可知，使用贝叶斯公式来估计后验概率最大的困难是难以从现有的训练样本中准确的估计出条件概率$P(x|c)$的概率分布。朴素贝叶斯分类器为了避开这个障碍，朴素贝叶斯方法对条件概率分布作了条件独立性的假设。具体地，条件独立性假设是
 $$P(x|c)=\prod_{i=1}^{d}P(x_{i}|c)\tag {3.1}$$  有了条件概率的简化条件之后，我们很容易将公式1.5的贝叶斯准则改写为

 $$h^{*}(x)=\arg{max}_{c\in Y}P(c|x)
=\arg{max}_{c\in Y}P(c)\prod_{i=1}^{d}P(x_{i}|c)\tag {3.2}$$  

 公式3.2就是著名的朴素贝叶斯的表达式。 

 下面对先验概率P(c)和条件概率

$P(x_{i}|c)$进行极大似然估计求得后验概率。 

 令

$D_{c}$表示训练集D中第c类样本组成的集合，先验概率的似然估计为 

 

 $$P(c)= \frac{\left |D_{c} \right |}{\left |D\right |}\tag {3.3}$$  

 对于离散属性而言，令

$D_{c,x_{i}}$表示

$D_{c}$中在第i个属性上取值为

$x_{i}$的样本组成的集合，则条件概率

$P(x|c)$的似然估计为 

 

 $$P(x|c)=\frac{\left |D_{c,x_{i}}\right |}{\left |D_{c}\right |}\tag {3.4}$$  

 而对于连输属性需要考虑其密度函数。 

 朴素贝叶斯分类算法主要分成如下三步：
 
计算先验概率P(c)和条件概率P(x|c)
计算后验概率$P(c|x)=P(c)\prod_{i=1}^{d}P(x_{i}|c)$
确定实例x的类$h^{*}(x)=\arg{max}_{c\in Y}P(c)\prod_{i=1}^{d}P(x_{i}|c)$
 
拉普拉斯平滑：使用极大似然估计可能会出现所要估计的概率值为0的情况，这样会影响到后验概率的结果，最终使得推荐分类产生偏差。使用贝叶斯估计而已解决这一问题。具体地，条件概率的贝叶斯估计是
 $$P_{\lambda }(x|c)=\frac{\left |D_{c}\right | + \lambda }{{\left |D_{c}\right | }+ N_{c}*\lambda }\tag {3.5}$$  

 当

$\lambda = 1$时称为拉普拉斯平滑（Laplace smoothing）。 

 同样先验概率的贝叶斯轨迹为

 $$P_{\lambda }(c)=\frac{\left |D_{c,x_{i}}\right | + \lambda}{\left |D\right | +N* \lambda}\tag {3.6}$$  

 显然，拉普拉斯平滑修正了因训练集样本不充分造成的概率为0的问题，并且在训练集变大时，估计值也逐渐趋向于实际的概率值。
 
4. 半朴素贝叶斯分类器
 
在现实任务中朴素贝叶斯的假设条件（属性条件独立）往往不成立，因此，在评估实际问题时朴素贝叶斯方法往往失去了部分精度，所以人们尝试对属性的独立性进行一定程度的放松，由此产生了半朴素贝叶斯分类器的学习方法。 
 半朴素贝叶斯分类器的基本思想是适当考虑一部分属性之间的相互依赖关系，从而既不需要完全联合概率计算，又不至于彻底忽略了比较强的属性依赖关系。 
 独立依赖估计是半朴素贝叶斯分类器最常用的一种策略，也就是假设每个属性在类别之 外最多依赖于一个 其他属性，即
 $$P(c|x)\propto P(c)\prod_{i=1}^{d}P(x_{i}|c,pa_{i})\tag {4.1}$$ 其中

$pa_{i}$为

$x_{i}$所依赖的属性，称为

$x_{i}$的父属性。由于作者对半朴素贝叶斯的理解有限，下面就简单的介绍几种常见的半朴素贝叶斯分类器，对于细节不再进行展开，如果想了解更多半朴素贝叶斯分类器的朋友可以参考书籍[1]。图4.1给出了朴素贝叶斯属性间的依赖关系（图4.1（a））、SPODE属性间的依赖关系（图4.1（b））和TAN属性间的依赖关系（图4.1（c））。 

 
 

 图4.1 属性依赖关系（图片来源于[1]）
 
SPODE(Super-Parent ODE)（超父独依赖估计）：该方法假设所有属性都依赖于同一个属性，该属性被称为超父属性，如图4.1（b）所示$x_{1}$是超父属性。
TAN(Tree Augmented naive Bayes)：该方法是在最大权生成树的基础上，首先通过计算两两属性之间的条件信息求出各个边的权值，然后构建完全图的最大带权生成树，最后加入类别y，增加从y到每个属性的有向边。如图4.1（c）所示为TAN属性的依赖关系。
 
参考文献
 
[1]: 周志华. 《机器学习》[M]. 清华大学出版社, 2016. 
 [2]: 李航. 《统计学习方法》[M].清华大学出版社,2013. 
 [3]: Tom M Michele. 《机器学习》[M].机械工业出版社，2003.

                                                                   "微信公众号" 
 
 
本文同步更新在我的微信公众号里，地址：https://mp.weixin.qq.com/s/jfQNQ0mMe7a-k3IQNL_YAg
 
本文同步更新在我的知乎专栏里，地址：https://zhuanlan.zhihu.com/p/40485461
 
1. 摘要
 
贝叶斯分类器是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类器。而朴素贝叶斯分类器是贝叶斯分类器中最简单，也是最常见的一种分类方法。并且，朴素贝叶斯算法仍然是流行的十大挖掘算法之一，该算法是有监督的学习算法，解决的是分类问题。该算法的优点在于简单易懂、学习效率高、在某些领域的分类问题中能够与决策树、神经网络相媲美。但由于该算法以自变量之间的独立（条件特征独立）性和连续变量的正态性假设为前提，就会导致算法精度在某种程度上受影响。
 
2. 贝叶斯分类器的基础
 
要想学习贝叶斯算法的要领，我们需要先了解先验概率、后验概率的概念。
 
先验概率：是指根据以往经验和分析得到的概率。
 
举个例子：如果我们对西瓜的色泽、根蒂和纹理等特征一无所知，按照常理来说，西瓜是好瓜的概率是60%。那么这个概率P（好瓜）就被称为先验概率。
 
后验概率：事情已经发生，要求这件事情发生的原因是由某个因素引起的可能性的大小。
 
举个例子：假如我们了解到判断西瓜是否好瓜的一个指标是纹理。一般来说，纹理清晰的西瓜是好瓜的概率大一些，大概是75%。如果把纹理清晰当作一种结果，然后去推测好瓜的概率，那么这个概率P（好瓜|纹理清晰）就被称为后验概率。后验概率类似于条件概率。
 
联合概率：设二维离散型随机变量（X，Y）所有可能取得值为，记则称 为随机变量X和Y的联合概率。计算如下：
 
 
举个例子：在买西瓜的案例中，P（好瓜，纹理清晰）称为联合分布，它表示纹理清晰且是好瓜的概率。关于它的联合概率，满足以下乘法等式：
 
 
其中，P(好瓜|纹理清晰)就是后验概率，表示在“纹理清晰”的条件下，是“好瓜”的概率。P(纹理清晰|好瓜)表示在“好瓜”的情况下，是“纹理清晰”的概率。
 
全概率：如果事件组满足：
 
 
全概率公式的意义在于：当直接计算P（A）较为困难时，而 
 
的计算较为简单时，可以利用全概率公式进行计算P（A）。
 
举个例子：上面联合概率概念买西瓜的例子中，我们要计算P（好瓜，纹理清晰）联合概率时，需要知道P（纹理清晰）的概率。那么，如何计算纹理清晰的概率呢？实际上可以分为两种情况：一种是好瓜状态下纹理清晰的概率，另一类是坏瓜状态下纹理清晰的概率。纹理清晰的概率就是这两种情况之和。因此，我们可以推导出全概率公式：
 
 
贝叶斯定理：贝叶斯公式是建立在条件概率的基础上寻找事件发生的原因（即大事件A已经发生的条件下，分割中的小事件的概率），设 是样本空间Ω的一个划分，则对任一事件A（P(A)>0)，有贝叶斯定理：
 
 
对于每个特征x，我们想要知道样本在这个特性x下属于哪个类别，即求后验概率P(c|x)最大的类标记。这样基于贝叶斯公式，可以得到：
 
 
好了，学习完上面的先验概率、后验概率、联合概率、全概率、贝叶斯定理后，我们来小试牛刀一下：
 
西瓜的状态分为两种：好瓜与坏瓜，概率分别为0.6和0.4，并且好瓜里面纹理清晰的概率是0.8，坏瓜里面纹理清晰的概率是0.4。那么，我现在挑了一个纹理清晰的瓜，该瓜是好瓜的概率是多少？
 
很明显，这是一个后验概率问题，我们可以直接给出公式：
 
 
对公式里面出现的概率一个一个分析：
 
后验概率：P（纹理清晰|好瓜）=0.8
 
先验概率：P（好瓜）=0.6
 
后验概率：P（纹理清晰|坏瓜）=0.4
 
先验概率：P（坏瓜）=0.4
 
由上面分析的数值，我们可以直接求解上式：
 
 
这样，我们就计算得到了纹理清晰的情况下好瓜的概率是0.75。上面计算后验概率P（好瓜|纹理清晰）的公式就是利用了贝叶斯定理。
 
3. 朴素贝叶斯分类器
 
不难发现，基于贝叶斯公式（公式1）来估计后验概率P(c|x)的主要困难在于：类条件概率P(x|c)是所以属性上的联合概率（即x代表的是多个属性），难以从有限的训练样本直接估计而得。为了避开这个障碍，朴素贝叶斯分类器（naive Bayes classifier）采用了“属性条件独立性假设”:对已知类别，假设所有属性相互独立。换言之，假设每个属性独立地对分类结果发生影响。
 
朴素贝叶斯的算法步骤：
 
1. 设某样本属性集合其中 n 为属性数目，为x在第i属性上的取值。
 
2. 把这个样本划分为类别集合c中的某一类，。
 
3.  计算后验概率：
 
 
其中，，体现了朴素贝叶斯的精髓：每个特征相互独立。
 
那么，如何计算出 呢？首先找到一个已知类别分类集合，在这个集合中统计特征属性在各个类别下的条件概率，即得到我们要计算的。
 
值得注意的是：上式中的分母部分,对于所有的类别来说都是一样的。因此可以省略，针对不同的 ，仅需要比较的分子部分。
 
4. 如果 ，则样本在属性集 x下属于。
 
 温馨提示：如果对上面的算法步骤有点困惑，可以先看下面的例子，然后再回过头来理解朴素贝叶斯的算法步骤，理解效果会更好一点。
 
4. 朴素贝叶斯分类实例
 
我们已经了解了贝叶斯定理和朴素贝叶斯算法，可能你对上面的朴素贝叶斯算法还很困惑。这一小节，我们用一个实例来熟悉朴素贝叶斯算法。
 
我们还以买西瓜为实例。现在，我们有包含10个样本的数据集，这组数据集是以纹理、色泽、敲声为特征判断是好瓜还是坏瓜。数据集如下：
 
 
其中，纹理分为：清晰和模糊，色泽分为：青绿和乌黑，敲声分为：浊响、沉闷和清脆。不同的特征值组合对应着两类：好瓜还是坏瓜。
 
现在，我从超市中挑选了一个西瓜，它的纹理清晰、色泽青绿、敲声沉闷。我们可以根据样本数据集和朴素贝叶斯算法来计算该西瓜是好瓜还是坏瓜。
 
（1）首先，计算好瓜的情况：
 
先验概率：P（好瓜）=6/10=0.6
 
条件概率：P（纹理清晰|好瓜）=4/6=2/3
 
条件概率：P（色泽青绿|好瓜）=4/6=2/3
 
条件概率：P（敲声沉闷|好瓜）=2/6=1/3
 
计算后验概率P（好瓜|纹理清晰、色泽青绿、敲声沉闷）分子部分：
 
P（好瓜）x P（纹理清晰|好瓜）x P（色泽青绿|好瓜）x P（敲声沉闷|好瓜）= 0.6 × (2 / 3) × (2 / 3) × (1 / 3) = 4 / 45。
 
（2）然后，计算坏瓜的情况：
 
先验概率：P（坏瓜）=4/10=0.4
 
条件概率： P(纹理清晰|坏瓜) =1/4=0.25
 
条件概率： P(色泽青绿|坏瓜) =1/4=0.25
 
条件概率： P(敲声沉闷|坏瓜) =1/4 =0.25
 
计算后验概率P（坏瓜|纹理清晰、色泽青绿、敲声沉闷）分子部分：
 
P(坏瓜) × P(纹理清晰|坏瓜) × P(色泽青绿|坏瓜) × P(敲声沉闷|坏瓜) = 0.4 × 0.25 × 0.25 × 0.25 = 1 / 160。
 
（3）比较好瓜、坏瓜类别中的后验概率：
 
P（好瓜|纹理清晰、色泽青绿、敲声沉闷）> P（坏瓜|纹理清晰、色泽青绿、敲声沉闷）,即4/45 > 1/160，所以预测该纹理清晰、色泽青绿、敲声沉闷西瓜为好瓜。
 
5. 关于朴素贝叶斯容易忽略的点
 
（1）由上文看出，计算各个划分的条件概率 是朴素贝叶斯分类的关键性步骤，当特征属性为离散值时，能很方便的统计训练样本中各个划分在每个类别中出现的频率即可用来估计 ，下面重点讨论特征属性是连续值的情况。
 
当特征属性为连续值时，通常假定其值服从高斯分布（也称正态分布）。即：
 
 
则：
 
因此只要计算出训练样本中各个类别中此特征项划分的各均值和标准差，代入上述公式即可得到需要的估计值。均值与标准差的计算在此不再赘述。
 
（2） 另一个需要讨论的问题就是当怎么办，当某个类别下某个特征项划分没有出现时，就是产生这种现象，这会令分类器质量大大降低。为了解决这个问题，我们引入Laplace校准，它的思想非常简单，就是对每个类别下所有划分的计数加1，这样如果训练样本集数量充分大时，并不会对结果产生影响，并且解决了上述频率为0的尴尬局面。
 
6. 朴素贝叶斯分类器的优缺点
 
（1）优点：
 
1）简单易懂、学习效率高。
 
2）分类过程中时空开销小。
 
（2）缺点：
 
算法以自变量之间的独立（条件特征独立）性和连续变量的正态性假设为前提，会导致算法精度在某种程度上受影响。
 
Reference：
 
【1】《机器学习》，周志华著。
 
【2】通俗易懂！白话朴素贝叶斯
 
【3】Machine Learning -- Naive Bayes(朴素贝叶斯)
 
【4】教你明白啥是朴素贝叶斯分类器
 
【5】带你理解朴素贝叶斯分类算法

构建一个KNN分类器来进行图像分类
 
K-NN原理介绍
 
K近邻算法(K-NN)算法是一种简单但也很常用的分类算法，它也可以应用于回归计算。K-NN是无参数学习,这意味着它不会对底层数据的分布做出任何假设。它是基于实例，即该算法没有显式地学习模型。相反，它选择的是记忆训练实例，并在一个有监督的学习环境中使用。KNN算法的实现过程主要包括距离计算方式的选择、k值得选取以及分类的决策规则三部分。 
 
1. 距离计算方式的选择
 
选择一种距离计算方式,计算测试数据与各个训练数据之间的距离。距离计算方式一般选择欧氏距离或曼哈顿距离。 
 给定训练集: $X_{train} = (x^{(1)},x^{(2)},x^{(3)},...,x^{(i)})$，测试集：$X_{test} = ({x'}^{(1)},{x'}^{(2)},{x'}^{(3)},...,{x'}^{(j)})$ 
 则欧式距离为： 
 $$d(x^{(i)},{x'}^{(j)}) = \sqrt{\sum_{l=1}^l (x_{l}^{(i)}-{x_{l}'}^{(j)})^{2}} \tag{1}$$  

 曼哈顿距离为： 

 $$d(x^{(i)},{x'}^{(j)}) = {\sum_{l=1}^l \left| {x_{l}^{(i)}-{x_{l}'}^{(j)}}\right| \tag{2}}$$ 
 
2. k值得选取
 
在计算测试数据与各个训练数据之间的距离之后，首先按照距离递增次序进行排序，然后选取距离最小的k个点。 
 一般会先选择较小的k值，然后进行交叉验证选取最优的k值。k值较小时，整体模型会变得复杂，且对近邻的训练数据点较为敏感，容易出现过拟合。k值较大时，模型则会趋于简单，此时较远的训练数据点也会起到预测作用，容易出现欠拟合。
 
3. 分类的决策规则
 
常用的分类决策规则是取k个近邻训练数据中类别出现次数最多者作为输入新实例的类别。即首先确定前k个点所在类别的出现频率，对于离散分类，返回前k个点出现频率最多的类别作预测分类；对于回归则返回前k个点的加权值作为预测值。 
 
学习目标
 
不使用循环计算测试数据与训练数据的距离
构建KNN分类器来进行图像二分类
构建KNN分类器来进行图像多分类
 
构建KNN分类器来进行图像二分类
 
第一步：数据预处理
 
导入库
 
import numpy as np
import os
import pickle
import matplotlib.pyplot as plt
import h5py
import scipy
from PIL import Image
from scipy import ndimage

%matplotlib inline
 
导入数据集
 
数据集介绍： 
 此数据集总共包含259张图像，每张图像大小为64*64*3，分为两类(含有猫和不含猫)。其中训练集包含209张图像，测试集包含50张图像。
 
dataset
shape
train_set_x_orig
(209,64,64,3)
test_set_x_orig
(50,64,64,3)
train_set_x
(209,1)
test_set_y
(50,1)
 
def load_dataset():
    train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
    train_set_x_orig = np.array(train_dataset["train_set_x"][:])
    train_set_y_orig = np.array(train_dataset["train_set_y"][:])

    test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
    test_set_x_orig = np.array(test_dataset["test_set_x"][:])
    test_set_y_orig = np.array(test_dataset["test_set_y"][:])

    classes = np.array(test_dataset["list_classes"][:])

    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))

    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
 
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
 
将数据集转换为矢量
 
train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T
 
数据标准化
 
train_set_x = train_set_x_flatten/255.
test_set_x = test_set_x_flatten/255.
 
第二步：构建KNN分类器
 
计算距离(欧式距离)
 
def distance(X_test, X_train):
    """
    输入:
    X_test -- 由numpy数组表示的测试集，大小为(图片长度 * 图片高度 * 3 , 测试样本数)
    X_train -- 由numpy数组表示的训练集，大小为(图片长度 * 图片高度 * 3 , 训练样本数)
    输出:
    distances -- 测试数据与各个训练数据之间的距离,大小为(测试样本数, 训练样本数量)的numpy数组
    """
    num_test = X_test.shape[1]
    num_train = X_train.shape[1]
    distances = np.zeros((num_test, num_train))
    # (X_test - X_train)*(X_test - X_train) = -2X_test*X_train + X_test*X_test + X_train*X_train
    dist1 = np.multiply(np.dot(X_test.T,X_train), -2)    # -2X_test*X_train, shape (num_test, num_train)
    dist2 = np.sum(np.square(X_test.T), axis=1, keepdims=True)    # X_test*X_test, shape (num_test, 1)
    dist3 = np.sum(np.square(X_train), axis=0,keepdims=True)    # X_train*X_train, shape(1, num_train)
    distances = np.sqrt(dist1 + dist2 + dist3)

    return distances
 
第三步：定义预测函数
 
def predict(X_test, X_train, Y_train, k = 1):
    """ 
    输入:
    X_test -- 由numpy数组表示的测试集，大小为(图片长度 * 图片高度 * 3 , 测试样本数)
    X_train -- 由numpy数组表示的训练集，大小为(图片长度 * 图片高度 * 3 , 训练样本数)
    Y_train -- 由numpy数组（向量）表示的训练标签，大小为 (1, 训练样本数)
    k -- 选取与训练集最近邻的数量
    输出:
    Y_prediction -- 包含X_test中所有预测值的numpy数组（向量）
    distances -- 由numpy数组表示的测试数据与各个训练数据之间的距离,大小为(测试样本数, 训练样本数)
    """
    distances = distance(X_test, X_train)
    num_test = X_test.shape[1]
    Y_prediction = np.zeros(num_test)
    for i in range(num_test):
        dists_min_k = np.argsort(distances[i])[:k]     # 按照距离递增次序进行排序,选取距离最小的k个点 
        y_labels_k = Y_train[0,dists_min_k]     # 确定前k个点的所在类别
        Y_prediction[i] = np.argmax(np.bincount(y_labels_k)) # 返回前k个点中出现频率最高的类别作为测试数据的预测分类

    return Y_prediction, distances
 
定义模型
 
def model(X_test, Y_test, X_train, Y_train, k = 1, print_correct = False):
    """
    输入：
    X_test -- 由numpy数组表示的测试集，大小为(图片长度 * 图片高度 * 3 , 测试样本数)
    X_train -- 由numpy数组表示的训练集，大小为(图片长度 * 图片高度 * 3 , 训练样本数)
    Y_train -- 由numpy数组（向量）表示的训练标签，大小为 (1, 训练样本数)
    Y_test -- 由numpy数组（向量）表示的测试标签，大小为 (1, 测试样本数)
    k -- 选取与训练集最近邻的数量
    print_correct -- 设置为true时，打印正确率
    输出：
    d -- 包含模型信息的字典
    """
    Y_prediction, distances = predict(X_test, X_train, Y_train, k)
    num_correct = np.sum(Y_prediction == Y_test)
    accuracy = np.mean(Y_prediction == Y_test)
    if print_correct:
        print('Correct %d/%d: The test accuracy: %f' % (num_correct, X_test.shape[1], accuracy))
    d = {"k": k,
         "Y_prediction": Y_prediction, 
         "distances" : distances,
         "accuracy": accuracy}
    return d
 
测试模型
 
d = model(test_set_x, test_set_y,train_set_x, train_set_y, k=1, print_correct = True)
 
Correct 37/50: The test accuracy: 0.740000
 
num_px = train_set_x_orig.shape[1]
index = 1
plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))
print ("y = " + str(test_set_y[0,index]) + ", you predicted that it is a \"" + classes[int(d["Y_prediction"][index])].decode('utf-8') +  "\" picture.")
 
y = 1, you predicted that it is a "cat" picture.
 
 
构建KNN分类器来进行图像多分类
 
导入数据集
 
def load_CIFAR_batch(filename):
    with open(filename, 'rb') as f:
        datadict = pickle.load(f,encoding='latin1')
        X = datadict['data']
        Y = datadict['labels']
        X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype("float")
        Y = np.array(Y)
    return X, Y
def load_CIFAR10():
    xs = []
    ys = []
    for b in range(1,6):
        f = os.path.join('datasets', 'cifar-10-batches-py', 'data_batch_%d' % (b, ))
        X, Y = load_CIFAR_batch(f)
        xs.append(X)
        ys.append(Y)    
    Xtr = np.concatenate(xs)
    Ytr = np.concatenate(ys)
    del X, Y
    Xte, Yte = load_CIFAR_batch(os.path.join('datasets', 'cifar-10-batches-py', 'test_batch'))
    return Xtr, Ytr, Xte, Yte
 
X_train, y_train, X_test, y_test = load_CIFAR10()
 
CIFAR-10数据集介绍
 
CIFAR-10数据集共有60000张彩色图像，每张图像大小为32*32*3，分为10个类，每类6000张图片。其中训练集包含50000张图像，测试集包含10000张图像。
 
dataset
shape
X_train
(50000,32,32,3)
X_test
(10000,32,32,3)
y_train
(50000,)
y_test
(10000,)
 
CIFAR-10数据集部分图像可视化
 
classes = ['plane', 'car', 'bird', 'cat', 'dear', 'dog', 'frog', 'horse', 'ship', 'truck']
num_classes = len(classes)
num_each_class = 7

for y, cls in enumerate(classes):
    idxs = np.flatnonzero(y_train == y)
    idxs = np.random.choice(idxs, num_each_class, replace=False)
    for i, idx in enumerate(idxs):
        plt_idx = i * num_classes + (y + 1)
        plt.subplot(num_each_class, num_classes, plt_idx)
        plt.imshow(X_train[idx].astype('uint8'))
        plt.axis('off')
        if i == 0:
            plt.title(cls)
plt.show()
 
 
取训练集的前10000个样本与测试集的前1000个样本
 
X_train = np.reshape(X_train, (X_train.shape[0], -1)).T
X_test = np.reshape(X_test, (X_test.shape[0], -1)).T
Y_set_train = y_train[:10000].reshape(1,-1)
Y_set_test = y_test[:1000].reshape(1,-1)
X_set_train = X_train[:,:10000]
X_set_test = X_test[:,:1000]
 
取不同的k值进行训练
 
models = {}
for k in [1, 3, 5, 10]:
    print ("k = " + str(k))
    models[str(k)] = model(X_set_test, Y_set_test, X_set_train, Y_set_train, k, print_correct = True)
    print ('\n' + "-------------------------------------------------------" + '\n')
 
k = 1
Correct 283/1000: The test accuracy: 0.283000

-------------------------------------------------------

k = 3
Correct 280/1000: The test accuracy: 0.280000

-------------------------------------------------------

k = 5
Correct 296/1000: The test accuracy: 0.296000

-------------------------------------------------------

k = 10
Correct 288/1000: The test accuracy: 0.288000

-------------------------------------------------------
 
画出不同k值对应的测试精度曲线
 
models = {}
k = []
accuracys = []
for i in range(1,11):
    models[str(i)] = model(X_set_test, Y_set_test, X_set_train, Y_set_train, i, print_correct = False)
    k.append(models[str(i)]["k"])
    accuracys.append(models[str(i)]["accuracy"])
plt.plot(k, accuracys)
plt.ylabel('accuracy')
plt.xlabel('k')
plt.show()
 
 
数据集下载地址 
 github 
 csdn