This is version 2.33 of "Chih-Chung Chang" and "Chih-Jen Lin" Support vector Machine; the class "ModelOldSVM" calls ths version. More...

Classes
class	Cache

struct	decision_function

class	Kernel
	Kernel evaluation. More...

class	ONE_CLASS_Q

class	Solver

class	Solver_NU

class	SVC_Q

struct	svm_node

struct	svm_parameter

struct	svm_problem

struct	SvmModel233

class	SVR_Q

Typedefs
typedef signed char	schar

typedef XmlElementTemplate< SvmModel233 >	XmlElementSvmModel233

typedef XmlElementSvmModel233 *	XmlElementSvmModel233Ptr

Enumerations
enum	{ C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR }

enum	{ LINEAR, POLY, RBF, SIGMOID }

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

void	info (const char *fmt,...)

void	info_flush ()

template<class T >
T	max (T x, T y)

template<class T >
T	min (T x, T y)

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

static void	solve_c_svc (const svm_problem prob, const svm_parameter param, double alpha, Solver::SolutionInfo si, double *C_)

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

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

static void	solve_nu_svr (const svm_problem prob, const svm_parameter param, double alpha, Solver::SolutionInfo si)

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

svm_problem *	svm_BuildProbFromTwoClassModel (const SvmModel233 *model, kkint32 excludeSupportVectorIDX)

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

void	svm_destroy_model (struct SvmModel233 *model)

void	svm_get_labels (const struct SvmModel233 model, kkint32 label)

kkint32	svm_get_nr_class (const struct SvmModel233 *model)

void	svm_GetSupportVectorStatistics (const struct SvmModel233 *model, kkint32 &numSVs, kkint32 &totalNumSVs)
	Extract Support Vector statistics . More...

struct SvmModel233 *	Svm_Load_Model (std::istream &f, RunLog &log)

void	svm_margin (SvmModel233 *model)

double	svm_predict (const struct SvmModel233 model, const struct svm_node x)

double	svm_predict (const struct SvmModel233 model, const svm_node x, std::vector< double > &dist, std::vector< kkint32 > &winners, kkint32 excludeSupportVectorIDX)
	Predicts a class for the specified training example. More...

double	svm_predictTwoClasses (const SvmModel233 model, const svm_node x, double &dist, kkint32 excludeSupportVectorIDX)

void	Svm_Save_Model (std::ostream &o, const SvmModel233 *model)

struct SvmModel233 *	svm_train (const struct svm_problem prob, const struct svm_parameter param)

decision_function	svm_train_one (const svm_problem prob, const svm_parameter param)

decision_function	svm_train_one (const svm_problem prob, const svm_parameter param, double Cp, double Cn, std::set< kkint32 > &BSVIndex)

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

	XmlFactoryMacro (SvmModel233) typedef float Qfloat

Variables
const kkint32	SCALE = 100

Detailed Description

This is version 2.33 of "Chih-Chung Chang" and "Chih-Jen Lin" Support vector Machine; the class "ModelOldSVM" calls ths version.

This is a vesion 2.33 of "Chih-Chung Chang" and "Chih-Jen Lin" libSVM (Support Vector Machine); the class "ModelOldSVM" calls ths version.

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 Tong Luo and Kurt Kramer.

Typedef Documentation

typedef signed char SVM233::schar

Definition at line 522 of file svm.cpp.

typedef XmlElementTemplate<SvmModel233> SVM233::XmlElementSvmModel233

Definition at line 206 of file svm.h.

typedef XmlElementSvmModel233* SVM233::XmlElementSvmModel233Ptr

Definition at line 207 of file svm.h.

Enumeration Type Documentation

anonymous enum

Enumerator
C_SVC
NU_SVC
ONE_CLASS
EPSILON_SVR
NU_SVR

Definition at line 62 of file svm.h.

62 { C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR }; /* svm_type */

SVM233::NU_SVC

Definition: svm.h:62

SVM233::C_SVC

Definition: svm.h:62

SVM233::ONE_CLASS

Definition: svm.h:62

SVM233::NU_SVR

Definition: svm.h:62

SVM233::EPSILON_SVR

Definition: svm.h:62

anonymous enum

Enumerator
LINEAR
POLY
RBF
SIGMOID

Definition at line 63 of file svm.h.

63 { LINEAR, POLY, RBF, SIGMOID }; /* kernel_type */

