train_cascade 源码阅读之级联训练

在主函数中，最耀眼的一句话就是这个了：

    classifier.train( cascadeDirName,
                      vecName,
                      bgName,
                      numPos, numNeg,
                      precalcValBufSize, precalcIdxBufSize,
                      numStages,
                      cascadeParams,
                      *featureParams[cascadeParams.featureType],
            stageParams,
            baseFormatSave );

其实现如下：

bool CvCascadeClassifier::
train(
        const string _cascadeDirName,
        const string _posFilename,
        const string _negFilename,
        int _numPos, int _numNeg,
        int _precalcValBufSize, int _precalcIdxBufSize,
        int _numStages,
        const CvCascadeParams& _cascadeParams,
        const CvFeatureParams& _featureParams,
        const CvCascadeBoostParams& _stageParams,
        bool baseFormatSave )
{
    // Start recording clock ticks for training time output
    const clock_t begin_time = clock();

    //确认数据是否有效，略过，下面代码同理，只保留关键语句
    ……

    //判断读入数据级数，并显示
    int startNumStages = (int)stageClassifiers.size();
    if ( startNumStages > 1 )
        cout << endl << "Stages 0-" << startNumStages-1 << " are loaded" << endl;
    else if ( startNumStages == 1)
        cout << endl << "Stage 0 is loaded" << endl;
    
    //计算要求的叶节点虚警率
    double requiredLeafFARate
            = pow( (double) stageParams->maxFalseAlarm, (double) numStages ) 
                   /(double)stageParams->max_depth;//子树最大深度，默认为1
    double tempLeafFARate;

    for( int i = startNumStages; i < numStages; i++ )
    {
        cout << endl << "===== TRAINING " << i << "-stage =====" << endl;
        cout << "<BEGIN" << endl;

        //无法满足需要的数据，返回
        if ( !updateTrainingSet( requiredLeafFARate, tempLeafFARate ) )
        {
            cout << "Train dataset for temp stage can not be filled. "
                    "Branch training terminated." << endl;
            break;
        }
        //叶节点虚警率已经达到要求，返回
        if( tempLeafFARate <= requiredLeafFARate )
        {
            cout << "Required leaf false alarm rate achieved. "
                    "Branch training terminated." << endl;
            break;
        }
        //开始训练本级
        CvCascadeBoost* tempStage = new CvCascadeBoost;
        bool isStageTrained = tempStage->train(
                    (CvFeatureEvaluator*)featureEvaluator,
                    curNumSamples, _precalcValBufSize, _precalcIdxBufSize,
                    *((CvCascadeBoostParams*)stageParams) );
        cout << "END>" << endl;
        //本级训练失败，返回
        if(!isStageTrained)
            break;
        //成功，添加本级
        stageClassifiers.push_back( tempStage );

        // save params
        ……

        // Output training time up till now
        ……
    }
    //上面for循环，break出来的
    if(stageClassifiers.size() == 0)
    {
        cout << "Cascade classifier can't be trained."
                " Check the used training parameters." << endl;
        return false;
    }

    //保存级联分类器到xml格式中
    save( dirName + CC_CASCADE_FILENAME, baseFormatSave );
    return true;
}

接着看updateTrainingSet，每一级操作前先更新样本数据

bool CvCascadeClassifier::updateTrainingSet(
        double  minimumAcceptanceRatio,
        double  & acceptanceRatio)
{
    int64 posConsumed = 0, negConsumed = 0;
    imgReader.restart();
    //获取正样本
    int posCount = fillPassedSamples( 0, numPos, true, 0, posConsumed );
    if( !posCount )
        return false;
    cout << "POS count : consumed   " << posCount << " : "
         << (int)posConsumed << endl;
    //计算需要的负样本 负样本总数乘以 获得的正样本与正样本总数之比，保持了选取训练样本的正负样本比例不变
    int proNumNeg = cvRound(
                (((double)numNeg) * ((double)posCount) ) / numPos
                );
    // apply only a fraction of negative samples.
    //double is required since overflow is possible
    //获取负样本
    int negCount = fillPassedSamples(
                posCount,
                proNumNeg,
                false,
                minimumAcceptanceRatio,
                negConsumed );
    if ( !negCount )
        return false;

    curNumSamples = posCount + negCount;
    //计算acceptanceRatio，也就是FP/（FP+TN）
    acceptanceRatio = negConsumed == 0 ?
                0 : ( (double)negCount/(double)(int64)negConsumed );
    cout << "NEG count : acceptanceRatio    "
         << negCount << " : " << acceptanceRatio << endl;
    return true;
}

