数据科学基础上机作业（5）——南京工业大学2023年春季

数据科学5月4日上机测试

——made by njtech_计2104 Melody

使用分类器集成的方法预测红酒质量，数据源为winequality-red.csv。该数据集包含有1599条数据，每条数据有11个属性（分别代表红酒的一项化验指标）及一个质量评分。要求每位同学进行以下操作：

1. 载入数据（提示：可参考任务1中使用read_csv方法的数据载入）；

2. 对数据进行拆分，把11个属性和评分拆为两个变量（X和Y）；

3. 对属性进行归一化（提示：可参考任务1中的归一化预处理，或使用sklearn中preprocessing库里面的scale函数）；

4. 把数据集拆分为训练集和测试集（提示：train_test_split），测试集的大小为25%，指定随机种子为0，并注意保持测试集与整个数据集评分比例一致（提示：stratify）；

5. 分别训练kNN、SVM、DecisionTree三个模型，测试并输出其训练准确率及测试准确率（提示：可参考任务5）；

6. 使用集成算法对上述三个模型进行集成，测试并输出其准确率（提示：可使用sklearn.ensemble中的VotingClassifier库，SVM的SVC算法可添加probability=True选项改进计算概率）；

7. 观察集成算法的输出结果，分析其优势及可能的原因；

8. 调整上述三个基分类器模型的参数，给出你所认为的最优参数，并说明原因。

# 导库
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import scale
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.ensemble import VotingClassifier
from sklearn.model_selection import GridSearchCV

1. 导入数据

1.1 载入数据

url = './data/winequality-red.csv'
data = pd.read_csv(url, delimiter=';',header=0)
data.info()

<class ‘pandas.core.frame.DataFrame’>
RangeIndex: 1599 entries, 0 to 1598
Data columns (total 12 columns):

Column Non-Null Count Dtype

---

0 fixed acidity 1599 non-null float64
1 volatile acidity 1599 non-null float64
2 citric acid 1599 non-null float64
3 residual sugar 1599 non-null float64
4 chlorides 1599 non-null float64
5 free sulfur dioxide 1599 non-null float64
6 total sulfur dioxide 1599 non-null float64
7 density 1599 non-null float64
8 pH 1599 non-null float64
9 sulphates 1599 non-null float64
10 alcohol 1599 non-null float64
11 quality 1599 non-null int64
dtypes: float64(11), int64(1)
memory usage: 150.0 KB

这里有个坑，之前遇到的csv文件都是以 , 作为分隔符，这里是 ; 需要特别指定.

# 把11个属性和评分拆为两个变量（X和Y）：
X = data.iloc[:, :-1] # 切片索引，指定所有行，列为从第一列到倒数第一列(不包括最后一列)
Y = data.iloc[:, -1]  # 切片索引，指定所有行，列为倒数第一列
print(X.info())
print('-------------------------------------------------------')
print(Y.info())

<class ‘pandas.core.frame.DataFrame’>
RangeIndex: 1599 entries, 0 to 1598
Data columns (total 11 columns):

Column Non-Null Count Dtype

---

0 fixed acidity 1599 non-null float64
1 volatile acidity 1599 non-null float64
2 citric acid 1599 non-null float64
3 residual sugar 1599 non-null float64
4 chlorides 1599 non-null float64
5 free sulfur dioxide 1599 non-null float64
6 total sulfur dioxide 1599 non-null float64
7 density 1599 non-null float64
8 pH 1599 non-null float64
9 sulphates 1599 non-null float64
10 alcohol 1599 non-null float64
dtypes: float64(11)
memory usage: 137.5 KB

None

---

<class ‘pandas.core.series.Series’>
RangeIndex: 1599 entries, 0 to 1598
Series name: quality
Column Non-Null Count Dtype

---

11 quality 1599 non-null int64

dtypes: int64(1)
memory usage: 12.6 KB
None

1.2 对属性进行归一化

X_scaled = scale(X)
X_scaled

