gene_genie 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f634d03e4f8bce6759898a2048719471aff1e0b
-  data.tar.gz: ff4ebfd191e17b182149935e1c544b51ceb0f46f
+  metadata.gz: ec1b4f9a01e789dfccd2c2ae244d88d024c2a1a1
+  data.tar.gz: 23d0def3b38095501ea43abf43eef535b5377cb0
 SHA512:
-  metadata.gz: a918e63beb5265d671b2e4b46b28358fb7e57727c590f9b37300eae2b0b57fc7d19abd30b90d0d0a5fea815c6a98bbf1ddb2e65e0b0a2f1e9915fbe88467fa21
-  data.tar.gz: 86719523c06e1fd0e35c242385a833c236745d3fe43973494d15cdab567bb43467f34bfda9211f5db1d6f1e00f820109c18f66139115e1252875357e0b2c5346
+  metadata.gz: 910757fa425a73ab14759642d5f28cbe0535390b0f8735439a38976941944c680de0cf7924164b19eb6f7dbea71c52f59394fe980b34c109ec89815165a1bc34
+  data.tar.gz: 727fe8801c9eaed03834693bc4d38601fb66b3ea9ec9bd39f423dddc7c99d39db7e5c3f0b35966020e6baf302bcf9601ea6aa23a9a9b23009676acd29fee316b

data/README.md

@@ -5,9 +5,9 @@
 # Gene Genie
 
 Hey, I wrote a genetic algorithm gem. Goals:
-    * Have fun
-    * Be easy and intuitive to use
-    * Be open to extension and experimentation
+* Have fun
+* Be easy and intuitive to use
+* Be open to extension and experimentation
 
 ## Installation
 
@@ -24,32 +24,38 @@ Or install it yourself as:
     $ gem install gene_genie
 
 ## Usage
-Basic usage is designed to be as simple as possible. You provide two things: an exemplar and an evaluator.
-An exemplar is a list of variables along with their possible range of values.
+Basic usage is designed to be as simple as possible. You provide two things: a template and an evaluator.
+A template is a list of variables along with their possible range of values.
 An evaluator implements a fitness method that returns a numeric value.
 The genetic algorithm will then search for the set of values that maximises the fitness.
 
 ```ruby
 require 'gene_genie'
 
-exemplar = {
+template = {
   range_of_ints: 1..10,
+<!---
   range_of_floats: 1.0..4.5,
-  set_of_items: [:apple, :banana, :orange],
+set_of_items: [:apple, :banana, :orange],
   ordered_set_of_items: [:one, :two, :three],
   circular_ordered_set: [:early_morning, :morning, :noon, :afternoon,
                          :evening, :midnight]
-  }
+-->
+}
 ```
 
 If you use the simple genie interface, the genetic algorithm will come up with a reasonable best-guesses for various algorthm parameters, but you can dive under the covers to give yourself more flexibility.
 * Population size
 * Gene pools
-* Initialisation
+* Initialization
 * Optimisation Criteria
 
 Custom objects for crossover, gene selection, etc.
 