SVM233::RBF

Definition: svm.h:63

LINEAR

#define LINEAR

Definition: UsfCasCor.h:221

SVM233::POLY

Definition: svm.h:63

SIGMOID

#define SIGMOID

Definition: UsfCasCor.h:219

Function Documentation

template<class S , class T >

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

inline

Definition at line 690 of file svm.cpp.

References svm_train_one().

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

void SVM233::info	(	const char *	fmt,
			...
	)

Definition at line 715 of file svm.cpp.

Referenced by SVM233::Solver::Solve(), solve_c_svc(), solve_epsilon_svr(), solve_nu_svc(), solve_nu_svr(), and svm_train_one().

715 {}

void SVM233::info_flush ( )

Definition at line 716 of file svm.cpp.

Referenced by SVM233::Solver::Solve().

716 {}

template<class T >

T SVM233::max	(	T	x,
		T	y
	)

inline

Definition at line 680 of file svm.cpp.

References svm_train_one().

680 { return (x>y)?x:y; }

template<class T >

T SVM233::min	(	T	x,
		T	y
	)

inline

Definition at line 676 of file svm.cpp.

References svm_train_one().

676 { return (x<y)?x:y; }

static void SVM233::solve_c_svc	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si,
		double	Cp,
		double	Cn
	)

static

Definition at line 2811 of file svm.cpp.

References SVM233::svm_parameter::C, SVM233::svm_parameter::eps, info(), SVM233::svm_problem::l, SVM233::svm_parameter::shrinking, SVM233::Solver::Solve(), SVM233::SVC_Q::SVC_Q(), and SVM233::svm_problem::y.

Referenced by svm_train_one().

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

static void SVM233::solve_c_svc	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si,
		double *	C_
	)

static

Definition at line 2864 of file svm.cpp.

References SVM233::svm_parameter::C, SVM233::svm_parameter::eps, info(), SVM233::svm_problem::l, SVM233::svm_parameter::shrinking, SVM233::Solver::Solve(), SVM233::SVC_Q::SVC_Q(), and SVM233::svm_problem::y.

Referenced by svm_train_one().

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

static void SVM233::solve_epsilon_svr	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si
	)

static

Definition at line 3008 of file svm.cpp.

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

Referenced by svm_train_one().

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

static void SVM233::solve_nu_svc	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si
	)

static

Definition at line 2914 of file svm.cpp.

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