fixed acidity	volatile acidity	citric acid	residual sugar	chlorides	free sulfur dioxide	total sulfur dioxide	density	pH	sulphates	alcohol
-0.52836	0.961877	-1.391472	-0.453218	-0.243707	-0.466193	-0.379133	0.558274	1.288643	-0.579207	-0.960246
-0.298547	1.967442	-1.391472	0.043416	0.223875	0.872638	0.624363	0.028261	-0.719933	0.12895	-0.584777
-0.298547	1.297065	-1.18607	-0.169427	0.096353	-0.083669	0.229047	0.134264	-0.331177	-0.048089	-0.584777
1.654856	-1.384443	1.484154	-0.453218	-0.26496	0.107592	0.4115	0.664277	-0.979104	-0.46118	-0.584777

1.3 拆分数据集

X_train, X_test, Y_train, Y_test = train_test_split(X_scaled, Y, test_size=0.25, random_state=0, stratify=Y)

• test_size：测试集的大小为25%
• random_state：指定随机种子为0
• stratify：保持测试集与整个数据集评分比例一致

2. 训练模型

分别训练kNN、SVM、DecisionTree三个模型，测试并输出其训练准确率及测试准确率

# 创建模型实例
knn_model = KNeighborsClassifier()
svm_model = SVC()
dt_model = DecisionTreeClassifier()

# 训练模型
knn_model.fit(X_train, Y_train)
svm_model.fit(X_train, Y_train)
dt_model.fit(X_train, Y_train)

# kNN
knn_train_accuracy = accuracy_score(Y_train, knn_model.predict(X_train))
knn_test_accuracy = accuracy_score(Y_test, knn_model.predict(X_test))

# SVM
svm_train_accuracy = accuracy_score(Y_train, svm_model.predict(X_train))
svm_test_accuracy = accuracy_score(Y_test, svm_model.predict(X_test))

# Decision Tree
dt_train_accuracy = accuracy_score(Y_train, dt_model.predict(X_train))
dt_test_accuracy = accuracy_score(Y_test, dt_model.predict(X_test))

# 格式化并输出结果：
print(f"kNN 训练准确率: {knn_train_accuracy * 100:.2f}%")
print(f"kNN 测试准确率: {knn_test_accuracy * 100:.2f}%")
print(f"SVM 训练准确率: {svm_train_accuracy * 100:.2f}%")
print(f"SVM 测试准确率: {svm_test_accuracy * 100:.2f}%")
print(f"DT 训练准确率: {dt_train_accuracy * 100:.2f}%")
print(f"DT 测试准确率: {dt_test_accuracy * 100:.2f}%")

kNN 训练准确率: 70.81%
kNN 测试准确率: 57.50%
SVM 训练准确率: 67.06%
SVM 测试准确率: 65.25%
DT 训练准确率: 100.00%
DT 测试准确率: 62.75%

结果不尽人意，可能是默认参数没有经过优化

3. 集成算法

投票分类器（Voting Classifier），是一种结合多个不同基分类器的预测结果的集成方法。投票分类器通过将多个模型的预测结果进行投票，以获得最终的预测结果。

投票分类器的工作原理如下：

1. 首先，训练多个基分类器。在本例中，使用了k-近邻（kNN）、支持向量机（SVM）和决策树（Decision Tree）作为基分类器。
2. 对于新输入的数据点，每个基分类器都会对其进行预测。每个基分类器的预测结果被视为一个投票。
3. 投票分类器会根据投票策略（硬投票或软投票）统计投票结果。
   • 软投票：基于预测概率计算加权投票结果。每个分类器输出的概率会被相加，最终选取概率之和最高的类别作为预测结果。软投票通常在分类器能够输出预测概率时具有更好的性能。
   • 硬投票：选择票数最多的类别作为最终预测结果。如果有平局，投票分类器通常会选择类别标签较小的那个

投票分类器起作用的原因：

1. 集成多个模型可以提高泛化能力。投票分类器结合了多个模型的强点，降低了单个模型的弱点对预测性能的影响。
2. 投票分类器利用了多个模型的多样性。每个基分类器可能在不同特征或数据子集上表现良好。通过集成这些模型，投票分类器能够捕捉到更多的数据模式和特征。
3. 软投票策略允许考虑模型的置信度。高置信度的预测结果在投票过程中具有更大的权重，从而有助于提高预测性能。

# 创建一个基于kNN、SVM、DecisionTree三个模型的集成分类器：
# 创建SVM模型实例并设置probability=True(kNN和决策树天然支持概率输出)
svm_model_prob = SVC(probability=True)
svm_model_prob.fit(X_train, Y_train)

