随机森林

Random Forest(s)，随机森林，又叫Random Trees[2][3]，是一种由多棵决策树组合而成的联合预测模型，天然可以作为快速且有效的多类分类模型。如下图所示，RF中的每一棵决策树由众多split和node组成：split通过输入的test取值指引输出的走向（左或右）；node为叶节点，决定单棵决策树的最终输出，在分类问题中为类属的概率分布或最大概率类属，在回归问题中为函数取值。整个RT的输出由众多决策树共同决定，argmax或者avg。

Node Test
node test通常很简单，但很多简单的拧在一起就变得无比强大，联合预测模型就是这样的东西。node test是因应用而异的。比如[1]的应用是基于深度图的人体部位识别，使用的node test是基于像素x的深度比较测试：


简单的说，就是比较像素x在u和v位移上的像素点的深度差是否大于某一阈值。u和v位移除以x深度值是为了让深度差与x本身的深度无关，与人体离相机的距离无关。这种node test乍一看是没有意义的，事实上也是没多少意义的，单个test的分类结果可能也只是比随机分类好那么一丁点。但就像Haar特征这种极弱的特征一样，起作用的关键在于后续的Boosting或Bagging——有效的联合可以联合的力量。

Training
RF属于Bagging类模型，因此大体训练过程和Bagging类似，关键在于样本的随机选取避免模型的overfitting问题。RF中的每棵决策树是分开训练的，彼此之间并无关联。对于每棵决策树，训练之前形成一个样本子集，在这个子集中有些样本可能出现多次，而另一些可能一次都没出现。接下去，就是循序决策树训练算法的，针对这个样本子集的单棵决策树训练。
单棵决策树的生成大致遵循以下过程：
1）随机生成样本子集；
2）分裂当前节点为左右节点，比较所有可选分裂，选取最优者；
3）重复2）直至达到最大节点深度，或当前节点分类精度达到要求。
这一过程是贪婪的。
当然对于不同的应用场合，训练过程中，会有细节上的差别，比如样本子集的生成过程、以及最优分割的定义。
在[1]中，决策树的真实样本其实是图片中的像素x，变量值则是上文提到的node test。但是，对于一张固定大小的图片而言可取的像素x是可数大量的，可取的位移(u，v)和深度差阈值几乎是不可数无限的。因此，[1]在训练单棵决策树前，要做的样本子集随机其实涉及到像素x集合的随机生成、位移(u，v)和深度差阈值组合的随机生成，最后还有训练深度图集合本身的随机生成。
最优分裂通常定义为使信息增量最大的分类，如[1]中的定义：

H指熵，通过分裂子集的部位标签分布计算。

---

Reference：
[1] J. Shotton, A. Fitzgibbon, M. Cook, T. Sharp, M. Finocchio, R. Moore, A. Kipman, and A. Blake. Real-Time Human Pose Recognition in Parts from a Single Depth Image. In CVPR 2011.
[2] L. Breiman. Random forests. Mach. Learning, 45(1):5–32, 2001.
[3] T. Hastie, R. Tibshirani, J. H. Friedman. The Elements of Statistical Learning. ISBN-13 978-0387952840, 2003, Springer.

[4] V. Lepetit, P. Lagger, and P. Fua. Randomized trees for real-time keypoint recognition. In Proc. CVPR, pages 2:775–781, 2005.

——————————————————————————————————————————————————————————————————

