前言

终于到了激动人心的地方了，这部分将会说明如何使用sklearn库相关函数来调用并实现相关机器学习模型的训练和预测。对于不懂代码的小伙伴来说，在一般情况下也可以复制并在相关数据集上套用，并对相关参数我会进行说明。

如你所见，这篇标题中指的是：监督学习分类的sklearn机器学习。在参考和使用本篇代码请确保你已经下载安装并配置好 Python 相关环境（如果没有，请参考【sklearn】机器学习环境搭建）和如下举例的包。

关于本篇的说明：

  • 使用的 Python 版本为 3.10.9（理论上你只要是 v3.0 以上就可以）
  • 在相关机器学习的文章中使用但是不限于如下的基本 Python 包，如果有使用其他包，将会在文章内容中做详细说明：
  • 另外请注意，本篇不会详细说明每个算法的原理，这并不是本文的初衷，所以如果你对算法的原理不了解或者感兴趣可以先了解算法的原理，再参考本文的代码实现

常见集成学习算法

常见分类算法 API 类别 适用类型
K近邻算法（KNN） sklearn.neighbors 机器学习
决策树算法 sklearn.tree 机器学习
Logistic 回归（逻辑回归） sklearn.linear_model 机器学习 标称型和数值型数据
朴素贝叶斯算法 sklearn.naive_bayes 机器学习 标称型数据
支持向量机 sklearn.svm 机器学习 标称型和数值型数据
人工神经网络（ANN） sklearn.neural_network 机器学习
随机森林 sklearn.ensemble 集成学习
Bagging Classifier sklearn.ensemble 集成学习
AdaBoost Classifier sklearn.ensemble 集成学习
Gradient Boosting Machine sklearn.ensemble 集成学习
Stacking sklearn.ensemble 集成学习
Voting Classifier sklearn.ensemble 集成学习

关于集成学习可以大致分为两类：

  • Bagging（袋装）算法：Bagging方法的特点是并行构建多个基分类器，每个基分类器使用不同的数据子集进行训练，然后将它们的预测结果进行组合。这些方法通过减小模型的方差来提高性能，通常对抗过拟合。
    • Bagged Classifier
    • 随机森林
    • Extra Trees（极端随机树）
  • Boosting（提升）算法：Boosting方法的特点是串行构建多个基分类器，每个基分类器都会关注前一轮中错误分类的样本，以逐步提高模型的性能。Boosting方法通常通过减小模型的偏差来提高性能，可以更好地适应复杂的数据。
    • AdaBoost
    • Gradient Boosting Machine（GBM）
    • XGBoost
    • LightGBM
    • CatBoost
    • 等等

数据集说明

关于本篇使用的数据集是基于sklearn包自带的鸢尾花数据集（Iris Dataset），该数据集一共 150 个数据，一共三个类别，其中每个类别数据量 50 个，维度（特征）是四个。

1
2
3
4
5
6
from sklearn.datasets import load_iris

# 读取数据
dataset = load_iris()
# 输出标签数量（即类别）
print(dataset.target_names)

输出：['setosa' 'versicolor' 'virginica']。

K近邻算法

算法原理

在特征空间中，如果一个样本附近的k个最近(即特征空间中最邻近)样本的大多数属于某一个类别，则该样本也属于这个类别。——百度百科

简单概述来说就是距离你最近的 k 个数据的类别统计，然后选择其中类别占比最多的类别为你新数据预测的类别。这也就是 K近邻算法的 K 的由来。

算法原型

KNN 算法函数原型：

1
class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, *, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None)

常用参数说明：

  • n_neighbors ：（整型）默认为 5，用于查询最近邻居数量
  • weights：用于预测的权重函数。可选值：
    • uniform：（默认值）统一权重，邻近的所有点权重一致。
    • distance：权重点按距离的倒数计算。在这种情况下，查询点较近的邻居将会比远处的邻居有更大的权重
    • [callable]：自定义权重。
  • algorithm：用于 KNN 算法类型，可选值：
    • ball_tree：将使用BallTree
    • kd_tree ：将使用KDTree
    • brute：将使用暴力搜索。
    • auto：（默认值）将尝试根据传递给fit方法的值来决定最合适的算法。
  • n_jobs：（整型）默认为 None。运行邻居搜索的并行作业数。-1意味着使用所有处理器。

其他详细参数，点我查看官方文档对于 KNN 的说明

代码示例

现在我们来直接上代码来使用 K近邻算法，直接用数据感受算法带来的结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 读取数据
dataset = load_iris()

# 划分训练集和测试集，我们划分 20% 的数据用于测试集，80% 用于训练集，给定一个随机种子 42
x_train, x_test, y_train, y_test = train_test_split(dataset.data, dataset.target, test_size=0.2,random_state=42)

# 定义一个 KNN 分类器对象
knn = KNeighborsClassifier()

# 训练分类器
knn.fit(x_train,y_train)

# 使用训练好的模型进行预测
y_pred = knn.predict(x_test)

# 计算模型的准确率
accuracy = accuracy_score(y_test,y_pred)
print(f'KNN 算法训练的模型准确率：{accuracy * 100:.2f}%')