# 创建VotingClassifier实例
ensemble_model = VotingClassifier(estimators=[
    ('knn', knn_model),
    ('svm', svm_model_prob),
    ('dt', dt_model)],
    voting='soft')

# 训练集成模型
ensemble_model.fit(X_train, Y_train)

# 计算集成模型的准确率
ensemble_train_accuracy = accuracy_score(Y_train, ensemble_model.predict(X_train))
ensemble_test_accuracy = accuracy_score(Y_test, ensemble_model.predict(X_test))

# 输出集成模型的准确率：

print(f"Ensemble 训练准确率: {ensemble_train_accuracy * 100:.2f}%")
print(f"Ensemble 测试准确率: {ensemble_test_accuracy * 100:.2f}%")

Ensemble 训练准确率: 97.16%
Ensemble 测试准确率: 65.50%

集成算法的优势和可能原因分析：

1. 集成算法通过结合多个模型的预测结果，可以提高模型的泛化能力。通常情况下，集成模型的表现要优于单个模型，因为它们可以抵消各个模型的弱点。
2. 使用不同类型的模型进行集成可以增加模型多样性，有助于捕捉数据中的不同模式和特征。
3. 本例中，使用了投票分类器（VotingClassifier），根据每个模型的预测概率来决定最终预测结果。使用软投票策略（voting=‘soft’）有助于提高性能，因为它允许模型根据它们的置信度来加权预测结果。

附录:常见的集成算法

Bagging

Bagging（Bootstrap Aggregating）：Bagging是一种基于自助采样（bootstrap sampling）的集成方法。它通过在原始数据集上进行多次自助采样，为每个基学习器生成不同的训练子集。这些基学习器通常是相同类型的模型，例如决策树。最终的预测结果由所有基学习器的预测结果的平均值（回归）或多数投票（分类）得出。随机森林（Random Forest）就是基于Bagging思想的一种算法。

Boosting

Boosting：Boosting方法通过串行地训练一系列基学习器，每个基学习器都试图纠正前一个基学习器的错误。Boosting算法通常使用较弱的基学习器（例如浅层决策树），并将其组合成一个强大的模型。常见的Boosting算法有AdaBoost（Adaptive Boosting）和梯度提升机（Gradient Boosting Machine, GBM）。

Stacking

Stacking（Stacked Generalization）：Stacking方法首先训练多个不同类型的基学习器，然后使用一个元学习器（meta-learner）来组合这些基学习器的预测结果。元学习器可以是任何模型（如线性回归、逻辑回归、神经网络等），其训练数据由基学习器的输出组成。这样的层次结构有助于捕捉不同基学习器之间的相互关系，从而提高预测性能。

投票分类器

投票分类器（Voting Classifier）：投票分类器是一种简单的集成方法，通过对多个基学习器的预测结果进行投票来得出最终预测。投票可以是硬投票（预测类别的多数投票）或软投票（基于预测概率的加权投票）

4. 调参

上文说到，使用默认参数进行训练的效果不佳，需要调参，本次使用网格搜索（GridSearchCV）来找到每个基分类器的最优参数组合。

网格搜索（Grid Search）是一种用于超参数优化的暴力搜索方法。通过在超参数空间中搜索所有可能的组合，网格搜索旨在找到最佳超参数组合，以便在给定的问题上获得最佳模型性能。通常情况下，网格搜索与交叉验证（Cross-Validation）结合使用，以评估不同超参数组合的性能。

网格搜索的工作原理：

1. 首先定义每个超参数的搜索范围（通常为离散值列表）。
2. 然后构造所有可能的超参数组合的笛卡尔积。每个组合都包含了所有超参数的一个值。
3. 对于每个超参数组合，使用交叉验证评估模型性能。这通常涉及将数据集分为多个子集（如k折交叉验证），对于每个子集，使用一部分子集进行模型训练，另一部分子集进行模型评估。评估结果会被平均，以得到该超参数组合下模型的整体性能。
4. 选择具有最佳性能的超参数组合。这些超参数将用于训练最终模型。

网格搜索的优缺点：

优点：

• 易于实现，不需要复杂的算法。
• 可以找到全局最优解，不会陷入局部最优解。

缺点：

