1. Toy模板网首页
  2. > Toy博客

17- 梯度提升回归树GBRT (集成算法) (算法)

9月前 作者：处女座_三月 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了17- 梯度提升回归树GBRT (集成算法) (算法)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

梯度提升回归树:

  • 梯度提升回归树是区别于随机森林的另一种集成方法，它的特点在于纠正与加强，通过合并多个决策树来构建一个更为强大的模型。
  • 该模型即可以用于分类问题，也可以用于回归问题中。
  • 在该模型中，有三个重要参数分别为 n_estimators(子树数量)、learning_rate(学习率)、max_depth(最大深度)。
    • n_estimators  子树数量:  通常用来设置纠正错误的子树数量，梯度提升树通常使用深度很小(1到 5之间)的子树，即强预剪枝，来进行构造强化树。并且这样占用的内存也更少，预测速度也更快。
    • learning_rate  学习率:  通常用来控制每颗树纠正前一棵树的强度。较高的学习率意味着每颗树都可以做出较强的修正，这样的模型普遍更复杂。
    • max_depth  最大深度:  通常用于降低每颗树的复杂度，从而避免深度过大造成过拟合的现象。梯度提升模型的 max_depth 通常都设置得很小，一般来讲不超过5。

  • 梯度提升决策树是监督学习中 最强大也是最常用 的模型之一。

  • 该算法无需对数据进行缩放就可以表现得很好，而且也适用于二元特征与连续特征同时存在的数据集。

  • 缺点是需要进行仔细调参，且训练时间可能较长，通常不适用于高维稀疏数据。

单一KNN算法:         # knn近邻算法: K-近邻算法（KNN)

from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)

KNN集成算法: 

from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import BaggingClassifier
# 100个算法，集成算法，准确提升到了73.3%
knn = KNeighborsClassifier()
# bag中100个knn算法
bag_knn = BaggingClassifier(base_estimator=knn, n_estimators=100, max_samples=0.8,
                            max_features=0.7)
bag_knn.fit(X_train,y_train)
print('KNN集成算法，得分是：', bag_knn.score(X_test,y_test))

逻辑斯蒂回归集成算法:

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import BaggingClassifier
bag = BaggingClassifier(base_estimator=LogisticRegression(),n_estimators=500,
                        max_samples=0.8, max_features=0.5)
bag.fit(X_train,y_train)

决策树集成算法:

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
bag = BaggingClassifier(base_estimator=DecisionTreeClassifier(),n_estimators=100,
                        max_samples=1.0,max_features=0.5)
bag.fit(X_train,y_train)

梯度提升回归算法:

from sklearn.ensemble import GradientBoostingRegressor
gbdt = GradientBoostingRegressor(n_estimators=3,loss = 'ls', # 最小二乘法
                                 learning_rate=0.1)
gbdt.fit(X,y)    # 训练

1、集成算法

1.1、不同集成算法

集成算法流程概述

gbrt,机器学习,算法,回归,人工智能,决策树

 同质学习器（也叫算法，model，模型）

  • 随机森林，同质学习器，内部的100个模型，都是决策树

  • bagging：套袋法

    • 随机森林

    • 极端森林

  • boosting：提升法

    • GBDT

    • AdaBoost

1.2、bagging

gbrt,机器学习,算法,回归,人工智能,决策树

1.3、自建集成算法（同质）

1、导包数据创建

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
X,y = datasets.load_wine(return_X_y = True)
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 1024)

2、KNN集成算法

算法原理：

gbrt,机器学习,算法,回归,人工智能,决策树

# 一个算法，准确率 62%
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
print('单一KNN算法，得分是：',knn.score(X_test,y_test))   # 0.6222222222222222

# 100个算法，集成算法，准确提升到了73.3%
knn = KNeighborsClassifier()
# bag中100个knn算法
bag_knn = BaggingClassifier(base_estimator=knn,n_estimators=100,max_samples=0.8,
                            max_features=0.7)
bag_knn.fit(X_train,y_train)
print('KNN集成算法，得分是：',bag_knn.score(X_test,y_test))  # 0.7555555555555555

3、逻辑斯蒂回归集成算法 

import warnings
warnings.filterwarnings('ignore')
lr = LogisticRegression()
lr.fit(X_train,y_train)
print('单一逻辑斯蒂算法，得分是：',lr.score(X_test,y_test))   # 0.9333333333333333

