当前位置：首页 > article >正文

一、机器学习算法与实践_07支持向量机与集成学习算法笔记

article 2024/11/14 11:08:57

1 支持向量机

1.1 定义

SVM（Support Vector Machine，即：支持向量机）是一种监督学习算法，主要用于分类问题，但也可用于回归分析（称为支持向量回归，Support Vector Regression，简称SVR）

1.2 核心思想

最大间隔原则：SVM试图找到一个超平面（在二维空间中是一条直线，在三维空间中是一个平面，在更高维空间中是超平面），这个超平面能够将不同类别的数据点分开，并且具有最大的间隔。这个间隔被称为“间隔边界”（margin），而最靠近这个超平面的数据点被称为“支持向量”（support vectors）
核技巧：在原始特征空间中，线性不可分的数据可以通过核函数映射到高维特征空间中，使其线性可分，常用的核函数包括线性核、多项式核、径向基函数核（RBF）和Sigmoid核等
优化问题：SVM的优化问题可以表述为一个凸二次规划问题，这保证了找到的解是全局最优解

1.3 工作原理

选择核函数：根据数据的特性，选择合适的核函数（如果数据是线性可分的，可以选择线性核；如果数据是非线性的，可以选择RBF核或其他非线性核）
构建并求解优化问题：构建一个凸二次规划问题，目标是最大化间隔，同时最小化分类误（可以通过拉格朗日乘子法和对偶问题来求解）
确定支持向量：在求解过程中，只有一部分数据点（支持向量）会影响最终的决策边界（这些支持向量是距离决策边界最近的点）
构建决策函数：根据支持向量和对应的拉格朗日乘子，构建决策函数，用于对新数据点进行分类

1.4 特点和应用场景

优点： 即使只有少量的数据，在孟高维空间中的表现非常好

缺点： 对于大规模数据集，其处理速度较慢，以及核函数的选择和参数调整可能比较困难

SVM在许多领域都有广泛的应用，包括但不限于图像识别、手写数字识别、生物信息学、文本分类、情感分析等

1.5 算法实践

以鸢尾花数据集为例，进行支持向量机算法的事件，查看分类报告和准确率，并绘制分类效果图形

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
iris = load_iris()
# 为了简化模型以及方便后面用图表输出，这里只取鸢尾花的前两个特征（“花萼长度”、“花萼宽度”）
X = iris.data[:, :2]
y = iris.target

# 引入train_test_split，将数据集切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# 在python中，sklearn.svm是 sklearn 库中的一个模块，它提供了对支持向量机（SVM）算法的实现
# 在sklearn.svm中，SVC就是用于SVM算法的分类器，所以我们需要先对其进行引入
from sklearn.svm import SVC
# SVC是一个类，所以应该用面向对象的思想对其进行使用（即：实例化对象）
# （1）kernel='linear'：这个参数指定了SVM的核函数类型为线性核'linear'（核函数决定了数据在特征空间中的映射方式），这意味着SVM将尝试找到一个线性的决策边界来分隔不同的类别
# 其他可选的核函数包括 'poly'（多项式核）、'rbf'（径向基函数核）、'sigmoid'（Sigmoid核）等
# （2）C=1.0：这个参数是SVM中的正则化参数，用于控制模型对误分类的惩罚程度，1.0是一个中等的值，用于平衡模型的偏差和方差
# 备注：较大的 C 值意味着模型会尝试通过增加间隔来正确分类所有训练样本，这可能会导致过拟合；较小的 C 值则允许更多的训练样本被误分类，从而增加间隔，这可能会导致欠拟合
clf = SVC(kernel='linear', C=1.0, random_state=0)

# 训练模型时，需要将训练集（X_train和y_train）作为参数传入fit方法中
clf.fit(X_train, y_train)
# 预测模型时，需要将测试集（X_test）作为参数传入predict方法中
y_pred = clf.predict(X=X_test)

