XGBoost 分类模型优化：超参数调优与性能提升的协同攻略

devtools/2025/1/8 0:52:26/

XGBoost 分类模型优化：超参数调优与性能提升的协同攻略

🧾 1. 极端梯度提升（XGBoost）

XGBoost是一个开源软件库，它为C++、Java、Python、R、Julia、Perl和Scala提供了一个正则化的梯度提升框架，它适用于Linux、Windows和macOS，从项目描述来看，它旨在提供一个"可扩展、可移植和分布式的梯度提升库"。

极端梯度提升算法.梯度提升是指一类集成机器学习算法，可用于分类或回归预测建模问题.集成由决策树模型构建。

XGBoost是一种更正则化的梯度提升形式。XGBoost使用高级正则化（L1和L2），这提高了模型泛化能力。与梯度提升相比，XGBoost提供了高性能。它的训练非常快，可以跨集群并行化。

Extreme Gadient Boosted（xgboost）类似于梯度提升框架，但更高效。它同时具有线性模型求解器和树学习算法。因此，它的快速之处在于它能够在单台机器上进行并行计算……

超参数介绍

🛠 2. 超参数

超参数调整是什么意思？

在机器学习中，超参数优化或调整是为学习算法选择一组最佳超参数的问题。超参数是一个参数，其值用于控制学习过程。相比之下，其他参数（通常是节点权重）的值被学习。超参数调整过程是走钢丝，以实现欠拟合和过拟合之间的平衡。欠拟合是指机器学习模型无法减少测试或训练集的误差。

什么是超参数调整示例？

模型超参数的一些例子包括：逻辑回归分类器中的惩罚，即L1或L2正则化。训练神经网络的学习率。支持向量机的C和sigma超参数。

为什么我们使用超参数调优？

超参数调整是控制机器学习模型行为的重要组成部分。如果我们不正确调整超参数，我们估计的模型参数会产生次优结果，因为它们不会最小化损失函数。这意味着我们的模型会犯更多的错误。

XGBoost参数-分类

⌛️ 3. 用于分类的XGBoost超参数

XGBoost Boosters

-> gbtree :
  • gbtree 用于 tree-based models;
-> gblinear :
  • gblinear 用于 linear models 在每次迭代时运行。
-> dart :
  • dart 也是一个基于树的模型。
  • XGBoost主要结合了大量的回归树和较小的学习率。在这种情况下，早期添加的树很重要，后期添加的树不重要。Vinayak和Gilad-Bachrach提出了一种新方法，将来自深度神经网络社区的dropout技术添加到增强树中，并在某些情况下报告了更好的结果——它被称为dart。它会丢弃树以解决过度拟合。可以防止琐碎的树（纠正微不足道的错误）。由于训练中引入的随机性，预计以下几个差异：训练可能比gbtree慢，因为随机丢弃会阻止预测缓冲区的使用。由于随机性，早期停止可能不稳定。

一般参数

它与我们使用哪种booster进行boost有关，通常是树模型或线性模型

1. booster [default（默认）=gbtree]
  • gbtree用于tree-based models；gblinear用于linear models在每次迭代时运行。
2. silent [default=0]:
  • 要激活静音静音模式，请将其设置为1，即关闭；因此，不会打印任何消息。

通常是个好主意，将其保持为0，因为消息可能有助于理解模型；以及指标的进展情况。

3. nthread [如果未设置，则默认为最大可用线程数]

这用于并行处理，应输入系统中的内核数
；如果您希望在所有内核上运行，则不应输入值，算法将自动检测

Booster参数

取决于您选择的助推器。我们将在这里讨论基于树的助推器。

1. eta [default=0.3]
  • 类似于learning_rate；与geeneralize一起工作。
  • **要使用的典型最终值：**0.01-0.2
2. min_child_weight [default=1]
  • 定义子中所需的所有观察值的最小权重和。它用于控制过度拟合。较高的值阻止模型学习-可能高度特定于为树选择的特定样本的关系。
  • 过高的值可能会导致拟合不足，因此，应使用CV进行调整。
3. max_depth [default=6]
  • 树的最大深度，它也用于控制过度拟合，因为更高的深度将允许模型学习非常特定于特定样本的关系。应使用CV进行调整。
  • Typical values: 3-10