# 偶尔效果会好
bag = BaggingClassifier(base_estimator=LogisticRegression(),n_estimators=500,
                        max_samples=0.8, max_features=0.5)
bag.fit(X_train,y_train)
print('逻辑斯蒂集成算法，得分是：', bag.score(X_test,y_test)) # 0.9333333333333333

4、决策树自建集成算法 

clf = DecisionTreeClassifier()
clf.fit(X_train,y_train)
print('单棵决策树，得分是：',clf.score(X_test,y_test))  # 0.9555555555555556
bag = BaggingClassifier(base_estimator=DecisionTreeClassifier(),n_estimators=100,
                        max_samples=1.0,max_features=0.5)
bag.fit(X_train,y_train)
print('决策树集成算法，得分是：',bag.score(X_test,y_test))  # 0.9777777777777777

1.4、boosting

gbrt,机器学习,算法,回归,人工智能,决策树

2、GBDT

2.1、梯度提升树概述

  • gradient Boosting DecisionTree  一一> GBDT

  • Boosting :提升的，一点点靠近最优答案

gbrt,机器学习,算法,回归,人工智能,决策树

  • 残差

    • 残差的意思就是： A的预测值 + A的残差 = A的实际值

    • 残差 = 实际值 - 预测值

    • 预测值 = 实际值 - 残差

2.2、梯度提升树应用

1、使用全量数据构建梯度提升树（0.1434）

from sklearn.ensemble import GradientBoostingRegressor
import numpy as np
import pandas as pd 

# 加载数据
data_train = pd.read_csv('zhengqi_train.txt', sep='\t')
data_test = pd.read_csv('zhengqi_test.txt', sep='\t')
X_train = data_train.iloc[:,:-1]
y_train = data_train['target']
X_test = data_test

# GBDT模型训练预测
gbdt = GradientBoostingRegressor()
gbdt.fit(X_train,y_train)
y_pred = gbdt.predict(X_test)
np.savetxt('GBDT_full_feature_result.txt', y_pred)

2、使用部分数据构建梯度提升树（0.1486） 

from sklearn.linear_model import ElasticNet
from sklearn.ensemble import GradientBoostingRegressor
import numpy as np
import pandas as pd 

# 加载数据
data_train = pd.read_csv('zhengqi_train.txt', sep='\t')
data_test = pd.read_csv('zhengqi_test.txt', sep='\t')
X_train = data_train.iloc[:,:-1]
y_train = data_train['target']
X_test = data_test

# 先使用ElaticNet模型进行数据筛选
model = ElasticNet(alpha = 0.1, l1_ratio=0.05)
model.fit(X_train, y_train)
cond = model.coef_ != 0
X_train = X_train.iloc[:,cond]
X_test = X_test.iloc[:,cond]
print('删除数据后，形状是：',X_train.shape)

# GBDT模型训练预测
gbdt = GradientBoostingRegressor()
gbdt.fit(X_train,y_train)
y_pred = gbdt.predict(X_test)
np.savetxt('GBDT_drop_feature_result.txt', y_pred)

2.3、梯度提升树原理

1、创建数据并使用梯度提升回归树进行预测

import numpy as np
from sklearn.ensemble import GradientBoostingRegressor
import matplotlib.pyplot as plt
from sklearn import tree
import graphviz

### 实际问题，年龄预测，回归问题
# 简单的数据，算法原理，无论简单数据，还是复杂数据，都一样
# 属性一表示花销，属性二表示上网时间
X = np.array([[600,0.8],[800,1.2],[1500,10],[2500,3]])
y = np.array([14,16,24,26]) # 高一、高三，大四，工作两年
# loss  = ls 最小二乘法
learning_rate = 0.1
gbdt = GradientBoostingRegressor(n_estimators=3,loss = 'ls',# 最小二乘法
                                 learning_rate=0.1)#learning_rate 学习率
gbdt.fit(X,y)#训练
y_ = gbdt.predict(X) # 预测

2、计算残差

# 目标值，真实值，算法，希望，预测，越接近真实，模型越好！！！
print(y)
# 求平均，这个平均值就是算法第一次预测的基准，初始值
print(y.mean())
# 残差：真实值，和预测值之间的差
residual = y - y.mean()
residual
# 残差，越小越好
# 如果残差是0，算法完全准确的把数值预测出来！