• 计算复杂度高，尤其是当超参数空间较大时，可能需要大量的计算资源和时间。
• 当超参数的搜索范围不合适时，可能无法找到最优解。

为每个模型设置参数网格

# kNN参数网格
knn_params = {
    'n_neighbors': list(range(1, 31)),
    'weights': ['uniform', 'distance'],
    'metric': ['euclidean', 'manhattan', 'minkowski']
}

# SVM参数网格
svm_params = {
    'C': [0.1, 0.5, 0.8, 1, 2, 5, 10],
    'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],
    'gamma': ['scale', 'auto'],
}

# DecisionTree参数网格
dt_params = {
    'criterion': ['gini', 'entropy'],
    'max_depth': [None, 10, 20, 30, 40, 50],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
    'random_state': [42]
}

1. kNN参数网格：
   • n_neighbors：kNN算法中的k值，表示选取最近的k个邻居进行投票。我们设置了从1到30的范围，以便找到一个合适的邻居数量，从而在过拟合和欠拟合之间达到平衡。
   • weights：用于确定邻居的权重。'uniform’表示所有邻居的权重相等，而’distance’表示权重与距离成反比。尝试这两种权重方法可以帮助我们找到更好的邻居投票策略。
   • metric：用于计算数据点之间的距离。我们选择了欧几里得距离（‘euclidean’）、曼哈顿距离（‘manhattan’）和闵可夫斯基距离（‘minkowski’）作为可能的距离度量。这些度量可以捕捉不同类型的数据模式。
2. SVM参数网格：
   • C：惩罚系数，用于控制模型的复杂度。较小的C值会导致较宽的间隔，允许一些错误分类，从而降低过拟合风险。较大的C值会导致较窄的间隔，强调正确分类，但可能导致过拟合。我们选择了一系列C值以找到最佳平衡。
   • kernel：核函数，用于将数据映射到更高维的空间。我们选择了线性核（‘linear’）、多项式核（‘poly’）、径向基核（‘rbf’）和Sigmoid核（‘sigmoid’），以便尝试不同的数据映射方法。
   • gamma：核函数的参数。对于’rbf’、'poly’和’sigmoid’核，'gamma’控制了特征空间的形状。我们选择了’scale’和’auto’两种方法，以便根据数据特征自动调整’gamma’值。
3. DecisionTree参数网格：
   • criterion：用于决定特征选择的方法。我们选择了基尼系数（‘gini’）和信息增益（‘entropy’），以便比较两种特征选择方法的效果。
   • max_depth：决策树的最大深度。设置最大深度可以防止过拟合。我们尝试了不限制深度（None）以及不同深度值，以找到最佳深度。
   • min_samples_split：拆分内部节点所需的最小样本数。较大的值可以防止过拟合，但可能导致树过于简单。我们尝试了2、5和10这几个值，以找到一个合适的拆分阈值。
   • min_samples_leaf：叶节点所需的最小样本数。这个参数可以限制树的生长，防止过拟合。我们选择了1、2和4这几个值，以便找到一个合适的叶节点样本数。
   • random_state：随机种子，用于确保结果的可重复性。我们设置了固定的随机种子42，以便实验结果在每次运行时保持一致。

对每个模型执行网格搜索

# kNN
knn_grid = GridSearchCV(KNeighborsClassifier(), knn_params, cv=5, scoring='accuracy', n_jobs=-1)
knn_grid.fit(X_train, Y_train)
print(f"最优kNN参数: {knn_grid.best_params_}")

# SVM
svm_grid = GridSearchCV(SVC(probability=True), svm_params, cv=5, scoring='accuracy', n_jobs=-1)
svm_grid.fit(X_train, Y_train)
print(f"最优SVM参数: {svm_grid.best_params_}")

# DecisionTree
dt_grid = GridSearchCV(DecisionTreeClassifier(), dt_params, cv=5, scoring='accuracy', n_jobs=-1)
dt_grid.fit(X_train, Y_train)
print(f"最优DecisionTree参数: {dt_grid.best_params_}")

最优kNN参数: {‘metric’: ‘euclidean’, ‘n_neighbors’: 11, ‘weights’: ‘distance’}
最优SVM参数: {‘C’: 2, ‘gamma’: ‘auto’, ‘kernel’: ‘rbf’}
最优DecisionTree参数: {‘criterion’: ‘gini’, ‘max_depth’: None, ‘min_samples_leaf’: 1, ‘min_samples_split’: 2, ‘random_state’: 42}

