十大集成学习模型超全总结

kexue · 发表于 2024-4-21 16:51:48

核心点：十大集成学习模型超全总结！
今天给大家分享的是关于集成学习的算法模型，也是整理了最常用最重要的10个算法模型：

Bagging
Boosting
AdaBoost
Gradient Boosting Machine
XGBoost
LightGBM
CatBoost
Stacking
Blending
Voting

简单来说，集成算法模型通过组合多个基本模型的预测结果来提高整体模型的性能和泛化能力，从而减少单个模型的偏差和方差。能够有效地利用多个模型的优势，提高预测准确率，并且适用于各种不同类型的机器学习问题。集成算法模型的核心思想是“众人拾柴火焰高”，通过多个模型的共同努力，达到更好的预测效果。

接下来，咱们一起来看下~
Bagging
Bagging (Bootstrap Aggregating) 通过对原始数据集进行有放回抽样（bootstrap）来构建多个子模型，并通过投票或平均等方式将这些子模型的结果进行组合，以提高整体模型的性能和泛化能力。
核心原理
1. Bootstrap抽样：从原始数据集中有放回地随机抽样生成多个新的训练数据集，每个数据集的大小与原始数据集相同，但可能包含重复的样本。

2. 构建多个子模型：利用这些新的训练数据集分别训练出多个基本模型，每个基本模型可能使用不同的算法或参数设置。

3. 组合预测结果：对于分类任务，通过投票机制（多数投票）确定最终的分类结果；对于回归任务，通过平均多个模型的预测值来得到最终的预测结果。
核心公式
1. Bootstrap抽样：

设原始数据集为，共有  个样本。通过有放回地从  中抽样  个样本构成新的数据集，重复抽样  次得到  个新数据集。

抽样方式可以用下面的公式表示：

其中，和  分别表示第  个数据集中的第  个样本的特征和标签。

2. 组合预测结果：

对于分类问题，假设有  个基本分类器，每个分类器对样本进行分类得到类别，其中  表示第  个样本，表示第  个基本分类器。

最终的分类结果通过投票的方式确定：

对于回归问题，假设有  个基本回归器，每个回归器对样本进行预测得到值。

最终的回归结果通过取平均值的方式确定：

Bagging 的核心在于通过引入随机性来增加模型的多样性，从而减少模型的方差。由于每个基本模型只看到了部分数据，因此每个模型学到的是数据的不同方面，通过组合这些模型可以得到更加稳健的整体模型。
特点和适用场景

降低方差：Bagging 主要适用于高方差的模型，通过组合多个模型可以显著降低整体模型的方差，提高泛化能力。
减少过拟合：由于每个基本模型只看到部分数据，因此 Bagging 也可以减少过拟合的风险。
适用于大数据集：由于采用了有放回抽样，因此 Bagging 在处理大数据集时也能够有效地进行模型训练。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor

复制代码

# 生成模拟数据
np.random.seed(0)
X = np.random.rand(100, 1) * 10
y = 2 * X.squeeze() + np.random.randn(100) # 添加噪声
# 创建 Bagging 回归器
base_estimator = DecisionTreeRegressor(max_depth=5) # 基本回归器
bagging_regressor = BaggingRegressor(base_estimator, n_estimators=10)
# 训练模型
bagging_regressor.fit(X, y)
# 绘制原始数据和拟合曲线
plt.figure(figsize=(10, 6))
plt.scatter(X, y, c='b', label='data')
plt.plot(np.sort(X, axis=0), bagging_regressor.predict(np.sort(X, axis=0)), c='r', label='Bagging Regression')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Bagging Regression')
plt.legend()
plt.show()

复制代码

代码中，使用了一个决策树回归器作为基本模型，然后构建了一个包含10个基本模型的Bagging回归器。最后，绘制了原始数据和Bagging回归器的拟合曲线，从图中可以看出Bagging回归器对原始数据进行了较好的拟合。

Boosting
Boosting 通过顺序构建一系列弱学习器（通常是决策树）并将它们组合成一个强学习器。Boosting的核心在于通过逐步调整数据的权重，使得每个新模型都专注于之前模型未能正确分类的样本，从而不断改进整体模型的性能。
核心原理
1. 顺序构建弱学习器：Boosting通过顺序构建一系列弱学习器来逐步改进模型。每个弱学习器都尝试在前一个模型的基础上修正错误，使得整体模型性能逐步提升。