3、绘制三棵树

  • 第一棵树

# 第一颗树，分叉时，friedman-mse (就是均方误差)= 26
print('均方误差：',((y - y.mean())**2).mean())
dot_data = tree.export_graphviz(gbdt[0,0],filled=True)
graph = graphviz.Source(dot_data)

gbrt,机器学习,算法,回归,人工智能,决策树

# 梯度下降，降低残差
residual = residual - learning_rate*residual
residual
# 输出：array([-5.4, -3.6,  3.6,  5.4])
  • 第二棵树
# 第二颗树
dot_data = tree.export_graphviz(gbdt[1,0],filled=True)
graph = graphviz.Source(dot_data)

gbrt,机器学习,算法,回归,人工智能,决策树

# 梯度下降，降低残差
residual = residual - learning_rate*residual
residual
# 输出：array([-4.86, -3.24,  3.24,  4.86])
  • 第三棵树
# 第三颗树
dot_data = tree.export_graphviz(gbdt[2,0],filled=True)
graph = graphviz.Source(dot_data)
# 梯度下降，降低残差
residual = residual - learning_rate*residual
residual
# 输出：array([-4.374, -2.916,  2.916,  4.374])

4、使用残差计算最终结果

# 使用残差一步步，计算的结果
y_ = y - residual
print('使用残差一步步计算，最终结果是：\n',y_)
# 使用算法，预测
gbdt.predict(X)
# 两者输出结果一样

2.4、梯度提升回归树的最佳裂分条件计算

1、第一棵树，分裂情况如下：

gbrt,机器学习,算法,回归,人工智能,决策树

# 计算未分裂均方误差
lower_mse = ((y - y.mean())**2).mean()
print('未分裂均方误差是：',lower_mse)
best_split = {}
for index in range(2):
    for i in range(3):
        t = X[:,index].copy()
        t.sort()
        split = t[i:i + 2].mean()
        cond = X[:,index] <= split
        mse1 = round(((y[cond] - y[cond].mean())**2).mean(),3)
        mse2 = round(((y[~cond] - y[~cond].mean())**2).mean(),3)
        p1 = cond.sum()/cond.size
        mse = round(mse1 * p1 + mse2 * (1- p1),3)
        print('第%d列' % (index),'裂分条件是：',split,'均方误差是：',mse1,mse2,mse)
        if mse < lower_mse:
            best_split.clear()
            lower_mse = mse
            best_split['第%d列'%(index)] = split
        elif mse == lower_mse:
            best_split['第%d列'%(index)] = split
print('最佳分裂条件是：',best_split)
# 输出：
'''
未分裂均方误差是： 26.0
第0列 裂分条件是： 700.0 均方误差是： 0.0 18.667 14.0
第0列 裂分条件是： 1150.0 均方误差是： 1.0 1.0 1.0
第0列 裂分条件是： 2000.0 均方误差是： 18.667 0.0 14.0
第1列 裂分条件是： 1.0 均方误差是： 0.0 18.667 14.0
第1列 裂分条件是： 2.1 均方误差是： 1.0 1.0 1.0
第1列 裂分条件是： 6.5 均方误差是： 27.556 0.0 20.667
最佳分裂条件是： {'第0列': 1150.0, '第1列': 2.1}
'''

2、第二棵树，分裂情况如下：

gbrt,机器学习,算法,回归,人工智能,决策树

# 梯度下降，降低残差
residual = residual - learning_rate*residual
# 计算未分裂均方误差
lower_mse = round(((residual - residual.mean())**2).mean(),3)
print('未分裂均方误差是：',lower_mse)
best_split = {}
for index in range(2):
    for i in range(3):
        t = X[:,index].copy()
        t.sort()
        split = t[i:i + 2].mean()
        cond = X[:,index] <= split
        mse1 = round(((residual[cond] - residual[cond].mean())**2).mean(),3)
        mse2 = round(((residual[~cond] - residual[~cond].mean())**2).mean(),3)
        p1 = cond.sum()/cond.size
        mse = round(mse1 * p1 + mse2 * (1- p1),3)
        print('第%d列' % (index),'裂分条件是：',split,'均方误差是：',mse1,mse2,mse)
        if mse < lower_mse:
            best_split.clear()
            lower_mse = mse
            best_split['第%d列'%(index)] = split
        elif mse == lower_mse:
            best_split['第%d列'%(index)] = split
