机器学习算法( 七、AdaBoost元算法)

一、概述　　

　　当做重要决定时，大家可能都会考虑吸取多个专家而不只是一个人的意见。机器学习处理问题时又何尝不是如此？这就是元算法（meta-algorithm）背后的思路。元算法是对其他算法进行组合的一种方式。接下来我们将集中关注一个称作AdaBoost的最流行的元算法。由于某些人认为AdaBoost是最好的监督学习的方法，所以该方法是机器学习工具箱中最强有力的工具之一。
　　本章首先讨论不同分类器的集成方法，然后主要关注boosting方法及其代表分类器Adaboost。再接下来，我们就会建立一个单层决策树（decision stump）分类器。实际上，它是一个单节点的决策树。AdaBoost算法将应用在上述单层决策树分类器之上。我们将在一个难数据集上应用AdaBoost分类器，以了解该算法是如何迅速超越其他分类器的。
　　最后，在结束分类话题之前，我们将讨论所有分类器都会遇到的一个通用问题：非均衡分类问题。当我们试图对样例数目不均衡的数据进行分类时，就会遇到这个问题。信用卡使用中的欺诈检测就是非均衡问题中的一个极好的例子，此时我们可能会对每一个正例样本都有1000个反例样本。在这种情况下，分类器将如何工作？读者将会了解到，可能需要利用修改后的指标来评价分类器的性能。而就这个问题而言，并非AdaBoost所独用，只是因为这是分类的最后一章，因此到了讨论这个问题的最佳时机。

二、优缺点

优点：泛化错误率低，易编码，可以应用在大部分分类器上，无参数调整。

缺点：对离群点敏感。

适用数据类型：数值型和标称型数据。

三、数学公式

四、基于数据集多重抽样的分类器

　　前面已经介绍了五种不同的分类算法，它们各有优缺点。我们自然可以将不同的分类器组合起来，而这种组合结果则被称为集成方法（ensemble method）或者元算法（meta-algorithm）。使用集成方法时会有多种形式：可以是不同算法的集成，也可以是同一算法在不同设置下的集成，还可以是数据集不同部分分配给不同分类器之后的集成。接下来，我们将介绍基于同一种分类器多个不同实例的两种计算方法。在这些方法当中，数据集也会不断变化，而后应用于不同的实例分类器上。最后，我们会讨论如何利用机器学习问题的通用框架来应用AdaBoost算法。

　　1、bagging：基于数据随机重抽样的分类器构建方法

　　　　自举汇聚法（bootstrap aggregating），也称为bagging方法，是在从原始数据集选择S次后得到S个新数据集的一种技术。新数据集和原数据集的大小相等。每个数据集都是通过在原始数据集中随机选择一个样本来进行替换而得到的。这里的替换就意味着可以多次地选择同一样本。这一性质就允许新数据集中可以有重复的值，而原始数据集的某些值在新集合中则不再出现。在S个数据集建好之后，将某个学习算法分别作用于每个数据集就得到了S个分类器。当我们要对新数据进行分类时，就可以应用这S个分类器进行分类。与此同时，选择分类器投票结果中最多的类别作为最后的分类结果。当然，还有一些更先进的bagging方法，比如随机森林（random forest）。接下来我们将注意力转向一个与bagging类似的集成分类器方法boosting。

　　2、boosting

　　　　boosting是一种与bagging很类似的技术。不论是在boost-ing还是bagging当中，所使用的多个分类器的类型都是一致的。但是在前者当中，不同的分类器是通过串行训练而获得的，每个新分类器都根据已训练出的分类器的性能来进行训练。boosting是通过集中关注被已有分类器错分的那些数据来获得新的分类器。由于boosting分类的结果是基于所有分类器的加权求和结果的，因此boosting与bagging不太一样。bagging中的分类器权重是相等的，而boosting中的分类器权重并不相等，每个权重代表的是其对应分类器在上一轮迭代中的成功度。boosting方法拥有多个版本，本章将只关注其中一个最流行的版本AdaBoost。

　　AdaBoost的一般流程

（1）收集数据：可以使用任意方法。

（2）准备数据：依赖于所使用的弱分类器类型，本章使用的是单层决策树，这种分类器可以处理任何数据类型。当然也可以使用任意分类器作为弱分类器，第2章到第6章中的任一分类器都可以充当弱分类器。作为弱分类器，简单分类器的效果更好。

（3）分析数据：可以使用任意方法。

（4）训练算法：AdaBoost的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。

（5）测试算法：计算分类的错误率。

（6）使用算法：同SVM一样，AdaBoost预测两个类别中的一个。如果想把它应用到多个类别的场合，那么就要像多类SVM中的做法一样对AdaBoost进行修改。

五、训练算法：基于错误提升分类器的性能

