weka 0.1.0-java

data/lib/weka/clusterers.rb

@@ -0,0 +1,16 @@
+Weka.require_all :clusterers
+
+require 'weka/class_builder'
+
+module Weka
+  module Clusterers
+    include ClassBuilder
+
+    build_classes :Canopy,
+                  :Cobweb,
+                  :EM,
+                  :FarthestFirst,
+                  :HierarchicalClusterer,
+                  :SimpleKMeans
+  end
+end

data/lib/weka/clusterers/cluster_evaluation.rb

@@ -0,0 +1,14 @@
+module Weka
+  module Clusterers
+    java_import 'weka.clusterers.ClusterEvaluation'
+
+    class ClusterEvaluation
+
+      alias :summary        :cluster_results_to_string
+      alias :clusters_count :num_clusters
+    end
+
+    Java::WekaClusterers::ClusterEvaluation.__persistent__ = true
+
+  end
+end

data/lib/weka/clusterers/utils.rb

@@ -0,0 +1,103 @@
+require 'active_support/concern'
+require 'weka/clusterers/cluster_evaluation'
+require 'weka/core/instances'
+
+module Weka
+  module Clusterers
+    module Utils
+      extend ActiveSupport::Concern
+
+      included do
+        java_import 'java.util.Random'
+
+        if instance_methods.include?(:build_clusterer)
+          attr_reader :training_instances
+
+          def train_with_instances(instances)
+            @training_instances = instances
+            build_clusterer(instances)
+
+            self
+          end
+
+          if ancestors.include?(Java::WekaClusterers::DensityBasedClusterer)
+            def cross_validate(folds: 3)
+              ensure_trained_with_instances!
+
+              ClusterEvaluation.cross_validate_model(
+                self,
+                training_instances,
+                folds.to_i,
+                Java::JavaUtil::Random.new(1)
+              )
+            end
+          end
+
+          def evaluate(test_instances)
+            ensure_trained_with_instances!
+
+            ClusterEvaluation.new.tap do |evaluation|
+              evaluation.clusterer = self
+              evaluation.evaluate_clusterer(test_instances)
+            end
+          end
+        end
+
+        if instance_methods.include?(:cluster_instance)
+          def cluster(instance_or_values)
+            ensure_trained_with_instances!
+
+            instance = clusterable_instance_from(instance_or_values)
+            cluster_instance(instance)
+          end
+        end
+
+        if instance_methods.include?(:update_clusterer)
+          def add_training_instance(instance)
+            training_instances.add(instance)
+            update_clusterer(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 = clusterable_instance_from(instance_or_values)
+            distribution_for_instance(instance).to_a
+          end
+        end
+
+        private
+
+        def ensure_trained_with_instances!
+          return unless training_instances.nil?
+
+          error   = 'Clusterer is not trained with Instances.'
+          hint    = 'You can set the training instances with #train_with_instances.'
+          message = "#{error} #{hint}"
+
+          raise UnassignedTrainingInstancesError, message
+        end
+
+        def clusterable_instance_from(instance_or_values)
+          attributes = training_instances.attributes
+          instances  = Weka::Core::Instances.new(attributes: attributes)
+
+          instances.add_instance(instance_or_values)
+          instances.first
+        end
+      end
+
+    end
+  end
+end
+

data/lib/weka/concerns.rb

@@ -0,0 +1,18 @@
+require 'active_support/concern'
+require 'weka/concerns/buildable'
+require 'weka/concerns/describable'
+require 'weka/concerns/optionizable'
+require 'weka/concerns/persistent'
+
+module Weka
+  module Concerns
+    extend ActiveSupport::Concern
+
+    included do
+      include Buildable
+      include Describable
+      include Optionizable
+      include Persistent
+    end
+  end
+end

data/lib/weka/concerns/buildable.rb

@@ -0,0 +1,19 @@
+require 'active_support/concern'
+
+module Weka
+  module Concerns
+    module Buildable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def build(&block)
+          instance = new
+          instance.instance_eval(&block) if block_given?
+          instance
+        end
+      end
+
+    end
+  end
+end

data/lib/weka/concerns/describable.rb

@@ -0,0 +1,30 @@
+require 'active_support/concern'
+
+module Weka
+  module Concerns
+    module Describable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def description
+          new.global_info
+        end
+
+        def options
+          descriptions = new.list_options.map do |option|
+            description_for_option(option)
+          end
+
+          descriptions.join("\n")
+        end
+
+        private
+
+        def description_for_option(option)
+          "#{option.synopsis}\t#{option.description.strip}"
+        end
+      end
+    end
+  end
+end

data/lib/weka/concerns/optionizable.rb

@@ -0,0 +1,49 @@
+require 'active_support/concern'
+
+module Weka
+  module Concerns
+    module Optionizable
+      extend ActiveSupport::Concern
+
+      included do
+        java_import "weka.core.Utils"
+
+        def use_options(*single_options, **hash_options)
+          joined_options = join_options(single_options, hash_options)
+          options        = Java::WekaCore::Utils.split_options(joined_options)
+
+          set_options(options)
+          @options = joined_options
+        end
+
+        def options
+          @options || self.class.default_options
+        end
+
+        private
+
+        def join_options(*single_options, **hash_options)
+          [
+            join_single_options(*single_options),
+            join_hash_options(**hash_options)
+          ].reject(&:empty?).join(' ')
+        end
+
+        def join_single_options(options)
+          options.map { |option| "-#{option.to_s.sub(/^-/, '')}" }.join(' ')
+        end
+
+        def join_hash_options(options)
+          options.map { |key, value| "-#{key} #{value}" }.join(' ')
+        end
+      end
+
+      module ClassMethods
+        def default_options
+          new.get_options.to_a.join(' ')
+        end
+      end
+
+    end
+  end
+end

data/lib/weka/concerns/persistent.rb

@@ -0,0 +1,16 @@
+require 'active_support/concern'
+
+module Weka
+  module Concerns
+    module Persistent
+      extend ActiveSupport::Concern
+
+      included do
+        if self.respond_to?(:__persistent__=)
+          self.__persistent__ = true
+        end
+      end
+
+    end
+  end
+end

data/lib/weka/core.rb

@@ -0,0 +1,6 @@
+require 'weka/core/converters'
+require 'weka/core/loader'
+require 'weka/core/saver'
+require 'weka/core/attribute'
+require 'weka/core/dense_instance'
+require 'weka/core/instances'

data/lib/weka/core/attribute.rb

@@ -0,0 +1,24 @@
+module Weka
+  module Core
+    java_import "weka.core.Attribute"
+
+    class Attribute
+
+      def values
+        enumerate_values.to_a
+      end
+
+      # The order of the if statements is important here, because a date is also
+      # a numeric.
+      def internal_value_of(value)
+        if date?
+          parse_date(value.to_s)
+        elsif numeric?
+          value.to_f
+        elsif nominal?
+          index_of_value(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/weka/core/converters.rb

@@ -0,0 +1,17 @@
+require 'weka/class_builder'
+
+module Weka
+  module Core
+    module Converters
+      include ClassBuilder
+
+      build_classes :ArffLoader,
+                    :ArffSaver,
+                    :CSVLoader,
+                    :CSVSaver,
+                    :JSONLoader,
+                    :JSONSaver,
+                    include_concerns: false
+    end
+  end
+end

data/lib/weka/core/dense_instance.rb

@@ -0,0 +1,68 @@
+module Weka
+  module Core
+    java_import "weka.core.DenseInstance"
+
+    class DenseInstance
+      java_import "java.util.Date"
+      java_import "java.text.SimpleDateFormat"
+
+      def initialize(data, weight: 1.0)
+        super(weight, data.to_java(:double))
+      end
+
+      def attributes
+        enumerate_attributes.to_a
+      end
+
+      def each_attribute
+        if block_given?
+          enumerate_attributes.each { |attribute| yield(attribute) }
+        else
+          enumerate_attributes
+        end
+      end
+
+      def each_attribute_with_index
+        enumerate_attributes.each_with_index do |attribute, index|
+          yield(attribute, index) if block_given?
+        end
+      end
+
+      def to_a
+        to_double_array.each_with_index.map do |value, index|
+          attribute = attribute_at(index)
+
+          if attribute.date?
+            format_date(value, attribute.date_format)
+          elsif attribute.numeric?
+            value
+          elsif attribute.nominal?
+            attribute.value(value)
+          end
+        end
+      end
+
+      alias :values       :to_a
+      alias :values_count :num_values
+
+      private
+
+      def attribute_at(index)
+        return attributes[index] unless dataset.class_attribute_defined?
+
+        if dataset.class_index == index
+          class_attribute
+        elsif index > dataset.class_index
+          attributes[index - 1]
+        else
+          attributes[index]
+        end
+      end
+
+      def format_date(value, format)
+        formatter = SimpleDateFormat.new(format)
+        formatter.format(Date.new(value))
+      end
+    end
+  end
+end

data/lib/weka/core/instances.rb

@@ -0,0 +1,199 @@
+require 'weka/core/converters'
+require 'weka/core/loader'
+require 'weka/core/saver'
+require 'weka/core/dense_instance'
+
+module Weka
+  module Core
+    java_import "weka.core.Instances"
+    java_import "weka.core.FastVector"
+
+    class Instances
+
+      DEFAULT_RELATION_NAME = 'Instances'
+
+      class << self
+        def from_arff(file)
+          Loader.load_arff(file)
+        end
+
+        def from_csv(file)
+          Loader.load_csv(file)
+        end
+
+        def from_json(file)
+          Loader.load_json(file)
+        end
+      end
+
+      def initialize(relation_name: DEFAULT_RELATION_NAME, attributes: [], &block)
+        attribute_list = FastVector.new
+        attributes.each { |attribute| attribute_list.add_element(attribute) }
+
+        super(relation_name.to_s, attribute_list, 0)
+      end
+
+      def instances
+        enumerate_instances.to_a
+      end
+
+      def attributes
+        enumerate_attributes.to_a
+      end
+
+      def attribute_names
+        attributes.map(&:name)
+      end
+
+      def add_attributes(&block)
+        self.instance_eval(&block) if block
+        self
+      end
+
+      alias :with_attributes  :add_attributes
+      alias :instances_count  :num_instances
+      alias :attributes_count :num_attributes
+
+      def each
+        if block_given?
+          enumerate_instances.each { |instance| yield(instance) }
+        else
+          enumerate_instances
+        end
+      end
+
+      def each_with_index
+        enumerate_instances.each_with_index do |instance, index|
+          yield(instance, index) if block_given?
+        end
+      end
+
+      def each_attribute
+        if block_given?
+          enumerate_attributes.each { |attribute| yield(attribute) }
+        else
+          enumerate_attributes
+        end
+      end
+
+      def each_attribute_with_index
+        enumerate_attributes.each_with_index do |attribute, index|
+          yield(attribute, index) if block_given?
+        end
+      end
+
+      def to_arff(file)
+        Saver.save_arff(file: file, instances: self)
+      end
+
+      def to_csv(file)
+        Saver.save_csv(file: file, instances: self)
+      end
+
+      def to_json(file)
+        Saver.save_json(file: file, instances: self)
+      end
+
+      def numeric(name, class_attribute: false)
+        attribute = Attribute.new(name.to_s)
+        add_attribute(attribute)
+        self.class_attribute = name if class_attribute
+      end
+
+      def nominal(name, values:, class_attribute: false)
+        attribute = Attribute.new(name.to_s, Array(values).map(&:to_s))
+        add_attribute(attribute)
+        self.class_attribute = name if class_attribute
+      end
+
+      def string(name, class_attribute: false)
+        attribute = Attribute.new(name.to_s, [])
+        add_attribute(attribute)
+        self.class_attribute = name if class_attribute
+      end
+
+      def date(name, format: 'yyyy-MM-dd HH:mm', class_attribute: false)
+        attribute = Attribute.new(name.to_s, format)
+        add_attribute(attribute)
+        self.class_attribute = name if class_attribute
+      end
+
+      def class_attribute=(name)
+        if name.nil?
+          reset_class_attribute
+        else
+          ensure_attribute_defined!(name)
+          setClass(attribute_with_name(name))
+        end
+      end
+
+      alias :add_numeric_attribute :numeric
+      alias :add_string_attribute  :string
+      alias :add_nominal_attribute :nominal
+      alias :add_date_attribute    :date
+
+      def class_attribute
+        classAttribute if class_attribute_defined?
+      end
+
+      def reset_class_attribute
+        set_class_index(-1)
+      end
+
+      def class_attribute_defined?
+        class_index >= 0
+      end
+
+      def add_instance(instance_or_values, weight: 1.0)
+        instance = instance_from(instance_or_values, weight: weight)
+        add(instance)
+      end
+
+      def add_instances(data, weight: 1.0)
+        data.each { |values| add_instance(values, weight: weight) }
+      end
+
+      def internal_values_of(values)
+        values.each_with_index.map do |value, index|
+          attribute(index).internal_value_of(value)
+        end
+      end
+
+      def apply_filter(filter)
+        filter.filter(self)
+      end
+
+      private
+
+      def add_attribute(attribute)
+        insert_attribute_at(attribute, attributes.count)
+      end
+
+      def ensure_attribute_defined!(name)
+        return if attribute_names.include?(name.to_s)
+
+        error   = "\"#{name}\" is not defined."
+        hint    = "Only defined attributes can be used as class attribute!"
+        message = "#{error} #{hint}"
+
+        raise ArgumentError, message
+      end
+
+      def attribute_with_name(name)
+        attributes.select { |attribute| attribute.name == name.to_s }.first
+      end
+
+      def instance_from(instance_or_values, weight:)
+        if instance_or_values.kind_of?(Java::WekaCore::Instance)
+          instance_or_values.weight = weight
+          instance_or_values
+        else
+          data = internal_values_of(instance_or_values)
+          DenseInstance.new(data, weight: weight)
+        end
+      end
+    end
+
+    Java::WekaCore::Instances.__persistent__ = true
+  end
+end