Machine-Learning-Mastery-XGBoost-教程-一-

Machine Learning Mastery XGBoost 教程（一）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

通过提前停止避免应用 Python 和 XGBoost 时发生的过拟合现象

原文： machinelearningmastery.com/avoid-overfitting-by-early-stopping-with-xgboost-in-python/

过拟合是非线性学习算法（例如梯度提升）中常见的一个复杂问题。

在这篇文章中，您将了解如何通过提前停止(early stopping)来抑制在 Python 中应用 XGBoost 时的过拟合现象。

阅读这篇文章，您会学习到：

• 提前停止(early stopping)是减少训练数据过拟合的一种方法。
• 如何在训练期间监测 XGBoost 模型的表现并绘制学习曲线。
• 如何使用提前停止(early stopping)来适时及早终止训练处于最佳 epoch 中的 XGBoost 模型。

请在我的新书中找到如何通过 XGBoost 配置、训练、调试和评估梯度提升模型，其中包括了 15 个手把手（Step-by-Step）的示例课程以及完整的 Python 代码。

让我们开始吧。

• 2017 年 1 月更新：此次更新为对应 scikit-learn API 版本 0.18.1 中的更改。
• 2018 年 3 月更新：为下载数据集添加了备用链接，旧链接已被移除。

通过提前停止(early stopping)避免 Python 中应用 XGBoost 时发生得过拟合（overfitting）现象 照片由Michael Hamann拍摄，保留部分版权。

通过提前停止(early stopping)避免过拟合

提前停止(early stopping)是一种训练复杂机器学习模型时避免过拟合的方法。

它通过监测在单独的测试数据集上训练模型的表现，并且观察到一旦在固定数量的训练迭代之后测试数据集上的表现没有得到改善，就会停止训练过程。

通过尝试自动选出测试数据集上的表现开始降低而训练数据集上的表现继续提高这样的过拟合发生迹象拐点来避免过拟合。

表现度量可以是通过训练模型而进行优化的损失函数（例如对数损失函数（logarithmic loss）），或者通常情况下问题所关注的外部指标（例如分类精度）。

在 XGBoost 中监测训练表现

XGBoost 模型可以在训练期间评估和报告模型在测试集上的表现。

它通过在训练模型和获取 verbose output 中调用 **model.fit（）**的同时指定测试数据集以及评估度量（evaluation metric）来支持此功能。

例如，我们可以在训练 XGBoost 模型时，在独立测试集（ eval_set ）上报告二值分类误差（"error"），如下所示：

eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, eval_metric="error", eval_set=eval_set, verbose=True)

XGBoost 所支持的评估度量（evaluation metric）集合包括但不仅限于：

• “rmse”表示均方根误差。
• “mae”表示平均绝对误差。
• “logloss”表示二值对数损失，“mlogloss”表示多类对数损失（交叉熵）。
• “error”表示分类误差。
• “auc”表示 ROC 曲线下的面积。

完整列表请参照 XGBoost 参数网页“学习任务参数(Learning Task Parameters)”。

例如，我们可以展示如何追踪 XGBoost 模型训练的表现，应用对象是Pima 印第安人糖尿病数据集(Pima Indians onset of diabetes dataset)，可以从 UCI 机器学习库(UCI Machine Learning Repository)获取下载（更新：从此处下载）。

完整示例代码如下：

# monitor training performance
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
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)
# fit model no training data
model = XGBClassifier()
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, eval_metric="error", 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))

运行这个例子将会在 67％的数据上训练模型，并在剩余 33％的测试数据集上，于每一个训练 epoch 评估一次模型。

每一次迭代的结果都将会报告分类误差，而分类精度将会在最后给出。

下面展示了结果输出，为简洁明了，只截取末尾部分。我们可以看到每次训练迭代都会报告分类误差（在每个 boosted tree 被添加到模型之后）。

...
[89]	validation_0-error:0.204724
[90]	validation_0-error:0.208661
[91]	validation_0-error:0.208661
[92]	validation_0-error:0.208661
[93]	validation_0-error:0.208661
[94]	validation_0-error:0.208661
[95]	validation_0-error:0.212598
[96]	validation_0-error:0.204724
[97]	validation_0-error:0.212598
[98]	validation_0-error:0.216535
[99]	validation_0-error:0.220472
Accuracy: 77.95%

回顾所有输出，我们可以看到在测试集上模型表现平稳，不过在训练即将结束时表现有些下降。

通过学习曲线评估 XGBoost 模型

我们可以在评估数据集上检视模型的表现，并通过绘制图像以更深入地展开了解训练中是如何学习的。

在训练 XGBoost 模型时，我们为eval_metric参数提供了一对 X 和 y 数组。除了测试集，我们也可以一并提供训练数据集。它将说明模型在训练期间在训练集和测试集上分别表现的情况。

例如：

eval_set = [(X_train, y_train), (X_test, y_test)]
model.fit(X_train, y_train, eval_metric="error", eval_set=eval_set, verbose=True)

此外，通过调用 **model.evals_result（）**函数，在每个评估集上训练的模型都可以存储并再度可用。这将返回评估数据集和评分的 dictionary，例如：

results = model.evals_result()
print(results)

这将 print 如下结果（为简洁明了，只截取部分作说明）：

{
	'validation_0': {'error': [0.259843, 0.26378, 0.26378, ...]},
	'validation_1': {'error': [0.22179, 0.202335, 0.196498, ...]}
}

'validation_0'和'validation_1'对应于在**fit（）**调用中向 eval_set 参数提供数据集的顺序。

若需要访问特定的结果数组，例如针对第一个数据集和其误差指标，可以操作如下：

results['validation_0']['error']

此外，我们可以通过向**fit（）**函数的 eval_metric 参数提供度量数组，来指定更多的评估度量（evaluation metric）用于评价和汇总。

我们可以使用这些汇总的表现度量来创建曲线图，并进一步解读模型在训练 epochs 过程中分别在训练数据集和测试数据集上的表现。

下面是完整的代码示例，显示了如何在曲线图上可视化汇总的结果。

# plot learning curve
from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
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]
# split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)
# fit model no training data
model = XGBClassifier()
eval_set = [(X_train, y_train), (X_test, y_test)]
model.fit(X_train, y_train, eval_metric=["error", "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))
# retrieve performance metrics
results = model.evals_result()
epochs = len(results['validation_0']['error'])
x_axis = range(0, epochs)
# plot log loss
fig, ax = pyplot.subplots()
ax.plot(x_axis, results['validation_0']['logloss'], label='Train')
ax.plot(x_axis, results['validation_1']['logloss'], label='Test')
ax.legend()
pyplot.ylabel('Log Loss')
pyplot.title('XGBoost Log Loss')
pyplot.show()
# plot classification error
fig, ax = pyplot.subplots()
ax.plot(x_axis, results['validation_0']['error'], label='Train')
ax.plot(x_axis, results['validation_1']['error'], label='Test')
ax.legend()
pyplot.ylabel('Classification Error')
pyplot.title('XGBoost Classification Error')
pyplot.show()

运行这段代码会显示每个 epoch 中训练数据集和测试数据集的分类误差。我们可以通过在 **fit（）**函数的调用中设置 verbose = False （默认值）来关闭这个功能。

我们看到结果创建了两张图。第一张图显示了训练数据集和测试数据集每个 epoch 中 XGBoost 模型的对数损失（logarithmic loss）。

XGBoost 学习曲线（对数损失（log loss））

第二张图显示了训练数据集和测试数据集每个 epoch 中 XGBoost 模型的分类误差（classification error）。

XGBoost 学习曲线（分类误差（classification error））

通过回顾 logloss 的图像，我们看起来是有提前停止学习过程的机会，也许在 epoch 20 到 epoch 40 之间的某个阶段。

在分类误差的图像中，我们也观察到了类似的情况，误差似乎在 epoch 40 左右出现上升。

在 XGBoost 中使用提前停止(early stopping)

XGBoost 可以支持在固定次数的迭代后提前停止(early stopping)。

除了为每个 epoch 指定用于评估的度量和测试数据集之外，还必须指定一个 epoch 窗长，它代表没有观察到任何改善的 epoch 数目。它可以在early_stopping_rounds参数中实现。

例如，我们可以在 10 个 epoch 中检查对数损失没有得到改善，代码如下：

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)

如果提供了多个评估数据集或多个评估度量（evaluation metric），则提前停止(early stopping)将使用列表中的最后一个。

下面展示提前停止(early stopping)的一个完整示例。

# 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 no 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))

运行示例代码将给出如下输出（为简洁明了，只截取部分作说明）：

...
[35]	validation_0-logloss:0.487962
[36]	validation_0-logloss:0.488218
[37]	validation_0-logloss:0.489582
[38]	validation_0-logloss:0.489334
[39]	validation_0-logloss:0.490969
[40]	validation_0-logloss:0.48978
[41]	validation_0-logloss:0.490704
[42]	validation_0-logloss:0.492369
Stopping. Best iteration:
[32]	validation_0-logloss:0.487297

我们可以看到模型在 epoch 42 停止训练（接近我们对学习曲线人为判断的预期），并且在 epoch 32 观察到具有最佳损失结果的模型。

通常情况下，选择 early_stopping_rounds 作为训练 epoch 总数（在这种情况下为 10％）是个不错的主意，或者尝试找到可能观察到的学习曲线拐点时期。

总结

在这篇文章中，您了解到了如何监测表现表现和提前停止(early stopping)。

所学到的要点是：

• 提前停止(early stopping)技术能够在训练数据集发生过拟合之前就停止模型训练。
• 如何在训练期间监测 XGBoost 模型的表现并绘制学习曲线。
• 如何在训练 XGBoost 模型中配置提前停止(early stopping)。

您对过拟合或这篇文章有任何疑问吗？请在评论中提出您的问题，我将会尽力回答。

在 Python 中如何调优 XGBoost 的多线程支持

原文： machinelearningmastery.com/best-tune-multithreading-support-xgboost-python/

为梯度提升（gradient boosting）而设计的 XGBoost 库具有高效的多核并行处理功能。

它能够在训练时有效地使用系统中的所有 CPU 核心。

在这篇文章中，您将了解在 Python 中使用 XGBoost 的并行处理能力。

阅读之后您会学习到：

• 如何确认 XGBoost 多线程功能可以在您的系统上运行。
• 如何在增加 XGBoost 上的线程数之后评估其效果。
• 如何在使用交叉验证和网格搜索(grid search)时充分利用多线程的 XGBoost。

让我们开始吧。

• 2017 年 1 月更新：对应 scikit-learn API 版本 0.18.1 中的更改​​。

在 Python 中如何调优 XGBoost 的多线程支持 照片由 Nicholas A. Tonelli 拍摄，保留部分版权。

问题描述：Otto Dataset

在本教程中，我们将使用 Otto Group 产品分类挑战赛数据集。

数据集可从 Kaggle 获得（您需要注册 Kaggle 以获取下载权限）。从数据页面（Data page）下载训练数据集 train.zip ，并将解压之后的 trian.csv 文件放入您的工作目录。

该数据集描述了超过 61,000 件产品的 93 个模糊细节。这些产品被分为 10 个类别（例如时尚，电子等）。填入属性(input attributes)是该种类对不同事件的计数。

任务目标是对新产品做出预测，在一个数组中给出分属 10 个类别的概率。评估模型将使用多类对数损失（multiclass logarithmic loss）（也称为交叉熵）。

这个竞赛已在 2015 年 5 月结束，该数据集对 XGBoost 来说是一个很好的挑战，因为有相当大规模的范例以及较大的问题难度，并且需要很少的数据准备（除了将字符串类型变量编码为整数）。

线程数的影响

XGBoost 是由 C++ 实现的，显式地使用 OpenMP API 来进行并行处理。

梯度提升中的并行性可以应用于单树（individual trees）的构建，而不是像随机森林并行创建树。这是因为在提升(boosting)中，树是被顺序添加到模型中。 XGBoost 的速度改观既体现在构造单树（individual trees）时添加并行性，也体现在有效地准备输入数据，以帮助加快树的构建。

根据您系统的平台，您可能需要专门编译 XGBoost 以支持多线程。详细信息请参阅 XGBoost 安装说明。

XGBoost 的 XGBClassifier 和 XGBRegressor 包装类给 scikit-learn 的使用提供了 nthread 参数，用于指定 XGBoost 在训练期间可以使用的线程数。

默认情况下，此参数设置为-1 以使用系统中的所有核心。

model = XGBClassifier(nthread=-1)

通常，您应该从 XGBoost 安装中直接获得多线程支持，而无需任何额外的工作。

根据您的 Python 环境（例如 Python 3），可能需要显式启用 XGBoost 的多线程支持。如果您需要帮助， XGBoost 库提供了一个示例。

您可以通过构建一定数量的不同的 XGBoost 模型来确认 XGBoost 多线程支持是否正常工作，指定线程数并计算构建每个模型所需的时间。这一过程将向您表明启用了多线程支持，并显示构建模型时的时长效果。

例如，如果您的系统有 4 个核心，您可以训练 8 个不同的模型，并计算创建每个模型所需的时间（以秒为单位），然后比较时长。

# evaluate the effect of the number of threads
results = []
num_threads = [1, 2, 3, 4]
for n in num_threads:
	start = time.time()
	model = XGBClassifier(nthread=n)
	model.fit(X_train, y_train)
	elapsed = time.time() - start
	print(n, elapsed)
	results.append(elapsed)

我们可以在 Otto 数据集上使用这种方法。为说明的完备性，下面给出完整示例。

您可以更改 num_threads 数组以符合您系统的核心数。

# Otto, tune number of threads
from pandas import read_csv
from xgboost import XGBClassifier
from sklearn.preprocessing import LabelEncoder
import time
from matplotlib import pyplot
# load data
data = read_csv('train.csv')
dataset = data.values
# split data into X and y
X = dataset[:,0:94]
y = dataset[:,94]
# encode string class values as integers
label_encoded_y = LabelEncoder().fit_transform(y)
# evaluate the effect of the number of threads
results = []
num_threads = [1, 2, 3, 4]
for n in num_threads:
	start = time.time()
	model = XGBClassifier(nthread=n)
	model.fit(X, label_encoded_y)
	elapsed = time.time() - start
	print(n, elapsed)
	results.append(elapsed)
# plot results
pyplot.plot(num_threads, results)
pyplot.ylabel('Speed (seconds)')
pyplot.xlabel('Number of Threads')
pyplot.title('XGBoost Training Speed vs Number of Threads')
pyplot.show()

运行这段示例代码将记录不同配置下的训练执行时间（以秒为单位），例如：

(1, 115.51652717590332)
(2, 62.7727689743042)
(3, 46.042901039123535)
(4, 40.55334496498108)

下图给出这些时间的直观说明。

单个模型的 XGBoost 调节线程数

随着线程数量的增加，我们可以看到执行时间减少的优越趋势。

如果您没有看到增加每个新线程的运行时间有所改善，可能需要检查怎样在安装过程中或运行过程中启用 XGBoost 多线程支持。

我们可以在具有更多核心的机器上运行相同的代码。例如大型的 Amazon Web Services EC2 具有 32 个核心。我们可以调整上面的代码来计算具有 1 到 32 个核心的模型所需的训练时间。结果如下图。

XGBoost 在 1 到 32 个核心上训练模型所需的时间

值得注意的是，在多于 16 个线程（大约 7 秒）的情况下，我们没有看到太多进步。我想其原因是 Amazon 仅在硬件中提供 16 个内核，而另外的 16 个核心是通过超线程提供额外。结果表明，如果您的计算机具有超线程能力，则可能需要将 num_threads 设置为等于计算机中物理 CPU 核心的数量。

使用 OpenMP 进行 XGBoost 的低层面最优执行能压缩像这样大型计算机的每一次最后一个周期（last cycle）。

交叉验证 XGBoost 模型时的并行性

scikit-learn 中的 k-fold 交叉验证也同样支持多线程。

例如， 当使用 k-fold 交叉验证评估数据集上的模型，**cross_val_score（）**函数的 n_jobs 参数允许您指定要运行的并行作业数。

默认情况下，此值设置为 1，但可以设置为-1 以使用系统上的所有 CPU 核心。这其实也是一个很好地实践。例如：

results = cross_val_score(model, X, label_encoded_y, cv=kfold, scoring='log_loss', n_jobs=-1, verbose=1)

这就提出了如何配置交叉验证的问题：

• 禁用 XGBoost 中的多线程支持，并允许交叉验证在所有核心上运行。
• 禁用交叉验证中的多线程支持，并允许 XGBoost 在所有核心上运行。
• 同时启用 XGBoost 和交叉验证的多线程支持。

我们可以通过简单计算在每种情况下评估模型所需的时间来得到这个问题的答案。

在下面的示例中，我们使用 10 次交叉验证来评估 Otto 训练数据集上的默认 XGBoost 模型。上述每种情况都得到了评估，并记录了所花费的时间。

完整的代码示例如下所示。

# Otto, parallel cross validation
from pandas import read_csv
from xgboost import XGBClassifier
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
import time
# load data
data = read_csv('train.csv')
dataset = data.values
# split data into X and y
X = dataset[:,0:94]
y = dataset[:,94]
# encode string class values as integers
label_encoded_y = LabelEncoder().fit_transform(y)
# prepare cross validation
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=7)
# Single Thread XGBoost, Parallel Thread CV
start = time.time()
model = XGBClassifier(nthread=1)
results = cross_val_score(model, X, label_encoded_y, cv=kfold, scoring='neg_log_loss', n_jobs=-1)
elapsed = time.time() - start
print("Single Thread XGBoost, Parallel Thread CV: %f" % (elapsed))
# Parallel Thread XGBoost, Single Thread CV
start = time.time()
model = XGBClassifier(nthread=-1)
results = cross_val_score(model, X, label_encoded_y, cv=kfold, scoring='neg_log_loss', n_jobs=1)
elapsed = time.time() - start
print("Parallel Thread XGBoost, Single Thread CV: %f" % (elapsed))
# Parallel Thread XGBoost and CV
start = time.time()
model = XGBClassifier(nthread=-1)
results = cross_val_score(model, X, label_encoded_y, cv=kfold, scoring='neg_log_loss', n_jobs=-1)
elapsed = time.time() - start
print("Parallel Thread XGBoost and CV: %f" % (elapsed))