　　能否使用弱分类器和多个实例来构建一个强分类器？这是一个非常有趣的理论问题。这里的“弱”意味着分类器的性能比随机猜测要略好，但是也不会好太多。这就是说，在二分类情况下弱分类器的错误率会高于50%，而“强”分类器的错误率将会低很多。AdaBoost算法即脱胎于上述理论问题。

　　AdaBoost是adaptive boosting（自适应boosting）的缩写，其运行过程如下：

　　训练数据中的每个样本，并赋予其一个权重，这些权重构成了向量D。一开始，这些权重都初始化成相等值。首先在训练数据上训练出一个弱分类器并计算该分类器的错误率，然后在同一数据集上再次训练弱分类器。在分类器的第二次训练当中，将会重新调整每个样本的权重，其中第一次分对的样本的权重将会降低，而第一次分错的样本的权重将会提高。为了从所有弱分类器中得到最终的分类结果，AdaBoost为每个分类器都分配了一个权重值alpha，这些alpha值是基于每个弱分类器的错误率进行计算的。其中，错误率ε的定义为：

　　aaarticlea/png;base64,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" alt="" />

而alpha的计算公式如下：

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJAAAAA7CAIAAAAb/5TCAAAMC0lEQVR4nO1ceVBT5xYHGrZoqmNnatXpTI1CRBhRxNdHoGAZHhk7akFBLeArgfcEl9dXa13Q4saOoMjixmKtKNLaxV20rLJYZRc3QNZAyB625Obef94f53HnNiEBchMwNJnfMJe7nO985/edc893vi8xwVDECAOCyZRrYMSEYCTMwGAkzMBgJMzAYCTMwGAkzMAw/QlTIDIMRXo4XRERB0pLijEUQRXySWgXVch5fb1RUcdv3byBq0EebwthCkSmDzuCmRrqa9etW1tWWoL9mS1EPqzvfomE/F07dyadSNRVc28LYUT76grATfPrV6tWOdfV1aiTr9tGVRXAUCQwMOBEYoJO2norCJMND1ZVlm/dGnT2TAamu4GvQGRy2ZCHu/u9u3cwFJHLhohX+TzupUvfe3t7d3W2669rqEKOKuQKRPbxx397+KCAPGdTTBh0pqy0hM0ONjExSYiPU7Ws1mxhKBITEx0eFqYqUyjgXczJptPppqamPZwujNyLDVXIYZDBgZIo0OSPx5XOzitlw4MkI//Uexh0QCwSUKnUxIR4THceJhTwVqxYzu3lwDAnXhoeGsBQ5ERigqWlZR+3h0wr4/EY6JG/v9/5c2dJdmrqCQNwezlUKjU+LhbThYeBgdLTUtnBwaPaFPwgOTnJwsKit6cb09bD4KnWlubDhyNjYqJ37dzx1X92vXr5QkkgpFRlpSWenp4GTxh0jNfXa21trauQCDLXrFlz6+YNiLpKN0ATJ08mUygUbi9H1b7qQBQC/z58UDB79uy4uFipRFRR/ohCoWwPD8fUxAkPd/f6+trpQFgft0eHhGEoIhTwVq1yFgp4o16FJpKTk8zNzVUJGz9kw4Pvv/8+0W8unD/X0vxaVSDwt2vnDkjxDZ4wXl+vrkIiDPziokIvLy91TOAepkqYSMivrn5SU/O0uvqJEurra5WcTCTkz5o169Chg2NqBYRdvJizZctmI2GjmOZMRnpoSAimJjSN6mFARuHvDxkMhp2dne3Ix8bGhsFg2NraMpku/VKxkqjIyO+WL3c8cGC/K5OZn39NLhsaVX/oZlVluSuTOR0Ig5AIhJHMEuHxiIgDR48e0UzYyeQkCoWilHRAag52R+TDSsdKaoew2StXOrW9ae3u6qiqLBcJ+Zp1a29rdXRcNh0I4/ZyZsyYER8Xiyrk6kao6hRHA2Hbw8PT01IxNWk3MUvUYh4GTZw9k0GhUAru3yNeggmDum4KBTwHBwfDJgzvJ41GSz2dgpH2MGAoNDQk88J5ddJwi1tZWQ30S7RrwsPDY8aMGfhJqUSUknKqs2P0ugkQJhEL7e3tDZswqGrn51975513fH19Xr96qephCkTW3vYmPS31xm+/YmPNVYGM0NCQC+fPaSCs+fUrP7+NpqamV6/m8vp6J+RheBmFQqH8KzT0xm+/Zmdl7t+3t7LiEabGWeGkVCJaunTp5BGmWjIgzxaGIs+bnl29mnst7+rly5ceFNxXelWgCnl3V+c3u782MzM7cjgSGysrgceDggLPZKSrI0yByB4+KMjN/eFa3tW8vCvPnz/TTv/8/LzwsG179nyTm3sZXmDq7IN72OLFiyeDsElYidBMqlQimjlzZmxMNDbyBiKW74g+B+cDAr7ISE+bZM01jGa8Aken0/VOGG6Oxsb6Z40NxEtikUD15vGUCZQ6AzmYkumJEAp47777bkx0FIYisuFBJcWIxhonYQpEhjeqddiAHFIpgZxiwsAov/7y88aNG/bt2+vv77dr504MRQYHpMuXO8Kx/paU8K6KhPyZM2dGRx2Hk9xezt07tzEUaWysz8nOqqutJhoRQ5Hg4C+h0jqFsUG1FxKx0M7OTo+EARNHjhyeN29ebc1TOOnp6SkRC3fs2G5tbc3p7sQIo1siFtbVVtfWPFVCXW11Y0Odku00+CIAxKoSdjEn+8MPP6TT6Ze+v8hisRYuXGhpafmorBQb8RtMY5YIc2R9Y1TCpBKR3tP67KxMCoXy5I8qDEUGB6QYisTHxcbFxlhYWMAYB+Xgb1lpia2tLYPBsLGxWTzygWNn55XqKnvjgUjIp9FoEBL7peL169fNmTPnx/xrGIrIZUM0Gi0wMADoAYZCQtgassTJxySl9TCf9fPbCHaBUR8Z+Z21tfXu3V+rmkOByAYHpAP9ElUMDfYT70Tkw01NjQ31tfV1NapoqK9tqK/t7urACNGfRqPhIZEd/OXcuXNxaY7Lln366acYYS1Rg4e1tjSra1cnAOFKo3OSPCw6OsrMzKy4qJCYjLm4uNja2oznTathrPF5XBaL5cpkujKZTBcXJbh/8okrkxlHqFRBSAQPw1Bka1DQBx988CfCVq/Gh4JmwsLDwlyZzE/c3FTbJQ9XJhOUv3njN4zwdp8kwhwdl7333nuQlcHs55dfrltaWjY21CndCZo9ffLY29vb29vbS+Xj6+ujmlKOH0pJx9agIGUPW70aG5+HTQkmiTArKytv739gKAIBjdPdaWVlBcs/YpHgxYsmXBX429HelpGelpGelp6WqoTMC+eVouJECZs1a1ZsTDS80oO//Oe8efPwq8sdHT1HQiIMnb/oO2zBggUeHh5w/OrlCwcH+1MnkwMDAyorHh08GAEFAn3vywT5gwNSKpV67NhROLl586bZs2fj99jZLcGXLf7SHnbn9q1FixZFRR1POXVywwbf69d/xFAkhM2mUqmnU05hKjMw4hRYFWN2SV0VTiTkJyedmDt3rpeXV2XFo7LSkpVOTvPnz8/OyuR0d/70Uz6dTre1tbl18wae1r+187AlS5bokTAMRfg8bsH9exXlZdBzBSKTiIXPnjWQaVUJRNZHnYMPDw20t7WKRQJuL4fT3dnd1cHncUVCftubln6puO1Ni1DAE/D72tta8ZA4JaWpMQnTe6Vj1G0nRA101RMMRXo43TDPIwlgKDAwQEPxd/KBe9iiRYvIyBnbw/C6APGkrmpR0I2c7KwFCxZQqdQ5c+YcOnSQ5JoA6BYYGPBX9DC9Aix7985tBoORnpaam/uDm5ubqalpRMQBjMSYwD1MV4QRS9JaDyacML17mP4Avrvnm91Q0YAz9vZLaTSaFqvASoRpXg+bqKHB1mSmJZO9HqYnyGVDHe1tcADm2L9/n4WFhUQs1FomeMPWrUGj5rFaWPn2rZuhISHx8XEBAV9s2ODb0FCHTfwVDvcL+H0fffSRARNG7Ay4Qti2fzs42GthERwgZ+/eb6OijmMkPAwUiI+Ps7a2vn/vLoYiJcVF5ubmyUknMG334rW2NDMYDMMmDCcGXGHhwoV5eVcw0u+wnOws+N4KmYJnD6eLQqF8++0eXHLB/XvahWsQWFxU6OLyd8MmjGjls2cy1q9fh5GbMwDTFeVln332mdaiILno7emeP39+0onEwQGpgN+nbgvb+DuYnpZq8Dt/cRO/eN7k5eUFG5jITxukEpErk0lmBQ4UY7ODWSzWf7/6yslpRVHh71qvUfx/lY7NTjl10rAJwzeSbtrkDwUU8l+GAL59fD7/+fpPWtCPLwA5Oa3w8flcgcgG+iV4Kqs1EPmwm6vryxfPDZgwME2/VLxj+/YGwpINmSwRGxnO2VmZEH8mShjcH7ZtG4VC6erswOuTqsuw4xeIKuQPCu6zWCySFpt6D5MND27Zsvn8ubPNr1/V1DxtaKjLyc5KSIjXwtBK6JeKHR2XvWlt0W62S6fTiUtuTU2N8fFxYpFAC1HAt6+vT27uZQMmDMrwnp6eJiYm5ubmpqamJiYmZmZmFhYWVZXlJAmDZ1NPp/j7+2ETDLPw7LFjR83Nzf39/dLTUo8fP3b4cKR2URHYKiku8nB3J78Td4o9TCwSFBU+fPy4sqK8rKqyvKqy/HFVRc3I9iySALuzWKwrV3InyhmgpLgoMSE+LfV0RXkZGR36pWJn55V/PK7ESIeNqQ+J+gMMZ24vx83NtbioECO9wqBddUMuG1q7dm12ViY2PX6nY0J7hLUzcUd72+bNm+AnhCb6pQfN+5HHRFdnO5sdDGxNw1/C0QfA1oMD0sTEhJLiImwSf2uqj9sTFxcL4VRXqzzTn7BpBiNhBgYjYQYGI2EGBiNhBgYjYQYGI2EGhv8B553l7X3JlhsAAAAASUVORK5CYII=" alt="" />

