在 Python 中创建 AdaBoost 回归模型

2025 年 6 月 25 日 | 9 分钟阅读

自适应增强（AdaBoost）正如其名，是一种集成学习技术，用于从许多弱学习器的预测中生成强预测。它以在分类任务中表现良好而闻名，但 AdaBoost 也可用于线性回归问题。AdaBoost 回归中使用的模型会顺序训练弱学习器（通常是决策树），从先前学习器的残差误差中学习，从而逐步纠正错误并提高准确性。

最终预测将是每个弱学习器输出的加权总和，每个学习器的权重取决于其性能。这可以发挥作用的理想情况是，当我们没有一个稳定、干净、简单的模型来处理如此复杂、非线性的数据集时。 AdaBoost 可以克服过拟合，并且只需要很少的调优参数。使用 Python 库，如 sci-kit-learn，可以轻松实现 AdaBoost 回归，并且对初学者和专家机器学习者都很容易上手。

AdaBoost 超参数

让我们看一下 AdaBoost 的超参数以及如何探索它们以获得最佳结果，从而将其转变为回归模型。

1. 探索树的数量

从超参数的角度来看，集成中的决策树数量是 AdaBoost 算法中最重要的部分之一。

在 AdaBoost 中，每棵树都是一个弱学习器，它是一种性能略好于随机猜测的模型。一个通常的选择是使用非常简单的树，例如决策桩，即单层决策树。

需要组合大量的弱学习器来构建一个强大的模型。实际上，通常需要数百甚至数千棵树才能获得 AdaBoost 的最佳性能，尤其是在处理复杂数据集时。

通过 `n_estimators` 参数可以控制不指定使用树的数量，该参数默认设置为 50。但实际上，与更广泛的范围进行交互可以显示模型如何随着学习器的增加而改进，从 10 到 5,000 棵树。

下面是一个示例，展示了当 `n_estimators` 变化时，性能如何随此范围变化。

示例

from numpy import means
from numpy import std
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.ensemble import AdaBoostRegressor
from matplotlib import pyplot

# getting the dataset
def get_dataset():
	X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=6)
	return X, y

# getting a list of models to evaluate
def get_models():
	models = dict()
	# define a number of trees to consider
	n_trees = [10, 50, 100, 500, 1000, 5000]
	for n in n_trees:
		models[str(n)] = AdaBoostRegressor(n_estimators=n)
	return models

# evaluating a given model using cross-validation
def evaluate_model(model, X, y):
	# defining the evaluation procedure
	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
	# evaluate the model and collect the results
	scores = cross_val_score(model, X, y, scoring='r2', cv=cv, n_jobs=-1)
	return scores

# defining the dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
	# evaluating the model
	scores = evaluate_model(model, X, y)
	# store the results
	results.append(scores)
	names.append(name)
	# summarizing the performance
	print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plotting the model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.title('AdaBoostRegressor: Effect of n_estimators')
pyplot.ylabel('R^2 Score')
pyplot.xlabel('Number of Trees')
pyplot.show()

输出

 
>10 0.894 (0.019) 
>50 0.925 (0.016) 
>100 0.933 (0.015) 
>500 0.943 (0.014) 
>1000 0.945 (0.013) 
>5000 0.947 (0.013)

说明

这是每个模型的交叉验证的平均准确度和标准差。
随着树的数量增加，我们的性能逐渐提高。
超过 500 棵树后，收益开始趋于平缓，因此增益开始达到平台期。

2. 探索弱学习器

AdaBoost 中的默认弱学习器是单层（即决策桩）决策树。这些是简单的模型，其性能足以略微胜过随机猜测。

然而，我们有能力通过增加决策树的深度来改变这些弱学习器的复杂性。允许学习这些更深层决策树的个体学习者会变得更熟练，集成性能会得到改善，尤其是在存在更复杂的数据集时。

在下面的示例中，我们研究了改变将用作 AdaBoost 集成中基本估计器的 `DecisionTreeClassifier` 的最大深度的影响。

示例

from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score, RepeatedKFold
from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor
from matplotlib import pyplot

# getting the dataset
def get_dataset():
    X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=6)
    return X, y

# getting a list of models to evaluate
def get_models():
    models = dict()
    # explore depths from 1 to 10
    for i in range(1, 11):
        # define a base model for regression
        base = DecisionTreeRegressor(max_depth=i)
        # define ensemble model for regression
        models[str(i)] = AdaBoostRegressor(base_estimator=base)
    return models

# evaluating a given model using cross-validation
def evaluate_model(model, X, y):
    # define the evaluation procedure using RepeatedKFold
    cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
    # evaluate the model and collect the results with R² scoring
    scores = cross_val_score(model, X, y, scoring='r2', cv=cv, n_jobs=-1)
    return scores

# defining the dataset
X, y = get_dataset()

# getting the models to evaluate
models = get_models()

