ai4ruby 1.11

data/lib/ai4r/data/parameterizable.rb

@@ -0,0 +1,64 @@
+# 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
+
+module Ai4r
+  module Data
+    module 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" }
+        def get_parameters_info
+          return @_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" }        
+        def parameters_info(params_info)
+          @_params_info_ = params_info
+          params_info.keys.each do |param|
+            attr_accessor param
+          end
+        end
+      end
+  
+      # Set parameter values on this algorithm instance.
+      # You must provide a hash with the folowing format:
+      # { :param_name => parameter_value }
+      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
+        end
+        return self
+      end
+      
+      # Get parameter values on this algorithm instance.
+      # Returns a hash with the folowing format:
+      # { :param_name => parameter_value }
+      def get_parameters
+        params = {}
+        self.class.get_parameters_info.keys.each do | key |
+          params[key] = send(key) if self.respond_to?(key)
+        end
+        return params
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+  
+    end
+  end
+end
+

data/lib/ai4r/data/proximity.rb

@@ -0,0 +1,100 @@
+# 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
+
+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)
+        sum = 0.0
+        a.each_with_index do |item_a, i|
+          item_b = b[i]
+          sum += (item_a - item_b)**2
+        end
+        return 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 
+      # distortion in distance relation (Duda et al, 2001)
+      # 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))
+      end
+      
+      
+      # city block, Manhattan distance, or L1 norm.
+      # Parameters a and b are vectors with continuous attributes.
+      def self.manhattan_distance(a, b)
+        sum = 0.0
+        a.each_with_index do |item_a, i|
+          item_b = b[i]
+          sum += (item_a - item_b).abs
+        end
+        return sum
+      end
+      
+      # Sup distance, or L-intinity norm
+      # Parameters a and b are vectors with continuous attributes.      
+      def self.sup_distance(a, b)
+        distance = 0.0
+        a.each_with_index do |item_a, i|
+          item_b = b[i]
+          diff = (item_a - item_b).abs
+          distance = diff if diff > distance
+        end
+        return distance
+      end
+      
+      # 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)
+        count = 0
+        a.each_index do |i|
+          count += 1 if a[i] != b[i]
+        end
+        return count
+      end
+      
+      # 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: 
+      # * 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)
+        similarity = 0.0
+        a.each {|item| similarity += 2 if b.include?(item)}
+        similarity /= (a.length + b.length)
+        return 1.0/similarity - 1
+      end      
+      
+    end
+    
+  end
+  
+end
+    

data/lib/ai4r/data/statistics.rb

@@ -0,0 +1,77 @@
+# 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__) + '/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
+      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
+      end
+  
+      # Get the variance.
+      # You can provide the mean if you have it already, to speed up things.
+      def self.variance(data_set, attribute, mean = nil)
+        index = data_set.get_index(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)
+      end
+      
+      # Get the standard deviation.
+      # You can provide the variance if you have it already, to speed up things.      
+      def self.standard_deviation(data_set, attribute, variance = nil)
+        variance ||= variance(data_set, attribute)
+        Math.sqrt(variance)
+      end
+      
+      # Get the sample mode. 
+      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
+      end
+      
+      # Get the maximum value of an attribute in the data set
+      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)
+      end
+      
+      # Get the minimum value of an attribute in the data set
+      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)
+      end
+      
+    end
+  end
+end

data/lib/ai4r/experiment/classifier_evaluator.rb

@@ -0,0 +1,95 @@
+require 'benchmark'
+require File.dirname(__FILE__) + '/../data/data_set' 
+
+
+module Ai4r
+
+  module Experiment
+  
+    # 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 
+    # algorithm against the classic classifiers.
+    class ClassifierEvaluator
+      
+      attr_reader :build_times, :eval_times, :classifiers
+      
+      def initialize
+        @classifiers = []
+      end
+
+      # Add a classifier instance to the test batch
+      def add_classifier(classifier)
+        @classifiers << classifier
+        return self
+      end
+      
+      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.
+      def build(data_set)
+        @build_times = []
+        @classifiers.each do |classifier|
+          @build_times << Benchmark.measure { classifier.build data_set }
+        end
+        return self
+      end
+
+      # You can evaluate new data, predicting its class.
+      # e.g.
+      #   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.
+      def eval(data)
+        @eval_times = []
+        results = []
+        @classifiers.each do |classifier|
+          @eval_times << Benchmark.measure { results << classifier.eval(data) }
+        end
+        return results
+      end
+      
+      # 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 
+      # following attributes:
+      #   ["Classifier", "Testing Time", "Errors", "Success rate"]
+      def test(data_set)
+        result_data_items = []
+        @classifiers.each do |classifier|
+          result_data_items << test_classifier(classifier, data_set)
+        end
+        return Ai4r::Data::DataSet.new(:data_items => result_data_items, 
+          :data_labels => ["Classifier","Testing Time","Errors","Success rate"])
+      end
+      
+      private
+      def test_classifier(classifier, data_set)
+        data_set_size = data_set.data_items.length
+        errors = 0
+        testing_times = Benchmark.measure do 
+          data_set.data_items.each do |data_item|
+            data = data_item[0...-1]
+            expected_result = data_item.last
+            result = classifier.eval data
+            errors += 1 if result != expected_result
+          end
+        end
+        return [classifier, testing_times.real, errors,
+          ((data_set_size-errors*1.0)/data_set_size)]
+      end
+
+    end
+    
+  end
+
+end