AdaBoost算法的流程如图7-1所示。

图7-1　AdaBoost算法的示意图。左边是数据集，其中直方图的不同宽度表示每个样例上的不同权重。在经过一个分类器之后，

加权的预测结果会通过三角形中的alpha值进行加权。每个三角形中输出的加权结果在圆形中求和，从而得到最终的输出结果

　　计算出alpha值之后，可以对权重向量D进行更新，以使得那些正确分类的样本的权重降低而错分样本的权重升高。D的计算方法如下。

　　如果某个样本被正确分类，那么该样本的权重更改为：

　　aaarticlea/png;base64,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" alt="" />

　　而如果某个样本被错分，那么该样本的权重更改为：

　　aaarticlea/png;base64,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" alt="" />

　　在计算出D之后，AdaBoost又开始进入下一轮迭代。Ad-aBoost算法会不断地重复训练和调整权重的过程，直到训练错误率为0或者弱分类器的数目达到用户的指定值为止。

六、基于单层决策树构建弱分类

　　单层决策树（decision stump，也称决策树桩）是一种简单的决策树。前面我们已经介绍了决策树的工作原理，接下来将构建一个单层决策树，而它仅基于单个特征来做决策。由于这棵树只有一次分裂过程，因此它实际上就是一个树桩。

　　在构造AdaBoost的代码时，我们将首先通过一个简单数据集来确保在算法实现上一切就绪。然后，建立一个叫adaboost.py的新文件并加入如下代码：

 def loadSimpData():
     datMat = matrix([[ 1. ,  2.1],
         [ 2. ,  1.1],
         [ 1.3,  1. ],
         [ 1. ,  1. ],
         [ 2. ,  1. ]])
     classLabels = [1.0, 1.0, -1.0, -1.0, 1.0] #注意 这里的分类 为 1 和 -1
     return datMat,classLabels