1. cv=5：交叉验证策略，表示将原始数据集分为5个子集，每次使用4个子集进行训练，剩下的1个子集进行验证。这个过程将进行5次，每次使用不同的子集进行验证。
2. scoring='accuracy'：模型性能的评估指标。在这个例子中，我们使用分类准确率（accuracy）作为评估指标。
3. n_jobs=-1：并行运算的数量。n_jobs 参数指定了用于计算的CPU核心数量。-1 表示使用所有可用的核心进行并行计算。

在给定的参数网格中，这些参数组合使模型在训练集的多个子集上达到了最佳性能。

# 使用最优参数训练模型
knn_optimal = KNeighborsClassifier(**knn_grid.best_params_)
svm_optimal = SVC(**svm_grid.best_params_, probability=True)
dt_optimal = DecisionTreeClassifier(**dt_grid.best_params_)

knn_optimal.fit(X_train, Y_train)
svm_optimal.fit(X_train, Y_train)
dt_optimal.fit(X_train, Y_train)

# 创建集成模型
ensemble_optimal = VotingClassifier(estimators=[
    ('knn', knn_optimal),
    ('svm', svm_optimal),
    ('dt', dt_optimal)],
    voting='soft')

ensemble_optimal.fit(X_train, Y_train)

# 计算准确率
knn_train_accuracy_optimal = accuracy_score(Y_train, knn_optimal.predict(X_train))
knn_test_accuracy_optimal = accuracy_score(Y_test, knn_optimal.predict(X_test))

svm_train_accuracy_optimal = accuracy_score(Y_train, svm_optimal.predict(X_train))
svm_test_accuracy_optimal = accuracy_score(Y_test, svm_optimal.predict(X_test))

dt_train_accuracy_optimal = accuracy_score(Y_train, dt_optimal.predict(X_train))
dt_test_accuracy_optimal = accuracy_score(Y_test, dt_optimal.predict(X_test))

ensemble_train_accuracy_optimal = accuracy_score(Y_train, ensemble_optimal.predict(X_train))
ensemble_test_accuracy_optimal = accuracy_score(Y_test, ensemble_optimal.predict(X_test))

# 输出结果
print(f"kNN 训练准确率: {knn_train_accuracy_optimal * 100:.2f}%")
print(f"kNN 测试准确率: {knn_test_accuracy_optimal * 100:.2f}%")
print(f"SVM 训练准确率: {svm_train_accuracy_optimal * 100:.2f}%")
print(f"SVM 测试准确率: {svm_test_accuracy_optimal * 100:.2f}%")
print(f"DT 训练准确率: {dt_train_accuracy_optimal * 100:.2f}%")
print(f"DT 测试准确率: {dt_test_accuracy_optimal * 100:.2f}%")
print(f"Ensemble 训练准确率: {ensemble_train_accuracy_optimal * 100:.2f}%")
print(f"Ensemble 测试准确率: {ensemble_test_accuracy_optimal * 100:.2f}%")

kNN 训练准确率: 100.00%
kNN 测试准确率: 66.00%
SVM 训练准确率: 70.31%
SVM 测试准确率: 66.25%
DT 训练准确率: 100.00%
DT 测试准确率: 62.50%
Ensemble 训练准确率: 100.00%
Ensemble 测试准确率: 66.75%

附录：知识背景

knn

一个样本可以通过其邻居的类别来确定自己的类别。即为了判断未知样本的类别，以所有已知类别的样本作为参照，计算未知样本与所有已知样本的距离，从中选取与未知样本距离最近的K个已知样本，根据少数服从多数的投票法则（majority-voting），将未知样本与K个最邻近样本中所属类别占比较多的归为一类。

如下图所示，如何判断绿色圆应该属于哪一类，是属于红色三角形还是属于蓝色四方形？如果K=3，由于红色三角形所占比例为2/3，绿色圆将被判定为属于红色三角形那个类，如果K=5，由于蓝色四方形比例为3/5，因此绿色圆将被判定为属于蓝色四方形类。