关于示例中的随机种子参数 42，有个很有意思的典故：42，是道格拉斯·亚当斯所作的小说《银河系漫游指南》中“生命、宇宙以及任何事情的终极答案”的答案，由于该作品的广泛流传，而成为在其他行业借此对该作品的致敬。

在故事中，一个具有高度智慧的跨维度生物种族为了找出一个能够回答终极问题的简单答案，所以制造了一台名叫“深思（Deep Thought）”超级电脑来计算，深思花费750万年来计算和验证，最后回答答案是42。当被继续要求提供所谓的终极问题时，深思表示无法直接给出，但可以给出制造一台更大的超级计算机来计算，该种族按照方案制造了这台超级计算机，而这台计算机就是地球。该种族花费了漫长的等待去获得结果，但可惜的是，经过1000万年，在快得出结果的前5分钟，地球因为阻挡了预定兴建的星际间高速公路的路线，被Vogons族毁灭，未能给出最后的结果。

可视化算法

可视化模型算法的方式有很多，此处使用一个基本的二维填图的方式，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# 绘图包
import matplotlib.pyplot as plt
# 数学包
import numpy as np
# 数据集
from sklearn.datasets import load_iris
# K近邻库
from sklearn.neighbors import KNeighborsClassifier
# 数据切分库
from sklearn.model_selection import train_test_split
# 数据计算库
from sklearn.metrics import accuracy_score
# 颜色库
from matplotlib.colors import ListedColormap

# 读取数据
dataset = load_iris()

# 划分训练集和测试集，我们划分 20% 的数据用于测试集，80% 用于训练集，给定一个随机种子 42
x_train, x_test, y_train, y_test = train_test_split(dataset.data, dataset.target, test_size=0.2,random_state=42)

# 定义一个 KNN 分类器对象
knn = KNeighborsClassifier()

# 训练分类器
knn.fit(x_train[:, (0, 1)], y_train)

# 使用训练好的模型进行预测
y_pred = knn.predict(x_test[:, (0, 1)])

# 计算模型的准确率
accuracy = accuracy_score(y_test, y_pred)
print(f'KNN 算法训练的模型准确率：{accuracy * 100:.2f}%')

lc = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])  # 颜色
lc2 = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])

# 可视化训练集数据
plt.figure(figsize=(8, 6))

# 可视化测试集数据
plt.scatter(x_test[:, 0], x_test[:, 1], c=y_test, cmap=lc2)

# 绘制决策边界
x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
# 返回网格，网格介于最大值和最小值之间步长0.01
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))
# 合并数据后预测网格点标签(其中将网格二维数据转换为一维数据)
Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])
# 将一维数据转换为网格维度数据
Z = Z.reshape(xx.shape)
# 网格填图
plt.contourf(xx, yy, Z, cmap=lc, alpha=0.6)

# 图形的xlabel和ylable内容设置
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
# 绘图
plt.show()

需要注意的是，因为是二维，意味着我们只能使用两个特征，对于本例来说它拥有 4 个特征是没有办法直接在 二维图上来直接显示的，所以我们采用了它的前两个属性（特征）来对其进行二维投图。

其投图原理就是在两个特征的最大值和最小值直接设置步长，来切分网格，以此来形成步长大小的“无数个”点，对这“无数个”点预测结果，来完成投图。

此处“无数个”并非真的无数个，指的是大量的点

image-20231006165709958

图中背景色表示预测结果，点表示实际预测数值及其类别，可以很清楚的看到部分类别的错误预测。

关于投图的另外一种思路来说，上述的思路过于粗暴，我们可以采用 PCA 或者 SVD 等降维手段，将数据维度从 4 维降低到 2 维再投图的效果要相对于好过这种粗暴的方式。

决策树算法

算法原理

决策树（Decision Tree）是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策分析方法，是直观运用概率分析的一种图解法。由于这种决策分支画成图形很像一棵树的枝干，故称决策树。——百度百科

算法原型

决策树算法原型：

1
class sklearn.tree.DecisionTreeClassifier(*, criterion='gini', splitter='best', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, class_weight=None, ccp_alpha=0.0)

相关常用参数说明：

  • criterion：决策树分类算法类型，可选值：
    • gini：（默认值）基尼系数来划分决策树
    • entropy：使用 熵 来划分
    • log_loss
  • max_depth：（整型）决策树最大深度，默认值None
  • random_state：（整型）随机种子，默认值None

其他详细参数，点我查看官方文档对于决策树的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 数据集包
from sklearn.datasets import load_iris
# 决策树包
from sklearn.tree import DecisionTreeClassifier
# 数据切片包
from sklearn.model_selection import train_test_split
# 数据计算包
from sklearn.metrics import accuracy_score


# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义决策树对象
dc_tree = DecisionTreeClassifier()

# 训练决策树
dc_tree.fit(x_train,y_train)

# 预测数据
y_pred = dc_tree.predict(x_test)

# 计算准确度
acc = accuracy_score(y_test,y_pred)
print(f'该决策树模型准确度：{acc*100:.2f}')

