随机森林（Random Forest），决策树，bagging， boosting（Adaptive Boosting，GBDT）

http://www.cnblogs.com/maybe2030/p/4585705.html

阅读目录

• 1 什么是随机森林？
• 2 随机森林的特点
• 3 随机森林的相关基础知识
• 4 随机森林的生成
• 5 袋外错误率（oob error）
• 6 随机森林工作原理解释的一个简单例子
• 7 随机森林的Python实现
• 8 参考内容

回到顶部

1 什么是随机森林？

　　作为新兴起的、高度灵活的一种机器学习算法，随机森林（Random Forest，简称RF）拥有广泛的应用前景，从市场营销到医疗保健保险，既可以用来做市场营销模拟的建模，统计客户来源，保留和流失，也可用来预测疾病的风险和病患者的易感性。最初，我是在参加校外竞赛时接触到随机森林算法的。最近几年的国内外大赛，包括2013年百度校园电影推荐系统大赛、2014年阿里巴巴天池大数据竞赛以及Kaggle数据科学竞赛，参赛者对随机森林的使用占有相当高的比例。此外，据我的个人了解来看，一大部分成功进入答辩的队伍也都选择了Random Forest 或者 GBDT 算法。所以可以看出，Random Forest在准确率方面还是相当有优势的。

　　那说了这么多，那随机森林到底是怎样的一种算法呢？

　　如果读者接触过决策树（Decision Tree）的话，那么会很容易理解什么是随机森林。随机森林就是通过集成学习的思想将多棵树集成的一种算法，它的基本单元是决策树，而它的本质属于机器学习的一大分支——集成学习（Ensemble Learning）方法。随机森林的名称中有两个关键词，一个是“随机”，一个就是“森林”。“森林”我们很好理解，一棵叫做树，那么成百上千棵就可以叫做森林了，这样的比喻还是很贴切的，其实这也是随机森林的主要思想--集成思想的体现。“随机”的含义我们会在下边部分讲到。

　　其实从直观角度来解释，每棵决策树都是一个分类器（假设现在针对的是分类问题），那么对于一个输入样本，N棵树会有N个分类结果。而随机森林集成了所有的分类投票结果，将投票次数最多的类别指定为最终的输出，这就是一种最简单的 Bagging 思想。

回到顶部

2 随机森林的特点

　　我们前边提到，随机森林是一种很灵活实用的方法，它有如下几个特点：

• 在当前所有算法中，具有极好的准确率/It is unexcelled in accuracy among current algorithms；
• 能够有效地运行在大数据集上/It runs efficiently on large data bases；
• 能够处理具有高维特征的输入样本，而且不需要降维/It can handle thousands of input variables without variable deletion；
• 能够评估各个特征在分类问题上的重要性/It gives estimates of what variables are important in the classification；
• 在生成过程中，能够获取到内部生成误差的一种无偏估计/It generates an internal unbiased estimate of the generalization error as the forest building progresses；
• 对于缺省值问题也能够获得很好得结果/It has an effective method for estimating missing data and maintains accuracy when a large proportion of the data are missing
• ... ...

　　实际上，随机森林的特点不只有这六点，它就相当于机器学习领域的Leatherman（多面手），你几乎可以把任何东西扔进去，它基本上都是可供使用的。在估计推断映射方面特别好用，以致都不需要像SVM那样做很多参数的调试。具体的随机森林介绍可以参见随机森林主页：Random Forest。

回到顶部

3 随机森林的相关基础知识

　　随机森林看起来是很好理解，但是要完全搞明白它的工作原理，需要很多机器学习方面相关的基础知识。在本文中，我们简单谈一下，而不逐一进行赘述，如果有同学不太了解相关的知识，可以参阅其他博友的一些相关博文或者文献。

　　1）信息、熵以及信息增益的概念

　　这三个基本概念是决策树的根本，是决策树利用特征来分类时，确定特征选取顺序的依据。理解了它们，决策树你也就了解了大概。

　　引用香农的话来说，信息是用来消除随机不确定性的东西。当然这句话虽然经典，但是还是很难去搞明白这种东西到底是个什么样，可能在不同的地方来说，指的东西又不一样。对于机器学习中的决策树而言，如果带分类的事物集合可以划分为多个类别当中，则某个类（x_i）的信息可以定义如下:

　　I(x)用来表示随机变量的信息，p(xi)指是当xi发生时的概率。

　　熵是用来度量不确定性的，当熵越大，X=xi的不确定性越大，反之越小。对于机器学习中的分类问题而言，熵越大即这个类别的不确定性更大，反之越小。

　　信息增益在决策树算法中是用来选择特征的指标，信息增益越大，则这个特征的选择性越好。

　　这方面的内容不再细述，感兴趣的同学可以看 信息&熵&信息增益 这篇博文。

　　2）决策树

　　决策树是一种树形结构，其中每个内部节点表示一个属性上的测试，每个分支代表一个测试输出，每个叶节点代表一种类别。常见的决策树算法有C4.5、ID3和CART。

　　3）集成学习　

　　集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成单预测，因此优于任何一个单分类的做出预测。

　　随机森林是集成学习的一个子类，它依靠于决策树的投票选择来决定最后的分类结果。你可以在这找到用python实现集成学习的文档：Scikit 学习文档。

回到顶部

4 随机森林的生成

