liblinear-ruby 0.0.2 → 0.0.3

data/{liblinear-1.93 → liblinear-1.94}/matlab/libsvmread.c

@@ -25,10 +25,11 @@ void exit_with_help()
 	);
 }
 
-static void fake_answer(mxArray *plhs[])
+static void fake_answer(int nlhs, mxArray *plhs[])
 {
-	plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL);
-	plhs[1] = mxCreateDoubleMatrix(0, 0, mxREAL);
+	int i;
+	for(i=0;i<nlhs;i++)
+		plhs[i] = mxCreateDoubleMatrix(0, 0, mxREAL);
 }
 
 static char *line;
@@ -53,7 +54,7 @@ static char* readline(FILE *input)
 }
 
 // read in a problem (in libsvm format)
-void read_problem(const char *filename, mxArray *plhs[])
+void read_problem(const char *filename, int nlhs, mxArray *plhs[])
 {
 	int max_index, min_index, inst_max_index, i;
 	long elements, k;
@@ -66,7 +67,7 @@ void read_problem(const char *filename, mxArray *plhs[])
 	if(fp == NULL)
 	{
 		mexPrintf("can't open input file %s\n",filename);
-		fake_answer(plhs);
+		fake_answer(nlhs, plhs);
 		return;
 	}
 
@@ -96,7 +97,7 @@ void read_problem(const char *filename, mxArray *plhs[])
 			if(endptr == idx || errno != 0 || *endptr != '\0' || index <= inst_max_index)
 			{
 				mexPrintf("Wrong input format at line %d\n",l+1);
-				fake_answer(plhs);
+				fake_answer(nlhs, plhs);
 				return;
 			}
 			else
@@ -135,14 +136,14 @@ void read_problem(const char *filename, mxArray *plhs[])
 		if(label == NULL)
 		{
 			mexPrintf("Empty line at line %d\n",i+1);
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 		labels[i] = strtod(label,&endptr);
 		if(endptr == label || *endptr != '\0')
 		{
 			mexPrintf("Wrong input format at line %d\n",i+1);
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 
@@ -161,7 +162,7 @@ void read_problem(const char *filename, mxArray *plhs[])
 			if (endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
 			{
 				mexPrintf("Wrong input format at line %d\n",i+1);
-				fake_answer(plhs);
+				fake_answer(nlhs, plhs);
 				return;
 			}
 			++k;
@@ -178,7 +179,7 @@ void read_problem(const char *filename, mxArray *plhs[])
 		if(mexCallMATLAB(1, lhs, 1, rhs, "transpose"))
 		{
 			mexPrintf("Error: cannot transpose problem\n");
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 		plhs[1] = lhs[0];
@@ -188,25 +189,25 @@ void read_problem(const char *filename, mxArray *plhs[])
 void mexFunction( int nlhs, mxArray *plhs[],
 		int nrhs, const mxArray *prhs[] )
 {
-	if(nrhs == 1)
+	char filename[256];
+
+	if(nrhs != 1 || nlhs != 2)
 	{
-		char filename[256];
+		exit_with_help();
+		fake_answer(nlhs, plhs);
+		return;
+	}
 
-		mxGetString(prhs[0], filename, mxGetN(prhs[0]) + 1);
+	mxGetString(prhs[0], filename, mxGetN(prhs[0]) + 1);
 
-		if(filename == NULL)
-		{
-			mexPrintf("Error: filename is NULL\n");
-			return;
-		}
-
-		read_problem(filename, plhs);
-	}
-	else
+	if(filename == NULL)
 	{
-		exit_with_help();
-		fake_answer(plhs);
+		mexPrintf("Error: filename is NULL\n");
 		return;
 	}
+
+	read_problem(filename, nlhs, plhs);
+
+	return;
 }
 

data/{liblinear-1.93 → liblinear-1.94}/matlab/libsvmwrite.c

@@ -16,6 +16,13 @@ void exit_with_help()
 	);
 }
 
+static void fake_answer(int nlhs, mxArray *plhs[])
+{
+	int i;
+	for(i=0;i<nlhs;i++)
+		plhs[i] = mxCreateDoubleMatrix(0, 0, mxREAL);
+}
+
 void libsvmwrite(const char *filename, const mxArray *label_vec, const mxArray *instance_mat)
 {
 	FILE *fp = fopen(filename,"w");
@@ -77,7 +84,14 @@ void libsvmwrite(const char *filename, const mxArray *label_vec, const mxArray *
 
 void mexFunction( int nlhs, mxArray *plhs[],
 		int nrhs, const mxArray *prhs[] )
-{	
+{
+	if(nlhs > 0)
+	{
+		exit_with_help();
+		fake_answer(nlhs, plhs);
+		return;
+	}
+	
 	// Transform the input Matrix to libsvm format
 	if(nrhs == 3)
 	{

data/{liblinear-1.93 → liblinear-1.94}/matlab/predict.c

@@ -49,14 +49,14 @@ void read_sparse_instance(const mxArray *prhs, int index, struct feature_node *x
 	x[j].index = -1;
 }
 
-static void fake_answer(mxArray *plhs[])
+static void fake_answer(int nlhs, mxArray *plhs[])
 {
-	plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL);
-	plhs[1] = mxCreateDoubleMatrix(0, 0, mxREAL);
-	plhs[2] = mxCreateDoubleMatrix(0, 0, mxREAL);
+	int i;
+	for(i=0;i<nlhs;i++)
+		plhs[i] = mxCreateDoubleMatrix(0, 0, mxREAL);
 }
 
-void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, const int predict_probability_flag)
+void do_predict(int nlhs, 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;
@@ -65,6 +65,7 @@ void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, co
 	double *ptr_prob_estimates, *ptr_dec_values, *ptr;
 	struct feature_node *x;
 	mxArray *pplhs[1]; // instance sparse matrix in row format
+	mxArray *tplhs[3]; // temporary storage for plhs[]
 
 	int correct = 0;
 	int total = 0;
@@ -95,13 +96,13 @@ void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, co
 	if(label_vector_row_num!=testing_instance_number)
 	{
 		mexPrintf("Length of label vector does not match # of instances.\n");
-		fake_answer(plhs);
+		fake_answer(nlhs, plhs);
 		return;
 	}
 	if(label_vector_col_num!=1)
 	{
 		mexPrintf("label (1st argument) should be a vector (# of column is 1).\n");
-		fake_answer(plhs);
+		fake_answer(nlhs, plhs);
 		return;
 	}
 
@@ -117,7 +118,7 @@ void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, co
 		if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose"))
 		{
 			mexPrintf("Error: cannot transpose testing instance matrix\n");
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 	}
@@ -125,15 +126,15 @@ void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, co
 
 	prob_estimates = Malloc(double, nr_class);
 
-	plhs[0] = mxCreateDoubleMatrix(testing_instance_number, 1, mxREAL);
+	tplhs[0] = mxCreateDoubleMatrix(testing_instance_number, 1, mxREAL);
 	if(predict_probability_flag)
-		plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_class, mxREAL);
+		tplhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_class, mxREAL);
 	else
-		plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_w, mxREAL);
+		tplhs[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]);
+	ptr_predict_label = mxGetPr(tplhs[0]);
+	ptr_prob_estimates = mxGetPr(tplhs[2]);
+	ptr_dec_values = mxGetPr(tplhs[2]);
 	x = Malloc(struct feature_node, feature_number+2);
 	for(instance_index=0;instance_index<testing_instance_number;instance_index++)
 	{
@@ -189,8 +190,8 @@ void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, co
 		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]);
+	tplhs[1] = mxCreateDoubleMatrix(3, 1, mxREAL);
+	ptr = mxGetPr(tplhs[1]);
 	ptr[0] = (double)correct/total*100;
 	ptr[1] = error/total;
 	ptr[2] = ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
@@ -199,12 +200,23 @@ void do_predict(mxArray *plhs[], const mxArray *prhs[], struct model *model_, co
 	free(x);
 	if(prob_estimates != NULL)
 		free(prob_estimates);
+
+	switch(nlhs)
+	{
+		case 3:
+			plhs[2] = tplhs[2];
+			plhs[1] = tplhs[1];
+		case 1:
+		case 0:
+			plhs[0] = tplhs[0];
+	}
 }
 
 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"
+			"       [predicted_label] = 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"
@@ -225,10 +237,10 @@ void mexFunction( int nlhs, mxArray *plhs[],
 	info = &mexPrintf;
 	col_format_flag = 0;
 
-	if(nrhs > 5 || nrhs < 3)
+	if(nlhs == 2 || nlhs > 3 || nrhs > 5 || nrhs < 3)
 	{
 		exit_with_help();
-		fake_answer(plhs);
+		fake_answer(nlhs, plhs);
 		return;
 	}
 	if(nrhs == 5)
@@ -242,7 +254,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 
 	if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) {
 		mexPrintf("Error: label vector and instance matrix must be double\n");
-		fake_answer(plhs);
+		fake_answer(nlhs, plhs);
 		return;
 	}
 
@@ -269,7 +281,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 				if(i>=argc && argv[i-1][1] != 'q')
 				{
 					exit_with_help();
-					fake_answer(plhs);
+					fake_answer(nlhs, plhs);
 					return;
 				}
 				switch(argv[i-1][1])
@@ -284,7 +296,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 					default:
 						mexPrintf("unknown option\n");
 						exit_with_help();
-						fake_answer(plhs);
+						fake_answer(nlhs, plhs);
 						return;
 				}
 			}