2. 样本权重调整：在每一轮训练中，Boosting会调整样本的权重，使得之前分类错误的样本在下一轮训练中受到更多的关注，从而让新模型集中学习这些难以分类的样本。

3. 加权投票组合：最终的预测结果是所有弱学习器的加权组合，通常采用加权投票的方式（分类问题）或加权平均的方式（回归问题）。
核心公式
1. 样本权重调整：

在每一轮训练中，Boosting会调整样本的权重，使得之前分类错误的样本在下一轮训练中受到更多的关注。假设有  个样本，初始时每个样本的权重相等，即，其中。

在第  轮训练后，计算样本的误差率，然后根据误差率更新样本的权重：

其中，是样本  的真实标签，是第  个弱学习器对样本  的预测结果，是第  个弱学习器的权重，是归一化因子，是第  轮的误差率。

2. 加权投票组合：

对于分类问题，假设有  个弱学习器，每个弱学习器的权重为。最终的分类结果通过加权投票的方式确定：

其中，是样本  的预测结果。

对于回归问题，最终的预测结果通过加权平均的方式确定：

Boosting的核心思想在于通过顺序训练多个弱学习器，每个弱学习器都专注于之前模型未能正确分类的样本，从而不断改进整体模型的性能。通过加权组合多个弱学习器，Boosting能够在每一轮迭代中降低整体模型的偏差，从而提高整体模型的泛化能力。
特点和适用场景

逐步改进：Boosting逐步改进模型，每一轮迭代都在前一轮的基础上提升性能，因此能够得到较高的准确率。
注意过拟合：Boosting容易受到噪声数据的影响，因此需要谨慎调整模型参数以防止过拟合。
适用于各种数据集：Boosting适用于各种类型的数据集和问题，尤其在分类和回归问题上表现优异。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor
# 生成模拟数据
np.random.seed(0)
X = np.random.rand(100, 1) * 10
y = 2 * X.squeeze() + np.random.randn(100) # 添加噪声
# 创建 AdaBoost 回归器
base_estimator = DecisionTreeRegressor(max_depth=5) # 基本回归器
adaboost_regressor = AdaBoostRegressor(base_estimator, n_estimators=10, learning_rate=0.1)
# 训练模型
adaboost_regressor.fit(X, y)
# 绘制原始数据和拟合曲线
plt.figure(figsize=(10, 6))
plt.scatter(X, y, c='b', label='data')
plt.plot(np.sort(X, axis=0), adaboost_regressor.predict(np.sort(X, axis=0)), c='r', label='AdaBoost Regression')
plt.xlabel('X')
plt.ylabel('y')
plt.title('AdaBoost Regression')
plt.legend()
plt.show()

复制代码

代码中，使用了一个决策树回归器作为基本模型，然后构建了一个包含10个基本模型的AdaBoost回归器。最后，绘制原始数据和AdaBoost回归器的拟合曲线，从图中可以看出AdaBoost回归器对原始数据进行了较好的拟合。

AdaBoost
AdaBoost（Adaptive Boosting）通过顺序构建一系列弱学习器（通常是决策树）并将它们组合成一个强学习器。AdaBoost的核心在于通过调整样本的权重，使得每个新模型都专注于之前模型未能正确分类的样本，从而不断改进整体模型的性能。
核心原理
1. 顺序构建弱学习器：AdaBoost通过顺序构建一系列弱学习器来逐步改进模型。每个弱学习器都尝试在前一个模型的基础上修正错误，使得整体模型性能逐步提升。

2. 样本权重调整：在每一轮训练中，AdaBoost会调整样本的权重，使得之前分类错误的样本在下一轮训练中受到更多的关注，从而让新模型集中学习这些难以分类的样本。

3. 加权投票组合：最终的预测结果是所有弱学习器的加权组合，其中每个弱学习器的权重由其在训练过程中的表现来决定。
核心公式
1. 样本权重调整：

在每一轮训练中，AdaBoost会调整样本的权重，使得之前分类错误的样本在下一轮训练中受到更多的关注。假设有  个样本，初始时每个样本的权重相等，即，其中。

