SVM289_BFS Namespace Reference

Namespace used to wrap implementation of libSVM version 2.89 to be used as a pair-wise SVM. 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

Enumerations
enum	Kernel_Type {   Kernel_NULL, LINEAR, POLY, RBF,   SIGMOID, 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 k, double **r, double *p)
double	powi (double base, kkint32 times)
double	sigmoid_predict (double decision_value, double A, double B)
void	sigmoid_train (kkint32 l, 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 svm_model *model, kkint32 *label)
kkint32	svm_get_nr_class (const svm_model *model)
SVM_Type	svm_get_svm_type (const svm_model *model)
double	svm_get_svr_probability (const 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

Namespace used to wrap implementation of libSVM version 2.89 to be used as a pair-wise SVM.

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 implemented 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. This particular implementation SVM289_BFS was meant to work with the Binary-Feature-Selection (Pair-Wise) version of the support vector machine as described by "Increased classification accuracy and speedup through pair-wise feature selection for support vector machines."

Typedef Documentation

typedef float SVM289_BFS::Qfloat

Definition at line 269 of file svm289_BFS.h.

typedef signed char SVM289_BFS::schar

Definition at line 271 of file svm289_BFS.h.

Enumeration Type Documentation

enum SVM289_BFS::Kernel_Type

Enumerator
Kernel_NULL
LINEAR
POLY
RBF
SIGMOID
PRECOMPUTED

Definition at line 77 of file svm289_BFS.h.

{ Kernel_NULL, LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED }     Kernel_Type; /* kernel_type */

enum SVM289_BFS::SVM_Type

strong

Enumerator
SVM_NULL
C_SVC
NU_SVC
ONE_CLASS
EPSILON_SVR
NU_SVR

Definition at line 67 of file svm289_BFS.h.

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

Function Documentation

template<class S , class T >

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

inline

Definition at line 274 of file svm289_BFS.h.

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

template<class T >

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

inline

Definition at line 78 of file svm289_BFS.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_BFS::Kernel_Type_FromStr

(

KKStr

s

)

Definition at line 575 of file svm289_BFS.cpp.

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

Referenced by SVM289_BFS::svm_parameter::ParseTabDelStr(), and SVM289_BFS::svm_parameter::ProcessSvmParameter().

 {
   s.Upper ();
   if  ((s.EqualIgnoreCase ("LINEAR"))       ||  (s == "0"))
     return  LINEAR;

   if  ((s.EqualIgnoreCase ("POLYNOMIAL"))   ||  (s.EqualIgnoreCase ("POLY"))  ||  (s == "1"))
     return  POLY;

   if  ((s.EqualIgnoreCase ("RBF"))          ||  (s == "2"))
     return  RBF;

   if  ((s.EqualIgnoreCase ("SIGMOID"))      ||  (s == "3"))
     return  SIGMOID;

   if  ((s.EqualIgnoreCase ("PRECOMPUTED"))  ||  (s == "4"))
     return  PRECOMPUTED;

   return  Kernel_NULL;
 }

KKStr SVM289_BFS::Kernel_Type_ToStr

(

Kernel_Type

kernelType

)

Definition at line 600 of file svm289_BFS.cpp.

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

Referenced by SVM289_BFS::svm_parameter::ToTabDelStr().

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

  return  "";
}

void SVM289_BFS::multiclass_probability	(	kkint32	k,
		double **	r,
		double *	p
	)

Parameters

k	Number of Classes.
r	Pairwise Probabilities.
p	Class Probability

Definition at line 3051 of file svm289_BFS.cpp.

References info().

