Inheritance diagram for SVM233::Kernel:

Public Member Functions
	Kernel (kkint32 l, svm_node const x, const svm_parameter &param)

virtual	~Kernel ()

virtual Qfloat *	get_Q (kkint32 column, kkint32 len) const =0

virtual void	swap_index (kkint32 i, kkint32 j) const

Static Public Member Functions
static double	k_function (const svm_node x, const svm_node y, const svm_parameter &param)

static double	k_function_subspace (const svm_node x, const svm_node y, const svm_parameter &param, const double *featureWeight)

Protected Attributes
double(Kernel::*	kernel_function )(kkint32 i, kkint32 j) const

Detailed Description

Kernel evaluation.

the static method k_function is for doing single kernel evaluation the constructor of Kernel prepares to calculate the l*l kernel matrix the member function get_Q is for getting one column from the Q Matrix

Definition at line 1525 of file svm.cpp.

Constructor & Destructor Documentation

SVM233::Kernel::Kernel	(	kkint32	l,
		svm_node const	x,
		const svm_parameter &	param
	)

Definition at line 1609 of file svm.cpp.

References SVM233::svm_parameter::coef0, SVM233::svm_parameter::degree, SVM233::svm_parameter::dim, SVM233::svm_parameter::dimSelect, SVM233::svm_parameter::gamma, kernel_function, SVM233::svm_parameter::kernel_type, SVM233::LINEAR, SVM233::POLY, SVM233::RBF, and SVM233::SIGMOID.

Referenced by SVM233::ONE_CLASS_Q::ONE_CLASS_Q(), SVM233::SVC_Q::SVC_Q(), and SVM233::SVR_Q::SVR_Q().

  :
    kernel_type  (param.kernel_type), 
    degree       (param.degree),
    gamma        (param.gamma), 
    coef0        (param.coef0)
 
 {
   dim=0;
   if  (param.dimSelect >0)
   {
     dim = param.dim;
     featureWeight = new double[dim];
     std::copy (param.featureWeight, param.featureWeight + dim, featureWeight);
   }
 
   switch (kernel_type)
   {
   case LINEAR:
     if(param.dimSelect >0)
       kernel_function = &Kernel::kernel_linear_subspace;
     else
       kernel_function = &Kernel::kernel_linear;
     break;
 
   case POLY:
     if(param.dimSelect >0)
       kernel_function = &Kernel::kernel_poly_subspace;
     else
       kernel_function = &Kernel::kernel_poly;
     break;
 
   case RBF:
     if(param.dimSelect >0)
       kernel_function = &Kernel::kernel_rbf_subspace;
     else
       kernel_function = &Kernel::kernel_rbf;
     break;
 
   case SIGMOID:
     if(param.dimSelect >0)
       kernel_function = &Kernel::kernel_sigmoid_subspace;
     else
       kernel_function = &Kernel::kernel_sigmoid;
     break;
   }
 
   clone (x, x_,  l);
 
   if  (kernel_type == RBF)
   {
     x_square = new double[l];
     for(kkint32 i=0;i<l;i++)
     {
       if(param.dimSelect > 0)
         x_square[i] = dotSubspace(x[i],x[i],featureWeight);
       else
         x_square[i] = dot(x[i],x[i]);
     }
   }
   else
     x_square = 0;
 }

SVM233::Kernel::~Kernel ( )

virtual

Definition at line 1676 of file svm.cpp.

 {
   if (dim>0)
     delete[] featureWeight;
   delete[] x;
   delete[] x_square;
 }

Member Function Documentation

virtual Qfloat* SVM233::Kernel::get_Q	(	kkint32	column,
		kkint32	len
	)		const

pure virtual

Implemented in SVM233::SVR_Q, SVM233::ONE_CLASS_Q, and SVM233::SVC_Q.

Referenced by SVM233::Solver::reconstruct_gradient(), and SVM233::Solver::Solve().

double SVM233::Kernel::k_function	(	const svm_node *	x,
		const svm_node *	y,
		const svm_parameter &	param
	)

static

Definition at line 1735 of file svm.cpp.

References SVM233::svm_parameter::coef0, SVM233::svm_parameter::degree, SVM233::svm_parameter::gamma, SVM233::svm_node::index, SVM233::svm_parameter::kernel_type, SVM233::LINEAR, SVM233::POLY, SVM233::RBF, SVM233::SIGMOID, and SVM233::svm_node::value.

