精华内容
参与话题
问答
  • GBDT梯度提升回归

    2019-10-19 18:36:24
    为啥用负梯度的值而不用提升树里的方法算残差呢,是因为当前损失函数是平方损失和指数损失函数时每步优化都很简单,但是对于一般损失函数而言,每一步的优化并不是那么容易,所以提出了梯度提升作为残差的近似值来...

    原理:

    提升树利用加法模型与向前分步算法实现学习的优化过程。
    (我觉得就是把提升树算法里的残差用当前损失函数的负梯度在当前模型的值近似替代,拟合下一颗树。)
    为啥用负梯度的值而不用提升树里的方法算残差呢,是因为当前损失函数是平方损失和指数损失函数时每步优化都很简单,但是对于一般损失函数而言,每一步的优化并不是那么容易,所以提出了梯度提升作为残差的近似值来拟合。基于残差进行学习,那么损失函数就会越来越小。
    这样是不是可以这样认为:提升树是梯度提升回归树的一个特例。

    梯度提升算法

    输入:训练数据集T = {(x1,y1),(x2,y2),…,(xN,yN)},
    在这里插入图片描述
    损失函数为:L(y,f(x))
    输出为:回归树F(x)
    (1).初始化
    在这里插入图片描述(2).对m = 1,2,…,M
    a:对 i = 1,2,…,N计算
    在这里插入图片描述
    b:对rmi拟合一个回归树,得到第m棵树的叶节点区域Rmj,j = 1,2,…,J.
    c:对j = 1,2,…,J,计算
    在这里插入图片描述
    (3)得到回归树
    在这里插入图片描述
    举个栗子:
    在这里插入图片描述
    有上面四组数据每组有两个特征一个标签。
    首先构造f0取训练样本标签值的均值
    (1.1+1.3+1.7+1.8)/4 = 1.475
    (意思就是找到一个值使得与四个真实的误差最小,所以取得均值。)
    算残差,用梯度算(但这里是损失函数用的是平方误差,因此求完梯度后在乘个无关紧要的0.5,那么就是真实值减预测值就是残差。)
    在这里插入图片描述
    用残差去拟合回归树
    在这里插入图片描述
    同样的方法计算ms,找到最小的,取相应的切分点进行划分。
    在这里插入图片描述
    继续算ms取最小,成为切分点。最终得到第一棵回归树。
    这样就可以进行更新:
    前面算的
    1.475+0.1(-0.375) = 1.4375
    1.475+0.1(-0.175) = 1.4575
    1.475+0.1(0.225) = 1.4975
    1.475+0.1(0.325) = 1.5075
    这里的0.1是因为为了避免过拟合乘的超参,可以当作做了正则化。
    以此作为更新后的值与真实值做残差这样可以得到第二棵树的值,可以在得出第二棵树的残差值,以此类推第三棵,第四棵,第五棵,第六棵。。。但这里的第几棵树是根据一开始设的超参设置。
    最后得到第五个数据的预测值为:
    1.475 +0.1(0.225+0.2025+0.1823+0.164+0.1476)=1.56714

    展开全文
  • @TOC

    学GBDT,GBRT之前要先对梯度下降法有一点了解.下面的链接可以做一定参考
    梯度与梯度下降法详解.
    GradientBoostingDescitionTree:梯度提升算法(提升树算法),利用梯度下降法求解的Boosting算法.

    1提升树的原理

     提升树(BoostingTree)是以决策树为基本学习器的提升方法,其预测性能相当优异.
     (1)对于分类问题:决策树是二叉分类树
     (2)对于回归问题:决策树是二叉回归树
    提升树模型:决策树作为基本分类器的加法模型:
    在这里插入图片描述
    M为决策树的数量,θm第m个决策树的参数,hm(x;θm)表示第m个决策树分类器
    注意:θm还有一层隐藏含义:
    θm的值要使得当前第m步提升树模型fm(x)(累加得到的)的损失函数最小化.而这一过程是通过梯度下降法实现的(梯度下降法求得当前模型的残差,残差拟合出一颗决策树得到θm),所以提升树模型又称为梯度提升算法.(这与之前的Boosting算法是有区别的)

    提升树算法采用前向分布算法.令fm-1(x)为前项模型(前m-1个决策树分类器累加得到的),则第m步提升树模型为:
    fm(x)=fm-1(x)+hm(x;θm)
    其中初始化提升树f0(x)=0
    然后通过最小化当前第m步模型的损失函数来确定第m步决策树分类器的θm参数
    所以当提升树有N个决策树分类器时,就要求得N个θ参数来使得当前第xxx步模型的损失函数最小化.相当于对损失函数做了N次优化(使得提升树的损失函数的最小值不断的减少)
    在这里插入图片描述
    其中:
    argmin 表达式:表示的是使这个表达式最小值时,对应表达式参数组的集合,当表达式只有一个最小值时,为单点集合.
    如果使用不同的损失函数,则得到两种不同的提升树算法(真实值为y,预测值为y1)
    (1)回归问题:通常使用平方损失函数:
    在这里插入图片描述
    (2)分类问题:通常使用指数损失函数:
    在这里插入图片描述
    用前项分布法,则在第m步给定前项模型,求解:
    在这里插入图片描述
    对于回归问题:采用平方误差损失函数:
    得到在这里插入图片描述
    r:当前第m步提升树模型拟合数据的残差(yi-fm-1(x),而这个值已经是m-1步损失函数的最小值了(然后用这个前项损失函数的最小值就是为当前模型的残差),对于提升树算法,只需要使用第m颗决策树hm(x;θm)拟合当前模型的残差(利用hm(x;θm)使得这个最小值取到进一步的最小值(找到对应的θm))
    补充:
    1.当前模型的残差=前项损失函数的最小值.
    总结:拟合前项残差(梯度下降) --> 找到θm --> 找到第m颗决策树 --> 累加前项模型得到当前模型

    2 提升树算法

    GBDT与GBRT算法:
    输入:训练数据集在这里插入图片描述
    输出:提升树fM(x) ,其中M的值为决策树分类器个数
    算法步骤:
     1 初始化f0(x)=c,给定损失函数(c的的取值可以使得第0步模型的损失函数取最小值)
     2 对于m=1,2…M
      计算残差rm=yi-fm-1(x),i=1,2…N(用前项模型残差近似替代的)
      拟合残差rm学习一颗回归树(决策树分类器),得到hm(x;θm)(求得θm的值)使得损失函数最小化(残差变小)
      更新提升树:fm(x)=fm-1(x)+hm(x;θm)
    3 得到提升树:
    在这里插入图片描述
    用上面的步骤解决分类问题:GBDT
          解决回归问题:GBRT

    3GBDT与GBRT

     提升是一个机器学习技术,可用于解决分类与回归问题,它每一步产生一个弱预测模型,如决策树,并加权累加到总模型中,如果每一步弱预测模型的生成都是依据损失函数的梯度方向(求解θ),则称之为梯度提升.
     梯度提升算法首先给定一个损失函数(目标函数),它的定义域是所有可行的弱函数集合(基函数),提升算法通过迭代的选择一个负梯度方向上的基函数来逐渐逼近局部极小值
     提升的理论意义:如果一个问题存在弱分类器,则可以通过提升的方式得到强分类器
    在提升树的基础上,利用梯度下降法,求解目标函数或者损失函数的最优情况,就称之为梯度提升算法.
     提升树中,如果损失函数是平方损失函数和指数损失函数时,由于这两种函数求导更简单,所以求解下面的参数最优解就比较简单了.
    在这里插入图片描述
     如果损失函数是一般函数,该优化问题往往比较难求得,Freidman提出了梯度提升算法来解决该最优值求解的问题–利用损失函数的负梯度(梯度下降法)在前项模型的值作为当前提升树算法中残差的近似值,拟合一颗决策树.在回归问题中,这称之为梯度提升回归树GBRT,在分类问题中,称之为梯度提升决策树GBDT;
    梯度提升决策树算法总结:
     多个决策树/回归树分类器的组合;
     首先要确定损失函数与初始化决策树分类器f0(x)=0
     第m步决策树分类器的参数θm使得到当前第m步梯度提升模型的损失函数最小化
     参数θm是通过梯度下降法求得的残差间接得到的
     而最小化损失函数的过程是根据提升树中决策树分类器个数而不断重复的过程(相当于对损失函数做了多次优化,多次求解极小值)
     对于残差的理解:前一步提升树所遗留下来的损失值(m-1步的损失函数的最小值),然后通过当前步的决策树分类器做进一步的减小.
    GBDT/GBRT与AdaBoost算法的区别:
     都是集成学习的串行方式
     但GBDT/GBRT在Boosting算的基础上,做了两点改进:
      1使用决策树/回归树算法,而AdaBoost使用的是各种算法(二分类)
      2使用梯度下降法降低损失函数,而AdaBoost使用的是样本的权值与分类器的线性组合来降低损失函数

    梯度提升回归树算法的详细步骤如下:
    输入训练数据集:在这里插入图片描述
    输出:回归树fM(x)
    1 初始化提升树:
    在这里插入图片描述
    注:这是一颗只有根节点的树(所有样本都在根节点中做了决策,属于什么类别),根节点的类别(指常数c)为使得损失函数值最小
    在这里插入图片描述
    2对于m=1,2…M指的是串行分类器的个数
    A对于i=1,2…N指的是求残差时yi与f(xi)中i的值
    在这里插入图片描述
     中括号表示的是梯度,说明他这里在用梯度下降法求解前项模型的残差,然后用前项模型的残差的最小值作为当前模型的残差(因为当前模型都没有算出来,没有办法计算残差yi-fm(xi),fm(xi)未知)
     这个公式说明可利用这个公式求得前项模型的残差的最小值作为当前模型的残差(再用第m颗决策树拟合它)
    B用rmj拟合一颗回归树,得到第m颗树的叶子节点区域Rmj,j=1,2…J,Rmj应该指的是第m颗树的某个叶子节点,由上知,当前第m颗树有J个叶子节点.
    C计算每个叶子节点区域Rmj上的输出值(因为样本最终会落在叶子节点上)
    在这里插入图片描述
     这个cmj求的应该是当前叶子节点上损失函数的最小值
     上述公式中yi与fm-1(x)用已经算出来的当前提升树残差rmi替换会不会好点?
     其中c指的是初始化决策树f0(x)=c,这个公式的过程就可以理解为在用rmi拟合一颗决策树/回归树的过程
    D在这里插入图片描述
    在这里插入图片描述
    3 得到回归树
    在这里插入图片描述
    上诉梯度提升算法,在回归问题中,这称之为梯度提升回归树GBRT,在分类问题中(损失函数使用0-1损失等),称之为梯度提升决策树GBDT

    4 GBRT的数学实例

    帮助对上面内容理解的
    训练数据如下表,属性x的取值范围[0.5,10.5],y的取值范围[5.0,10.0]学习GBRT
    在这里插入图片描述
    求解训练数据的切分点s
    在这里插入图片描述
    容易求得在R1,R2内部使得平方损失误差达到最小值的c1,c2为:
    在这里插入图片描述
    求训练数据的切分点,根据所给数据,考虑如下切分点:
    1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5
    对各切分点,不难求出相应的R1,R2,c1,c2及
    在这里插入图片描述
    例如:当s=1.5时,R1={1},R2={2,3…10},c1=5.56,c2=7.50
    在这里插入图片描述
    现将s及m(s)的计算结果列表如下:
    在这里插入图片描述
    由上表知,当x=6.5的时候达到最小值,此时R1={1,2…6},R2={7,8,9,10},c1=6.24,c2=8.91,所以回归树T1(x)为:
    在这里插入图片描述
     所以用的是均值作为预测结果
    用f1(x)拟合训练数据的残差见下表,表中r2i=yi-f1(xi),i=1,2…10 ,r2=∑r2i,表示为第二颗决策树要拟合的残差.
    在这里插入图片描述
    第二步求T2(x)方法与T1(x)一样,只是拟合的数据是上表的残差,可以得到:
    在这里插入图片描述
    继续求得:
    在这里插入图片描述
    在这里插入图片描述
    可以用拟合训练数据的平方损失等来作为结束条件.此时
    在这里插入图片描述
    假设此时已经满足误差要求,那么f(x)=f6(x)即为所求回归树

    5 API详解

    sklearn.ensembleGradientBoostingClassifier
    Parameter:
     loss:”deviance”,”exponential” 使用的损失函数 默认值:exponential
     “deviance”:”偏差”
     exponential:指数损失
    在这里插入图片描述
    learning_rate:float类型, 默认值=0.1
     学习率:用于减少每一步的步长,防止步长过长跨过极值点.通常学习率值比较小.但学习率设置的小,需要的决策树数量就比较多,反之也成立
    n_estimators:int类型, 默认值=100
     决策树数量(决策树分类器个数)

    补充集成学习的多样性增强

    1.数据样本扰动
     如Bagging框架中就是利用Boostrap抽样完成对数据样本的自助采样.
    2.输入属性扰动
     Bagging框架中的RandomForest的特征抽样
    3.算法参数的扰动
     在使用交叉验证(GridSearch网格搜索)来确定机器学习参数时.

    总结:集成学习中各个算法分别如何做分类和回归的

    1.决策树
     分类:指数损失
     回归:平方损失
    2.随机森林
     分类:简单的投票
     回归:简单的平均法
    3.AdaBoost
     分类:sgn函数,只能求解二分类问题
     回归:加法
    4.GBDT/GBRT
     分类:指数损失
     回归:平方损失

    展开全文
  • 梯度提升回归树 GBDT java

    千次阅读 2016-11-10 19:09:41
     * 梯度提升回归树 简单实现  * @author ysh 1208706282  *  */ public class Gbdt {  static List mSamples;  static List mTrainTarget;  static List mTrainCurTarget;  static List mCarts;
    /**
     * 梯度提升回归树    简单实现
     * @author ysh  1208706282
     *
     */
    public class Gbdt {
        static List<Sample> mSamples;
        static List<Double> mTrainTarget;
        static List<Double> mTrainCurTarget;
        static List<Cart> mCarts;
        /**
         * 加载数据   回归树
         * @param path
         * @param regex
         * @throws Exception
         */
        public  void loadData(String path,String regex) throws Exception{
            mSamples = new ArrayList<Sample>();
            mTrainTarget = new ArrayList<Double>();
            mTrainCurTarget = new ArrayList<Double>();
            BufferedReader reader = new BufferedReader(new FileReader(path));
            String line = null;
            String splits[] = null;
            Sample sample = null;
            while(null != (line=reader.readLine())){
                splits = line.split(regex);
                sample = new Sample();
                sample.label = Double.valueOf(splits[0]);
                mTrainTarget.add(sample.label);
                mTrainCurTarget.add(0.0);
                sample.feature = new ArrayList<Double>(splits.length-1);
                for(int i=0;i<splits.length-1;i++){
                    sample.feature.add(new Double(splits[i+1]));
                }
                
                mSamples.add(sample);
            }
            reader.close();
        }
        /**
         * 更新训练集目标
         * @author Administrator
         *
         */
        static class Update implements Runnable{
            int from;
            int to;
            Cart cart;
            public Update(int from,int to,Cart cart){
                this.from = from;
                this.to = to;
                this.cart = cart;
            }
            @Override
            public void run() {
                // TODO Auto-generated method stub
                Sample sample = null;
                for(int i=from;i<to;i++){
                    sample = mSamples.get(i);
                    mTrainCurTarget.set(i, mTrainCurTarget.get(i)+cart.classify(sample));
                    sample.label = mTrainTarget.get(i)-mTrainCurTarget.get(i);
                }
            }
            
        }
        public void updateTarget(Cart cart) throws InterruptedException{
            /*Sample sample = null;
            for(int i=0;i<mSamples.size();i++){
                sample = mSamples.get(i);
                mTrainCurTarget.set(i, mTrainCurTarget.get(i)+cart.classify(sample));
                sample.label = mTrainTarget.get(i)-mTrainCurTarget.get(i);
            }*/
            Update update = null;
            int num = 10;
            Thread ths[] = new Thread[num];
            int size = mSamples.size();
            
            for(int i=0;i<num;i++){
                update = new Update(i*size/num,(i+1)*size/num,cart);
                ths[i] = new Thread(update);
                ths[i].start();
            }
            for(int i=0;i<num;i++){
                ths[i].join();
            }
        }
        public void train(int iters) throws InterruptedException{
            mCarts = new ArrayList<Cart>(iters);
            Random ran = new Random();
            ran.setSeed(100);
            for(int iter=0;iter<iters;iter++){
                System.out.println("start iter "+iter+"  time:"+System.currentTimeMillis()/1000);
                Cart cart = new Cart();
                cart.mFeatureRate = 0.8;
                cart.mMaxDepth = 5;
                cart.mMinLeaf = 1;
                cart.mRandom = ran;
                cart.setData(mSamples);
                cart.train();
                mCarts.add(cart);
                updateTarget(cart);
                System.out.println("end iter "+iter+"  time:"+System.currentTimeMillis()/1000);
            }
        }
        public double classify(Sample sample){
            double ret = 0;
            for(Cart cart:mCarts){
                ret += cart.classify(sample);
            }
            return ret;
        }
        /**
         * @param args
         * @throws Exception
         */
        public static void main(String[] args) throws Exception {
            // TODO Auto-generated method stub
            System.out.println(System.currentTimeMillis());
            Gbdt gbdt = new Gbdt();
            gbdt.loadData("F:/2016-contest/20161001/train_data_1.csv", ",");
            gbdt.train(100);
            List<Sample> samples = Cart.loadTestData("F:/2016-contest/20161001/valid_data_1.csv", true, ",");
            double sum = 0;
            for(Sample s:samples){
                double val = gbdt.classify(s);
                sum += (val-s.label)*(val-s.label);
                System.out.println(val+"  "+s.label);
            }
            System.out.println(sum/samples.size()+"  "+sum);
            System.out.println(System.currentTimeMillis());
        }

    }

    展开全文
  • 04-梯度提升回归

    2019-12-15 16:34:47
    梯度提升树 Boosting: ​ 与Bagging方法不同,在Boosting算法中,学习器之间是存在先后顺序的,同时,每一个样本是有权重的,初始时,每一个样本的权重是相等的。首先,第1个学习器对训练样本进行学习,当学习完成...

    梯度提升树

    Boosting:

    与Bagging方法不同,在Boosting算法中,学习器之间是存在先后顺序的,同时,每一个样本是有权重的,初始时,每一个样本的权重是相等的。首先,第1个学习器对训练样本进行学习,当学习完成后,增大错误样本的权重,同时减小正确样本的权重,再利用第2个学习器对其进行学习,依次进行下去,最终得到b个学习器,最终,合并这b个学习器的结果,同时,与Bagging中不同的是,每一个学习器的权重也是不一样的。

    定义: 梯度提升树是一种从它的错误中进行学习的技术。它本质上就是集思广益,集成一堆较差的学习算法进行学习。

    一、梯度提升回归树(Regressor-Tree)

    1、定义: 回归树(Regression Decistion Tree(即DT、RT) )用于预测实数值,数值本身有意义,进行运算的结果仍有意义,而分类树用于分类标签值,如阴/晴天这种,所以其加减是不具有意义的。
    2、回归树生成过程
    (1)、决策树分为两大类:回归树和分类树。回归树用于预测实数值,数值本身有意义,进行运算的结果仍有意义
    (2)、回归树的总体流程跟分类树很相似,不过在每个节点都可以得到一个预测值,以预测年龄为例,结点处代表的预测值并不是一个具体值,而是所有分到这个节点的所有年龄的平均值(就是经过feature阈值分开后的每部分的平均值)。
    (3)、回归树在进行分枝时,会穷举每个feature的每个阀值(得到均方误差)找到最佳的分割点,但是衡量最好分割的标准不再是使用最大熵值进行选择(分类树方式),而是计算最小化均方差,即为: [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yArLbVEg-1576398489688)(C:\Users\Handsomeheee\Desktop\算法总结\分类模型\img\梯度回归提升树.png)] (即求均方误差((x-x平均值)**2).mean()) ,平均年龄代表结点代表的预测值,当错的越多,均方差就会越大。然后我们会根据梯度提升,减小残差(残差越小,结果越好,越准确),最后得到一个预测值(y - residual),即真实值减去最后的残差。
    3、公式推导过程

    X数据:上网时间和购物金额

    y目标:14(高一),16(高三),24(大学毕业),26(工作两年)

    X = np.array([[800,3],[1200,1],[1800,4],[2500,2]])
    y = np.array([14,16,24,26])

    • residual = y - y.mean() #第一颗树,根据平均值,计算了残差[-6,-4,4,6]
    • residual = residual - residual *0.1 #根据指定的learning_rate=0.1进行梯度变化
    • 然后重复以上步骤,知道达到tol=0.0001指定容忍度,得到最后的残差
      上步骤,知道达到tol=0.0001指定容忍度,得到最后的残差
    • final_predict = y - residual #将真实值和残差相减,得到最后的预测值
    展开全文
  • =======================================================================               Machine Learning notebook Python机器学习基础教程(introduction to Machine Learning with Python) ...
  • 梯度提升回归树(GBDT)

    万次阅读 2018-08-30 13:22:26
    1.梯度提升回归树是一种从它的错误中进行学习的技术。它本质上就是集思广益,集成一堆较差的学习算法进行学习。 2.GBDT是基于Boosting思想的,Adaboosting是最著名的Boosting算法,其基本思想是使用多个弱分类器来...
  • 要理解GBDT,首先要理解DT和线性回归。可以参考一下文章: 《python机器学习手写算法系列——线性回归》 《python机器学习手写算法系列——决策树》 概述 GBDT全称Gradent Boosting Decision Tree, 也叫Gradient ...
  • Gradient boosting regression梯度提升回归模型的分析。 1Boosting Boosting是一种机器学习算法,常见的机器学习算法有: 决策树算法、朴素贝叶斯算法、支持向量机算法、随机森林算法、人工神经网络算法 ...
  • gbm包gbm包是梯度提升回归树(GBRT)在R 中的实现。GBRT,全称为Gradient Boosting Regression Tree, 有时也称为GBDT。wiki中对GBRT的定义 Gradient boosting is a machine learning technique for regression and ...
  • 梯度提升回归树是另一种决策树集成方法,通过合并多个决策树来构建一个更为强大的模型。虽然名字中含有“回归”,但这个模型既可以用于回归也可以用于分类。 与随机森林方法不同,梯度提升采用连续的方式构造树,每...
  • 另外,因为这是个预测准确值的任务,所以它也是个回归任务。 注: 1)监督学习(Supervised learning):根据已有的数据集,知道输入和输出结果之间的关系。根据这种已知 的关系,训练得到一个最优的模型。也就是...
  • from pyspark.ml import Pipeline from pyspark.ml.regression import GBTRegressor from pyspark.ml.feature import VectorIndexer from pyspark.ml.evaluation import RegressionEvaluator ...
  • 集成是合并多个学习模型来构建更强大模型的方法。 随机森林 随机森林是解决决策树经常对训练数据过拟合的一种方法,是许多决策树的集合,每棵树和其他树略有不同,对这些树的结果取平均值。 在two-moons数据集应用...
  • 决策树集成即是以决策树为基础的模型,主要有随机森林(random forest)与梯度提升回归树(gradient boosted decision tree, GBDT)。 随机森林 随机森林本质上是许多以不同方式过拟合的决策树的集合,我们可以对...
  • 本文不讲解复杂的数学理论,涉及到了K近邻、线性模型、朴素贝叶斯分类器、决策树、随机森林、梯度提升回归树、SVM、MLP,以及监督学习模型的选择原则,全文2万多字,后续还会进一步补充。在后面的博客中会记录机器...
  • 帮我把最后自己写的那个提升算法完善一下。。测试集该怎么测试准确率??? 求大佬补充 from sklearn.datasets import load_iris # 用决策树作为基础模型 from sklearn.tree import DecisionTreeClassifier from ...

空空如也

1 2 3 4 5 ... 20
收藏数 2,190
精华内容 876
关键字:

梯度提升回归