　　图7-2给出了上述数据集的示意图。如果想要试着从某个坐标轴上选择一个值（即选择一条与坐标轴平行的直线）来将所有的圆形点和方形点分开，这显然是不可能的。这就是单层决策树难以处理的一个著名问题。通过使用多棵单层决策树，我们就可以构建出一个能够对该数据集完全正确分类的分类器。

图7-2　用于检测AdaBoost构建函数的简单数据。这不可能仅仅通过在某个坐标轴上选择某个阈值来将圆形点和方形点分开。AdaBoost需要将多个单层决策树组合起来才能对该数据集进行正确分类

　　有了数据，接下来就可以通过构建多个函数来建立单层决策树。

　　第一个函数将用于测试是否有某个值小于或者大于我们正在测试的阈值。第二个函数则更加复杂一些，它会在一个加权数据集中循环，并找到具有最低错误率的单层决策树。这个程序的伪代码看起来大致如下：

将最小错误率minError设为+∞

对数据集中的每一个特征（第一层循环）：

对每个步长（第二层循环）：

对每个不等号（第三层循环）：

建立一棵单层决策树并利用加权数据集对它进行测试

如果错误率低于minError，则将当前单层决策树设为最佳单层决策树

返回最佳单层决策树

　　程序清单7-1　单层决策树生成函数

 # 是通过阈值比较对数据进行分类的。所有在阈值一边的数据会分到类别-1，而在另外一边的数据分到类别+1。该函数可以通过数组过滤来实现，首先将返回数组的全部元素设置为1，然后将所有不满足不等式要求的元素设置为-1。
