jrb-libsvm 0.1.2-java

data/jrb-libsvm.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jrb-libsvm/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "jrb-libsvm"
+  gem.version       = JrbLibsvm::VERSION
+  gem.platform      = 'java'
+  gem.authors       = ["Andreas Eger"]
+  gem.email         = ["dev@eger-andreas.de"]
+  gem.description   = %q{JRuby language bindings for libsvm}
+  gem.summary       = %q{basic wrapper around the java libsvm libary}
+  gem.homepage      = "https://github.com/sch1zo/jrb-libsvm"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  # specify any dependencies here
+  gem.add_development_dependency('rspec', '>= 2.7.0')
+end

data/lib/jrb-libsvm/model.rb

@@ -0,0 +1,97 @@
+java_import 'java.io.DataOutputStream'
+java_import 'java.io.ByteArrayOutputStream'
+
+java_import 'java.io.StringReader'
+java_import 'java.io.BufferedReader'
+
+module Libsvm
+  class Model
+    class << self
+      def train(problem, parameter)
+        return Svm.svm_train(problem, parameter)
+      end
+    end
+
+    # Return the SVM problem type for this model
+    def svm_type
+      self.param.svm_type
+    end
+
+    # Return the kernel type for this model
+    def kernel_type
+      self.param.kernel_type
+    end
+
+    # Return the value of the degree parameter
+    def degree
+      self.param.degree
+    end
+
+    # Return the value of the gamma parameter
+    def gamma
+      self.param.gamma
+    end
+
+    # Return the value of the cost parameter
+    def cost
+      self.param.c
+    end
+
+    # Return the number of classes handled by this model.
+    def classes
+      self.nr_class
+    end
+
+    # Save model to given filename.
+    # Raises IOError on any error.
+    def save filename
+      Svm.svm_save_model(filename, self)
+    rescue e = java.io.IOException
+      raise IOError.new "Error in saving SVM model to file: #{e}"
+    end
+
+    # Serialize model and return a string
+    def serialize
+      stream = ByteArrayOutputStream.new
+      do_stream = DataOutputStream.new(stream)
+      Svm.svm_save_model(do_stream, self)
+      stream.to_s
+    rescue java.io.IOException
+      raise IOError.new "Error in serializing SVM model"
+    end
+    def to_s
+      serialize
+    end
+
+    # Load model from given filename.
+    # Raises IOError on any error.
+    def self.load filename
+      Svm.svm_load_model(filename)
+    rescue java.io.IOException
+      raise IOError.new "Error in loading SVM model from file"
+    end
+
+    # Load model from string.
+    def self.parse string
+      reader = BufferedReader.new(StringReader.new(string))
+      Svm.svm_load_model(reader)
+    rescue java.io.IOException
+      raise IOError.new "Error in loading SVM model from string"
+    end
+
+    def predict(example, &block)
+      if block.nil?
+        return Svm.svm_predict(self, example)
+      else
+        prediction, probabilities = predict_probability(example)
+        yield probabilities
+        return prediction
+      end
+    end
+
+    def predict_probability(example)
+      probabilities = Java::double[self.classes].new
+      return Svm.svm_predict_probability(self, example, probabilities), probabilities
+    end
+  end
+end

data/lib/jrb-libsvm/node.rb

@@ -0,0 +1,37 @@
+module Libsvm
+  class Node
+    class << self
+      def features(*vargs)
+        array_of_nodes = []
+        if vargs.size == 1
+          if vargs.first.class == Array
+            vargs.first.each_with_index do |value, index|
+              array_of_nodes << Node.new(index.to_i, value.to_f)
+            end
+          elsif vargs.first.class == Hash
+            vargs.first.each do |index, value|
+              array_of_nodes << Node.new(index.to_i, value.to_f)
+            end
+          else
+            raise(ArgumentError.new("Node features need to be a Hash, Array or Floats"))
+          end
+        else
+          vargs.each_with_index do |value, index|
+            array_of_nodes << Node.new(index.to_i, value.to_f)
+          end
+        end
+        array_of_nodes
+      end
+    end
+
+    def initialize(index=0, value=0.0)
+      super()
+      self.index = index
+      self.value = value
+    end
+
+    def ==(other)
+      index == other.index && value == other.value
+    end
+  end
+end

data/lib/jrb-libsvm/parameter.rb

@@ -0,0 +1,66 @@
+module Libsvm
+  class Parameter
+    alias :c :C
+    alias :c= :C=
+
+    def label_weights
+      Hash[self.weight_label.zip(self.weight)]
+    end
+    def label_weights=v
+      self.nr_weight = v.keys.size
+      self.weight_label = v.keys.to_java :int
+      self.weight =  v.values.to_java :double
+    end
+
+    # Constructor sets up values of attributes based on provided map.
+    # Valid keys with their default values:
+    # * :svm_type = Parameter::C_SVC, for the type of SVM
+    # * :kernel_type = Parameter::LINEAR, for the type of kernel
+    # * :cost = 1.0, for the cost or C parameter
+    # * :gamma = 0.0, for the gamma parameter in kernel
+    # * :degree = 1, for polynomial kernel
+    # * :coef0 = 0.0, for polynomial/sigmoid kernels
+    # * :eps = 0.001, for stopping criterion
+    # * :nr_weight = 0, for C_SVC
+    # * :nu = 0.5, used for NU_SVC, ONE_CLASS and NU_SVR. Nu must be in (0,1]
+    # * :p = 0.1, used for EPSILON_SVR
+    # * :shrinking = 1, use the shrinking heuristics
+    # * :probability = 0, use the probability estimates
+    def initialize args={}
+      super()
+      self.svm_type    = args.fetch(:svm_type, Parameter::C_SVC)
+      self.kernel_type = args.fetch(:kernel_type, Parameter::LINEAR)
+      self.C           = args.fetch(:cost, 1.0)
+      self.gamma       = args.fetch(:gamma, 0.0)
+      self.degree      = args.fetch(:degree, 1)
+      self.coef0       = args.fetch(:coef0, 0.0)
+      self.eps         = args.fetch(:eps, 0.001)
+      self.nr_weight   = args.fetch(:nr_weight, 0)
+      self.nu          = args.fetch(:nu, 0.5)
+      self.p           = args.fetch(:p, 0.1)
+      self.shrinking   = args.fetch(:shrinking, 1)
+      self.probability = args.fetch(:probability, 0)
+      self.cache_size = args.fetch(:cache_size, 1)
+
+      unless self.nu > 0.0 and self.nu <= 1.0
+        raise ArgumentError "Invalid value of nu #{self.nu}, should be in (0,1]"
+      end
+    end
+  end
+  SvmParameter = Parameter
+
+  module KernelType
+    LINEAR = Parameter::LINEAR
+    POLY = Parameter::POLY
+    RBF = Parameter::RBF
+    SIGMOID = Parameter::SIGMOID
+    PRECOMPUTED = Parameter::PRECOMPUTED
+  end
+  module SvmType
+    C_SVC = Parameter::C_SVC
+    NU_SVC = Parameter::NU_SVC
+    ONE_CLASS = Parameter::ONE_CLASS
+    EPSILON_SVR = Parameter::EPSILON_SVR
+    NU_SVR = Parameter::NU_SVR
+  end
+end

data/lib/jrb-libsvm/problem.rb

@@ -0,0 +1,35 @@
+module Libsvm
+  class Problem
+    def set_examples(labels, features)
+      unless features.size == labels.size
+        raise ArgumentError.new "Number of features must equal number of labels"
+      end
+      unless features.size > 0
+        raise ArgumentError.new "There must be at least one feature."
+      end
+      unless features.collect {|i| i.size}.min == features.collect {|i| i.size}.max
+        raise ArgumentError.new "All features must have the same size"
+      end
+
+      self.l = labels.size
+      # -- add in the training data
+      self.x = Node[features.size, features[0].size].new
+      features.each.with_index do |feature, i|
+        feature.each.with_index do |node, j|
+          self.x[i][j] = node
+        end
+      end
+
+      # -- add in the labels
+      self.y = Java::double[labels.size].new
+      labels.each.with_index do |label, i| 
+        self.y[i] = label
+      end
+
+      return labels.size
+    end
+    def examples
+      return self.y, self.x
+    end
+  end
+end