在第  轮训练后，计算样本的误差率，然后根据误差率更新样本的权重：

其中，是样本  的真实标签，是第  个弱学习器对样本  的预测结果，是第  个弱学习器的权重，是归一化因子，是第  轮的误差率。

2. 加权投票组合：

最终的预测结果通过加权投票的方式确定：

其中，是样本  的预测结果。

AdaBoost 的核心思想在于通过顺序训练多个弱学习器，每个弱学习器都专注于之前模型未能正确分类的样本，从而不断改进整体模型的性能。通过加权组合多个弱学习器，AdaBoost能够在每一轮迭代中降低整体模型的偏差，从而提高整体模型的泛化能力。
特点和适用场景

自适应调整：AdaBoost会自适应地调整样本的权重，使得每个新模型都能够更专注于之前模型未能正确分类的样本，从而提高整体模型的性能。
注意过拟合：AdaBoost容易受到噪声数据的影响，因此需要谨慎调整模型参数以防止过拟合。
适用于各种数据集：AdaBoost适用于各种类型的数据集和问题，尤其在分类和回归问题上表现优异。

一个详细的案例

# 绘制分类结果
plt.figure(figsize=(10, 6))
# 绘制训练数据点
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap='viridis', marker='o', label='Train Data')
# 绘制测试数据点
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap='viridis', marker='s', label='Test Data')
# 绘制决策边界
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))
Z = adaboost_classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.5, cmap='viridis')
# 添加标题和标签
plt.title('AdaBoost Classification')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
# 显示网格
plt.grid(True)
plt.show()

复制代码

代码中，首先生成了一个二维的示例数据集，然后将数据集分成训练集和测试集。接着初始化了一个AdaBoost分类器，使用决策树作为基分类器。在训练集上训练了AdaBoost分类器，并在测试集上进行了预测，计算了分类准确率。

最后，通过绘制训练数据点、测试数据点以及分类边界来可视化分类结果。

Gradient Boosting Machine
Gradient Boosting Machine (GBM) 通过顺序构建一系列弱学习器，并通过梯度下降法逐步优化模型的损失函数，从而得到一个强大的整体模型。GBM的核心在于利用梯度信息来提升模型性能，通过不断减小残差（预测值与真实值之间的差异），从而逐步改进整体模型。
核心原理
1. 顺序构建弱学习器：GBM通过顺序构建一系列弱学习器来逐步改进模型。每个弱学习器都尝试在前一个模型的基础上修正残差，使得整体模型性能逐步提升。

2. 损失函数优化：GBM通过梯度下降法优化损失函数，即最小化模型预测值与真实值之间的差异。在每一轮训练中，GBM计算残差，并利用残差来拟合下一个弱学习器，从而逐步减小残差，改进整体模型。

3. 加权组合：最终的预测结果是所有弱学习器的加权组合，其中每个弱学习器的权重由其在训练过程中的表现来决定。
核心公式
1. 损失函数优化：

在每一轮训练中，GBM需要优化的是损失函数，常用的损失函数包括平方损失函数（用于回归问题）和对数损失函数（用于分类问题）。

假设第轮的模型为，损失函数为，其中是真实标签，是第轮模型的预测值。则第轮需要拟合的残差为。

2. 加权组合：

最终的预测结果通过加权组合的方式确定：

其中，是学习率，用于控制每个弱学习器的权重，是第个弱学习器的权重，是第个弱学习器的预测结果。

GBM的核心思想在于通过梯度下降法优化损失函数，即最小化模型预测值与真实值之间的差异。每一轮迭代都尝试降低残差，从而逐步改进整体模型。通过加权组合多个弱学习器，GBM能够在每一轮迭代中降低整体模型的偏差，从而提高整体模型的泛化能力。
特点和适用场景

灵活性和鲁棒性：GBM在处理不同类型的数据和问题时表现良好，具有较强的灵活性和鲁棒性。
优秀的泛化能力：GBM通过逐步改进模型，能够得到较高的准确率和泛化能力。
注意过拟合：GBM容易受到噪声数据的影响，需要谨慎调整模型参数以防止过拟合。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
# 生成模拟数据
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 创建 Gradient Boosting 回归器
gbm_regressor = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3)
# 训练模型
gbm_regressor.fit(X_train, y_train)
# 在测试集上评估模型
y_pred = gbm_regressor.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print("Mean Squared Error:", mse)
# 绘制特征重要性
plt.figure(figsize=(10, 6))
plt.bar(range(len(gbm_regressor.feature_importances_)), gbm_regressor.feature_importances_)
plt.xlabel('Feature Index')
plt.ylabel('Feature Importance')
plt.title('Feature Importance in GBM')
plt.show()