4. max_leaf_nodes
  • 树中终端节点或叶子的最大数量。
  • 由于创建了二叉树，深度为“n”将产生最多2^n个叶子。如果定义了这个，GBM将忽略max_depth。
5. gamma [default=0]
  • 只有当产生的拆分在损失函数中给出正减少时，才会拆分节点。Gamma指定发生拆分所需的最小损失减少。
  • 使算法保守。值可以根据损失函数而变化，应该进行调整。可用于控制过拟合。
6. max_delta_step [default=0]
  • 在最大增量步长中，我们允许每棵树的权重估计为。如果将值设置为0，则表示没有约束。如果将其设置为正值，则有助于使更新步骤更加保守。
  • 这通常不使用。
7. subsample [default=1]
  • 它表示观察值的部分是每棵树的随机样本。
  • 较低的值使算法更加保守，并防止过度拟合但太小的值可能会导致欠拟合。
  • Typical values: 0.5-1
8. colsample_bytree [default=1]
  • 表示每棵树的随机样本列的分数。较小的colsample_bytreepovides额外的规则化。
  • Typical values: 0.5-1
9. colsample_bylevel [default=1]
  • 表示每个级别中每个拆分的列的子样本比率。
10. alpha [default=0]
  • L1正则化项。
  • L1正则化通过在每次迭代中从权重中减去少量，从而最终使权重为零，从而强制无信息特征的权重为零。为了简单起见，它也被称为正则化。适用于叶子权重（而不是特征权重）；较大的值意味着更多的正则化。
11. lambda [default=1]
  • L2正则化项。
  • 这用于处理XGBoost的正则化部分。应该探索它以减少过度拟合。
  • L2正则化就像在每次迭代中去除一小部分权重的力。因此，权重永远不会等于零。L2正则化惩罚（权重）²有一个额外的参数来调整L2正则化项，称为正则化率（lambda）。
  • 比alpha更光滑。此外，适用于叶子重量。
12. scale_pos_weight [default=1]
  • 在高级不平衡的情况下，应使用大于0的值，因为它有助于更快地收敛。

学习任务参数

决定学习场景。例如，回归任务可能会在排名任务中使用不同的参数。

1. objective [default=reg:linear]
  • 这个定义了要最小化的损失函数。
  • 最常用的值是：
  • reg：线性-用于回归
  • reg： logistic-用于分类，当您只想要决策，而不是概率时。
  • 二进制：逻辑-二分类的逻辑回归，返回预测概率（而不是决策类）
  • 多分类：softmax-多类分类使用softmax目标，返回预测类（不是概率）；你还需要设置一个额外的num_class（类的数量）参数来定义唯一类的数量
  • 多分类：softprob-与softmax相同，但返回属于每个类的每个数据点的预测概率。
2. eval_metric [ default according to objective ]
  • 用于验证数据的指标。
  • 默认值为rmse用于回归，错误用于分类。
  • Typical values are:
  • rmse – 均方根误差
  • mae – 平均绝对误差
  • logloss – 负对数似然
  • error – 二进制分类错误率（0.5阈值）
  • merror – 多类分类错误率
  • mlogloss – 多类对数损失
  • auc – 曲线下方的区域
3. seed [default=0]
  • 为了重现结果

命令行参数

-与XGBoost的CLI版本的行为相关。

理解偏差-方差权衡

🧮 4. 理解偏差-方差权衡

如果你学习过机器学习或统计学课程，这很可能是最重要的概念之一，当我们允许模型变得更复杂（例如更深入）时，模型有更好的能力来拟合训练数据，导致模型偏差更小，然而，这样复杂的模型需要更多的数据来拟合。

XGBoost中的大多数参数都是关于偏差方差权衡的。最好的模型应该小心地将模型复杂性与其预测能力进行交易。参数文档会告诉你每个参数是否会使模型更加保守。这可以用来帮助你在复杂模型和简单模型之间转动旋钮。

XGBoost超参数调优方法

📑 6. 超参数调整的最佳方法

导入必要的模块和功能

