集成学习——梯度提升法GDBT（机器学习）

深度学习模型集成：提高预测准确性的方法 #生活技巧# #学习技巧# #深度学习技巧#

目录

一、实验内容

二、实验过程

1、算法思想：

2、算法原理

3、算法分析

三、源程序代码

四、实验总结

一、实验内容

熟知集成学习方法的概念和基本算法思想；掌握梯度提升法的算法原理；掌握梯度提升法的设计及Python实现。

二、实验过程

1、算法思想：

        梯度提升决策树，是一种迭代决策树算法，主要用于回归，经过改进过也可用于实现分类任务。GBDT的实现思想是构建多棵决策树，并将所有决策树的输出结果进行综合，得到最终的结果。

2、算法原理

        GBDT算法的构建过程与分类决策树类似

        主要区别在于回归树节点的数据类型为连续型数据，每一个节点均有一个具体数值，此数值是该叶子节点上所有样本数值的平均值。

        同时，衡量每个节点的每个分支属性表现，不再使用熵，信息增益或Gini指标等纯度指标，而是通过最小化每个节点的损失函数值来进行表示每个节点的分裂。

3、算法分析

（1）初始化决策树，估计一个使损失函数最小化的常数构建一个只有根节点的树。

（2）不断提升迭代

1、计算当前模型中损失函数的负梯度值，作为残差的估计值。

2、估计回归树中叶子节点的区域，拟合残差的近似值；

3、利用线性搜索估计叶子节点区域的值，使损失函数极小化。

4、更新决策树。

 （3）经过若干轮的提升法迭代过程之后，输出最终的模型。

三、源程序代码

import numpy as np

from sklearn import datasets

import sys

class Gx:

def __init__(self,feature,split,left,right):

self.feature=feature

self.split= split

self.left =left

self.right = right

class GDBT:

def __init__(self,Train,Test,e):

self.Train=Train

self.Test=Test

self.feature_num = self.Train.shape[1] - 2

self.label = self.Train.shape[1] - 2

self.r = self.Train.shape[1] - 1

self.Gx=[]

self.e=e

self.split = self.cal_split()

def cal_split(self):

split = {}

for i in range(self.feature_num):

split[i] = []

d = self.Train[np.argsort(self.Train[:, i])]

for j in range(d.shape[0] - 1):

sp = (d[j][i] + d[j + 1][i]) / 2

if sp not in split[i]:

split[i].append(sp)

return split

def cost(self, data):

X = data[:, self.r:self.r + 1]

avg = np.sum(X) / X.shape[0]

sum = 0

for i in range(X.shape[0]):

sum += (X[i][0] - avg) ** 2

return sum,avg

def update_r(self,G):

feature=G.feature

split=G.split

left=G.left

right=G.right

for i in range(self.Train.shape[0]):

if self.Train[i][feature] <= split:

self.Train[i][self.r]=self.Train[i][self.r]-left

else:

self.Train[i][self.r] = self.Train[i][self.r] - right

def cal_best_split(self):

min_cost=sys.maxsize

min_split=0

min_feature=0

min_left=0

min_right=0

for i in range(self.feature_num):

for j in self.split[i]:

left = self.Train[(self.Train[:, i] <= j), :]

right = self.Train[(self.Train[:, i] > j), :]

cost1,avg1=self.cost(left)

cost2,avg2=self.cost(right)

if cost1+cost2 < min_cost:

min_cost= cost1+cost2

min_feature=i

min_split=j

min_left=avg1

min_right=avg2

G=Gx(min_feature,min_split,min_left,min_right)

self.update_r(G)

self.Gx.append(G)

def fit(self):

L=sys.maxsize

while L>self.e:

self.cal_best_split()

print("当前损失值:")

L=self.cal_cost(self.Train)

print(L)

print("***************")

def print_Gx(self):

for gx in self.Gx:

print("特征:")

print(gx.feature)

print("切分点")

print(gx.split)

print("左值")

print(gx.left)

print("右值")

print(gx.right)

print("******************************")

def cal_cost(self,data):

L=0

for i in range(data.shape[0]):

sum=0

for gx in self.Gx:

feature=gx.feature

split=gx.split

left=gx.left

right=gx.right

if data[i][feature] <=split:

sum+=left

else:

sum+=right

L+=(data[i][self.label]-sum)**2

return L

boston=datasets.load_boston()

data1=boston.data

print(data1.shape)

data2=boston.target

data2.resize([data2.shape[0],1])

data3=np.concatenate((data1,data2), axis=1)

data=np.concatenate((data3,data2), axis=1)

print(data.shape)

print(data)

train_size = int(len(data) * 0.7)

train = np.array(data[:train_size])

test=np.array(data[train_size:])

model=GDBT(train,test,100)

model.fit()

四、实验总结

        相比较单一算法，集成算法的效果更好。GBDT是一种boosting形式的集成算法，通断不断的优化残差值，最后达到一个非常好的效果

网址：集成学习——梯度提升法GDBT（机器学习） https://www.yuejiaxmz.com/news/view/656073

相关内容

机器篇——集成学习(三) 细说 提升(Boosting) 算法
【机器学习算法】梯度提升方法
机器学习（七）：提升（boosting）方法
机器学习算法的性能优化：提高学习效率的关键方法
机器学习提升秘籍：Scikit
提升成绩的学习方法集锦
机器学习的优化技巧：提高性能的方法
深度学习优化：提升训练效率与模型精度
集成学习：装袋法Bagging与随机森林
机器学习详解(10):优化器optimizer总结

随便看看