# 引入classification_report和accuracy_score，打印分类报告和准确率
from sklearn.metrics import classification_report, accuracy_score
report = classification_report(y_test, y_pred)
acc = accuracy_score(y_test, y_pred)
print(f"预测的分类报告为：\n {report}")
print(f"预测的准确率为：{acc}")



# 下面用绘图的方式来展示支持向量机是的分类训练效果
# 引入numpy，提供一些科学计算的方法
import numpy as np
# 引入matplotlib的pyplot函数，为绘图做准备
import matplotlib.pyplot as plt
# 如果是用pycharm等后端工具绘图，需要指定图形用户界面工具包
# import matplotlib
# matplotlib.use('TkAgg')  # 设置绘图后端为 TkAgg

# 定义绘图方法（绘制的是等高线图）
def plot_decision_boundary(X, y, clf):
    # 将X的第一个特征最小值-1，最大值+1，作为图形的X轴边框
    X1_min, X1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    # 将X的第二个特征最小值-1，最大值+1，作为图形的y轴边框
    X2_min, X2_max  = X[:, 1].min() - 1, X[:, 1].max() + 1

    # 将X1和X2的最小值到最大值每隔0.1获取等差数列，并组合成坐标网格
    xx, yy = np.meshgrid(np.arange(X1_min, X1_max, 0.1), np.arange(X2_min, X2_max, 0.1))

    # 将X的两个特征带入predict方法，获取预测结果，并将其作为Z轴的值
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    # 用contourf方法绘制等高线图
    # alpha用于设置填充颜色的透明度，范围从 0 到 1，其中 0 表示完全透明，1 表示完全不透明
    contour = plt.contourf(xx, yy, Z, alpha=0.2)
    # 添加颜色条（不同的颜色代表不同的高度值）
    plt.colorbar(contour)

    # 取X的第一个和第二个特征为横纵坐标来绘制散点，并将函数参数y视为散点颜色
    # edgecolors='k'用于设置散点的边缘颜色，'k' 表示黑色（keyword 的缩写）
    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', s=20)
    # 设置图形的x轴标签
    plt.xlabel('Sepal length')
    # 设置图形的y轴标签
    plt.ylabel('Sepal width')
    # 设置图形标题
    plt.title('SVM Decision Boundary with linear kernel')
    # 显示图形
    plt.show()

plot_decision_boundary(X_test, y_test, clf)

运行结果如下：

2 集成学习

2.1 定义

集成学习（Ensemble Learning）是一种机器学习方法，它结合多个不同的机器学习模型，以便提高预测准确性、鲁棒性或计算效率

2.2 核心思想

类似于团队合作，即使每个成员不是顶尖的，但通过有效的合作和协调，团队有可能完成超出顶尖个体能力的任务

集成学习同理，其核心思想是“三个臭皮匠，干掉诸葛亮”，即组合多个模型的预测结果，通过头脑风暴，获得比单个模型更好的性能（不同的模型可能会在不同的数据子集或特征子集上表现更好，通过集成这些模型，可以减少单一模型可能遇到的过拟合或欠拟合问题）

2.3 关键要素

一批弱分类器
组合策略

2.4 组合策略及算法示例

在集成学习中，可以用不同的策略来组合多个模型的预测，以提高整体的预测性能，主要的组合策略包括Voting、Bagging、Stacking、Boosting这四种

2.4.1 Voting（投票策略）

投票策略，就是先让多个分类器对同一数据点进行分类，然后再根据投票结果来决定最终的类型，可进一步划分为两种方式：

硬投票（Hard Voting）：每个模型的预测结果视为等权重的一票，出现最多的类别被选为最终预测结果（少数服从多数）
软投票（Soft Voting）：在分类问题中，每个模型输出一个概率分布，然后对这些概率进行平均（加权平均），选择平均概率最高的类别作为最终预测

核心思想： 算法不同，数据相同（相同的数据集在不同算法中做训练和预测，然后进行硬投票或软投票）