import numpy as np 
import pandas as pd 
import os
import seaborn as sns
import matplotlib.pyplot as plt
from scipy import stats
import warnings
import json
from sklearn import manifoldfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import OrdinalEncoderimport xgboost as xgbfrom sklearn.model_selection import RandomizedSearchCV, GridSearchCV
from sklearn.model_selection import StratifiedKFoldfrom sklearn.metrics import roc_auc_score
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score, KFold
from sklearn.metrics import confusion_matrix
from xgboost import plot_treewarnings.filterwarnings('ignore')

warnings.filterwarnings('ignore')

def process_df(df):df=df.drop(['Name','PassengerId'],axis=1)df=df.dropna()target=df['Transported']df=df.drop(['Transported'],axis=1)target = target.astype(int)df['Cabin_1']= df['Cabin'].str[0]df['Cabin_2']= df['Cabin'].str[2]df['Cabin_3']= df['Cabin'].str[5]df=df.drop(['Cabin'],axis=1)# Create the training and test datasetsX_train, X_test, y_train, y_test = train_test_split(df, target, test_size = 0.2, random_state=100,stratify=target)numaric_columns=list(df.select_dtypes(include=np.number).columns)print("Numaric columns ("+str(len(numaric_columns))+") :",", ".join(numaric_columns))cat_columns=df.select_dtypes(include=['object']).columns.tolist()print("Categorical columns ("+str(len(cat_columns))+") :",", ".join(cat_columns))X_train_n=X_train[numaric_columns]X_test_n=X_test[numaric_columns]X_train_c=X_train[cat_columns]X_test_c=X_test[cat_columns]encoder=OrdinalEncoder()X_train_c = encoder.fit_transform(X_train_c)X_train_c=pd.DataFrame(X_train_c)X_test_c = encoder.transform(X_test_c)X_test_c=pd.DataFrame(X_test_c)i=1for column in X_train_c:X_train_n["cat_"+str(i)]=X_train_c[column]X_test_n["cat_"+str(i)]=X_test_c[column]i=i+1#X_train=pd.concat([X_train_n,X_train_c],axis=1,ignore_index=True)#X_test=pd.concat([X_test_n,X_test_c],axis=1,ignore_index=True)X_train_n=X_train_n.fillna(X_train_n.mean())X_test_n=X_test_n.fillna(X_test_n.mean())return X_train_n, X_test_n, y_train, y_test

准备数据

df= pd.read_csv("./spaceship-titanic/train.csv")
df.head()

X_train, X_test, y_train, y_test = process_df(df)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

Numaric columns (6) : Age, RoomService, FoodCourt, ShoppingMall, Spa, VRDeck
Categorical columns (7) : HomePlanet, CryoSleep, Destination, VIP, Cabin_1, Cabin_2, Cabin_3
(5411, 13) (1353, 13) (5411,) (1353,)

准备功能以使以后的事情更容易

基本参数：
  • booster=“gbtree”，因为这是一个分类问题
  • 目标=“二进制：逻辑”，根据问题
  • tree_method="gpu_hist"使用GPU
def xgb_helper(PARAMETERS,V_PARAM_NAME=False,V_PARAM_VALUES=False,BR=10):temp_dmatrix =xgb.DMatrix(data=X_train, label=y_train)if V_PARAM_VALUES==False:cv_results = xgb.cv(dtrain=temp_dmatrix, nfold=5,num_boost_round=BR,params=PARAMETERS, as_pandas=True, seed=123 )return cv_resultselse:results=[]for v_param_value in V_PARAM_VALUES:PARAMETERS[V_PARAM_NAME]=v_param_valuecv_results = xgb.cv(dtrain=temp_dmatrix, nfold=5,num_boost_round=BR,params=PARAMETERS, as_pandas=True, seed=123)results.append((cv_results["train-auc-mean"].tail().values[-1],cv_results["test-auc-mean"].tail().values[-1]))data = list(zip(V_PARAM_VALUES, results))print(pd.DataFrame(data,columns=[V_PARAM_NAME,"auc"]))return cv_results