+Note:
+Due to the non-deterministic nature of the algorithm, some of the tests don't
+pass every time at the moment! This is a known issue.
+
 ## Contributing
 
 1. Fork it ( https://github.com/MEHColeman/gene_genie/fork )

data/lib/gene_genie/gene.rb

@@ -5,11 +5,14 @@ module GeneGenie
   # @since 0.0.1
   class Gene
     def initialize(information, fitness_evaluator)
+      fail ArgumentError, 'information must be Array' unless information.kind_of? Array
+      fail ArgumentError, 'information must be Array of Hashes' unless information[0].kind_of? Hash
+
       @information = information
       @fitness_evaluator = fitness_evaluator
     end
 
-    def to_hash
+    def to_hashes
       @information
     end
 
@@ -19,20 +22,24 @@ module GeneGenie
 
     def mutate(mutator)
       @information = mutator.call @information
+      @fitness = nil
       self
     end
 
     def combine(other_gene)
-      other_gene_hash = other_gene.to_hash
-      new_hash = {}
-      @information.each do | k, v |
-        new_hash[k] = (rand > 0.5) ? @information[k] : other_gene_hash[k]
+      other_gene_hash = other_gene.to_hashes
+      new_information = @information.map.with_index do |part, index|
+        new_hash = {}
+        part.each do |k, v|
+          new_hash[k] = (rand > 0.5) ? v : other_gene_hash[index][k]
+        end
+        new_hash
       end
-      Gene.new(new_hash, @fitness_evaluator)
+      Gene.new(new_information, @fitness_evaluator)
     end
 
-    def <=>(gene)
-      fitness <=> gene.fitness
+    def <=>(other)
+      fitness <=> other.fitness
     end
   end
 end

data/lib/gene_genie/gene_factory.rb

@@ -15,21 +15,25 @@ module GeneGenie
     def create(size = 1)
       genes = []
       size.times do
-        hash = create_hash_from_template
-        genes << Gene.new(hash, @fitness_evaluator)
+        genes << create_gene_from_template
       end
-
       genes
     end
 
     private
 
-    def create_hash_from_template
+    def create_gene_from_template
+      gene_array = @template.map do |part|
+        create_hash_from_template_part(part)
+      end
+      Gene.new(gene_array, @fitness_evaluator)
+    end
+
+    def create_hash_from_template_part(part)
       new_hash = {}
-      @template.each do |k, v|
+      part.each do |k, v|
         new_hash[k] = rand(v)
       end
-
       new_hash
     end
   end

data/lib/gene_genie/gene_pool.rb

@@ -1,13 +1,19 @@
 require_relative 'gene_factory'
 require_relative 'mutator/simple_gene_mutator'
 require_relative 'mutator/null_mutator'
+require_relative 'selector/proportional_selector'
+require_relative 'template_evaluator'
 
 module GeneGenie
   class GenePool
-    def initialize(template, fitness_evaluator, gene_factory,
-                   mutator = NullMutator.new)
-      unless template.instance_of? Hash
-        fail ArgumentError, 'template must be a hash of ranges'
+    def initialize(template:,
+                   fitness_evaluator:,
+                   gene_factory:,
+                   size: 10,
+                   mutator: NullMutator.new,
+                   selector: ProportionalSelector.new)
+      unless (template.instance_of? Array) && (template[0].instance_of? Hash)
+        fail ArgumentError, 'template must be an array of hashes of ranges'
       end
       unless fitness_evaluator.respond_to?(:fitness)
         fail ArgumentError, 'fitness_evaluator must respond to fitness'
@@ -16,19 +22,32 @@ module GeneGenie
       @template = template
       @fitness_evaluator = fitness_evaluator
       @mutator = mutator
-
-      #size = template_evaluator.recommended_size
-      size ||= 10
+      @selector = selector
       @pool = gene_factory.create(size)
+      @generation = 0
+      @listeners = []
     end
 
     # build a GenePool with a reasonable set of defaults.
     # You only need to specily the minimum no. of parameters
     def self.build(template, fitness_evaluator)
+      unless (template.instance_of? Array) && (template[0].instance_of? Hash)
+        fail ArgumentError, 'template must be an array of hashes of ranges'
+      end
       gene_mutator = SimpleGeneMutator.new(template)
       gene_factory = GeneFactory.new(template, fitness_evaluator)
-      GenePool.new(template, fitness_evaluator, gene_factory,
-                   gene_mutator)
+
+      template_evaluator = TemplateEvaluator.new(template)
+      size = template_evaluator.recommended_size
+      GenePool.new(template: template,
+                   fitness_evaluator: fitness_evaluator,
+                   gene_factory: gene_factory,
+                   size: size,
+                   mutator: gene_mutator)
+    end
+
+    def register_listener(listener)
+      @listeners << listener
     end
 
     def size
@@ -36,46 +55,78 @@ module GeneGenie
     end
 
     def best
-      @pool.max_by { |gene| gene.fitness }
+      @pool.max_by(&:fitness)
+    end
+
+    def best_fitness
+      best.fitness
+    end
+
+    def best_ever
+      @best_ever ||= best
     end
 
     def evolve
       old_best_fitness = best.fitness
       new_pool = []
       size.times do
-        first_gene, second_gene = select_genes
-        new_gene = combine_genes(first_gene, second_gene)
-        new_pool << new_gene.mutate(@mutator)
+        new_pool << select_genes_combine_and_mutate
       end
       @pool = new_pool
+      check_best_ever
+      @generation += 1
+
+      @listeners.each { |l| l.call(self) }
+
       best.fitness > old_best_fitness
     end
 
+    def generation
+      @generation
+    end
+
+    def average_fitness
+      total_fitness / @pool.size
+    end
+
+    def total_fitness
+      fitness_values.reduce(:+)
+    end
+
+    def genes
+      @pool
+    end
+
+    def worst
+      @pool.min_by(&:fitness)
+    end
+
+    def worst_fitness
+      worst.fitness
+    end
+
     private
-    # a very simple selection - pick by sorted order
-    # pick two different genes
+
+    def check_best_ever
+      @best_ever = best if best.fitness > best_ever.fitness
+    end
+
     def select_genes
-      selectees = @pool.sort.reverse
-      first, second = nil, nil
-      probability =  [(( 1.0/size ) * 3), 0.8].min
-      while !first || !second do
-        selectees.each do |s|
-          if rand < probability
-            selectees.delete(s)
-            if !first
-              first = s
-              break
-            else
-              second = s
-            end
-          end
-        end
-      end
-      [first, second]
+      @selector.call(self)
     end
 
     def combine_genes(first, second)
       first.combine(second)
     end
+
+    def fitness_values
+      @pool.map(&:fitness)
+    end
+
+    def select_genes_combine_and_mutate
+      first_gene, second_gene = select_genes
+      new_gene = combine_genes(first_gene, second_gene)
+      new_gene.mutate(@mutator)
+    end
   end
 end

data/lib/gene_genie/genie.rb

@@ -3,13 +3,11 @@ require_relative 'gene_pool'
 # Namespace for GeneGenie genetic algorithm optimisation gem
 # @since 0.0.1
 module GeneGenie
-
   # Top level, basic interface for GA optimisation.
   # Genie will attempt to optimise based on best-guess defaults if none are
   # provided
   # @since 0.0.1
   class Genie
-
     DEFAULT_NO_OF_GENERATIONS = 50
     IMPROVEMENT_THRESHOLD = 0.1 # %
 
@@ -33,34 +31,33 @@ module GeneGenie
       end
 
       @best_fitness = @fitness_evaluator.fitness(best)
-
       @best_fitness > previous_best
     end
     alias_method :optimize, :optimise
 
     def best
-      @gene_pool.best.to_hash
+      @gene_pool.best_ever.to_hashes
     end
 
     def best_fitness
-      @gene_pool.best.fitness
+      @gene_pool.best_ever.fitness
     end
 
     private
+
     def evolve_n_times(n)
       n.times { @gene_pool.evolve }
     end
 
     def optimise_by_strategy
       DEFAULT_NO_OF_GENERATIONS.times do
-        current_fitness = best_fitness
         @gene_pool.evolve
       end
       DEFAULT_NO_OF_GENERATIONS.times do
         current_fitness = best_fitness
         @gene_pool.evolve
         break if best_fitness < current_fitness *
-          (1 + (IMPROVEMENT_THRESHOLD / 100 ))
+          (1 + (IMPROVEMENT_THRESHOLD / 100))
       end
     end
   end

data/lib/gene_genie/listener/logging_listener.rb

@@ -0,0 +1,18 @@
+module GeneGenie
+  module Listener
+    class LoggingListener
+      def initialize(logger)
+        @logger = logger
+        @last_time = Time.now
+      end
+
+      def call(pool)
+        @logger.info "Pool Generation ##{pool.generation}"
+        @logger.info "Average Fitness: #{pool.average_fitness}"
+        @logger.info "Best Fitness:    #{pool.best_fitness}"
+        @logger.info "Time elapsed:    #{Time.now - @last_time}"
+        @last_time = Time.now
+      end
+    end
+  end
+end

data/lib/gene_genie/mutator/simple_gene_mutator.rb

@@ -9,13 +9,15 @@ module GeneGenie
       @mutation_rate = mutation_rate
     end
 
-    def call(hash)
-      hash.each do |k, v|
-        if rand < @mutation_rate
-          hash[k] = rand(@template[k])
+    def call(genes)
+      genes.each_with_index do |hash, index|
+        hash.each do |k, v|
+          if rand < @mutation_rate
+            hash[k] = rand(@template[index][k])
+          end
         end
       end
-      hash
+      genes
     end
   end
 end

data/lib/gene_genie/selector/coin_flip_selector.rb

@@ -0,0 +1,31 @@
+module GeneGenie
+  # A simple gene selection algorithm.
+  # Genes are ordered by score.
+  # Effectively, a loaded coin is tossed. If it's heads, the top gene is
+  # selected, otherwise, continue down the list until a head comes up.
+  # The coin is loaded, so that there is a reasonable spread throughout the
+  # gene population, but the better the gene, the more likely it is to turn up.
+  class CoinFlipSelector
+    def call(pool)
+      # a very simple selection - pick by sorted order
+      # pick two different genes
+      selectees = pool.genes.sort.reverse
+      first, second = nil, nil
+      probability = [((1.0 / pool.size) * 3), 0.8].min
+      while !first || !second do
+        selectees.each do |s|
+          if rand < probability
+            selectees.delete(s)
+            if !first
+              first = s
+              break
+            else
+              second = s
+            end
+          end
+        end
+      end
+      [first, second]
+    end
+  end
+end

data/lib/gene_genie/selector/proportional_selector.rb

@@ -0,0 +1,29 @@
+module GeneGenie
+  # A proportional gene selection algorithm.
+  # Genes are picked in proportion to thier normalised score.
+  class ProportionalSelector
+    def call(pool)
+      [pick_one(pool), pick_one(pool)]
+    end
+
+    private
+
+    def pick_one(pool)
+      proportional_index = rand(total_normalised_fitness(pool))
+      total = 0
+      pool.genes.each_with_index do |gene, index|
+        total += normalised_fitness(gene,pool)
+        return gene if total >= proportional_index || index == (pool.size - 1)
+      end
+    end
+
+    def total_normalised_fitness(pool)
+      pool.genes.map { |gene| normalised_fitness(gene,pool) }.reduce(:+)
+    end
+
+    def normalised_fitness(gene,pool)
+      gene.fitness -
+        pool.worst_fitness + 1
+    end
+  end
+end

data/lib/gene_genie/template_evaluator.rb

@@ -0,0 +1,27 @@
+module GeneGenie
+  # A Template Evaluator provides certain analysis and useful information
+  # about templates
+  # @since 0.0.2
+  class TemplateEvaluator
+    def initialize(template)
+      @template = template
+    end
+
+    def permutations
+      @permutations ||= @template.map { |hash|
+        hash.map { |_, v| v.size }.reduce(:*)
+      }.reduce(:*)
+    end
+
+    # returns a minimum of 10 unless the total number of permutations
+    # is below that
+    # otherwise, returns 1/1000th of the number of permutations up to a
+    # maximum of 1000
+    def recommended_size
+      [
+        [(permutations / 100_000), 5000].min,
+        [10, permutations].min,
+      ].max
+    end
+  end
+end

data/lib/gene_genie/version.rb

@@ -1,3 +1,3 @@
 module GeneGenie
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gene_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Mark Coleman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-28 00:00:00.000000000 Z
+date: 2016-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,8 +66,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: JUST A PROTOTYPE WORK IN PROGRESS! Optimise anything that responds to
-  'fitness' and takes a hash
+description: Optimise anything that responds to 'fitness' and takes a hash
 email:
 - m@rkcoleman.co.uk
 executables: []
@@ -80,8 +79,12 @@ files:
 - lib/gene_genie/gene_factory.rb
 - lib/gene_genie/gene_pool.rb
 - lib/gene_genie/genie.rb
+- lib/gene_genie/listener/logging_listener.rb
 - lib/gene_genie/mutator/null_mutator.rb
 - lib/gene_genie/mutator/simple_gene_mutator.rb
+- lib/gene_genie/selector/coin_flip_selector.rb
+- lib/gene_genie/selector/proportional_selector.rb
+- lib/gene_genie/template_evaluator.rb
 - lib/gene_genie/version.rb
 homepage: https://github.com/MEHColeman/gene_genie
 licenses:
@@ -95,7 +98,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -103,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Genetic algorithm optimisation gem