OpenCV2.4.9源码分析——Support Vector Machines

标签：

引言

本文共分为三个部分，第一个部分介绍SVM的原理，我们全面介绍了5中常用的SVM算法：C-SVC、ν-SVC、单类SVM、ε-SVR和ν-SVR，其中C-SVC和ν-SVC不仅介绍了处理两类分类问题的情况，还介绍处理多类问题的情况。在具体求解SVM过程中，我们介绍了SMO算法和广义SMO算法。第二个部分我们给出了OpenCV中SVM程序的详细注解。第三个部分我们给出了一个基于OpenCV的SVM算法的简单应用实例。

由于这篇文章太长，公式很多，把文章复制到这里，阅读体验会很差，因此，我把这篇文章的完整版上传到了百度文库：

http://wenku.baidu.com/view/5dcd95d8a76e58fafab003fe

大家可以在线阅读，也可以免费下载。在这里，我仅把源码分析部分和应用实例部分复制过来。

源码分析 

OpenCV 2.4.9的SVM程序是基于LibSVMv2.6。LibSVM是由台湾大学林智仁等开发的用于SVM分类和回归的开源机器学习工具包。

struct CvSVMParams
{
    CvSVMParams();
    CvSVMParams( int _svm_type, int _kernel_type,
                 double _degree, double _gamma, double _coef0,
                 double _C, double _nu, double _p,
                 CvMat* _class_weights, CvTermCriteria _term_crit );

    int         svm_type;
    int         kernel_type;
    double      degree; // for poly
    double      gamma;  // for poly/rbf/sigmoid
    double      coef0;  // for poly/sigmoid

    double      C;  // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR
    double      nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR
    double      p; // for CV_SVM_EPS_SVR
    CvMat*      class_weights; // for CV_SVM_C_SVC
    CvTermCriteria term_crit; // termination criteria
};

svm_type表示OpenCV能够实现的SVM的类型：C-SVC、ν-SVC、单类SVM、ε-SVR和ν-SVR，对应的变量分别为：CvSVM::C_SVC、CvSVM::NU_SVC、CvSVM::ONE_CLASS、CvSVM::EPS_SVR和CvSVM::NU_SVR

kernel_type表示OpenCV能够实现的核函数的类型：线性核函数、多项式核函数、高斯核函数和Sigmoid核函数，对应的变量分别为：CvSVM::LINEAR、CvSVM::POLY、CvSVM::RBF和CvSVM::SIGMOID

degree表示多项式核函数（式54）中的参数q

gamma表示多项式核函数（式54）、高斯核函数（式56）和Sigmoid核函数（式57）中的参数γ

coef0表示多项式核函数（式54）和Sigmoid核函数（式57）中的参数p

C表示惩罚参数C

nu表示ν-SVC和ν-SVR的参数ν

p表示ε-SVR的参数ε

class_weights表示不同分类的权值，该值与参数C相乘后，实现了不同分类的不同惩罚力度，该值越大，该类别的误分类数据的惩罚就越大

typedef struct CvTermCriteria
{
    //CV_TERMCRIT_ITER（表示使用迭代次数作为终止条件）和CV_TERMCRIT_EPS（表示使用精度作为终止条件）二值之一，或者二者的组合
    int  type; 
    int  max_iter;    //最大迭代次数
    double  epsilon;    //结果的精确性
}

CvSVM::CvSVM()
{
    decision_func = 0;    //表示决策函数，数据类型为CvSVMDecisionFunc
    class_labels = 0;    //表示分类问题的类标签
    class_weights = 0;    //表示分类问题的类别权重
    storage = 0;    //表示存储空间
    var_idx = 0;    //表示用到的特征属性的索引
    kernel = 0;    //表示核函数，数据类型为CvSVMKernel
    solver = 0;    //表示广义SMO算法的求解，数据类型为类CvSVMSolver
    default_model_name = "my_svm";

    clear();    //清空一些全局变量
}

bool CvSVM::train( const CvMat* _train_data, const CvMat* _responses,
    const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params )
//_train_data表示训练样本数据集
//_responses表示训练样本的响应值
//_var_idx表示真正用到的特征属性的索引
//_sample_idx表示真正用到的训练样本的索引
//_params表示SVM算法所需要的一些参数，如SVM的类型，核函数的类型等
{
    bool ok = false;    //用于该函数的正确返回标识
    CvMat* responses = 0;    //表示样本的响应值
    CvMemStorage* temp_storage = 0;    //暂存
    const float** samples = 0;    //表示完整的训练样本数据

    CV_FUNCNAME( "CvSVM::train" );

    __BEGIN__;
    //svm_type表示SVM类型，sample_count表示训练样本的数量，var_count表示特征属性的数量，sample_size表示训练样本的存储空间的尺寸大小
    int svm_type, sample_count, var_count, sample_size;
    int block_size = 1 << 16;    //先定义一个很大的存储空间的尺寸大小
    //表示拉格朗日乘子α，但我们在实际计算中，已经把5种SVM转换为统一的f(β)形式，因此这里的alpha表示的是式150、式151、式152、式154和式156中β，在后面的程序中，涉及到拉格朗日乘子α的，本质上指的都是β
    double* alpha; 

    clear();    //清空一些全局变量
    //调用set_params函数，为全局变量params赋值（它的数据类型为CvSVMParams，用于表示SVM算法所需的一些参数），并判断params中元素的正确性
    CV_CALL( set_params( _params ));

    svm_type = _params.svm_type;    //表示SVM的类型

    /* Prepare training data and related parameters */
    //调用cvPrepareTrainData函数，为SVM算法准备样本数据，即初始化样本。首先检查样本_train_data，该变量矩阵一定要是CV_ROW_SAMPLE，即矩阵的行表示样本，列表示特征属性；然后赋值样本响应值，如果SVM类型为CvSVM::ONE_CLASS，响应值为0，否则为_responses，并且如果SVM为CvSVM::C_SVC或CvSVM::NU_SVC，响应值_responses的类型为CV_VAR_CATEGORICAL，即为分类，否则为CV_VAR_ORDERED，即为回归；再根据_sample_idx和_var_idx确定那些真正要用到的样本数据以及那些真正要用到的特征属性；最终得到完整的样本数据samples。
    CV_CALL( cvPrepareTrainData( "CvSVM::train", _train_data, CV_ROW_SAMPLE,
                                 svm_type != CvSVM::ONE_CLASS ? _responses : 0,
                                 svm_type == CvSVM::C_SVC ||
                                 svm_type == CvSVM::NU_SVC ? CV_VAR_CATEGORICAL :
                                 CV_VAR_ORDERED, _var_idx, _sample_idx,
                                 false, &samples, &sample_count, &var_count, &var_all,
                                 &responses, &class_labels, &var_idx ));

    //得到训练样本的存储空间大小
    sample_size = var_count*sizeof(samples[0][0]);

    // make the storage block size large enough to fit all
    // the temporary vectors and output support vectors.
    //定义一个足够大的存储空间，用于满足所有的暂存向量和输出支持向量
    block_size = MAX( block_size, sample_count*(int)sizeof(CvSVMKernelRow));
    block_size = MAX( block_size, sample_count*2*(int)sizeof(double) + 1024 );
    block_size = MAX( block_size, sample_size*2 + 1024 );
    //下面三条语句虽然略有不同，但基本上实现的功能都是分配内存空间并初始化
    CV_CALL( storage = cvCreateMemStorage(block_size + sizeof(CvMemBlock) + sizeof(CvSeqBlock)));
    CV_CALL( temp_storage = cvCreateChildMemStorage(storage));
    CV_CALL( alpha = (double*)cvMemStorageAlloc(temp_storage, sample_count*sizeof(double)));
    // create_kernel函数的作用是通过参数params得到参数kernel，即得到核函数
    create_kernel();
    // create_solver函数的作用是实例化CvSVMSolver类，得到参数solver
    create_solver();
    //调用do_train函数，真正完成SVM训练任务，后面给出了该函数的详细讲解
    if( !do_train( svm_type, sample_count, var_count, samples, responses, temp_storage, alpha ))
        EXIT;
    //表示成功得到了SVM模型
    ok = true; // model has been trained succesfully

    __END__;
    //释放一些不再使用的变量和内存空间
    delete solver;
    solver = 0;
    cvReleaseMemStorage( &temp_storage );
    cvReleaseMat( &responses );
    cvFree( &samples );

    if( cvGetErrStatus() < 0 || !ok )
        clear();

    return ok;    //返回
}

bool CvSVM::do_train( int svm_type, int sample_count, int var_count, const float** samples,
                    const CvMat* responses, CvMemStorage* temp_storage, double* alpha )