　　前面提到，随机森林中有许多的分类树。我们要将一个输入样本进行分类，我们需要将输入样本输入到每棵树中进行分类。打个形象的比喻：森林中召开会议，讨论某个动物到底是老鼠还是松鼠，每棵树都要独立地发表自己对这个问题的看法，也就是每棵树都要投票。该动物到底是老鼠还是松鼠，要依据投票情况来确定，获得票数最多的类别就是森林的分类结果。森林中的每棵树都是独立的，99.9%不相关的树做出的预测结果涵盖所有的情况，这些预测结果将会彼此抵消。少数优秀的树的预测结果将会超脱于芸芸“噪音”，做出一个好的预测。将若干个弱分类器的分类结果进行投票选择，从而组成一个强分类器，这就是随机森林bagging的思想（关于bagging的一个有必要提及的问题：bagging的代价是不用单棵决策树来做预测，具体哪个变量起到重要作用变得未知，所以bagging改进了预测准确率但损失了解释性。）。下图可以形象地描述这个情况：

　

　　有了树我们就可以分类了，但是森林中的每棵树是怎么生成的呢？

　　每棵树的按照如下规则生成：

　　1）如果训练集大小为N，对于每棵树而言，随机且有放回地从训练集中的抽取N个训练样本（这种采样方式称为bootstrap sample方法），作为该树的训练集；

　　从这里我们可以知道：每棵树的训练集都是不同的，而且里面包含重复的训练样本（理解这点很重要）。

　　为什么要随机抽样训练集？（add @2016.05.28）

　　如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的，这样的话完全没有bagging的必要；

　　为什么要有放回地抽样？（add @2016.05.28）

　　我理解的是这样的：如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是"有偏的"，都是绝对"片面的"（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决，这种表决应该是"求同"，因此使用完全不同的训练集来训练每棵树这样对最终分类结果是没有帮助的，这样无异于是"盲人摸象"。

　　2）如果每个样本的特征维度为M，指定一个常数m<<M，随机地从M个特征中选取m个特征子集，每次树进行分裂时，从这m个特征中选择最优的；

　　3）每棵树都尽最大程度的生长，并且没有剪枝过程。

　　一开始我们提到的随机森林中的“随机”就是指的这里的两个随机性。两个随机性的引入对随机森林的分类性能至关重要。由于它们的引入，使得随机森林不容易陷入过拟合，并且具有很好得抗噪能力（比如：对缺省值不敏感）。

　　随机森林分类效果（错误率）与两个因素有关：

• 森林中任意两棵树的相关性：相关性越大，错误率越大；
• 森林中每棵树的分类能力：每棵树的分类能力越强，整个森林的错误率越低。

　　减小特征选择个数m，树的相关性和分类能力也会相应的降低；增大m，两者也会随之增大。所以关键问题是如何选择最优的m（或者是范围），这也是随机森林唯一的一个参数。

回到顶部

5 袋外错误率（oob error）

　　上面我们提到，构建随机森林的关键问题就是如何选择最优的m，要解决这个问题主要依据计算袋外错误率oob error（out-of-bag error）。

　　随机森林有一个重要的优点就是，没有必要对它进行交叉验证或者用一个独立的测试集来获得误差的一个无偏估计。它可以在内部进行评估，也就是说在生成的过程中就可以对误差建立一个无偏估计。

　　我们知道，在构建每棵树时，我们对训练集使用了不同的bootstrap sample（随机且有放回地抽取）。所以对于每棵树而言（假设对于第k棵树），大约有1/3的训练实例没有参与第k棵树的生成，它们称为第k棵树的oob样本。

　　而这样的采样特点就允许我们进行oob估计，它的计算方式如下：

　　（note：以样本为单位）

　　1）对每个样本，计算它作为oob样本的树对它的分类情况（约1/3的树）；

　　2）然后以简单多数投票作为该样本的分类结果；

　　3）最后用误分个数占样本总数的比率作为随机森林的oob误分率。

　　（文献原文：Put each case left out in the construction of the kth tree down the kth tree to get a classification. In this way, a test set classification is obtained for each case in about one-third of the trees. At the end of the run, take j to be the class that got most of the votes every time case n was oob. The proportion of times that j is not equal to the true class of n averaged over all cases is the oob error estimate. This has proven to be unbiased in many tests.）

　　oob误分率是随机森林泛化误差的一个无偏估计，它的结果近似于需要大量计算的k折交叉验证。

回到顶部

6 随机森林工作原理解释的一个简单例子

　　描述：根据已有的训练集已经生成了对应的随机森林，随机森林如何利用某一个人的年龄（Age）、性别（Gender）、教育情况（Highest Educational Qualification）、工作领域（Industry）以及住宅地（Residence）共5个字段来预测他的收入层次。

　　收入层次 :

　　　　Band 1 : Below $40,000

　　　　Band 2: $40,000 – 150,000

　　　　Band 3: More than $150,000

　　随机森林中每一棵树都可以看做是一棵CART（分类回归树），这里假设森林中有5棵CART树，总特征个数N=5，我们取m=1（这里假设每个CART树对应一个不同的特征）。

　　CART 1 : Variable Age

　　

　　CART 2 : Variable Gender

　　

　　CART 3 : Variable Education

　　

　　CART 4 : Variable Residence

　　

　　CART 5 : Variable Industry

　　

