机器学习之提升-XgBoost

算法的引入

       在平时的算法中，基本分类器可分为强分类器与弱分类器，强弱之分主要是指分类器分类的准确率，在随机森林中，算法是生成很多颗树，将这些树的结果集成，生成一个分类效果较好的分类器，随机森林中，树的建立是相互独立的，如果我们换一个想法，已经有N棵树，那么建N+1棵树时可以受前面N棵树的影响，让分类得到提升？

算法概论

      提升算法是将弱分类器集成为一个强分类器，这类算法的工作机制是:

1. 选用一个基学习器
2. 用初始的数据集对基学习器进行训练
3. 根据训练结果对样本的分布进行调整，得到一个新的训练本样集，调整是让分错的样本后面得到更多的关注
4. 用得到的新样本集对基学习器进行训练
5. 重复步骤3，4直到达到指定指标。

AdaBoost算法

     AdaBoost算法在分类问题中的主要特点是：通过改变训练样本的权重，学习多个分类器，并将这个分类器进行线性的组合，提高分类的性能

训练数据集:

                                                        

1.  初始化训练数据的权值分布，假设训练数据有均匀的权值分布
2. 使用当前的权值分布对训练数据学习，得到基本的分类器（采用使分错误差率最小为目标函数）
3. 计算上分错的误差率                                                                                                                                                                                                       
4. 计算G₁的系数                                                                                                                                                                                                      
5. 更新数据集的权值分布                                                                                                                                                                                                             
6. 用，替换,重复上面的2-5,可得到分类器分类器,依次下可以得到分类器
7.  构建分类器的线性组合                                                                                                                                                                                                           

程序示例

import numpy as np
import math

def loadData():
    x = np.arange(0, 10).reshape(-1,1)
    y = np.array([1, 1, 1, -1, -1, -1, 1, 1, 1, -1]).reshape(-1,1)
    D = np.ones_like(x) * 1.0/np.size(x)
    return x, y, D

def minErrorClassify(x, y, Di):
    gx = np.ones_like(x)

    b = np.repeat(np.arange(0, 10).reshape(-1, 1), 9, axis=1)
    xsize, ysize = b.shape
    for i in range(0, xsize, 1):
        for j in range(0, ysize, 1):
            if i > j:
                b[i][j] = 1
            else:
                b[i][j] = -1
    ry = np.repeat(y, 9, axis=1)
    ry2 = ry * b * np.repeat(Di, 9, axis=1)
    error = np.where(ry2 < 0, ry2, 0)
    error = abs(np.sum(error,axis=0)) # [-1, 1]
    error2 = 1 - error # [1 -1]
    if error.min() < error2.min():
        index = np.where(error == error.min())
        gx[0:index[0][0]+1] = -1
        return error.min(), gx
    else:
        index = np.where(error2 == error2.min())
        gx[index[0][0]+1:] = -1
        return error2.min(), gx

def predictYError(x, y, gxlist):
    predict_y = np.empty_like(y)*0
    for gxinfo in gxlist:
        a = gxinfo['a']
        gx = gxinfo['gx']
        predict_y = predict_y + a * gx
    predict_y = np.sign(predict_y)
    error = predict_y * y
    error = np.where(error < 0, error, 0)
    return predict_y,abs(error.sum())/np.size(x)


if __name__ == '__main__':
    x, y, D = loadData()
    gxlist = []
    exp = lambda t: math.exp(t)
    vfunc = np.vectorize(exp)

    D_next = D
    predict_error = 1
    min_error = 1
    while predict_error > 0.001:

        min_error,  gx = minErrorClassify(x, y, D_next)

        a = 0.5 * math.log((1-min_error)/min_error)

        gxlist.append({'a': a, 'gx': gx})
        predict_y, predict_error = predictYError(x, y, gxlist)
        print "predict_y,predict_error\n",predict_y, predict_error
        D_next = vfunc(-a*y*gx) * D_next
        D_next = D_next/D_next.sum()
        D = np.append(D,D_next,axis=1)
    print "D=", D
    print gxlist

 结果显示经过3次就可以完全分正确。修改y的值，可以测试代码。关于算法的理论明就不给出了，可以参考下在面的链接，讲的都比较好

1. https://plushunter.github.io/2017/01/26/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%AE%97%E6%B3%95%E7%B3%BB%E5%88%97%EF%BC%888%EF%BC%89%EF%BC%9AXgBoost/
2. https://blog.csdn.net/qq_39521554/article/details/80691421
3. https://www.csdn.net/gather_26/MtTacg5sNjM1MC1ibG9n.html
4. https://blog.csdn.net/weiyongle1996/article/details/77856131
5. http://www.sohu.com/a/161539462_642762
6. https://blog.csdn.net/sb19931201/article/details/52506157
7. https://blog.csdn.net/suipingsp/article/details/42264413
8. https://blog.csdn.net/sb19931201/article/details/52506157
9. https://blog.csdn.net/akon_wang_hkbu/article/details/77621631