Namespce used to wrap implementation of libSVM version 2.89. More...

Classes
class	Cache

struct	decision_function

class	Kernel

class	ONE_CLASS_Q

class	QMatrix

class	Solver

class	Solver_NU

class	SVC_Q

struct	Svm_Model

struct	svm_parameter

struct	svm_problem

class	SVR_Q

Typedefs
typedef float	Qfloat

typedef signed char	schar

typedef XmlElementTemplate< Svm_Model >	XmlElementSvm_Model

typedef XmlElementSvm_Model *	XmlElementSvm_ModelPtr

Enumerations
enum	Kernel_Type { Kernel_Type::Kernel_NULL, Kernel_Type::LINEAR, Kernel_Type::POLY, Kernel_Type::RBF, Kernel_Type::SIGMOID, Kernel_Type::PRECOMPUTED }

enum	SVM_Type { SVM_Type::SVM_NULL, SVM_Type::C_SVC, SVM_Type::NU_SVC, SVM_Type::ONE_CLASS, SVM_Type::EPSILON_SVR, SVM_Type::NU_SVR }

Functions
template<class S , class T >
void	clone (T &dst, S src, kkint32 n)

template<class T >
T *	GrowAllocation (T *src, kkint32 origSize, kkint32 newSize)

Kernel_Type	Kernel_Type_FromStr (KKStr s)

KKStr	Kernel_Type_ToStr (Kernel_Type kernelType)

void	multiclass_probability (kkint32 numClasses, double *pairwiseProbs, double classProb)

double	powi (double base, kkint32 times)

double	sigmoid_predict (double decision_value, double A, double B)

void	sigmoid_train (kkint32 numExamples, const double dec_values, const double labels, double &A, double &B)

void	solve_c_svc (const svm_problem prob, const svm_parameter param, double alpha, Solver::SolutionInfo si, double Cp, double Cn, RunLog &_log)

void	solve_epsilon_svr (const svm_problem prob, const svm_parameter param, double alpha, Solver::SolutionInfo si, RunLog &_log)

void	solve_nu_svc (const svm_problem prob, const svm_parameter param, double alpha, Solver::SolutionInfo si, RunLog &_log)

void	solve_one_class (const svm_problem prob, const svm_parameter param, double alpha, Solver::SolutionInfo si, RunLog &_log)

const char *	svm_check_parameter (const struct svm_problem prob, const struct svm_parameter param)

kkint32	svm_check_probability_model (const struct Svm_Model *model)

void	svm_cross_validation (const svm_problem &prob, const svm_parameter &param, kkint32 nr_fold, double *target, RunLog &log)

void	svm_destroy_model (struct Svm_Model *&model)

void	svm_destroy_param (struct svm_parameter *&param)

void	svm_get_labels (const struct Svm_Model model, kkint32 label)

kkint32	svm_get_nr_class (const struct Svm_Model *model)

kkint32	svm_get_svm_type (const struct Svm_Model *model)

double	svm_get_svr_probability (const struct Svm_Model *model)

double	svm_predict (const struct Svm_Model *model, const FeatureVector &x)

double	svm_predict_probability (Svm_Model model, const FeatureVector &x, double prob_estimates, kkint32 *votes)

void	svm_predict_values (const Svm_Model model, const FeatureVector &x, double dec_values)

Svm_Model *	svm_train (const svm_problem &prob, const svm_parameter &param, RunLog &log)

decision_function	svm_train_one (const svm_problem &prob, const svm_parameter &param, double Cp, double Cn, RunLog &_log)

SVM_Type	SVM_Type_FromStr (KKStr s)

KKStr	SVM_Type_ToStr (SVM_Type svmType)

template<class T >
void	swap (T &x, T &y)

Variables
kkint32	libsvm_version

void(*	svm_print_string )(const char *) = &print_string_stdout

Detailed Description

Namespce used to wrap implementation of libSVM version 2.89.

There is more than one version of libSVM implemented in the library. To prevent name conflicts between them each one was wrapped in their own namespace.
libSVM is a Support Vector Machine implementation done by "Chih-Chung Chang" and "Chih-Jen Lin". It was downloaded from http://www.csie.ntu.edu.tw/~cjlin/libsvm/. The source code was modified by Kurt Kramer. The primary changes to this implementation involves the replacement of the sparse data-structure in the original implementation with fixed length array implemented through the "FeatureVector" class and the ability to specify a sub-set of features to be utilized via the "FeatureNumList" class. This allows us to load in a single set of training data with all its features that can then be used for multiple Support Vector Machine instances where each instance utilizes a different set of features. The use of this version of libSVM(SVM289_MFS) is via the "ModelSvmBase" class.

Typedef Documentation

typedef float SVM289_MFS::Qfloat

Definition at line 287 of file svm2.h.

typedef signed char SVM289_MFS::schar

Definition at line 289 of file svm2.h.

typedef XmlElementTemplate< Svm_Model > SVM289_MFS::XmlElementSvm_Model

Definition at line 230 of file svm2.h.

typedef XmlElementSvm_Model * SVM289_MFS::XmlElementSvm_ModelPtr

Definition at line 231 of file svm2.h.

Enumeration Type Documentation

enum SVM289_MFS::Kernel_Type

strong

Enumerator
Kernel_NULL
LINEAR
POLY
RBF
SIGMOID
PRECOMPUTED

Definition at line 83 of file svm2.h.

   {
     Kernel_NULL,
     LINEAR,
     POLY,
     RBF,
     SIGMOID,
     PRECOMPUTED
   };

enum SVM289_MFS::SVM_Type

strong

Enumerator
SVM_NULL
C_SVC
NU_SVC
ONE_CLASS
EPSILON_SVR
NU_SVR

Definition at line 72 of file svm2.h.

   {
     SVM_NULL,
     C_SVC,
     NU_SVC,
     ONE_CLASS,
     EPSILON_SVR,
     NU_SVR
   };

Function Documentation

template<class S , class T >

void SVM289_MFS::clone	(	T *&	dst,
		S *	src,
		kkint32	n
	)

inline

Definition at line 292 of file svm2.h.

   {
     dst = new T[n];
 
     kkint32  sizeOfT = sizeof(T);
     KKStr::MemCpy ((void *)dst, (void *)src, sizeOfT * n);
   }

template<class T >

T* SVM289_MFS::GrowAllocation	(	T *	src,
		kkint32	origSize,
		kkint32	newSize
	)

inline

Definition at line 80 of file svm2.cpp.

   {
     kkint32  zed = 0;
     T*  dest = new T[newSize];
     while  (zed < origSize)    {dest[zed] = src[zed];  zed++;}
     while  (zed < newSize)     {dest[zed] = (T)0;      zed++;}
     delete  src;
     return  dest;
   }  /* GrowAllocation */

Kernel_Type SVM289_MFS::Kernel_Type_FromStr ( KKStr s )

Definition at line 564 of file svm2.cpp.