// svm_type表示SVM算法的类型
// sample_count表示训练样本的数量
// var_count表示特征属性的数量
// samples表示完整的训练样本数据
// responses表示训练样本的响应值
// temp_storage表示训练所需的内存空间
// alpha表示拉格朗日乘子α，实际为式148中的变量β
{
    bool ok = false;    //用于该函数的正确返回标识

    CV_FUNCNAME( "CvSVM::do_train" );

    __BEGIN__;

    CvSVMDecisionFunc* df = 0;    //表示SVM的决策函数
    const int sample_size = var_count*sizeof(samples[0][0]);    //定义样本空间大小
    int i, j, k;

    cvClearMemStorage( storage );    //清空storage内存空间

    if( svm_type == ONE_CLASS || svm_type == EPS_SVR || svm_type == NU_SVR )
    //如果SVM的类型为单类SVM、ε-SVR或ν-SVR
    {
        int sv_count = 0;    //表示支持向量的数量
        //为变量df（决策函数）分配内存空间，并把它的首地址指针指向变量decision_func
        CV_CALL( decision_func = df =
            (CvSVMDecisionFunc*)cvAlloc( sizeof(df[0]) ));

        df->rho = 0;    //初始化决策函数中的变量ρ，ρ实质为偏移量b
        //调用train1函数，该函数作用主要是根据SVM类型的不同，参数solver实现不同的SMO算法函数：类型为C_SVC，实现的是solver->solve_c_svc函数；类型为NU_SVC，实现的是solver->solve_nu_svc函数；类型为ONE_CLASS，实现的是solver->solve_one_class函数；类型为EPS_SVR，实现的是solver->solve_eps_svr函数；类型为NU_SVR，实现的是solver->solve_nu_svr函数。这5个函数在后面都会给出详细的讲解
        //在这里SVM的类型只能为ONE_CLASS、EPS_SVR或NU_SVR
        if( !train1( sample_count, var_count, samples, svm_type == ONE_CLASS ? 0 :
            responses->data.i, 0, 0, temp_storage, alpha, df->rho ))
            EXIT;
        //遍历所有训练样本，统计支持向量的数量，只有αi大于0的向量才是支持向量
        for( i = 0; i < sample_count; i++ )
            sv_count += fabs(alpha[i]) > 0;

        CV_Assert(sv_count != 0);    //确保不能没有支持向量

        sv_total = df->sv_count = sv_count;    //赋值支持向量的数量
        //为支持向量数据sv和拉格朗日乘子df->alpha开辟一块存储空间
        CV_CALL( df->alpha = (double*)cvMemStorageAlloc( storage, sv_count*sizeof(df->alpha[0])) );
        CV_CALL( sv = (float**)cvMemStorageAlloc( storage, sv_count*sizeof(sv[0])));
        //遍历训练样本
        for( i = k = 0; i < sample_count; i++ )
        {
            if( fabs(alpha[i]) > 0 )    //拉格朗日乘子αi大于0
            {
                //得到支持向量的样本数据sv，以及它所对应的αi值df->alpha
                CV_CALL( sv[k] = (float*)cvMemStorageAlloc( storage, sample_size ));
                memcpy( sv[k], samples[i], sample_size );
                df->alpha[k++] = alpha[i];
            }
        }
    }
    else    //SVM类型为C-SVC和ν-SVC，即分类问题
    {
        int class_count = class_labels->cols;    //得到样本的类别数量
        int* sv_tab = 0;    //用于标识某一样本是否为支持向量
        const float** temp_samples = 0;    //表示暂时需要使用的训练样本
        // class_ranges表示分类范围，例如有9个样本，共三类，并且已经按照响应值的大小进行了排序，结果为：1,1,1,2,2,3,3,3,3，则class_ranges[0]=0, class_ranges[1]=3, class_ranges[2]=5, class_ranges[3]=9，因此通过该变量很容易得到每类的样本数，以及它们的分布范围
        int* class_ranges = 0; 
        schar* temp_y = 0;        //表示暂时需要使用的训练样本的分类标签
        //再次确认是分类问题
        assert( svm_type == CvSVM::C_SVC || svm_type == CvSVM::NU_SVC );
        //如果是C_SVC类型，并且初始化了变量params.class_weights
        if( svm_type == CvSVM::C_SVC && params.class_weights )
        {
            const CvMat* cw = params.class_weights;    //为类别权重赋值
            //判断类别权重cw的数据格式是否正确，即cw必须是一维的矩阵形式，即向量，向量的元素数量必须等于分类数量，并且数据类型必须为CV_32FC1或CV_64FC1
            if( !CV_IS_MAT(cw) || (cw->cols != 1 && cw->rows != 1) ||
                cw->rows + cw->cols - 1 != class_count ||
                (CV_MAT_TYPE(cw->type) != CV_32FC1 && CV_MAT_TYPE(cw->type) != CV_64FC1) )
                CV_ERROR( CV_StsBadArg, "params.class_weights must be 1d floating-point vector "
                    "containing as many elements as the number of classes" );
            //把cw赋值给全局变量class_weights
            CV_CALL( class_weights = cvCreateMat( cw->rows, cw->cols, CV_64F ));
            CV_CALL( cvConvert( cw, class_weights ));
            //实现了该等式：class_weights = class_weights × params.C
            CV_CALL( cvScale( class_weights, class_weights, params.C ));
        }
        //为变量df（决策函数）分配内存空间，并把它的首地址指针指向变量decision_func
        CV_CALL( decision_func = df = (CvSVMDecisionFunc*)cvAlloc(
            (class_count*(class_count-1)/2)*sizeof(df[0])));
        //分配内存空间给sv_tab，并清零
        CV_CALL( sv_tab = (int*)cvMemStorageAlloc( temp_storage, sample_count*sizeof(sv_tab[0]) ));
        memset( sv_tab, 0, sample_count*sizeof(sv_tab[0]) );
        //分配内存空间给class_ranges，temp_samples和temp_y
        CV_CALL( class_ranges = (int*)cvMemStorageAlloc( temp_storage,
                            (class_count + 1)*sizeof(class_ranges[0])));
        CV_CALL( temp_samples = (const float**)cvMemStorageAlloc( temp_storage,
                            sample_count*sizeof(temp_samples[0])));
        CV_CALL( temp_y = (schar*)cvMemStorageAlloc( temp_storage, sample_count));

        class_ranges[class_count] = 0;    //清零
        //调用cvSortSamplesByClasses函数，实现了按照响应值对样本进行升序排序，并得到了变量class_ranges
        cvSortSamplesByClasses( samples, responses, class_ranges, 0 );
        //check that while cross-validation there were the samples from all the classes
        //确保class_ranges[class_count]必须大于0，交叉验证时要用到
        if( class_ranges[class_count] <= 0 )
            CV_ERROR( CV_StsBadArg, "While cross-validation one or more of the classes have "
            "been fell out of the sample. Try to enlarge <CvSVMParams::k_fold>" );

        if( svm_type == NU_SVC )    //如果为NU_SVC类型
        {
            // check if nu is feasible
            //得到样本中任意两个类别的样本数，检查ν-SVC中的参数ν是否满足式66的条件
            for(i = 0; i < class_count; i++ )    //遍历样本的所有类别
            {
                int ci = class_ranges[i+1] - class_ranges[i];    //得到第i个类别的样本数量
                for( j = i+1; j< class_count; j++ )    //遍历当前类别以后的所有类别
                {
                    //得到第j个类别的样本数量，第j个类别在第i个类别的排序后面
                    int cj = class_ranges[j+1] - class_ranges[j]; 
                    //如果不满足式66的条件，则退出程序
                    if( params.nu*(ci + cj)*0.5 > MIN( ci, cj ) )
                    {
                        // !!!TODO!!! add some diagnostic
                        EXIT; // exit immediately; will release the model and return NULL pointer
                    }
                }
            }
        }

        // train n*(n-1)/2 classifiers
        //下面的for循环实现了一对一的多类SVC方法
        //得到n*(n-1)/2个SVM分类器，这里的n表示分类数，即class_count，每一个SVM分类器的信息都单独存储在自己的df变量中
        for( i = 0; i < class_count; i++ )    //遍历所有类别
        {
            for( j = i+1; j < class_count; j++, df++ )    //遍历当前分类以后的所有类别
            {
                //si和sj分别表示第i个类别和第j个类别在排序后样本的起始索引值
                //ci和cj分别表示第i个类别和第j个类别的样本数量
                int si = class_ranges[i], ci = class_ranges[i+1] - si;
                int sj = class_ranges[j], cj = class_ranges[j+1] - sj;
                //Cn和Cp分别表示负例和正例的惩罚参数
                double Cp = params.C, Cn = Cp;
                //k1用于计数索引，sv_count表示支持向量的数量
                int k1 = 0, sv_count = 0;

                for( k = 0; k < ci; k++ )    //遍历第i个类别的所有样本
                {
                    temp_samples[k] = samples[si + k];    //第i个类别的所有样本
                    temp_y[k] = 1;    //第i个类别的样本分类标签，设为1
                }

                for( k = 0; k < cj; k++ )    //遍历第j个类别的所有样本
                {
                    temp_samples[ci + k] = samples[sj + k];    //第j个类别的所有样本
                    temp_y[ci + k] = -1;    //第j个类别的样本分类标签，设为-1
                }

                if( class_weights )    //如果应用分类权重class_weights这个参数
                {
                    //Cp和Cn分别为加权后的第i个和第j个类别的惩罚参数
                    Cp = class_weights->data.db[i];
                    Cn = class_weights->data.db[j];
                }
                //调用train1函数，该函数作用主要是根据SVM类型的不同，参数solver实现不同的SMO算法函数：类型为C_SVC，实现的是solver->solve_c_svc函数；类型为NU_SVC，实现的是solver->solve_nu_svc函数；类型为ONE_CLASS，实现的是solver->solve_one_class函数；类型为EPS_SVR，实现的是solver->solve_eps_svr函数；类型为NU_SVR，实现的是solver->solve_nu_svr函数。这5个函数在后面都会给出详细的讲解
                //在这里SVM的类型只能为C_SVC或NU_SVC
                if( !train1( ci + cj, var_count, temp_samples, temp_y,
                             Cp, Cn, temp_storage, alpha, df->rho ))
                    EXIT;
                //遍历第i个和第j个类别的所有样本，得到当前分类器的支持向量数量
                for( k = 0; k < ci + cj; k++ )
                    sv_count += fabs(alpha[k]) > 0;

                df->sv_count = sv_count;    //赋值当前分类器的支持向量数量

                //为拉格朗日乘子df->alpha和支持向量索引df->sv_index开辟一块存储空间
                CV_CALL( df->alpha = (double*)cvMemStorageAlloc( temp_storage,
                                                sv_count*sizeof(df->alpha[0])));
                CV_CALL( df->sv_index = (int*)cvMemStorageAlloc( temp_storage,
                                                sv_count*sizeof(df->sv_index[0])));

                for( k = 0; k < ci; k++ )    //遍历第i个类别的样本
                {
                    if( fabs(alpha[k]) > 0 )    //拉格朗日乘子αi大于0
                    {
                        sv_tab[si + k] = 1;    //标注该样本为支持向量
                        //当前分类器的支持向量在样本序列的索引值
                        df->sv_index[k1] = si + k; 
                        df->alpha[k1++] = alpha[k];    //赋值当前分类器的支持向量αi
                    }
                }

                for( k = 0; k < cj; k++ )    //遍历第j个类别的样本
                {
                    if( fabs(alpha[ci + k]) > 0 )    //拉格朗日乘子αi大于0
                    {
                        sv_tab[sj + k] = 1;    //标注该样本为支持向量
                        //当前分类器的支持向量在样本序列的索引值
                        df->sv_index[k1] = sj + k; 
                        df->alpha[k1++] = alpha[ci + k];    //赋值当前分类器的支持向量αi
                    }
                }
            }
        }    //训练n*(n-1)/2个SVM分类器结束

        // allocate support vectors and initialize sv_tab
        for( i = 0, k = 0; i < sample_count; i++ )    //遍历所有训练样本
        {
            //在前面计算n*(n-1)/2个SVM分类器的过程中，无论对于哪一个分类器，只要某一样本为支持向量，它的sv_tab都为1，在这里sv_tab又被赋值为全部样本下支持向量的计数值，即当前支持向量是全部支持向量的第几个支持向量
            if( sv_tab[i] )
                sv_tab[i] = ++k;
        }

        sv_total = k;    //得到了支持向量的数量
        //为支持向量数据sv分配存储空间
        CV_CALL( sv = (float**)cvMemStorageAlloc( storage, sv_total*sizeof(sv[0])));

        for( i = 0, k = 0; i < sample_count; i++ )    //遍历所有样本
        {
            if( sv_tab[i] )    //如果当前样本是支持向量
            {
                //得到支持向量的样本数据sv
                CV_CALL( sv[k] = (float*)cvMemStorageAlloc( storage, sample_size ));
                memcpy( sv[k], samples[i], sample_size );
                k++;    //计数值累加
            }
        }

        df = (CvSVMDecisionFunc*)decision_func;    //决策函数的指针重新定位

        // set sv pointers
        //重新设置df->sv_index，以前变量df->sv_index[i]表示的是当前分类器的第i个支持向量在当前训练样本序列的索引值，而现在经过下面多重for循环，df->sv_index[i]表示的是当前分类器的第i个支持向量在全部训练样本中所有支持向量的第几个支持向量减1
        //再次遍历n*(n-1)/2个SVM分类器
        for( i = 0; i < class_count; i++ )    //遍历所有分类
        {
            for( j = i+1; j < class_count; j++, df++ )    //遍历当前分类以后的所有分类
            {
                //遍历当前SVM分类器的所有支持向量
                for( k = 0; k < df->sv_count; k++ ) 
                {
                    //为df->sv_index重新赋值
                    df->sv_index[k] = sv_tab[df->sv_index[k]]-1;
                    //确保df->sv_index的值必须小于所有支持向量的总数
                    assert( (unsigned)df->sv_index[k] < (unsigned)sv_total );
                }
            }
        }
    }
    //对于使用线性核函数的SVM来说，即式53，它们的支持向量是呈现线性的，因此只需用一个支持向量就可以代表所有的支持向量，这么可以简化SVM模型，optimize_linear_svm函数就实现了这个功能，该函数的详见讲解见后面
    optimize_linear_svm();
    ok = true;    //返回变量赋值

    __END__;

    return ok;    //函数返回
}

