liblinear-ruby 0.0.7 → 1.0.0

data/spec/liblinear/example_spec.rb

@@ -0,0 +1,17 @@
+$: << File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+require 'liblinear'
+
+describe Liblinear::Example do
+  describe '#max_feature_id' do
+    it 'returns max feature id' do
+      expect(Liblinear::Example.max_feature_id([[1, 4], [1, 2, 3, 100]])).to eq(4)
+      expect(Liblinear::Example.max_feature_id([{1 => 1, 2 => 2}, {100 => 100}])).to eq(100)
+    end
+  end
+
+  describe '#array_to_hash' do
+    it 'returns hash' do
+      expect(Liblinear::Example.array_to_hash([1, 2, 3])).to eq({1 => 1, 2 => 2, 3 => 3})
+    end
+  end
+end

data/spec/liblinear/feature_node_matrix_spec.rb

@@ -0,0 +1,14 @@
+$: << File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+require 'liblinear'
+
+describe Liblinear::FeatureNodeMatrix do
+  before do
+    @feature_node_matrix = Liblinear::FeatureNodeMatrix.new([[1], [2]], -1)
+  end
+
+  describe '#swig' do
+    it 'returns SWIG::TYPE_p_p_feature_node' do
+      expect(@feature_node_matrix.swig.class).to eq(SWIG::TYPE_p_p_feature_node)
+    end
+  end
+end

data/spec/liblinear/feature_node_spec.rb

@@ -0,0 +1,14 @@
+$: << File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+require 'liblinear'
+
+describe Liblinear::FeatureNode do
+  before do
+    @feature_node = Liblinear::FeatureNode.new([1, 2], 2)
+  end
+
+  describe '#swig' do
+    it 'returns Liblinearswig::Feature_node' do
+      expect(@feature_node.swig.class).to eq(Liblinearswig::Feature_node)
+    end
+  end
+end

data/spec/liblinear/model_spec.rb

@@ -3,99 +3,56 @@ require 'liblinear'
 
 describe Liblinear::Model do
   before do
-    @prob = Liblinear::Problem.new([1, 2], [[1],[2]])
-    @param_1 = Liblinear::Parameter.new
-    @model_classification = Liblinear::Model.new(@prob, @param_1)
-
-    @param_2 = Liblinear::Parameter.new({ solver_type: Liblinear::L2R_L2LOSS_SVR })
-    @model_regression = Liblinear::Model.new(@prob, @param_2)
+    @problem = Liblinear::Problem.new([1, 2], [[1],[2]])
+    @parameter = Liblinear::Parameter.new()
+    @model = Liblinear::Model.train(@problem, @parameter)
   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]')
+  describe '#swig' do
+    it 'returns [Liblinearswig::Model]' do
+      expect(@model.swig.class).to eq(Liblinearswig::Model)
     end
   end
 
   describe '#class_size' do
-    it 'returns the number of classes' do
-      expect(@model_classification.class_size).to eq(2)
+    it 'returns class size' do
+      expect(@model.class_size).to eq(2)
     end
   end
 
   describe '#feature_size' do
-    it 'returns the number of features' do
-      expect(@model_classification.feature_size).to eq(1)
-    end
-  end
-
-  describe '#labels' do
-    it 'returns labels' do
-      expect(@model_classification.labels).to eq([1, 2])
-    end
-  end
-
-  describe '#predict' do
-    it 'returns predicted class' do
-      expect(@model_classification.predict([1]).class).to eq(Float)
+    it 'returns feature size' do
+      expect(@model.feature_size).to eq(1)
     end
   end
 
-  describe '#predict_probability' do
-    it 'returns predict_probability' do
-      expect(@model_classification.predict_probability([1]).class).to eq(Hash)
+  describe '#feature_weights' do
+    it 'returns feature weights' do
+      expect(@model.feature_weights.first.class).to eq(Float)
     end
   end
 
-  describe '#predict_values' do
-    it 'returns predict_values' do
-      expect(@model_classification.predict_values([1]).class).to eq(Hash)
+  describe '#bias' do
+    it 'returns bias' do
+      expect(@model.bias).to eq(-1)
     end
   end
 
