ai4r 1.13 → 2.0

data/lib/ai4r/classifiers/one_r.rb

@@ -1,110 +1,178 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens (Implementation only)
 # License::   MPL 1.1
 # Project::   ai4r
-# Url::       http://www.ai4r.org/
+# Url::       https://github.com/SergioFierens/ai4r
 #
-# You can redistribute it and/or modify it under the terms of 
-# the Mozilla Public License version 1.1  as published by the 
+# 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 'set'
-require File.dirname(__FILE__) + '/../data/data_set'
-require File.dirname(__FILE__) + '/../classifiers/classifier'
+require_relative '../data/data_set'
+require_relative '../classifiers/classifier'
 
 module Ai4r
   module Classifiers
-
     # = Introduction
-    # 
+    #
     # The idea of the OneR algorithm is identify the single
-    # attribute to use to classify data that makes 
+    # attribute to use to classify data that makes
     # fewest prediction errors.
     # It generates rules based on a single attribute.
+    # Numeric attributes are automatically discretized into a fixed
+    # number of bins (default is 10).
     class OneR < Classifier
-      
       attr_reader :data_set, :rule
 
+      parameters_info selected_attribute: 'Index of the attribute to force.',
+                      tie_break: 'Strategy when two attributes yield the same accuracy.',
+                      bin_count: 'Number of bins used to discretize numeric attributes.'
+
+      # @return [Object]
+      def initialize
+        super()
+        @selected_attribute = nil
+        @tie_break = :first
+        @bin_count = 10
+      end
+
       # Build a new OneR classifier. You must provide a DataSet instance
-      # as parameter. The last attribute of each item is considered as 
+      # as parameter. The last attribute of each item is considered as
       # the item class.
+      # @param data_set [Object]
+      # @return [Object]
       def build(data_set)
         data_set.check_not_empty
         @data_set = data_set
-        if (data_set.num_attributes == 1) 
+        if data_set.num_attributes == 1
           @zero_r = ZeroR.new.build(data_set)
-          return self;
+          return self
         else
-          @zero_r = nil;
+          @zero_r = nil
         end
         domains = @data_set.build_domains
         @rule = nil
-        domains[1...-1].each_index do |attr_index|
-          rule = build_rule(@data_set.data_items, attr_index, domains)
-          @rule = rule if !@rule || rule[:correct] > @rule[:correct]
+        if @selected_attribute
+          @rule = build_rule(@data_set.data_items, @selected_attribute, domains)
+        else
+          domains[1...-1].each_index do |attr_index|
+            rule = build_rule(@data_set.data_items, attr_index, domains)
+            if !@rule || rule[:correct] > @rule[:correct] ||
+               (rule[:correct] == @rule[:correct] && @tie_break == :last)
+              @rule = rule
+            end
+          end
         end
-        return self
+        self
       end
-      
+
       # You can evaluate new data, predicting its class.
       # e.g.
-      #   classifier.eval(['New York',  '<30', 'F'])  # => 'Y'      
+      #   classifier.eval(['New York',  '<30', 'F'])  # => 'Y'
+      # @param data [Object]
+      # @return [Object]
       def eval(data)
         return @zero_r.eval(data) if @zero_r
+
         attr_value = data[@rule[:attr_index]]
-        return @rule[:rule][attr_value]
+        if @rule[:bins]
+          bin = @rule[:bins].find { |b| b.include?(attr_value) }
+          attr_value = bin
+        end
+        @rule[:rule][attr_value]
       end
-      
+
       # This method returns the generated rules in ruby code.
       # e.g.
-      #   
+      #
       #   classifier.get_rules
       #     # =>  if age_range == '<30' then marketing_target = 'Y'
       #           elsif age_range == '[30-50)' then marketing_target = 'N'
       #           elsif age_range == '[50-80]' then marketing_target = 'N'
       #           end
       #
-      # It is a nice way to inspect induction results, and also to execute them:  
+      # It is a nice way to inspect induction results, and also to execute them:
       #     marketing_target = nil
-      #     eval classifier.get_rules   
+      #     eval classifier.get_rules
       #     puts marketing_target
       #       # =>  'Y'
+      # @return [Object]
       def get_rules
         return @zero_r.get_rules if @zero_r
+
         sentences = []
         attr_label = @data_set.data_labels[@rule[:attr_index]]
-        class_label = @data_set.data_labels.last
+        class_label = @data_set.category_label
         @rule[:rule].each_pair do |attr_value, class_value|
-          sentences << "#{attr_label} == '#{attr_value}' then #{class_label} = '#{class_value}'"
+          sentences << if attr_value.is_a?(Range)
+                         "(#{attr_value}).include?(#{attr_label}) then #{class_label} = '#{class_value}'"
+                       else
+                         "#{attr_label} == '#{attr_value}' then #{class_label} = '#{class_value}'"
+                       end
         end
-        return "if " + sentences.join("\nelsif ") + "\nend"        
+        "if #{sentences.join("\nelsif ")}\nend"
       end
-      
+
       protected
-      
+
+      # @param data_examples [Object]
+      # @param attr_index [Object]
+      # @param domains [Object]
+      # @return [Object]
       def build_rule(data_examples, attr_index, domains)
         domain = domains[attr_index]
-        value_freq = Hash.new
-        domain.each do |attr_value| 
-          value_freq[attr_value] = Hash.new { |hash, key| hash[key] = 0 }
-        end
-        data_examples.each do |data|
-          value_freq[data[attr_index]][data.last] = value_freq[data[attr_index]][data.last] + 1
+        bins, value_freq = build_frequency(domain, data_examples, attr_index)
+        rule, correct_instances = rule_from_frequency(value_freq)
+        { attr_index: attr_index, rule: rule, correct: correct_instances, bins: bins }
+      end
+
+      def build_frequency(domain, data_examples, attr_index)
+        if domain.is_a?(Array) && domain.length == 2 && domain.all? { |v| v.is_a? Numeric }
+          bins = discretize_range(domain, @bin_count)
+          value_freq = bins.each_with_object({}) { |b, h| h[b] = Hash.new(0) }
+          data_examples.each do |data|
+            bin = bins.find { |b| b.include?(data[attr_index]) }
+            value_freq[bin][data.last] += 1
+          end
+        else
+          bins = nil
+          value_freq = domain.each_with_object({}) { |v, h| h[v] = Hash.new(0) }
+          data_examples.each do |data|
+            value_freq[data[attr_index]][data.last] += 1
+          end
         end
+        [bins, value_freq]
+      end
+
+      def rule_from_frequency(value_freq)
         rule = {}
         correct_instances = 0
-        value_freq.each_pair do |attr, class_freq_hash|  
-          max_freq = 0
-          class_freq_hash.each_pair do |class_value, freq| 
-            if max_freq < freq
-              rule[attr] = class_value 
-              max_freq = freq
-            end
-          end
+        value_freq.each_pair do |attr, class_freq_hash|
+          pair = class_freq_hash.max_by { |_k, v| v }
+          next unless pair
+
+          rule[attr], max_freq = pair
           correct_instances += max_freq
         end
-        return {:attr_index => attr_index, :rule => rule, :correct => correct_instances}
+        [rule, correct_instances]
       end
 
+      # @param range [Object]
+      # @param bins [Object]
+      # @return [Object]
+      def discretize_range(range, bins)
+        min, max = range
+        step = (max - min).to_f / bins
+        ranges = []
+        bins.times do |i|
+          low = min + (i * step)
+          high = i == bins - 1 ? max : min + ((i + 1) * step)
+          ranges << (i == bins - 1 ? (low..high) : (low...high))
+        end
+        ranges
+      end
     end
   end
 end

data/lib/ai4r/classifiers/prism.rb

@@ -1,65 +1,99 @@
-# Author::    Sergio Fierens (Implementation only, Cendrowska is 
+# frozen_string_literal: true
+
+# Author::    Sergio Fierens (Implementation only, Cendrowska is
 # the creator of the algorithm)
 # License::   MPL 1.1
 # Project::   ai4r
-# Url::       http://www.ai4r.org/
+# Url::       https://github.com/SergioFierens/ai4r
 #
-# You can redistribute it and/or modify it under the terms of 
-# the Mozilla Public License version 1.1  as published by the 
+# 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
 #
-# J. Cendrowska (1987). PRISM: An algorithm for inducing modular rules. 
+# J. Cendrowska (1987). PRISM: An algorithm for inducing modular rules.
 # International Journal of Man-Machine Studies. 27(4):349-370.
 
-require File.dirname(__FILE__) + '/../data/data_set'
-require File.dirname(__FILE__) + '/../classifiers/classifier'
+require_relative '../data/data_set'
+require_relative '../classifiers/classifier'
 
 module Ai4r
   module Classifiers
-
     # = Introduction
-    # This is an implementation of the PRISM algorithm (Cendrowska, 1987) 
+    # This is an implementation of the PRISM algorithm (Cendrowska, 1987)
     # Given a set of preclassified examples, it builds a set of rules
     # to predict the class of other instaces.
-    # 
-    # J. Cendrowska (1987). PRISM: An algorithm for inducing modular rules. 
+    #
+    # J. Cendrowska (1987). PRISM: An algorithm for inducing modular rules.
     # International Journal of Man-Machine Studies. 27(4):349-370.
     class Prism < Classifier
-            
-      attr_reader :data_set, :rules
+      attr_reader :data_set, :rules, :majority_class
+
+      parameters_info(
+        fallback_class: 'Default class returned when no rule matches.',
+        bin_count: 'Number of bins used to discretize numeric attributes.',
+        default_class: 'Return this value when no rule matches.',
+        tie_break: 'Strategy when multiple conditions have equal ratios.'
+      )
+
+      def initialize
+        super()
+        @fallback_class = nil
+        @bin_count = 10
+        @attr_bins = {}
+
+        @default_class = nil
+        @tie_break = :first
+        @bin_count = 10
+        @attr_bins = {}
+      end
 
       # Build a new Prism classifier. You must provide a DataSet instance
-      # as parameter. The last attribute of each item is considered as 
+      # as parameter. The last attribute of each item is considered as
       # the item class.
+      # @param data_set [Object]
+      # @return [Object]
       def build(data_set)
         data_set.check_not_empty
         @data_set = data_set
+
+        freqs = Hash.new(0)
+        @data_set.data_items.each { |item| freqs[item.last] += 1 }
+        @majority_class = freqs.max_by { |_, v| v }&.first
+        @fallback_class = @default_class if @default_class
+        @fallback_class = @majority_class if @fallback_class.nil?
+
         domains = @data_set.build_domains
-        instances = @data_set.data_items.collect {|data| data }
+        @attr_bins = {}
+        domains[0...-1].each_with_index do |domain, i|
+          @attr_bins[@data_set.data_labels[i]] = discretize_range(domain, @bin_count) if domain.is_a?(Array) && domain.length == 2 && domain.all? { |v| v.is_a? Numeric }
+        end
+        instances = @data_set.data_items.collect { |data| data }
         @rules = []
         domains.last.each do |class_value|
-          while(has_class_value(instances, class_value))
+          while class_value?(instances, class_value)
             rule = build_rule(class_value, instances)
             @rules << rule
-            instances = instances.select {|data| !matches_conditions(data, rule[:conditions])}
+            instances = instances.reject { |data| matches_conditions(data, rule[:conditions]) }
           end
         end
-        return self
+        self
       end
 
       # You can evaluate new data, predicting its class.
       # e.g.
-      #   classifier.eval(['New York',  '<30', 'F'])  # => 'Y'      
+      #   classifier.eval(['New York',  '<30', 'F'])  # => 'Y'
+      # @param instace [Object]
+      # @return [Object]
       def eval(instace)
         @rules.each do |rule|
           return rule[:class_value] if matches_conditions(instace, rule[:conditions])
         end
-        return nil
+        @default_class || @fallback_class
       end
-      
+
       # This method returns the generated rules in ruby code.
       # e.g.
-      #   
+      #
       #   classifier.get_rules
       #     # => if age_range == '<30' then marketing_target = 'Y'
       #    elsif age_range == '>80' then marketing_target = 'Y'
@@ -67,131 +101,188 @@ module Ai4r
       #    else marketing_target = 'N'
       #    end
       #
-      # It is a nice way to inspect induction results, and also to execute them:  
+      # It is a nice way to inspect induction results, and also to execute them:
       #        age_range = '[30-50)'
       #        city = 'New York'
-      #        eval(classifier.get_rules) 
+      #        eval(classifier.get_rules)
       #        puts marketing_target
       #         'Y'
+      # @return [Object]
       def get_rules
         out = "if #{join_terms(@rules.first)} then #{then_clause(@rules.first)}"
-        @rules[1...-1].each do |rule| 
+        @rules[1...-1].each do |rule|
           out += "\nelsif #{join_terms(rule)} then #{then_clause(rule)}"
         end
         out += "\nelse #{then_clause(@rules.last)}" if @rules.size > 1
         out += "\nend"
-        return out
+        out
       end
-      
+
       protected
-      
+
+      # @param data [Object]
+      # @param attr [Object]
+      # @return [Object]
       def get_attr_value(data, attr)
         data[@data_set.get_index(attr)]
       end
-      
-      def has_class_value(instances, class_value)
-        instances.each { |data| return true if data.last == class_value}
-        return false
+
+      # @param instances [Object]
+      # @param class_value [Object]
+      # @return [Object]
+      def class_value?(instances, class_value)
+        instances.any? { |data| data.last == class_value }
       end
-      
-      def is_perfect(instances, rule)
+
+      # @param instances [Object]
+      # @param rule [Object]
+      # @return [Object]
+      def perfect?(instances, rule)
         class_value = rule[:class_value]
-        instances.each do |data| 
-          return false if data.last != class_value and matches_conditions(data, rule[:conditions])
+        instances.each do |data|
+          return false if (data.last != class_value) && matches_conditions(data, rule[:conditions])
         end
-        return true
+        true
       end
-      
+
+      # @param data [Object]
+      # @param conditions [Object]
+      # @return [Object]
       def matches_conditions(data, conditions)
         conditions.each_pair do |attr_label, attr_value|
-          return false if get_attr_value(data, attr_label) != attr_value
+          value = get_attr_value(data, attr_label)
+          if attr_value.is_a?(Range)
+            return false unless attr_value.include?(value)
+          else
+            return false unless value == attr_value
+          end
         end
-        return true
+        true
       end
-      
+
+      # @param class_value [Object]
+      # @param instances [Object]
+      # @return [Object]
       def build_rule(class_value, instances)
-        rule = {:class_value => class_value, :conditions => {}}
-        rule_instances = instances.collect {|data| data }
-        attributes = @data_set.data_labels[0...-1].collect {|label| label }
-        until(is_perfect(instances, rule) || attributes.empty?)
+        rule = { class_value: class_value, conditions: {} }
+        rule_instances = instances.collect { |data| data }
+        attributes = @data_set.data_labels[0...-1].collect { |label| label }
+        until perfect?(instances, rule) || attributes.empty?
           freq_table = build_freq_table(rule_instances, attributes, class_value)
           condition = get_condition(freq_table)
           rule[:conditions].merge!(condition)
-          rule_instances = rule_instances.select do |data| 
-            matches_conditions(data, condition) 
+          attributes.delete(condition.keys.first)
+          rule_instances = rule_instances.select do |data|
+            matches_conditions(data, condition)
           end
         end
-        return rule
+        rule
       end
-      
+
       # Returns a structure with the folloring format:
       # => {attr1_label => { :attr1_value1 => [p, t], attr1_value2 => [p, t], ... },
       #     attr2_label => { :attr2_value1 => [p, t], attr2_value2 => [p, t], ... },
       #     ...
       #     }
       # where p is the number of instances classified as class_value
-      # with that attribute value, and t is the total number of instances with 
+      # with that attribute value, and t is the total number of instances with
       # that attribute value
+      # @param rule_instances [Object]
+      # @param attributes [Object]
+      # @param class_value [Object]
+      # @return [Object]
       def build_freq_table(rule_instances, attributes, class_value)
-        freq_table = Hash.new()
+        freq_table = {}
         rule_instances.each do |data|
           attributes.each do |attr_label|
             attr_freqs = freq_table[attr_label] || Hash.new([0, 0])
-            pt = attr_freqs[get_attr_value(data, attr_label)]
-            pt = [(data.last == class_value) ? pt[0]+1 : pt[0], pt[1]+1]
-            attr_freqs[get_attr_value(data, attr_label)] = pt
+            value = get_attr_value(data, attr_label)
+            if (bins = @attr_bins[attr_label])
+              value = bins.find { |b| b.include?(value) }
+            end
+            pt = attr_freqs[value]
+            pt = [data.last == class_value ? pt[0] + 1 : pt[0], pt[1] + 1]
+            attr_freqs[value] = pt
             freq_table[attr_label] = attr_freqs
           end
         end
-        return freq_table
+        freq_table
       end
-      
+
       # returns a single conditional term: {attrN_label => attrN_valueM}
       # selecting the attribute with higher pt ratio
-      # (occurrences of attribute value classified as class_value / 
+      # (occurrences of attribute value classified as class_value /
       #  occurrences of attribute value)
+      # @param freq_table [Object]
+      # @return [Object]
       def get_condition(freq_table)
         best_pt = [0, 0]
         condition = nil
         freq_table.each do |attr_label, attr_freqs|
           attr_freqs.each do |attr_value, pt|
-            if(better_pt(pt, best_pt))
+            if better_pt(pt, best_pt)
               condition = { attr_label => attr_value }
               best_pt = pt
             end
           end
         end
-        return condition
+        condition
       end
-      
+
       # pt = [p, t]
       # p = occurrences of attribute value with instance classified as class_value
       # t = occurrences of attribute value
       # a pt is better if:
       #   1- its ratio is higher
-      #   2- its ratio is equal, and has a higher p 
+      #   2- its ratio is equal, and has a higher p
+      # @param pt [Object]
+      # @param best_pt [Object]
+      # @return [Object]
       def better_pt(pt, best_pt)
-        return false if pt[1] == 0
-        return true if best_pt[1] == 0
-        a = pt[0]*best_pt[1]
-        b = best_pt[0]*pt[1]
-        return true if a>b || (a==b && pt[0]>best_pt[0])
-        return false
+        return false if pt[1].zero?
+        return true if best_pt[1].zero?
+
+        a = pt[0] * best_pt[1]
+        b = best_pt[0] * pt[1]
+        return true if a > b || (a == b && pt[0] > best_pt[0])
+        return true if a == b && pt[0] == best_pt[0] && @tie_break == :last
+
+        false
       end
-      
+
+      # @param range [Object]
+      # @param bins [Object]
+      # @return [Object]
+      def discretize_range(range, bins)
+        min, max = range
+        step = (max - min).to_f / bins
+        ranges = []
+        bins.times do |i|
+          low = min + (i * step)
+          high = i == bins - 1 ? max : min + ((i + 1) * step)
+          ranges << (i == bins - 1 ? (low..high) : (low...high))
+        end
+        ranges
+      end
+
+      # @param rule [Object]
+      # @return [Object]
       def join_terms(rule)
-        terms = []
-        rule[:conditions].each do |attr_label, attr_value| 
-            terms << "#{attr_label} == '#{attr_value}'"
+        terms = rule[:conditions].map do |attr_label, attr_value|
+          if attr_value.is_a?(Range)
+            "(#{attr_value}).include?(#{attr_label})"
+          else
+            "#{attr_label} == '#{attr_value}'"
+          end
         end
-        "#{terms.join(" and ")}"
+        terms.join(' and ').to_s
       end
-      
+
+      # @param rule [Object]
+      # @return [Object]
       def then_clause(rule)
-        "#{@data_set.data_labels.last} = '#{rule[:class_value]}'"
+        "#{@data_set.category_label} = '#{rule[:class_value]}'"
       end
-          
     end
   end
 end
-

data/lib/ai4r/classifiers/random_forest.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Author::    OpenAI ChatGPT
+# License::   MPL 1.1
+# Project::   ai4r
+#
+# A simple Random Forest implementation using ID3 decision trees.
+
+require_relative 'id3'
+require_relative '../data/data_set'
+require_relative '../classifiers/classifier'
+require_relative 'votes'
+
+module Ai4r
+  module Classifiers
+    # RandomForest ensemble classifier built from decision trees.
+    class RandomForest < Classifier
+      parameters_info n_trees: 'Number of trees to build. Default 10.',
+                      sample_size: 'Number of data items for each tree (with replacement). Default: data set size.',
+                      feature_fraction:
+                        'Fraction of attributes sampled for each tree. Default: sqrt(num_attributes)/num_attributes.',
+                      random_seed: 'Seed for reproducible randomness.'
+
+      attr_reader :trees, :features
+
+      def initialize
+        super()
+        @n_trees = 10
+        @sample_size = nil
+        @feature_fraction = nil
+        @random_seed = nil
+      end
+
+      def build(data_set)
+        data_set.check_not_empty
+        rng = @random_seed ? Random.new(@random_seed) : Random.new
+        num_attributes = data_set.data_labels.length - 1
+        frac = @feature_fraction || (Math.sqrt(num_attributes) / num_attributes)
+        feature_count = [1, (num_attributes * frac).round].max
+        @sample_size ||= data_set.data_items.length
+        @trees = []
+        @features = []
+        @n_trees.times do
+          sampled = Array.new(@sample_size) { data_set.data_items.sample(random: rng) }
+          feature_idx = (0...num_attributes).to_a.sample(feature_count, random: rng)
+          tree_items = sampled.map do |item|
+            values = feature_idx.map { |i| item[i] }
+            values + [item.last]
+          end
+          labels = feature_idx.map { |i| data_set.data_labels[i] } + [data_set.data_labels.last]
+          ds = Ai4r::Data::DataSet.new(data_items: tree_items, data_labels: labels)
+          @trees << ID3.new.build(ds)
+          @features << feature_idx
+        end
+        self
+      end
+
+      def eval(data)
+        votes = Votes.new
+        @trees.each_with_index do |tree, idx|
+          sub_data = @features[idx].map { |i| data[i] }
+          votes.increment_category(tree.eval(sub_data))
+        end
+        votes.get_winner
+      end
+
+      def get_rules
+        'RandomForest does not support rule extraction.'
+      end
+    end
+  end
+end