推荐：使用NSDT场景编辑器快速搭建3D应用场景

  本文将揭开集成学习的神秘面纱，并向您介绍其强大的随机森林算法。无论您是希望磨练工具包的数据科学家，还是寻求构建强大机器学习模型的实用见解的开发人员，这篇文章都适合所有人！

  在本文结束时，您将全面了解集成学习以及 Python 中的随机森林的工作原理。因此，无论您是经验丰富的数据科学家，还是只是想扩展您的机器学习能力，请加入我们的冒险之旅，提高您的机器学习专业知识！

1. 什么是集成学习？

  集成学习是一种机器学习方法，其中来自多个弱模型的预测相互组合以获得更强的预测。集成学习背后的概念是通过利用每个模型的预测能力来减少单个模型的偏差和错误。

  为了有一个更好的例子，让我们举一个生活的例子，假设你见过一只动物，你不知道这种动物属于什么物种。因此，你不是问一个专家，而是问十个专家，你会得到他们中大多数人的投票。这称为硬投票。

  硬投票是指我们考虑每个分类器的类预测，然后根据特定类的最大投票数对输入进行分类。另一方面，软投票是指我们考虑每个分类器对每个类的概率预测，然后根据该类的平均概率（对分类器的概率求平均值）以最大概率对输入进行分类。

2. 何时使用集成学习

  集成学习始终用于提高模型性能，包括提高分类准确性和减少回归模型的平均绝对误差。除此之外，集成学习器总是产生更稳定的模型。当模型不相关时，集成学习器可以发挥最佳作用，然后每个模型都可以学习一些独特的东西并致力于提高整体性能。

3. 集成学习策略

  尽管集成学习可以以多种方式应用，但是在将其应用于实践时，有三种策略由于其易于实现和使用而广受欢迎。这三种策略是：

1. 装袋：装袋是引导聚合的缩写，是一种集成学习策略，其中模型使用数据集的随机样本进行训练。
2. 堆垛：堆叠是堆叠泛化的缩写，是一种集成学习策略，其中我们训练一个模型来组合根据我们的数据训练的多个模型。
3. 提升：提升是一种集成学习技术，专注于选择错误分类的数据来训练模型。

  让我们更深入地了解这些策略中的每一个，看看如何使用 Python 在我们的数据集上训练这些模型。

4. 装袋集成学习

  装袋随机抽样数据，并使用学习算法和均值来查找装袋概率;也称为引导聚合;它聚合来自多个模型的结果以获得一个广泛的结果。

这种方法涉及：

1. 将原始数据集拆分为多个子集并进行替换。
2. 为每个子集开发基本模型。
3. 在运行所有预测之前并发运行所有模型以获得最终预测。

  Scikit-learn为我们提供了实现BaggingClassifier和BaggingRegressor的能力。BaggingMetaEstimator 识别原始数据集的随机子集以拟合每个基本模型，然后通过使用投票或平均将单个基本模型预测聚合为聚合预测?—?通过投票或平均?—?聚合到最终预测中。这种方法通过随机化其构建过程来减少方差。

让我们举一个例子，其中我们使用scikit learn的bagging 估计器：

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
bagging = BaggingClassifier(base_estimator=DecisionTreeClassifier(),n_estimators=10, max_samples=0.5, max_features=0.5)

装袋分类器考虑了几个参数：

• base_estimator：装袋方法中使用的基本模型。这里我们使用决策树分类器。
• n_estimators：我们将在装袋方法中使用的估计器数量。
• max_samples：将从训练集中为每个基础估计量抽取的样本数。
• max_features：将用于训练每个基本估计器的特征数。

现在我们将这个分类器拟合到训练集上并对其进行评分。

bagging.fit(X_train, y_train)
bagging.score(X_test,y_test)

我们可以对回归任务做同样的事情，不同之处在于我们将使用回归估计器。

from sklearn.ensemble import BaggingRegressor
bagging = BaggingRegressor(DecisionTreeRegressor())
bagging.fit(X_train, y_train)
model.score(X_test,y_test)

5. 堆叠集成学习

  堆叠是一种组合多个估计器的技术，以最小化它们的偏差并产生准确的预测。然后将来自每个估计器的预测组合并输入到通过交叉验证训练的最终预测元模型中;堆叠可以应用于分类和回归问题。

堆叠集成学习

堆叠按以下步骤进行：

1. 将数据拆分为训练集和验证集
2. 将训练集划分为 K 折叠
3. 在 k-1 折叠上训练基础模型，并对第 k 个折叠进行预测
4. 重复，直到对每个折叠都有预测
5. 将基本模型拟合到整个训练集
6. 使用模型对测试集进行预测
7. 对其他基本型号重复步骤 3-6
8. 使用来自测试集的预测作为新模型（元模型）的特征
9. 使用元模型对测试集进行最终预测

  在下面的示例中，我们首先创建两个基本分类器（RandomForestClassifier 和 GradientBoostingClassifier）和一个元分类器（LogisticRegression），并使用 K 折叠交叉验证将这些分类器对训练数据（鸢尾花数据集）的预测用于元分类器（LogisticRegression）的输入特征。

  在使用 K-fold 交叉验证从测试数据集上的基础分类器进行预测作为我们元分类器的输入特征后，使用两个集合一起对测试集进行预测，并根据堆叠的集成对应项评估它们的准确性。

