weka 0.1.0-java

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :prepare
+task :install => :prepare
+
+desc 'Install weka jars & dependencies'
+task :prepare do
+  require 'lock_jar'
+  lib_path = File.expand_path('.', File.dirname(__FILE__))
+  jars_dir = File.join(lib_path, 'jars')
+
+  LockJar.install('Jarfile.lock', local_repo: jars_dir)
+end
+
+desc "Start an irb session with the gem loaded"
+task :irb do
+  sh 'irb -I ./lib -r weka'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "weka"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/weka.rb

@@ -0,0 +1,32 @@
+require 'java'
+require 'weka/jars'
+require 'weka/version'
+require 'weka/exceptions'
+
+module Weka
+  include Jars
+
+  class << self
+    def require_all(type)
+      files        = Dir[File.expand_path("../weka/#{type}/**/*.rb", __FILE__)]
+      utils        = File.expand_path("../weka/#{type}/utils.rb", __FILE__)
+      sorted_files = move_to_head(utils, files)
+
+      sorted_files.each { |file| require file }
+    end
+
+    private
+
+    def move_to_head(file, files)
+      file_to_move = files.delete(file)
+      files.unshift(file_to_move) unless file_to_move.nil?
+      files
+    end
+  end
+end
+
+require 'weka/core'
+require 'weka/classifiers'
+require 'weka/filters'
+require 'weka/clusterers'
+require 'weka/attribute_selection'

data/lib/weka/attribute_selection.rb

@@ -0,0 +1 @@
+Weka.require_all :attribute_selection

data/lib/weka/attribute_selection/attribute_selection.rb

@@ -0,0 +1,11 @@
+module Weka
+  module AttributeSelection
+    java_import 'weka.attributeSelection.AttributeSelection'
+
+    class AttributeSelection
+
+      alias :summary :to_results_string
+      alias :selected_attributes_count :number_attributes_selected
+    end
+  end
+end

data/lib/weka/attribute_selection/evaluator.rb

@@ -0,0 +1,29 @@
+require 'weka/class_builder'
+
+module Weka
+  module AttributeSelection
+    module Evaluator
+      include ClassBuilder
+
+      build_classes :CfsSubsetEval,
+                    :CorrelationAttributeEval,
+                    :GainRatioAttributeEval,
+                    :InfoGainAttributeEval,
+                    :OneRAttributeEval,
+                    :PrincipalComponents,
+                    :ReliefFAttributeEval,
+                    :SymmetricalUncertAttributeEval,
+                    :WrapperSubsetEval,
+                    weka_module: 'weka.attributeSelection'
+
+      class CfsSubset                  < CfsSubsetEval; end
+      class CorrelationAttribute       < CorrelationAttributeEval; end
+      class GainRatioAttribute         < GainRatioAttributeEval; end
+      class InfoGainAttribute          < InfoGainAttributeEval; end
+      class OneRAttribute              < OneRAttributeEval; end
+      class ReliefFAttribute           < ReliefFAttributeEval; end
+      class SymmetricalUncertAttribute < SymmetricalUncertAttributeEval; end
+      class WrapperSubset              < WrapperSubsetEval; end
+    end
+  end
+end

data/lib/weka/attribute_selection/search.rb

@@ -0,0 +1,14 @@
+require 'weka/class_builder'
+
+module Weka
+  module AttributeSelection
+    module Search
+      include ClassBuilder
+
+      build_classes :GreedyStepwise,
+                    :Ranker,
+                    :BestFirst,
+                    weka_module: 'weka.attributeSelection'
+    end
+  end
+end

data/lib/weka/class_builder.rb

@@ -0,0 +1,88 @@
+require 'active_support/concern'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/module'
+require 'weka/concerns'
+
+module Weka
+  module ClassBuilder
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def build_class(class_name, weka_module: nil, include_concerns: true)
+        java_import java_class_path(class_name, weka_module)
+        define_class(class_name, include_concerns: include_concerns)
+      end
+
+      def build_classes(*class_names, weka_module: nil, include_concerns: true)
+        class_names.each do |name|
+          build_class(name, weka_module: weka_module, include_concerns: include_concerns)
+        end
+      end
+
+      private
+
+      def java_class_path(class_name, weka_module)
+        if weka_module
+          "#{weka_module}.#{class_name}"
+        else
+          [*java_super_modules, java_including_module, class_name].compact.join('.')
+        end
+      end
+
+      def java_super_modules
+        super_modules.split('::').map do |name|
+          downcase_first_char(name)
+        end
+      end
+
+      def super_modules
+        toplevel_module? ? self.name : self.name.deconstantize
+      end
+
+      def java_including_module
+        downcase_first_char(including_module)
+      end
+
+      def including_module
+        self.name.demodulize unless toplevel_module?
+      end
+
+      def toplevel_module?
+        self.name.scan('::').count == 1
+      end
+
+      def define_class(class_name, include_concerns: true)
+        module_eval <<-CLASS_DEFINITION, __FILE__, __LINE__ + 1
+          class #{class_name}
+            #{'include Concerns' if include_concerns}
+            #{include_utils}
+          end
+        CLASS_DEFINITION
+      end
+
+      def include_utils
+        return unless utils_defined?
+        "include #{utils}"
+      end
+
+      def utils_defined?
+        utils_super_modules.constantize.const_defined?(:Utils)
+      end
+
+      def utils
+        "::#{utils_super_modules}::Utils"
+      end
+
+      def utils_super_modules
+        super_modules.split('::')[0..1].join('::')
+      end
+
+      def downcase_first_char(string)
+        return if string.blank?
+        string[0].downcase + string[1..-1]
+      end
+    end
+
+  end
+end