{
  kkint32 t,j;
  kkint32  iter     = 0;
  kkint32  max_iter = Max (100, k);

  double**  Q  = new double*[k];
  double*   Qp = new double[k];
  double    pQp; 
  double    eps = 0.005 / k;
  
  for  (t = 0;  t < k;  t++)
  {
    p[t]    = 1.0 / k;  // Valid if k = 1
    Q[t]    = new double[k];
    Q[t][t] = 0;
    for  (j = 0;  j < t;  j++)
    {
      Q[t][t] += r[j][t] * r[j][t];
      Q[t][j] =  Q[j][t];
    }

    for  (j = t + 1;  j < k;  j++)
    {
      Q[t][t] +=  r[j][t] * r[j][t];
      Q[t][j] =-  r[j][t] * r[t][j];
    }
  }

  for (iter = 0;  iter <max_iter;  iter++)
  {
    // stopping condition, recalculate QP,pQP for numerical accuracy
    pQp = 0;
    for (t = 0;  t < k;  t++)
    {
      Qp[t] = 0;
      for  (j = 0;  j < k;  j++)
        Qp[t] += Q[t][j] * p[j];
      pQp += p[t] * Qp[t];
    }
    double max_error = 0;
    for (t = 0;  t < k;  t++)
    {
      double error = fabs (Qp[t] - pQp);
      if  (error > max_error)
        max_error = error;
    }

    if  (max_error < eps) 
      break;
    
    for  (t = 0;  t < k;  t++)
    {
      double diff = (-Qp[t] +pQp) / Q[t][t];
      p[t] += diff;
      pQp = (pQp + diff * (diff * Q[t][t] + 2 * Qp[t]))  /  (1 + diff) / (1 + diff);
      for (j = 0;  j < k;  j++)
      {
        Qp[j] = (Qp[j] + diff * Q[t][j]) / (1 + diff);
        p[j] /= (1 + diff);
      }
    }
  }
  if  (iter >= max_iter)
    info ("Exceeds max_iter in multiclass_prob\n");

  for  (t = 0;  t < k;  t++)
  {delete Q[t];  Q[t] = NULL;}

  delete  Q;  Q  = NULL;
  delete  Qp; Qp = NULL;
}  /* multiclass_probability */

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

inline

Definition at line 93 of file svm289_BFS.cpp.

Referenced by SVM289_BFS::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_BFS::sigmoid_predict	(	double	decision_value,
		double	A,
		double	B
	)

Definition at line 3034 of file svm289_BFS.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_BFS::sigmoid_train	(	kkint32	l,
		const double *	dec_values,
		const double *	labels,
		double &	A,
		double &	B
	)

Definition at line 2899 of file svm289_BFS.cpp.

References info().

Referenced by svm_binary_svc_probability().

{
  double  prior1 = 0;
  double  prior0 = 0;
  kkint32 i;

  for (i=0;i<l;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[l];
  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 < l;  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 < l;  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 < l;  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_BFS::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 2451 of file svm289_BFS.cpp.

References SVM289_BFS::svm_parameter::eps, SVM289_BFS::svm_problem::l, SVM289_BFS::svm_parameter::shrinking, SVM289_BFS::Solver::Solve(), SVM289_BFS::SVC_Q::SVC_Q(), and SVM289_BFS::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;

  SVC_Q*  jester = new SVC_Q (*prob, *param, y, _log);

  s.Solve (l, 
           *jester, 
           minus_ones, 
           y,
           alpha, 
           Cp, 
           Cn, 
           param->eps, 
           si, 
           param->shrinking
          );
  delete  jester;
  jester = NULL;

  double  sum_alpha =0;

  for  (i = 0;  i < l;  i++)
    sum_alpha += alpha[i];

  //if  (Cp == Cn)
  //  info ("nu = %f\n", sum_alpha / (Cp * prob->l));

  for  (i = 0;  i < l;  i++)
    alpha[i] *= y[i];

  delete[] minus_ones;
  delete[] y;
}  /* solve_c_svc */

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

Definition at line 2650 of file svm289_BFS.cpp.

References SVM289_BFS::svm_parameter::C, SVM289_BFS::svm_parameter::eps, info(), SVM289_BFS::svm_problem::l, SVM289_BFS::svm_parameter::p, SVM289_BFS::svm_parameter::shrinking, SVM289_BFS::Solver::Solve(), SVM289_BFS::SVR_Q::SVR_Q(), and SVM289_BFS::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;
  }


  SVR_Q*  jester = new SVR_Q (*prob, *param, _log);
  Solver s;
  s.Solve (2 * l, 
           *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 < 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;
}  /* solve_epsilon_svr */

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

Definition at line 2513 of file svm289_BFS.cpp.

