rubyneat 0.3.5.alpha.6 → 0.4.0.alpha.3

data/Rakefile

@@ -25,6 +25,7 @@ Jeweler::Tasks.new do |gem|
   gem.license = "MIT"
   gem.summary = %Q{RubyNEAT NeuralEvolution of Augmenting Topologies}
   gem.version = s_version
+  gem.required_ruby_version = '>= 2.0'
   gem.description = %Q{
   RubyNEAT -- Neural Evolution of Augmenting Topologies for Ruby.
   By way of an enhanced form of Genetic Algorithms -- the NEAT algorithm,
@@ -42,15 +43,15 @@ Jeweler::Tasks.new do |gem|
   because it's also extensible and modular. See http://rubyneat.com for the
   details.
   }
-  gem.email = "fred@lrcsoft.com"
+  gem.email = "lordalveric@yahoo.com"
   gem.authors = ["Fred Mitchell"]
   # dependencies defined in Gemfile
 
   # Exclude the Neural Docs directory
   gem.files.exclude 'Neural_Docs/*', 'foo/**/*', 'rdoc/*',
                     '.idea/**/*', '.idea/**/.*', '.yardoc/**/*',
-                    'public/**/*', 'neater/**/*', 'doc/**/*',
-                    'public/**/.*', 'Guardfile'
+                    'app/**/*', 'neater/**/*', 'doc/**/*',
+                    'app/**/.*', 'Guardfile'
 end
 Jeweler::RubygemsDotOrgTasks.new
 

data/lib/rubyneat.rb

@@ -2,7 +2,8 @@
 =RubyNEAT -- Neural Evolution of Augmenting Topologies
 =end
 
-require 'rubyneat/rubyneat'
-require 'rubyneat/graph'
-require 'rubyneat/dsl'
+require_relative 'rubyneat/rubyneat'
+require_relative 'rubyneat/graph'
+require_relative 'rubyneat/dsl'
+require_relative 'rubyneat/reporting'
 require 'set'

data/lib/rubyneat/cli.rb

@@ -4,5 +4,7 @@ require 'semver'
 NEATER = File.join [Dir.pwd, "neater"]
 NEATGLOB = NEATER + '/*_neat.rb'
 
-require 'rubyneat/cli/main'
+require_relative 'cli/generate'
+require_relative 'cli/console'
+require_relative 'cli/main'
 require 'rubyneat'

data/lib/rubyneat/cli/console.rb

@@ -0,0 +1,18 @@
+require 'irb'
+require 'irb/completion'
+
+module RubyNEAT
+  module Cli
+    class Console < Thor
+      class << self
+        def default_command
+          # TODO: maybe dynamically set it in Rakefile and then retrieve from ENV?
+          # require "#{$calling_gem_name}"
+          ARGV.clear
+          IRB.start
+        end
+        alias_method :default_task, :default_command
+      end
+    end
+  end
+end

data/lib/rubyneat/cli/main.rb

@@ -1,4 +1,4 @@
-require 'rubyneat/cli/generate'
+require 'rubyneat/cli'
 
 module RubyNEAT
   module Cli
@@ -43,10 +43,7 @@ module RubyNEAT
       end
 
       desc 'console', 'Run RubyNEAT interactively'
-      def console
-        #TODO: Finish the console
-        puts "Not Implemented Yet."
-      end
+      subcommand 'console', Console
 
       desc 'run <neater> [<neater> <neater> ...] [OPTS]', 'Run a Neater'
       option :log, type: :string, banner: 'info|warn|debug|error'
@@ -57,6 +54,7 @@ module RubyNEAT
         neaters.map do |neater|
           "#{neater}_neat.rb"
         end.each do |file|
+          NEAT::controller.neater = file
           load file
         end
       end

data/lib/rubyneat/cli/templates/generate/.irbrc.tt

@@ -0,0 +1,3 @@
+require 'bond'
+Bond.start
+# TODO: incorporate this in the generator

data/lib/rubyneat/critter.rb

@@ -222,7 +222,7 @@ module NEAT
       end
 
       #= Gene Specification
-      # The Gene specifices a singlular input and
+      # The Gene specifies a singular input and
       # output neuron, which represents a connection
       # between them, along with the weight of that
       # connection, which may be positive, negative, or zero.
@@ -236,7 +236,7 @@ module NEAT
         attr_accessor :innovation
 
         # input neuron's name (where our output goes)
-        # ouptut neuron's name (neuron to be queried)
+        # output neuron's name (neuron to be queried)
         attr_accessor :in_neuron, :out_neuron
 
         # weight of the connection

data/lib/rubyneat/default_neat.rb

@@ -1,4 +1,4 @@
-require 'rubyneat/dsl'
+require_relative 'dsl'
 =begin rdoc
 = Default Parameters for RubyNEAT
 Here all default parameters are defined.

data/lib/rubyneat/dsl.rb

@@ -1,4 +1,4 @@
-require 'rubyneat/rubyneat'
+require_relative 'rubyneat'
 
 =begin rdoc
 = RubyNEAT DSL
@@ -42,11 +42,11 @@ module NEAT
       # to the input nodes. In the case of hash, the keys in the hash
       # shall correspond to the names given to the input neurons.
       def query(&block)
-        NEAT::controller.query_func = block
+        NEAT::controller.query_func_add  &block
       end
 
       def recurrence(&block)
-        NEAT::controller.recurrence_func = block
+        NEAT::controller.recurrence_func_set &block
       end
 
       # fitness function calls the block with 2 vectors or two hashes, input and output
@@ -54,26 +54,27 @@ module NEAT
       # number that can be used to index what the actual output should be.
       # |vin, vout, seq|
       def fitness(&block)
-        NEAT::controller.fitness_func = block
+        NEAT::controller.fitness_func_set &block
       end
 
       # Fitness ordering -- given 2 fitness numbers,
       # use the <=> to compare them (or the equivalent, following
       # the +1, 0, -1 that is in the sense of <=>)
       def compare(&block)
-        NEAT::controller.compare_func = block
+        NEAT::controller.compare_func_set &block
       end
 
       # Calculation to add the cost to the fitness, resulting in a fitness
       # that incorporates the cost for sorting purposes.
       def cost(&block)
-        NEAT::controller.cost_func = block
+        NEAT::controller.cost_func_set &block
       end
 
       # Stop the progression once the fitness criteria is reached
-      # for the most fit critter
+      # for the most fit critter. We allow more than one stop
+      # function here.
       def stop_on_fitness(&block)
-        NEAT::controller.stop_on_fit_func = block
+        NEAT::controller.stop_on_fit_func_add &block
       end
 
       # Helper function to
@@ -101,12 +102,12 @@ module NEAT
 
     # Report on evaluations
     def report(&block)
-      NEAT::controller.report_hook = block
+      NEAT::controller.report_add &block
     end
 
     # Run the engine. The block is called on each generation.
     def run_engine(&block)
-      NEAT::controller.end_run_func = block
+      NEAT::controller.end_run_add &block
       NEAT::controller.run
     end
 
@@ -125,6 +126,6 @@ module NEAT
   end
 end
 
-# FIXME: This needs to better specified for cases in which there may be multiple
-# Controllers.
+# FIXME: This needs to better specified for cases in which
+# FIXME: there may be multiple Controllers.
 require 'rubyneat/default_neat'

data/lib/rubyneat/evaluator.rb

@@ -1,4 +1,4 @@
-require 'rubyneat/rubyneat'
+require_relative 'rubyneat'
 
 module NEAT
   #= Evaluator evaluates phenotype of critter for fitness, novelty, etc.
@@ -22,10 +22,14 @@ module NEAT
     # FIXME: this should not really have to deal with an error.
     # FIXME: the error should be handled upstream from here.
     def evaluate!(critter)
-      vin = @controller.query_func.(@controller.seq_num)
+      vin = @controller.query_func_hook(@controller.seq_num)
       @crit_hist[critter] = {} unless @crit_hist.member? critter
       begin
-        vout = critter.phenotype.stimulate *vin, &@controller.recurrence_func
+        vout = unless @controller.recurrence_func_none?
+                 critter.phenotype.stimulate *vin, &@controller.recurrence_func_hook_itself
+               else
+                 critter.phenotype.stimulate *vin
+               end
         log.debug "Critter #{critter.name}: vin=#{vin}. vout=#{vout}"
         @crit_hist[critter][@controller.seq_num] = [vin, vout]
       rescue Exception => e
