ai4r 1.1 → 1.2

data/lib/ai4r/genetic_algorithm/genetic_algorithm.rb

@@ -0,0 +1,272 @@
+# 
+# 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 Chromosomeclass 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 you specific problem.
+# 
+# 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 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 solutions for a specific 
+    # problem. You will have to redifine you Chromosome representation for each
+    # particular problem, along with its fitness, mutate, reproduce, and seed 
+    # functions.
+    class Chromosome
+
+      attr_accessor :data
+      attr_accessor :normalized_fitness
+
+      def initialize(data)
+        @data = data
+      end
+
+      # The fitness function 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 is a function 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 is used to vary the programming of a chromosome or 
+      # chromosomes from one generation to the next. 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 better initial solutions.
+      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

data/lib/ai4r/neural_network/backpropagation.rb

@@ -0,0 +1,271 @@
+# The utility of artificial neural network 
+# models lies in the fact that they can be used 
+# to infer a function from observations. 
+# This is particularly useful in applications 
+# where the complexity of the data or task makes the 
+# design of such a function by hand impractical.
+# Neural Networks are being used in many businesses and applications. Their 
+# ability to learn by example makes them attractive in environments where 
+# the business rules are either not well defined or are hard to enumerate and 
+# define. Many people believe that Neural Networks can only solve toy problems.
+# Give them a try, and let you decide if they are good enough to solve your 
+# needs.
+# 
+# In this module you will find an implementation of neural networks
+# using the Backpropagation is a supervised learning technique (described 
+# by Paul Werbos in 1974, and further developed by David E. 
+# Rumelhart, Geoffrey E. Hinton and Ronald J. Williams in 1986)
+# 
+# More about neural networks and backpropagation:
+# 
+# * http://en.wikipedia.org/wiki/Backpropagation
+# * http://en.wikipedia.org/wiki/Neural_networks
+# 
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# Specials thanks to John Miller, for several bugs fixes and comments in the
+# Backpropagation implementation
+#
+# 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 NeuralNetwork
+
+    # = Introduction
+    # 
+    # This is an implementation of neural networks
+    # using the Backpropagation is a supervised learning technique (described 
+    # by Paul Werbos in 1974, and further developed by David E. 
+    # Rumelhart, Geoffrey E. Hinton and Ronald J. Williams in 1986)
+    # 
+    # = How to use it
+    # 
+    #   # Create the network
+    #   net = Backpropagation.new([4, 3, 2])  # 4 inputs
+    #                                         # 1 hidden layer with 3 neurons, 
+    #                                         # 2 outputs
+    #   # Train the network 
+    #   1..upto(100) do |i|
+    #     net.train(example[i], result[i])
+    #   end
+    #   
+    #   # Use it: Evaluate data with the trained network
+    #   net.eval([12, 48, 12, 25])  # =>  [0.86, 0.01]
+    #   
+    class Backpropagation
+
+      DEFAULT_BETA = 0.5
+      DEFAULT_LAMBDA = 0.25
+      DEFAULT_THRESHOLD = 0.66
+
+    # Creates a new network specifying the its architecture.
+    # E.g.
+    #    
+    #   net = Backpropagation.new([4, 3, 2])  # 4 inputs
+    #                                         # 1 hidden layer with 3 neurons, 
+    #                                         # 2 outputs    
+    #   net = Backpropagation.new([2, 3, 3, 4])   # 2 inputs
+    #                                             # 2 hidden layer with 3 neurons each, 
+    #                                             # 4 outputs    
+    #   net = Backpropagation.new([2, 1])   # 2 inputs
+    #                                       # No hidden layer
+    #                                       # 1 output
+    #
+    # Optionally you can customize certain parameters:
+    # 
+    # threshold = A real number which we will call Threshold. 
+    # Experiments have shown that best values for q are between 0.25 and 1. 
+    # 
+    # lambda = The Learning Rate: a real number, usually between 0.05 and 0.25.
+    # 
+    # momentum = A momentum will avoid oscillations during learning, converging 
+    # to a solution in less iterations.
+      def initialize(layer_sizes, threshold=DEFAULT_THRESHOLD, lambda=DEFAULT_LAMBDA, momentum=DEFAULT_BETA)
+        @neurons = []
+        layer_sizes.reverse.each do |layer_size|
+          layer = []
+          layer_size.times { layer <<  Neuron.new(@neurons.last, threshold, lambda, momentum) }
+          @neurons << layer
+        end
+        @neurons.reverse!
+      end
+
+    # Evaluates the input.
+    # E.g.
+    #     net = Backpropagation.new([4, 3, 2])
+    #     net.eval([25, 32.3, 12.8, 1.5])
+    #         # =>  [0.83, 0.03]
+      def eval(input)
+        #check input size
+        if(input.length != @neurons.first.length)
+          raise "Wrong input dimension. Expected: #{@neurons.first.length}, received: #{input.length}"  
+        end
+        #Present input
+        input.each_index do |input_index|
+          @neurons.first[input_index].propagate(input[input_index])
+        end
+        #Propagate
+        @neurons[1..-1].each do |layer|
+          layer.each {|neuron| neuron.propagate}
+        end
+        output = []
+        @neurons.last.each { |neuron| output << neuron.state }
+        return output
+      end
+
+      # This method trains the network using the backpropagation algorithm.
+      # 
+      # input: Networks input
+      # 
+      # output: Expected output for the given input.
+      #
+      # This method returns the network error (not an absolut amount, 
+      # the difference between real output and the expected output)
+      def train(input, output)
+        #check output size
+        if(output.length != @neurons.last.length)
+          raise "Wrong output dimension. Expected: #{@neurons.last.length}, received: #{output.length}"  
+        end
+        #Eval input
+        eval(input)
+        #Set expected output
+        output.each_index do |output_index|
+          @neurons.last[output_index].expected_output = output[output_index]
+        end
+        #Calculate error
+        @neurons.reverse.each do |layer|
+          layer.each {|neuron| neuron.calc_error}
+        end
+        #Change weight
+        @neurons.each do |layer|
+          layer.each {|neuron| neuron.change_weights }
+        end
+        #return net error
+        return @neurons.last.collect { |x| x.calc_error }
+      end
+
+      private
+      def print_weight
+        @neurons.each_index do |layer_index|
+          @neurons[layer_index].each_index do |neuron_index| 
+            puts "L #{layer_index} N #{neuron_index} W #{@neurons[layer_index][neuron_index].w.inspect}"
+          end
+        end
+      end
+
+    end
+
+
+    class Neuron
+
+      attr_accessor :state
+      attr_accessor :error
+      attr_accessor :expected_output
+      attr_accessor :w
+      attr_accessor :x
+
+      def initialize(childs, threshold, lambda, momentum)
+        #instance state
+        @w = nil
+        @childs = childs
+        @error = nil
+        @state = 0
+        @pushed = 0
+        @last_delta = 0
+        @x = 0
+        #Parameters
+        @lambda = lambda
+        @momentum = momentum
+        @threshold = threshold
+        #init w     
+        if(childs)
+          @w = []
+          childs.each { @w << init_weight }
+        end
+      end
+
+      def push(x)
+        @pushed += x
+      end
+
+      def propagate(input = nil)
+        if(input)
+          input = input.to_f
+          @x = input
+          @state = input
+          @childs.each_index do |child_index| 
+            @childs[child_index].push(input * @w[child_index])
+          end
+        else
+          @x = @pushed + @threshold
+          @pushed = 0
+          @state = Neuron.f(@x)
+          if @childs
+            @childs.each_index do |child_index| 
+              @childs[child_index].push(@state * @w[child_index])
+            end
+          end
+        end
+      end
+
+      def calc_error
+        if(!@childs && @expected_output)
+          @error = (@expected_output - @state)
+        elsif(@childs)
+          @error = 0
+          @childs.each_index do |child_index|
+            @error += (@childs[child_index].error * @w[child_index])
+          end
+        end
+      end
+
+      def change_weights
+        return if !@childs
+        @childs.each_index do |child_index |
+          delta = @lambda * @childs[child_index].error * (@state) * Neuron.f_prime(@childs[child_index].x)
+          @w[child_index] += (delta + @momentum * @last_delta)
+          @last_delta = delta
+        end
+      end
+
+      # Propagation function.
+      # By default: 
+      #   f(x) = 1/(1 + e^(-x))
+      # You can override it with any derivable function.
+      # A usually usefull one is: 
+      #   f(x) = x.
+      # If you override this function, you will have to override
+      # f_prime too.
+      def self.f(x)
+        return 1/(1+Math.exp(-1*(x)))
+      end
+
+      # Derived function of the propagation function (self.f)
+      # By default: 
+      #   f_prime(x) = f(x)(1- f(x))
+      # If you override f(x) with:
+      #   f(x) = x.
+      # Then you must override f_prime as:
+      #   f_prime(x) = 1
+      def self.f_prime(x)
+        val = f(x)
+        return val*(1-val)
+      end
+
+      private 
+      def init_weight
+        rand/4
+      end
+
+    end
+
+  end
+
+end