ai4r 1.13 → 2.0

data/lib/ai4r/data/parameterizable.rb

@@ -1,64 +1,70 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens
 # License::   MPL 1.1
 # Project::   ai4r
-# Url::       http://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
 
 module Ai4r
   module Data
+    # Mix-in to declare configurable parameters for algorithms.
     module Parameterizable
-	
+      # Class-level helpers for Parameterizable.
       module ClassMethods
-        
         # Get info on what can be parameterized on this algorithm.
         # It returns a hash with the following format:
         # { :param_name => "Info on the parameter" }
+        # @return [Object]
         def get_parameters_info
-          return @_params_info_ || {}
+          @_params_info_ || {}
         end
-        
+
         # Set info on what can be parameterized on this algorithm.
         # You must provide a hash with the following format:
-        # { :param_name => "Info on the parameter" }        
+        # { :param_name => "Info on the parameter" }
+        # @param params_info [Object]
+        # @return [Object]
         def parameters_info(params_info)
-          @_params_info_ = params_info
-          params_info.keys.each do |param|
-            attr_accessor param
+          @_params_info_ = get_parameters_info.merge(params_info)
+          params_info.each_key do |param|
+            attr_accessor param unless method_defined?(param) || method_defined?("#{param}=")
           end
         end
       end
-  
+
       # Set parameter values on this algorithm instance.
-      # You must provide a hash with the folowing format:
+      # You must provide a hash with the following format:
       # { :param_name => parameter_value }
+      # @param params [Object]
+      # @return [Object]
       def set_parameters(params)
-        self.class.get_parameters_info.keys.each do | key |
-          if self.respond_to?("#{key}=".to_sym)
-            send("#{key}=".to_sym, params[key]) if params.has_key? key
-          end
+        params.each do |key, val|
+          public_send("#{key}=", val) if respond_to?("#{key}=")
         end
-        return self
+        self
       end
-      
+
       # Get parameter values on this algorithm instance.
-      # Returns a hash with the folowing format:
+      # Returns a hash with the following format:
       # { :param_name => parameter_value }
+      # @return [Object]
       def get_parameters
         params = {}
-        self.class.get_parameters_info.keys.each do | key |
-          params[key] = send(key) if self.respond_to?(key)
+        self.class.get_parameters_info.each_key do |key|
+          params[key] = send(key) if respond_to?(key)
         end
-        return params
+        params
       end
 
+      # @param base [Object]
+      # @return [Object]
       def self.included(base)
         base.extend(ClassMethods)
       end
-  
     end
   end
 end
-

data/lib/ai4r/data/proximity.rb

@@ -1,122 +1,122 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens
 # License::   MPL 1.1
 # Project::   ai4r
-# Url::       http://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
 
 module Ai4r
   module Data
-  
     # This module provides classical distance functions
     module Proximity
-      
       # This is a faster computational replacement for eclidean distance.
       # Parameters a and b are vectors with continuous attributes.
-      def self.squared_euclidean_distance(a, b)
+      def squared_euclidean_distance(vec_a, vec_b)
         sum = 0.0
-        a.each_with_index do |item_a, i|
-          item_b = b[i]
+        vec_a.each_with_index do |item_a, i|
+          item_b = vec_b[i]
           sum += (item_a - item_b)**2
         end
-        return sum
+        sum
       end
-      
+
       # Euclidean distance, or L2 norm.
       # Parameters a and b are vectors with continuous attributes.
-      # Euclidean distance tends to form hyperspherical 
-      # clusters(Clustering, Xu and Wunsch, 2009). 
-      # Translations and rotations do not cause a 
+      # Euclidean distance tends to form hyperspherical
+      # clusters(Clustering, Xu and Wunsch, 2009).
+      # Translations and rotations do not cause a
       # distortion in distance relation (Duda et al, 2001)
-      # If attributes are measured with different units, 
-      # attributes with larger values and variance will 
+      # If attributes are measured with different units,
+      # attributes with larger values and variance will
       # dominate the metric.
-      def self.euclidean_distance(a, b)
-        Math.sqrt(squared_euclidean_distance(a, b))
+      def euclidean_distance(vec_a, vec_b)
+        Math.sqrt(squared_euclidean_distance(vec_a, vec_b))
       end
-      
-      
+
       # city block, Manhattan distance, or L1 norm.
       # Parameters a and b are vectors with continuous attributes.
-      def self.manhattan_distance(a, b)
+      def manhattan_distance(vec_a, vec_b)
         sum = 0.0
-        a.each_with_index do |item_a, i|
-          item_b = b[i]
+        vec_a.each_with_index do |item_a, i|
+          item_b = vec_b[i]
           sum += (item_a - item_b).abs
         end
-        return sum
+        sum
       end
-      
+
       # Sup distance, or L-intinity norm
-      # Parameters a and b are vectors with continuous attributes.      
-      def self.sup_distance(a, b)
+      # Parameters a and b are vectors with continuous attributes.
+      def sup_distance(vec_a, vec_b)
         distance = 0.0
-        a.each_with_index do |item_a, i|
-          item_b = b[i]
+        vec_a.each_with_index do |item_a, i|
+          item_b = vec_b[i]
           diff = (item_a - item_b).abs
           distance = diff if diff > distance
         end
-        return distance
+        distance
       end
-      
-      # The Hamming distance between two attributes vectors of equal 
-      # length is the number of attributes for which the corresponding 
+
+      # The Hamming distance between two attributes vectors of equal
+      # length is the number of attributes for which the corresponding
       # vectors are different
       # This distance function is frequently used with binary attributes,
       # though it can be used with other discrete attributes.
-      def self.hamming_distance(a,b)
+      def hamming_distance(vec_a, vec_b)
         count = 0
-        a.each_index do |i|
-          count += 1 if a[i] != b[i]
+        vec_a.each_index do |i|
+          count += 1 if vec_a[i] != vec_b[i]
         end
-        return count
+        count
       end
-      
-      # The "Simple matching" distance between two attribute sets is given 
+
+      # The "Simple matching" distance between two attribute sets is given
       # by the number of values present on both vectors.
       # If sets a and b have lengths da and db then:
-      # 
+      #
       #  S = 2/(da + db) * Number of values present on both sets
       #  D = 1.0/S - 1
-      # 
-      # Some considerations: 
+      #
+      # Some considerations:
       # * a and b must not include repeated items
       # * all attributes are treated equally
       # * all attributes are treated equally
-      def self.simple_matching_distance(a,b)
+      def simple_matching_distance(vec_a, vec_b)
         similarity = 0.0
-        a.each {|item| similarity += 2 if b.include?(item)}
-        similarity /= (a.length + b.length)
-        return 1.0/similarity - 1
-      end      
-      
-      # Cosine similarity is a measure of similarity between two vectors 
-      # of an inner product space that measures the cosine of the 
+        vec_a.each { |item| similarity += 2 if vec_b.include?(item) }
+        similarity /= (vec_a.length + vec_b.length)
+        (1.0 / similarity) - 1
+      end
+
+      # Cosine similarity is a measure of similarity between two vectors
+      # of an inner product space that measures the cosine of the
       # angle between them (http://en.wikipedia.org/wiki/Cosine_similarity).
-      # 
+      #
       # Parameters a and b are vectors with continuous attributes.
       #
       # D = sum(a[i] * b[i]) / sqrt(sum(a[i]**2)) * sqrt(sum(b[i]**2))
-      def self.cosine_distance(a,b)
+      def cosine_distance(vec_a, vec_b)
         dot_product = 0.0
         norm_a = 0.0
         norm_b = 0.0
-        magnitude = 0.0
-        
-        a.each_index do |i|
-          dot_product += a[i] * b[i]
-          norm_a += a[i] ** 2
-          norm_b += b[i] ** 2
+
+        vec_a.each_index do |i|
+          dot_product += vec_a[i] * vec_b[i]
+          norm_a += vec_a[i]**2
+          norm_b += vec_b[i]**2
         end
-        
+
         magnitude = Math.sqrt(norm_a) * Math.sqrt(norm_b)
-        return 1 - (dot_product / magnitude)
+        1 - (dot_product / magnitude)
       end
+
+      module_function :squared_euclidean_distance, :euclidean_distance,
+                      :manhattan_distance, :sup_distance,
+                      :hamming_distance, :simple_matching_distance,
+                      :cosine_distance
     end
-    
   end
-  
 end
-    

data/lib/ai4r/data/statistics.rb

@@ -1,77 +1,88 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens
 # 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 File.dirname(__FILE__) + '/data_set'
-
 module Ai4r
   module Data
-  
     # This module provides some basic statistics functions to operate on
     # data set attributes.
     module Statistics
-      
       # Get the sample mean
+      # @param data_set [Object]
+      # @param attribute [Object]
+      # @return [Object]
       def self.mean(data_set, attribute)
         index = data_set.get_index(attribute)
         sum = 0.0
         data_set.data_items.each { |item| sum += item[index] }
-        return sum / data_set.data_items.length
+        sum / data_set.data_items.length
       end
-  
+
       # Get the variance.
       # You can provide the mean if you have it already, to speed up things.
+      # @param data_set [Object]
+      # @param attribute [Object]
+      # @param mean [Object]
+      # @return [Object]
       def self.variance(data_set, attribute, mean = nil)
         index = data_set.get_index(attribute)
-        mean = mean(data_set, attribute)
+        mean ||= mean(data_set, attribute)
         sum = 0.0
-        data_set.data_items.each { |item| sum += (item[index]-mean)**2 }
-        return sum / (data_set.data_items.length-1)
+        data_set.data_items.each { |item| sum += (item[index] - mean)**2 }
+        sum / (data_set.data_items.length - 1)
       end
-      
+
       # Get the standard deviation.
-      # You can provide the variance if you have it already, to speed up things.      
+      # You can provide the variance if you have it already, to speed up things.
+      # @param data_set [Object]
+      # @param attribute [Object]
+      # @param variance [Object]
+      # @return [Object]
       def self.standard_deviation(data_set, attribute, variance = nil)
         variance ||= variance(data_set, attribute)
         Math.sqrt(variance)
       end
-      
-      # Get the sample mode. 
+
+      # Get the sample mode.
+      # @param data_set [Object]
+      # @param attribute [Object]
+      # @return [Object]
       def self.mode(data_set, attribute)
         index = data_set.get_index(attribute)
-        count = Hash.new {0}
-        max_count = 0
-        mode = nil
-        data_set.data_items.each do |data_item| 
-          attr_value = data_item[index]
-          attr_count = (count[attr_value] += 1)
-          if attr_count > max_count
-            mode = attr_value
-            max_count = attr_count
-          end
-        end
-        return mode
+        data_set
+          .data_items
+          .map { |item| item[index] }
+          .tally
+          .max_by { _2 }
+          &.first
       end
-      
+
       # Get the maximum value of an attribute in the data set
+      # @param data_set [Object]
+      # @param attribute [Object]
+      # @return [Object]
       def self.max(data_set, attribute)
         index = data_set.get_index(attribute)
-        item = data_set.data_items.max {|x,y| x[index] <=> y[index]}
-        return (item) ? item[index] : (-1.0/0)
+        item = data_set.data_items.max_by { |item| item[index] }
+        item ? item[index] : -Float::INFINITY
       end
-      
+
       # Get the minimum value of an attribute in the data set
+      # @param data_set [Object]
+      # @param attribute [Object]
+      # @return [Object]
       def self.min(data_set, attribute)
         index = data_set.get_index(attribute)
-        item = data_set.data_items.min {|x,y| x[index] <=> y[index]}
-        return (item) ? item[index] : (1.0/0)
+        item = data_set.data_items.min_by { |item| item[index] }
+        item ? item[index] : Float::INFINITY
       end
-      
     end
   end
 end

data/lib/ai4r/experiment/classifier_evaluator.rb

@@ -1,82 +1,137 @@
-require 'benchmark'
-require File.dirname(__FILE__) + '/../data/data_set' 
+# frozen_string_literal: true
 
+require 'benchmark'
+require_relative '../data/data_set'
+require_relative 'split'
 
 module Ai4r
-
   module Experiment
-  
-    # The ClassifierEvaluator is useful to compare different classifiers 
-    # algorithms. The evaluator builds the Classifiers using the same data 
+    # The ClassifierEvaluator is useful to compare different classifiers
+    # algorithms. The evaluator builds the Classifiers using the same data
     # examples, and provides methods to evalute their performance in parallel.
-    # It is a nice tool to compare and evaluate the performance of different 
-    # algorithms, the same algorithm with different parameters, or your own new 
+    # It is a nice tool to compare and evaluate the performance of different
+    # algorithms, the same algorithm with different parameters, or your own new
     # algorithm against the classic classifiers.
     class ClassifierEvaluator
-      
       attr_reader :build_times, :eval_times, :classifiers
-      
+
+      # @return [Object]
       def initialize
         @classifiers = []
       end
 
       # Add a classifier instance to the test batch
+      # @param classifier [Object]
+      # @return [Object]
       def add_classifier(classifier)
         @classifiers << classifier
-        return self
+        self
       end
-      
-      alias :<< :add_classifier
-      
+
+      alias << add_classifier
+
       # Build all classifiers, using data examples found in data_set.
       # The last attribute of each item is considered as the
       # item class.
       # Building times are measured by separate, and can be accessed
       # through build_times attribute reader.
+      # @param data_set [Object]
+      # @return [Object]
       def build(data_set)
         @build_times = []
         @classifiers.each do |classifier|
           @build_times << Benchmark.measure { classifier.build data_set }
         end
-        return self
+        self
       end
 
       # You can evaluate new data, predicting its class.
       # e.g.
-      #   classifier.eval(['New York',  '<30', 'F'])  
+      #   classifier.eval(['New York',  '<30', 'F'])
       #   => ['Y', 'Y', 'Y', 'N', 'Y', 'Y', 'N']
       # Evaluation times are measured by separate, and can be accessed
       # through eval_times attribute reader.
+      # @param data [Object]
+      # @return [Object]
       def eval(data)
         @eval_times = []
         results = []
         @classifiers.each do |classifier|
           @eval_times << Benchmark.measure { results << classifier.eval(data) }
         end
-        return results
+        results
       end
-      
-      # Test classifiers using a data set. The last attribute of each item 
+
+      # Test classifiers using a data set. The last attribute of each item
       # is considered as the expected class. Data items are evaluated
       # using all classifiers: evalution times, sucess rate, and quantity of
       # classification errors are returned in a data set.
-      # The return data set has a row for every classifier tested, and the 
+      # The return data set has a row for every classifier tested, and the
       # following attributes:
       #   ["Classifier", "Testing Time", "Errors", "Success rate"]
+      # @param data_set [Object]
+      # @return [Object]
       def test(data_set)
-        result_data_items = []
-        @classifiers.each do |classifier|
-          result_data_items << test_classifier(classifier, data_set)
+        result_data_items = @classifiers.map do |classifier|
+          test_classifier(classifier, data_set)
         end
-        return Ai4r::Data::DataSet.new(:data_items => result_data_items, 
-          :data_labels => ["Classifier","Testing Time","Errors","Success rate"])
+
+        Ai4r::Data::DataSet.new(data_items: result_data_items,
+                                data_labels: ['Classifier',
+                                              'Testing Time', 'Errors', 'Success rate'])
       end
-      
+
+      # Perform k-fold cross validation on all classifiers.
+      # The dataset is split into +k+ folds using the Split utility. For each
+      # fold, classifiers are trained on the remaining folds and then tested on
+      # the held-out fold. The method returns a DataSet with the average time
+      # (build and test) and accuracy for each classifier.
+      # @param data_set [Ai4r::Data::DataSet] data to evaluate
+      # @param k [Integer] number of folds
+      # @return [Ai4r::Data::DataSet]
+      def cross_validate(data_set, k:)
+        folds = Split.split(data_set, k: k)
+        times = Array.new(@classifiers.length, 0.0)
+        accuracies = Array.new(@classifiers.length, 0.0)
+
+        folds.each_with_index do |test_set, i|
+          train_items = []
+          folds.each_with_index do |fold, j|
+            next if i == j
+
+            train_items.concat(fold.data_items)
+          end
+          train_set = Ai4r::Data::DataSet.new(
+            data_items: train_items,
+            data_labels: data_set.data_labels
+          )
+
+          @classifiers.each_with_index do |classifier, idx|
+            build_time = Benchmark.measure { classifier.build(train_set) }.real
+            result = test_classifier(classifier, test_set)
+            times[idx] += build_time + result[1]
+            accuracies[idx] += result[3]
+          end
+        end
+
+        result_items = @classifiers.each_index.map do |idx|
+          [@classifiers[idx], times[idx] / k, accuracies[idx] / k]
+        end
+        Ai4r::Data::DataSet.new(
+          data_items: result_items,
+          data_labels: ['Classifier', 'Avg. Time', 'Avg. Success rate']
+        )
+      end
+
       private
+
+      # @param classifier [Object]
+      # @param data_set [Object]
+      # @return [Object]
       def test_classifier(classifier, data_set)
         data_set_size = data_set.data_items.length
         errors = 0
-        testing_times = Benchmark.measure do 
+        testing_times = Benchmark.measure do
           data_set.data_items.each do |data_item|
             data = data_item[0...-1]
             expected_result = data_item.last
@@ -84,12 +139,9 @@ module Ai4r
             errors += 1 if result != expected_result
           end
         end
-        return [classifier, testing_times.real, errors,
-          ((data_set_size-errors*1.0)/data_set_size)]
+        [classifier, testing_times.real, errors,
+         ((data_set_size - (errors * 1.0)) / data_set_size)]
       end
-
     end
-    
   end
-
 end

data/lib/ai4r/experiment/split.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# 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
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require_relative '../data/data_set'
+
+module Ai4r
+  module Experiment
+    # Utility methods for experiment workflows.
+    module Split
+      module_function
+
+      # Split a dataset into +k+ folds.
+      # @param data_set [Ai4r::Data::DataSet] dataset to split
+      # @param k [Integer] number of folds
+      # @return [Array<Ai4r::Data::DataSet>] list of folds
+      def split(data_set, k:)
+        raise ArgumentError, 'k must be greater than 0' unless k.positive?
+
+        items = data_set.data_items.dup
+        labels = data_set.data_labels
+        fold_size = (items.length.to_f / k).ceil
+        folds = []
+        k.times do |i|
+          part = items.slice(i * fold_size, fold_size) || []
+          folds << Ai4r::Data::DataSet.new(data_items: part, data_labels: labels)
+        end
+        folds
+      end
+    end
+  end
+end

data/lib/ai4r/genetic_algorithm/chromosome_base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ai4r
+  module GeneticAlgorithm
+    # Base interface for chromosomes used by GeneticSearch.
+    # Implementations must define class methods `seed`, `mutate`,
+    # `reproduce` and the instance method `fitness`.
+    class ChromosomeBase
+      attr_accessor :data, :normalized_fitness
+
+      # @param data [Object]
+      # @return [Object]
+      def initialize(data = nil)
+        @data = data
+      end
+
+      # @return [Object]
+      def fitness
+        raise NotImplementedError, 'Subclasses must implement #fitness'
+      end
+
+      # @return [Object]
+      def self.seed
+        raise NotImplementedError, 'Implement .seed in subclass'
+      end
+
+      # @param _a [Object]
+      # @param _b [Object]
+      # @param _crossover_rate [Object]
+      # @return [Object]
+      def self.reproduce(_a, _b, _crossover_rate = 0.4)
+        raise NotImplementedError, 'Implement .reproduce in subclass'
+      end
+
+      # @param _chromosome [Object]
+      # @param _mutation_rate [Object]
+      # @return [Object]
+      def self.mutate(_chromosome, _mutation_rate = 0.3)
+        raise NotImplementedError, 'Implement .mutate in subclass'
+      end
+    end
+  end
+end