bool CvSVMSolver::solve_c_svc( int _sample_count, int _var_count, const float** _samples, schar* _y,
                               double _Cp, double _Cn, CvMemStorage* _storage,
                               CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
{
    int i;
    //调用create函数，用于设置广义SMO算法的参数，在后面给出该函数的详细讲解
    //对于C-SVC，select_working_set_func函数指针指向select_working_set，calc_rho_func函数指针指向calc_rho，get_row_func函数指针指向get_row_svc，_Cp和_Cn分别表示正例和负例的惩罚参数C
    if( !create( _sample_count, _var_count, _samples, _y, _sample_count,
                 _alpha, _Cp, _Cn, _storage, _kernel, &CvSVMSolver::get_row_svc,
                 &CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho ))
        return false;
    //遍历所有样本，清空alpha数组，赋值b数组
    for( i = 0; i < sample_count; i++ )
    {
        alpha[i] = 0;    //α即为式148中的β，对于C-SVC，β初始化为0
        b[i] = -1;    //b即为式148中的p，对于C-SVC（式150），p为-1
    }
    //调用solve_generic，执行广义SMO算法的迭代过程，该函数在后面给出详细的讲解
    if( !solve_generic( _si ))
        return false;
    //遍历所有样本，使负例的β为负值，当再次用到alpha[i]时，会取绝对值，因此正负无所谓，这么做的好处是可以通过alpha[i]值，就能看出是正例还是负例
    for( i = 0; i < sample_count; i++ )
        alpha[i] *= y[i];

    return true;
}

bool CvSVMSolver::solve_nu_svc( int _sample_count, int _var_count, const float** _samples, schar* _y,
                                CvMemStorage* _storage, CvSVMKernel* _kernel,
                                double* _alpha, CvSVMSolutionInfo& _si )
{
    int i;
    double sum_pos, sum_neg, inv_r;
    //调用create函数，用于设置广义SMO算法的参数，在后面给出该函数的详细讲解
    //对于ν-SVC，select_working_set_func函数指针指向select_working_set_nu_svm，calc_rho_func函数指针指向calc_rho_nu_svm，get_row_func函数指针指向get_row_svc
    if( !create( _sample_count, _var_count, _samples, _y, _sample_count,
                 _alpha, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_svc,
                 &CvSVMSolver::select_working_set_nu_svm, &CvSVMSolver::calc_rho_nu_svm ))
        return false;
    // sum_pos = sum_neg =νN/2，用于初始化β，详见原理部分的解释
    sum_pos = kernel->params->nu * sample_count * 0.5;
    sum_neg = kernel->params->nu * sample_count * 0.5;
    //遍历所有样本
    for( i = 0; i < sample_count; i++ )
    {
        if( y[i] > 0 )    //正例下，β的初始化
        {
            alpha[i] = MIN(1.0, sum_pos);
            sum_pos -= alpha[i];
        }
        else    //负例下，β的初始化
        {
            alpha[i] = MIN(1.0, sum_neg);
            sum_neg -= alpha[i];
        }
        b[i] = 0;    //b即为式148中的p，对于ν-SVC（式151），p为0
    }
    //调用solve_generic，执行广义SMO算法的迭代过程，该函数在后面给出详细的讲解
    if( !solve_generic( _si ))
        return false;
    //_si.r为原理部分式142下面段落中的ρ*，则inv_r就为1/ρ*
    inv_r = 1./_si.r;
    //遍历所有拉格朗日乘子，得到α＝α*/ρ*
    for( i = 0; i < sample_count; i++ )
        alpha[i] *= y[i]*inv_r;

    _si.rho *= inv_r;    //得到b＝b*/ρ*
    _si.obj *= (inv_r*inv_r);    //目标函数也要除以ρ*的平方
    _si.upper_bound_p = inv_r;    //赋值正界
    _si.upper_bound_n = inv_r;    //赋值负界

    return true;
}

bool CvSVMSolver::solve_one_class( int _sample_count, int _var_count, const float** _samples,
                                   CvMemStorage* _storage, CvSVMKernel* _kernel,
                                   double* _alpha, CvSVMSolutionInfo& _si )
{
    int i, n;
    double nu = _kernel->params->nu;    //得到参数ν
    //调用create函数，用于设置广义SMO算法的参数，在后面给出该函数的详细讲解
    //对于单类SVM，select_working_set_func函数指针指向select_working_set，calc_rho_func函数指针指向calc_rho，get_row_func函数指针指向get_row_one_class
    if( !create( _sample_count, _var_count, _samples, 0, _sample_count,
                 _alpha, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_one_class,
                 &CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho ))
        return false;
    //为变量y分配空间
    y = (schar*)cvMemStorageAlloc( storage, sample_count*sizeof(y[0]) );
    n = cvRound( nu*sample_count );    //定义n=[vN]
    //遍历所有样本
    for( i = 0; i < sample_count; i++ )
    {
        y[i] = 1;    //单类SVM的所有样本的响应值都设为1
        b[i] = 0;    //b即为式148中的p，对于ν-SVC（式152），p为0
        alpha[i] = i < n ? 1 : 0;    //初始化β，详见原理部分的解释
    }
    //初始化因四舍五入而产生的小数部分对应的β
    if( n < sample_count )
        alpha[n] = nu * sample_count - n;
    else
        alpha[n-1] = nu * sample_count - (n-1);
    //调用solve_generic，执行广义SMO算法的迭代过程，该函数在后面给出详细的讲解
    return solve_generic(_si);
}

bool CvSVMSolver::solve_eps_svr( int _sample_count, int _var_count, const float** _samples,
                                 const float* _y, CvMemStorage* _storage,
                                 CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
{
    int i;
    //p表示ε-SVR类型的参数ε，kernel_param_c表示惩罚参数C
    double p = _kernel->params->p, kernel_param_c = _kernel->params->C;
    //调用create函数，用于设置广义SMO算法的参数，在后面给出该函数的详细讲解
    //对于ε-SVR，select_working_set_func函数指针指向select_working_set，calc_rho_func函数指针指向calc_rho，get_row_func函数指针指向get_row_svr
    if( !create( _sample_count, _var_count, _samples, 0,
                 _sample_count*2, 0, kernel_param_c, kernel_param_c, _storage, _kernel, &CvSVMSolver::get_row_svr,
                 &CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho ))
        return false;
    //为y和alpha开辟内存空间，它们的长度都为样本数量N的2倍
    y = (schar*)cvMemStorageAlloc( storage, sample_count*2*sizeof(y[0]) );
    alpha = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha[0]) );
    //遍历所有样本，初始化参数
    for( i = 0; i < sample_count; i++ )
    {
        //前N个参数
        alpha[i] = 0;    //β初始化为0，前N个β即为α―
        //b即为式148中的p，对于ε-SVR（式154），前N个p为εeT－yT
        b[i] = p - _y[i];
        //y对应于式154中的z，对于ε-SVR（式154），前N个z为1
        y[i] = 1;
        //后N个参数
        alpha[i+sample_count] = 0;    //β初始化为0，后N个β即为α＋
        //b即为式148中的p，对于ε-SVR（式154），后N个p为εeT+yT
        b[i+sample_count] = p + _y[i];
        //y对应于式154中的z，对于ε-SVR（式154），后N个z为-1
        y[i+sample_count] = -1;
    }
    //调用solve_generic，执行广义SMO算法的迭代过程，该函数在后面给出详细的讲解
    if( !solve_generic( _si ))
        return false;
    //遍历所有样本，计算ε-SVR的决策函数（式105）中核函数前的系数α――α＋
    for( i = 0; i < sample_count; i++ )
        _alpha[i] = alpha[i] - alpha[i+sample_count];

    return true;
}