Referenced by svm_train_one().

 {
   kkint32 i;
   kkint32 l = prob->l;
   double nu = param->nu;
 
   schar *y = new schar[l];
 
   for(i=0;i<l;i++)
     if(prob->y[i]>0)
       y[i] = +1;
     else
       y[i] = -1;
 
   double sum_pos = nu*l/2;
   double sum_neg = nu*l/2;
 
   for(i=0;i<l;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[l];
 
     for(i=0;i<l;i++)
       zeros[i] = 0;
 
     Solver_NU s;
     s.Solve(l, SVC_Q(*prob,*param,y), zeros, y,
       alpha, 1.0, 1.0, param->eps, si,  param->shrinking);
     double r = si->r;
 
     info("C = %f\n",1/r);
 
     for(i=0;i<l;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 */

static void SVM233::solve_nu_svr	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si
	)

static

Definition at line 3059 of file svm.cpp.

References SVM233::svm_parameter::C, SVM233::svm_parameter::eps, info(), SVM233::svm_problem::l, SVM233::svm_parameter::nu, SVM233::Solver::SolutionInfo::r, SVM233::svm_parameter::shrinking, SVM233::Solver_NU::Solve(), SVM233::SVR_Q::SVR_Q(), and SVM233::svm_problem::y.

Referenced by svm_train_one().

 {
   kkint32 l = prob->l;
   double C = param->C;
   double *alpha2 = new double[2*l];
   double *linear_term = new double[2*l];
   schar *y = new schar[2*l];
   kkint32 i;
 
   double sum = C * param->nu * l / 2;
   for(i=0;i<l;i++)
   {
     alpha2[i] = alpha2[i+l] = min(sum,C);
     sum -= alpha2[i];
 
     linear_term[i] = - prob->y[i];
     y[i] = 1;
 
     linear_term[i+l] = prob->y[i];
     y[i+l] = -1;
   }
 
   Solver_NU s;
   s.Solve(2*l, SVR_Q(*prob,*param), linear_term, y,
     alpha2, C, C, param->eps, si, param->shrinking);
 
   info("epsilon = %f\n",-si->r);
 
   for (i = 0; i < l;  i++)
   {
     alpha[i] = alpha2[i] - alpha2[i + l];
   }
 
   delete[] alpha2;
   delete[] linear_term;
   delete[] y;
 }

static void SVM233::solve_one_class	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double *	alpha,
		Solver::SolutionInfo *	si
	)

static

Definition at line 2973 of file svm.cpp.

References SVM233::svm_parameter::eps, SVM233::svm_problem::l, SVM233::svm_parameter::nu, SVM233::ONE_CLASS_Q::ONE_CLASS_Q(), SVM233::svm_parameter::shrinking, and SVM233::Solver::Solve().

Referenced by svm_train_one().

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

svm_problem * SVM233::svm_BuildProbFromTwoClassModel	(	const SvmModel233 *	model,
		kkint32	excludeSupportVectorIDX
	)

Parameters

excludeSupportVectorIDX Specify index of a S/V to remove from computation.

Definition at line 4356 of file svm.cpp.

References SVM233::SvmModel233::dim, EPSILON_SVR, SVM233::svm_node::index, SVM233::svm_problem::index, SVM233::svm_problem::l, SVM233::SvmModel233::l, SVM233::SvmModel233::nr_class, SVM233::SvmModel233::nSV, NU_SVR, ONE_CLASS, SVM233::SvmModel233::param, SVM233::SvmModel233::SV, SVM233::svm_problem::svm_problem(), SVM233::svm_parameter::svm_type, SVM233::svm_node::value, SVM233::svm_problem::weOwnContents, SVM233::svm_problem::x, and SVM233::svm_problem::y.

Referenced by KKMLL::SVMModel::FindWorstSupportVectors2().

 {
   if  (model->param.svm_type == ONE_CLASS   ||
        model->param.svm_type == EPSILON_SVR ||
        model->param.svm_type == NU_SVR
       )
   {
     return NULL;
   }
 
   kkint32 nr_class = model->nr_class;
   if  (nr_class != 2)
   {
     printf ("\n\n\n svm_predictTwoClasses  *** ERROR ***  NumOf Classes != 2\n\n");
     return NULL;
   }
 
   if  (model->dim > 0)
   {
     cerr << std::endl
          << "SVM233::svm_BuildProbFromTwoClassModel   ***ERROR***    model->dim[" << model->dim << "] > 0" << std::endl
          << std::endl;
     return NULL;
   }
 
 
   kkint32 l = model->l;
   kkint32  numSVsFirstClass = model->nSV[0];
 
   svm_problem*  newProb = new svm_problem ();
   newProb->weOwnContents = true;
   newProb->l = l;
   if  ((excludeSupportVectorIDX >= 0)  &&  (excludeSupportVectorIDX < l))
      (newProb->l)--;
 
   newProb->y     = new double[newProb->l];
   newProb->x     = new svm_node*[newProb->l];
   newProb->index = new kkint32[newProb->l];
 
   kkint32  newIDX = 0;
   for (kkint32 svIDX = 0;  svIDX < l;  svIDX++)
   {
     if  (svIDX == excludeSupportVectorIDX)
       continue;
 
     if  (svIDX < numSVsFirstClass)
       newProb->y[newIDX] = 0;
     else
       newProb->y[newIDX] = 1;
 
     newProb->index[newIDX] = newIDX;
     newProb->exampleNames.push_back (model->exampleNames[svIDX]);
 
     {
       kkint32  numElements = 0;
       svm_node* nextNode = model->SV[svIDX];
       while  (nextNode->index != -1)
       {
         numElements++;
         nextNode++;
       }
       numElements++;
 
       newProb->x[newIDX] = new svm_node[numElements];
 
       for  (kkint32  fnIDX = 0;  fnIDX < numElements;  fnIDX++)
       {
         newProb->x[newIDX][fnIDX].index = model->SV[svIDX][fnIDX].index;
         newProb->x[newIDX][fnIDX].value = model->SV[svIDX][fnIDX].value;
       }
     }
 
     newIDX++;
   }
 
   return  newProb;
 }  /* svm_BuildProbFromTwoClassModel */

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

void SVM233::svm_destroy_model ( struct SvmModel233 * model )

Definition at line 4442 of file svm.cpp.

Referenced by KKMLL::SvmDestroyModel().

 {
   delete model;
   model = NULL;
 }

void SVM233::svm_get_labels	(	const struct SvmModel233 *	model,
		kkint32 *	label
	)

kkint32 SVM233::svm_get_nr_class ( const struct SvmModel233 * model )

void SVM233::svm_GetSupportVectorStatistics	(	const struct SvmModel233 *	model,
		kkint32 &	numSVs,
		kkint32 &	totalNumSVs
	)

Extract Support Vector statistics .

Parameters

[in]	model	Training Support Vector Machine.
[out]	numSVs	The number of training examples selected as Support Vectors.
[out]	totalNumSVs	Total number of SVs used by all the binary classifiers.

Definition at line 4776 of file svm.cpp.

References KKB::KKStr::Concat(), EPSILON_SVR, KKB::KKException::KKException(), SVM233::SvmModel233::l, SVM233::SvmModel233::nr_class, SVM233::SvmModel233::nSV, NU_SVR, ONE_CLASS, SVM233::SvmModel233::param, SVM233::SvmModel233::sv_coef, and SVM233::svm_parameter::svm_type.

Referenced by KKMLL::SVMModel::SupportVectorStatistics().

 {
   numSVs      = 0;
   totalNumSVs = 0;
 
   if  (model == NULL)
   {
     KKStr errMsg = "svm_GetupportVectorsStatistics  ***ERROR***   (model == NULL).   Model was not defined.";
     cerr << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (model->param.svm_type == ONE_CLASS   ||
        model->param.svm_type == EPSILON_SVR ||
        model->param.svm_type == NU_SVR
       )
   {
     cerr << endl << endl
       << "svm_GetupportVectorsStatistics   ***ERROR***   This function does not support for SVM Type[" << model->param.svm_type << "]" << endl
       << endl;
     return;
   }
 
   numSVs = model->l;
 
   {
     kkint32 i;
     kkint32 nr_class = model->nr_class;
 
     kkint32 l = model->l;
 
 
     // 'start'  will be built to point to the beginning of the list of S'V's for each class.
     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];
 
 
     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++)
           if  (coef1[si + k] != 0.0)
             totalNumSVs++;
 
         for  (k = 0;  k < cj;  k++)
           if  (coef2[sj + k] != 0.0)
             totalNumSVs++;
       }
     }
 
     delete[]  start;
     start = NULL;
   }
 
   return;
 }  /* svm_GetupportVectorsStatistic */