print('最佳分裂条件是：',best_split)
# 输出
'''
未分裂均方误差是： 21.06
第0列 裂分条件是： 700.0 均方误差是： 0.0 15.12 11.34
第0列 裂分条件是： 1150.0 均方误差是： 0.81 0.81 0.81
第0列 裂分条件是： 2000.0 均方误差是： 15.12 0.0 11.34
第1列 裂分条件是： 1.0 均方误差是： 0.0 15.12 11.34
第1列 裂分条件是： 2.1 均方误差是： 0.81 0.81 0.81
第1列 裂分条件是： 6.5 均方误差是： 22.32 0.0 16.74
最佳分裂条件是： {'第0列': 1150.0, '第1列': 2.1}
'''

3、第三棵树，分裂情况如下：

gbrt,机器学习,算法,回归,人工智能,决策树文章来源地址https://www.toymoban.com/news/detail-770244.html

# 梯度下降，降低残差
residual = residual - learning_rate*residual
# 计算未分裂均方误差
lower_mse = round(((residual - residual.mean())**2).mean(),3)
print('未分裂均方误差是：',lower_mse)
best_split = {}
for index in range(2):
    for i in range(3):
        t = X[:,index].copy()
        t.sort()
        split = t[i:i + 2].mean()
        cond = X[:,index] <= split
        mse1 = round(((residual[cond] - residual[cond].mean())**2).mean(),3)
        mse2 = round(((residual[~cond] - residual[~cond].mean())**2).mean(),3)
        p1 = cond.sum()/cond.size
        mse = round(mse1 * p1 + mse2 * (1- p1),3)
        print('第%d列' % (index),'裂分条件是：',split,'均方误差是：',mse1,mse2,mse)
        if mse < lower_mse:
            best_split.clear()
            lower_mse = mse
            best_split['第%d列'%(index)] = split
        elif mse == lower_mse:
            best_split['第%d列'%(index)] = split
print('最佳分裂条件是：',best_split)
# 输出
'''
未分裂均方误差是： 17.059
第0列 裂分条件是： 700.0 均方误差是： 0.0 12.247 9.185
第0列 裂分条件是： 1150.0 均方误差是： 0.656 0.656 0.656
第0列 裂分条件是： 2000.0 均方误差是： 12.247 0.0 9.185
第1列 裂分条件是： 1.0 均方误差是： 0.0 12.247 9.185
第1列 裂分条件是： 2.1 均方误差是： 0.656 0.656 0.656
第1列 裂分条件是： 6.5 均方误差是： 18.079 0.0 13.559
最佳分裂条件是： {'第0列': 1150.0, '第1列': 2.1}
'''