运行这段示例代码将会 print 以下结果：

Single Thread XGBoost, Parallel Thread CV: 359.854589
Parallel Thread XGBoost, Single Thread CV: 330.498101
Parallel Thread XGBoost and CV: 313.382301

我们可以看到，并行化 XGBoost 较之并行化交叉验证会带来提升。这是说得通的，因为 10 个单列快速任务将比（10 除以 num_cores）慢任务表现优秀。

有趣的是，我们可以看到通过在 XGBoost 和交叉验证中同时启用多线程实现了最佳结果。这是令人惊讶的，因为它代表并行 XGBoost 模型的 num_cores 数在与创建模型中相同的 num_cores 数进行竞争。然而，这实现了最快的结果，它是进行交叉验证的 XGBoost 优选使用方法。

因为网格搜索（grid search）使用相同的基础方法来实现并行性，所以我们期望同样的结论可用于优化 XGBoost 的超参数。

总结

在这篇文章中，您了解到了 XGBoost 的多线程功能。

所学到的要点是：

• 如何检查您的系统中是否启用了 XGBoost 中的多线程支持。
• 增加线程数会如何影响训练 XGBoost 模型的表现。
• 如何在 Python 中最优配置 XGBoost 和交叉验证以获取最短的运行时间。

您对 XGBoost 的多线程功能或者这篇文章有任何疑问吗？请在评论中提出您的问题，我将会尽力回答。

如何配置梯度提升算法

原文： machinelearningmastery.com/configure-gradient-boosting-algorithm/

梯度提升是应用机器学习最强大的技术之一，因此很快成为最受欢迎的技术之一。

但是，如何为您的问题配置梯度提升？

在这篇文章中，您将了解如何通过查看书籍，论文和竞赛结果中报告的配置来配置机器学习问题的梯度提升。

阅读这篇文章后，你会知道：

• 如何根据原始来源配置梯度提升。
• 从标准实现中的默认值和建议配置算法的想法。
• 从顶级 Kaggle 竞争对手配置梯度提升和 XGBoost 的经验法则。

让我们开始吧。

如何配置梯度提升算法 照片来自 Chris Sorge ，保留一些权利。

如何配置梯度增压机

在 1999 年的论文“贪婪函数逼近：梯度提升机”中，Jerome Friedman 评论了树木数量（M）和学习率（v）之间的权衡：

v-M 的权衡显而易见;较小的 v 值会产生较大的最佳 M 值。它们还提供更高的准确度，v <1 的回报递减。 0.125。对于 M> 1，错误分类错误率非常平坦。 200，因此它的最佳 M 值是不稳定的。 ......这些结果的定性性质相当普遍。

他建议首先为树木数量设置一个较大的值，然后调整收缩参数以获得最佳结果。本文的研究优选收缩值为 0.1，树木的数量在 100 到 500 之间，树木中的终端节点数在 2 到 8 之间。

在 1999 年的论文“ Stochastic Gradient Boosting ”中，弗里德曼重申了对收缩参数的偏好：

“收缩”参数 0 < v＆lt; 1 控制程序的学习率。根据经验......，发现小值（v​​ <= 0.1）导致更好的泛化误差。

在论文中，弗里德曼介绍并实证研究了随机梯度提升（基于行的子采样）。他发现几乎所有的子采样百分比都比所谓的确定性提升更好，或许 30％到 50％是一个很好的选择一些问题的价值和 50％到 80％的其他问题。

...采样分数的最佳值...约为 40％（f = 0.4）......然而，在每次迭代中仅采样 30％甚至 20％的数据比没有采样有相当大的改进，并且具有相应的计算速度 - 因子分别为 3 和 5。

他还研究了树木中终端节点数量的影响，发现像 3 和 6 这样的值比 11,21 和 41 等更大的值更好。

在两种情况下，平均超过 100 个目标的最佳树大小是 L = 6.通过使用较大的树来增加基础学习器的容量通过“过拟合”降低表现。

在 H2O 中题为“梯度提升机器学习”的演讲中，Trevor Hastie 评论说，一般梯度提升比随机森林表现更好，后者反过来比单个决策树表现更好。

随机森林＆gt;套袋＆gt;单树

第十章标题为“统计学习要素：数据挖掘，推理和预测”中的“提升和加性树”专门用于提升。在其中，它们提供了用于配置梯度提升的启发式方法以及一些实证研究。

他们评论说树中的节点数（J）的值很好，约为 6，通常在 4 到 8 的范围内有良好的值。

虽然在许多应用中 J = 2 是不够的，但是 J>不可能。将需要 10。到目前为止的经验表明 4＆lt; = J＆lt; = 8 在增强的情况下工作良好，结果对该范围内的特定选择相当不敏感。

他们建议监控验证数据集的表现，以便校准树的数量，并在验证数据集的表现开始降低后使用早期停止程序。

正如在弗里德曼的第一个梯度提升论文中，他们评论了树木数量（M）和学习率（v）之间的权衡，并建议学习率的一个小值＆lt; 0.1。

对于相同的训练风险，较小的 v 值导致较大的 M 值，因此在它们之间存在折衷。 ......实际上，最好的策略似乎是将 v 设置得非常小（v <0.1），然后通过提前停止选择 M.

此外，正如弗里德曼的随机梯度提升纸一样，他们建议采用二次采样百分比（n）而不更换值约为 50％。

n 的典型值可以是 1/2，但是对于大的 N，n 可以基本上小于 1/2。

R 中梯度提升的配置

梯度提升算法在 R 中实现为 gbm 包。

回顾软件包文档，gbm（）函数指定合理的默认值：

• n.trees = 100（树木数量）。
• interaction.depth = 1（叶数）。
• n.minobsinnode = 10（树终端节点中的最小样本数）。
• 收缩率= 0.001（学习率）。

值得注意的是，使用较小的收缩因子并且树桩是默认值。接下来，里奇韦解释了小的收缩。

在 R 中使用 gbm 软件包的标题为“ Generalized Boosted Models：gbm 软件包的指南”中，Greg Ridgeway 提供了一些使用启发式方法。他建议第一次将学习率（lambda）设置为尽可能小，然后使用交叉验证调整树的数量（迭代或 T）。

在实践中，我将 lambda 设置为尽可能小，然后通过交叉验证选择 T.当 lambda 尽可能小的表现时，表现最佳，并且对于越来越小的 lambda，边际效用越来越小。

他评论了他将默认收缩率设置为 0.001 而不是 0.1 的小值的基本原理。

重要的是要知道较小的收缩值（几乎）总能提高预测表现。也就是说，设置收缩率= 0.001 几乎肯定会导致模型具有比设置收缩率= 0.01 更好的样本外预测表现。 ...收缩率= 0.001 的模型可能需要十倍于具有收缩率= 0.01 的模型的迭代次数

