dwarf 0.0.3

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in quarry.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    dwarf (0.0.3)
+      rubytree (>= 0.8.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    rubytree (0.8.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  dwarf!
+  rspec (>= 2.0.1)
+  rubytree (>= 0.8.1)

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec) do
+end
+

data/dwarf.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/dwarf/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "dwarf"
+  s.version     = Dwarf::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alex Redington"]
+  s.email       = ["aredington@gmail.com"]
+  s.homepage    = "http://github.com/aredington/dwarf"
+  s.summary     = "C4.5 for ActiveRecord objects"
+  s.description = "Dwarf is an implementation of the C4.5 algorithm targeted for use in the Rails 3 console environment for classifying ActiveRecord objects."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "dwarf"
+
+  s.add_dependency "rubytree", ">= 0.8.1"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", ">= 2.0.1"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/dwarf.rb

@@ -0,0 +1,4 @@
+module Dwarf
+  require 'dwarf/classifier'
+  require 'dwarf/tree_node'
+end

data/lib/dwarf/classifier.rb

@@ -0,0 +1,176 @@
+module Dwarf
+  class Classifier
+    attr_accessor :examples
+    attr_accessor :example_attributes
+    attr_accessor :classifier_logic
+
+    def initialize()
+      @examples, @example_attributes = {}, []
+      @decision_tree = TreeNode.new("ROOT")
+    end
+
+    def add_examples(example_hash)
+      example_hash.each do |example, classification|
+        add_example(example, classification)
+      end
+    end
+
+    def add_example(example_record, classification)
+      @examples[example_record]=classification
+      @example_attributes |= example_record.attributes
+    end
+
+    def classify(example)
+      return nil
+    end
+
+    def learn!
+      @decision_tree.examples = @examples.keys
+      pending = []
+      pending.push @decision_tree
+      used_attributes = []
+      until pending.empty?
+        node = pending.pop
+        if classification = homogenous_examples(node)
+          node.classification = classification
+        elsif no_valuable_attributes?(node) && node.parent
+          node.parent.classification= expected_value(node.examples)
+        elsif no_valuable_attributes?(node)
+          classifier_logic = expected_value(node.examples)
+        elsif false #stub branch
+          #C4.5 would also allow for previously unseen classifications
+          #dwarf's API dictates all classifications are known before learning
+          #starts
+        else
+          infogains = {}
+          (@example_attributes-used_attributes).each do |example_attribute|
+            infogains[information_gain(node.examples,example_attribute)] = example_attribute
+          end
+          best_gain = infogains.keys.sort[0]
+          best_attribute = infogains[best_gain]
+          split(node,best_attribute).each {|child_node| pending.push(child_node)}
+          used_attributes << best_attribute
+        end
+      end
+      self.classifier_logic = codify_tree(@decision_tree)
+      implement_classify
+    end
+
+    private
+
+    def implement_classify
+      classify_impl = "def classify(example)\n#{self.classifier_logic}\nend"
+      self.instance_eval classify_impl
+    end
+
+    def codify_tree(decision_tree)
+      lines = [""]
+      depth = 1
+      codify_node(decision_tree, lines, depth)
+      lines.join("\n")
+    end
+
+    def codify_node(decision_tree, lines, depth)
+      if decision_tree.attribute
+        lines << ("  "*depth)+"case example.#{decision_tree.attribute}"
+        decision_tree.children.each do |child|
+          lines << ("  "*depth)+"when #{codify_literal(child.name)}"
+          codify_node(child, lines, depth + 1)
+        end
+        lines << ("  "*depth)+"end"
+      elsif decision_tree.classification
+        lines << ("  "*depth)+"return #{codify_literal(decision_tree.classification)}"
+      end
+    end
+
+    def codify_literal(object)
+      case object
+        when Symbol then ":#{object}"
+        when String then "\"#{object}\""
+      else
+        object.to_s
+      end
+    end
+    
+    def split(node, attribute)
+      node.attribute = attribute
+      example_subset = node.examples
+      examples_inversion = invert_with_dups(attribute_map(example_subset,attribute))
+      examples_inversion.each do |key, value|
+        child_node = TreeNode.new(key)
+        child_node.examples = value
+        node << child_node
+      end
+      node.examples = nil
+      node.children
+    end
+
+    def expected_value(example_subset)
+      examples_inversion = invert_with_dups(classification_map(example_subset))
+      occurrences = examples_inversion.merge(examples_inversion) { |key, value| value.length }
+      occurrences.keys.sort { |key| occurrences[key] }[0]
+    end
+
+    def no_valuable_attributes?(node)
+      @example_attributes.map {|example_attribute|
+        information_gain(node.examples, example_attribute)}.each {|info_gain|
+        return false if info_gain != 0}
+      return true
+    end
+    
+
+    def homogenous_examples(node)
+      classifications = classifications(node.examples)
+      if classifications.length == 1
+        return classifications[0]
+      else
+        return nil
+      end
+    end
+
+    def entropy(example_subset)
+      set_size = example_subset.length.to_f
+      examples_inversion = invert_with_dups(classification_map(example_subset))
+      occurences = examples_inversion.merge(examples_inversion) { |key, value| value.length.to_f }
+      0.0 - classifications(example_subset).inject(0.0) do |sum, classification|
+        sum + ((occurences[classification]/set_size)* Math.log2((occurences[classification]/set_size)))
+      end
+    end
+
+    def information_gain(example_subset,attribute)
+      set_size = example_subset.length.to_f
+      examples_inversion = invert_with_dups(attribute_map(example_subset,attribute))
+      occurrences = examples_inversion.merge(examples_inversion) { |key, value| value.length }
+      entropy(example_subset) - attribute_values(example_subset,attribute).inject(0.0) do |sum, attribute_value|
+        sum + (occurrences[attribute_value]/set_size) * entropy(examples_inversion[attribute_value])
+      end
+    end
+
+    def classifications(example_subset)
+      example_subset.map {|example| @examples[example]}.compact
+    end
+
+    def classification_map(example_subset)
+      classification_map = {}
+      example_subset.each {|example| classification_map[example] = @examples[example]}
+      classification_map
+    end
+
+    def attribute_values(example_subset, attribute)
+      example_subset.map {|example| example.method(attribute.to_sym).call}.compact
+    end
+
+    def attribute_map(example_subset, attribute)
+      example_map = {}
+      example_subset.each {|example| example_map[example] = example.method(attribute.to_sym).call}
+      example_map
+    end
+
+    def invert_with_dups(hash)
+      inversion = {}
+      hash.values.each {|value| inversion[value] = []}
+      hash.keys.each {|key| inversion[hash[key]] << key}
+      inversion
+    end    
+  end
+end

data/lib/dwarf/tree_node.rb

@@ -0,0 +1,15 @@
+require 'tree'
+module Dwarf
+  class TreeNode < Tree::TreeNode
+    attr_accessor :examples
+    attr_accessor :classification
+    attr_accessor :attribute
+
+    def initialize(name, content = nil)
+      examples = []
+      classification = nil
+      attribute = nil
+      super(name, content)
+    end
+  end
+end

data/lib/dwarf/version.rb

@@ -0,0 +1,3 @@
+module Dwarf
+  VERSION = "0.0.3"
+end

data/spec/classifier_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), *%w[spec_helper])
+
+describe Dwarf::Classifier do  
+  
+  before(:each) do
+    @classifier = Dwarf::Classifier.new()
+  end
+  
+  it "accepts example classifications" do
+    @classifier.should respond_to(:add_example)
+  end
+
+  it "stores examples" do
+    @example3 = double('example3')
+    @example3.stub(:attributes) { [] }
+    @classifier.add_example(@example3, :irish)
+    @classifier.examples.should include(@example3)
+  end
+
+  it "only implements classify on the learning instance" do
+    @example = double('example3')
+    @example.stub(:attributes) { [] }
+    @class2 = Dwarf::Classifier.new()
+    @classifier.add_example(@example, :round)
+    @classifier.learn!
+    @classifier.classify(@example).should eq(:round)
+    @class2.classify(@example).should eq(nil)
+  end
+
+  context "classifying cars" do
+    def mock_car_examples
+      @example1 = double('example1')
+      @example1.stub(:body_style) { :boxy }
+      @example1.stub(:cylinders) { 4 }
+      @example1.stub(:attributes) { ["body_style", "cylinders"] }
+      @example2 = double('example2')
+      @example2.stub(:body_style) { :swoopy }
+      @example2.stub(:cylinders) { 6 }
+      @example2.stub(:attributes) { ["body_style", "cylinders"] }
+      @example3 = double('example3')
+      @example3.stub(:body_style) { :angry }
+      @example3.stub(:cylinders) { 8 }
+      @example3.stub(:attributes) { ["body_style", "cylinders"] }
+      @example4 = double('example4')
+      @example4.stub(:body_style) {:swoopy}
+      @example4.stub(:cylinders) {8}
+      @example4.stub(:attributes) { ["body_style", "cylinders"] }
+    end
+   
+    it "enumerate example attributes" do
+      mock_car_examples
+      @classifier.add_example(@example1, :japanese)
+      @classifier.example_attributes.should include("body_style", "cylinders")
+    end
+
+    it "classifies in a trivial case" do
+      mock_car_examples
+      @classifier.add_example(@example1, :japanese)
+      @classifier.add_example(@example2, :german)
+      @classifier.add_example(@example3, :american)
+      @classifier.learn!
+      @classifier.classify(@example1).should eq(:japanese)
+      @classifier.classify(@example2).should eq(:german)
+      @classifier.classify(@example3).should eq(:american)
+    end
+
+    it "classifies when multiple predicates required" do
+      mock_car_examples
+      @classifier.add_examples(@example1 => :japanese, @example2 => :german, @example3 => :american, @example4 => :german)
+      @classifier.learn!
+      @classifier.classify(@example1).should eq(:japanese)
+      @classifier.classify(@example2).should eq(:german)
+      @classifier.classify(@example3).should eq(:american)
+      @classifier.classify(@example4).should eq(:german)
+    end
+    
+  end
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), *%w[.. lib dwarf])

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: dwarf
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Alex Redington
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-22 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubytree
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 1
+        version: 0.8.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id003
+description: Dwarf is an implementation of the C4.5 algorithm targeted for use in the Rails 3 console environment for classifying ActiveRecord objects.
+email: 
+- aredington@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- dwarf.gemspec
+- lib/dwarf.rb
+- lib/dwarf/classifier.rb
+- lib/dwarf/tree_node.rb
+- lib/dwarf/version.rb
+- spec/classifier_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/aredington/dwarf
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: dwarf
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: C4.5 for ActiveRecord objects
+test_files: []
+