bool CvSVMSolver::solve_nu_svr( int _sample_count, int _var_count, const float** _samples,
                                const float* _y, CvMemStorage* _storage,
                                CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
{
    int i;
    // kernel_param_c表示惩罚参数C
    double kernel_param_c = _kernel->params->C, sum;
    //调用create函数，用于设置广义SMO算法的参数，在后面给出该函数的详细讲解
    //对于ν-SVR，select_working_set_func函数指针指向select_working_set_nu_svm，calc_rho_func函数指针指向calc_rho_nu_svm，get_row_func函数指针指向get_row_svr
    if( !create( _sample_count, _var_count, _samples, 0,
                 _sample_count*2, 0, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_svr,
                 &CvSVMSolver::select_working_set_nu_svm, &CvSVMSolver::calc_rho_nu_svm ))
        return false;
    //为y和alpha开辟内存空间，它们的长度都为样本数量N的2倍
    y = (schar*)cvMemStorageAlloc( storage, sample_count*2*sizeof(y[0]) );
    alpha = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha[0]) );
    //sum = CνN/2
    sum = kernel_param_c * _kernel->params->nu * sample_count * 0.5;
    //遍历所有样本，初始化参数
    for( i = 0; i < sample_count; i++ )
    {
        //初始化β，详见原理部分的解释
        alpha[i] = alpha[i + sample_count] = MIN(sum, kernel_param_c);
        sum -= alpha[i];
        //b即为式148中的p，对于ν-SVR（式156），前N个p为－yT
        b[i] = -_y[i];
        //y对应于式156中的z，对于ν-SVR（式156），前N个z为1
        y[i] = 1;
        //b即为式148中的p，对于ν-SVR（式156），后N个p为yT
        b[i + sample_count] = _y[i];
        //y对应于式156中的z，对于ν-SVR（式156），后N个z为-1
        y[i + sample_count] = -1;
    }
    //调用solve_generic，执行广义SMO算法的迭代过程，该函数在后面给出详细的讲解
    if( !solve_generic( _si ))
        return false;
    //遍历所有样本，计算ν-SVR的决策函数（式116）中核函数前的系数α――α＋
    for( i = 0; i < sample_count; i++ )
        _alpha[i] = alpha[i] - alpha[i+sample_count];

    return true;
}

bool CvSVMSolver::create( int _sample_count, int _var_count, const float** _samples, schar* _y,
                int _alpha_count, double* _alpha, double _Cp, double _Cn,
                CvMemStorage* _storage, CvSVMKernel* _kernel, GetRow _get_row,
                SelectWorkingSet _select_working_set, CalcRho _calc_rho )
//_sample_count表示训练样本的数量
//_var_count表示特征属性的数量
//_samples表示训练样本的数据集
//_y表示样本的响应值
//_alpha_count表示拉格朗日乘子αi的数量
//_alpha表示拉格朗日乘子αi的值
//_Cp表示对于SVC的正例的惩罚参数
//_Cn表示对于SVC的负例的惩罚参数
//_storage表示一块存储空间
//_kernel表示核函数
//_get_row表示得到矩阵Q的列的首地址
//_select_working_set表示选取工作集βi和βj
//_calc_rho表示计算ρ
{
    bool ok = false;    //该函数返回的标识变量
    int i, svm_type;    //svm_type表示SVM类型

    CV_FUNCNAME( "CvSVMSolver::create" );

    __BEGIN__;

    int rows_hdr_size;    //矩阵Q的列的首地址指针尺寸大小

    clear();    //清空一些全局变量

    sample_count = _sample_count;    //训练样本的数量
    var_count = _var_count;    //特征属性的数量
    samples = _samples;    //训练样本
    y = _y;    //样本响应值
    alpha_count = _alpha_count;    //拉格朗日乘子αi的数量
    alpha = _alpha;    //拉格朗日乘子αi的值
    kernel = _kernel;    //核函数

    C[0] = _Cn;    //负例的惩罚参数
    C[1] = _Cp;    //正例的惩罚参数
    eps = kernel->params->term_crit.epsilon;    //表示式170和式171中的ε
    max_iter = kernel->params->term_crit.max_iter;    //表示最大迭代次数
    storage = cvCreateChildMemStorage( _storage );    //开辟内存空间
    //为变量b，alpha_status，G和buf开辟内存空间
    //b表示式148中的参数p；alpha_status表示拉格朗日乘子αi（实质是βi）的状态，即βi是下界（βi=0），上界（βi=C），还是其他；G表示式149；buf在函数get_row调用时会用到
    b = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(b[0]));
    alpha_status = (schar*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha_status[0]));
    G = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(G[0]));
    for( i = 0; i < 2; i++ )
        buf[i] = (Qfloat*)cvMemStorageAlloc( storage, sample_count*2*sizeof(buf[i][0]) );
    svm_type = kernel->params->svm_type;    //SVM类型
    //函数指针赋值，该函数的作用是选择工作集βi和βj
    select_working_set_func = _select_working_set; 
    //如果函数指针select_working_set_func没有被赋值，则根据SVM的类型来确定该函数
    if( !select_working_set_func )
        //如果是ν-SVC或ν-SVR，select_working_set_func = select_working_set_nu_svm；如果是C-SVC、单类SVM或ε-SVR，select_working_set_func= select_working_set
        select_working_set_func = svm_type == CvSVM::NU_SVC || svm_type == CvSVM::NU_SVR ?
        &CvSVMSolver::select_working_set_nu_svm : &CvSVMSolver::select_working_set;
    //函数指针赋值，作用是计算ρ，即b
    calc_rho_func = _calc_rho; 
    //如果函数指针calc_rho_func没有被赋值，则根据SVM的类型来确定该函数
    if( !calc_rho_func )
        //如果是ν-SVC或ν-SVR，calc_rho_func = calc_rho_nu_svm；如果是C-SVC、单类SVM或ε-SVR，calc_rho_func = calc_rho
        calc_rho_func = svm_type == CvSVM::NU_SVC || svm_type == CvSVM::NU_SVR ?
            &CvSVMSolver::calc_rho_nu_svm : &CvSVMSolver::calc_rho;
    //函数指针赋值，作用是得到矩阵Q的列首地址
    get_row_func = _get_row; 
    //如果函数指针get_row_func没有被赋值，则根据SVM的类型来确定该函数
    if( !get_row_func )
        //如果是ε-SVR或ν-SVR，get_row_func = get_row_svr；如果是C-SVC或ν-SVC，get_row_func = get_row_svc；如果是单类SVM，get_row_func = get_row_one_class
        get_row_func = params->svm_type == CvSVM::EPS_SVR ||
                       params->svm_type == CvSVM::NU_SVR ? &CvSVMSolver::get_row_svr :
                       params->svm_type == CvSVM::C_SVC ||
                       params->svm_type == CvSVM::NU_SVC ? &CvSVMSolver::get_row_svc :
                       &CvSVMSolver::get_row_one_class;
    //定义cache_line_size和cache_size的大小，主要用于get_row_func函数
    cache_line_size = sample_count*sizeof(Qfloat);
    // cache size = max(num_of_samples^2*sizeof(Qfloat)*0.25, 64Kb)
    // (assuming that for large training sets ~25% of Q matrix is used)
    cache_size = MAX( cache_line_size*sample_count/4, CV_SVM_MIN_CACHE_SIZE );

    // the size of Q matrix row headers
    //定义rows_hdr_size大小
    rows_hdr_size = sample_count*sizeof(rows[0]);
    if( rows_hdr_size > storage->block_size )
        CV_ERROR( CV_StsOutOfRange, "Too small storage block size" );
    //定义lru_list变量
    lru_list.prev = lru_list.next = &lru_list;
    rows = (CvSVMKernelRow*)cvMemStorageAlloc( storage, rows_hdr_size );
    memset( rows, 0, rows_hdr_size );

    ok = true;    //设置正确返回变量

    __END__;

    return ok;    //返回
}

