當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

XGBOOST从原理到实战：二分类、多分类

發布時間：2023/12/20 编程问答 36 豆豆

生活随笔收集整理的這篇文章主要介紹了 XGBOOST从原理到实战：二分类、多分类小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

注：轉載請注明出處，https://blog.csdn.net/HHTNAN/

文章目錄

- - XGboost完整系統的原理+實戰：[課程直通車](https://edu.csdn.net/course/detail/10332)
  - - 1.XGBoost
    - 2. XGBoost的優點
    - - 2.1 正則化
      - 2.2 并行處理
      - 2.3 靈活性
      - 2.4 缺失值處理
      - 2.5 剪枝
      - 2.6 內置交叉驗證
    - 3. XGBoost詳解
    - - 3.1 數據格式
      - 3.2 參數設置
      - 3.3xgboost 模型訓練方法和參數
    - 4.模型的訓練、預測、保存
    - - 4.1 訓練模型
      - 4.3 保存與加載模型
    - 5. XGBoost參數說明
    - - 5.1 General Parameters
      - 5.2 Parameters for Tree Booster
      - 5.3 Parameter for Linear Booster
      - 5.4 Task Parameters
    - 6. XGBoost實戰
    - - 特征重要性
      - 多分類
      - 兩大類接口
      - 基于XGBoost原生接口的分類
        基于XGBoost原生接口的回歸
        基于Scikit-learn接口的分類
        基于Scikit-learn接口的回歸

XGboost完整系統的原理+實戰：課程直通車

##### 數據topK a = np.array([1,4,3,5,2]) K=4 #返回索引 print(a[np.argpartition(-a,K)][:3]) #返回排序后的結果 print( a[np.argsort(-a)][:3])

1.XGBoost

xgboost是大規模并行boosted tree的工具，它是目前最快最好的開源boosted tree工具包，比常見的工具包快10倍以上。在數據科學方面，有大量kaggle選手選用它進行數據挖掘比賽，其中包括兩個以上kaggle比賽的奪冠方案。在工業界規模方面，xgboost的分布式版本有廣泛的可移植性，支持在YARN, MPI, Sungrid Engine等各個平臺上面運行，并且保留了單機并行版本的各種優化，使得它可以很好地解決于工業界規模的問題。
下載地址：直通車

2. XGBoost的優點

2.1 正則化

XGBoost在代價函數里加入了正則項，用于控制模型的復雜度。正則項里包含了樹的葉子節點個數、每個葉子節點上輸出的score的L2模的平方和。從Bias-variance tradeoff角度來講，正則項降低了模型的variance，使學習出來的模型更加簡單，防止過擬合，這也是xgboost優于傳統GBDT的一個特性。

2.2 并行處理

XGBoost工具支持并行。Boosting不是一種串行的結構嗎?怎么并行的？注意XGBoost的并行不是tree粒度的并行，XGBoost也是一次迭代完才能進行下一次迭代的（第t次迭代的代價函數里包含了前面t-1次迭代的預測值）。XGBoost的并行是在特征粒度上的。

我們知道，決策樹的學習最耗時的一個步驟就是對特征的值進行排序（因為要確定最佳分割點），XGBoost在訓練之前，預先對數據進行了排序，然后保存為block結構，后面的迭代中重復地使用這個結構，大大減小計算量。這個block結構也使得并行成為了可能，在進行節點的分裂時，需要計算每個特征的增益，最終選增益最大的那個特征去做分裂，那么各個特征的增益計算就可以開多線程進行。

2.3 靈活性

XGBoost支持用戶自定義目標函數和評估函數，只要目標函數二階可導就行。

2.4 缺失值處理

對于特征的值有缺失的樣本，xgboost可以自動學習出它的分裂方向

2.5 剪枝

XGBoost 先從頂到底建立所有可以建立的子樹，再從底到頂反向進行剪枝。比起GBM，這樣不容易陷入局部最優解。

2.6 內置交叉驗證

XGBoost允許在每一輪boosting迭代中使用交叉驗證。因此，可以方便地獲得最優boosting迭代次數。而GBM使用網格搜索，只能檢測有限個值。

3. XGBoost詳解

3.1 數據格式

XGBoost可以加載多種數據格式的訓練數據：

libsvm 格式的文本數據；

Numpy 的二維數組；

XGBoost 的二進制的緩存文件。加載的數據存儲在對象 DMatrix 中

下面一一列舉：

加載libsvm格式的數據

dtrain1 = xgb.DMatrix('train.svm.txt')

加載numpy的數組

data = np.random.rand(5,10) # 5 entities, each contains 10 features label = np.random.randint(2, size=5) # binary target dtrain = xgb.DMatrix( data, label=label)

將scipy.sparse格式的數據轉化為 DMatrix 格式

csr = scipy.sparse.csr_matrix( (dat, (row,col)) ) dtrain = xgb.DMatrix( csr )

將 DMatrix 格式的數據保存成XGBoost的二進制格式，在下次加載時可以提高加載速度，使用方式如下

dtrain = xgb.DMatrix('train.svm.txt') dtrain.save_binary("train.buffer")

可以用如下方式處理 DMatrix中的缺失值：

dtrain = xgb.DMatrix( data, label=label, missing = -999.0)

當需要給樣本設置權重時，可以用如下方式

w = np.random.rand(5,1)dtrain = xgb.DMatrix( data, label=label, missing = -999.0, weight=w)

3.2 參數設置

XGBoost使用key-value字典的方式存儲參數：

params = {'booster': 'gbtree','objective': 'multi:softmax', # 多分類的問題'num_class': 10, # 類別數，與 multisoftmax 并用'gamma': 0.1, # 用于控制是否后剪枝的參數,越大越保守，一般0.1、0.2這樣子。'max_depth': 12, # 構建樹的深度，越大越容易過擬合'lambda': 2, # 控制模型復雜度的權重值的L2正則化項參數，參數越大，模型越不容易過擬合。'subsample': 0.7, # 隨機采樣訓練樣本'colsample_bytree': 0.7, # 生成樹時進行的列采樣'min_child_weight': 3,'silent': 1, # 設置成1則沒有運行信息輸出，最好是設置為0.'eta': 0.007, # 如同學習率'seed': 1000,'nthread': 4, # cpu 線程數 }

3.3xgboost 模型訓練方法和參數

在訓練過程中主要用到兩個方法：xgboost.train()和xgboost.cv().

#xgboost.train()API xgboost.train(params,dtrain,num_boost_round=10,evals=(),obj=None,feval=None,maximize=False,early_stopping_rounds=None, evals_result=None,verbose_eval=True,learning_rates=None,xgb_model=None)

params 這是一個字典，里面包含著訓練中的參數關鍵字和對應的值，形式是params =
{‘booster’:’gbtree’,’eta’:0.1}
dtrain 訓練的數據
num_boost_round 這是指提升迭代的個數
evals 這是一個列表，用于對訓練過程中進行評估列表中的元素。形式是evals =
[(dtrain,’train’),(dval,’val’)]或者是evals =
[(dtrain,’train’)],對于第一種情況，它使得我們可以在訓練過程中觀察驗證集的效果。
obj,自定義目的函數
feval,自定義評估函數
maximize ,是否對評估函數進行最大化
early_stopping_rounds,早期停止次數，假設為100，驗證集的誤差迭代到一定程度在100次內不能再繼續降低，就停止迭代。這要求evals 里至少有一個元素，如果有多個，按最后一個去執行。返回的是最后的迭代次數（不是最好的）。如果early_stopping_rounds
存在，則模型會生成三個屬性，bst.best_score,bst.best_iteration,和bst.best_ntree_limit
evals_result 字典，存儲在watchlist 中的元素的評估結果。
verbose_eval (可以輸入布爾型或數值型)，也要求evals 里至少有一個元素。如果為True ,則對evals中元素的評估結果會輸出在結果中；如果輸入數字，假設為5，則每隔5個迭代輸出一次。
learning_rates 每一次提升的學習率的列表，
xgb_model ,在訓練之前用于加載的xgb model。

參數初步定之后劃分20%為驗證集，準備一個watchlist 給train和validation set ,設置num_round 足夠大（比如100000），以至于你能發現每一個round 的驗證集預測結果，如果在某一個round后 validation set 的預測誤差上升了，你就可以停止掉正在運行的程序了。

watchlist = [(dtrain,'train'),(dval,'val')] model = xgb.train(params,dtrain,num_boost_round=100000,evals = watchlist)

4.模型的訓練、預測、保存

4.1 訓練模型

有了參數列表和數據就可以訓練模型了

num_round = 10 bst = xgb.train( plst, dtrain, num_round, evallist )

#####4.2模型預測

# X_test類型可以是二維List，也可以是numpy的數組 dtest = DMatrix(X_test) ans = model.predict(dtest)

4.3 保存與加載模型

在訓練完成之后可以將模型保存下來，也可以查看模型內部的結構

bst.save_model('test.model')

加載模型
通過如下方式可以加載模型：

bst = xgb.Booster({'nthread':4}) # init model bst.load_model("model.bin") # load data

#####4.4導出模型和特征映射（Map）
你可以導出模型到txt文件并瀏覽模型的含義：

# dump model bst.dump_model('dump.raw.txt') # dump model with feature map bst.dump_model('dump.raw.txt','featmap.txt')

5. XGBoost參數說明

在運行XGboost之前，必須設置三種類型成熟：general parameters，booster parameters和task parameters：

General parameters

該參數參數控制在提升（boosting）過程中使用哪種booster，常用的booster有樹模型（tree）和線性模型（linear model）。

Booster parameters

這取決于使用哪種booster。

Task parameters

控制學習的場景，例如在回歸問題中會使用不同的參數控制排序。

5.1 General Parameters

booster [default=gbtree]

有兩中模型可以選擇gbtree和gblinear。gbtree使用基于樹的模型進行提升計算，gblinear使用線性模型進行提升計算。缺省值為gbtree

silent [default=0]

取0時表示打印出運行時信息，取1時表示以緘默方式運行，不打印運行時信息。缺省值為0

nthread

XGBoost運行時的線程數。缺省值是當前系統可以獲得的最大線程數

num_pbuffer

預測緩沖區大小，通常設置為訓練實例的數目。緩沖用于保存最后一步提升的預測結果，無需人為設置。

num_feature

Boosting過程中用到的特征維數，設置為特征個數。XGBoost會自動設置，無需人為設置。

5.2 Parameters for Tree Booster

eta [default=0.3]

為了防止過擬合，更新過程中用到的收縮步長。在每次提升計算之后，算法會直接獲得新特征的權重。 eta通過縮減特征的權重使提升計算過程更加保守。缺省值為0.3
取值范圍為：[0,1]

gamma [default=0]

minimum loss reduction required to make a further partition on a leaf node of the tree. the larger, the more conservative the algorithm will be.
取值范圍為：[0,∞]

max_depth [default=6]

數的最大深度。缺省值為6
取值范圍為：[1,∞]

min_child_weight [default=1]

子節點中最小的樣本權重和。如果一個葉子節點的樣本權重和小于min_child_weight則拆分過程結束。在現行回歸模型中，這個參數是指建立每個模型所需要的最小樣本數。該成熟越大算法越conservative
取值范圍為：[0,∞]

max_delta_step [default=0]

我們允許每個樹的權重被估計的值。如果它的值被設置為0，意味著沒有約束；如果它被設置為一個正值，它能夠使得更新的步驟更加保守。通常這個參數是沒有必要的，但是如果在邏輯回歸中類極其不平衡這時候他有可能會起到幫助作用。把它范圍設置為1-10之間也許能控制更新。
取值范圍為：[0,∞]

subsample [default=1]

用于訓練模型的子樣本占整個樣本集合的比例。如果設置為0.5則意味著XGBoost將隨機的從整個樣本集合中隨機的抽取出50%的子樣本建立樹模型，這能夠防止過擬合。
取值范圍為：(0,1]

colsample_bytree [default=1]

在建立樹時對特征采樣的比例。缺省值為1
取值范圍為：(0,1]

5.3 Parameter for Linear Booster

lambda [default=0]

L2 正則的懲罰系數

alpha [default=0]

L1 正則的懲罰系數

lambda_bias

在偏置上的L2正則。缺省值為0（在L1上沒有偏置項的正則，因為L1時偏置不重要）

5.4 Task Parameters

objective [ default=reg:linear ]

定義學習任務及相應的學習目標，可選的目標函數如下：

“reg:linear” —— 線性回歸。 “reg:logistic”—— 邏輯回歸。 “binary:logistic”—— 二分類的邏輯回歸問題，輸出為概率。 “binary:logitraw”—— 二分類的邏輯回歸問題，輸出的結果為wTx。 “count:poisson”—— 計數問題的poisson回歸，輸出結果為poisson分布。在poisson回歸中，max_delta_step的缺省值為0.7。(used to safeguard optimization) “multi:softmax” –讓XGBoost采用softmax目標函數處理多分類問題，同時需要設置參數num_class（類別個數） “multi:softprob” –和softmax一樣，但是輸出的是ndata * nclass的向量，可以將該向量reshape成ndata行nclass列的矩陣。沒行數據表示樣本所屬于每個類別的概率。 “rank:pairwise” –set XGBoost to do ranking task by minimizing the pairwise loss base_score [ default=0.5 ]

所有實例的初始化預測分數，全局偏置；
為了足夠的迭代次數，改變這個值將不會有太大的影響。

eval_metric [ default according to objective ]

校驗數據所需要的評價指標，不同的目標函數將會有缺省的評價指標（rmse for regression, and error for classification, mean average precision for ranking）

用戶可以添加多種評價指標，對于Python用戶要以list傳遞參數對給程序，而不是map參數list參數不會覆蓋’eval_metric’

可供的選擇如下:

“rmse”: root mean square error “logloss”: negative log-likelihood “error”: Binary classification error rate. It is calculated as #(wrong cases)/#(all cases). For the predictions, the evaluation will regard the instances with prediction value larger than 0.5 as positive instances, and the others as negative instances. “merror”: Multiclass classification error rate. It is calculated as #(wrongcases)#(allcases). “mlogloss”: Multiclass logloss “auc”: Area under the curve for ranking evaluation. “ndcg”:Normalized Discounted Cumulative Gain “map”:Mean average precision “ndcg@n”,”map@n”: n can be assigned as an integer to cut off the top positions in the lists for evaluation. “ndcg-“,”map-“,”ndcg@n-“,”map@n-“: In XGBoost, NDCG and MAP will evaluate the score of a list without any positive samples as 1. By adding “-” in the evaluation metric XGBoost will evaluate these score as 0 to be consistent under some conditions. training repeatively seed [ default=0 ]

隨機數的種子。缺省值為0

6. XGBoost實戰

XGBoost有兩大類接口：XGBoost原生接口和 scikit-learn接口，并且XGBoost能夠實現分類和回歸兩種任務。對于分類任務，XGBOOST可以實現二分類和多分類，本文從這兩個方向入手：
#####二分類

""" 使用鳶尾花的數據來說明二分類的問題 """ from sklearn import datasetsiris = datasets.load_iris() data = iris.data[:100] print (data.shape)#一共有100個樣本數據, 維度為4維 label = iris.target[:100] print (label)

(100, 4)
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
上面分類為0-1二分類，接下來進行模型的預測與評估

from sklearn.cross_validation import train_test_splittrain_x, test_x, train_y, test_y = train_test_split(data, label, random_state=0) import xgboost as xgb dtrain=xgb.DMatrix(train_x,label=train_y) dtest=xgb.DMatrix(test_x)params={'booster':'gbtree','objective': 'binary:logistic','eval_metric': 'auc','max_depth':4,'lambda':10,'subsample':0.75,'colsample_bytree':0.75,'min_child_weight':2,'eta': 0.025,'seed':0,'nthread':8,'silent':1}watchlist = [(dtrain,'train')] bst=xgb.train(params,dtrain,num_boost_round=5,evals=watchlist) #輸出概率 ypred=bst.predict(dtest)# 設置閾值, 輸出一些評價指標，選擇概率大于0.5的為1，其他為0類 y_pred = (ypred >= 0.5)*1from sklearn import metrics print ('AUC: %.4f' % metrics.roc_auc_score(test_y,ypred)) print ('ACC: %.4f' % metrics.accuracy_score(test_y,y_pred)) print ('Recall: %.4f' % metrics.recall_score(test_y,y_pred)) print ('F1-score: %.4f' %metrics.f1_score(test_y,y_pred)) print ('Precesion: %.4f' %metrics.precision_score(test_y,y_pred)) print(metrics.confusion_matrix(test_y,y_pred))

[0] train-auc:1
[1] train-auc:1
[2] train-auc:1
[3] train-auc:1
[4] train-auc:1
AUC: 1.0000
ACC: 1.0000
Recall: 1.0000
F1-score: 1.0000
Precesion: 1.0000
[[13 0]
[ 0 12]]
######所屬的葉子節點
當設置pred_leaf=True的時候, 這時就會輸出每個樣本在所有樹中的葉子節點

ypred_leaf = bst.predict(dtest, pred_leaf=True)

[[1 1 1 1 1]
[2 2 2 2 2]
[1 1 1 1 1]
…
[2 2 2 2 2]
[1 1 1 1 1]]

輸出的維度為[樣本數, 樹的數量], 樹的數量默認是100, 所以ypred_leaf的維度為[100*100].對于第一行數據的解釋就是, 在xgboost所有的100棵樹里, 預測的葉子節點都是1(相對于每顆樹).那怎么看每顆樹以及相應的葉子節點的分值呢?這里有兩種方法, 可視化樹或者直接輸出模型.

xgb.to_graphviz(bst, num_trees=0) #可視化第一棵樹的生成情況)#直接輸出模型的迭代工程 bst.dump_model("model.txt")

booster[0]:
0:[f2<2.45] yes=1,no=2,missing=1
1:leaf=-0.019697
2:leaf=0.0214286
booster[1]:
0:[f2<2.35] yes=1,no=2,missing=1
1:leaf=-0.0212184
2:leaf=0.0212
booster[2]:
0:[f2<2.35] yes=1,no=2,missing=1
1:leaf=-0.0197404
2:leaf=0.0197235
booster[3]:
0:[f2<2.6] yes=1,no=2,missing=1
1:leaf=-0.0161663
2:leaf=0.0219079
booster[4]:
0:[f2<2.45] yes=1,no=2,missing=1
1:leaf=-0.0185029
2:leaf=0.0213033

通過上述命令就可以輸出模型的迭代過程, 可以看到每顆樹都有兩個葉子節點(樹比較簡單). 然后我們對每顆樹中的葉子節點1的value進行累加求和, 同時進行相應的函數轉換, 就是第一個樣本的預測值.
在這里, 以第一個樣本為例, 可以看到, 該樣本在所有樹中都屬于第一個葉子, 所以累加值, 得到以下值.

同樣, 以第二個樣本為例, 可以看到, 該樣本在所有樹中都屬于第二個葉子, 所以累加值, 得到以下值.

leaf1 -1.381214
leaf2 1.410950
在使用xgboost模型最開始, 模型初始化的時候, 我們就設置了’objective’: ‘binary:logistic’, 因此使用函數將累加的值轉換為實際的打分:
$f (x) = 1 / (1 + e x p (? x))$

1/float(1+np.exp(1.38121416)) 1/float(1+np.exp(-1.410950))

0.20081407112186503
0.8039157403338895
這就與ypred = bst.predict(dtest) 的分值相對應上了.

特征重要性

接著, 我們看另一種輸出方式, 輸出的是特征相對于得分的重要性.

ypred_contribs = bst.predict(dtest, pred_contribs=True) ypred_contribs

[[ 0. 0. -0.10902276 0. 0.01369767]
[ 0. 0. 0.09186566 0. 0.01369767]
[ 0. 0. -0.10902276 0. 0.01369767]
[ 0. 0. 0.09186566 0. 0.01369767]
…
[ 0. 0. 0.09186566 0. 0.01369767]
[ 0. 0. -0.10902276 0. 0.01369767]
[ 0. 0. 0.09186566 0. 0.01369767]
[ 0. 0. -0.10902276 0. 0.01369767]]
輸出的ypred_contribs的維度為[100,4], 前面的四列分別是每個特征對最后打分的影響因子, 可以看出, 前面兩個特征是不起作用的.

多分類

多分類皮膚病預測

import numpy as np from sklearn.model_selection import train_test_split import xgboost as xgb from sklearn.metrics import mean_squared_error #33: lambda x:int(x == '?') 將第33列?轉化為0 ，對應第34列數值-1 data = np.loadtxt('dermatology.data.txt', delimiter=',',converters={33: lambda x:int(x == '?'), 34: lambda x:int(x)-1} ) sz=data.shape X,Y=data[:,0:33],data[:,34] X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=0) #加載numpy的數組到DMatrix對象 xg_train = xgb.DMatrix(X_train, label=y_train) xg_test = xgb.DMatrix( X_test, label=y_test) #1.訓練模型 # setup parameters for xgboost param = {} # use softmax multi-class classification param['objective'] = 'multi:softmax' # scale weight of positive examples param['eta'] = 0.1 param['max_depth'] = 6 param['silent'] = 1 param['nthread'] = 4 param['num_class'] = 6watchlist = [ (xg_train,'train'), (xg_test, 'test') ] num_round = 6 bst = xgb.train(param, xg_train, num_round, watchlist );pred = bst.predict( xg_test ); print ('predicting, classification error=%f' % (sum( int(pred[i]) != y_test[i] for i in range(len(y_test))) / float(len(y_test)) ))

[0] train-merror:0.023438 test-merror:0.063636
[1] train-merror:0.015625 test-merror:0.045455
[2] train-merror:0.015625 test-merror:0.036364
[3] train-merror:0.007813 test-merror:0.036364
[4] train-merror:0.007813 test-merror:0.036364
[5] train-merror:0.007813 test-merror:0.018182
predicting, classification error=0.018182

#2.probabilities # do the same thing again, but output probabilities param['objective'] = 'multi:softprob' bst = xgb.train(param, xg_train, num_round, watchlist ); # Note: this convention has been changed since xgboost-unity # get prediction, this is in 1D array, need reshape to (ndata, nclass) yprob = bst.predict( xg_test ).reshape( y_test.shape[0], 6 ) #從預測的6組中選擇最大的概率進行輸出 ylabel = np.argmax(yprob, axis=1) # return the index of the biggest proprint ('predicting, classification error=%f' % (sum( int(ylabel[i]) != y_test[i] for i in range(len(y_test))) / float(len(y_test)) )) #最小二乘方差 mse2 = mean_squared_error(y_test,ylabel)print(mse2)

from sklearn import metrics print ('ACC: %.4f' % metrics.accuracy_score(y_test,ylabel)) print(metrics.confusion_matrix(y_test,ylabel))

ACC: 0.9818
[[27 0 0 0 0 0]
[ 0 19 0 1 0 0]
[ 0 0 21 0 0 0]
[ 0 1 0 17 0 0]
[ 0 0 0 0 16 0]
[ 0 0 0 0 0 8]]

# 顯示重要特征 plot_importance(bst) plt.show()

兩大類接口

基于XGBoost原生接口的分類

from sklearn.datasets import load_iris import xgboost as xgb from xgboost import plot_importance from matplotlib import pyplot as plt from sklearn.model_selection import train_test_split# read in the iris data iris = load_iris()X = iris.data y = iris.targetX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234565)params = {'booster': 'gbtree','objective': 'multi:softmax','num_class': 3,'gamma': 0.1,'max_depth': 6,'lambda': 2,'subsample': 0.7,'colsample_bytree': 0.7,'min_child_weight': 3,'silent': 1,'eta': 0.1,'seed': 1000,'nthread': 4, }plst = params.items()dtrain = xgb.DMatrix(X_train, y_train) num_rounds = 500 model = xgb.train(plst, dtrain, num_rounds)# 對測試集進行預測 dtest = xgb.DMatrix(X_test) ans = model.predict(dtest)# 計算準確率 cnt1 = 0 cnt2 = 0 for i in range(len(y_test)):if ans[i] == y_test[i]:cnt1 += 1else:cnt2 += 1print("Accuracy: %.2f %% " % (100 * cnt1 / (cnt1 + cnt2)))# 顯示重要特征 plot_importance(model) plt.show()

基于XGBoost原生接口的回歸

import xgboost as xgb from xgboost import plot_importance from matplotlib import pyplot as plt from sklearn.model_selection import train_test_split# 讀取文件原始數據 data = [] labels = [] labels2 = [] with open("lppz5.csv", encoding='UTF-8') as fileObject:for line in fileObject:line_split = line.split(',')data.append(line_split[10:])labels.append(line_split[8])X = [] for row in data:row = [float(x) for x in row]X.append(row)y = [float(x) for x in labels]# XGBoost訓練過程 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)params = {'booster': 'gbtree','objective': 'reg:gamma','gamma': 0.1,'max_depth': 5,'lambda': 3,'subsample': 0.7,'colsample_bytree': 0.7,'min_child_weight': 3,'silent': 1,'eta': 0.1,'seed': 1000,'nthread': 4, }dtrain = xgb.DMatrix(X_train, y_train) num_rounds = 300 plst = params.items() model = xgb.train(plst, dtrain, num_rounds)# 對測試集進行預測 dtest = xgb.DMatrix(X_test) ans = model.predict(dtest)# 顯示重要特征 plot_importance(model) plt.show()

基于Scikit-learn接口的分類

from sklearn.datasets import load_iris import xgboost as xgb from xgboost import plot_importance from matplotlib import pyplot as plt from sklearn.model_selection import train_test_split# read in the iris data iris = load_iris()X = iris.data y = iris.targetX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 訓練模型 model = xgb.XGBClassifier(max_depth=5, learning_rate=0.1, n_estimators=160, silent=True, objective='multi:softmax') model.fit(X_train, y_train)# 對測試集進行預測 ans = model.predict(X_test)# 計算準確率 cnt1 = 0 cnt2 = 0 for i in range(len(y_test)):if ans[i] == y_test[i]:cnt1 += 1else:cnt2 += 1print("Accuracy: %.2f %% " % (100 * cnt1 / (cnt1 + cnt2)))# 顯示重要特征 plot_importance(model) plt.show()

基于Scikit-learn接口的回歸

import xgboost as xgb from xgboost import plot_importance from matplotlib import pyplot as plt from sklearn.model_selection import train_test_split# 讀取文件原始數據 data = [] labels = [] labels2 = [] with open("lppz5.csv", encoding='UTF-8') as fileObject:for line in fileObject:line_split = line.split(',')data.append(line_split[10:])labels.append(line_split[8])X = [] for row in data:row = [float(x) for x in row]X.append(row)y = [float(x) for x in labels]# XGBoost訓練過程 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)model = xgb.XGBRegressor(max_depth=5, learning_rate=0.1, n_estimators=160, silent=True, objective='reg:gamma') model.fit(X_train, y_train)# 對測試集進行預測 ans = model.predict(X_test)# 顯示重要特征 plot_importance(model) plt.show()

####django2.0.5調用
參見鏈接：https://blog.csdn.net/HHTNAN/article/details/80894247

參考文獻:
文獻1
文獻2
文獻3
文獻4
文獻5
文獻6
文獻7

總結

以上是生活随笔為你收集整理的XGBOOST从原理到实战：二分类、多分类的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：恶意软件横行无忌 DNS“功”不可没
下一篇： HDOJ--1052--Tian Ji