创建通用基础模型并评估性能

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc"}
xgb_helper(PARAMETERS)
train-auc-meantrain-auc-stdtest-auc-meantest-auc-std
00.8584130.0021870.8218620.005628
10.8702820.0016890.8286900.004939
20.8763220.0008560.8358790.002703
30.8801060.0014560.8387580.004261
40.8841370.0016240.8386740.003967
50.8870570.0016970.8415440.003510
60.8896950.0023410.8422140.005057
70.8912140.0024970.8427080.005743
80.8928860.0021780.8436440.005887
90.8939280.0024170.8440920.005543

优化提升轮数（因为我们将使用xgb中的DMatrix）

# 创建DMatrix：housing_dmatrix
housing_dmatrix =xgb.DMatrix(data=X_train, label=y_train)# 为每棵树创建参数字典：参数 
params = {"objective":"binary:logistic", "max_depth":5}# 创建提升轮数列表
num_rounds = [5, 10, 15, 20, 25]# 每个XGBoost模型存储最后一轮rmse的空列表
final_rmse_per_round = []# 迭代num_rounds，每个num_boost_round参数构建一个模型
for curr_num_rounds in num_rounds:# 执行交叉验证：cv_resultscv_results = xgb.cv(dtrain=housing_dmatrix, params=params, nfold=5, num_boost_round=curr_num_rounds, metrics="auc", as_pandas=True, seed=123)# 追加最后一轮RMSEfinal_rmse_per_round.append(cv_results["test-auc-mean"].tail().values[-1])# 打印生成的DataFrame
num_rounds_rmses = list(zip(num_rounds, final_rmse_per_round))
print(pd.DataFrame(num_rounds_rmses,columns=["num_boosting_rounds","auc"]))

       num_boosting_rounds       auc0                    5  0.8400331                   10  0.8435942                   15  0.8457473                   20  0.8454004                   25  0.844094
Pointers:
  • Taking num_boosting_rounds = 10; 以避免过度拟合

1.选择学习率。也许你可以从更高的开始。0.5-0.1在大多数情况下是可以开始的。

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5}
xgb_helper(PARAMETERS)
train-auc-meantrain-auc-stdtest-auc-meantest-auc-std
00.8584130.0021870.8218620.005628
10.8729580.0021870.8316660.004109
20.8798170.0015060.8367760.005321
30.8840870.0022110.8381990.005545
40.8880990.0023160.8408620.006667
50.8909200.0020140.8415200.005769
60.8939140.0013300.8422230.005199
70.8963950.0023590.8426090.005717
80.8974770.0028520.8426700.005631
90.9004220.0022090.8427160.005787
Pointers:
  • 一个好的起始分类器，train-auc均值为0.900422，test-auc均值为0.842716。让我们继续调整并减少过度拟合。

2. 使用 CV, tune max_depth and min_child_weight next.

2.1. 调整 max_depth.

Tips: 保持在3-10左右。

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5}
V_PARAM_NAME="max_depth"
V_PARAM_VALUES=range(3,10,1)data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

       max_depth                                       auc0          3  (0.8643899441624237, 0.8434407018878254)1          4  (0.8762391828253827, 0.8432457875673736)2          5  (0.8898517716460612, 0.8449580853400329)3          6  (0.9004222967227931, 0.8427158084686912)4          7  (0.9107993432039982, 0.8379593667718235)5          8  (0.9233976130022082, 0.8309442810154544)6          9  (0.9331601626845524, 0.8328975608830239)
Pointers:
  • Taking max_depth 5, as per the score.

2.2. 调整 min_child_weigh.

Tips: 对于不平衡的数据集保持小，有利于平衡

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5,"max_depth":5}
V_PARAM_NAME="min_child_weight"
V_PARAM_VALUES=range(0,5,1)data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

       min_child_weight                                       auc0                 0  (0.8923932136315347, 0.8400307515925263)1                 1  (0.8898517716460612, 0.8449580853400329)2                 2  (0.8878844356167308, 0.8430174554684318)3                 3   (0.8842988914848681, 0.842868768786811)4                 4  (0.8841976959835126, 0.8426672020116197)
Pointers:
  • Taking min_child_weight 1, as per the score.

3. gamma.