struct SvmModel233* SVM233::Svm_Load_Model	(	std::istream &	f,
		RunLog &	log
	)

Referenced by KKMLL::SvmLoadModel().

void SVM233::svm_margin ( SvmModel233 * model )

Definition at line 4650 of file svm.cpp.

References EPSILON_SVR, SVM233::Kernel::k_function(), SVM233::SvmModel233::margin, SVM233::SvmModel233::nr_class, SVM233::SvmModel233::nSV, NU_SVR, ONE_CLASS, SVM233::SvmModel233::param, SVM233::SvmModel233::SV, SVM233::SvmModel233::sv_coef, and SVM233::svm_parameter::svm_type.

 {
   //kkint32 numClass=model->param.numClass;
 
   assert (model);
 
   if(model->param.svm_type == ONE_CLASS ||
     model->param.svm_type == EPSILON_SVR ||
     model->param.svm_type == NU_SVR)
   {
     /*
     double *sv_coef = model->sv_coef[0];
     double sum = 0;
     for(kkint32 i=0;i<model->l;i++)
     sum += sv_coef[i] * Kernel::k_function(x,model->SV[i],model->param);
     sum -= model->rho[0];
     if(model->param.svm_type == ONE_CLASS)
     return (sum>0)?1:-1;
     else
     return sum;
     */
   }
   else
   {
     kkint32 i;
     kkint32 nr_class = model->nr_class;
 
     model->margin = new double[nr_class * (nr_class - 1) / 2];
 
     std::vector<kkint32> start(nr_class,0);
     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; // computer the L of the K since it is symetric
         double trace=0; // compute the trace
 
         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++)
           //y[k]=+1;
         {
           double kvalue = Kernel::k_function(model->SV[si+k],model->SV[si+k],model->param);
           trace += coef1[si+k]*coef1[si+k]*kvalue;
 
           for(kkint32 kk=k+1; kk<ci; kk++)
             //y[kk]=+1 and y[k]*y[kk]=+1;
           {
             kvalue = Kernel::k_function(model->SV[si+k],model->SV[si+kk],model->param);
             sum+= coef1[si+k]*coef1[si+kk]*kvalue;
           }
           //sum += coef1[si+k] * kvalue[si+k];
 
           {  // kk:  jun-06-2003
             for(kkint32 kk=0; kk<cj; kk++)
               //y[kk]=-1 and y[k]*y[kk]=-1
             {
               kvalue = Kernel::k_function(model->SV[si+k],model->SV[sj+kk],model->param);
 
               // kk  2010-06-13   I believe that since the coef already reflects the label(sign) of the training 
               //                  example that the following line should be adding not subtracting.
               // sum -= coef1[si+k]*coef2[sj+kk]*kvalue;
               sum += coef1[si+k]*coef2[sj+kk]*kvalue;
             }
           }  // kk:  jun-06-2003
 
         }
 
         for (k=0; k<cj-1; k++)
           //y[k]=-1
         {
           double kvalue = Kernel::k_function(model->SV[sj+k],model->SV[sj+k],model->param);
           trace += coef2[sj + k] * coef2[sj + k] * kvalue;
 
           for(kkint32 kk=k+1; kk<cj; kk++)
             //y[kk]=-1 and y[k]*y[kk]=+1
           {
             kvalue = Kernel::k_function(model->SV[sj+k],model->SV[sj+kk],model->param);
 
             // kk 2010-06-13
             // I suspect this next line should be subtracting but I am not doing anything 
             // about it at this point until I understand.
             sum += coef2[sj + k] * coef2[sj + kk] * kvalue;
           }
         }
 
         double marginSqr = 2 * sum + trace;
         if  (marginSqr <= 0.0)
         {
           cerr << endl << endl 
             << "SVM233::svm_margin   ***ERROR***    the computed margin <= 0.0.   This is very bad." << endl
             << endl;
           marginSqr = 0.1;
         }
 
 
 
         model->margin[p] = sqrt(marginSqr);
         p++;
       }
   }
 }