-  describe '#coefficient' do
-    it 'returns a coefficient' do
-      expect(@model_classification.coefficient(1, 0).class).to eq(Float)
-    end
-
-    it 'returns a coefficient' do
-      expect(@model_classification.coefficient(1).class).to eq(Float)
-    end
-
-    it 'returns all coefficients' do
-      expect(@model_classification.coefficient.class).to eq(Array)
+  describe '#labels' do
+    it 'returns labels' do
+      expect(@model.labels).to eq([1, 2])
     end
   end
 
-  describe '#bias' do
-    it 'return a bias' do
-      expect(@model_classification.bias.class).to eq(Float)
+  describe '#probability_model?' do
+    it 'returns false' do
+      expect(@model.probability_model?).to eq(false)
     end
   end
 
   describe '#regression_model?' do
-    it 'returns true' do
-      expect(@model_regression.regression_model?).to eq(true)
-    end
-
     it 'returns false' do
-      expect(@model_classification.regression_model?).to eq (false)
+      expect(@model.regression_model?).to eq(false)
     end
   end
 end

data/spec/liblinear/parameter_spec.rb

@@ -2,56 +2,66 @@ $: << File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
 require 'liblinear'
 
 describe Liblinear::Parameter do
-  before do
-    @param = Liblinear::Parameter.new
+  describe 'class method' do
+    describe '#default_epsilon' do
+      it 'returns default value of epsilon' do
+        expect(Liblinear::Parameter.default_epsilon(Liblinear::L2R_L2LOSS_SVR)).to eq(0.001)
+      end
+    end
   end
 
-  describe '#solver_type' do
-    it 'returns solver type' do
-      @param.solver_type = 0
-      expect(@param.solver_type).to eq(Liblinear::L2R_LR)
+  describe 'instance method' do
+    before do
+      @parameter = Liblinear::Parameter.new({
+        solver_type:    Liblinear::L2R_LR,
+        cost:           0.5,
+        sensitive_loss: 0.2,
+        epsilon:        0.5,
+        weight_labels:  [1, 2],
+        weights:        [0.1, 0.2],
+      })
     end
-  end
 
-  describe '#c' do
-    it 'returns C' do
-      @param.C = 2
-      expect(@param.C).to eq(2)
+    describe '#swig' do
+      it 'returns [Liblinearswig::Parameter]' do
+        expect(@parameter.swig.class).to eq(Liblinearswig::Parameter)
+      end
     end
-  end
 
-  describe '#eps' do
-    it 'returns eps' do
-      @param.eps = 0.0
-      expect(@param.eps).to eq(0.0)
+    describe '#solver_type' do
+      it 'returns solver type' do
+        expect(@parameter.solver_type).to eq(Liblinear::L2R_LR)
+      end
     end
-  end
 
-  describe '#p' do
-    it 'returns p' do
-      @param.p = 0.0
-      expect(@param.p).to eq(0.0)
+    describe '#cost' do
+      it 'returns cost' do
+        expect(@parameter.cost).to eq(0.5)
+      end
     end
-  end
 
-  describe '#nr_weight' do
-    it 'returns nr_weight' do
-      @param.nr_weight = 3
-      expect(@param.nr_weight).to eq(3)
+    describe '#sensitive_loss' do
+      it 'returns sensitive loss' do
+        expect(@parameter.sensitive_loss).to eq(0.2)
+      end
     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)
+    describe '#epsilon' do
+      it 'returns epsilon' do
+        expect(@parameter.epsilon).to eq(0.5)
+      end
+    end
+
+    describe '#weight_labels' do
+      it 'returns weight labels' do
+        expect(@parameter.weight_labels).to eq([1, 2])
+      end
     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)
+    describe '#weights' do
+      it 'returns weights' do
+        expect(@parameter.weights).to eq([0.1, 0.2])
+      end
     end
   end
 end

data/spec/liblinear/problem_spec.rb

