集成學習算法彙總----Boosting和Bagging（推薦AAA）

時間 2019-11-24

標籤集成學習算法彙總 boosting bagging 推薦 aaa 欄目 C&C++ 简体版

原文原文鏈接

python機器學習-乳腺癌細胞挖掘（博主親自錄製視頻）

https://study.163.com/course/introduction.htm?courseId=1005269003&utm_campaign=commission&utm_source=cp-400000000398149&utm_medium=share

adaboost(adaptive boost)python

bootsting is a fairly simple variation on bagging that strives to improve the learners by
focusing area where the system is not performing wellredis

bootsting和bagging有一些小區別，算法

重點關注系統表現不佳的地區，從而獲得改進bootstrap

此算法不太容易過分擬合
建議先去噪聲，噪音影響權重安全

集成機器學習算法代價-計算量太大微信

a 越小，分類越多，偏差越小，越平滑網絡

ensemble methods and machine learning are a kind of meta algorithm that make use of other machine learning algorithms as a component to learn a collection of predictors ensemble methods take the attitude that more predictors can bebetter than any single oneantd

集合方法和機器學習是一種元算法，利用其餘機器學習算法做爲組件來學習預測數據，多個算法組合能夠比任何單一的算法更優越。app

http://lib.csdn.net/article/machinelearning/35135框架

集成學習在機器學習算法中具備較高的準去率，不足之處就是模型的訓練過程可能比較複雜，效率不是很高。目前接觸較多的集成學習主要有2種：基於Boosting的和基於Bagging，前者的表明算法有Adaboost、GBDT、XGBOOST、後者的表明算法主要是隨機森林。

一、集成學習概述

1.1 集成學習概述

1.2 集成學習的主要思想
集成學習的主要思想是利用必定的手段學習出多個分類器，並且這多個分類器要求是弱分類器，而後將多個分類器進行組合公共預測。核心思想就是如何訓練處多個弱分類器以及如何將這些弱分類器進行組合。

1.三、集成學習中弱分類器選擇
通常採用弱分類器的緣由在於將偏差進行均衡，由於一旦某個分類器太強了就會形成後面的結果受其影響太大，嚴重的會致使後面的分類器沒法進行分類。經常使用的弱分類器能夠採用偏差率小於0.5的，好比說邏輯迴歸、SVM、神經網絡。

1.四、多個分類器的生成
能夠採用隨機選取數據進行分類器的訓練，也能夠採用不斷的調整錯誤分類的訓練數據的權重生成新的分類器。

1.五、多個弱分類區如何組合
基本分類器之間的整合方式，通常有簡單多數投票、權重投票，貝葉斯投票，基於D-S證據理論的整合，基於不一樣的特徵子集的整合。

二、Boosting算法

2.1 基本概念

Boosting方法是一種用來提升弱分類算法準確度的方法,這種方法經過構造一個預測函數系列,而後以必定的方式將他們組合成一個預測函數。他是一種框架算法,主要是經過對樣本集的操做得到樣本子集,而後用弱分類算法在樣本子集上訓練生成一系列的基分類器。他能夠用來提升其餘弱分類算法的識別率,也就是將其餘的弱分類算法做爲基分類算法放於Boosting 框架中,經過Boosting框架對訓練樣本集的操做,獲得不一樣的訓練樣本子集,用該樣本子集去訓練生成基分類器;每獲得一個樣本集就用該基分類算法在該樣本集上產生一個基分類器,這樣在給定訓練輪數 n 後,就可產生 n 個基分類器,而後Boosting框架算法將這 n個基分類器進行加權融合,產生一個最後的結果分類器,在這 n個基分類器中,每一個單個的分類器的識別率不必定很高,但他們聯合後的結果有很高的識別率,這樣便提升了該弱分類算法的識別率。在產生單個的基分類器時可用相同的分類算法,也可用不一樣的分類算法,這些算法通常是不穩定的弱分類算法,如神經網絡(BP) ,決策樹(C4.5)等。

2.二、Adaboost

Adaboost是boosting中較爲表明的算法，基本思想是經過訓練數據的分佈構造一個分類器，而後經過偏差率求出這個若弱分類器的權重，經過更新訓練數據的分佈，迭代進行，直到達到迭代次數或者損失函數小於某一閾值。

Adaboost的算法流程：
假設訓練數據集爲T={(X1,Y1),(X2,Y2),(X3,Y3),(X4,Y4),(X5,Y5)} 其中Yi={-1,1}

一、初始化訓練數據的分佈
訓練數據的權重分佈爲D={W11,W12,W13,W14,W15},其中W1i=1/N。即平均分配。