可视化算法

关于决策树的可视化有很多包和相关绘图可以绘制，但是总体来说大差不差，此处说明两个可视化的方法

使用 sklearn

我们可以使用 sklearn 自带的可视化方法，代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 导入绘图包
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
# 注意，你还需要导入 plot_tree
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score


# 读取数据
dataset = load_iris()

print(dataset)

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义决策树对象
dc_tree = DecisionTreeClassifier()

# 训练决策树
dc_tree.fit(x_train,y_train)

# 预测数据
y_pred = dc_tree.predict(x_test)

# 计算准确度
acc = accuracy_score(y_test,y_pred)
print(f'该决策树模型准确度：{acc*100:.2f}')

# 绘制决策树，其中 filled 表示是否要填充颜色，rounded 表示是否需要圆角
plot_tree(dc_tree, filled=True, class_names=[temp for temp in dataset.target_names], rounded=True)
plt.show()

运行结果：

image-20231006194419329

使用 dtreeviz

dtreeviz 是用于决策树可视化和模型解释的 python 库，关于这个库作者的描述：

A python library for decision tree visualization and model interpretation. Decision trees are the fundamental building block of gradient boosting machines and Random Forests(tm), probably the two most popular machine learning models for structured data. Visualizing decision trees is a tremendous aid when learning how these models work and when interpreting models. The visualizations are inspired by an educational animation by R2D3; A visual introduction to machine learning. Please see How to visualize decision trees for deeper discussion of our decision tree visualization library and the visual design decisions we made.

Currently dtreeviz supports: scikit-learn, XGBoost, Spark MLlib, LightGBM, and Tensorflow. See Installation instructions.

关于库的安装，使用如下命令：

1
2
3
4
5
6
7
8
9
# 使用sklearn库来做机器学习，直接安装第一个就可以，其他的不用管
pip install dtreeviz             # install dtreeviz for sklearn

# 如果有使用其他的库的，请查看如下支持相关库
pip install dtreeviz[xgboost]    # install XGBoost related dependency
pip install dtreeviz[pyspark]    # install pyspark related dependency
pip install dtreeviz[lightgbm]   # install LightGBM related dependency
pip install dtreeviz[tensorflow_decision_forests]   # install tensorflow_decision_forests related dependency
pip install dtreeviz[all]        # install all related dependencies

现在我们对上面的代码示例做一些改动，引入 dtreeviz 来实现可视化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 记得引入 dtreeviz
import dtreeviz

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义决策树对象
dc_tree = DecisionTreeClassifier()

# 训练决策树
dc_tree.fit(x_train,y_train)

# 预测数据
y_pred = dc_tree.predict(x_test)

# 计算准确度
acc = accuracy_score(y_test,y_pred)
print(f'该决策树模型准确度：{acc*100:.2f}')

# 可视化决策树
viz_model = dtreeviz.model(dc_tree,x_train,y_train,class_names=[temp for temp in dataset.target_names])
# 生成图
viz_model.view(orientation="LR").show()

运行后将会拉起你的浏览器或者其他默认软件来打开svg图像，如下所示：

image-20231006203312875

当然，你也可以做很多其他设置，详细的设置请查看点我查看官方地址，如果有帮助记得给原作者一个 Star。

Logistic 回归

Logistic 回归部分地方翻译为逻辑回归，两者指的是同一个算法。

算法原理

Logistci 回归我个人认为是最像神经网络的机器学习算法，原理是类似，不过逻辑回归是梯度上升，而神经网络是基于梯度下降，两者殊途同归。

logistic回归又称logistic回归分析，是一种广义的线性回归分析模型，常用于数据挖掘，疾病自动诊断，经济预测等领域。 逻辑回归根据给定的自变量数据集来估计事件的发生概率，由于结果是一个概率，因此因变量的范围在 0 和 1 之间。——百度百科

算法原型

1
class sklearn.linear_model.LogisticRegression(penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)

常用参数说明：

  • penalty：损失函数惩罚，可选值：
    • None：不添加惩罚
    • l2：（默认值）L2 正则化惩罚
    • l1：L1 正则化惩罚
    • elasticnet：L1 和 L2 惩罚均添加
  • random_state：（整型）随机种子
  • max_iter：求解器最大迭代次数，默认100次。
  • n_jobs：（整型）默认None，在类上并行化时使用的 CPU 内核数（如果 multi_class='ovr'）。-1意味着使用所有处理器。

其他详细参数，点我查看官方文档对于 Logistic 回归的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建逻辑回归分类器
logistic_classifier = LogisticRegression(max_iter=100, random_state=42)

# 训练逻辑回归模型
logistic_classifier.fit(x_train, y_train)

# 使用训练好的模型进行预测
y_pred = logistic_classifier.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"逻辑回归模型的准确性：{accuracy * 100:.2f}%")

可视化算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建逻辑回归分类器
logistic_classifier = LogisticRegression(max_iter=100, random_state=42)

# 训练逻辑回归模型
logistic_classifier.fit(x_train[:,(0,1)], y_train)