bool CvSVMSolver::solve_generic( CvSVMSolutionInfo& si )
{
    int iter = 0;    //用于记录迭代的次数
    int i, j, k;

    // 1. initialize gradient and alpha status
    //遍历所有拉格朗日乘子αi，得到αi的状态，程序中的α实质是式148的β
    for( i = 0; i < alpha_count; i++ ) 
    {
/****************
#define update_alpha_status(i)     alpha_status[i] = (schar)(alpha[i] >= get_C(i) ? 1 : alpha[i] <= 0 ? -1 : 0)
****************/
        //宏定义update_alpha_status表示得到拉格朗日乘子αi的状态：当αi等于惩罚参数C时，alpha_status[i]等于1；当αi=0时，alpha_status[i]等于-1；当0<αi<C时，alpha_status[i]等于0。其中宏定义get_C表示得到正例和负例的惩罚参数C
        update_alpha_status(i);
        G[i] = b[i];    //式149，先初始化梯度为p，数组b已经被赋值为向量p
        if( fabs(G[i]) > 1e200 )    //确保变量G[i]不能过大
            return false;
    }

    for( i = 0; i < alpha_count; i++ )    //遍历所有拉格朗日乘子αi
    {
/*******************
#define is_lower_bound(i) (alpha_status[i] < 0)
#define is_upper_bound(i) (alpha_status[i] > 0)
*******************/
        //宏定义is_lower_bound用于表示αi是否为下界，即是否等于0，如果等于0，则is_lower_bound为1，否则为0；宏定义is_upper_bound用于表示αi是否为上界，即是否等于C，如果等于C，则is_upper_bound为1，否则为0
        if( !is_lower_bound(i) )    //如果αi≠0
        {
            //函数get_row表示得到矩阵Q的第i列首地址，Q即为式148中的Q，虽然Qij都可以表示为zizjK(xi, xj)，但不同类型的SVM的zi含义不同，因此在get_row函数内，先通过get_row_base函数得到核函数K(xi, xj)的第i列，然后再调用get_row_func函数，前面已经分析过了，不同的SVM，get_row_func函数的函数指针会指向不同的函数
            const Qfloat *Q_i = get_row( i, buf[0] );
            double alpha_i = alpha[i];    //得到αi值，实质为βi
            //计算式149，得到f(β)的梯度向量▽f(β)，G[j]表示▽f(β)向量的第j个元素
            for( j = 0; j < alpha_count; j++ )
                G[j] += alpha_i*Q_i[j];
        }
    }

    // 2. optimization loop
    for(;;)    //优化β的迭代死循环
    {
        // Q_i和Q_j分别表示式148中的Q的第i列和第j列的首地址
        const Qfloat *Q_i, *Q_j;
        //C_i和C_j分别表示第i个和第j个样本所对应的惩罚参数C，如图10所示
        double C_i, C_j;
        //old_alpha_i、old_alpha_j、alpha_i和alpha_j分别表示式161中βik、βjk、βinew和βjnew
        double old_alpha_i, old_alpha_j, alpha_i, alpha_j;
        // delta_alpha_i和delta_alpha_j分别表示每次迭代前后的βi的差值和βj的差值
        double delta_alpha_i, delta_alpha_j;

#ifdef _DEBUG
        for( i = 0; i < alpha_count; i++ )
        {
            if( fabs(G[i]) > 1e+300 )
                return false;

            if( fabs(alpha[i]) > 1e16 )
                return false;
        }
#endif
        //当满足终止条件或超过最大迭代次数，则退出迭代死循环
        // select_working_set_func函数用于工作集βi和βj的选取，如果该函数的返回值为1，则表示终止迭代循环，max_iter表示最大迭代次数。前面已经分析过，不同的SVM，select_working_set_func函数的函数指针会指向不同的函数，第一类SVM指向的是select_working_set函数，第二类SVM指向的是select_working_set_nu_svm，这两个函数在后面都会给出详细的讲解
        if( (this->*select_working_set_func)( i, j ) != 0 || iter++ >= max_iter )
            break;
        //分别得到矩阵Q的第i列和第j列的首地址
        Q_i = get_row( i, buf[0] );
        Q_j = get_row( j, buf[1] );
        //分别得到第i个和第j个样本的C值
        C_i = get_C(i);
        C_j = get_C(j);
        //分别得到第i个和第j个样本的β值
        alpha_i = old_alpha_i = alpha[i];
        alpha_j = old_alpha_j = alpha[j];

        if( y[i] != y[j] )    //zi≠zj时，式160中的第1行
        {
            double denom = Q_i[i]+Q_j[j]+2*Q_i[j];    //得到式160中第1行的aij
            //得到式162中分式的分子部分，即－▽if(β)－▽jf(β)
            double delta = (-G[i]-G[j])/MAX(fabs(denom),FLT_EPSILON);
            double diff = alpha_i - alpha_j;    //得到式164中的T
            //得到式162中的βinew和βjnew
            alpha_i += delta;
            alpha_j += delta;
            //如图10(a)，限制β的值在矩形区域内
            if( diff > 0 && alpha_j < 0 )    //区域Ⅲ
            {
                alpha_j = 0;
                alpha_i = diff;
            }
            else if( diff <= 0 && alpha_i < 0 )    //区域Ⅳ
            {
                alpha_i = 0;
                alpha_j = -diff;
            }

            if( diff > C_i - C_j && alpha_i > C_i )    //区域Ⅰ
            {
                alpha_i = C_i;
                alpha_j = C_i - diff;
            }
            else if( diff <= C_i - C_j && alpha_j > C_j )    //区域Ⅱ
            {
                alpha_j = C_j;
                alpha_i = C_j + diff;
            }
        }
        else    //zi＝zj时，式160中的第2行
        {
            double denom = Q_i[i]+Q_j[j]-2*Q_i[j];    //得到式160中第2行的ats
            //得到式163中分式的分子部分，即▽if(β)－▽jf(β)
            double delta = (G[i]-G[j])/MAX(fabs(denom),FLT_EPSILON);
            double sum = alpha_i + alpha_j;    //得到式165中的S
            //得到式163中的βinew和βjnew
            alpha_i -= delta;
            alpha_j += delta;
            //如图10(b)，限制β的值在矩形区域内
            if( sum > C_i && alpha_i > C_i )    //区域Ⅰ
            {
                alpha_i = C_i;
                alpha_j = sum - C_i;
            }
            else if( sum <= C_i && alpha_j < 0)    //区域Ⅱ
            {
                alpha_j = 0;
                alpha_i = sum;
            }

            if( sum > C_j && alpha_j > C_j )    //区域Ⅲ
            {
                alpha_j = C_j;
                alpha_i = sum - C_j;
            }
            else if( sum <= C_j && alpha_i < 0 )    //区域Ⅳ
            {
                alpha_i = 0;
                alpha_j = sum;
            }
        }

        // update alpha
        //更新βi和βj，以及它们的状态
        alpha[i] = alpha_i;
        alpha[j] = alpha_j;
        update_alpha_status(i);
        update_alpha_status(j);

        // update G
        //得到迭代前后βi的差值和βj的差值
        delta_alpha_i = alpha_i - old_alpha_i;
        delta_alpha_j = alpha_j - old_alpha_j;
        //更新▽f(β)
        for( k = 0; k < alpha_count; k++ )
            G[k] += Q_i[k]*delta_alpha_i + Q_j[k]*delta_alpha_j;
    }    //迭代优化结束

    // calculate rho
    // calc_rho_func函数计算ρ，即决策函数中的参数b。前面已经分析过，不同类型的SVM，calc_rho_func函数的函数指针会指向不同的函数，第一类SVM指向的是calc_rho函数，第二类SVM指向的是calc_rho_nu_svm，这两个函数在后面都会给出详细的讲解
    (this->*calc_rho_func)( si.rho, si.r );

    // calculate objective value
    //计算式148，得到目标函数f(β)的值
    //f(β)＝0.5×[βT×(▽f(β)+p)]＝0.5×[βT×(Qβ＋p)+p)]＝0.5×βTQβ＋pTβ
    for( i = 0, si.obj = 0; i < alpha_count; i++ )
        si.obj += alpha[i] * (G[i] + b[i]);

    si.obj *= 0.5;

    si.upper_bound_p = C[1];    //正例的惩罚参数C
    si.upper_bound_n = C[0];    //负例的惩罚参数C

    return true;
}