Ridgeway 还使用了大量的树（这里称为迭代），数千而不是数百

我通常瞄准 3,000 到 10,000 次迭代，收缩率在 0.01 到 0.001 之间。

在 scikit-learn 中配置梯度提升

Python 库提供了用于分类的梯度提升的实现，称为 GradientBoostingClassifier 类，并且回归称为 GradientBoostingRegressor 类。

查看此库中算法的默认配置很有用。

有许多参数，但下面是几个关键的默认值。

• learning_rate = 0.1（收缩）。
• n_estimators = 100（树的数量）。
• MAX_DEPTH = 3。
• min_samples_split = 2。
• min_samples_leaf = 1。
• 子样本= 1.0。

有趣的是，默认收缩与 Friedman 匹配，并且树深度未设置为 R 包之类的树桩。树深度为 3（如果创建的树是对称的）将具有 8 个叶节点，匹配 Friedman 研究中的首选终端节点数的上限（可以设置 max_leaf_nodes）。

在标题为“ Gradient Tree Boosting ”的部分下的 scikit-learn 用户指南中，作者评论说，设置最大叶节点与将最大深度设置为减去最大叶节点的效果类似，但结果表现更差。

我们发现 max_leaf_nodes = k 给出了与 max_depth = k-1 相当的结果，但是以稍高的训练误差为代价训练得更快。

在一项小型研究中，证明了梯度提升的正则化方法“梯度提升正则化”，结果显示了使用收缩和二次采样的好处。

在 XGBoost 中配置梯度提升

XGBoost 库专用于梯度提升算法。

它也指定了值得注意的默认参数，首先是 XGBoost 参数页面：

• eta = 0.3（收缩率或学习率）。
• MAX_DEPTH = 6。
• 子样本= 1。

与大多数研究和其他图书馆相比，这显示出更高的学习率和更大的最大深度。同样，我们可以在 Python API 参考中总结 XGBoost 的默认参数。

• MAX_DEPTH = 3。
• learning_rate = 0.1。
• n_estimators = 100。
• 子样本= 1。

这些默认值通常更符合 scikit-learn 默认值和论文推荐。

在与 TechEd Europe 的一次题为“ xgboost：用于快速和准确梯度提升的 R 包”的谈话中，当被问及如何配置 XGBoost 时，Tong He 建议调整三个最重要的参数：

• 树木数量。
• 树深度。
• 步长（学习率）。

他还为新问题提供了简洁的配置策略：

1. 运行默认配置（并且可能会查看学习曲线？）。
2. 如果系统过度学习，请减慢学习速度（使用收缩？）。
3. 如果系统学习不足，可以加快学习速度（使用收缩？）。

在 Owen Zhang 于 2015 年与 NYC 数据科学学院进行的题为“获奖数据科学竞赛”的谈话中，他提供了一些使用 XGBoost 配置梯度提升的一般技巧。 Owen 是梯度提升的重要用户。

我的忏悔：我（过）使用 GBM。如有疑问，请使用 GBM。

他提供了一些配置梯度提升的技巧：

• 学习率+树木数量：定位 500 到 1000 棵树并调整学习率。
• 叶子中的样本数量：获得良好平均估计值所需的观察数量。
• 互动深度：10+。

在同一个谈话的更新幻灯片中，他总结了他用于 XGBoost 的常见参数：

Owen Zhang 超级参数调整 XGBoost 的建议表

我们可以在这张表中看到一些有趣的东西。

• 将学习率与树木数量的关系简化为近似比例：学习率= [2-10] /树。
• 探索随机梯度提升的行和列采样的值。
• 探索与弗里德曼（4-10）报道的最大深度相同的范围。
• 调整最小叶重量，作为罕见事件数量百分比的近似比率为 3。

欧文在 2015 年波士顿 ODSC 题为“开源工具和数据科学竞赛”的类似演讲中，他再次总结了他使用的常用参数：

Owen Zhang 关于调整 XGBoost 的建议

我们可以看到一些可能相关的细微差别。

• 目标 100 而不是 1000 棵树并调整学习率。
• 最小孩子体重在事件率的平方根上为 1。
• 没有行的子采样。

最后，Abhishek Thakur 在题为“接近（几乎）任何机器学习问题”的帖子中提供了一个类似的表格，列出了关键的 XGBoost 参数和调整建议。

Abhishek Thakur 对调整 XGBoost 的建议

点差确实涵盖了上面建议的一般默认值以及更多。

值得注意的是，Abhishek 确实提供了一些调整 alpha 和 beta 模型惩罚术语以及行采样的建议。

摘要

在这篇文章中，您深入了解了如何为您自己的机器学习问题配置梯度提升。

特别是你学到了：

• 关于树木数量的折衷以及子采样的收缩和良好的默认值。
• 关于限制树大小的不同想法以及树深度和终端节点数量的良好默认值。
• 顶级 Kaggle 比赛获胜者使用的网格搜索策略。

您对配置梯度提升或关于此帖子有任何疑问吗？在评论中提出您的问题。

使用 Python 和 XGBoost 为梯度提升准备数据

原文： machinelearningmastery.com/data-preparation-gradient-boosting-xgboost-python/

XGBoost 因其速度和表现而成为 Gradient Boosting 的流行实现。

在内部，XGBoost 模型将所有问题表示为回归预测性建模问题，仅将数值作为输入。如果您的数据格式不同，则必须将其准备为预期格式。

在这篇文章中，您将了解如何准备数据，以便在 Python 中使用 XGBoost 库进行梯度提升。

阅读这篇文章后你会知道：

• 如何编码字符串输出变量进行分类。
• 如何使用单热编码准备分类输入变量。
• 如何使用 XGBoost 自动处理缺失数据。

让我们开始吧。

• 2016 年 9 月更新：我在 impute 示例中更新了一些小错字。
• 2017 年 1 月更新：已更新，以反映 scikit-learn API 版本 0.18.1 中的更改​​。
• 2017 年 1 月更新：更新了将输入数据转换为字符串的乳腺癌示例。

使用 Python 中的 XGBoost 进行梯度提升的数据准备 照片由 Ed Dunens 拍摄，保留一些权利。

标签编码字符串类值

虹膜花分类问题是具有字符串类值的问题的示例。

这是一个预测问题，其中以厘米为单位给出鸢尾花的测量值，任务是预测给定花属于哪个物种。

下面是原始数据集的示例。您可以从 UCI 机器学习库中了解有关此数据集的更多信息并以 CSV 格式下载原始数据。

5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa

XGBoost 无法按原样对此问题进行建模，因为它要求输出变量为数字。

我们可以使用 LabelEncoder 轻松地将字符串值转换为整数值。三个类值（Iris-setosa，Iris-versicolor，Iris-virginica）被映射到整数值（0,1,2）。

# encode string class values as integers
label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)

我们将标签编码器保存为单独的对象，以便我们可以使用相同的编码方案转换训练以及稍后的测试和验证数据集。

下面是一个演示如何加载虹膜数据集的完整示例。请注意，Pandas 用于加载数据以处理字符串类值。

# multiclass classification
import pandas
import xgboost
from sklearn import model_selection
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder
# load data
data = pandas.read_csv('iris.csv', header=None)
dataset = data.values
# split data into X and y
X = dataset[:,0:4]
Y = dataset[:,4]
# encode string class values as integers
label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)
seed = 7
test_size = 0.33
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, label_encoded_y, test_size=test_size, random_state=seed)
# fit model no training data
model = xgboost.XGBClassifier()
model.fit(X_train, y_train)
print(model)
# 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))

运行该示例将生成以下输出：

XGBClassifier(base_score=0.5, colsample_bylevel=1, colsample_bytree=1,
       gamma=0, learning_rate=0.1, max_delta_step=0, max_depth=3,
       min_child_weight=1, missing=None, n_estimators=100, nthread=-1,
       objective='multi:softprob', reg_alpha=0, reg_lambda=1,
       scale_pos_weight=1, seed=0, silent=True, subsample=1)
Accuracy: 92.00%

请注意 XGBoost 模型如何配置为使用 multi：softprob 目标自动建模多分类问题，该目标是 softmax loss 函数的一种变体，用于模拟类概率。这表明在内部，输出类自动转换为一种热类型编码。

单热编码分类数据

一些数据集仅包含分类数据，例如乳腺癌数据集。

该数据集描述了乳腺癌活组织检查的技术细节，预测任务是预测患者是否复发癌症。

下面是原始数据集的示例。您可以在 UCI 机器学习库中了解有关此数据集的更多信息，并从 mldata.org 以 CSV 格式下载。

'40-49','premeno','15-19','0-2','yes','3','right','left_up','no','recurrence-events'
'50-59','ge40','15-19','0-2','no','1','right','central','no','no-recurrence-events'
'50-59','ge40','35-39','0-2','no','2','left','left_low','no','recurrence-events'
'40-49','premeno','35-39','0-2','yes','3','right','left_low','yes','no-recurrence-events'
'40-49','premeno','30-34','3-5','yes','2','left','right_up','no','recurrence-events'

我们可以看到所有 9 个输入变量都是分类的，并以字符串格式描述。问题是二进制分类预测问题，输出类值也以字符串格式描述。

我们可以重用上一节中的相同方法，并将字符串类值转换为整数值，以使用 LabelEncoder 对预测进行建模。例如：

# encode string class values as integers
label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)

我们可以在 X 中的每个输入要素上使用相同的方法，但这只是一个起点。

# encode string input values as integers
features = []
for i in range(0, X.shape[1]):
	label_encoder = LabelEncoder()
	feature = label_encoder.fit_transform(X[:,i])
	features.append(feature)
encoded_x = numpy.array(features)
encoded_x = encoded_x.reshape(X.shape[0], X.shape[1])

XGBoost 可以假设每个输入变量的编码整数值具有序数关系。例如，对于 breast-quad 变量，“left-up”编码为 0 并且“left-low”编码为 1 具有作为整数的有意义的关系。在这种情况下，这种假设是不真实的。

相反，我们必须将这些整数值映射到新的二进制变量，每个分类值都有一个新变量。

例如，breast-quad 变量具有以下值：

left-up
left-low
right-up
right-low
central

我们可以将其建模为 5 个二进制变量，如下所示：

left-up, left-low, right-up, right-low, central
1,0,0,0,0
0,1,0,0,0
0,0,1,0,0
0,0,0,1,0
0,0,0,0,1

这称为单热编码。我们可以使用 scikit-learn 中的 OneHotEncoder 类对所有分类输入变量进行热编码。

在我们对其进行标签编码后，我们可以对每个功能进行热编码。首先，我们必须将要素数组转换为 2 维 NumPy 数组，其中每个整数值是长度为 1 的要素向量。

feature = feature.reshape(X.shape[0], 1)

然后我们可以创建 OneHotEncoder 并对特征数组进行编码。

onehot_encoder = OneHotEncoder(sparse=False)
feature = onehot_encoder.fit_transform(feature)

最后，我们可以通过逐个连接单热编码特征来建立输入数据集，将它们作为新列添加（轴= 2）。我们最终得到一个由 43 个二进制输入变量组成的输入向量。

# encode string input values as integers
encoded_x = None
for i in range(0, X.shape[1]):
	label_encoder = LabelEncoder()
	feature = label_encoder.fit_transform(X[:,i])
	feature = feature.reshape(X.shape[0], 1)
	onehot_encoder = OneHotEncoder(sparse=False)
	feature = onehot_encoder.fit_transform(feature)
	if encoded_x is None:
		encoded_x = feature
	else:
		encoded_x = numpy.concatenate((encoded_x, feature), axis=1)
print("X shape: : ", encoded_x.shape)

理想情况下，我们可以尝试不使用单热编码输入属性，因为我们可以使用显式序数关系对它们进行编码，例如第一个列的年龄值为'40 -49'和'50 -59'。如果您有兴趣扩展此示例，则将其留作练习。

下面是带有标签和单热编码输入变量和标签编码输出变量的完整示例。

# binary classification, breast cancer dataset, label and one hot encoded
import numpy
from pandas import read_csv
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
# load data
data = read_csv('datasets-uci-breast-cancer.csv', header=None)
dataset = data.values
# split data into X and y
X = dataset[:,0:9]
X = X.astype(str)
Y = dataset[:,9]
# encode string input values as integers
encoded_x = None
for i in range(0, X.shape[1]):
	label_encoder = LabelEncoder()
	feature = label_encoder.fit_transform(X[:,i])
	feature = feature.reshape(X.shape[0], 1)
	onehot_encoder = OneHotEncoder(sparse=False)
	feature = onehot_encoder.fit_transform(feature)
	if encoded_x is None:
		encoded_x = feature
	else:
		encoded_x = numpy.concatenate((encoded_x, feature), axis=1)