Referenced by SVM233::svm_margin(), SVM233::svm_predictTwoClasses(), and SVM233::svm_train_one().

 {
 
   switch(param.kernel_type)
   {
   case LINEAR:
     return dot(x,y);
 
   case POLY:
     return pow(param.gamma*dot(x,y)+param.coef0,param.degree);
 
   case RBF:
     {
       double sum = 0;
       while(x->index != -1 && y->index !=-1)
       {
         if(x->index == y->index)
         {
           double d = x->value - y->value;
           sum += d*d;
           ++x;
           ++y;
         }
         else
         {
           if(x->index > y->index)
           {
             double d=y->value;
             sum += d*d;
             ++y;
           }
           else
           {
             double d=x->value;
             sum += d*d;
             ++x;
           }
         }
       }
 
       while(x->index != -1)
       {
         double d = x->value;
         sum += d*d;
         //sum += x->value * x->value;
         ++x;
       }
 
       while(y->index != -1)
       {
         double d=y->value;
         sum += d * d;
         //sum += y->value * y->value;
         ++y;
       }
 
       return exp (-param.gamma * sum);
     }
   case SIGMOID:
     return tanh(param.gamma*dot(x,y)+param.coef0);
   default:
     return 0;  /* Unreachable */
   }
 }

double SVM233::Kernel::k_function_subspace	(	const svm_node *	x,
		const svm_node *	y,
		const svm_parameter &	param,
		const double *	featureWeight
	)

static

Definition at line 1805 of file svm.cpp.

References SVM233::svm_parameter::coef0, SVM233::svm_parameter::degree, SVM233::svm_parameter::gamma, SVM233::svm_node::index, SVM233::svm_parameter::kernel_type, SVM233::LINEAR, SVM233::POLY, SVM233::RBF, SVM233::SIGMOID, and SVM233::svm_node::value.

Referenced by SVM233::svm_predictTwoClasses(), and SVM233::svm_train_one().

 {
   switch  (param.kernel_type)
   {
   case LINEAR:
     return dotSubspace(x,y,featureWeight);
   case POLY:
     return pow(param.gamma*dotSubspace(x,y,featureWeight)+param.coef0,param.degree);
 
   case RBF:
     {
       double sum = 0;
       while(x->index != -1 && y->index !=-1)
       {
         if(x->index == y->index)
         {
           double d = x->value - y->value;
           sum+=d*d*featureWeight[x->index-1];
 
           ++x;
           ++y;
         }
         else
         {
           if(x->index > y->index)
           {
             double d=y->value;
             sum+=d*d*featureWeight[y->index-1];
             ++y;
           }
           else
           {
             double d=x->value;
             sum+=d*d*featureWeight[x->index-1];
             ++x;
           }
         }
       }
 
       while(x->index != -1)
       {
         double d = x->value;
         sum+=d*d*featureWeight[x->index-1];
 
         //sum += x->value * x->value;
         ++x;
       }
 
       while(y->index != -1)
       {
         double d=y->value;
 
         sum+=d*d*featureWeight[y->index-1];
 
         //sum += y->value * y->value;
         ++y;
       }
 
       return exp (-param.gamma * sum);
     }
   case SIGMOID:
     return tanh(param.gamma*dotSubspace(x,y, featureWeight)+param.coef0);
   default:
     return 0;  /* Unreachable */
   }
 }  /* k_function_subspace */

virtual void SVM233::Kernel::swap_index	(	kkint32	i,
		kkint32	j
	)		const

inlinevirtual

Reimplemented in SVM233::SVR_Q, SVM233::ONE_CLASS_Q, and SVM233::SVC_Q.

Definition at line 1547 of file svm.cpp.

Referenced by SVM233::Solver::swap_index(), SVM233::SVC_Q::swap_index(), and SVM233::ONE_CLASS_Q::swap_index().

   {
     Swap (x[i],x[j]);
     if(x_square) Swap(x_square[i],x_square[j]);
   }

Member Data Documentation

double(Kernel::* SVM233::Kernel::kernel_function) (kkint32 i, kkint32 j) const

protected

Definition at line 1555 of file svm.cpp.

Referenced by SVM233::SVC_Q::get_Q(), SVM233::ONE_CLASS_Q::get_Q(), SVM233::SVR_Q::get_Q(), and Kernel().

The documentation for this class was generated from the following file:

C:/Users/Kurt/GitHub/KSquareLibraries/KKMachineLearning/svm.cpp

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation