第四十三篇：haartrainning结果的含义

opencv中cascadetrainning的结果如下：

下面来分析一下行结果的意思

<?xml version="1.0"?>

<opencv_storage>
<cascade>
  <stageType>BOOST</stageType>
  <featureType>HAAR</featureType>
  <height>24</height>                                                     //样本的高
  <width>24</width>                                                        //训练样本的宽
  <stageParams>                                                         
    <boostType>GAB</boostType>
    <minHitRate>9.4999998807907104e-001</minHitRate>                               
    <maxFalseAlarm>5.0000000000000000e-001</maxFalseAlarm>              //虚警
    <weightTrimRate>9.4999999999999996e-001</weightTrimRate>             //训练的识别正确率
    <maxDepth>1</maxDepth>
    <maxWeakCount>100</maxWeakCount></stageParams>
  <featureParams>
    <maxCatCount>0</maxCatCount>
    <featSize>1</featSize>
    <mode>ALL</mode></featureParams>
  <stageNum>15</stageNum>
  <stages>
    <!-- stage 0 -->                                                                                                 //分类器的级
    <_>
      <maxWeakCount>6</maxWeakCount>                                                           //弱分类器的个数   6个
      <stageThreshold>-9.3017762899398804e-001</stageThreshold>       //级联的强分类器的阈值
      <weakClassifiers>
        <_>
          <internalNodes>
            0 -1 53 -7.1651302278041840e-002</internalNodes>                          //0，-1代表左右的标志位     弱分类器的阈值
          <leafValues>
            4.8380860686302185e-001 -6.3721960783004761e-001</leafValues></_>           //左右的阈值
        <_>
          <internalNodes>
            0 -1 31 9.3044321984052658e-003</internalNodes>
          <leafValues>
            9.2744462192058563e-002 -7.5913965702056885e-001</leafValues></_>
        <_>
          <internalNodes>
            0 -1 90 -1.1703098565340042e-001</internalNodes>
          <leafValues>
            5.5687570571899414e-001 -2.3895284533500671e-001</leafValues></_>
        <_>
          <internalNodes>
            0 -1 161 -3.4744767472147942e-003</internalNodes>
          <leafValues>
            -6.7214423418045044e-001 1.8688599765300751e-001</leafValues></_>
        <_>
          <internalNodes>
            0 -1 27 1.8264122772961855e-003</internalNodes>
          <leafValues>
            1.5197283029556274e-001 -6.4832943677902222e-001</leafValues></_>
        <_>
          <internalNodes>
            0 -1 194 1.8098486179951578e-005</internalNodes>
          <leafValues>

            -3.2951089739799500e-001 3.1469380855560303e-001</leafValues></_></weakClassifiers></_>

    <_>
      <rects>
        <_>
          2 20 19 4 -1.</_>                      //矩阵。前四个数值是矩阵四个点的位置，最后一个数值是矩阵像素和的权值
        <_>
          2 21 19 2 2.</_></rects>        //矩阵。前四个数值是矩阵四个点的位置，最后一个是像素和的权值，这样两个矩阵就形成了一个Haar特征
      <tilted>0</tilted></_>                 //是否是倾斜的Haar特征

具体的树状分类器的意思可以从源程序读懂

Opencv研读笔记:haartraining程序之cvCreateCARTClassifier函数详解（CART树状弱分类器创建）~，

cvCreateCARTClassifier函数在haartraining程序中用于创建CART树状弱分类器，但一般只采用单一节点的CART分类器，即桩分类器，一个多节点的CART分类器训练耗时很多。根据自己的测试，要等差不多10分钟（2000正样本、2000负样本）才能训练完一个3节点的弱分类器，当然，总体的树状弱分类器的数目可能也会减少1/2。之所以将此函数拿出来说说，主要是因为在网上找不到针对这个函数的详细说明，同时，CART的应用十分广泛，自己也趁这个机会好好学学，把自己的一点理解分享给大家。

1. 先说说CART树的设计问题，也就是CvCARTClassifier这个结构体，结构体中变量的意义着实让我伤了一番脑筋。现添加其变量含义，如下：

typedef struct CvCARTClassifier
{
    CV_CLASSIFIER_FIELDS()
    /* number of internal nodes */
    int count;                      // 非叶子节点个数

    /* internal nodes (each array of <count> elements) */
    int* compidx;                   // 节点所采用的最优Haar特征序号
    float* threshold;               // 节点所采用的最优Haar特征阈值
    int* left;                      // 非叶子节点的左子节点序号（叶子节点为负数，非叶子节点为正数）
    int* right;                     // 非叶子节点的右子节点序号（叶子节点为负数，非叶子节点为正数）

    /* leaves (array of <count>+1 elements) */
    float* val;                     // 叶子节点输出置信度
} CvCARTClassifier;