算法示例：

"""
    在sklearn中，ensemble是集成学习相关的模块，包含了多个实现集成学习的类
    对于Voting策略，其分类器为VotingClassifier，回归器为VotingRegressor
"""
# 下面以分类任务进行实践，此处先引入VotingClassifier类
from sklearn.ensemble import VotingClassifier
"""
### VotingClassifier类的官方描述为：
Soft Voting/Majority Rule classifier for unfitted estimators.
### 翻译：
Soft Voting（软投票）或 Majority Rule（多数规则）分类器是一种集成学习方法，它可以用来改善一组未拟合（unfitted）估计器的性能
在这种情况下，"未拟合"的估计器指的是那些由于过于简单或训练不充分而未能捕捉到数据中关键模式的模型
这些模型在训练集上的误差可能很大，因为它们没有从数据中学到足够的信息
### 关键词说明：
unfitted 未拟合（主动构建的弱分类器）
    - 主动构建一批弱鸡分类器
    - 集成学习策略
overfit 过拟合（训练大了，入戏太深，书呆子，把训练集上的错误也学习了）
    - 训练集表现非常好
    - 测试集表现非常差
    - 模型被训练废了，不能用了
underfit 欠拟合（训练不够，没有充分学习全部有效知识）
    - 训练集表现不够好
    - 测试集表现也不够好
    - 原因：训练不够
"""

# 引入numpy，提供一些科学计算的方法
import numpy as np
# 引入逻辑回归、高斯贝叶斯、随机森林算法的实现类
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier

# 实例化对象（逻辑回归、高斯贝叶斯、随机森林三个弱分类器）
clf1 = LogisticRegression(multi_class='multinomial', random_state=0)
clf2 = GaussianNB()
clf3 = RandomForestClassifier(n_estimators=50, random_state=0)

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 引入train_test_split，将数据集进一步切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# 实例化VotingClassifier对象，构建投票器实例
# estimators参数用于指定分类器的名称和实例，voting参数用于指定投票方式是硬投票还是软投票
vclf = VotingClassifier(estimators=[('lr', clf1), 
                                    ('gnb', clf2), 
                                    ('rf', clf3)], 
                        voting='hard')

# 代入X_train, y_train，进行模型训练
vclf = vclf.fit(X_train, y_train)
# 代入X_test，进行模型预测
y_pred = vclf.predict(X_test)

# 比较测试集的标签值和预测出来的标签值，计算预测的准确率
acc = (y_pred == y_test).mean()
print(f"预测的准确率为:{acc}")

2.4.2 Bagging（自助采样策略）

Bagging（Bootstrap Aggregating，即自举汇聚法），是一种通过在原始数据集上进行多次随机采样来训练多个模型的方法

每个模型只在采样得到的子集上进行训练，而未被选中的样本则被排除在外（这种方法减少了模型的方差，并提高了模型的稳定性）

典型算法：随机森林（Random Forest）是一个流行的Bagging算法，它使用多个决策树并行地对数据进行预测

核心思想： 算法相同，数据不同（将原始的数据集随机采样获得多个子数据集，在相同算法中做训练和预测）

算法示例：

"""
    在sklearn中，ensemble是集成学习相关的模块，包含了多个实现集成学习的类
    对于Bagging策略，其分类器为BaggingClassifier，回归器为BaggingRegressor
"""
# 下面以分类任务进行实践，此处先引入BaggingClassifier类
from sklearn.ensemble import BaggingClassifier
"""
### BaggingClassifier类的官方描述为：
A Bagging classifier is an ensemble meta-estimator that fits base
classifiers each on random subsets of the original dataset and then
aggregate their individual predictions (either by voting or by averaging)
to form a final prediction. Such a meta-estimator can typically be used as
a way to reduce the variance of a black-box estimator (e.g., a decision
tree), by introducing randomization into its construction procedure and
then making an ensemble out of it.
### 翻译：
Bagging分类器是一种集成元估计器，它通过在原始数据集的随机子集上训练基分类器，然后将这些基分类器的个体预测结果（通过投票或平均的方式）聚合起来，以形成最终的预测
这种元估计器通常可以用来减少一个黑盒估计器（例如决策树）的方差，方法是在其构建过程中引入随机性，然后创建一个模型集成
"""

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 引入train_test_split，将数据集进一步切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# 引入支持向量机算法的实现类，并实例化对象作为基分类器
from sklearn.svm import SVC
clf = SVC()