二、選擇基本分類器
這裏選擇最簡單的線性分類器y=aX+b ，分類器選定以後，最小化分類偏差能夠求得參數。

三、計算分類器的係數和更新數據權重
偏差率也能夠求出來爲e1.同時能夠求出這個分類器的係數。基本的Adaboost給出的係數計算公式爲
而後更新訓練數據的權重分佈，
（圖片來自李航的統計學習方法）

四、分類器的組合

固然這種組合方式基於分類器的係數的，而分類器的係數又是根據偏差率求出來的，因此Adaboots最後影響的就是如何使用偏差率，以及訓練數據更新權重的的計算係數。

五、Adaboost的一些問題

Adaboost中涉及到一些能夠進行調整的參數和計算公式的選擇主要有如下幾點：

**弱分類器如何選擇
**如何更好的實驗偏差率計算分類器的係數
**如何更好的計算訓練數據的權重的分佈
**弱分類器如何進行組合
**迭代次數
**損失函數的閾值選取多少

三、Bagging算法

bagging方法bootstrap aggregating的縮寫，採用的是隨機有放回的選擇訓練數據而後構造分類器，最後組合。這裏以隨機森林爲例進行講解。
隨機森林算法概述

隨機森林算法是上世紀八十年代Breiman等人提出來的，其基本思想就是構造不少棵決策樹，造成一個森林，而後用這些決策樹共同決策輸出類別是什麼。隨機森林算法及在構建單一決策樹的基礎上的，同時是單一決策樹算法的延伸和改進。在整個隨機森林算法的過程當中，有兩個隨機過程，第一個就是輸入數據是隨機的從總體的訓練數據中選取一部分做爲一棵決策樹的構建，並且是有放回的選取；第二個就是每棵決策樹的構建所需的特徵是從總體的特徵集隨機的選取的，這兩個隨機過程使得隨機森林很大程度上避免了過擬合現象的出現。

隨機森林算法具體的過程：

一、從訓練數據中選取n個數據做爲訓練數據輸入，通常狀況下n是遠小於總體的訓練數據N的，這樣就會形成有一部分數據是沒法被去到的，這部分數據稱爲袋外數據，可使用袋外數據作偏差估計。

二、選取了輸入的訓練數據的以後，須要構建決策樹，具體方法是每個分裂結點從總體的特徵集M中選取m個特徵構建，通常狀況下m遠小於M。

三、在構造每棵決策樹的過程當中，按照選取最小的基尼指數進行分裂節點的選取進行決策樹的構建。決策樹的其餘結點都採起相同的分裂規則進行構建，直到該節點的全部訓練樣例都屬於同一類或者達到樹的最大深度。

四、重複第2步和第3步屢次，每一次輸入數據對應一顆決策樹，這樣就獲得了隨機森林，能夠用來對預測數據進行決策。

五、輸入的訓練數據選擇好了，多棵決策樹也構建好了，對待預測數據進行預測，好比說輸入一個待預測數據，而後多棵決策樹同時進行決策，最後採用多數投票的方式進行類別的決策。

隨機森林算法圖示

隨機森林算法的注意點：

一、在構建決策樹的過程當中是不須要剪枝的。
二、整個森林的樹的數量和每棵樹的特徵須要人爲進行設定。
三、構建決策樹的時候分裂節點的選擇是依據最小基尼係數的。

隨機森林有不少的優勢：

a. 在數據集上表現良好，兩個隨機性的引入，使得隨機森林不容易陷入過擬合。

b. 在當前的不少數據集上，相對其餘算法有着很大的優點，兩個隨機性的引入，使得隨機森林具備很好的抗噪聲能力。

c. 它可以處理很高維度（feature不少）的數據，而且不用作特徵選擇，對數據集的適應能力強：既能處理離散型數據，也能處理連續型數據，數據集無需規範化。

d. 在建立隨機森林的時候，對generlization error使用的是無偏估計。

e. 訓練速度快，能夠獲得變量重要性排序。

f. 在訓練過程當中，可以檢測到feature間的互相影響。

g 容易作成並行化方法。

h. 實現比較簡單。

1、主要目的

雖然大多數Kaggle競賽獲勝者使用各類模型的疊加/集合，可是一個特定的模式是大部分集合的部分是梯度提高（GBM）算法的一些變體。以最新的Kaggle比賽獲勝者爲例：Michael Jahrer的解決方案是在安全駕駛的預測中的表示學習。他的解決方案是6個模型的混合。1 個LightGBM（GBM的變體）和5個神經網絡。雖然他的成功歸因於他爲結構化數據發明的新的半監督學習，但梯度提高模型也發揮了做用。

儘管GBM被普遍使用，許多從業人員仍然將其視爲複雜的黑盒算法，只是使用預建的庫運行模型。這篇文章的目的是爲了簡化所謂複雜的算法，並幫助讀者直觀地理解算法。我將解釋基本版本的梯度提高算法，並將在最後分享其不一樣的變體的連接。我已經從fast.ai庫（fastai/courses/ml1/lesson3-rf_foundations.ipynb）取得了基本的DecisionTree代碼，最重要的是，我創建了本身的簡單版本的基本梯度提高模型。

關於Ensemble, Bagging 和 Boosting的簡要描述

當咱們試圖用任何機器學習技術來預測目標變量時，實際值和預測值的主要差別是噪聲，方差和誤差。集成有助於減小這些因素。

一個集合只是一個聚集在一塊兒（例如全部預測的平均值）來做出最終預測的預測器集合。咱們使用集成的緣由是許多不一樣的預測變量試圖預測相同的目標變量將比任何單一的預測器完成的更好。集成技術進一步分爲Bagging和Boosting。

Bagging是一個簡單的集成技術，咱們創建許多獨立的預測變量/模型/學習者，並使用一些模型平均技術將它們結合起來。（例如加權平均數，多數票或正態平均數）。

咱們一般對每一個模型採用隨機的子樣本/bootstrap數據，所以全部模型彼此之間幾乎沒有差異。每一個觀察結果在全部模型中出現的機率相同。由於這種技術須要許多不相關的學習者作出最終的模型，因此經過減小方差來減小錯誤。Bagging集成的例子是隨機森林模型。

Boosting是一種集成技術，其中預測變量不是獨立的，而是按順序進行的。

這種技術使用了後面的預測變量從以前的預測變量的錯誤中學習的邏輯。所以，觀測值在後續模型中出現的機率是不相同的，而偏差最大的出現最頻繁。預測變量能夠從一系列模型中選擇，如決策樹，迴歸量，分類器等等。由於新的預測變量是從之前的預測變量所犯的錯誤中學習的，因此須要更少的時間/次數來接近實際的預測。可是咱們必須慎重選擇停機判據，不然可能致使訓練數據過分擬合。梯度提高是Boosting算法的一個例子。

圖1.集成

圖2. Bagging (獨立模式) 和 Boosting (順序模式).

參考：https：//quantdare.com/what-is-the-ding-between-bagging-and-boosting /

2、梯度提高算法

在維基百科的定義中，梯度提高是一種用於迴歸和分類問題的機器學習技術，它以弱預測模型（一般是決策樹）的集合的形式產生預測模型。

任何監督學習算法的目標是定義一個損失函數，並將其最小化。讓咱們看看梯度提高算法的數學運算。假設咱們將均方根偏差（MSE）定義爲：

咱們但願咱們的預測，使咱們的損失函數（MSE）最小。經過使用梯度降低和基於學習速率更新咱們的預測，咱們能夠找到MSE最小的值。

因此，咱們基本上是更新預測，使咱們的殘差總和接近0（或最小），預測值足夠接近實際值。

3、梯度提高背後的直覺

梯度提高背後的邏輯很簡單，（能夠直觀地理解，不使用數學符號）。我指望任何閱讀這篇文章的人均可以熟悉簡單的線性迴歸模型。

線性迴歸的一個基本假設是其殘差之和爲0，即殘差應該在0左右隨機分佈。

圖3.抽樣隨機正態分佈殘差均值在0附近

如今把這些殘差看做咱們的預測模型所犯的錯誤。雖然基於樹的模型（把決策樹看成咱們梯度提高的基本模型）並非基於這樣的假設，可是若是咱們從邏輯上（而不是統計上）考慮這個假設，那麼咱們可能證實，若是咱們可以看到一些殘差在0左右的模式，咱們能夠利用這種模式來擬合模型。

所以，梯度提高算法的直覺就是反覆利用殘差模式，增強預測能力較弱的模型，使其更好。一旦咱們達到殘差沒有任何模式能夠建模的階段，咱們能夠中止建模殘差（不然可能致使過分擬合）。在算法上，咱們正在最小化咱們的損失函數，使得測試損失達到最小值。

綜上所述，

咱們首先用簡單的模型對數據進行建模，並分析錯誤的數據。
這些錯誤經過一個簡單的模型來表示數據點是很難的。
那麼對於之後的模型，咱們特別關注那些難以處理的數據，以使它們正確。
最後，咱們經過給每一個預測變量賦予一些權重來組合全部的預測變量。

關於同一邏輯的更爲技術性的引用寫在Probably Approximately Correct: Nature’s Algorithms for Learning and Prospering in a Complex World，「這個想法是屢次使用弱的學習方法來得到連續的假設，每個調整的例子是以往發現困難和錯誤分類的。...可是，請注意，能作到這一點並不明顯」。

