liblinear-ruby 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5627682e3eced50c405c213569f4c18f178bd6a5
-  data.tar.gz: abdf3297770c99e176b26a74c34d2e2c4eb03de1
+  metadata.gz: 5a7efbbe95e53288a0a4be6ae55411f693a16b65
+  data.tar.gz: c7882e4f98923ff2193b9eb797f918bf7a83295d
 SHA512:
-  metadata.gz: 71443f67c21c93fbafd8031554045db2b8bdeddd2574b5dc582bf7cd034f5725c2bfe2acf56706fb5b07f5e82b598b43b2595619e14889c7ca913136668bf1ee
-  data.tar.gz: c85b14d11e5a858297826747c49a890ef60e63531750be77cb403cfc3543ca294d440dafa084d25752801387a351cd7da9d7cca8277846345de30b0bb9d02e2e
+  metadata.gz: 333b9b43537b0b903761a7141b25dce9ef9af61cc04a9b985ad6988c63a9d53c46caa07ff8ed123a295a759ab7bd4dcfcbbf69ccabdaf7529d41f250eea37712
+  data.tar.gz: d94f42793a1b98e6bdf3f33fddded2934806be5e8a9e0913fb8c44a041b59a6c4d7afa4f3d84aa0985ac3b5f5811b61f48d2a01b65e066bb13d0e1c49e2b85b7

data/README.md

@@ -1,6 +1,8 @@
 # Liblinear-Ruby
+[![Gem Version](https://badge.fury.io/rb/liblinear-ruby.png)](http://badge.fury.io/rb/liblinear-ruby)
 
-Liblinear-Ruby is Ruby interface to LIBLINEAR(1.9.3) using SWIG.
+Liblinear-Ruby is Ruby interface to LIBLINEAR using SWIG.  
+Now, this interface is supporting LIBLINEAR 1.94.
 
 ## Installation
 
@@ -16,21 +18,150 @@ Or install it yourself as:
 
     $ gem install liblinear-ruby
 
-## Usage
-
+## Quick Start
+This sample code execute classification with L2-regularized logistic regression.
 ```ruby
 require 'liblinear'
-pa = Liblinear::Parameter.new({solver_type: 0})
-bias = 0.5
-labels = [1, 2]
-# examples must be Array of Hash or Array
+
+# Setting parameters
+param = Liblinear::Parameter.new
+param.solver_type = Liblinear::L2R_LR
+
+# Training phase
+labels = [1, -1]
 examples = [
   {1=>0, 2=>0, 3=>0, 4=>0, 5=>0},
   {1=>1, 2=>1, 3=>1, 4=>1, 5=>1}
 ]
-pr = Liblinear::Problem.new(labels, examples, bias)
-m = Liblinear::Model.new(pr, pa)
-puts m.predict({1=>1, 2=>1, 3=>1, 4=>1, 5=>1}) # => 2.0
+bias = 0.5
+prob = Liblinear::Problem.new(labels, examples, bias)
+model = Liblinear::Model.new(prob, param)
+
+# Predicting phase
+puts model.predict({1=>1, 2=>1, 3=>1, 4=>1, 5=>1}) # => -1.0
+```
+## Usage
+
+### Setting parameters
+First, you have to make an instance of Liblinear::Parameter:
+```ruby
+param = Liblinear::Parameter.new
+```
+And then set the parameters as:
+```ruby
+param.[parameter_you_set] = value
+```
+Or you can set by Hash as:
+```ruby
+parameter = {
+  parameter_you_set: value,
+  ...
+}
+param = Liblinear::Parameter.new(parameter)
+```
+
+#### Type of solver
+This parameter is comparable to -s option on command line.  
+You can set as:
+```ruby
+param.solver_type = solver_type # default 1 (Liblinear::L2R_L2LOSS_SVC_DUAL)
+```
+Solver types you can set are shown below.
+```ruby
+# for multi-class classification
+Liblinear::L2R_LR              # L2-regularized logistic regression (primal)
+Liblinear::L2R_L2LOSS_SVC_DUAL # L2-regularized L2-loss support vector classification (dual)
+Liblinear::L2R_L2LOSS_SVC      # L2-regularized L2-loss support vector classification (primal)
+Liblinear::L2R_L1LOSS_SVC_DUAL # L2-regularized L1-loss support vector classification (dual)
+Liblinear::MCSVM_CS            # support vector classification by Crammer and Singer
+Liblinear::L1R_L2LOSS_SVC      # L1-regularized L2-loss support vector classification
+Liblinear::L1R_LR              # L1-regularized logistic regression
+Liblinear::L2R_LR_DUAL         # L2-regularized logistic regression (dual)
+
+# for regression
+Liblinear::L2R_L2LOSS_SVR      # L2-regularized L2-loss support vector regression (primal)
+Liblinear::L2R_L2LOSS_SVR_DUAL # L2-regularized L2-loss support vector regression (dual)
+Liblinear::L2R_L1LOSS_SVR_DUAL # L2-regularized L1-loss support vector regression (dual)
+```
+
+#### C parameter
+This parameter is comparable to -c option on command line.   
+You can set as:
+```ruby
+param.C = value # default 1
+```
+
+#### Epsilon in loss function of epsilon-SVR
+This parameter is comparable to -p option on command line.   
+You can set as:
+```ruby
+param.p = value # default 0.1
+```
+
+#### Tolerance of termination criterion
+This parameter is comparable to -e option on command line.   
+You can set as:
+```ruby
+param.eps = value # default 0.1
+```
+
+#### Weight
+This parameter adjust the parameter C of different classes(see LIBLINEAR's README for details).  
+nr_weight is the number of elements in the array weight_label and weight.  
+You can set as:
+```ruby
+param.nr_weight = value                # default 0
+param.weight_label = [Array <Integer>] # default []
+param.weight = [Array <Double>]        # default []
+```
+
+### Training phase
+You have to prepare training data.  
+The format of training data is shown below:
+```ruby
+# Labels mean class
+label = [1, -1, ...]
+
+# Training data have to be array of hash or array of array
+# If you chose array of hash
+examples = [
+  {1=>0, 2=>0, 3=>0, 4=>0, 5=>0},
+  {1=>1, 2=>1, 3=>1, 4=>1, 5=>1},
+  ...
+]
+
+# If you chose array of array
+examples = [
+  [0, 0, 0, 0, 0],
+  [1, 1, 1, 1, 1],
+]
+```
+Next, set the bias (this is comparable to -B option on command line):
+```ruby
+bias = 0.5 # default -1
+```
+And then make an instance of Liblinear::Problem and Liblinear::Model:
+```ruby
+prob = Liblinear::Problem.new(labels, examples, bias)
+model = Liblinear::Model.new(prob, param)
+```
+If you have already had a model file, you can load it as:
+```ruby
+prob = Liblinear::Problem.new(labels, examples, bias)
+model = Liblinear::Model.new(model_file)
+```
+In this phase, you can save model as:
+```ruby
+model.save(file_name)
+```
+
+### Predicting phase
+Input a data whose format is same as training data:
+```ruby
+# Hash
+model.predict({1=>1, 2=>1, 3=>1, 4=>1, 5=>1})
+# Array
+model.predict([1, 1, 1, 1, 1])
 ```
 
 ## Contributing

data/ext/linear.cpp

@@ -2051,8 +2051,8 @@ static void transpose(const problem *prob, feature_node **x_space_ret, problem *
 	int i;
 	int l = prob->l;
 	int n = prob->n;
-	int nnz = 0;
-	int *col_ptr = new int[n+1];
+	long int nnz = 0;
+	long int *col_ptr = new long int [n+1];
 	feature_node *x_space;
 	prob_col->l = l;
 	prob_col->n = n;
@@ -2140,6 +2140,24 @@ static void group_classes(const problem *prob, int *nr_class_ret, int **label_re
 		}
 	}
 
+	//
+	// Labels are ordered by their first occurrence in the training set. 
+	// However, for two-class sets with -1/+1 labels and -1 appears first, 
+	// we swap labels to ensure that internally the binary SVM has positive data corresponding to the +1 instances.
+	//
+	if (nr_class == 2 && label[0] == -1 && label[1] == 1)
+	{
+		swap(label[0],label[1]);
+		swap(count[0],count[1]);
+		for(i=0;i<l;i++)
+		{
+			if(data_label[i] == 0)
+				data_label[i] = 1;
+			else
+				data_label[i] = 0;
+		}
+	}
+
 	int *start = Malloc(int,nr_class);
 	start[0] = 0;
 	for(i=1;i<nr_class;i++)
@@ -2190,7 +2208,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			tron_obj.set_print_string(liblinear_print_string);
 			tron_obj.tron(w);
 			delete fun_obj;
-			delete C;
+			delete[] C;
 			break;
 		}
 		case L2R_L2LOSS_SVC:
@@ -2208,7 +2226,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			tron_obj.set_print_string(liblinear_print_string);
 			tron_obj.tron(w);
 			delete fun_obj;
-			delete C;
+			delete[] C;
 			break;
 		}
 		case L2R_L2LOSS_SVC_DUAL:
@@ -2253,7 +2271,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			tron_obj.set_print_string(liblinear_print_string);
 			tron_obj.tron(w);
 			delete fun_obj;
-			delete C;
+			delete[] C;
 			break;
 
 		}
@@ -2409,10 +2427,15 @@ model* train(const problem *prob, const parameter *param)
 void cross_validation(const problem *prob, const parameter *param, int nr_fold, double *target)
 {
 	int i;
-	int *fold_start = Malloc(int,nr_fold+1);
+	int *fold_start;
 	int l = prob->l;
 	int *perm = Malloc(int,l);
-
+	if (nr_fold > l)
+	{
+		nr_fold = l;
+		fprintf(stderr,"WARNING: # folds > # data. Will use # folds = # data instead (i.e., leave-one-out cross validation)\n");
+	}
+	fold_start = Malloc(int,nr_fold+1);
 	for(i=0;i<l;i++) perm[i]=i;
 	for(i=0;i<l;i++)
 	{

data/ext/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/lib/liblinear/model.rb

@@ -11,13 +11,13 @@ module Liblinear
     def initialize(arg_1, arg_2 = nil)
       if arg_2
         unless arg_1.is_a?(Liblinear::Problem) && arg_2.is_a?(Liblinear::Parameter)
-          raise ArgumentError, 'arguments must be Liblinear::Problem and Liblinear::Parameter'
+          raise ArgumentError, 'arguments must be [Liblinear::Problem] and [Liblinear::Parameter]'
         end
         error_msg = check_parameter(arg_1.prob, arg_2.params)
         raise InvalidParameter, error_msg if error_msg
         @model = train(arg_1.prob, arg_2.params)
       else
-        raise ArgumentError, 'argument must be String' unless arg_1.is_a?(String)
+        raise ArgumentError, 'argument must be [String]' unless arg_1.is_a?(String)
         @model = load_model(arg_1)
       end
     end
@@ -27,7 +27,7 @@ module Liblinear
       get_nr_class(@model)
     end
 
-    # @return [Array<Integer>]
+    # @return [Array <Integer>]
     def labels
       c_int_array = new_int(nr_class)
       get_labels(@model, c_int_array)

data/lib/liblinear/parameter.rb

@@ -19,13 +19,13 @@ module Liblinear
       end
     end
 
-    # @params weigt_label [Array<Integer>]
+    # @params weigt_label [Array <Integer>]
     def weight_label=(weight_label)
       free_int_array(@params.weight_label)
       @params.weight_label = new_int_array(weight_label)
     end
 
-    # @params weight [Array<Double>]
+    # @params weight [Array <Double>]
     def weight=(weight)
       free_double_array(@params.weight)
       @params.weight = new_double_array(weight)

data/lib/liblinear/problem.rb

@@ -4,11 +4,11 @@ module Liblinear
     include Liblinearswig
     attr_accessor :prob
 
-    # @param labels [Array<Double>]
-    # @param examples [Array<Double>, Array<Hash>]
+    # @param labels [Array <Double>]
+    # @param examples [Array <Double, Hash>]
     # @param bias [Double]
     # @raise [ArgumentError]
-    def initialize(labels, examples, bias)
+    def initialize(labels, examples, bias = -1)
       unless labels.size == examples.size
         raise ArgumentError, 'labels and examples must be same size'
       end
@@ -16,7 +16,7 @@ module Liblinear
       @c_label = new_double_array(labels)
       @examples = examples
       @bias = bias
-      @max_example_index = max_example_index
+      @max_example_index = max_index(@examples)
       @example_matrix = feature_node_matrix(examples.size)
       @c_example_array = []
 
@@ -32,19 +32,6 @@ module Liblinear
       end
     end
 
-    # @return [Integer]
-    def max_example_index
-      max_example_index = 0
-      @examples.each do |example|
-        if example.is_a?(Hash)
-          max_example_index = [max_example_index, example.keys.max].max if example.size > 0
-        else
-          max_example_index = [max_example_index, example.size].max
-        end
-      end
-      max_example_index
-    end
-
     def set_example_matrix
       @examples.size.times do |index|
         c_example = convert_to_feature_node_array(@examples[index], @max_example_index, @bias)

data/lib/liblinear/version.rb

@@ -1,3 +1,3 @@
 module Liblinear
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/liblinear.rb

@@ -8,7 +8,19 @@ require 'liblinear/problem'
 require 'liblinear/version'
 
 module Liblinear
-  # @param ruby_array [Array<Integer>]
+  L2R_LR = Liblinearswig::L2R_LR
+  L2R_L2LOSS_SVC_DUAL = Liblinearswig::L2R_L2LOSS_SVC_DUAL
+  L2R_L2LOSS_SVC = Liblinearswig::L2R_L2LOSS_SVC
+  L2R_L1LOSS_SVC_DUAL = Liblinearswig::L2R_L1LOSS_SVC_DUAL
+  MCSVM_CS = Liblinearswig::MCSVM_CS
+  L1R_L2LOSS_SVC = Liblinearswig::L1R_L2LOSS_SVC
+  L1R_LR = Liblinearswig::L1R_LR
+  L2R_LR_DUAL = Liblinearswig::L2R_LR_DUAL
+  L2R_L2LOSS_SVR = Liblinearswig::L2R_L2LOSS_SVR
+  L2R_L2LOSS_SVR_DUAL = Liblinearswig::L2R_L2LOSS_SVR_DUAL
+  L2R_L1LOSS_SVR_DUAL = Liblinearswig::L2R_L1LOSS_SVR_DUAL
+
+  # @param ruby_array [Array <Integer>]
   # @return [SWIG::TYPE_p_int]
   def new_int_array(ruby_array)
     c_int_array = Liblinearswig.new_int(ruby_array.size)
@@ -23,7 +35,7 @@ module Liblinear
     delete_int(c_array) unless c_array.nil?
   end
 
-  # @param ruby_array [Array<Double>]
+  # @param ruby_array [Array <Double>]
   # @return [SWIG::TYPE_p_double]
   def new_double_array(ruby_array)
     c_double_array = Liblinearswig.new_double(ruby_array.size)
@@ -47,27 +59,48 @@ module Liblinear
 
   # @param c_array [SWIG::TYPE_p_double]
   # @param size [Integer]
-  # @return [Array<Double>]
+  # @return [Array <Double>]
   def double_array_c_to_ruby(c_array, size)
     size.times.map {|index| double_getitem(c_array, index)}
   end
 
+  # @param examples [Array <Hash, Array>]
+  # @return [Integer]
+  def max_index(examples)
+    max_index = 0
+    examples.each do |example|
+      if example.is_a?(Hash)
+        max_index = [max_index, example.keys.max].max if example.size > 0
+      else
+        max_index = [max_index, example.size].max
+      end
+    end
+    max_index
+  end
+
+  # @param array [Array]
+  # @return [Hash]
+  def array_to_hash(array)
+    raise ArgumentError unless array.is_a?(Array)
+    hash = {}
+    key = 1
+    array.each do |value|
+      hash[key] = value
+      key += 1
+    end
+    hash
+  end
+
   # @param example [Hash, Array]
   # @param max_value_index [Integer]
   # @param bias [Double]
   # @return [Liblinearswig::Feature_node]
   def convert_to_feature_node_array(example, max_value_index, bias = -1)
+    example = array_to_hash(example) if example.is_a?(Array)
+
     example_indexes = []
-    if example.is_a?(Hash)
-      example.each_key do |key|
-        example_indexes << key
-      end
-    elsif example.is_a?(Array)
-      example.each_index do |index|
-        example_indexes << index
-      end
-    else
-      raise TypeError, 'example must be a Hash or an Array'
+    example.each_key do |key|
+      example_indexes << key
     end
     example_indexes.sort!
 

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

@@ -2051,8 +2051,8 @@ static void transpose(const problem *prob, feature_node **x_space_ret, problem *
 	int i;
 	int l = prob->l;
 	int n = prob->n;
-	int nnz = 0;
-	int *col_ptr = new int[n+1];
+	long int nnz = 0;
+	long int *col_ptr = new long int [n+1];
 	feature_node *x_space;
 	prob_col->l = l;
 	prob_col->n = n;
@@ -2140,6 +2140,24 @@ static void group_classes(const problem *prob, int *nr_class_ret, int **label_re
 		}
 	}
 
+	//
+	// Labels are ordered by their first occurrence in the training set. 
+	// However, for two-class sets with -1/+1 labels and -1 appears first, 
+	// we swap labels to ensure that internally the binary SVM has positive data corresponding to the +1 instances.
+	//
+	if (nr_class == 2 && label[0] == -1 && label[1] == 1)
+	{
+		swap(label[0],label[1]);
+		swap(count[0],count[1]);
+		for(i=0;i<l;i++)
+		{
+			if(data_label[i] == 0)
+				data_label[i] = 1;
+			else
+				data_label[i] = 0;
+		}
+	}
+
 	int *start = Malloc(int,nr_class);
 	start[0] = 0;
 	for(i=1;i<nr_class;i++)
@@ -2190,7 +2208,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			tron_obj.set_print_string(liblinear_print_string);
 			tron_obj.tron(w);
 			delete fun_obj;
-			delete C;
+			delete[] C;
 			break;
 		}
 		case L2R_L2LOSS_SVC:
@@ -2208,7 +2226,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			tron_obj.set_print_string(liblinear_print_string);
 			tron_obj.tron(w);
 			delete fun_obj;
-			delete C;
+			delete[] C;
 			break;
 		}
 		case L2R_L2LOSS_SVC_DUAL:
@@ -2253,7 +2271,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			tron_obj.set_print_string(liblinear_print_string);
 			tron_obj.tron(w);
 			delete fun_obj;
-			delete C;
+			delete[] C;
 			break;
 
 		}
@@ -2409,10 +2427,15 @@ model* train(const problem *prob, const parameter *param)
 void cross_validation(const problem *prob, const parameter *param, int nr_fold, double *target)
 {
 	int i;
-	int *fold_start = Malloc(int,nr_fold+1);
+	int *fold_start;
 	int l = prob->l;
 	int *perm = Malloc(int,l);
-
+	if (nr_fold > l)
+	{
+		nr_fold = l;
+		fprintf(stderr,"WARNING: # folds > # data. Will use # folds = # data instead (i.e., leave-one-out cross validation)\n");
+	}
+	fold_start = Malloc(int,nr_fold+1);
 	for(i=0;i<l;i++) perm[i]=i;
 	for(i=0;i<l;i++)
 	{

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

@@ -19,7 +19,7 @@ Introduction
 
 This tool provides a simple interface to LIBLINEAR, a library for
 large-scale regularized linear classification and regression
-(http://www.csie.ntu.edu.tw/~cjlin/liblinear).  It is very easy to use
+(http://www.csie.ntu.edu.tw/~cjlin/liblinear). It is very easy to use
 as the usage and the way of specifying parameters are the same as that
 of LIBLINEAR.
 
@@ -95,6 +95,7 @@ matlab> model = train(training_label_vector, training_instance_matrix [,'libline
             if 'col' is set, each column of training_instance_matrix is a data instance. Otherwise each row is a data instance.
 
 matlab> [predicted_label, accuracy, decision_values/prob_estimates] = predict(testing_label_vector, testing_instance_matrix, model [, 'liblinear_options', 'col']);
+matlab> [predicted_label] = predict(testing_label_vector, testing_instance_matrix, model [, 'liblinear_options', 'col']);
 
         -testing_label_vector:
             An m by 1 vector of prediction labels. If labels of test