# 实例化BaggingClassifier对象，构建装袋器实例
# estimators参数用于指定分类器的实例，n_estimators参数表示生成10个与基分类器相同的分类器
bclf = BaggingClassifier(estimator=clf, 
                         n_estimators=10, 
                         random_state=0)

# 代入X_train, y_train，进行模型训练
bclf.fit(X_train, y_train)
# 代入X_test，进行模型预测
y_pred = bclf.predict(X_test)

# 比较测试集的标签值和预测出来的标签值，计算预测的准确率
acc = (y_pred == y_test).mean()
print(f"预测的准确率为:{acc}")

2.4.3 Stacking（堆叠策略）

Stacking是一种双阶段策略，第一阶段训练多个不同的基模型，第二阶段使用一个新的模型（称为元学习器或元分类器）来组合这些基模型的预测，基模型的输出作为元学习器的输入

优点：Stacking可以结合不同类型的模型，利用它们的互补优势来提高整体性能
难点：选择合适的元学习器和基模型，以及调优它们的参数可能比较复杂

核心思想： 组合（通过一个元学习器，来将多个不同基估计器的输出进行组合，从而计算最终的预测结果）

算法示例：

"""
    在sklearn中，ensemble是集成学习相关的模块，包含了多个实现集成学习的类
    对于Stacking策略，其分类器为StackingClassifier，回归器为StackingRegressor
"""
# 下面以分类任务进行实践，此处先引入StackingClassifier类
from sklearn.ensemble import StackingClassifier
"""
### StackingClassifier类的官方描述为：
Stacked generalization consists in stacking the output of individual
estimator and use a classifier to compute the final prediction. 
翻译：
先用多个分类器进行模型训练，再用一个分类器将训练的结果组合在一起，计算最终结果
"""

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 引入train_test_split，将数据集进一步切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 引入随机森林、线性支持向量机、逻辑回归算法的实现类
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import LinearSVC
from sklearn.linear_model import LogisticRegression
# 引入StandardScaler类，用于将特征缩放到均值为0、标准差为1的范围内（即：数据的标准化）
from sklearn.preprocessing import StandardScaler
# 引入make_pipeline类，make_pipeline用于创建一个处理管道，它按顺序链式连接多个数据处理步骤和估计器（即模型）。这样可以确保在模型训练和预测时，数据总是按照相同的顺序经过所有预处理步骤
from sklearn.pipeline import make_pipeline

# 实例化对象（随机森林、线性支持向量机这两个基分类器，LogisticRegression这个元分类器）
clf1 = RandomForestClassifier(n_estimators=10, random_state=42)
lsvc = LinearSVC(dual="auto", random_state=42)
# 将lsvc的实例按照标准化方法进行处理
clf2 = make_pipeline(StandardScaler(), lsvc)

# 生成基分类器的组合
estimators = [
('rf', clf1),
('svr', clf2)]

# 生成元分类器
clf3 = LogisticRegression()

# 实例化BaggingClassifier对象，构建堆叠器实例
sclf = StackingClassifier(
    estimators=estimators, 
    final_estimator=clf3
)

# 代入X_train, y_train，进行模型训练
sclf.fit(X_train, y_train)
# 代入X_test，进行模型预测
y_pred = sclf.predict(X_test)

# 比较测试集的标签值和预测出来的标签值，计算预测的准确率
acc = (y_pred == y_test).mean()
print(f"预测的准确率为:{acc}")