data/lib/weka/classifiers.rb

@@ -0,0 +1 @@
+Weka.require_all :classifiers

data/lib/weka/classifiers/bayes.rb

@@ -0,0 +1,16 @@
+require 'weka/class_builder'
+
+module Weka
+  module Classifiers
+    module Bayes
+      include ClassBuilder
+
+      build_classes :BayesNet,
+                    :NaiveBayes,
+                    :NaiveBayesMultinomial,
+                    :NaiveBayesMultinomialText,
+                    :NaiveBayesMultinomialUpdateable,
+                    :NaiveBayesUpdateable
+    end
+  end
+end

data/lib/weka/classifiers/evaluation.rb

@@ -0,0 +1,37 @@
+module Weka
+  module Classifiers
+    java_import 'weka.classifiers.Evaluation'
+
+    class Evaluation
+
+      # Use both nomenclatures f_measure and fmeasure for consistency
+      # due to jruby's auto method generation of 'fMeasure' to 'f_measure' and
+      # 'weightedFMeasure' to 'weighted_fmeasure'.
+      alias :weighted_f_measure       :weighted_fmeasure
+      alias :fmeasure                 :f_measure
+
+      alias :summary                  :to_summary_string
+      alias :class_details            :to_class_details_string
+
+      alias :instance_count           :num_instances
+      alias :correct_count            :correct
+      alias :incorrect_count          :incorrect
+      alias :unclassified_count       :unclassified
+
+      alias :correct_percentage       :pct_correct
+      alias :incorrect_percentage     :pct_incorrect
+      alias :unclassified_percentage  :pct_unclassified
+
+      alias :true_negative_count      :num_true_negatives
+      alias :false_negative_count     :num_false_negatives
+      alias :true_positive_count      :num_true_positives
+      alias :false_positive_count     :num_false_positives
+      alias :average_cost             :avg_cost
+
+      alias :cumulative_margin_distribution :to_cumulative_margin_distribution_string
+    end
+
+    Java::WekaClassifiers::Evaluation.__persistent__ = true
+
+  end
+end

data/lib/weka/classifiers/functions.rb

@@ -0,0 +1,21 @@
+require 'weka/class_builder'
+
+module Weka
+  module Classifiers
+    module Functions
+      include ClassBuilder
+
+      build_classes :GaussianProcesses,
+                    :LinearRegression,
+                    :Logistic,
+                    :MultilayerPerceptron,
+                    :SGD,
+                    :SGDText,
+                    :SimpleLinearRegression,
+                    :SimpleLogistic,
+                    :SMO,
+                    :SMOreg,
+                    :VotedPerceptron
+    end
+  end
+end

data/lib/weka/classifiers/lazy.rb

@@ -0,0 +1,13 @@
+require 'weka/class_builder'
+
+module Weka
+  module Classifiers
+    module Lazy
+      include ClassBuilder
+
+      build_classes :IBk,
+                    :KStar,
+                    :LWL
+    end
+  end
+end

data/lib/weka/classifiers/meta.rb

@@ -0,0 +1,29 @@
+require 'weka/class_builder'
+
+module Weka
+  module Classifiers
+    module Meta
+      include ClassBuilder
+
+      build_classes :AdaBoostM1,
+                    :AdditiveRegression,
+                    :AttributeSelectedClassifier,
+                    :Bagging,
+                    :ClassificationViaRegression,
+                    :CostSensitiveClassifier,
+                    :CVParameterSelection,
+                    :FilteredClassifier,
+                    :IterativeClassifierOptimizer,
+                    :LogitBoost,
+                    :MultiClassClassifier,
+                    :MultiClassClassifierUpdateable,
+                    :MultiScheme,
+                    :RandomCommittee,
+                    :RandomizableFilteredClassifier,
+                    :RandomSubSpace,
+                    :RegressionByDiscretization,
+                    :Stacking,
+                    :Vote
+    end
+  end
+end