上段代码中最重要的就是fillPassedSamples函数了。

int CvCascadeClassifier::fillPassedSamples(
        int     first,
        int     count,
        bool    isPositive,
        double  minimumAcceptanceRatio,
        int64   &consumed )
{
    int getcount = 0;
    Mat img(cascadeParams.winSize, CV_8UC1);
    for( int i = first; i < first + count; i++ )
    {
        for( ; ; )
        {
            if( consumed != 0
                    && ((double)getcount+1)/(double)(int64)consumed
                    <= minimumAcceptanceRatio )
                return getcount;
            //获取对应类别图片
            bool isGetImg = isPositive ? imgReader.getPos( img ) :
                                         imgReader.getNeg( img );
            if( !isGetImg )
                return getcount;
            consumed++;
            //在数据矩阵中设置图像类别
            featureEvaluator->setImage( img, isPositive ? 1 : 0, i );
            //如果预测为正样本就跳出循环，在填充负样本的过程中，返回的也是误判为正样本的值。
            if( predict( i ) == 1.0F )
            {
                getcount++;
                printf("%s current samples: %d\r",
                       isPositive ? "POS":"NEG", getcount);
                break;
            }
        }
    }
    return getcount;
}

实际的预测过程，值是每个弱分类器预测值的和。

float CvCascadeBoost::predict( int sampleIdx, bool returnSum ) const
{
    CV_Assert( weak );
    double sum = 0;
    CvSeqReader reader;
    cvStartReadSeq( weak, &reader );
    cvSetSeqReaderPos( &reader, 0 );
    for( int i = 0; i < weak->total; i++ )
    {
        CvBoostTree* wtree;
        CV_READ_SEQ_ELEM( wtree, reader );
        sum += ((CvCascadeBoostTree*)wtree)->predict(sampleIdx)->value;
    }
    if( !returnSum )
        sum = sum < threshold - CV_THRESHOLD_EPS ? 0.0 : 1.0;
    return (float)sum;
}

到了训练部分：

bool CvCascadeBoost::
train(
        const CvFeatureEvaluator* _featureEvaluator,
        int _numSamples,
        int _precalcValBufSize, int _precalcIdxBufSize,
        const CvCascadeBoostParams& _params )
{
    bool isTrained = false;
    CV_Assert( !data );
    clear();
    data = new CvCascadeBoostTrainData(
                _featureEvaluator, _numSamples,
                _precalcValBufSize, _precalcIdxBufSize, _params );
    CvMemStorage *storage = cvCreateMemStorage();
    weak = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvBoostTree*), storage );
    storage = 0;

    set_params( _params );
    if ( (_params.boost_type == LOGIT) || (_params.boost_type == GENTLE) )
        data->do_responses_copy();
    //初始化权值
    update_weights( 0 );

    cout << "+----+---------+---------+" << endl;
    cout << "|  N |    HR   |    FA   |" << endl;
    cout << "+----+---------+---------+" << endl;

    do
    {
        //训练树
        CvCascadeBoostTree* tree = new CvCascadeBoostTree;
        if( !tree->train( data, subsample_mask, this ) )
        {
            delete tree;
            break;
        }
        cvSeqPush( weak, &tree );
        //更新权值
        update_weights( tree );
        trim_weights();
        if( cvCountNonZero(subsample_mask) == 0 )
            break;
    }
    while( !isErrDesired() && (weak->total < params.weak_count) );
    //循环终止条件，虚警率达到要求或者达到最大弱分类器数目

    if(weak->total > 0)
    {
        data->is_classifier = true;
        data->free_train_data();
        isTrained = true;
    }
    else
        clear();

    return isTrained;
}

这样，一级就训练完了。