之前介绍过Hog特征(http://www.rosoo.net/a/201408/17027.html)，也介绍过SVM分类器（http://www.rosoo.net/a/201408/17028.html ）；而本文的目的在于介绍利用Hog特征和SVM分类器来进行行人检测。

在2005年CVPR上，来自法国的研究人员Navneet Dalal 和Bill Triggs提出利用Hog进行特征提取，利用线性SVM作为分类器，从而实现行人检测。而这两位也通过大量的测试发现，Hog+SVM是速度和效果综合平衡性能较好的一种行人检测方法。后来，虽然很多研究人员也提出了很多改进的行人检测算法，但基本都以该算法为基础框架。因此，Hog+SVM也成为一个里程表式的算法被写入到OpenCV中。在OpenCV2.0之后的版本，都有Hog特征描述算子的API，而至于SVM，早在OpenCV1.0版本就已经集成进去了；OpenCV虽然提供了Hog和SVM的API，也提供了行人检测的sample，遗憾的是，OpenCV并没有提供样本训练的sample。这也就意味着，很多人只能用OpenCV自带的已经训练好的分类器来进行行人检测。然而，OpenCV自带的分类器是利用Navneet Dalal和Bill Triggs提供的样本进行训练的，不见得能适用于你的应用场合。因此，针对你的特定应用场景，很有必要进行重新训练得到适合你的分类器。本文的目的，正在于此。

重新训练行人检测的流程：

（1）准备训练样本集合；包括正样本集和负样本集；根据机器学习的基础知识我们知道，要利用机器学习算法进行样本训练，从而得到一个性能优良的分类器，训练样本应该是无限多的，而且训练样本应该覆盖实际应用过程中可能发生的各种情况。（很多朋友，用10来个正样本，10来 个负样本进行训练，之后，就进行测试，发现效果没有想象中的那么好，就开始发牢骚，抱怨。。。对于这些人，我只能抱歉的说，对于机器学习、模式识别的认 识，你还处于没有入门的阶段）；实际应用过程中，训练样本不可能无限多，但无论如何，三五千个正样本，三五千个负样本，应该不是什么难事吧？（如果连这个 都做不到，建议你别搞机器学习，模式识别了；训练素材都没有，怎么让机器学习到足够的信息呢？）

（2）收集到足够的训练样本之后，你需要手动裁剪样本。例如，你想用Hog+SVM来对商业步行街的监控画面中进行行人检测，那么，你就应该用收集到的训练样本集合，手动裁剪画面中的行人（可以写个简单程序，只需要鼠标框选一下，就将框选区域保存下来）。

（3）裁剪得到训练样本之后，将所有正样本放在一个文件夹中；将所有负样本放在另一个文件夹中；并将所有训练样本缩放到同样的尺寸大小。OpenCV自带的例子在训练时，就是将样本缩放为64*128进行训练的；

（4）提取所有正样本的Hog特征；

（5）提取所有负样本的Hog特征；

（6）对所有正负样本赋予样本标签；例如，所有正样本标记为1，所有负样本标记为0；

（7）将正负样本的Hog特征，正负样本的标签，都输入到SVM中进行训练；Dalal在论文中考虑到速度问题，建议采用线性SVM进行训练。这里，不妨也采用线性SVM；

（8）SVM训练之后，将结果保存为文本文件。

（9）线性SVM进行训练之后得到的文本文件里面，有一个数组，叫做support vector，还有一个数组，叫做alpha,有一个浮点数，叫做rho;将alpha矩阵同support vector相乘，注意，alpha*supportVector,将得到一个列向量。之后，再该列向量的最后添加一个元素rho。如此，变得到了一个分类器，利用该分类器，直接替换opencv中行人检测默认的那个分类器（cv::HOGDescriptor::setSVMDetector()），就可以利用你的训练样本训练出来的分类器进行行人检测了。

下面给出样本训练的参考代码：

class Mysvm: public CvSVM 
{ 
public: 
    int get_alpha_count() 
    { 
        return this->sv_total; 
    } 
 
    int get_sv_dim() 
    { 
        return this->var_all; 
    } 
 
    int get_sv_count() 
    { 
        return this->decision_func->sv_count; 
    } 
 
    double* get_alpha() 
    { 
        return this->decision_func->alpha; 
    } 
 
    float** get_sv() 
    { 
        return this->sv; 
    } 
 
    float get_rho() 
    { 
        return this->decision_func->rho; 
    } 
}; 
 
void Train() 
{ 
    char classifierSavePath[256] = "c:/pedestrianDetect-peopleFlow.txt"; 
 
    string positivePath = "E:\\pictures\\train1\\pos\\"; 
    string negativePath = "E:\\pictures\\train1\\neg\\"; 
 
    int positiveSampleCount = 4900; 
    int negativeSampleCount = 6192; 
    int totalSampleCount = positiveSampleCount + negativeSampleCount; 
 
    cout<<"//////////////////////////////////////////////////////////////////"<<endl; 
    cout<<"totalSampleCount: "<<totalSampleCount<<endl; 
    cout<<"positiveSampleCount: "<<positiveSampleCount<<endl; 
    cout<<"negativeSampleCount: "<<negativeSampleCount<<endl; 
 
    CvMat *sampleFeaturesMat = cvCreateMat(totalSampleCount , 1764, CV_32FC1); 
    //64*128的训练样本，该矩阵将是totalSample*3780,64*64的训练样本，该矩阵将是totalSample*1764 
    cvSetZero(sampleFeaturesMat);   
    CvMat *sampleLabelMat = cvCreateMat(totalSampleCount, 1, CV_32FC1);//样本标识   
    cvSetZero(sampleLabelMat);   
 
    cout<<"************************************************************"<<endl; 
    cout<<"start to training positive samples..."<<endl; 
 
    char positiveImgName[256]; 
    string path; 
    for(int i=0; i<positiveSampleCount; i++)   
    {   
        memset(positiveImgName, '\0', 256*sizeof(char)); 
        sprintf(positiveImgName, "%d.jpg", i); 
        int len = strlen(positiveImgName); 
        string tempStr = positiveImgName; 
        path = positivePath + tempStr; 
 
        cv::Mat img = cv::imread(path); 
        if( img.data == NULL ) 
        { 
            cout<<"positive image sample load error: "<<i<<" "<<path<<endl; 
            system("pause"); 
            continue; 
        } 
 
        cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8)
, cv::Size(8,8), 9); 
        vector<float> featureVec;  
 
        hog.compute(img, featureVec, cv::Size(8,8));   
        int featureVecSize = featureVec.size(); 
 
        for (int j=0; j<featureVecSize; j++)   
        {        
            CV_MAT_ELEM( *sampleFeaturesMat, float, i, j ) = featureVec[j];  
        }   
        sampleLabelMat->data.fl[i] = 1; 
    } 
    cout<<"end of training for positive samples..."<<endl; 
 
    cout<<"*********************************************************"<<endl; 
    cout<<"start to train negative samples..."<<endl; 
 
    char negativeImgName[256]; 
    for (int i=0; i<negativeSampleCount; i++) 
    {   
        memset(negativeImgName, '\0', 256*sizeof(char)); 
        sprintf(negativeImgName, "%d.jpg", i); 
        path = negativePath + negativeImgName; 
        cv::Mat img = cv::imread(path); 
        if(img.data == NULL) 
        { 
            cout<<"negative image sample load error: "<<path<<endl; 
            continue; 
        } 
 
        cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8)