其中，count就是main主函数中的参数nsplits，用于定义的是非叶子节点数，或者叫做中间节点数。个人认为，这样设计一棵树很科学，将非叶子节点与叶子节点分开表述，结构体十分简洁，只不过当时left的真实含义让我琢磨了挺长时间。

2. cvCreateCARTClassifier中节点的“分类属性”仍旧是Haar特征，“分类准则”是分类错误率的下降程度，在程序中表现为”父节点的左（右）分支error与当前节点基于最优Haar特征的error之和之间的差值(errdrop)的大小“。

3. CART树状分类器的形式多种多样，就3个非叶子节点来说，我调试之后，就遇到了如下两种弱分类器：

4. 可能有童鞋会问，为什么要采用树状的弱分类器，我的理解是，一个树状的分类器在测试过程中，特征比较的次数相对串行的弱分类器要少很多，比如说，3个串行的Haar特征，比较次数是3次，但是如果是一颗3节点的CART树，比较次数可能只需要两次。并且， 一个树状弱分类器中，子节点针对的数据集更加具体，具有针对性，可能精度会更高。

以上就是自己对cvCreateCARTClassifier函数的理解，带有注释的源代码如下所示：

转载请注明：http://blog.csdn.net/wsj998689aa/article/details/43411809

CV_BOOST_IMPL
CvClassifier* cvCreateCARTClassifier( CvMat* trainData,                     // 训练样本特征值矩阵
                                     int flags,                             // 样本按行排列
                                     CvMat* trainClasses,                   // 训练样本类别向量
                                     CvMat* typeMask,           
                                     CvMat* missedMeasurementsMask,
                                     CvMat* compIdx,                        // 特征序列向量
                                     CvMat* sampleIdx,                      // 样本序列向量
                                     CvMat* weights,                        // 样本权值向量
                                     CvClassifierTrainParams* trainParams ) // 参数
{
    CvCARTClassifier* cart = NULL;          // CART树状弱分类器
    size_t datasize = 0;
    int count = 0;                          // CART中的节点数目
    int i = 0;
    int j = 0;

    CvCARTNode* intnode = NULL;             // CART节点
    CvCARTNode* list = NULL;                // CART节点列表
    int listcount = 0;                      // CART节点列表元素个数
    CvMat* lidx = NULL;                     // 当前节点左节点样本序列
    CvMat* ridx = NULL;                     // 当前节点右节点样本序列

    float maxerrdrop = 0.0F;
    int idx = 0;

    // 设置节点分裂函数指针
    void (*splitIdxCallback)( int compidx, float threshold,
        CvMat* idx, CvMat** left, CvMat** right,
        void* userdata );
    void* userdata;

    // 设置非叶子节点个数
    count = ((CvCARTTrainParams*) trainParams)->count;

    assert( count > 0 );

    datasize = sizeof( *cart ) + (sizeof( float ) + 3 * sizeof( int )) * count + 
        sizeof( float ) * (count + 1);

    cart = (CvCARTClassifier*) cvAlloc( datasize );
    memset( cart, 0, datasize );

    cart->count = count;

    // 输出当前样本的置信度 
    cart->eval = cvEvalCARTClassifier;
    
    cart->save = NULL;
    cart->release = cvReleaseCARTClassifier;

    cart->compidx = (int*) (cart + 1);                      // 当前非叶子节点的最优Haar特征序号
    cart->threshold = (float*) (cart->compidx + count);     // 当前非叶子节点的最优Haar特征阈值
    cart->left  = (int*) (cart->threshold + count);         // 当前节点的左子节点序号，包含叶子节点序号
    cart->right = (int*) (cart->left + count);              // 当前节点的右子节点序号，包含叶子节点序号
    cart->val = (float*) (cart->right + count);             // 叶子节点输出置信度

    datasize = sizeof( CvCARTNode ) * (count + count);
    intnode = (CvCARTNode*) cvAlloc( datasize );
    memset( intnode, 0, datasize );
    list = (CvCARTNode*) (intnode + count);

    // 节点分裂函数指针，一般为icvSplitIndicesCallback函数
    splitIdxCallback = ((CvCARTTrainParams*) trainParams)->splitIdx;
    userdata = ((CvCARTTrainParams*) trainParams)->userdata;

    // R代表样本按行排列，C代表样本按列排列
    if( splitIdxCallback == NULL )
    {
        splitIdxCallback = ( CV_IS_ROW_SAMPLE( flags ) )
            ? icvDefaultSplitIdx_R : icvDefaultSplitIdx_C;
        userdata = trainData;
    }

    // 创建CART根节点
    intnode[0].sampleIdx = sampleIdx;
    intnode[0].stump = (CvStumpClassifier*)
        ((CvCARTTrainParams*) trainParams)->stumpConstructor( trainData, flags,
        trainClasses, typeMask, missedMeasurementsMask, compIdx, sampleIdx, weights,
        ((CvCARTTrainParams*) trainParams)->stumpTrainParams );
    cart->left[0] = cart->right[0] = 0;

    // 创建树状弱分类器，lerror或者rerror不为0代表着当前节点为非叶子节点
    listcount = 0;
    for( i = 1; i < count; i++ )
    {
        // 基于当前节点弱分类器阈值，对当前节点进行分裂
        splitIdxCallback( intnode[i-1].stump->compidx, intnode[i-1].stump->threshold,
            intnode[i-1].sampleIdx, &lidx, &ridx, userdata );

        // 为分裂之后的非叶子节点计算最优特征
        if( intnode[i-1].stump->lerror != 0.0F )
        {
            // 小于阈值的样本集合
            list[listcount].sampleIdx = lidx;

            // 基于新样本集合寻找最优特征
            list[listcount].stump = (CvStumpClassifier*)
                ((CvCARTTrainParams*) trainParams)->stumpConstructor( trainData, flags,
                trainClasses, typeMask, missedMeasurementsMask, compIdx,
                list[listcount].sampleIdx,
                weights, ((CvCARTTrainParams*) trainParams)->stumpTrainParams );

            // 计算信息增益(这里是error的下降程度)
            list[listcount].errdrop = intnode[i-1].stump->lerror
                - (list[listcount].stump->lerror + list[listcount].stump->rerror);
            list[listcount].leftflag = 1;
            list[listcount].parent = i-1;
            listcount++;
        }
        else
        {
            cvReleaseMat( &lidx );
        }

        // 同上，左分支换成右分支，偏向于右分支
        if( intnode[i-1].stump->rerror != 0.0F )
        {
            list[listcount].sampleIdx = ridx;
            list[listcount].stump = (CvStumpClassifier*)
                ((CvCARTTrainParams*) trainParams)->stumpConstructor( trainData, flags,
                trainClasses, typeMask, missedMeasurementsMask, compIdx,
                list[listcount].sampleIdx,
                weights, ((CvCARTTrainParams*) trainParams)->stumpTrainParams );
            list[listcount].errdrop = intnode[i-1].stump->rerror
                - (list[listcount].stump->lerror + list[listcount].stump->rerror);
            list[listcount].leftflag = 0;       // 优先级更高的证据
            list[listcount].parent = i-1;
            listcount++;
        }
        else
        {
            cvReleaseMat( &ridx );
        }

        if( listcount == 0 ) break;

        idx = 0;
        maxerrdrop = list[idx].errdrop;
        for( j = 1; j < listcount; j++ )
        {
            if( list[j].errdrop > maxerrdrop )
            {
                idx = j;
                maxerrdrop = list[j].errdrop;
            }
        }

        // 添加新节点
        intnode[i] = list[idx];

        // 确定当前节点的非叶子子节点的序号
        if( list[idx].leftflag )
        {
            cart->left[list[idx].parent] = i;
        }
        else
        {
            cart->right[list[idx].parent] = i;
        }

        if( idx != (listcount - 1) )
        {
            list[idx] = list[listcount - 1];
        }
        listcount--;
    }

    // 这段代码用于确定树中节点最优特征序号、阈值与叶子节点序号和输出置信度
    // left与right大于等于0，为0代表叶子节点
    // 就算CART中只有一个节点，仍旧需要设置叶子节点
    j = 0;
    cart->count = 0;
    for( i = 0; i < count && (intnode[i].stump != NULL); i++ )
    {
        cart->count++;
        cart->compidx[i] = intnode[i].stump->compidx;
        cart->threshold[i] = intnode[i].stump->threshold;

        // 确定叶子序号与叶子的输出置信度
        if( cart->left[i] <= 0 )
        {
            cart->left[i] = -j;
            cart->val[j] = intnode[i].stump->left;
            j++;
        }
        if( cart->right[i] <= 0 )
        {
            cart->right[i] = -j;
            cart->val[j] = intnode[i].stump->right;
            j++;
        }
    }

    // 后续处理
    for( i = 0; i < count && (intnode[i].stump != NULL); i++ )
    {
        intnode[i].stump->release( (CvClassifier**) &(intnode[i].stump) );
        if( i != 0 )
        {
            cvReleaseMat( &(intnode[i].sampleIdx) );
        }
    }
    for( i = 0; i < listcount; i++ )
    {
        list[i].stump->release( (CvClassifier**) &(list[i].stump) );
        cvReleaseMat( &(list[i].sampleIdx) );
    }

    cvFree( &intnode );

    return (CvClassifier*) cart;
}