References KKB::KKStr::EqualIgnoreCase(), Kernel_NULL, LINEAR, KKB::KKStr::operator==(), POLY, PRECOMPUTED, RBF, SIGMOID, and KKB::KKStr::Upper().

Referenced by SVM289_MFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ProcessSvmParameter(), and SVM289_MFS::Svm_Model::ReadXML().

  {
    s.Upper ();
    if  ((s.EqualIgnoreCase ("LINEAR"))       ||  (s == "0"))                                      return  Kernel_Type::LINEAR;
    if  ((s.EqualIgnoreCase ("POLYNOMIAL"))   ||  (s.EqualIgnoreCase ("POLY"))  ||  (s == "1"))    return  Kernel_Type::POLY;
    if  ((s.EqualIgnoreCase ("RBF"))          ||  (s == "2"))                                      return  Kernel_Type::RBF;
    if  ((s.EqualIgnoreCase ("SIGMOID"))      ||  (s == "3"))                                      return  Kernel_Type::SIGMOID;
    if  ((s.EqualIgnoreCase ("PRECOMPUTED"))  ||  (s == "4"))                                      return  Kernel_Type::PRECOMPUTED;
 
    return  Kernel_Type::Kernel_NULL;
  }

KKStr SVM289_MFS::Kernel_Type_ToStr ( Kernel_Type kernelType )

Definition at line 580 of file svm2.cpp.

References LINEAR, POLY, PRECOMPUTED, RBF, and SIGMOID.

Referenced by SVM289_MFS::svm_parameter::ToTabDelStr(), and SVM289_MFS::Svm_Model::WriteXML().

 {
   switch  (kernelType)
   {
   case  Kernel_Type::LINEAR:       return  "linear";
   case  Kernel_Type::POLY:         return  "polynomial";
   case  Kernel_Type::RBF:          return  "rbf";
   case  Kernel_Type::SIGMOID:      return  "sigmoid";
   case  Kernel_Type::PRECOMPUTED:  return  "precomputed";
   } 
 
   return  "";
 }

void SVM289_MFS::multiclass_probability	(	kkint32	numClasses,
		double **	pairwiseProbs,
		double *	classProb
	)

Implements method 2 from the multiclass_prob paper by Wu, Lin, and Weng

Parameters

[in]	numClasses
[in]	pairwiseProbs
[out]	classProb

Parameters

numClasses	Number of Classes.
pairwiseProbs	Pair-wise Probabilities.
classProb	Class Probability

Definition at line 3009 of file svm2.cpp.

References info().

 {
   kkint32 t,j;
   kkint32  iter     = 0;
   kkint32  max_iter = Max (100, numClasses);
 
   double**  Q  = new double*[numClasses];
   double*   Qp = new double[numClasses];
   double    pQp; 
   double    eps = 0.005 / numClasses;
   
   for  (t = 0;  t < numClasses;  ++t)
   {
     classProb[t] = 1.0 / numClasses;  // Valid if k = 1
     Q[t]    = new double[numClasses];
     for  (kkint32 i = 0;  i < numClasses;  ++i)
       Q[t][i] = 0;
 
     Q[t][t] = 0;
     for  (j = 0;  j < t;  j++)
     {
       Q[t][t] += pairwiseProbs[j][t] * pairwiseProbs[j][t];
       Q[t][j] =  Q[j][t];
     }
 
     for  (j = t + 1;  j < numClasses;  ++j)
     {
       Q[t][t] +=  pairwiseProbs[j][t] * pairwiseProbs[j][t];
       Q[t][j] =-  pairwiseProbs[j][t] * pairwiseProbs[t][j];
     }
   }
 
   for (iter = 0;  iter < max_iter;  iter++)
   {
     // stopping condition, recalculate QP,pQP for numerical accuracy
     pQp = 0;
     for (t = 0;  t < numClasses;  t++)
     {
       Qp[t] = 0;
       for  (j = 0;  j < numClasses;  j++)
         Qp[t] += Q[t][j] * classProb[j];
       pQp += classProb[t] * Qp[t];
     }
     double max_error = 0;
     for (t = 0;  t < numClasses;  ++t)
     {
       double error = fabs (Qp[t] - pQp);
       if  (error > max_error)
         max_error = error;
     }
 
     if  (max_error < eps) 
       break;
     
     for  (t = 0;  t < numClasses;  ++t)
     {
       double diff = (-Qp[t] +pQp) / Q[t][t];
       classProb[t] += diff;
       pQp = (pQp + diff * (diff * Q[t][t] + 2 * Qp[t]))  /  (1 + diff) / (1 + diff);
       for (j = 0;  j < numClasses;  ++j)
       {
         Qp[j] = (Qp[j] + diff * Q[t][j]) / (1 + diff);
         classProb[j] /= (1 + diff);
       }
     }
   }
   if  (iter >= max_iter)
     info ("Exceeds max_iter in multiclass_prob\n");
 
   for  (t = 0;  t < numClasses;  ++t)
   {delete Q[t];  Q[t] = NULL;}
 
   delete[]  Q;  Q  = NULL;
   delete[]  Qp; Qp = NULL;
 }  /* multiclass_probability */

double SVM289_MFS::powi	(	double	base,
		kkint32	times
	)

inline

Definition at line 94 of file svm2.cpp.

Referenced by SVM289_MFS::Kernel::k_function().

   {
     double tmp = base, ret = 1.0;
 
     for  (kkint32 t = times;  t > 0;  t /= 2)
     {
       if  ((t % 2) == 1) 
        ret *= tmp;
       tmp = tmp * tmp;
     }
     return ret;
   }

double SVM289_MFS::sigmoid_predict	(	double	decision_value,
		double	A,
		double	B
	)

Definition at line 2986 of file svm2.cpp.

 {
   double  fApB = decision_value * A + B;
   if  (fApB >= 0)
     return exp (-fApB) / (1.0 + exp (-fApB));
   else
     return 1.0 / (1 + exp (fApB));
 }  /* sigmoid_predict */

void SVM289_MFS::sigmoid_train	(	kkint32	numExamples,
		const double *	dec_values,
		const double *	labels,
		double &	A,
		double &	B
	)

Definition at line 2850 of file svm2.cpp.

References info().