4、擬合梯度提高模型的步驟

讓咱們思考下面的散點圖中顯示的模擬數據，其中1個輸入（x）和1個輸出（y）變量。

圖4.模擬數據（x：輸入，y：輸出）

上面顯示的圖的數據是使用下面的python代碼生成的：

一、對數據擬合一個簡單的線性迴歸或決策樹（我在個人代碼中選擇了決策樹）[將x做爲輸入，將y做爲輸出]

二、計算偏差殘差。實際目標值減去預測目標值[e1 = y_predicted1 - y]

三、將偏差殘差的新模型做爲具備相同輸入變量的目標變量[稱爲e1_predicted]

四、將預測的殘差添加到先前的預測中[y_predicted2 = y_predicted1 + e1_predicted]

五、在剩餘的殘差上擬合另外一個模型。即[e2 = y-y_predicted2]並重復步驟2到5，直到它開始過擬合或殘差總和變成恆定。過分擬合能夠經過持續檢查驗證數據的準確性來控制。

爲了幫助理解基本概念，下面是從零開始完整實現簡單梯度提高模型的連接。 [連接：從頭開始梯度提高]

共享代碼是一種非優化的梯度提高的普通實現。庫中的大多數梯度提高模型都通過了很好的優化，而且有不少超參數。

6、工做梯度提高樹的可視化

藍點（左）是輸入（x）與輸出（y）的關係•紅線（左）顯示由決策樹預測的值•綠點（右）顯示第i次迭代的殘差與輸入（x）•迭表明示擬合梯度提高樹的順序。

圖5.梯度提高預測的可視化（前4次迭代）

圖6.梯度提高預測的可視化（第18次至第20次迭代）

咱們觀察到，在第20次迭代以後，殘差在0附近是隨機分佈的（我並非說隨機的正態分佈），咱們的預測很是接近真實值。（迭代在sklearn實現中被稱爲n_estimators）。這將是一個很好的點來中止或開始過分擬合模型。

讓咱們看看咱們的模型在第五十次迭代中的樣子。

咱們能夠看到，即便在第50次迭代以後，殘差對x的曲線看起來也與咱們在第20次迭代中看到的類似。可是，模型變得愈來愈複雜，預測過分的訓練數據，並試圖學習每一個訓練數據。因此，最好是中止在第20次迭代。

用於繪製全部上述數據的Python代碼片斷：

# plotting after prediction xa = np.array(x.x) # column name of x is x order = np.argsort(xa) xs = np.array(xa)[order] ys = np.array(predf)[order] #epreds = np.array(epred[:,None])[order] f, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize = (13,2.5)) ax1.plot(x,y, 'o') ax1.plot(xs, ys, 'r') ax1.set_title(f'Prediction (Iteration {i+1})') ax1.set_xlabel('x') ax1.set_ylabel('y / y_pred') ax2.plot(x, ei, 'go') ax2.set_title(f'Residuals vs. x (Iteration {i+1})') ax2.set_xlabel('x') ax2.set_ylabel('Residuals')

https://quantdare.com/what-is-the-difference-between-bagging-and-boosting/

bagging 和boosting都是集成機器學習算法，他們都把弱學習機器組合在一塊兒，變成強學習機器。

Bagging and Boosting are both ensemble methods in Machine Learning, but what’s the key behind them?

Bagging and Boosting are similar in that they are both ensemble techniques, where a set of weak learners are combined to create a strong learner that obtains better performance than a single one. So, let’s start from the beginning:

What is an ensemble method?

成百上千學習機器可組合起來共同解決問題

Ensemble is a Machine Learning concept in which the idea is to train multiple models using the same learning algorithm. The ensembles take part in a bigger group of methods, called multiclassifiers, where a set of hundreds or thousands of learners with a common objective are fused together to solve the problem.

The second group of multiclassifiers contain the hybrid methods. They use a set of learners too, but they can be trained using different learning techniques. Stacking is the most well-known. If you want to learn more about Stacking, you can read my previous post, 「Dream team combining classifiers「.

學習中主要錯誤包括噪音，誤差和方差。集成機器學習有助於下降噪音，誤差和方差。下降方差能夠提升模型穩定性。

The main causes of error in learning are due to noise, bias and variance. Ensemble helps to minimize these factors. These methods are designed to improve the stability and the accuracy of Machine Learning algorithms. Combinations of multiple classifiers decrease variance, especially in the case of unstable classifiers, and may produce a more reliable classification than a single classifier.

使用 Bagging 或Boosting，你必須選擇一個基礎算法。若是咱們選擇分類樹，Bagging 或Boosting將包括衆多樹。

