Machine Learning Mastery XGBoost 教程（三）
用于回归的 XGBoost
极限梯度增强(XGBoost)是一个开源库，它提供了梯度增强算法的高效和有效的实现。
在开发和最初发布后不久，XGBoost 就成为了热门方法，并且经常成为在机器学习竞赛中赢得一系列问题解决方案的关键组件。
回归预测建模问题涉及预测一个数值，如一美元金额或高度。 XGBoost 可直接用于回归预测建模。
在本教程中，您将发现如何在 Python 中开发和评估 XGBoost 回归模型。
完成本教程后，您将知道:
- XGBoost 是梯度增强的有效实现，可用于回归预测建模。
- 如何使用重复 k 倍交叉验证的最佳实践技术评估 XGBoost 回归模型？
- 如何拟合最终模型，并利用它对新数据进行预测。
我们开始吧。
回归的 xboost 图片由 chas B 提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 极限梯度助推
- XGBoost 回归 API
- XGBoost 回归示例
极限梯度助推
梯度提升是指一类可用于分类或回归预测建模问题的集成机器学习算法。
集成是由决策树模型构建的。树被一次一个地添加到集合中，并且适合于校正由先前模型产生的预测误差。这是一种称为 boosting 的集成机器学习模型。
使用任意可微损失函数和梯度下降优化算法拟合模型。这给这项技术起了一个名字，“梯度增强”，因为随着模型的拟合，损失梯度被最小化，很像一个神经网络。
有关渐变增强的更多信息，请参见教程:
极限梯度增强，简称 XGBoost，是梯度增强算法的一个高效开源实现。因此，XGBoost 是一个算法、一个开源项目和一个 Python 库。
它最初是由陈天棋开发的，并由陈和在他们 2016 年的论文《XGBoost:一个可扩展的树木提升系统》中进行了描述
它被设计为既有计算效率(例如，执行速度快)，又非常有效，可能比其他开源实现更有效。
使用 XGBoost 的两个主要原因是执行速度和模型表现。
XGBoost 在分类和回归预测建模问题上主导结构化或表格数据集。证据是，它是 Kaggle 竞争数据科学平台上竞争赢家的 go-to 算法。
在 2015 年 Kaggle 博客上发布的 29 个挑战获胜解决方案 3 中，有 17 个解决方案使用了 XGBoost。[……]该系统的成功也在 KDDCup 2015 中得到了见证，在该赛事中，XGBoost 被前 10 名中的每一个获胜团队所使用。
——xboost:一个可扩展的树提升系统，2016。
现在我们已经熟悉了什么是 XGBoost 以及它为什么重要，让我们更仔细地看看如何在我们的回归预测建模项目中使用它。
XGBoost 回归 API
xboost 可以作为一个独立的库安装，并且可以使用 Sklearn API 开发一个 xboost 模型。
第一步是安装尚未安装的 XGBoost 库。这可以在大多数平台上使用 pip python 包管理器来实现；例如:
sudo pip install xgboost
然后，您可以通过运行以下脚本来确认 XGBoost 库安装正确，并且可以使用。
# check xgboost version
import xgboost
print(xgboost.__version__)
运行该脚本将打印您安装的 XGBoost 库的版本。
您的版本应该相同或更高。如果没有，您必须升级 XGBoost 库的版本。
1.1.1
您可能对最新版本的库有问题。这不是你的错。
有时，库的最新版本会带来额外的要求，或者可能不太稳定。
如果您在尝试运行上述脚本时确实有错误，我建议降级到 1.0.1 版(或更低版本)。这可以通过指定要安装到 pip 命令的版本来实现，如下所示:
sudo pip install xgboost==1.0.1
如果您需要开发环境的特定说明，请参阅教程:
尽管我们将通过 Sklearn 包装类使用这个方法:xgbreversor和 XGBClassifier ，但是 XGBoost 库有自己的自定义 API。这将允许我们使用 Sklearn 机器学习库中的全套工具来准备数据和评估模型。
一个 XGBoost 回归模型可以通过创建一个xgbreversor类的实例来定义；例如:
...
# create an xgboost regression model
model = XGBRegressor()
您可以为类构造函数指定超参数值来配置模型。
可能最常见的配置超参数如下:
- n _ estimates:集合中的树的数量，经常增加，直到看不到进一步的改进。
- max_depth :每棵树的最大深度，往往取值在 1 到 10 之间。
- eta :用于对每个模型进行加权的学习率，通常设置为 0.3、0.1、0.01 或更小的值。
- 子样本:每个树中使用的样本(行)数量，设置为 0 到 1 之间的值，通常为 1.0 以使用所有样本。
- colsample_bytree :每个树中使用的特征(列)数量，设置为 0 到 1 之间的值，通常为 1.0 以使用所有特征。
例如:
...
# create an xgboost regression model
model = XGBRegressor(n_estimators=1000, max_depth=7, eta=0.1, subsample=0.7, colsample_bytree=0.8)
好的超参数值可以通过对给定数据集的反复试验或系统实验来找到，例如在一系列值中使用网格搜索。
随机性用于模型的构建。这意味着算法每次在相同的数据上运行时，可能会产生稍微不同的模型。
当使用具有随机学习算法的机器学习算法时，最好通过在多次运行或重复交叉验证中平均它们的表现来评估它们。当拟合最终模型时，可能需要增加树的数量，直到模型的方差在重复评估中减小，或者拟合多个最终模型并对它们的预测进行平均。
让我们看看如何为回归开发一个 XGBoost 集成。
XGBoost 回归示例
在本节中，我们将研究如何为标准回归预测建模数据集开发一个 XGBoost 模型。
首先，让我们介绍一个标准回归数据集。
我们将使用房屋数据集。
外壳数据集是一个标准的机器学习数据集，包括 506 行数据，有 13 个数字输入变量和一个数字目标变量。
使用三次重复的重复分层 10 倍交叉验证的测试工具，一个简单的模型可以获得大约 6.6 的平均绝对误差(MAE) 。一个表现最好的模型可以在大约 1.9 的相同测试线束上实现 MAE。这提供了此数据集的预期表现范围。
该数据集包括预测美国波士顿郊区的房价。
不需要下载数据集；我们将自动下载它作为我们工作示例的一部分。
下面的示例将数据集下载并加载为熊猫数据框，并总结了数据集的形状和前五行数据。
# load and summarize the housing dataset
from pandas import read_csv
from matplotlib import pyplot
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
# summarize shape
print(dataframe.shape)
# summarize first few lines
print(dataframe.head())
运行该示例确认了 506 行数据、13 个输入变量和一个数字目标变量(总共 14 个)。我们还可以看到，所有的输入变量都是数字。
(506, 14)
0 1 2 3 4 5 ... 8 9 10 11 12 13
0 0.00632 18.0 2.31 0 0.538 6.575 ... 1 296.0 15.3 396.90 4.98 24.0
1 0.02731 0.0 7.07 0 0.469 6.421 ... 2 242.0 17.8 396.90 9.14 21.6
2 0.02729 0.0 7.07 0 0.469 7.185 ... 2 242.0 17.8 392.83 4.03 34.7
3 0.03237 0.0 2.18 0 0.458 6.998 ... 3 222.0 18.7 394.63 2.94 33.4
4 0.06905 0.0 2.18 0 0.458 7.147 ... 3 222.0 18.7 396.90 5.33 36.2
[5 rows x 14 columns]
接下来，让我们评估一个关于这个问题的带有默认超参数的回归 XGBoost 模型。
首先，我们可以将加载的数据集分成输入和输出列，用于训练和评估预测模型。
...
# split data into input and output columns
X, y = data[:, :-1], data[:, -1]
接下来，我们可以创建一个具有默认配置的模型实例。
...
# define model
model = XGBRegressor()
我们将使用 3 次重复和 10 次重复的重复 k-fold 交叉验证的最佳实践来评估模型。
这可以通过使用 RepeatedKFold 类配置评估过程，并调用 cross_val_score() 使用该过程评估模型并收集分数来实现。
将使用均方差(MAE)评估模型表现。注意，MAE 在 Sklearn 库中被设为负，这样它可以被最大化。因此，我们可以忽略符号，假设所有错误都是正的。
...
# define model evaluation method
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
一旦评估完毕，我们就可以报告模型的估计表现，用于对这个问题的新数据进行预测。
在这种情况下，因为分数被设为负值，所以我们可以使用绝对()NumPy 函数将分数设为正值。
然后，我们使用分数分布的平均值和标准偏差来报告表现的统计摘要，这是另一种好的做法。
...
# force scores to be positive
scores = absolute(scores)
print('Mean MAE: %.3f (%.3f)' % (scores.mean(), scores.std()) )
将这些联系在一起，下面列出了评估住房回归预测建模问题的 XGBoost 模型的完整示例。
# evaluate an xgboost regression model on the housing dataset
from numpy import absolute
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from xgboost import XGBRegressor
# load the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# split data into input and output columns
X, y = data[:, :-1], data[:, -1]
# define model
model = XGBRegressor()
# define model evaluation method
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# force scores to be positive
scores = absolute(scores)
print('Mean MAE: %.3f (%.3f)' % (scores.mean(), scores.std()) )
运行该示例评估住房数据集上的 XGBoost 回归算法，并报告 10 倍交叉验证的三次重复的平均 MAE。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到模型实现了大约 2.1 的 MAE。
这是一个不错的分数，比基线好，意味着模型有技巧，接近 1.9 的最佳分数。
Mean MAE: 2.109 (0.320)
我们可能会决定使用 XGBoost 回归模型作为我们的最终模型，并对新数据进行预测。
这可以通过在所有可用数据上拟合模型并调用 predict() 函数，传入新的数据行来实现。
例如:
...
# make a prediction
yhat = model.predict(new_data)
我们可以用下面列出的一个完整的例子来演示这一点。
# fit a final xgboost model on the housing dataset and make a prediction
from numpy import asarray
from pandas import read_csv
from xgboost import XGBRegressor
# load the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# split dataset into input and output columns
X, y = data[:, :-1], data[:, -1]
# define model
model = XGBRegressor()
# fit model
model.fit(X, y)
# define new data
row = [0.00632,18.00,2.310,0,0.5380,6.5750,65.20,4.0900,1,296.0,15.30,396.90,4.98]
new_data = asarray([row])
# make a prediction
yhat = model.predict(new_data)
# summarize prediction
print('Predicted: %.3f' % yhat)
运行该示例符合模型，并对新的数据行进行预测。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到模型预测的值约为 24。
Predicted: 24.019
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
- Python 中的极限梯度增强(XGBoost)集成
- 使用 Sklearn、XGBoost、LightGBM 和 CatBoost 进行梯度增强
- 标准机器学习数据集的最佳结果
- 如何使用 XGBoost 进行时间序列预测
报纸
- XGBoost:一个可扩展的树木助推系统，2016。
蜜蜂
- XGBoost 安装指南
- xboost。xgbreversor API。
- sklearn.model_selection。重复应用编程接口。
- sklearn . model _ selection . cross _ val _ score API。
摘要
在本教程中，您发现了如何在 Python 中开发和评估 XGBoost 回归模型。
具体来说，您了解到:
- XGBoost 是梯度增强的有效实现，可用于回归预测建模。
- 如何使用重复 k 倍交叉验证的最佳实践技术评估 XGBoost 回归模型？
- 如何拟合最终模型，并利用它对新数据进行预测。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
如何将 XGBoost 用于时间序列预测
最后更新于 2021 年 3 月 19 日
XGBoost 是针对分类和回归问题的梯度提升的有效实现。
它既快速又高效，在广泛的预测建模任务中表现良好，如果不是最好的，也是数据科学竞赛获奖者的最爱，例如 Kaggle 上的获奖者。
XGBoost 也可以用于时间序列预测，尽管它需要先将时间序列数据集转化为有监督的学习问题。它还需要使用一种专门的技术来评估模型，称为向前验证，因为使用 k-fold 交叉验证来评估模型会导致乐观偏差的结果。
在本教程中，您将发现如何开发一个用于时间序列预测的 XGBoost 模型。
完成本教程后，您将知道:
- XGBoost 是用于分类和回归的梯度提升集成算法的实现。
- 可以使用滑动窗口表示将时间序列数据集转换为监督学习。
- 如何使用用于时间序列预测的 XGBoost 模型进行拟合、评估和预测。
用我的新书 XGBoost With Python 启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
- 更新 2020 年 8 月:修复了 MAE 计算中的 bug，更新了模型配置，做出了更好的预测(感谢考斯塔夫！)
如何使用 XGBoost 进行时间序列预测 图片由gothoptam提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- XGBoost 一起
- 时间序列数据准备
- 用于时间序列预测的 XGBoost
XGBoost 一起
XGBoost 是极限梯度提升的简称，是随机梯度提升机器学习算法的高效实现。
随机梯度增强算法，也称为梯度增强机器或树增强，是一种强大的机器学习技术，在一系列具有挑战性的机器学习问题上表现良好，甚至最好。
树提升已经被证明在许多标准分类基准上给出了最先进的结果。
——xboost:一个可扩展的树提升系统，2016。
这是一个决策树算法的集合，其中新的树修复了那些已经是模型一部分的树的错误。树被添加，直到模型没有进一步的改进。
XGBoost 提供了随机梯度增强算法的高效实现，并提供了对一组模型超参数的访问，这些参数旨在提供对模型训练过程的控制。
XGBoost 成功背后最重要的因素是它在所有场景中的可扩展性。该系统在单台机器上的运行速度比现有的流行解决方案快十倍以上，并且在分布式或内存有限的环境中可扩展到数十亿个示例。
——xboost:一个可扩展的树提升系统，2016。
XGBoost 是为表格数据集的分类和回归而设计的，尽管它可以用于时间序列预测。
有关渐变增强和 XGBoost 实现的更多信息，请参见教程:
首先，必须安装 XGBoost 库。
您可以使用 pip 安装它，如下所示:
sudo pip install xgboost
安装完成后，您可以通过运行以下代码来确认安装成功，并且您使用的是现代版本:
# xgboost
import xgboost
print("xgboost", xgboost.__version__)
运行代码时，您应该会看到以下版本号或更高的版本号。
xgboost 1.0.1
虽然 XGBoost 库有自己的 Python API，但是我们可以通过xgbreversor包装类将 XGBoost 模型与 Sklearn API 一起使用。
模型的一个实例可以像任何其他用于模型评估的 Sklearn 类一样被实例化和使用。例如:
...
# define model
model = XGBRegressor()
现在我们已经熟悉了 XGBoost，让我们看看如何为监督学习准备一个时间序列数据集。
时间序列数据准备
时间序列数据可以被称为监督学习。
给定一个时间序列数据集的数字序列，我们可以重构数据，使其看起来像一个有监督的学习问题。我们可以通过使用以前的时间步长作为输入变量，并使用下一个时间步长作为输出变量来实现这一点。
让我们用一个例子来具体说明。假设我们有一个时间序列如下:
time, measure
1, 100
2, 110
3, 108
4, 115
5, 120
我们可以通过使用前一时间步的值来预测下一时间步的值，从而将这个时间序列数据集重构为一个有监督的学习问题。
以这种方式重新组织时间序列数据集，数据将如下所示:
X, y
?, 100
100, 110
110, 108
108, 115
115, 120
120, ?
请注意，时间列被删除，一些数据行不可用于训练模型，例如第一行和最后一行。
这种表示称为滑动窗口，因为输入和预期输出的窗口随着时间向前移动，为监督学习模型创建新的“样本”。
有关准备时间序列预测数据的滑动窗口方法的更多信息，请参见教程:
我们可以使用 Pandas 中的 shift()函数在给定输入和输出序列的期望长度的情况下，自动创建时间序列问题的新框架。
这将是一个有用的工具，因为它将允许我们用机器学习算法探索时间序列问题的不同框架，看看哪一个可能导致更好的模型。
下面的函数将把一个时间序列作为一个具有一列或多列的 NumPy 数组时间序列，并将其转换为具有指定数量的输入和输出的监督学习问题。
# transform a time series dataset into a supervised learning dataset
def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
n_vars = 1 if type(data) is list else data.shape[1]
df = DataFrame(data)
cols = list()
# input sequence (t-n, ... t-1)
for i in range(n_in, 0, -1):
cols.append(df.shift(i))
# forecast sequence (t, t+1, ... t+n)
for i in range(0, n_out):
cols.append(df.shift(-i))
# put it all together
agg = concat(cols, axis=1)
# drop rows with NaN values
if dropnan:
agg.dropna(inplace=True)
return agg.values
我们可以使用这个函数为 XGBoost 准备一个时间序列数据集。
有关该函数逐步开发的更多信息，请参见教程:
一旦准备好数据集，我们必须小心如何使用它来拟合和评估模型。
例如，用未来的数据拟合模型并让它预测过去是无效的。模型必须基于过去进行训练，并预测未来。
这意味着在评估期间随机化数据集的方法，如 k 倍交叉验证，不能使用。相反，我们必须使用一种叫做向前验证的技术。
在向前行走验证中，首先通过选择切割点将数据集分割成训练集和测试集，例如，除了最后 12 天之外的所有数据都用于训练，最后 12 天用于测试。
如果我们有兴趣进行一步预测，例如一个月，那么我们可以通过在训练数据集上训练和预测测试数据集中的第一步来评估模型。然后，我们可以将测试集中的真实观察值添加到训练数据集中，重新调整模型，然后让模型预测测试数据集中的第二步。
对整个测试数据集重复这一过程将给出对整个测试数据集的一步预测，由此可以计算误差度量来评估模型的技能。
有关向前验证的更多信息，请参见教程:
下面的函数执行向前行走验证。
它将时间序列数据集的整个监督学习版本和用作测试集的行数作为参数。
然后它遍历测试集，调用*xboost _ forecast()*函数进行一步预测。计算误差度量，并返回详细信息进行分析。
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# split test row into input and output columns
testX, testy = test[i, :-1], test[i, -1]
# fit model on history and make a prediction
yhat = xgboost_forecast(history, testX)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# summarize progress
print('>expected=%.1f, predicted=%.1f' % (testy, yhat))
# estimate prediction error
error = mean_absolute_error(test[:, -1], predictions)
return error, test[:, 1], predictions
调用 train_test_split() 函数将数据集拆分为训练集和测试集。
我们可以在下面定义这个函数。
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test, :], data[-n_test:, :]
我们可以使用xgbreversor类进行一步预测。
下面的*xboost _ forecast()*函数实现了这一点，以训练数据集和测试输入行为输入，拟合一个模型，进行一步预测。
# fit an xgboost model and make a one step prediction
def xgboost_forecast(train, testX):
# transform list into array
train = asarray(train)
# split into input and output columns
trainX, trainy = train[:, :-1], train[:, -1]
# fit model
model = XGBRegressor(objective='reg:squarederror', n_estimators=1000)
model.fit(trainX, trainy)
# make a one-step prediction
yhat = model.predict([testX])
return yhat[0]
现在我们知道了如何准备时间序列数据来预测和评估 xboost 模型，接下来我们可以看看如何在真实数据集上使用 xboost。
用于时间序列预测的 XGBoost
在本节中，我们将探讨如何使用 XGBoost 进行时间序列预测。
我们将使用标准的单变量时间序列数据集，目的是使用该模型进行一步预测。
您可以将本节中的代码用作自己项目的起点，并轻松地将其用于多元输入、多元预测和多步预测。
我们将使用每日女性出生数据，即三年间的每月出生数据。
您可以从这里下载数据集，并将其放在当前工作目录中，文件名为“每日女性出生总数. csv ”。
数据集的前几行如下所示:
"Date","Births"
"1959-01-01",35
"1959-01-02",32
"1959-01-03",30
"1959-01-04",31
"1959-01-05",44
...
首先，让我们加载并绘制数据集。
下面列出了完整的示例。
# load and plot the time series dataset
from pandas import read_csv
from matplotlib import pyplot
# load dataset
series = read_csv('daily-total-female-births.csv', header=0, index_col=0)
values = series.values
# plot dataset
pyplot.plot(values)
pyplot.show()
运行该示例会创建数据集的线图。
我们可以看到没有明显的趋势或季节性。
月出生时间序列数据集的线图
当预测最后 12 天时，持久性模型可以实现大约 6.7 次出生的 MAE。这提供了一个表现基线，在这个基线之上，模型可以被认为是熟练的。
接下来，当对过去 12 天的数据进行一步预测时，我们可以在数据集上评估 XGBoost 模型。
我们将只使用前面的 6 个时间步长作为模型和默认模型超参数的输入，除了我们将损失更改为“ reg:squarederror ”(以避免警告消息)并在集合中使用 1000 棵树(以避免欠学习)。
下面列出了完整的示例。
# forecast monthly births with xgboost
from numpy import asarray
from pandas import read_csv
from pandas import DataFrame
from pandas import concat
from sklearn.metrics import mean_absolute_error
from xgboost import XGBRegressor
from matplotlib import pyplot
# transform a time series dataset into a supervised learning dataset
def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
n_vars = 1 if type(data) is list else data.shape[1]
df = DataFrame(data)
cols = list()
# input sequence (t-n, ... t-1)
for i in range(n_in, 0, -1):
cols.append(df.shift(i))
# forecast sequence (t, t+1, ... t+n)
for i in range(0, n_out):
cols.append(df.shift(-i))
# put it all together
agg = concat(cols, axis=1)
# drop rows with NaN values
if dropnan:
agg.dropna(inplace=True)
return agg.values
# split a univariate dataset into train/test sets
def train_test_split(data, n_test):
return data[:-n_test, :], data[-n_test:, :]
# fit an xgboost model and make a one step prediction
def xgboost_forecast(train, testX):
# transform list into array
train = asarray(train)
# split into input and output columns
trainX, trainy = train[:, :-1], train[:, -1]
# fit model
model = XGBRegressor(objective='reg:squarederror', n_estimators=1000)
model.fit(trainX, trainy)
# make a one-step prediction
yhat = model.predict(asarray([testX]))
return yhat[0]
# walk-forward validation for univariate data
def walk_forward_validation(data, n_test):
predictions = list()
# split dataset
train, test = train_test_split(data, n_test)
# seed history with training dataset
history = [x for x in train]
# step over each time-step in the test set
for i in range(len(test)):
# split test row into input and output columns
testX, testy = test[i, :-1], test[i, -1]
# fit model on history and make a prediction
yhat = xgboost_forecast(history, testX)
# store forecast in list of predictions
predictions.append(yhat)
# add actual observation to history for the next loop
history.append(test[i])
# summarize progress
print('>expected=%.1f, predicted=%.1f' % (testy, yhat))
# estimate prediction error
error = mean_absolute_error(test[:, -1], predictions)
return error, test[:, -1], predictions
# load the dataset
series = read_csv('daily-total-female-births.csv', header=0, index_col=0)
values = series.values
# transform the time series data into supervised learning
data = series_to_supervised(values, n_in=6)
# evaluate
mae, y, yhat = walk_forward_validation(data, 12)
print('MAE: %.3f' % mae)
# plot expected vs preducted
pyplot.plot(y, label='Expected')
pyplot.plot(yhat, label='Predicted')
pyplot.legend()
pyplot.show()
运行该示例会报告测试集中每个步骤的预期值和预测值，然后是所有预测值的 MAE。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
我们可以看到，该模型比持久性模型表现得更好，实现了大约 5.9 次出生的 MAE，而不是 6.7 次出生。
你能做得更好吗？ 你可以测试不同的 XGBoost 超参数和时间步数作为输入，看看是否能达到更好的表现。在下面的评论中分享你的结果。
>expected=42.0, predicted=44.5
>expected=53.0, predicted=42.5
>expected=39.0, predicted=40.3
>expected=40.0, predicted=32.5
>expected=38.0, predicted=41.1
>expected=44.0, predicted=45.3
>expected=34.0, predicted=40.2
>expected=37.0, predicted=35.0
>expected=52.0, predicted=32.5
>expected=48.0, predicted=41.4
>expected=55.0, predicted=46.6
>expected=50.0, predicted=47.2
MAE: 5.957
将数据集最后 12 天的一系列预期值和预测值进行比较，创建一个折线图。
这给出了模型在测试集上表现如何的几何解释。
使用 XGBoost 预测的预期与出生的线图
一旦选择了最终的 XGBoost 模型配置，就可以最终确定一个模型，并用于对新数据进行预测。
这被称为样本外预测，例如预测超出训练数据集。这与在模型评估过程中进行预测是一样的:因为我们总是希望使用我们期望在模型用于对新数据进行预测时使用的相同过程来评估模型。
下面的例子演示了在所有可用数据上拟合最终的 XGBoost 模型，并在数据集结束后进行一步预测。
# finalize model and make a prediction for monthly births with xgboost
from numpy import asarray
from pandas import read_csv
from pandas import DataFrame
from pandas import concat
from xgboost import XGBRegressor
# transform a time series dataset into a supervised learning dataset
def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
n_vars = 1 if type(data) is list else data.shape[1]
df = DataFrame(data)
cols = list()
# input sequence (t-n, ... t-1)
for i in range(n_in, 0, -1):
cols.append(df.shift(i))
# forecast sequence (t, t+1, ... t+n)
for i in range(0, n_out):
cols.append(df.shift(-i))
# put it all together
agg = concat(cols, axis=1)
# drop rows with NaN values
if dropnan:
agg.dropna(inplace=True)
return agg.values
# load the dataset
series = read_csv('daily-total-female-births.csv', header=0, index_col=0)
values = series.values
# transform the time series data into supervised learning
train = series_to_supervised(values, n_in=6)
# split into input and output columns
trainX, trainy = train[:, :-1], train[:, -1]
# fit model
model = XGBRegressor(objective='reg:squarederror', n_estimators=1000)
model.fit(trainX, trainy)
# construct an input for a new preduction
row = values[-6:].flatten()
# make a one-step prediction
yhat = model.predict(asarray([row]))
print('Input: %s, Predicted: %.3f' % (row, yhat[0]))
运行该示例符合所有可用数据的 XGBoost 模型。
使用最后 6 天的已知数据准备新的输入行，并预测数据集结束后的下一个月。
Input: [34 37 52 48 55 50], Predicted: 42.708
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
相关教程
摘要
在本教程中，您发现了如何开发用于时间序列预测的 XGBoost 模型。
具体来说，您了解到:
- XGBoost 是用于分类和回归的梯度提升集成算法的实现。
- 可以使用滑动窗口表示将时间序列数据集转换为监督学习。
- 如何使用用于时间序列预测的 XGBoost 模型进行拟合、评估和预测。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
XGBoost 损失函数的温和介绍
最后更新于 2021 年 4 月 14 日
XGBoost 是梯度增强集成算法的一个强大且流行的实现。
配置 XGBoost 模型的一个重要方面是选择在模型训练期间最小化的损失函数。
损失函数必须与预测建模问题类型相匹配，同样，我们必须基于具有深度学习神经网络的问题类型选择合适的损失函数。
在本教程中，您将发现如何为 XGBoost 集成模型配置损失函数。
完成本教程后，您将知道:
- 指定训练 XGBoost 集成时使用的损失函数是一个关键步骤，很像神经网络。
- 如何为二类和多类分类任务配置 XGBoost 损失函数？
- 如何为回归预测建模任务配置 XGBoost 损失函数？
我们开始吧。
XGBoost 损失函数的温和介绍 图片由凯文·雷塞提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 扩展和损失函数
- 分类损失
- 回归的最大损失
扩展和损失函数
极限梯度增强，简称 XGBoost，是梯度增强算法的一个高效开源实现。因此，XGBoost 是一个算法、一个开源项目和一个 Python 库。
它最初是由陈天琪开发的，并由陈和卡洛斯·盖斯特林在他们 2016 年的论文《XGBoost:一个可扩展的树提升系统》中描述
它被设计为既有计算效率(例如，执行速度快)，又非常有效，可能比其他开源实现更有效。
XGBoost 支持一系列不同的预测建模问题，最显著的是分类和回归。
XGBoost 是通过最小化目标函数对数据集的损失来训练的。因此，损失函数的选择是一个关键的超参数，直接与要解决的问题类型相关联，很像深度学习神经网络。
该实现允许通过“目标”超参数指定目标函数，并且使用适用于大多数情况的合理默认值。
然而，对于在训练 XGBoost 模型时使用什么损失函数，初学者仍有一些困惑。
在本教程中，我们将详细了解如何为 XGBoost 配置损失函数。
在我们开始之前，让我们开始设置。
xboost 可以作为一个独立的库安装，并且可以使用 Sklearn API 开发一个 xboost 模型。
第一步是安装尚未安装的 XGBoost 库。这可以在大多数平台上使用 pip python 包管理器来实现；例如:
sudo pip install xgboost
然后，您可以通过运行以下脚本来确认 XGBoost 库安装正确，并且可以使用。
# check xgboost version
import xgboost
print(xgboost.__version__)
运行该脚本将打印您安装的 XGBoost 库的版本。
您的版本应该相同或更高。如果没有，您必须升级 XGBoost 库的版本。
1.1.1
您可能对最新版本的库有问题。这不是你的错。
有时，库的最新版本会带来额外的要求，或者可能不太稳定。
如果您在尝试运行上述脚本时确实有错误，我建议降级到 1.0.1 版(或更低版本)。这可以通过指定要安装到 pip 命令的版本来实现，如下所示:
sudo pip install xgboost==1.0.1
如果您看到一条警告消息，您可以暂时忽略它。例如，下面是一个警告消息示例，您可能会看到它，但可以忽略它:
FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.
如果您需要开发环境的特定说明，请参阅教程:
尽管我们将通过 Sklearn 包装类使用这个方法:xgbreversor和 XGBClassifier ，但是 XGBoost 库有自己的自定义 API。这将允许我们使用 Sklearn 机器学习库中的全套工具来准备数据和评估模型。
这两个模型以相同的方式运行，并采用相同的参数来影响决策树的创建和添加。
有关如何在 Sklearn 中使用 XGBoost API 的更多信息，请参见教程:
接下来，让我们仔细看看如何在分类问题上为 XGBoost 配置损失函数。
分类损失
分类任务包括给定一个输入样本，预测每个可能类别的标签或概率。
具有互斥标签的分类任务主要有两种类型:具有两个类别标签的二进制分类和具有两个以上类别标签的多类别分类。
- 二进制分类:有两个类标签的分类任务。
- 多类分类:两个以上类标签的分类任务。
有关不同类型分类任务的更多信息，请参见教程:
XGBoost 为这些问题类型提供了损失函数。
在机器学习中，典型的做法是训练一个模型来预测概率任务的类成员概率，如果任务需要清晰的类标签来对预测的概率进行后处理(例如，使用 argmax )。
这种方法在训练深度学习神经网络进行分类时使用，在使用 XGBoost 进行分类时也推荐使用。
用于预测二元分类问题概率的损失函数为“二元:logistic ”，用于预测多类问题类概率的损失函数为“多元:softprob ”。
- “二元:logistic”:XGBoost 损失函数为二元分类。
- " multi:softprob ": XGBoost 损失函数进行多类分类。
这些字符串值可以在配置 XGBClassifier 模型时通过“目标””超参数来指定。
例如，对于二进制分类:
...
# define the model for binary classification
model = XGBClassifier(objective='binary:logistic')
对于多类分类:
...
# define the model for multi-class classification
model = XGBClassifier(objective='multi:softprob')
重要的是，如果您没有指定“*目标”*超参数， XGBClassifier 将根据训练期间提供的数据自动选择这些损失函数之一。
我们可以用一个具体的例子来说明这一点。
下面的例子创建了一个合成的二进制分类数据集，用默认的超参数在数据集上拟合一个 XGBClassifier ，然后打印模型目标配置。
# example of automatically choosing the loss function for binary classification
from sklearn.datasets import make_classification
from xgboost import XGBClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# define the model
model = XGBClassifier()
# fit the model
model.fit(X, y)
# summarize the model loss function
print(model.objective)
运行该示例使模型适合数据集，并打印损失函数配置。
我们可以看到模型自动选择一个损失函数进行二元分类。
binary:logistic
或者，我们可以指定目标并拟合模型，确认使用了损失函数。
# example of manually specifying the loss function for binary classification
from sklearn.datasets import make_classification
from xgboost import XGBClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# define the model
model = XGBClassifier(objective='binary:logistic')
# fit the model
model.fit(X, y)
# summarize the model loss function
print(model.objective)
运行该示例使模型适合数据集，并打印损失函数配置。
我们可以看到用于指定二元分类损失函数的模型。
binary:logistic
让我们在具有两个以上类的数据集上重复这个例子。在这种情况下，三个类。
下面列出了完整的示例。
# example of automatically choosing the loss function for multi-class classification
from sklearn.datasets import make_classification
from xgboost import XGBClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1, n_classes=3)
# define the model
model = XGBClassifier()
# fit the model
model.fit(X, y)
# summarize the model loss function
print(model.objective)
运行该示例使模型适合数据集，并打印损失函数配置。
我们可以看到模型自动选择了一个损失函数进行多类分类。
multi:softprob
或者，我们可以手动指定损失函数，并确认它用于训练模型。
# example of manually specifying the loss function for multi-class classification
from sklearn.datasets import make_classification
from xgboost import XGBClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1, n_classes=3)
# define the model
model = XGBClassifier(objective="multi:softprob")
# fit the model
model.fit(X, y)
# summarize the model loss function
print(model.objective)
运行该示例使模型适合数据集，并打印损失函数配置。
我们可以看到用于为多类分类指定损失函数的模型。
multi:softprob
最后，还有其他损失函数可以用来分类，包括:“二进制:logitraw ”和“二进制:铰链”用于二进制分类，以及“多:softmax ”用于多类分类。
您可以在这里看到完整的列表:
接下来，让我们看看用于回归的 XGBoost 损失函数。
回归的最大损失
回归指的是预测建模问题，其中给定输入样本，预测数值。
虽然预测概率听起来像回归问题(即概率是数值)，但它通常不被认为是回归型预测建模问题。
预测数值时使用的 XGBoost 目标函数是“ reg:平方误差”损失函数。
- “reg:平方误差”:回归预测建模问题的损失函数。
在配置您的xgbreversor模型时，可以通过“目标”超参数指定该字符串值。
例如:
...
# define the model for regression
model = XGBRegressor(objective='reg:squarederror')
重要的是，如果您没有指定“*目标”*超参数，xgbrejector会自动为您选择该目标函数。
我们可以用一个具体的例子来说明这一点。
下面的示例创建了一个合成回归数据集，在数据集上拟合一个xgbreturnor，然后打印模型目标配置。
# example of automatically choosing the loss function for regression
from sklearn.datasets import make_regression
from xgboost import XGBRegressor
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7)
# define the model
model = XGBRegressor()
# fit the model
model.fit(X, y)
# summarize the model loss function
print(model.objective)
运行该示例使模型适合数据集，并打印损失函数配置。
我们可以看到模型自动选择一个损失函数进行回归。
reg:squarederror
或者，我们可以指定目标并拟合模型，确认使用了损失函数。
# example of manually specifying the loss function for regression
from sklearn.datasets import make_regression
from xgboost import XGBRegressor
# define dataset
X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=7)
# define the model
model = XGBRegressor(objective='reg:squarederror')
# fit the model
model.fit(X, y)
# summarize the model loss function
print(model.objective)
运行该示例使模型适合数据集，并打印损失函数配置。
我们可以看到模型使用了指定的损失函数进行回归。
reg:squarederror
最后，还有其他可以用于回归的损失函数，包括:“ reg:squaredlogerror ”、“ reg:logistic ”、“reg:pseuhubererror”、“ reg:gamma ”和“ reg:tweedie ”。
您可以在这里看到完整的列表:
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
蜜蜂
摘要
在本教程中，您发现了如何为 XGBoost 集成模型配置损失函数。
具体来说，您了解到:
- 像神经网络一样，指定训练 XGBoost 集成时使用的损失函数是一个关键步骤。
- 如何为二类和多类分类任务配置 XGBoost 损失函数？
- 如何为回归预测建模任务配置 XGBoost 损失函数？
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
开始使用 Python 和 XGBoost 的 7 步迷你课程
XGBoost 使用 Python 迷你课程。
XGBoost 是梯度提升的一种实现，用于赢得机器学习竞赛。
它很强大，但很难开始。
在这篇文章中，您将发现使用 Python 的 XGBoost 7 部分速成课程。
这个迷你课程专为已经熟悉 scikit-learn 和 SciPy 生态系统的 Python 机器学习从业者而设计。
让我们开始吧。
- 2017 年 1 月更新：已更新，以反映 scikit-learn API 版本 0.18.1 中的更改。
- 更新 March / 2018 ：添加了备用链接以下载数据集，因为原始图像已被删除。
XGBoost 与 Python 迷你课程 照片由 Teresa Boardman ，保留一些权利。
（提示：_ 你可能想打印或书签这个页面，以便以后再参考 _。）
这个迷你课程是谁？
在我们开始之前，让我们确保您在正确的位置。以下列表提供了有关本课程设计对象的一般指导原则。
如果你没有完全匹配这些点，请不要惊慌，你可能只需要在一个或另一个区域刷新以跟上。
- 开发人员知道如何编写一些代码。这意味着使用 Python 完成任务并了解如何在工作站上设置 SciPy 生态系统（先决条件）对您来说并不是什么大问题。它并不意味着你是一个向导编码器，但它确实意味着你不怕安装软件包和编写脚本。
- 知道一点机器学习的开发人员。这意味着您了解机器学习的基础知识，如交叉验证，一些算法和偏方差权衡。这并不意味着你是一个机器学习博士，只是你知道地标或知道在哪里查找它们。
这个迷你课程不是 XGBoost 的教科书。没有方程式。
它将带您从一个熟悉 Python 的小机器学习的开发人员到能够获得结果并将 XGBoost 的强大功能带到您自己的项目中的开发人员。
迷你课程概述（期待什么）
这个迷你课程分为 7 个部分。
每节课的目的是让普通开发人员大约 30 分钟。你可能会更快完成一些，而其他人可能会选择更深入，花更多时间。
您可以根据需要快速或慢速完成每个部分。舒适的时间表可能是在一周的时间内每天完成一节课。强烈推荐。
您将在接下来的 7 节课中讨论的主题如下：
- 第 01 课：Gradient Boosting 简介。
- 第 02 课：XGBoost 简介。
- 第 03 课：开发你的第一个 XGBoost 模型。
- 第 04 课：监控表现和提前停止。
- 第 05 课：功能与 XGBoost 的重要性。
- 第 06 课：如何配置梯度提升。
- 第 07 课：XGBoost Hyperparameter Tuning。
这将是一件很有趣的事情。
你将不得不做一些工作，一点点阅读，一点研究和一点点编程。您想了解 XGBoost 吗？
（提示：_ 这些课程的帮助可以在这个博客上找到，使用搜索功能 _。）
如有任何问题，请在下面的评论中发布。
在评论中分享您的结果。
挂在那里，不要放弃！
第 01 课：梯度提升简介
梯度提升是构建预测模型的最强大技术之一。
提升的想法来自于弱学习器是否可以被修改为变得更好的想法。应用程序取得巨大成功的第一个实现提升的是 Adaptive Boosting 或简称 AdaBoost。 AdaBoost 中的弱学习器是决策树，只有一个分裂，称为决策树桩的短缺。
AdaBoost 和相关算法在统计框架中重铸，并被称为梯度提升机器。统计框架将推进作为一个数值优化问题，其目标是通过使用类似过程的梯度下降添加弱学习器来最小化模型的损失，因此得名。
Gradient Boosting 算法涉及三个要素：
- 要优化的损失函数，例如用于分类的交叉熵或用于回归问题的均方误差。
- 做出预测的弱学习器，例如贪婪构建的决策树。
- **一个加法模型，**用于添加弱学习器以最小化损失函数。
为了纠正所有先前树木的残留误差，将新的弱学习器添加到模型中。结果是一个强大的预测性建模算法，可能比随机森林更强大。
在下一课中，我们将仔细研究梯度提升的 XGBoost 实现。
第 02 课：XGBoost 简介
XGBoost 是为速度和表现而设计的梯度提升决策树的实现。
XGBoost 代表 e X treme G radient Boosti ng。
它由陈天琪开发，激光专注于计算速度和模型表现，因此几乎没有多余的装饰。
除了支持该技术的所有关键变体之外，真正感兴趣的是通过精心设计实现所提供的速度，包括：
- 在训练期间使用所有 CPU 内核构建树的并行化。
- 分布式计算用于使用一组机器训练超大型模型。
- 非核心计算适用于不适合内存的超大型数据集。
- 缓存优化的数据结构和算法，以充分利用硬件。
传统上，梯度提升实现很慢，因为必须构造每个树并将其添加到模型中的顺序性质。
XGBoost 开发中的表现已经成为最好的预测性建模算法之一，现在可以利用硬件平台的全部功能，或者您可能在云中租用的超大型计算机。
因此，XGBoost 一直是机器学习竞赛的基石，是赢家赢得和推荐的技术。例如，以下是一些最近的 Kaggle 比赛获奖者所说的话：
作为越来越多的 Kaggle 比赛的赢家，XGBoost 再次向我们展示了一个值得在您的工具箱中使用的全面算法。
如有疑问，请使用 xgboost。
在下一课中，我们将使用 Python 开发我们的第一个 XGBoost 模型。
第 03 课：开发您的第一个 XGBoost 模型
假设您有一个可用的 SciPy 环境，可以使用 pip 轻松安装 XGBoost。
例如：
sudo pip install xgboost
您可以在 XGBoost 安装说明中了解有关在您的平台上安装和构建 XGBoost 的更多信息。
XGBoost 模型可以使用包装类直接在 scikit-learn 框架中使用， XGBClassifier 用于分类， XGBRegressor 用于回归问题。
这是在 Python 中使用 XGBoost 的推荐方法。
从 UCI 机器学习库下载 Pima Indians 糖尿病数据集[更新：从这里下载）。它是二进制分类的一个很好的测试数据集，因为所有输入变量都是数字的，这意味着问题可以直接建模而无需数据准备。
我们可以通过构造它并调用 **model.fit（）**函数来训练 XGBoost 模型进行分类：
model = XGBClassifier()
model.fit(X_train, y_train)
然后可以通过在新数据上调用 **model.predict（）**函数来使用该模型做出预测。
y_pred = model.predict(X_test)
我们可以将这些结合起来如下：
# First XGBoost model for Pima Indians dataset
from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# split data into train and test sets
seed = 7
test_size = 0.33
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
# fit model on training data
model = XGBClassifier()
model.fit(X_train, y_train)
# make predictions for test data
y_pred = model.predict(X_test)
predictions = [round(value) for value in y_pred]
# evaluate predictions
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: %.2f%%" % (accuracy * 100.0))
在下一课中，我们将研究如何使用早期停止来限制过拟合。
第 04 课：监控表现和提前停止
XGBoost 模型可以在训练期间评估和报告模型的测试集上的表现。
它通过在训练模型和指定详细输出（ verbose = True ）时调用 **model.fit（）**时指定测试数据集和评估指标来支持此功能。
例如，我们可以在训练 XGBoost 模型时报告独立测试集（ eval_set ）上的二进制分类错误率（错误），如下所示：
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, eval_metric="error", eval_set=eval_set, verbose=True)
使用此配置运行模型将在添加每个树后报告模型的表现。例如：
...
[89] validation_0-error:0.204724
[90] validation_0-error:0.208661
一旦没有对模型进行进一步改进，我们就可以使用此评估来停止训练。
我们可以通过在调用 **model.fit（）**时将 early_stopping_rounds 参数设置为在停止训练之前验证数据集未见改进的迭代次数来完成此操作。
下面提供了使用 Pima Indians Onset of Diabetes 数据集的完整示例。
# exmaple of early stopping
from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# split data into train and test sets
seed = 7
test_size = 0.33
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
# fit model on training data
model = XGBClassifier()
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, early_stopping_rounds=10, eval_metric="logloss", eval_set=eval_set, verbose=True)
# make predictions for test data
y_pred = model.predict(X_test)
predictions = [round(value) for value in y_pred]
# evaluate predictions
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: %.2f%%" % (accuracy * 100.0))
在下一课中，我们将研究如何使用 XGBoost 计算特征的重要性
第 05 课：使用 XGBoost 进行功能重要性
使用诸如梯度提升之类的决策树方法的集合的好处是它们可以从训练的预测模型自动提供特征重要性的估计。
经过训练的 XGBoost 模型可自动计算预测性建模问题的特征重要性。
这些重要性分数可在训练模型的 feature_importances_ 成员变量中找到。例如，它们可以直接打印如下：
print(model.feature_importances_)
XGBoost 库提供了一个内置函数来绘制按其重要性排序的特征。
该函数称为 plot_importance（），可以按如下方式使用：
plot_importance(model)
pyplot.show()
这些重要性分数可以帮助您确定要保留或丢弃的输入变量。它们也可以用作自动特征选择技术的基础。
下面提供了使用 Pima Indians Onset of Diabetes 数据集绘制特征重要性分数的完整示例。
# plot feature importance using built-in function
from numpy import loadtxt
from xgboost import XGBClassifier
from xgboost import plot_importance
from matplotlib import pyplot
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
y = dataset[:,8]
# fit model on training data
model = XGBClassifier()
model.fit(X, y)
# plot feature importance
plot_importance(model)
pyplot.show()
在下一课中，我们将研究启发式算法，以便最好地配置梯度提升算法。
第 06 课：如何配置梯度提升
梯度提升是应用机器学习最强大的技术之一，因此很快成为最受欢迎的技术之一。
但是，如何为您的问题配置梯度提升？
在原始梯度提升论文中发表了许多配置启发式方法。它们可以概括为：
- 学习率或收缩率（XGBoost 中的 learning_rate ）应设置为 0.1 或更低，较小的值将需要添加更多树。
- 树的深度（XGBoost 中的 tree_depth ）应该在 2 到 8 的范围内配置，其中对于更深的树没有多少益处。
- 行采样（XGBoost 中的子样本）应配置在训练数据集的 30％到 80％的范围内，并且与未采样的 100％的值进行比较。
这些是配置模型时的一个很好的起点。
一个好的通用配置策略如下：
- 运行默认配置并查看训练和验证数据集上的学习曲线图。
- 如果系统过度学习，则降低学习率和/或增加树木数量。
- 如果系统学习不足，可以通过提高学习率和/或减少树木数量来加快学习速度。
Owen Zhang ，前 Kaggle 排名第一的竞争对手，现在是 Data Robot 的首席技术官提出了一个配置 XGBoost 的有趣策略。
他建议将树木的数量设置为目标值，如 100 或 1000，然后调整学习率以找到最佳模型。这是快速找到好模型的有效策略。
在下一节和最后一节中，我们将看一个调整 XGBoost 超参数的示例。
第 07 课：XGBoost 超参数调整
scikit-learn 框架提供了搜索参数组合的功能。
此功能在 GridSearchCV 类中提供，可用于发现配置模型以获得最佳表现的最佳方法。
例如，我们可以定义一个树的数量（ n_estimators ）和树大小（ max_depth ）的网格，通过将网格定义为：
n_estimators = [50, 100, 150, 200]
max_depth = [2, 4, 6, 8]
param_grid = dict(max_depth=max_depth, n_estimators=n_estimators)
然后使用 10 倍交叉验证评估每个参数组合：
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=7)
grid_search = GridSearchCV(model, param_grid, scoring="neg_log_loss", n_jobs=-1, cv=kfold, verbose=1)
result = grid_search.fit(X, label_encoded_y)
然后，我们可以查看结果，以确定最佳组合以及改变参数组合的一般趋势。
这是将 XGBoost 应用于您自己的问题时的最佳做法。要考虑调整的参数是：
- 树木的数量和大小（ n_estimators 和 max_depth ）。
- 学习率和树木数量（ learning_rate 和 n_estimators ）。
- 行和列子采样率（子样本， colsample_bytree 和 colsample_bylevel ）。
下面是调整 Pima Indians Onset of Diabetes 数据集中 learning_rate 的完整示例。
# Tune learning_rate
from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import StratifiedKFold
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# grid search
model = XGBClassifier()
learning_rate = [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3]
param_grid = dict(learning_rate=learning_rate)
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=7)
grid_search = GridSearchCV(model, param_grid, scoring="neg_log_loss", n_jobs=-1, cv=kfold)
grid_result = grid_search.fit(X, Y)
# summarize results
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
print("%f (%f) with: %r" % (mean, stdev, param))
XGBoost 学习迷你课程评论
恭喜你，你做到了。做得好！
花点时间回顾一下你走了多远：
- 您了解了梯度提升算法和 XGBoost 库。
- 您开发了第一个 XGBoost 模型。
- 您学习了如何使用早期停止和功能重要性等高级功能。
- 您学习了如何配置梯度提升模型以及如何设计对照试验来调整 XGBoost 超参数。
不要轻视这一点，你在很短的时间内走了很长的路。这只是您在 Python 中使用 XGBoost 的旅程的开始。继续练习和发展你的技能。
你喜欢这个迷你课吗？你有任何问题或疑点吗？ 发表评论让我知道。