@@ -7,17 +7,39 @@ describe Liblinear::Problem 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')
+  describe '#swig' do
+    it 'returns [Liblinearswig::Problem]' do
+      expect(@problem.swig.class).to eq(Liblinearswig::Problem)
     end
   end
 
-  describe '#prob' do
-    it 'returns an instance of [Liblinearswig::Problem]' do
-      expect(@problem.prob.class).to eq(Liblinearswig::Problem)
+  describe '#example_size' do
+    it 'returns example size' do
+      expect(@problem.example_size).to eq(2)
+    end
+  end
+
+  describe '#max_feature_id' do
+    it 'returns max feature id' do
+      expect(@problem.max_feature_id).to eq(1)
+    end
+  end
+
+  describe '#labels' do
+    it 'returns labels' do
+      expect(@problem.labels).to eq([1, 2])
+    end
+  end
+
+  describe '#example_matrix' do
+    it 'returns example matrix' do
+      expect(@problem.example_matrix.class).to eq(Liblinear::FeatureNodeMatrix)
+    end
+  end
+
+  describe '#bias' do
+    it 'returns bias' do
+      expect(@problem.bias).to eq(-1)
     end
   end
 end

data/spec/liblinear_spec.rb

@@ -2,103 +2,63 @@ $: << File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
 require 'liblinear'
 
 describe Liblinear do
-  include Liblinear
-  include Liblinearswig
-
   before do
-    @int_ruby_array = [1, 2, 3]
-    @double_ruby_array = [1.0, 2.0, 3.0]
-    @int_c_array = new_int_array(@int_ruby_array)
-    @double_c_array = new_double_array(@double_ruby_array)
-    @examples_hash = [{1=>1, 2=>2}, {3=>3, 4=>4}]
-    @examples_array = [[1, 2], [3, 4, 5]]
-    @example_hash = {1=>1, 2=>2, 3=>3}
-    @example_array = [1, 2, 3]
+    @model = Liblinear.train(
+      { solver_type: Liblinear::L2R_LR },
+      [1, 2],
+      [[-1, -1], [1, 1]],
+    )
   end
 
   describe 'solver type' do
     it 'solver type equal integer value defined Liblinearswig' do
-      expect(Liblinear::L2R_LR).to eq(Liblinearswig::L2R_LR)
+      expect(Liblinear::L2R_LR).to              eq(Liblinearswig::L2R_LR)
       expect(Liblinear::L2R_L2LOSS_SVC_DUAL).to eq(Liblinearswig::L2R_L2LOSS_SVC_DUAL)
-      expect(Liblinear::L2R_L2LOSS_SVC).to eq(Liblinearswig::L2R_L2LOSS_SVC)
+      expect(Liblinear::L2R_L2LOSS_SVC).to      eq(Liblinearswig::L2R_L2LOSS_SVC)
       expect(Liblinear::L2R_L1LOSS_SVC_DUAL).to eq(Liblinearswig::L2R_L1LOSS_SVC_DUAL)
-      expect(Liblinear::MCSVM_CS).to eq(Liblinearswig::MCSVM_CS)
-      expect(Liblinear::L1R_L2LOSS_SVC).to eq(Liblinearswig::L1R_L2LOSS_SVC)
-      expect(Liblinear::L1R_LR).to eq(Liblinearswig::L1R_LR)
-      expect(Liblinear::L2R_LR_DUAL).to eq(Liblinearswig::L2R_LR_DUAL)
-      expect(Liblinear::L2R_L2LOSS_SVR).to eq(Liblinearswig::L2R_L2LOSS_SVR)
+      expect(Liblinear::MCSVM_CS).to            eq(Liblinearswig::MCSVM_CS)
+      expect(Liblinear::L1R_L2LOSS_SVC).to      eq(Liblinearswig::L1R_L2LOSS_SVC)
+      expect(Liblinear::L1R_LR).to              eq(Liblinearswig::L1R_LR)
+      expect(Liblinear::L2R_LR_DUAL).to         eq(Liblinearswig::L2R_LR_DUAL)
+      expect(Liblinear::L2R_L2LOSS_SVR).to      eq(Liblinearswig::L2R_L2LOSS_SVR)
       expect(Liblinear::L2R_L2LOSS_SVR_DUAL).to eq(Liblinearswig::L2R_L2LOSS_SVR_DUAL)
       expect(Liblinear::L2R_L1LOSS_SVR_DUAL).to eq(Liblinearswig::L2R_L1LOSS_SVR_DUAL)
     end
   end
 