Tips: 保持它像0.1-0.2一样小。稍后会调整。

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5,"max_depth":5,"min_child_weight":1}
V_PARAM_NAME = "gamma"
V_PARAM_VALUES = [0.1,0.2,0.5,1,1.5,2]data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

       gamma                                       auc0    0.1   (0.889994877151358, 0.8443115370456209)1    0.2  (0.8908020107961383, 0.8447684831269007)2    0.5   (0.888948000423167, 0.8450077335411604)3    1.0   (0.888184172336776, 0.8451616022595031)4    1.5  (0.8875863399894248, 0.8435783340359313)5    2.0  (0.8861811009373095, 0.8449147712912233)
Pointers:
  • Taking gamma 1, as per the score.

4. 调整 subsample 和 colsample_bytree.

4.1. 调整 subsample.

Tips: 保持范围小0.5-0.9。

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5,"max_depth":5,"min_child_weight":1,"gamma":1}
V_PARAM_NAME = "subsample"
V_PARAM_VALUES = [.4,.5,.6,.7,.8,.9]data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

       subsample                                       auc0        0.4    (0.8749532101660904, 0.83281692487631)1        0.5  (0.8789542430190034, 0.8356286366243391)2        0.6  (0.8804439995005579, 0.8371190653296372)3        0.7  (0.8852418637174774, 0.8388110573107215)4        0.8  (0.8868771320489373, 0.8385871061415084)5        0.9  (0.8880784719598278, 0.8414592031099557)
Pointers:
  • Taking 0.7

4.2. Tune colsample_bytree.

Tips: Keep it small in range 0.5-0.9.

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5,"max_depth":5,"min_child_weight":1,"gamma":1,"subsample":0.7}
V_PARAM_NAME = "colsample_bytree"
V_PARAM_VALUES = [.4,.5,.6,.7,.8,.9]data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

       colsample_bytree                                       auc0               0.4   (0.8737438808751801, 0.831927418798438)1               0.5  (0.8781175336774438, 0.8371252843166564)2               0.6  (0.8793282404547682, 0.8362558750372221)3               0.7  (0.8815593124156965, 0.8382064256388843)4               0.8  (0.8818068187259996, 0.8414608580897104)5               0.9  (0.8824219339976163, 0.8391185793280422)
Pointers:
  • Taking 0.8

4.3. 调整 scale_pos_weight.

Tips: 基于 class 不平衡.

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5,"max_depth":5,"min_child_weight":1,"gamma":1,"subsample":0.7,"colsample_bytree":.8}V_PARAM_NAME = "scale_pos_weight"
V_PARAM_VALUES = [.5,1,2]data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

       scale_pos_weight                                       auc0               0.5  (0.8793958985004761, 0.8381736971719818)1               1.0  (0.8818068187259996, 0.8414608580897104)2               2.0  (0.8810854054804358, 0.8366761184232949)
Pointers:
  • Taking 1

5. 调整正则化参数 (alpha,lambda)

5.1. 更改 alpha.

Tips: Based on class imbalance.

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5,"max_depth":5,"min_child_weight":1,"gamma":1,"subsample":0.7,"colsample_bytree":.8, "scale_pos_weight":1}V_PARAM_NAME = "reg_alpha"
V_PARAM_VALUES = np.linspace(start=0.001, stop=1, num=20).tolist()data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

        reg_alpha                                       auc0    0.001000  (0.8818047689235573, 0.8414642805838721)1    0.053579  (0.8822512519204411, 0.8400495473072034)2    0.106158  (0.8816533897741998, 0.8393925267300872)3    0.158737  (0.8817818509762845, 0.8406296490672798)4    0.211316  (0.8801161063692018, 0.8397169942954633)5    0.263895  (0.8812037168173367, 0.8392127901963959)6    0.316474  (0.8801615034837067, 0.8427679621158068)7    0.369053  (0.8805653368213827, 0.8404140823263765)8    0.421632  (0.8802277851530302, 0.8402395041940075)9    0.474211  (0.8803759440342087, 0.8421274755689788)10   0.526789  (0.8803912729575127, 0.8423146821519907)11   0.579368  (0.8801605635521235, 0.8414003162278721)12   0.631947  (0.8819615487131747, 0.8424679296448012)13   0.684526  (0.8812525217771652, 0.8419542782384447)14   0.737105  (0.8800798281136639, 0.8411308776060921)15   0.789684   (0.8791173070125374, 0.843057560946075)16   0.842263  (0.8800692484855718, 0.8442545484482243)17   0.894842  (0.8790444602851833, 0.8393354812370287)18   0.947421  (0.8796063533992223, 0.8406622971346293)19   1.000000   (0.8784791031845056, 0.841360884610965)
