分类属于监督学习的范畴，是数据挖掘、机器学习和数据科学的重要研究领域。分类模型类似于人类的学习方式。通过学习历史数据或训练集，得到一个目标函数，然后用这个目标函数预测新数据集的未知属性。本章主要介绍分类算法的基本概念，结合决策树、KNN和SVM分类算法对各种数据集进行分析，使读者学会使用Python分类算法分析自己的数据集，研究自己的知识，创造价值。
一、分类1。分类模型类似于前面提到的聚类模型，分类算法的模型如图1所示。它主要包括两个步骤：
培训。给定一个数据集，每个样本包含一组特征和一个类别信息，然后调用分类算法训练分类模型。预测。利用生成的模型或函数对新的数据集(测试集)进行分类预测，判断分类结果，并进行可视化绘图和显示。通常，为了测试学习模型的性能，使用检查集。数据集分为不相交的训练集和测试集，训练集用于构建分类模型，测试集用于检验有多少种标签被正确分类。这里有一个分类的例子。假设有一个垃圾邮件分类系统，将邮件分为“垃圾邮件”和“非垃圾邮件”。现在有一个训练集，里面有是不是垃圾邮件，然后训练一个分类模型来预测测试集。步骤如下：
(1)分类模型训练训练集，判断每一行数据是正数据还是负数据，并不断与真实结果进行比较，反复训练模型，直到模型达到某一状态或超过某一阈值，模型的训练结束。(2)用模型预测测试集，判断其类别是“垃圾邮件”还是“非垃圾邮件”，计算分类模型的准确率、召回率和F特征值。经过以上步骤，当我们收到一封新邮件时，可以根据邮件的内容或特征来判断它是否是垃圾邮件，这给我们提供了很大的便利，也可以防止垃圾短信的骚扰。2.常见分类算法的监督学习包括分类和回归。常见的分类算法包括朴素贝叶斯分类器、决策树、K近邻分类算法、支持向量机、神经网络和基于规则的分类算法等。同时还有结合单类方法的集成学习算法，比如Bagging和Boosting。(1)朴素贝叶斯分类器(NBC)起源于经典数学理论，具有坚实的数学基础和稳定的分类效率。该算法利用贝叶斯定理预测未知样本属于每个类别的可能性，选择可能性最大的类别作为样本的最终类别。其中，朴素贝叶斯方法是一种基于贝叶斯定理和特征条件的独立假设的方法，是一种利用概率统计知识的分类算法。这种算法的广泛使用的模型被称为朴素贝叶斯模型(NBM)。根据贝叶斯定理，对于一个分类问题，给定样本特征X，样本属于类别Y的概率如下：
其中p(x)表示X事件的概率，p(y)表示Y事件的概率，p(x|y)表示Y事件之后X事件的概率。由于贝叶斯定理的成立本身需要很强的条件独立性假设，而在实际情况下往往不成立，其分类精度会下降，而且对缺失数据不敏感。本书不详细介绍朴素贝叶斯分类例子。希望读者能下来自己研究。(2)决策树算法决策树是一种基于实例的归纳学习算法。它是对一组无序的、不规则的例子建立决策树，并推导出树结果的分类规则。作为分类和预测的主要技术之一，决策树的构建是为了找出属性和类别之间的关系，并利用它来预测未知数据的类别。该算法采用自顶向下的递归方法，对决策树内部节点的属性进行比较。根据不同的属性值，判断从该节点向下的分支，在决策树的叶节点处得到反馈结果。决策树算法利用树结构根据数据的属性建立决策模型，常用于解决分类和回归问题。常见的算法有：分类回归树、ID3、C4.5、随机森林等。(3) K近邻分类算法K近邻(KNN)分类算法是一种基于案例的分类方法，是数据挖掘分类技术中最简单也是最常用的方法之一。所谓k近邻就是找出k个最近邻，每个样本可以用它最近的k个邻居来表示。这种方法需要找出与未知样本X最接近的K个训练样本，根据K个样本属于哪个类，将未知样本X归入那个类。K-最近邻法是一种懒学习方法，它存储样本，直到需要分类时才进行分类。如果样本集很复杂，可能会造成很大的计算开销，所以不能应用于实时情况。(4)支持向量机支持向量机(SVM)是数学家Vapnik等人根据统计学习理论提出的一种新的学习方法。其基本模型定义为特征空间中区间最大的线性分类器，其学习策略是区间最大化，最终转化为一个凸二次规划问题的求解。SVM算法的最大特点是根据结构风险最小化准则，通过最大化分类区间来构造最优分类超平面提高学习机的泛化能力可以解决非线性、高维、局部极小等问题。同时在维数大于样本数时仍然有效，支持不同的核函数(线性、多项式、S型等。).(5)神经网络(也称人工神经网络)算法在20世纪80年代的机器学习领域非常流行，但在90年代中期衰落了。现在，随着“深度学习”的趋势再次升温，它已经成为最强大的机器学习算法之一。图2是神经网络的例子，包括输入层、隐藏层和输出层。
人工神经网络(ANN)是模仿生物神经网络的结构和功能的数学或计算模型。在该模型中，大量的节点或“神经元”相互连接形成网络，即“神经网络”，以达到处理信息的目的。神经网络通常需要训练，训练的过程就是学习的过程。训练改变网络节点的连接权值，使其具有分类功能，训练好的网络可用于物体识别。常见的人工神经网络有BP(Back Propagation)神经网络、径向基函数RBF神经网络、Hopfield神经网络、随机神经网络(Boltzmann machine)、深度神经网络DNN、卷积神经网络CNN等。(6)集成学习(Ensemble Learning)是一种机器学习方法，利用一系列的学习者进行学习，用一定的规则对学习结果进行集成，从而获得比单个学习者更好的学习效果。由于实际应用的复杂性和数据的多样性，单一的分类方法往往是无效的。因此，学者们对各种分类方法的集成进行了广泛的研究，即集成学习，这已经成为国际机器学习领域的一个研究热点。集成学习试图通过不断调用单个学习算法来获取不同的基础学习器，然后将这些学习器按照规则组合起来解决同一个问题。可以明显看出提高学习系统的泛化能力。多基学习器主要采用投票(加权)方式，常见的算法有Bagging、Boosting等。3.回归、聚类、分类的区别。第12篇详细讲解了回归分析，13篇详细讲解了聚类分析。本章重点是分类分析，但它们之间有什么区别和联系？
分类和回归属于监督学习。它们的区别在于：回归是用来预测连续的实值，比如给定住房面积，来预测房价，返回的结果就是房价；分类用于预测有限的离散值，比如一个人是否患有糖尿病，返回值为“是”或“否”。也就是说，很清楚该对象属于哪个预定义的目标类。预定义的目标类在离散时被分类，在连续时被回归。分类属于监督学习，聚类属于无监督学习。主要区别在于结果是否已知，或者训练过程中是否有班标。比如让孩子给水果分类，给他苹果的时候告诉他是苹果，给他桃子的时候告诉他是桃子。经过反复的训练和学习，现在给他一个新的水果，问他：“这是什么？”孩子回答，判断，整个过程是一个分类学习的过程。在训练孩子的过程中，反复告诉他们对应果实的真实类别。如果用聚类算法分析，给孩子一堆水果，有苹果，橘子，桃子。孩子一开始不知道水果需要分类什么，让孩子自己给水果分类，根据自己的特点总结判断。孩子们被分成三堆后，给他们新的水果，比如苹果。儿童将它们放入苹果堆的整个过程称为聚类学习过程。总之，分类学习在训练过程中知道对应类目标的结果，即训练集中有对应的类目标；但是聚类学习在训练过程中并不知道数据对应的结果。根据数据集的特点，将属性相似的数据按照“物以类聚”的方法聚集在一起。4.性能评估的分类算法有很多种，不同的分类算法也有很多种。不同的分类算法在不同的数据集上有不同的特点和不同的效果。我们需要根据具体的任务选择相应的算法。选择分类算法后，如何评价一个分类算法的好坏？这本书主要用精度、召回率和F值(F-measure或F-score)来评价分类算法。(1)查准率和查全率查准率定义为检索到的相关文献数与检索到的总文献数的比值，衡量检索系统的查准率；查全率定义为检索到的相关文档数与文档库中所有相关文档数的比值，衡量检索系统的查全率。公式如下：
其中，参数N代表实验结果中正确识别的聚类数，S代表实验结果中实际识别的聚类数，T代表数据集中所有与聚类相关的真实聚类数。(2)F-measure(F-measure或F-score)的准确率和召回率在一定情况下是相互制约的，很难用单一的评价指标来衡量实验的效果。f值是准确率和召回率的调和平均值，可以作为衡量实验结果的最终评价指标。f值更接近两个数字中较小的一个。f是指下式所示的计算公式：
(3)其他指标其他常用分类算法的评价指标包括：
准确性、错误率、敏感性、特异性)ROC曲线.二。决策树1。算法的示例描述。通过一个招聘案例描述了决策树的基本原理和过程。假设一个程序员和面试官在第一次面试中的简单对话，我们用决策树分类的思想来构造一个树形结构。对话如下：
面试官：你多大了？程序员：25岁。面试官本科毕业了吗？程序员：是的。面试官：编程技术很难吗？程序员：不算太大，一般水平。面试官：你熟悉Python吗？程序员：熟悉，做过数据挖掘相关应用。面试官：是的，你通过了。
这个面试决策过程是典型的分类树决策。相当于把程序员的初试按照年龄、学历、编程技能、对Python语言的熟悉程度分为两类：通过和失败。假设面试官对程序员的要求是30岁以下，本科以上学历，并且是编程能力很强的程序员或者熟悉Pyhon语言中平均水平以上的编程技术，面试官的决策逻辑过程如图3所示。
第二个例子是典型的决策树判断苹果。假设有4个样本，2个属性来判断苹果好不好，其中第二列1表示苹果很红，0表示苹果不红；第三列，1表示苹果很大，0表示苹果很小；第4列结果1表示苹果好吃，0表示苹果不好吃。
样本中有两个属性，即苹果红属性和苹果大小属性。这里，红苹果用A0表示，大苹果用A1表示。构建的决策树如图19.4所示。在图片的顶部有四个苹果(1，2，3，4)。然后它把红色的苹果放在一边(A0=红色)，把非红色的苹果放在另一边。结果是1，2是红苹果，3，4是非红苹果。然后把苹果按大小分，判断大苹果好吃(A1=大)。最终输出结果如图中第三层所示，其中1和3是好吃的苹果，2和4是难吃的苹果。这个例子说明苹果越大越好吃。
决策树算法根据数据的属性建立决策模型，采用树形结构，常用于解决分类和回归问题。常见的决策树算法包括：
以及分类回归树(cart)、ID3算法(迭代二分法3)C4.5算法、随机森林算法、梯度提升机(GBM)。决策树构建的基本步骤包括四个步骤，具体步骤如下：
步骤1:首先将所有记录视为一个节点。第二步：遍历每个变量的每个分割方法，寻找最佳分割点。步骤3:分成两个节点N1和N2。步骤4:分别对N1和N2继续第二步和第三步，直到每个节点都足够“纯净”。决策号有两个优点：
该模型具有可读性和描述性，有助于人工分析。效率高，决策树只需要建立一次，可以重复使用，每次预测的最大计算次数不超过决策树的深度。2.DTC算法在Sklearn机器学习包中，实现决策树(DTC)的类是sk learn . tree . decision decision tree classifier，可以解决数据集的多类分类问题。输入参数是两个数组X[n_samples，n_features]和y[n_samples]，其中X是训练数据，Y是训练数据。决策树分类器的构造方法是：
sk learn . tree . decision tree classifier(criteria=' Gini 'splitter='best 'max_depth=None，min_samples_split=2，min_samples_leaf=1，max_features=None，Random _ state=none，min _ density=none，compute _ importance=none，max _ leaf _ nodes=None)decision tree classifier类主要包括两种方法：clf.fit (train_data，train_target)用于加载(train_data，train _ target)Pre=clf . predict(test _ data)使用决策树模型
3.基于决策树的虹膜分析。前面第12篇文章介绍了Iris的logistic回归分析实例。在这里，我们将再次解释Iris的决策树分析的例子，以加深读者的印象。(1)数据集回顾在Sklearn机器学习包中，整合了各种数据集，包括糖尿病数据集、虹膜数据集、新闻数据集等。这里使用的是Iris数据集，这是一个常用的数据集，有150行数据，包括四个特征变量：
萼片长度萼片宽度花瓣长度花瓣宽度。同时，包括一个类别变量，iris分为三个类别，即：
Iris-setosa，Iris-versicolor，Iris-virginica表2为Iris数据集，详情见下表。
鸢尾是鸢尾属植物。这里存储了它的萼片和花瓣的长度和宽度，有四个属性。鸢尾属植物分为三类。Iris数据集包括两个属性iris.data和iris.target.其中，数据是一个矩阵，每列代表萼片或花瓣的长度和宽度，总共有4列。每行数据代表一个测量的鸢尾植物，采样150个记录。加载iris数据集的代码如下：
从Sklearn.datasets导入load _ iris iris=load _ iris()print(iris . data)print(iris . target)(2)决策树对iris的简单分析以下代码通过调用Sklearn机器学习包中的DecisionTreeClassifier算法实现分类分析，并绘制预测散点图。
#-*-编码：utf-8-*-# by:east mount csdn 2023-07-06 #从sklearn.datasets导入数据集iris导入load _ iris=load _ iris()print(iris . data)#输出数据集print(iris.target) #输出真实标签print(len(iris . target))print(iris . data . shape)#每个样本4个特征的150个样本#从sklearn.tree导入决策树DTC包导入决策树分类器CLF=决策树分类器()clf.fit (iris.data， iris . target)# training print(clf)predicted=clf . predicted(iris . data)# prediction #获取花的两列数据集x=iris . datal 1=[x[0]for x in x]L2=[x[1]for x in x]# Import numpy as NP Import matplotlib . py plot as PLT . scatter(L1，L2，c=predicted，Marker=' x ')# cmap=PLT . cm . paired PLT . title(' DTC ')输出结果如图5所示。 可以看出，决策树算法将数据集预测为三类，分别代表数据集对应的三种虹膜，但数据集中存在少量交叉结果。预测结果如下：
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]150(150，4)决策树分类器(class_weight=None，criterion='gini 'max_depth=None，max_features=None，max_leaf_nodes=None，min _ infinity _ decrease=0.0，_ decrease
以下是对上述核心代码的简要描述。
Fromsklearn.datasets导入load_iris iris=load_iris()这部分代码是导入sklearn机器学习包自带的iris数据集，调用load _ iris()函数导入数据，分为数据和目标两部分。
Fromsklearn.tree导入决策树分类器CLF=决策树分类器()clf.fit (iris.data，iris . target)predicted=clf . predict(iris . data)这部分代码导入到决策树模型中，调用fit()函数进行训练，使用predict()函数进行预测。
将matplotlib.py图导入为pltplt.scatter (L1，L2，c=预测，标记=' x ')。这部分代码是导入matplotlib绘图扩展包，调用scatter()函数绘制散点图。但是上面的代码有两个问题：
代码中通过“L1=[x[0] for x in X]”得到第一列和第二列数据集进行分类分析和绘制，而真实的虹膜数据集包含四个特征，那么如何绘制四个特征的图形呢？这个需要用PCA降维技术处理，参考上一篇文章。第二个问题是，在聚类、回归和分类模型中，需要先训练新的数据集，然后再进行预测。在这里，整个数据集被分类和分析。其实数据集需要分为训练集和测试集，比如数据集70%用于训练，30%用于预测，或者80%用于训练，20%用于预测。4.数据集划分和分类评估。这部分主要围绕代码优化，将数据集分为80%训练集和20%预测集，并对决策树分类算法进行评估。因为提供的数据集有一定的规律，前50类为0(绿色鸢尾)，中间50类为1(杂色鸢尾)，后50类为2(弗吉尼亚鸢尾)。即：
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]这里， 调用NumPy库中的concatenate()函数对数据集进行选择整合，选取0-40、50-90、100-140行的数据作为训练集，对应的类标签作为训练样本类标签； 然后，选择第40-50、90-100和140-150行的数据作为测试集，并使用相应的样本类别标签作为预测类别标签。代码如下：“axis=0”表示所选值的算术区间为0，即紧挨着获得的值。
#训练集train _ data=NP . concatenate((iris . data[0:40，)，iris.data [50: 90，iris.data [100: 140，])，Axis=0)#训练集样本类别train _ target=NP . concatenate((iris . target[0:40]，iris.target [50: 90]，iris.target [100: 140])，Axis=0)#测试集test _ data=NP .(iris . data[40:50， axis=0)同时调用sklearn机器学习包中的metrics类对决策树分类算法进行评估，将输出准确率(Precison)、召回率(Recall)、F-score、支持度等。
#从sk learn导入指标sprint(指标)中输出精度召回f值。分类_报告(测试_目标，预测_目标))打印(指标。混淆矩阵(test _ target，predict _ target))分类报告的核心功能是：
sk learn . metrics . classification _ report(y_true，y_pred，labels=none，target _ names=none，sample _ weight=none，digits=2)，其中y _ true参数表示正确的分类标准，y _ pred表示分类预测的分类标准，labels表示分类报告中显示的类标签的索引列表，target _ names参数显示标签对应的名称，digits是指定输出格式的精度。评估公式如下：
在调用metrics.classification_report()方法对决策树算法进行求值后，最后一行将对所有指标进行加权平均。有关详细信息，请参见下面的完整代码。
# -*-编码：utf-8-*-# By:east mount CSDN 2023-07-06 from sklearn . datasets导入load_irisfrom sklearn.tree导入决策树分类器from sk learn导入metrics导入num Pynp导入matplotlib.pyplot asplt #导入数据集iris ' '重点：划分数据集以构建训练集/测试集，80/2070%训练0-40 50-90 100-14030%预测40-50 90-100 iris.target [100: 140]) Axis=0) #训练集样本类别test _ data=NP . concatenate((iris . data[40:50，)，iris.data [90: 100，]，iris.data [140: 150，]，Axis=0) #测试集test _ target=NP . concatenate((iris . target[40:50]，iris.target [90: 100]，iris.target [140: 150])，Axis=0) # test Train_target) #注意训练数据集和样本类标准打印(CLF)predict _ target=clf . predict(test _ data)#测试集打印(predict_target)#比较预测结果和真实结果打印(sum(predict _ target==test _ target))#输出精度召回f值打印(metrics。 class ification _ report(test _ target，Predict _ target))print(metrics . confusion _ matrix(test _ target，Predict_target))# Get两列数据x=test _ datal 1=[n[0]for n in x]L2=[n[1]for n in x]# drawing PLT . scatter(L1，L2，c=predict _ target，Marker=' x ')# cmap=PLT . cm . paired PLT . title(' decision tree classifier ')PLT . show()的输出结果如下，包括数据集44的预测结果
[0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]30精确召回F1-分数支持0 1.00 1.00 1.00 1.00 101 1 1.00 1.00 1.00 1.00 1.00 102 1.00 1.00 1.00 10 10 AVG/总计1.00 1.00 1.00 1.00 1.00 1.00 30[[1000][0 100][0 010]
读者可以自行深入研究，调用sklearn.tree.export_graphviz类，通过导出决策树实现绘制树形结构的过程。例如，iris数据集输出如图7所示的树结构。https://www.freesion.com/article/894048252/
5.区域划分比较。下面是区域划分的对比实验(之前已经出现过)。它是指将数据集按照其真实的类标准划分成不同的颜色区域。这里的虹膜数据集分为三个区域，最后绘制散点图并进行对比。每个区域对应一类散乱点，意味着预测结果与真实结果一致。如果某个区域混有其他散乱点，说明该点的预测结果与真实结果不一致。完整的代码如下所示。代码首先调用“iris.data[:2]”代码获取两列数据(两个特征)，然后进行决策树分类分析。
# -*-编码：utf-8-*-# By:east mount CSDN 2023-07-06 import matplotlib . py plot as pltimport numpy as NP from sk learn . datasets import Load _ iris from sk learn . tree import decision tr ee classifier # Load iris数据集iris=load _ iris () x=x=iris.data [:2] #获取前两列数据Y=iris . target lr=decision tree classifier()lr . fit(x，Y)#meshgrid函数生成两个网格矩阵h=。min ()-.5，x [:0]。max () .5y _ min，y _ max=x [:1]。min ()-。YY=NP。网状网格(NP。ARANGE (x _ min，x _ max，h)，NP。ARANGE (y _ min，y _ max，h)) # pcolorMesh函数在图片Z=LR上绘制两个网格矩阵XX和YY以及对应的预测结果Z。预测(NP。YY。ravel()])Z=Z . shape(XX . shape)PLT . figure(1，figure size=(8，6)) plt.pcolormesh (xx，YY，Z，CMAP=plt.cm.paired) #绘制散点图plt.scatter. color='red 'marker='o 'label=' setosa ')PLT . scatter(X[50:100，0]，X[50:100，1]，color='blue 'marker='x 'label=' versi color ')PLT . scatter(sMAX ()) PLT。伊利姆(YY。最小()，YY。MAX ()) PLT。x票(())PLT。y票(())PLT。图例(位置=2) PLT。SHOW()下面，作者详细讲解了区域划分对比代码。
x_min，x_max=X[:0]。min() – .5，X[:0]。max() .5y_min，y_max=X[:1]。min() – .5，X[:1]。max() .5xx，yy=np.meshgrid(np.arange(x_min，x_max，H)，np.arange(y_min，y_max，H))，对应萼片长度和萼片宽度，各点坐标为(x，y)。首先取X 2D数组第一列(长度)的最小值、最大值和步长H(设置为0.02)生成数组，然后取X 2D数组第二列(宽度)的最小值、最大值和步长H生成数组，最后用meshgrid()函数生成两个网格矩阵xx和yy，如下图：
[[ 3.8 3.82 3.84 . 8.36 8.38 8.4 ][ 3.8 3.82 3.84 . 8.36 8.38 8.4 ].[ 3.8 3.82 3.84 . 8.36 8.38 8.4 ][ 3.8 3.82 3.84 . 8.36 8.38 8.4 ]][[ 1.5 1.5 1.5 . 1.5 1.5 1.5 ][ 1.52 1.52 1.52 . 1.52 1.52 1.52].[ 4.88 4.88 4.88 . 4.88 4.88 4.88][ 4.9 4.9 4.9 .4.9 4.9 4.9]]z=lr . predict(NP . c _[xx . ravel()，yy.ravel ()])。调用ravel()函数将xx和yy两个矩阵转换成一维数组，然后进行预测分析。因为两个矩阵的大小相等，所以两个一维数组的大小也相等。Np.c_[xx.ravel()，yy.ravel()]为生成矩阵，即：
xx.ravel()[ 3.8 3.82 3.84.8.36 8.38 8.4]YY . ravel()[1.5 1.5 1.5.4.9 4.9 4.9]np.c_[xx.ravel()，YY。ravel()][[3.8 1.5][3.82 1.5][3.84 1.5].[8.36 4.9][8.38 4.9][8.4 4.9]总之，上面的操作就是将萼片长度数据的第一列按H分成等份作为行，复制多行得到xx网格矩阵。然后，将萼片宽度数据的第二列按H等分为列，复制多列得到yy网格矩阵；最后把xx和yy矩阵变成两个一维数组，调用np.c_[]函数把它们组合成一个二维数组进行预测。调用predict()函数进行预测，预测结果赋给z，即：
Z=logreg.predict (NP。C _ [xx。拉威尔(YY)。Ravel ()]] [1 1 1.2 2 2]Size:39501 z=z . shape(xx。shape)调用shape()函数修改形状，并将其Z转换为两个要素(Z=Z . shape(xx . shape)输出如下：
[[1 1 1 . 2 2 2][1 1 1 . 2 2 2][0 1 1 . 2 2 2].[0 0 0 . 2 2 2][0 0 0 . 2 2 2][0 0 0 .2 2 2]]plt.pcolormesh(xx，yy，Z，Cmap=plt.cm.Paired)调用pcolormesh()函数在图片上绘制两个网格矩阵xx和yy以及对应的预测结果Z。可以发现输出是三个色块，分别代表三种类型的区域。Cmap=plt.cm.Paired表示绘制样式选择配对主题。的输出区域如下图所示：
PLT。scatter (x [:50，0]，x [:50，1]，color=' red 'marker=' o 'label=' setosa ')调用scatter()来绘制散点图。第一个参数是第一列数据(长度)，第二个参数是第二列数据。
最终输出如图9所示。经过决策树分析，分为三个区域，左上角是一个红点，对应的是setosa虹膜。右边部分为绿色方块，对应海滨鸢尾；中间部分分成一颗蓝色的星，对应的是鸢尾的杂色。散点图是每个数据点的真实花型，分为三个区域。预测的分类结果与训练数据的真实结果基本一致，部分鸢尾花交叉。
三。KNN分类算法1。算法示例描述KNN分类算法是最近邻算法，字面意思是找到最近的邻居。它是由Cover和Hart于1968年提出的，它简单、直观、易于实现。这里用一个经典的例子来说明如何找邻居，选择多少个邻居。图10需要判断右边的动物是鸭、鸡还是鹅吗？这就涉及到KNN算法的核心思想，判断与这个样本点相似的类别，然后预测其类别。因为它走路叫起来像鸭子，所以右边的动物很可能是鸭子。
KNN分类算法的核心思想是在所有的训练样本X中，找出与测试样本(常用的欧氏距离)最接近的前k个样本(作为相似度)，然后选取与待分类样本距离最小的k个样本作为X的k个最近邻，检查这k个样本中的大部分属于哪一类样本，使这个测试样本类别属于这一类样本。KNN分类的算法步骤如下：
计算测试样本点到所有样本点的欧氏距离dist，利用勾股定理计算用户自定义的设置参数k，选择最接近被测点的k个点。从这k个点开始，统计每个类型或类标记的个数，选择出现频率最高的类标记作为未知样本的类标记。反馈最终的预测结果，假设现在需要判断图11中的圆形图案属于三角形还是正方形范畴，采用KNN算法分析步骤如下：
当K=3时，图形中的第一个圆包含三个图形，包括两个三角形和一个正方形，该圆归类为三角形。当K=5时，第二个圆包含五个图形、两个三角形和三个正方形。然后，一个3:2的投票结果预测圆是正方形范畴。同样，当K=11的原理相同时，设置不同的K值可能会导致不同的预测结果。因此，KNN是一种非常简单易懂的分类算法。最后，简要描述了KNN算法的优缺点。KNN分类算法的优点包括：
该算法简单，易于实现。当有新的样本加入训练集时，不需要重新训练，即重新训练的成本低。计算时间和空间线性度与训练集大小有关。它的缺点是分类速度慢。因为每个待分类的新样本都必须与所有训练集进行比较才能得到前K个分类样本，所以时间的复杂度很高。整个算法的复杂度时间可以用O(m*n)来表示，其中m是选择的特征项个数，n是训练集样本个数。同时，如果k的取值不好，也会影响整个实验的结果，这也是KNN算法的另一个缺点。2.在2。KNeighborsClassifierSklearn机器学习包，实现KNN分类算法的类是neighbors.KNeighborsClassifier，构造方法如下：
kneighborsclassifier(algorithm=' ball _ tree 'leaf _ size=30，metric=' Minkowski 'metric _ params=none，n _ jobs=1，n_neighbors=3，p=2，weights=' uniform ')最重要。同时KNeighborsClassifier可以设置brute、kd_tree、ball_tree三种算法。具体调用方法如下：
来自sklearn。邻居导入kneighborsclassifier KNN=kneighborsclassifier(n _ neighbors=3，algorithm=' ball _ tree') KNN算法分析也包括训练和预测两种方法。
Training: knn.fit(data，target)预测：pre=knn.predict(data)以下代码是一个简单调用knn分类算法进行预测的示例。代码如下。
# -*-编码：utf-8-*-# By:east mount CSDN 2023-07-06 import numpy as NP from sk learn . neighborsclassifierx=NP . array([[-1，-1]，[-2，-2]，[1，2]，[1，1]，[-3，-4]，[3，2])Y=[0，0，1，1，0，1]x=[[4，5]，[-4，-3]，[3]调用knn.fit(X，Y)函数对模型进行训练后，调用predict()函数对[4，5]，[-4，-3]和[2，6]三个点的坐标进行预测，输出结果分别为[1，0，1]，其中X和Y坐标为正负。同时，还可以计算k个最近点的下标和距离。代码和结果如下，其中索引表示点的下标，距离表示距离。
distances，indexes=KNN . kneighbors(X)print(indexes)print(distances)[1 0 1][[0 1 3][1 0 4][2 3 5][3 2 5][4 1 0][5 2 3]][[0。1.41421356 2.82842712][0.1 . 41421356 2.23606798][0.1 . 2][0.1 . 2 . 23606798][0.2 . 23606798 3.6055128][0.2 . 2 . 23606798]]采用以下一种。
3.红酒种类的KNN分析(1)数据集这个实验数据集是UCI机器学习知识库开源网站提供的最流行的数据集(自2007年以来的点击数)红酒数据集。是对意大利同一地区生产的三种不同的葡萄酒进行大量分析得出的数据。这些数据包括三种葡萄酒中13种不同成分的特征，共有178行数据，如图13所示。
该数据集包括三种类型的葡萄酒中13种不同成分的量，有13种成分：酒精、苹果酸、灰分、灰分的碱度、镁、总酚、类黄酮、非类黄酮酚、原花青素、颜色强度、色调、废葡萄酒的od280/od315和脯氨酸。每个组件都可以被视为一个特征，对应一个数据。三种酒分别标有“1”、“2”、“3”。数据集的描述见表3。
数据存储在wine.txt文件中，如图14所示。每行数据代表一个样本，共有178行数据，每行数据包含14列，即第一列是类别属性，后面是13列特征。类别1中有59个样本，类别2中有71个样本，类别3中有48个样本。
注意：上一节我们讲了如何读取CSV文件数据集或者Sklearn扩展包提供的数据集。但是在现实分析中，很多数据集都是以TXT或者数据文件的形式存储的，它们之间用一定的符号分隔，比如图中的逗号。如何获取这类文件中的数据也是很重要的知识。所以先教你看这类文件的数据。(2)读取数据集从图14可以看出，整个数据集是用逗号分隔的。读取这类数据集的常用方法是调用open()函数读取文件，依次读取TXT文件中的所有内容，然后根据逗号分隔符获取每行14列数据并存储在数组或矩阵中，以便对数据进行分析。下面是调用loadtxt()函数读取逗号分隔数据的另一种方法。代码如下：
#-*-编码：UTF-8-*-import OS import numpy as NP path=' wine/wine . txt ' data=NP . load txt(path，dtype=float，delimiter='')打印(数据)输出如下：
load()读入文件函数的原型如下：loadtxt (fname，dtype，delimiter，converters，usecols)，其中参数fname表示文件路径，dtype表示数据类型，delimiter表示分隔符，转换器用转换函数映射数据列，如{1:fun}，usecols表示选中数据的列。(3)将数据集分成训练集和预测集。由于葡萄酒数据集的前59个样本都是1类，中间71个样本是2类，后48个样本是3类，所以需要将数据集拆分成训练集和预测集。步骤如下：
调用split()函数将数据集的第一列(Y数据)与13列要素(X数组)分开。函数参数包括数据data和分割位置，其中1表示从第一列开始分割，轴1表示水平分割，0表示垂直分割。由于数据集第一列存储的类标签是1.0、2.0或3.0浮点数据，需要转换成整数。这里在for循环中调用int()函数进行转换，存储在Y数组中，也可以通过np.astype()实现。最后调用np.concatenate()函数将0-40，60-100，140-160行数据分成训练集，包括13列特征和类标记，剩下的78行数据为测试集。代码如下：
# -*-编码：utf-8-*-import OSI impy as NP path=' wine/wine . txt ' data=NP . load txt(path，dtype=float，delimiter='')print(data)yy，x=np.split(data，(1，)，axis=1)print(yy.shape，X . shape)y=[]for n in YY:y . append(int(n))Train _ data=NP . concatenate((X[0:40，)，x[60:1
(178L，1L) (178L，13L) (100L，1L) (100L，13L) (78L，1L) (78L，13L)下面是一个随机拆分方法，调用sk learn . model _ selection . training _ test _ split类来随机划分训练集和测试集。代码如下：
from sklearn.model_selection导入train_test_splitx，y=np.split(data，(1，)axis=1)x_tr
ain, x_test, y_train, y_test = train_test_split(x, y, random_state=1, train_size=0.7)#Python2调用方法#from sklearn.cross_validation import train_test_split
参数x表示所要划分的样本特征集；y是所要划分的样本结果；train_size表示训练样本占比，0.7表示将数据集划分为70%的训练集、30%的测试集；random_state是随机数的种子。该函数在部分版本的sklearn库中是导入model_selection类，建议读者下来尝试。(4) KNN分类算法分析上面已经将178个样本分成100个训练样本和78个测试样本，采用KNN分类算法训练模型，再对测试集进行预测，判别出测试样本所属于酒的类型，同时输出测试样本计算的正确率和错误率。KNN核心代码如下：
from sklearn.neighbors import KNeighborsClassifierclf = KNeighborsClassifier(n_neighbors=3,algorithm=’kd_tree’)clf.fit(train_data,train_target)result = clf.predict(test_data)print(result)
预测输出结果如下所示：
[1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 3 2 2 2 2 2 2 2 2 3 2 3 2 2 2 22 2 3 3 2 2 2 2 2 2 2 2 3 2 3 3 3 3 2 1 2 3 3 2 2 3 2 3 2 2 2 1 2 2 2 3 11 1 1 3]
(5) 完整代码下面代码实现了调用Sklearn机器学习包中KNeighborsClassifier算法进行分类分析，并绘制预测的散点图和背景图，完整代码如下。
# -*- coding: utf-8 -*-# By:Eastmount CSDN 2023-07-06import osimport numpy as npfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn import metricsfrom sklearn.decomposition import PCAimport matplotlib.pyplot as pltfrom matplotlib.colors import ListedColormap#—————————————————————————-#第一步 加载数据集path = “wine/wine.txt”data = np.loadtxt(path,dtype=float,delimiter=”,”)print(data)#—————————————————————————-#第二步 划分数据集yy, x = np.split(data, (1,), axis=1) #第一列为类标yy,后面13列特征为xprint(yy.shape, x.shape)y = []for n in yy: #将类标浮点型转化为整数y.append(int(n))x = x[:, :2] #获取x前两列数据,方便绘图 对应x、y轴train_data = np.concatenate((x[0:40,:], x[60:100,:], x[140:160,:]), axis = 0) #训练集train_target = np.concatenate((y[0:40], y[60:100], y[140:160]), axis = 0) #样本类别test_data = np.concatenate((x[40:60, :], x[100:140, :], x[160:,:]), axis = 0) #测试集test_target = np.concatenate((y[40:60], y[100:140], y[160:]), axis = 0) #样本类别print(train_data.shape, train_target.shape)print(test_data.shape, test_target.shape)#—————————————————————————-#第三步 KNN训练clf = KNeighborsClassifier(n_neighbors=3,algorithm=’kd_tree’) #K=3clf.fit(train_data,train_target)result = clf.predict(test_data)print(result)#—————————————————————————-#第四步 评价算法print(sum(result==test_target)) #预测结果与真实结果比对print(metrics.classification_report(test_target, result)) #准确率 召回率 F值#—————————————————————————-#第五步 创建网格x1_min, x1_max = test_data[:,0].min()-0.1, test_data[:,0].max()+0.1 #第一列x2_min, x2_max = test_data[:,1].min()-0.1, test_data[:,1].max()+0.1 #第二列xx, yy = np.meshgrid(np.arange(x1_min, x1_max, 0.1),np.arange(x2_min, x2_max, 0.1)) #生成网格型数据print(xx.shape, yy.shape) #(53L, 36L) (53L, 36L)z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) #ravel()拉直函数print(xx.ravel().shape, yy.ravel().shape) #(1908L,) (1908L,)print(np.c_[xx.ravel(), yy.ravel()].shape) #合并 (1908L,2)#—————————————————————————-#第六步 绘图可视化cmap_light = ListedColormap([‘#FFAAAA’, ‘#AAFFAA’, ‘#AAAAFF’]) #颜色Mapcmap_bold = ListedColormap([‘#FF0000’, ‘#00FF00’, ‘#0000FF’])plt.figure()z = z.reshape(xx.shape)print(xx.shape, yy.shape, z.shape, test_target.shape)#(53L, 36L) (53L, 36L) (53L, 36L) (78L,)plt.pcolormesh(xx, yy, z, cmap=cmap_light)plt.scatter(test_data[:,0], test_data[:,1], c=test_target,cmap=cmap_bold, s=50)plt.show()
输出结果如下所示，包括预测的78行类标，共预测正确58行数据，准确率为0.76，召回率为0.74，f特征为0.74。其结果不太理想，需要进一步优化算法。
[1 3 1 1 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 3 2 2 3 2 2 2 2 2 3 2 2 2 2 22 1 2 2 2 3 3 3 2 2 2 2 3 2 3 1 1 2 3 3 3 3 3 1 3 3 3 3 3 3 3 1 3 2 1 1 33 3 1 3]58precision recall f1-score support1 0.68 0.89 0.77 192 0.88 0.74 0.81 313 0.67 0.64 0.65 28avg / total 0.76 0.74 0.74 78
输出图形如图15所示，可以看到整个区域划分为三种颜色，左下角为绿色区域，右下角为红色区域，右上部分为蓝色区域。同时包括78个点分布，对应78行数据的类标，包括绿色、蓝色和红色的点。可以发现，相同颜色的点主要集中于该颜色区域，部分蓝色点划分至红色区域或绿色点划分至蓝色区域，则表示预测结果与实际结果不一致。
最后简单总结，整个分析过程包括六个步骤，大致内容如下：1) 加载数据集采用loadtxt()函数加载酒类数据集，采用逗号（,）分割。2) 划分数据集由于Wine数据集第一列为类标，后面13列为13个酒类特征，获取其中两列特征，并将其划分成特征数组和类标数组，调用concatenate()函数实现。
3) KNN训练调用Sklearn机器学习包中KNeighborsClassifier()函数训练，设置K值为3类，并调用clf.fit(train_data,train_target)训练模型，clf.predict(test_data)预测分类结果。4) 评价算法通过classification_report()函数计算该分类预测结果的准确率、召回率和F值。5) 创建网格由于绘图中，拟将预测的类标划分为三个颜色区域，真实的分类结果以散点图形式呈现，故需要获取数据集中两列特征的最大值和最小值，并创建对应的矩阵网格，调用numpy扩展包的meshgrid()函数实现，在对其颜色进行预测。6) 绘图可视化设置不同类标的颜色，调用pcolormesh()函数绘制背景区域颜色，调用scatter()函数绘制实际结果的散点图，形成如图15的效果图。
四.SVM分类算法
支持向量机（Support Vector Machine，简称SVM）是常见的一种判别方法。在机器学习领域，是一个有监督的学习模型，通常用来进行模式识别、分类以及回归分析。该算法的最大特点是根据结构风险最小化准则，以最大化分类间隔构造最优分类超平面来提高学习机的泛化能力，较好地解决了非线性、高维数、局部极小点等问题。
1.SVM基础知识
(1) 基础概念由于作者数学推算能力不太好，同时SVM原理也比较复杂，所以SVM算法基础知识推荐大家阅读CSDN博客著名算法大神“JULY”的文章《支持向量机通俗导论（理解SVM的三层境界）》，这篇文章由浅入深的讲解了SVM算法，而本小节作者主要讲解SVM的用法。SVM分类算法的核心思想是通过建立某种核函数，将数据在高维寻找一个满足分类要求的超平面，使训练集中的点距离分类面尽可能的远，即寻找一个分类面使得其两侧的空白区域最大。如图19.16所示，两类样本中离分类面最近的点且平行于最优分类面的超平面上的训练样本就叫做支持向量。
(2) SVM导入方法SVM分类算法在Sklearn机器学习包中，实现的类是 svm.SVC，即C-Support Vector Classification，它是基于libsvm实现的。构造方法如下：
SVC(C=1.0,cache_size=200,class_weight=None,coef0=0.0,decision_function_shape=None,degree=3,gamma=’auto’,kernel=’rbf’,max_iter=-1,probability=False,random_state=None,shrinking=True,tol=0.001,verbose=False)
其中参数含义如下：
C表示目标函数的惩罚系数，用来平衡分类间隔margin和错分样本的，默认值为1.0；cache_size是制定训练所需要的内存（以MB为单位）；gamma是核函数的系数，默认是gamma=1/n_features；kernel可以选择RBF、Linear、Poly、Sigmoid，默认的是RBF；degree决定了多项式的最高次幂；max_iter表示最大迭代次数，默认值为1；coef0是核函数中的独立项；class_weight表示每个类所占据的权重，不同的类设置不同的惩罚参数C，缺省为自适应；decision_function_shape包括ovo（一对一）、ovr（多对多）或None（默认值）。
SVC算法主要包括两个步骤：
训练：nbrs.fit(data, target)预测：pre = clf.predict(data)
下面这段代码是简单调用SVC分类算法进行预测的例子，数据集中x和y坐标为负数的类标为1，x和y坐标为正数的类标为2，同时预测点[-0.8,-1]的类标为1，点[2,1]的类标为2。
import numpy as npfrom sklearn.svm import SVCX = np.array([[-1, -1], [-2, -2], [1, 3], [4, 6]])y = np.array([1, 1, 2, 2])clf = SVC()clf.fit(X, y)print(clf)print(clf.predict([[-0.8,-1], [2,1]]))#输出结果：[1, 2]
支持向量机分类器还有其他的方法，比如NuSVC核支持向量分类，LinearSVC线性向量支持分类等，这里不再介绍。同时，支持向量机也已经推广到解决回归问题，称为支持向量回归，比如SVR做线性回归。
2.SVM分析红酒数据
接着采用SVM分类算法对酒类数据集Wine进行分析，并对比前面19.3小节的实例代码，校验SVM分类算法和KNN分类算法的分析结果和可视化分析的优劣。其分析步骤基本一致，主要包括如下六个步骤：
第一步，加载数据集。采用loadtxt()函数加载酒类数据集，采用逗号（,）分割。第二步，划分数据集。将Wine数据集划分为训练集和预测集，仅提取酒类13个特种中的两列特征进行数据分析。第三步，SVM训练。导入Sklearn机器学习包中svm.SVC()函数分析，调用fit()函数训练模型，predict(test_data)函数预测分类结果。第四步，评价算法。通过classification_report()函数计算该分类预测结果的准确率、召回率和F值。第五步，创建网格。获取数据集中两列特征的最大值和最小值，并创建对应的矩阵网格，用于绘制背景图，调用numpy扩展包的meshgrid()函数实现。第六步，绘图可视化。设置不同类标的颜色，调用pcolormesh()函数绘制背景区域颜色，调用scatter()函数绘制实际结果的散点图。
完整代码如下所示：
# -*- coding: utf-8 -*-# By:Eastmount CSDN 2023-07-06import osimport numpy as npfrom sklearn.svm import SVCfrom sklearn import metricsimport matplotlib.pyplot as pltfrom matplotlib.colors import ListedColormap#—————————————————————————-#第一步 加载数据集path = “wine/wine.txt”data = np.loadtxt(path,dtype=float,delimiter=”,”)print(data)#—————————————————————————-#第二步 划分数据集yy, x = np.split(data, (1,), axis=1) #第一列为类标yy,后面13列特征为xprint(yy.shape, x.shape)y = []for n in yy: #将类标浮点型转化为整数y.append(int(n))x = x[:, :2] #获取x前两列数据,方便绘图 对应x、y轴train_data = np.concatenate((x[0:40,:], x[60:100,:], x[140:160,:]), axis = 0) #训练集train_target = np.concatenate((y[0:40], y[60:100], y[140:160]), axis = 0) #样本类别test_data = np.concatenate((x[40:60, :], x[100:140, :], x[160:,:]), axis = 0) #测试集test_target = np.concatenate((y[40:60], y[100:140], y[160:]), axis = 0) #样本类别print(train_data.shape, train_target.shape)print(test_data.shape, test_target.shape)#—————————————————————————-#第三步 SVC训练clf = SVC()clf.fit(train_data,train_target)result = clf.predict(test_data)print(result)#—————————————————————————-#第四步 评价算法print(sum(result==test_target)) #预测结果与真实结果比对print(metrics.classification_report(test_target, result)) #准确率 召回率 F值#—————————————————————————-#第五步 创建网格x1_min, x1_max = test_data[:,0].min()-0.1, test_data[:,0].max()+0.1 #第一列x2_min, x2_max = test_data[:,1].min()-0.1, test_data[:,1].max()+0.1 #第二列xx, yy = np.meshgrid(np.arange(x1_min, x1_max, 0.1),np.arange(x2_min, x2_max, 0.1)) #生成网格型数据z = clf.predict(np.c_[xx.ravel(), yy.ravel()])#—————————————————————————-#第六步 绘图可视化cmap_light = ListedColormap([‘#FFAAAA’, ‘#AAFFAA’, ‘#AAAAFF’]) #颜色Mapcmap_bold = ListedColormap([‘#000000’, ‘#00FF00’, ‘#FFFFFF’])plt.figure()z = z.reshape(xx.shape)print(xx.shape, yy.shape, z.shape, test_target.shape)plt.pcolormesh(xx, yy, z, cmap=cmap_light)plt.scatter(test_data[:,0], test_data[:,1], c=test_target,cmap=cmap_bold, s=50)plt.show()
代码提取了178行数据的第一列作为类标，剩余13列数据作为13个特征的数据集，并划分为训练集（100行）和测试集（78行）。输出结果如下，包括78行SVM分类预测的类标结果，其中61行数据类标与真实的结果一致，其准确率为0.78，召回率为0.78，F1特征为0.78。
最后可视化绘图输出如下图所示的结果。
3.优化SVM分析红酒数据集
前面SVM分析红酒数据集的代码存在两个缺点，一是采用固定的组合方式划分的数据集，即调用np.concatenate()函数将0-40、60-100、140-160行数据分割为训练集，其余为预测集；二是只提取了数据集中的两列特征进行SVM分析和可视化绘图，即调用“x = x[:, :2]”获取前两列特征，而红酒数据集共有13列特征。真实的数据分析中通常会随机划分数据集，分析过程也是对所有的特征进行训练及预测操作，再经过降维处理之后进行可视化绘图展示。下面对SVM分析红酒数据集实例进行简单的代码优化，主要包括：
随机划分红酒数据集对数据集的所有特征进行训练和预测分析采用PCA算法降维后再进行可视化绘图操作
完整代码如下，希望读者也认真学习该部分知识，更好地优化自己的研究或课题。
# -*- coding: utf-8 -*-# By:Eastmount CSDN 2023-07-06import osimport numpy as npfrom sklearn.svm import SVCfrom sklearn import metricsimport matplotlib.pyplot as pltfrom matplotlib.colors import ListedColormapfrom sklearn.model_selection import train_test_splitfrom sklearn.decomposition import PCA#第一步 加载数据集path = “wine/wine.txt”data = np.loadtxt(path,dtype=float,delimiter=”,”)print(data)#第二步 划分数据集yy, x = np.split(data, (1,), axis=1) #第一列类标yy,后面13列特征为xprint(yy.shape, x.shape)y = []for n in yy:y.append(int(n))y = np.array(y, dtype = int) #list转换数组#划分数据集 测试集40%train_data, test_data, train_target, test_target = train_test_split(x, y, test_size=0.4, random_state=42)print(train_data.shape, train_target.shape)print(test_data.shape, test_target.shape)#第三步 SVC训练clf = SVC()clf.fit(train_data, train_target)result = clf.predict(test_data)print(result)print(test_target)#第四步 评价算法print(sum(result==test_target)) #预测结果与真实结果比对print(metrics.classification_report(test_target, result)) #准确率 召回率 F值#第五步 降维操作pca = PCA(n_components=2)newData = pca.fit_transform(test_data)#第六步 绘图可视化plt.figure()cmap_bold = ListedColormap([‘#000000’, ‘#00FF00’, ‘#FFFFFF’])plt.scatter(newData[:,0], newData[:,1], c=test_target, cmap=cmap_bold, s=50)plt.show()
输出结果如下所示，其准确率、召回率和F值很低，仅为50%、39%和23%。
(106L, 13L) (106L,)(72L, 13L) (72L,)[2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 22 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2][1 1 3 1 2 1 2 3 2 3 1 3 1 2 1 2 2 2 1 2 1 2 2 3 3 3 2 2 2 1 1 2 3 1 1 1 33 2 3 1 2 2 2 3 1 2 2 3 1 2 1 1 3 3 2 2 1 2 1 3 2 2 3 1 1 1 3 1 1 2 3]28precision recall f1-score support1 1.00 0.04 0.07 262 0.38 1.00 0.55 273 0.00 0.00 0.00 19avg / total 0.50 0.39 0.23 72
上述代码如下采用决策树进行分析，则其准确率、召回率和F值就很高，结果如下所示。所以并不是每种分析算法都适应所有的数据集，不同数据集其特征不同，最佳分析的算也会不同，我们在进行数据分析时，通常会对比多种分析算法，再优化自己的实验和模型。
from sklearn.tree import DecisionTreeClassifierclf = DecisionTreeClassifier()print(metrics.classification_report(test_target, result))# precision recall f1-score support## 1 0.96 0.88 0.92 26# 2 0.90 1.00 0.95 27# 3 1.00 0.95 0.97 19##avg / total 0.95 0.94 0.94 72
SVM算法分析后输出的图形如下所示。
五.各模型分类对比实验
算法评价和对比实验是深度学习重要的知识点，这里作者对各种机器学习分类算法进行对比，以鸢尾花数据集为例，我们从绘制的分类边界效果以及实验评估指标（Precision、Recall、F1-socre）分别进行对比。1.决策树原始代码如下：
# -*- coding: utf-8 -*-# By:Eastmount CSDN 2023-07-06# 该部分参考知乎萌弟老师：https://zhuanlan.zhihu.com/p/173945775import numpy as npfrom sklearn import metricsfrom sklearn import datasetsimport matplotlib.pyplot as pltfrom matplotlib.colors import ListedColormapfrom sklearn.model_selection import train_test_splitfrom sklearn.decomposition import PCAfrom sklearn.preprocessing import StandardScaler#————————————————————————#第一步 导入数据iris = datasets.load_iris()X = iris.data[:,[2,3]]y = iris.targetprint(“Class labels:”,np.unique(y)) #打印分类类别的种类 [0 1 2]#30%测试数据 70%训练数据 stratify=y表示训练数据和测试数据具有相同的类别比例X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=1,stratify=y)#————————————————————————#第二步 数据标准化sc = StandardScaler() #估算训练数据中的mu和sigmasc.fit(X_train) #使用训练数据中的mu和sigma对数据进行标准化X_train_std = sc.transform(X_train)X_test_std = sc.transform(X_test)print(X_train_std)print(X_test_std)#————————————————————————#第三步 可视化函数 画出决策边界def plot_decision_region(X,y,classifier,resolution=0.02):markers = (‘s’,’x’,’o’,’^’,’v’)colors = (‘red’,’blue’,’lightgreen’,’gray’,’cyan’)cmap = ListedColormap(colors[:len(np.unique(y))])# plot the decision surfacex1_min,x1_max = X[:,0].min()-1,X[:,0].max()+1x2_min,x2_max = X[:,1].min()-1,X[:,1].max()+1xx1,xx2 = np.meshgrid(np.arange(x1_min,x1_max,resolution),np.arange(x2_min,x2_max,resolution))Z = classifier.predict(np.array([xx1.ravel(),xx2.ravel()]).T)Z = Z.reshape(xx1.shape)plt.contourf(xx1,xx2,Z,alpha=0.3,cmap=cmap)plt.xlim(xx1.min(),xx1.max())plt.ylim(xx2.min(),xx2.max())# plot class samplesfor idx,cl in enumerate(np.unique(y)):plt.scatter(x=X[y==cl,0],y = X[y==cl,1],alpha=0.8,c=colors[idx],marker = markers[idx],label=cl,edgecolors=’black’)#————————————————————————#第四步 决策树分类from sklearn.tree import DecisionTreeClassifiertree = DecisionTreeClassifier(criterion=’gini’,max_depth=4,random_state=1)tree.fit(X_train_std,y_train)print(X_train_std.shape, X_test_std.shape, len(y_train), len(y_test)) #(105, 2) (45, 2) 105 45res1 = tree.predict(X_test_std)print(res1)print(metrics.classification_report(y_test, res1, digits=4)) #四位小数plot_decision_region(X_train_std,y_train,classifier=tree,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘DecisionTreeClassifier’)plt.legend(loc=’upper left’)plt.show()
实验的精确率、召回率和F1值输出如下：macro avg： 0.9792 0.9778 0.9778
precision recall f1-score support0 1.0000 1.0000 1.0000 151 0.9375 1.0000 0.9677 152 1.0000 0.9333 0.9655 15accuracy 0.9778 45macro avg 0.9792 0.9778 0.9778 45weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据分类效果如下图所示，可以看到分类效果明显。
2.KNN核心代码如下：macro avg： 0.98 0.98 0.98
#第五步 KNN分类from sklearn.neighbors import KNeighborsClassifierknn = KNeighborsClassifier(n_neighbors=2,p=2,metric=”minkowski”)knn.fit(X_train_std,y_train)res2 = knn.predict(X_test_std)print(res2)print(metrics.classification_report(y_test, res2, digits=4)) #四位小数plot_decision_region(X_train_std,y_train,classifier=knn,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘KNeighborsClassifier’)plt.legend(loc=’upper left’)plt.show()
输出结果如下：macro avg： 0.9792 0.9778 0.9778
precision recall f1-score support0 1.0000 1.0000 1.0000 151 0.9375 1.0000 0.9677 152 1.0000 0.9333 0.9655 15accuracy 0.9778 45macro avg 0.9792 0.9778 0.9778 45weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据分类效果如下图所示：
3.SVM核心代码如下：
#第六步 SVM分类 核函数对非线性分类问题建模(gamma=0.20)from sklearn.svm import SVCsvm = SVC(kernel=’rbf’,random_state=1,gamma=0.20,C=1.0) #较小的gamma有较松的决策边界svm.fit(X_train_std,y_train)res3 = svm.predict(X_test_std)print(res3)print(metrics.classification_report(y_test, res3, digits=4))plot_decision_region(X_train_std,y_train,classifier=svm,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘SVM’)plt.legend(loc=’upper left’)plt.show()
输出结果如下：macro avg： 0.9361 0.9333 0.9340
precision recall f1-score support0 1.0000 0.9333 0.9655 151 0.9333 0.9333 0.9333 152 0.8750 0.9333 0.9032 15accuracy 0.9333 45macro avg 0.9361 0.9333 0.9340 45weighted avg 0.9361 0.9333 0.9340 45
绘制的训练数据分类效果如下图所示：
如果使用的核函数gamma为100，然后实现非线性分类，则绘制结果如下图所示：svm = SVC(kernel=‘rbf’,random_state=1,gamma=100.0,C=1.0,verbose=1)
从不同的gamma取值的图像来看：对于高斯核函数，增大gamma值，将增大训练样本的影响范围，导致决策边界紧缩和波动；较小的gamma值得到的决策边界相对宽松。虽然较大的gamma值在训练样本中有很小的训练误差，但是很可能泛化能力较差，容易出现过拟合。4.逻辑回归核心代码如下：
#第七步 逻辑回归分类from sklearn.linear_model import LogisticRegressionlr = LogisticRegression(C=100.0,random_state=1)lr.fit(X_train_std,y_train)res4 = lr.predict(X_test_std)print(res4)print(metrics.classification_report(y_test, res4, digits=4))plot_decision_region(X_train_std,y_train,classifier=lr,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘LogisticRegression’)plt.legend(loc=’upper left’)plt.show()
输出结果如下：macro avg： 0.9792 0.9778 0.9778
precision recall f1-score support0 1.0000 1.0000 1.0000 151 0.9375 1.0000 0.9677 152 1.0000 0.9333 0.9655 15accuracy 0.9778 45macro avg 0.9792 0.9778 0.9778 45weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据分类效果如下图所示：
5.朴素贝叶斯核心代码如下：
#第八步 朴素贝叶斯分类from sklearn.naive_bayes import GaussianNBgnb = GaussianNB()gnb.fit(X_train_std,y_train)res5 = gnb.predict(X_test_std)print(res5)print(metrics.classification_report(y_test, res5, digits=4))plot_decision_region(X_train_std,y_train,classifier=gnb,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘GaussianNB’)plt.legend(loc=’upper left’)plt.show()
输出结果如下：macro avg： 0.9792 0.9778 0.9778
precision recall f1-score support0 1.0000 1.0000 1.0000 151 0.9375 1.0000 0.9677 152 1.0000 0.9333 0.9655 15accuracy 0.9778 45macro avg 0.9792 0.9778 0.9778 45weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据分类效果如下图所示，还挺好看的，边界呈曲线分布。
6.随机森林核心代码如下：
#第九步 随机森林分类from sklearn.ensemble import RandomForestClassifierforest = RandomForestClassifier(criterion=’gini’,n_estimators=25,random_state=1,n_jobs=2,verbose=1)forest.fit(X_train_std,y_train)res6 = gnb.predict(X_test_std)print(res6)print(metrics.classification_report(y_test, res6, digits=4))plot_decision_region(X_train_std,y_train,classifier=forest,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘GaussianNB’)plt.legend(loc=’upper left’)plt.show()
输出结果如下：macro avg： 0.9792 0.9778 0.9778
precision recall f1-score support0 1.0000 1.0000 1.0000 151 0.9375 1.0000 0.9677 152 1.0000 0.9333 0.9655 15accuracy 0.9778 45macro avg 0.9792 0.9778 0.9778 45weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据分类效果如下图所示：
7.AdaBoost核心代码如下：
#第十步 集成学习分类from sklearn.ensemble import AdaBoostClassifierada = AdaBoostClassifier()ada.fit(X_train_std,y_train)res7 = ada.predict(X_test_std)print(res7)print(metrics.classification_report(y_test, res7, digits=4))plot_decision_region(X_train_std,y_train,classifier=forest,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘AdaBoostClassifier’)plt.legend(loc=’upper left’)plt.show()
输出结果如下：macro avg： 0.9792 0.9778 0.9778
precision recall f1-score support0 1.0000 1.0000 1.0000 151 0.9375 1.0000 0.9677 152 1.0000 0.9333 0.9655 15accuracy 0.9778 45macro avg 0.9792 0.9778 0.9778 45weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据分类效果如下图所示：
8.GradientBoosting核心代码如下：
#第11步 GradientBoosting分类from sklearn.ensemble import GradientBoostingClassifiergb = GradientBoostingClassifier()ada.fit(X_train_std,y_train)res8 = ada.predict(X_test_std)print(res8)print(metrics.classification_report(y_test, res8, digits=4))plot_decision_region(X_train_std,y_train,classifier=forest,resolution=0.02)plt.xlabel(‘petal length [standardized]’)plt.ylabel(‘petal width [standardized]’)plt.title(‘GradientBoostingClassifier’)plt.legend(loc=’upper left’)plt.show()
输出结果如下：macro avg： 0.9792 0.9778 0.9778
precision recall f1-score support0 1.0000 1.0000 1.0000 151 0.9375 1.0000 0.9677 152 1.0000 0.9333 0.9655 15accuracy 0.9778 45macro avg 0.9792 0.9778 0.9778 45weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据分类效果如下图所示：
9.实验结果对比最后通常需要对实验结果进行对比，由于数据集比较少，所有效果都比较好，这里不太好进行对比实验。简单给出两张对比结果图，但方法是类似的。随着作者深入会分享更多