　　#可以基于数据集中的任一元素进行比较，同时也可以将不等号在大于、小于之间切换。
1 def stumpClassify(dataMatrix,dimen,threshVal,threshIneq):# 返回一个列向量-------- 分正确的为1， 分错的为-1 ，
     retArray = ones((shape(dataMatrix)[0],1))
     if threshIneq == 'lt':
         retArray[dataMatrix[:,dimen] <= threshVal] = -1.0
     else:
         retArray[dataMatrix[:,dimen] > threshVal] = -1.0
     #print (retArray)
     return retArray

 #遍历stumpClassify()函数所有的可能输入值，并找到数据集上最佳的单层决策树。这里的“最佳”是基于数据的权重向量D来定义的
 def buildStump(dataArr,classLabels,D): #权重向量D  classLabels=[1.0, 1.0, -1.0, -1.0, 1.0]
     dataMatrix = mat(dataArr); labelMat = mat(classLabels).T   #labelMat = 列矩阵
     m,n = shape(dataMatrix)
     numSteps = 10.0; bestStump = {}; bestClasEst = mat(zeros((m,1)))
     minError = inf #init error sum, to +infinity
     for i in range(n):#loop over all dimensions
         rangeMin = dataMatrix[:,i].min(); rangeMax = dataMatrix[:,i].max();
         stepSize = (rangeMax-rangeMin)/numSteps
         for j in range(-1,int(numSteps)+1):#loop over all range in current dimension
             for inequal in ['lt', 'gt']: #go over less than and greater than
                 threshVal = (rangeMin + float(j) * stepSize)
                 predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)#列向量
                 #print (predictedVals)
                 errArr = mat(ones((m,1))) #构建一个列向量errArr，如果predict-edVals中的值不等于labelMat中的真正类别标签值，那么er-rArr的相应位置为1。
                 errArr[predictedVals == labelMat] = 0
                 print(errArr)
                 weightedError = D.T*errArr  #将错误向量errArr和权重向量D的相应元素相乘并求和  -----分类错误率
                 #print "split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" % (i, threshVal, inequal, weightedError)
                 if weightedError < minError:
                     minError = weightedError
                     bestClasEst = predictedVals.copy()
                     bestStump['dim'] = i
                     bestStump['thresh'] = threshVal
                     bestStump['ineq'] = inequal
     return bestStump,minError,bestClasEst　　#返回分类的最小错误率

　　为了解实际运行过程，在Python提示符下输入如下命令：

 >>> import adaboost
 >>> from numpy import *
 >>> D=mat(ones((5,1))/5)
 >>> datMat,classLabels=adaboost.loadSimpData()
 >>> adaboost.buildStump(datMat,classLabels,D)
 split: dim 0, thresh 0.90, thresh ineqal: lt, the weighted error is 0.400
 split: dim 0, thresh 0.90, thresh ineqal: gt, the weighted error is 0.600
 split: dim 0, thresh 1.00, thresh ineqal: lt, the weighted error is 0.400
 split: dim 0, thresh 1.00, thresh ineqal: gt, the weighted error is 0.600
 split: dim 0, thresh 1.10, thresh ineqal: lt, the weighted error is 0.400
 split: dim 0, thresh 1.10, thresh ineqal: gt, the weighted error is 0.600
 split: dim 0, thresh 1.20, thresh ineqal: lt, the weighted error is 0.400
 split: dim 0, thresh 1.20, thresh ineqal: gt, the weighted error is 0.600
 split: dim 0, thresh 1.30, thresh ineqal: lt, the weighted error is 0.200
 split: dim 0, thresh 1.30, thresh ineqal: gt, the weighted error is 0.800
 split: dim 0, thresh 1.40, thresh ineqal: lt, the weighted error is 0.200
 split: dim 0, thresh 1.40, thresh ineqal: gt, the weighted error is 0.800
 split: dim 0, thresh 1.50, thresh ineqal: lt, the weighted error is 0.200
 split: dim 0, thresh 1.50, thresh ineqal: gt, the weighted error is 0.800
 split: dim 0, thresh 1.60, thresh ineqal: lt, the weighted error is 0.200
 split: dim 0, thresh 1.60, thresh ineqal: gt, the weighted error is 0.800
 split: dim 0, thresh 1.70, thresh ineqal: lt, the weighted error is 0.200
 split: dim 0, thresh 1.70, thresh ineqal: gt, the weighted error is 0.800
 split: dim 0, thresh 1.80, thresh ineqal: lt, the weighted error is 0.200
 split: dim 0, thresh 1.80, thresh ineqal: gt, the weighted error is 0.800
 split: dim 0, thresh 1.90, thresh ineqal: lt, the weighted error is 0.200
 split: dim 0, thresh 1.90, thresh ineqal: gt, the weighted error is 0.800
 split: dim 0, thresh 2.00, thresh ineqal: lt, the weighted error is 0.600
 split: dim 0, thresh 2.00, thresh ineqal: gt, the weighted error is 0.400
 split: dim 1, thresh 0.89, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 0.89, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.00, thresh ineqal: lt, the weighted error is 0.200
 split: dim 1, thresh 1.00, thresh ineqal: gt, the weighted error is 0.800
 split: dim 1, thresh 1.11, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.11, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.22, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.22, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.33, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.33, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.44, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.44, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.55, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.55, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.66, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.66, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.77, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.77, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.88, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.88, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 1.99, thresh ineqal: lt, the weighted error is 0.400
 split: dim 1, thresh 1.99, thresh ineqal: gt, the weighted error is 0.600
 split: dim 1, thresh 2.10, thresh ineqal: lt, the weighted error is 0.600
 split: dim 1, thresh 2.10, thresh ineqal: gt, the weighted error is 0.400
 ({'ineq': 'lt', 'thresh': 1.3, 'dim': 0}, matrix([[ 0.2]]), array([[-1.],
        [ 1.],
        [-1.],
        [-1.],
        [ 1.]]))
 >>> 