　　我们要预测的某个人的信息如下：

　　1. Age : 35 years ; 2. Gender : Male ; 3. Highest Educational Qualification : Diploma holder; 4. Industry : Manufacturing; 5. Residence : Metro.

　　根据这五棵CART树的分类结果，我们可以针对这个人的信息建立收入层次的分布情况：

　　

　　最后，我们得出结论，这个人的收入层次70%是一等，大约24%为二等，6%为三等，所以最终认定该人属于一等收入层次（小于$40,000）。

回到顶部

7 随机森林的Python实现

　　利用Python的两个模块，分别为pandas和scikit-learn来实现随机森林。

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import numpy as np

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['is_train'] = np.random.uniform(0, 1, len(df)) <= .75
df['species'] = pd.Factor(iris.target, iris.target_names)
df.head()

train, test = df[df['is_train']==True], df[df['is_train']==False]

features = df.columns[:4]
clf = RandomForestClassifier(n_jobs=2)
y, _ = pd.factorize(train['species'])
clf.fit(train[features], y)

preds = iris.target_names[clf.predict(test[features])]
pd.crosstab(test['species'], preds, rownames=['actual'], colnames=['preds'])

　　分类结果：

　　

　　与其他机器学习分类算法进行对比：

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.lda import LDA
from sklearn.qda import QDA

h = .02  # step size in the mesh

names = ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Decision Tree",
         "Random Forest", "AdaBoost", "Naive Bayes", "LDA", "QDA"]
classifiers = [
    KNeighborsClassifier(3),
    SVC(kernel="linear", C=0.025),
    SVC(gamma=2, C=1),
    DecisionTreeClassifier(max_depth=5),
    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
    AdaBoostClassifier(),
    GaussianNB(),
    LDA(),
    QDA()]

X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1)
rng = np.random.RandomState(2)
X += 2 * rng.uniform(size=X.shape)
linearly_separable = (X, y)

datasets = [make_moons(noise=0.3, random_state=0),
            make_circles(noise=0.2, factor=0.5, random_state=1),
            linearly_separable
            ]

figure = plt.figure(figsize=(27, 9))
i = 1
# iterate over datasets
for ds in datasets:
    # preprocess dataset, split into training and test part
    X, y = ds
    X = StandardScaler().fit_transform(X)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)

    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))

    # just plot the dataset first
    cm = plt.cm.RdBu
    cm_bright = ListedColormap(['#FF0000', '#0000FF'])
    ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
    # Plot the training points
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
    # and testing points
    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xticks(())
    ax.set_yticks(())
    i += 1

    # iterate over classifiers
    for name, clf in zip(names, classifiers):
        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
        clf.fit(X_train, y_train)
        score = clf.score(X_test, y_test)

        # Plot the decision boundary. For that, we will assign a color to each
        # point in the mesh [x_min, m_max]x[y_min, y_max].
        if hasattr(clf, "decision_function"):
            Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
        else:
            Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]

        # Put the result into a color plot
        Z = Z.reshape(xx.shape)
        ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)

        # Plot also the training points
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
        # and testing points
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
                   alpha=0.6)

        ax.set_xlim(xx.min(), xx.max())
        ax.set_ylim(yy.min(), yy.max())
        ax.set_xticks(())
        ax.set_yticks(())
        ax.set_title(name)
        ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
                size=15, horizontalalignment='right')
        i += 1

figure.subplots_adjust(left=.02, right=.98)
plt.show()

　　这里随机生成了三个样本集，分割面近似为月形、圆形和线形的。我们可以重点对比一下决策树和随机森林对样本空间的分割：

　　1）从准确率上可以看出，随机森林在这三个测试集上都要优于单棵决策树，90%>85%，82%>80%，95%=95%；

　　2）从特征空间上直观地可以看出，随机森林比决策树拥有更强的分割能力（非线性拟合能力）。

　　更多有关随机森林的代码：

　　1）Fortran版本

　　2）OpenCV版本

　　3）Matlab版本

　　4）R版本

回到顶部

随机森林与决策树

一、决策树

决策树是机器学习最基本的模型，在不考虑其他复杂情况下，我们可以用一句话来描述决策树：如果得分大于等于60分，那么你及格了。

这是一个最最简单的决策树的模型，我们把及格和没及格分别附上标签，及格（1），没及格（0），那么得到的决策树是这样的

但是我们几乎不会让计算机做这么简单的工作，我们把情况变得复杂一点

引用别的文章的一个例子

这是一张女孩对于不同条件的男性是否会选择见面的统计表，图中是否见面作为我们需要分类的结果，因此最后我们的结果无非就只是是和否两种情况。这是一个二分类的问题，但是需要判断的条件多了很多，现在不仅仅只是一个判断就能得出结果了，但是从上图我们找到了一个结果为否的记录，因此如果一个男性在城市无房产、年收入小于 17w 且离过婚，则可以预测女孩不会跟他见面。

那么问题就来了，在这种复杂的情况下，决策树怎么构建？

先通过城市是否拥有房产这条特征，把这10个人划分为2类

这个分类结果并不是很好，因为它没有将见面与不见面完全的分开，在算法中，当然不能凭我们的“感觉”去评价分类结果的好坏。我们需要用一个数去表示。

二、Gini不纯度

Gini不纯度是对分类结果好坏的度量标准（还可以用信息熵和增益去表示，可自行了解）

