Algorithm-SVM

 view release on metacpan or  search on metacpan

SVM.xs  view on Meta::CPAN

MODULE = Algorithm::SVM::DataSet	PACKAGE = Algorithm::SVM::DataSet

DataSet *
_new_dataset(l)
     double l

double
DataSet::_getLabel()
    CODE:
      RETVAL = THIS->getLabel();
    OUTPUT:
      RETVAL

void
DataSet::_setLabel(l)
     double l
    CODE:
      THIS->setLabel(l);

double
DataSet::_getAttribute(k)
     int k
    CODE:
      RETVAL = THIS->getAttribute(k);
    OUTPUT:
      RETVAL

void
DataSet::_setAttribute(k,v)
     int k
     double v
    CODE:
      THIS->setAttribute(k,v);

int
DataSet::_getIndexAt(i)
			int i
		CODE:
			RETVAL = THIS->getIndexAt(i);
		OUTPUT:
			RETVAL

double
DataSet::_getValueAt(i)
			int i
		CODE:
			RETVAL = THIS->getValueAt(i);
		OUTPUT:
			RETVAL

int
DataSet::_getMaxI()
		CODE:
			RETVAL = THIS->getMaxI();
		OUTPUT:
			RETVAL

void
DataSet::DESTROY()

MODULE = Algorithm::SVM			PACKAGE = Algorithm::SVM

SVM *
_new_svm(st,kt,d,g,c0,C,nu,e)
     int st

SVM.xs  view on Meta::CPAN

void
SVM::_clearDataSet()
    CODE:
      THIS->clearDataSet();

int
SVM::_train(retrain)
     int retrain
    CODE:
      RETVAL = THIS->train(retrain);
    OUTPUT:
      RETVAL

double
SVM::_crossValidate(nfolds)
     int nfolds
    CODE:
      RETVAL = THIS->crossValidate(nfolds);
    OUTPUT:
      RETVAL

double
SVM::_predict_value(ds)
     DataSet *ds
    CODE:
      RETVAL = THIS->predict_value(ds);
    OUTPUT:
      RETVAL

double
SVM::_predict(ds)
     DataSet *ds
    CODE:
      RETVAL = THIS->predict(ds);
    OUTPUT:
      RETVAL

int
SVM::_saveModel(filename)
     char *filename
    CODE:
      RETVAL = THIS->saveModel(filename);
    OUTPUT:
      RETVAL

int
SVM::_loadModel(filename)
     char *filename
    CODE:
      RETVAL = THIS->loadModel(filename);
    OUTPUT:
      RETVAL

int
SVM::_getNRClass()
    CODE:
      RETVAL = THIS->getNRClass();
    OUTPUT:
      RETVAL

void
SVM::_getLabels(classes)
     int classes
    PPCODE:
     int i;
     int *labels;
     labels = new int[classes];
     if(THIS->getLabels(labels)) {

SVM.xs  view on Meta::CPAN

	  XPUSHs(sv_2mortal(newSViv(labels[i])));
       }
     } else {
       XSRETURN_UNDEF;
     }

double
SVM::_getSVRProbability()
    CODE:
      RETVAL = THIS->getSVRProbability();
    OUTPUT:
      RETVAL

int
SVM::_checkProbabilityModel()
    CODE:
      RETVAL = THIS->checkProbabilityModel();
    OUTPUT:
      RETVAL

void
SVM::_setSVMType(st)
     int st
    CODE:
      THIS->setSVMType(st);

int
SVM::_getSVMType()
    CODE:
      RETVAL = THIS->getSVMType();
    OUTPUT:
      RETVAL

void
SVM::_setKernelType(kt)
     int kt
    CODE:
      THIS->setKernelType(kt);

int
SVM::_getKernelType()
    CODE:
      RETVAL = THIS->getKernelType();
    OUTPUT:
      RETVAL

void
SVM::_setGamma(g)
     double g
    CODE:
      THIS->setGamma(g);

double
SVM::_getGamma()
    CODE:
      RETVAL = THIS->getGamma();
    OUTPUT:
      RETVAL

void
SVM::_setDegree(d)
     int d
    CODE:
      THIS->setDegree(d);

double
SVM::_getDegree()
    CODE:
      RETVAL = THIS->getDegree();
    OUTPUT:
      RETVAL

void
SVM::_setCoef0(c)
     double c
    CODE:
      THIS->setCoef0(c);

double
SVM::_getCoef0()
    CODE:
      RETVAL = THIS->getCoef0();
    OUTPUT:
      RETVAL

void
SVM::_setC(c)
     double c
    CODE:
      THIS->setC(c);

double
SVM::_getC()
    CODE:
      RETVAL = THIS->getC();
    OUTPUT:
      RETVAL

void
SVM::_setNu(n)
     double n
    CODE:
      THIS->setNu(n);

double
SVM::_getNu()
    CODE:
      RETVAL = THIS->getNu();
    OUTPUT:
      RETVAL

void
SVM::_setEpsilon(e)
     double e
    CODE:
      THIS->setEpsilon(e);

double
SVM::_getEpsilon()
    CODE:
      RETVAL = THIS->getEpsilon();
    OUTPUT:
      RETVAL

void
SVM::DESTROY()

libsvm.cpp  view on Meta::CPAN

			break;
		case POLY:
			kernel_function = &Kernel::kernel_poly;
			break;
		case RBF:
			kernel_function = &Kernel::kernel_rbf;
			break;
		case SIGMOID:
			kernel_function = &Kernel::kernel_sigmoid;
			break;
		case PRECOMPUTED:
			kernel_function = &Kernel::kernel_precomputed;
			break;
	}

	clone(x,x_,l);

	if(kernel_type == RBF)
	{
		x_square = new double[l];
		for(int i=0;i<l;i++)

libsvm.cpp  view on Meta::CPAN

			while(y->index != -1)
			{
				sum += y->value * y->value;
				++y;
			}
			
			return exp(-param.gamma*sum);
		}
		case SIGMOID:
			return tanh(param.gamma*dot(x,y)+param.coef0);
		case PRECOMPUTED:  //x: test (validation), y: SV
			return x[(int)(y->value)].value;
		default:
			return 0;  // Unreachable 
	}
}

// An SMO algorithm in Fan et al., JMLR 6(2005), p. 1889--1918
// Solves:
//
//	min 0.5(\alpha^T Q \alpha) + p^T \alpha

libsvm.cpp  view on Meta::CPAN

	const double * const *sv_coef = model->sv_coef;
	const svm_node * const *SV = model->SV;

	for(int i=0;i<l;i++)
	{
		for(int j=0;j<nr_class-1;j++)
			fprintf(fp, "%.16g ",sv_coef[j][i]);

		const svm_node *p = SV[i];

		if(param.kernel_type == PRECOMPUTED)
			fprintf(fp,"0:%d ",(int)(p->value));
		else
			while(p->index != -1)
			{
				fprintf(fp,"%d:%.8g ",p->index,p->value);
				p++;
			}
		fprintf(fp, "\n");
	}
	if (ferror(fp) != 0 || fclose(fp) != 0) return -1;

libsvm.cpp  view on Meta::CPAN

	   svm_type != NU_SVR)
		return "unknown svm type";
	
	// kernel_type, degree
	
	int kernel_type = param->kernel_type;
	if(kernel_type != LINEAR &&
	   kernel_type != POLY &&
	   kernel_type != RBF &&
	   kernel_type != SIGMOID &&
	   kernel_type != PRECOMPUTED)
		return "unknown kernel type";

	if(param->degree < 0)
		return "degree of polynomial kernel < 0";

	// cache_size,eps,C,nu,p,shrinking

	if(param->cache_size <= 0)
		return "cache_size <= 0";

libsvm.h  view on Meta::CPAN

};

struct svm_problem
{
	int l;
	double *y;
	struct svm_node **x;
};

enum { C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR };	/* svm_type */
enum { LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED }; /* kernel_type */

struct svm_parameter
{
	int svm_type;
	int kernel_type;
	int degree;	/* for poly */
	double gamma;	/* for poly/rbf/sigmoid */
	double coef0;	/* for poly/sigmoid */

	/* these are for training only */

typemap  view on Meta::CPAN

TYPEMAP

SVM *				T_SVM
DataSet*			T_DATASET


OUTPUT

T_SVM
	if( $var == NULL )	XSRETURN_UNDEF;
	sv_setref_pv( $arg, "Algorithm::SVM", (void*)$var );

T_DATASET
	if( $var == NULL )	XSRETURN_UNDEF;
	sv_setref_pv( $arg, "Algorithm::SVM::DataSet", (void*)$var );

INPUT

T_SVM
	if( sv_isobject($arg) && sv_isa($arg, \"Algorithm::SVM\") ) {
		$var = ($type)SvIV((SV*)SvRV( $arg ));
	} else {
		warn( \"${Package}::$func_name() -- $var is not an Algorithm::SVM object\" );
		XSRETURN_UNDEF;
	}

T_DATASET