double SVM233::svm_predict	(	const struct SvmModel233 *	model,
		const struct svm_node *	x
	)

double SVM233::svm_predict	(	const struct SvmModel233 *	model,
		const svm_node *	x,
		std::vector< double > &	dist,
		std::vector< kkint32 > &	winners,
		kkint32	excludeSupportVectorIDX
	)

Predicts a class for the specified training example.

Parameters

[in]	model	A previously trained model.
[in]	x	Example that we want to make prediction on.
[out]	dist	Entry for each class-pair indicating the distance from the decision boundary.
[out]	winners	A list of one or more classes that won the highest number of votes; that is for each pair of classes there is a vote and it is possible for there t be a tie for winner.
[in]	excludeSupportVectorIDX	Index of training example that should be excluded from computation; if less than zero will be ignored; this would be the same index specified when training the model to ignore.

Returns: The predicted class; the won that won the most amount of votes; if there is a tie the 1st one will be returned.

double SVM233::svm_predictTwoClasses	(	const SvmModel233 *	model,
		const svm_node *	x,
		double &	dist,
		kkint32	excludeSupportVectorIDX
	)

Parameters

[in]	model	A previously trained model.
[in]	x	Example that we want to make prediction on.
[out]	dist	Distance from decision boundary.
[in]	excludeSupportVectorIDX	Index of support vector that should be excluded form computation; if less than zero will be ignored.

Returns: The predicted class; Zero(0) or One(1); if (dist less-or-equal 0) the class Zero otherwise class One.

Definition at line 4218 of file svm.cpp.

References SVM233::svm_parameter::dimSelect, EPSILON_SVR, SVM233::SvmModel233::featureWeight, SVM233::Kernel::k_function(), SVM233::Kernel::k_function_subspace(), SVM233::SvmModel233::kValueTable, SVM233::SvmModel233::l, SVM233::SvmModel233::label, SVM233::SvmModel233::nr_class, SVM233::SvmModel233::nSV, NU_SVR, ONE_CLASS, SVM233::SvmModel233::param, SVM233::SvmModel233::rho, SVM233::SvmModel233::SV, SVM233::SvmModel233::sv_coef, and SVM233::svm_parameter::svm_type.

