OpenCV中CvSVM部分函数解读

Posted 2020-10-01 zhchoutai

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了OpenCV中CvSVM部分函数解读相关的知识，希望对你有一定的参考价值。

CvSVM::predict函数解析：无论是Mat接口还是CvMat接口终于都是通过指针的形式调用的。也就是终于都是调用的下面函数实现的

float CvSVM::predict( const float* row_sample, int row_len, bool returnDFVal ) const

{

// 首先确保创建了核函数输入了样本

assert( kernel );

assert( row_sample );

// 样本的长度，也就是特征的维数必须匹配

int var_count = get_var_count();

assert( row_len == var_count );

(void)row_len; // 不知道干啥的

// 计算类别数目

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 ||

params.svm_type == NU_SVR ||

params.svm_type == ONE_CLASS )

{

CvSVMDecisionFunc* df = (CvSVMDecisionFunc*)decision_func;

int i, sv_count = df->sv_count;

double sum = -df->rho;

// 计算最优平面与当前样本点之间的距离

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];

result = params.svm_type == ONE_CLASS ? (float)(sum > 0) : (float)sum;

}

// 对于分类问题使用下面方法

else if( params.svm_type == C_SVC ||

params.svm_type == NU_SVC )

{

CvSVMDecisionFunc* df = (CvSVMDecisionFunc*)decision_func;

int* vote = (int*)(buffer + sv_total);

int i, j, k;

memset( vote, 0, class_count*sizeof(vote[0]));

// 计算样本点到全部支持向量之间的距离。sum(xi-yi)。当中xi表示样本点，yi表示支持向量，i=1:N。N表示一个样本的特征维度

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++ )

{

// 获取样本点到最优分界面的距离：buffer中存放測试样本与每一个支持向量距离度量值

sum = -df->rho;

int sv_count = df->sv_count;

for( k = 0; k < sv_count; k++ )

sum += df->alpha[k]*buffer[df->sv_index[k]]; // sv_index存储的是支持向量index。对于2分类实际sv_index[k]=k

// sum大于0表示属于第一个类别。也就是类别标记较小的那个类别，对于二分类问题也就是负样本

vote[sum > 0 ? i : j]++;

}

// 统计每一个类别的投票次数，注意大于0投票给了0也就是0为负样本，假设一次也没有投票的话，默认输出的也是负样本

for( i = 1, k = 0; i < class_count; i++ )

{

if( vote[i] > vote[k] )

k = i;

}

// returnDFVal仅仅对于2分类问题有效，sum大于0表示属于类别标记较小的那个类别也就是-1，sum小于0表示属于类别标记较大的那个类别也就是+1

result = returnDFVal && class_count == 2 ? (float)sum : (float)(class_labels->data.i[k]);

}

else

CV_Error( CV_StsBadArg, "INTERNAL ERROR: Unknown SVM type, "

"the SVM structure is probably corrupted" );

return result;

}

kernel->calc( sv_total, var_count, (const float**)sv, row_sample, buffer );

计算样本点到支持向量点间的距离，结果存储到buffer中，以线性核函数为例

从上面的分析能够看出。假设不更改rho或者alpha的符号，计算的是-rho+w*x的结果，大于0表示负样本，小于0表示正样本；因此在HOGDescriptor中须要将alpha更改符号。直接保存rho就可以，这样给出的结果rho-alpha*x。大于0表示正样本。

w=alpha*sv; alpha中存放每一个支持向量的权重，sv表示每一个支持向量，w为加权后的支持向量

void CvSVMKernel::calc( int vcount, int var_count, const float** vecs,

const float* another, Qfloat* results )

{

const Qfloat max_val = (Qfloat)(FLT_MAX*1e-3);

int j;

// 对于核函数为Liner时调用线性核函数进行计算

(this->*calc_func)( vcount, var_count, vecs, another, results );

// 检查是否越界

for( j = 0; j < vcount; j++ )

{

if( results[j] > max_val )

results[j] = max_val;

}

线性核函数又调用non_rbf_base核函数进行计算

void CvSVMKernel::calc_linear( int vcount, int var_count, const float** vecs,

const float* another, Qfloat* results )

{

calc_non_rbf_base( vcount, var_count, vecs, another, results, 1, 0 );

}

vcount表示支持向量的个数，也就是位于正负样本分界面上的正负样本总数

var_count表示样本的特征维度

vecs表示支持向量。也就是位于正负样本分解面上的正负样本

another表示測试样本

result表示对于每一个支持向量的累加结果值

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++ )

