• 机器学习——boosting之XGBoost(未完）

    划水一整天，模型看了仨！不错，虽然现在在打哈欠，还是很想把XGBoost梳理梳理
    先从名字开始

    XGBoost，eXtreme Gradient Boosting: em。。。。不理解

    书上说，XGBoost有很好的性能，在各大比赛中大放异彩，行吧，冲这句，好好看看！

    看了几篇，总感觉这个XGBoost不仅仅是对GBDT的改进版，还包含了对CART决策树的改进

    1. 首先，GBDT是经过泰勒一阶导出来的，XGBoost则是经过泰勒二阶导，越高阶导越接近原函数值

    初始的平方损失函数为 L o r i g i n a l = ( y i − y p r e ) 2 L_{original} = (y_i-y_{pre})^2 Loriginal​=(yi​−ypre​)2，由于 y p r e y_{pre} ypre​是由 y p r e = f ( x ) = ∑ i = 1 m f i ( x ) y_{pre}=f(x)=∑_{i=1}^mf_i(x) ypre​=f(x)=∑i=1m​fi​(x)

    因此， L o r i g i n a l = L ( y , f ( x ) ) ，表示由 y 和 f ( x ) 影响 L 值 L_{original}=L(y,f(x))，表示由y和f(x)影响L值 Loriginal​=L(y,f(x))，表示由y和f(x)影响L值

    L ( y , f ( x ) ) = L m − 1 ( y , f m − 1 ( x ) ) + ə L ( y , f m − 1 ( x ) ) ə f m − 1 ( x ) ∗ [ f ( x ) − f m − 1 ( x ) ] + 1 2 ∗ ə L ( y , f m − 1 ( x ) ) 2 ə f m − 1 ( x ) 2 ∗ ( f ( x ) − f m − 1 ( x ) ) 2 L(y,f(x)) = L_{m-1}(y,f_{m-1}(x))+\frac{ə_{L(y,f_{m-1}(x))}}{ə_{f_{m-1}(x)}}*[f(x)-f_{m-1}(x)]+\frac{1}{2}*\frac{ə^2_{L(y,f_{m-1}(x))}}{ə^2_{f_{m-1}(x)}}*(f(x)-f_{m-1}(x))^2 L(y,f(x))=Lm−1​(y,fm−1​(x))+əfm−1​(x)​əL(y,fm−1​(x))​​∗[f(x)−fm−1​(x)]+21​∗əfm−1​(x)2​əL(y,fm−1​(x))2​​∗(f(x)−fm−1​(x))2

    令 g i = ə L ( y i , f m − 1 ( x i ) ) ə f m − 1 ( x i ) g_i = \frac{ə_{L(y_i,f_{m-1}(x_i))}}{ə_{f_{m-1}(x_i)}} gi​=əfm−1​(xi​)​əL(yi​,fm−1​(xi​))​​， h i = ə L ( y , f m − 1 ( x i ) ) 2 ə f m − 1 ( x i ) 2 h_i = \frac{ə^2_{L(y,f_{m-1}(x_i))}}{ə^2_{f_{m-1}(x_i)}} hi​=əfm−1​(xi​)2​əL(y,fm−1​(xi​))2​​， L ( y , f m − 1 ( x ) ) L(y,f_{m-1}(x)) L(y,fm−1​(x))这仨都是前m-1轮的，相当于常数

    令 f ( x ) = f m ( x ) f(x)=f_m(x) f(x)=fm​(x)，则有 T m = f m ( x ) − f m − 1 ( x ) T_m = f_m(x)-f_{m-1}(x) Tm​=fm​(x)−fm−1​(x)

    则 L m ( y , f m ( x ) ) = L m − 1 ( y , f m − 1 ( x ) ) + ∑ i = 1 N d a t a g i ∗ T m ( x i , θ m ) + 1 2 ∑ i = 1 N d a t a h i ∗ T m 2 ( x i , θ m ) L_m(y,f_m(x)) = L_{m-1}(y,f_{m-1}(x))+∑_{i=1}^{N_{data}}g_i*T_m(x_i,θ_m)+\frac{1}{2}∑_{i=1}^{N_{data}}h_i*T^2_m(x_i,θ_m) Lm​(y,fm​(x))=Lm−1​(y,fm−1​(x))+∑i=1Ndata​​gi​∗Tm​(xi​,θm​)+21​∑i=1Ndata​​hi​∗Tm2​(xi​,θm​)

    2. 其次，XGBoost的优化①：增加正则化项 Ω ( T m ( x ) ) Ω(T_m(x)) Ω(Tm​(x))

    晕了…明天再说！
    本来周末把书带回家，准备要看看…果然，美男误我…

    这里的 Ω ( T m ( x ) ) = γ ∗ N 叶 + λ ∑ i = 1 N 叶 C i 2 ( x ) Ω(T_m(x)) = γ*N_{叶}+λ∑_{i=1}^{N_{叶}}C_{i}^2(x) Ω(Tm​(x))=γ∗N叶​+λ∑i=1N叶​​Ci2​(x)，这里的 N 叶 N_叶 N叶​表示所有叶子节点的个数， C i ( x ) C_{i}(x) Ci​(x)是叶子节点的均值

    γ ∗ N 叶 γ*N_{叶} γ∗N叶​是对叶子节点个数的惩罚，毕竟如果分裂太多，容易过拟合

    但 λ ∑ i = 1 N 叶 C i 2 ( x ) λ∑_{i=1}^{N_{叶}}C_{i}^2(x) λ∑i=1N叶​​Ci2​(x)是为什么要对叶子均值进行惩罚呢？

    哦！

    因为在XGBoost中，每个叶子节点的均值，其实都是这组叶子节点的残差均值

    但有些残差是正的，有些是负的，那要衡量拟合效果是否好，应该看与0的差距。

    • 残差为0，表示完美拟合
    • 残差为正，表示大于原值
    • 残差为负，表示小于原值

    那么为了统一表示拟合效果，直接求平方，可避免正、负判别，且计算起来比绝对值更方便。

    因此， λ ∑ i = 1 N 叶 C i 2 ( x ) λ∑_{i=1}^{N_{叶}}C_{i}^2(x) λ∑i=1N叶​​Ci2​(x)主要是对残差的惩罚

    所以有 Ω ( T m ( x ) ) = γ ∗ N 叶 + λ ∑ i = 1 N 叶 C i 2 ( x ) Ω(T_m(x)) = γ*N_{叶}+λ∑_{i=1}^{N_{叶}}C_{i}^2(x) Ω(Tm​(x))=γ∗N叶​+λ∑i=1N叶​​Ci2​(x)，完成了对叶子数量和残差的惩罚

    惩罚项也加入到 L K L_K LK​损失函数里

    L m ( y , f m ( x ) ) = L m − 1 ( y , f m − 1 ( x ) ) + ∑ i = 1 N d a t a g i ∗ T m ( x i , θ m ) + 1 2 ∑ i = 1 N d a t a h i ∗ T m 2 ( x i , θ m ) + γ ∗ N 叶 + λ ∑ i = 1 N 叶 C i 2 ( x ) L_m(y,f_m(x)) = L_{m-1}(y,f_{m-1}(x))+∑_{i=1}^{N_{data}}g_i*T_m(x_i,θ_m)+\frac{1}{2}∑_{i=1}^{N_{data}}h_i*T^2_m(x_i,θ_m)+ γ*N_{叶}+λ∑_{i=1}^{N_{叶}}C_{i}^2(x) Lm​(y,fm​(x))=Lm−1​(y,fm−1​(x))+∑i=1Ndata​​gi​∗Tm​(xi​,θm​)+21​∑i=1Ndata​​hi​∗Tm2​(xi​,θm​)+γ∗N叶​+λ∑i=1N叶​​Ci2​(x)

    求这个损失函数的极小值，求极值的时候，常数项不需要参与运算，因此函数里可以去掉常数项 L m − 1 ( y , f m − 1 ( x ) ) L_{m-1}(y,f_{m-1}(x)) Lm−1​(y,fm−1​(x))，并且为了求极值计算方便，还可以将平方项 λ ∑ i = 1 N 叶 C i 2 ( x ) λ∑_{i=1}^{N_{叶}}C_{i}^2(x) λ∑i=1N叶​​Ci2​(x)的系数，设为 1 2 \frac{1}{2} 21​这样后续求极值时可以化简运算

    最终 L m ( y , f m ( x ) ) = ∑ i = 1 N d a t a g i ∗ T m ( x i , θ m ) + 1 2 ∑ i = 1 N d a t a h i ∗ T m 2 ( x i , θ m ) + γ ∗ N 叶 + 1 2 λ ∑ i = 1 N 叶 C i 2 ( x ) L_m(y,f_m(x)) =∑_{i=1}^{N_{data}}g_i*T_m(x_i,θ_m)+\frac{1}{2}∑_{i=1}^{N_{data}}h_i*T^2_m(x_i,θ_m)+ γ*N_{叶}+\frac{1}{2}λ∑_{i=1}^{N_{叶}}C_{i}^2(x) Lm​(y,fm​(x))=∑i=1Ndata​​gi​∗Tm​(xi​,θm​)+21​∑i=1Ndata​​hi​∗Tm2​(xi​,θm​)+γ∗N叶​+21​λ∑i=1N叶​​Ci2​(x)

    这里要梳理一下 N d a t a 和 N 叶 N_{data}和N_{叶} Ndata​和N叶​的关系
    在这里插入图片描述
    所以，可以将损失函数里式子进行转化

    • ∑ i = 1 N d a t a g i ∗ T m ( x i , θ m ) = ∑ j = 1 N 叶 （ ∑ i ∈ I ( j ) g i ） C j ( x ) ∑_{i=1}^{N_{data}}g_i*T_m(x_i,θ_m)=∑_{j=1}^{N_{叶}}（∑_{i∈I(j)}g_i）C_{j}(x) ∑i=1Ndata​​gi​∗Tm​(xi​,θm​)=∑j=1N叶​​（∑i∈I(j)​gi​）Cj​(x)，用 G j 表示 ∑ i ∈ I ( j ) g i G_j表示∑_{i∈I(j)}g_i Gj​表示∑i∈I(j)​gi​
    • ∑ i = 1 N d a t a h i ∗ T m 2 ( x i , θ m ) = ∑ j = 1 N 叶 （ ∑ i ∈ I ( j ) h i ） C j 2 ( x ) ∑_{i=1}^{N_{data}}h_i*T^2_m(x_i,θ_m)=∑_{j=1}^{N_{叶}}（∑_{i∈I(j)}h_i）C_{j}^2(x) ∑i=1Ndata​​hi​∗Tm2​(xi​,θm​)=∑j=1N叶​​（∑i∈I(j)​hi​）Cj2​(x)，用 H j 表示 ∑ i ∈ I ( j ) h i H_j表示∑_{i∈I(j)}h_i Hj​表示∑i∈I(j)​hi​

    则损失函数为
    L m ( y , f m ( x ) ) = ∑ j = 1 N 叶 G j C j ( x ) + 1 2 ∑ j = 1 N 叶 H j C j 2 ( x ) + γ ∗ N 叶 + 1 2 λ ∑ j = 1 N 叶 C j 2 ( x ) + λ N 叶 L_m(y,f_m(x)) =∑_{j=1}^{N_{叶}}G_jC_{j}(x)+\frac{1}{2}∑_{j=1}^{N_{叶}}H_jC_{j}^2(x)+ γ*N_{叶}+\frac{1}{2}λ∑_{j=1}^{N_{叶}}C_{j}^2(x)+λN_{叶} Lm​(y,fm​(x))=∑j=1N叶​​Gj​Cj​(x)+21​∑j=1N叶​​Hj​Cj2​(x)+γ∗N叶​+21​λ∑j=1N叶​​Cj2​(x)+λN叶​

    合并同类项：

    L m ( y , f m ( x ) ) L_m(y,f_m(x)) Lm​(y,fm​(x))

    = ∑ j = 1 N 叶 G j C j ( x ) + 1 2 ∑ j = 1 N 叶 （ H j + λ ） C j 2 ( x ) + γ ∗ N 叶 =∑_{j=1}^{N_{叶}}G_jC_{j}(x)+\frac{1}{2}∑_{j=1}^{N_{叶}}（H_j+λ）C_{j}^2(x)+ γ*N_{叶} =∑j=1N叶​​Gj​Cj​(x)+21​∑j=1N叶​​（Hj​+λ）Cj2​(x)+γ∗N叶​

    = ∑ j = 1 N 叶 [ G j C j ( x ) + 1 2 ( H j + λ ) C j 2 ( x ) + γ ] =∑_{j=1}^{N_{叶}}[G_jC_{j}(x)+\frac{1}{2}(H_j+λ)C_{j}^2(x)+ γ] =∑j=1N叶​​[Gj​Cj​(x)+21​(Hj​+λ)Cj2​(x)+γ]

    • G j = ∑ i ∈ I ( j ) g i = ∑ i ∈ I ( j ) ə L ( y i , f m − 1 ( x i ) ) ə f m − 1 ( x i ) G_j=∑_{i∈I(j)}g_i=∑_{i∈I(j)} \frac{ə_{L(y_i,f_{m-1}(x_i))}}{ə_{f_{m-1}(x_i)}} Gj​=∑i∈I(j)​gi​=∑i∈I(j)​əfm−1​(xi​)​əL(yi​,fm−1​(xi​))​​，是常数项
    • H j = ∑ i ∈ I ( j ) h i = ∑ i ∈ I ( j ) ə L ( y , f m − 1 ( x i ) ) 2 ə f m − 1 ( x i ) 2 H_j=∑_{i∈I(j)}h_i=∑_{i∈I(j)}\frac{ə^2_{L(y,f_{m-1}(x_i))}}{ə^2_{f_{m-1}(x_i)}} Hj​=∑i∈I(j)​hi​=∑i∈I(j)​əfm−1​(xi​)2​əL(y,fm−1​(xi​))2​​，也是常数项
    • γ也是我们提前设置的常数项
    • 只要计算出每个叶子节点中的 G j C j ( x ) + 1 2 ( H j + λ ) C j 2 ( x ) + γ G_jC_{j}(x)+\frac{1}{2}(H_j+λ)C_{j}^2(x)+ γ Gj​Cj​(x)+21​(Hj​+λ)Cj2​(x)+γ极小值，就可以算出所有叶子节点 ∑ j = 1 N 叶 G j C j ( x ) + 1 2 ∑ j = 1 N 叶 （ H j + λ ） C j 2 ( x ) + γ ∗ N 叶 ∑_{j=1}^{N_{叶}}G_jC_{j}(x)+\frac{1}{2}∑_{j=1}^{N_{叶}}（H_j+λ）C_{j}^2(x)+ γ*N_{叶} ∑j=1N叶​​Gj​Cj​(x)+21​∑j=1N叶​​（Hj​+λ）Cj2​(x)+γ∗N叶​的极小值
    • L j = 1 2 ( H j + λ ) C j 2 ( x ) + G j C j ( x ) + γ L_j =\frac{1}{2}(H_j+λ)C_{j}^2(x)+ G_jC_{j}(x)+ γ Lj​=21​(Hj​+λ)Cj2​(x)+Gj​Cj​(x)+γ相当于一元二次方程 y = a x 2 + b x + c y = ax^2+bx+c y=ax2+bx+c，在 x = − b 2 a x=-\frac{b}{2a} x=−2ab​处可以取到极值 4 a c − b 2 4 a \frac{4ac-b^2}{4a} 4a4ac−b2​
    • 因此当 C j ( x ) = − G j H j + λ C_{j}(x) = -\frac{G_j}{H_j+λ} Cj​(x)=−Hj​+λGj​​时，可以求到单个叶子节点的损失函数极小值 m i n : L j = 2 γ ( H j + λ ) − G j 2 2 ( H j + λ ) = γ − G j 2 2 ( H j + λ ) min:L_j=\frac{2γ(H_j+λ)-G_j^2}{2(H_j+λ)}=γ-\frac{G_j^2}{2(H_j+λ)} min:Lj​=2(Hj​+λ)2γ(Hj​+λ)−Gj2​​=γ−2(Hj​+λ)Gj2​​
    • 那么第m次迭代时所有样本的损失函数为， m i n : L m ( y , f m ( x ) ) = ∑ j = 1 N 叶 [ γ − G j 2 2 ( H j + λ ) ] min:L_m(y,f_m(x))=∑_{j=1}^{N_{叶}}[γ-\frac{G_j^2}{2(H_j+λ)}] min:Lm​(y,fm​(x))=∑j=1N叶​​[γ−2(Hj​+λ)Gj2​​]

    3. 最后，XGBoost的决策树分裂的特征及特征值，与CART决策树选取标准是不同的

    CART决策树是根据基尼系数最小，选取的特征及特征值来分裂树
    而XGBoost是可以采用贪心算法，根据特征及特征值分裂后的损失函数增益最大值，来选取的特征及特征值来分裂树

    • 损失函数增益，指的是，每次分裂一个节点时，损失值减小的程度
      • 当前节点的损失值会发生改变，而其他节点的损失值不变。
      • 如果当前节点的损失值比分裂前非常非常小，说明整体的损失值也会变小，增益程度也会更大
      • 如果当前节点的损失值比分裂前差不多，说明整体的损失值没有太大改变，增益程度不大
      • 因此，应该选择损失值增益最大的特征及特征值，作为分裂的节点
        在这里插入图片描述

    因此，
    G a i n = [ γ − G j 父 2 2 ( H j 父 + λ ) ] − [ γ − G j 左 2 2 ( H j 左 + λ ) ] − [ γ − G j 右 2 2 ( H j 右 + λ ) ] Gain =[γ-\frac{G_{j父}^2}{2(H_{j父}+λ)}]-[γ-\frac{G_{j左}^2}{2(H_{j左}+λ)}]-[γ-\frac{G_{j右}^2}{2(H_{j右}+λ)}] Gain=[γ−2(Hj父​+λ)Gj父2​​]−[γ−2(Hj左​+λ)Gj左2​​]−[γ−2(Hj右​+λ)Gj右2​​]

    = G j 左 2 2 ( H j 左 + λ ) + G j 右 2 2 ( H j 右 + λ ) − G j 父 2 2 ( H j 父 + λ ) − γ =\frac{G_{j左}^2}{2(H_{j左}+λ)}+\frac{G_{j右}^2}{2(H_{j右}+λ)}-\frac{G_{j父}^2}{2(H_{j父}+λ)}-γ =2(Hj左​+λ)Gj左2​​+2(Hj右​+λ)Gj右2​​−2(Hj父​+λ)Gj父2​​−γ

    其中 G j 父 2 2 ( H j 父 + λ ) \frac{G_{j父}^2}{2(H_{j父}+λ)} 2(Hj父​+λ)Gj父2​​，

    G j 父 = ∑ i ∈ I ( j 左 + j 右 ) g i = ∑ i ∈ I ( j 左 ) g i + ∑ i ∈ I ( j 右 ) g i = G j 左 + G j 右 G_{j父}=∑_{i∈I(j左+j右)}g_i=∑_{i∈I(j左)}g_i+∑_{i∈I(j右)}g_i = G_{j左}+G_{j右} Gj父​=∑i∈I(j左+j右)​gi​=∑i∈I(j左)​gi​+∑i∈I(j右)​gi​=Gj左​+Gj右​
    H j 父 = ∑ i ∈ I ( j 左 + j 右 ) h i = ∑ i ∈ I ( j 左 ) h i + ∑ i ∈ I ( j 右 ) h i = H j 左 + H j 右 H_{j父}=∑_{i∈I(j左+j右)}h_i=∑_{i∈I(j左)}h_i+∑_{i∈I(j右)}h_i = H_{j左}+H_{j右} Hj父​=∑i∈I(j左+j右)​hi​=∑i∈I(j左)​hi​+∑i∈I(j右)​hi​=Hj左​+Hj右​

    因此， G j 父 2 2 ( H j 父 + λ ) = ( G j 左 + G j 右 ) 2 2 ( H j 左 + H j 右 + λ ) \frac{G_{j父}^2}{2(H_{j父}+λ)}=\frac{(G_{j左}+G_{j右})^2}{2(H_{j左}+H_{j右}+λ)} 2(Hj父​+λ)Gj父2​​=2(Hj左​+Hj右​+λ)(Gj左​+Gj右​)2​

    所以最终的
    G a i n = G j 左 2 2 ( H j 左 + λ ) + G j 右 2 2 ( H j 右 + λ ) − G j 父 2 2 ( H j 父 + λ ) − γ Gain=\frac{G_{j左}^2}{2(H_{j左}+λ)}+\frac{G_{j右}^2}{2(H_{j右}+λ)}-\frac{G_{j父}^2}{2(H_{j父}+λ)}-γ Gain=2(Hj左​+λ)Gj左2​​+2(Hj右​+λ)Gj右2​​−2(Hj父​+λ)Gj父2​​−γ

    = G j 左 2 2 ( H j 左 + λ ) + G j 右 2 2 ( H j 右 + λ ) − ( G j 左 + G j 右 ) 2 2 ( H j 左 + H j 右 + λ ) − γ =\frac{G_{j左}^2}{2(H_{j左}+λ)}+\frac{G_{j右}^2}{2(H_{j右}+λ)}-\frac{(G_{j左}+G_{j右})^2}{2(H_{j左}+H_{j右}+λ)}-γ =2(Hj左​+λ)Gj左2​​+2(Hj右​+λ)Gj右2​​−2(Hj左​+Hj右​+λ)(Gj左​+Gj右​)2​−γ

    因此，最终是根据Gain最大的结果，来选取最优的分裂特征及特征值

    完美！

    程序设计

    1. 数据结构：一棵二叉树

    • 每个节点存储的数据：
      • 当前节点的样本残差集
      • 选择分裂的特征及特征值

    2. 实现流程：核心步骤

    • 获取当前节点的所有特征及特征值

    • 遍历每个特征及特征值

      • 根据当前特征及特征值分两组
      • 计算G左、G右
        • G i = ∑ i ∈ I ( j ) ə L ( y i , f m − 1 ( x i ) ) ə f m − 1 ( x i ) G_i=∑_{i∈I(j)} \frac{ə_{L(y_i,f_{m-1}(x_i))}}{ə_{f_{m-1}(x_i)}} Gi​=∑i∈I(j)​əfm−1​(xi​)​əL(yi​,fm−1​(xi​))​​
        • L ( y i , f m − 1 ( x i ) ) = ( y i − y p r e ) 2 = [ y i − f m − 1 ( x i ) ] 2 L(y_i,f_{m-1}(x_i))=(y_i-y_{pre})^2=[y_i-f_{m-1}(x_i)]^2 L(yi​,fm−1​(xi​))=(yi​−ypre​)2=[yi​−fm−1​(xi​)]2
        • G i = ∑ i ∈ I ( j ) ə L ( y i , f m − 1 ( x i ) ) ə f m − 1 ( x i ) = ∑ i ∈ I ( j ) [ − 2 ( y i − f m − 1 ( x i ) ) ] G_i=∑_{i∈I(j)} \frac{ə_{L(y_i,f_{m-1}(x_i))}}{ə_{f_{m-1}(x_i)}}=∑_{i∈I(j)} [-2(y_i-f_{m-1}(x_i))] Gi​=∑i∈I(j)​əfm−1​(xi​)​əL(yi​,fm−1​(xi​))​​=∑i∈I(j)​[−2(yi​−fm−1​(xi​))]
      • 计算H左、H右
        • H i = ∑ i ∈ I ( j ) ə L ( y i , f m − 1 ( x i ) ) 2 ə f m − 1 ( x i ) = ∑ i ∈ I ( j ) [ − 2 ( y i − f m − 1 ( x i ) ) ] ′ = ∑ i ∈ I ( j ) 2 y i H_i=∑_{i∈I(j)} \frac{ə^2_{L(y_i,f_{m-1}(x_i))}}{ə_{f_{m-1}(x_i)}}=∑_{i∈I(j)} [-2(y_i-f_{m-1}(x_i))]'=∑_{i∈I(j)} 2y_i Hi​=∑i∈I(j)​əfm−1​(xi​)​əL(yi​,fm−1​(xi​))2​​=∑i∈I(j)​[−2(yi​−fm−1​(xi​))]′=∑i∈I(j)​2yi​
      • 计算分组后的Gain值，记录最大值及对应的特征、特征值
        • G a i n = G j 左 2 2 ( H j 左 + λ ) + G j 右 2 2 ( H j 右 + λ ) − ( G j 左 + G j 右 ) 2 2 ( H j 左 + H j 右 + λ ) − γ Gain=\frac{G_{j左}^2}{2(H_{j左}+λ)}+\frac{G_{j右}^2}{2(H_{j右}+λ)}-\frac{(G_{j左}+G_{j右})^2}{2(H_{j左}+H_{j右}+λ)}-γ Gain=2(Hj左​+λ)Gj左2​​+2(Hj右​+λ)Gj右2​​−2(Hj左​+Hj右​+λ)(Gj左​+Gj右​)2​−γ

    • 判断Gain最大值情况下，是否可以分裂左右组

      • 条件：Gain大于0 则可以分裂，否则停止分裂

    • 将最终划分的两个组，设置为左右节点分裂，再分别递归划分

    实践遇到的问题

    问题1：XGBoost到底是一棵树还是多棵树？

    显然是多棵树

    问题2：那第一棵树的第一个分裂节点，没有 y p r e y_{pre} ypre​怎么计算G值，怎么计算Gain值?
    没有Gain值，怎么选择分裂节点？

    直击灵魂深处，万事开头难，古人诚不欺我也

    所以，为了踏出第一步，需要提前设置一个 y p r e 0 y_{pre0} ypre0​初始预测值
    这里，可以设置为 y p r e 0 = a v e r a g e ( y t r u e ) y_{pre0}=average(y_{true}) ypre0​=average(ytrue​)，表示第0棵树的所有样本预测值为所有样本真实值的均值,并记录当前预测值 f 0 ( x ) = y p r e 0 f_0(x)=y_{pre0} f0​(x)=ypre0​，计算出初始残差值 r 0 r_0 r0​

    • 1、计算出初始残差值 r 0 r_0 r0​后，开始建立第一棵树

      • 先分裂节点：
        • ①获取当前节点的所有特征及特征值
        • ②遍历特征及特征值，计算出最大gain
        • ③判断是否可以分裂
        • ④完成分裂，左右树递归
      • 再进行预测：
        • ①预测所有样本的预测值 y p r e 1 y_{pre1} ypre1​
        • ②计算当前所有树的预测结果 f 1 ( x ) = f 0 ( x ) + y p r e 1 f_{1}(x)=f_0(x)+y_{pre1} f1​(x)=f0​(x)+ypre1​

    • 2、计算出第一棵树的残差值 r 1 = y − f 1 ( x ) r_1=y-f_{1}(x) r1​=y−f1​(x)后，开始建立第二棵树

      • 先分裂节点：
        • ①获取当前节点的所有特征及特征值
        • ②遍历特征及特征值，计算出最大gain
        • ③判断是否可以分裂
        • ④完成分裂，左右树递归
      • 再进行预测：
        • ①预测所有样本的预测值 y p r e 2 y_{pre2} ypre2​
        • ②计算当前所有树的预测结果 f 2 = f 1 ( x ) + y p r e 2 f_{2}=f_1(x)+y_{pre2} f2​=f1​(x)+ypre2​

    • …

    • 这里要区分 f m ( x ) 和 y p r e f_m(x)和y_{pre} fm​(x)和ypre​的定义

      • f m ( x ) f_m(x) fm​(x)是对实际y值拟合的预测值， y p r e y_{pre} ypre​是对上一轮的残差拟合的预测值， T ( x ) = y p r e T(x)=y_{pre} T(x)=ypre​

    应该是这样的，估计要创建树的多个对象，然后维护一个全局的数据样本残差表，然后依次根据每棵树对象来更新这个样本残差表

    最后模型保留的，就是每棵树以及树的结构，树里每个节点都保留分裂的特征及特征值，保留叶子节点的均值

    最终代码

    最终我只建了10棵树，我还没想好树的数量标准
    但10棵树的预测效果，还是不错的，虽然不确定会不会过拟合，但以后有时间再验证

    终于可以进入聚类了~~~~~

    在这里插入图片描述

    import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
pd.set_option('display.max_rows',None)
# 获取所需数据：'推荐分值', '专业度','回复速度','服务态度','推荐类型'
datas = pd.read_excel('./datas4.xlsx')
important_features = ['专业度','回复速度','服务态度','推荐分值'] #
datas_1 = datas[important_features]
Y_features = '推荐分值'
X_features = X.columns

class Node():
    def __init__(self,datas):
        self.datas = datas
        self.all_feat_and_point = self.get_feat_points(datas)
        self.feat = None
        self.point = None
        self.mean = None
        self.left = None
        self.right = None
    def get_feat_points(self,datas):
        """计算出每个节点的特征及特征值"""
        feats = X_features
        feat_and_point = {}
        for feat in feats:
            feat_and_point[feat]= datas[feat].unique()
        return feat_and_point

class Tree():
    def __init__(self,datas,gama=1):
        self.datas = datas
        self.gama = gama
        self.root = Node(self.datas)
    def devide(self,node=None):
        """选择特征及特征值，进行递归分裂"""
        node.mean = node.datas['r'].mean(axis=0)
        max_gain = None
        for feat,points in node.all_feat_and_point.items():
            for point in points:
                value = self.get_gain(feat,point,node.datas)
                if max_gain==None or value['gain']>max_gain:
                    max_gain = value['gain']
                    temp_feat = feat
                    temp_point = point
                    left_datas = value['left_datas']
                    right_datas = value['right_datas']
        if max_gain<10**-7 or left_datas.empty or right_datas.empty:
            return
        node.feat = temp_feat
        node.point = temp_point
        node.left = Node(left_datas)
        node.right = Node(right_datas)
        self.devide(node.left)
        self.devide(node.right)
    
    def get_gain(self,feat,point,datas):
        """计算Gain值"""
        value = {}
        left_datas = datas[datas[feat]<=point]
        right_datas = datas[datas[feat]>point]
        G_left = 2*left_datas['Fm'].sum(axis=0)-2*left_datas[Y_features].sum(axis=0)
        G_right = 2 * right_datas['Fm'].sum(axis=0) - 2 * right_datas[Y_features].sum(axis=0)
        H_left = 2 * left_datas[Y_features].sum(axis=0)
        H_right = 2 * right_datas[Y_features].sum(axis=0)
        gain = G_left**2/(2*H_left+2*self.gama)+G_right**2/(2*H_right+2*self.gama)+(G_left+G_right)**2/(2*H_left+2*H_right+2*self.gama)
        value['gain'] = gain
        value['left_datas'] = left_datas
        value['right_datas'] = right_datas
        return value
    def get_new_datas(self):
        Y_pre = []
        for index,data in self.datas.iterrows():
            temp = self.find_Y(data,self.root)
            Y_pre.append(temp)
        self.datas['r'] = self.datas['r']-Y_pre
        self.datas['Fm'] = self.datas['Fm']+Y_pre
        return self.datas
    def find_Y(self,data,node=None):
        feat = node.feat
        point = node.point
        if feat == None:
            return node.mean
        if data[feat]<=point:
            return self.find_Y(data,node.left)
        else:
            return self.find_Y(data,node.right)

class XGB():
    def __init__(self,datas,gama=1):
        self.datas = datas
        self.gama = gama
        self.end = 10 # 建多少棵树
        self.trees = []
        self.Fm = datas[Y_features].mean(axis=0)
        self.datas['Fm'] = [self.Fm for i in range(len(self.datas))]
        self.datas['r'] = self.datas[Y_features] - self.Fm
    def learning(self):
        for i in range(self.end):
            tree = Tree(self.datas,self.gama)
            tree.devide(tree.root)
            self.datas = tree.get_new_datas()  # 更新r和fm值
            self.trees.append(tree)
        return self.trees
    def predict(self,datas):
        Y_pre = []
        for index,data in datas.iterrows():
            fm = self.Fm
            for tree in self.trees:
                temp = tree.find_Y(data,tree.root)
                fm += temp # 累计每棵树的fm，作为最终的预测值
            Y_pre.append(fm)
        return Y_pre

tree = XGB(datas_1)
tree.learning()
Y_pre = tree.predict(datas_1)

datas_1['Y_pre'] = Y_pre
datas_1['r_final'] = datas_1[Y_features]-datas_1['Y_pre']
print(datas_1[[Y_features,'Y_pre','r_final']])


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
  • 相关阅读:
    MongoDB索引操作和执行计划Explain()详解
    基于Android+vue的大学生综合信息处理软件APP设计
    沈阳陪诊系统|沈阳陪诊系统开发|沈阳陪诊系统功能和优势
    云IDE介绍——CSDN开发云
    【学习】深度学习代码各个步骤都是为了啥（一）
    第十四届蓝桥杯省赛C++ B组（个人经历 + 题解）
    《智能网联汽车自动驾驶功能测试规程》
    split(),splice(),slice()傻傻分不清楚？
    PTrade和QMT对比那个更好用？
    dind（docker in docker）学习
  • 原文地址：https://blog.csdn.net/weixin_50348308/article/details/132743146