Pointers:
  • Taking 0.15

5.2. 更改 lambda.

Tips: Based on class imbalance.

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","learning_rate": 0.5,"max_depth":5,"min_child_weight":1,"gamma":1,"subsample":0.7,"colsample_bytree":.8, "scale_pos_weight":1,"reg_alpha":0.15}V_PARAM_NAME = "reg_lambda"
V_PARAM_VALUES = np.linspace(start=0.001, stop=1, num=20).tolist()data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

        reg_lambda                                       auc0     0.001000  (0.8842321498802038, 0.8369315944875698)1     0.053579  (0.8846942202574949, 0.8367595558776119)2     0.106158  (0.8842139683915015, 0.8376755628888233)3     0.158737  (0.8841648054675174, 0.8374257380594093)4     0.211316  (0.8846029132722426, 0.8409101483580509)5     0.263895  (0.8849316913321706, 0.8349999831449061)6     0.316474  (0.8827466914234432, 0.8407336856742689)7     0.369053  (0.8835788031788671, 0.8399715195787192)8     0.421632    (0.883240239698053, 0.839815382235226)9     0.474211  (0.8833454760444799, 0.8381444821333328)10    0.526789  (0.8817612864701729, 0.8376539639984177)11    0.579368  (0.8820436530763995, 0.8367212403795014)12    0.631947  (0.8814519611406787, 0.8389461863625524)13    0.684526  (0.8808375865994101, 0.8382765202241252)14    0.737105  (0.8809840506591808, 0.8395892670674611)15    0.789684  (0.8814380192185137, 0.8398002164520746)16    0.842263   (0.8822586609494353, 0.840774913104777)17    0.894842  (0.8812572158281702, 0.8421072055782199)18    0.947421  (0.8815423976980001, 0.8404889892591069)19    1.000000   (0.881010486305841, 0.8407738594877234)
Pointers:
  • Taking 1

6. 最后，降低学习率并添加更多树木

6.1. 降低学习率（Learning rate）.

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","max_depth":5,"min_child_weight":1,"gamma":1,"subsample":0.7,"colsample_bytree":.8, "scale_pos_weight":1,"reg_alpha":0.15,"reg_lambda":1}V_PARAM_NAME = "learning_rate"
V_PARAM_VALUES = np.linspace(start=0.01, stop=0.3, num=10).tolist()data=xgb_helper(PARAMETERS,V_PARAM_NAME=V_PARAM_NAME,V_PARAM_VALUES=V_PARAM_VALUES);

       learning_rate                                       auc0       0.010000   (0.855713530270808, 0.8334207445339894)1       0.042222  (0.8587092932455096, 0.8348147563720609)2       0.074444   (0.862042487494276, 0.8357581120451331)3       0.106667  (0.8658326130454131, 0.8380194134948816)4       0.138889   (0.867456218936832, 0.8397551989588203)5       0.171111  (0.8710396787562106, 0.8411854139672925)6       0.203333   (0.873634746455022, 0.8417298506166315)7       0.235556  (0.8742498286647391, 0.8442379624397564)8       0.267778  (0.8758428845033487, 0.8421168040274616)9       0.300000  (0.8763744967034954, 0.8431341804372676)
Pointers:
  • Taking 0.3

完整模型

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc","max_depth":5,"min_child_weight":1,"gamma":1,"subsample":0.7,"colsample_bytree":.8, "scale_pos_weight":1,"reg_alpha":0.15,"reg_lambda":1,"learning_rate": 0.3}clf = xgb.XGBClassifier( tree_method="gpu_hist",objective="binary:logistic",eval_metric="auc",max_depth=5,min_child_weight=1,gamma=1,subsample=0.7,colsample_bytree=.8, scale_pos_weight=1,reg_alpha=0.15,reg_lambda=1,learning_rate= 0.3,n_estimators=800)clf.fit(X_train,y_train)clf.save_model("categorical-model.json")

pred = clf.predict(X_test)