# 使用训练好的模型进行预测
y_pred = logistic_classifier.predict(x_test[:,(0,1)])

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"逻辑回归模型的准确性：{accuracy * 100:.2f}%")

# 绘制决策边界
x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))
Z = logistic_classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# 填图
plt.contourf(xx, yy, Z, alpha=0.8)

# 显示类别概率分布
probs = logistic_classifier.predict_proba(np.c_[xx.ravel(), yy.ravel()])
probs = probs.reshape(xx.shape + (3,))
for i in range(3):
    plt.contour(xx, yy, probs[:, :, i], levels=[0.5], colors=[f'C{i}'], linewidths=2)

# 绘制数据点
plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train, marker='o', s=25, edgecolor='k')

plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.show()

运行结果：

image-20231006213805252

对于逻辑回归和 K近邻算法类似，因为维度是 4 ，无法在三维及其以上直接可视化，本例简单粗暴的时候了前两个属性来可视化，现实情况，你可以使用其他的方式来可视化，例如，PCA 或者 SVD 等降维手段降维后可视化。

朴素贝叶斯算法

⚠️请注意：朴素贝叶斯是基于词频原理分类的，这就意味着它并不适合数值型的分类，它只适合标称型数据分类。此处拿来做分类，仅作示例。

算法原理

朴素贝叶斯方法是在贝叶斯算法的基础上进行了相应的简化，即假定给定目标值时属性之间相互条件独立。也就是说没有哪个属性变量对于决策结果来说占有着较大的比重，也没有哪个属性变量对于决策结果占有着较小的比重。虽然这个简化方式在一定程度上降低了贝叶斯分类算法的分类效果，但是在实际的应用场景中，极大地简化了贝叶斯方法的复杂性。——百度百科

简单来说，朴素贝叶斯基于贝叶斯公式，通过概率的方式，对词频进行统计，进而求出概率分类。

算法原型

1
class sklearn.naive_bayes.CategoricalNB(*, alpha=1.0, force_alpha='warn', fit_prior=True, class_prior=None, min_categories=None)

常用参数说明：

  • fit_prior：（布尔值）默认为True。是否学习类先验概率，如果为false，则使用统一先验概率。

其他详细参数，点我查看官方文档对于 朴素贝叶斯算法 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.naive_bayes import CategoricalNB

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建朴素贝叶斯分类器对象
cat_nb = CategoricalNB()

# 训练分类器
cat_nb.fit(x_train,y_train)

# 预测测试集
y_pred = cat_nb.predict(x_test)

# 输出训练结果
acc = accuracy_score(y_test,y_pred)
print(f'朴素贝叶斯分类器的准确率为：{acc*100:.2f}')

可视化算法

学习曲线

通过可视化学习曲线来了解，模型训练过程中数据量对于模型的拟合情况验证，可以查看和判断是否过拟合以及后续的参数配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.naive_bayes import GaussianNB
# 学习曲线
from sklearn.model_selection import learning_curve

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建朴素贝叶斯分类器对象
cat_nb = GaussianNB()

# 训练分类器
cat_nb.fit(x_train,y_train)

# 预测测试集
y_pred = cat_nb.predict(x_test)

# 输出训练结果
acc = accuracy_score(y_test,y_pred)
print(f'朴素贝叶斯分类器的准确率为：{acc*100:.2f}')

# 绘制学习曲线
train_sizes, train_scores, test_scores = learning_curve(
    cat_nb, x_train, y_train, cv=5, n_jobs=-1, train_sizes=np.linspace(0.1, 1.0, 10)
)

# 计算平均训练集和测试集得分
train_scores_mean = np.mean(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)

# 绘制学习曲线图
plt.figure(figsize=(10, 6))
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.plot(train_sizes, train_scores_mean, label='训练分数')
plt.plot(train_sizes, test_scores_mean, label='交叉验证分数')
plt.title('朴素贝叶斯分类器学习曲线')
plt.xlabel('训练集')
plt.ylabel('准确度分数')
plt.legend()
plt.grid()
plt.show()

运行结果：

image-20231007100114038

决策边界

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.naive_bayes import GaussianNB

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建朴素贝叶斯分类器对象
cat_nb = GaussianNB()

# 训练分类器
cat_nb.fit(x_train[:,(0,1)],y_train)

# 预测测试集
y_pred = cat_nb.predict(x_test[:,(0,1)])

# 输出训练结果
acc = accuracy_score(y_test,y_pred)
print(f'朴素贝叶斯分类器的准确率为：{acc*100:.2f}')

# 绘制决策边界
x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))
Z = cat_nb.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.8)
plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train, cmap=plt.cm.coolwarm)
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Naive Bayes Decision Boundary')
plt.show()

运行结果：

image-20231007095948613

支持向量机

支持向量机是一个复杂且有用的分类算法，它的适用性和泛化结果相对不错。建议多了解支持向量机原理，如果你足够感兴趣。

算法原理

