精华内容
下载资源
问答
  • GBRT(梯度提升回归树)python实现 文章目录GBRT(梯度提升回归树)python实现前言一、什么是梯度提升回归树是什么?二、使用步骤1.不多说直接上代码2.建立模型总结 前言 随着人工智能的不断发展,机器学习这门...

    GBRT(梯度提升回归树)python实现


    前言

    随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的梯度提升回归树(GBRT)所以我爬了一个二手房网站,获取了一些二手房房屋信息,然后通过机器学习进行分析。


    一、什么是梯度提升回归树是什么?

    梯度提升回归树是一种集成方法,通过合并多个决策树来构建一个更为强大的模型。这也就表明了提升树是迭代多颗回归树来共同决策的,后面的每一颗决策树都在不断地修正前面的决策树

    二、使用步骤

    1.不多说直接上代码

    import pandas as pd
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.model_selection import KFold #k折交叉验证
    from sklearn.model_selection import GridSearchCV #网格搜索
    from sklearn.metrics import make_scorer
    import os
    plt.rcParams['font.family'] = ['sans-serif']
    plt.rcParams['font.sans-serif'] = ['SimHei']
    #这个地方数据来源 我去掉了
    df = data[['地址','价格','所属地区','房屋朝向','所在楼层','装修情况','套内面积','是否配备电梯','交易权属','多少人关注','房子总面积','建筑年代','楼型']]
    

    中间这部分数据处理就省略了。。。
    主要是,这个需要把数据类型转化为float类型,数值化0,1变量,用one-hot编码就OK

    df.drop(['所在楼层','房屋朝向','装修情况','所属地区','楼型','是否配备电梯','交易权属','地址'],axis=1,inplace=True)
    y = df['价格'].values.tolist()
    x = df.drop(['价格'],axis=1)
    x = x.values.tolist()
    corrDf = df.corr()   #这里多写了一点,是相关系数,运行起来较慢可以删除
    print(corrDf['价格'].sort_values(ascending =False))
    train_x,test_x,train_y,test_y = train_test_split(x,y,test_size=0.15,random_state=0)
    

    2.建立模型

    def performance_metric(y_true, y_predict):
        from sklearn.metrics import r2_score
        score = r2_score(y_true,y_predict)
        return score
    
    def fit_model(x, y):
        cross_validator = KFold(n_splits=3,shuffle=True, random_state=500) #交叉验证
        from sklearn.ensemble import GradientBoostingRegressor
        regressor = GradientBoostingRegressor(loss='ls',random_state=500,max_features=None,min_samples_leaf=10, min_impurity_split=10,learning_rate=0.2)
        params = {'max_depth':range(1,30)}  #决策树最大深度
        scoring_fnc = make_scorer(performance_metric)   # 评分函数
        grid = GridSearchCV(regressor,params,cv=cross_validator,scoring=scoring_fnc)
        # 基于输入数据 [x,y],进行网格搜索
        grid = grid.fit(x, y)
        # 返回网格搜索后的最优模型
        return grid.best_estimator_
    

    模型建立这个地方,我用了一个网格搜索,用来确定决策树的深度到达多少时候,返回模型精确度最高的那个。运行时间也会变长

    model = fit_model(train_x,train_y)
    def model_imge(model):
        #joblib.dump(model,'./keep_model/model.pkl')
        pre_y = model.predict(test_x)
        #计算决策系数r方
        r2 = performance_metric(test_y,pre_y)  
        print(r2)
        plt.figure(figsize=(10,9),dpi=100)
        plt.plot(test_y,label='实际值')
        plt.plot(pre_y,label='预测值')
        plt.legend()
        plt.title('GBRT模型实际值与预测值对比')
        plt.show()
    model_imge(model)
    

    这个地方就是画图,观察真实值和预测值的对比情况,r2也就是模型的精确度了,我这个模型写的不好只有0.8几。

    总结

    梯度提升回归树模型总的来说是非常不错的,优势劣势也是比较明显的,许多建模比赛等等都用到了这个,他的优势主要是比较精确,毕竟在提升过程中是在不断修正前面的决策树的,劣势就是调太麻烦了,建议使用网格搜索,但是时间花费太长,个人觉得最好是用GPU来跑,啊哈哈,这也是我的第一篇博客了。。。

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

    千次阅读 2020-02-21 23:46:14
    虽然名字中有“回归”,但是该方法既能用于回归问题,也能用于分类问题,与随机森林不同的是,梯度提升回归树(GBDT)采用连续的方式构造树,每棵树都在试图修正前一棵树的错误。默认情况下,梯度提升回归树没有随机...

    本文的主要内容是基于Python机器学习基础教程决策树部分进行整理和总结。

    模型描述

    梯度提升回归树和随机森林一样,是一种决策树集成方法,通过合并多个决策树来构建一个更为强大的模型。虽然名字中有“回归”,但是该方法既能用于回归问题,也能用于分类问题,与随机森林不同的是,梯度提升回归树(GBDT)采用连续的方式构造树,每棵树都在试图修正前一棵树的错误。默认情况下,梯度提升回归树没有随机化,而是用到了强预剪枝,并且梯度提升通常使用深度很小(1<max_depth<5)的树。这样的模型占用内存小,预测速度也更快。
    梯度提升的主要思想在于合并多个简单模型,每棵树只能对部分数据做出好的预测,添加的树越多,就可以不断的迭代提高性能。
    与随机森林相比,梯度提升对参数设置更为敏感,如果参数设置正确的话,模型精度也会更高。

    Sklearn实现

    应用梯度提升算法对乳腺癌数据进行预测,默认使用100棵树,最大深度3,学习率0.1(学习率用于控制每棵树纠正前一棵树错误的强度,高学习率对应更复杂的模型)

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import load_breast_cancer
    from sklearn.ensemble import GradientBoostingClassifier
    
    cancer = load_breast_cancer()
    X_train,X_test,y_train,y_test = train_test_split(cancer['data'],cancer['target'],random_state=0)
    
    gbdt = GradientBoostingClassifier(random_state=0)
    gbdt.fit(X_train,y_train)
    
    print("Accuracy of train set {:.3f}".format(gbdt.score(X_train,y_train)))
    print("Accuracy of test set {:.3f}".format(gbdt.score(X_test,y_test)))
    
    Accuracy of train set 1.000
    Accuracy of test set 0.958
    

    训练精度过高,判断存在过拟合,此时可以通过两个方法减小过拟合,降低决策树最大深度max_depth和降低学习率learning_rate来降低模型复杂度,抑制过拟合。
    降低决策树最大深度:

    gbdt = GradientBoostingClassifier(max_depth=1,random_state=0)
    gbdt.fit(X_train,y_train)
    print("Accuracy of train set {:.3f}".format(gbdt.score(X_train,y_train)))
    print("Accuracy of test set {:.3f}".format(gbdt.score(X_test,y_test)))
    
    Accuracy of train set 0.991
    Accuracy of test set 0.972
    

    降低学习率:

    gbdt = GradientBoostingClassifier(learning_rate=0.01,random_state=0)
    gbdt.fit(X_train,y_train)
    print("Accuracy of train set {:.3f}".format(gbdt.score(X_train,y_train)))
    print("Accuracy of test set {:.3f}".format(gbdt.score(X_test,y_test)))
    
    Accuracy of train set 0.988
    Accuracy of test set 0.965
    

    可以看到,使用上述两种方法都达到了减小过拟合,提高测试集精度的目的。
    特征重要性的可视化:

    def plot_feature_importances_cancer(model):
        n_features = cancer.data.shape[1]
        plt.barh(range(n_features),model.feature_importances_,align='center')
        plt.yticks(np.arange(n_features),cancer.feature_names)
        plt.xlabel('Feature importance')
        plt.ylabel("Feature")
    
    plot_feature_importances_cancer(gbdt)
    

    在这里插入图片描述

    模型评价

    • 由于梯度提升和随机森林在类似的数据上都具有很好的性能,因此一种常用的方法就是先使用随机森林,它的鲁棒性很好,若使用随机森林预测时间过长,那么切换成梯度提升通常会有用;
    • 梯度提升不需要对数据进行缩放(如归一化或标准化),也适用于二元特征和连续特征同时存在的数据集;
    • 该模型的一个主要缺点就是需要仔细调参,同时不适用于高维稀疏矩阵;
    • 梯度提升树模型的主要参数包括树的数量n_estimators和学习率learning_rate,learning_rate主要用于控制每棵树对前一棵树的纠正强度,learning_rate越低,就需要更多的树来构建具有相似复杂度的模型,增大n_estimators会导致模型复杂,所以通常的做法是根据时间和内存的预算选择合适的n_estimators,然后对不同的learning_rate进行遍历。
    展开全文
  • 基于梯度提升回归树的处理器性能数据挖掘研究.pdf
  • python 决策树集成-梯度提升回归树之分类实操 基础概念 集成 集成是合并多个机器学习模型来构建更强大模型的方法。在机器学习算法中有许多模型属于这一类,但已证明有两种集成模型对大量分类和回归的数据集都是有效...

    python 决策树集成-梯度提升回归树之分类实操

    基础概念

    集成

    集成是合并多个机器学习模型来构建更强大模型的方法。在机器学习算法中有许多模型属于这一类,但已证明有两种集成模型对大量分类和回归的数据集都是有效的,二者都以决策树为基础,分别是随机森林(random forest)梯度提升决策树(gradiet boosted decision tree)

    之前已经讲解过了随机森林(决策树集成-随机森林之分类实操),这次讲解梯度提升决策树。在了解梯度提升决策树之前,建议先去看一下我的另外两篇讲解决策树的文章决策树算法之讲解实操(上)决策树算法之讲解实操(下),重复的东西,我这里就不在赘述了。

    思想简介

    在之前的一篇文章决策树算法之讲解实操(上)中我们提到过,决策树的一个主要缺点在于经常对训练数据过拟合。那么除了随机森林之外,梯度提升回归树就是解决这个问题的另一种方法。

    梯度提升回归树是通过合并多个决策树来构建一个更为强大的模型。虽然名字中含有"回归",但是这个模型既可以用于回归也可以用于分类。与随机森林的方法不同,梯度提升采用连续的方式构造树,每颗树都试图纠正前一棵树的错误.默认情况下,梯度提升回归树中没有随机化,而是用到了强预剪枝。梯度提升树通常使用深度很小(1到5之间)的树,这样模型占用的内存更少,预测速度也更快.

    梯度提升树背后的主要思想是合并许多简单的模型(在这个语境中叫做弱学习器),比如深度较小的树.每棵树只能对部分数据作出好的预测,因此,添加的树越来越多,可以不断迭代,提高性能.

    梯度提升树经常是机器学习竞赛的优胜者,并广泛应用于业界.与随机森林相比,它通常对参数的设置更为敏感,但如果参数设置正确的话,模型精度会更高.

    实操建模

    数据是一份红酒质量分类的数据集,通过各个维度来判断红酒质量,之前在决策树算法之讲解实操(上)中已经讲解使用过了,这里就不多在赘述了,我们直接建模,代码如下所示:

    import pandas as pd
    import numpy as np
    import winreg
    from sklearn.model_selection import train_test_split
    from sklearn.ensemble import GradientBoostingClassifier#梯度提升回归树
    from sklearn.metrics import accuracy_score
    ###################
    real_address = winreg.OpenKey(winreg.HKEY_CURRENT_USER,r'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders',)
    file_address=winreg.QueryValueEx(real_address, "Desktop")[0]
    file_address+='\\'
    file_origin=file_address+"\\源数据-分析\\winequality-red.csv"###https://www.kaggle.com/uciml/red-wine-quality-cortez-et-al-2009
    red_wine=pd.read_csv(file_origin)
    #设立桌面绝对路径,读取源数据文件,这样将数据直接下载到桌面上就可以了,省得还要去找
    ###################
    train=red_wine.drop(["quality"],axis=1)
    X_train,X_test,y_train,y_test=train_test_split(train,red_wine["quality"],random_state=1)
    ###考虑到接下来可能需要进行其他的操作,所以定了一个随机种子,保证接下来的train和test是同一组数
    gbcf=GradientBoostingClassifier(random_state=1)
    gbcf.fit(X_train,y_train)
    print("梯度提升回归树训练模型评分:"+str(accuracy_score(y_train,gbcf.predict(X_train))))
    print("梯度提升回归树待测模型评分:"+str(accuracy_score(y_test,gbcf.predict(X_test))))
    

    结果如下所示:
    在这里插入图片描述

    下面是之前的文章中单棵决策树建立的模型结果:
    在这里插入图片描述
    二者相比可以看出,梯度提升树的模型精度要比单棵树的要好一点,过拟合现象也比之前要减轻很多。
    接下来我们了解一下梯度提升树的主要模型参数。

    模型参数

    在梯度提升回归树中,我们主要会用到三个模型参数n_estimators(树的个数),max_depth(树的深度),learning_rate(学习率),至于其它的参数,一般情况下直接默认就好。

    max_depth:用于降低每棵树的复杂度.一般来说,梯度提升模型的max_depth通常设置得很小,一般不超过5.
    接下来我们来调节这个参数,提高模型精度,代码及结果如下所示:

    result_1=pd.DataFrame(columns=["决策树深度(max_depth)","梯度提升回归树待测模型评分"])
    for i in range(1,5):
        gbcf=GradientBoostingClassifier(max_depth=i,random_state=1)
        gbcf.fit(X_train,y_train)
        result_1=result_1.append([{"决策树深度(max_depth)":i,"梯度提升回归树待测模型评分":accuracy_score(y_test,gbcf.predict(X_test))}])
    result_1[result_1["梯度提升回归树待测模型评分"]==result_1["梯度提升回归树待测模型评分"].max()]
    

    在这里插入图片描述

    可以看到当我们设定参数max_depth为4的时候,模型精度可以达到66.5%左右,较之前的结果提高了一些。

    梯度提升树模型的另外两个主要参数包括树的数量n_estimators学习率learn_rate,后者用于控制每棵树对前一棵树的错误纠正程度.这两个参数高度相关,因为learning_rate越低,就需要更多的树来构建具有相似复杂度的模型.随机森林的n_estimators值总是越大越好,但是梯度提升不同,增大n_estimators会导致模型更加复杂,进而可能导致过拟合.通常的做法是根据时间和内存的预算选择合适的n_estimators,然后对不同的learning_rate进行遍历.

    这两个参数的调节代码及结果如下所示:

    result_2=pd.DataFrame(columns=["集成树的个数(n_estimators)","梯度提升回归树待测模型评分"])
    for i in range(1,500,10):
        gbcf=GradientBoostingClassifier(max_depth=4,n_estimators=i,random_state=1)
        gbcf.fit(X_train,y_train)
        result_2=result_2.append([{"集成树的个数(n_estimators)":i,"梯度提升回归树待测模型评分":accuracy_score(y_test,gbcf.predict(X_test))}])
    result_2[result_2["梯度提升回归树待测模型评分"]==result_2["梯度提升回归树待测模型评分"].max()]
    

    在这里插入图片描述
    n_estimators的调节结果如上图所示,那么接下来我们在上面的参数基础上继续调节学习率:

    result_3=pd.DataFrame(columns=["学习率(learning_rate)","梯度提升回归树待测模型评分"])
    for i in range(1,10):
        m=i/10
        gbcf=GradientBoostingClassifier(max_depth=4,n_estimators=161,learning_rate=m,random_state=1)
        gbcf.fit(X_train,y_train)
        result_3=result_3.append([{"学习率(learning_rate)":m,"梯度提升回归树待测模型评分":accuracy_score(y_test,gbcf.predict(X_test))}])
    result_3[result_3["梯度提升回归树待测模型评分"]==result_3["梯度提升回归树待测模型评分"].max()]
    

    在这里插入图片描述
    接下来,我们还可以对学习率的参数调节进行进一步的区间划分,代码及结果如下所示:

    result_4=pd.DataFrame(columns=["学习率(learning_rate)","梯度提升回归树待测模型评分"])
    for i in range(1,20):
        m=i/100
        gbcf=GradientBoostingClassifier(max_depth=4,n_estimators=161,learning_rate=m,random_state=1)
        gbcf.fit(X_train,y_train)
        result_4=result_4.append([{"学习率(learning_rate)":m,"梯度提升回归树待测模型评分":accuracy_score(y_test,gbcf.predict(X_test))}])
    result_4[result_4["梯度提升回归树待测模型评分"]==result_4["梯度提升回归树待测模型评分"].max()]
    

    在这里插入图片描述
    至此,这个模型的参数就调节完毕了.
    (ps:为了提高模型精度,参数是可以进行更近一步的调节,不过剩下的就需要朋友们自行探索了)

    分析特征重要性

    与随机森林类似,梯度提升树也可以给出特征重要性,代码及结果如下:

    from sklearn.ensemble import RandomForestClassifier
    import seaborn as sns
    import matplotlib.pyplot as plt
    plt.style.use("fivethirtyeight")
    sns.set_style({'font.sans-serif':['SimHei','Arial']})
    %matplotlib inline
    gbcf=GradientBoostingClassifier(max_depth=4,random_state=1)###梯度提升回归树
    forest=RandomForestClassifier(max_depth=4,random_state=1)###随机森林分类器
    gbcf_prediction=gbcf.fit(X_train,y_train)
    forest_prediction=forest.fit(X_train,y_train)
    fig= plt.subplots(figsize=(20,15))
    fig1 = plt.subplot(211)
    plt.title('梯度提升回归树特征重要性',fontsize=20)
    plt.bar(train.columns,gbcf_prediction.feature_importances_,0.4,color="blue")
    plt.legend()
    fig2=plt.subplot(212)
    plt.title('随机森林特征重要性',fontsize=20)
    plt.bar(train.columns,forest_prediction.feature_importances_,0.4,color="green")
    plt.legend()
    plt.xticks(fontsize=13)
    

    在这里插入图片描述

    如上图所示,在保证树的深度参数(max_depth)相同的情况下,梯度提升树的特征重要性与随机森林的特征重要性有些相似,实际上在某些数据集中,梯度提升树可能会完全忽略某些特征.

    优缺点

    梯度提升决策树是监督学习中最强大也是最常用的模型之一.其主要缺点是需要仔细调参,而且训练的时间可能会比较长.与其他基于树的模型类似,这一算法不需要对数据进行缩放就可以表现得很好,而且也适用于二元特征与连续特征同时存在的数据集.但它也通常不适用于高维稀疏数据.

    由于梯度提升和随机森林两种方法在类似的数据上表现的都很好,因此一种常用的方法就是先尝试随机森林,它的鲁棒性很好.如果随机森林效果很好,但预测时间太长,或者机器学习模型精度小数点后第二位的提高也很重要,那么切换成梯度提升通常会有用.

    有很多地方做的不是很好,欢迎网友来提出建议,也希望可以遇到些朋友来一起交流讨论。

    展开全文
  • ##Work Area for Practice Gradient Boosting Regression Trees 这是我使用梯度提升回归树练习、学习和演示监督学习技术的仓库。 我可能会使用其中的一些内容来创建博客文章(如果我想出了一些有趣的东西)来分享我...
  • 梯度提升回归树 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());
        }

    }

    展开全文
  • 梯度提升回归树是另一种决策树集成方法,通过合并多个决策树来构建一个更为强大的模型。虽然名字中含有“回归”,但这个模型既可以用于回归也可以用于分类。 与随机森林方法不同,梯度提升采用连续的方式构造树,每...
  • GBDT梯度提升回归树

    2019-10-19 18:36:24
    为啥用负梯度的值而不用提升里的方法算残差呢,是因为当前损失函数是平方损失和指数损失函数时每步优化都很简单,但是对于一般损失函数而言,每一步的优化并不是那么容易,所以提出了梯度提升作为残差的近似值来...
  • 决策树集成即是以决策树为基础的模型,主要有随机森林(random forest)与梯度提升回归树(gradient boosted decision tree, GBDT)。 随机森林 随机森林本质上是许多以不同方式过拟合的决策树的集合,我们可以对...
  • gbm包gbm包是梯度提升回归树(GBRT)在R 中的实现。GBRT,全称为Gradient Boosting Regression Tree, 有时也称为GBDT。wiki中对GBRT的定义 Gradient boosting is a machine learning technique for regression and ...
  • GBDT梯度提升决策树与GBRT梯度提升回归树原理详解 1提升树的原理 2 提升树算法 3GBDT与GBRT 4 GBRT的数学实例 5 API详解 补充集成学习的多样性增强 总结:集成学习中各个算法分别如何做分类和回归的 学GBDT,GBRT之前...
  • 梯度提升回归树是另一种集成方法,通过合并多个决策树来构建一个更为强大的模型。 虽然名字中含有“回归”,但这个模型既可以用于回归也可以用于分类 。与随机森林方法不同,梯度提升采用连续的方式构造树,每颗树都...
  • 随机森林是解决决策经常对训练数据过拟合的一种方法,是许多决策的集合,每棵和其他略有不同,对这些的结果取平均值。 在two-moons数据集应用RandomForestClassifier 的个数(n_eastimators参数决定)-&...
  • 本文不讲解复杂的数学理论,涉及到了K近邻、线性模型、朴素贝叶斯分类器、决策树、随机森林、梯度提升回归树、SVM、MLP,以及监督学习模型的选择原则,全文2万多字,后续还会进一步补充。在后面的博客中会记录机器...
  •   梯度提升决策树(GBDT)算法是梯度提升(GB)算法限定基学习器是回归决策树时的模型,尤其是CART回归树,关于梯度提升(GB)可以看我的blog中对应的部分。   这里根据GB算法,改写成使用CART回归树的GBDT算法。 ...
  • 具体而言即为,将梯度提升中的基学习器,分段常数回归树,扩展为分段线性回归树。分段线性回归树能够加速GBDT的收敛速度,而且可以提升准确率。 作者们还提出一些优化技巧,大幅度加快了分段线性回归树的训练时间,...
  • 梯度提升回归树算法,更改公式、加注释使其更加容易理解  增加章节2.GBDT优缺点,6.梯度提升分类树算法 1.GBDT概念 以决策树为基学习器的集成学习算法具有预测精度高的优势,树的集成算法主要有随机森林和GBDT。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,278
精华内容 4,911
关键字:

梯度提升回归树