liblinear-ruby 0.0.1

data/liblinear-1.93/matlab/libsvmwrite.c

@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "mex.h"
+
+#ifdef MX_API_VER
+#if MX_API_VER < 0x07030000
+typedef int mwIndex;
+#endif
+#endif
+
+void exit_with_help()
+{
+	mexPrintf(
+	"Usage: libsvmwrite('filename', label_vector, instance_matrix);\n"
+	);
+}
+
+void libsvmwrite(const char *filename, const mxArray *label_vec, const mxArray *instance_mat)
+{
+	FILE *fp = fopen(filename,"w");
+	int i, k, low, high, l;
+	mwIndex *ir, *jc;
+	int label_vector_row_num;
+	double *samples, *labels;
+	mxArray *instance_mat_col; // instance sparse matrix in column format
+
+	if(fp ==NULL)
+	{
+		mexPrintf("can't open output file %s\n",filename);			
+		return;
+	}
+
+	// transpose instance matrix
+	{
+		mxArray *prhs[1], *plhs[1];
+		prhs[0] = mxDuplicateArray(instance_mat);
+		if(mexCallMATLAB(1, plhs, 1, prhs, "transpose"))
+		{
+			mexPrintf("Error: cannot transpose instance matrix\n");
+			return;
+		}
+		instance_mat_col = plhs[0];
+		mxDestroyArray(prhs[0]);
+	}
+
+	// the number of instance
+	l = (int) mxGetN(instance_mat_col);
+	label_vector_row_num = (int) mxGetM(label_vec);
+
+	if(label_vector_row_num!=l)
+	{
+		mexPrintf("Length of label vector does not match # of instances.\n");
+		return;
+	}
+
+	// each column is one instance
+	labels = mxGetPr(label_vec);
+	samples = mxGetPr(instance_mat_col);
+	ir = mxGetIr(instance_mat_col);
+	jc = mxGetJc(instance_mat_col);
+
+	for(i=0;i<l;i++)
+	{
+		fprintf(fp,"%g", labels[i]);
+
+		low = (int) jc[i], high = (int) jc[i+1];
+		for(k=low;k<high;k++)
+			fprintf(fp," %ld:%g", ir[k]+1, samples[k]);		
+
+		fprintf(fp,"\n");
+	}
+
+	fclose(fp);
+	return;
+}
+
+void mexFunction( int nlhs, mxArray *plhs[],
+		int nrhs, const mxArray *prhs[] )
+{	
+	// Transform the input Matrix to libsvm format
+	if(nrhs == 3)
+	{
+		char filename[256];
+		if(!mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2]))
+		{
+			mexPrintf("Error: label vector and instance matrix must be double\n");			
+			return;
+		}
+		
+		mxGetString(prhs[0], filename, mxGetN(prhs[0])+1);		
+
+		if(mxIsSparse(prhs[2]))
+			libsvmwrite(filename, prhs[1], prhs[2]);
+		else
+		{
+			mexPrintf("Instance_matrix must be sparse\n");			
+			return;
+		}
+	}
+	else
+	{
+		exit_with_help();		
+		return;
+	}
+}

data/liblinear-1.93/matlab/linear_model_matlab.c