{

// 获取第j个支持向量或者说第j个样本

const float* sample = vecs[j];

double s = 0;

// 特征维度大于4的时候进行优化

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];

// 计算其余的维度

for( ; k < var_count; k++ )

s += sample[k]*another[k];

// 计算測试样本与第j个样本之间的距离

results[j] = (Qfloat)(s*alpha + beta); // 注意这里的alpha和beta为每一个支持向量的权重，对于线性核函数而言alpha=1，beta=0能够从calc_linear函数看出

}

// RBF核函数，遵循RBF核函数公式

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;

int j, k;

// vcount=sv_count

for( j = 0; j < vcount; j++ )

{

const float* sample = vecs[j];

double s = 0;

// var_count=feature_num

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;

}

for( ; k < var_count; k++ )

{

double t0 = sample[k] - another[k];

s += t0*t0;

}

results[j] = (Qfloat)(s*gamma);

}

if( vcount > 0 )

cvExp( &R, &R );

}

// 依据交叉次数自己主动训练函数,CvParamGrid为训练參数构造函数，其包括三个參数(min_val,max_val,step)

// Param Grid的检查函数，最大值不小于最小值。最小值不小于DBL_EPSILON。step不小于1（应该是不小于等于1）

bool CvParamGrid::check() const

{

bool ok = false;

CV_FUNCNAME( "CvParamGrid::check" );

__BEGIN__;

if( min_val > max_val )

CV_ERROR( CV_StsBadArg, "Lower bound of the grid must be less then the upper one" );

if( min_val < DBL_EPSILON )

CV_ERROR( CV_StsBadArg, "Lower bound of the grid must be positive" );

if( step < 1. + FLT_EPSILON )

CV_ERROR( CV_StsBadArg, "Grid step must greater then 1" );

ok = true;

__END__;

return ok;

}

假设不确定參数的值的范围能够通过下面函数获得，当然也能够通过一次次实验不断调整，最后得到一个大概的范围后採用train_auto函数进行训练

CvParamGrid CvSVM::get_default_grid( int param_id )

{

CvParamGrid grid;

if( param_id == CvSVM::C )

{

grid.min_val = 0.1;

grid.max_val = 500;

grid.step = 5; // total iterations = 5

}

else if( param_id == CvSVM::GAMMA )

{

grid.min_val = 1e-5;

grid.max_val = 0.6;

grid.step = 15; // total iterations = 4

}

else if( param_id == CvSVM::P )

{

grid.min_val = 0.01;

grid.max_val = 100;

grid.step = 7; // total iterations = 4

}

else if( param_id == CvSVM::NU )

{

grid.min_val = 0.01;

grid.max_val = 0.2;

grid.step = 3; // total iterations = 3

}

else if( param_id == CvSVM::COEF )

{

grid.min_val = 0.1;

grid.max_val = 300;

grid.step = 14; // total iterations = 3

}

else if( param_id == CvSVM::DEGREE )

{

grid.min_val = 0.01;

grid.max_val = 4;

grid.step = 7; // total iterations = 3

}

else

cvError( CV_StsBadArg, "CvSVM::get_default_grid", "Invalid type of parameter "

"(use one of CvSVM::C, CvSVM::GAMMA et al.)", __FILE__, __LINE__ );

return grid;

}

bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,

const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params, int k_fold,

CvParamGrid C_grid, CvParamGrid gamma_grid, CvParamGrid p_grid,

CvParamGrid nu_grid, CvParamGrid coef_grid, CvParamGrid degree_grid,

bool balanced)