Referenced by svm_binary_svc_probability().

 {
   double  prior1 = 0;
   double  prior0 = 0;
   kkint32 i;
 
   for (i = 0;  i < numExamples;  ++i)
   {
     if  (labels[i] > 0)
       prior1 += 1;
     else 
       prior0 += 1;
   }
 
   kkint32 max_iter  = 100;    // Maximal number of iterations
   double  min_step  = 1e-10;  // Minimal step taken in line search
   double  sigma     = 1e-12;  // For numerically strict PD of Hessian
   double  eps       = 1e-5;
   double  hiTarget  = (prior1 + 1.0) / (prior1 + 2.0);
   double  loTarget  =  1 / (prior0 + 2.0);
   double* t = new double[numExamples];
   double  fApB, p, q, h11, h22, h21, g1, g2, det, dA, dB, gd, stepsize;
   double  newA, newB, newf, d1, d2;
   kkint32   iter; 
   
   // Initial Point and Initial Fun Value
   A = 0.0; 
   B = log ((prior0 + 1.0) / (prior1 + 1.0));
   double  fval = 0.0;
 
   for  (i = 0;  i < numExamples;  ++i)
   {
     if  (labels[i] > 0) 
       t[i] = hiTarget;
     else 
       t[i] = loTarget;
 
     fApB = dec_values[i] * A + B;
     
     if (fApB >= 0)
       fval += t[i] * fApB + log (1 + exp (-fApB));
     else
       fval += (t[i] - 1) * fApB + log (1 + exp (fApB));
   }
 
   for  (iter=0;  iter < max_iter;  iter++)
   {
     // Update Gradient and Hessian (use H' = H + sigma I)
     h11 = sigma; // numerically ensures strict PD
     h22 = sigma;
     h21 = 0.0;
     g1  = 0.0;
     g2  = 0.0;
     for  (i = 0;  i < numExamples;  i++)
     {
       fApB = dec_values[i] * A + B;
       if  (fApB >= 0)
       {
         p = exp (-fApB) / (1.0 + exp(-fApB));
         q = 1.0 / (1.0 + exp(-fApB));
       }
       else
       {
         p = 1.0 / (1.0 + exp (fApB));
         q = exp (fApB) / (1.0 + exp (fApB));
       }
 
       d2   = p * q;
       h11  += dec_values[i] * dec_values[i] * d2;
       h22  += d2;
       h21  += dec_values[i] * d2;
       d1   = t[i] - p;
       g1   += dec_values[i] * d1;
       g2   += d1;
     }
 
     // Stopping Criteria
     if  ((fabs (g1) < eps)  &&  (fabs(g2) < eps))
       break;
 
     // Finding Newton direction: -inv(H') * g
     det = h11 * h22  -  h21 * h21;
     dA  = -(h22*g1 - h21 * g2) / det;
     dB  = -(-h21 * g1  +  h11 * g2) / det;
     gd  = g1 * dA  +  g2 * dB;
 
 
     stepsize = 1;    // Line Search
     while (stepsize >= min_step)
     {
       newA = A + stepsize * dA;
       newB = B + stepsize * dB;
 
       // New function value
       newf = 0.0;
       for (i = 0;  i < numExamples;  i++)
       {
         fApB = dec_values[i] * newA + newB;
         if (fApB >= 0)
           newf += t[i] * fApB + log (1 + exp (-fApB));
         else
           newf += (t[i] - 1) * fApB + log (1 + exp (fApB));
       }
 
       // Check sufficient decrease
       if (newf < fval + 0.0001 * stepsize * gd)
       {
         A    = newA;
         B    = newB;
         fval = newf;
         break;
       }
       else
         stepsize = stepsize / 2.0;
     }
 
     if (stepsize < min_step)
     {
       info("Line search fails in two-class probability estimates\n");
       break;
     }
   }
 
   if  (iter >= max_iter)
     info ("Reaching maximal iterations in two-class probability estimates\n");
 
   delete[]  t;  t = NULL;
 }  /* sigmoid_train */

void SVM289_MFS::solve_c_svc	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si,
		double	Cp,
		double	Cn,
		RunLog &	_log
	)

Definition at line 2414 of file svm2.cpp.

References SVM289_MFS::svm_parameter::eps, SVM289_MFS::svm_problem::numTrainExamples, SVM289_MFS::svm_parameter::shrinking, SVM289_MFS::Solver::Solve(), SVM289_MFS::SVC_Q::SVC_Q(), and SVM289_MFS::svm_problem::y.

Referenced by svm_train_one().

 {
   
   kkint32  numTrainExamples = prob->numTrainExamples;
   double*  minus_ones       = new double[numTrainExamples];
   schar*   y                = new schar [numTrainExamples];
 
   kkint32 i;
 
   for  (i = 0;  i < numTrainExamples;  ++i)
   {
     alpha[i]      = 0;
     minus_ones[i] = -1;
     if  (prob->y[i] > 0) 
       y[i] = +1; 
     else 
       y[i] = -1;
   }
 
   Solver  s;
 
   SVC_Q*  jester = new SVC_Q (*prob, *param, y, _log);
 
   s.Solve (numTrainExamples, 
            *jester, 
            minus_ones, 
            y,
            alpha, 
            Cp, 
            Cn, 
            param->eps, 
            si, 
            param->shrinking
           );
   delete  jester;
   jester = NULL;
 
   double  sum_alpha =0;
 
   for  (i = 0;  i < numTrainExamples;  i++)
     sum_alpha += alpha[i];
 
   //if  (Cp == Cn)
   //  info ("nu = %f\n", sum_alpha / (Cp * prob->numTrainExamples));
 
   for  (i = 0;  i < numTrainExamples;  i++)
     alpha[i] *= y[i];
 
   delete[] minus_ones;
   delete[] y;
 }  /* solve_c_svc */

void SVM289_MFS::solve_epsilon_svr	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si,
		RunLog &	_log
	)

Definition at line 2613 of file svm2.cpp.

References SVM289_MFS::svm_parameter::C, SVM289_MFS::svm_parameter::eps, info(), SVM289_MFS::svm_problem::numTrainExamples, SVM289_MFS::svm_parameter::p, SVM289_MFS::svm_parameter::shrinking, SVM289_MFS::Solver::Solve(), SVM289_MFS::SVR_Q::SVR_Q(), and SVM289_MFS::svm_problem::y.

Referenced by svm_train_one().

 {
   kkint32 numTrainExamples = prob->numTrainExamples;
   double*  alpha2       = new double [2 * numTrainExamples];
   double*  linear_term  = new double [2 * numTrainExamples];
   schar*   y = new schar[2 * numTrainExamples];
   kkint32 i;
 
   for  (i = 0;  i < numTrainExamples;  ++i)
   {
     alpha2[i] = 0;
     linear_term[i] = param->p - prob->y[i];
     y[i] = 1;
 
     alpha2      [i + numTrainExamples] = 0;
     linear_term [i + numTrainExamples] = param->p + prob->y[i];
     y           [i + numTrainExamples] = -1;
   }
 
 
   SVR_Q*  jester = new SVR_Q (*prob, *param, _log);
   Solver s;
   s.Solve (2 * numTrainExamples, 
            *jester, 
            linear_term, 
            y,
            alpha2, 
            param->C, 
            param->C, 
            param->eps, 
            si, 
            param->shrinking
           );
 
   delete  jester;
   jester = NULL;
 
   double sum_alpha = 0;
   for  (i = 0;  i < numTrainExamples;  i++)
   {
     alpha[i] = alpha2[i] - alpha2[i + numTrainExamples];
     sum_alpha += fabs (alpha[i]);
   }
 
   info ("nu = %f\n", sum_alpha / (param->C * numTrainExamples));
 
   delete[] alpha2;
   delete[] linear_term;
   delete[] y;
 }  /* solve_epsilon_svr */