支持向量机（Support Vector Machine, SVM）是一类按监督学习（supervised learning）方式对数据进行二元分类的广义线性分类器（generalized linear classifier），其决策边界是对学习样本求解的最大边距超平面（maximum-margin hyperplane）——百度百科。

通俗来理解就是，找到类别直接的最宽距离，中间找到一条线性的方程或者非线性方程，使用超平面分割两个类别。

算法原型

1
class sklearn.svm.SVC(*, C=1.0, kernel='rbf', degree=3, gamma='scale', coef0=0.0, shrinking=True, probability=False, tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape='ovr', break_ties=False, random_state=None)

常用参数说明：

  • C：（浮点型）正则化参数。默认值1.0
  • kernel：指定算法中使用的内核类型，可选值：
    • linear：线性
    • poly
    • rbf：（默认值）
    • sigmoid
    • precomputed
  • random_state ：随机种子参数
  • max_iter ：最大迭代次数，默认-1，表示无限制
  • probability：（布尔值）是否启用概率估计，在调用之前需要fit()，这个方法会降低训练速度，因为它内部使用 5 倍交叉验证。

其他详细参数，点我查看官方文档对于 支持向量机 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.svm import SVC

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建SVM分类器
svm_classifier = SVC(kernel='linear',probability=True)

# 训练SVM模型
svm_classifier.fit(x_train, y_train)

# 使用训练好的模型进行预测
y_pred = svm_classifier.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

可视化算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.svm import SVC

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建SVM分类器
svm_classifier = SVC(kernel='linear',probability=True)

# 训练SVM模型
svm_classifier.fit(x_train[:,(0,1)], y_train)

# 使用训练好的模型进行预测
y_pred = svm_classifier.predict(x_test[:,(0,1)])

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

# 创建网格来绘制决策边界
x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))

# 预测网格上每个点的类别
Z = svm_classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# 绘制决策边界
plt.contourf(xx, yy, Z, cmap=plt.cm.coolwarm, alpha=0.8)

# 绘制训练数据点
plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train, cmap=plt.cm.coolwarm, edgecolors='k')

# 绘制支持向量
plt.scatter(svm_classifier.support_vectors_[:, 0], svm_classifier.support_vectors_[:, 1], s=100, facecolors='none', edgecolors='k')
plt.title('SVM Decision Boundary with Support Vectors')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()

本示例，也是简单粗暴的只是用了特征的前两个来绘制二维下的分类，运行结果：

image-20231007103649306

人工神经网络

算法原理

人工神经网络（Artificial Neural Network，即ANN ），是20世纪80 年代以来人工智能领域兴起的研究热点。它从信息处理角度对人脑神经元网络进行抽象， 建立某种简单模型，按不同的连接方式组成不同的网络。在工程与学术界也常直接简称为神经网络或类神经网络。神经网络是一种运算模型，由大量的节点（或称神经元）之间相互联接构成。每个节点代表一种特定的输出函数，称为激励函数（activation function）。每两个节点间的连接都代表一个对于通过该连接信号的加权值，称之为权重，这相当于人工神经网络的记忆。网络的输出则依网络的连接方式，权重值和激励函数的不同而不同。而网络自身通常都是对自然界某种算法或者函数的逼近，也可能是对一种逻辑策略的表达。——百度百科

人工神经网络（多层感知机）解释起来相对复杂一些，需要先了解，反向传播，梯度下降，损失函数，人工神经网络将会是深度学习的基础，由于解释人工神经网络将会占用较大篇幅，此处暂时省略说明，将会在深度学习基础的部分详细说明人工神经网络。

请自行百度学习人工神经网络，当然你也可以直接尝试套用代码示例来查看是否满足你的需求。

算法原型

1
class sklearn.neural_network.MLPClassifier(hidden_layer_sizes=(100,), activation='relu', *, solver='adam', alpha=0.0001, batch_size='auto', learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=10, max_fun=15000)

常用参数说明：

  • hide_layer_sizes：（接受一个类似数组的形状）多层感知机的隐藏层的神经元数量。默认(100,)，表示第一层隐藏层使用100个神经元，第二层0个。
  • activation：激活函数类型（非线性函数），可选值：
    • identity：无非线性激活，返回 $f(x) = x$
    • logistic：sigmoid函数，返回 $\Large f(x) = \frac{1}{1+ e^{-x}}$
    • tanh：双曲 tan 函数，返回 $f(x) = \tanh(x)$
    • relu：（默认值）返回 $f(x) = max(0,x)$
  • solver：求解器，可选值：
    • lbfgs：
    • sgd：随机梯度下降
    • adam：（浮点型）
  • Learning_rate_init：（浮点型）初始学习率，默认0,001
  • max_iter：（整型）默认200

其他详细参数，点我查看官方文档对于 人工神经网络（多层感知机）的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.neural_network import MLPClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义多层感知机
mlp = MLPClassifier(max_iter=1000)

# 训练多层感知机
mlp.fit(x_train,y_train)

# 预测数据
y_pred = mlp.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

可视化算法

学习曲线

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.neural_network import MLPClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义多层感知机
mlp = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=1000, random_state=42)