# Load the dataset
data = load_iris()
X, y = data.data, data.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Define base classifiers
base_classifiers = [
   RandomForestClassifier(n_estimators=100, random_state=42),
   GradientBoostingClassifier(n_estimators=100, random_state=42)
]

# Define a meta-classifier
meta_classifier = LogisticRegression()

# Create an array to hold the predictions from base classifiers
base_classifier_predictions = np.zeros((len(X_train), len(base_classifiers)))

# Perform stacking using K-fold cross-validation
kf = KFold(n_splits=5, shuffle=True, random_state=42)
for train_index, val_index in kf.split(X_train):
   train_fold, val_fold = X_train[train_index], X_train[val_index]
   train_target, val_target = y_train[train_index], y_train[val_index]

   for i, clf in enumerate(base_classifiers):
       cloned_clf = clone(clf)
       cloned_clf.fit(train_fold, train_target)
       base_classifier_predictions[val_index, i] = cloned_clf.predict(val_fold)

# Train the meta-classifier on base classifier predictions
meta_classifier.fit(base_classifier_predictions, y_train)

# Make predictions using the stacked ensemble
stacked_predictions = np.zeros((len(X_test), len(base_classifiers)))
for i, clf in enumerate(base_classifiers):
   stacked_predictions[:, i] = clf.predict(X_test)

# Make final predictions using the meta-classifier
final_predictions = meta_classifier.predict(stacked_predictions)

# Evaluate the stacked ensemble's performance
accuracy = accuracy_score(y_test, final_predictions)
print(f"Stacked Ensemble Accuracy: {accuracy:.2f}")

6. 促进集成学习

  提升是一种机器学习集成技术，通过将弱学习器转变为强学习器来减少偏差和方差。这些弱学习器按顺序应用于数据集;首先，通过创建一个初始模型并将其拟合到训练集。一旦识别出第一个模型中的错误，就会设计另一个模型来纠正它们。

有流行的算法和实现来提升集成学习技术。让我们探索最著名的。

6.1. AdaBoost

AdaBoost是一种有效的集成学习技术，它按顺序使用弱学习器进行训练。每次迭代都会优先考虑不正确的预测，同时减少分配给正确预测实例的权重;这种对具有挑战性的观察的战略强调迫使AdaBoost随着时间的推移变得越来越准确，其最终预测由其弱学习者的多数票或加权总和决定。

AdaBoost是一种适用于回归和分类任务的通用算法，但在这里我们重点介绍它使用Scikit-learn在分类问题中的应用。让我们看看如何在下面的示例中将其用于分类任务：

from sklearn.ensemble import AdaBoostClassifier
model = AdaBoostClassifier(n_estimators=100)
model.fit(X_train, y_train)
model.score(X_test,y_test)

在这个例子中，我们使用了scikit learn的AdaBoostClassifier，并将n_estimators设置为100。默认学习是一个决策树，您可以更改它。除此之外，还可以调整决策树的参数。

2. EXreme梯度增压（XGBoost）

极限梯度增强或更广为人知的XGBoost，是增强集成学习器的最佳实现之一，因为它的并行计算使其非常优化，可以在单台计算机上运行。XGBoost 可以通过机器学习社区开发的 xgboost 包使用。

import xgboost as xgb
params = {"objective":"binary:logistic",'colsample_bytree': 0.3,'learning_rate': 0.1,
               'max_depth': 5, 'alpha': 10}
model = xgb.XGBClassifier(**params)
model.fit(X_train, y_train)
model.fit(X_train, y_train)
model.score(X_test,y_test)

3. 光标

LightGBM是另一种基于树学习的梯度提升算法。然而，它与其他基于树的算法不同，因为它使用叶子上的树生长，这使得它收敛得更快。

在下面的示例中，我们将 LightGBM 应用于二元分类问题：

import lightgbm as lgb
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
params = {'boosting_type': 'gbdt',
             'objective': 'binary',
             'num_leaves': 40,
             'learning_rate': 0.1,
             'feature_fraction': 0.9
             }
gbm = lgb.train(params,
   lgb_train,
   num_boost_round=200,
   valid_sets=[lgb_train, lgb_eval],
   valid_names=['train','valid'],
  )

集成学习和随机森林是强大的机器学习模型，机器学习从业者和数据科学家始终使用它们。在本文中，我们介绍了它们背后的基本直觉，何时使用它们，最后，我们介绍了它们最流行的算法以及如何在 Python 中使用它们。

由3D建模学习工作室 整理翻译，转载请注明出处！