svm_toolkit 1.1.7-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 573f621dd03d73aa37c8ac0f65ef5bedd70fe3831f538ab5977685578979688e
+  data.tar.gz: 1ddbc97a37507768149f19cb7097a1277287726f4436ab04a45c70227f977895
+SHA512:
+  metadata.gz: 9a5e17905c86237e6586df1df7d06ff2f5bfcdcabf38e03f4a53bb647030a32f4e16fc03616ca9f98dff6cebe16d2df25d687477003e544f06d8712b016a1c00
+  data.tar.gz: 8b9798b3d37eba4e24f080a807a2b44c5cba885e4b1aad97956d9fbd5eede6866dbc5b990467da327d2a5cd28a58392e7a5d36788958799a9063634e80a9f57c

data/LICENSE.rdoc

@@ -0,0 +1,59 @@
+= MIT License
+
+Copyright (c) 2011-20, Peter Lane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+= For libsvm:
+
+Copyright (c) 2000-2012 Chih-Chung Chang and Chih-Jen Lin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither name of copyright holders nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+= For PlotPackage:
+
+Library General Public License (http://www.gnu.org/copyleft/lgpl.html)

data/README.rdoc

@@ -0,0 +1,103 @@
+= SVM Toolkit 
+
+source:: https://notabug.org/peterlane/svm_toolkit/
+
+== 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, and simple
+visualisations.  Training/testing of models can use a variety of built-in or
+user-defined evaluation methods, including overall accuracy, geometric mean,
+precision and recall.
+
+== Features 
+
+- All features of LibSVM 3.11 are supported, and many are augmented with Ruby wrappers.
+- Loading Problem definitions from file in Svmlight, Csv or Arff (simple subset) format.
+- Creating Problem definitions from values supplied programmatically in arrays.
+- Rescaling of feature values.
+- Integrated cost/gamma search for model with RBF kernel, taking advantage of multiple cores.
+- Contour plot visualisation of cost/gamma search results.
+- Model provides value of w-squared for hyperplane.
+- svm-demo application, a version of the svm_toy applet which comes with libsvm.
+- Model stores indices of training instances used as support vectors.
+- User-selected evaluation techniques supported in Model#evaluate_dataset and
+  Svm.cross_validation_search.
+- Library provides evaluation classes for Cohen's Kappa statistics, F-measure,
+  geometric-mean, Matthews Correlation Coefficient, overall-accuracy,
+  precision, and recall.
+
+== Example
+
+The following example illustrates how a dataset can be constructed in code, and 
+an SVM model created and tested against the different kernels. 
+
+   require "svm_toolkit"
+   include SvmToolkit
+   
+   puts "Classification with LIBSVM"
+   puts "--------------------------"
+    
+   # Sample dataset: the 'Play Tennis' dataset 
+   # from T. Mitchell, Machine Learning (1997)
+   # --------------------------------------------
+   # Labels for each instance in the training set
+   #    1 = Play, 0 = Not
+   Labels = [0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0]
+   
+   # Recoding the attribute values into range [0, 1]
+   Instances = [
+     [0.0,1.0,1.0,0.0],
+     [0.0,1.0,1.0,1.0],
+     [0.5,1.0,1.0,0.0],
+     [1.0,0.5,1.0,0.0],
+     [1.0,0.0,0.0,0.0],
+     [1.0,0.0,0.0,1.0],
+     [0.5,0.0,0.0,1.0],
+     [0.0,0.5,1.0,0.0],
+     [0.0,0.0,0.0,0.0],
+     [1.0,0.5,0.0,0.0],
+     [0.0,0.5,0.0,1.0],
+     [0.5,0.5,1.0,1.0],
+     [0.5,1.0,0.0,0.0],
+     [1.0,0.5,1.0,1.0]
+   ]
+   
+   # create some arbitrary train/test split
+   TrainingSet = Problem.from_array(Instances.slice(0, 10), Labels.slice(0, 10))
+   TestSet     = Problem.from_array(Instances.slice(10, 4), Labels.slice(10, 4))
+   
+   # Iterate over each kernel type
+   Parameter.kernels.each do |kernel|
+    
+     # -- train model for this kernel type
+     params = Parameter.new(
+       :svm_type => Parameter::C_SVC, 
+       :kernel_type => kernel,
+       :cost => 10, 
+       :degree => 1,
+       :gamma => 100
+     )
+     model = Svm.svm_train(TrainingSet, params)
+   
+     # -- test kernel performance on the training set
+     errors = model.evaluate_dataset(TrainingSet, :print_results => true)
+     puts "Kernel #{Parameter.kernel_name(kernel)} has #{errors} on the training set"
+   
+     # -- test kernel performance on the test set
+     errors = model.evaluate_dataset(TestSet, :print_results => true)
+     puts "Kernel #{Parameter.kernel_name(kernel)} has #{errors} on the test set"
+   end
+
+More examples can be found in the source code, linked above.
+
+== Acknowledgements
+
+The svm_toolkit is based on LibSVM, which is available from: 
+http://www.csie.ntu.edu.tw/~cjlin/libsvm/
+
+The contour plot uses the PlotPackage library, available from:
+http://thehuwaldtfamily.org/java/Packages/Plot/PlotPackage.html
+

data/bin/svm-demo

@@ -0,0 +1,354 @@
+#!/usr/bin/env jruby
+
+#
+# A loose equivalent of the svm_toy applet which is 
+# distributed with libsvm.
+#
+
+require "java"
+require "svm-toolkit"
+include SvmToolkit
+
+["BorderLayout", "Color", 
+ "Dimension", "GridLayout", 
+ "event.ActionListener", "event.MouseListener"
+].each do |i|
+  import "java.awt.#{i}"
+end
+
+["Box", "BoxLayout", "JButton", "JComboBox", "JFrame", "JLabel",
+ "JOptionPane", "JPanel", "JScrollPane", "JSpinner", "JTextField",
+ "SpinnerNumberModel", "WindowConstants", "border.TitledBorder"
+].each do |i|
+  import "javax.swing.#{i}"
+end
+
+class Display < JPanel
+  Point = Struct.new(:x, :y, :colour)
+
+  class MyMouseListener
+    include MouseListener
+    
+    def initialize parent
+      @parent = parent
+    end
+
+    def mouseEntered e; end
+    def mouseExited e; end
+    def mousePressed e; end
+    def mouseReleased e; end
+
+    def mouseClicked e
+      @parent.clicked(e.x, e.y)
+    end
+  end
+
+  attr_accessor :colour # current label/colour of point to show
+
+  Width = 800
+  Height = 600
+
+  def initialize
+    super()
+    
+    self.preferred_size = Dimension.new(Width, Height)
+    add_mouse_listener MyMouseListener.new(self)
+
+    @points = []
+    @support_vectors = []
+    @colour = Color.blue
+  end
+
+  def paint g
+    super
+    
+    if @buffer.nil?
+      g.background = Color.lightGray
+      g.clear_rect(0, 0, Width, Height)
+    else
+      g.draw_image(@buffer, 0, 0, self)
+    end
+
+    @support_vectors.each do |point|
+      g.color = Color.yellow
+      g.fill_oval(point.x-7, point.y-7, 14, 14)
+    end
+
+    @points.each do |point|
+      g.color =  point.colour
+      g.fill_oval(point.x-3, point.y-3, 6, 6)
+    end
+  end
+
+  def clear
+    @points.clear
+    @support_vectors.clear
+    @buffer = nil
+    repaint
+  end
+
+  def clicked(x, y)
+    if x < Width and y < Height
+      @points << Point.new(x, y, @colour)
+      repaint
+    end
+  end
+
+  def background_colour prediction
+    if prediction.zero?
+      Color.new(100, 200, 100)
+    else
+      Color.new(100, 100, 200)
+    end
+  end
+
+  def train(kernel, cost, gamma, degree)
+    return if @points.empty?
+    labels = []
+    instances = []
+    @points.each do |point|
+      if point.colour == Color::blue
+        labels << 1
+      else 
+        labels << 0 
+      end
+      instances << [point.x / Width.to_f, point.y / Height.to_f]
+    end
+    problem = Problem.from_array(instances, labels)
+    param = Parameter.new(
+      :svm_type => Parameter::C_SVC,
+      :kernel_type => kernel,
+      :cost => cost,
+      :gamma => gamma,
+      :degree => degree
+    )
+    model = Svm.svm_train(problem, param)
+
+    buffer = self.create_image(Width, Height)
+    buffer_gc = buffer.graphics
+    window_gc = self.graphics
+    instance = Node[2].new
+    instance[0] = Node.new(0, 0)
+    instance[1] = Node.new(1, 0)
+    Width.times do |i|
+      if i < 498 # draw a progress line
+        buffer_gc.color = Color::red
+        buffer_gc.draw_line(i+1, 0, i+1, Height-1)
+        window_gc.color = Color::red
+        window_gc.draw_line(i+1, 0, i+1, Height-1)
+      end
+      Height.times do |j|
+        instance[0].value = i / Width.to_f
+        instance[1].value = j / Height.to_f
+        prediction = Svm.svm_predict(model, instance)
+        buffer_gc.color = background_colour prediction
+        buffer_gc.draw_line(i, j, i, j)
+        window_gc.color = background_colour prediction
+        window_gc.draw_line(i, j, i, j)
+      end
+    end
+    @buffer = buffer
+    @support_vectors = []
+    model.support_vector_indices.each do |index|
+      @support_vectors << @points[index]
+    end
+
+    repaint
+  end
+end
+
+class DemoFrame < JFrame
+  class LabelListener
+    include ActionListener
+
+    def initialize(display, box)
+      @display = display
+      @box = box
+    end
+
+    def actionPerformed e
+      @display.colour = if @box.selected_item == "blue" then 
+                          Color.blue
+                        else
+                          Color.green
+                        end
+    end
+  end
+
+  class KernelChoiceListener
+    include ActionListener
+
+    def initialize(kernel_choice, gamma_choice, degree_choice)
+      @kernel_choice = kernel_choice
+      @gamma_choice = gamma_choice
+      @degree_choice = degree_choice
+    end
+
+    def actionPerformed e
+      case @kernel_choice.selected_item
+      when "linear"
+        @gamma_choice.enabled = false
+        @degree_choice.enabled = false
+      when "polynomial"
+        @gamma_choice.enabled = false
+        @degree_choice.enabled = true
+      when "RBF", "sigmoid"
+        @gamma_choice.enabled = true
+        @degree_choice.enabled = false
+      end
+    end
+  end
+
+  def initialize
+    super("Support-Vector Machines: Demonstration")
+    self.setSize(700, 400)
+
+    @display_panel = Display.new
+    add(JScrollPane.new(@display_panel))
+    add(createLabelButtons, BorderLayout::NORTH)
+    add(createTrainButtons, BorderLayout::EAST)
+    add(createHelpLine, BorderLayout::SOUTH)
+
+    self.setDefaultCloseOperation(WindowConstants::DISPOSE_ON_CLOSE)
+  end
+
+  def createHelpLine
+    JLabel.new(<<-END)
+<html><body>
+Select a class colour and click on main panel to define instances.<br>
+Choose kernel type and parameter settings for training.
+</body></html>
+END
+  end
+
+  def createLabelButtons
+    panel = JPanel.new
+    panel.layout = BorderLayout.new
+
+    combo_box = JComboBox.new 
+    ["blue", "green"].each do |item|
+      combo_box.add_item item
+    end
+    combo_box.add_action_listener LabelListener.new(@display_panel, combo_box)
+
+    clear_button = JButton.new "clear"
+    clear_button.add_action_listener do
+      @display_panel.clear
+    end
+
+    @message = JLabel.new
+    
+    pane = JPanel.new
+    pane.add JLabel.new("Class:")
+    pane.add combo_box
+    pane.add clear_button
+
+    panel.add(pane, BorderLayout::WEST)
+    panel.add @message
+
+    return panel
+  end
+
+  def createTrainButtons
+    kernel_choice = JComboBox.new
+    ["linear", "RBF", "polynomial", "sigmoid"].each do |item|
+      kernel_choice.add_item item
+    end
+    cost_choice = JTextField.new(10)
+    cost_choice.text = "1.0"
+    cost_choice.setMaximumSize(cost_choice.getPreferredSize)
+    gamma_choice = JTextField.new(10)
+    gamma_choice.text = "1.0"
+    gamma_choice.setMaximumSize(gamma_choice.getPreferredSize)
+    gamma_choice.enabled = false
+    degree_choice = JSpinner.new(SpinnerNumberModel.new(1, 0, 30, 1))
+    degree_choice.enabled = false
+    kernel_choice.add_action_listener KernelChoiceListener.new(kernel_choice, gamma_choice, degree_choice)
+
+    run_button = JButton.new "Train"
+    run_button.add_action_listener do
+      # -- kernel
+      case kernel_choice.selected_item
+      when "linear"
+        kernel = Parameter::LINEAR
+      when "RBF"
+        kernel = Parameter::RBF
+      when "polynomial"
+        kernel = Parameter::POLY
+      when "sigmoid"
+        kernel = Parameter::SIGMOID
+      end
+      # -- cost
+      begin
+        cost = Float cost_choice.text
+      rescue ArgumentError
+        JOptionPane.show_message_dialog(self, 
+                                        "Cost value #{cost_choice.text} is not a number", 
+                                        "Error in cost value",
+                                        JOptionPane::ERROR_MESSAGE)
+        return
+      end
+      # -- gamma
+      begin
+        gamma = Float gamma_choice.text
+      rescue ArgumentError
+        JOptionPane.show_message_dialog(self, 
+                                        "Gamma value #{gamma_choice.text} is not a number", 
+                                        "Error in gamma value",
+                                        JOptionPane::ERROR_MESSAGE)
+        return
+      end
+      # -- degree
+      degree = degree_choice.model.number
+      #
+      @message.text = "Training and updating display: Please wait"
+      swt = MySwingWorker.new
+      swt.task = lambda do 
+        run_button.enabled = false
+        @display_panel.train(kernel, cost, gamma, degree) 
+        @message.text = ""
+        run_button.enabled = true
+      end
+      swt.execute
+    end
+
+    panel = JPanel.new
+    panel.border = TitledBorder.new("Training options")
+    panel.layout = GridLayout.new(5, 2, 10, 10)
+
+    panel.add JLabel.new("Kernel type:", JLabel::RIGHT)
+    panel.add kernel_choice
+    panel.add JLabel.new("Cost:", JLabel::RIGHT)
+    panel.add cost_choice
+    panel.add JLabel.new("Gamma:", JLabel::RIGHT)
+    panel.add gamma_choice
+    panel.add JLabel.new("Degree:", JLabel::RIGHT)
+    panel.add degree_choice
+    panel.add JLabel.new ""
+    panel.add run_button
+
+    pane = JPanel.new
+    pane.add panel
+    return pane
+  end
+
+  class MySwingWorker < javax.swing.SwingWorker
+    attr_accessor :task
+    def doInBackground
+      @task.call
+    end
+  end
+end
+
+javax.swing::UIManager.getInstalledLookAndFeels.each do |info|
+  begin
+    if "Nimbus" == info.name
+      javax.swing::UIManager.setLookAndFeel(info.className)
+    end
+  rescue Exception
+    # ignore exceptions
+  end
+end
+
+DemoFrame.new.visible = true
+

data/lib/svm_toolkit/evaluators.rb

@@ -0,0 +1,169 @@
+module SvmToolkit
+
+  # The Evaluator classes provides some classes and methods to construct 
+  # classes for evaluating the performance of a model against a dataset.  
+  # Different evaluators measure different kinds of performance.  
+  #
+  # Evaluator classes are accessed by name, with an optional positive label name.
+  # For example:
+  #
+  #   Evaluator::OverallAccuracy # => class evaluates overall accuracy
+  #   Evaluator::ClassPrecision(label) # => class evaluates precision for class "label"
+  # 
+  # Evaluators are wrapped around confusion matrices, outputting the required 
+  # statistical measure, and support the following methods:
+  #
+  # add_result(actual, prediction):: called to add information about each instance
+  #                                  when testing a model.
+  # value:: retrieves the appropriate measure of performance, based on the class name.
+  # to_s:: returns a string naming the evaluator and giving its value.
+  #
+  class Evaluator
+
+    # Defines an Evaluator returning the value of precision for given class
+    # label.
+    #
+    def Evaluator.ClassPrecision label
+      Class.new(Evaluator) do 
+        @@label = label
+
+        # Returns the precision.
+        #
+        def value
+          @cm.precision(@@label)
+        end
+
+        def to_s # :nodoc:
+          "Precision for label #{@@label}: #{value}"
+        end
+      end
+    end
+
+    # Defines an Evaluator returning the value of recall for given class
+    # label.
+    #
+    def Evaluator.ClassRecall label
+      Class.new(Evaluator) do 
+        @@label = label
+
+        def value # :nodoc:
+          @cm.recall(@@label)
+        end
+
+        def to_s # :nodoc:
+          "Recall for label #{@@label}: #{value}"
+        end
+      end
+    end
+
+    # Defines an Evaluator returning the value of the F-measure for given class
+    # label.
+    #
+    def Evaluator.FMeasure label
+      Class.new(Evaluator) do 
+        @@label = label
+
+        def value # :nodoc:
+          @cm.f_measure(@@label)
+        end
+
+        def to_s # :nodoc:
+          "F-measure for label #{@@label}: #{value}"
+        end
+      end
+    end
+
+    # Defines an Evaluator returning the value of Cohen's Kappa statistics for
+    # given class label.
+    #
+    def Evaluator.Kappa label
+      Class.new(Evaluator) do 
+        @@label = label
+
+        def value # :nodoc:
+          @cm.kappa(@@label)
+        end
+
+        def to_s # :nodoc:
+          "Kappa for label #{@@label}: #{value}"
+        end
+      end
+    end
+
+    # Defines an Evaluator returning the value of the Matthews Correlation
+    # Coefficient for given class label.
+    #
+    def Evaluator.MatthewsCorrelationCoefficient label
+      Class.new(Evaluator) do 
+        @@label = label
+
+        def value # :nodoc:
+          @cm.matthews_correlation(@@label)
+        end
+
+        def to_s # :nodoc:
+          "Matthews correlation coefficient: #{value}"
+        end
+      end
+    end
+
+    # Creates a new Evaluator, with a confusion matrix to store results.
+    #
+    def initialize
+      @cm = ConfusionMatrix.new
+    end
+
+    # Adds result to the underlying confusion matrix.
+    #
+    def add_result(actual, prediction)
+      @cm.add_for(actual, prediction)
+    end
+
+    # This object is better than given object, if the given object is an 
+    # instance of nil, or the value of this object is better.
+    #
+    def better_than? other
+      other.nil? or self.value > other.value
+    end
+
+    # Prints the confusion matrix.
+    #
+    def display
+      puts @cm
+    end
+  end
+
+  # Defines an Evaluator returning the value of overall accuracy.
+  #
+  class OverallAccuracy < Evaluator
+    # Returns the overall accuracy, as a percentage.
+    #
+    def value
+      100 * @cm.overall_accuracy
+    end
+
+    # Returns a string naming this evaluator and giving its value.
+    #
+    def to_s
+      "Overall accuracy: #{value}%"
+    end
+  end
+
+  # Defines an Evaluator returning the value of geometric mean.
+  #
+  class GeometricMean < Evaluator
+    # Returns the geometric mean.
+    #
+    def value
+      @cm.geometric_mean
+    end
+
+    # Returns a string naming this evaluator and giving its value.
+    #
+    def to_s
+      "Geometric mean: #{value}"
+    end
+  end
+
+end
+