　　上述单层决策树的生成函数是决策树的一个简化版本。它就是所谓的弱学习器，即弱分类算法。到现在为止，我们已经构建了单层决策树，并生成了程序，做好了过渡到完整AdaBoost算法的准备。在下一节当中，我们将使用多个弱分类器来构建Ad-aBoost代码。

七、完整的AdaBoost算法

　　整个实现的伪代码如下：

对每次迭代：

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

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

计算alpha

计算新的权重向量D

更新累计类别估计值

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

　　程序清单7-2　基于单层决策树的AdaBoost训练过程

 def adaBoostTrainDS(dataArr,classLabels,numIt=40):
     weakClassArr = []
     m = shape(dataArr)[0]
     D = mat(ones((m,1))/m)   #向量D非常重要，它包含了每个数据点的权重
     aggClassEst = mat(zeros((m,1)))   #列向量aggClassEst，记录每个数据点的类别估计累计值。
     for i in range(numIt):
         bestStump,error,classEst = buildStump(dataArr,classLabels,D)#bestStump=字典,error=分类错误率,classEst=列向量，预测之后的分类列表
         #print "D:",D.T
         alpha = float(0.5*log((1.0-error)/max(error,1e-16)))#求alpha 值 上面的数学公式, throw in max(error,eps) to account for error=0
         bestStump['alpha'] = alpha
         weakClassArr.append(bestStump)                  #store Stump Params in Array
         #print "classEst: ",classEst.T // ①（以下两行）为下一次迭代计算D
         expon = multiply(-1*alpha*mat(classLabels).T,classEst) # 样本被正确分类的话 expon 为负，错误分类的话 为正 其中第一次分对的样本的权重将会降低，而第一次分错的样本的权重将会提高
         D = multiply(D,exp(expon))                              #迭代计算公式
         D = D/D.sum()
         # ②（以下五行）错误率累加计算
         aggClassEst += alpha*classEst
         #print "aggClassEst: ",aggClassEst.T
         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,aggClassEst

　　测试代码：

 >>> imp.reload(adaboost)
 <module 'adaboost' from 'F:\\99999_算法\\《机器学习实战》源代码\\machinelearninginaction\\Ch07\\adaboost.py'>
 >>> classifierArray,aggClassEst=adaboost.adaBoostTrainDS(datMat,classLabels,9)
 D: [[ 0.2  0.2  0.2  0.2  0.2]]
 alpha: 0.6931471805599453
 classEst:  [[-1.  1. -1. -1.  1.]]
 aggClassEst:  [[-0.69314718  0.69314718 -0.69314718 -0.69314718  0.69314718]]
 aggErrors : [[ 1.  0.  0.  0.  0.]]
 total error:  0.2
 D: [[ 0.5    0.125  0.125  0.125  0.125]]
 alpha: 0.9729550745276565
 classEst:  [[ 1.  1. -1. -1. -1.]]
 aggClassEst:  [[ 0.27980789  1.66610226 -1.66610226 -1.66610226 -0.27980789]]
 aggErrors : [[ 0.  0.  0.  0.  1.]]
 total error:  0.2
 D: [[ 0.28571429  0.07142857  0.07142857  0.07142857  0.5       ]]
 alpha: 0.8958797346140273
 classEst:  [[ 1.  1.  1.  1.  1.]]
 aggClassEst:  [[ 1.17568763  2.56198199 -0.77022252 -0.77022252  0.61607184]]
 aggErrors : [[ 0.  0.  0.  0.  0.]]
 total error:  0.0
 >>> classifierArray
 [{'ineq': 'lt', 'thresh': 1.3, 'alpha': 0.6931471805599453, 'dim': 0}, {'ineq': 'lt', 'thresh': 1.0, 'alpha': 0.9729550745276565, 'dim': 1}, 
　　{'ineq': 'lt', 'thresh': 0.90000000000000002, 'alpha': 0.8958797346140273, 'dim': 0}]
 >>> aggClassEst
 matrix([[ 1.17568763],
         [ 2.56198199],
         [-0.77022252],
         [-0.77022252],
         [ 0.61607184]])
 >>> 

　AdaBoost算法的输入参数包括数据集、类别标签以及迭代次数numIt，其中numIt是在整个AdaBoost算法中唯一需要用户指定的参数。