@@ -296,7 +308,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 		{
 			mexPrintf("Error: can't read model: %s\n", error_msg);
 			free_and_destroy_model(&model_);
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 
@@ -310,12 +322,12 @@ void mexFunction( int nlhs, mxArray *plhs[],
 		}
 
 		if(mxIsSparse(prhs[1]))
-			do_predict(plhs, prhs, model_, prob_estimate_flag);
+			do_predict(nlhs, plhs, prhs, model_, prob_estimate_flag);
 		else
 		{
 			mexPrintf("Testing_instance_matrix must be sparse; "
 				"use sparse(Testing_instance_matrix) first\n");
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 		}
 
 		// destroy model_
@@ -324,7 +336,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 	else
 	{
 		mexPrintf("model file should be a struct array\n");
-		fake_answer(plhs);
+		fake_answer(nlhs, plhs);
 	}
 
 	return;

data/{liblinear-1.93 → liblinear-1.94}/matlab/train.c

@@ -243,9 +243,11 @@ int parse_command_line(int nrhs, const mxArray *prhs[], char *model_file_name)
 	return 0;
 }
 
-static void fake_answer(mxArray *plhs[])
+static void fake_answer(int nlhs, mxArray *plhs[])
 {
-	plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL);
+	int i;
+	for(i=0;i<nlhs;i++)
+		plhs[i] = mxCreateDoubleMatrix(0, 0, mxREAL);
 }
 
 int read_problem_sparse(const mxArray *label_vec, const mxArray *instance_mat)
