The Optimization of the Adaboost and Gradient Boosted Decision Tree
The Optimization of the Adaboost
1.对于Adaboost error function的推导
再回到咱们上篇文章讲到的Adaboost算法，咱们要从Adaboost算法推导出GBDT。首先回顾一下上篇文章的Adaboost，主要思想就是把弱分类器集中起来获得一个强的分类器。首先第一次建造树的时候每个样本的权值都是同样的，以后的每一次训练只要有错误，那么这个错误就会被放大，而正确的权值就会被缩小，以后会获得每个模型的α，根据每个树的α把结果结合起来就获得须要的结果。
node
在Adaboost里面，Ein表达式：
每个错误的点乘权值相加求平均，咱们想把这一个特征结合到decision tree里面，那么就须要咱们在决策树的每个分支下面加上权值，这样很麻烦。为了保持决策树的封闭性和稳定性，咱们不改变结构，只是改变数据的结果，喂给的数据乘上权值，其余的不改变，把决策树当成是一个黑盒子。
权值u其实就是这个数据用boostrap抽样抽到的几率，能够作一个带权抽样，也就是带了u的sample，这样抽出来的数据没一个样本和u的比例应该是差很少一致的，因此带权sampling也叫boostrap的反操做。这种方法就是对数据自己进行改变而对于算法自己的数据结构不变。
上面的步骤就是获得gt，接下来就是求α了，α就是每个model的重要性，上节课咱们是讲到过怎么求的，先获得错误率ξ，而后：
这个东西很重要，以后咱们会对这公式作推导。
①为何Adaboost要弱类型的分类器？
分类器讲道理，应该是越强越好的，可是Adaboost相反，他只要弱的，强的不行。来看一下α，若是你的分类器很强，ξ基本就是equal 0了，这样的α是无穷大的，其余的分类器就没有意义了，这样就又回到了单分类器，而单分类器是作不到aggregation model的好处的，祥见aggregation model这篇文章。
git
咱们把这种称为autocracy，独裁。针对这两个缘由，咱们能够作剪枝，限制树的大小等等的操做，好比只使用一部分样本，这在sampling的操做中已经起到这类做用，由于必然有些样本没有被采样到。
因此，综上缘由，Adaboost经常使用的模型就是decision stump，一层的决策树。
事实上，若是树高为1时，一般较难遇到ξ=0的状况，且通常不采用sampling的操做，而是直接将权重u代入到算法中。这是由于此时的AdaBoost-DTree就至关因而AdaBoost-Stump，而AdaBoost-Stump就是直接使用u来优化模型的。前面的算法实现也是基于这些理论实现的算法。
回到正题，继续从optimization的角度讨论Adaboost，Adaboost权重计算以下：
github
把上面两张形式结合一下，获得下面综合形式。第一层的u是1/N，每一次递推要乘上
因而，u(t+1)：
而在这里面
仔细看一下，voting score是由许多的g(x)经过不一样的α进行线性组合而成的，换一个角度，把g(x)看作是特征转换的φ(x)，α就是权重w，这样一来再和SVM对比一下：
对比上面实际上是很像的，乘上的y就是表名是在正确的一侧仍是错误的一侧，因此，这里的voting score也能够看作是没有正规化的距离。也就是没有除|w|的距离，因此从效果上看，voting score是要越大越好。再来看以前的乘上y的表达式，咱们要作的就是要使得分类正确，因此y的符号和voting score符号相同的数量会愈来愈多，这样也就保证了这个voting score是在不断增大，距离不断增大。这种距离要求大的在SVM里面咱们叫正则化——regularization，一样，这样就证实了①Adaboost的regularization。刚刚的g(x)看作是φ其实就是feature transform，因此也证实了②Adaboost的feature transform。这两个特性一个是踩刹车一个是加速，效果当然是比单分类器好的。
因此根据上面的公式，能够获得u是在不断减少的：
因此咱们的目标就是要求通过了(t+1)轮的迭代以后，u的数据集合要愈来愈小。有以下：
②Adaboost的error
上式中咱们把voting score看作是s。对于0/1error，若是ys >= 0，证实是分类正确的，不惩罚err0/1 = 0,；若是ys < 0，证实分类错误，惩罚err0/1 = 1。对于Adaboost，咱们能够用算法
来表示，可能有些同窗以为这里不太对， 这里明明是u的表达式为何能够做为错误的衡量？这个表达式里面包含了y和s，正好能够用来表达Adaboost的error，是就使用了。
正好也是减少的，和咱们须要的err是同样的，要注意这里Adaboost咱们是反推，已知到效果和方法反推表达式，使用要用上一切可使用的。
和error0/1对比：
因此，Adaboost的error function是能够代替error0/1的，而且效果更好。
2.对于Adaboost error function的一些简单处理
③首先要了解一些泰勒展开：
在通常的函数状况下，是有:
数据结构
①：
②：
①②式子代入上面：
这就是一阶Taylor expansion。待会要利用他们来求解。
用Taylor expansion处理一下Adaboost error function：
app
这是Gradient descent的公式，咱们类比一下error function：
这里是使用exp(x) 的Taylor一阶展开，这里的方向是h(x)，而Gradient descent是w才是方向，w是某一个点的方向，而h(x)也能够代入某一个点获得一个value，这个value就是方向，因此基本上和梯度降低是一致的：
对于y和h(x)咱们均限定是{1，-1}，对这个优化项作一些平移：
因此要优化的项最后又转变成了Ein，咱们的演算法一直都是在作减少Ein这件事，因此Adaboost的base algorithm——decision stump就是作的这件事。h(x)就能够解决了。
解决了h(x)的问题接下来就是η的问题了：
因此最后的公式如上图所示。
上式中有几个状况能够考虑：
通过推导：
求η最小值天然就是求导了：
就获得：
而η = α，这样就推导出了α的表达式了。
Adaboost实际上就是在寻找最块降低方向和最快降低步长的过程当中优化，而α至关于最大的步长，h(x)至关于最快的方向。因此，Adaboost就是在Gradient descent上寻找最快的方向和最快的步长。
Gradient Boosted Decision Tree
推导完了Adaboost，咱们接着推导Gradient Boosted Decision Tree，其实看名字就知道只不过是error function不太同样而已。前面Adaboost的推导总的能够归纳为：less
这种exp(-ys)function是Adaboost专有的，咱们能不能换成其余的？好比logistics或者linear regression的。
使用Gradient descent的就是这种形式，虽然形式变了，可是最终的结果都是求解最快的方向和最长的步长。
这里使用均方差替代error。使用一阶泰勒展开：
constant咱们不须要管，咱们只须要关心最后的一项。使得这一项最小，那只须要h(x)和2(s - y)互为相反数，而且h(x)很大很大就行了，h(x)不作限制，很明显这样是求不出来的。有一个简单的作法，收了regularization的启发，咱们能够在后面加上惩罚项，使用L2范式，L2范式会使他们很小但不会为0，可是L1范式会使得他们集中到边角上，系数矩阵，使用这里使用L2范式，另外一方面，也是对于化简的方便作了准备。
因此，优化的目标：
y-s咱们称为残差，咱们要作的就是使得h(x)和(y - s)接近，也就是作一个拟合的过程，也就是作regression。
拟合出来获得的h(x)就是咱们要的gt(x)了。以后就是求η了。
③：
获得了g(x)以后就是求η步长了。注意上面的③才是咱们要求的公式，
总结一下，以上就是GBDT的流程了。值得注意的是，sn的初始值通常均设为0，即s1=s2=⋯=sN=0。每轮迭代中，方向函数gt经过C&RT算法作regression，进行求解；步进长度η经过简单的单参数线性回归进行求解；而后每轮更新sn的值，即sn←sn+αtgt(xn)。T轮迭代结束后，最终获得
Summary of Aggregation Models
到这里，aggregation model基本就完成了。主要有三个方面：
①uniform：把g(x)平均结合。
②non-uniform：把g(x)线性组合。
③conditional：根据不一样条件作非线性组合。
uniform采用投票、求平均的形式更注重稳定性；而non-uniform和conditional追求的更复杂准确的模型，但存在过拟合的危险。
dom
刚刚所讨论的model都是创建在g(x)已知的状况下，若是g(x)不知道，咱们就可使用一下方法：
①Bagging：经过boostrap方法训练模型平均结合结果。
②Adaboost：经过boostrap方法训练模型进行线性组合。
③Decision Tree：数据分割获得不一样的g(x)进行线性组合。
除了以上的方法，咱们还能够把Bagging和Decision Tree结合起来称为random forest，Adaboost和decision tree结合起来就是Adaboost-stump，Gradient Boosted和Adaboost结合起来就是GBDT了。
Aggregation的核心是将全部的gt结合起来，融合到一块儿，也就是集体智慧的思想。这种作法可以获得好的G的缘由，是由于aggregation具备两个方面的优势：cure underfitting和cure overfitting。
①aggregation models有助于防止欠拟合（underfitting）。它把全部比较弱的gt结合起来，利用集体智慧来得到比较好的模型G。aggregation就至关因而feature transform，来得到复杂的学习模型。
②aggregation models有助于防止过拟合（overfitting）。它把全部gt进行组合，容易获得一个比较中庸的模型，相似于SVM的large margin同样的效果，避免了一些过拟合的状况发生。从这个角度来讲，aggregation起到了regularization的效果。
因为aggregation具备这两个方面的优势，因此在实际应用中aggregation models都有很好的表现。
代码实现
主要的作法就是用{(x, (y - s))}作拟合就行了。
因为以前写的决策树结构设计的不太好，使用起来不方便因而从新写了一个，这里的CART树是用方差来衡量impurity的。函数
def loadDataSet(filename):
'''
load dataSet
:param filename: the filename which you need to open
:return: dataset in file
'''
dataMat = pd.read_csv(filename)
for i in range(np.shape(dataMat)[0]):
if dataMat.iloc[i, 2] == 0:
dataMat.iloc[i, 2] = -1
return dataMat
pass
def split_data(data_array, col, value):
'''split the data according to the feature'''
array_1 = data_array.loc[data_array.iloc[:, col] >= value, :]
array_2 = data_array.loc[data_array.iloc[:, col] < value, :]
return array_1, array_2
pass
def getErr(data_array):
'''calculate the var '''
return np.var(data_array.iloc[:, -1]) * data_array.shape[0]
pass
def regLeaf(data_array):
return np.mean(data_array.iloc[:, -1])
加载数据，分割数据，计算方差，计算叶子平均,其实就是计算拟合的类别了。学习
def get_best_split(data_array, ops = (1, 4)):
'''the best point to split data'''
tols = ops[0]
toln = ops[1]
if len(set(data_array.iloc[:, -1])) == 1:
return None, regLeaf(data_array)
m, n = data_array.shape
best_S = np.inf
best_col = 0
best_value = 0
S = getErr(data_array)
for col in range(n - 1):
values = set(data_array.iloc[:, col])
for value in values:
array_1, array_2 = split_data(data_array, col, value)
if (array_1.shape[0] < toln) or (array_2.shape[0] < toln):
continue
totalError = getErr(array_1) + getErr(array_2)
if totalError< best_S:
best_col = col
best_value = value
best_S = totalError
if (S - best_S) < tols:
return None, regLeaf(data_array)
array_1, array_2 = split_data(data_array, best_col, best_value)
if (array_1.shape[0] < toln) or (array_2.shape[0] < toln):
return None, regLeaf(data_array)
return best_col, best_value
获得最好的分类，这里相比以前的决策树加了一些条件限制，叶子数量不能少于4，和以前的同样，计算方差对比看看哪一个小。
class node:
'''tree node'''
def __init__(self, col=-1, value=None, results=None, gb=None, lb=None):
self.col = col
self.value = value
self.results = results
self.gb = gb
self.lb = lb
pass
叶子节点，col列，val划分的值，results结果，gb右子树，lb左子树。
def buildTree(data_array, ops = (1, 4)):
col, val = get_best_split(data_array, ops)
if col == None:
return node(results=val)
else:
array_1, array_2 = split_data(data_array, col, val)
greater_branch = buildTree(array_1, ops)
less_branch = buildTree(array_2, ops)
return node(col=col, value=val, gb=greater_branch, lb=less_branch)
pass
创建一棵树。
def treeCast(tree, inData):
'''get the classification'''
if tree.results != None:
return tree.results
if inData.iloc[tree.col] > tree.value:
return treeCast(tree.gb, inData)
else:
return treeCast(tree.lb, inData)
pass
def createForeCast(tree, testData):
m = len(testData)
yHat = np.mat(np.zeros((m, 1)))
for i in range(m):
yHat[i, 0] = treeCast(tree, testData.iloc[i])
return yHat
建立分类。
def GBDT_model(data_array, num_iter, ops = (1, 4)):
m, n = data_array.shape
x = data_array.iloc[:, 0:-1]
y = data_array.iloc[:, -1]
y = np.mat(y).T
list_trees = []
yHat = None
for i in range(num_iter):
print('the ', i, ' tree')
if i == 0:
tree = buildTree(data_array, ops)
list_trees.append(tree)
yHat = createForeCast(tree, x)
else:
r = y - yHat
data_array = np.hstack((x, r))
data_array = pd.DataFrame(data_array)
tree = buildTree(data_array, ops)
list_trees.append(tree)
rHat = createForeCast(tree, x)
yHat = yHat + rHat
return list_trees, yHat
这里只是使用了回归问题的回归树，x和(y - s)作拟合以后加入预测集便可。
接下来就是画图了：
def getwidth(tree):
if tree.gb == None and tree.lb == None: return 1
return getwidth(tree.gb) + getwidth(tree.lb)
def getdepth(tree):
if tree.gb == None and tree.lb == None: return 0
return max(getdepth(tree.gb), getdepth(tree.lb)) + 1
def drawtree(tree, jpeg='tree.jpg'):
w = getwidth(tree) * 100
h = getdepth(tree) * 100 + 120
img = Image.new('RGB', (w, h), (255, 255, 255))
draw = ImageDraw.Draw(img)
drawnode(draw, tree, w / 2, 20)
img.save(jpeg, 'JPEG')
def drawnode(draw, tree, x, y):
if tree.results == None:
# Get the width of each branch
w1 = getwidth(tree.lb) * 100
w2 = getwidth(tree.gb) * 100
# Determine the total space required by this node
left = x - (w1 + w2) / 2
right = x + (w1 + w2) / 2
# Draw the condition string
draw.text((x - 20, y - 10), str(tree.col) + ':' + str(tree.value), (0, 0, 0))
# Draw links to the branches
draw.line((x, y, left + w1 / 2, y + 100), fill=(255, 0, 0))
draw.line((x, y, right - w2 / 2, y + 100), fill=(255, 0, 0))
# Draw the branch nodes
drawnode(draw, tree.lb, left + w1 / 2, y + 100)
drawnode(draw, tree.gb, right - w2 / 2, y + 100)
else:
txt = str(tree.results)
draw.text((x - 20, y), txt, (0, 0, 0))
以后就是运行主函数了：
if __name__ == '__main__':
data = loadDataSet('../Data/LogiReg_data.txt')
tree = buildTree(data)
drawtree(tree, jpeg='treeview_cart.jpg')
gbdt_results, y = GBDT_model(data, 10)
print(y)
for i in range(len(y)):
if y[i] > 0:
print('1')
elif y[i] < 0:
print('0')
效果：
效果貌似仍是能够的。aggregation model就到此为止了，几乎全部经常使用模型都讲完了。
最后符上GitHub全部代码：
https://github.com/GreenArrow2017/MachineLearning/tree/master/MachineLearning/GBDT