机器学习算法总结_决策树(含代码)

第六章 提升算法

6.1 引言

当做重要决定时，大家可能都会考虑吸取多个专家而不是一个人的意见。机器学习处理问题时也是如此，这就是提升算法背后的思路，提升算法是对其它算法进行组合的一种方式，接下来我们将对提升算法，以及提升算法中最流行的一个算法AdaBoost 算法进行介绍，并对提升树以及简单的基于单层决策树的Adaboost 算法进行讨论。

提升方法是一种常用的统计学习方法，应用广泛且有效，在分类问题上，它通过改变训练样本的权重，学习多个分类器，并将这些分类器进行线性组合，提高分类性能。一个分类器在训练数据上能够获得比其他分类器更好的拟合，但是在训练数据外的数据集上却不能很好的拟合数据，这时就称为该分类器出现了过拟合（overfitting ）。提升算法能够有效地防止过拟合现象的发生。

图1 过拟合现象示意图

提升算法是一种为了拟合自适应基函数模型（adaptive basis-function models, ABM ）的贪心算法，自适应基函数模型可表达为：

()()01M

m m m f X w w X φ==+∑ （6-1）

其中，m φ是一种分类算法或者回归算法，被称为弱分类器（weak learner ）或者基分类器（base learner ）。也可以表达为如下形式：

1()(;)M

m m m f X b X βγ==∑ （6-2）

提升算法的目的是对以下公式的优化：

1

min (,())N

i i f

i L y f x =∑ （6-3）

其中，?(,)L y y 称为损失函数（loss function ），f 是ABM 模型。不同的损失函数有着不同

的性质，对应不同的提升算法，如表1所示。

将(2)式代入(3)式可得如下表达式：

,11min ,(;)m m

N

M

i m i m i m L y x βγβφγ==??

???

∑∑ （6-4） 因为学习的是加法模型，如果能够从前向后，每一步只学习一个基分类器及其系数，那

么就可以简化优化的复杂度，具体推导过程如下所示：

(),1

min ,(;)m m

N

i m i m i L y x βγβφγ=∑ （6-5）

表1 常见损失函数以及相应提升算法

名称 损失函数

导数

*f

算法 平方误差 21

(())2

i i y f x - ()i i y f x -

[]|i y x E

L2Boosting 绝对误差 ()i i y f x -

sgn(())

i i y f x -

(|)i median y x

Gradient boosting 指数损失 ()

exp ()i i y f x -

()

exp ()i i i y y f x --

1

log 21i i ππ- AdaBoost 对数损失

()log 1i i

y f e -+

i i y π-

1

log 21i i

ππ-

LogitBoost

01

()arg min (,(;))N

i i i f X L y f x γ

γ==∑ （6-6）

1,1

(,)argmin (,()(;))N

m m i m i i i L y f x x βγ

βγβφγ-==+∑ （6-7）

1()()(;)m m m m f X f X X βφγ-=+ （6-8）

算法不进行回溯对参数进行修改，因此该算法称为前向分步算法。

6.2 AdaBoost 算法

AdaBoost （Adaptive boosting ）算法，也称为自适应提升算法。训练数据中的每个样本，并赋予其一个权重，这些权重构成向量D 。一开始，这些权重都初始化为相等值，首先

在训练数据上训练出一个弱分类器并计算该分类器的错误率，然后在同一数据集上再次训练弱分类器。再次训练分类器的过程中，将会重新调整每个样本的权重，其中上一次分对的样本权重会降低，而上一次分错的样本权重会提高。

图2 AdaBoost 算法示意图

给定一个二类分类的训练数据集1122{(,),(,),,(,)}N N T x y x y x y =，其中，每个样本点由实例

与标记组成，实例n i x R χ∈?，标记{1,1}i y Y ∈=-+，χ是实例空间，Y 是标记集合。损失函数可以表达为：

1,1

1

()exp[(()())]exp(())N N

m i m i i i m i i i i L y f x x w y x φβφβφ-===-+=-∑∑ （6-9）

其中，,1exp(())i m i m i w y f x --，{}1,1i y ∈-+，则可以有如下推导：

()

,,,,()

()

1

1

()(())i i i i N N

m i m i m i m i i i m

y x y x i i L e w e w e e w I y x e w β

β

ββ

βφ

φ

φφ---=≠===+=-≠+∑∑∑∑ （6-10）

其中，11

log

2m m m

err err β-=，,1,1(())

N

i m i m i i m N i m

i w I y x err w φ==≠=∑∑，m

err 称为分类误差率。则可以得到第

m 个分类器：

