OpenCV中CvSVM部分函数解读

超、凢脫俗 2022-08-06 03:11 171阅读 0赞

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部分函数解读

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 100多个常用的Python函数！（部分函数含代码解读）

相关 OpenCV 中的 remap 函数

相关 bert代码模型部分的解读

相关 OpenCV的函数的开头部分CV_Assert的意思！

相关 OpenCV函数解读之groupRectangles

相关 OpenCV原理解读之HAAR+Adaboost

相关 OpenCV中CvSVM部分函数解读

相关 openCV中waitKey函数介绍

相关 opencv 部分函数的cols，rows顺序

相关 opencv中的copyTo函数在opencv-Python中的实现