To use Bagging or Boosting you must select a base learner algorithm. For example, if we choose a classification tree, Bagging and Boosting would consist of a pool of trees as big as we want.

How do Bagging and Boosting get N learners?

重複抽樣法把訓練數據分爲若干份。Bagging任何一個元素有相同機率出如今新的訓練數據集，可是boosting用了加權，某些元素出現機率不一樣。

Bagging and Boosting get N learners by generating additional data in the training stage. N new training data sets are produced by random sampling with replacement from the original set. By sampling with replacement some observations may be repeated in each new training data set.

In the case of Bagging, any element has the same probability to appear in a new data set. However, for Boosting the observations are weighted and therefore some of them will take part in the new sets more often:

These multiple sets are used to train the same learner algorithm and therefore different classifiers are produced.

Why are the data elements weighted?

bagging用並行方法訓練數據，boosting用線性方法訓練數據

At this point, we begin to deal with the main difference between the two methods. While the training stage is parallel for Bagging (i.e., each model is built independently), Boosting builds the new learner in a sequential way:

boosting算法中，每一個分類器用於訓練數據時參考了以前分類器的成功失敗。每次訓練後，權重會程序調整。分錯的數據會增長錯誤分類數據的權重。下一個分類器會關注上個分類器錯誤的數據（權重大）

In Boosting algorithms each classifier is trained on data, taking into account the previous classifiers’ success. After each training step, the weights are redistributed. Misclassified data increases its weights to emphasise the most difficult cases. In this way, subsequent learners will focus on them during their training.

How does the classification stage work?

分類環節中，bagging採用投票機制，少數服從多數。boosting採用加權平均法來預測數據。

To predict the class of new data we only need to apply the N learners to the new observations. In Bagging the result is obtained by averaging the responses of the N learners (or majority vote). However, Boosting assigns a second set of weights, this time for the N classifiers, in order to take a weighted average of their estimates.

在Boosting訓練階段，算法爲每一個結果模型分配權重。訓練數據的分類結果良好的學習者將被賦予高權重，差的分類器被賦予低權重。所以，在評估新學習者時，boosting要跟蹤以前學習機器的錯誤

In the Boosting training stage, the algorithm allocates weights to each resulting model. A learner with good a classification result on the training data will be assigned a higher weight than a poor one. So when evaluating a new learner, Boosting needs to keep track of learners’ errors, too. Let’s see the differences in the procedures:

一些新的boosting算法包括額外條件保留或丟棄學習機器。例如，在AdaBoost中，最着名的是，維護模型須要小於50％的偏差; 不然，重複迭代直至得到比隨機猜想更好的學習機器。boosting算法中，常見的有 AdaBoost, LPBoost, XGBoost, GradientBoost, BrownBoost

Some of the Boosting techniques include an extra-condition to keep or discard a single learner. For example, in AdaBoost, the most renowned, an error less than 50% is required to maintain the model; otherwise, the iteration is repeated until achieving a learner better than a random guess.

The previous image shows the general process of a Boosting method, but several alternatives exist with different ways to determine the weights to use in the next training step and in the classification stage. Click here if you like to go into detail: AdaBoost, LPBoost, XGBoost, GradientBoost, BrownBoost.

Which is the best, Bagging or Boosting?

bagging和boosting哪一個分類器最好?沒有最好分類器，要根據數據維度，數據分佈，環境，缺失值，數據量，目標等來選擇模型。bagging和boosting下降單個模型方差，他們均可以獲得穩定性最好模型。若是一個模型的表現力不好，bagging很難減小誤差，boosting能夠減小誤差，讓模型得到更高準確性。

若是模型的主要問題是過分擬合，bagging是最好選擇。boosting不能解決過分擬合問題

There’s not an outright winner; it depends on the data, the simulation and the circumstances.
Bagging and Boosting decrease the variance of your single estimate as they combine several estimates from different models. So the result may be a model with higher stability.

If the problem is that the single model gets a very low performance, Bagging will rarely get a better bias. However, Boosting could generate a combined model with lower errors as it optimises the advantages and reduces pitfalls of the single model.

By contrast, if the difficulty of the single model is over-fitting, then Bagging is the best option. Boosting for its part doesn’t help to avoid over-fitting; in fact, this technique is faced with this problem itself. For this reason, Bagging is effective more often than Boosting.

bagging和boosting的相同點和區別

相同點不一樣點

1.二者都是集成類機器學習算法 bagging的每一個分類器是獨立的，boosting每一個分類器不是獨立的，下個分類器決策依賴上個分類器

2.都採用隨機抽樣 boosting抽樣會加大錯誤數據權重

3.都採用投票機制來預測數據 bagging的每一個分類器權重一致，boosting的每一個分類器權重不一致，好的分類器權重更大