1()()()m m m f X f X X βφ-=+ （6-11）

计算第m+1个分类器的参数可以通过下式得到：

()(2(())1)2(()),1,,,m i m i m i m i m i m i m y x I y x I y x i m i m i m i m w w e w e w e e βφβφβφβ-≠-≠-+=== （6-12）

总结起来Adaboost 算法主要有以下7步。 1 1i w N = 2 for 1:m M =do

3 Fit a classifier ()m X φ to the training set using weights w

4 Compute ,11(())

N

i m i m i i m N i

i w I y x err w φ==≠=∑∑

5 Compute 1log (2)m

m m m m

err err ααβ-== 6 Set (())

m i m i I y x i i w w e α

φ≠←

7 Return 1()sgn ()M

m m m f x X αφ=?

?=??

∑ 算法结束条件是训练错误率为0或者弱分类器数目达到用户指定的值。在具体应用AdaBoost 算法时，可以将其总结为以下的一般流程：

(1) 收集数据：可以使用任意方法；

(2) 准备数据：依赖于所使用弱分类器的类型，这里k-近邻、决策树、朴素贝叶斯、逻辑

回归、支持向量机等任意分类算法都可以作为本部分弱分类器； (3) 分析数据：可使用任意方法；

(4) 训练算法：AdaBoost 算法大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器； (5) 测试算法：计算分类错误率；

(6) 使用算法：同支持向量机类似，AdaBoost 算法预测两个类别中的一个，如果想应用多分类，需要做与支持向量机类似的相应修改。

6.3 提升树

分类与回归树（Classification and regression trees, CART ）又称为决策树（decision tree ），使用分类数与回归树作为基本分类器的提升方法，称为提升树（Boosting tree ）。

图3 决策树示意图

决策树模型将空间分为数个互不相交的区域,1,,j R j J =，每一个区域作为树的叶子节点，并为每个区域分配一个参数j γ：

()j j

x R f x γ∈?= （6-13）

因此决策树则可以表达为如下形式：

()()1;J

j j j T x I x R γ=Θ=∈∑ （6-14）

其中，1{,}J j j R γΘ=，该参数由最小化经验风险计算得到：

1arg min (,)j j

J

j j j x R L y γΘ

=∈Θ=∑

∑

（6-15）

决策树模型是一种传统的学习方法，易于被理解，相比较人工神经网络，我们能够清晰地了解如何构建决策树，而且决策树模型无信息丢失。但是决策树模型也存在不稳定的缺点，训练样本较小的变化会导致结果的较大差异。为解决这一问题，研究者主要通过提升算法来对决策树模型进行优化，即所谓的提升树（Boosting tree ），其基本算法思路为，构建多个决策树，多个决策树决策结果的加权平均对样本的变化不敏感。

提升树模型是一系列的决策树的和：

()1();M

M m m f x T x ==Θ∑ （6-16）

引入前向分步算法：

11?argmin (,()(;))m

N

m i m i i m

i L y f x T x -Θ=Θ=+Θ∑ （6-17） 已知1()m f x -求得1{,}m

J m jm jm R γΘ=，已知jm R 求jm γ：

1?arg min

(,())jm

i jm

jm i m i jm x R L y f x γγγ-∈=+∑

（6-18）

6.4 基于单层决策树的AdaBoost 算法

单层决策树（decision stump ，也称决策树桩）是一种简单的决策树，仅基于单个特征来做决策，由于这棵树只有一次分裂过程，因此它实际上就是一个树桩。利用Python 对单

层决策树进行实现，代码如下：

def stumpClassify(dataMatrix,dimen,threshVal,threshIneq): retArray = ones((shape(dataMatrix)[0],1)) if threshIneq == 'lt':

retArray[dataMatrix[:,dimen] <= threshVal] = -1.0 else:

retArray[dataMatrix[:,dimen] > threshVal] = -1.0 return retArray

def buildStump(dataArr,classLabels,D):

dataMatrix = mat(dataArr); labelMat = mat(classLabels).T m,n = shape(dataMatrix)

numSteps = 10.0; bestStump = {}; bestClasEst = mat(zeros((m,1)))

minError = inf

for i in range(n):

rangeMin = dataMatrix[:,i].min(); rangeMax = dataMatrix[:,i].max();

stepSize = (rangeMax-rangeMin)/numSteps

for j in range(-1,int(numSteps)+1):

for inequal in ['lt', 'gt']:

threshVal = (rangeMin + float(j) * stepSize)

predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)

errArr = mat(ones((m,1)))

errArr[predictedVals == labelMat] = 0

weightedError = D.T*errArr