data/lib/ai4r/genetic_algorithm/genetic_algorithm.rb

@@ -0,0 +1,270 @@
+# 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
+module Ai4r
+  
+  # The GeneticAlgorithm module implements the GeneticSearch and Chromosome 
+  # classes. The GeneticSearch is a generic class, and can be used to solved 
+  # any kind of problems. The GeneticSearch class performs a stochastic search 
+  # of the solution of a given problem.
+  # 
+  # The Chromosome is "problem specific". Ai4r built-in Chromosome class was 
+  # designed to model the Travelling salesman problem. If you want to solve other 
+  # type of problem, you will have to modify the Chromosome class, by overwriting 
+  # its fitness, reproduce, and mutate functions, to model your specific problem.
+  module GeneticAlgorithm
+
+    #   This class is used to automatically:
+    #   
+    #     1. Choose initial population
+    #     2. Evaluate the fitness of each individual in the population
+    #     3. Repeat
+    #           1. Select best-ranking individuals to reproduce
+    #           2. Breed new generation through crossover and mutation (genetic operations) and give birth to offspring
+    #           3. Evaluate the individual fitnesses of the offspring
+    #           4. Replace worst ranked part of population with offspring
+    #     4. Until termination
+    #
+    #   If you want to customize the algorithm, you must modify any of the following classes:
+    #     - Chromosome
+    #     - Population
+    class GeneticSearch
+
+      attr_accessor :population
+
+
+      def initialize(initial_population_size, generations)
+        @population_size = initial_population_size
+        @max_generation = generations
+        @generation = 0
+      end
+
+      #     1. Choose initial population
+      #     2. Evaluate the fitness of each individual in the population
+      #     3. Repeat
+      #           1. Select best-ranking individuals to reproduce
+      #           2. Breed new generation through crossover and mutation (genetic operations) and give birth to offspring
+      #           3. Evaluate the individual fitnesses of the offspring
+      #           4. Replace worst ranked part of population with offspring
+      #     4. Until termination    
+      #     5. Return the best chromosome
+      def run
+        generate_initial_population                    #Generate initial population 
+        @max_generation.times do
+          selected_to_breed = selection                #Evaluates current population 
+          offsprings = reproduction selected_to_breed  #Generate the population for this new generation
+          replace_worst_ranked offsprings
+        end
+        return best_chromosome
+      end
+
+
+      def generate_initial_population
+       @population = []
+       @population_size.times do
+         population << Chromosome.seed
+       end
+      end
+
+      # Select best-ranking individuals to reproduce
+      # 
+      # Selection is the stage of a genetic algorithm in which individual 
+      # genomes are chosen from a population for later breeding. 
+      # There are several generic selection algorithms, such as 
+      # tournament selection and roulette wheel selection. We implemented the
+      # latest.
+      # 
+      # Steps:
+      # 
+      # 1. The fitness function is evaluated for each individual, providing fitness values
+      # 2. The population is sorted by descending fitness values.
+      # 3. The fitness values ar then normalized. (Highest fitness gets 1, lowest fitness gets 0). The normalized value is stored in the "normalized_fitness" attribute of the chromosomes.
+      # 4. A random number R is chosen. R is between 0 and the accumulated normalized value (all the normalized fitness values added togheter).
+      # 5. The selected individual is the first one whose accumulated normalized value (its is normalized value plus the normalized values of the chromosomes prior it) greater than R.
+      # 6. We repeat steps 4 and 5, 2/3 times the population size.    
+      def selection
+        @population.sort! { |a, b| b.fitness <=> a.fitness}
+        best_fitness = @population[0].fitness
+        worst_fitness = @population.last.fitness
+        acum_fitness = 0
+        if best_fitness-worst_fitness > 0
+        @population.each do |chromosome| 
+          chromosome.normalized_fitness = (chromosome.fitness - worst_fitness)/(best_fitness-worst_fitness)
+          acum_fitness += chromosome.normalized_fitness
+        end
+        else
+          @population.each { |chromosome| chromosome.normalized_fitness = 1}  
+        end
+        selected_to_breed = []
+        ((2*@population_size)/3).times do 
+          selected_to_breed << select_random_individual(acum_fitness)
+        end
+        selected_to_breed
+      end
+
+      # We combine each pair of selected chromosome using the method 
+      # Chromosome.reproduce
+      #
+      # The reproduction will also call the Chromosome.mutate method with 
+      # each member of the population. You should implement Chromosome.mutate
+      # to only change (mutate) randomly. E.g. You could effectivly change the
+      # chromosome only if 
+      #     rand < ((1 - chromosome.normalized_fitness) * 0.4)
+      def reproduction(selected_to_breed)
+        offsprings = []
+        0.upto(selected_to_breed.length/2-1) do |i|
+          offsprings << Chromosome.reproduce(selected_to_breed[2*i], selected_to_breed[2*i+1])
+        end
+        @population.each do |individual|
+          Chromosome.mutate(individual)
+        end
+        return offsprings
+      end
+
+      # Replace worst ranked part of population with offspring
+      def replace_worst_ranked(offsprings)
+        size = offsprings.length
+        @population = @population [0..((-1*size)-1)] + offsprings
+      end
+
+      # Select the best chromosome in the population
+      def best_chromosome
+        the_best = @population[0]
+        @population.each do |chromosome|
+          the_best = chromosome if chromosome.fitness > the_best.fitness
+        end
+        return the_best
+      end
+
+      private 
+      def select_random_individual(acum_fitness)
+        select_random_target = acum_fitness * rand
+        local_acum = 0
+        @population.each do |chromosome|
+          local_acum += chromosome.normalized_fitness
+          return chromosome if local_acum >= select_random_target
+        end
+      end
+
+    end
+
+    # A Chromosome is a representation of an individual solution for a specific 
+    # problem. You will have to redifine the Chromosome representation for each
+    # particular problem, along with its fitness, mutate, reproduce, and seed 
+    # methods.
+    class Chromosome
+
+      attr_accessor :data
+      attr_accessor :normalized_fitness
+
+      def initialize(data)
+        @data = data
+      end
+
+      # The fitness method quantifies the optimality of a solution 
+      # (that is, a chromosome) in a genetic algorithm so that that particular 
+      # chromosome may be ranked against all the other chromosomes. 
+      # 
+      # Optimal chromosomes, or at least chromosomes which are more optimal, 
+      # are allowed to breed and mix their datasets by any of several techniques, 
+      # producing a new generation that will (hopefully) be even better.
+      def fitness
+        return @fitness if @fitness
+        last_token = @data[0]
+        cost = 0
+        @data[1..-1].each do |token|
+          cost += @@costs[last_token][token]
+          last_token = token
+        end
+        @fitness = -1 * cost
+        return @fitness
+      end
+
+      # mutation method is used to maintain genetic diversity from one 
+      # generation of a population of chromosomes to the next. It is analogous 
+      # to biological mutation. 
+      # 
+      # The purpose of mutation in GAs is to allow the 
+      # algorithm to avoid local minima by preventing the population of 
+      # chromosomes from becoming too similar to each other, thus slowing or even 
+      # stopping evolution.
+      # 
+      # Calling the mutate function will "probably" slightly change a chromosome
+      # randomly. 
+      #
+      # This implementation of "mutation" will (probably) reverse the 
+      # order of 2 consecutive randome nodes 
+      # (e.g. from [ 0, 1, 2, 4] to [0, 2, 1, 4]) if:
+      #     ((1 - chromosome.normalized_fitness) * 0.4)
+      def self.mutate(chromosome)
+        if chromosome.normalized_fitness && rand < ((1 - chromosome.normalized_fitness) * 0.3)
+          data = chromosome.data
+          index = rand(data.length-1)
+          data[index], data[index+1] = data[index+1], data[index]
+          chromosome.data = data
+          @fitness = nil
+        end
+      end
+
+      # Reproduction method is used to combine two chromosomes (solutions) into 
+      # a single new chromosome. There are several ways to
+      # combine two chromosomes: One-point crossover, Two-point crossover,
+      # "Cut and splice", edge recombination, and more. 
+      # 
+      # The method is usually dependant of the problem domain.
+      # In this case, we have implemented edge recombination, wich is the 
+      # most used reproduction algorithm for the Travelling salesman problem.
+      def self.reproduce(a, b)
+        data_size = @@costs[0].length
+        available = []
+        0.upto(data_size-1) { |n| available << n }
+        token = a.data[0]
+        spawn = [token]
+        available.delete(token)
+        while available.length > 0 do 
+          #Select next
+          if token != b.data.last && available.include?(b.data[b.data.index(token)+1])
+            next_token = b.data[b.data.index(token)+1]
+          elsif token != a.data.last && available.include?(a.data[a.data.index(token)+1])
+            next_token = a.data[a.data.index(token)+1] 
+          else
+            next_token = available[rand(available.length)]
+          end
+          #Add to spawn
+          token = next_token
+          available.delete(token)
+          spawn << next_token
+          a, b = b, a if rand < 0.4
+        end
+        return Chromosome.new(spawn)
+      end
+
+      # Initializes an individual solution (chromosome) for the initial 
+      # population. Usually the chromosome is generated randomly, but you can 
+      # use some problem domain knowledge, to generate a 
+      # (probably) better initial solution.
+      def self.seed
+        data_size = @@costs[0].length
+        available = []
+        0.upto(data_size-1) { |n| available << n }
+        seed = []
+        while available.length > 0 do 
+          index = rand(available.length)
+          seed << available.delete_at(index)
+        end
+        return Chromosome.new(seed)
+      end
+
+      def self.set_cost_matrix(costs)
+        @@costs = costs
+      end
+    end
+
+  end
+
+end