　　我们假定迭代次数设为9，如果算法在第三次迭代之后错误率为0，那么就会退出迭代过程，因此，此时就不需要执行所有的9次迭代过程。每次迭代的中间结果都会通过print语句进行输出。后面，读者可以把print输出语句注释掉，但是现在可以通过中间结果来了解AdaBoost算法的内部运行过程。

　　向量D非常重要，它包含了每个数据点的权重。一开始，这些权重都赋予了相等的值。在后续的迭代中，AdaBoost算法会在增加错分数据的权重的同时，降低正确分类数据的权重。D是一个概率分布向量，因此其所有的元素之和为1.0。为了满足此要求，一开始的所有元素都会被初始化成1/m。同时，程序还会建立另一个列向量aggClassEst，记录每个数据点的类别估计累计值。

　　AdaBoost算法的核心在于for循环，该循环运行numIt次或者直到训练错误率为0为止。循环中的第一件事就是利用前面介绍的buildStump()函数建立一个单层决策树。该函数的输入为权重向量D，返回的则是利用D而得到的具有最小错误率的单层决策树，同时返回的还有最小的错误率以及估计的类别向量。

　　接下来，需要计算的则是alpha值。该值会告诉总分类器本次单层决策树输出结果的权重。其中的语句max(error,1e-16)用于确保在没有错误时不会发生除零溢出。而后，alpha值加入到bestStump字典中，该字典又添加到列表中。该字典包括了分类所需要的所有信息。

　　接下来的三行①则用于计算下一次迭代中的新权重向量D。

　　在训练错误率为0时，就要提前结束for循环。此时程序是通过aggClassEst变量保持一个运行时的类别估计值来实现的②。该值只是一个浮点数，为了得到二值分类结果还需要调用sign()函数。如果总错误率为0，则由break语句中止for循环。

　　classifierArray：该数组包含三部词典，其中包含了分类所需要的所有信息。

　　此时，一个分类器已经构建成功，而且只要我们愿意，随时都可以将训练错误率降到0。那么测试错误率会如何呢？为了观察测试错误率，我们需要编写分类的一些代码。下一节我们将讨论分类。

八、测试算法：基于AdaBoost的分类

　　一旦拥有了多个弱分类器以及其对应的alpha值，进行测试就变得相当容易了。在程序清单7-2的adaBoostTrainDS()中，我们实际已经写完了大部分的代码。现在，需要做的就只是将弱分类器的训练过程从程序中抽出来，然后应用到某个具体的实例上去。每个弱分类器的结果以其对应的alpha值作为权重。所有这些弱分类器的结果加权求和就得到了最后的结果。在程序清单7-3中列出了实现这一过程的所有代码。然后，将下列代码添加到adaboost.py中，就可以利用它基于adaboostTrainDS()中的弱分类器对数据进行分类。

　　程序清单7-3　AdaBoost分类函数

 def adaClassify(datToClass,classifierArr):
     dataMatrix = mat(datToClass)#do stuff similar to last aggClassEst in adaBoostTrainDS
     m = shape(dataMatrix)[0]
     aggClassEst = mat(zeros((m,1)))
     for i in range(len(classifierArr)):
         classEst = stumpClassify(dataMatrix,classifierArr[i]['dim'],\
                                  classifierArr[i]['thresh'],\
                                  classifierArr[i]['ineq'])#call stump classify
         aggClassEst += classifierArr[i]['alpha']*classEst
         print (aggClassEst)
     return sign(aggClassEst) #返回-1  0  1 

上述的adaClassify()函数就是利用训练出的多个弱分类器进行分类的函数。该函数的输入是由一个或者多个待分类样例datToClass以及多个弱分类器组成的数组classifierArr。程序返回aggClassEst的符号，即如果aggClassEst大于0则返回+1，而如果小于0则返回-1。

　　我们再看看实际中的运行效果。加入程序清单7-3中的代码之后，在Python提示符下输入：

 >>> adaboost.adaClassify([0,0],classifierArray)
 [[-0.69314718]]
 [[-1.66610226]]
 [[-2.56198199]]
 matrix([[-1.]])
 >>> 

　　可以发现，随着迭代的进行，数据点[0,0]的分类结果越来越强。

九、示例：在一个难数据集上应用AdaBoost

　　本节我们将在第4章给出的马疝病数据集上应用AdaBoost分类器。在第4章，我们曾经利用Logistic回归来预测患有疝病的马是否能够存活。而在本节，我们则想要知道如果利用多个单层决策树和AdaBoost能不能预测得更准。

示例：在一个难数据集上的AdaBoost应用

（1）收集数据：提供的文本文件。

（2）准备数据：确保类别标签是+1和-1而非1和0。

（3）分析数据：手工检查数据。

（4）训练算法：在数据上，利用adaBoostTrainDS()函数训练出一系列的分类器。

（5）测试算法：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对AdaBoost和Logistic回归的结果进行完全对等的比较。

（6）使用算法：观察该例子上的错误率。不过，也可以构建一个Web网站，让驯马师输入马的症状然后预测马是否会死去。