void SVM289_MFS::solve_nu_svc	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si,
		RunLog &	_log
	)

Definition at line 2476 of file svm2.cpp.

References SVM289_MFS::svm_parameter::eps, info(), SVM289_MFS::svm_parameter::nu, SVM289_MFS::svm_problem::numTrainExamples, SVM289_MFS::Solver::SolutionInfo::obj, SVM289_MFS::Solver::SolutionInfo::r, SVM289_MFS::Solver::SolutionInfo::rho, SVM289_MFS::svm_parameter::shrinking, SVM289_MFS::Solver_NU::Solve(), SVM289_MFS::SVC_Q::SVC_Q(), SVM289_MFS::Solver::SolutionInfo::upper_bound_n, SVM289_MFS::Solver::SolutionInfo::upper_bound_p, and SVM289_MFS::svm_problem::y.

Referenced by svm_train_one().

 {
   kkint32  i;
   kkint32  numTrainExamples = prob->numTrainExamples;
   double nu = param->nu;
 
   schar *y = new schar[numTrainExamples];
 
   for  (i = 0;  i < numTrainExamples;  i++)
   {
     if  (prob->y[i] > 0)
       y[i] = +1;
     else
       y[i] = -1;
   }
 
 
   double sum_pos = nu * numTrainExamples / 2;
   double sum_neg = nu * numTrainExamples / 2;
 
   for  (i = 0;  i < numTrainExamples;  i++)
   {
     if  (y[i] == +1)
     {
       alpha[i] = Min(1.0, sum_pos);
       sum_pos -= alpha[i];
     }
     else
     {
       alpha[i] = Min(1.0,sum_neg);
       sum_neg -= alpha[i];
     }
   }
 
   double *zeros = new double[numTrainExamples];
 
   for  (i = 0;  i < numTrainExamples;  i++)
     zeros[i] = 0;
 
   SVM289_MFS::Solver_NU  s;
 
   SVC_Q*  jester = new SVC_Q (*prob, *param, y, _log);
 
   s.Solve (numTrainExamples, 
            *jester, 
            zeros, 
            y,
            alpha, 
            1.0, 
            1.0, 
            param->eps, 
            si,  
            param->shrinking
           );
 
   delete  jester;
   jester = NULL;
 
   double r = si->r;
 
   info ("C = %f\n",1/r);
 
   for  (i = 0;  i < numTrainExamples;  ++i)
     alpha[i] *= y[i] / r;
 
   si->rho /= r;
   si->obj /= (r * r);
   si->upper_bound_p = 1 / r;
   si->upper_bound_n = 1 / r;
 
   delete[] y;
   delete[] zeros;
 }  /* solve_nu_svc */

void SVM289_MFS::solve_one_class	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si,
		RunLog &	_log
	)

Definition at line 2558 of file svm2.cpp.

References SVM289_MFS::svm_parameter::eps, SVM289_MFS::svm_parameter::nu, SVM289_MFS::svm_problem::numTrainExamples, SVM289_MFS::ONE_CLASS_Q::ONE_CLASS_Q(), SVM289_MFS::svm_parameter::shrinking, and SVM289_MFS::Solver::Solve().

Referenced by svm_train_one().

 {
   kkint32  numTrainExamples = prob->numTrainExamples;
 
   double*   zeros = new double [numTrainExamples];
   schar*    ones  = new schar  [numTrainExamples];
   kkint32 i;
 
   kkint32 n = (kkint32)(param->nu * prob->numTrainExamples);  // # of alpha's at upper bound
 
   for  (i = 0;  i < n;  i++)
     alpha[i] = 1;
 
   if  (n < prob->numTrainExamples)
     alpha[n] = param->nu * prob->numTrainExamples - n;
 
   for  (i = n + 1;  i < numTrainExamples;  i++)
     alpha[i] = 0;
 
   for  (i = 0;  i < numTrainExamples;  i++)
   {
     zeros[i] = 0;
     ones [i] = 1;
   }
 
   ONE_CLASS_Q*  jester = new ONE_CLASS_Q (*prob, *param, _log);
 
   Solver s;
   s.Solve (numTrainExamples, 
            *jester, 
            zeros, 
            ones,
            alpha, 
            1.0, 
            1.0, 
            param->eps, 
            si, 
            param->shrinking
           );
 
   delete  jester;  
   jester = NULL;
 
   delete[] zeros;
   delete[] ones;
 }  /* solve_one_class */

const char* SVM289_MFS::svm_check_parameter	(	const struct svm_problem *	prob,
		const struct svm_parameter *	param
	)

kkint32 SVM289_MFS::svm_check_probability_model ( const struct Svm_Model * model )

void SVM289_MFS::svm_cross_validation	(	const svm_problem &	prob,
		const svm_parameter &	param,
		kkint32	nr_fold,
		double *	target,
		RunLog &	log
	)

Definition at line 3661 of file svm2.cpp.

References C_SVC, SVM289_MFS::svm_problem::FileDesc(), NU_SVC, SVM289_MFS::svm_problem::numTrainExamples, SVM289_MFS::svm_parameter::probability, SVM289_MFS::svm_problem::SelFeatures(), svm_destroy_model(), svm_get_nr_class(), svm_group_classes(), SVM289_MFS::svm_problem::svm_problem(), svm_train(), SVM289_MFS::svm_parameter::svm_type, and SVM289_MFS::svm_problem::y.