bool
CvSVMSolver::select_working_set( int& out_i, int& out_j )
//out_i和out_j分别表示βi和βj
{
    // return i,j which maximize -grad(f)^T d , under constraint
    // if alpha_i == C, d != +1
    // if alpha_i == 0, d != -1
    //定义一个最大值
    double Gmax1 = -DBL_MAX;        // max { -grad(f)_i * d | y_i*d = +1 }
    int Gmax1_idx = -1;    //初始化i=-1
    //定义一个最大值
    double Gmax2 = -DBL_MAX;        // max { -grad(f)_i * d | y_i*d = -1 }
    int Gmax2_idx = -1;    //初始化j＝－1

    int i;
    //遍历所有β
    for( i = 0; i < alpha_count; i++ )
    {
        double t;

        if( y[i] > 0 )    // y = +1，即式166中的zt＝1
        {
            if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 )  // d = +1
            //表示满足式166中的第一行max中的第一项
            {
                Gmax1 = t;    //更新最大值
                Gmax1_idx = i;    //得到工作集中第一个βi的索引值i
            }
            if( !is_lower_bound(i) && (t = G[i]) > Gmax2 )  // d = -1
            //表示满足式166中的第二行max中的第二项
            {
                Gmax2 = t;    //更新最大值
                Gmax2_idx = i;    //得到工作集中第二个βj的索引值j
            }
        }
        else        // y = -1，即式166中的zt＝－1
        {
            if( !is_upper_bound(i) && (t = -G[i]) > Gmax2 )  // d = +1
            //表示满足式166中的第二行max中的第一项
            {
                Gmax2 = t;    //更新最大值
                Gmax2_idx = i;    //得到工作集中第二个βj的索引值j
            }
            if( !is_lower_bound(i) && (t = G[i]) > Gmax1 )  // d = -1
            //表示满足式166中的第一行max中的第二项
            {
                Gmax1 = t;    //更新最大值
                Gmax1_idx = i;    //得到工作集中第一个βi的索引值i
            }
        }
    }
    //为βi和βj赋值
    out_i = Gmax1_idx;
    out_j = Gmax2_idx;
    //式170，判断迭代是否终止
    return Gmax1 + Gmax2 < eps;
}

bool
CvSVMSolver::select_working_set_nu_svm( int& out_i, int& out_j )
{
    // return i,j which maximize -grad(f)^T d , under constraint
    // if alpha_i == C, d != +1
    // if alpha_i == 0, d != -1
    //定义一个最大值
    double Gmax1 = -DBL_MAX;    // max { -grad(f)_i * d | y_i = +1, d = +1 }
    int Gmax1_idx = -1;    //初始化ip

    double Gmax2 = -DBL_MAX;    // max { -grad(f)_i * d | y_i = +1, d = -1 }
    int Gmax2_idx = -1;    //初始化jp

    double Gmax3 = -DBL_MAX;    // max { -grad(f)_i * d | y_i = -1, d = +1 }
    int Gmax3_idx = -1;    //初始化in

    double Gmax4 = -DBL_MAX;    // max { -grad(f)_i * d | y_i = -1, d = -1 }
    int Gmax4_idx = -1;    //初始化jn

    int i;
    //遍历所有β
    for( i = 0; i < alpha_count; i++ )
    {
        double t;

        if( y[i] > 0 )    // y == +1
        //第一次由zi＝1这个条件得到ip和jp
        {
            if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 )  // d = +1
            //式167的第一行公式
            {
                Gmax1 = t;    //更新最大值
                Gmax1_idx = i;    //得到ip
            }
            if( !is_lower_bound(i) && (t = G[i]) > Gmax2 )  // d = -1
            //式167的第二行公式
            {
                Gmax2 = t;    //更新最大值
                Gmax2_idx = i;    //得到jp
            }
        }
        else        // y == -1
        //第二次由zi＝－1这个条件得到in和jn
        {
            if( !is_upper_bound(i) && (t = -G[i]) > Gmax3 )  // d = +1
            //式168的第一行公式
            {
                Gmax3 = t;    //更新最大值
                Gmax3_idx = i;    //得到in
            }
            if( !is_lower_bound(i) && (t = G[i]) > Gmax4 )  // d = -1
            //式168的第二行公式
            {
                Gmax4 = t;    //更新最大值
                Gmax4_idx = i;    //得到jn
            }
        }
    }
    //式171，判断迭代是否终止
    if( MAX(Gmax1 + Gmax2, Gmax3 + Gmax4) < eps )
        return 1;
    //得到最终的工作集βi和βj
    if( Gmax1 + Gmax2 > Gmax3 + Gmax4 )    //式169的第一行公式
    {
        out_i = Gmax1_idx;
        out_j = Gmax2_idx;
    }
    else    //式169的第二行公式
    {
        out_i = Gmax3_idx;
        out_j = Gmax4_idx;
    }
    return 0;
}

void
CvSVMSolver::calc_rho( double& rho, double& r )
{
    int i, nr_free = 0;
    double ub = DBL_MAX, lb = -DBL_MAX, sum_free = 0;
    //遍历所有β
    for( i = 0; i < alpha_count; i++ )
    {
        double yG = y[i]*G[i];    //式172的分子中的一项

        if( is_lower_bound(i) )    //βi＝0
        {
            if( y[i] > 0 )
                ub = MIN(ub,yG);    //式175中min的前一项内容
            else
                lb = MAX(lb,yG);    //式174中max的前一项内容
        }
        else if( is_upper_bound(i) )    //βi＝C
        {
            if( y[i] < 0)
                ub = MIN(ub,yG);    //式175中min的后一项内容
            else
                lb = MAX(lb,yG);    //式174中max的后一项内容
        }
        else    //0＜βi＜C
        {
            ++nr_free;    //式172的分母，即计数
            sum_free += yG;    //式172的分子求和
        }
    }
    //如果nr_free大于0，说明有样本的βi的值在0和C之间，则利用式172计算ρ；否则利用式173计算ρ
    rho = nr_free > 0 ? sum_free/nr_free : (ub + lb)*0.5;
    r = 0;
}

void
CvSVMSolver::calc_rho_nu_svm( double& rho, double& r )
{
    int nr_free1 = 0, nr_free2 = 0;
    double ub1 = DBL_MAX, ub2 = DBL_MAX;
    double lb1 = -DBL_MAX, lb2 = -DBL_MAX;
    double sum_free1 = 0, sum_free2 = 0;
    double r1, r2;

    int i;
    //遍历所有β
    for( i = 0; i < alpha_count; i++ )
    {
        double G_i = G[i];    //得到▽if(β)
        if( y[i] > 0 )    
        {
            if( is_lower_bound(i) )    //式178分子中的第二项
                ub1 = MIN( ub1, G_i );
            else if( is_upper_bound(i) )    //式178分子中的第一项
                lb1 = MAX( lb1, G_i );
            else    //式176
            {
                ++nr_free1;    //式176的分母，即计数
                sum_free1 += G_i;    //式176的分子，求和
            }
        }
        else
        {
            if( is_lower_bound(i) )    //式179分子中的第二项
                ub2 = MIN( ub2, G_i );
            else if( is_upper_bound(i) )    //式179分子中的第一项
                lb2 = MAX( lb2, G_i );
            else    //式177
            {
                ++nr_free2;    //式177的分母，即计数
                sum_free2 += G_i;    //式177的分子，求和
            }
        }
    }
    //如果nr_free1大于0，说明在zi＝1下有样本的βi的值在0和C之间，则利用式176计算r1；否则利用式178计算r1
    r1 = nr_free1 > 0 ? sum_free1/nr_free1 : (ub1 + lb1)*0.5;
    //如果nr_free2大于0，说明在zi＝－1下有样本的βi的值在0和C之间，则利用式177计算r2；否则利用式179计算r2
    r2 = nr_free2 > 0 ? sum_free2/nr_free2 : (ub2 + lb2)*0.5;

    rho = (r1 - r2)*0.5;    //式180，得到－b
    r = (r1 + r2)*0.5;    //式180，得到ρ，该变量用于ν-SVC
}