data/lib/jrb-libsvm/version.rb

@@ -0,0 +1,3 @@
+module JrbLibsvm
+  VERSION = "0.1.2"
+end

data/lib/jrb-libsvm.rb

@@ -0,0 +1,31 @@
+require_relative "jrb-libsvm/version"
+require "java"
+require_relative "java/libsvm"
+
+module Libsvm
+  java_import "libsvm.Parameter"
+  java_import "libsvm.Model"
+  java_import "libsvm.Problem"
+  java_import "libsvm.Node"
+  java_import "libsvm.Svm"
+
+  module CoreExtensions
+    module Collection
+      def to_example
+        Node.features(self)
+      end
+    end
+  end
+end
+
+require_relative 'jrb-libsvm/parameter'
+require_relative 'jrb-libsvm/model'
+require_relative 'jrb-libsvm/node'
+require_relative 'jrb-libsvm/problem'
+
+class Hash
+  include Libsvm::CoreExtensions::Collection
+end
+class Array
+  include Libsvm::CoreExtensions::Collection
+end

data/spec/model_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Model do
+  def create_example
+    Node.features(0.2, 0.3, 0.4, 0.5)
+  end
+
+  def create_problem
+    problem = Problem.new
+    features = [Node.features([0.2,0.3,0.4,0.4]),
+                Node.features([0.1,0.5,0.1,0.9]),
+                Node.features([0.2,0.2,0.6,0.5]),
+                Node.features([0.3,0.1,0.5,0.9])]
+    problem.set_examples([1,2,1,2], features)
+    problem
+  end
+
+  def create_parameter
+    parameter = Parameter.new
+    parameter.cache_size = 50 # mb
+    parameter.eps = 0.01
+    parameter.c = 10
+    parameter.probability = 1
+    parameter
+  end
+
+  context "The class interface" do
+    before(:each) do
+      @problem = create_problem
+      @parameter = create_parameter
+    end
+
+    it "results from training on a problem under a certain parameter set" do
+      model = Model.train(@problem,@parameter)
+      model.should_not be_nil
+    end
+  end
+
+  context "A saved model" do
+    before(:each) do
+      @filename = "tmp/svm_model.model"
+      model = Model.train(create_problem, create_parameter)
+      model.save(@filename)
+      @model_string = model.to_s
+    end
+
+    it "can be loaded from a file" do
+      model = Model.load(@filename)
+      model.should_not be_nil
+    end
+
+    it "can be loaded from a string" do
+      model = Model.parse @model_string
+      model.should_not be_nil
+    end
+
+    it "should do the same for load and load_from_string" do
+      model = Model.load @filename
+      model2 = Model.parse @model_string
+      model.serialize.should == model2.serialize
+    end
+
+    after(:each) do
+      File.delete(@filename) rescue nil
+    end
+  end
+
+  context "An Libsvm model" do
+    before(:each) do
+      @problem = create_problem
+      @parameter = create_parameter
+      @model = Model.train(@problem, @parameter)
+      @file_path = "tmp/svm_model.model"
+    end
+    after(:each) do
+      File.delete(@file_path) if File.exists?(@file_path)
+    end
+
+    it "can be saved to a file" do
+      @model.save(@file_path)
+      File.exist?(@file_path).should be_true
+    end
+
+    it "can be serialized to a string" do
+      @model.serialize.should_not be_empty
+    end
+
+    it "should generate the same text for serialize and save" do
+      @model.save(@file_path)
+      @model.serialize.should == IO.read(@file_path)
+    end
+
+    it "can be asked for it's svm_type" do
+      @model.svm_type.should == Parameter::C_SVC
+    end
+
+    it "can be asked for it's number of classes (aka. labels)" do
+      @model.classes.should == 2
+    end
+
+    it "can predict" do
+      prediction = @model.predict(create_example)
+      prediction.should_not be_nil
+    end
+    it "can predict probability" do
+      prediction, probabilities = @model.predict_probability(create_example)
+      prediction.should_not be_nil
+      probabilities.should have(@model.classes).items
+      probabilities.each { |e| e.should_not be_nil }
+    end
+    it "can predict with block" do
+      prediction = @model.predict(create_example) do |probabilities|
+        probabilities.should be_all { |p| p.kind_of? Float }
+        probabilities.count.should == @model.classes
+      end
+      prediction.should be_a Float
+    end
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Node do
+  context "construction" do
+    it "using the properties" do
+      n = Node.new
+      n.index = 11
+      n.value = 0.11
+      n.index.should == 11
+      n.value.should be_within(0.0001).of(0.11)
+    end
+
+    it "using the constructor parameters" do
+      n = Node.new(14, 0.14)
+      n.index.should == 14
+      n.value.should be_within(0.0001).of(0.14)
+    end
+  end
+
+  context "inner workings" do
+    let(:node) {Node.new}
+
+    it "can be created" do
+      node.should_not be_nil
+    end
+
+    it "does not segfault on setting properties" do
+      node.index = 99
+      node.index.should == 99
+      node.value = 3.141
+      node.value.should be_within(0.00001).of(3.141)
+    end
+
+    it "has inited properties" do
+      node.index.should == 0
+      node.value.should be_within(0.00001).of(0)
+    end
+
+    it "class can create nodes from an array" do
+      ary = Node.features([0.1, 0.2, 0.3, 0.4, 0.5])
+      ary.map {|n| n.class.should == Node}
+      ary.map {|n| n.value }.should == [0.1, 0.2, 0.3, 0.4, 0.5]
+    end
+
+    it "class can create nodes from variable parameters" do
+      ary = Node.features(0.1, 0.2, 0.3, 0.4, 0.5)
+      ary.map {|n| Node.should === n }
+      ary.map {|n| n.value }.should == [0.1, 0.2, 0.3, 0.4, 0.5]
+    end
+
+    it "class can create nodes from hash" do
+      ary = Node.features(3=>0.3, 5=>0.5, 6=>0.6, 10=>1.0)
+      ary.map {|n| n.class.should == Node}
+      ary.map {|n| n.value }.sort.should == [0.3, 0.5, 0.6, 1.0]
+      ary.map {|n| n.index }.sort.should == [3, 5, 6, 10]
+    end
+
+    it "implements a value-like equality, not identity-notion" do
+      Node.new(1, 0.1).should == Node.new(1, 0.1)
+    end
+  end
+end

