liblinear-ruby 0.0.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7d1e2c1eeff706b5cd0494d4fc720dec937f710
-  data.tar.gz: 3d436efa057c9fa1a68e0e4e884322b4c07dfb10
+  metadata.gz: fe141358d47228659a23f83ea68a49dc09fc1401
+  data.tar.gz: 2165c62af5e42c40836eb17131f668e44a0c3311
 SHA512:
-  metadata.gz: 59d78c950c0d15db0213b6925a56a7aa56b567126fa184ceea744e13c418bedd4cd00638182ac0635f40075041cd96cde6bb1ba1c788440f0fbe70a9e46b128f
-  data.tar.gz: fbeaad15badd01d2fea3ebf2ab2a4cf594e7f4b90975e5c88c73f13433f9c3c3282c5d7939dd347355543e2a94216e5e9274d3089a823650cb616507c089bd8b
+  metadata.gz: 723448dcbff38bee0b668ee62d53c07ebbcd0d86feff6022480ab4a5904b39f8ef79bc5440baef3c38f55e120d58ce22327dd69d070cc36454d6dca6afe9c1d6
+  data.tar.gz: cd6f6aaaf33b0cf5d5400328b59341f80561eab64aece3e24c7dde2466800b5b4176e8dd81fcf26fba66eb8d3d444c607288dc2be842e122b1af47f3eb7db8ec

data/README.md

@@ -1,8 +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 using SWIG.
-Now, this interface is supporting LIBLINEAR 1.95.
+Liblinear-Ruby is Ruby interface of LIBLINEAR using SWIG.  
+Now, this interface is supporting LIBLINEAR 2.1.
 
 ## Installation
 
@@ -23,63 +23,29 @@ This sample code execute classification with L2-regularized logistic regression.
 ```ruby
 require 'liblinear'
 
-# 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}
-]
-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
-
-# Analyzing phase
-puts model.coefficient
-puts model.bias
-
-# Cross Validation
-fold = 2
-cv = Liblinear::CrossValidator.new(prob, param, fold)
-cv.execute
-
-puts cv.accuracy                        # for classification
-puts cv.mean_squared_error              # for regression
-puts cv.squared_correlation_coefficient # for regression
+# train
+model = Liblinear.train(
+  { solver_type: Liblinear::L2R_LR },   # parameter
+  [-1, -1, 1, 1],                       # labels (classes) of training data
+  [[-2, -2], [-1, -1], [1, 1], [2, 2]], # training data
+)
+# predict
+puts Liblinear.predict(model, [0.5, 0.5]) # predicted class will be 1
 ```
-## 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)
-```
+## Parameter
+There are some parameters you can specify:
 
-#### 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.
+- `solver_type`
+- `cost`
+- `sensitive_loss`
+- `epsilon`
+- `weight_labels` and `weights`
+
+### solver_type
+This parameter specifies a type of solver (default: `Liblinear::L2R_L2LOSS_SVC_DUAL`).  
+This corresponds to `-s` option on command line.  
+Solver types you can set are shown below:  
 ```ruby
 # for multi-class classification
 Liblinear::L2R_LR              # L2-regularized logistic regression (primal)
@@ -97,92 +63,80 @@ Liblinear::L2R_L2LOSS_SVR_DUAL # L2-regularized L2-loss support vector regressio
 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
-```
+### cost
+This parameter specifies the cost of constraints violation (default `1.0`).  
+This corresponds to `-c` option on command line.
 
-#### 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
-```
+### sensitive_loss
+This parameter specifies an epsilon in loss function of epsilon-SVR (default `0.1`).  
+This corresponds to `-p` option on command line.   
 
-#### 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
-```
+### epsilon
+This parameter specifies a tolerance of termination criterion.  
+This corresponds to `-e` option on command line.  
+The default value depends on a type of solver. See LIBLINEAR's README or `Liblinear::Parameter.default_epsion` for more details.
 
-#### 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 []
-```
+### weight_labels and weights
+These parameters are used to change the penalty for some classes (default `[]`).  
+Each `weights[i]` corresponds to `weight_labels[i]`, meaning that the penalty of class `weight_labels[i]` is scaled by a factor of `weights[i]`.  
+
+
+## Train
+First, prepare training data.  
 
-### Training phase
-You have to prepare training data.  
-The format of training data is shown below:
 ```ruby
-# Labels mean class
-label = [1, -1, ...]
+# Define class of each training data:
+labels = [1, -1, ...]
 
-# Training data have to be array of hash or array of array
-# If you chose array of hash
+# Training data is Array of Array:
 examples = [
-  {1=>0, 2=>0, 3=>0, 4=>0, 5=>0},
-  {1=>1, 2=>1, 3=>1, 4=>1, 5=>1},
+  [1, 0, 0, 1, 0],
+  [0, 0, 0, 1, 1],
   ...
 ]
 
-# If you chose array of array
+# You can also use Array of Hash instead:
 examples = [
-  [0, 0, 0, 0, 0],
-  [1, 1, 1, 1, 1],
+  { 1 => 1, 4 => 1 },
+  { 4 => 1, 5 => 1 },
+  ...
 ]
 ```
-Next, set the bias (this is comparable to -B option on command line):
+
+Next, set the bias (this corresponds 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:
+
+Then, specify parameters and execute `Liblinear.train` to get the instance of `Liblinear::Model`.
 ```ruby
-model = Liblinear::Model.new(model_file)
+model = Liblinear.train(parameter, labels, examples, bias)
 ```
+
 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:
+If you have already had a model file, you can load it as:
 ```ruby
-# Hash
-model.predict({1=>1, 2=>1, 3=>1, 4=>1, 5=>1})
-# Array
-model.predict([1, 1, 1, 1, 1])
+model = Liblinear::Model.load(file_name)
 ```
 
-## Contributing
+## Predict
+Prepare the data you want to predict its class and call `Liblinear.predict`.
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+```ruby
+examples = [0, 0, 0, 1, 1]
+Liblinear.predict(model, example)
+```
+
+## Cross Validation
+To get classes predicted by k-fold cross validation, use `Liblinear.cross_validation`.  
+For example, `results[0]` is a class predicted by `examples` excepts part including `examples[0]`.
+```ruby
+results = Liblinear.cross_validation(fold, parameter, labels, examples)
+```
 
 ## Thanks
 - http://www.csie.ntu.edu.tw/~cjlin/liblinear/

data/lib/liblinear/array/double.rb

@@ -0,0 +1,26 @@
+class Liblinear
+  class Array::Double < Array
+    class << self
+      # @param array [SWIG::TYPE_p_double]
+      # @param size [Integer]
+      # @return [Array <Float>]
+      def decode(array, size)
+        size.times.map {|index| Liblinearswig.double_getitem(array, index)}
+      end
+
+      # @param array [SWIG::TYPE_p_double]
+      def delete(array)
+        Liblinearswig.delete_double(array)
+      end
+    end
+
+    # @param array [Array <Float>]
+    def initialize(array)
+      @array = Liblinearswig.new_double(array.size)
+      array.size.times do |index|
+        Liblinearswig.double_setitem(@array, index, array[index])
+      end
+      @size = array.size
+    end
+  end
+end

data/lib/liblinear/array/integer.rb

@@ -0,0 +1,26 @@
+class Liblinear
+  class Array::Integer < Array
+    class << self
+      # @param array [SWIG::TYPE_p_int]
+      # @param size [Integer]
+      # @param return [Array <Integer>]
+      def decode(array, size)
+        size.times.map {|index| Liblinearswig.int_getitem(array, index)}
+      end
+
+      # @param array [SWIG::TYPE_p_int]
+      def delete(array)
+        Liblinearswig.delete_int(array)
+      end
+    end
+
+    # @param array [Array <Integer>]
+    def initialize(array)
+      @array = Liblinearswig.new_int(array.size)
+      array.size.times do |index|
+        Liblinearswig.int_setitem(@array, index, array[index])
+      end
+      @size = array.size
+    end
+  end
+end

data/lib/liblinear/array.rb

@@ -0,0 +1,15 @@
+class Liblinear
+  class Array
+    def swig
+      @array
+    end
+
+    def decode
+      self.class.decode(@array, @size)
+    end
+
+    def delete
+      self.class.delete(@array)
+    end
+  end
+end

data/lib/liblinear/error.rb

@@ -1,4 +1,4 @@
-module Liblinear
+class Liblinear
   class InvalidParameter < StandardError
   end
 end

data/lib/liblinear/example.rb

@@ -0,0 +1,29 @@
+class Liblinear
+  class Example
+    class << self
+      # @param examples [Array <Hash, Array>]
+      # @return [Integer]
+      def max_feature_id(examples)
+        max_feature_id = 0
+        examples.each do |example|
+          if example.is_a?(::Hash)
+            max_feature_id = [max_feature_id, example.keys.max].max if example.size > 0
+          else
+            max_feature_id = [max_feature_id, example.size].max
+          end
+        end
+        max_feature_id
+      end
+
+      # @param example_array [Array]
+      # @return [Hash]
+      def array_to_hash(example_array)
+        example_hash = {}
+        example_array.size.times do |index|
+          example_hash[index + 1] = example_array[index]
+        end
+        example_hash
+      end
+    end
+  end
+end

data/lib/liblinear/feature_node.rb

@@ -0,0 +1,40 @@
+class Liblinear
+  class FeatureNode
+    # @param examples [Array <Float> or Hash]
+    # @param max_feature_id [Integer]
+    # @param bias [Float]
+    def initialize(example, max_feature_id, bias = -1)
+      example = Liblinear::Example.array_to_hash(example) if example.is_a?(::Array)
+
+      example_indexes = []
+      example.each_key do |key|
+        example_indexes << key
+      end
+      example_indexes.sort!
+
+      if bias >= 0
+        @feature_node = Liblinearswig.feature_node_array(example_indexes.size + 2)
+        Liblinearswig.feature_node_array_set(@feature_node, example_indexes.size, max_feature_id + 1, bias)
+        Liblinearswig.feature_node_array_set(@feature_node, example_indexes.size + 1, -1, 0)
+      else
+        @feature_node = Liblinearswig.feature_node_array(example_indexes.size + 1)
+        Liblinearswig.feature_node_array_set(@feature_node, example_indexes.size, -1, 0)
+      end
+
+      f_index = 0
+      example_indexes.each do |e_index|
+        Liblinearswig.feature_node_array_set(@feature_node, f_index, e_index, example[e_index])
+        f_index += 1
+      end
+    end
+
+    # @return [Liblinearswig::Feature_node]
+    def swig
+      @feature_node
+    end
+
+    def delete
+      Liblinearswig.feature_node_array_destroy(@feature_node)
+    end
+  end
+end

data/lib/liblinear/feature_node_matrix.rb

@@ -0,0 +1,23 @@
+class Liblinear
+  class FeatureNodeMatrix
+    # @param examples [Array <Array <Float> or Hash>]
+    # @param bias [Float]
+    def initialize(examples, bias)
+      @feature_node_matrix = Liblinearswig.feature_node_matrix(examples.size)
+      max_feature_id = Liblinear::Example.max_feature_id(examples)
+      examples.size.times do |index|
+        feature_node = Liblinear::FeatureNode.new(examples[index], max_feature_id, bias)
+        Liblinearswig.feature_node_matrix_set(@feature_node_matrix, index, feature_node.swig)
+      end
+    end
+
+    # @return [SWIG::TYPE_p_p_feature_node]
+    def swig
+      @feature_node_matrix
+    end
+
+    def delete
+      Liblinearswig.feature_node_matrix_destroy(@feature_node_matrix)
+    end
+  end
+end

data/lib/liblinear/model.rb

@@ -1,113 +1,78 @@
-module Liblinear
+class Liblinear
   class Model
-    include Liblinear
-    include Liblinearswig
-    attr_accessor :model
+    class << self
+      # @param problem [LibLinear::Problem]
+      # @param parameter [Liblinear::Parameter]
+      # @return [Liblinear::Model]
+      def train(problem, parameter)
+        model = self.new
+        model.train(problem, parameter)
+        model
+      end
 
-    # @param arg_1 [LibLinear::Problem, String]
-    # @param arg_2 [Liblinear::Parameter]
-    # @raise [ArgumentError]
-    # @raise [Liblinear::InvalidParameter]
-    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]'
-        end
-        error_msg = check_parameter(arg_1.prob, arg_2.param)
-        raise InvalidParameter, error_msg if error_msg
-        @model = train(arg_1.prob, arg_2.param)
-      else
-        raise ArgumentError, 'argument must be [String]' unless arg_1.is_a?(String)
-        @model = load_model(arg_1)
+      # @param file_name [String]
+      # @return [Liblinear::Model]
+      def load(file_name)
+        model = self.new
+        model.load(file_name)
+        model
       end
     end
 
-    # @return [Integer]
-    def class_size
-      get_nr_class(@model)
+    # @param problem [LibLinear::Problem]
+    # @param parameter [Liblinear::Parameter]
+    def train(problem, parameter)
+      @model = Liblinearswig.train(problem.swig, parameter.swig)
     end
 
-    # @return [Integer]
-    def nr_class
-      warn "'nr_class' is deprecated. Please use 'class_size' instead."
-      class_size
+    # @param file_name [String]
+    def load(file_name)
+      @model = Liblinearswig.load_model(file_name)
     end
 
-    # @return [Integer]
-    def feature_size
-      get_nr_feature(@model)
+    # @return [Liblinear::Model]
+    def swig
+      @model
     end
 
-    # @return [Array <Integer>]
-    def labels
-      c_int_array = new_int(class_size)
-      get_labels(@model, c_int_array)
-      labels = int_array_c_to_ruby(c_int_array, class_size)
-      delete_int(c_int_array)
-      labels
+    # @param filename [String]
+    def save(filename)
+      Liblinearswig.save_model(filename, @model)
     end
 
-    # @param example [Array, Hash]
-    # @return [Double]
-    def predict(example)
-      feature_nodes = convert_to_feature_node_array(example, @model.nr_feature, @model.bias)
-      prediction = Liblinearswig.predict(@model, feature_nodes)
-      feature_node_array_destroy(feature_nodes)
-      prediction
+    # @return [Integer]
+    def class_size
+      @model.nr_class
     end
 
-    # @param example [Array, Hash]
-    # @return [Hash]
-    def predict_probability(example)
-      predict_prob_val(example, :predict_probability)
+    # @return [Integer]
+    def feature_size
+      @model.nr_feature
     end
 
-    # @param example [Array, Hash]
-    # @return [Hash]
-    def predict_values(example)
-      predict_prob_val(example, :predict_values)
+    # @return [Array <Float>]
+    def feature_weights
+      Liblinear::Array::Double.decode(@model.w, feature_size)
     end
 
-    # @param filename [String]
-    def save(filename)
-      save_model(filename, @model)
+    # @return [Float]
+    def bias
+      @model.bias
     end
 
-    # @param feature_index [Integer]
-    # @param label_index [Integer]
-    # @return [Double, Array <Double>]
-    def coefficient(feature_index = nil, label_index = 0)
-      return get_decfun_coef(@model, feature_index, label_index) if feature_index
-      coefficients = []
-      feature_size.times.map {|feature_index| get_decfun_coef(@model, feature_index + 1, label_index)}
+    # @return [Array <Integer>]
+    def labels
+      Liblinear::Array::Integer.decode(@model.label, class_size)
     end
 
-    # @param label_index [Integer]
-    # @return [Double]
-    def bias(label_index = 0)
-      get_decfun_bias(@model, label_index)
+    # @return [Boolean]
+    def probability_model?
+      Liblinearswig.check_probability_model(@model) == 1 ? true : false
     end
 
     # @return [Boolean]
     def regression_model?
-      check_regression_model(@model) == 1 ? true : false
-    end
-
-    private
-    # @param example [Array, Hash]
-    # @return [Hash]
-    def predict_prob_val(example, liblinear_func)
-      feature_nodes = convert_to_feature_node_array(example, @model.nr_feature, @model.bias)
-      c_double_array = new_double(class_size)
-      Liblinearswig.send(liblinear_func, @model, feature_nodes, c_double_array)
-      values = double_array_c_to_ruby(c_double_array, class_size)
-      delete_double(c_double_array)
-      feature_node_array_destroy(feature_nodes)
-      value_list = {}
-      labels.size.times do |i|
-        value_list[labels[i]] = values[i]
-      end
-      value_list
+      Liblinearswig.check_regression_model(@model) == 1 ? true : false
     end
   end
 end