4.兩個分類器都減小方差，增長穩定性 boosting增長準確性時也增長過分擬合，bagging能夠減小過分擬合

從結構到性能，一文概述XGBoost、Light GBM和CatBoost的同與不一樣

文章選自Medium，機器之心編譯，原文點此跳轉。

儘管近年來神經網絡復興並大爲流行，可是 boosting 算法在訓練樣本量有限、所需訓練時間較短、缺少調參知識等場景依然有其不可或缺的優點。本文從算法結構差別、每一個算法的分類變量時的處理、算法在數據集上的實現等多個方面對 3 種表明性的 boosting 算法 CatBoost、Light GBM 和 XGBoost 進行了對比；雖然本文結論依據於特定的數據集，但一般狀況下，XGBoost 都比另外兩個算法慢。

最近，我參加了 kaggle 競賽 WIDS Datathon，並經過使用多種 boosting 算法，最終排名前十。從那時開始，我就對這些算法的內在工做原理很是好奇，包括調參及其優劣勢，因此有了這篇文章。儘管最近幾年神經網絡復興，並變得流行起來，但我仍是更加關注 boosting 算法，由於在訓練樣本量有限、所需訓練時間較短、缺少調參知識的場景中，它們依然擁有絕對優點。

2014 年 3 月，XGBOOST 最先做爲研究項目，由陳天奇提出
2017 年 1 月，微軟發佈首個穩定版 LightGBM
2017 年 4 月，俄羅斯頂尖技術公司 Yandex 開源 CatBoost

因爲 XGBoost（一般被稱爲 GBM 殺手）已經在機器學習領域出現了好久，現在有很是多詳細論述它的文章，因此本文將重點討論 CatBoost 和 LGBM，在下文咱們將談到：

算法結構差別
每一個算法的分類變量時的處理
如何理解參數
算法在數據集上的實現
每一個算法的表現

LightGBM 和 XGBoost 的結構差別

在過濾數據樣例尋找分割值時，LightGBM 使用的是全新的技術：基於梯度的單邊採樣（GOSS）；而 XGBoost 則經過預分類算法和直方圖算法來肯定最優分割。這裏的樣例（instance）表示觀測值/樣本。

首先讓咱們理解預分類算法如何工做：

對於每一個節點，遍歷全部特徵
對於每一個特徵，根據特徵值分類樣例
進行線性掃描，根據當前特徵的基本信息增益，肯定最優分割
選取全部特徵分割結果中最好的一個

簡單說，直方圖算法在某個特徵上將全部數據點劃分到離散區域，並經過使用這些離散區域來肯定直方圖的分割值。雖然在計算速度上，和須要在預分類特徵值上遍歷全部可能的分割點的預分類算法相比，直方圖算法的效率更高，但和 GOSS 算法相比，其速度仍然更慢。

爲何 GOSS 方法如此高效？

在 Adaboost 中，樣本權重是展現樣本重要性的很好的指標。但在梯度提高決策樹（GBDT）中，並無自然的樣本權重，所以 Adaboost 所使用的採樣方法在這裏就不能直接使用了，這時咱們就須要基於梯度的採樣方法。

梯度表徵損失函數切線的傾斜程度，因此天然推理到，若是在某些意義上數據點的梯度很是大，那麼這些樣本對於求解最優分割點而言就很是重要，由於算其損失更高。

GOSS 保留全部的大梯度樣例，並在小梯度樣例上採起隨機抽樣。好比，假若有 50 萬行數據，其中 1 萬行數據的梯度較大，那麼個人算法就會選擇（這 1 萬行梯度很大的數據+x% 從剩餘 49 萬行中隨機抽取的結果）。若是 x 取 10%，那麼最後選取的結果就是經過肯定分割值獲得的，從 50 萬行中抽取的 5.9 萬行。

在這裏有一個基本假設：若是訓練集中的訓練樣例梯度很小，那麼算法在這個訓練集上的訓練偏差就會很小，由於訓練已經完成了。

爲了使用相同的數據分佈，在計算信息增益時，GOSS 在小梯度數據樣例上引入一個常數因子。所以，GOSS 在減小數據樣例數量與保持已學習決策樹的準確度之間取得了很好的平衡。

高梯度/偏差的葉子，用於 LGBM 中的進一步增加

每一個模型是如何處理屬性分類變量的？

CatBoost

CatBoost 可賦予分類變量指標，進而經過獨熱最大量獲得獨熱編碼形式的結果（獨熱最大量：在全部特徵上，對小於等於某個給定參數值的不一樣的數使用獨熱編碼）。