print("X shape: : ", encoded_x.shape)
# encode string class values as integers
label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)
# split data into train and test sets
seed = 7
test_size = 0.33
X_train, X_test, y_train, y_test = train_test_split(encoded_x, label_encoded_y, test_size=test_size, random_state=seed)
# fit model no training data
model = XGBClassifier()
model.fit(X_train, y_train)
print(model)
# 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))

运行此示例，我们得到以下输出：

('X shape: : ', (285, 43))
XGBClassifier(base_score=0.5, colsample_bylevel=1, colsample_bytree=1,
       gamma=0, learning_rate=0.1, max_delta_step=0, max_depth=3,
       min_child_weight=1, missing=None, n_estimators=100, nthread=-1,
       objective='binary:logistic', reg_alpha=0, reg_lambda=1,
       scale_pos_weight=1, seed=0, silent=True, subsample=1)
Accuracy: 71.58%

我们再次看到 XGBoost 框架自动选择' binary：logistic '目标，这是二进制分类问题的正确目标。

支持缺失数据

XGBoost 可以自动学习如何最好地处理缺失数据。

事实上，XGBoost 被设计为处理稀疏数据，如前一节中的单热编码数据，并且通过最小化损失函数来处理丢失数据的方式与处理稀疏或零值的方式相同。

有关如何在 XGBoost 中处理缺失值的技术细节的更多信息，请参见文章 XGBoost：可伸缩树升压系统中的第 3.4 节“_ 稀疏感知拆分查找 _”。

Horse Colic 数据集是演示此功能的一个很好的示例，因为它包含大部分缺失数据，大约 30％。

您可以了解有关 Horse Colic 数据集的更多信息，并从 UCI 机器学习库下载原始数据文件。

这些值由空格分隔，我们可以使用 Pandas 函数 read_csv 轻松加载它。

dataframe = read_csv("horse-colic.csv", delim_whitespace=True, header=None)

加载后，我们可以看到缺少的数据标有问号字符（'？'）。我们可以将这些缺失值更改为 XGBoost 预期的稀疏值，即值零（0）。

# set missing values to 0
X[X == '?'] = 0

由于缺少的数据被标记为字符串，因此缺少数据的那些列都作为字符串数据类型加载。我们现在可以将整个输入数据集转换为数值。

# convert to numeric
X = X.astype('float32')

最后，这是一个二分类问题，尽管类值用整数 1 和 2 标记。我们将 XGBoost 中的二进制分类问题建模为逻辑 0 和 1 值。我们可以使用 LabelEncoder 轻松地将 Y 数据集转换为 0 和 1 整数，就像我们在虹膜花示例中所做的那样。

# encode Y class values as integers
label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)

完整性代码清单如下所示。

# binary classification, missing data
from pandas import read_csv
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder
# load data
dataframe = read_csv("horse-colic.csv", delim_whitespace=True, header=None)
dataset = dataframe.values
# split data into X and y
X = dataset[:,0:27]
Y = dataset[:,27]
# set missing values to 0
X[X == '?'] = 0
# convert to numeric
X = X.astype('float32')
# encode Y class values as integers
label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)
# 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, label_encoded_y, test_size=test_size, random_state=seed)
# fit model no training data
model = XGBClassifier()
model.fit(X_train, y_train)
print(model)
# 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))

运行此示例将生成以下输出。

XGBClassifier(base_score=0.5, colsample_bylevel=1, colsample_bytree=1,
       gamma=0, learning_rate=0.1, max_delta_step=0, max_depth=3,
       min_child_weight=1, missing=None, n_estimators=100, nthread=-1,
       objective='binary:logistic', reg_alpha=0, reg_lambda=1,
       scale_pos_weight=1, seed=0, silent=True, subsample=1)
Accuracy: 83.84%

我们可以通过使用非零值（例如 1）标记缺失值来梳理 XGBoost 自动处理缺失值的效果。

X[X == '?'] = 1

重新运行该示例表明模型的准确率下降。

Accuracy: 79.80%

我们还可以使用特定值来估算缺失的数据。

通常使用列的平均值或中值。我们可以使用 scikit-learn Imputer 类轻松地估算缺失的数据。

# impute missing values as the mean
imputer = Imputer()
imputed_x = imputer.fit_transform(X)

下面是完整的示例，其中缺少的数据与每列的平均值估算。

# binary classification, missing data, impute with mean
import numpy
from pandas import read_csv
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import Imputer
# load data
dataframe = read_csv("horse-colic.csv", delim_whitespace=True, header=None)
dataset = dataframe.values
# split data into X and y
X = dataset[:,0:27]
Y = dataset[:,27]
# set missing values to 0
X[X == '?'] = numpy.nan
# convert to numeric
X = X.astype('float32')
# impute missing values as the mean
imputer = Imputer()
imputed_x = imputer.fit_transform(X)
# encode Y class values as integers
label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)
# split data into train and test sets
seed = 7
test_size = 0.33
X_train, X_test, y_train, y_test = train_test_split(imputed_x, label_encoded_y, test_size=test_size, random_state=seed)
# fit model no training data
model = XGBClassifier()
model.fit(X_train, y_train)
print(model)
# 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))

运行此示例，我们看到的结果等同于将值固定为一（1）。这表明至少在这种情况下，我们最好用不同的零（0）值而不是有效值（1）或估算值来标记缺失值。

Accuracy: 79.80%

当您缺少值时，尝试这两种方法（自动处理和输入）是一个很好的教训。

摘要

在这篇文章中，您发现了如何使用 Python 中的 XGBoost 为梯度提升准备机器学习数据。

具体来说，你学到了：

• 如何使用标签编码为二进制分类准备字符串类值。
• 如何使用单热编码准备分类输入变量以将它们建模为二进制变量。
• XGBoost 如何自动处理缺失数据以及如何标记和估算缺失值。

您对如何为 XGBoost 或此帖子准备数据有任何疑问吗？在评论中提出您的问题，我会尽力回答。

如何使用 Python 和 scikit-learn 开发您的第一个 XGBoost 模型

原文： machinelearningmastery.com/develop-first-xgboost-model-python-scikit-learn/

XGBoost 是梯度提升决策树的一种实现，旨在提高机器学习竞赛速度和表现。

在这篇文章中，您将了解如何在 Python 中安装和创建第一个 XGBoost 模型。

阅读这篇文章后你会知道：

• 如何在您的系统上安装 XGBoost 以便在 Python 中使用。
• 如何准备数据并训练您的第一个 XGBoost 模型。
• 如何使用 XGBoost 模型做出预测。

让我们开始吧。

• 2017 年 1 月更新：已更新，以反映 scikit-learn API 版本 0.18.1 中的更改​​。
• 2017 年 3 月更新：添加缺失导入，使导入更清晰。
• 更新 March / 2018 ：添加了备用链接以下载数据集，因为原始图像已被删除。

如何用 scikit-learn 开发你的第一个 XGBoost 模型 照片由 Justin Henry 开发，保留一些权利。

教程概述

本教程分为以下 6 个部分：

1. 安装 XGBoost 以与 Python 一起使用。
2. 问题定义和下载数据集。
3. 加载并准备数据。
4. 训练 XGBoost 模型。
5. 做出预测并评估模型。
6. 将它们结合在一起并运行示例。

1.安装 XGBoost 以便在 Python 中使用

假设您有一个可用的 SciPy 环境，可以使用 pip 轻松安装 XGBoost。

例如：

sudo pip install xgboost

要更新 XGBoost 的安装，您可以键入：

sudo pip install --upgrade xgboost

如果您不能使用 pip 或者想要从 GitHub 运行最新代码，则另一种安装 XGBoost 的方法要求您复制 XGBoost 项目并执行手动构建和安装。

例如，要在 Mac OS X 上没有多线程构建 XGBoost（已经通过 macports 或 homebrew 安装了 GCC），您可以键入：

git clone --recursive https://github.com/dmlc/xgboost
cd xgboost
cp make/minimum.mk ./config.mk
make -j4
cd python-package
sudo python setup.py install

您可以在 XGBoost 安装指南上了解有关如何为不同平台安装 XGBoost 的更多信息。有关安装 XGBoost for Python 的最新说明，请参阅 XGBoost Python 包。

作为参考，您可以查看 XGBoost Python API 参考。

2.问题描述：预测糖尿病的发病

在本教程中，我们将使用皮马印第安人糖尿病数据集。

该数据集由描述患者医疗细节的 8 个输入变量和一个输出变量组成，以指示患者是否在 5 年内患有糖尿病。

您可以在 UCI 机器学习存储库网站上了解有关此数据集的更多信息。

这是第一个 XGBoost 模型的一个很好的数据集，因为所有输入变量都是数字的，问题是一个简单的二进制分类问题。对于 XGBoost 算法来说，它不一定是一个好问题，因为它是一个相对较小的数据集，并且很容易建模。

下载此数据集并将其放入当前工作目录，文件名为“ pima-indians-diabetes.csv ”（更新：从此处下载）。

3.加载和准备数据

在本节中，我们将从文件加载数据并准备用于训练和评估 XGBoost 模型。

我们将从导入我们打算在本教程中使用的类和函数开始。

from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

接下来，我们可以使用 NumPy 函数 **loadtext（）**将 CSV 文件作为 NumPy 数组加载。

# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")

我们必须将数据集的列（属性或特征）分成输入模式（X）和输出模式（Y）。我们可以通过以 NumPy 数组格式指定列索引来轻松完成此操作。

# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]

最后，我们必须将 X 和 Y 数据拆分为训练和测试数据集。训练集将用于准备 XGBoost 模型，测试集将用于进行新的预测，我们可以从中评估模型的表现。

为此，我们将使用 scikit-learn 库中的 **train_test_split（）**函数。我们还为随机数生成器指定种子，以便每次执行此示例时始终获得相同的数据分割。

# 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)

我们现在准备训练我们的模型。

4.训练 XGBoost 模型

XGBoost 提供了一个包装类，允许在 scikit-learn 框架中将模型视为分类器或回归器。

这意味着我们可以使用带有 XGBoost 模型的完整 scikit-learn 库。

用于分类的 XGBoost 模型称为 XGBClassifier 。我们可以创建并使其适合我们的训练数据集。使用 scikit-learn API 和 **model.fit（）**函数拟合模型。

训练模型的参数可以传递给构造函数中的模型。在这里，我们使用合理的默认值。

# fit model no training data
model = XGBClassifier()
model.fit(X_train, y_train)

您可以通过打印模型来查看训练模型中使用的参数，例如：

print(model)

您可以在 XGBoost Python scikit-learn API 中了解有关 XGBClassifier 和 XGBRegressor 类的默认值的更多信息。

您可以在 XGBoost 参数页面上了解有关每个参数含义以及如何配置它们的更多信息。

我们现在准备使用训练有素的模型做出预测。

5.使用 XGBoost 模型做出预测

我们可以使用测试数据集上的拟合模型做出预测。

为了做出预测，我们使用 scikit-learn 函数 model.predict（）。

默认情况下，XGBoost 进行的预测是概率。因为这是二分类问题，所以每个预测是输入模式属于第一类的概率。我们可以通过将它们四舍五入为 0 或 1 来轻松地将它们转换为二进制类值。

# make predictions for test data
y_pred = model.predict(X_test)
predictions = [round(value) for value in y_pred]

现在我们已经使用拟合模型对新数据做出预测，我们可以通过将预测值与预期值进行比较来评估预测的表现。为此，我们将在 scikit-learn 中使用内置的 **accuracy_score（）**函数。

# evaluate predictions
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: %.2f%%" % (accuracy * 100.0))

6.将它们捆绑在一起

我们可以将所有这些部分组合在一起，下面是完整的代码清单。

# 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 no 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))

运行此示例将生成以下输出。

Accuracy: 77.95%

对于这个问题，这是一个良好的准确度得分，我们可以期待，考虑到模型的能力和问题的适度复杂性。

摘要

在这篇文章中，您了解了如何在 Python 中开发第一个 XGBoost 模型。

具体来说，你学到了：

• 如何在您的系统上安装 XGBoost 以备 Python 使用。
• 如何在标准机器学习数据集上准备数据并训练您的第一个 XGBoost 模型。
• 如何使用 scikit-learn 做出预测并评估训练有素的 XGBoost 模型的表现。

您对 XGBoost 或该帖子有任何疑问吗？在评论中提出您的问题，我会尽力回答。