data/lib/weka/classifiers/rules.rb

@@ -0,0 +1,16 @@
+require 'weka/class_builder'
+
+module Weka
+  module Classifiers
+    module Rules
+      include ClassBuilder
+
+      build_classes :DecisionTable,
+                    :JRip,
+                    :M5Rules,
+                    :OneR,
+                    :PART,
+                    :ZeroR
+    end
+  end
+end

data/lib/weka/classifiers/trees.rb

@@ -0,0 +1,18 @@
+require 'weka/class_builder'
+
+module Weka
+  module Classifiers
+    module Trees
+      include ClassBuilder
+
+      build_classes :DecisionStump,
+                    :HoeffdingTree,
+                    :J48,
+                    :LMT,
+                    :M5P,
+                    :RandomForest,
+                    :RandomTree,
+                    :REPTree
+    end
+  end
+end

data/lib/weka/classifiers/utils.rb

@@ -0,0 +1,138 @@
+require 'active_support/concern'
+require 'active_support/core_ext/hash'
+require 'weka/classifiers/evaluation'
+require 'weka/core/instances'
+
+module Weka
+  module Classifiers
+    module Utils
+      extend ActiveSupport::Concern
+
+      included do
+        java_import 'java.util.Random'
+
+        if instance_methods.include?(:build_classifier)
+          attr_reader :training_instances
+
+          def train_with_instances(instances)
+            ensure_class_attribute_assigned!(instances)
+
+            @training_instances = instances
+            build_classifier(instances)
+
+            self
+          end
+
+          def cross_validate(folds: 3)
+            ensure_trained_with_instances!
+
+            evaluation = Evaluation.new(training_instances)
+            random     = Java::JavaUtil::Random.new(1)
+
+            evaluation.cross_validate_model(self, training_instances, folds.to_i, random)
+            evaluation
+          end
+
+          def evaluate(test_instances)
+            ensure_trained_with_instances!
+            ensure_class_attribute_assigned!(test_instances)
+
+            evaluation = Evaluation.new(training_instances)
+            evaluation.evaluate_model(self, test_instances)
+            evaluation
+          end
+        end
+
+        if instance_methods.include?(:classify_instance)
+          def classify(instance_or_values)
+            ensure_trained_with_instances!
+
+            instance = classifiable_instance_from(instance_or_values)
+            index    = classify_instance(instance)
+
+            class_value_of_index(index)
+          end
+        end
+
+        if instance_methods.include?(:update_classifier)
+          def add_training_instance(instance)
+            training_instances.add(instance)
+            update_classifier(instance)
+
+            self
+          end
+
+          def add_training_data(data)
+            values   = self.training_instances.internal_values_of(data)
+            instance = Weka::Core::DenseInstance.new(values)
+            add_training_instance(instance)
+          end
+        end
+
+        if instance_methods.include?(:distribution_for_instance)
+          def distribution_for(instance_or_values)
+            ensure_trained_with_instances!
+
+            instance      = classifiable_instance_from(instance_or_values)
+            distributions = distribution_for_instance(instance)
+
+            class_distributions_from(distributions).with_indifferent_access
+          end
+        end
+
+        private
+
+        def ensure_class_attribute_assigned!(instances)
+          return if instances.class_attribute_defined?
+
+          error   = 'Class attribute is not assigned for Instances.'
+          hint    = 'You can assign a class attribute with #class_attribute=.'
+          message = "#{error} #{hint}"
+
+          raise UnassignedClassError, message
+        end
+
+        def ensure_trained_with_instances!
+          return unless training_instances.nil?
+
+          error   = 'Classifier is not trained with Instances.'
+          hint    = 'You can set the training instances with #train_with_instances.'
+          message = "#{error} #{hint}"
+
+          raise UnassignedTrainingInstancesError, message
+        end
+
+        def classifiable_instance_from(instance_or_values)
+          attributes = training_instances.attributes
+          instances  = Weka::Core::Instances.new(attributes: attributes)
+
+          class_attribute = training_instances.class_attribute
+          class_index     = training_instances.class_index
+          instances.insert_attribute_at(class_attribute, class_index)
+
+          instances.class_index = training_instances.class_index
+          instances.add_instance(instance_or_values)
+
+          instance = instances.first
+          instance.set_class_missing
+          instance
+        end
+
+        def class_value_of_index(index)
+          training_instances.class_attribute.value(index)
+        end
+
+        def class_distributions_from(distributions)
+          class_values = training_instances.class_attribute.values
+
+          distributions.each_with_index.reduce({}) do |result, (distribution, index)|
+            class_value = class_values[index].to_sym
+            result[class_value] = distribution
+            result
+          end
+        end
+      end
+
+    end
+  end
+end