Referenced by svm_svr_probability().

 {
   kkint32 i;
   kkint32 *fold_start = new kkint32[nr_fold + 1];
   kkint32 numTrainExamples = prob.numTrainExamples;
   kkint32 *perm = new kkint32[numTrainExamples];
   kkint32 nr_class;
 
   // stratified cv may not give leave-one-out rate
   // Each class to l folds -> some folds may have zero elements
   if  ((param.svm_type == SVM_Type::C_SVC || param.svm_type == SVM_Type::NU_SVC)  && 
        (nr_fold < numTrainExamples)
       )
   {
     kkint32 *start = NULL;
     kkint32 *label = NULL;
     kkint32 *count = NULL;
     svm_group_classes (&prob, &nr_class, &label, &start, &count, perm);
 
     // random shuffle and then data grouped by fold using the array perm
     kkint32 *fold_count = new kkint32[nr_fold];
     kkint32 c;
     kkint32 *index = new kkint32[numTrainExamples];
     for  (i = 0;  i < numTrainExamples;  i++)
       index[i] = perm[i];
 
     for (c = 0;  c < nr_class;  c++) 
     {
       for  (i = 0;  i < count[c];  i++)
       {
         kkint32 j = i + rand() % (count[c]-i);
         SVM289_MFS::swap (index[start[c]+j], index[start[c]+i]);
       }
     }
 
     for  (i = 0;  i < nr_fold;  ++i)
     {
       fold_count[i] = 0;
       for  (c = 0;  c < nr_class;  ++c)
         fold_count[i] += (i + 1) * count[c] / nr_fold - i * count[c] / nr_fold;
     }
 
     fold_start[0] = 0;
     for (i = 1;  i <= nr_fold;  i++)
       fold_start[i] = fold_start[i-1] + fold_count[i-1];
 
     for (c=0; c<nr_class;c++)
     {
       for(i=0;i<nr_fold;i++)
       {
         kkint32 begin = start[c]+i*count[c]/nr_fold;
         kkint32 end = start[c]+(i+1)*count[c]/nr_fold;
         for(kkint32 j=begin;j<end;j++)
         {
           perm[fold_start[i]] = index[j];
           fold_start[i]++;
         }
       }
     }
 
     fold_start[0]=0;
     for (i=1;i<=nr_fold;i++)
       fold_start[i] = fold_start[i-1]+fold_count[i-1];
 
     delete start;        start = NULL;
     delete label;       label = NULL;
     delete count;        count = NULL;
     delete index;       index = NULL;
     delete fold_count;  fold_count = NULL;
   }
   else
   {
     for (i = 0;  i < numTrainExamples;  ++i)
       perm[i]=i;
 
     for (i = 0;  i < numTrainExamples;  ++i)
     {
       kkint32 j = i + rand() % (numTrainExamples - i);
       SVM289_MFS::swap (perm[i], perm[j]);
     }
     for  (i = 0;  i <=  nr_fold; i++)
       fold_start[i] = i * numTrainExamples / nr_fold;
   }
 
   for  (i = 0;  i < nr_fold;  i++)
   {
     kkint32 begin = fold_start[i];
     kkint32 end = fold_start[i+1];
     kkint32 j,k;
 
     svm_problem  subprob (prob.SelFeatures (), prob.FileDesc (), log);
 
     subprob.numTrainExamples = numTrainExamples - (end - begin);
     //subprob.x = Malloc(struct svm_node*,subprob.l);
     // subprob.x  will be initialized to an empty FeatureVectorList 
     subprob.y = new double[subprob.numTrainExamples];
       
     k = 0;
     for  (j = 0;  j < begin;  j++)
     {
       //subprob.x[k] = prob->x[perm[j]];
       subprob.x.PushOnBack (prob.x.IdxToPtr (perm[j]));
       subprob.y[k] = prob.y[perm[j]];
       ++k;
     }
 
     for  (j = end;  j < numTrainExamples;  j++)
     {
       //subprob.x[k] = prob->x[perm[j]];
       subprob.x.PushOnBack (prob.x.IdxToPtr (perm[j]));
       subprob.y[k] = prob.y[perm[j]];
       ++k;
     }
 
     Svm_Model*  submodel = svm_train (subprob, param, log);
     if  (param.probability && 
        (param.svm_type == SVM_Type::C_SVC || param.svm_type == SVM_Type::NU_SVC))
     {
       double *prob_estimates = new double[svm_get_nr_class (submodel)];
       kkint32  *votes          = new kkint32 [svm_get_nr_class (submodel)];
 
       for  (j = begin;  j < end;  j++)
         target[perm[j]] = svm_predict_probability (submodel, prob.x[perm[j]], prob_estimates, votes);
       delete  prob_estimates;
       prob_estimates = NULL;
       delete  votes;
       votes = NULL;
     }
     else
     {
       for  (j = begin;  j < end;  j++)
         target[perm[j]] = svm_predict (submodel, prob.x[perm[j]]);
     }
 
     svm_destroy_model (submodel);
     delete  submodel;
     submodel = NULL;
 
     //free(subprob.x);
     delete  subprob.y;   subprob.y = NULL;
   }    
 
   delete fold_start;  fold_start = NULL;
   delete perm;        perm       = NULL;
 }  /* svm_cross_validation */

void SVM289_MFS::svm_destroy_model ( struct Svm_Model *& model )

Definition at line 4611 of file svm2.cpp.

Referenced by svm_cross_validation(), KKMLL::ModelSvmBase::TrainModel(), and KKMLL::ModelSvmBase::~ModelSvmBase().

 {
   //if  (model->weOwnSupportVectors  &&  (model->l > 0))
   //  free ((void *)(model->SV[0]));
   if  (model->weOwnSupportVectors)
     model->SV.Owner (true);
   else
     model->SV.Owner (false);
 
   delete  model;
   model = NULL;
 }

void SVM289_MFS::svm_destroy_param ( struct svm_parameter *& param )

Definition at line 4627 of file svm2.cpp.

 {
   delete  param;
   param = NULL;
 }

void SVM289_MFS::svm_get_labels	(	const struct Svm_Model *	model,
		kkint32 *	label
	)

kkint32 SVM289_MFS::svm_get_nr_class ( const struct Svm_Model * model )

Referenced by svm_cross_validation().

kkint32 SVM289_MFS::svm_get_svm_type ( const struct Svm_Model * model )

double SVM289_MFS::svm_get_svr_probability ( const struct Svm_Model * model )

double SVM289_MFS::svm_predict	(	const struct Svm_Model *	model,
		const FeatureVector &	x
	)

Referenced by KKMLL::ModelSvmBase::Predict(), and svm_predict_probability().

double SVM289_MFS::svm_predict_probability	(	Svm_Model *	model,
		const FeatureVector &	x,
		double *	prob_estimates,
		kkint32 *	votes
	)

Definition at line 3988 of file svm2.cpp.

References C_SVC, SVM289_MFS::Svm_Model::DecValues(), SVM289_MFS::Svm_Model::label, SVM289_MFS::Svm_Model::NormalizeProbability(), SVM289_MFS::Svm_Model::nr_class, NU_SVC, SVM289_MFS::Svm_Model::PairwiseProb(), SVM289_MFS::Svm_Model::param, SVM289_MFS::Svm_Model::probA, SVM289_MFS::Svm_Model::probB, SVM289_MFS::Svm_Model::ProbEstimates(), SVM289_MFS::svm_parameter::probParam, svm_predict(), svm_predict_values(), and SVM289_MFS::svm_parameter::svm_type.