# 训练多层感知机
mlp.fit(x_train,y_train)

# 预测数据
y_pred = mlp.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

# 获取训练过程中的损失值
loss_curve = mlp.loss_curve_

# 绘制学习曲线
plt.figure(figsize=(8, 6))
plt.plot(np.arange(1, len(loss_curve) + 1), loss_curve)
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.xlabel('迭代次数')
plt.ylabel('损失函数')
plt.title('多层感知机损失函数学习曲线')
plt.grid(True)
plt.show()

运行结果：

image-20231007163259573

预测结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.neural_network import MLPClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义多层感知机
mlp = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=1000, random_state=42)

# 训练多层感知机
mlp.fit(x_train,y_train)

# 预测数据
y_pred = mlp.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

# 获取真实的类别标签
true_labels = y_test

# 获取预测的类别标签
predicted_labels = y_pred

# 创建颜色映射以区分真实类别和预测类别
true_colors = ['r', 'g', 'b']
predicted_colors = ['c', 'm', 'y']

# 创建子图，绘制真实类别的散点图
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
for i in range(3):  # 三个真实类别
    plt.scatter(x_test[true_labels == i][:, 0], x_test[true_labels == i][:, 1], color=true_colors[i], label=f'True Class {i}')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('True Data Class Labels')
plt.legend()

# 在另一个子图中绘制预测类别的散点图
plt.subplot(1, 2, 2)
for i in range(3):  # 三个预测类别
    plt.scatter(x_test[predicted_labels == i][:, 0], x_test[predicted_labels == i][:, 1], color=predicted_colors[i], label=f'Predicted Class {i}')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Predicted Data Class Labels')
plt.legend()

plt.tight_layout()
plt.show()

运行结果：

image-20231007164105990

随机森林

算法原理

在机器学习中，随机森林是一个包含多个决策树的分类器， 并且其输出的类别是由个别树输出的类别的众数而定。——百度百科

随机森林是一种集成学习算法，集成学习的思想是采用多个弱分类器来构建一个泛化能力更高的分类器，随机森林就是如此，采用多个决策树进行分类，根据每个决策树的结果来综合给出预测结果。

算法原型

1
class sklearn.ensemble.RandomForestClassifier(n_estimators=100, *, criterion='gini', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='sqrt', max_leaf_nodes=None, min_impurity_decrease=0.0, bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None, ccp_alpha=0.0, max_samples=None)

常用参数说明：

  • n_estimators ：森林中树木的数量，默认值100
  • criterion：决策树分割算法，可选值：
    • gini：（默认值）基尼系数
    • entropy：熵
    • log_loss
  • max_depth：（整型）树最大深度，默认值None
  • bootstrap：（布尔型）构建树是否使用引导样本，如果为False，则使用整个数据集来构建每棵树。默认值True
  • max_samples ：（整型或浮点型）如果bootstrap为True，则从X中抽取样本来训练每个决策树。默认值None。可选值：
    • None：（默认值），则使用 X.shape[0] 个样本。
    • int：则使用 max_samples 个样本。
    • float：则使用 max(round(n_samples * max_samples), 1) 个样本。因此，max_samples 应在区间 (0.0, 1.0] 内。

其他详细参数，点我查看官方文档对于 随机森林 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义一个随机森林对象
random_forest = RandomForestClassifier()

# 随机森林拟合
random_forest.fit(x_train,y_train)

# 随机森林预测
y_pred = random_forest.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

可视化算法

绘制单棵树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier
# 请注意绘制单棵树需要导入这个包
from sklearn.tree import plot_tree

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义一个随机森林对象
random_forest = RandomForestClassifier()

# 随机森林拟合
random_forest.fit(x_train,y_train)

# 随机森林预测
y_pred = random_forest.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

# 提取第一棵树并绘制
plt.figure(figsize=(12, 8))
plot_tree(random_forest.estimators_[0], filled=True, feature_names=dataset.feature_names, class_names=[name for name in dataset.target_names])
plt.show()

运行结果：

image-20231007104929668

如果你还记得之前决策树可视化的时候dtreeviz包的话，你也可以使用该包来可视化单棵树。

绘制特征重要度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 定义一个随机森林对象
random_forest = RandomForestClassifier()

# 随机森林拟合
random_forest.fit(x_train,y_train)

# 随机森林预测
y_pred = random_forest.predict(x_test)

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

# 提取特征重要性
feature_importance = random_forest.feature_importances_

# 绘制特征重要性条形图
plt.figure(figsize=(10, 6))
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.barh(range(dataset.data.shape[1]), feature_importance, align='center')
plt.yticks(range(dataset.data.shape[1]), dataset.feature_names)
plt.xlabel('特征重要性')
plt.title('随机森林特征重要性')
plt.show()

运行结果：

image-20231007104537713

Bagged Classifier

算法原理

Baggged Classifier（装袋分类器），它和随机森林是一个原理，都是基于多个并行的子分类器来最终获得预测结果。不同的是 Bagged Classifier 可以选择不同的子分类器，而随机森林是使用的决策树子分类器。

算法原型

