svm_toolkit 1.1.7-java → 1.1.8-java

data/lib/svm_toolkit/svm.rb

@@ -1,224 +1,219 @@
-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
+module SvmToolkit
+
+  # Extends the Java SVM class.
+  class Svm
+
+    # Using given Problem and Parameter instances, builds and trains 
+    # an SVM model.
+    def self.train(problem, parameters)
+      Svm.svm_train(problem, parameters)
+    end
+ 
+    # Using given Problem and Parameter instances, builds and trains 
+    # SVM models using n-fold cross-validation.
+    def self.cross_validation(problem, parameters, n_folds, target)
+      Svm.svm_cross_validation(problem, parameters, n_folds, target)
+    end
+
+    # 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

@@ -1,37 +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'
-
+
+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

@@ -1,29 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: svm_toolkit
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.1.8
 platform: java
 authors:
 - Peter Lane
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: confusion_matrix
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  name: confusion_matrix
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
 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\
@@ -34,8 +47,8 @@ executables:
 - svm-demo
 extensions: []
 extra_rdoc_files:
-- README.rdoc
 - LICENSE.rdoc
+- README.rdoc
 files:
 - LICENSE.rdoc
 - README.rdoc
@@ -49,12 +62,14 @@ files:
 - lib/svm_toolkit/parameter.rb
 - lib/svm_toolkit/problem.rb
 - lib/svm_toolkit/svm.rb
-homepage:
+homepage: https://rubygems.org/gems/svm_toolkit
 licenses:
 - MIT
-metadata: {}
+metadata:
+  documentation_uri: https://rubydoc.info/gems/svm_toolkit
+  source_code_uri: https://codeberg.org/peterlane/svm_toolkit
 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\
+  \ not, add \n/home/peter/.rbenv/versions/jruby-10.0.2.0/lib/ruby/gems/shared/gems/svm_toolkit-1.1.8-java/bin\n\
   \ to your path."
 rdoc_options:
 - "-m"
@@ -65,15 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.25
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A JRuby wrapper around the libsvm library, with additional functionality.
 test_files: []