@@ -38,10 +42,10 @@ module NEAT
     # Note that if cost_func is set, we call that to integrate the cost to
     # the fitness average fitness calculated for the fitness vector.
     def analyze_for_fitness!(critter)
-      fitvec = @crit_hist[critter].map{|seq, vio| @controller.fitness_func.(vio[0], vio[1], seq) }
+      fitvec = @crit_hist[critter].map{|seq, vio| @controller.fitness_func_hook(vio[0], vio[1], seq) }
       # Average the fitness vector to get a scalar fitness.
-      critter.fitness = unless @controller.cost_func.nil?
-                          @controller.cost_func.(fitvec, critter.genotype.fitness_cost)
+      critter.fitness = unless @controller.cost_func_none?
+                          @controller.cost_func_hook(fitvec, critter.genotype.fitness_cost)
                         else
                           fitvec.reduce {|a,r| a+r} / fitvec.size.to_f + critter.genotype.fitness_cost
                         end

data/lib/rubyneat/evolver.rb

@@ -1,5 +1,6 @@
 require 'rubyneat'
 require 'distribution'
+
 module NEAT
   #= Evolver -- Basis of all evolvers.
   # All evolvers shall derive from this basic evolver (or this one can be
@@ -83,7 +84,7 @@ module NEAT
       @npop.species.each do |k, sp|
         sp.sort!{|c1, c2|
           unless @controller.compare_func.nil?
-            @controller.compare_func.(c1.fitness, c2.fitness)
+            @controller.compare_func_hook(c1.fitness, c2.fitness)
           else
             c1.fitness <=> c2.fitness
           end

data/lib/rubyneat/expressor.rb

@@ -1,4 +1,4 @@
-require 'rubyneat/rubyneat'
+require_relative 'rubyneat'
 require 'pp'
 
 module NEAT

data/lib/rubyneat/neuron.rb

@@ -1,5 +1,5 @@
 require 'rubyneat'
-require 'rubyneat/graph'
+require_relative 'graph'
 
 =begin rdoc
 = Neuron Types

data/lib/rubyneat/population.rb

@@ -1,4 +1,4 @@
-require 'rubyneat/rubyneat'
+require_relative 'rubyneat'
 
 module NEAT
   #= Population of NEAT Critters.
@@ -8,6 +8,11 @@ module NEAT
   # expression, all the phenotypes shall be created individually.
   #
   class Population < NeatOb
+    # Generation number of the Population.
+    # Any newly-derivied population is always one greater
+    # than the former. Needs to be set, invalid if nil.
+    attr_neat :generation, default: nil
+
     # Ordered list or hash of input neuron classes 
     # (all critters generated here shall have this)
     attr_accessor :input_neurons
@@ -46,6 +51,7 @@ module NEAT
       @critters = (0 ... c.parms.start_population_size || c.parms.population_size).map do
         Critter.new(self)
       end
+
       block.(self) unless block.nil?
     end
 
@@ -160,22 +166,12 @@ module NEAT
 
     end
 
-    #== Generate a report on the state of this population.
-    #
-    def report
-      {
-          fitness:         report_fitness,
-          fitness_species: report_fitness_species,
-          best_critter:    report_best_fit,
-          worst_critter:   report_worst_fit,
-      }
-    end
-
     # The "best critter" is the critter with the lowest (closet to zero)
     # fitness rating.
+    # TODO: DRY up best_critter and worst_critter
     def best_critter
-      unless @controller.compare_func.nil?
-        @critters.min {|a, b| @controller.compare_func.(a.fitness, b.fitness) }
+      unless @controller.compare_func.empty?
+        @critters.min {|a, b| @controller.compare_func_hook(a.fitness, b.fitness) }
       else
         @critters.min {|a, b| a.fitness <=> b.fitness}
       end
@@ -184,8 +180,8 @@ module NEAT
     # The "worst critter" is the critter with the highest (away from zero)
     # fitness rating.
     def worst_critter
-      unless @controller.compare_func.nil?
-        @critters.max {|a, b| @controller.compare_func.(a.fitness, b.fitness) }
+      unless @controller.compare_func.empty?
+        @critters.max {|a, b| @controller.compare_func_hook(a.fitness, b.fitness) }
       else
         @critters.max {|a, b| a.fitness <=> b.fitness}
       end
@@ -194,34 +190,5 @@ module NEAT
     def dump_s
       to_s + "\npopulation:\n" + @critters.map{|crit| crit.dump_s }.join("\n")
     end
-
-    protected
-    # report on many fitness metrics
-    def report_fitness
-      {
-          overall: @critters.map{|critter| critter.fitness}.reduce{|m, f| m + f} / @critters.size,
-          best: best_critter.fitness,
-          worst: worst_critter.fitness,
-      }
-    end
-
-    # report on the best and worst species
-    def report_fitness_species
-      {
-        best: nil,
-        worst: nil,
-      }
-    end
-
-    # Find the best fit critter
-    def report_best_fit
-      best_critter.phenotype.code
-    end
-
-    # Find the worst fit critter
-    def report_worst_fit
-      worst_critter.phenotype.code
-    end
-
   end
 end

data/lib/rubyneat/reporting.rb

@@ -0,0 +1,113 @@
+=begin rdoc
+=RubyNEAT Reporting
+Here we factor out all reporting-related functionality across the entire
+RubyNEAT system to this one place, because reporting is not directly related
+to RubyNEAT functionality. As such, it will make it much easier for forkers
+to slim down RubyNEAT for some specific application where reporting may not
+be so needed.
+
+As far as plugins go, we could insist that all plugins do their own reporting.
+However, we wish to insulate such activities from the internal structures of
+the Population, Critters, etc. simply they are subject to change. This affords
+us the one place to look to update the API in response to deep structural changes.
+=end
+
+module NEAT
+  #= Population Reporting
+  # The tangenial reporting needs for the Population module
+  # are extracted here simply because they do not directly relate
+  # to the operations of the Population.
+  class Population
+    # report on many fitness metrics
+    def report_fitness
+      {
+          overall: critters.map{|critter| critter.fitness}.reduce{|m, f| m + f} / critters.size,
+          best: best_critter.fitness,
+          worst: worst_critter.fitness,
+      }
+    end
+
+    # report on the best and worst species
+    def report_fitness_species
+      {
+          best: nil,
+          worst: nil,
+      }
+    end
+
+    # Find the best fit critter
+    def report_best_fit
+      best_critter.phenotype.code
+    end
+
+    # Find the worst fit critter
+    def report_worst_fit
+      worst_critter.phenotype.code
+    end
+
+    # Create a hash of critter names and fitness values
+    def report_critters
+      critters.inject({}){|memo, critter| memo[critter.name] = critter.fitness; memo }
+    end
+
+    #== Generate a report on the state of this population.
+    #
+    def report
+      [
+          self,
+          {
+              generation:      generation,
+              fitness:         report_fitness,
+              fitness_species: report_fitness_species,
+              best_critter:    report_best_fit,
+              worst_critter:   report_worst_fit,
+              all_critters:    report_critters,
+          }
+      ]
+    end
+
+    #TODO: we should probably provide a means to invalidate this cache.
+    #TODO: but in most reasonable use cases this would not be called until
+    #TODO: after all the critters have been created.
+    def critter_hash
+      @critter_hash ||= critters.inject({}){|memo, crit| memo[crit.name]=crit; memo}
+    end
+
+    # Retrive list of critters given from parameters given, names of critters.
+    # Return the results in an array. Names given must exist. Can be either
+    # strings or symbols or something that can be reduced to symbols, at least.
+    def find_critters(*names)
+      names.map{|name| critter_hash[name.to_sym]}
+    end
+  end
+
+  #= Critter Reporting
+  # The reporting functionality for critters are represented here,
+  # since this is only tangenial to the actual functionality of
+  # the critters themselves.
+  class Critter
+    def report_neuron_types
+      {
+          input:  population.input_neurons.map {|n| n.name},
+          output: population.output_neurons.map{|n| n.name},
+          hidden: population.hidden_neurons.map{|n| n.name}
+      }
+    end
+
+    def report_genotype
+      genotype.genes.map{|innov, gene| {in: gene.in_neuron, out: gene.out_neuron, innov: innov}}
+    end
+
+    def report_phenotype
+      phenotype.code
+    end
+
+    def report
+      {
+          genotype: report_genotype,
+          phenotype: report_phenotype,
+          neuron_types: report_neuron_types
+      }
+    end
+  end
+end