机器学习之提升-XgBoost

最新推荐文章于 2020-12-12 11:38:36 发布

原创最新推荐文章于 2020-12-12 11:38:36 发布 · 410 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#AdaBoost算法 # 提升算法 #机器学习

本文介绍AdaBoost算法原理及实现过程，通过不断调整训练样本权重，学习多个分类器并线性组合，提高整体分类性能。

算法的引入

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

算法概论

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

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

AdaBoost算法

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

训练数据集:

$\\D=\{ (x^1,y^1),(x^2,y^2)\dots (x^M,y^M)\} \\y^i \in \{-1,+1\}$

初始化训练数据的权值分布，假设训练数据有均匀的权值分布 $D_1 = (w_{11},w_{12},\dots,w_{1i}\dots,w_{1M}),w_{1i}=\frac{1}{N}$
使用当前的权值分布 $D_1$ 对训练数据学习，得到基本的分类器 $G_1(x)$ （采用使分错误差率最小为目标函数）
计算 $G_1(x)$ 上分错的误差率 $\\e_1 = P(G_1(x^i)!=y^i)= \sum_{i=0}^M w_{1i}I(G_1(x^i)!=y^i) \\I(G_1(x^i),y^i) = \begin{cases} 0 & G_1(x^i) == y^i \\ 1 & G_1(x^i) != y^i \end{cases}$
计算G<sub>1</sub>的系数 $a_1 = \frac{1}{2}ln\frac{1-e_1}{e_1}$
更新数据集的权值分布 $\\D_2 = (w_{21},w_{22},\dots,w_{2i}\dots,w_{2M}) \\ w_{2i} = \frac{w_{1i}}{Z_k}e^{-a_1y^iG_1(x^i)} \\ Z_k = \sum_{i=1}^{M}w_{1i}e^{-a_1y^iG_1(x^i)}$
用 $D_2$ ，替换 $D_1$ ,重复上面的2-5,可得到分类器 $G_2(x)$ 分类器,依次下可以得到 $G_k(x)$ 分类器
构建分类器的线性组合 $\\f(x) = \sum_{k=1}^{K}a_kG_k(x)\\ G(x) = sign(f(x))$

程序示例

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的值，可以测试代码。关于算法的理论明就不给出了，可以参考下在面的链接，讲的都比较好