他的值是：1-每个标签占总数的比例的平方和。即1–∑mi=1fi2

对于上述的结果来讲，总的集合D被分为两个集合D1，D2，假设见面为1，不见面为0。

那么D1的不纯度为1-f1^2-f0^2，总数为5，见面的占了全部，则f1=1，f0=0，结果为0

D2的不纯度为1-f1^2-f0^2，f1=0.8，f0=0.2，结果为0.32

ok，那么整个分类结果的Gini不纯度就是D1/D与0的乘积 加上 D2/D与0.32的乘积，为0.16

Gini值代表了某一个分类结果的“纯度”，我们希望结果的纯度很高，这样就不需要对这一结果进行处理了。

从以上分析可以看出，Gini值越小，纯度越高，结果越好。

三、决策树的生成

在第一个例子中“如果得分大于等于60分，那么你及格了”中，生成决策树步骤是首先选择特征，“得分”，然后确定临界值，“>=60”

1.复杂的情况下也是一样，对于每一个特征，找到一个使得Gini值最小的分割点（这个分割点可以是>,<,>=这样的判断，也可以是=，!=），然后比较每个特征之间最小的Gini值，作为当前最优的特征的最优分割点（这实际上涉及到了两个步骤，选择最优特征以及选择最优分割点）。

2.在第一步完成后，会生成两个叶节点，我们对这两个叶节点做判断，计算它的Gini值是否足够小（若是，就将其作为叶子不再分类）

3.将上步得到的叶节点作为新的集合，进行步骤1的分类，延伸出两个新的叶子节点（当然此时该节点变成了父节点）

4.循环迭代至不再有Gini值不符合标准的叶节点

四、决策树的缺陷

我们用决策树把一个平面上的众多点分为两类，每一个点都有（x1，x2）两个特征，下面展示分类的过程

最后生成的决策树，取了四个分割点，在图上的显示如下，只要是落在*矩形区域内默认是绿色，否则为红色

不过这种情况是分类参数选择比较合理的情况（它不介意某些绿色的点落在外围），但是当我们在训练的时候需要将所有的绿点无差错的分出来（即参数选择不是很合理的情况），决策树会产生过拟合的现象，导致泛化能力变弱。

五、随机森林

鉴于决策树容易过拟合的缺点，随机森林采用多个决策树的投票机制来改善决策树，我们假设随机森林使用了m棵决策树，那么就需要产生m个一定数量的样本集来训练每一棵树，如果用全样本去训练m棵决策树显然是不可取的，全样本训练忽视了局部样本的规律，对于模型的泛化能力是有害的

产生n个样本的方法采用Bootstraping法，这是一种有放回的抽样方法，产生n个样本

而最终结果采用Bagging的策略来获得，即多数投票机制

随机森林的生成方法：

1.从样本集中通过重采样的方式产生n个样本

2.假设样本特征数目为a，对n个样本选择a中的k个特征，用建立决策树的方式获得最佳分割点

3.重复m次，产生m棵决策树

4.多数投票机制来进行预测

（需要注意的一点是，这里m是指循环的次数，n是指样本的数目，n个样本构成训练的样本集，而m次循环中又会产生m个这样的样本集）

转自：http://blog.****.net/mao_xiao_feng/article/details/52728164

六、随机森林模型的总结

随机森林是一个比较优秀的模型，在我的项目的使用效果上来看，它对于多维特征的数据集分类有很高的效率，还可以做特征重要性的选择。运行效率和准确率较高，实现起来也比较简单。但是在数据噪音比较大的情况下会过拟合，过拟合的缺点对于随机森林来说还是较为致命的。

Bagging and Boosting 概念和区别

Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个性能更加强大的分类器，更准确的说这是一种分类算法的组装方法。即将弱分类器组装成强分类器的方法。

首先介绍Bootstraping，即自助法：它是一种有放回的抽样方法（可能抽到重复的样本）。

1、Bagging (bootstrap aggregating)

Bagging即套袋法，其算法过程如下：

A）从原始样本集中抽取训练集。每轮从原始样本集中使用Bootstraping的方法抽取n个训练样本（在训练集中，有些样本可能被多次抽取到，而有些样本可能一次都没有被抽中）。共进行k轮抽取，得到k个训练集。（k个训练集之间是相互独立的）

B）每次使用一个训练集得到一个模型，k个训练集共得到k个模型。（注：这里并没有具体的分类算法或回归方法，我们可以根据具体问题采用不同的分类或回归方法，如决策树、感知器等）

C）对分类问题：将上步得到的k个模型采用投票的方式得到分类结果；对回归问题，计算上述模型的均值作为最后的结果。（所有模型的重要性相同）

2、Boosting

其主要思想是将弱分类器组装成一个强分类器。在PAC（概率近似正确）学习框架下，则一定可以将弱分类器组装成一个强分类器。

关于Boosting的两个核心问题：

1）在每一轮如何改变训练数据的权值或概率分布？

通过提高那些在前一轮被弱分类器分错样例的权值，减小前一轮分对样例的权值，来使得分类器对误分的数据有较好的效果。

2）通过什么方式来组合弱分类器？

通过加法模型将弱分类器进行线性组合，比如AdaBoost通过加权多数表决的方式，即增大错误率小的分类器的权值，同时减小错误率较大的分类器的权值。