经过上述分析，可以知道在KNN算法中，影响准确度最大的参数通常是 K 值，k值的选择对算法的准确性和稳定性有很大影响。较小的k值容易受到噪声数据的影响，导致过拟合；较大的k值可能会使模型过于平滑，导致欠拟合。通常，k值的选择通过交叉验证来确定。

流程：

1. 计算待分类样本与已知类别样本之间的距离。
2. 按距离升序排序，选取距离最近的k个邻居。
3. 统计k个邻居中各类别的出现次数。
4. 将出现次数最多的类别作为待分类样本的类别。

svm

假设我们有一个二维空间中的数据集，包括两个类别：A 和 B。我们的目标是根据这些已标记的数据点构建一个分类器，以便在未来对新的未标记数据点进行分类。

这里，SVM可以帮助我们找到一个能够尽可能正确地将A类和B类数据点分开的决策边界（在这种情况下是一条直线）。

以下是SVM如何实现这一目标的：

1. 最大化间隔：SVM试图找到一个最佳的直线，使得它与两个类别中距离最近的数据点（即支持向量）之间的距离（间隔）最大。这有助于提高分类器的泛化能力，因为最大化间隔能够降低过拟合的风险。
2. 最小化分类误差：在某些情况下，数据集可能是线性不可分的，这意味着没有一条直线能完全正确地将A类和B类数据点分开。在这种情况下，SVM允许一些数据点被错误分类，以便找到一个在整体上表现较好的决策边界。为了实现这一目标，SVM引入了松弛变量和惩罚系数C，它们控制允许错误分类的程度。
3. 处理线性不可分问题：如果数据集是线性不可分的，SVM可以使用核技巧将数据点映射到更高维的特征空间，在该空间中找到一个线性可分的超平面。核函数（如径向基函数、多项式核等）可以直接计算数据点在高维空间中的内积，从而避免了显式地将数据点映射到高维空间的计算复杂性。

训练SVM后，我们可以得到一个分类器，它可以根据找到的决策边界对新的未标记数据点进行分类。这对于解决现实世界中的分类问题，如垃圾邮件过滤、图像识别、文本分类等，都是非常有用的。

决策树

决策树（Decision Tree）是一种监督学习算法，用于分类和回归任务。它通过递归地将数据集划分为多个子集，以构建一个具有分支结构的树形模型。每个分支表示一个特征的划分条件，而叶节点表示最终的类别（对于分类任务）或输出值（对于回归任务）。决策树算法易于理解和实现，同时可以很好地解释模型预测结果。

原理：

1. 特征选择：决策树算法首先从输入特征中选择一个最佳特征，用于根据该特征的值将数据集进行划分。特征选择的目标是找到一个可以最大程度减少子集内类别混乱程度的特征。常用的特征选择方法有基尼系数（Gini Impurity）和信息增益（Information Gain）。
2. 递归划分：选择最佳特征后，将数据集划分为多个子集，每个子集包含相应特征值的样本。然后，对每个子集重复进行特征选择和划分，直到满足终止条件（如达到最大树深度、叶节点最小样本数等）。
3. 剪枝：为了防止过拟合，可以对决策树进行剪枝。剪枝是一种简化树结构的方法，通过合并不重要的叶节点来减少决策树的复杂度。常用的剪枝方法有预剪枝（Pre-Pruning）和后剪枝（Post-Pruning）。

工作方式：

1. 训练：在训练阶段，决策树算法通过递归地选择特征并对数据集进行划分，最终形成一个决策树模型。
2. 预测：在预测阶段，将输入样本从决策树的根节点开始，沿着满足特征条件的分支向下传递，直到达到叶节点。对于分类任务，叶节点的类别作为预测结果；对于回归任务，叶节点的输出值作为预测结果。

集成算法

集成算法（Ensemble Learning）是一种将多个模型组合在一起的机器学习方法，旨在提高模型的性能、准确性和稳定性。集成方法通常可以降低模型的方差（减少过拟合）和偏差（减少欠拟合），从而在许多问题上实现更好的泛化能力。

集成算法的主要思想是利用一组基本模型（称为基分类器或基回归器）的预测能力，通过对它们的输出进行组合，以获得一个更强大的最终模型。通常情况下，基模型可以是相同类型的模型（例如，多个决策树）或不同类型的模型（例如，决策树、支持向量机和K近邻等）。