到了这里，关于17- 梯度提升回归树GBRT (集成算法) (算法)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 集成学习算法梯度提升（gradient boosting）的直观看法

    集成学习算法梯度提升（gradient boosting）的直观看法

    reference： Intuitive Ensemble Learning Guide with Gradient Boosting 梯度提升算法的核心思想：使用前一个模型的残差作为下一个模型的目标。 使用单个机器学习模型可能并不总是适合数据。优化其参数也可能无济于事。一种解决方案是将多个模型组合在一起以拟合数据。本教程以梯度提

    2023年04月09日
    浏览(52)
  • 机器学习：基于梯度下降算法的逻辑回归实现和原理解析

    机器学习：基于梯度下降算法的逻辑回归实现和原理解析

    当涉及到二元分类问题时，逻辑回归是一种常用的机器学习算法。它不仅简单而且有效，通常是入门机器学习领域的第一步。本文将介绍逻辑回归的基本概念、原理、应用场景和代码示例。 逻辑回归是一种用于解决二元分类问题的统计学习方法。尽管其名称中包含\\\"回归\\\"一词

    2024年02月09日
    浏览(50)
  • 【机器学习】P17 梯度下降 与 梯度下降优化算法（BGD 等 与 Adam Optimizer、AdaGrad、RMSProp）

    【机器学习】P17 梯度下降 与 梯度下降优化算法（BGD 等 与 Adam Optimizer、AdaGrad、RMSProp）

    梯度下降（Gradient Descent）是一种常用的优化算法，用于求解目标函数的最小值。（在机器学习应用梯度下降中，主要目标是为了最小化损失函数）； 其基本思想是通过不断迭代调整参数，使得目标函数的值不断逼近最小值。（机器学习中是为了最小化损失函数，即使得预测

    2023年04月16日
    浏览(46)
  • 机器学习与深度学习——使用paddle实现随机梯度下降算法SGD对波士顿房价数据进行线性回归和预测

    机器学习与深度学习——使用paddle实现随机梯度下降算法SGD对波士顿房价数据进行线性回归和预测

    随机梯度下降（SGD）也称为增量梯度下降，是一种迭代方法，用于优化可微分目标函数。该方法通过在小批量数据上计算损失函数的梯度而迭代地更新权重与偏置项。SGD在高度非凸的损失表面上远远超越了朴素梯度下降法，这种简单的爬山法技术已经主导了现代的非凸优化。

    2024年02月03日
    浏览(54)
  • 机器学习——线性回归、梯度下降

    机器学习——线性回归、梯度下降

    监督学习 ：学习数据带有标签 无监督学习 ：没有任何的标签，或者有相同的标签 其他：强化学习、推荐系统等 还是房价预测的例子， 训练集如下： 定义各个变量的含义如下： m——代表训练集中实例的数量 x——代表特征/输入变量 y——代表目标变量/输出变量 (x,y)——代

    2024年02月07日
    浏览(46)
  • 多元回归预测 | Matlab灰狼算法(GWO)优化极限梯度提升树XGBoost回归预测,GWO-XGBoost回归预测模型,多变量输入模型

    多元回归预测 | Matlab灰狼算法(GWO)优化极限梯度提升树XGBoost回归预测,GWO-XGBoost回归预测模型,多变量输入模型

    效果一览 文章概述 多元回归预测 | Matlab灰狼算法(GWO)优化极限梯度提升树XGBoost回归预测,GWO-XGBoost回归预测模型,多变量输入模型 评价指标包括:MAE、RMSE和R2等，代码质量极高，方便学习和替换数据。要求2018版本及以上。 部分源码

    2024年02月12日
    浏览(37)
  • 多元回归预测 | Matlab粒子群算法(PSO)优化极限梯度提升树XGBoost回归预测,PSO-XGBoost回归预测模型,多变量输入模型

    多元回归预测 | Matlab粒子群算法(PSO)优化极限梯度提升树XGBoost回归预测,PSO-XGBoost回归预测模型,多变量输入模型

    效果一览 文章概述 粒子群算法(PSO)优化极限梯度提升树XGBoost回归预测,PSO-XGBoost回归预测模型,多变量输入模型，多变量输入模型，matlab代码回归预测，多变量输入模型，多变量输入模型 评价指标包括:MAE、RMSE和R2等，代码质量极高，方便学习和替换数据。要求2018版本及以上。

    2024年02月13日
    浏览(51)
  • 机器学习(二)：线性回归之梯度下降法

    机器学习(二)：线性回归之梯度下降法

    ✍ 作者简介： i阿极 ，CSDN Python领域新星创作者， 专注于分享python领域知识。 ✍ 本文录入于《机器学习案例》 ，本专栏精选了经典的机器学习算法进行讲解，针对大学生、初级数据分析工程师精心打造，对机器学习算法知识点逐一击破，不断学习，提升自我。 ✍ 订阅后，

    2023年04月22日
    浏览(43)
  • 【机器学习(二)】线性回归之梯度下降法

    【机器学习(二)】线性回归之梯度下降法

    ✍ 作者简介： i阿极 ，CSDN Python领域新星创作者， 专注于分享python领域知识。 ✍ 本文录入于《机器学习案例》 ，本专栏精选了经典的机器学习算法进行讲解，针对大学生、初级数据分析工程师精心打造，对机器学习算法知识点逐一击破，不断学习，提升自我。 ✍ 订阅后，

    2023年04月14日
    浏览(42)
  • 【机器学习】P2 线性回归、损失函数与梯度下降

    【机器学习】P2 线性回归、损失函数与梯度下降

    线性回归简单的说就是线性函数； 线性回归属于机器学习 回归问题； 在线性回归建立的线性关系的模型中，假设目标变量和自变量之间存在一种线性关系，模型的目标是找到最佳的拟合线，是的模型对于未知的数据能够进行最准确的预测； 线性回归模型的一般形式为： y

    2023年04月08日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包