References SVM289_BFS::svm_parameter::eps, info(), SVM289_BFS::svm_problem::l, SVM289_BFS::svm_parameter::nu, SVM289_BFS::Solver::SolutionInfo::obj, SVM289_BFS::Solver::SolutionInfo::r, SVM289_BFS::Solver::SolutionInfo::rho, SVM289_BFS::svm_parameter::shrinking, SVM289_BFS::Solver_NU::Solve(), SVM289_BFS::SVC_Q::SVC_Q(), SVM289_BFS::Solver::SolutionInfo::upper_bound_n, SVM289_BFS::Solver::SolutionInfo::upper_bound_p, and SVM289_BFS::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;

  SVM289_BFS::Solver_NU  s;

  SVC_Q*  jester = new SVC_Q (*prob, *param, y, _log);

  s.Solve (l, 
           *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 < 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 */

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

Definition at line 2595 of file svm289_BFS.cpp.

References SVM289_BFS::svm_parameter::eps, SVM289_BFS::svm_problem::l, SVM289_BFS::svm_parameter::nu, SVM289_BFS::ONE_CLASS_Q::ONE_CLASS_Q(), SVM289_BFS::svm_parameter::shrinking, and SVM289_BFS::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;

  if  (n < prob->l)
    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;
  }

  ONE_CLASS_Q*  jester = new ONE_CLASS_Q (*prob, *param, _log);

  Solver s;
  s.Solve (l, 
           *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_BFS::svm_check_parameter	(	const struct svm_problem *	prob,
		const struct svm_parameter *	param
	)

kkint32 SVM289_BFS::svm_check_probability_model

(

const struct svm_model *

model

)

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

Definition at line 3701 of file svm289_BFS.cpp.

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

Referenced by svm_svr_probability().

{
  kkint32 i;
  kkint32 *fold_start = new kkint32[nr_fold + 1];
  kkint32 l = prob.l;
  kkint32 *perm = new kkint32[l];
  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 < l)
      )
  {
    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[l];
    for  (i = 0;  i < l;  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_BFS::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 < l;  i++) 
      perm[i]=i;

    for (i = 0;  i < l;  i++)
    {
      kkint32 j = i + rand() % (l - i);
      SVM289_BFS::swap (perm[i], perm[j]);
    }
    for  (i = 0;  i <=  nr_fold; i++)
      fold_start[i] = i * l / 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.l = l - (end - begin);
    //subprob.x = Malloc(struct svm_node*,subprob.l);
    // subprob.x  will be initilized to an empty FeatureVectorList 
    subprob.y = new double[subprob.l];
      
    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 < l;  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_BFS::svm_destroy_model

(

struct svm_model *&

model

)

Definition at line 4649 of file svm289_BFS.cpp.

Referenced by svm_cross_validation().

{
  //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_BFS::svm_destroy_param

(

struct svm_parameter *&

param

)

Definition at line 4664 of file svm289_BFS.cpp.

{
  delete  param;
  param = NULL;
}

void SVM289_BFS::svm_get_labels	(	const svm_model *	model,
		kkint32 *	label
	)

Definition at line 3869 of file svm289_BFS.cpp.

References SVM289_BFS::svm_model::label, and SVM289_BFS::svm_model::nr_class.

{
  if (model->label != NULL)
    for(kkint32 i=0;i<model->nr_class;i++)
      label[i] = model->label[i];
}

kkint32 SVM289_BFS::svm_get_nr_class

(

const svm_model *

model

)

Definition at line 3861 of file svm289_BFS.cpp.

References SVM289_BFS::svm_model::nr_class.

Referenced by svm_cross_validation().

{
  return model->nr_class;
}

SVM_Type SVM289_BFS::svm_get_svm_type

(

const svm_model *

model

)

Definition at line 3854 of file svm289_BFS.cpp.

References SVM289_BFS::svm_model::param, and SVM289_BFS::svm_parameter::svm_type.

{
  return model->param.svm_type;
}

double SVM289_BFS::svm_get_svr_probability

(

const svm_model *

model

)

Definition at line 3880 of file svm289_BFS.cpp.

References EPSILON_SVR, NU_SVR, SVM289_BFS::svm_model::param, SVM289_BFS::svm_model::probA, and SVM289_BFS::svm_parameter::svm_type.

{
  if ((model->param.svm_type == SVM_Type::EPSILON_SVR || model->param.svm_type == SVM_Type::NU_SVR) &&
      model->probA!=NULL)
    return model->probA[0];
  else
  {
    fprintf(stderr,"Model doesn't contain information for SVR probability inference\n");
    return 0;
  }
}

double SVM289_BFS::svm_predict	(	const struct svm_model *	model,
		const FeatureVector &	x
	)

Referenced by svm_predict_probability().

double SVM289_BFS::svm_predict_probability	(	svm_model *	model,
		const FeatureVector &	x,
		double *	prob_estimates,
		kkint32 *	votes
	)

Definition at line 4027 of file svm289_BFS.cpp.

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

{
  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 - min_prob);
          pairwise_prob[j][i] = 1 - 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 - min_prob);
          pairwise_prob[j][i] = 1 - 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_BFS::svm_predict_values	(	const svm_model *	model,
		const FeatureVector &	x,
		double *	dec_values
	)

Definition at line 3895 of file svm289_BFS.cpp.

References EPSILON_SVR, SVM289_BFS::svm_model::l, SVM289_BFS::svm_model::nr_class, SVM289_BFS::svm_model::nSV, NU_SVR, ONE_CLASS, SVM289_BFS::svm_model::param, SVM289_BFS::svm_model::rho, SVM289_BFS::svm_model::sv_coef, and SVM289_BFS::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->l;  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 l = model->l;
    
    double *kvalue = new double[l];
    for  (i = 0;  i < l;  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_BFS::svm_train	(	const svm_problem &	prob,
		const svm_parameter &	param,
		RunLog &	log
	)

Definition at line 3385 of file svm289_BFS.cpp.

References SVM289_BFS::decision_function::alpha, SVM289_BFS::svm_parameter::C, EPSILON_SVR, KKMLL::FeatureVectorList::FeatureVectorList(), SVM289_BFS::svm_problem::FileDesc(), info(), SVM289_BFS::svm_problem::l, SVM289_BFS::svm_model::l, SVM289_BFS::svm_model::label, SVM289_BFS::svm_model::nr_class, SVM289_BFS::svm_parameter::nr_weight, SVM289_BFS::svm_model::nSV, NU_SVR, ONE_CLASS, SVM289_BFS::svm_model::probA, SVM289_BFS::svm_parameter::probability, SVM289_BFS::svm_model::probB, SVM289_BFS::svm_model::rho, SVM289_BFS::decision_function::rho, SVM289_BFS::svm_problem::SelFeatures(), SVM289_BFS::svm_model::sv_coef, svm_binary_svc_probability(), svm_group_classes(), SVM289_BFS::svm_model::svm_model(), SVM289_BFS::svm_problem::svm_problem(), svm_svr_probability(), svm_train_one(), SVM289_BFS::svm_parameter::svm_type, SVM289_BFS::svm_parameter::weight, SVM289_BFS::svm_parameter::weight_label, SVM289_BFS::svm_model::weOwnSupportVectors, and SVM289_BFS::svm_problem::y.

Referenced by svm_binary_svc_probability(), and svm_cross_validation().

{
  svm_model*  model = new svm_model (param, prob.SelFeatures (), prob.FileDesc (), log);

  model->weOwnSupportVectors = false;  // XXX

  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.l;  i++)
    {
      if  (fabs(f.alpha[i]) > 0) 
        ++nSV;
    }

    model->l = nSV;
    //model->SV = Malloc(svm_node *,nSV);
    // model->SV is now a FeatureVectorList object that was initialized to empty and not owner in the consructor
    model->SV.Owner (true);
    model->sv_coef[0] = new double[nSV];
    kkint32 j = 0;
    for  (i = 0;  i < prob.l;  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.l;
    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.l = ci + cj;
        //sub_prob.x = Malloc (svm_node *,sub_prob.l);
        sub_prob.y = new double[sub_prob.l];
        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->l = 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_BFS::svm_train_one	(	const svm_problem &	prob,
		const svm_parameter &	param,
		double	Cp,
		double	Cn,
		RunLog &	_log
	)

Definition at line 2781 of file svm289_BFS.cpp.

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

Referenced by svm_train().

{
  double*  alpha = new double [prob.l];
  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_BFS::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.l;  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_BFS::SVM_Type_FromStr

(

KKStr

s

)

Definition at line 536 of file svm289_BFS.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_BFS::svm_parameter::ParseTabDelStr(), and SVM289_BFS::svm_parameter::ProcessSvmParameter().

{
  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_BFS::SVM_Type_ToStr

(

SVM_Type

svmType

)

Definition at line 560 of file svm289_BFS.cpp.

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

Referenced by SVM289_BFS::svm_parameter::ToTabDelStr().

{
  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  "";
}

template<class T >

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

inline

Definition at line 265 of file svm289_BFS.h.

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

Variable Documentation

kkint32 SVM289_BFS::libsvm_version

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

Definition at line 624 of file svm289_BFS.cpp.