　　程序清单7-4　自适应数据加载函数

 def loadDataSet(fileName):      #general function to parse tab -delimited floats
     numFeat = len(open(fileName).readline().split('\t')) #get number of fields
     dataMat = []; labelMat = []
     fr = open(fileName)
     for line in fr.readlines():
         lineArr =[]
         curLine = line.strip().split('\t')
         for i in range(numFeat-1):
             lineArr.append(float(curLine[i]))
         dataMat.append(lineArr)
         labelMat.append(float(curLine[-1]))
     return dataMat,labelMat

　　将上述代码添加到adaboost.py文件中并且将其保存之后，就可以输入如下命令来使用上述函数：

 >>> datArr,labelArr=adaboost.loadDataSet('horseColicTraining2.txt')
 >>> classifierArray，b=adaboost.adaBoostTrainDS(datArr,labelArr,10)
 total error:0.284280936455
 total error:0.284280936455
                     .
                     .
 total error:0.230769230769
 >>> testArr,testLabelArr=adaboost.loadDataSet('horseColicTest2.txt')
 >>> prediction10=adaboost.adaClassify(testArr,classifierArray)
 To get the number of misclassified examples type in:
 >>> errArr=mat(ones((67,1)))
 >>>errArr[prediction10!=mat(testLabelArr).T].sum()
 16.0

　　要得到错误率，只需将上述错分样例的个数除以67即可。

　　将弱分类器的数目设定为1到10000之间的几个不同数字，并运行上述过程。这时，得到的结果就会如表7-1所示。在该数据集上得到的错误率相当低。如果没忘的话，在第5章中，我们在同一数据集上采用Logistic回归得到的平均错误率为0.35。而采用AdaBoost，得到的错误率就永远不会那么高了。从表中可以看出，我们仅仅使用50个弱分类器，就达到了较高的性能。

　　表7-1　不同弱分类器数目情况下的AdaBoost测试和分类错误率。该数据集是个难数据集。通常情况下，AdaBoost会达到一个稳定的测试错误率，而并不会随分类器数目的增多而提高

　　观察表7-1中的测试错误率一栏，就会发现测试错误率在达到了一个最小值之后又开始上升了。这类现象称之为过拟合（overfitting，也称过学习）。有文献声称，对于表现好的数据集，AdaBoost的测试错误率就会达到一个稳定值，并不会随着分类器的增多而上升。或许在本例子中的数据集也称不上“表现好”。该数据集一开始有30%的缺失值，对于Logistic回归而言，这些缺失值的假设就是有效的，而对于决策树却可能并不合适。如果回到数据集，将所有的0值替换成其他值，或者给定类别的平均值，那么能否得到更好的性能？

　　很多人都认为，AdaBoost和SVM是监督机器学习中最强大的两种方法。实际上，这两者之间拥有不少相似之处。我们可以把弱分类器想象成SVM中的一个核函数，也可以按照最大化某个最小间隔的方式重写AdaBoost算法。而它们的不同就在于其所定义的间隔计算方式有所不同，因此导致的结果也不同。特别是在高维空间下，这两者之间的差异就会更加明显。

　　在下一节中，我们不再讨论AdaBoost，而是转而关注所有分类器中的一个普遍问题。

十、非均衡分类的问题

　　在我们结束分类这个主题之前，还必须讨论一个问题。在前面六章的所有分类介绍中，我们都假设所有类别的分类代价是一样的。例如在第5章，我们构建了一个用于检测患疝病的马匹是否存活的系统。在那里，我们构建了分类器，但是并没有对分类后的情形加以讨论。假如某人给我们牵来一匹马，他希望我们能预测这匹马能否生存。我们说马会死，那么他们就可能会对马实施安乐死，而不是通过给马喂药来延缓其不可避免的死亡过程。我们的预测也许是错误的，马本来是可以继续活着的。毕竟，我们的分类器只有80%的精确率（accuracy）。如果我们预测错误，那么我们将会错杀了一个如此昂贵的动物，更不要说人对马还存在情感上的依恋。

　　如何过滤垃圾邮件呢？如果收件箱中会出现某些垃圾邮件，但合法邮件永远不会扔进垃圾邮件夹中，那么人们是否会满意呢？癌症检测又如何呢？只要患病的人不会得不到治疗，那么再找一个医生来看看会不会更好呢（即情愿误判也不漏判）？

　　还可以举出很多很多这样的例子，坦白地说，在大多数情况下不同类别的分类代价并不相等。在本节中，我们将会考察一种新的分类器性能度量方法，并通过图像技术来对在上述非均衡问题下不同分类器的性能进行可视化处理。然后，我们考察这两种分类器的变换算法，它们能够将不同决策的代价考虑在内。

　　1、其他分类性能度量指标：正确率、召回率及ROC曲线

　　2、基于代价函数的分类器决策控制

　　3、处理非均衡问题的数据抽样方法