void CvSVM::optimize_linear_svm()
{
    // we optimize only linear SVM: compress all the support vectors into one.
    if( params.kernel_type != LINEAR )    //判断是否为线性核函数
        return;
    //如果是SVC，则得到分类的数量；如果是单类SVM，则class_count为1；如果是SVR，则class_count为0
    int class_count = class_labels ? class_labels->cols :
            params.svm_type == CvSVM::ONE_CLASS ? 1 : 0;
    // df_count为决策函数的数量，在多个分类的SVC中，该值为class_count*(class_count-1)/2，其他情况该值为1
    int i, df_count = class_count > 1 ? class_count*(class_count-1)/2 : 1;
    CvSVMDecisionFunc* df = decision_func;    //赋值决策函数指针
    //遍历所有的决策函数，如果当前决策函数的支持向量的数量不为1，则退出该循环
    for( i = 0; i < df_count; i++ )
    {
        int sv_count = df[i].sv_count;
        if( sv_count != 1 )
            break;
    }

    // if every decision functions uses a single support vector;
    // it's already compressed. skip it then.
    //i为前面for循环中的循环次数索引，如果i等于df_count，说明所有的决策函数中的支持向量的数量都为1个，所以无需再优化处理，则退出该函数
    if( i == df_count )
        return;

    int var_count = get_var_count();    //得到特征属性的数量
    cv::AutoBuffer<double> vbuf(var_count);    //为vbuf分配内存
    double* v = vbuf;    //赋值
    //为new_sv变量分配内存，new_sv表示每个决策函数优化处理后的新的支持向量
    float** new_sv = (float**)cvMemStorageAlloc(storage, df_count*sizeof(new_sv[0]));
    //遍历所有的决策函数，优化处理每个决策函数
    for( i = 0; i < df_count; i++ )
    {
        //为第i个决策函数的新的支持向量new_sv[i]分配内存
        new_sv[i] = (float*)cvMemStorageAlloc(storage, var_count*sizeof(new_sv[i][0]));
        float* dst = new_sv[i];    //赋值
        memset(v, 0, var_count*sizeof(v[0]));    //清零
        int j, k, sv_count = df[i].sv_count;
        //遍历当前决策函数的所有支持向量
        for( j = 0; j < sv_count; j++ )
        {
            //得到当前支持向量所对应的样本
            const float* src = class_count > 1 && df[i].sv_index ? sv[df[i].sv_index[j]] : sv[j];
            double a = df[i].alpha[j];    //得到当前支持向量的αi
            //遍历该样本的所有特征属性，得到一个新的支持向量v＝∑ixiαi
            for( k = 0; k < var_count; k++ )
                v[k] += src[k]*a;
        }
        for( k = 0; k < var_count; k++ )
            dst[k] = (float)v[k];    //赋值
        df[i].sv_count = 1;    //此时，只有一个支持向量v
        df[i].alpha[0] = 1.;    //根据约束条件，只有一个支持向量时，α=1
        if( class_count > 1 && df[i].sv_index )
            df[i].sv_index[0] = i;    //索引赋值
    }

    sv = new_sv;    //新的支持向量
    //支持向量的数量，它等于决策函数的数量，因为此时每个决策函数只有一个支持向量
    sv_total = df_count; 
}

在前面应用get_row函数计算矩阵Q（即式148中的Q=z_iz_jK(x_i,x_j)）的第i列首地址时，涉及到计算核函数K(x_i,x_j)，即调用calc函数。在用于SVM对样本进行预测时，需要计算决策函数，此时也需要计算核函数K(x_i,x_j)。但两者还是有区别的，在计算Q时，要用到所有的样本，而计算决策函数时，只需要用到支持向量即可，也就是说在计算Q时，用于表示支持向量的变量用全体样本来替代。

下面我们就来介绍calc函数：

void CvSVMKernel::calc( int vcount, int var_count, const float** vecs,
                        const float* another, Qfloat* results )
// vcount表示支持向量的数量
// var_count表示样本的特征属性的数量
// vecs表示具体的支持向量
// another表示核函数所需要的另一个样本数据，如果是预测，则为预测样本
//results表示最终的核函数结果
{
    const Qfloat max_val = (Qfloat)(FLT_MAX*1e-3);
    int j;
    //调用calc_func函数
    //在实例化CvSVMKernel时，会通过create函数为calc_func的函数指针赋值：当为线性核函数（式53）时，calc_func函数为calc_linear；当为多项式核函数（式54）时，calc_func函数为calc_poly；当为高斯核函数（式56）时，calc_func函数为calc_rbf；当为Sigmoid核函数（式57）时，calc_func函数为calc_sigmoid。这4个函数在后面都有介绍
    (this->*calc_func)( vcount, var_count, vecs, another, results );
    //遍历支持向量，确保核函数的向量中不能有太大的元素
    for( j = 0; j < vcount; j++ )
    {
        if( results[j] > max_val )
            results[j] = max_val;
    }
}

void CvSVMKernel::calc_linear( int vcount, int var_count, const float** vecs,
                               const float* another, Qfloat* results )
{
    //调用calc_non_rbf_base函数，计算α xi·xj＋β，对于线性核函数来说，α＝1，β＝0，该函数在后面会给出讲解
    calc_non_rbf_base( vcount, var_count, vecs, another, results, 1, 0 );
}

void CvSVMKernel::calc_poly( int vcount, int var_count, const float** vecs,
                             const float* another, Qfloat* results )
{
    CvMat R = cvMat( 1, vcount, QFLOAT_TYPE, results );
    //调用calc_non_rbf_base函数，计算α xi·xj＋β，对于多项式核函数（式54）来说，α＝γ，β＝p，γ为params->gamma，p为params->coef0，该函数在后面会给出讲解
    calc_non_rbf_base( vcount, var_count, vecs, another, results, params->gamma, params->coef0 );
    //最终得到式54，式中的q为params->degree
    if( vcount > 0 )
        cvPow( &R, &R, params->degree );
}

void CvSVMKernel::calc_sigmoid( int vcount, int var_count, const float** vecs,
                                const float* another, Qfloat* results )
{
    int j;
    //调用calc_non_rbf_base函数，计算－2(γ xi·xj＋p)，对于Sigmoid核函数（式57）来说，α＝－2γ，β＝－2p，γ为params->gamma，p为params->coef0，该函数在后面会给出讲解
    calc_non_rbf_base( vcount, var_count, vecs, another, results,
                       -2*params->gamma, -2*params->coef0 );
    // TODO: speedup this
    for( j = 0; j < vcount; j++ )    //计算式57
    {
        Qfloat t = results[j];    //得到e的指数部分，即－2(γ xi·xj＋p)
        double e = exp(-fabs(t));    //得到e指数
        //得到双曲正切
        if( t > 0 )
            results[j] = (Qfloat)((1. - e)/(1. + e));
        else
            results[j] = (Qfloat)((e - 1.)/(e + 1.));
    }
}

void CvSVMKernel::calc_rbf( int vcount, int var_count, const float** vecs,
                            const float* another, Qfloat* results )
{
    //定义一个矩阵，作为高斯核函数的结果输出
    CvMat R = cvMat( 1, vcount, QFLOAT_TYPE, results ); 
    double gamma = -params->gamma;    //得到式55中的参数－γ
    int j, k;
    //遍历所有支持向量
    for( j = 0; j < vcount; j++ )
    {
        const float* sample = vecs[j];    //得到当前支持向量，即样本数据
        double s = 0;
        //以4个为一个单位，遍历当前样本的特征属性，计算||xi－xj||
        for( k = 0; k <= var_count - 4; k += 4 )
        {
            double t0 = sample[k] - another[k];
            double t1 = sample[k+1] - another[k+1];

            s += t0*t0 + t1*t1;

            t0 = sample[k+2] - another[k+2];
            t1 = sample[k+3] - another[k+3];

            s += t0*t0 + t1*t1;
        }
        //计算不足4个的，也就是剩余的特征属性的||xi－xj||
        for( ; k < var_count; k++ )
        {
            double t0 = sample[k] - another[k];
            s += t0*t0;
        }
        results[j] = (Qfloat)(s*gamma);    //得到－γ||xi－xj||
    }

    if( vcount > 0 )
        cvExp( &R, &R );    //得到最终的结果，即式56
}

void CvSVMKernel::calc_non_rbf_base( int vcount, int var_count, const float** vecs,
                                     const float* another, Qfloat* results,
                                     double alpha, double beta )
{
    int j, k;
    //遍历所有支持向量
    for( j = 0; j < vcount; j++ )
    {
        const float* sample = vecs[j];    //得到当前的支持向量，即样本数据
        double s = 0;
        //以4个为一个单位，遍历当前样本的特征属性，计算xi·xj
        for( k = 0; k <= var_count - 4; k += 4 )
            s += sample[k]*another[k] + sample[k+1]*another[k+1] +
                 sample[k+2]*another[k+2] + sample[k+3]*another[k+3];
        //计算不足4个的，也就是剩余的特征属性的xi·xj
        for( ; k < var_count; k++ )
            s += sample[k]*another[k];
        //最终得到α xi·xj＋β
        results[j] = (Qfloat)(s*alpha + beta);
    }
}