而提升树通过拟合残差的方式逐步减小残差，将每一步生成的模型叠加得到最终模型。

3、Bagging，Boosting二者之间的区别

Bagging和Boosting的区别：

1）样本选择上：

Bagging：训练集是在原始集中有放回选取的，从原始集中选出的各轮训练集之间是独立的。

Boosting：每一轮的训练集不变，只是训练集中每个样例在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整。

2）样例权重：

Bagging：使用均匀取样，每个样例的权重相等

Boosting：根据错误率不断调整样例的权值，错误率越大则权重越大。

3）预测函数：

Bagging：所有预测函数的权重相等。

Boosting：每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重。

4）并行计算：

Bagging：各个预测函数可以并行生成

Boosting：各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。

4、总结

这两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果，将不同的分类算法套入到此类算法框架中一定程度上会提高了原单一分类器的分类效果，但是也增大了计算量。

下面是将决策树与这些算法框架进行结合所得到的新的算法：

1）Bagging + 决策树 = 随机森林

2）AdaBoost + 决策树 = 提升树

3）Gradient Boosting + 决策树 = GBDT

5、Adaptive Boosting是一种迭代算法。

每轮迭代中会在训练集上产生一个新的学习器，然后使用该学习器对所有样本进行预测，以评估每个样本的重要性(Informative)。换句话来讲就是，算法会为每个样本赋予一个权重，每次用训练好的学习器标注/预测各个样本，如果某个样本点被预测的越正确，则将其权重降低；否则提高样本的权重。权重越高的样本在下一个迭代训练中所占的比重就越大，也就是说越难区分的样本在训练过程中会变得越重要；整个迭代过程直到错误率足够小或者达到一定的迭代次数为止。

Adaboost算法可以简述为三个步骤：
 （1）首先，是初始化训练数据的权值分布D1。假设有N个训练样本数据，则每一个训练样本最开始时，都被赋予相同的权值：w1=1/N。
 （2）然后，训练弱分类器hi。具体训练过程中是：如果某个训练样本点，被弱分类器hi准确地分类，那么在构造下一个训练集中，它对应的权值要减小；相反，如果某个训练样本点被错误分类，那么它的权值就应该增大。权值更新过的样本集被用于训练下一个分类器，整个训练过程如此迭代地进行下去。
 （3）最后，将各个训练得到的弱分类器组合成一个强分类器。各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，使其在最终的分类函数中起着较大的决定作用，而降低分类误差率大的弱分类器的权重，使其在最终的分类函数中起着较小的决定作用。
  换而言之，误差率低的弱分类器在最终分类器中占的权重较大，否则较小。

二、AdaBoost算法过程

给定训练数据集：，其中用于表示训练样本的类别标签，i=1,...,N。Adaboost的目的就是从训练数据中学习一系列弱分类器或基本分类器，然后将这些弱分类器组合成一个强分类器。

相关符号定义：

Adaboost的算法流程如下：

相关说明：

综合上面的推导，可得样本分错与分对时，其权值更新的公式为：

三、AdaBoost实例讲解

例：给定如图所示的训练样本，弱分类器采用平行于坐标轴的直线，用Adaboost算法的实现强分类过程。

数据分析：

将这10个样本作为训练数据，根据 X 和Y 的对应关系，可把这10个数据分为两类，图中用“+”表示类别1，用“O”表示类别-1。本例使用水平或者垂直的直线作为分类器，图中已经给出了三个弱分类器，即：

初始化：

首先需要初始化训练样本数据的权值分布，每一个训练样本最开始时都被赋予相同的权值：wi=1/N，这样训练样本集的初始权值分布D1(i)：

令每个权值w1i = 1/N = 0.1，其中，N = 10，i = 1,2, ..., 10，然后分别对于t= 1,2,3, ...等值进行迭代（t表示迭代次数，表示第t轮），下表已经给出训练样本的权值分布情况：

第1次迭代t=1：

初试的权值分布D1为1/N（10个数据，每个数据的权值皆初始化为0.1），

D1=[0.1,  0.1, 0.1, 0.1, 0.1, 0.1,0.1, 0.1, 0.1, 0.1]

在权值分布D1的情况下，取已知的三个弱分类器h1、h2和h3中误差率最小的分类器作为第1个基本分类器H1(x)（三个弱分类器的误差率都是0.3，那就取第1个吧）

在分类器H1(x)=h1情况下，样本点“5 7 8”被错分，因此基本分类器H1(x)的误差率为：

可见，被误分类样本的权值之和影响误差率e，误差率e影响基本分类器在最终分类器中所占的权重α。

然后，更新训练样本数据的权值分布，用于下一轮迭代，对于正确分类的训练样本“1 2 3 4 6 9 10”（共7个）的权值更新为：

这样，第1轮迭代后，最后得到各个样本数据新的权值分布：

D2=[1/14,1/14,1/14,1/14,1/6,1/14,1/6,1/6,1/14,1/14]

由于样本数据“5 7 8”被H1(x)分错了，所以它们的权值由之前的0.1增大到1/6；反之，其它数据皆被分正确，所以它们的权值皆由之前的0.1减小到1/14，下表给出了权值分布的变换情况：

可得分类函数：f1(x)= α1H1(x) = 0.4236H1(x)。此时，组合一个基本分类器sign(f1(x))作为强分类器在训练数据集上有3个误分类点（即5 7 8），此时强分类器的训练错误为：0.3