复制代码

使用了一个包含100个弱学习器的GBM回归器。使用测试集评估了模型的性能。

最后，绘制了特征重要性的可视化图。

XGBoost
XGBoost（eXtreme Gradient Boosting）是一种基于Gradient Boosting算法的优化版本，通过结合优化的正则化技术和并行化策略，提高了模型的性能和可扩展性。XGBoost的核心在于通过梯度提升算法逐步构建多个弱学习器，并结合正则化技术和并行化处理来提高模型的泛化能力和训练效率。
核心原理
1. 顺序构建弱学习器：XGBoost通过顺序构建多个弱学习器来逐步改进模型。每个弱学习器都尝试在前一个模型的基础上修正残差，使得整体模型性能逐步提升。

2. 正则化技术：XGBoost引入了正则化技术，包括和正则化以及树的复杂度控制，通过限制模型的复杂度来避免过拟合。

3. 并行化处理：XGBoost通过利用并行化处理来加速模型的训练过程，包括特征分裂并行化和树的构建并行化。
核心公式
1. 损失函数：

XGBoost的损失函数由两部分组成：第一部分是模型预测值与真实值之间的损失，第二部分是正则化项。

损失函数的一般形式为：

其中，表示第个样本的损失函数，表示第个弱学习器的正则化项。

2. 弱学习器的构建：

弱学习器的构建分为两个阶段：第一个阶段是计算残差，第二个阶段是根据残差拟合一个新的弱学习器。

对于第轮迭代，弱学习器的输出为，则第轮的残差为：

然后，根据残差拟合一个新的弱学习器，使得损失函数最小化：

XGBoost的核心在于通过梯度提升算法逐步构建多个弱学习器，并结合正则化技术和并行化处理来提高模型的泛化能力和训练效率。通过限制模型的复杂度和加速训练过程，XGBoost能够在处理大规模数据和复杂模型时表现出色。
特点和适用场景

高效性：XGBoost通过并行化处理和优化的算法实现了高效的模型训练，尤其适用于大规模数据和复杂模型。
泛化能力：XGBoost通过结合正则化技术和梯度提升算法，能够得到具有较强泛化能力的模型。
广泛应用：XGBoost适用于各种类型的数据和问题，尤其在分类、回归和排序等任务中表现出色。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
import xgboost as xgb
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
# 生成模拟数据
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 转换数据为DMatrix格式
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
# 定义参数
params = {
'objective': 'reg:squarederror',
'eval_metric': 'rmse',
'eta': 0.1,
'max_depth': 3,
'subsample': 0.8,
'colsample_bytree': 0.8,
'lambda': 1,
'alpha': 0.1,
'seed': 42
}
# 训练模型
num_round = 100
bst = xgb.train(params, dtrain, num_round)
# 在测试集上评估模型
y_pred = bst.predict(dtest)
mse = mean_squared_error(y_test, y_pred)
print("Mean Squared Error:", mse)
# 绘制特征重要性
xgb.plot_importance(bst)
plt.show()

复制代码

代码中使用了XGBoost库来构建回归模型。以及一个包含100个迭代轮数的XGBoost模型。

最后，使用测试集评估了模型的性能，并绘制了特征重要性的可视化图。

LightGBM
LightGBM 是一种基于梯度提升决策树（GBDT）的高效梯度提升框架，具有快速训练速度和高效的内存使用。其核心原理是基于梯度提升决策树的思想，但采用了一些创新的算法来提高训练速度和模型性能。
核心原理
1. 基于叶子结点的决策树算法：LightGBM采用基于叶子结点的决策树算法，即每次选择最大收益（即最大信息增益）的叶子结点进行分裂，而不是遍历所有可能的分裂点，从而减少了计算复杂度。