from sklearn.metrics import classification_report
print(classification_report(y_test, pred, target_names=["0","1"]))

                  precision    recall  f1-score   support0       0.81      0.72      0.76       6731       0.75      0.83      0.79       680accuracy                           0.78      1353macro avg       0.78      0.78      0.78      1353weighted avg       0.78      0.78      0.78      1353

from sklearn.metrics import plot_roc_curve
plot_roc_curve(clf, X_test, y_test)

<sklearn.metrics._plot.roc_curve.RocCurveDisplay at 0x7822c299bf10>


from sklearn.metrics import roc_auc_score
roc_auc_score(y_test,pred)

0.7765033650904642

# Get a graph
graph = xgb.to_graphviz(clf, num_trees=1)
# Or get a matplotlib axis
ax = xgb.plot_tree(clf, num_trees=1)
# Get feature importances
plt.show()

哪个参数做什么？

📒 5. 哪个参数做什么？

控制过拟合

当你观察到训练精度高，但测试精度低时，很可能你遇到了过拟合问题。
通常有两种方法可以控制XGBoost中的过度拟合：

  • 第一种方法是直接控制模型复杂度。

    • 这包括max_depth、min_child_weight和γ。

  • 第二种方法是添加随机性以使训练对噪音具有鲁棒性。

    • 这包括子样本和colsample_bytree。
    • 你也可以减少步长eta。记住这样做时增加num_round。

控制过拟合-代码示例：方法1

正常条件

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc"}
xgb_helper(PARAMETERS)
train-auc-meantrain-auc-stdtest-auc-meantest-auc-std
00.8584130.0021870.8218620.005628
10.8702820.0016890.8286900.004939
20.8763220.0008560.8358790.002703
30.8801060.0014560.8387580.004261
40.8841370.0016240.8386740.003967
50.8870570.0016970.8415440.003510
60.8896950.0023410.8422140.005057
70.8912140.0024970.8427080.005743
80.8928860.0021780.8436440.005887
90.8939280.0024170.8440920.005543

因此，训练和测试AUC分数之间的差异约为0.05，即5%-这相当高。

让我们正规化。

过拟合控制

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc", "max_depth":2 , "min_child_weight":3, "gamma":2}
xgb_helper(PARAMETERS)
train-auc-meantrain-auc-stdtest-auc-meantest-auc-std
00.7560950.0067120.7456160.012709
10.7946880.0030160.7870550.012553
20.8071680.0030950.8004970.013173
30.8135500.0037320.8077740.011470
40.8166390.0035050.8104550.011466
50.8178540.0034830.8120030.011679
60.8210960.0044410.8149930.011331
70.8251880.0029740.8184320.010964
80.8289950.0022060.8215160.010546
90.8309420.0012930.8244460.009938

因此，训练和测试AUC分数之间的差异小于0.01，即1%-这是相当好的。

控制过拟合-代码示例：方法2

PARAMETERS={"objective":'binary:logistic',"eval_metric":"auc", "subsample":0.3,"colsample_bytree":0.3,"eta":.05}
xgb_helper(PARAMETERS,25) #increasing num bossting round to 15
train-auc-meantrain-auc-stdtest-auc-meantest-auc-std
00.7951860.0033690.7770800.012016
10.8025560.0134060.7846620.018255
20.8052640.0125720.7844390.015186
30.8119220.0102740.7884790.010984
40.8142760.0099950.7881800.011646
50.8173060.0097680.7879110.007396
60.8175540.0118560.7883860.007400
70.8199850.0130850.7915020.012313
80.8216930.0136830.7940370.013249
90.8272550.0047180.7991010.009761

所以，现在训练和测试AUC分数之间的差异小于0.035，即3.5%-这比正常情况下要好。

更快的训练表现

有一个名为tree_method的参数，将其设置为hist或gpu_hist以加快计算速度。

处理不平衡数据集

对于广告点击日志等常见情况，数据集极不平衡。这会影响XGBoost模型的训练，有两种方法可以改进它。

  • 如果您只关心预测的整体性能指标（AUC）

    • 通过scale_pos_weight平衡正负权重
    • 使用AUC进行评估

  • 如果你关心预测正确的概率

    • 在这种情况下，您无法重新平衡数据集
    • 设置参数max_delta_step为有限的数字（如1），以帮助收敛