if weightedError < minError:

minError = weightedError

bestClasEst = predictedVals.copy()

bestStump['dim'] = i

bestStump['thresh'] = threshVal

bestStump['ineq'] = inequal

return bestStump,minError,bestClasEst

上述程序包含两个函数。第一个函数stumpClassfy()是通过阈值比较对数据进行分类的，所有的阈值一边的数据会分到类别-1，而在另一边的数据分到类别+1.该函数可以通过数组过滤来实现，首先将返回数组的全部元素设置为1，然后将所有不满足不等式要求的元素设置为-1，可以给予数据集中的任意元素进行比较，同时也可以将不等号在大于、小于之间切换。

第二个函数buildStump()将会遍历stumpClassfy()函数所有可能的输入，并找到数据集上最佳的单层决策树。在确保输入数据符合矩阵格式之后，整个函数就开始执行了，然后函数将构建一个称为bestStump的空字典，这个字典用语存储给定权重向量D时所得到的最佳单层决策树的相关信息。变量numSteps用于在特征的所有可能值上进行遍历。而变量minError则在一开始就初始化成正无穷大，之后用语寻找可能的最小错误率。

三层嵌套的for循环是程序最主要的部分。第一层for循环在数据集所有特征上遍历。考虑到数值型的特征，我们就可以通过计算最小值和最大值来了解应该需要多大的不畅。然后，第二层for循环再在这些值上遍历。甚至将阈值设置为整个取值范围之外也是可以的。因此在取值范围之外还应该有两个额外的步骤，最后一个for循环则是在大于和小于之间切换不等式。

上述单层决策树的生成函数是决策树的一个简化版本，即是所谓的弱学习器（弱分类器）。到现在为止，我们已经建立了单层决策树，并生成了程序，做好了过渡到完整AdaBoost算法，如下所示：

def adaBoostTrainDS(dataArr,classLabels,numIt=40):

weakClassArr = []

m = shape(dataArr)[0]

D = mat(ones((m,1))/m) #init D to all equal

aggClassEst = mat(zeros((m,1)))

for i in range(numIt):

bestStump,error,classEst = buildStump(dataArr,classLabels,D)

alpha = float(0.5*log((1.0-error)/max(error,1e-16)))

bestStump['alpha'] = alpha

weakClassArr.append(bestStump)

expon = multiply(-1*alpha*mat(classLabels).T,classEst)

D = multiply(D,exp(expon))

D = D/D.sum()

aggClassEst += alpha*classEst

aggErrors = multiply(sign(aggClassEst) != mat(classLabels).T,ones((m,1)))

errorRate = aggErrors.sum()/m

print "total error:",errorRate

if errorRate == 0.0: break

return weakClassArr

伪代码可以简单总结为以下步骤：

对每次迭代：

利用buildStump( )函数找到最佳的单层决策树

将最佳单层决策树加入到单层决策树组

计算alpha

计算新的权重向量D

更新累积类别估计值

如果错误率等于0.0，则退出循环

该AdaBoost算法的输入参数包括数据集、类别标签以及迭代次数numIt，其中numI是在整个AdaBoost算法中唯一需要用户指定的参数。AdaBoost算法的核心在于for循环，该循环运行numIt次，或者知道训练错误率为0为止。循环中的第一件事就是利用前面介绍的buildStump()函数建立一个单层决策树，同时返回的还有最小的错误率以及估计的类别向量。

然后则需要计算的则是alpha值，该值会告诉总分类器本次单层决策树输出结果的权重，其中的语句max(error, 1e-16)用语确保在没有错误时，不会发生除零溢出，而后，alpha值加入到bestStump字典中，该字典又添加到列表中。该字典包含分类所需要的所有信息。接下来则是计算下一次迭代中的新权重向量D，在训练错误率为0时则提前结束for 循环。图4则为我们所得到的一组弱分类器及其权重。

图4 弱分类器

如图5所示，为不同弱分类器数，所得的分类结果，可以看到，弱分类器越多，在训练集上分类错误率越低，分类效果越好，但是并不是弱分类器越多，对测试数据的分类效果越好。

图5 不同数量弱分类器分类结果

6.5 小结

提升方法通过组合多个弱分类器的分类结果，获得了比简单的单分类器更好的分类结果。目前还存在利用不同分类器的集成方法，但是本章仅介绍了利用同一分类器的集成方法。

多个分类器组合可能会进一步凸显单分类器的不足，比如过拟合问题。如果分类器之间差别显著，那么多个分类器组合就可能会缓解这一问题。分类器之间的差别可以使算法本身

或者是应用于算法上的数据的不同。