Referenced by KKMLL::ModelSvmBase::Predict(), and KKMLL::ModelSvmBase::ProbabilitiesByClass().

 {
   double  probParam = model->param.probParam;
 
   if  ((model->param.svm_type == SVM_Type::C_SVC  ||  model->param.svm_type == SVM_Type::NU_SVC)  &&  
        ((model->probA != NULL  &&  model->probB != NULL)  ||  (probParam > 0.0))
       )
   {
     kkint32   i;
     kkint32   nr_class = model->nr_class;
 
     double*  prob_estimates = model->ProbEstimates ();
     double*  dec_values     = model->DecValues     ();
     double** pairwise_prob  = model->PairwiseProb  ();
 
     for  (i = 0;  i < nr_class;  ++i)
       votes[i] = 0;
 
     svm_predict_values (model, x, dec_values);
 
     double min_prob = 1e-7;
 
     kkint32 k = 0;
     for (i = 0;  i < nr_class;  ++i)
     {
       for (kkint32 j = i + 1;  j < nr_class;  ++j)
       {
         if  (probParam > 0.0)
         {
           double probability = (double)(1.0 / (1.0 + exp (-1.0 * probParam * dec_values[k])));
           pairwise_prob[i][j] = Min (Max (probability, min_prob), 1.0 - min_prob);
           pairwise_prob[j][i] = 1.0 - pairwise_prob[i][j];
         }
         else
         {
           pairwise_prob[i][j] = Min (Max (sigmoid_predict (dec_values[k], model->probA[k], model->probB[k]), min_prob), 1.0 - min_prob);
           pairwise_prob[j][i] = 1.0 - pairwise_prob[i][j];
         }
 
         if  (pairwise_prob[i][j] > 0.5)
           votes[model->label[i]]++;
         else
           votes[model->label[j]]++;
 
         k++;
       }
     }
 
     // The 'pairwise_prob' and 'prob_estimates' variables are actually located
     // in 'model'.  So by calling 'NormalizeProbability'  we normalize 
     // 'prob_estimates'.
     model->NormalizeProbability (); 
 
     //multiclass_probability (nr_class, pairwise_prob, prob_estimates);
 
     kkint32 prob_max_idx = 0;
     for (i = 1;  i < nr_class;  i++)
     {
       if  (prob_estimates[i] > prob_estimates[prob_max_idx])
         prob_max_idx = i;
     }
 
     for (i = 0;  i < nr_class;  i++)
       classProbabilities[model->label[i]] = prob_estimates[i];
 
     return  model->label[prob_max_idx];
   }
   else 
   {
     return  svm_predict (model, x);
   }
 }  /* svm_predict_probability */

void SVM289_MFS::svm_predict_values	(	const Svm_Model *	model,
		const FeatureVector &	x,
		double *	dec_values
	)

Definition at line 3856 of file svm2.cpp.

References EPSILON_SVR, SVM289_MFS::Svm_Model::nr_class, SVM289_MFS::Svm_Model::nSV, NU_SVR, SVM289_MFS::Svm_Model::numSVs, ONE_CLASS, SVM289_MFS::Svm_Model::param, SVM289_MFS::Svm_Model::rho, SVM289_MFS::Svm_Model::sv_coef, and SVM289_MFS::svm_parameter::svm_type.

Referenced by svm_predict_probability().

 {
   if  (model->param.svm_type == SVM_Type::ONE_CLASS    ||
        model->param.svm_type == SVM_Type::EPSILON_SVR  ||
        model->param.svm_type == SVM_Type::NU_SVR
       )
   {
     double *sv_coef = model->sv_coef[0];
     double sum = 0;
     for  (kkint32 i = 0;  i < model->numSVs;  i++)
       sum += sv_coef[i] * Kernel::k_function (x, 
                                               model->SV[i], 
                                               model->param, 
                                               model->selFeatures
                                              );
     sum -= model->rho[0];
     *dec_values = sum;
   }
   else
   {
     kkint32 i;
     kkint32 nr_class = model->nr_class;
     kkint32 numSVs = model->numSVs;
     
     double *kvalue = new double[numSVs];
     for  (i = 0;  i < numSVs;  i++)
       kvalue[i] = Kernel::k_function (x, model->SV[i], model->param, model->selFeatures);
 
     kkint32 *start = new kkint32[nr_class];
     start[0] = 0;
     for  (i = 1;  i < nr_class;  i++)
       start[i] = start[i-1]+model->nSV[i-1];
 
     kkint32  p=0;
     for  (i = 0;  i < nr_class;  i++)
     {
       for  (kkint32 j = i + 1;  j < nr_class;  j++)
       {
         double sum = 0;
         kkint32 si = start[i];
         kkint32 sj = start[j];
         kkint32 ci = model->nSV[i];
         kkint32 cj = model->nSV[j];
         
         kkint32 k;
         double *coef1 = model->sv_coef[j - 1];
         double *coef2 = model->sv_coef[i];
         for  (k = 0;  k < ci;  k++)
           sum += coef1[si + k] * kvalue[si + k];
 
 
         for  (k = 0;  k < cj;  k++)
           sum += coef2[sj + k] * kvalue[sj + k];
 
         sum -= model->rho[p];
         dec_values[p] = sum;
         p++;
       }
     }
 
     delete  kvalue;   kvalue = NULL;
     delete  start;    start  = NULL;
   }
 }  /* svm_predict_values */

Svm_Model * SVM289_MFS::svm_train	(	const svm_problem &	prob,
		const svm_parameter &	param,
		RunLog &	log
	)

Definition at line 3345 of file svm2.cpp.