1
class sklearn.ensemble.BaggingClassifier(estimator=None, n_estimators=10, *, max_samples=1.0, max_features=1.0, bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None, random_state=None, verbose=0, base_estimator='deprecated')

常用参数说明：

  • estimator：（object类型）用于拟合数据的子评估器（分类器），默认值None。如果为None，则默认使用决策树分类器。
  • n_estimators：集成算法中的评估器（分类器）的数量

其他详细参数，点我查看官方文档对于 Bagging Classifier 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建一个基础的决策树分类器，本示例使用的决策树作为子分类器
base_classifier = DecisionTreeClassifier()

# 创建Bagging分类器，设置基础分类器和要构建的子模型数量
bagging_classifier = BaggingClassifier(base_classifier, n_estimators=10)

# 训练模型
bagging_classifier.fit(x_train, y_train)  # X_train和y_train是训练数据

# 进行预测
y_pred = bagging_classifier.predict(x_test)  # X_test是测试数据

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

Extra Trees

算法原理

Extra Trees（极端随机树）：与随机森林十分相似，都由许多决策树组成。有两个主要区别：一是随机森林应用的是Bagging模型，而极端随机树是使用所有的训练样本得到每棵决策树，也就是每棵决策树应用的是相同的全部训练样本。二是随机森林是在一个随机子集内得到最优分叉特征属性，而极端随机树是完全随机的选择分叉特征属性，从而实现对决策树分叉的。

算法原型

1
class sklearn.ensemble.ExtraTreesClassifier(n_estimators=100, *, criterion='gini', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='sqrt', max_leaf_nodes=None, min_impurity_decrease=0.0, bootstrap=False, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None, ccp_alpha=0.0, max_samples=None)

常用参数说明：

  • n_estimators ：森林中树木的数量，默认值100
  • criterion：决策树分割算法，可选值：
    • gini：（默认值）基尼系数
    • entropy：熵
    • log_loss
  • max_depth：（整型）树最大深度，默认值None
  • bootstrap：（布尔型）构建树是否使用引导样本，如果为False，则使用整个数据集来构建每棵树。默认值True

其他详细参数，点我查看官方文档对于 ExtraTreesClassifier 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import ExtraTreesClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建一个基础的决策树分类器
extra_classifier = ExtraTreesClassifier()

# 训练模型
extra_classifier.fit(x_train, y_train)  # X_train和y_train是训练数据

# 进行预测
y_pred = extra_classifier.predict(x_test)  # X_test是测试数据

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

AdaBoost

算法原理

AdaBoost为英文”Adaptive Boosting”（自适应增强）的缩写，是一种机器学习方法，由约阿夫·弗罗因德和罗伯特·沙皮尔提出。[1]AdaBoost方法的自适应在于：前一个分类器分错的样本会被用来训练下一个分类器。——维基百科

AdaBoost方法是一种迭代算法，在每一轮中加入一个新的弱分类器，直到达到某个预定的足够小的错误率。每一个训练样本都被赋予一个权重，表明它被某个分类器选入训练集的概率。如果某个样本点已经被准确地分类，那么在构造下一个训练集中，它被选中的概率就被降低；相反，如果某个样本点没有被准确地分类，那么它的权重就得到提高。通过这样的方式，AdaBoost方法能“聚焦于”那些较难分（更富信息）的样本上。——维基百科

算法原型

1
class sklearn.ensemble.AdaBoostClassifier(estimator=None, *, n_estimators=50, learning_rate=1.0, algorithm='SAMME.R', random_state=None, base_estimator='deprecated')

常用参数说明：

  • estimator：（object类型）用于拟合数据的子评估器（分类器），默认值None。如果为None，则默认使用决策树分类器。
  • n_estimators：集成算法中的评估器（分类器）的数量，默认值50
  • learning_rate：（浮点型）在每次提升迭代时应用于每个分类器的权重。默认值1.0
  • random_state ：每次迭代的随机种子

其他详细参数，点我查看官方文档对于 AdaBoost Classifier 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建一个基础的决策树分类器
base_classifier = DecisionTreeClassifier(max_depth=1)  # 通常使用简单的弱分类器

# 创建AdaBoost分类器，设置基础分类器和要构建的子模型数量
adaboost_classifier = AdaBoostClassifier(base_classifier, n_estimators=5, learning_rate=1.0)

# 训练模型
adaboost_classifier.fit(x_train, y_train)  # X_train和y_train是训练数据

# 进行预测
y_pred = adaboost_classifier.predict(x_test)  # X_test是测试数据

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

Gradient Boosting Machine

算法原理

原理和 AdaBoost 基本上如出一辙，不同的是，AdaBoost 算法的损失函数是上一个分类器错误的地方，而 GBM 算法是降低上一个分类器预测值和真实值的残差。

算法原型

1
class sklearn.ensemble.AdaBoostClassifier(estimator=None, *, n_estimators=50, learning_rate=1.0, algorithm='SAMME.R', random_state=None, base_estimator='deprecated')