Referenced by KKMLL::SVMModel::DistanceFromDecisionBoundary(), KKMLL::SVMModel::FindWorstSupportVectors(), KKMLL::SVMModel::FindWorstSupportVectors2(), and KKMLL::SvmPredictRaw().

 {
   kkint32  winner = 0;
 
   kkint32 dimSelect = model->param.dimSelect;
 
   if  (model->param.svm_type == ONE_CLASS   ||
        model->param.svm_type == EPSILON_SVR ||
        model->param.svm_type == NU_SVR
       )
   {
     double*  sv_coef = model->sv_coef[0];
     double   sum = 0;
 
     for  (kkint32 i=0; i < model->l; i++)
     {
       if  (i == excludeSupportVectorIDX)
         continue;
 
       if  (dimSelect > 0)
         sum += sv_coef[i] * Kernel::k_function_subspace (x, model->SV[i],model->param, model->featureWeight);
       else
         sum += sv_coef[i] * Kernel::k_function (x, model->SV[i], model->param);
     }
 
     sum -= model->rho[0];
 
     double  returnVal = 0.0;
 
     if  (model->param.svm_type == ONE_CLASS)
       returnVal = (sum > 0) ? 1:-1;
     else
       returnVal = sum;
 
     return  returnVal;
   }
   else
   {
     kkint32 i;
 
     kkint32 nr_class = model->nr_class;
     if  (nr_class != 2)
     {
       cerr << std::endl
            << "svm_predictTwoClasses  ***ERROR***  nr_class[" << nr_class << "] != 2" << std::endl
            << std::endl;
       exit (-1);
     }
 
     kkint32 l = model->l;
     //double *kvalue = Malloc (double, l);
 
     double* kvalue = model->kValueTable;
 
     if  (dimSelect > 0)
     {
       for  (i = 0;  i < l;  i++)
       {
         if  (i == excludeSupportVectorIDX)
           kvalue[i] = 0.0;
         else
           kvalue[i] = Kernel::k_function_subspace (x, model->SV[i], model->param, model->featureWeight);
       }
     }
     else
     {
       for  (i = 0;  i < l;  i++)
       {
         if  (i == excludeSupportVectorIDX)
           kvalue[i] = 0.0;
         else
           kvalue[i] = Kernel::k_function (x, model->SV[i], model->param);
       }
     }
 
     kkint32 start[2];
     start[0] = 0;
     for  (i = 1;  i < nr_class;  i++)
       start[i] = start[i-1] + model->nSV[i-1];
 
     kkint32 p = 0;
 
     i = 0;
     kkint32 j = 1;
     {
       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];
 
       if  (sum > 0)
         winner = 0;
       else
         winner = 1;
 
       dist = sum;
 
       //if  (model->margin)
       //{
       //  if  (model->margin[0] != 0.0)
       //    dist = dist / model->margin[0];
       //}
     }
 
     p=0;
 
     double  winningLabel = (double)model->label[winner];
 
     return  winningLabel;
   }
 }  /* svm_predictTwoClasses */

void SVM233::Svm_Save_Model	(	std::ostream &	o,
		const SvmModel233 *	model
	)

Referenced by KKMLL::SvmSaveModel().

struct SvmModel233* SVM233::svm_train	(	const struct svm_problem *	prob,
		const struct svm_parameter *	param
	)

Referenced by KKMLL::SVMModel::FindWorstSupportVectors2(), and KKMLL::SvmTrainModel().

decision_function SVM233::svm_train_one	(	const svm_problem *	prob,
		const svm_parameter *	param
	)

Definition at line 3107 of file svm.cpp.

References SVM233::decision_function::alpha, C_SVC, info(), SVM233::svm_problem::l, SVM233::Solver::SolutionInfo::obj, SVM233::Solver::SolutionInfo::rho, SVM233::decision_function::rho, solve_c_svc(), SVM233::svm_parameter::svm_type, and SVM233::svm_problem::W.

 {
   double *alpha = Malloc(double,prob->l);
   Solver::SolutionInfo si;
   switch(param->svm_type)
   {
   case C_SVC:
     solve_c_svc (prob, param, alpha,&si, prob->W);
     break;
   }
 
   info("obj = %f, rho = %f\n",si.obj,si.rho);
 
   // output SVs
 
   kkint32 nSV = 0;
   kkint32 nBSV = 0;
   for (kkint32 i = 0;  i < prob->l;  i++)
   {
     if  (fabs (alpha[i]) > 0)
     {
       ++nSV;
       if (prob->y[i] > 0)
       {
         if (fabs (alpha[i]) >= prob->W[i])
           ++nBSV;
       }
       else
       {
         if (fabs(alpha[i]) >= prob->W[i])
           ++nBSV;
       }
     }
   }
 
   info("nSV = %d, nBSV = %d\n",nSV,nBSV);
 
   decision_function f;
   f.alpha = alpha;
   f.rho = si.rho;
   return f;
 }  /* svm_train_one */

