解决方案:百家号MCN矩阵软件
优采云 发布时间: 2022-10-12 05:22解决方案:百家号MCN矩阵软件
百家号MCN矩阵软件一直是我们表达自由的向往，尤其是从2017年至今，视频建设极为火爆，其粉丝互动性强、购买率优秀等无数亮点，慢慢吸引了无数人对于品牌方，我们通常会更新到所有平台，以获得更好的曝光率。但是，实际操作的时候，你会觉得：每天开始工作，都要输入账号密码一个一个登录，然后按顺序同步生产出来的内容，这肯定太浪费人力成本了。下面我有一套经验，免费与大家分享。
电子媒体助手：图片、文字、短视频同时上传到系统
为了获得更可喜的流量，很多人会加入秒拍、搜狐视频等十几个视频平台，如果只同步稿件，发8个平台需要30分钟，如果要上传短视频, 10个平台估计要半个多小时，最重要的是要保证多个发帖全部完成。达成目标后，你会发现每次同步都是极其耗时耗力的，但如果只使用易媒助手的一键发布软件，小视频、小视频发送到40多个新媒体平台一次，七八分钟全部释放，彻底解放双手。
自媒体如何蹭热点，成功“出类拔萃”？
内容垂直
你们玩自媒体这么久，大概对文章的垂直度有了一些了解吧。内容的垂直度是指你入驻时选择的领域。之后，你必须发布相关的行业内容。不要跨行业发布，为什么要这样做？因为容易掌握精准的人群推荐，增加账号权重，有利于提升平台推荐，从而增加阅读量。
追热点事件
互联网热点是爆文的优采云。如果你想获得大量的浏览量，你必须学会关注热点事件，然后根据热点事件快速编写你的作品。这样，内容本身就具有了流行属性。，能轻松获得大量系统推荐和高阅读量，自然特别有希望出产10万+。
帐户具有功能
自媒体内容的简化特别明显，所以作者多元化的作品更容易突破，那么如何实现多元化呢？在发展定位上，每个人都要有自己的个性点，而不是静态的内容。如何创造独特的点？其实很简单：停止臆测，从事自己擅长的内容，适当安排一些其他的内容。最好不要涉及高成本和不擅长的领域。这基本上可以做到。
在线测绘
平时文章在写稿子的过程中，总会遇到素材不是很漂亮，照片需要调整的情况。不过现在外面的主流软件实在是太专业了，初学者很难上手。大佬们特地珍藏了很多在线图片编辑网站希望对亲们有所帮助：*敏*感*词*制作，国外工具：Cacoo
高清图库
无论是视频封面还是文章封面，图片对整体数据的影响都很大。几张戳心的画面，会很好的赢得粉丝的打开意愿。但是，在大多数情况下，内容好的素材图片很少，无法使用。对了，我在下面找了几张高清图片网，各位高手，如果能帮到你，就不要光顾了，看这里：Creative Mass,
舆论数据
写文章的人，想要实现频繁的爆文，前提是要有热点意识。想出爆文最快的方法就是看各种热点话题，所以小编汇集了很多了解爆文的强大工具：新浪舆情链接、神策数据
舆论数据
控制内容的人一定要懂得关注热点，才能写出高质量的文章，而打磨爆文最快的方法就是浏览多个网站，于是我发现实时查看全网的一些工具爆文：EasyMedia Assistant、MobTech
解决方案:「Python从零到壹」 十四.机器学习之分类算法五万字总结全网首发
分类属于监督学习的范畴，是数据挖掘、机器学习、数据科学等重要的研究领域。分类模型类似于人类学习，从历史数据或训练集中学习以获得目标函数，然后使用该目标函数来预测新数据集的未知属性。本章主要介绍分类算法的基本概念，并分析各种数据集与决策树、KNN、SVM分类算法案例，让读者学会使用Python分类算法分析自己的数据集，研究自己的领域知识，创造价值。
一。分类
1. 分类模型
与前面描述的聚类分析模型类似，分类算法的模型如图 1 所示。它主要包括两个步骤：
通常，为了测试学习模型的性能，使用校验集。数据集分为不相交训练集和测试集，用于构造分类模型和测试集，以验证正确分类的类标签数量。
下面是一个分类示例。假设有一个垃圾分类系统将邮件分为“垃圾邮件”和“非垃圾邮件”，现在有一个训练集，其中收录垃圾邮件类目标，即它是否是垃圾邮件，然后训练一个分类模型以对测试集进行预测，如下所示：
经过上述步骤后，当我们收到新的电子邮件时，我们可以根据电子邮件的内容或特征来判断它是否是垃圾邮件，这为我们提供了极大的便利，可以防止垃圾邮件信息的骚扰。
2. 常用分类算法
监督学习包括分类和回归。常见的分类算法包括朴素贝叶斯分类器、决策树、K-最近邻分类算法、支持向量机、神经网络和基于规则的分类算法，以及用于组合单类方法的集成学习算法，例如 Bagging 和 Boosting。
（1） 朴素贝叶斯分类器
朴素贝叶斯分类器（NBC）起源于经典数学理论，具有坚实的数学基础和稳定的分类效率。该算法使用贝叶斯定理来预测未知类的样本属于每个类别的可能性，并选择最可能的类别作为样本的最终类别。其中，朴素贝叶斯法是基于贝叶斯定理和特征条件的独立假设，是一类利用概率和统计知识进行分类的算法，该算法被广泛使用的模型称为朴素贝叶斯模型（NBM）。
根据贝叶斯定理，对于分类问题，给定样本特征 x，样本属于类别 y 的概率为：
其中 p（x） 表示 x 事件发生的概率，p（y） 表示发生
y 事件，p（x|y） 表示事件发生 y 后事件 x 发生的概率。由于贝叶斯定理的建立需要一个强有力的条件独立性假设，这在实践中通常是不正确的，它的分类准确性会降低，并且对缺失的数据不那么敏感。本书没有详细介绍朴素贝叶斯分类的例子，我希望读者能够自己下来研究它。
（2） 决策树算法
决策树是一种基于实例的归纳学习算法，它为一组未排序和不规则的实例建立决策判断树，并推导树形结果的分类规则。作为分类和预测的主要技术之一，构建决策树以找出属性和类别之间的关系，并使用它来预测未知数据的类别。该算法采用自上而下的递归来比较决策树内部节点的属性，根据不同属性的值判断节点向下的分支，并在决策树的叶节点上得到反馈结果。
诊断树
算法使用树状结构根据数据的属性建立决策模型，通常用于解决分类和回归问题。常见的算法包括：分类和回归树、ID3、*敏*感*词*.5、随机森林等。
（3） K最近邻分类算法
K-最近邻 （KNN） 分类算法是一种基于实例的分类方法，是数据挖掘分类技术中最简单和最常用的方法之一。所谓K最近邻就是找K个最近邻，每个样本都可以用其最近的K个邻居来表示。该方法需要找出最接近未知样本X的K训练样本，看出这些K样本中的哪一类属于大数，然后将未知样本X分类到哪个类别中。
K-Near方法是一种惰性学习方法，用于存储样本直到需要分类，如果样本集很复杂，则可能导致较大的计算开销，因此无法应用于实时情况。
（4） 支持向量机
支持向量机（SVM）是数学家Vapnik等人基于统计学习理论提出的一种新的学习方法，其基本模型被定义为特征空间上间距最大的线性分类器，其学习策略是最大化间距并最终转化为凸二次规划问题的解。
SVM算法的最大特点是，根据结构风险最小化准则，构建最优分类超平面，最大化分类区间，提高学习机的泛化能力，较好地解决了非线性、高维、局部最小等问题，而当样本数量大于样本数量时，维度仍然有效， 并支持不同的核函数（线性、多项式、s 型等）。
（5） 神经网络
神经网络（也称为人工神经网络）算法在1980年代的机器学习中非常流行，但在1990年代中期有所下降。现在随着“深度学习”的趋势，它已经成为最强大的机器学习算法之一。图2是神经网络的一个示例，包括输入层、隐藏层和输出层。
人工神经网络（ANN）是一种数学或计算模型，模仿生物神经网络的结构和功能。在该模型中，大量节点或“神经元”相互连接以形成网络，即“神经网络”，以达到处理信息的目的。神经网络通常需要被训练，训练过程就是网络学习的过程，训练改变网络节点的连接权重值，使其具有分类功能，并且训练后的网络可以用于对象识别。
常见的人工神经网络有BP（反向传播）神经网络、径向基RBF神经网络、霍普菲尔德神经网络、随机神经网络（玻尔兹曼机）、深度神经网络DNN、卷积神经网络CNN等。
（6）综合学习
集成学习是一种机器学习方法，它使用一系列学习者进行学习，并使用一些规则来整合学习结果，以实现比单个学习者更好的学习结果。由于实际应用的复杂性和数据的多样性往往使单一的分类方法失效，学者们对多种分类方法的整合，即集成学习进行了广泛的研究，这已成为国际机器学习界的研究热点。
集成学习试图通过不断调用单个学习算法来获得不同的基础学习者，然后根据规则组合这些学习者来解决同一个问题，这可以显着提高学习系统的泛化能力。组合多个基础学习者主要使用投票（加权）方法，常见的算法是装袋，提升等。
3. 回归、聚类和分类之间的区别
在第12部分中，文章我们将详细解释回归分析，13详细解释聚类分析，本章重点介绍分类分析，但是它们之间的区别和关系是什么？
总之，分类学习知道训练过程中对应班级目标的结果，即训练集具有相应的班级目标;在训练过程中，聚类学习并不知道数据的相应结果，根据数据集的特征，按照“聚类事物”的方法，将具有相似属性的数据采集在一起。
4. 绩效评估
分类算法有很多种，不同的分类算法都有
许多不同的变体，不同的分类算法具有不同的特征，并且性能对不同数据集的影响也不同，我们需要根据具体任务选择相应的算法。选择分类算法后，如何评价分类算法的质量？
本书主要使用精度、召回率和 F 度量或 F 得分来评估分类算法。
（1） 准确率（精度）和召回率（召回率）
）。准确率定义为文档数量的比率
检索到检索到的文档总数，它衡量检索系统的准确率;召回率定义为检索到的相关文档数与文档库中所有相关文档数的比率，由检索系统测量。公式如下：
其中，参数N表示实验结果中正确识别的聚类数，S表示
在实验结果中实际识别的聚类，T表示数据集中实际存在的聚类相关聚类的数量。
（2） F 测量值或 F 分数
准确率和召回率这两个评价指标在某些情况下是相互限制的，使得很难用单一的评价指标来衡量实验的有效性。F值是精度和召回率的一致性平均值，可用作实验结果的最终评估指标，并且F值更接近两个数字中的较小者。F 值引用如下计算公式：
（3）其他指标
其他常用的分类算法包括评估指标
二。决策树
1. 算法实例说明
以下是招聘案例研究，用于解释决策树的基本原则和过程。假设程序员和面试官之间的简单对话进行初始面试，我们使用决策树分类的概念来构建树形结构。对话如下：
记者：你多大了？
程序员：25岁。
采访者：你本科毕业了吗？
程序员：是的。
采访者：编程技术强吗？
程序员：不太好，中等水平。
采访者：熟悉蟒蛇语言吗？
程序员：熟悉，做过数据挖掘相关的应用。
采访者：是的，你通过了。
这次面试的决策过程是一个典型的分类树决策。它相当于将程序员的初步考试分为两类，按年龄，教育程度，编程技能和对Python语言的熟悉程度：通过和失败。假设面试官的程序员要求是30岁以下，本科以上*敏*感*词*，编程能力强或熟悉Phoeon语言及以上编程技能的程序员，则该面试官的决策逻辑过程如图3所示。
第二个例子是
判断苹果的决策树的典型例子，假设有4个样本和2个属性来确定它是否是一个好苹果，其中第二列1表示苹果非常红，0表示苹果不红;1的第三列表示苹果大，0表示苹果小;第4列结果1表示苹果好吃，0表示苹果不好吃。
示例中有 2 个属性，即苹果红色属性和苹果大小属性。这里，红苹果用 A0 表示，大苹果用 A1 表示，构建的决策树如图 19.4 所示。图的顶部有四个苹果（1，2，3，4），然后把红苹果放在一边（A0=红色），另一边不是红色的苹果，结果是1，2是红苹果，3，4不是红苹果;然后根据苹果的大小进行划分，判断大苹果好吃（A1=大），最终输出如图三层所示，其中1和3是好吃的苹果，2和4是坏苹果，示例表明苹果越大，味道越好。
决策树算法基于数据的属性构建决策模型，并采用树状结构，通常用于解决分类和回归问题。常见的决策树算法包括
：
决策树构建的基本步骤包括4个步骤，具体步骤如下：
决策数量有两个优点：
2. 数字信号处理器算法
在 Sklearn 机器学习包中，实现决策树分类器 （DTC） 的类包括：
sklearn.tree.DecisionTree分类器
它解决了数据集的多类分类问题，输入参数为两个数组X[n_samples，n_features]和y[n_samples]，X是训练数据，y是训练数据标记值。决策树分类器构造函数是：
sklearn.tree.DecisionTreeClassifier(criterion='gini'
, splitter='best'
, max_depth=None
, min_samples_split=2
, min_samples_leaf=1
, max_features=None
, random_state=None
, min_density=None
, compute_importances=None
, max_leaf_nodes=None)
类由两个主要方法组成：
train_target train_data）
用于加载（train_data、train_target）训练数据和训练分类模型。
pre = clf.predict（test_data）
使用经过训练的决策树模型对test_data测试集执行预测分析。
3. 虹膜的决策树分析
之前的12文章介绍了虹膜的逻辑回归分析的例子，这里又讲解了虹膜实例的决策树分析，从而加深了读者的印象。
（1）数据集回顾
在Sklearn机器学习包中，集成了各种各样的数据集，包括糖尿病数据集，虹膜数据集，新闻数据集等。这里使用的是Iris的Iris数据集，这是一个非常常用的数据集，共有150行数据，包括四个特征变量：
还包括一个分类变量，将虹膜分为三类，即：
表2为虹膜数据集，详情如下表所示。
鸢尾是一种鸢尾植物，这里存储着其萼片和花瓣的长度和宽度，共有4种属性，鸢尾花植物分为三类。虹膜数据集包括两个属性：虹膜数据和虹膜目标。其中，数据数据为矩阵，每列表示萼片或花瓣的长度和宽度，共4列，每行数据表示一株实测鸢尾花，共抽样150条记录。加载 Iris 数据集的代码如下所示：
from sklearn.datasets import load_iris
iris = load_iris()
print(iris.data)
print(iris.target)
（2）虹膜的决策树简单分析
以下代码在 Sklearn 机器学习包中实现用于分类分析的决策树分类器决策树算法，并绘制预测的散点图。
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
#导入数据集iris
from sklearn.datasets import load_iris
iris = load_iris()
print(iris.data) #输出数据集
print(iris.target) #输出真实标签
print(len(iris.target))
print(iris.data.shape) #150个样本 每个样本4个特征
#导入决策树DTC包
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier()
clf.fit(iris.data, iris.target) #训练
print(clf)
predicted = clf.predict(iris.data) #预测
#获取花卉两列数据集
X = iris.data
L1 = [x[0] for x in X]
L2 = [x[1] for x in X]
#绘图
import numpy as np
import matplotlib.pyplot as plt
plt.scatter(L1, L2, c=predicted, marker='x') #cmap=plt.cm.Paired
plt.title("DTC")
plt.show()
输出结果如图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 0
0 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 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)
DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
max_features=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, presort=False,
random_state=None, splitter='best')
以下是上述核心代码的简要说明。
这部分代码是导入
sklearn机器学习包附带的虹膜数据集，调用load_iris（）函数导入数据，数据分为数据和目标两部分。
这部分代码导入决策树模型，并调用 fit（） 函数进行训练，调用 predict（） 函数进行预测。
这部分代码是导入 matplotlib 绘制扩展包并调用 scatter（） 函数来绘制散点图。
但是上面的代码中有两个问题：
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 0
0 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 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]
调用NumPy库中的contanate（）函数来选择和集成数据集，选择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.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)
同时，调用sklearn机器学习包中的指标类来评估决策树分类算法，该算法将输出准确性（优先级），召回率（召回率），F得分（F得分），支持（支持）等。
#输出准确率 召回率 F值
from sklearn import metrics
print(metrics.classification_report(test_target, predict_target))
print(metrics.confusion_matrix(test_target, predict_target))
分类报告的核心功能是：
sklearn.metrics.classification_report(y_true,
y_pred,
labels=None,
target_names=None,
sample_weight=None,
digits=2)
其中y_true参数表示正确的分类类标签，y_pred表示类标签
由分类预测，标签表示分类报告中显示的类标签的索引列表，target_names参数显示与标签对应的名称，数字是指定输出格式的准确性。评估公式如下：
调用metrics.classification_report（）方法评估决策树算法后，所有指标的加权平均值将在最后一行执行，如下面的完整代码中所述。
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn import metrics
import numpy as np
import matplotlib.pyplot as plt
#导入数据集iris
'''
重点：分割数据集 构造训练集/测试集，80/20
70%训练 0-40 50-90 100-140
30%预测 40-50 90-100 140-150
'''
iris = load_iris()
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.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) #测试集样本类别
#导入决策树DTC包
clf = DecisionTreeClassifier()
clf.fit(train_data, train_target) #注意均使用训练数据集和样本类标
print(clf)
predict_target = clf.predict(test_data) #测试集
print(predict_target)
#预测结果与真实结果比对
print(sum(predict_target == test_target))
#输出准确率 召回率 F值
print(metrics.classification_report(test_target, predict_target))
print(metrics.confusion_matrix(test_target, predict_target))
#获取花卉测试数据集两列数据
X = test_data
L1 = [n[0] for n in X]
L2 = [n[1] for n in X]
#绘图
plt.scatter(L1, L2, c=predict_target, marker='x') #cmap=plt.cm.Paired
plt.title("DecisionTreeClassifier")
plt.show()
输出结果如下，包括
数据集 40-50、90-100、140-150 和下一个输出“30”表示整个 30 组类尺度的预测结果与实际结果一致，最终输出评估结果进行评估。
[0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2]
30
precision recall f1-score support
0 1.00 1.00 1.00 10
1 1.00 1.00 1.00 10
2 1.00 1.00 1.00 10
avg / total 1.00 1.00 1.00 30
[[10 0 0]
[ 0 10 0]
[ 0 0 10]]
同步输出图如图6所示。
读者可以更深入地挖掘并调用sklearn.tree.export_graphviz类来实现导出决策树以绘制树结构的过程，例如图7所示的虹膜数据集输出树结构。
5. 区域划分的比较
下面介绍一下区域划分比较实验（前面已经出现过），它指的是根据数据集的实际类比例将其划分为不同的颜色区域，其中虹膜数据集分为三个区域，最后比较散点图。每个区域对应一种散点类型，表示预测结果与真实结果一致，如果一个区域与其他类型的散射混合，则表示该点的预测结果与真实结果不一致。
完整的代码如下，代码首先调用“iris.data[：：2]”代码获取两列数据（两个特征），然后进行决策树分类分析。
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
#载入鸢尾花数据集
iris = load_iris()
X = X = iris.data[:, :2] #获取花卉前两列数据
Y = iris.target
lr = DecisionTreeClassifier()
lr.fit(X,Y)
#meshgrid函数生成两个网格矩阵
h = .02
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
#pcolormesh函数将xx,yy两个网格矩阵和对应的预测结果Z绘制在图片上
Z = lr.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.figure(1, figsize=(8,6))
plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired)
#绘制散点图
plt.scatter(X[:50,0], X[:50,1], color='red',marker='o', label='setosa')
plt.scatter(X[50:100,0], X[50:100,1], color='blue', marker='x', label='versicolor')
plt.scatter(X[100:,0], X[100:,1], color='green', marker='s', label='Virginica')
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.xticks(())
plt.yticks(())
plt.legend(loc=2)
plt.show()
以下作者详细解释了区域划分比较代码。
在虹膜上获得的两列数据对应于萼片的长度和萼片的宽度，每个点的坐标为（x，y）。首先取X二维数组第一列（长度）的最小值、最大值和步长h（设置为0.02）生成数组，然后取X二维数组第二列（宽度）的最小值、最大值和步长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_
调用 ravel（） 函数将 xx 和 yy 两个矩阵转换为一维数组，然后执行预测分析。由于两个矩阵的大小相等，因此两个一维数组的大小也相等。np.c_[xx.拉威尔（）， yy.拉威尔（）] 是一个生成矩阵，即：
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.ravel(), yy.ravel()])
[1 1 1 ..., 2 2 2]
size: 39501
Z = Z 形重塑（xx.
调用reshape（）函数修改形状，将其Z转换为两个特征（长度和宽度），然后将39501数据转换为171 * 231的矩阵。Z = Z 形（xx 形状）输出，如下所示：
[[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.配对）
调用 pcolormesh（） 函数在图片上绘制 xx 和 yy 两个网格矩阵以及相应的预测结果 Z，您可以发现输出的是三个色块，表示三种类型的区域。输出区域如下图所示：
普特散射（X[：50，0]， X[：50，1]， 颜色=“红色”，标记=“o”，标签=“塞托萨”）
调用 scatter（） 绘制散点图，第一个参数是第一列数据（长度），第二个参数是
第二列数据（宽度），第三和第四个参数是设定点的颜色是红色的，样式是一个圆圈，最后一个参数被标记为setosa。
最终输出如图9所示，在决策树分析后分为三个区域，左上角是对应于setosa虹膜的红点;右侧部分是对应于*敏*感*词*虹膜的绿色正方形;中下部是一颗蓝色的星星，对应于杂色虹膜。散点图是每个数据点的真实花朵类型，划分的三个区域是数据点预测的花朵类型，预测的分类结果与训练数据的真实结果基本一致，部分鸢尾花相交。
三、KNN分类算法
1. 算法实例说明
KNN分类算法是最近邻算法，字面意思是查找最近邻，由Cover和Hart于1968年提出，它简单直观，易于实现。下面是一个经典示例，用于说明如何查找邻居以及要选择多少个邻居。图10需要确定右边的动物是鸭子、鸡还是鹅。这涉及KNN算法的核心思想，判断类似于此示例点的类别，然后预测它们所属的类别。由于它像鸭子一样走路和吠叫，右边的动物很可能是鸭子。
KNN 分类算法的核心思想是从训练样本 X 中找到所有训练样本 X 中最接近测试样本（通常为欧氏距离）的前 K 个样本（作为相似性），然后选择与样本距离最小的 K 样本进行分类为最接近 X 的 K 个样本， 并检测这些K样本中的大多数属于哪种类型的样本，然后测试样本类别属于这种类型的样本。
KNN 分类的算法步骤如下：
假设现在有必要确定图 11 中的圆形形态是属于三角形还是正方形类别，则使用 KNN 算法的分析步骤如下：
最后，简要讨论了KNN算法的优缺点。KNN 分类算法的优点包括：
缺点主要表现为分类速度慢，因为每个待分类的新样本都必须计算出与所有训练集的相似性进行比较，才能取出前K个分类样本，因此时间复杂度较高。整个算法的时间复杂度可以表示为 O（m*n），其中 m 是所选特征项的数量，n 是训练集样本的数量。同时，如果K值确定不好，也会影响整个实验的结果，这是KNN算法的另一个缺点。
2.奈格伯斯分类器
在 Sklearn 机器学习包中，实现 KNN 分类算法的类是邻居。KNei*敏*感*词*orsClassifier.构造函数如下所示：
KNei*敏*感*词*orsClassifier(algorithm='ball_tree',
leaf_size=30,
metric='minkowski',
metric_params=None,
n_jobs=1,
n_nei*敏*感*词*ors=3,
p=2,
weights='uniform')
最重要的参数之一是 n_nei*敏*感*词*ors=3，它设置最近的邻居 K 值。同时，KNei*敏*感*词*ors分类器可以设置3种算法：暴力破解，kd_tree ball_tree。具体调用方法如下：
from sklearn.nei*敏*感*词*ors import KNei*敏*感*词*orsClassifier
knn = KNei*敏*感*词*orsClassifier(n_nei*敏*感*词*ors=3, algorithm="ball_tree")
KNN算法还包括分析时的训练和预测两种方法。
下面的代码是对 KNN 分类算法进行预测的简单调用的示例，代码如下所示。
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
import numpy as np
from sklearn.nei*敏*感*词*ors import KNei*敏*感*词*orsClassifier
X = 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],[2,6]]
knn = KNei*敏*感*词*orsClassifier(n_nei*敏*感*词*ors=3, algorithm="ball_tree")
knn.fit(X,Y)
pre = knn.predict(x)
print(pre)
定义二维数组以存储 6 个点，其中具有负 x 和 y 坐标的类标签定义为 0，将 x 和 y 坐标为正数的类标签定义为 1。调用 knn.fit（X，Y） 函数来训练模型后，再调用 predict（） 函数来预测 [4，5]、 [-4，-3]、 [2，6] 三个点的坐标，输出结果为：[1， 0， 1]，其中 x 和 y 坐标被划分为一个正数类和一个类用于负数。
也可以计算K个最近点的下标和距离，代码和结果如下，其中索引表示点的下标，距离表示距离。
distances, indices = knn.knei*敏*感*词*ors(X)
print(indices)
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.60555128]
[ 0. 2. 2.23606798]]
>>>
以下是结合可视化技术以加深读者印象的完整示例。
3. KNN分析葡萄酒的种类
（1） 数据集
实验数据集是
由UCI机器学习存储库开源网站提供的最受欢迎的数据集（自2007年以来点击）红酒数据集，这是对意大利同一地区生产的三种不同葡萄酒进行大量分析的结果。这些数据包括三类葡萄酒，共有13种不同的葡萄酒成分特征，共有178条线数据，如图13所示。
该数据集包括三种葡萄酒中13种不同成分的数量：酒精，马利卡西，灰分，灰分的酒精度，镁，总酚，黄烷类，诺弗拉瓦诺酚，原花青素，颜色强度，色调，稀释葡萄酒的OD280 / OD 315和脯氨酸，每种成分都可以看作是一个特征，对应于一个数据。这三种类型的葡萄酒被标记为“1”，“2”和“3”。数据集的特征如表3所示。
数据存储在葡萄酒.txt文件中，如图 14 所示。每行数据表示178行数据的样本，每行数据收录14列，即第一列是类标签属性，后跟13列要素。其中，第1类有59个样本，2类有71个样本，3类有48个样本。
注意：前面描述了如何读取CSV文件数据集或Sklearn扩展包提供的数据集，但在现实分析中，许多数据集将存储在TXT或DATA文件中，它们被某些符号分隔，例如在图表中使用逗号分隔，如何获取此类文件中的数据， 也是非常重要的知识。因此，让我们教您阅读此类文件的数据。
（2） 读取数据集
从图 14 中，
你可以看到整个数据集都是用逗号分隔的，而读取这类数据集的常用方法是调用open（）函数来读取文件，依次读取TXT文件的所有内容，然后按照逗号分割器获取存储在数组或矩阵中的每行数据中的14列数据， 以便进行数据分析。下面是另一种调用 loadtxt（） 函数以使用代码读取逗号分隔数据的方法，如下所示：
# -*- coding: utf-8 -*-
import os
import numpy as np
path = "wine/wine.txt"
data = np.loadtxt(path,dtype=float,delimiter=",")
print(data)
输出如下：
loadtxt（） 读入文件函数原型如下：
loadtxt（fname， dtype， 分隔符， converters， usecols）
其中，参数 fname 表示文件路径，dtype 表示数据类型，分隔符表示分隔符，转换器使用 {1：fun} 等字段映射数据列，usecols 表示选取数据的列。
（3） 数据集拆分训练集和预测集
由于 Wine 数据集的前 59 个样本均为 1 类，中间 71 个样本为 2 类，最后 48 个样本为 3 类，因此需要将数据集拆分为训练集和预测集。步骤如下：
代码如下：
# -*- coding: utf-8 -*-
import os
import numpy as np
path = "wine/wine.txt"
data = np.loadtxt(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: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)
输出如下：
(178L, 1L)
(178L, 13L)
(100L, 1L) (100L, 13L)
(78L, 1L) (78L, 13L)
下面是一个随机拆分方法，调用sklearn.model_selection.train_test_split 类来随机划分训练集和测试集。代码如下：
from sklearn.model_selection import train_test_split
x, y = np.split(data, (1,), axis=1)
x_train, 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。此函数导入到model_selection类的 sklearn 库的某些版本中，建议读者尝试一下。
（4） KNN分类算法分析
将上述178个样本分为100个训练样本和78个测试样本，使用KNN分类算法对模型进行训练，然后预测测试集，确定测试样本所属的酒种，并输出测试样本计算的正确率和错误率。KNN 核心代码如下：
from sklearn.nei*敏*感*词*ors import KNei*敏*感*词*orsClassifier
clf = KNei*敏*感*词*orsClassifier(n_nei*敏*感*词*ors=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 2
2 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 1
1 1 1 3]
（5） 完整代码
以下代码在 Sklearn 机器学习包中实现 KNei*敏*感*词*ors 分类器算法进行分类分析，并绘制预测的散点图和背景图，完整代码如下。
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
import os
import numpy as np
from sklearn.nei*敏*感*词*ors import KNei*敏*感*词*orsClassifier
from sklearn import metrics
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
from 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列特征为x
print(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 = KNei*敏*感*词*orsClassifier(n_nei*敏*感*词*ors=3,algorithm='kd_tree') #K=3
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)) #生成网格型数据
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']) #颜色Map
cmap_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 2
2 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 3
3 3 1 3]
58
precision recall f1-score support
1 0.68 0.89 0.77 19
2 0.88 0.74 0.81 31
3 0.67 0.64 0.65 28
avg / total 0.76 0.74 0.74 78
输出图如图15所示，可以看到整个区域分为三种颜色，左下角是绿色区域，右下角是红色区域，右上部分是蓝色区域。它还包括 78 个点的分布，对应于 78 行数据的类标签，包括绿色、蓝色和红色点。可以发现，同色点主要集中在这个颜色区域，一些蓝点被分成红色区域或绿点分成蓝色区域，说明预测结果与实际结果不一致。
最后，简单总结一下，整个分析过程由六个步骤组成，大致如下：
1） 加载数据集
loadtxt（） 函数用于加载葡萄酒数据集，该数据集由逗号 （，） 拆分。
2） 划分数据集
由于 Wine 数据集的第一列被列为类标签，
接下来的13列被列为13个酒特征，得到其中的两个特征，将其划分为一个特征数组和一个类标签，并调用contanate（）函数实现。
3） 知识库学校培训
调用 Sklearn 机器学习包中的 KNehbors 分类器（） 函数训练，将 K 值设置为类 3，并调用 clf.fit（train_data，train_target） 来训练模型，并调用 clf.predict（test_data） 来预测分类结果。
4） 评估算法
此分类的预测结果的准确性、召回率和 F 值由 classification_report（） 函数计算。
5） 创建网格
由于在剧情中，
预测的类尺度分为三个颜色区域，而真实的分类结果以散点图的形式呈现，因此需要获得数据集中两列特征的最大值和最小值，并创建相应的矩阵网格，调用 meshgrid（） 函数实现 numpy 扩展包， 并预测其颜色。
6） 绘图可视化
设置不同类刻度的颜色，调用 pcolormesh（） 函数来绘制
背景区域颜色，并调用dist（）函数绘制实际结果的散点图，形成如图15所示的效果。
四、SVM分类算法
支持向量机 （SVM） 是一种常见的判别方法。在机器学习领域，它是一种监督学习模型，通常用于模式识别、分类和回归分析。该算法的最大特点是，根据结构风险最小化准则，构建最优分类超平面，使分类区间最大化，提高学习机的泛化能力，更好地解决非线性、高维、局部最小等问题。
1. 软件知识安全模块基础知识
（1） 基本概念
由于笔者的数学估计能力不是很好，而且SVM原理也比较复杂，所以SVM算法的基础知识建议大家阅读CSDN博客著名算法神“JULY”文章《支持向量机通俗介绍（了解SVM领域的三层）》，本文文章从浅浅而深入的解释来解释SVM算法， 本节的作者主要讲解了SVM的用法。
SVM分类算法的核心思想是通过建立某种核函数，找到一个满足高维数据分类要求的超平面，使训练集中的点尽可能远离分类平面，即找到一个分类面，使其两侧的空白区域最大化。如图 19.16 所示，最接近分类表面并平行于最佳分类表面的两种样本的超平面上的训练样本称为支持向量。
（2） SVM 导入方法
SVM 分类算法在 Sklearn 机器学习包中实现，实现的类是 svm。SVC 或 C 支持向量分类是基于库实现的。构造函数如下所示：
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)
其中参数的含义如下：
SVC 算法主要包括两个步骤：
下面的代码是一个简单的调用 SVC 分类算法进行预测的示例，数据集中具有负 x 和 y 坐标的类标记为 1，将 x 和 y 坐标为正数的类标记为 2，将预测点的类标记为 1， 并且点 [2，1] 的类被标记为 2。
import numpy as np
from sklearn.svm import SVC
X = 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核支持向量分类、线性SVC线性向量支持分类等，这里不做介绍。同时，支持向量机也被推广到解决回归问题，称为支持向量回归，如SVR做线性回归。
2. SVM 分析葡萄酒数据
然后，使用 SVM 分类算法
用于对葡萄酒数据集进行分析，通过比较上一节19.3中的示例代码，验证了SVM分类算法和KNN分类算法的分析结果和可视化分析。其分析步骤基本一致，主要包括以下六个步骤：
完整的代码如下所示：
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
import os
import numpy as np
from sklearn.svm import SVC
from sklearn import metrics
import matplotlib.pyplot as plt
from 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列特征为x
print(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']) #颜色Map
cmap_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分析的简单代码优化示例，主要包括：
完整的代码如下，希望读者也能仔细研究这部分知识，以更好的优化自己的研究或课题。
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
import os
import numpy as np
from sklearn.svm import SVC
from sklearn import metrics
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from 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列特征为x
print(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)
<p>
#第三步 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()</p>
输出如下所示，精度低，召回率低，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 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]
[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 3
3 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]
28
precision recall f1-score support
1 1.00 0.04 0.07 26
2 0.38 1.00 0.55 27
3 0.00 0.00 0.00 19
avg / total 0.50 0.39 0.23 72
使用下面的决策树对上述代码进行分析，其准确性、召回率和 F 值都很高，结果如下。因此，并不是每个分析算法都适应所有的数据集，不同的数据集有不同的特点，计算出最好的分析也会有所不同，我们通常在分析数据时比较多种分析算法，然后优化自己的实验和模型。
from sklearn.tree import DecisionTreeClassifier
clf = 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 算法分析后的图形输出如下所示。
五。每个模型的分类比较实验
算法评估和
比较实验是深度学习的一个重要知识点，笔者在这里比较了各种机器学习分类算法，以虹膜数据集为例，分别比较了分类边界效应和实验评价指标（精度、召回率、F1-socre）。
1. 决策树
原创代码如下：
# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2021-07-06
# 该部分参考知乎萌弟老师：https://zhuanlan.zhihu.com/p/173945775
import numpy as np
from sklearn import metrics
from sklearn import datasets
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
#------------------------------------------------------------------------
#第一步 导入数据
iris = datasets.load_iris()
X = iris.data[:,[2,3]]
y = iris.target
print("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和sigma
sc.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 surface
x1_min,x1_max = X[:,0].min()-1,X[:,0].max()+1
x2_min,x2_max = X[:,1].min()-1,X[:,1].max()+1
xx1,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 samples
for 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 DecisionTreeClassifier
tree = 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 45
res1 = 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值输出如下：
宏平均： 0.9792 0.9778 0.9778
precision recall f1-score support
0 1.0000 1.0000 1.0000 15
1 0.9375 1.0000 0.9677 15
2 1.0000 0.9333 0.9655 15
accuracy 0.9778 45
macro avg 0.9792 0.9778 0.9778 45
weighted avg 0.9792 0.9778 0.9778 45
分类效果
绘制的训练数据如下图所示，可以看出分类效果明显。
2.克尼恩
核心代码如下：
宏平均： 0.98 0.98 0.98
#第五步 KNN分类
from sklearn.nei*敏*感*词*ors import KNei*敏*感*词*orsClassifier
knn = KNei*敏*感*词*orsClassifier(n_nei*敏*感*词*ors=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('KNei*敏*感*词*orsClassifier')
plt.legend(loc='upper left')
plt.show()
输出如下：
宏平均： 0.9792 0.9778 0.9778
precision recall f1-score support
0 1.0000 1.0000 1.0000 15
1 0.9375 1.0000 0.9677 15
2 1.0000 0.9333 0.9655 15
accuracy 0.9778 45
macro avg 0.9792 0.9778 0.9778 45
weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据的分类效果如下图所示：
3.高级管理
核心代码如下：
#第六步 SVM分类 核函数对非线性分类问题建模(gamma=0.20)
from sklearn.svm import SVC
svm = 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()
输出如下：
宏平均： 0.9361 0.9333 0.9340
precision recall f1-score support
0 1.0000 0.9333 0.9655 15
1 0.9333 0.9333 0.9333 15
2 0.8750 0.9333 0.9032 15
accuracy 0.9333 45
macro avg 0.9361 0.9333 0.9340 45
weighted avg 0.9361 0.9333 0.9340 45
绘制的训练数据的分类效果如下图所示：
如果使用核函数 gamma 为 100，然后实现非线性分类，则结果绘制如下图所示：
svm = SVC（内核='rbf'，random_state=1，伽玛=100.0，C=1.0，详细=1）
来自不同伽马的图像
值：对于高斯核函数，增加伽马值将增加训练样本的影响范围，导致决策边界的收紧和波动;较小的伽马应该进入相对宽松的决策边界。虽然较大的伽玛值在训练样本中具有较小的训练误差，但泛化能力可能较差，并且容易过度拟合。
4. 逻辑回归
核心代码如下：
#第七步 逻辑回归分类
from sklearn.linear_model import LogisticRegression
lr = 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()
输出如下：
宏平均： 0.9792 0.9778 0.9778
precision recall f1-score support
0 1.0000 1.0000 1.0000 15
1 0.9375 1.0000 0.9677 15
2 1.0000 0.9333 0.9655 15
accuracy 0.9778 45
macro avg 0.9792 0.9778 0.9778 45
weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据的分类效果如下图所示：
5. 朴素贝叶斯
核心代码如下：
#第八步 朴素贝叶斯分类
from sklearn.naive_bayes import GaussianNB
gnb = 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()
输出如下：
宏平均： 0.9792 0.9778 0.9778
precision recall f1-score support
0 1.0000 1.0000 1.0000 15
1 0.9375 1.0000 0.9677 15
2 1.0000 0.9333 0.9655 15
accuracy 0.9778 45
macro avg 0.9792 0.9778 0.9778 45
weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据的分类效果如下图所示，相当不错，边界呈曲线分布。
6. 随机森林
核心代码如下：
#第九步 随机森林分类
from sklearn.ensemble import RandomForestClassifier
forest = 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()
输出如下：
宏平均： 0.9792 0.9778 0.9778
precision recall f1-score support
0 1.0000 1.0000 1.0000 15
1 0.9375 1.0000 0.9677 15
2 1.0000 0.9333 0.9655 15
accuracy 0.9778 45
macro avg 0.9792 0.9778 0.9778 45
weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据的分类效果如下图所示：
7.阿达助推器
核心代码如下：
#第十步 集成学习分类
from sklearn.ensemble import AdaBoostClassifier
ada = 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()
输出如下：
宏平均： 0.9792 0.9778 0.9778
precision recall f1-score support
0 1.0000 1.0000 1.0000 15
1 0.9375 1.0000 0.9677 15
2 1.0000 0.9333 0.9655 15
accuracy 0.9778 45
macro avg 0.9792 0.9778 0.9778 45
weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据的分类效果如下图所示：
8.梯度增压
核心代码如下：
#第11步 GradientBoosting分类
from sklearn.ensemble import GradientBoostingClassifier
gb = 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()
输出如下：
宏平均： 0.9792 0.9778 0.9778
precision recall f1-score support
0 1.0000 1.0000 1.0000 15
1 0.9375 1.0000 0.9677 15
2 1.0000 0.9333 0.9655 15
accuracy 0.9778 45
macro avg 0.9792 0.9778 0.9778 45
weighted avg 0.9792 0.9778 0.9778 45
绘制的训练数据的分类效果如下图所示：
9. 实验结果比较
最后，通常需要比较实验结果，因为数据集相对较小，所有结果都比较好，在这里比较实验并不容易。简单地给出比较结果的两个图，但方法相似。随着作者的深入，将分享更多相关的文章。
六。本章摘要
到此，这文章结束了，你对分类有更好的了解吗？
聚类分析是一种无监督学习算法，它不需要通过定义一个距离测量方法来标记结果，该方法指示两个事物的相似程度，然后将具有高类内相似性和低类间相似性的数据放在一个类中。相比之下，分类需要标记类目标，这属于监督学习，这意味着采集某类数据的共同特征，找出差异性大的特征，利用这些特征对要分类的数据进行分类，并且由于它是标记结果，因此可以通过重复训练来改进分类算法。
常见的分类算法包括朴素贝叶斯、逻辑回归、决策树、支持向量机等。常见应用，如分析市民历史公交卡交易数据，对乘客出行习惯和偏好进行分类和预测;京东从海量产品图片中提取图片特征，通过分类向用户推荐产品和广告，如“查找相同”应