如何使用 Python 和 XGBoost 评估梯度提升模型

原文： machinelearningmastery.com/evaluate-gradient-boosting-models-xgboost-python/

开发预测模型的目标是开发一个对看不见的数据准确的模型。

这可以使用统计技术来实现，其中训练数据集被仔细地用于估计模型在新的和未看到的数据上的表现。

在本教程中，您将了解如何使用 Python 中的 XGBoost 评估梯度提升模型的表现。

完成本教程后，您将了解到。

• 如何使用训练和测试数据集评估 XGBoost 模型的表现。
• 如何使用 k-fold 交叉验证评估 XGBoost 模型的表现。

让我们开始吧。

• 2017 年 1 月更新：已更新，以反映 scikit-learn API 版本 0.18.1 中的更改​​。
• 更新 March / 2018 ：添加了备用链接以下载数据集，因为原始图像已被删除。

如何在 Python 中使用 XGBoost 评估梯度提升模型 照片由 Timitrius ，保留一些权利。

使用训练和测试集评估 XGBoost 模型

我们可以用来评估机器学习算法表现的最简单方法是使用不同的训练和测试数据集。

我们可以将原始数据集分成两部分。在第一部分训练算法，然后对第二部分做出预测，并根据预期结果评估预测。

拆分的大小可能取决于数据集的大小和细节，尽管通常使用 67％的数据进行训练，剩余的 33％用于测试。

该算法评估技术很快。它非常适用于大型数据集（数百万条记录），其中有强有力的证据表明数据的两个分裂都代表了潜在的问题。由于速度的原因，当您正在调查的算法训练缓慢时，使用此方法很有用。

这种技术的缺点是它可能具有很大的差异。这意味着训练和测试数据集的差异可能导致模型准确率估计的有意义差异。

我们可以使用 scikit-learn 库中的 **train_test_split（）**函数将数据集拆分为训练和测试集。例如，我们可以将数据集拆分为 67％和 33％的分组，用于训练和测试集，如下所示：

# split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)

下面使用 Pima 印第安人糖尿病数据集开始提供完整的代码清单，假设它位于当前工作目录中（更新：从这里下载）。具有默认配置的 XGBoost 模型适合训练数据集并在测试数据集上进行评估。

# train-test split evaluation of xgboost model
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
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)
# fit model no 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))

运行此示例总结了测试集上模型的表现。

Accuracy: 77.95%

使用 k-fold 交叉验证评估 XGBoost 模型

交叉验证是一种可用于估计机器学习算法表现的方法，其方差小于单个训练测试集拆分。

它的工作原理是将数据集分成 k 部分（例如 k = 5 或 k = 10）。每次分割数据称为折叠。该算法在 k-1 折叠上进行训练，其中一个被扣住并在保持的背部折叠上进行测试。重复这一过程，以便数据集的每个折叠都有机会成为阻碍测试集。

运行交叉验证后，您最终得到 k 个不同的表现分数，您可以使用均值和标准差来总结。

结果是在给定测试数据的情况下，对新数据的算法表现进行更可靠的估计。它更准确，因为算法在不同数据上被多次训练和评估。

k 的选择必须允许每个测试分区的大小足够大以成为问题的合理样本，同时允许对算法的训练测试评估的足够重复以提供对看不见的数据的算法表现的公平估计。 。对于数千或数万个观测值中的适度大小的数据集，k 值为 3,5 和 10 是常见的。

我们可以使用 scikit-learn 中提供的 k-fold 交叉验证支持。首先，我们必须创建 KFold 对象，指定折叠的数量和数据集的大小。然后，我们可以将此方案与特定数据集一起使用。来自 scikit-learn 的 **cross_val_score（）**函数允许我们使用交叉验证方案评估模型，并返回每个折叠上训练的每个模型的分数列表。

kfold = KFold(n_splits=10, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)

下面提供了用于评估具有 k 折交叉验证的 XGBoost 模型的完整代码清单，以确保完整性。

