svm_toolkit 1.1.7-java

data/lib/svm_toolkit/svm.rb

@@ -0,0 +1,224 @@
+module SvmToolkit
+
+  # Extends the Java SVM class
+  #
+  # Available methods include:
+  # 
+  # Svm.svm_train(problem, param)
+  # 
+  # problem:: instance of Problem
+  # param:: instance of Parameter
+  #
+  # Returns an instance of Model
+  #
+  # Svm.svm_cross_validation(problem, param, nr_folds, target)
+  #
+  # problem:: instance of Problem
+  # param:: instance of Parameter
+  # nr_fold:: number of folds
+  # target:: resulting predictions in an array
+  #
+  class Svm
+
+    # Perform cross validation search on given gamma/cost values, 
+    # using an RBF kernel, 
+    # returning the best performing model and optionally displaying 
+    # a contour map of performance.
+    #
+    # training_set::   instance of Problem, used for training
+    # cross_valn_set:: instance of Problem, used for evaluating models
+    # costs::          array of cost values to search across
+    # gammas::         array of gamma values to search across
+    # params::         Optional parameters include:
+    # * :evaluator => Evaluator::OverallAccuracy, the name of the class 
+    #   to use for computing performance
+    # * :show_plot => false, whether to display contour plot
+    #
+    # Returns an instance of Model, the best performing model.
+    #
+    def Svm.cross_validation_search(training_set, cross_valn_set, 
+                                     costs = [-2,-1,0,1,2,3].collect {|i| 2**i}, 
+                                     gammas = [-2,-1,0,1,2,3].collect {|i| 2**i}, 
+                                     params = {})
+      evaluator = params.fetch :evaluator, Evaluator::OverallAccuracy
+      show_plot = params.fetch :show_plot, false
+
+      fjp = ForkJoinPool.new
+      task = CrossValidationSearch.new gammas, costs, training_set, cross_valn_set, evaluator
+      results, best_model = fjp.invoke task
+
+      if show_plot
+        ContourDisplay.new(costs.collect {|n| Math.log2(n)}, 
+                           gammas.collect {|n| Math.log2(n)}, 
+                           results)
+      end
+
+      return best_model
+    end
+
+    private
+    # Set up the cross validation search across a cost/gamma pair
+    class CrossValidationSearch < RecursiveTask
+      # Creates an instance of the CrossValidationSearch.
+      #
+      # gammas:: array of gamma values to search over
+      # costs:: array of cost values to search over
+      # training_set:: for building the model
+      # cross_valn_set:: for testing the model
+      # evaluator:: name of Evaluator class, used for evaluating the model
+      #
+      def initialize gammas, costs, training_set, cross_valn_set, evaluator
+        super() 
+
+        @gammas = gammas
+        @costs = costs
+        @training_set = training_set
+        @cross_valn_set = cross_valn_set  
+        @evaluator = evaluator
+      end
+
+      # perform actual computation, return results/best_model
+      def compute
+        tasks = []
+        # create one task per gamma/cost pair
+        @gammas.each do |gamma|
+          @costs.each do |cost|
+            tasks << SvmTrainer.new(@training_set, Parameter.new(
+              :svm_type => Parameter::C_SVC,
+              :kernel_type => Parameter::RBF,
+              :cost => cost,
+              :gamma => gamma
+            ), @cross_valn_set, @evaluator)
+          end
+        end
+
+        # set off all the tasks
+        tasks.each do |task|
+          task.fork
+        end
+
+        # collect the results
+        results = []
+        best_model = nil
+        lowest_error = nil
+
+        @gammas.each do |gamma|
+          results_row = []
+          @costs.each do |cost|
+            task = tasks.shift
+            model, result = task.join
+
+            if result.better_than? lowest_error
+              best_model = model
+              lowest_error = result
+            end
+            puts "Result for cost = #{cost}  gamma = #{gamma} is #{result.value}"
+            results_row << result.value
+          end
+          results << results_row
+        end
+
+        return results, best_model
+      end
+    end
+
+    # Represent a single training task for an SVM RBF model
+    class SvmTrainer < RecursiveTask
+
+      # Creates an instance of an SvmTrainer.
+      #
+      # training_set:: used to train the model
+      # parameters:: parameters for building the model
+      # cross_valn_set:: used to test the model performance
+      # evaluator:: class name of Evaluator to use for evaluating the model performance
+      #
+      def initialize training_set, parameters, cross_valn_set, evaluator
+        super()
+
+        @training_set = training_set
+        @parameters = parameters
+        @cross_valn_set = cross_valn_set
+        @evaluator = evaluator
+      end
+
+      # Trains and evaluates a model, using the parameters.
+      #
+      # Returns the model and evaluation.
+      #
+      def compute
+        model = Svm.svm_train @training_set, @parameters
+        result = model.evaluate_dataset @cross_valn_set, :evaluator => @evaluator
+        return model, result
+      end
+    end
+
+    # Swing Frame displaying the cross-validation performance.
+    #
+    class ContourDisplay < javax.swing.JFrame
+      # Creates an instance of the ContourDisplay.
+      #
+      # xs:: array of x-coordinates
+      # ys:: array of y-coordinates
+      # zs:: array of values for matching (x, y) coordinate
+      #
+      def initialize(xs, ys, zs)
+        super("Cross-Validation Performance")
+        self.setSize(500, 400)
+
+        cxs = Java::double[][ys.size].new
+        cys = Java::double[][ys.size].new
+        ys.size.times do |i|
+          cxs[i] = Java::double[xs.size].new
+          cys[i] = Java::double[xs.size].new
+          xs.size.times do |j|
+            cxs[i][j] = xs[j]
+            cys[i][j] = ys[i]
+          end
+        end
+
+        czs = Java::double[][ys.size].new
+        ys.size.times do |i|
+          czs[i] = Java::double[xs.size].new
+          xs.size.times do |j|
+            czs[i][j] = zs[i][j]
+          end
+        end
+
+        plot = ContourPlot.new(
+          cxs,
+          cys,
+          czs,
+          10,
+          false,
+          "",
+          "Cost (log-scale)",
+          "Gamma (log-scale)",
+          nil,
+          nil
+        )
+        plot.colorizeContours(java.awt::Color.green, java.awt::Color.red)
+
+        symbol = DiamondSymbol.new
+        symbol.border_color = java.awt::Color.blue
+        symbol.fill_color = java.awt::Color.blue
+        symbol.size = 4
+
+        run = PlotRun.new
+        ys.size.times do |i|
+          xs.size.times do |j|
+            run.add(PlotDatum.new(cxs[i][j], cys[i][j], false, symbol))
+          end
+        end
+
+        plot.runs << run
+
+        panel = PlotPanel.new(plot)
+        panel.background = java.awt::Color.white
+        add panel
+
+        self.setDefaultCloseOperation(javax.swing.WindowConstants::DISPOSE_ON_CLOSE)
+        self.visible = true
+      end
+    end
+  end
+end

data/lib/svm_toolkit.rb

@@ -0,0 +1,37 @@
+
+require 'confusion_matrix'
+require 'csv'
+
+require 'java'
+require 'libsvm'
+require 'PlotPackage'
+
+# Containing module for this library.
+#
+module SvmToolkit
+  # import the required java classes - must do this before loading the ruby classes
+  
+  java_import 'libsvm.Parameter'
+  java_import 'libsvm.Model'
+  java_import 'libsvm.Problem'
+  java_import 'libsvm.Node'
+  java_import 'libsvm.Svm'
+
+  java_import 'java.util.concurrent.ForkJoinPool'
+  java_import 'java.util.concurrent.RecursiveTask'
+
+  java_import 'jahuwaldt.plot.ContourPlot'
+  java_import 'jahuwaldt.plot.DiamondSymbol'
+  java_import 'jahuwaldt.plot.PlotDatum'
+  java_import 'jahuwaldt.plot.PlotPanel'
+  java_import 'jahuwaldt.plot.PlotRun'
+end
+
+# finally require the ruby code which extends the Java classes
+require 'svm_toolkit/evaluators'
+require 'svm_toolkit/model'
+require 'svm_toolkit/node'
+require 'svm_toolkit/parameter'
+require 'svm_toolkit/problem'
+require 'svm_toolkit/svm'
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: svm_toolkit
+version: !ruby/object:Gem::Version
+  version: 1.1.7
+platform: java
+authors:
+- Peter Lane
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  name: confusion_matrix
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: "Support-vector machines are a popular tool in data mining.  This package\
+  \ includes an amended version of the Java implementation of the libsvm library (version\
+  \ 3.11).  Additional methods and examples are provided to support standard training\
+  \ techniques, such as cross-validation, various alternative evaluation methods,\
+  \ such as overall accuracy, precision or recall, and simple visualisations. \n"
+email: peterlane@gmx.com
+executables:
+- svm-demo
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- LICENSE.rdoc
+files:
+- LICENSE.rdoc
+- README.rdoc
+- bin/svm-demo
+- lib/PlotPackage.jar
+- lib/libsvm.jar
+- lib/svm_toolkit.rb
+- lib/svm_toolkit/evaluators.rb
+- lib/svm_toolkit/model.rb
+- lib/svm_toolkit/node.rb
+- lib/svm_toolkit/parameter.rb
+- lib/svm_toolkit/problem.rb
+- lib/svm_toolkit/svm.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message: "'svm-demo' should now be available via your jruby path.  If\
+  \ not, add \nC:/jruby-9.4.0.0/lib/ruby/gems/shared/gems/svm_toolkit-1.1.7-java/bin\n\
+  \ to your path."
+rdoc_options:
+- "-m"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.25
+signing_key:
+specification_version: 4
+summary: A JRuby wrapper around the libsvm library, with additional functionality.
+test_files: []