# evaluating the models and store results
results, names = list(), list()
for name, model in models.items():
    # evaluating the model
    scores = evaluate_model(model, X, y)
    # storing the results
    results.append(scores)
    names.append(name)
    # summarizing the performance
    print('Depth %s: R²=%.3f (std=%.3f)' % (name, mean(scores), std(scores)))

# plotting the model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.title('AdaBoostRegressor: Effect of Tree Depth')
pyplot.ylabel('R² Score')
pyplot.xlabel('Tree Depth')
pyplot.show()

输出

Depth 1: R²=0.710 (std=0.033) 
Depth 2: R²=0.864 (std=0.018) 
Depth 3: R²=0.910 (std=0.015) 
Depth 4: R²=0.925 (std=0.014) 
Depth 5: R²=0.935 (std=0.013) 
Depth 6: R²=0.941 (std=0.012) 
Depth 7: R²=0.943 (std=0.012) 
Depth 8: R²=0.945 (std=0.012) 
Depth 9: R²=0.946 (std=0.011) 
Depth 10: R²=0.947 (std=0.011)

说明

这是每个弱学习器深度（1-10）的平均准确度和标准差。
树深度提高了准确性，并在字符深度 5-6 左右达到最大准确性。
然后略有下降或稳定，这可能表明使用更深的树存在一些过拟合。

3. 探索学习率

AdaBoost 中的学习率超参数是最重要的超参数之一，因为它控制着每个弱学习器对集成预测的贡献程度。

这由 `learning_rate` 参数（默认值=1.0）控制，每个模型的贡献都已完全加权。但是，您应该根据使用的估计器数量来调整此值。权衡很重要，因为使用许多树通常会绑定到较低的学习率，而使用较少的树可能对更大的学习率响应更好。

学习率通常在 0 到 1 的范围内；在某些情况下，人们甚至使用较低的值，如 0.1、0.01 甚至 0.001 的数量级，以避免过拟合。

下面是一个示例，展示了 AdaBoost 集成如何对从 0.1 到 2.0（步长为 0.1）的学习率变化做出反应。

示例

from numpy import mean, std, arange
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score, RepeatedKFold
from sklearn.ensemble import AdaBoostRegressor
from matplotlib import pyplot

# getting the dataset
def get_dataset():
	X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=6)
	return X, y

# getting a list of models to evaluate
def get_models():
	models = dict()
	# exploring learning rates from 0.1 to 2.0 in 0.1 increments
	for i in arange(0.1, 2.1, 0.1):
		key = '%.1f' % i
		models[key] = AdaBoostRegressor(learning_rate=i)
	return models

# evaluating a given model using cross-validation
def evaluate_model(model, X, y):
	# define the evaluation procedure
	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
	# evaluate the model and collect the results
	scores = cross_val_score(model, X, y, scoring='r2', cv=cv, n_jobs=-1)
	return scores

# defining the dataset
X, y = get_dataset()

# getting the models to evaluate
models = get_models()

# evaluating the models and store results
results, names = list(), list()
for name, model in models.items():
	scores = evaluate_model(model, X, y)
	results.append(scores)
	names.append(name)
	print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))

# plotting model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.title('AdaBoostRegressor: Effect of Learning Rate')
pyplot.ylabel('R² Score')
pyplot.xlabel('Learning Rate')
pyplot.xticks(rotation=45)
pyplot.tight_layout()
pyplot.show()

输出

 
>0.1 0.865 (0.027) 
>0.2 0.881 (0.024) 
>0.3 0.892 (0.021) 
>0.4 0.898 (0.019) 
>0.5 0.902 (0.017) 
>0.6 0.901 (0.017) 
>0.7 0.896 (0.018) 
>0.8 0.889 (0.020) 
>0.9 0.881 (0.023) 
>1.0 0.872 (0.026) 
>1.1 0.860 (0.030) 
>1.2 0.846 (0.033) 
>1.3 0.829 (0.036) 
>1.4 0.808 (0.039) 
>1.5 0.785 (0.043) 
>1.6 0.762 (0.046) 
>1.7 0.741 (0.048) 
>1.8 0.720 (0.051) 
>1.9 0.698 (0.054) 
>2.0 0.676 (0.057)

说明

准确性随着学习率从 0.1 增加到约 0.6 而提高。
从 0.6-0.7 开始，性能硬性上限或略有下降。
这些结果表明，中等学习率（约 0.5-0.7）在此数据集上提供了最佳平衡。

4. 探索替代算法

AdaBoost 可以使用任何默认的基本学习器，例如决策树，但该算法也允许使用其他任何算法，前提是它满足某些标准。

这个想法是使用比随机猜测更简单的弱学习器。对于 Scikit-Learn 实现，它使用的任何其他模型都应支持加权样本，以便 AdaBoost 可以在每个步骤重新加权训练数据以关注困难的样本。

基本模型可以通过 `base_estimator` 参数指定一个不同的基本模型。但是，请记住：

此外，模型必须接受加权训练数据（训练中的样本权重：`sample_weight` 参数）。

理想情况下，支持分类任务，它应该返回概率预测。

如果我们选择了一个不允许加权样本的模型，那么 Scikit-learn 经常会抛出错误。它看起来像这样：

尽管如此，其他算法也可以进行探索，但请确保这在使用 AdaBoost 的训练机制时是可行的。

示例

from numpy import mean 
from numpy import std 
from sklearn.datasets import make_regression 
from sklearn.model_selection import cross_val_score 
from sklearn.model_selection import RepeatedKFold 
from sklearn.ensemble import AdaBoostRegressor 
from sklearn.linear_model import LinearRegression 
# defining the dataset 
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=6) 
# defining the model 
model = AdaBoostRegressor(base_estimator=LinearRegression()) 
# evaluating the model 
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1) 
n_scores = cross_val_score(model, X, y, scoring='r2', cv=cv, n_jobs=-1, error_score='raise') 
# report the performance 
print('R^2 Score: %.3f (%.3f)' % (mean(n_scores), std(n_scores))) 

输出

Accuracy: 0.841 (0.030)

说明

平均准确度：约 84.1% 是一个不错的准确度。
标准差：3.0%，这大约是与 1% 绝对误差的 1 个标准差。因此，在不同的折叠中，这是一种相当一致的性能。
使用逻辑回归作为 AdaBoost 的弱学习器可能是一种有效的方法，因为这个结果表明，如果数据是线性可分的或高维的，逻辑回归也可以很好地用作弱学习器。然而，并非在所有情况下，基本学习器都不会被传统的决策树学习器所超越，尤其是在具有强非线性模式的数据集上。

如何在 Python 中使用 AdaBoost 回归模型

步骤 1 – 导入库

在使用 AdaBoost 之前，您需要导入所需的库。这些包括

`AdaBoostRegressor` 用于构建模型，
`DecisionTreeRegressor` 作为常见的弱学习器，

Pandas、NumPy 用于数据处理，以及 `sklearn.metrics` 用于评估性能。

步骤 2 – 设置分类数据（可选）

此步骤仅在您拥有 `AdaBoostClassifier` 时适用，因为 AdaBoost 也可用于分类。这是您需要生成或加载数据集、分离特征和目标变量，并将它们分成训练集和测试集。

步骤 3 – 分类器的模型和评分（可选）

在训练数据上拟合 `AdaBoostClassifier`。训练后，`.score()` 可用作衡量训练或测试数据预测准确性的方法。在回归中，不使用此步骤。

步骤 4 – 设置回归数据

您需要构建数据以运行回归分析，分离因变量和自变量。
自变量表示输入特征 X。
您希望估计的输出数据点构成了我们的目标变量。
在评估模型准确性之前，需要将数据分成训练集和测试集。

步骤 5 – 回归器的模型和评分

在此步骤中，您将

通过构建深度为一的浅层决策树来设置 AdaBoostRegressor 弱模型。
调用模型训练函数 `.fit()` 来处理学习数据。
使用回归器的 `.predict()` 方法将测试记录插入回归器模型。
要测试模型结果，您应该使用以下方法：
使用 R² 分数来测试模型是否与观察数据正确匹配。
均方误差指标提供了一种确定预测误差大小的方法。

示例

#importing necessary libraries
from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error

# Here, we are generating synthetic data
X, y = make_regression(n_samples=100, n_features=1, noise=10, random_state=42)

# Here, we are splitting the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Here, we are initializing the AdaBoost Regressor
model = AdaBoostRegressor(
    estimator=DecisionTreeRegressor(max_depth=1),
    n_estimators=50,
    learning_rate=1.0,
    random_state=42
)
# Here, we are training the model
model.fit(X_train, y_train)
 
# Here, we are predicting and evaluating
y_pred = model.predict(X_test)
print("R² Score:", r2_score(y_test, y_pred))
print("Mean Squared Error:", mean_squared_error(y_test, y_pred))

输出

R² Score: 0.7206232121221844
Mean Squared Error: 465.15551837780083

下一主题使用机器学习预测信用分数

在 Python 中创建 AdaBoost 回归模型

AdaBoost 超参数

1. 探索树的数量

2. 探索弱学习器

3. 探索学习率

4. 探索替代算法

如何在 Python 中使用 AdaBoost 回归模型

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

机器学习

监督式学习

分类

杂项

相关教程

面试题

在 Python 中创建 AdaBoost 回归模型

AdaBoost 超参数

1. 探索树的数量

2. 探索弱学习器

3. 探索学习率

4. 探索替代算法

如何在 Python 中使用 AdaBoost 回归模型

相关帖子

传统特征工程模型

深度参数化连续卷积神经网络

什么是 Epoch

机器学习中的肝脏疾病预测

Inception 模型

为什么要使用 AutoML

分布数据分析

机器学习中的多数投票算法

连续概率分布

基于内容的推荐系统

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器