常用参数说明：

  • estimator：（object类型）用于拟合数据的子评估器（分类器），默认值None。如果为None，则默认使用决策树分类器。
  • n_estimators：集成算法中的评估器（分类器）的数量，默认值50
  • learning_rate：（浮点型）在每次提升迭代时应用于每个分类器的权重。默认值1.0
  • subsample：（浮点型）用于拟合各个基础学习器的样本比例。默认值1.0。
  • max_depth：（整型或者None）各个回归估计器的最大深度。最大深度限制了树中的节点数量。默认值3
  • random_state ：每次迭代的随机种子

其他详细参数，点我查看官方文档对于 GBM 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import GradientBoostingClassifier

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建Gradient Boosting分类器
gb_classifier = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, subsample=0.8, random_state=42)

# 训练模型
gb_classifier.fit(x_train, y_train)  # X_train和y_train是训练数据

# 进行预测
y_pred = gb_classifier.predict(x_test)  # X_test是测试数据

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

Stacking Classifier

算法原理

堆叠（英语：Stacking）（有时称为堆叠泛化）涉及训练学习算法以组合其他几种学习算法的预测。首先，使用可用数据训练所有其他算法，然后训练组合器算法以使用其他算法的所有预测作为附加输入进行最终预测。如果使用任意组合器算法，那么堆叠理论上可以表示本文中描述的任何集合技术，但实际上，通常用逻辑斯谛回归模型作为组合器。——维基百科

算法原型

1
class sklearn.ensemble.StackingClassifier(estimators, final_estimator=None, *, cv=None, stack_method='auto', n_jobs=None, passthrough=False, verbose=0)[source]

常见参数说明：

  • estimators：评估器列表，堆叠第一层基础评估器
  • final_estimator：最后一程评估器，组合所有的基础评估器。默认值None，当为None时，为 Logistic 回归评估器
  • cv：（整型）交叉验证生成器，默认None。可选值：
    • None：默认 5 折交叉验证
    • 整数：则对应整数交叉验证

其他详细参数，点我查看官方文档对于 Stacking Classifier 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import StackingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建基础分类器
base_classifiers = [
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('knn', KNeighborsClassifier(n_neighbors=3)),
]
# 创建堆叠分类器，设置元分类器
stacked_classifier = StackingClassifier(
    estimators=base_classifiers,
    final_estimator=LogisticRegression()
)
# 训练模型
stacked_classifier.fit(x_train, y_train)  # X_train和y_train是训练数据

# 进行预测
y_pred = stacked_classifier.predict(x_test)  # X_test是测试数据

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

Voting Classifier

算法原理

Voting是一种集成学习，它将来自多个机器学习模型的预测结合起来产生结果。在整个数据集上训练多个基础模型来进行预测。每个模型预测被认为是一个“投票”。得到多数选票的预测将被选为最终预测。——deephub

有两种类型的投票用于汇总基础预测-硬投票和软投票。

image-20231007200445652

硬投票选择投票数最高的预测作为最终预测，而软投票将每个模型中每个类的概率结合起来，选择概率最高的类作为最终预测。

算法原型

1
class sklearn.ensemble.VotingClassifier(estimators, *, voting='hard', weights=None, n_jobs=None, flatten_transform=True, verbose=False)

常用参数说明：

  • estimators：基础评估器列表
  • voting：投票方式。可选值：
    • soft：软投票
    • hard：硬投票（默认值）
  • weights：权重分配，默认值None

其他详细参数，点我查看官方文档对于 Voting Classifier 的说明

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC

# 读取数据
dataset = load_iris()

# 切分数据集和训练集
x_train,x_test,y_train,y_test = train_test_split(dataset.data,dataset.target,test_size=0.2,random_state=42)

# 创建基础分类器
clf1 = LogisticRegression(random_state=42,max_iter=10000)
clf2 = DecisionTreeClassifier(random_state=42)
clf3 = SVC(probability=True, random_state=42)

# 创建投票分类器
voting_classifier = VotingClassifier(estimators=[
    ('lr', clf1),
    ('dt', clf2),
    ('svc', clf3)
], voting='soft')  # 可以选择'hard'或'soft'投票方式

# 训练模型
voting_classifier.fit(x_train, y_train)  # X_train和y_train是训练数

# 进行预测
y_pred = voting_classifier.predict(x_test)  # X_test是测试数据

# 计算模型的准确性
accuracy = accuracy_score(y_test, y_pred)
print(f"模型的准确性：{accuracy * 100:.2f}%")

关于模型可视化

对于一个模型的可视化内容可以大致分为如下的内容，当然你可以选择很多不同的类型的库来展示不一样的内容，但是大致可视化内容可以分为如下：

  1. 决策边界可视化
  2. 学习曲线可视化
  3. 特征重要性
  4. 混淆矩阵和分类报告
  5. 特征重要性变化

End

到这里就暂时小结了，为不多的次数能将编辑器写的稍微带点卡顿的，这应该是目前关于常见的监督分类算法最全面的了，其中大部分的可以直接复制，然后根据自己的数据集做调参数就好了。

后续有机会将无监督学习和监督回归算法也写一个。

参考文章