Referenced by svm_binary_svc_probability(), svm_cross_validation(), and KKMLL::ModelSvmBase::TrainModel().

 {
   Svm_Model*  model = new Svm_Model (param, prob.SelFeatures (), prob.FileDesc ());
 
   model->weOwnSupportVectors = false;
 
   if  ((param.svm_type == SVM_Type::ONE_CLASS)    ||
        (param.svm_type == SVM_Type::EPSILON_SVR)  ||
        (param.svm_type == SVM_Type::NU_SVR)
       )
   {
     // regression or one-class-svm
     model->nr_class = 2;
     model->label    = NULL;
     model->nSV      = NULL;
     model->probA    = NULL; 
     model->probB    = NULL;
     model->sv_coef  = new double*[1];
 
     if  (param.probability  &&  (param.svm_type == SVM_Type::EPSILON_SVR  ||  param.svm_type == SVM_Type::NU_SVR))
     {
       model->probA = new double[1];
       model->probA[0] = svm_svr_probability (prob, param, log);
     }
 
     decision_function f = svm_train_one (prob, param, 0, 0, log);
     model->rho = new double[1];
     model->rho[0] = f.rho;
 
     kkint32 nSV = 0;
     kkint32 i;
     for  (i = 0;  i < prob.numTrainExamples;  ++i)
     {
       if  (fabs(f.alpha[i]) > 0) 
         ++nSV;
     }
 
     model->numSVs = nSV;
     //model->SV = Malloc(svm_node *,nSV);
     // model->SV is now a FeatureVectorList object that was initialized to empty and not owner in the constructor
     model->SV.Owner (true);
     model->sv_coef[0] = new double[nSV];
     kkint32 j = 0;
     for  (i = 0;  i < prob.numTrainExamples;  ++i)
     {
       if  (fabs (f.alpha[i]) > 0)
       {
         //model->SV[j] = prob->x[i];
         model->SV.PushOnBack (new FeatureVector (prob.x[i]));
         model->sv_coef[0][j] = f.alpha[i];
         ++j;
       }    
     }
 
     delete  f.alpha;  f.alpha = NULL;
   }
   else
   {
     // Classification
     kkint32 l = prob.numTrainExamples;
     kkint32 nr_class;
     kkint32 *label = NULL;
     kkint32 *start = NULL;
     kkint32 *count = NULL;
     kkint32 *perm = new kkint32[l];
 
     // group training data of the same class
     svm_group_classes (&prob, 
                        &nr_class,
                        &label,
                        &start,
                        &count,
                        perm
                       );
 
     kkint32  numBinaryCombos = nr_class * (nr_class - 1) / 2;
 
     //svm_node **x = Malloc(svm_node *,l);
     FeatureVectorList x (prob.FileDesc (), false);
 
     kkint32 i;
     for  (i = 0;  i < l;  i++)
     {
       //x[i] = prob->x[perm[i]];
       x.PushOnBack (prob.x.IdxToPtr (perm[i]));
     }
 
     // calculate weighted C
     double*  weighted_C = new double[nr_class];
     for  (i = 0;  i < nr_class;  i++)
       weighted_C[i] = param.C;
 
     for  (i = 0;  i < param.nr_weight;  i++)
     {  
       kkint32 j;
       for  (j = 0;  j < nr_class;  j++)
       {
         if  (param.weight_label[i] == label[j])
           break;
       }
 
       if  (j == nr_class)
         fprintf(stderr,"warning: class label %d specified in weight is not found\n", param.weight_label[i]);
       else
         weighted_C[j] *= param.weight[i];
     }
 
     // train k*(k-1)/2 models
     
     bool *nonzero = new bool[l];
 
     for  (i = 0;  i < l;  i++)
       nonzero[i] = false;
 
     decision_function *f = new decision_function[numBinaryCombos];
 
     double*  probA = NULL;
     double*  probB = NULL;
 
     if (param.probability)
     {
       probA = new double[numBinaryCombos];
       probB = new double[numBinaryCombos];
     }
 
     kkint32 p = 0;
     for  (i = 0;  i < nr_class;  i++)
     {
       for  (kkint32 j = i + 1;  j < nr_class;  j++)
       {
         svm_problem  sub_prob (prob.SelFeatures (), prob.FileDesc (), log);
         kkint32 si = start[i], sj = start[j];
         kkint32 ci = count[i], cj = count[j];
         sub_prob.numTrainExamples = ci + cj;
         //sub_prob.x = Malloc (svm_node *,sub_prob.l);
         sub_prob.y = new double[sub_prob.numTrainExamples];
         kkint32 k;
         for  (k = 0;  k < ci;  k++)
         {
           //sub_prob.x[k] = x[si+k];
           sub_prob.x.PushOnBack (x.IdxToPtr (si + k));
           sub_prob.y[k] = +1;
         }
         for  (k = 0;  k < cj;  k++)
         {
           //sub_prob.x[ci+k] = x[sj+k];
           sub_prob.x.PushOnBack (x.IdxToPtr (sj + k));
           sub_prob.y[ci + k] = -1;
         }
 
         if  (param.probability)
           svm_binary_svc_probability (&sub_prob, &param, weighted_C[i], weighted_C[j], probA[p], probB[p], log);
 
 
         f[p] = svm_train_one (sub_prob, param, weighted_C[i], weighted_C[j], log);
 
         for  (k = 0;  k < ci;  k++)
         {
           if  (!nonzero[si + k]  &&  fabs(f[p].alpha[k]) > 0)
             nonzero[si + k] = true;
         }
 
         for  (k = 0;  k < cj;  k++)
         {
           if  (!nonzero[sj + k]  &&  fabs(f[p].alpha[ci+k]) > 0)
             nonzero[sj + k] = true;
         }
 
         //free(sub_prob.x);
         delete  sub_prob.y;  
         sub_prob.y = NULL;
         ++p;
       }
     }
 
 
     // At this point all the Binary Classifiers have been built.  They are now going 
     // to be packaged into one not so neat model.
 
     // build output
     model->nr_class = nr_class;
     
     model->label = new kkint32[nr_class];
     for  (i = 0;  i < nr_class;  i++)
       model->label[i] = label[i];
     
     model->rho = new double[numBinaryCombos];
     for  (i = 0;  i < numBinaryCombos;  i++)
       model->rho[i] = f[i].rho;
 
     if  (param.probability)
     {
       model->probA = new double[numBinaryCombos];
       model->probB = new double[numBinaryCombos];
       for  (i = 0;  i < numBinaryCombos;  i++)
       {
         model->probA[i] = probA[i];
         model->probB[i] = probB[i];
       }
     }
     else
     {
       model->probA = NULL;
       model->probB = NULL;
     }
 
     kkint32 total_sv = 0;
     kkint32*  nz_count = new kkint32[nr_class];
 
     model->nSV = new kkint32[nr_class];
     for  (i = 0;  i < nr_class;  i++)
     {
       kkint32 nSV = 0;
       for  (kkint32 j = 0;  j < count[i];  j++)
       {
         if  (nonzero[start[i] + j])
         {  
           ++nSV;
           ++total_sv;
         }
       }
       model->nSV[i] = nSV;
       nz_count[i]   = nSV;
     }
     
     info("Total nSV = %d\n",total_sv);
 
     model->numSVs = total_sv;
     //model->SV = Malloc(svm_node *, total_sv);
     model->SV.DeleteContents ();
     model->SV.Owner (false);
     model->weOwnSupportVectors = false;
 
     p = 0;
     for  (i = 0;  i < l;  i++)
     {
       if  (nonzero[i])
       {
         //model->SV[p++] = x[i];
         model->SV.PushOnBack (x.IdxToPtr (i));
         p++;
       }
     }
 
     kkint32 *nz_start = new kkint32[nr_class];
     nz_start[0] = 0;
     for  (i = 1;  i < nr_class;  i++)
       nz_start[i] = nz_start[i - 1] + nz_count[i - 1];
 
     model->sv_coef = new double*[nr_class - 1];
     for  (i = 0;  i < nr_class - 1;  i++)
       model->sv_coef[i] = new double[total_sv];
 
     p = 0;
     for  (i = 0;  i < nr_class;  i++)
     {
       for  (kkint32 j = i + 1;  j < nr_class;  j++)
       {
         // classifier (i,j): coefficients with
         // i are in sv_coef[j-1][nz_start[i]...],
         // j are in sv_coef[i][nz_start[j]...]
 
         kkint32 si = start[i];
         kkint32 sj = start[j];
         kkint32 ci = count[i];
         kkint32 cj = count[j];
         
         kkint32 q = nz_start[i];
         kkint32 k;
     
         for  (k = 0;  k < ci;  k++)
         {
           if  (nonzero[si + k])
             model->sv_coef[j - 1][q++] = f[p].alpha[k];
         }
 
         q = nz_start[j];
         for  (k = 0;  k < cj;  k++)
         {
           if  (nonzero[sj + k])
             model->sv_coef[i][q++] = f[p].alpha[ci + k];
         }
         ++p;
       }
     }
 
     delete label;  label = NULL;
     delete probA;  probA = NULL;
     delete probB;  probB = NULL;
     delete count;  count = NULL;
     delete perm;   perm  = NULL;
     delete start;  start = NULL;
     //free (x);
     delete weighted_C;  weighted_C = NULL;
     delete nonzero;     nonzero    = NULL;
     for  (i = 0;  i < numBinaryCombos;  i++)
     {
       delete f[i].alpha;
       f[i].alpha = NULL;
     }
     delete f;          f = NULL;
     delete nz_count;   nz_count = NULL;
     delete nz_start;   nz_start = NULL;
   }
 
   return  model;
 }  /* svm_train */