2. 直方图算法：LightGBM采用直方图算法来构建每个特征的直方图，通过对直方图的分裂来找到最佳的分裂点，进一步加速了模型的训练速度。

3. Leaf-wise生长策略：LightGBM采用Leaf-wise生长策略，即每次选择增益最大的叶子结点进行分裂，而不是按层进行分裂，这样能够更快地找到最优的分裂点。
核心公式
1. 损失函数：

LightGBM的损失函数由两部分组成：第一部分是模型预测值与真实值之间的损失，第二部分是正则化项。

损失函数的一般形式为：

其中，表示第个样本的损失函数，表示第个叶子结点的正则化项。

2. 弱学习器的构建：

弱学习器的构建采用了梯度提升算法的思想，即每次构建一个新的弱学习器来拟合当前模型的残差，从而逐步改进模型。

LightGBM的核心思想是基于梯度提升决策树的思想，但在算法上做了一些优化，包括Leaf-wise生长策略、直方图算法等，从而实现了快速的模型训练和高效的内存使用。通过这些优化，LightGBM能够在处理大规模数据和复杂模型时表现出色。
特点和适用场景

高效性：LightGBM通过Leaf-wise生长策略和直方图算法实现了快速的模型训练，适用于大规模数据和高维特征。
低内存占用：LightGBM采用了基于直方图的算法，减少了内存占用，使得可以处理更大规模的数据。
准确性：LightGBM在模型的准确性上有较好的表现，能够得到较高的预测精度。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 生成模拟数据
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 转换数据为Dataset格式
train_data = lgb.Dataset(X_train, label=y_train)
test_data = lgb.Dataset(X_test, label=y_test)
# 定义参数
params = {
'objective': 'binary',
'metric': 'binary_error',
'num_leaves': 31,
'learning_rate': 0.1,
'feature_fraction': 0.8,
'bagging_fraction': 0.8,
'bagging_freq': 5,
'seed': 42
}
# 训练模型
num_round = 100
bst = lgb.train(params, train_data, num_round, valid_sets=[test_data], early_stopping_rounds=10)
# 在测试集上评估模型
y_pred = np.round(bst.predict(X_test))
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
# 绘制特征重要性
lgb.plot_importance(bst, max_num_features=10)
plt.show()

复制代码

以上代码，使用了一个包含100轮迭代的LightGBM模型。使用测试集评估了模型的性能，绘制了特征重要性的可视化图。

CatBoost
CatBoost 是一种基于梯度提升决策树（GBDT）的机器学习算法，特别设计用于处理分类问题。其核心原理类似于其他梯度提升算法，但具有一些创新的技术，如自适应的特征处理、类别特征的处理、基于对称的树的生长策略等，以提高模型的性能和泛化能力。
核心原理
1. 自适应的特征处理：CatBoost能够自动处理缺失值和分类特征，无需进行独热编码或者填充缺失值，从而简化了特征工程的流程。

2. 基于对称的树的生长策略：CatBoost采用基于对称的树的生长策略，即每次选择增益最大的分裂点进行分裂，而不是按层进行分裂，这样能够更快地找到最优的分裂点。

3. 类别特征的处理：CatBoost采用了一种特殊的编码方式来处理类别特征，即对类别特征进行排序后，将每个类别映射到一个实数值，从而能够更好地处理类别特征。
核心公式
1. 损失函数：

CatBoost的损失函数由两部分组成：第一部分是模型预测值与真实值之间的损失，第二部分是正则化项。

损失函数的一般形式为：

其中，表示第个样本的损失函数，表示第个叶子结点的正则化项。

2. 弱学习器的构建：

弱学习器的构建采用了梯度提升算法的思想，即每次构建一个新的弱学习器来拟合当前模型的残差，从而逐步改进模型。

CatBoost的核心思想是基于梯度提升决策树的思想，但在算法上做了一些优化，如自适应的特征处理、类别特征的处理等，从而实现了更高的模型性能和泛化能力。
特点和适用场景

自适应特征处理：CatBoost能够自动处理缺失值和类别特征，适用于需要快速建模的场景。
高性能：CatBoost采用了基于对称的树的生长策略和特殊的类别特征编码方式，能够实现更高的训练速度和模型性能。
适用于分类问题：CatBoost特别适用于处理分类问题，如用户行为预测、推荐系统等。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
import catboost as cb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 生成模拟数据
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 定义CatBoost分类器
clf = cb.CatBoostClassifier(iterations=100, depth=6, learning_rate=0.1, loss_function='Logloss')
# 训练模型
clf.fit(X_train, y_train, eval_set=(X_test, y_test), verbose=10)
# 在测试集上评估模型
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
# 绘制特征重要性
cb.plot_importance(clf, max_num_features=10)
plt.show()

复制代码

使用了CatBoost库来构建分类模型。使用了一个包含100轮迭代的CatBoost模型。使用测试集评估了模型的性能，最后绘制了特征重要性的可视化图。
Stacking
Stacking（堆叠）是一种集成学习方法，通过将多个基本模型的预测结果作为新特征，再训练一个次级模型来融合基本模型的预测结果，从而得到更强大的整体模型。其核心原理在于通过组合多个模型的优点来弥补各个模型的缺点，从而提高整体模型的性能。
核心原理
1. 多模型集成：Stacking通过组合多个不同类型的基本模型来构建更强大的整体模型。这些基本模型可以是任意类型的机器学习模型，如决策树、支持向量机、神经网络等。

2. 特征融合：Stacking将多个基本模型的预测结果作为新特征，构建一个新的特征矩阵，作为次级模型的输入。这样可以利用不同模型的优点，提高整体模型的泛化能力。

3. 次级模型训练：将新特征矩阵和真实标签作为次级模型的训练数据，训练一个次级模型来融合各个基本模型的预测结果。次级模型可以是任意类型的机器学习模型，通常采用简单的线性模型如逻辑回归或者岭回归。
核心公式
Stacking的核心公式可以分为两个阶段：

1. 特征融合：

将多个基本模型的预测结果作为新特征构建特征矩阵：

其中，是训练样本数量，是基本模型的数量，表示第个样本在第个基本模型的预测结果。

2. 次级模型训练：

使用新特征矩阵和真实标签训练一个次级模型：

Stacking的核心思想在于通过组合多个不同类型的基本模型，利用它们的优点来提高整体模型的泛化能力。通过构建一个新的特征矩阵，并训练一个次级模型来融合各个基本模型的预测结果，从而得到更强大的整体模型。
特点和适用场景

泛化能力强：Stacking能够充分利用不同模型的优点，提高整体模型的泛化能力。
灵活性高：Stacking可以使用任意类型的基本模型，并可以灵活选择次级模型，适用于各种不同类型的数据和问题。
计算成本高：Stacking需要训练多个基本模型和一个次级模型，计算成本较高，尤其在处理大规模数据时需要谨慎考虑。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
# 生成模拟数据
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 定义基本模型
models = [
RandomForestClassifier(n_estimators=100, random_state=42),
SVC(kernel='linear', C=0.1, probability=True, random_state=42)
]
# 生成空特征矩阵
X_meta_train = np.zeros((len(X_train), len(models)))
X_meta_test = np.zeros((len(X_test), len(models)))
# 交叉验证生成元特征
kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for i, model in enumerate(models):
for train_index, val_index in kf.split(X_train, y_train):
X_train_fold, X_val_fold = X_train[train_index], X_train[val_index]
y_train_fold, y_val_fold = y_train[train_index], y_train[val_index]
model.fit(X_train_fold, y_train_fold)
X_meta_train[val_index, i] = model.predict_proba(X_val_fold)[:, 1]
X_meta_test[:, i] = model.predict_proba(X_test)[:, 1]
# 定义次级模型
meta_model = LogisticRegression()
# 训练次级模型
meta_model.fit(X_meta_train, y_train)
# 在测试集上评估模型
y_pred = meta_model.predict(X_meta_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
from sklearn.metrics import roc_curve, auc, confusion_matrix
# 绘制 ROC 曲线
plt.figure(figsize=(10, 5))
for i, model in enumerate(models):
fpr, tpr, _ = roc_curve(y_test, X_meta_test[:, i])
roc_auc = auc(fpr, tpr)
plt.plot(fpr, tpr, label=f'{model.__class__.__name__} (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], 'k--', lw=2)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc="lower right")
plt.show()
# 绘制混淆矩阵
conf_mat = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 6))
plt.imshow(conf_mat, interpolation='nearest', cmap=plt.cm.Blues)
plt.title('Confusion Matrix')
plt.colorbar()
plt.xticks([0, 1], ['Predicted Negative', 'Predicted Positive'])
plt.yticks([0, 1], ['True Negative', 'True Positive'])
for i in range(2):
for j in range(2):
plt.text(j, i, format(conf_mat[i, j], 'd'), horizontalalignment="center", color="white" if conf_mat[i, j] > conf_mat.max() / 2 else "black")
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.tight_layout()
plt.show()

复制代码

案例中，选择了两种基本模型：随机森林和支持向量机，然后使用交叉验证生成元特征矩阵。训练了一个逻辑回归模型作为次级模型。

最后，ROC 曲线展示了不同模型的性能，AUC 值越大，模型性能越好。混淆矩阵展示了模型的预测结果与真实标签之间的关系，可以更直观地了解模型的分类效果。

Blending
Blending（混合）是一种集成学习方法，类似于Stacking，它也是通过组合多个基本模型的预测结果来得到最终的预测结果。但与Stacking不同的是，Blending不是使用交叉验证来生成次级模型的训练数据，而是直接使用验证集的预测结果。Blending的核心原理在于通过组合多个基本模型的预测结果，利用验证集的信息来融合这些预测结果，从而得到更好的整体模型。
核心原理
1. 多模型集成：与Stacking类似，Blending通过组合多个不同类型的基本模型来构建更强大的整体模型。

2. 验证集预测：Blending使用验证集来生成基本模型的预测结果，并将这些预测结果作为新特征构建特征矩阵。

3. 次级模型训练：将新特征矩阵和验证集的真实标签作为次级模型的训练数据，训练一个次级模型来融合各个基本模型的预测结果。
核心公式
Blending的核心公式与Stacking类似，也可以分为两个阶段：

1. 特征融合：

将多个基本模型在验证集上的预测结果作为新特征构建特征矩阵：

其中，是验证集样本数量，是基本模型的数量，表示第个样本在第个基本模型的预测结果。

2. 次级模型训练：使用新特征矩阵和验证集的真实标签训练一个次级模型：

Blending的核心思想在于通过组合多个不同类型的基本模型的预测结果，利用验证集的信息来融合这些预测结果，从而得到更好的整体模型。Blending相比于Stacking更简单，因为它不需要进行交叉验证来生成次级模型的训练数据，但由于只使用了一部分数据进行模型融合，因此有一定的过拟合风险。
特点和适用场景

简单直接：Blending相对于Stacking来说更简单直接，不需要进行交叉验证生成次级模型的训练数据。
过拟合风险：由于Blending只使用了一部分数据进行模型融合，因此有一定的过拟合风险，需要注意调参和模型选择。
适用场景：Blending适用于需要快速建模的场景，对于数据量较大或者计算资源有限的情况下尤为适用。

一个详细的案例
下面是一个使用Scikit-Learn库实现Blending算法的简单案例，在分类问题上进行演示。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
# 生成模拟数据
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
# 划分训练集和验证集
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
# 定义基本模型
models = [
RandomForestClassifier(n_estimators=100, random_state=42),
SVC(kernel='linear', C=0.1, probability=True, random_state=42)
]
# 生成空特征矩阵
X_blend_train = np.zeros((len(X_val), len(models)))
X_blend_val = np.zeros((
len(X_val), len(models)))
# 生成验证集上的基本模型预测结果
for i, model in enumerate(models):
model.fit(X_train, y_train)
X_blend_train[:, i] = model.predict_proba(X_val)[:, 1]
X_blend_val[:, i] = model.predict_proba(X_val)[:, 1]
# 定义次级模型
meta_model = LogisticRegression()
# 训练次级模型
meta_model.fit(X_blend_train, y_val)
# 在验证集上评估模型
y_pred = meta_model.predict(X_blend_val)
accuracy = accuracy_score(y_val, y_pred)
print("Accuracy:", accuracy)
from sklearn.metrics import roc_curve, auc
# 为每个模型计算 ROC 曲线和 ROC 曲线下面积
fpr = dict()
tpr = dict()
roc_auc = dict()
for i, model in enumerate(models):
y_score = model.predict_proba(X_val)[:, 1]
fpr, tpr, _ = roc_curve(y_val, y_score)
roc_auc = auc(fpr, tpr)
# 绘制 ROC 曲线
plt.figure()
colors = ['blue', 'red']
for i, color in zip(range(len(models)), colors):
plt.plot(fpr, tpr, color=color, lw=2,
label='ROC curve of Model {0} (AUC = {1:0.2f})'
''.format(i, roc_auc))
plt.plot([0, 1], [0, 1], color='gray', lw=1, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve')
plt.legend(loc="lower right")
plt.show()

复制代码

代码中，使用了Scikit-Learn库来实现Blending算法。选择了两种基本模型：随机森林和支持向量机，然后使用验证集来生成基本模型的预测结果。

最后，训练了一个逻辑回归模型作为次级模型，并在验证集上评估了模型的性能。

Voting
Voting（投票）通过结合多个基本模型的预测结果，采用投票或平均的方式来做出最终的预测。其核心原理在于利用多个模型的意见来得出最终的决策，从而减少单个模型的偏差和方差，提高整体模型的性能。
核心原理
1. 多模型集成：Voting通过组合多个不同类型的基本模型来构建更强大的整体模型。这些基本模型可以是同质的，即都是同一种类型的模型，也可以是异质的，即来自于不同类型的模型。

2. 投票策略：Voting采用投票或平均的方式来做出最终的预测。在二分类问题中，可以采用硬投票（直接选择预测结果中票数最多的类别）或软投票（将多个模型的预测概率进行平均，然后选择概率最大的类别）。
核心公式
Voting的核心公式可以表示为：

其中，是最终的预测结果，是多个基本模型的预测结果。

Voting的核心思想在于利用多个模型的意见来做出最终的预测，以减少单个模型的偏差和方差，提高整体模型的性能。通过投票或平均的方式，可以有效地利用多个模型的优势，从而得到更稳健的预测结果。
特点和适用场景
稳健性：Voting能够有效减少单个模型的偏差和方差，提高整体模型的稳健性。
简单直观：Voting方法简单直观，易于实现和理解，适用于各种类型的数据和问题。
适用场景：Voting适用于各种类型的机器学习问题，尤其适用于二分类和多分类问题。

一个详细的案例

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from sklearn.model_selection import learning_curve
# 生成模拟数据
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 定义基本模型
model1 = LogisticRegression(random_state=42)
model2 = KNeighborsClassifier(n_neighbors=5)
model3 = SVC(kernel='linear', probability=True, random_state=42)
# 定义Voting分类器
voting_clf = VotingClassifier(estimators=[('lr', model1), ('knn', model2), ('svm', model3)], voting='hard')
# 定义模型列表和标签
models = [model1, model2, model3, voting_clf]
model_labels = ['Logistic Regression', 'KNN', 'SVM', 'Voting Classifier']
def plot_learning_curve_multiple(models, model_labels, X, y, ylim=None, cv=None, n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):
plt.figure(figsize=(10, 8))
plt.title("Learning Curves")
if ylim is not None:
plt.ylim(*ylim)
plt.xlabel("Training examples")
plt.ylabel("Score")
plt.grid()
for model, label in zip(models, model_labels):
train_sizes, train_scores, test_scores = learning_curve(
model, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1)
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1)
plt.plot(train_sizes, train_scores_mean, 'o-', label=f"Training {label}")
plt.plot(train_sizes, test_scores_mean, 'o-', label=f"Cross-validation {label}")
plt.legend(loc="best")
return plt
# 绘制多个模型的学习曲线
plot_learning_curve_multiple(models, model_labels, X_train, y_train, cv=5, n_jobs=-1)
plt.show()

复制代码

代码中，选择了三种基本模型：逻辑回归、K近邻和支持向量机，然后使用Voting分类器将它们组合起来。在测试集上评估了模型的性能，并绘制了基本模型的投票情况。

最后，代码绘制每个模型的学习曲线，包括训练集和交叉验证集上的得分随着训练样本数量的变化。通过观察学习曲线，大家可以了解模型的偏差和方差，以及它们在不同训练样本大小下的表现。

最后
喜欢本文的朋友可以收藏、点赞、转发起来！

来源：cos大壮深夜努力写Python

十大集成学习模型超全总结

相关帖子