下面介绍SVM预测样本函数predict。该函数有许多形式，如：

float CvSVM::predict(const Mat& sample,bool returnDFVal=false )

float CvSVM::predict(const CvMat* sample,bool returnDFVal=false )

float CvSVM::predict(const CvMat* samples,CvMat* results)

其中，sample表示需要预测的样本数据，returnDFVal定义该函数的返回类型，为true，并且是两类分类问题时，该函数返回决策函数中sgn函数内的具体值，否则该函数返回分类标签（SVC），或返回估计函数（SVR），results表示相对应样本的预测输出，如果只预测一个样本，则该函数返回预测结果，如果预测多个样本，则必须使用results参数来返回预测结果。

float CvSVM::predict( const float* row_sample, int row_len, bool returnDFVal ) const
// row_sample表示待预测的一个样本
// row_len表示该样本的特征属性的数量
//函数返回为预测结果
{
    assert( kernel );    //确保SVM模型中核函数数据形式的正确
    assert( row_sample );    //确保预测样本数据形式的正确

    int var_count = get_var_count();    //得到SVM模型中样本的特征属性的数量
    //确保SVM模型的样本和预测样本的特征属性的数量相同
    assert( row_len == var_count );
    (void)row_len;
    //如果是SVC，class_count为分类的数量；如果是单类SVM，class_count为1；如果是SVR，class_count为0
    int class_count = class_labels ? class_labels->cols :
                  params.svm_type == ONE_CLASS ? 1 : 0;

    float result = 0;    //表示预测结果
    cv::AutoBuffer<float> _buffer(sv_total + (class_count+1)*2);    //分配一块内存空间
    float* buffer = _buffer;

    if( params.svm_type == EPS_SVR ||    //ε-SVR类型
        params.svm_type == NU_SVR ||    //ν-SVR类型
        params.svm_type == ONE_CLASS )    //单类SVM类型
    {
        CvSVMDecisionFunc* df = (CvSVMDecisionFunc*)decision_func;    //得到决策函数
        int i, sv_count = df->sv_count;    //sv_count表示支持向量的数量
        double sum = -df->rho;    //得到决策函数的参数b
        //计算核函数
        kernel->calc( sv_count, var_count, (const float**)sv, row_sample, buffer );
        //遍历所有的支持向量，由决策函数得到最终的预测结果
        for( i = 0; i < sv_count; i++ )
            sum += buffer[i]*df->alpha[i];
        //如果是单类SVM，则对sum取sgn，即式90
        result = params.svm_type == ONE_CLASS ? (float)(sum > 0) : (float)sum;
    }
    else if( params.svm_type == C_SVC ||    //C-SVC类型
             params.svm_type == NU_SVC )    //ν-SVC类型
    {
        CvSVMDecisionFunc* df = (CvSVMDecisionFunc*)decision_func;    //得到决策函数
        int* vote = (int*)(buffer + sv_total);    //表示记录投票结果
        int i, j, k;
        //为vote开辟内存并清零
        memset( vote, 0, class_count*sizeof(vote[0]));
        //计算核函数
        kernel->calc( sv_total, var_count, (const float**)sv, row_sample, buffer );
        double sum = 0.;

        for( i = 0; i < class_count; i++ )    //遍历所有分类类别
        {
            //对不重复的两个分类进行比较
            for( j = i+1; j < class_count; j++, df++ )
            {
                sum = -df->rho;    //得到决策函数的参数b
                int sv_count = df->sv_count;
                //遍历所有的支持向量，由决策函数得到最终的预测结果
                for( k = 0; k < sv_count; k++ )
                    sum += df->alpha[k]*buffer[df->sv_index[k]];

                vote[sum > 0 ? i : j]++;    //统计投票结果
            }
        }
        //遍历所有分类类别，得到票数最多的那个分类类别
        for( i = 1, k = 0; i < class_count; i++ )
        {
            if( vote[i] > vote[k] )
                k = i;    //k表示票数最多的那个分类类别
        }
        //如果returnDFVal为true，并且是2类的SVM，则result为决策函数中sgn函数内的值，否则result为预测的分类标签
        result = returnDFVal && class_count == 2 ? (float)sum : (float)(class_labels->data.i[k]);
    }
    else    //不是以上5种SVM类型，则提示错误信息
        CV_Error( CV_StsBadArg, "INTERNAL ERROR: Unknown SVM type, "
                                "the SVM structure is probably corrupted" );

    return result;    //返回预测结果
}

应用实例

#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/ml/ml.hpp"

#include <iostream>
using namespace cv;
using namespace std;

int main( int argc, char** argv )
{	
    //60个训练样本
    double trainingData[60][4]={{5.1,3.5,1.4,0.2}, {4.9,3.0,1.4,0.2}, {4.7,3.2,1.3,0.2},
                            {4.6,3.1,1.5,0.2}, {5.0,3.6,1.4,0.2}, {5.4,3.9,1.7,0.4},
                            {4.6,3.4,1.4,0.3}, {5.0,3.4,1.5,0.2}, {4.4,2.9,1.4,0.2},
                            {4.9,3.1,1.5,0.1}, {5.4,3.7,1.5,0.2}, {4.8,3.4,1.6,0.2},
                            {4.8,3.0,1.4,0.1}, {4.3,3.0,1.1,0.1}, {5.8,4.0,1.2,0.2},
                            {5.7,4.4,1.5,0.4}, {5.4,3.9,1.3,0.4}, {5.1,3.5,1.4,0.3},
                            {5.7,3.8,1.7,0.3}, {5.1,3.8,1.5,0.3},
                            {7.0,3.2,4.7,1.4}, {6.4,3.2,4.5,1.5}, {6.9,3.1,4.9,1.5},
                            {5.5,2.3,4.0,1.3}, {6.5,2.8,4.6,1.5}, {5.7,2.8,4.5,1.3},
                            {6.3,3.3,4.7,1.6}, {4.9,2.4,3.3,1.0}, {6.6,2.9,4.6,1.3},
                            {5.2,2.7,3.9,1.4}, {5.0,2.0,3.5,1.0}, {5.9,3.0,4.2,1.5},
                            {6.0,2.2,4.0,1.0}, {6.1,2.9,4.7,1.4}, {5.6,2.9,3.6,1.3},
                            {6.7,3.1,4.4,1.4}, {5.6,3.0,4.5,1.5}, {5.8,2.7,4.1,1.0},
                            {6.2,2.2,4.5,1.5}, {5.6,2.5,3.9,1.1},
                            {6.3,3.3,6.0,2.5}, {5.8,2.7,5.1,1.9}, {7.1,3.0,5.9,2.1},
                            {6.3,2.9,5.6,1.8}, {6.5,3.0,5.8,2.2}, {7.6,3.0,6.6,2.1},
                            {4.9,2.5,4.5,1.7}, {7.3,2.9,6.3,1.8}, {6.7,2.5,5.8,1.8},
                            {7.2,3.6,6.1,2.5}, {6.5,3.2,5.1,2.0}, {6.4,2.7,5.3,1.9},
                            {6.8,3.0,5.5,2.1}, {5.7,2.5,5.0,2.0}, {5.8,2.8,5.1,2.4},
                            {6.4,3.2,5.3,2.3}, {6.5,3.0,5.5,1.8}, {7.7,3.8,6.7,2.2},
                            {7.7,2.6,6.9,2.3}, {6.0,2.2,5.0,1.5}	};
    Mat trainingDataMat(60, 4, CV_32FC1, trainingData); 
    //训练样本所对应的类别，S表示setosa，V表示versicolor，R表示virginica
    float responses[60] = {'S','S','S','S','S','S','S','S','S','S','S','S','S','S','S','S','S','S','S','S',
                      'V','V','V','V','V','V','V','V','V','V','V','V','V','V','V','V','V','V','V','V',
                      'R','R','R','R','R','R','R','R','R','R','R','R','R','R','R','R','R','R','R','R'};
    Mat responsesMat(60, 1, CV_32FC1, responses);

    //设置SVM参数
    CvSVMParams params;
    params.svm_type = CvSVM::C_SVC;    //SVM类型为C-SVC
    params.C = 10.0;    //C参数设置为10
    params.kernel_type = CvSVM::RBF;    //核函数为高斯核函数
    params.gamma = 8.0;    //高斯核函数中的γ参数设置为8
    //迭代的终止条件
    params.term_crit = cvTermCriteria(CV_TERMCRIT_EPS, 1000, FLT_EPSILON);

    //建立SVM模型
    CvSVM svm;
    svm.train(trainingDataMat, responsesMat, Mat(), Mat(), params);
    //预测样本数据
    double sampleData[4]={ 6.7, 3.1, 4.7, 1.5};
    Mat sampleMat(4, 1, CV_32FC1, sampleData);
    float r = svm.predict(sampleMat);    //预测结果
    cout<<endl<<"result:  "<<(char)r<<endl;    //输出结果

    return 0;
}

输出结果为：

OpenCV2.4.9源码分析——Support Vector Machines

标签：

原文地址：http://blog.csdn.net/zhaocj/article/details/51297907