decision_function SVM289_MFS::svm_train_one	(	const svm_problem &	prob,
		const svm_parameter &	param,
		double	Cp,
		double	Cn,
		RunLog &	_log
	)

Definition at line 2744 of file svm2.cpp.

References SVM289_MFS::decision_function::alpha, C_SVC, KKB::KKStr::Concat(), EPSILON_SVR, KKB::KKException::KKException(), NU_SVC, NU_SVR, SVM289_MFS::svm_problem::numTrainExamples, ONE_CLASS, SVM289_MFS::Solver::SolutionInfo::rho, SVM289_MFS::decision_function::rho, solve_c_svc(), solve_epsilon_svr(), solve_nu_svc(), solve_nu_svr(), solve_one_class(), SVM289_MFS::svm_parameter::svm_type, and SVM289_MFS::svm_problem::y.

Referenced by svm_train().

 {
   double*  alpha = new double [prob.numTrainExamples];
   Solver::SolutionInfo  si;
 
   switch  (param.svm_type)
   {
     case SVM_Type::C_SVC:       solve_c_svc       (&prob, &param, alpha, &si, Cp, Cn, _log);    break;
     case SVM_Type::NU_SVC:      solve_nu_svc      (&prob, &param, alpha, &si, _log);            break;
     case SVM_Type::ONE_CLASS:   solve_one_class   (&prob, &param, alpha, &si, _log);            break;
     case SVM_Type::EPSILON_SVR: solve_epsilon_svr (&prob, &param, alpha, &si, _log);            break;
     case SVM_Type::NU_SVR:      solve_nu_svr      (&prob, &param, alpha, &si, _log);            break;
 
     default:
       {
         KKStr errMsg = "SVM289_MFS::svm_train_one   ***ERROR***   Invalid Solver Defined.";
         errMsg << "   Solver[" << (int)param.svm_type << "]";
         _log.Level (-1) << endl << endl << errMsg << endl << endl;
         throw KKException (errMsg);
       }
   }
 
   //info ("obj = %f, rho = %f\n", si.obj, si.rho);
 
   // output SVs
 
   std::vector<kkint32> SVIndex;     // Normalize by Margin Width(NMW).
 
   kkint32 nSV   = 0;
   kkint32 nBSV  = 0;
   for  (kkint32 i = 0;  i < prob.numTrainExamples;  i++)
   {
     if  (fabs (alpha[i]) > 0)
     {
       ++nSV;
       SVIndex.push_back (i);    // NMW
       if  (prob.y[i] > 0)
       {
         if  (fabs (alpha[i]) >= si.upper_bound_p)
         {
           ++nBSV;
           // BSVIndex.insert (prob->index[i]);   // NMW
         }
       }
       else
       {
         if  (fabs (alpha[i]) >= si.upper_bound_n)
         {
           ++nBSV;
           // BSVIndex.insert (prob->index[i]);
         }
       }
     }
   }
 
 
   //**********************************************************************************
   //  Code to normalize by margin width.
 
   
   double sum=0.0;
   std::vector<kkint32>::iterator it,it2;
   double kvalue = 0.0;
 
   for (it = SVIndex.begin();  it < SVIndex.end();  it++)
   {
     for  (it2 = SVIndex.begin(); it2 < SVIndex.end();  it2++)
     {
       kkint32 k  = *it;
       kkint32 kk = *it2;
 
       kvalue = Kernel::k_function (prob.x[k], prob.x[kk], param, prob.SelFeatures ());
 
       sum += prob.y[k] * prob.y[kk] * alpha[k] * alpha[kk] * kvalue;
     }
   }
 
   sum /= SVIndex.size();
   sum = sqrt(sum);
 
   for  (it = SVIndex.begin();  it < SVIndex.end();  it++)
     alpha[*it] /= sum;
 
   si.rho /= sum;
   
   //info ("nSV = %d, nBSV = %d\n", nSV, nBSV);
 
   decision_function  f;
   f.alpha  = alpha;
   f.rho    = si.rho;
   return  f;
 }  /* svm_train_one */

SVM_Type SVM289_MFS::SVM_Type_FromStr ( KKStr s )

Definition at line 534 of file svm2.cpp.

References C_SVC, EPSILON_SVR, KKB::KKStr::EqualIgnoreCase(), NU_SVC, NU_SVR, ONE_CLASS, KKB::KKStr::operator==(), SVM_NULL, and KKB::KKStr::Upper().

Referenced by SVM289_MFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ProcessSvmParameter(), and SVM289_MFS::Svm_Model::ReadXML().

 {
   s.Upper ();
 
   if  ((s.EqualIgnoreCase ("C_SVC"))        ||  (s == "0"))  return SVM_Type::C_SVC;
   if  ((s.EqualIgnoreCase ("NU_SVC"))       ||  (s == "1"))  return SVM_Type::NU_SVC;
   if  ((s.EqualIgnoreCase ("ONE_CLASS"))    ||  (s == "2"))  return  SVM_Type::ONE_CLASS;
   if  ((s.EqualIgnoreCase ("EPSILON_SVR"))  ||  (s == "3"))  return  SVM_Type::EPSILON_SVR;
   if  ((s.EqualIgnoreCase ("NU_SVR"))       ||  (s == "4"))  return  SVM_Type::NU_SVR;
 
   return  SVM_Type::SVM_NULL;
 }

KKStr SVM289_MFS::SVM_Type_ToStr ( SVM_Type svmType )

Definition at line 549 of file svm2.cpp.

References C_SVC, EPSILON_SVR, NU_SVC, NU_SVR, and ONE_CLASS.

Referenced by SVM289_MFS::svm_parameter::ToTabDelStr(), and SVM289_MFS::Svm_Model::WriteXML().

 {
   switch  (svmType)
   {
   case  SVM_Type::C_SVC:        return  "c_svc";
   case  SVM_Type::NU_SVC:       return  "nu_svc";
   case  SVM_Type::ONE_CLASS:    return  "one_class";
   case  SVM_Type::EPSILON_SVR:  return  "epsilon_svr";
   case  SVM_Type::NU_SVR:       return  "nu_svr";
   }
   return  "NULL";
 }

template<class T >

void SVM289_MFS::swap	(	T &	x,
		T &	y
	)

inline

Definition at line 283 of file svm2.h.

283 { T t=x; x=y; y=t; }

Variable Documentation

kkint32 SVM289_MFS::libsvm_version

void(* SVM289_MFS::svm_print_string)(const char *) = &print_string_stdout

Definition at line 604 of file svm2.cpp.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation