liblinear-ruby 0.0.7 → 1.0.0

data/lib/liblinear/parameter.rb

@@ -1,42 +1,83 @@
-module Liblinear
+class Liblinear
   class Parameter
-    include Liblinear
-    include Liblinearswig
-    attr_accessor :param
-
-    # @param param [Hash]
-    def initialize(param = {})
-      @param = Liblinearswig::Parameter.new
-      self.solver_type = 1
-      self.C = 1
-      self.eps = 0.1
-      self.p = 0.1
-      self.nr_weight = 0
-      self.weight_label = []
-      self.weight = []
-      param.each do |k, v|
-        self.send("#{k}=", v)
+    class << self
+      # @return [Float]
+      def default_epsilon(solver_type)
+        case solver_type
+        when Liblinear::L2R_LR              then
+          0.01
+        when Liblinear::L2R_L2LOSS_SVC_DUAL then
+          0.1
+        when Liblinear::L2R_L2LOSS_SVC      then
+          0.01
+        when Liblinear::L2R_L1LOSS_SVC_DUAL then
+          0.1
+        when Liblinear::MCSVM_CS            then
+          0.1
+        when Liblinear::L1R_L2LOSS_SVC      then
+          0.01
+        when Liblinear::L1R_LR              then
+          0.01
+        when Liblinear::L2R_LR_DUAL         then
+          0.1
+        when Liblinear::L2R_L2LOSS_SVR      then
+          0.001
+        when Liblinear::L2R_L2LOSS_SVR_DUAL then
+          0.1
+        when Liblinear::L2R_L1LOSS_SVR_DUAL then
+          0.1
+        end
       end
     end
 
-    # @param weigt_label [Array <Integer>]
-    def weight_label=(weight_label)
-      free_int_array(@param.weight_label)
-      @param.weight_label = new_int_array(weight_label)
+    # @param parameter [Hash]
+    def initialize(parameter = {})
+      parameter[:weight_labels] = [] if parameter[:weight_labels].nil?
+      parameter[:weights]       = [] if parameter[:weights].nil?
+
+      @parameter = Liblinearswig::Parameter.new
+      @parameter.solver_type  = parameter[:solver_type] || Liblinear::L2R_L2LOSS_SVC_DUAL
+      @parameter.C            = parameter[:cost] || 1.0
+      @parameter.p            = parameter[:sensitive_loss] || 0.1
+      @parameter.eps          = parameter[:epsilon] || self.class.default_epsilon(@parameter.solver_type)
+      @parameter.nr_weight    = parameter[:weight_labels].size
+      @parameter.weight_label = Liblinear::Array::Integer.new(parameter[:weight_labels]).swig
+      @parameter.weight       = Liblinear::Array::Double.new(parameter[:weights]).swig
     end
 
-    # @param weight [Array <Double>]
-    def weight=(weight)
-      free_double_array(@param.weight)
-      @param.weight = new_double_array(weight)
+    # @return [Liblinearswig::Parameter]
+    def swig
+      @parameter
     end
 
-    def method_missing(m, *args)
-      if m.to_s.index('=')
-        @param.send(m.to_sym, args.first)
-      else
-        @param.send(m.to_sym)
-      end
+    # @return [Integer]
+    def solver_type
+      @parameter.solver_type
+    end
+
+    # @return [Float]
+    def cost
+      @parameter.C
+    end
+
+    # @return [Float]
+    def sensitive_loss
+      @parameter.p
+    end
+
+    # @return [Float]
+    def epsilon
+      @parameter.eps
+    end
+
+    # @return [Array <Integer>]
+    def weight_labels
+      Liblinear::Array::Integer.decode(@parameter.weight_label, @parameter.nr_weight)
+    end
+
+    # @return [Array <Float>]
+    def weights
+      Liblinear::Array::Double.decode(@parameter.weight, @parameter.nr_weight)
     end
   end
 end

data/lib/liblinear/problem.rb

@@ -1,45 +1,50 @@
-module Liblinear
+class Liblinear
   class Problem
-    include Liblinear
-    include Liblinearswig
-    attr_accessor :prob
-    attr_reader :labels, :examples
-
-    # @param labels [Array <Double>]
-    # @param examples [Array <Double, Hash>]
-    # @param bias [Double]
-    # @raise [ArgumentError]
+    # @param labels [Array <Float>]
+    # @param examples [Array <Array <Float> or Hash>]
+    # @param bias [Float]
     def initialize(labels, examples, bias = -1)
-      unless labels.size == examples.size
-        raise ArgumentError, 'labels and examples must be same size'
-      end
-      @prob = Liblinearswig::Problem.new
-      @labels = labels
-      c_labels = new_double_array(@labels)
+      @labels   = labels
       @examples = examples
-      @bias = bias
-      @max_example_index = max_index(@examples)
-      @example_matrix = feature_node_matrix(examples.size)
-      @c_example_array = []
+      @bias     = bias
+
+      @problem = Liblinearswig::Problem.new
+      @problem.y    = Liblinear::Array::Double.new(labels).swig
+      @problem.x    = example_matrix.swig
+      @problem.bias = bias
+      @problem.l    = examples.size
+      @problem.n    = Liblinear::Example.max_feature_id(examples)
+      @problem.n += 1 if bias >= 0
+    end
+
+    # @return [Liblinearswig::Problem]
+    def swig
+      @problem
+    end
 
-      set_example_matrix
+    # @return [Integer]
+    def example_size
+      @problem.l
+    end
+
+    # @return [Integer]
+    def max_feature_id
+      @problem.n
+    end
+
+    # @return [Array <Float>]
+    def labels
+      Liblinear::Array::Double.decode(@problem.y, @labels.size)
+    end
 
-      @prob.tap do |p|
-        p.y = c_labels
-        p.x = @example_matrix
-        p.bias = bias
-        p.l = examples.size
-        p.n = @max_example_index
-        p.n += 1 if bias >= 0
-      end
+    # @return [Liblinear::FeatureNodeMatrix]
+    def example_matrix
+      Liblinear::FeatureNodeMatrix.new(@examples, @bias)
     end
 
-    def set_example_matrix
-      @examples.size.times do |index|
-        c_example = convert_to_feature_node_array(@examples[index], @max_example_index, @bias)
-        @c_example_array << c_example
-        feature_node_matrix_set(@example_matrix, index, c_example)
-      end
+    # @return [Float]
+    def bias
+      @problem.bias
     end
   end
 end

data/lib/liblinear/version.rb

@@ -1,3 +1,3 @@
-module Liblinear
-  VERSION = '0.0.7'
+class Liblinear
+  VERSION = '1.0.0'
 end

data/lib/liblinear.rb

@@ -1,124 +1,129 @@
 $: << File.expand_path(File.join(__FILE__, '..', '..', 'ext'))
 
 require 'liblinearswig'
-require 'liblinear/cross_validator'
+require 'liblinear/array'
+require 'liblinear/array/integer'
+require 'liblinear/array/double'
+require 'liblinear/example'
+require 'liblinear/feature_node'
+require 'liblinear/feature_node_matrix'
 require 'liblinear/error'
 require 'liblinear/model'
 require 'liblinear/parameter'
 require 'liblinear/problem'
 require 'liblinear/version'
 
-module Liblinear
-  L2R_LR = Liblinearswig::L2R_LR
+class Liblinear
+  L2R_LR              = Liblinearswig::L2R_LR
   L2R_L2LOSS_SVC_DUAL = Liblinearswig::L2R_L2LOSS_SVC_DUAL
-  L2R_L2LOSS_SVC = Liblinearswig::L2R_L2LOSS_SVC
+  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
+  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)
-    ruby_array.size.times do |index|
-      Liblinearswig.int_setitem(c_int_array, index, ruby_array[index])
+  class << self
+    # @param problem [Liblinear::Problem]
+    # @param parameter [Liblinear::Parameter]
+    # @return [String]
+    def check_parameter(problem, parameter)
+      Liblinearswig.check_parameter(problem.swig, parameter.swig)
     end
-    c_int_array
-  end
-
-  # @param c_array [SWIG::TYPE_p_int]
-  def free_int_array(c_array)
-    delete_int(c_array) unless c_array.nil?
-  end
 
-  # @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)
-    ruby_array.size.times do |index|
-      Liblinearswig.double_setitem(c_double_array, index, ruby_array[index])
+    # @param fold [Integer]
+    # @param parameter [Hash]
+    # @param labels [Array <Integer>]
+    # @examples [Array [Array <Float> or Hash]
+    # @bias [<Float>]
+    # @return [Array <Float>]
+    def cross_validation(fold, parameter, labels, examples, bias = -1)
+      parameter = Liblinear::Parameter.new(parameter)
+      problem = Liblinear::Problem.new(labels, examples, bias)
+      error_message = self.check_parameter(problem, parameter)
+      raise Liblinear::InvalidParameter, error_message if error_message
+      prediction_swig = Liblinearswig.new_double(labels.size)
+      Liblinearswig.cross_validation(problem.swig, parameter.swig, fold, prediction_swig)
+      prediction = Liblinear::Array::Double.decode(prediction_swig, labels.size)
+      Liblinear::Array::Double.delete(prediction_swig)
+      prediction
     end
-    c_double_array
-  end
 
-  # @param c_array [SWIG::TYPE_p_double]
-  def free_double_array(c_array)
-    delete_double(c_array) unless c_array.nil?
-  end
-
-  # @param c_array [SWIG::TYPE_p_int]
-  # @param size [Integer]
-  # @return [Array<Integer>]
-  def int_array_c_to_ruby(c_array, size)
-    size.times.map {|index| int_getitem(c_array, index)}
-  end
-
-  # @param c_array [SWIG::TYPE_p_double]
-  # @param size [Integer]
-  # @return [Array <Double>]
-  def double_array_c_to_ruby(c_array, size)
-    size.times.map {|index| double_getitem(c_array, index)}
-  end
+    # @param parameter [Liblinear::Parameter]
+    # @param labels [Array <Integer>]
+    # @examples [Array [Array <Float> or Hash]
+    # @bias [<Float>]
+    # @return [Liblinear::Model]
+    def train(parameter, labels, examples, bias = -1)
+      parameter = Liblinear::Parameter.new(parameter)
+      problem = Liblinear::Problem.new(labels, examples, bias)
+      error_message = self.check_parameter(problem, parameter)
+      raise Liblinear::InvalidParameter, error_message if error_message
+      Liblinear::Model.train(problem, parameter)
+    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
+    # @param model [Liblinear::Model]
+    # @param examples [Array <Float> or Hash]
+    # @return [Integer]
+    def predict(model, example)
+      feature_node = Liblinear::FeatureNode.new(example, model.feature_size, model.bias)
+      prediction = Liblinearswig.predict(model.swig, feature_node.swig)
+      feature_node.delete
+      prediction
     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
+    # @param model [Liblinear::Model]
+    # @examples [Array <Float> or Hash]
+    # @return [Array <Float>]
+    def predict_probabilities(model, example)
+      feature_node = Liblinear::FeatureNode.new(example, model.feature_size, model.bias)
+      probability_swig = Liblinearswig.new_double(model.class_size)
+      Liblinearswig.predict_probability(model.swig, feature_node.swig, probability_swig)
+      probability = Liblinear::Array::Double.decode(probability_swig, model.class_size)
+      Liblinear::Array::Double.delete(probability_swig)
+      feature_node.delete
+      probability
     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)
+    # @param model [Liblinear::Model]
+    # @examples [Array <Float> or Hash]
+    # @return [Array <Float>]
+    def predict_values(model, example)
+      feature_node = Liblinear::FeatureNode.new(example, model.feature_size, model.bias)
+      values_swig = Liblinearswig.new_double(model.class_size)
+      Liblinearswig.predict_values(model.swig, feature_node.swig, values_swig)
+      values = Liblinear::Array::Double.decode(values_swig, model.class_size)
+      Liblinear::Array::Double.delete(values_swig)
+      feature_node.delete
+      values
+    end
 
-    example_indexes = []
-    example.each_key do |key|
-      example_indexes << key
+    # @param model [Liblinear::Model]
+    # @param feature_id [Integer]
+    # @param label_index [Integer]
+    # @return [Float]
+    def decision_function_coefficient(model, feature_id, label_index)
+      Liblinearswig.get_decfun_coef(model.swig, feature_id, label_index)
     end
-    example_indexes.sort!
 
-    if bias >= 0
-      feature_nodes = Liblinearswig.feature_node_array(example_indexes.size + 2)
-      Liblinearswig.feature_node_array_set(feature_nodes, example_indexes.size, max_value_index + 1, bias)
-      Liblinearswig.feature_node_array_set(feature_nodes, example_indexes.size + 1, -1, 0)
-    else
-      feature_nodes = Liblinearswig.feature_node_array(example_indexes.size + 1)
-      Liblinearswig.feature_node_array_set(feature_nodes, example_indexes.size, -1, 0)
+    # @param model [Liblinear::Model]
+    # @param label_index [Integer]
+    # @return [Float]
+    def decision_function_bias(model, label_index)
+      Liblinearswig.get_decfun_bias(model.swig, label_index)
     end
 
-    f_index = 0
-    example_indexes.each do |e_index|
-      Liblinearswig.feature_node_array_set(feature_nodes, f_index, e_index, example[e_index])
-      f_index += 1
+    # @param model [Liblinear::Model]
+    # @return [Array <Integer>]
+    def labels(model)
+      labels_swig = Liblinearswig.new_int(model.class_size)
+      Liblinearswig.get_labels(model.swig, labels_swig)
+      labels = Liblinear::Array::Integer.decode(labels_swig, model.class_size)
+      Liblinear::Array::Integer.delete(labels_swig)
+      labels
     end
-    feature_nodes
   end
 end

data/spec/liblinear/array/double_spec.rb

@@ -0,0 +1,21 @@
+$: << File.expand_path(File.join(__FILE__, '..', '..', '..', '..', 'lib'))
+require 'liblinear'
+
+describe Liblinear::Array::Double do
+  before do
+    @array = Liblinear::Array::Double.new([1.0, 1.1, 1.2])
+  end
+
+  describe '#decode' do
+    it 'returns decoded array' do
+      expect(Liblinear::Array::Double.decode(@array.swig, 3)).to eq([1.0, 1.1, 1.2])
+    end
+  end
+
+  describe '#delete' do
+    it 'delete array' do
+      Liblinear::Array::Double.delete(@array.swig)
+      expect(Liblinear::Array::Double.decode(@array.swig, 3)).not_to eq([1.0, 1.1, 1.2])
+    end
+  end
+end