evolvable 0.1.3 → 1.0.0

data/bin/console

@@ -3,48 +3,12 @@
 require 'bundler/setup'
 require 'evolvable'
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-
-class BandMember
-  include Evolvable
-
-  SYNTHS = [:synth_1, :synth_2]
-
-  # SYNTH_OPTIONS = { synth_1: [[:cutoff, (1..100).to_a],
-                              # [:reverb: (1..5).to_a]],
-                    # synth_2: []}
-
-  SAMPLES = [:sample_1, :sample_2]
-
-  # SAMPLE_OPTIONS = { sample_1: [[:cutoff, (1..100).to_a],
-                                # [:reverb: (1..5).to_a]],
-                     # sample_2: []}
-
-  def self.evolvable_gene_pool
-    
-  end
-
-  def base.evolvable_random_genes(count = nil)
-    gene_pool = evolvable_gene_pool_cache
-    count ||= evolvable_genes_count
-    gene_pool = gene_pool.sample(count) if count < gene_pool.size
-    genes = {}
-    gene_pool.each { |name, potentials| genes[name] = potentials.sample }
-    genes
-  end
-
-  def fitness
-    0
-  end
-end
-
+require './examples/evolvable_string'
 
+puts "To get started, try this:\n\n" \
+     " population = EvolvableString.new_population\n" \
+     " population.mutation.probability = 0.8\n" \
+     " population.evolve(goal_value: EvolvableString::TARGET_STRING.length)\n\n"
 
 require 'irb'
 IRB.start(__FILE__)

data/evolvable.gemspec

@@ -29,4 +29,3 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'byebug', '~> 11.0'
   spec.add_development_dependency 'rubocop', '~> 0.64.0'
 end
-

data/examples/evolvable_string.rb

@@ -0,0 +1,32 @@
+require './examples/evolvable_string/char_gene'
+
+class EvolvableString
+  include Evolvable
+
+  TARGET_STRING = 'supercalifragilisticexpialidocious'
+
+  def self.gene_space
+    { char_genes: { type: 'CharGene', count: TARGET_STRING.length } }
+  end
+
+  def self.before_evolution(population)
+    best_instance = population.best_instance
+    puts "#{best_instance} | #{best_instance.value} matches | Generation #{population.evolutions_count}"
+  end
+
+  def to_s
+    find_genes(:char_genes).join
+  end
+
+  def value
+    @value ||= compute_value
+  end
+
+  def compute_value
+    value = 0
+    find_genes(:char_genes).each_with_index do |gene, index|
+      value += 1 if gene.to_s == TARGET_STRING[index]
+    end
+    value
+  end
+end

data/examples/evolvable_string/char_gene.rb

@@ -0,0 +1,9 @@
+class CharGene
+  include Evolvable::Gene
+
+  CHARS = ('a'..'z').to_a
+
+  def to_s
+    @to_s ||= CHARS.sample
+  end
+end

data/lib/evolvable.rb

@@ -1,86 +1,73 @@
 # frozen_string_literal: true
 
 require 'forwardable'
-require 'logger'
-
 require 'evolvable/version'
-require 'evolvable/population'
-require 'evolvable/crossover'
+require 'evolvable/error/undefined_method'
+require 'evolvable/gene'
+require 'evolvable/gene_space'
+require 'evolvable/goal'
+require 'evolvable/goal/equalize'
+require 'evolvable/goal/maximize'
+require 'evolvable/goal/minimize'
+require 'evolvable/evaluation'
+require 'evolvable/evolution'
+require 'evolvable/selection'
+require 'evolvable/gene_crossover'
+require 'evolvable/point_crossover'
+require 'evolvable/uniform_crossover'
 require 'evolvable/mutation'
-require 'evolvable/helper_methods'
-require 'evolvable/hooks'
-require 'evolvable/errors/not_implemented'
+require 'evolvable/population'
 
 module Evolvable
-  extend HelperMethods
-
   def self.included(base)
-    base.extend Hooks
-
-    def base.evolvable_gene_pool
-      raise Errors::NotImplemented, __method__
-    end
-
-    def base.evolvable_genes_count
-      evolvable_gene_pool_size
-    end
-
-    def base.evolvable_evaluate!(_objects); end
-
-    def base.evolvable_population_attrs
-      {}
+    def base.new_population(keyword_args = {})
+      keyword_args[:evolvable_class] = self
+      Population.new(**keyword_args)
     end
 
-    def base.evolvable_population(args = {})
-      clear_evolvable_gene_pool_caches
-      args = evolvable_population_attrs.merge!(args)
-      args[:evolvable_class] = self
-      Population.new(args)
-    end
-
-    def base.evolvable_initialize(genes, population, _object_index)
-      evolvable = new
-      evolvable.genes = genes
+    def base.new_instance(population: nil, genes: [], population_index: nil)
+      evolvable = initialize_instance
       evolvable.population = population
+      evolvable.genes = genes
+      evolvable.population_index = population_index
+      evolvable.initialize_instance
       evolvable
     end
 
-    def base.evolvable_gene_pool_cache
-      @evolvable_gene_pool_cache ||= evolvable_gene_pool
+    def base.initialize_instance
+      new
     end
 
-    def base.evolvable_gene_pool_size
-      @evolvable_gene_pool_size ||= evolvable_gene_pool_cache.size
+    def base.new_gene_space
+      GeneSpace.build(gene_space)
     end
 
-    def base.clear_evolvable_gene_pool_caches
-      @evolvable_gene_pool_cache = nil
-      @evolvable_gene_pool_size = nil
+    def base.gene_space
+      {}
     end
 