Random Forests (随机森林）

随机森林的思想很简单，百度百科上介绍的随机森林算法比较好理解。

在机器学习中，随机森林是一个包含多个决策树的分类器， 并且其输出的类别是由个别树输出的类别的众数而定。 Leo Breiman和Adele Cutler发展出推论出随机森林的算法。 而 "Random Forests" 是他们的商标。 这个术语是1995年由贝尔实验室的Tin Kam Ho所提出的随机决策森林（random decision forests）而来的。这个方法则是结合 Breimans 的 "Bootstrap aggregating" 想法和 Ho 的"random subspace method"" 以建造决策树的集合。

学习算法

 根据下列算法而建造每棵树：

      1. 用 N 来表示训练例子的个数，M表示变量的数目。

      2. 我们会被告知一个数 m ，被用来决定当在一个节点上做决定时，会使用到多少个变量。m应小于M

      3. 从N个训练案例中以可重复取样的方式，取样N次，形成一组训练集（即bootstrap取样。）。并使用这棵树来对剩余预测其类别，并评估其误差。

      4. 对于每一个节点，随机选择m个基于此点上的变量。根据这 m 个变量，计算其最佳的分割方式。

      5. 每棵树都会完整成长而不会剪枝（Pruning）（这有可能在建完一棵正常树状分类器后会被采用）。

 

　　优点

 随机森林的优点有：

      1. 对于很多种资料，它可以产生高准确度的分类器。

      2. 它可以处理大量的输入变量。

      3. 它可以在决定类别时，评估变量的重要性。

      4. 在建造森林时，它可以在内部对于一般化后的误差产生不偏差的估计。

      5. 它包含一个好方法可以估计遗失的资料，并且，如果有很大一部分的资料遗失，仍可以维持准确度。

      6. 它提供一个实验方法，可以去侦测 variable interactions 。

      7. 对于不平衡的分类资料集来说，它可以平衡误差。

      8. 它计算各例中的亲近度，对于数据挖掘、侦测偏离者（outlier）和将资料视觉化非常有用。

      9. 使用上述。它可被延伸应用在未标记的资料上，这类资料通常是使用非监督式聚类。也可侦测偏离者和观看资料。

      10. 学习过程是很快速的。

 

　　缺点

      1. 随机森林已经被证明在某些噪音较大的分类或回归问题上会过拟

      2. 对于有不同级别的属性的数据，级别划分较多的属性会对随机森林产生更大的影响，所以随机森林在这种数据上产出的属性权值是不可信的。

 

论文和源代码见：http://www.stat.berkeley.edu/users/breiman/RandomForests/

 

mahout实现random forests：https://cwiki.apache.org/MAHOUT/random-forests.html 

 

 

 

online Random Forests  （在线随机森林）

 

这是一片09年，ICCV 上的文章，效果和离线的random forest差不多，特别的牛。可以做分类，叶可以做预测，

程序可下载：http://www.everbox.com/f/7igWhZFJBp7xxqmbaM6UyewatN

 

这里介绍的主要是在线随机决策树，其思想主要是：每棵树可以在线分裂。每个叶子分裂的条件是预测的数量要达到一定的值和每个叶子节点信息。

每个树的生长主要通过预测的样本（在线接受的样本），每棵树的叶子节点分裂主要根据该节点的熵或Gini

                                          or     

学过决策树和信息论的，对这个概念都有了解。其中j表示第j棵树，i表示第i个分类结果。K表示总的分类数。

对有一个给定的结合S（在线预测中给定），每棵树上叶子节点P_j的的概率可以表示为：

如果要在P_j叶子节点分类，那么，得到二个叶子节点的概率可以用下式表示：

                                                                                and             

解释一下 P_jls，l为left，s为测试集合。所以P_jls表示为在集合S中P_j叶子节点的分列的左节点。同理，P_jrs表示为在集合S中P_j叶子节点的分列的右节点。

那么，每棵树上叶子节点P_j分裂必须符合以下二个条件：

        1. 落在叶子节点P_j的个数必须大于一个常数（可以人工设定）

        2. 叶子节点的Gini必须大于一个常数（可以人工设定），Gini计算公式如下：

以上步骤就完成整个树的更新。

 

下面给出了在线随机森林算法的流程：

步骤3. 用个possion分布确定从采样的次数，其原理见online boosting： http://www.cnblogs.com/liqizhou/archive/2012/05/10/2494145.html

步骤6. u代表分类的类别。

步骤7. j代表第t棵树上叶子节点。

步骤8. 统计第j个叶子节点的数目和计算Gini

步骤9. 判断条件是否分裂的二个条件。

步骤10. 在符合条件的叶子节点中，选择一个Gini最大的叶子节点作为分类节点。

以上就是online Random forests 的主要思想。

这个程序特别牛，我跑了一下，挺牛逼的，效果没比offline mode差不多。如果你需要做online learning的话十分推荐。

——————————————————————————————————————————————————————————————————

随机森林分类器是专门针对决策树进行组合的一种组合分类器。

•随机选取训练样本集：使用Bagging方法形成每颗树的训练集

•随机选取分裂属性集：假设共有M个属性，指定一个属性数F≤M，在每个内部结点，从M个属性中随机抽取F个属性作分裂属性集，以这F个属性上最好的分裂方式对结点进行分裂（在整个森林的生长过程中， F的值一般维持不变）

•每颗树任其生长，不进行剪枝

——————————————————————————————————————————————————————————————————————————————

随机森林是一种比较新的机器学习模型。经典的机器学习模型是神经网络，有半个多世纪的历史了。神经网络预测精确，但是计算量很大。上世纪八十年代Breiman等人发明分类树的算法(Breiman et al. 1984)，通过反复二分数据进行分类或回归，计算量大大降低。2001年Breiman把分类树组合成随机森林(Breiman 2001a)，即在变量（列）的使用和数据（行）的使用上进行随机化，生成很多分类树，再汇总分类树的结果。随机森林在运算量没有显著提高的前提下提高了预测精度。随机森林对多元公线性不敏感，结果对缺失数据和非平衡的数据比较稳健，可以很好地预测多达几千个解释变量的作用(Breiman 2001b)，被誉为当前最好的算法之一(Iverson et al. 2008)。

 

今年5月在人大组织的R语言会议上，我用朱鹮的例子介绍了随机森林的原理和应用。有些同学要求拷贝演讲材料。这个材料在统计之都（http://cos.name）上有。为了更方便地下载，我把它放在这里 Random Forest.pdf。

 

这个pdf共25页，首先是原理，然后列举R的两个运行随机森林包，后面有数据格式、代码和结果。随机森林完成两个任务：回归（y为连续变量时）和判别（y为分类变量时）。这两个的任务的代码略有不同。这个材料对于要编代码运行随机森林模型的人有用。没有任何理论基础的人（但是需要有R的知识），看过这个pdf后，可以应用上面的代码运行随机森林，解释因变量的贡献，进行预测。本人强烈建议使用者首先阅读Breiman在2001年发表的两篇文章（见参考文献），然后再应用这个模型。随机森林对数据前提条件的要求（正态性、独立性等）比广义线性模型等要宽松得多，应用前景非常广阔。

————————————————————————————————————————————————————————————————————————————

1.随机森林原理介绍

随机森林，指的是利用多棵树对样本进行训练并预测的一种分类器。该分类器最早由Leo Breiman和Adele Cutler提出，并被注册成了商标。简单来说，随机森林就是由多棵CART（Classification And Regression Tree）构成的。对于每棵树，它们使用的训练集是从总的训练集中有放回采样出来的，这意味着，总的训练集中的有些样本可能多次出现在一棵树的训练集中，也可能从未出现在一棵树的训练集中。在训练每棵树的节点时，使用的特征是从所有特征中按照一定比例随机地无放回的抽取的，根据Leo Breiman的建议，假设总的特征数量为M，这个比例可以是sqrt(M),1/2sqrt(M),2sqrt(M)。

因此，随机森林的训练过程可以总结如下：

(1)给定训练集S，测试集T，特征维数F。确定参数：使用到的CART的数量t，每棵树的深度d，每个节点使用到的特征数量f，终止条件：节点上最少样本数s，节点上最少的信息增益m

对于第1-t棵树，i=1-t：

(2)从S中有放回的抽取大小和S一样的训练集S(i)，作为根节点的样本，从根节点开始训练

(3)如果当前节点上达到终止条件，则设置当前节点为叶子节点，如果是分类问题，该叶子节点的预测输出为当前节点样本集合中数量最多的那一类c(j)，概率p为c(j)占当前样本集的比例；如果是回归问题，预测输出为当前节点样本集各个样本值的平均值。然后继续训练其他节点。如果当前节点没有达到终止条件，则从F维特征中无放回的随机选取f维特征。利用这f维特征，寻找分类效果最好的一维特征k及其阈值th，当前节点上样本第k维特征小于th的样本被划分到左节点，其余的被划分到右节点。继续训练其他节点。有关分类效果的评判标准在后面会讲。

(4)重复(2)(3)直到所有节点都训练过了或者被标记为叶子节点。

(5)重复(2),(3),(4)直到所有CART都被训练过。

利用随机森林的预测过程如下：

对于第1-t棵树，i=1-t：

(1)从当前树的根节点开始，根据当前节点的阈值th，判断是进入左节点(<th)还是进入右节点(>=th)，直到到达，某个叶子节点，并输出预测值。

(2)重复执行(1)直到所有t棵树都输出了预测值。如果是分类问题，则输出为所有树中预测概率总和最大的那一个类，即对每个c(j)的p进行累计；如果是回归问题，则输出为所有树的输出的平均值。

注：有关分类效果的评判标准，因为使用的是CART，因此使用的也是CART的平板标准，和C3.0,C4.5都不相同。

对于分类问题（将某个样本划分到某一类），也就是离散变量问题，CART使用Gini值作为评判标准。定义为Gini=1-∑(P(i)*P(i)),P(i)为当前节点上数据集中第i类样本的比例。例如：分为2类，当前节点上有100个样本，属于第一类的样本有70个，属于第二类的样本有30个，则Gini=1-0.7×07-0.3×03=0.42，可以看出，类别分布越平均，Gini值越大，类分布越不均匀，Gini值越小。在寻找最佳的分类特征和阈值时，评判标准为：argmax（Gini-GiniLeft-GiniRight），即寻找最佳的特征f和阈值th，使得当前节点的Gini值减去左子节点的Gini和右子节点的Gini值最大。

对于回归问题，相对更加简单，直接使用argmax(Var-VarLeft-VarRight)作为评判标准，即当前节点训练集的方差Var减去减去左子节点的方差VarLeft和右子节点的方差VarRight值最大。

 

2.OpenCV函数使用

OpenCV提供了随机森林的相关类和函数。具体使用方法如下：

(1)首先利用CvRTParams定义自己的参数，其格式如下

 

 CvRTParams::CvRTParams(int max_depth, int min_sample_count, float regression_accuracy, bool use_surrogates, int max_categories, const float* priors, bool calc_var_importance, int nactive_vars, int max_num_of_trees_in_the_forest, float forest_accuracy, int termcrit_type)

 

大部分参数描述都在http://docs.opencv.org/modules/ml/doc/random_trees.html上面有，说一下没有描述的几个参数的意义

bool use_surrogates：是否使用代理，指的是，如果当前的测试样本缺少某些特征，但是在当前节点上的分类or回归特征正是缺少的这个特征，那么这个样本就没法继续沿着树向下走了，达不到叶子节点的话，就没有预测输出，这种情况下，可以利用当前节点下面的所有子节点中的叶子节点预测输出的平均值，作为这个样本的预测输出。

const float*priors：先验知识，这个指的是，可以根据各个类别样本数量的先验分布，对其进行加权。比如：如果一共有3类，第一类样本占整个训练集的80%，其余两类各占10%，那么这个数据集里面的数据就很不平均，如果每类的样本都加权的话，就算把所有样本都预测成第一类，那么准确率也有80%，这显然是不合理的，因此我们需要提高后两类的权重，使得后两类的分类正确率也不会太低。

float regression_accuracy：回归树的终止条件，如果当前节点上所有样本的真实值和预测值之间的差小于这个数值时，停止生产这个节点，并将其作为叶子节点。

后来发现这些参数在决策树里面有解释，英文说明在这里http://docs.opencv.org/modules/ml/doc/decision_trees.html#cvdtreeparams

具体例子如下，网上找了个别人的例子，自己改成了可以读取MNIST数据并且做分类的形式，如下：

 

#include <cv.h>       // opencv general include file#include <ml.h>          // opencv machine learning include file#include <stdio.h>using namespace cv; // OpenCV API is in the C++ "cv" namespace/******************************************************************************/// global definitions (for speed and ease of use)//手写体数字识别#define NUMBER_OF_TRAINING_SAMPLES 60000#define ATTRIBUTES_PER_SAMPLE 784#define NUMBER_OF_TESTING_SAMPLES 10000#define NUMBER_OF_CLASSES 10// N.B. classes are integer handwritten digits in range 0-9/******************************************************************************/// loads the sample database from file (which is a CSV text file)inline void revertInt(int&x){    x=((x&0x000000ff)<<24)|((x&0x0000ff00)<<8)|((x&0x00ff0000)>>8)|((x&0xff000000)>>24);};int read_data_from_csv(const char* samplePath,const char* labelPath, Mat data, Mat classes,                       int n_samples ){    FILE* sampleFile=fopen(samplePath,"rb");    FILE* labelFile=fopen(labelPath,"rb");    int mbs=0,number=0,col=0,row=0;    fread(&mbs,4,1,sampleFile);    fread(&number,4,1,sampleFile);    fread(&row,4,1,sampleFile);    fread(&col,4,1,sampleFile);    revertInt(mbs);    revertInt(number);    revertInt(row);    revertInt(col);    fread(&mbs,4,1,labelFile);    fread(&number,4,1,labelFile);    revertInt(mbs);    revertInt(number);    unsigned char temp;    for(int line = 0; line < n_samples; line++)    {        // for each attribute on the line in the file        for(int attribute = 0; attribute < (ATTRIBUTES_PER_SAMPLE + 1); attribute++)        {            if (attribute < ATTRIBUTES_PER_SAMPLE)            {                // first 64 elements (0-63) in each line are the attributes                fread(&temp,1,1,sampleFile);                //fscanf(f, "%f,", &tmp);                data.at<float>(line, attribute) = static_cast<float>(temp);                // printf("%f,", data.at<float>(line, attribute));            }            else if (attribute == ATTRIBUTES_PER_SAMPLE)            {                // attribute 65 is the class label {0 ... 9}                fread(&temp,1,1,labelFile);                //fscanf(f, "%f,", &tmp);                classes.at<float>(line, 0) = static_cast<float>(temp);                // printf("%f\n", classes.at<float>(line, 0));            }        }    }    fclose(sampleFile);    fclose(labelFile);    return 1; // all OK}/******************************************************************************/int main( int argc, char** argv ){        for (int i=0; i< argc; i++)        std::cout<<argv[i]<<std::endl;        // lets just check the version first    printf ("OpenCV version %s (%d.%d.%d)\n",            CV_VERSION,            CV_MAJOR_VERSION, CV_MINOR_VERSION, CV_SUBMINOR_VERSION);        //定义训练数据与标签矩阵    Mat training_data = Mat(NUMBER_OF_TRAINING_SAMPLES, ATTRIBUTES_PER_SAMPLE, CV_32FC1);    Mat training_classifications = Mat(NUMBER_OF_TRAINING_SAMPLES, 1, CV_32FC1);    //定义测试数据矩阵与标签    Mat testing_data = Mat(NUMBER_OF_TESTING_SAMPLES, ATTRIBUTES_PER_SAMPLE, CV_32FC1);    Mat testing_classifications = Mat(NUMBER_OF_TESTING_SAMPLES, 1, CV_32FC1);    // define all the attributes as numerical    // alternatives are CV_VAR_CATEGORICAL or CV_VAR_ORDERED(=CV_VAR_NUMERICAL)    // that can be assigned on a per attribute basis    Mat var_type = Mat(ATTRIBUTES_PER_SAMPLE + 1, 1, CV_8U );    var_type.setTo(Scalar(CV_VAR_NUMERICAL) ); // all inputs are numerical    // this is a classification problem (i.e. predict a discrete number of class    // outputs) so reset the last (+1) output var_type element to CV_VAR_CATEGORICAL    var_type.at<uchar>(ATTRIBUTES_PER_SAMPLE, 0) = CV_VAR_CATEGORICAL;    double result; // value returned from a prediction    //加载训练数据集和测试数据集    if (read_data_from_csv(argv[1],argv[2], training_data, training_classifications, NUMBER_OF_TRAINING_SAMPLES) &&            read_data_from_csv(argv[3],argv[4], testing_data, testing_classifications, NUMBER_OF_TESTING_SAMPLES))    {      /********************************步骤1：定义初始化Random Trees的参数******************************/        float priors[] = {1,1,1,1,1,1,1,1,1,1};  // weights of each classification for classes        CvRTParams params = CvRTParams(20, // max depth                                       50, // min sample count                                       0, // regression accuracy: N/A here                                       false, // compute surrogate split, no missing data                                       15, // max number of categories (use sub-optimal algorithm for larger numbers)                                       priors, // the array of priors                                       false,  // calculate variable importance                                       50,       // number of variables randomly selected at node and used to find the best split(s).                                       100,     // max number of trees in the forest                                       0.01f,                // forest accuracy                                       CV_TERMCRIT_ITER |    CV_TERMCRIT_EPS // termination cirteria                                      );        /****************************步骤2：训练 Random Decision Forest(RDF)分类器*********************/        printf( "\nUsing training database: %s\n\n", argv[1]);        CvRTrees* rtree = new CvRTrees;        bool train_result=rtree->train(training_data, CV_ROW_SAMPLE, training_classifications,                     Mat(), Mat(), var_type, Mat(), params);//        float train_error=rtree->get_train_error();//        printf("train error:%f\n",train_error);        // perform classifier testing and report results        Mat test_sample;        int correct_class = 0;        int wrong_class = 0;        int false_positives [NUMBER_OF_CLASSES] = {0,0,0,0,0,0,0,0,0,0};        printf( "\nUsing testing database: %s\n\n", argv[2]);        for (int tsample = 0; tsample < NUMBER_OF_TESTING_SAMPLES; tsample++)        {            // extract a row from the testing matrix            test_sample = testing_data.row(tsample);        /********************************步骤3：预测*********************************************/            result = rtree->predict(test_sample, Mat());            printf("Testing Sample %i -> class result (digit %d)\n", tsample, (int) result);            // if the prediction and the (true) testing classification are the same            // (N.B. openCV uses a floating point decision tree implementation!)            if (fabs(result - testing_classifications.at<float>(tsample, 0))                    >= FLT_EPSILON)            {                // if they differ more than floating point error => wrong class                wrong_class++;                false_positives[(int) result]++;            }            else            {                // otherwise correct                correct_class++;            }        }        printf( "\nResults on the testing database: %s\n"                "\tCorrect classification: %d (%g%%)\n"                "\tWrong classifications: %d (%g%%)\n",                argv[2],                correct_class, (double) correct_class*100/NUMBER_OF_TESTING_SAMPLES,                wrong_class, (double) wrong_class*100/NUMBER_OF_TESTING_SAMPLES);        for (int i = 0; i < NUMBER_OF_CLASSES; i++)        {            printf( "\tClass (digit %d) false postives     %d (%g%%)\n", i,                    false_positives[i],                    (double) false_positives[i]*100/NUMBER_OF_TESTING_SAMPLES);        }        // all matrix memory free by destructors        // all OK : main returns 0        return 0;    }    // not OK : main returns -1    return -1;}

 

MNIST样本可以在这个网址http://yann.lecun.com/exdb/mnist/下载，改一下路径可以直接跑的。

3.如何自己设计随机森林程序

有时现有的库无法满足要求，就需要自己设计一个分类器算法，这部分讲一下如何设计自己的随机森林分类器，代码实现就不贴了，因为在工作中用到了，因此比较敏感。

首先，要有一个RandomForest类，里面保存整个树需要的一些参数，包括但不限于：训练样本数量、测试样本数量、特征维数、每个节点随机提取的特征维数、CART树的数量、树的最大深度、类别数量（如果是分类问题）、一些终止条件、指向所有树的指针，指向训练集和测试集的指针，指向训练集label的指针等。还要有一些函数，至少要有train和predict吧。train里面直接调用每棵树的train方法即可，predict同理，但要对每棵树的预测输出做处理，得到森林的预测输出。

 

其次，要有一个sample类，这个类可不是用来存储训练集和对应label的，这是因为，每棵树、每个节点都有自己的样本集和，如果你的存储每个样本集和的话，需要的内存实在是太过巨大了，假设样本数量为M，特征维数为N，则整个训练集大小为M×N，而每棵树的每层都有这么多样本，树的深度为D，共有S棵树的话，则需要存储M×N×D×S的存储空间。这实在是太大了。因此，每个节点训练时用到的训练样本和特征，我们都用序号数组来代替，sample类就是干这个的。sample的函数基本需要两个就行，第一个是从现有训练集有放回的随机抽取一个新的训练集，当然，只包含样本的序号。第二个函数是从现有的特征中无放回的随机抽取一定数量的特征，同理，也是特征序号即可。

然后，需要一个Tree类，代表每棵树，里面保存树的一些参数以及一个指向所有节点的指针。

最后，需要一个Node类，代表树的每个节点。

 

需要说明的是，保存树的方式可以是最普通的数组，也可是是vector。Node的保存方式同理，但是个人不建议用链表的方式，在程序设计以及函数处理上太麻烦，但是在省空间上并没有太多的体现。

————————————————————————————————————————————————————————————————————————————

决策树模型组合之（在线）随机森林与GBDT

前言：

决策树这种算法有着很多良好的特性，比如说训练时间复杂度较低，预测的过程比较快速，模型容易展示（容易将得到的决策树做成图片展示出来）等。但是同时， 单决策树又有一些不好的地方，比如说容易over-fitting，虽然有一些方法，如剪枝可以减少这种情况，但是还是不够的。

模型组合（比如说有Boosting，Bagging等）与决策树相关的算法比较多，这些算法最终的结果是生成N(可能会有几百棵以上）棵树，这样可以大 大的减少单决策树带来的毛病，有点类似于三个臭皮匠等于一个诸葛亮的做法，虽然这几百棵决策树中的每一棵都很简单（相对于C4.5这种单决策树来说），但 是他们组合起来确是很强大。

在最近几年的paper上，如iccv这种重量级的会议，iccv 09年 的里面有不少的文章都是与Boosting与随机森林相关的。模型组合+决策树相关的算法有两种比较基本的形式 - 随机森林与GBDT((Gradient Boost Decision Tree)，其他的比较新的模型组合+决策树的算法都是来自这两种算法的延伸。本文主要侧重于GBDT，对于随机森林只是大概提提，因为它相对比较简单。

在看本文之前，建议先看看机器学习与数学(3)与其中引用的论文，本文中的GBDT主要基于此，而随机森林相对比较独立。

基础内容：

这里只是准备简单谈谈基础的内容，主要参考一下别人的文章，对于随机森林与GBDT，有两个地方比较重要，首先是information gain，其次是决策树。这里特别推荐Andrew Moore大牛的Decision Trees Tutorial，与Information Gain Tutorial。Moore的Data Mining Tutorial系列非常赞，看懂了上面说的两个内容之后的文章才能继续读下去。

决策树实际上是将空间用超平面进行划分的一种方法，每次分割的时候，都将当前的空间一分为二，比如说下面的决策树：

就是将空间划分成下面的样子：

这样使得每一个叶子节点都是在空间中的一个不相交的区域，在进行决策的时候，会根据输入样本每一维feature的值，一步一步往下，最后使得样本落入N个区域中的一个（假设有N个叶子节点）

随机森林(Random Forest):

随机森林是一个最近比较火的算法，它有很多的优点：

• 在数据集上表现良好
• 在当前的很多数据集上，相对其他算法有着很大的优势
• 它能够处理很高维度（feature很多）的数据，并且不用做特征选择
• 在训练完后，它能够给出哪些feature比较重要
• 在创建随机森林的时候，对generlization error使用的是无偏估计
• 训练速度快
• 在训练过程中，能够检测到feature间的互相影响
• 容易做成并行化方法
• 实现比较简单

随机森林顾名思义，是用随机的方式建立一个森林，森林里面有很多的决策树组成，随机森林的每一棵决策树之间是没有关联的。在得到森林之后，当有一个新的输 入样本进入的时候，就让森林中的每一棵决策树分别进行一下判断，看看这个样本应该属于哪一类（对于分类算法），然后看看哪一类被选择最多，就预测这个样本 为那一类。

在建立每一棵决策树的过程中，有两点需要注意 - 采样与完全分裂。首先是两个随机采样的过程，random forest对输入的数据要进行行、列的采样。对于行采样，采用有放回的方式，也就是在采样得到的样本集合中，可能有重复的样本。假设输入样本为N个，那 么采样的样本也为N个。这样使得在训练的时候，每一棵树的输入样本都不是全部的样本，使得相对不容易出现over-fitting。然后进行列采样，从M 个feature中，选择m个(m << M)。之后就是对采样之后的数据使用完全分裂的方式建立出决策树，这样决策树的某一个叶子节点要么是无法继续分裂的，要么里面的所有样本的都是指向的同一 个分类。一般很多的决策树算法都一个重要的步骤 - 剪枝，但是这里不这样干，由于之前的两个随机采样的过程保证了随机性，所以就算不剪枝，也不会出现over-fitting。

按这种算法得到的随机森林中的每一棵都是很弱的，但是大家组合起来就很厉害了。我觉得可以这样比喻随机森林算法：每一棵决策树就是一个精通于某一个窄领域 的专家（因为我们从M个feature中选择m让每一棵决策树进行学习），这样在随机森林中就有了很多个精通不同领域的专家，对一个新的问题（新的输入数 据），可以用不同的角度去看待它，最终由各个专家，投票得到结果。

随机森林的过程请参考Mahout的random forest 。这个页面上写的比较清楚了，其中可能不明白的就是Information Gain，可以看看之前推荐过的Moore的页面。

Gradient Boost Decision Tree:

GBDT是一个应用很广泛的算法，可以用来做分类、回归。在很多的数据上都有不错的效果。GBDT这个算法还有一些其他的名字，比如说MART(Multiple Additive Regression Tree)，GBRT(Gradient Boost Regression Tree)，Tree Net等，其实它们都是一个东西（参考自wikipedia – Gradient Boosting)，发明者是Friedman

Gradient Boost其实是一个框架，里面可以套入很多不同的算法，可以参考一下机器学习与数学(3)中的讲解。Boost是"提升"的意思，一般Boosting算法都是一个迭代的过程，每一次新的训练都是为了改进上一次的结果。

原始的Boost算法是在算法开始的时候，为每一个样本赋上一个权重值，初始的时候，大家都是一样重要的。在每一步训练中得到的模型，会使得数据点的估计 有对有错，我们就在每一步结束后，增加分错的点的权重，减少分对的点的权重，这样使得某些点如果老是被分错，那么就会被“严重关注”，也就被赋上一个很高 的权重。然后等进行了N次迭代（由用户指定），将会得到N个简单的分类器（basic learner），然后我们将它们组合起来（比如说可以对它们进行加权、或者让它们进行投票等），得到一个最终的模型。

而Gradient Boost与传统的Boost的区别是，每一次的计算是为了减少上一次的残差(residual)，而为了消除残差，我们可以在残差减少的梯度(Gradient)方向上建立一个新的模型。所以说，在Gradient Boost中，每个新的模型的简历是为了使得之前模型的残差往梯度方向减少，与传统Boost对正确、错误的样本进行加权有着很大的区别。

在分类问题中，有一个很重要的内容叫做Multi-Class Logistic，也就是多分类的Logistic问题，它适用于那些类别数>2的问题，并且在分类结果中，样本x不是一定只属于某一个类可以得到 样本x分别属于多个类的概率（也可以说样本x的估计y符合某一个几何分布），这实际上是属于Generalized Linear Model中讨论的内容，这里就先不谈了，以后有机会再用一个专门的章节去做吧。这里就用一个结论：如果一个分类问题符合几何分布，那么就可以用Logistic变换来进行之后的运算。

假设对于一个样本x，它可能属于K个分类，其估计值分别为F1(x)…FK(x)，Logistic变换如下，logistic变换是一个平滑且将数据规范化（使得向量的长度为1）的过程，结果为属于类别k的概率pk(x)，

对于Logistic变换后的结果，损失函数为：

其中，yk为输入的样本数据的估计值，当一个样本x属于类别k时，yk = 1，否则yk = 0。

将Logistic变换的式子带入损失函数，并且对其求导，可以得到损失函数的梯度：

上面说的比较抽象，下面举个例子：

假设输入数据x可能属于5个分类（分别为1,2,3,4,5），训练数据中，x属于类别3，则y = (0, 0, 1, 0, 0)，假设模型估计得到的F(x) = (0, 0.3, 0.6, 0, 0)，则经过Logistic变换后的数据p(x) = (0.16,0.21,0.29,0.16,0.16)，y - p得到梯度g：(-0.16, -0.21, 0.71, -0.16, -0.16)。观察这里可以得到一个比较有意思的结论：

假设gk为样本当某一维（某一个分类）上的梯度:

gk>0时，越大表示其在这一维上的概率p(x)越应该提高，比如说上面的第三维的概率为0.29，就应该提高，属于应该往“正确的方向”前进

越小表示这个估计越“准确”

gk<0时，越小，负得越多表示在这一维上的概率应该降低，比如说第二维0.21就应该得到降低。属于应该朝着“错误的反方向”前进

越大，负得越少表示这个估计越“不错误 ”

总的来说，对于一个样本，最理想的梯度是越接近0的梯度。所以，我们要能够让函数的估计值能够使得梯度往反方向移动（>0的维度上，往负方向移动，<0的维度上，往正方向移动）最终使得梯度尽量=0），并且该算法在会严重关注那些梯度比较大的样本，跟Boost的意思类似。

得到梯度之后，就是如何让梯度减少了。这里是用的一个迭代+决策树的方法，当初始化的时候，随便给出一个估计函数F(x)（可以让F(x)是一个随机的值，也可以让F(x)=0），然后之后每迭代一步就根据当前每一个样本的梯度的情况，建立一棵决策树。就让函数往梯度的反方向前进，最终使得迭代N步后，梯度越小。

这里建立的决策树和普通的决策树不太一样，首先，这个决策树是一个叶子节点数J固定的，当生成了J个节点后，就不再生成新的节点了。

算法的流程如下:（参考自treeBoost论文）

0. 表示给定一个初始值

1. 表示建立M棵决策树（迭代M次）

2. 表示对函数估计值F(x)进行Logistic变换

3. 表示对于K个分类进行下面的操作（其实这个for循环也可以理解为向量的操作，每一个样本点xi都对应了K种可能的分类yi，所以yi, F(xi), p(xi)都是一个K维的向量，这样或许容易理解一点）

4. 表示求得残差减少的梯度方向

5. 表示根据每一个样本点x，与其残差减少的梯度方向，得到一棵由J个叶子节点组成的决策树

6. 为当决策树建立完成后，通过这个公式，可以得到每一个叶子节点的增益（这个增益在预测的时候用的）

每个增益的组成其实也是一个K维的向量，表示如果在决策树预测的过程中，如果某一个样本点掉入了这个叶子节点，则其对应的K个分类的值是多少。比如 说，GBDT得到了三棵决策树，一个样本点在预测的时候，也会掉入3个叶子节点上，其增益分别为（假设为3分类的问题）：

(0.5, 0.8, 0.1),  (0.2, 0.6, 0.3),  (0.4, 0.3, 0.3)，那么这样最终得到的分类为第二个，因为选择分类2的决策树是最多的。

7. 的意思为，将当前得到的决策树与之前的那些决策树合并起来，作为新的一个模型(跟6中所举的例子差不多)

GBDT的算法大概就讲到这里了，希望能够弥补一下上一篇文章中没有说清楚的部分：）

实现：

看明白了算法，就需要去实现一下，或者看看别人实现的代码，这里推荐一下wikipedia中的gradient boosting页面，下面就有一些开源软件中的一些实现，比如说下面这个：http://elf-project.sourceforge.net/

参考资料：

除了文章中的引用的内容（已经给出了链接）外，主要还是参考Friedman大牛的文章：Greedy function approximation : A Gradient Boosting Machine

本文由LeftNotEasy发布于http://leftnoteasy.cnblogs.com, 本文可以被全部的转载或者部分使用，但请注明出处，如果有问题，请联系[e-mail]

=========================================

cvchina上的《online random forest》

一直忽悠cvchina，心有歉意。第一次发文，简单写点online learning的东西。

传统的SVM和adaboost都是batch mode learning. 所谓的batch mode learning， 简单说，就是所有的训练数据都是available的（或则说所有训练数据都已经在内存中）。这种方法主要有2个缺点：

1）  有时候数据量太大，在内存中放不下，处理起来不方便

2）  由于应用环境限制，有时候无法在训练之前得到所有训练数据

而Online learning， 他的数据是come in sequence，也就是说traning sample 是一个一个来，或则是几个几个来，然后classifer 根据新来的samples进行更新。Online learning是比较困难的，主要原因是你无法知道将来的训练数据是如何的。显然adaboost和svm是行不通的。最近几年也有一些人做 online learning的研究，主要方法还是集中在online boosting这一块。推荐2篇不错的文章：

1）  online adaboost [1], 并把他用在object tracking等方面。这篇文章发表于CVPR2006引用率蛮高。这几年的cvpr上的几篇做tracking的文章以这个idea为基础。 tracking的方法是用最近比较流行的tracking-by-detection的方法。简答的说就是在tracking的时 候，observation model这一块是用一个在线训练的分类器。tracking的过程如下图所示（图中还有一步是用跟踪的结果作为训练器的新的输入）：

这篇文章online 训练的时候，用tracking 的结果作为online classifier的positive samples。显然这种数据是有噪声的，最后tracking会drift掉。而且需要指出的是，这种方法没有严格证明，只是模仿batch mode adaboost. 我把这个算法用在uci的训练数据上，效果不是很好。作者的主页是：http://www.vision.ee.ethz.ch/~hegrabne/. 这个是他用online learning 做tracking的项目主页：http://www.vision.ee.ethz.ch/boostingTrackers/。 有现成代码和demo。

2）  去年的一篇论文是关于online random forest[2]。网上有现成的代码。我跑了一下，挺牛逼的，效果没比offline mode差不多。如果你需要做online learning的话十分推荐。

[1].On-line Boosting and Vision. 06CVPR.

[2]. Online random forest. 09ICCV workshop on online machine learning.

PS：code的原始链接失效了，我传了一份到mediafire。丕子发现mediafirm也被墙了，NND，所以自己上传了一份弄到微盘里面了：

分享代码，难得下到的。Online random forest. 09ICCV workshop on online machine learning.通过@微盘 分享文件"OnlineForest-0.11.tar.gz" http://t.cn/SzV3Lq