第二次迭代t=2：

在权值分布D2的情况下，再取三个弱分类器h1、h2和h3中误差率最小的分类器作为第2个基本分类器H2(x)：
①　当取弱分类器h1=X1=2.5时，此时被错分的样本点为“5 7 8”：
误差率e=1/6+1/6+1/6=3/6=1/2；
②　当取弱分类器h2=X1=8.5时，此时被错分的样本点为“3 4 6”：
误差率e=1/14+1/14+1/14=3/14；
③　当取弱分类器h3=X2=6.5时，此时被错分的样本点为“1 2 9”：
误差率e=1/14+1/14+1/14=3/14；

因此，取当前最小的分类器h2作为第2个基本分类器H2(x)

显然，H2(x)把样本“3 4 6”分错了，根据D2可知它们的权值为D2(3)=1/14，D2(4)=1/14， D2(6)=1/14，所以H2(x)在训练数据集上的误差率：

这样，第2轮迭代后，最后得到各个样本数据新的权值分布：

D3=[1/22,1/22,1/6,1/6,7/66,1/6,7/66,7/66,1/22,1/22]

下表给出了权值分布的变换情况：

可得分类函数：f2(x)=0.4236H1(x) + 0.6496H2(x)。此时，组合两个基本分类器sign(f2(x))作为强分类器在训练数据集上有3个误分类点（即3 4 6），此时强分类器的训练错误为：0.3

第三次迭代t=3:

在权值分布D3的情况下，再取三个弱分类器h1、h2和h3中误差率最小的分类器作为第3个基本分类器H3(x)：
①　当取弱分类器h1=X1=2.5时，此时被错分的样本点为“5 7 8”：
误差率e=7/66+7/66+7/66=7/22；
②　当取弱分类器h2=X1=8.5时，此时被错分的样本点为“3 4 6”：
误差率e=1/6+1/6+1/6=1/2=0.5；
③　当取弱分类器h3=X2=6.5时，此时被错分的样本点为“1 2 9”：
误差率e=1/22+1/22+1/22=3/22；

因此，取当前最小的分类器h3作为第3个基本分类器H3(x)：

这样，第3轮迭代后，得到各个样本数据新的权值分布为：

D4=[1/6,1/6,11/114,11/114,7/114,11/114,7/114,7/114,1/6,1/38]

下表给出了权值分布的变换情况：

可得分类函数：f3(x)=0.4236H1(x) + 0.6496H2(x)+0.9229H3(x)。此时，组合三个基本分类器sign(f3(x))作为强分类器，在训练数据集上有0个误分类点。至此，整个训练过程结束。

整合所有分类器，可得最终的强分类器为：

这个强分类器Hfinal对训练样本的错误率为0！

本例Matlab代码，如下：

先建立Matlab函数文件，定义h1,h2和h3三个弱分类器

1. function kind = wcH1( X,TH )
2. %h1弱分类器
3. X1=X(1);
4. X2=X(2);
5. if X1<TH
6. kind=1;
7. else
8. kind=-1;
9. end
10. end

1. function kind = wcH2( X,TH )
2. %h2弱分类器
3. X1=X(1);
4. X2=X(2);
5. if X1<TH
6. kind=1;
7. else
8. kind=-1;
9. end
10. end

1. function kind = wcH3( X,TH )
2. %h3弱分类器
3. X1=X(1);
4. X2=X(2);
5. if X2<TH
6. kind=-1;
7. else
8. kind=1;
9. end
10. end

主程序Matlab代码：