decision_function SVM233::svm_train_one	(	const svm_problem *	prob,
		const svm_parameter *	param,
		double	Cp,
		double	Cn,
		std::set< kkint32 > &	BSVIndex
	)

Definition at line 3154 of file svm.cpp.

References SVM233::decision_function::alpha, C_SVC, SVM233::svm_parameter::dimSelect, EPSILON_SVR, SVM233::svm_parameter::featureWeight, info(), SVM233::Kernel::k_function(), SVM233::Kernel::k_function_subspace(), SVM233::svm_problem::l, NU_SVC, NU_SVR, SVM233::Solver::SolutionInfo::obj, ONE_CLASS, SVM233::Solver::SolutionInfo::rho, SVM233::decision_function::rho, solve_c_svc(), solve_epsilon_svr(), solve_nu_svc(), solve_nu_svr(), solve_one_class(), SVM233::svm_parameter::svm_type, SVM233::svm_problem::x, and SVM233::svm_problem::y.

Referenced by clone(), max(), min(), and Swap().

 {
   double *alpha = Malloc (double, prob->l);
   Solver::SolutionInfo si;
   switch(param->svm_type)
   {
   case C_SVC:
     solve_c_svc (prob, param, alpha, &si, Cp, Cn);
     break;
 
   case NU_SVC:
     solve_nu_svc(prob,param,alpha,&si);
     break;
 
   case ONE_CLASS:
     solve_one_class(prob,param,alpha,&si);
     break;
 
   case EPSILON_SVR:
     solve_epsilon_svr(prob,param,alpha,&si);
     break;
 
   case NU_SVR:
     solve_nu_svr(prob,param,alpha,&si);
     break;
   }
 
   info("obj = %f, rho = %f\n",si.obj,si.rho);
 
   // output SVs
 
   std::vector<kkint32> SVIndex;
 
   kkint32 nSV = 0;
   kkint32 nBSV = 0;
 
   for  (kkint32 i = 0;  i < prob->l;  i++)
   {
     if  (fabs(alpha[i]) > 0)
     {
       ++nSV;
       SVIndex.push_back (i);
       if (prob->y[i] > 0)
       {
         if  (fabs (alpha[i]) >= si.upper_bound_p)
         {
           ++nBSV;
           BSVIndex.insert (prob->index[i]);
         }
       }
       else
       {
         if  (fabs(alpha[i]) >= si.upper_bound_n)
         {
           ++nBSV;
           BSVIndex.insert (prob->index[i]);
         }
       }
     }
   }
 
   info("nSV = %d, nBSV = %d\n",nSV,nBSV);
 
   double sum=0.0;
   std::vector<kkint32>::iterator it,it2;
 
   for (it = SVIndex.begin();  it < SVIndex.end();  it++)
   {
     for  (it2 = SVIndex.begin(); it2 < SVIndex.end();  it2++)
     {
       kkint32 k  = *it;
       kkint32 kk = *it2;
 
       double kvalue;
 
       if  (param->dimSelect > 0)
       {
         kvalue = Kernel::k_function_subspace (prob->x[k], 
           prob->x[kk], 
           *param, 
           param->featureWeight
           );
       }
       else
       {
         kvalue = Kernel::k_function(prob->x[k], prob->x[kk], *param);
       }
 
       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;
 
   decision_function f;
 
   f.alpha = alpha;
   f.rho   = si.rho;
   return f;
 }  /* svm_train_one */

template<class T >

void SVM233::Swap	(	T &	x,
		T &	y
	)

inline

Definition at line 687 of file svm.cpp.

References svm_train_one().

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

SVM233::XmlFactoryMacro ( SvmModel233 )

Variable Documentation

const kkint32 SVM233::SCALE = 100

Definition at line 27 of file svm.h.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation