ai4ruby 1.11

data/test/classifiers/ib1_test.rb

@@ -0,0 +1,78 @@
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require File.dirname(__FILE__) + '/../../lib/ai4r/classifiers/ib1'
+require 'test/unit'
+
+class Ai4r::Classifiers::IB1
+  attr_accessor :data_set, :min_values, :max_values
+end
+
+include Ai4r::Classifiers
+include Ai4r::Data
+
+class IB1Test < Test::Unit::TestCase
+
+  @@data_labels = [ 'city', 'age', 'gender', 'marketing_target'  ]
+
+  @@data_items = [['New York',  25, 'M', 'Y'],
+              ['New York',  23, 'M', 'Y'],
+              ['New York',  18, 'M', 'Y'],
+              ['Chicago',   43, 'M', 'Y'],
+              ['New York',  34, 'F', 'N'],
+              ['Chicago',   33, 'F', 'Y'],
+              ['New York',  31, 'F', 'N'],
+              ['Chicago',   55, 'M', 'N'],
+              ['New York',  58, 'F', 'N'],
+              ['New York',  59, 'M', 'N'],
+              ['Chicago',   71, 'M', 'N'],
+              ['New York',  60, 'F', 'N'],
+              ['Chicago',   85, 'F', 'Y']
+            ]
+  
+  
+  def setup
+    IB1.send(:public, *IB1.protected_instance_methods)
+    @data_set = DataSet.new(:data_items => @@data_items, :data_labels => @@data_labels)
+    @classifier = IB1.new.build(@data_set)
+  end
+  
+  def test_build
+    assert_raise(ArgumentError) { IB1.new.build(DataSet.new) }
+    assert @classifier.data_set
+    assert_equal [nil, 18, nil, nil], @classifier.min_values
+    assert_equal [nil, 85, nil, nil], @classifier.max_values
+  end
+
+  def test_norm
+    assert_equal(0,@classifier.norm('Chicago', 0))
+    assert_in_delta(0.5522,@classifier.norm(55, 1),0.0001)
+    assert_equal(0,@classifier.norm('F', 0))
+  end
+
+  def test_distance
+    item = ['Chicago',   55, 'M', 'N']
+    assert_equal(0, @classifier.distance(['Chicago',  55, 'M'], item))
+    assert_equal(1, @classifier.distance([nil,  55, 'M'], item))
+    assert_equal(1, @classifier.distance(['New York',  55, 'M'], item))
+    assert_in_delta(0.2728, @classifier.distance(['Chicago',  20, 'M'], item), 0.0001)
+  end
+
+  def test_eval
+    classifier = IB1.new.build(@data_set)
+    assert classifier
+    assert_equal('N', classifier.eval(['Chicago',  55, 'M']))
+    assert_equal('N', classifier.eval(['New York', 35, 'F']))
+    assert_equal('Y', classifier.eval(['New York', 25, 'M']))
+    assert_equal('Y', classifier.eval(['Chicago',  85, 'F'])) 
+  end
+
+end
+
+  

data/test/classifiers/id3_test.rb

@@ -0,0 +1,208 @@
+# id3_test.rb
+# 
+# This is a unit test file for the ID3 algorithm (Quinlan) implemented
+# in ai4r  
+# 
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require File.dirname(__FILE__) + '/../../lib/ai4r/classifiers/id3'
+require 'test/unit'
+
+DATA_LABELS = [ 'city', 'age_range', 'gender', 'marketing_target'  ]
+
+DATA_ITEMS = [  ['New York',  '<30',      'M', 'Y'],
+              ['Chicago',     '<30',      'M', 'Y'],
+              ['Chicago',     '<30',      'F', 'Y'],
+              ['New York',  '<30',      'M', 'Y'],
+              ['New York',  '<30',      'M', 'Y'],
+              ['Chicago',     '[30-50)',  'M', 'Y'],
+              ['New York',  '[30-50)',  'F', 'N'],
+              ['Chicago',     '[30-50)',  'F', 'Y'],
+              ['New York',  '[30-50)',  'F', 'N'],
+              ['Chicago',     '[50-80]', 'M', 'N'],
+              ['New York',  '[50-80]', 'F', 'N'],
+              ['New York',  '[50-80]', 'M', 'N'],
+              ['Chicago',     '[50-80]', 'M', 'N'],
+              ['New York',  '[50-80]', 'F', 'N'],
+              ['Chicago',     '>80',      'F', 'Y']
+            ]
+
+SPLIT_DATA_ITEMS_BY_CITY = [  [
+                              ["New York", "<30", "M", "Y"], 
+                              ["New York", "<30", "M", "Y"], 
+                              ["New York", "<30", "M", "Y"], 
+                              ["New York", "[30-50)", "F", "N"], 
+                              ["New York", "[30-50)", "F", "N"], 
+                              ["New York", "[50-80]", "F", "N"], 
+                              ["New York", "[50-80]", "M", "N"], 
+                              ["New York", "[50-80]", "F", "N"]], 
+                            [
+                              ["Chicago", "<30", "M", "Y"], 
+                              ["Chicago", "<30", "F", "Y"], 
+                              ["Chicago", "[30-50)", "M", "Y"], 
+                              ["Chicago", "[30-50)", "F", "Y"], 
+                              ["Chicago", "[50-80]", "M", "N"], 
+                              ["Chicago", "[50-80]", "M", "N"], 
+                              ["Chicago", ">80", "F", "Y"]]
+                          ]
+                          
+SPLIT_DATA_ITEMS_BY_AGE = [   [
+                              ["New York", "<30", "M", "Y"], 
+                              ["Chicago", "<30", "M", "Y"], 
+                              ["Chicago", "<30", "F", "Y"], 
+                              ["New York", "<30", "M", "Y"], 
+                              ["New York", "<30", "M", "Y"]], 
+                            [
+                              ["Chicago", "[30-50)", "M", "Y"], 
+                              ["New York", "[30-50)", "F", "N"], 
+                              ["Chicago", "[30-50)", "F", "Y"], 
+                              ["New York", "[30-50)", "F", "N"]], 
+                            [
+                              ["Chicago", "[50-80]", "M", "N"], 
+                              ["New York", "[50-80]", "F", "N"], 
+                              ["New York", "[50-80]", "M", "N"], 
+                              ["Chicago", "[50-80]", "M", "N"], 
+                              ["New York", "[50-80]", "F", "N"]], 
+                            [
+                              ["Chicago", ">80", "F", "Y"]]
+                         ]
+
+  EXPECTED_RULES_STRING =  
+    "if age_range=='<30' then marketing_target='Y'\n"+
+    "elsif age_range=='[30-50)' and city=='Chicago' then marketing_target='Y'\n"+
+    "elsif age_range=='[30-50)' and city=='New York' then marketing_target='N'\n"+
+    "elsif age_range=='[50-80]' then marketing_target='N'\n"+
+    "elsif age_range=='>80' then marketing_target='Y'\n"+
+    "else raise 'There was not enough information during training to do a proper induction for this data element' end"
+    
+include Ai4r::Classifiers
+include Ai4r::Data
+
+class ID3Test < Test::Unit::TestCase
+
+  def test_build
+    Ai4r::Classifiers::ID3.send(:public, *Ai4r::Classifiers::ID3.protected_instance_methods)
+    Ai4r::Classifiers::ID3.send(:public, *Ai4r::Classifiers::ID3.private_instance_methods)
+  end
+
+  def test_log2
+    assert_equal 1.0, ID3.log2(2)
+    assert_equal 0.0, ID3.log2(0)
+    assert 1.585 - ID3.log2(3) < 0.001
+  end
+
+  def test_sum
+    assert_equal 28, ID3.sum([5, 0, 22, 1])
+    assert_equal 0, ID3.sum([])
+  end
+
+  def test_data_labels
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS))
+    expected_default = [ 'attribute_1', 'attribute_2', 'attribute_3', 'class_value' ]
+    assert_equal(expected_default, id3.data_set.data_labels)
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    assert_equal(DATA_LABELS, id3.data_set.data_labels)
+  end
+
+  def test_domain
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    expected_domain = [["New York", "Chicago"], ["<30", "[30-50)", "[50-80]", ">80"], ["M", "F"], ["Y", "N"]]
+    assert_equal expected_domain, id3.domain(DATA_ITEMS)
+  end
+
+  def test_grid
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    expected_grid = [[3, 5], [5, 2]]
+    domain = id3.domain(DATA_ITEMS)
+    assert_equal expected_grid, id3.freq_grid(0, DATA_ITEMS, domain)
+    expected_grid = [[5, 0], [2, 2], [0, 5], [1, 0]]
+    assert_equal expected_grid, id3.freq_grid(1, DATA_ITEMS, domain)
+  end
+
+  def test_entropy
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    expected_entropy = 0.9118
+    domain = id3.domain(DATA_ITEMS)
+    freq_grid = id3.freq_grid(0, DATA_ITEMS, domain)
+    assert expected_entropy - id3.entropy(freq_grid, DATA_ITEMS.length) < 0.0001
+    expected_entropy = 0.2667
+    freq_grid = id3.freq_grid(1, DATA_ITEMS, domain)
+    assert expected_entropy - id3.entropy(freq_grid, DATA_ITEMS.length) < 0.0001
+    expected_entropy = 0.9688
+    freq_grid = id3.freq_grid(2, DATA_ITEMS, domain)
+    assert expected_entropy - id3.entropy(freq_grid, DATA_ITEMS.length) < 0.0001
+  end
+
+  def test_min_entropy_index
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    domain = id3.domain(DATA_ITEMS)
+    assert_equal 1, id3.min_entropy_index(DATA_ITEMS, domain)
+    assert_equal 0, id3.min_entropy_index(DATA_ITEMS, domain, [1])
+    assert_equal 2, id3.min_entropy_index(DATA_ITEMS, domain, [1, 0])
+  end
+
+  def test_split_data_examples
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    domain = id3.domain(DATA_ITEMS)
+    res = id3.split_data_examples(DATA_ITEMS, domain, 0)
+    assert_equal(SPLIT_DATA_ITEMS_BY_CITY, res)
+    res = id3.split_data_examples(DATA_ITEMS, domain, 1)
+    assert_equal(SPLIT_DATA_ITEMS_BY_AGE, res)
+  end
+
+  def test_most_freq
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    domain = id3.domain(DATA_ITEMS)
+    assert_equal 'Y', id3.most_freq(DATA_ITEMS, domain)
+    assert_equal 'Y', id3.most_freq(SPLIT_DATA_ITEMS_BY_AGE[3], domain)
+    assert_equal 'N', id3.most_freq(SPLIT_DATA_ITEMS_BY_AGE[2], domain)
+  end
+
+  def test_get_rules
+    assert_equal [["marketing_target='N'"]], CategoryNode.new('marketing_target', 'N').get_rules
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    assert_equal EXPECTED_RULES_STRING, id3.get_rules
+  end
+
+  def test_eval
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    #if age_range='<30' then marketing_target='Y'
+    assert_equal 'Y', id3.eval(['New York', '<30', 'F'])
+    assert_equal 'Y', id3.eval(['Chicago', '<30', 'M'])
+    #if age_range='[30-50)' and city='Chicago' then marketing_target='Y'
+    assert_equal 'Y', id3.eval(['Chicago', '[30-50)', 'F'])
+    assert_equal 'Y', id3.eval(['Chicago', '[30-50)', 'M'])
+    #if age_range='[30-50)' and city='New York' then marketing_target='N'
+    assert_equal 'N', id3.eval(['New York', '[30-50)', 'F'])
+    assert_equal 'N', id3.eval(['New York', '[30-50)', 'M'])      
+    #if age_range='[50-80]' then marketing_target='N'
+    assert_equal 'N', id3.eval(['New York', '[50-80]', 'F'])
+    assert_equal 'N', id3.eval(['Chicago', '[50-80]', 'M'])      
+    #if age_range='>80' then marketing_target='Y'
+    assert_equal 'Y', id3.eval(['New York', '>80', 'M'])      
+    assert_equal 'Y', id3.eval(['Chicago', '>80', 'F'])      
+  end
+
+  def test_rules_eval
+    id3 = ID3.new.build(DataSet.new(:data_items =>DATA_ITEMS, :data_labels => DATA_LABELS))
+    #if age_range='<30' then marketing_target='Y'
+    age_range = '<30'
+    marketing_target = nil
+    eval id3.get_rules
+    assert_equal 'Y', marketing_target
+    #if age_range='[30-50)' and city='New York' then marketing_target='N'
+    age_range='[30-50)' 
+    city='New York'
+    eval id3.get_rules
+    assert_equal 'N', marketing_target
+  end
+end
+
+  

data/test/classifiers/multilayer_perceptron_test.rb

@@ -0,0 +1,79 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/classifiers/multilayer_perceptron'
+require File.dirname(__FILE__) + '/../../lib/ai4r/data/data_set'
+
+# Make all accessors and methods public
+class Ai4r::Classifiers::MultilayerPerceptron
+  attr_accessor :data_set, :class_value, :network, :domains, :outputs
+  public :get_max_index
+  public :data_to_output
+end
+
+class MultilayerPerceptronTest < Test::Unit::TestCase
+  
+  include Ai4r::Classifiers
+  include Ai4r::Data
+  
+  @@data_set = DataSet.new(:data_items =>[   ['New York',  '<30',      'M', 'Y'],
+                ['Chicago',     '<30',      'M', 'Y'],
+                ['New York',  '<30',      'M', 'Y'],
+                ['New York',  '[30-50)',  'F', 'N'],
+                ['Chicago',     '[30-50)',  'F', 'Y'],
+                ['New York',  '[30-50)',  'F', 'N'],
+                ['Chicago',     '[50-80]', 'M', 'N'],
+              ])
+
+   def test_initialize
+    classifier = MultilayerPerceptron.new
+    assert_equal 1, classifier.active_node_value
+    assert_equal 0, classifier.inactive_node_value
+    assert_equal Ai4r::NeuralNetwork::Backpropagation, classifier.network_class
+    assert_equal [], classifier.hidden_layers
+    assert classifier.network_parameters
+    assert classifier.network_parameters.empty?
+    assert classifier.training_iterations > 1
+  end
+  
+  def test_build
+    assert_raise(ArgumentError) { MultilayerPerceptron.new.build(DataSet.new) }
+    classifier = MultilayerPerceptron.new
+    classifier.training_iterations = 1
+    classifier.build(@@data_set)
+    assert_equal [7,2], classifier.network.structure
+    classifier.hidden_layers = [6, 4]
+    classifier.build(@@data_set)  
+    assert_equal [7,6,4,2], classifier.network.structure    
+  end
+  
+  def test_eval
+    classifier = MultilayerPerceptron.new.build(@@data_set)
+    assert classifier
+    assert_equal('N', classifier.eval(['Chicago', '[50-80]', 'M']))
+    assert_equal('N', classifier.eval(['New York', '[30-50)', 'F']))
+    assert_equal('Y', classifier.eval(['New York', '<30', 'M']))
+    assert_equal('Y', classifier.eval(['Chicago',  '[30-50)', 'F']))    
+  end
+  
+  def test_get_rules
+    assert_match(/raise/, MultilayerPerceptron.new.get_rules)
+  end
+  
+  def test_get_max_index
+    classifier = MultilayerPerceptron.new
+    assert_equal(0, classifier.get_max_index([3, 1, 0.2, -9, 0, 2.99]))
+    assert_equal(2, classifier.get_max_index([3, 1, 5, -9, 0, 2.99]))
+    assert_equal(5, classifier.get_max_index([3, 1, 5, -9, 0, 6]))
+  end
+  
+  def test_data_to_output
+    classifier = MultilayerPerceptron.new
+    classifier.outputs = 4
+    classifier.outputs = 4
+    classifier.domains = [nil, nil, nil, ["A", "B", "C", "D"]]
+    assert_equal([1,0,0,0], classifier.data_to_output("A"))
+    assert_equal([0,0,1,0], classifier.data_to_output("C"))
+    assert_equal([0,0,0,1], classifier.data_to_output("D"))
+  end
+  
+end
+

data/test/classifiers/naive_bayes_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../lib/ai4r/classifiers/naive_bayes'
+require File.dirname(__FILE__) + '/../../lib/ai4r/data/data_set'
+require 'test/unit'
+
+include Ai4r::Classifiers
+include Ai4r::Data
+
+class NaiveBayesTest < Test::Unit::TestCase
+
+  @@data_labels = [ "Color","Type","Origin","Stolen?" ]
+
+  @@data_items = [
+              ["Red",   "Sports", "Domestic", "Yes"],
+              ["Red",   "Sports", "Domestic", "No"],
+              ["Red",   "Sports", "Domestic", "Yes"],
+              ["Yellow","Sports", "Domestic", "No"],
+              ["Yellow","Sports", "Imported", "Yes"],
+              ["Yellow","SUV",    "Imported", "No"],
+              ["Yellow","SUV",    "Imported", "Yes"],
+              ["Yellow","Sports", "Domestic", "No"],
+              ["Red",   "SUV",    "Imported", "No"],
+              ["Red",   "Sports", "Imported", "Yes"]
+            ]
+
+  def setup
+    @data_set = DataSet.new
+    @data_set = DataSet.new(:data_items => @@data_items, :data_labels => @@data_labels)
+    @b = NaiveBayes.new.set_parameters({:m=>3}).build @data_set
+  end
+
+  def test_eval
+    result = @b.eval(["Red", "SUV", "Domestic"])
+    assert_equal "No", result
+  end
+
+  def test_get_probability_map
+    map = @b.get_probability_map(["Red", "SUV", "Domestic"])
+    assert_equal 2, map.keys.length
+    assert_in_delta 0.42, map["Yes"], 0.1
+    assert_in_delta 0.58, map["No"], 0.1
+  end
+
+end

data/test/classifiers/one_r_test.rb

@@ -0,0 +1,62 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/classifiers/one_r'
+
+class OneRTest < Test::Unit::TestCase
+  
+  include Ai4r::Classifiers
+  include Ai4r::Data
+  
+  @@data_examples = [   ['New York',  '<30',      'M', 'Y'],
+                ['Chicago',     '<30',      'M', 'Y'],
+                ['New York',  '<30',      'M', 'Y'],
+                ['New York',  '[30-50)',  'F', 'N'],
+                ['Chicago',     '[30-50)',  'F', 'Y'],
+                ['New York',  '[30-50)',  'F', 'N'],
+                ['Chicago',     '[50-80]', 'M', 'N']
+              ]
+
+  @@data_labels = [ 'city', 'age_range', 'gender', 'marketing_target'  ]
+  
+  def test_build
+    assert_raise(ArgumentError) { OneR.new.build(DataSet.new) } 
+    classifier = OneR.new.build(DataSet.new(:data_items => @@data_examples))
+    assert_not_nil(classifier.data_set.data_labels)
+    assert_not_nil(classifier.rule)
+    assert_equal("attribute_1", classifier.data_set.data_labels.first)
+    assert_equal("class_value", classifier.data_set.data_labels.last)
+    classifier = OneR.new.build(DataSet.new(:data_items => @@data_examples,
+      :data_labels => @@data_labels))
+    assert_not_nil(classifier.data_set.data_labels)
+    assert_not_nil(classifier.rule)
+    assert_equal("city", classifier.data_set.data_labels.first)
+    assert_equal("marketing_target", classifier.data_set.data_labels.last)
+    assert_equal(1, classifier.rule[:attr_index])
+  end
+  
+  def test_eval
+    classifier = OneR.new.build(DataSet.new(:data_items => @@data_examples))
+    assert_equal("Y", classifier.eval(['New York',  '<30',      'M']))
+    assert_equal("N", classifier.eval(['New York',  '[30-50)',      'M']))
+    assert_equal("N", classifier.eval(['Chicago',  '[50-80]',      'M']))
+  end
+  
+  def test_get_rules
+    classifier = OneR.new.build(DataSet.new(:data_items => @@data_examples,
+      :data_labels => @@data_labels))
+    marketing_target = nil
+    age_range = nil
+    eval(classifier.get_rules) 
+    assert_nil(marketing_target)
+    age_range = '<30'
+    eval(classifier.get_rules) 
+    assert_equal("Y", marketing_target)
+    age_range = '[30-50)'
+    eval(classifier.get_rules) 
+    assert_equal("N", marketing_target)
+    age_range = '[50-80]'
+    eval(classifier.get_rules) 
+    assert_equal("N", marketing_target)    
+  end
+  
+end
+