1. clc,clear all;
2. %% 训练样本数据
3. xData=[1 5;2 2;3 1;4 6;6 8;6 5;7 9;8 7;9 8;10 2] %样本数据点，对应编号为1,2,...10
4. Y=[1 1 -1 -1 1 -1 1 1 -1 -1]'; %对应的样本类别，用1和-1表示
5. xNum=1:10; %编号
6. format rat
7. %% 绘制样本分布图
8. L1=find(Y==1);
9. x=xData(L1,1);y=xData(L1,2);
10. plot(x,y,'b+','LineWidth',3,'MarkerSize',12);
11. hold on;
12. L2=find(Y==-1);
13. x=xData(L2,1);y=xData(L2,2);
14. plot(x,y,'ro','LineWidth',3,'MarkerSize',12);
15. xlabel('X1');ylabel('X2');axis([0 10 0 10])
16. %% ***********************************初试过程************************************
17. H1=zeros(10,1);H2=H1;H3=H1
18. for i=1:10
19. X=xData(i,:);
20. H1(i) = wcH1( X,2.5 );%弱分类器h1
21. H2(i) = wcH2( X,8.5 );%弱分类器h2
22. H3(i) = wcH3( X,6.5 );%弱分类器h3
23. end
24. errDataH1=find(H1~=Y);%找到被h1错分的样本点的序号
25. errDataH2=find(H2~=Y);%找到被h2错分的样本点的序号
26. errDataH3=find(H3~=Y);%找到被h3错分的样本点的序号
27. accDataH1=find(H1==Y);%找到被h1正确分的样本点的序号
28. accDataH2=find(H2==Y);%找到被h2正确分的样本点的序号
29. accDataH3=find(H3==Y);%找到被h3正确分的样本点的序号
30. errDataAll=[errDataH1,errDataH2,errDataH3];
31. accDataAll=[accDataH1,accDataH2,accDataH3];
33. N=10;
34. D1=zeros(10,1)+1/N % 初始化权值分布
35. %% ***********************************第一次迭代***********************************
36. err1=sum(D1(errDataH1,:));%所有被错分类的样本点的权值之和即为误差率
37. err2=sum(D1(errDataH2,:));%所有被错分类的样本点的权值之和即为误差率
38. err3=sum(D1(errDataH3,:));%所有被错分类的样本点的权值之和即为误差率
39. errAll=[err1,err2,err3];
40. [minErr,minIndex]=min(errAll);
41. %根据误差率e1计算H1的系数：
42. a1=0.5*log((1-minErr)/minErr)
43. minErrData=errDataAll(:,minIndex);
44. minAccData=accDataAll(:,minIndex);
45. D2=D1;
46. for i=minAccData'
47. D2(i)=D2(i)/(2*(1-minErr));
48. end
49. for i=minErrData'
50. D2(i)=D2(i)/(2*minErr);
51. end
52. D2
53. %分类函数
54. f1=a1.*H1;
55. kindFinal=sign(f1)%此时强分类器的分类结果
57. %% ***********************************第二次迭代***********************************
58. err1=sum(D2(errDataH1,:));%所有被错分类的样本点的权值之和即为误差率
59. err2=sum(D2(errDataH2,:));%所有被错分类的样本点的权值之和即为误差率
60. err3=sum(D2(errDataH3,:));%所有被错分类的样本点的权值之和即为误差率
61. errAll=[err1,err2,err3];
62. [minErr,minIndex]=min(errAll);
63. % 根据误差率e2计算H2的系数：
64. a2=0.5*log((1-minErr)/minErr)
65. minErrData=errDataAll(:,minIndex);
66. minAccData=accDataAll(:,minIndex);
67. D3=D2;
68. for i=minAccData'
69. D3(i)=D3(i)/(2*(1-minErr));
70. end
71. for i=minErrData'
72. D3(i)=D3(i)/(2*minErr);
73. end
74. D3
75. % 分类函数
76. f2=a1.*H1+a2*H2;
77. kindFinal=sign(f2)%此时强分类器的分类结果
79. %% ***********************************第三次迭代***********************************
80. err1=sum(D3(errDataH1,:));%所有被错分类的样本点的权值之和即为误差率
81. err2=sum(D3(errDataH2,:));%所有被错分类的样本点的权值之和即为误差率
82. err3=sum(D3(errDataH3,:));%所有被错分类的样本点的权值之和即为误差率
83. errAll=[err1,err2,err3];
84. [minErr,minIndex]=min(errAll);
85. % 根据误差率e3计算G3的系数：
86. a3=0.5*log((1-minErr)/minErr)
87. minErrData=errDataAll(:,minIndex);
88. minAccData=accDataAll(:,minIndex);
89. D4=D3;
90. for i=minAccData'
91. D4(i)=D4(i)/(2*(1-minErr));
92. end
93. for i=minErrData'
94. D4(i)=D4(i)/(2*minErr);
95. end
96. D4
97. % 分类函数
98. f3=a1.*H1+a2*H2+a3*H3;
99. kindFinal=sign(f3)%此时强分类器的分类结果
100. %%

Adaboost算法的某些特性是非常好的，这里主要介绍Adaboost的两个特性。（1）是训练的错误率上界，随着迭代次数的增加，会逐渐下降；（2）是Adaboost算法即使训练次数很多，也不会出现过拟合的问题。关于这两方面的研究和分析，我建议各大网友，还是看看大神的博客：http://blog.****.net/v_july_v/article/details/40718799

四、AdaBoost的优点和缺点

优点

（1）Adaboost提供一种框架，在框架内可以使用各种方法构建子分类器。可以使用简单的弱分类器，不用对特征进行筛选，也不存在过拟合的现象。

（2）Adaboost算法不需要弱分类器的先验知识，最后得到的强分类器的分类精度依赖于所有弱分类器。无论是应用于人造数据还是真实数据，Adaboost都能显著的提高学习精度。

（3）Adaboost算法不需要预先知道弱分类器的错误率上限，且最后得到的强分类器的分类精度依赖于所有弱分类器的分类精度，可以深挖分类器的能力。Adaboost可以根据弱分类器的反馈，自适应地调整假定的错误率，执行的效率高。

（4）Adaboost对同一个训练样本集训练不同的弱分类器，按照一定的方法把这些弱分类器集合起来，构造一个分类能力很强的强分类器，即“三个臭皮匠赛过一个诸葛亮”。

缺点：

在Adaboost训练过程中，Adaboost会使得难于分类样本的权值呈指数增长，训练将会过于偏向这类困难的样本，导致Adaboost算法易受噪声干扰。此外，Adaboost依赖于弱分类器，而弱分类器的训练时间往往很长。

GBDT实例

GBDT是迭代多棵回归树来共同决策。当采用平方误差损失函数时，每一棵回归树学习的是之前所有树的结论和残差，拟合得到一个当前的残差回归树，残差的意义如公式：残差 = 真实值 - 预测值 。参考一篇博客的例子，训练一个GBDT模型来预测年龄：训练集是4个人，A，B，C，D年龄分别是14，16，24，26。样本中有购物金额、上网时长、经常到百度知道提问等特征。提升树的过程如下：

