Adaboost应用系列之二：Opencv2.0中利用Adaboost训练LBP特征产生xml分类器-CSDN博客

本文链接：https://blog.csdn.net/holybin/article/details/16863043

1.采集样本

2.预处理样本

3.生成正负样本描述文件

4.创建正样本vec文件

前4个步骤参考我的另一篇文章：《Adaboost应用系列之一：Opencv2.0中利用Adaboost训练Haar特征产生xml分类器》。以上4个步骤的大体内容一致，需要区别的是这里训练LBP特征时使用的正样本尺寸为默认大小24*24，负样本不需要缩放，但是需要大于正样本的尺寸，否则容易造成训练中途卡死，参考这篇文章：http://blog.csdn.net/naruto0001/article/details/8064007。

5.训练样本

（1）上一篇文章采用的是opencv_haartraining.exe来训练Haar特征，但是对于LBP和HOG特征需要使用新版本的opencv_traincascade.exe来训练。将程序拷贝到工作目录：

注意：这里的正样本缩放到默认尺寸24*24（pos_24_24目录中），负样本没有缩放（neg目录中），但是比正样本尺寸要大。

（2）在当前目录的CMD输入如下命令：

opencv_traincascade.exe -data LBP_classifier -vec pos_24_24.vec -bg neg\neg.txt -numPos 1416 -numNeg 1957 -numStages 20 -featureType LBP -w 24 -h 24

（3）opencv_traincascade.exe的命令行参数解释如下：

具体可以参考这里：级联分类器训练 — OpenCV 2.3.2 documentation

通用参数：

-data <cascade_dir_name>：目录用于保存训练产生的分类器xml文件和中间文件（对于上面的LBP_classifier），如不存在训练程序会创建它；

-vec <vec_file_name>：由 opencv_createsamples 程序生成的包含正样本的vec文件名（对应上面的pos_24_24.vec）；

-bg <background_file_name>：背景描述文件，也就是包含负样本文件名的那个描述文件（对应上面的neg\neg.txt）；

-numPos <number_of_positive_samples>：每级分类器训练时所用的正样本数目（默认值为2000）；
-numNeg <number_of_negative_samples>：每级分类器训练时所用的负样本数目，可以大于 -bg 指定的图片数目（默认值为1000）；

-numStages <number_of_stages>：训练的分类器的级数（默认值为20级）；

-precalcValBufSize <precalculated_vals_buffer_size_in_Mb>：缓存大小，用于存储预先计算的特征值(feature values)，单位为MB（默认值为256）；
-precalcIdxBufSize <precalculated_idxs_buffer_size_in_Mb>：缓存大小，用于存储预先计算的特征索引(feature indices)，单位为MB（默认值为256）；

内存越大，训练时间越短。
-baseFormatSave：这个参数仅在使用Haar特征时有效。如果指定这个参数，那么级联分类器将以老的格式存储（默认不指定该参数项，此时其值为false；一旦指定则其值默认为true）；

级联参数：CvCascadeParams类，定义于cascadeclassifier.h
-stageType <BOOST(default)>：级别（stage）参数。目前只支持将BOOST分类器作为级联的类型；
-featureType<{HAAR(default), LBP}>：特征的类型： HAAR - 类Haar特征； LBP - 局部纹理模式特征（默认Harr）；
-w <sampleWidth>：训练样本的宽（单位为像素，默认24）；
-h <sampleHeight>：训练样本的高（单位为像素，默认24）；
训练样本的尺寸必须跟训练样本创建（使用 opencv_createsamples 程序创建）时的尺寸保持一致。