2.4.4 Boosting（提升策略）

Boosting是一种按顺序训练模型的方法，每个模型试图纠正前一个模型的错误（类似于错题集的思想）

Boosting算法通常从一个初始模型开始，然后逐个添加模型，每个新模型都专注于前一模型预测错误的样本

典型算法：AdaBoost、Gradient Boosting和XGBoost是流行的Boosting算法，它们通过关注被之前模型错误分类的样本来提高模型的性能
特点：Boosting通常能够提高模型的准确性，但也可能增加过拟合的风险，特别是当使用较少的数据时

核心思想： 错题集（先为数据集中的每个样本分配一个相同的初始权重，然后会计算训练结果的误差，针对那些被错误分类的样本，会增加其权重，最后通过加权多数投票的方式来结合所有基分类器的预测结果，形成最终的预测）

算法示例：

"""
    在sklearn中，ensemble是集成学习相关的模块，包含了多个实现集成学习的类
    对于Boosting策略，其分类器有很多种，比如基于Gradient Boosting算法分类器GradientBoostingClassifier、回归器GradientBoostingRegressor
"""
# 下面以分类任务进行实践，此处先引入GradientBoostingClassifier类
from sklearn.ensemble import GradientBoostingClassifier
"""
### GradientBoostingClassifier类的官方描述为：
This algorithm builds an additive model in a forward stage-wise fashion; it
allows for the optimization of arbitrary differentiable loss functions. In
each stage ``n_classes_`` regression trees are fit on the negative gradient
of the loss function, e.g. binary or multiclass log loss. Binary
classification is a special case where only a single regression tree is
induced.
翻译：
这个算法以一种逐步前进的方式构建一个加法模型，它允许对任意可微的损失函数进行优化（是梯度提升法，做分类任务，而不是像梯度下降法那样做参数优化）
在每个阶段中，该算法都会在损失函数的负梯度上拟合n_classes_棵回归树，例如二分类或多分类的对数损失（二分类是一个特殊情况，其中仅诱导一棵回归树）
"""

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 引入train_test_split，将数据集进一步切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建 Gradient Boosting 分类器实例
# n_estimators=100，意味着将训练 100 个决策树并将它们的预测结果组合起来形成最终的预测
gclf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.5, random_state=42)

# 代入X_train, y_train，进行模型训练
gclf.fit(X_train, y_train)
# 代入X_test，进行模型预测
y_pred = gclf.predict(X_test)

# 比较测试集的标签值和预测出来的标签值，计算预测的准确率
acc = (y_pred == y_test).mean()
print(f"预测的准确率为:{acc}")

2.5 实用算法及实践

这些实用算法代表了集成学习领域中几个非常强大的模型，它们在各种数据科学竞赛和实际应用中都取得了显著的成功。让我们来逐一了解这些算法：

2.5.1 随机森林算法（Random Forest）

随机森林（属于Bagging策略）是一种基于决策树的集成学习方法，它通过构建多个决策树并让它们对数据进行投票来提高预测的准确性和鲁棒性

工作原理：随机森林中的每棵树都是在原始数据的一个随机子集上训练的，这些子集是通过自助采样（bootstrap sampling）得到的，每棵树在训练时还会随机选择一部分特征来寻找最佳分裂点，从而增加树之间的多样性
优点：随机森林对于高维数据表现良好，能够处理大量特征，并且对特征的缩放不敏感，它还提供了特征重要性的估计，有助于了解模型的预测是如何受各个特征影响的
缺点：随机森林模型可能会消耗较多的内存和计算资源，尤其是在数据集很大或特征很多的情况下（很慢）

算法实践：