@@ -0,0 +1,176 @@
+#include <stdlib.h>
+#include <string.h>
+#include "../linear.h"
+
+#include "mex.h"
+
+#ifdef MX_API_VER
+#if MX_API_VER < 0x07030000
+typedef int mwIndex;
+#endif
+#endif
+
+#define Malloc(type,n) (type *)malloc((n)*sizeof(type))
+
+#define NUM_OF_RETURN_FIELD 6
+
+static const char *field_names[] = {
+	"Parameters",
+	"nr_class",
+	"nr_feature",
+	"bias",
+	"Label",
+	"w",
+};
+
+const char *model_to_matlab_structure(mxArray *plhs[], struct model *model_)
+{
+	int i;
+	int nr_w;
+	double *ptr;
+	mxArray *return_model, **rhs;
+	int out_id = 0;
+	int n, w_size;
+
+	rhs = (mxArray **)mxMalloc(sizeof(mxArray *)*NUM_OF_RETURN_FIELD);
+
+	// Parameters
+	// for now, only solver_type is needed
+	rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL);
+	ptr = mxGetPr(rhs[out_id]);
+	ptr[0] = model_->param.solver_type;
+	out_id++;
+
+	// nr_class
+	rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL);
+	ptr = mxGetPr(rhs[out_id]);
+	ptr[0] = model_->nr_class;
+	out_id++;
+
+	if(model_->nr_class==2 && model_->param.solver_type != MCSVM_CS)
+		nr_w=1;
+	else
+		nr_w=model_->nr_class;
+
+	// nr_feature
+	rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL);
+	ptr = mxGetPr(rhs[out_id]);
+	ptr[0] = model_->nr_feature;
+	out_id++;
+
+	// bias
+	rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL);
+	ptr = mxGetPr(rhs[out_id]);
+	ptr[0] = model_->bias;
+	out_id++;
+
+	if(model_->bias>=0)
+		n=model_->nr_feature+1;
+	else
+		n=model_->nr_feature;
+
+	w_size = n;
+	// Label
+	if(model_->label)
+	{
+		rhs[out_id] = mxCreateDoubleMatrix(model_->nr_class, 1, mxREAL);
+		ptr = mxGetPr(rhs[out_id]);
+		for(i = 0; i < model_->nr_class; i++)
+			ptr[i] = model_->label[i];
+	}
+	else
+		rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL);
+	out_id++;
+
+	// w
+	rhs[out_id] = mxCreateDoubleMatrix(nr_w, w_size, mxREAL);
+	ptr = mxGetPr(rhs[out_id]);
+	for(i = 0; i < w_size*nr_w; i++)
+		ptr[i]=model_->w[i];
+	out_id++;
+
+	/* Create a struct matrix contains NUM_OF_RETURN_FIELD fields */
+	return_model = mxCreateStructMatrix(1, 1, NUM_OF_RETURN_FIELD, field_names);
+
+	/* Fill struct matrix with input arguments */
+	for(i = 0; i < NUM_OF_RETURN_FIELD; i++)
+		mxSetField(return_model,0,field_names[i],mxDuplicateArray(rhs[i]));
+	/* return */
+	plhs[0] = return_model;
+	mxFree(rhs);
+
+	return NULL;
+}
+
+const char *matlab_matrix_to_model(struct model *model_, const mxArray *matlab_struct)
+{
+	int i, num_of_fields;
+	int nr_w;
+	double *ptr;
+	int id = 0;
+	int n, w_size;
+	mxArray **rhs;
+
+	num_of_fields = mxGetNumberOfFields(matlab_struct);
+	rhs = (mxArray **) mxMalloc(sizeof(mxArray *)*num_of_fields);
+
+	for(i=0;i<num_of_fields;i++)
+		rhs[i] = mxGetFieldByNumber(matlab_struct, 0, i);
+
+	model_->nr_class=0;
+	nr_w=0;
+	model_->nr_feature=0;
+	model_->w=NULL;
+	model_->label=NULL;
+
+	// Parameters
+	ptr = mxGetPr(rhs[id]);
+	model_->param.solver_type = (int)ptr[0];
+	id++;
+
+	// nr_class
+	ptr = mxGetPr(rhs[id]);
+	model_->nr_class = (int)ptr[0];
+	id++;
+
+	if(model_->nr_class==2 && model_->param.solver_type != MCSVM_CS)
+		nr_w=1;
+	else
+		nr_w=model_->nr_class;
+
+	// nr_feature
+	ptr = mxGetPr(rhs[id]);
+	model_->nr_feature = (int)ptr[0];
+	id++;
+
+	// bias
+	ptr = mxGetPr(rhs[id]);
+	model_->bias = (int)ptr[0];
+	id++;
+
+	if(model_->bias>=0)
+		n=model_->nr_feature+1;
+	else
+		n=model_->nr_feature;
+	w_size = n;
+
+	// Label
+	if(mxIsEmpty(rhs[id]) == 0)
+	{
+		model_->label = Malloc(int, model_->nr_class);
+		ptr = mxGetPr(rhs[id]);
+		for(i=0;i<model_->nr_class;i++)
+			model_->label[i] = (int)ptr[i];
+	}
+	id++;
+
+	ptr = mxGetPr(rhs[id]);
+	model_->w=Malloc(double, w_size*nr_w);
+	for(i = 0; i < w_size*nr_w; i++)
+		model_->w[i]=ptr[i];
+	id++;
+	mxFree(rhs);
+
+	return NULL;
+}
+

data/liblinear-1.93/matlab/linear_model_matlab.h

@@ -0,0 +1,2 @@
+const char *model_to_matlab_structure(mxArray *plhs[], struct model *model_);
+const char *matlab_matrix_to_model(struct model *model_, const mxArray *matlab_struct);

data/liblinear-1.93/matlab/make.m

@@ -0,0 +1,21 @@
+% This make.m is for MATLAB and OCTAVE under Windows, Mac, and Unix
+
+try
+	Type = ver;
+	% This part is for OCTAVE
+	if(strcmp(Type(1).Name, 'Octave') == 1)
+		mex libsvmread.c
+		mex libsvmwrite.c
+		mex train.c linear_model_matlab.c ../linear.cpp ../tron.cpp ../blas/*.c
+		mex predict.c linear_model_matlab.c ../linear.cpp ../tron.cpp ../blas/*.c
+	% This part is for MATLAB
+	% Add -largeArrayDims on 64-bit machines of MATLAB
+	else
+		mex CFLAGS="\$CFLAGS -std=c99" -largeArrayDims libsvmread.c
+		mex CFLAGS="\$CFLAGS -std=c99" -largeArrayDims libsvmwrite.c
+		mex CFLAGS="\$CFLAGS -std=c99" -largeArrayDims train.c linear_model_matlab.c ../linear.cpp ../tron.cpp "../blas/*.c"
+		mex CFLAGS="\$CFLAGS -std=c99" -largeArrayDims predict.c linear_model_matlab.c ../linear.cpp ../tron.cpp "../blas/*.c"
+	end
+catch
+	fprintf('If make.m fails, please check README about detailed instructions.\n');
+end

data/liblinear-1.93/matlab/predict.c

@@ -0,0 +1,331 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "../linear.h"
+
+#include "mex.h"
+#include "linear_model_matlab.h"
+
+#ifdef MX_API_VER
+#if MX_API_VER < 0x07030000
+typedef int mwIndex;
+#endif
+#endif
+
+#define CMD_LEN 2048
+
+#define Malloc(type,n) (type *)malloc((n)*sizeof(type))
+
+int print_null(const char *s,...) {}
+int (*info)(const char *fmt,...);
+
+int col_format_flag;
+
+void read_sparse_instance(const mxArray *prhs, int index, struct feature_node *x, int feature_number, double bias)
+{
+	int i, j, low, high;
+	mwIndex *ir, *jc;
+	double *samples;
+
+	ir = mxGetIr(prhs);
+	jc = mxGetJc(prhs);
+	samples = mxGetPr(prhs);
+
+	// each column is one instance
+	j = 0;
+	low = (int) jc[index], high = (int) jc[index+1];
+	for(i=low; i<high && (int) (ir[i])<feature_number; i++)
+	{
+		x[j].index = (int) ir[i]+1;
+		x[j].value = samples[i];
+		j++;
+	}
+	if(bias>=0)
+	{
+		x[j].index = feature_number+1;
+		x[j].value = bias;
+		j++;
+	}
+	x[j].index = -1;
+}
+
+static void fake_answer(mxArray *plhs[])
+{
+	plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL);
+	plhs[1] = mxCreateDoubleMatrix(0, 0, mxREAL);
+	plhs[2] = mxCreateDoubleMatrix(0, 0, mxREAL);
+}
+
+void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, const int predict_probability_flag)
+{
+	int label_vector_row_num, label_vector_col_num;
+	int feature_number, testing_instance_number;
+	int instance_index;
+	double *ptr_label, *ptr_predict_label;
+	double *ptr_prob_estimates, *ptr_dec_values, *ptr;
+	struct feature_node *x;
+	mxArray *pplhs[1]; // instance sparse matrix in row format
+
+	int correct = 0;
+	int total = 0;
+	double error = 0;
+	double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0;
+
+	int nr_class=get_nr_class(model_);
+	int nr_w;
+	double *prob_estimates=NULL;
+
+	if(nr_class==2 && model_->param.solver_type!=MCSVM_CS)
+		nr_w=1;
+	else
+		nr_w=nr_class;
+
+	// prhs[1] = testing instance matrix
+	feature_number = get_nr_feature(model_);
+	testing_instance_number = (int) mxGetM(prhs[1]);
+	if(col_format_flag)
+	{
+		feature_number = (int) mxGetM(prhs[1]);
+		testing_instance_number = (int) mxGetN(prhs[1]);
+	}
+
+	label_vector_row_num = (int) mxGetM(prhs[0]);
+	label_vector_col_num = (int) mxGetN(prhs[0]);
+
+	if(label_vector_row_num!=testing_instance_number)
+	{
+		mexPrintf("Length of label vector does not match # of instances.\n");
+		fake_answer(plhs);
+		return;
+	}
+	if(label_vector_col_num!=1)
+	{
+		mexPrintf("label (1st argument) should be a vector (# of column is 1).\n");
+		fake_answer(plhs);
+		return;
+	}
+
+	ptr_label    = mxGetPr(prhs[0]);
+
+	// transpose instance matrix
+	if(col_format_flag)
+		pplhs[0] = (mxArray *)prhs[1];
+	else
+	{
+		mxArray *pprhs[1];
+		pprhs[0] = mxDuplicateArray(prhs[1]);
+		if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose"))
+		{
+			mexPrintf("Error: cannot transpose testing instance matrix\n");
+			fake_answer(plhs);
+			return;
+		}
+	}
+
+
+	prob_estimates = Malloc(double, nr_class);
+
+	plhs[0] = mxCreateDoubleMatrix(testing_instance_number, 1, mxREAL);
+	if(predict_probability_flag)
+		plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_class, mxREAL);
+	else
+		plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_w, mxREAL);
+
+	ptr_predict_label = mxGetPr(plhs[0]);
+	ptr_prob_estimates = mxGetPr(plhs[2]);
+	ptr_dec_values = mxGetPr(plhs[2]);
+	x = Malloc(struct feature_node, feature_number+2);
+	for(instance_index=0;instance_index<testing_instance_number;instance_index++)
+	{
+		int i;
+		double target_label, predict_label;
+
+		target_label = ptr_label[instance_index];
+
+		// prhs[1] and prhs[1]^T are sparse
+		read_sparse_instance(pplhs[0], instance_index, x, feature_number, model_->bias);
+
+		if(predict_probability_flag)
+		{
+			predict_label = predict_probability(model_, x, prob_estimates);
+			ptr_predict_label[instance_index] = predict_label;
+			for(i=0;i<nr_class;i++)
+				ptr_prob_estimates[instance_index + i * testing_instance_number] = prob_estimates[i];
+		}
+		else
+		{
+			double *dec_values = Malloc(double, nr_class);
+			predict_label = predict_values(model_, x, dec_values);
+			ptr_predict_label[instance_index] = predict_label;
+
+			for(i=0;i<nr_w;i++)
+				ptr_dec_values[instance_index + i * testing_instance_number] = dec_values[i];
+			free(dec_values);
+		}
+
+		if(predict_label == target_label)
+			++correct;
+		error += (predict_label-target_label)*(predict_label-target_label);
+		sump += predict_label;
+		sumt += target_label;
+		sumpp += predict_label*predict_label;
+		sumtt += target_label*target_label;
+		sumpt += predict_label*target_label;
+
+		++total;
+	}
+
+	if(model_->param.solver_type==L2R_L2LOSS_SVR ||
+	   model_->param.solver_type==L2R_L1LOSS_SVR_DUAL ||
+	   model_->param.solver_type==L2R_L2LOSS_SVR_DUAL)
+	{
+		info("Mean squared error = %g (regression)\n",error/total);
+		info("Squared correlation coefficient = %g (regression)\n",
+			((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
+			((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt))
+			);
+	}
+	else
+		info("Accuracy = %g%% (%d/%d)\n", (double) correct/total*100,correct,total);
+
+	// return accuracy, mean squared error, squared correlation coefficient
+	plhs[1] = mxCreateDoubleMatrix(3, 1, mxREAL);
+	ptr = mxGetPr(plhs[1]);
+	ptr[0] = (double)correct/total*100;
+	ptr[1] = error/total;
+	ptr[2] = ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
+				((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt));
+
+	free(x);
+	if(prob_estimates != NULL)
+		free(prob_estimates);
+}
+
+void exit_with_help()
+{
+	mexPrintf(
+			"Usage: [predicted_label, accuracy, decision_values/prob_estimates] = predict(testing_label_vector, testing_instance_matrix, model, 'liblinear_options','col')\n"
+			"liblinear_options:\n"
+			"-b probability_estimates: whether to output probability estimates, 0 or 1 (default 0); currently for logistic regression only\n"
+			"-q quiet mode (no outputs)\n"
+			"col: if 'col' is setted testing_instance_matrix is parsed in column format, otherwise is in row format\n"
+			"Returns:\n"
+			"  predicted_label: prediction output vector.\n"
+			"  accuracy: a vector with accuracy, mean squared error, squared correlation coefficient.\n"
+			"  prob_estimates: If selected, probability estimate vector.\n"
+			);
+}
+
+void mexFunction( int nlhs, mxArray *plhs[],
+		int nrhs, const mxArray *prhs[] )
+{
+	int prob_estimate_flag = 0;
+	struct model *model_;
+	char cmd[CMD_LEN];
+	info = &mexPrintf;
+	col_format_flag = 0;
+
+	if(nrhs > 5 || nrhs < 3)
+	{
+		exit_with_help();
+		fake_answer(plhs);
+		return;
+	}
+	if(nrhs == 5)
+	{
+		mxGetString(prhs[4], cmd, mxGetN(prhs[4])+1);
+		if(strcmp(cmd, "col") == 0)
+		{
+			col_format_flag = 1;
+		}
+	}
+
+	if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) {
+		mexPrintf("Error: label vector and instance matrix must be double\n");
+		fake_answer(plhs);
+		return;
+	}
+
+	if(mxIsStruct(prhs[2]))
+	{
+		const char *error_msg;
+
+		// parse options
+		if(nrhs>=4)
+		{
+			int i, argc = 1;
+			char *argv[CMD_LEN/2];
+
+			// put options in argv[]
+			mxGetString(prhs[3], cmd,  mxGetN(prhs[3]) + 1);
+			if((argv[argc] = strtok(cmd, " ")) != NULL)
+				while((argv[++argc] = strtok(NULL, " ")) != NULL)
+					;
+
+			for(i=1;i<argc;i++)
+			{
+				if(argv[i][0] != '-') break;
+				++i;
+				if(i>=argc && argv[i-1][1] != 'q')
+				{
+					exit_with_help();
+					fake_answer(plhs);
+					return;
+				}
+				switch(argv[i-1][1])
+				{
+					case 'b':
+						prob_estimate_flag = atoi(argv[i]);
+						break;
+					case 'q':
+						info = &print_null;
+						i--;
+						break;
+					default:
+						mexPrintf("unknown option\n");
+						exit_with_help();
+						fake_answer(plhs);
+						return;
+				}
+			}
+		}
+
+		model_ = Malloc(struct model, 1);
+		error_msg = matlab_matrix_to_model(model_, prhs[2]);
+		if(error_msg)
+		{
+			mexPrintf("Error: can't read model: %s\n", error_msg);
+			free_and_destroy_model(&model_);
+			fake_answer(plhs);
+			return;
+		}
+
+		if(prob_estimate_flag)
+		{
+			if(!check_probability_model(model_))
+			{
+				mexPrintf("probability output is only supported for logistic regression\n");
+				prob_estimate_flag=0;
+			}
+		}
+
+		if(mxIsSparse(prhs[1]))
+			do_predict(plhs, prhs, model_, prob_estimate_flag);
+		else
+		{
+			mexPrintf("Testing_instance_matrix must be sparse; "
+				"use sparse(Testing_instance_matrix) first\n");
+			fake_answer(plhs);
+		}
+
+		// destroy model_
+		free_and_destroy_model(&model_);
+	}
+	else
+	{
+		mexPrintf("model file should be a struct array\n");
+		fake_answer(plhs);
+	}
+
+	return;
+}