Boosted分类器参数：CvCascadeBoostParams类，定义于boost.h
-bt <{DAB, RAB, LB, GAB(default)}>：Boosted分类器的类型（DAB - Discrete AdaBoost, RAB - Real AdaBoost, LB - LogitBoost, GAB - Gentle AdaBoost为默认）；
-minHitRate <min_hit_rate>：分类器的每一级希望得到的最小检测率（默认值为0.995），总的检测率大约为 min_hit_rate^number_of_stages；
-maxFalseAlarmRate <max_false_alarm_rate>：分类器的每一级希望得到的最大误检率（默认值为0.5），总的误检率大约为 max_false_alarm_rate^number_of_stages；
-weightTrimRate <weight_trim_rate>：Specifies whether trimming should be used and its weight，一个还不错的数值是0.95；
-maxDepth <max_depth_of_weak_tree>：弱分类器树最大的深度。一个还不错的数值是1，是二叉树（stumps）；
-maxWeakCount <max_weak_tree_count>：每一级中的弱分类器的最大数目（默认值为100）。The boosted classifier (stage) will have so many weak trees (<=maxWeakCount), as needed to achieve the given -maxFalseAlarmRate；

类Haar特征参数：
-mode <BASIC (default) | CORE | ALL>：选择训练过程中使用的Haar特征的类型。 BASIC 只使用右上特征， ALL 使用所有右上特征和45度旋转特征；
LBP特征参数：
LBP特征无参数。但是我们从代码中可以看出LBP特征的参数设置（主要是lbpfeatures.H和lbpfeatures.cpp文件）：

-首先这里采取的是8领域的LBP，从定义maxCatCount = 256可以大概知道，主要从CvLBPEvaluator::generateFeatures()函数实现中看出：

void CvLBPEvaluator::generateFeatures()
{
    int offset = winSize.width + 1;
    for( int x = 0; x < winSize.width; x++ )
        for( int y = 0; y < winSize.height; y++ )
            for( int w = 1; w <= winSize.width / 3; w++ )
                for( int h = 1; h <= winSize.height / 3; h++ )
                    if ( (x+3*w <= winSize.width) && (y+3*h <= winSize.height) )
                        features.push_back( Feature(offset, x, y, w, h ) );
    numFeatures = (int)features.size();
}

所以这里保证每个winSize至少能够容纳3*3个block（四个参数x,y,w,h）

-其次是采取积分图的计算方式。对于3*3区域中的每个block，使用积分图计算像素值之和：

CvLBPEvaluator::Feature::Feature( int offset, int x, int y, int _blockWidth, int _blockHeight )
{
    Rect tr = rect = cvRect(x, y, _blockWidth, _blockHeight);
    CV_SUM_OFFSETS( p[0], p[1], p[4], p[5], tr, offset )
    tr.x += 2*rect.width;
    CV_SUM_OFFSETS( p[2], p[3], p[6], p[7], tr, offset )
    tr.y +=2*rect.height;
    CV_SUM_OFFSETS( p[10], p[11], p[14], p[15], tr, offset )
    tr.x -= 2*rect.width;
    CV_SUM_OFFSETS( p[8], p[9], p[12], p[13], tr, offset )
}

我画了粗略的图表示：

-最后是每个8领域区域与中心区域比较转化成LBP值：

inline uchar CvLBPEvaluator::Feature::calc(const Mat &_sum, size_t y) const
{
    const int* sum = _sum.ptr<int>((int)y);
    int cval = sum[p[5]] - sum[p[6]] - sum[p[9]] + sum[p[10]];

    return (uchar)((sum[p[0]] - sum[p[1]] - sum[p[4]] + sum[p[5]] >= cval ? 128 : 0) |   // 0
        (sum[p[1]] - sum[p[2]] - sum[p[5]] + sum[p[6]] >= cval ? 64 : 0) |    // 1
        (sum[p[2]] - sum[p[3]] - sum[p[6]] + sum[p[7]] >= cval ? 32 : 0) |    // 2
        (sum[p[6]] - sum[p[7]] - sum[p[10]] + sum[p[11]] >= cval ? 16 : 0) |  // 5
        (sum[p[10]] - sum[p[11]] - sum[p[14]] + sum[p[15]] >= cval ? 8 : 0) | // 8
        (sum[p[9]] - sum[p[10]] - sum[p[13]] + sum[p[14]] >= cval ? 4 : 0) |  // 7
        (sum[p[8]] - sum[p[9]] - sum[p[12]] + sum[p[13]] >= cval ? 2 : 0) |   // 6
        (sum[p[4]] - sum[p[5]] - sum[p[8]] + sum[p[9]] >= cval ? 1 : 0));     // 3
}

依据就很简单了：