-    def base.evolvable_random_genes(count = nil)
-      gene_pool = evolvable_gene_pool_cache
-      count ||= evolvable_genes_count
-      gene_pool = gene_pool.sample(count) if count < gene_pool.size
-      genes = {}
-      gene_pool.each { |name, potentials| genes[name] = potentials.sample }
-      genes
-    end
-  end
+    def base.before_evaluation(population); end
+
+    def base.before_evolution(population); end
 
-  def self.logger
-    @logger ||= Logger.new(STDOUT)
+    def base.after_evolution(population); end
   end
 
-  attr_accessor :genes,
-                :population
+  def initialize_instance; end
+
+  attr_accessor :population,
+                :genes,
+                :population_index
+
+  def value
+    raise Errors::UndefinedMethod, "#{self.class.name}##{__method__}"
+  end
 
-  def fitness
-    raise Errors::NotImplemented, __method__
+  def find_gene(key)
+    @genes.detect { |g| g.key == key }
   end
 
-  def evolvable_progress(info = nil)
-    info ||= "Generation: #{population.generation_count} | Fitness: #{fitness}"
-    Evolvable.logger.info(info)
+  def find_genes(key)
+    @genes.select { |g| g.key == key }
   end
 end

data/lib/evolvable/error/undefined_method.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Evolvable
+  module Errors
+    class UndefinedMethod < StandardError; end
+  end
+end

data/lib/evolvable/evaluation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Evolvable
+  class Evaluation
+    GOALS = { maximize: Evolvable::Goal::Maximize.new,
+              minimize: Evolvable::Goal::Minimize.new,
+              equalize: Evolvable::Goal::Equalize.new }.freeze
+
+    def initialize(goal = :maximize)
+      @goal = normalize_goal(goal)
+    end
+
+    attr_accessor :goal
+
+    def call(population)
+      population.instances.sort_by! { |instance| goal.evaluate(instance) }
+    end
+
+    def best_instance(population)
+      population.instances.max_by { |instance| goal.evaluate(instance) }
+    end
+
+    def met_goal?(population)
+      goal.met?(population.instances.last)
+    end
+
+    private
+
+    def normalize_goal(goal_arg)
+      case goal_arg
+      when Symbol
+        goal_from_symbol(goal_arg)
+      when Hash
+        goal_from_hash(goal_arg)
+      else
+        goal
+      end
+    end
+
+    def goal_from_symbol(goal_arg)
+      GOALS[goal_arg]
+    end
+
+    def goal_from_hash(goal_arg)
+      goal_type, value = goal_arg.first
+      goal = GOALS[goal_type]
+      goal.value = value
+      goal
+    end
+  end
+end

data/lib/evolvable/evolution.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Evolvable
+  class Evolution
+    extend Forwardable
+
+    def initialize(selection: Selection.new,
+                   crossover: GeneCrossover.new,
+                   mutation: Mutation.new)
+      @selection = selection
+      @crossover = crossover
+      @mutation = mutation
+    end
+
+    attr_accessor :selection,
+                  :crossover,
+                  :mutation
+
+    def call(population)
+      @selection.call(population)
+      @crossover.call(population)
+      @mutation.call(population)
+      population
+    end
+  end
+end

data/lib/evolvable/gene.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Evolvable
+  module Gene
+    def self.included(base)
+      def base.crossover(gene_a, gene_b)
+        [gene_a, gene_b].sample
+      end
+    end
+
+    attr_accessor :instance, :key
+  end
+end

data/lib/evolvable/gene_crossover.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Evolvable
+  class GeneCrossover
+    def call(population)
+      population.instances = initialize_offspring(population)
+      population
+    end
+
+    private
+
+    def initialize_offspring(population)
+      parent_genes = population.instances.map!(&:genes)
+      parent_gene_couples = parent_genes.combination(2).cycle
+      Array.new(population.size) do |index|
+        genes_1, genes_2 = parent_gene_couples.next
+        genes = crossover_genes(genes_1, genes_2)
+        population.new_instance(genes: genes, population_index: index)
+      end
+    end
+
+    def crossover_genes(genes_1, genes_2)
+      genes_1.zip(genes_2).map! do |gene_a, gene_b|
+        gene_a.class.crossover(gene_a, gene_b)
+      end
+    end
+  end
+end

data/lib/evolvable/gene_space.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Evolvable
+  class GeneSpace
+    def self.build(config)
+      return config if config.respond_to?(:new_genes)
+
+      new(config: config)
+    end
+
+    def initialize(config: {})
+      @config = normalize_config(config)
+    end
+
+    attr_reader :config
+
+    def new_genes
+      genes = []
+      config.each do |gene_key, gene_config|
+        (gene_config[:count] || 1).times do
+          gene = gene_config[:class].new
+          gene.key = gene_key
+          genes << gene
+        end
+      end
+      genes
+    end
+
+    private
+
+    def normalize_config(config)
+      config.each do |_gene_key, gene_config|
+        gene_config[:class] = Kernel.const_get(gene_config[:type]) if gene_config[:type]
+      end
+    end
+  end
+end

data/lib/evolvable/goal.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Evolvable
+  module Goal
+    def initialize(value: nil)
+      @value = value if value
+    end
+
+    attr_accessor :value
+
+    def evaluate(_instance)
+      raise Errors::UndefinedMethod, "#{self.class.name}##{__method__}"
+    end
+
+    def met?(_instance)
+      raise Errors::UndefinedMethod, "#{self.class.name}##{__method__}"
+    end
+  end
+end

data/lib/evolvable/goal/equalize.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Evolvable::Goal
+  class Equalize
+    include Evolvable::Goal
+
+    def value
+      @value ||= 0
+    end
+
+    def evaluate(instance)
+      -(instance.value - value).abs
+    end
+
+    def met?(instance)
+      instance.value == value
+    end
+  end
+end