预测值等于所有树值得累加：

• A: 14岁高一学生，购物较少，经常问学长问题；预测年龄A = 15 – 1 = 14
• B: 16岁高三学生；购物较少，经常被学弟问问题；预测年龄B = 15 + 1 = 16
• C: 24岁应届毕业生；购物较多，经常问师兄问题；预测年龄C = 25 – 1 = 24
• D: 26岁工作两年员工；购物较多，经常被师弟问问题；预测年龄D = 25 + 1 = 26

2.2 GBDT算法

GBDT是集成学习Boosting家族的成员，但是却和传统的Adaboost有很大的不同。Adaboost是利用前一轮迭代弱学习器的误差率来更新训练集的权重，这样一轮轮的迭代下去。GBDT也是迭代，使用了前向分布算法，但是弱学习器限定了只能使用CART回归树模型，同时迭代思路和Adaboost也有所不同。在GBDT的迭代中，假设我们前一轮迭代得到的强学习器是ft−1(x)ft−1(x)， 损失函数是L(y,ft−1(x))L(y,ft−1(x)) ,，我们本轮迭代的目标是找到一个CART回归树模型的弱学习器ht(x)ht(x)，让本轮的损失损失L(y,ft(x))=L(y,ft−1(x))+ht(x)L(y,ft(x))=L(y,ft−1(x))+ht(x)最小。也就是说，本轮迭代找到决策树，要让样本的损失尽量变得更小。

GBDT利用加法模型和前向分步算法实现学习的优化过程。当损失函数是平方损失和指数损失函数时，每一步的优化很简单。但对于一般的损失函数，往往每一步优化没那么容易，如下图中的绝对值损失函数和Huber损失函数。针对这一问题，Freidman提出了用损失函数的负梯度来拟合本轮损失的近似值，进而拟合一个CART回归树。

第m轮的第i个样本的损失函数的负梯度可表示为：

• rim=−[∂L(yi,f(xi))∂f(xi)]f(xi)=fm−1(xi)rim=−[∂L(yi,f(xi))∂f(xi)]f(xi)=fm−1(xi)

算法流程如下：

1. 初始化：估计使损失函数极小化的常数值γγ，它是只有一个根节点的树。
2. M轮迭代（生成M棵树） 
   • 在第m轮，对于每一个样本ii，计算损失函数的负梯度在当前模型的值rimrim，将它作为残差的估计
   • 利用样本集（x，rim）（x，rim）生成一棵回归树，以拟合残差的近似值。其中RjmRjm为第m棵树的第j个叶子节点，JmJm为回归树的叶子节点的个数
   • 利用线性搜索估计叶节点区域的值，使损失函数极小化
   • 更新模型
3. 得到输出的最终GBDT模型 f(x)f(x)

GBDT算法的scikit-learn实现以及调参可参考：scikit-learn GBDT类库概述

2.3 GBDT分类算法

GBDT的分类算法从思想上和GBDT的回归算法没有区别，但是由于样本输出不是连续的值，而是离散的类别，导致我们无法直接从输出类别去拟合类别输出的误差。为了解决这个问题，主要有两个方法，一个是用指数损失函数，此时GBDT退化为Adaboost算法。另一种方法是用类似于逻辑回归的对数似然损失函数的方法。也就是说，我们用的是类别的预测概率值和真实概率值的差来拟合损失。于对数似然损失函数，我们又有二元分类和多元分类的区别，具体介绍见：梯度提升树(GBDT)原理小结。

2.4 GBDT的正则化

和Adaboost一样，我们也需要对GBDT进行正则化，防止过拟合。GBDT的正则化主要有三种方式：

第一种是和Adaboost类似的正则化项，即步长(learning rate)。定义为νν，对于前面的弱学习器的迭代

• fk(x)=fk−1(x)+hk(x)fk(x)=fk−1(x)+hk(x)

如果我们加上了正则化项，则有:

• fk(x)=fk−1(x)+νhk(x)fk(x)=fk−1(x)+νhk(x)

νν 的取值范围为0<ν≤10<ν≤1 。对于同样的训练集学习效果，较小的νν意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。

第二种正则化的方式是通过子采样比例（subsample）。取值为(0,1]。注意这里的子采样和随机森林不一样，随机森林使用的是放回抽样，而这里是不放回抽样。如果取值为1，则全部样本都使用，等于没有使用子采样。如果取值小于1，则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差，即防止过拟合，但是会增加样本拟合的偏差，因此取值不能太低。推荐在[0.5, 0.8]之间。由于使用了子采样，程序可以通过采样分发到不同的任务去做boosting的迭代过程，最后形成新树，从而减少弱学习器难以并行迭代的弱点。

第三种是对于弱学习器即CART回归树进行正则化剪枝。

8 参考内容

　　[1] Random Forest's homepage (by Leo Breiman and Adele Cutler)

　　[2] Introduction to Random forest - Simplified

　　[3] Comparing a Random Forest to a CART model (Part 2)

　　[4] Introduction to Random forest (博主：爱67)

　　[5] Python实现随机森林

　　[6] 随机森林之oob error估计

　　[7] 随机森林

　　[8] Wikipedia-Random Forest

　　[9] Ensemble methods