-  describe '#new_int_array' do
-    it 'returns [SWIG::TYPE_p_int]' do
-      expect(new_int_array(@int_ruby_array).class).to eq(SWIG::TYPE_p_int)
-    end
-  end
-
-  describe '#free_int_array' do
-    it 'returns different array when free c array' do
-      expect(int_array_c_to_ruby(@int_c_array, 3)).to eq(@int_ruby_array)
-      free_int_array(@int_c_array)
-      expect(int_array_c_to_ruby(@int_c_array, 3)).not_to eq(@int_ruby_array)
-    end
-  end
-
-  describe '#new_double_array' do
-    it 'returns [SWIG::TYPE_p_double]' do
-      expect(new_double_array(@double_ruby_array).class).to eq(SWIG::TYPE_p_double)
-    end
-  end
-
-  describe '#free_double_array' do
-    it 'returns different array when free c array' do
-      expect(double_array_c_to_ruby(@double_c_array, 3)).to eq(@double_ruby_array)
-      free_double_array(@double_c_array)
-      expect(double_array_c_to_ruby(@double_c_array, 3)).not_to eq(@double_ruby_array)
-    end
-  end
-
-  describe '#int_array_c_to_ruby' do
-    it 'returns [Array<Integer>]' do
-      expect(int_array_c_to_ruby(@int_c_array, 3)).to eq(@int_ruby_array)
+  describe '#check_parameter' do
+    it 'returns error message' do
+      expect(
+        Liblinear.check_parameter(
+          Liblinear::Problem.new([1, 2], [[1], [2]]),
+          Liblinear::Parameter.new({cost: -1})
+        )
+      ).to eq('C <= 0')
     end
   end
 
-  describe '#double_array_c_to_ruby' do
-    it 'returns [Array<Double>]' do
-      expect(double_array_c_to_ruby(@double_c_array, 3)).to eq(@double_ruby_array)
+  describe '#cross_validation' do
+    it 'returns cross validation result' do
+      expect(
+        Liblinear.cross_validation(
+          2,
+          {},
+          [1, 2],
+          [[1], [-1]]
+        ).class
+      ).to eq(Array)
     end
   end
 
-  describe '#max_index' do
-    it 'returns max key when example is [Hash]' do
-      expect(max_index(@examples_hash)).to eq(4)
-    end
-
-    it 'returns max index + 1 when example is [Array]' do
-      expect(max_index(@examples_array)).to eq(3)
+  describe '#predict' do
+    it 'returns prediction' do
+      expect(Liblinear.predict(@model, [0.5, 0.5])).to eq(2.0)
     end
   end
 
-  describe '#array_to_hash' do
-    it 'returns hash whose key is index + 1 of array' do
-      expect(array_to_hash(@example_array)).to eq(@example_hash)
-    end
-
-    it 'raise ArgumentError when array is not [Array]' do
-      expect{array_to_hash(1)}.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#convert_to_feature_node_array' do
-    it 'returns [Liblinearswig::Feature_node] when example is [Hash]' do
-      expect(convert_to_feature_node_array(@example_hash, 3).class).to eq(Liblinearswig::Feature_node)
-    end
-
-    it 'returns [Liblinearswig::Feature_node] when examples is [Array]' do
-      expect(convert_to_feature_node_array(@example_array, 3).class).to eq(Liblinearswig::Feature_node)
+  describe 'labels' do
+    it 'returns labels' do
+      expect(Liblinear.labels(@model)).to eq([1, 2])
     end
   end
 end