# 引入随机森林算法的实现类
from sklearn.ensemble import RandomForestClassifier
"""
    随机森林算法随机的是什么？
    1、样本的随机性：每棵树训练时使用的数据样本是随机选择的。
    2、特征的随机性：每棵树在分裂节点时考虑的特征是随机选择的子集。
    3、分裂点的随机性：由于特征选择的随机性，每棵树在每个节点上选择的分裂点也可能是随机的
"""

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 引入train_test_split，将数据集进一步切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 实例化RandomForestClassifier对象
# n_estimators=100，用于指定此随机森林对象中有100个决策树
clf = RandomForestClassifier(n_estimators=100, random_state=42)

# 代入X_train, y_train，进行模型训练
clf.fit(X_train, y_train)
# 代入X_test，进行模型预测
y_pred = clf.predict(X_test)

# 比较测试集的标签值和预测出来的标签值，计算预测的准确率
acc = (y_pred == y_test).mean()
print(f"预测的准确率为:{acc}")

2.5.2 XGBoost（eXtreme Gradient Boosting）

XGBoost（属于Boosting策略）是一种高效的梯度提升框架，它通过迭代地训练决策树来最小化一个预定的损失函数（是Kaggle比赛中大杀器）

工作原理：XGBoost通过按顺序添加树来提升模型的性能，每棵树都尝试纠正前一棵树的错误，它采用了正则化项来防止过拟合，并支持用户定义的损失函数和评估标准
优点：XGBoost在速度和性能上进行了优化，它支持并行处理，能够在单机上高效地处理大规模数据，此外，它还提供了正则化参数来控制模型的复杂度，有助于防止过拟合
缺点：虽然XGBoost非常强大，但需要仔细调整其众多的参数来获得最佳性能

算法实践：

# 引入xgboost算法的实现类
from xgboost import XGBClassifier

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 引入train_test_split，将数据集进一步切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 实例化XGBClassifier对象
# n_estimators=100，意味着将训练 100 个决策树并将它们的预测结果组合起来形成最终的预测
clf = XGBClassifier(n_estimators=100, learning_rate=0.1, random_state=42)

# 代入X_train, y_train，进行模型训练
clf.fit(X_train, y_train)
# 代入X_test，进行模型预测
y_pred = clf.predict(X_test)

# 比较测试集的标签值和预测出来的标签值，计算预测的准确率
acc = (y_pred == y_test).mean()
print(f"预测的准确率为:{acc}")

2.5.3 LightGBM（Light Gradient Boosting Machine）

LightGBM（属于Boosting策略）是由微软开发的梯度提升框架，它专注于处理大规模数据集，并且在速度和效率上进行了优化 （顶流明星，机器学习中的大数据算法）

工作原理：LightGBM使用了基于梯度的单边采样（Gradient-based One-Side Sampling, GOSS）和互斥特征捆绑（Exclusive Feature Bundling, EFB）技术来减少计算量，它还支持类别特征和缺失值的处理
优点：LightGBM在处理大规模数据集时非常高效，它的速度通常比XGBoost更快，同时保持了相似或更好的性能，它还提供了内置的支持来处理类别特征，这在其他一些梯度提升工具中可能需要额外的预处理步骤
缺点：虽然LightGBM在许多方面都很出色，但在某些特定类型的数据或问题上，可能需要更多的调参来达到最佳性能

算法实践：

# 引入lightgbm算法的实现类
from lightgbm import LGBMClassifier

# 引入load_iris，获取鸢尾花数据集
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 引入train_test_split，将数据集进一步切分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 实例化LGBMClassifier对象
# n_estimators=100，意味着将训练 100 个决策树并将它们的预测结果组合起来形成最终的预测
clf = LGBMClassifier(n_estimators=100, learning_rate=0.1, random_state=42)

# 代入X_train, y_train，进行模型训练
clf.fit(X_train, y_train)
# 代入X_test，进行模型预测
y_pred = clf.predict(X_test)

# 比较测试集的标签值和预测出来的标签值，计算预测的准确率
acc = (y_pred == y_test).mean()
print(f"预测的准确率为:{acc}")