data/spec/parameter_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+describe Parameter do
+  before do
+    @p = Libsvm::SvmParameter.new
+  end
+  it "can be created with a constructor" do
+    ->{Libsvm::SvmParameter.new(svm_type: Libsvm::SvmType::C_SVC, cost: 23, gamma: 65)}.should_not raise_error
+  end
+  it "int svm_type" do
+    SvmType::C_SVC.should == 0
+    @p.svm_type = SvmType::C_SVC
+    @p.svm_type.should == SvmType::C_SVC
+  end
+
+  it "int kernel_type" do
+    KernelType::RBF.should == 2
+    @p.kernel_type = KernelType::RBF
+    @p.kernel_type.should == KernelType::RBF
+  end
+
+  it "int degree" do
+    @p.degree = 99
+    @p.degree.should == 99
+  end
+
+  it "double gamma" do
+    @p.gamma = 0.33
+    @p.gamma.should == 0.33
+  end
+
+  it "double coef0" do
+    @p.coef0 = 0.99
+    @p.coef0.should == 0.99
+  end
+
+  it "double cache_size" do
+    @p.cache_size = 0.77
+    @p.cache_size.should == 0.77
+  end
+
+  it "double eps" do
+    @p.eps = 0.111
+    @p.eps.should == 0.111
+    @p.eps = 0.112
+    @p.eps.should == 0.112
+  end
+
+  it "double C" do
+    @p.c = 3.141
+    @p.c.should == 3.141
+  end
+
+  it "can set and read weights (weight, weight_label, nr_weight members from struct)" do
+    @p.label_weights = {1=> 1.2, 3=>0.2, 5=>0.888}
+    @p.label_weights.should == {1=> 1.2, 3=>0.2, 5=>0.888}
+  end
+
+
+  it "double nu" do
+    @p.nu = 1.1
+    @p.nu.should == 1.1
+  end
+
+  it "double p" do
+    @p.p = 0.123
+    @p.p.should == 0.123
+  end
+
+  it "int shrinking" do
+    @p.shrinking = 22
+    @p.shrinking.should == 22
+  end
+
+  it "int probability" do
+    @p.probability = 35
+    @p.probability.should == 35
+  end
+end

data/spec/problem_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Problem do
+  before(:each) do
+    @problem = Problem.new
+    @features = [ Node.features(0.2,0.3,0.4,0.4),
+                  Node.features(0.1,0.5,0.1,0.9),
+                  Node.features(0.2,0.2,0.6,0.5),
+                  Node.features(0.3,0.1,0.5,0.9) ]
+  end
+
+  it "examples get stored and retrieved" do
+    @problem.set_examples([1,2,1,2], @features)
+    labels, examples =  @problem.examples
+    labels.size.should == 4
+    examples.size.should == 4
+    examples.map {|x|x.size}.should == [4,4,4,4]
+    examples.first.map {|node| node.index}.should == [0,1,2,3]
+    examples.first.map {|node| node.value}.should == [0.2,0.3,0.4,0.4]
+  end
+
+  it "can be populated" do
+    examples = [Node.features(0.2,0.3,0.4,0.4),
+                Node.features(0.1,0.5,0.1,0.9),
+                Node.features(0.2,0.2,0.6,0.5),
+                Node.features(0.3,0.1,0.5,0.9)]
+    ->{@problem.set_examples([1,2,1,2], examples)}.should_not raise_error
+  end
+
+  it "can be set twice over" do
+    features = [Node.features(0.2, 0.3, 0.4, 0.4), Node.features(0.3,0.1,0.5,0.9)]
+    @problem.set_examples([1,2], features)
+    features = [Node.features(0.2, 0.3, 0.4, 0.4), Node.features(0.3,0.1,0.5,0.9)]
+    ->{@problem.set_examples([8,2], features)}.should_not raise_error
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler.setup
+Bundler.require(:default, :test)
+require 'jrb-libsvm'
+
+include Libsvm
+
+RSpec.configure do |config|
+end

data/spec/usage_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Basic usage" do
+  before do
+    @problem = Problem.new
+    @parameter = Parameter.new
+    @parameter.cache_size = 1 # mb
+
+    # "eps is the stopping criterion (we usually use 0.00001 in nu-SVC,
+    # 0.001 in others)." (from README)
+    @parameter.eps = 0.001
+
+    @parameter.c = 10
+  end
+
+  it "has a nice API" do
+    example = {11 => 0.11, 21 => 0.21, 101 => 0.99 }.to_example
+    example.should == Node.features({11 => 0.11, 21 => 0.21, 101 => 0.99 })
+  end
+
+  it "is as in [PCI,217]" do
+    examples = [ [1,0,1], [-1,0,-1] ].map {|ary| Node.features(ary) }
+    labels = [1, -1]
+    @problem.set_examples(labels, examples)
+
+    model = Model.train(@problem, @parameter)
+
+    pred = model.predict(Node.features(1, 1, 1))
+    pred.should == 1.0
+
+    pred = model.predict(Node.features(-1, 1, -1))
+    pred.should == -1.0
+
+    pred = model.predict(Node.features(-1, 55, -1))
+    pred.should == -1.0
+  end
+
+  it "kernel parameter use" do
+    @parameter.kernel_type = Parameter::RBF
+    examples = [[1, 2, 3], [-2, -2, -2]].map {|ary| Node.features(ary) }
+    @problem.set_examples([1, 2], examples)
+
+    model = Model.train(@problem, @parameter)
+
+    model.predict(Node.features(1, 2, 3)).should == 2
+  end
+end