, cv::Size(8,8), 9);   
        vector<float> featureVec;  
 
        hog.compute(img,featureVec,cv::Size(8,8));//计算HOG特征 
        int featureVecSize = featureVec.size();   
 
        for ( int j=0; j<featureVecSize; j ++)   
        {   
            CV_MAT_ELEM( *sampleFeaturesMat, float, i + positiveSampleCount, j )
 = featureVec[ j ]; 
        }   
 
        sampleLabelMat->data.fl[ i + positiveSampleCount ] = -1; 
    }   
 
    cout<<"end of training for negative samples..."<<endl; 
    cout<<"********************************************************"<<endl; 
    cout<<"start to train for SVM classifier..."<<endl; 
 
    CvSVMParams params;   
    params.svm_type = CvSVM::C_SVC;   
    params.kernel_type = CvSVM::LINEAR;   
    params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 1000, FLT_EPSILON); 
    params.C = 0.01; 
 
    Mysvm svm; 
    svm.train( sampleFeaturesMat, sampleLabelMat, NULL, NULL, params );
 //用SVM线性分类器训练 
    svm.save(classifierSavePath); 
 
    cvReleaseMat(&sampleFeaturesMat); 
    cvReleaseMat(&sampleLabelMat); 
 
    int supportVectorSize = svm.get_support_vector_count(); 
    cout<<"support vector size of SVM："<<supportVectorSize<<endl; 
    cout<<"************************ end of training for SVM ******************"<<endl; 
 
    CvMat *sv,*alp,*re;//所有样本特征向量  
    sv  = cvCreateMat(supportVectorSize , 1764, CV_32FC1); 
    alp = cvCreateMat(1 , supportVectorSize, CV_32FC1); 
    re  = cvCreateMat(1 , 1764, CV_32FC1); 
    CvMat *res  = cvCreateMat(1 , 1, CV_32FC1); 
 
    cvSetZero(sv); 
    cvSetZero(re); 
   
    for(int i=0; i<supportVectorSize; i++) 
    { 
        memcpy( (float*)(sv->data.fl+i*1764), svm.get_support_vector(i)
, 1764*sizeof(float));    
    } 
 
    double* alphaArr = svm.get_alpha(); 
    int alphaCount = svm.get_alpha_count(); 
 
    for(int i=0; i<supportVectorSize; i++) 
    { 
        alp->data.fl[i] = alphaArr[i]; 
    } 
    cvMatMul(alp, sv, re); 
 
    int posCount = 0; 
    for (int i=0; i<1764; i++) 
    { 
        re->data.fl[i] *= -1; 
    } 
 
    FILE* fp = fopen("c:/hogSVMDetector-peopleFlow.txt","wb"); 
    if( NULL == fp ) 
    { 
        return 1; 
    } 
    for(int i=0; i<1764; i++) 
    { 
        fprintf(fp,"%f \n",re->data.fl[i]); 
    } 
    float rho = svm.get_rho(); 
    fprintf(fp, "%f", rho); 
    cout<<"c:/hogSVMDetector.txt 保存完毕"<<endl;//保存HOG能识别的分类器 
    fclose(fp); 
 
    return 1; 
} 