http://www.ppmy.cn/devtools/148460.html

相关文章

机器学习周报-ModernTCN文献阅读

机器学习周报-ModernTCN文献阅读

文章目录 摘要Abstract 0 提升有效感受野&#xff08;ERF&#xff09;1 相关知识1.1 标准卷积1.2 深度分离卷积&#xff08;Depthwise Convolution&#xff0c;DWConv&#xff09;1.3 逐点卷积&#xff08;Pointwise Convolution&#xff0c;PWConv&#xff09;1.4 组卷积(Grou…
阅读更多...
【OpenCV】使用Python和OpenCV实现火焰检测

【OpenCV】使用Python和OpenCV实现火焰检测

1、 项目源码和结构&#xff08;转&#xff09; https://github.com/mushfiq1998/fire-detection-python-opencv 2、 运行环境 # 安装playsound&#xff1a;用于播放报警声音 pip install playsound # 安装opencv-python&#xff1a;cv2用于图像和视频处理&#xff0c;特别是…
阅读更多...
CDP集群安全指南-动态数据加密

CDP集群安全指南-动态数据加密

[〇]关于本文 集群的动态数据加密主要指的是加密通过网络协议传输的数据&#xff0c;防止数据在传输的过程中被窃取。由于大数据涉及的主机及服务众多。你需要更具集群的实际环境来评估需要为哪些环节实施动态加密。 这里介绍一种通过Cloudera Manager 的Auto-TLS功能来为整个…
阅读更多...
网络安全技能试题总结参考

网络安全技能试题总结参考

对网络安全技能测试相关的试题进行了总结，供大家参考。 一、单选题 1.(单选题)以下属于汇聚层功能的是 A.拥有大量的接口，用于与最终用户计算机相连 B.接入安全控制 C.高速的包交换 D.复杂的路由策略 答案：D 2.(单选题)VLAN划分的方法，选择一个错误选项 A.基于端口…
阅读更多...
级联配准learning

级联配准learning

1.定义 级联配准&#xff08;Cascade Registration&#xff09;是一种在图像处理、计算机视觉等领域广泛应用的技术。它主要用于将不同视角、不同模态或者不同时间获取的图像进行精确的对齐&#xff0c;并且是通过多个阶段&#xff08;级联&#xff09;的处理来逐步优化配准的精…
阅读更多...
打造三甲医院人工智能矩阵新引擎（一）：文本大模型篇--基于GPT-4o的探索

打造三甲医院人工智能矩阵新引擎（一）：文本大模型篇--基于GPT-4o的探索

一、引言 当今时代，人工智能技术正以前所未有的速度蓬勃发展，深刻且广泛地渗透至各个领域，医疗行业更是这场变革的前沿阵地。在人口老龄化加剧、慢性疾病患病率上升以及人们对健康需求日益增长的大背景下，三甲医院作为医疗体系的核心力量，承担着极为繁重且复杂的医疗任务。…
阅读更多...
基于SpringBoot在线竞拍平台系统功能实现十五

基于SpringBoot在线竞拍平台系统功能实现十五

一、前言介绍&#xff1a; 1.1 项目摘要 随着网络技术的飞速发展和电子商务的普及&#xff0c;竞拍系统作为一种新型的在线交易方式&#xff0c;已经逐渐深入到人们的日常生活中。传统的拍卖活动需要耗费大量的人力、物力和时间&#xff0c;从组织拍卖、宣传、报名、竞拍到成…
阅读更多...
服务器信息整理：用途、操作系统安装日期、设备序列化、IP、MAC地址、BIOS时间、系统

服务器信息整理：用途、操作系统安装日期、设备序列化、IP、MAC地址、BIOS时间、系统

文章目录 引言I BIOS时间Windows查看BIOS版本安装日期linux查看BIOS时间II 操作系统安装日期LinuxWindowsIII MAC 地址IV 设备序列号Linux 查看主板信息知识扩展Linux常用命令引言 信息内容：重点信息：用途、操作系统安装日期、设备序列化、IP、MAC地址、BIOS时间、系统 Linux…
阅读更多...
最新文章

Copyright @ 2022~2023