{

bool ok = false;

CvMat* responses = 0;

CvMat* responses_local = 0;

CvMemStorage* temp_storage = 0;

const float** samples = 0;

const float** samples_local = 0;

CV_FUNCNAME( "CvSVM::train_auto" );

__BEGIN__;

int svm_type, sample_count, var_count, sample_size;

int block_size = 1 << 16;

double* alpha;

RNG* rng = &theRNG();

// all steps are logarithmic and must be > 1

// 步长都必须大于1，由于等于1的时候会造成死循环。，默认step=10

double degree_step = 10, g_step = 10, coef_step = 10, C_step = 10, nu_step = 10, p_step = 10;

double gamma = 0, curr_c = 0, degree = 0, coef = 0, p = 0, nu = 0;

double best_degree = 0, best_gamma = 0, best_coef = 0, best_C = 0, best_nu = 0, best_p = 0;

float min_error = FLT_MAX, error;

// SVMType为ONE_CLASS的时候不能进行自己主动训练

if( _params.svm_type == CvSVM::ONE_CLASS )

{

if(!train( _train_data, _responses, _var_idx, _sample_idx, _params ))

EXIT;

return true;

}

clear();

// 选择的交叉验证层数必须大于等于2。等于2的时候就是使用一个训练另外一个測试。训练两次，測试两次

// 等于10表示训练10次。測试10次，选择一组測试其余9组训练

if( k_fold < 2 )

CV_ERROR( CV_StsBadArg, "Parameter <k_fold> must be > 1" );

CV_CALL(set_params( _params ));

svm_type = _params.svm_type;

// All the parameters except, possibly, <coef0> are positive.

// <coef0> is nonnegative

// 检查各个參数的值是否满足要求，这是第一步检查（步长不能小于1），后面依据SVM类型与Kernel类型还会进行二次检查

if( C_grid.step <= 1 )

{

C_grid.min_val = C_grid.max_val = params.C;

C_grid.step = 10;

}

else

CV_CALL(C_grid.check());

if( gamma_grid.step <= 1 )

{

gamma_grid.min_val = gamma_grid.max_val = params.gamma;

gamma_grid.step = 10;

}

else

CV_CALL(gamma_grid.check());

if( p_grid.step <= 1 )

{

p_grid.min_val = p_grid.max_val = params.p;

p_grid.step = 10;

}

else

CV_CALL(p_grid.check());

if( nu_grid.step <= 1 )

{

nu_grid.min_val = nu_grid.max_val = params.nu;

nu_grid.step = 10;

}

else

CV_CALL(nu_grid.check());

if( coef_grid.step <= 1 )

{

coef_grid.min_val = coef_grid.max_val = params.coef0;

coef_grid.step = 10;

}

else

CV_CALL(coef_grid.check());

if( degree_grid.step <= 1 )

{

degree_grid.min_val = degree_grid.max_val = params.degree;

degree_grid.step = 10;

}

else

CV_CALL(degree_grid.check());

// these parameters are not used:

// 二次检查參数的值。依据核函数类型与SVM类型优化參数

if( params.kernel_type != CvSVM::POLY )

degree_grid.min_val = degree_grid.max_val = params.degree;

if( params.kernel_type == CvSVM::LINEAR )

gamma_grid.min_val = gamma_grid.max_val = params.gamma;

if( params.kernel_type != CvSVM::POLY && params.kernel_type != CvSVM::SIGMOID )

coef_grid.min_val = coef_grid.max_val = params.coef0;

if( svm_type == CvSVM::NU_SVC || svm_type == CvSVM::ONE_CLASS )

C_grid.min_val = C_grid.max_val = params.C;

if( svm_type == CvSVM::C_SVC || svm_type == CvSVM::EPS_SVR )

nu_grid.min_val = nu_grid.max_val = params.nu;

if( svm_type != CvSVM::EPS_SVR )

p_grid.min_val = p_grid.max_val = params.p;

CV_ASSERT( g_step > 1 && degree_step > 1 && coef_step > 1);

CV_ASSERT( p_step > 1 && C_step > 1 && nu_step > 1 );

/* Prepare training data and related parameters */

// 实现数据的转存，放到指针中

CV_CALL(cvPrepareTrainData( "CvSVM::train_auto", _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();

create_solver();

{

const int testset_size = sample_count/k_fold; // 每组測试集合大小

const int trainset_size = sample_count - testset_size; // 每组训练集合大小

const int last_testset_size = sample_count - testset_size*(k_fold-1); // 最后一组測试集合大小。实际为testset_size

const int last_trainset_size = sample_count - last_testset_size; // 最后一组训练集合大小。实际trainset_size

const bool is_regression = (svm_type == EPS_SVR) || (svm_type == NU_SVR);

size_t resp_elem_size = CV_ELEM_SIZE(responses->type);

size_t size = 2*last_trainset_size*sizeof(samples[0]);

samples_local = (const float**) cvAlloc( size );

memset( samples_local, 0, size );

responses_local = cvCreateMat( 1, trainset_size, CV_MAT_TYPE(responses->type) );

cvZero( responses_local );

// randomly permute samples and responses

// 随机变更样本和标签的顺序为了获取分组

for(int i = 0; i < sample_count; i++ )

{

int i1 = (*rng)(sample_count);

int i2 = (*rng)(sample_count);

const float* temp;

float t;

int y;

CV_SWAP( samples[i1], samples[i2], temp );

if( is_regression )

CV_SWAP( responses->data.fl[i1], responses->data.fl[i2], t );

else

CV_SWAP( responses->data.i[i1], responses->data.i[i2], y );

}

// 假设是分类问题。而且是2分类，而且须要均衡化分组

if (!is_regression && class_labels->cols==2 && balanced)

{

// count class samples

// responses中存放0和1。class_label中存放为0和1就对了，因此注意负样本的标签为0，正样本的标签为1！

！

int num_0=0,num_1=0;

for (int i=0; i<sample_count; ++i)

{

if (responses->data.i[i]==class_labels->data.i[0])

++num_0;

else

++num_1;

}

// 哪个类别是较大的

int label_smallest_class;

int label_biggest_class;

if (num_0 < num_1)

{

label_biggest_class = class_labels->data.i[1];

label_smallest_class = class_labels->data.i[0];

}

else

{

label_biggest_class = class_labels->data.i[0];

label_smallest_class = class_labels->data.i[1];

int y;

CV_SWAP(num_0,num_1,y);

}

const double class_ratio = (double) num_0/sample_count;

// calculate class ratio of each fold

indexedratio *ratios=0;

ratios = (indexedratio*) cvAlloc(k_fold*sizeof(*ratios));

for (int k=0, i_begin=0; k<k_fold; ++k, i_begin+=testset_size)

{

int count0=0;

int count1=0;

int i_end = i_begin + (k<k_fold-1 ? testset_size : last_testset_size);

for (int i=i_begin; i<i_end; ++i)

{

if (responses->data.i[i]==label_smallest_class)

++count0;

else

++count1;

}

ratios[k].ind = k;

ratios[k].count_smallest = count0;

ratios[k].count_biggest = count1;

ratios[k].eval();

}

// initial distance

qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);

double old_dist = 0.0;

for (int k=0; k<k_fold; ++k)

old_dist += abs(ratios[k].val-class_ratio);

double new_dist = 1.0;

// iterate to make the folds more balanced

while (new_dist > 0.0)

{

if (ratios[0].count_biggest==0 || ratios[k_fold-1].count_smallest==0)

break; // we are not able to swap samples anymore

// what if we swap the samples, calculate the new distance

ratios[0].count_smallest++;

ratios[0].count_biggest--;

ratios[0].eval();

ratios[k_fold-1].count_smallest--;

ratios[k_fold-1].count_biggest++;

ratios[k_fold-1].eval();

qsort(ratios, k_fold, sizeof(ratios[0]), icvCmpIndexedratio);

new_dist = 0.0;

for (int k=0; k<k_fold; ++k)

new_dist += abs(ratios[k].val-class_ratio);

if (new_dist < old_dist)

{

// swapping really improves, so swap the samples

// index of the biggest_class sample from the minimum ratio fold

int i1 = ratios[0].ind * testset_size;

for ( ; i1<sample_count; ++i1)

{

if (responses->data.i[i1]==label_biggest_class)

break;

}

// index of the smallest_class sample from the maximum ratio fold

int i2 = ratios[k_fold-1].ind * testset_size;

for ( ; i2<sample_count; ++i2)

{

if (responses->data.i[i2]==label_smallest_class)

break;

}

// swap

const float* temp;

int y;

CV_SWAP( samples[i1], samples[i2], temp );

CV_SWAP( responses->data.i[i1], responses->data.i[i2], y );

old_dist = new_dist;

}

else

break; // does not improve, so break the loop

}

cvFree(&ratios);

}

// 遍历每一个參数进行測试，将最小错误率的检測结果保存下来

// 在自己主动话训练时是依照例如以下方式进行的。当然针对不同的核函数与不同的SVM类型进行了优化

while(cur_val=min_val; cur_val<=max_val; cur_val*=step)

int* cls_lbls = class_labels ? class_labels->data.i : 0;

curr_c = C_grid.min_val;

{

params.C = curr_c;

gamma = gamma_grid.min_val;

{

params.gamma = gamma;

p = p_grid.min_val;

{

params.p = p;

nu = nu_grid.min_val;

{

params.nu = nu;

coef = coef_grid.min_val;

{

params.coef0 = coef;

degree = degree_grid.min_val;

{

params.degree = degree;

float** test_samples_ptr = (float**)samples;

uchar* true_resp = responses->data.ptr;

int test_size = testset_size;

int train_size = trainset_size;

// 依据每轮训练中最小错误率保存结果

// 一组測试。其余组用于训练。依据总的错误率作为最佳结果

error = 0;

for(int k = 0; k < k_fold; k++ )

{

// 分段拷贝训练样本与训练样本标签

memcpy( samples_local, samples, sizeof(samples[0])*test_size*k );

memcpy( samples_local + test_size*k, test_samples_ptr + test_size,

sizeof(samples[0])*(sample_count - testset_size*(k+1)) );

memcpy( responses_local->data.ptr, responses->data.ptr, resp_elem_size*test_size*k );

memcpy( responses_local->data.ptr + resp_elem_size*test_size*k,

true_resp + resp_elem_size*test_size,

resp_elem_size*(sample_count - testset_size*(k+1)) );

if( k == k_fold - 1 )

{

test_size = last_testset_size;

train_size = last_trainset_size;

responses_local->cols = last_trainset_size;

}

// Train SVM on <train_size> samples

// 分组測试

if( !do_train( svm_type, train_size, var_count,

(const float**)samples_local, responses_local, temp_storage, alpha ) )

EXIT;

// Compute test set error on <test_size> samples

// 统计错误样本个数

for(int i = 0; i < test_size; i++, true_resp += resp_elem_size, test_samples_ptr++ )

{

float resp = predict( *test_samples_ptr, var_count );

error += is_regression ? powf( resp - *(float*)true_resp, 2 )

: ((int)resp != cls_lbls[*(int*)true_resp]);

}

// 保存具有最小错误样本个数的训练參数

if( min_error > error )

{

min_error = error;

best_degree = degree;

best_gamma = gamma;

best_coef = coef;

best_C = curr_c;

best_nu = nu;

best_p = p;

}

degree *= degree_grid.step;

}

while( degree < degree_grid.max_val );

coef *= coef_grid.step;

}

while( coef < coef_grid.max_val );

nu *= nu_grid.step;

}

while( nu < nu_grid.max_val );

p *= p_grid.step;

}

while( p < p_grid.max_val );

gamma *= gamma_grid.step;

}

while( gamma < gamma_grid.max_val );

curr_c *= C_grid.step;

}

while( curr_c < C_grid.max_val );

}

// 计算错误率

min_error /= (float) sample_count;

params.C = best_C;

params.nu = best_nu;

params.p = best_p;

params.gamma = best_gamma;

params.degree = best_degree;

params.coef0 = best_coef;

// 依据最佳的參数做一次最后的训练，因此分组測试的目的是为了寻找最佳參数

CV_CALL(ok = do_train( svm_type, sample_count, var_count, samples, responses, temp_storage, alpha ));

__END__;

delete solver;

solver = 0;

cvReleaseMemStorage( &temp_storage );

cvReleaseMat( &responses );

cvReleaseMat( &responses_local );

cvFree( &samples );

cvFree( &samples_local );

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

clear();

return ok;

}

总结：

1） predict函数首先计算測试样本到每一个支持向量sv[j]之间的距离。然后乘以每一个支持向量的权重alpha[i]结果得到一个数，该值减去rho。假设大于0表示为负样本，否则为正样本

2）对于二分类使用balanced=true的train_auto而言，负样本标签必须为0，这样就能够通过统计正负样本的比例而得到一个较好的平衡结果

以上是关于OpenCV中CvSVM部分函数解读的主要内容，如果未能解决你的问题，请参考以下文章

未在此范围内声明 CvSVM 错误

OpenCV支持向量机(SVM)介绍

CvSVM 问题

将提取的 HoG 特征输入到 CvSVM 的训练函数中

Opencv 3 SVM 训练