接着，再给出利用训练好的分类器进行行人检测的参考代码：

void Detect() 
{ 
    CvCapture* cap = cvCreateFileCapture("E:\\02.avi"); 
    if (!cap) 
    { 
        cout<<"avi file load error..."<<endl; 
        system("pause"); 
        exit(-1); 
    } 
 
    vector<float> x; 
    ifstream fileIn("c:/hogSVMDetector-peopleFlow.txt", ios::in); 
    float val = 0.0f; 
    while(!fileIn.eof()) 
    { 
        fileIn>>val; 
        x.push_back(val); 
    } 
    fileIn.close(); 
 
    vector<cv::Rect>  found; 
    cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16)
, cv::Size(8,8), cv::Size(8,8), 9); 
    hog.setSVMDetector(x); 
 
    IplImage* img = NULL; 
    cvNamedWindow("img", 0); 
    while(img=cvQueryFrame(cap)) 
    { 
        hog.detectMultiScale(img, found, 0, cv::Size(8,8), cv::Size(32,32), 1.05, 2); 
        if (found.size() > 0) 
        { 
 
            for (int i=0; i<found.size(); i++) 
            { 
CvRect tempRect = cvRect(found[i].x, found[i].y, found[i].width, found[i].height); 
cvRectangle(img, cvPoint(tempRect.x,tempRect.y), 
cvPoint(tempRect.x+tempRect.width,tempRect.y+tempRect.height),CV_RGB(255,0,0), 2); 
            } 
        } 
    } 
    cvReleaseCapture(&cap); 
}