若是在 CatBoost 語句中沒有設置「跳過」，CatBoost 就會將全部列看成數值變量處理。

注意，若是某一列數據中包含字符串值，CatBoost 算法就會拋出錯誤。另外，帶有默認值的 int 型變量也會默認被當成數值數據處理。在 CatBoost 中，必須對變量進行聲明，纔可讓算法將其做爲分類變量處理。

對於可取值的數量比獨熱最大量還要大的分類變量，CatBoost 使用了一個很是有效的編碼方法，這種方法和均值編碼相似，但能夠下降過擬合狀況。它的具體實現方法以下：

1. 將輸入樣本集隨機排序，並生成多組隨機排列的狀況。

2. 將浮點型或屬性值標記轉化爲整數。

3. 將全部的分類特徵值結果都根據如下公式，轉化爲數值結果。

其中 CountInClass 表示在當前分類特徵值中，有多少樣本的標記值是「1」；Prior 是分子的初始值，根據初始參數肯定。TotalCount 是在全部樣本中（包含當前樣本），和當前樣本具備相同的分類特徵值的樣本數量。

能夠用下面的數學公式表示：

LightGBM

和 CatBoost 相似，LighGBM 也能夠經過使用特徵名稱的輸入來處理屬性數據；它沒有對數據進行獨熱編碼，所以速度比獨熱編碼快得多。LGBM 使用了一個特殊的算法來肯定屬性特徵的分割值。

注意，在創建適用於 LGBM 的數據集以前，須要將分類變量轉化爲整型變量；此算法不容許將字符串數據傳給分類變量參數。

XGBoost

和 CatBoost 以及 LGBM 算法不一樣，XGBoost 自己沒法處理分類變量，而是像隨機森林同樣，只接受數值數據。所以在將分類數據傳入 XGBoost 以前，必須經過各類編碼方式：例如標記編碼、均值編碼或獨熱編碼對數據進行處理。

超參數中的類似性

全部的這些模型都須要調節大量參數，但咱們只談論其中重要的。如下是將不一樣算法中的重要參數按照功能進行整理的表格。

實現

在這裏，我使用了 2015 年航班延誤的 Kaggle 數據集，其中同時包含分類變量和數值變量。這個數據集中一共有約 500 萬條記錄，所以很適合用來同時評估比較三種 boosting 算法的訓練速度和準確度。我使用了 10% 的數據：50 萬行記錄。

如下是建模使用的特徵：

月、日、星期：整型數據
航線或航班號：整型數據
出發、到達機場：數值數據
出發時間：浮點數據
到達延誤狀況：這個特徵做爲預測目標，並轉爲二值變量：航班是否延誤超過 10 分鐘
距離和飛行時間：浮點數據

import pandas as pd, numpy as np, time
from sklearn.model_selection import train_test_split

data = pd.read_csv("flights.csv")
data = data.sample(frac = 0.1, random_state=10)

data = data[["MONTH","DAY","DAY_OF_WEEK","AIRLINE","FLIGHT_NUMBER","DESTINATION_AIRPORT",
                 "ORIGIN_AIRPORT","AIR_TIME", "DEPARTURE_TIME","DISTANCE","ARRIVAL_DELAY"]]
data.dropna(inplace=True)

data["ARRIVAL_DELAY"] = (data["ARRIVAL_DELAY"]>10)*1

cols = ["AIRLINE","FLIGHT_NUMBER","DESTINATION_AIRPORT","ORIGIN_AIRPORT"]
for item in cols:
    data[item] = data[item].astype("category").cat.codes +1

train, test, y_train, y_test = train_test_split(data.drop(["ARRIVAL_DELAY"], axis=1), data["ARRIVAL_DELAY"],
                                                random_state=10, test_size=0.25)

XGBoost

import xgboost as xgb
from sklearn import metrics

def auc(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict_proba(train)[:,1]),
                            metrics.roc_auc_score(y_test,m.predict_proba(test)[:,1]))

# Parameter Tuning
model = xgb.XGBClassifier()
param_dist = {"max_depth": [10,30,50],
              "min_child_weight" : [1,3,6],
              "n_estimators": [200],
              "learning_rate": [0.05, 0.1,0.16],}
grid_search = GridSearchCV(model, param_grid=param_dist, cv = 3, 
                                   verbose=10, n_jobs=-1)
grid_search.fit(train, y_train)

grid_search.best_estimator_

model = xgb.XGBClassifier(max_depth=50, min_child_weight=1,  n_estimators=200,\
                          n_jobs=-1 , verbose=1,learning_rate=0.16)
model.fit(train,y_train)

auc(model, train, test)

Light GBM

import lightgbm as lgb
from sklearn import metrics

