#include <stdio.h>#include <stdlib.h>#include <string.h>//#include <malloc.h>#include <ctype.h>#include "svm.h"#define Malloc(type,n) (type *)malloc((n)*sizeof(type))void exit_with_help(){	printf(	"Usage: svm-train [options] training_set_file [model_file]\n"	"options:\n"	"-b cost0 : set the beginning cost value of alpha seeding for -t 0 -s 0 and 3 (default 1)\n"	"-c cost : set the parameter C of support vector machine (default 1)\n"	"-d degree : set degree in kernel function (default 3)\n"	"-e epsilon : set tolerance of termination criterion (default 0.001)\n"	"-g gamma : set gamma in kernel function (default 1/k)\n"	"-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)\n"	"-i step : set the step value of alpha seeding for -t 0 -s 0 and 3 (default 2)\n"	"		cost0, cost0*step, cost0*step^2, ..., cost.\n"	"-m cachesize : set cache memory size in MB (default 40) (useless for -t 0)\n"	"-p epsilon : set the epsilon in loss function of support vector regression (default 0.1)\n"	"-q qpsize : set the sub-problem size for -s 0,1 and 3\n"	"-r coef0 : set coef0 in kernel function (default 0)\n"	"-s svm_type : set type of SVM (default 0)\n"	"    0 -- multi-class bound-constrained support vector classification (SVC)\n"	"    1 -- multi-class SVC from solving a bound-constrained problem\n"	"    2 -- multi-class SVC from Cram and Singer\n"	"    3 -- bound-constrained support vector regression\n"	"-t kernel_type : set type of kernel function (default 2)\n"	"    0 -- linear: u'*v\n"	"    1 -- polynomial: (gamma*u'*v + coef0)^degree\n"	"    2 -- radial basis function: exp(-gamma*|u-v|^2)\n"	"    3 -- sigmoid: tanh(gamma*u'*v + coef0)\n"	"-v n: n-fold cross validation mode\n"	"-wi weight: set the parameter C of class i to weight*C, for classification problem (default 1)\n"	);	exit(1);}void parse_command_line(int argc, char **argv, char *input_file_name, char *model_file_name);void read_problem(const char *filename);void do_cross_validation();struct svm_parameter param;		// set by parse_command_linestruct svm_problem prob;		// set by read_problemstruct svm_model *model;struct svm_node *x_space;int cross_validation = 0;int nr_fold;int main(int argc, char **argv){	char input_file_name[1024];	char model_file_name[1024];	const char *error_msg;//	mallopt(M_MMAP_THRESHOLD, 32*1024);//	mallopt(M_MMAP_MAX, 32*1024);	parse_command_line(argc, argv, input_file_name, model_file_name);	read_problem(input_file_name);	error_msg = svm_check_parameter(&prob,&param);	if(error_msg)	{		fprintf(stderr,"Error: %s\n",error_msg);		exit(1);	}	if(cross_validation)	{		do_cross_validation();	}	else	{		model = svm_train(&prob,&param);		svm_save_model(model_file_name,model);		svm_destroy_model(model);	}	free(prob.y);	free(prob.x);	free(x_space);	return 0;}void do_cross_validation(){	int i;	int total_correct = 0;	double total_error = 0;	double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;	// random shuffle	for(i=0;i<prob.l;i++)	{		int j = i+rand()%(prob.l-i);		struct svm_node *tx;		double ty;					tx = prob.x[i];		prob.x[i] = prob.x[j];		prob.x[j] = tx;		ty = prob.y[i];		prob.y[i] = prob.y[j];		prob.y[j] = ty;	}	for(i=0;i<nr_fold;i++)	{		int begin = i*prob.l/nr_fold;		int end = (i+1)*prob.l/nr_fold;		int j,k;		struct svm_problem subprob;		subprob.l = prob.l-(end-begin);		subprob.n = prob.n;		subprob.x = Malloc(struct svm_node*,subprob.l);		subprob.y = Malloc(double,subprob.l);					k=0;		for(j=0;j<begin;j++)		{			subprob.x[k] = prob.x[j];			subprob.y[k] = prob.y[j];			++k;		}		for(j=end;j<prob.l;j++)		{			subprob.x[k] = prob.x[j];			subprob.y[k] = prob.y[j];			++k;		}		if(param.svm_type == EPSILON_SVR)		{			struct svm_model *submodel = svm_train(&subprob,&param);			double error = 0;			for(j=begin;j<end;j++)			{				double v = svm_predict(submodel,prob.x[j]);				double y = prob.y[j];				error += (v-y)*(v-y);				sumv += v;				sumy += y;				sumvv += v*v;				sumyy += y*y;				sumvy += v*y;			}			svm_destroy_model(submodel);			printf("Mean squared error = %g\n", error/(end-begin));			total_error += error;					}		else		{			struct svm_model *submodel = svm_train(&subprob,&param);			int correct = 0;			for(j=begin;j<end;j++)			{				double v = svm_predict(submodel,prob.x[j]);				if(v == prob.y[j])					++correct;			}			svm_destroy_model(submodel);			printf("Accuracy = %g%% (%d/%d)\n", 100.0*correct/(end-begin),correct,(end-begin));			total_correct += correct;		}		free(subprob.x);		free(subprob.y);	}			if(param.svm_type == EPSILON_SVR)	{		printf("Cross Validation Mean squared error = %g\n",total_error/prob.l);		printf("Cross Validation Squared correlation coefficient = %g\n",			((prob.l*sumvy-sumv*sumy)*(prob.l*sumvy-sumv*sumy))/			((prob.l*sumvv-sumv*sumv)*(prob.l*sumyy-sumy*sumy))			);	}	else		printf("Cross Validation Accuracy = %g%%\n",100.0*total_correct/prob.l);}void parse_command_line(int argc, char **argv, char *input_file_name, char *model_file_name){	int i;	// default values	param.svm_type = C_SVC;	param.kernel_type = RBF;	param.degree = 3;	param.gamma = 0;	// 1/k	param.coef0 = 0;	param.cache_size = 40;	param.C = 1;	param.eps = 1e-3;	param.p = 0.1;	param.shrinking = 1;	param.qpsize = 10;	param.nr_weight = 0;	param.weight_label = NULL;	param.weight = NULL;	param.Cbegin = 1;	param.Cstep = 2;	// parse options	for(i=1;i<argc;i++)	{		if(argv[i][0] != '-') break;		++i;		switch(argv[i-1][1])		{			case 's':				param.svm_type = atoi(argv[i]);				break;			case 't':				param.kernel_type = atoi(argv[i]);				break;			case 'd':				param.degree = atof(argv[i]);				break;			case 'g':				param.gamma = atof(argv[i]);				break;			case 'r':				param.coef0 = atof(argv[i]);				break;			case 'm':				param.cache_size = atof(argv[i]);				break;			case 'c':				param.C = atof(argv[i]);				break;			case 'e':				param.eps = atof(argv[i]);				break;			case 'p':				param.p = atof(argv[i]);				break;			case 'h':				param.shrinking = atoi(argv[i]);				break;			case 'q':				param.qpsize = atoi(argv[i]);				break;			case 'v':				cross_validation = 1;				nr_fold = atoi(argv[i]);				if(nr_fold < 2)				{					fprintf(stderr,"n-fold cross validation: n must >= 2\n");					exit_with_help();				}				break;			case 'w':				++param.nr_weight;				param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);				param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);				param.weight_label[param.nr_weight-1] = atoi(&argv[i-1][2]);				param.weight[param.nr_weight-1] = atof(argv[i]);				break;			case 'b':				param.Cbegin = atof(argv[i]);				break;			case 'i':				param.Cstep = atof(argv[i]);				break;			default:				fprintf(stderr,"unknown option\n");				exit_with_help();		}	}	// determine filenames	if(i>=argc)		exit_with_help();	strcpy(input_file_name, argv[i]);	if(i<argc-1)		strcpy(model_file_name,argv[i+1]);	else	{		char *p = strrchr(argv[i],'/');		if(p==NULL)			p = argv[i];		else			++p;		sprintf(model_file_name,"%s.model",p);	}}// read in a problem (in svmlight format)void read_problem(const char *filename){	int elements, max_index, i, j;	FILE *fp = fopen(filename,"r");		if(fp == NULL)	{		fprintf(stderr,"can't open input file %s\n",filename);		exit(1);	}	prob.l = 0;	elements = 0;	while(1)	{		int c = fgetc(fp);		switch(c)		{			case '\n':				++prob.l;				// fall through,				// count the '-1' element			case ':':				++elements;				break;			case EOF:				goto out;			default:				;		}	}out:	rewind(fp);	prob.y = Malloc(double,prob.l);	prob.x = Malloc(struct svm_node *,prob.l);	x_space = Malloc(struct svm_node,elements);	max_index = 0;	j=0;	for(i=0;i<prob.l;i++)	{		double label;		prob.x[i] = &x_space[j];		fscanf(fp,"%lf",&label);		prob.y[i] = label;		while(1)		{			int c;			do {				c = getc(fp);				if(c=='\n') goto out2;			} while(isspace(c));			ungetc(c,fp);			fscanf(fp,"%d:%lf",&(x_space[j].index),&(x_space[j].value));			++j;		}	out2:		if(j>=1 && x_space[j-1].index > max_index)			max_index = x_space[j-1].index;		x_space[j++].index = -1;	}	prob.n = max_index;	if(param.gamma == 0)		param.gamma = 1.0/max_index;	fclose(fp);}