@@ -342,6 +344,13 @@ void mexFunction( int nlhs, mxArray *plhs[],
 	// (for cross validation)
 	srand(1);
 
+	if(nlhs > 1)
+	{
+		exit_with_help();
+		fake_answer(nlhs, plhs);
+		return;
+	}
+
 	// Transform the input Matrix to libsvm format
 	if(nrhs > 1 && nrhs < 5)
 	{
@@ -349,7 +358,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 
 		if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) {
 			mexPrintf("Error: label vector and instance matrix must be double\n");
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 
@@ -357,7 +366,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 		{
 			exit_with_help();
 			destroy_param(&param);
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 
@@ -368,7 +377,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 			mexPrintf("Training_instance_matrix must be sparse; "
 				"use sparse(Training_instance_matrix) first\n");
 			destroy_param(&param);
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 
@@ -383,7 +392,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 			free(prob.y);
 			free(prob.x);
 			free(x_space);
-			fake_answer(plhs);
+			fake_answer(nlhs, plhs);
 			return;
 		}
 
@@ -412,7 +421,7 @@ void mexFunction( int nlhs, mxArray *plhs[],
 	else
 	{
 		exit_with_help();
-		fake_answer(plhs);
+		fake_answer(nlhs, plhs);
 		return;
 	}
 }

data/{liblinear-1.93 → liblinear-1.94}/python/README

@@ -56,7 +56,7 @@ in liblinearutil.py and the usage is the same as the LIBLINEAR MATLAB interface.
 # Sparse data
 >>> y, x = [1,-1], [{1:1, 3:1}, {1:-1,3:-1}]
 >>> prob  = problem(y, x)
->>> param = parameter('-c 4 -B 1')
+>>> param = parameter('-s 0 -c 4 -B 1')
 >>> m = train(prob, param)
 
 # Other utility functions

data/{liblinear-1.93 → liblinear-1.94}/python/liblinear.py

@@ -147,7 +147,7 @@ class parameter(Structure):
 		self.bias = -1
 		self.cross_validation = False
 		self.nr_fold = 0
-		self.print_func = None
+		self.print_func = cast(None, PRINT_STRING_FUN)
 
 	def parse_options(self, options):
 		if isinstance(options, list):

data/{liblinear-1.93 → liblinear-1.94}/tron.cpp

@@ -74,7 +74,7 @@ void TRON::tron(double *w)
 	for (i=0; i<n; i++)
 		w[i] = 0;
 
-        f = fun_obj->fun(w);
+	f = fun_obj->fun(w);
 	fun_obj->grad(w, g);
 	delta = dnrm2_(&n, g, &inc);
 	double gnorm1 = delta;
@@ -94,10 +94,10 @@ void TRON::tron(double *w)
 
 		gs = ddot_(&n, g, &inc, s, &inc);
 		prered = -0.5*(gs-ddot_(&n, s, &inc, r, &inc));
-                fnew = fun_obj->fun(w_new);
+		fnew = fun_obj->fun(w_new);
 
 		// Compute the actual reduction.
-	        actred = f - fnew;
+		actred = f - fnew;
 
 		// On the first iteration, adjust the initial step bound.
 		snorm = dnrm2_(&n, s, &inc);
@@ -127,7 +127,7 @@ void TRON::tron(double *w)
 			iter++;
 			memcpy(w, w_new, sizeof(double)*n);
 			f = fnew;
-		        fun_obj->grad(w, g);
+			fun_obj->grad(w, g);
 
 			gnorm = dnrm2_(&n, g, &inc);
 			if (gnorm <= eps*gnorm1)

data/spec/liblinear/model_spec.rb

@@ -0,0 +1,56 @@
+$: << File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+require 'liblinear'
+
+describe Liblinear::Model do
+  before do
+    @prob = Liblinear::Problem.new([1, 2], [[1],[2]])
+    @param = Liblinear::Parameter.new
+    @model = Liblinear::Model.new(@prob, @param)
+  end
+
+  describe '#initialize' do
+    it 'raise ArgumentError when arg_1 not equal [Liblinear::Problem] or arg_2 not equal [Liblinear::Parameter]' do
+      expect{
+        Liblinear::Model.new(1, 2)
+      }.to raise_error(ArgumentError, 'arguments must be [Liblinear::Problem] and [Liblinear::Parameter]')
+    end
+
+    it 'raise Liblinear::InvalidParameter when parameter is invalid' do
+      param = Liblinear::Parameter.new
+      param.C = -1
+      expect{
+        Liblinear::Model.new(@prob, param)
+      }.to raise_error(Liblinear::InvalidParameter, 'C <= 0')
+    end
+
+    it 'raise ArgumentError when argument is not [String]' do
+      expect{
+        Liblinear::Model.new(1)
+      }.to raise_error(ArgumentError, 'argument must be [String]')
+    end
+  end
+
+  describe '#nr_class' do
+    it 'returns the number of classes' do
+      expect(@model.nr_class).to eq(2)
+    end
+  end
+
+  describe '#labels' do
+    it 'returns labels' do
+      expect(@model.labels).to eq([1, 2])
+    end
+  end
+
+  describe '#predict' do
+    it 'return predicted class' do
+      expect(@model.predict([1]).class).to eq(Float)
+    end
+  end
+
+  describe '#predict_probability' do
+    it 'return predict_probability' do
+      expect(@model.predict_probability([1]).class).to eq(Hash)
+    end
+  end
+end

data/spec/liblinear/parameter_spec.rb

@@ -0,0 +1,57 @@
+$: << File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+require 'liblinear'
+
+describe Liblinear::Parameter do
+  before do
+    @param = Liblinear::Parameter.new
+  end
+
+  describe '#solver_type' do
+    it 'returns solver type' do
+      @param.solver_type = 0
+      expect(@param.solver_type).to eq(Liblinear::L2R_LR)
+    end
+  end
+
+  describe '#c' do
+    it 'returns C' do
+      @param.C = 2
+      expect(@param.C).to eq(2)
+    end
+  end
+
+  describe '#eps' do
+    it 'returns eps' do
+      @param.eps = 0.0
+      expect(@param.eps).to eq(0.0)
+    end
+  end
+
+  describe '#p' do
+    it 'returns p' do
+      @param.p = 0.0
+      expect(@param.p).to eq(0.0)
+    end
+  end
+
+  describe '#nr_weight' do
+    it 'returns nr_weight' do
+      @param.nr_weight = 3
+      expect(@param.nr_weight).to eq(3)
+    end
+  end
+
+  describe '#weight_label' do
+    it 'returns weight_label' do
+      @param.weight_label = [1, 2, 3]
+      expect(@param.weight_label.class).to eq(SWIG::TYPE_p_int)
+    end
+  end
+
+  describe '#weight' do
+    it 'returns weight' do
+      @param.weight = [1.0, 2.0, 3.0]
+      expect(@param.weight.class).to eq(SWIG::TYPE_p_double)
+    end
+  end
+end

data/spec/liblinear/problem_spec.rb

@@ -0,0 +1,23 @@
+$: << File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+require 'liblinear'
+
+describe Liblinear::Problem do
+  include Liblinearswig
+  before do
+    @problem = Liblinear::Problem.new([1, 2], [[1],[2]])
+  end
+
+  describe '#initialize' do
+    it 'raise ArgumentError when size of labels is different from that of examples' do
+      expect{
+        Liblinear::Problem.new([1, 2], [[1]])
+      }.to raise_error(ArgumentError, 'labels and examples must be same size')
+    end
+  end
+
+  describe '#prob' do
+    it 'returns an instance of [Liblinearswig::Problem]' do
+      expect(@problem.prob.class).to eq(Liblinearswig::Problem)
+    end
+  end
+end