def auc2(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict(train)),
                            metrics.roc_auc_score(y_test,m.predict(test)))

lg = lgb.LGBMClassifier(silent=False)
param_dist = {"max_depth": [25,50, 75],
              "learning_rate" : [0.01,0.05,0.1],
              "num_leaves": [300,900,1200],
              "n_estimators": [200]
             }
grid_search = GridSearchCV(lg, n_jobs=-1, param_grid=param_dist, cv = 3, scoring="roc_auc", verbose=5)
grid_search.fit(train,y_train)
grid_search.best_estimator_

d_train = lgb.Dataset(train, label=y_train)
params = {"max_depth": 50, "learning_rate" : 0.1, "num_leaves": 900,  "n_estimators": 300}

# Without Categorical Features
model2 = lgb.train(params, d_train)
auc2(model2, train, test)

#With Catgeorical Features
cate_features_name = ["MONTH","DAY","DAY_OF_WEEK","AIRLINE","DESTINATION_AIRPORT",
                 "ORIGIN_AIRPORT"]
model2 = lgb.train(params, d_train, categorical_feature = cate_features_name)
auc2(model2, train, test)

CatBoost

在對 CatBoost 調參時，很難對分類特徵賦予指標。所以，我同時給出了不傳遞分類特徵時的調參結果，並評估了兩個模型：一個包含分類特徵，另外一個不包含。我單獨調整了獨熱最大量，由於它並不會影響其餘參數。

import catboost as cb
cat_features_index = [0,1,2,3,4,5,6]

def auc(m, train, test): 
    return (metrics.roc_auc_score(y_train,m.predict_proba(train)[:,1]),
                            metrics.roc_auc_score(y_test,m.predict_proba(test)[:,1]))

params = {'depth': [4, 7, 10],
          'learning_rate' : [0.03, 0.1, 0.15],
         'l2_leaf_reg': [1,4,9],
         'iterations': [300]}
cb = cb.CatBoostClassifier()
cb_model = GridSearchCV(cb, params, scoring="roc_auc", cv = 3)
cb_model.fit(train, y_train)

With Categorical features
clf = cb.CatBoostClassifier(eval_metric="AUC", depth=10, iterations= 500, l2_leaf_reg= 9, learning_rate= 0.15)
clf.fit(train,y_train)
auc(clf, train, test)

With Categorical features
clf = cb.CatBoostClassifier(eval_metric="AUC",one_hot_max_size=31, \
                            depth=10, iterations= 500, l2_leaf_reg= 9, learning_rate= 0.15)
clf.fit(train,y_train, cat_features= cat_features_index)
auc(clf, train, test)

結語

爲了評估模型，咱們應該同時考慮模型的速度和準確度表現。

請記住，CatBoost 在測試集上表現得最好，測試集的準確度最高（0.816）、過擬合程度最小（在訓練集和測試集上的準確度很接近）以及最小的預測和調試時間。但這個表現僅僅在有分類特徵，並且調節了獨熱最大量時纔會出現。若是不利用 CatBoost 算法在這些特徵上的優點，它的表現效果就會變成最差的：僅有 0.752 的準確度。所以咱們認爲，只有在數據中包含分類變量，同時咱們適當地調節了這些變量時，CatBoost 纔會表現很好。

第二個使用的是 XGBoost，它的表現也至關不錯。即便不考慮數據集包含有轉換成數值變量以後能使用的分類變量，它的準確率也和 CatBoost 很是接近了。可是，XGBoost 惟一的問題是：它太慢了。尤爲是對它進行調參，很是使人崩潰（我用了 6 個小時來運行 GridSearchCV——太糟糕了）。更好的選擇是分別調參，而不是使用 GridSearchCV。

最後一個模型是 LightGBM，這裏須要注意的一點是，在使用 CatBoost 特徵時，LightGBM 在訓練速度和準確度上的表現都很是差。我認爲這是由於它在分類數據中使用了一些修正的均值編碼方法，進而致使了過擬合（訓練集準確率很是高：0.999，尤爲是和測試集準確率相比之下）。但若是咱們像使用 XGBoost 同樣正常使用 LightGBM，它會比 XGBoost 更快地得到類似的準確度，若是不是更高的話（LGBM—0.785, XGBoost—0.789）。

最後必須指出，這些結論在這個特定的數據集下成立，在其餘數據集中，它們可能正確，也可能並不正確。但在大多數狀況下，XGBoost 都比另外兩個算法慢。

python風控建模實戰lendingClub(博主錄製，catboost，lightgbm建模，2K超清分辨率)

https://study.163.com/course/courseMain.htm?courseId=1005988013&share=2&shareId=400000000398149

微信掃二維碼，免費學習更多python資源

相關標籤/搜索