# k-fold cross validation evaluation of xgboost model
from numpy import loadtxt
import xgboost
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# CV model
model = xgboost.XGBClassifier()
kfold = KFold(n_splits=10, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print("Accuracy: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

运行此示例总结了数据集上默认模型配置的表现，包括平均值和标准差分类精度。

Accuracy: 76.69% (7.11%)

如果您有许多类用于分类类型预测性建模问题，或者类是不平衡的（一个类的实例比另一个类多得多），那么在执行交叉验证时创建分层折叠可能是个好主意。

这具有在执行交叉验证评估时在每个折叠中强制执行与在整个训练数据集中相同的类分布的效果。 scikit-learn 库在 StratifiedKFold 类中提供此功能。

下面是修改为使用分层交叉验证来评估 XGBoost 模型的相同示例。

# stratified k-fold cross validation evaluation of xgboost model
from numpy import loadtxt
import xgboost
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import cross_val_score
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# CV model
model = xgboost.XGBClassifier()
kfold = StratifiedKFold(n_splits=10, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print("Accuracy: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

运行此示例将生成以下输出。

Accuracy: 76.95% (5.88%)

什么技术使用时

• 通常，k 折交叉验证是用于评估机器学习算法在看不见的数据上的表现的金标准，其中 k 设置为 3,5 或 10。
• 当存在大量类或每个类的实例不平衡时，使用分层交叉验证来强制执行类分发。
• 使用慢速算法时，使用训练/测试分割有利于提高速度，并在使用大型数据集时产生具有较低偏差的表现估计。

最好的建议是试验并找到一种快速解决问题的技术，并产生可用于制定决策的合理表现估算。

如果有疑问，请对回归问题使用 10 倍交叉验证，并对分类问题进行 10 倍交叉验证。

摘要

在本教程中，您了解了如何通过估计 XGBoost 模型在未见数据上的执行情况来评估它们。

具体来说，你学到了：

• 如何将数据集拆分为训练和测试子集以进行训练和评估模型的表现。
• 如何在数据集的不同子集上创建 k XGBoost 模型并平均得分以获得更稳健的模型表现估计。
• 启发式帮助您在问题中选择训练测试拆分和 k 折交叉验证。

您对如何评估 XGBoost 模型或该帖子的表现有任何疑问吗？在下面的评论中提出您的问题，我会尽力回答。

使用 Python 和 XGBoost 的特征重要性和特征选择

原文： machinelearningmastery.com/feature-importance-and-feature-selection-with-xgboost-in-python/

使用诸如梯度提升之类的决策树方法的集合的好处是它们可以从训练的预测模型自动提供特征重要性的估计。

在本文中，您将了解如何使用 Python 中的 XGBoost 库来估计功能对预测性建模问题的重要性。

阅读这篇文章后你会知道：

• 如何使用梯度提升算法计算特征重要性。
• 如何在 XGBoost 模型计算的 Python 中绘制要素重要性。
• 如何使用 XGBoost 计算的要素重要性来执行要素选择。

让我们开始吧。

• 2017 年 1 月更新：已更新，以反映 scikit-learn API 版本 0.18.1 中的更改​​。
• 更新 March / 2018 ：添加了备用链接以下载数据集，因为原始图像已被删除。

功能重要性和功能选择使用 Python 中的 XGBoost 照片由 Keith Roper ，保留一些权利。

梯度提升中的特征重要性

使用梯度提升的好处是，在构建增强树之后，检索每个属性的重要性分数是相对简单的。

通常，重要性提供分数，该分数指示每个特征在模型内的增强决策树的构造中的有用性或有价值。使用决策树做出关键决策的属性越多，其相对重要性就越高。

对于数据集中的每个属性，明确计算此重要性，允许对属性进行排名并相互比较。

通过每个属性分割点改进表现度量的量来计算单个决策树的重要性，并由节点负责的观察数量加权。表现度量可以是用于选择分裂点的纯度（基尼指数）或另一个更具体的误差函数。

然后，在模型中的所有决策树中对要素重要性进行平均。

有关如何在提升的决策树中计算特征重要性的更多技术信息，请参阅本书统计学习要素：数据挖掘，推理，第 10.53.1 节“_ 预测变量的相对重要性 _”。和预测，第 367 页。

另外，请参阅 Matthew Drury 对 StackOverflow 问题的回答“ Boosting 的相对变量重要性”，他提供了非常详细和实用的答案。

手动绘制功能重要性

经过训练的 XGBoost 模型可自动计算预测性建模问题的特征重要性。

这些重要性分数可在训练模型的 feature_importances_ 成员变量中找到。例如，它们可以直接打印如下：

print(model.feature_importances_)

我们可以直接在条形图上绘制这些分数，以直观地显示数据集中每个要素的相对重要性。例如：

# plot
pyplot.bar(range(len(model.feature_importances_)), model.feature_importances_)
pyplot.show()

我们可以通过在 Pima 印第安人糖尿病数据集上训练 XGBoost 模型并根据计算的特征重要性创建条形图来证明这一点（更新：从这里下载）。

# plot feature importance manually
from numpy import loadtxt
from xgboost import XGBClassifier
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 no training data
model = XGBClassifier()
model.fit(X, y)
# feature importance
print(model.feature_importances_)
# plot
pyplot.bar(range(len(model.feature_importances_)), model.feature_importances_)
pyplot.show()

运行此示例首先输出重要性分数：

[ 0.089701    0.17109634  0.08139535  0.04651163  0.10465116  0.2026578 0.1627907   0.14119601]

我们还得到了相对重要性的条形图。

XGBoost 功能重要性的手动条形图

这个图的缺点是功能按输入索引而不是它们的重要性排序。我们可以在绘图之前对功能进行排序。

值得庆幸的是，有一个内置的绘图功能来帮助我们。

使用内置的 XGBoost 功能重要性图

XGBoost 库提供了一个内置函数来绘制按其重要性排序的特征。

该函数称为 plot_importance（），可以按如下方式使用：

# plot feature importance
plot_importance(model)
pyplot.show()

例如，下面是一个完整的代码清单，使用内置的 **plot_importance（）**函数绘制 Pima Indians 数据集的特征重要性。

# 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 no training data
model = XGBClassifier()
model.fit(X, y)
# plot feature importance
plot_importance(model)
pyplot.show()

运行该示例为我们提供了更有用的条形图。

XGBoost 功能重要性条形图

您可以看到功能是根据它们在 F0 到 F7 的输入数组（X）中的索引自动命名的。

在问题描述中手动将这些指数映射到名称，我们可以看到该图显示 F5（体重指数）具有最高重要性，F3（皮肤折叠厚度）具有最低重要性。

使用 XGBoost 功能重要性分数进行特征选择

特征重要性分数可用于 scikit-learn 中的特征选择。

这是使用 SelectFromModel 类完成的，该类采用模型并可以将数据集转换为具有所选特征的子集。

该课程可以采用预训练的模型，例如在整个训练数据集上训练的模型。然后，它可以使用阈值来决定选择哪些功能。当您在 SelectFromModel 实例上调用 **transform（）**方法以在训练数据集和测试数据集上始终选择相同的特征时，将使用此阈值。

在下面的示例中，我们首先分别训练并评估整个训练数据集和测试数据集上的 XGBoost 模型。

使用从训练数据集计算的要素重要性，然后我们将模型包装在 SelectFromModel 实例中。我们使用它来选择训练数据集上的特征，从所选特征子集训练模型，然后根据相同的特征选择方案评估测试集上的模型。

例如：

# select features using threshold
selection = SelectFromModel(model, threshold=thresh, prefit=True)
select_X_train = selection.transform(X_train)
# train model
selection_model = XGBClassifier()
selection_model.fit(select_X_train, y_train)
# eval model
select_X_test = selection.transform(X_test)
y_pred = selection_model.predict(select_X_test)

为了兴趣，我们可以测试多个阈值，以按功能重要性选择要素。具体而言，每个输入变量的特征重要性，基本上允许我们按重要性测试每个特征子集，从所有特征开始，以具有最重要特征的子集结束。

完整的代码清单如下。

# use feature importance for feature selection
from numpy import loadtxt
from numpy import sort
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.feature_selection import SelectFromModel
# 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
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)
# fit model on all training data
model = XGBClassifier()
model.fit(X_train, y_train)
# make predictions for test data and evaluate
y_pred = model.predict(X_test)
predictions = [round(value) for value in y_pred]
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: %.2f%%" % (accuracy * 100.0))
# Fit model using each importance as a threshold
thresholds = sort(model.feature_importances_)
for thresh in thresholds:
	# select features using threshold
	selection = SelectFromModel(model, threshold=thresh, prefit=True)
	select_X_train = selection.transform(X_train)
	# train model
	selection_model = XGBClassifier()
	selection_model.fit(select_X_train, y_train)
	# eval model
	select_X_test = selection.transform(X_test)
	y_pred = selection_model.predict(select_X_test)
	predictions = [round(value) for value in y_pred]
	accuracy = accuracy_score(y_test, predictions)
	print("Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (thresh, select_X_train.shape[1], accuracy*100.0))

运行此示例将输出以下输出：

Accuracy: 77.95%
Thresh=0.071, n=8, Accuracy: 77.95%
Thresh=0.073, n=7, Accuracy: 76.38%
Thresh=0.084, n=6, Accuracy: 77.56%
Thresh=0.090, n=5, Accuracy: 76.38%
Thresh=0.128, n=4, Accuracy: 76.38%
Thresh=0.160, n=3, Accuracy: 74.80%
Thresh=0.186, n=2, Accuracy: 71.65%
Thresh=0.208, n=1, Accuracy: 63.78%

我们可以看到模型的表现通常随着所选特征的数量而减少。

在这个问题上，需要权衡测试集合精度的特征，我们可以决定采用较不复杂的模型（较少的属性，如 n = 4），并接受估计精度的适度降低，从 77.95％降至 76.38％。

这可能是对这么小的数据集的一种洗涤，但对于更大的数据集并且使用交叉验证作为模型评估方案可能是更有用的策略。

摘要

在这篇文章中，您发现了如何在训练有素的 XGBoost 梯度提升模型中访问特征和使用重要性。

具体来说，你学到了：

• 重要的是什么，一般如何在 XGBoost 中计算。
• 如何从 XGBoost 模型访问和绘制要素重要性分数。
• 如何使用 XGBoost 模型中的要素重要性来选择要素。

您对 XGBoost 或此帖中的功能重要性有任何疑问吗？在评论中提出您的问题，我会尽力回答。

浅谈机器学习的梯度提升算法

原文： machinelearningmastery.com/gentle-introduction-gradient-boosting-algorithm-machine-learning/

梯度提升是构建预测模型的最强大技术之一。

在这篇文章中，您将发现梯度提升机器学习算法，并轻松介绍它的来源和工作原理。

阅读这篇文章后，你会知道：

• 从学习理论和 AdaBoost 推动的起源。
• 梯度提升的工作原理包括损失函数，弱学习器和加法模型。
• 如何通过各种正则化方案提高基本算法的表现

让我们开始吧。

机器学习梯度提升算法的温和介绍 brando.n 的照片，保留一些权利。

提升的起源

提升的想法来自于弱学习器是否可以被修改为变得更好的想法。

Michael Kearns 将目标阐述为“_ 假设推进问题 _”从实际角度阐述了目标：

...一种将相对较差的假设转换为非常好的假设的有效算法

• 关于假设提升的思考 [PDF]，1988

弱假设或弱学习器被定义为其表现至少略好于随机机会的假设。

这些想法建立在 Leslie Valiant 关于免费分发或概率近似正确（PAC）学习的工作之上，这是一个研究机器学习问题复杂性的框架。

假设提升是过滤观察的想法，留下弱学习器可以处理的观察，并专注于开发新的弱学习以处理剩余的困难观察。

我们的想法是多次使用弱学习方法来得到一系列假设，每一个假设都重新聚焦于前面发现的困难和错误分类的例子。 ...但是，请注意，如何做到这一点并不明显

• 大概正确：大自然在复杂世界中学习和繁荣的算法，第 152 页，2013

AdaBoost 第一个提升算法

在应用中取得巨大成功的第一个实现提升的是 Adaptive Boosting 或 AdaBoost 。

提升是指通过组合粗略和中度不准确的经验法则来产生非常准确的预测规则的一般问题。

• 在线学习的决策理论推广及其应用 [PDF]，1995

AdaBoost 中的弱学习器是决策树，只有一个分裂，称为决策树桩的短缺。

AdaBoost 通过对观察结果进行加权，更加重视难以分类的实例，而不是那些已经处理好的实例。新的弱学习器按顺序添加，将他们的训练集中在更难的模式上。

这意味着难以分类的样本会获得越来越大的权重，直到算法识别出正确分类这些样本的模型

• Applied Predictive Modeling ，2013

通过对弱学习器预测的多数投票做出预测，并根据他们的个人准确率进行加权。 AdaBoost 算法最成功的形式是二进制分类问题，称为 AdaBoost.M1。

您可以在帖子中了解有关 AdaBoost 算法的更多信息：

• Boosting 和 AdaBoost 机器学习。

AdaBoost 作为梯度提升的推广

AdaBoost 和相关算法首先由 Breiman 称之为 ARCing 算法的统计框架重铸。

Arcing 是 Adaptive Reweighting and Combining 的首字母缩写。电弧放电算法中的每个步骤都包括加权最小化，然后重新计算[分类器]和[加权输入]。

• 预测游戏和拱形算法 [PDF]，1997

这个框架由 Friedman 进一步开发，称为 Gradient Boosting Machines。后来称为梯度提升或梯度树增强。

统计框架将推进作为一个数值优化问题，其目标是通过使用梯度下降类似过程添加弱学习器来最小化模型的损失。

这类算法被描述为阶段性加法模型。这是因为一次添加一个新的弱学习器，并且模型中现有的弱学习器被冻结并保持不变。

请注意，此阶段策略与逐步方法不同，后者在添加新的时重缩放先前输入的术语。

• 贪婪函数逼近：梯度增压机 [PDF]，1999

泛化允许使用任意可微分损失函数，将技术扩展到二分类问题之外，以支持回归，多分类等。

梯度提升的工作原理

梯度提升涉及三个要素：

1. 要优化的损失函数。
2. 做出预测的弱学习器。
3. 添加模型，添加弱学习器以最小化损失函数。

1.损失功能

使用的损失函数取决于要解决的问题类型。

它必须是可区分的，但支持许多标准丢失函数，您可以定义自己的函数。

例如，回归可能使用平方误差，分类可能使用对数损失。

梯度提升框架的一个好处是不必为可能想要使用的每个损失函数导出新的增强算法，相反，它是足够通用的框架，可以使用任何可微分损失函数。

2.弱小的学习器

决策树被用作梯度提升中的弱学习器。

特别是使用回归树，其输出分裂的实际值并且其输出可以被加在一起，允许添加后续模型输出并“校正”预测中的残差。

树木以贪婪的方式构建，根据基尼等纯度分数选择最佳分割点，或尽量减少损失。

最初，例如在 AdaBoost 的情况下，使用非常短的决策树，其仅具有单个分割，称为决策残余。较大的树木通常可以使用 4 到 8 级。

通常以特定方式约束弱学习器，例如最大层数，节点，分裂或叶节点。

这是为了确保学习器保持弱势，但仍然可以贪婪地构建。

3.添加剂模型

树一次添加一个树，模型中的现有树不会更改。

梯度下降程序用于最小化添加树木时的损失。

传统上，梯度下降用于最小化一组参数，例如回归方程中的系数或神经网络中的权重。在计算错误或丢失之后，更新权重以最小化该错误。

我们有弱学习器子模型或更具体的决策树，而不是参数。在计算损失之后，为了执行梯度下降过程，我们必须向模型添加树以减少损失（即遵循梯度）。我们通过参数化树来完成此操作，然后修改树的参数并向右移动（减少剩余损失。

通常，这种方法称为功能梯度下降或具有功能的梯度下降。

产生优化[成本]的分类器的加权组合的一种方法是通过函数空间中的梯度下降

• 在函数空间中提升算法作为梯度下降 [PDF]，1999

然后将新树的输出添加到现有树序列的输出中，以便纠正或改进模型的最终输出。

一旦损失达到可接受的水平或在外部验证数据集上不再改进，则添加固定数量的树或训练停止。

基本梯度提升的改进

梯度提升是一种贪婪算法，可以快速过度训练数据集。

它可以受益于惩罚算法的各个部分的正则化方法，并且通常通过减少过拟合来改善算法的表现。

在本节中，我们将介绍基本梯度提升的 4 个增强功能：

1. 树约束
2. 收缩
3. 随机采样
4. 惩罚学习

1.树约束

重要的是弱势学习器有技巧但仍然很弱。

树可以通过多种方式进行约束。

一个好的通用启发式方法是，树的创建越多，模型中需要的树就越多，反之，在不受约束的单个树中，所需的树就越少。

以下是可以对决策树构造施加的一些约束：

• 树木数量，通常会为模型添加更多树木，过拟合可能会非常缓慢。建议继续添加树木，直至观察不到进一步的改善。
• 树深，更深的树木更复杂的树木和更短的树木是首选。通常，4-8 级可以看到更好的结果。
• 节点数或叶数，如深度，这可以约束树的大小，但如果使用其他约束，则不限于对称结构。
• 每次分割的观察次数对训练节点的训练数据量施加最小约束，然后才能考虑分割
• 最小化损失是对添加到树中的任何拆分的改进的约束。

2.加权更新

每棵树的预测按顺序加在一起。

可以对每个树对该总和的贡献进行加权以减慢算法的学习。这种加权称为收缩或学习率。

每个更新只是通过“学习速率参数 v”的值进行缩放

— Greedy Function Approximation: A Gradient Boosting Machine [PDF], 1999

结果是学习速度变慢，反过来需要将更多树木添加到模型中，反过来需要更长的时间来训练，提供树木数量和学习率之间的配置权衡。

减小 v [学习率]的值会增加 M [树的数量]的最佳值。

— Greedy Function Approximation: A Gradient Boosting Machine [PDF], 1999

通常具有 0.1 至 0.3 范围内的小值，以及小于 0.1 的值。

与随机优化中的学习速率类似，收缩减少了每棵树的影响，并为将来的树木留出了空间来改进模型。

• 随机梯度提升 [PDF]，1999

3.随机梯度提升

对装袋合奏和随机森林的深入了解允许从训练数据集的子样本中贪婪地创建树。

可以使用相同的益处来减少梯度提升模型中序列中的树之间的相关性。

这种增强的变化称为随机梯度提升。

在每次迭代中，从完整训练数据集中随机（无替换）绘制训练数据的子样本。然后使用随机选择的子样本而不是完整样本来适合基础学习器。

— Stochastic Gradient Boosting [PDF], 1999

可以使用的一些随机增压变体：

• 在创建每个树之前的子样本行。
• 创建每个树之前的子样本列
• 在考虑每个拆分之前的子采样列。

通常，积极的子采样（例如仅选择 50％的数据）已被证明是有益的。

根据用户反馈，使用列子采样可以比传统的行子采样更加防止过拟合

• XGBoost：可扩展的树升压系统，2016

4. Penalized Gradient Boosting

除了它们的结构之外，还可以对参数化树施加附加约束。

像 CART 这样的经典决策树不被用作弱学习器，而是使用称为回归树的修改形式，其在叶节点（也称为终端节点）中具有数值。在一些文献中，树叶中的值可以称为权重。

因此，可以使用流行的正则化函数来规范树的叶权值，例如：

• L1 权重的正则化。
• 权重的 L2 正则化。

额外的正则化项有助于平滑最终学习的权重以避免过拟合。直观地，正则化目标将倾向于选择采用简单和预测函数的模型。

— XGBoost: A Scalable Tree Boosting System, 2016

梯度提升资源

梯度提升是一种迷人的算法，我相信你想要更深入。

本节列出了可用于了解梯度提升算法的更多信息。

梯度提升视频

• Gradient Boosting Machine Learning ，Trevor Hastie，2014
• Gradient Boosting ，Alexander Ihler，2012
• GBM ，John Mount，2015 年
• 学习：提升，麻省理工学院 6.034 人工智能，2010
• xgboost：用于快速准确梯度提升的 R 包，2016
• XGBoost：可扩展的树木升压系统，陈天琪，2016

教科书中的梯度提升

• 第 8.2.3 节 Boosting，第 321 页，统计学习简介：在 R 中的应用。
• 第 8.6 节 Boosting，第 203 页，应用预测性建模。
• 第 14.5 节“随机梯度提升”，第 390 页，应用预测性建模。
• 第 16.4 节 Boosting，第 556 页，机器学习：概率视角
• 第十章 Boosting 和 Additive 树，第 337 页，统计学习的要素：数据挖掘，推理和预测

Gradient Boosting Papers

• 关于假设提升的思考 [PDF]，Michael Kearns，1988
• 在线学习的决策理论推广及其应用 [PDF]，1995
• 弧形边缘 [PDF]，1998
• 随机梯度提升 [PDF]，1999
• 在函数空间中提升算法作为梯度下降 [PDF]，1999

梯度提升幻灯片

• Boosted Trees 简介，2014
• 一个温和的梯度提升介绍，程力

梯度提升网页

• 提升（机器学习）
• 梯度提升
• 在 scikit-learn 中提升梯度树

摘要

在这篇文章中，您发现了用于机器学习中预测性建模的梯度提升算法。

具体来说，你学到了：

• 提升学习理论和 AdaBoost 的历史。
• 梯度提升算法如何与损失函数，弱学习器和附加模型一起工作。
• 如何通过正则化提高梯度提升的表现。

您对梯度提升算法或此帖有任何疑问吗？在评论中提出您的问题，我会尽力回答。

应用机器学习的杀器：XGBoost 温和简介

原文： machinelearningmastery.com/gentle-introduction-xgboost-applied-machine-learning/

XGBoost 是一种算法库，近年来在应用机器学习和 Kaggle 竞赛中占据统治地位，它专长于处理结构化数据或表格数据。

XGBoost 是为速度和表现而设计的一种梯度提升决策树方法。

在这篇文章中，您将轻松了解 XGBoost 的入门信息，并知晓它究竟是什么，源自何处，以及如何学习它的更多信息。

阅读之后您会学习到：

• 什么是 XGBoost 以及本项目所达成的目标。
• 为什么 XGBoost 必须与您现有的机器学习工具包作区分。
• 在您的下一个机器学习项目中，您可以从哪里获取使用 XGBoost 的更多信息。

让我们开始吧。

应用机器学习的杀器： XGBoost 简介。照片由 Sigfrid Lundberg 拍摄，保留部分权利。

什么是 XGBoost？

XGBoost 的名字源自 e X treme G radient B oosting （极限梯度提升）。

其实 xgboost 实际上是在致力于将提升树算法对计算资源的利用推至工程极限。这也是为什么有许多人会使用 xgboost 的原因。

• Tianqi Chen（陈天奇）对 Quora 问题“ R gbm（梯度提升机）和 xgboost（极限梯度提升）有什么区别？ “的回答。

它是 Tianqi Chen 创建的一种梯度提升机实现，现在有许多开发人员在为这个项目做贡献。它属于分布式机器学习社区（DMLC） 宽泛范畴中的一种工具。Chen 同时也是流行的 mxnet 深度学习库创建者。

Tianqi Chen 在 XGBoost 的背后故事与经验中提供了关于 XGBoost 演进的简短而有趣的背景故事。

XGBoost 定义了一个软件库，您可以在您的电脑上下载和安装，有多种接口方式可以调用。具体来说，XGBoost 支持以下主要接口：

• 命令行界面（CLI）。
• C++（编写 XGBoost 库的语言）。
• Python 界面以及作为 scikit-learn 的一个模型。
• R 接口以及作为 caret 包中的模型。
• Julia。
• Java 和 JVM 语言，例如 Scala，以及像 Hadoop 这样的平台。

XGBoost 的特点

XGBoost 库高度专注于计算速度和模型表现，因此几乎没有冗余功能。不过它仍然提供了许多高级功能。

模型的特点

XGBoost 模型支持 scikit-learn 和 R 的实现，并且新增了正则化等功能。它支持三种主要的梯度提升形式：

• Gradient Boosting 算法，也称为具有学习率的梯度提升机。
• 对行、列以及分割列进行子采样的随机梯度提升。
• L1 和 L2 正则化的正则化梯度提升。

系统的特点

XGBoost 库提供了丰富的计算环境，包括而不限于：

• 在训练期间使用所有 CPU 内核并行化的进行树构建。
• 分布式计算可在一组计算机集群上训练超大型模型。
• **核外计算（Out-Of-Core）（外扩存储计算）**适用于无法装载入内存的超大型数据集。
• 数据结构的缓存优化以及充分利用硬件的算法。

算法的特点

算法的实现致力于提高计算时间和内存资源的使用效率。设计目标就是充分利用可用资源来训练模型。一些关键的算法实现特点包括：

• 具有自动处理缺失数据值的稀疏感知能力。
• 具有支持树构建并行化的块结构。
• 具有继续训练能力，以便您可以进一步根据新数据提升已经训练过的模型。

XGBoost 是免费的开源软件，可在 Apache-2 许可范围使用。

为什么要使用 XGBoost？

使用 XGBoost 的两个原因也是本项目的两个目标：

1. 执行速度。
2. 模型表现。

1. XGBoost 执行速度

通常，XGBoost 相当快速。与梯度提升的其他实现方法相比，真的很快。

Szilard Pafka 进行了一些客观的基准测试，比较了 XGBoost 与其它梯度提升实现方法以及 bagged 决策树方法。他在 2015 年 5 月的博客文章“随机森林方法的基准测试”中展示了他的结果。

他同时在 GitHub 上提供了所有代码以及附有更多硬核数字的拓展报告。

XGBoost 的基准表现，引自随机森林方法的基准测试。

他的结果表明 XGBoost 在 R、Python、Spark 和 H2O 的实现几乎总是比其它基准测试的实现方法更快。

在他的实验中，他评论说：

我也比较了 xgboost，它是一个可以构建随机森林的流行提升库。它速度快、内存使用效率高，同时具有高精度。

• Szilard Pafka，可以构建随机森林。

2. XGBoost 的模型表现

XGBoost 在分类和回归预测性建模问题上对于有着结构化或表格化形式的数据集占据着统治地位。

有证据表明，它是 Kaggle 数据科学平台竞赛获胜者的首选算法。

这里给出一个不完整的第一、第二和第三名竞赛获胜者名单，标题取名为： XGBoost：机器学习挑战赛获胜解决方案。

为了使这一点更加具象，下面是来自 Kaggle 比赛获胜者的一些有启示的见解：

作为 Kaggle 比赛的赢家，并且仍在增长获胜数字，XGBoost 再次向我们展示了它是一个值得留在您工具箱中的全面算法。

• Dato 获奖者访谈：第 1 名 Mad Professors

如果感到困惑，不知道作何选择，请使用 xgboost。

• Avito 获奖者访谈：第 1 名，Owen Zhang

我喜欢让单一模特表现的更好，而我最好的单一模特是 XGBoost，它可以自己获得第 10 名。

• Caterpillar 获奖者访谈：第 1 名

我只用过 XGBoost。

• Liberty Mutual Property Inspection，获奖者访谈：第 1 名，Qingchen Wang

我唯一用过的有监督学习方法是梯度提升，通过优秀的 xgboost 实现。

• Recruit Coupon Purchase 获奖者访谈：第 2 名，Halla Yang

XGBoost 使用什么算法？

XGBoost 库执行梯度提升决策树算法。

该算法有许多不同的名称，例如梯度提升（gradient boosting），多重加性回归树（multiple additive regression trees），随机梯度提升（stochastic gradient boosting）或梯度提升机（gradient boosting machines）。

提升是一种调和技术（ensemble technique），它可以添加新模型以纠正现有模型所产生的误差。在这个过程中，模型会被逐步添加，直到不能再进一步改进。一个流行的例子是 AdaBoost 算法，它对很难预测的数据点进行加权。

梯度提升是一种方法，其中创建新模型以预测先前模型的残差或误差，然后将其加在一起以进行最终预测。它被称为梯度提升，因为它使用梯度下降算法来最小化添加新模型时的损失。

这种方法支持回归和分类预测性建模问题。

关于提升和梯度提升的更多信息，请参阅 Trevor Hastie 关于梯度提升机器学习的演讲。

<iframe allowfullscreen="" frameborder="0" height="281" src="www.youtube.com/embed/wPqtz…" width="500"></iframe>

官方 XGBoost 资源

关于 XGBoost 的最佳信息来源是项目的官方 GitHub 仓库。

从那里，您可以访问议题追踪（Issue Tracker）以及用户组（User Group），它们可用于提问和报告 bug。

Awesome XGBoost 页面是一个很好的资源库，配有示例代码和帮助信息。

此外还有一个官方文档页面，其中包含一系列不同语言的入门指南，教程，操作向导等。

关于 XGBoost 有许多更正式的论文值得阅读，可以从中获取更多关于这个库的使用背景：

• Higgs Boson Discovery with Boosted Trees ，2014。
• XGBoost：A Scalable Tree Boosting System，2016。

XGBoost 的演讲

当开始使用像 XGBoost 这样的新工具时，在深入研究代码之前，先回顾一下有关该主题的一些演讲会很有帮助。

XGBoost：A Scalable Tree Boosting System

XGBoost 库的创建者 Tianqi Chen 2016 年 6 月在洛杉矶 Data Science Group 进行了一次题为“ XGBoost：A Scalable Tree Boosting System”的演讲。

<iframe allowfullscreen="" frameborder="0" height="281" src="www.youtube.com/embed/Vly8x…" width="500"></iframe>

您可以在此处读到他演讲中的幻灯片：

<iframe allowfullscreen="true" allowtransparency="true" frameborder="0" height="345" id="talk_frame_345261" mozallowfullscreen="true" src="//speakerdeck.com/player/5c6dab45648344208185d2b1ab4fdc95" style="border:0; padding:0; margin:0; background:transparent;" webkitallowfullscreen="true" width="500"></iframe>

在 DataScience LA blog可以找到更多信息。

XGBoost：eXtreme Gradient Boosting

2015 年 12 月一位 XGBoost 的 R 语言接口贡献者在纽约 Data Science Academy 发表了题为“ XGBoost: eXtreme Gradient Boosting”的演讲。

<iframe allowfullscreen="" frameborder="0" height="281" src="www.youtube.com/embed/ufHo8…" width="500"></iframe>

您也可以在此处读到他演讲中的幻灯片：

<iframe allowfullscreen="" frameborder="0" height="356" marginheight="0" marginwidth="0" scrolling="no" src="www.slideshare.net/slideshow/e…" style="border:1px solid #CCC; border-width:1px; margin-bottom:5px; max-width: 100%;" width="427"></iframe>

Xgboost from Vivian Shangxuan Zhang

有关此次演讲的更多信息，请访问NYC Data Science Academy blog。

安装 XGBoost

在XGBoost 文档网站上有综合的安装指南。

它涵盖了 Linux，Mac OS X 和 Windows 的安装指南。

它也包括了在 R 和 Python 等平台上的安装向导。

R 中的 XGBoost

如果您是 R 语言用户，最好的入门位置是 xgboost 包的 CRAN 页面。

在此页面中，您可以访问 R vignette Package'xgboost' （pdf）。

此页面还链接了一些优秀的 R 教程，以帮助您入门：

• [Discover your data]](cran.r-project.org/web/package…)
• XGBoost Presentation
• xgboost：eXtreme Gradient Boosting (pdf)

还有官方的 XGBoost R Tutorial和Understand your dataset with XGBoost 。

Python 中的 XGBoost

安装说明可在 XGBoost 安装指南的 Python section of the XGBoost installation guide部分找到。

官方 Python 包简介是在 Python 中使用 XGBoost 最好的起步位置。

若想要快速使用，您可以输入：

sudo pip install xgboost

在 XGBoost Python Feature Walkthrough中，有一个很好的 Python 范例源代码列表。

总结

在本文中，您了解了应用机器学习的 XGBoost 方法。

您学到了：

• XGBoost 是一个用于开发快速和高表现梯度提升树模型的库。
• XGBoost 目前在一系列困难的机器学习任务中都达到最佳表现。
• 可以在命令行，Python 和 R 中使用这个库，以及如何开始使用。

你用过 XGBoost 吗？请在下面的评论中分享您的经验。

您对 XGBoost 或这篇文章有任何疑问吗？请在下面的评论中提出您的问题，我会尽力回答。

应用机器学习中 XGBoost 的温和介绍

原文：machinelearningmastery.com/gentle-intr…

最后更新于 2021 年 2 月 17 日

XGBoost 是一种算法，最近在结构化或表格数据的应用机器学习和 Kaggle 竞赛中占据主导地位。

XGBoost 是梯度增强决策树的实现，旨在提高速度和表现。

在这篇文章中，你将发现 XGBoost，并得到一个温和的介绍，它是什么，它来自哪里，以及你如何可以了解更多。

看完这篇文章你会知道:

• XGBoost 是什么，项目的目标是什么。
• 为什么 XGBoost 必须是你的机器学习工具包的一部分。
• 在下一个机器学习项目中，您可以了解更多关于开始使用 XGBoost 的信息。

用我的新书 XGBoost With Python 启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

• 2021 年 2 月更新:修复断链。

应用机器学习 XGBoost 简介 图片由西格弗里德·伦德伯格提供，版权所有。

什么是 XGBoost？

XGBoost 代表 eXtremeGradientBoost。

然而，xgboost 这个名字实际上指的是工程目标，即提升树算法的计算资源极限。这也是很多人使用 xgboost 的原因。

—陈天琪在回答问题“R GBM(梯度助推机)和 xgboost(极限梯度助推)有什么区别？“在 Quora 上

是陈天棋创造的梯度助推机的实现，现在有很多开发者贡献。它属于分布式机器学习社区或 DMLC 旗下更广泛的工具集合，这些人也是流行的 mxnet 深度学习库的创建者。

陈天琪在帖子中提供了一个关于 XGBoost 创作的简短有趣的背景故事，以及 XGBoost 演变背后的故事和教训。

XGBoost 是一个软件库，你可以下载并安装在你的机器上，然后从各种界面访问。具体来说，XGBoost 支持以下主要接口:

• 命令行界面。
• C++(编写库的语言)。
• Python 接口以及 Sklearn 中的一个模型。
• 接口以及插入符号包中的模型。
• 朱莉娅。
• 像 Scala 这样的 Java 和 JVM 语言以及 Hadoop 这样的平台。

XGBoost 功能

该库专注于计算速度和模型表现，因此几乎没有多余的东西。然而，它确实提供了许多高级功能。

模型特征

该模型的实现支持 Sklearn 和 R 实现的特性，并增加了正则化等新功能。支持三种主要形式的梯度增强:

• 梯度提升算法也叫梯度提升机包括学习率。
• 随机梯度增强，在行、列和列各级进行子采样。
• L1 和 L2 正则化的正则化梯度增强。

系统功能

该库提供了一个在一系列计算环境中使用的系统，尤其是:

• 并行化在训练过程中使用你所有的 CPU 核心进行树的构建。
• 分布式计算使用一组机器训练非常大的模型。
• 核外计算用于不适合内存的非常大的数据集。
• 数据结构和算法的缓存优化以充分利用硬件。

算法特征

算法的实现是为了计算时间和内存资源的效率而设计的。设计目标是充分利用现有资源来训练模型。一些关键的算法实现特性包括:

• 稀疏感知实现，自动处理丢失的数据值。
• 块结构支持树构造的并行化。
• 继续训练，这样你就可以在新的数据上进一步提升已经拟合好的模型。

XGBoost 是自由开源软件，可在许可的 Apache-2 许可证下使用。

为什么要使用 XGBoost？

使用 XGBoost 的两个原因也是项目的两个目标:

1. 执行速度。
2. 模型表现。

1.XGBoost 执行速度

一般来说，XGBoost 速度很快。与其他梯度增强实现相比，速度非常快。

Szilard Pafka 执行了一些客观的基准测试，将 XGBoost 的表现与梯度提升和袋装决策树的其他实现进行了比较。2015 年 5 月，他在名为“基准随机森林实施”的博客中写下了自己的结果。

他还在 GitHub 上提供了所有的代码，以及一份更广泛的硬数字结果报告。

XGBoost 的基准表现，取自基准随机森林实现。

他的结果显示，XGBoost 几乎总是比来自 R、Python Spark 和 H2O 的其他基准实现更快。

从他的实验中，他评论道:

我还尝试了 xgboost，这是一个流行的增强库，它也能构建随机森林。它速度快，内存效率高，精确率高

— Szilard Pafka，基准测试随机森林实现。

2.XGBoost 模型表现

XGBoost 在分类和回归预测建模问题上主导结构化或表格数据集。

证据是，它是 Kaggle 竞争数据科学平台上竞争赢家的 go-to 算法。

例如，有一个不完整的第一名、第二名和第三名竞赛获胜者列表，使用了标题为: XGBoost:机器学习挑战获胜解决方案。

为了使这一点更加具体，以下是来自卡格尔竞赛获胜者的一些有见地的名言:

作为越来越多 Kaggle 竞赛的获胜者，XGBoost 再次向我们展示了它是一个非常棒的全能算法，值得放在你的工具箱里。

——达图获奖者面试:第一名，疯狂教授

有疑问时，使用 xgboost。

——阿维托冠军访谈:第一名，欧文·张

我喜欢表现出色的单曲，我最好的单曲是一首可以自己获得第十名的 XGBoost。

——卡特彼勒获奖者面试:第一名

我只用了 XGBoost。

——自由互助物业检查，优胜面试:第一名，王

我使用的唯一一种监督学习方法是梯度增强，它是在优秀的 xgboost 包中实现的。

——招募优惠券购买赢家面试:第二名，哈拉杨

XGBoost 使用什么算法？

XGBoost 库实现了梯度提升决策树算法。

该算法有许多不同的名称，如梯度增强、多重加性回归树、随机梯度增强或梯度增强机器。

增强是一种集成技术，通过添加新模型来纠正现有模型产生的错误。模型按顺序添加，直到无法进一步改进。一个流行的例子是 AdaBoost 算法，它对难以预测的数据点进行加权。

梯度增强是一种创建新模型的方法，新模型预测先前模型的残差或误差，然后加在一起进行最终预测。之所以称之为梯度提升，是因为它使用梯度下降算法，在添加新模型时将损失降至最低。

这种方法支持回归和分类预测建模问题。

关于增强和梯度增强的更多信息，请参见特雷弗·哈斯蒂在梯度增强机器学习上的演讲。

<iframe title="Trevor Hastie - Gradient Boosting Machine Learning" width="500" height="281" src="https://www.youtube.com/embed/wPqtzj5VZus?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""/></div> <p/> <h2>官方 XGBoost 资源</h2> <p>XGBoost 上最好的信息来源是项目的<a href="https://github.com/dmlc/xgboost">官方 GitHub 资源库。</a></p> <p>从那里您可以访问<a href="https://github.com/dmlc/xgboost/issues">问题跟踪器</a>和<a href="https://groups.google.com/forum/#!forum/xgboost-user/">用户组</a>，它们可用于提问和报告错误。</p> <p>示例代码和帮助的一个很好的链接来源是<a href="https://github.com/dmlc/xgboost/tree/master/demo">超赞的 XGBoost 页面</a>。</p> <p>还有一个<a href="https://xgboost.readthedocs.io/en/latest/">官方文档页面</a>，包括一系列不同语言的入门指南、教程、操作指南等。</p> <p>关于 XGBoost，有一些更正式的论文值得一读，了解更多关于图书馆的背景知识:</p> <ul> <li><a href="http://jmlr.org/proceedings/papers/v42/chen14.pdf">希格斯玻色子发现与助推树</a>，2014。</li> <li><a href="https://arxiv.org/abs/1603.02754"> XGBoost:一个可扩展的树木助推系统</a>，2016。</li> </ul> <h2>关于 XGBoost 的讨论</h2> <p>当开始使用像 XGBoost 这样的新工具时，在深入研究代码之前，回顾一些关于这个主题的讨论可能会有所帮助。</p> <h3>XGBoost:一个可扩展的树增强系统</h3> <p>2016 年 6 月，该库的创建者陈天琦在 LA 数据科学组做了一个题为“<a href="https://www.youtube.com/watch?v=Vly8xGnNiWs"> XGBoost:一个可扩展的树提升系统</a>”的演讲。</p> <p><span class="oxjLm3csmGtLYMueaTVM1TfANv098rsN1SJCFZnDPC5AridHhop7kQ0RJ5QluwIz"/></p> <div class="responsive-video"><iframe loading="lazy" title="XGBoost A Scalable Tree Boosting System June 02, 2016" width="500" height="281" src="about:blank" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" data-rocket-lazyload="fitvidscompatible" data-lazy-src="https://www.youtube.com/embed/Vly8xGnNiWs?feature=oembed"/><iframe title="XGBoost A Scalable Tree Boosting System June 02, 2016" width="500" height="281" src="https://www.youtube.com/embed/Vly8xGnNiWs?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""/></div> <p/> <p>您可以在此查看他演讲中的幻灯片:</p> <p><span class="XOG1LQfhP4ateMCAUcJqSmn6jYy5oBlpgu3vbHRZszN2xVdkwWE70T"> <iframe loading="lazy" title="Tianqi Chen - XGBoost: Overview and Latest News - LA Meetup Talk" id="talk_frame_345261" src="about:blank" width="500" height="281" style="border:0; padding:0; margin:0; background:transparent;" frameborder="0" allowtransparency="true" allowfullscreen="allowfullscreen" mozallowfullscreen="true" webkitallowfullscreen="true" data-rocket-lazyload="fitvidscompatible" data-lazy-src="//speakerdeck.com/player/5c6dab45648344208185d2b1ab4fdc95"/> <iframe title="Tianqi Chen - XGBoost: Overview and Latest News - LA Meetup Talk" id="talk_frame_345261" src="//speakerdeck.com/player/5c6dab45648344208185d2b1ab4fdc95" width="500" height="281" style="border:0; padding:0; margin:0; background:transparent;" frameborder="0" allowtransparency="true" allowfullscreen="allowfullscreen" mozallowfullscreen="true" webkitallowfullscreen="true"/> </span></p> <p><a href="http://datascience.la/xgboost-workshop-and-meetup-talk-with-tianqi-chen/">数据科学 LA 博客</a>上有更多信息。</p> <h3>极限梯度增强</h3> <p>2015 年 12 月，XGBoost R 接口投稿人佟鹤在纽约数据科学学院做了一个演讲，题目是“<a href="https://www.youtube.com/watch?v=ufHo8vbk6g4">XGBoost:eXtreme Gradient Boosting</a>”。</p> <p><span class="0otMhAYytO6ImyrZijBW2vDZHieYsJAF5O023IeLg3x6EwPzch7axuNvgSTN1nCj"/></p> <div class="responsive-video"><iframe loading="lazy" title="Kaggle Winning Solution Xgboost Algorithm - Learn from Its Author, Tong He" width="500" height="281" src="about:blank" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" data-rocket-lazyload="fitvidscompatible" data-lazy-src="https://www.youtube.com/embed/ufHo8vbk6g4?feature=oembed"/><iframe title="Kaggle Winning Solution Xgboost Algorithm - Learn from Its Author, Tong He" width="500" height="281" src="https://www.youtube.com/embed/ufHo8vbk6g4?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""/></div> <p/> <p>您可以在此查看他演讲中的幻灯片:</p> <p><span class="5Ex7hGdwrn4OBL6pmKvPZ0lH3Wz2Q9NIbfDAcyYjkSqXstCgJVUe1uFToaMiR"> <iframe loading="lazy" title="Xgboost" src="about:blank" width="427" height="356" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" style="border:1px solid #CCC; border-width:1px; margin-bottom:5px; max-width: 100%;" allowfullscreen="" data-rocket-lazyload="fitvidscompatible" data-lazy-src="https://www.slideshare.net/slideshow/embed_code/key/lhcV8LfZ8RfrG">**[Xgboost](https://www.slideshare.net/ShangxuanZhang/xgboost-55872323 "Xgboost")** from **[Vivian S. Zhang](https://www.slideshare.net/ShangxuanZhang)**

在纽约数据科学院博客上有更多关于这个演讲的信息。

安装 XGBoost

xboost 文档网站上有全面的安装指南。

它涵盖了 Linux、Mac OS X 和 Windows 的安装。

它还涵盖了在诸如 R 和 Python 等平台上的安装。

R 中的 XGBoost

如果你是 R 用户，最好的入门网站是 xgboost 包的 CRAN 页面。

从该页面，您可以访问 R 晕映包【Xgboost】【pdf】。

本页还链接了一些优秀的 R 教程，帮助您入门:

• 发现自己的数据
• xboost 演示
• xboost:eXtreme Gradient Boosting【pdf】

还有官方的 XGBoost R 教程和用 XGBoost 了解你的数据集教程。

Python 中的 XGBoost

安装说明可在 XGBoost 安装指南的 Python 部分获得。

官方 Python 包介绍是在 Python 中使用 XGBoost 时最好的入手点。

要快速开始，您可以键入:

sudo pip install xgboost

在 XGBoost Python 特性演练上也有一个 Python 示例源代码的优秀列表。

摘要

在这篇文章中，你发现了应用机器学习的 XGBoost 算法。

你学会了:

• XGBoost 是一个用于开发快速和高表现梯度提升树模型的库。
• XGBoost 在一系列困难的机器学习任务中取得了最佳表现。
• 你可以从命令行使用这个库，Python 和 R 以及如何开始。

你用过 XGBoost 吗？在下面的评论中分享你的经历。

你对 XGBoost 或者这个帖子有什么疑问吗？在下面的评论中提出你的问题，我会尽力回答。