rubyneat 0.3.5.alpha.2

data/lib/rubyneat/critter.rb

@@ -0,0 +1,374 @@
+require 'rubyneat'
+
+=begin rdoc
+= Critter
+=end
+module NEAT
+
+  #= Critters for NEAT
+  # The Critter class comprises a Genotype and a Phenotype.
+  # The Genotype comprises Genes and Neurons.
+  class Critter < NeatOb
+    attr_reader :population
+    attr_accessor :genotype, :phenotype
+
+    # Ratings assigned by Evaluator
+    attr_accessor :fitness, :novelty
+
+    # Critter construction. We construct the genotype.
+    # The phenotype will be constructed by the Expressor operator.
+    def initialize(pop, mating = false, &block)
+      super pop.controller
+      @population = pop
+      @genotype = Genotype.new(self, mating)
+      block.(self) unless block.nil?
+    end
+
+    # Get the Critter ready for the Expressor to
+    # express the geneotype.
+    def ready_for_expression!
+      @genotype.wire!
+      @phenotype = NEAT::Critter::Phenotype[self]
+      @phenotype
+    end
+
+    # Exoress this critter using the Expressor plugin.
+    def express!
+      @controller.expressor.express! self
+    end
+
+    # This initializes neurons in preparation for recurrence.
+    # Note that the Critter should already have expressed its
+    # genotype before this is called.
+    def initialize_neurons!
+      @phenotype.initialize_neurons
+    end
+
+    # A single evaluation step. Evaluate and
+    # generate fitness, novelty, etc.
+    # Returns the result.
+    def evaluate!
+      @controller.evaluator.evaluate! self
+    end
+
+    #= Genotype part of the Critter
+    # List of connections, basically.
+    #
+    # Also, basic phentypic expression (which may be overriden by
+    # the expressor)
+    #
+    #= Notes
+    # Currently, all lists of neurons and genes are Hashes. The
+    # neurons are indexed by their own names, and the genes
+    # are indexed by their innovation numbers.
+    #
+    class Genotype < NeatOb
+      # Critter to which we belong
+      attr_accessor :critter
+
+      # Genes keyed by innovation numbers
+      attr_accessor :genes
+
+      # List of neurons hashed by name
+      attr_accessor :neurons
+
+      # Instantiations of neural inputs and outputs
+      attr_reader :neural_inputs, :neural_outputs
+
+      # This will be set to true if there are dangling neurons.
+      attr_accessor :dangling_neurons
+      alias :dangling_neurons? :dangling_neurons
+
+      # Map neurons to the genes that marks them as output
+      # { oneu_name => [ gene_1, gene_2,... gene_n], ...}
+      # Just take the in_neuron name and the weight to do
+      # the call to that neuron function with the appropriate weights
+      attr_reader :neural_gene_map
+
+      def initialize(critter, mating = false, &block)
+        super critter.controller
+        @critter = critter
+
+        # Initialize basic structures
+        @genes = nil
+        @neural_inputs = Hash[@critter.population.input_neurons.map { |sym, ineu|
+                                [sym, ineu.new(@controller, sym)]
+                              }]
+
+        @neural_outputs = Hash[@critter.population.output_neurons.map { |sym, ineu|
+                                [sym, ineu.new(@controller, sym)]
+                              }]
+        @neurons = @neural_inputs.clone # this must be a shallow clone!
+        @neurons.merge! @neural_outputs
+
+        @controller.evolver.gen_initial_genes!(self) unless mating
+        block.(self) unless block.nil?
+      end
+
+      # We add genes given here to the genome.
+      # An array of genes is returned from the block
+      # and we simply add them in.
+      # @param [boolean] clean
+      # @param [Proc] block
+      def neucleate(clean: true, &block)
+        genes = Hash[block.(self).map { |g|
+          g.genotype = self
+          [g.innovation, g] }]
+        if clean
+          @genes = genes
+        else
+          @genes.merge! genes
+        end
+        nuke_redundancies!
+      end
+
+      # Remove any redundancies in the genome,
+      # any genes refering to the same two neurons.
+      # Simply choose one and delete the rest.
+      # TODO: implement nuke_redundancies!
+      def nuke_redundancies!
+        log.warn 'nuke_redundancies! NIY'
+      end
+
+      # Make the neurons forget their wiring.
+      def forget!
+        @neurons.each { |name, neu| neu.clear_graph }
+        @neural_gene_map = Hash.new {|h, k| h[k] = [] }
+      end
+
+      # Wire up the neurons based on the genes.
+      def wire!
+        forget!
+        @genes.each do |innov, gene|
+          if gene.enabled?
+            raise NeatException.new "Can't find #{gene.out_neuron}" if @neurons[gene.out_neuron].nil?
+            @neurons[gene.out_neuron] << @neurons[gene.in_neuron]
+            @neural_gene_map[gene.out_neuron] << gene unless gene.in_neuron.nil?
+          end
+        end unless @genes.nil?
+        if @genes.nil?
+          $log.error 'Genes Not Present'
+        end
+      end
+
+      # Add new neurons to the fold
+      def add_neurons(*neus)
+        neus.each do |neu|
+          @neurons[neu.name] = neu
+        end
+      end
+
+      # Genes added here MUST correspond to pre-existing neurons.
+      # Be sure to do add_neurons first!!!!
+      def add_genes(*genes)
+        genes.each do |gene|
+          raise NeatException.new "Neuron #{gene.in_neuron} missing" unless @neurons.member? gene.in_neuron
+          raise NeatException.new "Neuron #{gene.out_neuron} missing" unless @neurons.member? gene.out_neuron
+          @genes[gene.innovation] = gene
+        end
+      end
+
+      # We take the neural hashes (presumably from other neurons), and innervate them.
+      # We do this in distinctions based on the neuron's names.
+      # FIXME We need to randomly select a neuron in the case of clashes.
+      # @param [Hash] hneus -- hashes of neurons to innervate
+      def innervate!(*hneus)
+        hneus.each do |neus|
+          @neurons.merge! neus.dclone
+        end
+      end
+
+      # Go through the list of neurons and drop
+      # any neurons not referenced by the genes.
+      #
+      # Then go through the genes and drop any that
+      # are dangling (i.e. no matching neurons)
+      #
+      # Then make sure that @neural_inputs and @neural_outputs reference the actual
+      # instance neurons in @neurons
+      #
+      # TODO add this circularity check to prune!
+      def prune!
+        # Take care of dangling neurons
+        neunames = @genes.values.map{|g| [g.in_neuron, g.out_neuron]}.flatten.to_set
+        @neurons = Hash[@neurons.values.reject do |n|
+          not neunames.member? n.name
+        end.map do |n|
+          [n.name, n]
+        end]
+
+        # Take care of dangling genes
+        @genes = Hash[@genes.values.reject do |gene|
+          not (@neurons.member?(gene.in_neuron) and @neurons.member?(gene.out_neuron))
+        end.map do |gene|
+          [gene.name, gene]
+        end]
+
+        # Make sure @neural_inputs and @neural_outputs are consistent
+        @neural_inputs = Hash[@neural_inputs.values.map{|n| [n.name, @neurons[n.name]]}]
+        @neural_outputs = Hash[@neural_outputs.values.map{|n| [n.name, @neurons[n.name]]}]
+      end
+
+      # Calculate the cost of this genotype.
+      def fitness_cost
+        p = @controller.parms
+        p.fitness_cost_per_neuron * @neurons.size + p.fitness_cost_per_gene * @genes.size
+      end
+
+      def dump_s
+        to_s + "\ngenes:\n" + @genes.map{|k, gene|
+          gene.to_s}.join("\n") + "\nneurons:\n" + @neurons.map{|k, neu|
+          neu.to_s}.join("\n")
+      end
+
+      #= Gene Specification
+      # The Gene specifices a singlular input and
+      # output neuron, which represents a connection
+      # between them, along with the weight of that
+      # connection, which may be positive, negative, or zero.
+      #
+      # There is also the enabled flag
+      class Gene < NeatOb
+        # parent genotype
+        attr_accessor :genotype
+
+        # innovation number
+        attr_accessor :innovation
+
+        # input neuron's name (where our output goes)
+        # ouptut neuron's name (neuron to be queried)
+        attr_accessor :in_neuron, :out_neuron
+
+        # weight of the connection
+        attr_accessor :weight
+        # Is this gene enabled?
+        attr_accessor :enabled
+
+        def initialize(genotype, &block)
+          super genotype.controller
+          @genotype = genotype
+          @enabled = true
+          @innovation = NEAT::new_innovation
+          @in_neuron = @out_neuron = nil
+          block.(self) unless block.nil?
+        end
+
+        def enabled? ; @enabled ; end
+        def disabled? ; not enabled? ; end
+
+        # Create a new Gene and set it up fully.
+        ## genotype -- genotype
+        ## input -- name of input neuron connection
+        ## output -- name of output neuron connection
+        ## weight -- weight to give neuron (optional)
+        ## innov -- innovation number of gene (optional)
+        def self.[](genotype, input, output, weight = 0.0, innov = nil)
+          g = Gene.new genotype
+          g.in_neuron = (input.kind_of? Symbol) ? input : input.name
+          g.out_neuron = (output.kind_of? Symbol) ? output : output.name
+          g.weight = weight
+          g.innovation = innov unless innov.nil?
+          return g
+        end
+
+        def to_s
+          super + "[i%s,w%s,%s]" % [@innovation, @weight, self.enabled?]
+        end
+        alias_method :dump_s, :to_s
+
+      end
+
+    end
+
+    #= Phenotype part of the Critter
+    # This is created by Evolver. 
+    class Phenotype < NeatOb
+      include Math
+
+      # Critter to which we belong
+      attr_accessor :critter
+
+      # Expressed code as a string (that was instance_eval()ed)
+      attr_accessor :code
+
+      def self.[](critter)
+        ph = Phenotype.new critter.controller
+        ph.critter = critter
+        ph.code = "## Phenotype Code %s for critter %s\n" % [ph.name, critter.name]
+        return ph
+      end
+      
+      # Take what is in code and express that!
+      def express!
+        instance_eval @code
+        self
+      end
+
+      # This function is re-written by Expressor -- with parameters and all.
+      # It returns a "response" in the form of a response hash.
+      # TODO This *is* network activation, so we should rename this at a later date...
+      def stimulate
+        nil
+      end
+
+      # This gives us a complete
+      def to_s
+        "## %s\n%s" % [super, @code]
+      end
+    end
+
+    # Compare ourselves against another critter for
+    # compability.
+    #
+    # The function to be used here is:
+    ## distance = c1*E + c2*D + c3*W
+    # 
+    # Where:
+    ## E, D - The number of excess and disjoint genes repesctively.
+    ## N - The number of genes in the largest genome.
+    ## W - The sum of absolute weight differences.
+    #
+    # This is a variation of the formulation suggested by the Stanley
+    # paper, which normalizes the E and D terms by N.
+    def compare(oc)
+      c1 = @controller.parms.excess_coefficient
+      c2 = @controller.parms.disjoint_coefficient
+      c3 = @controller.parms.weight_coefficient
+      e = excess(oc)
+      d = disjoint(oc)
+      w = weight_diff(oc)
+      return c1 * e + c2 * d + c3 * w
+    end
+
+    # Critter print
+    def dump_s
+      to_s + @genotype.dump_s + "\n" + @phenotype.to_s + "\n"
+    end
+
+    private
+    # Return a count of excesses.
+    def excess(oc)
+      (@genotype.genes.size - oc.genotype.genes.size).abs
+    end
+
+    # Return the count of disjoint genes
+    def disjoint(oc)
+      a = @genotype.genes.keys
+      b = oc.genotype.genes.keys
+      (a - b).size + (b - a).size - excess(oc)
+    end
+
+    # 
+    def weight_diff(oc)
+      ag = @genotype.genes
+      bg = oc.genotype.genes
+      matches = ag.keys & bg.keys
+      unless matches.empty?
+        matches.map{|i| (ag[i].weight - bg[i].weight).abs}.reduce{|w, ws| w + ws} / matches.size
+      else
+        0
+      end
+    end
+
+  end
+end

data/lib/rubyneat/default_neat.rb

@@ -0,0 +1,10 @@
+require 'rubyneat/dsl'
+=begin rdoc
+= Default Parameters for RubyNEAT
+Here all default parameters are defined.
+=end
+
+include NEAT::DSL
+
+define "Default Parameters" do
+end

data/lib/rubyneat/dsl.rb

@@ -0,0 +1,130 @@
+require 'rubyneat/rubyneat'
+
+=begin rdoc
+= RubyNEAT DSL
+DSL is a domain-specific language for RubyNEAT to allow you to configure the NEAT engine
+for various evolutionary projects.
+=end
+module NEAT
+  module DSL
+    include NEAT
+    include NEAT::BasicNeuronTypes
+    include Math
+
+    # DSL -- Define defines the parameters to the controller.
+    def define(name = NEAT.random_name_generator, &block)
+      [
+       :inputs,
+       :outputs,
+       :hidden  # we really don't care about mapping hidden neurons, but we'll ignore them later.
+      ].each do |iometh|
+        instance_eval %Q[
+   def #{iometh}(nodes = nil, &block)
+     neui = unless nodes.nil?
+              nodes
+            else
+              block.()
+            end
+     NEAT::controller.neural_#{iometh} = if neui.kind_of? Hash
+                                           neui
+                                         else
+                                           Hash[neui.map{|n| [NEAT::random_name_generator, n]}]
+                                         end
+   end]
+      end
+      block.(NEAT::controller)
+    end
+
+    # DSL -- Run evolution
+    def evolve(&block)
+      # Query function is called with the sequence (time evolution) number,
+      # and returns an array or hash of parameters that will be given
+      # 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
+      end
+
+      def recurrence(&block)
+        NEAT::controller.recurrence_func = block
+      end
+
+      # fitness function calls the block with 2 vectors or two hashes, input and output
+      # vectors of the critter being evaluated for fitness, as well as a sequence
+      # number that can be used to index what the actual output should be.
+      # |vin, vout, seq|
+      def fitness(&block)
+        NEAT::controller.fitness_func = 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
+      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
+      end
+
+      # Stop the progression once the fitness criteria is reached
+      # for the most fit critter
+      def stop_on_fitness(&block)
+        NEAT::controller.stop_on_fit_func = block
+      end
+
+      # Helper function to
+      # Condition boolean vectors to be +1 if true, -1 if false (0 if sigmoid)
+      def condition_boolean_vector(vec, sig = :tanh)
+        vec.map{|b| b ? 1 : ((sig == :sigmoid) ? 0 : -1)}
+      end
+
+      # Helper function to
+      # Uncondition boolean vectors to be +1 if true, -1 if false
+      # FIXME we need a better discrimination function
+      def uncondition_boolean_vector(vec, sig = :tanh)
+        vec.map{|o| o > ((sig == :sigmoid) ? 0.5 : 0) ? true : false}
+      end
+
+      # Helper function to do a simple fitness calculation
+      # on the basis of the sum of the square of the diffences
+      # of the element in the two vectors.
+      def simple_fitness_error(v1, v2)
+        sqrt v1.zip(v2).map{|a, b| (a - b) ** 2.0}.reduce{|m, c| m + c}
+      end
+
+      block.(NEAT::controller)
+    end
+
+    # Report on evaluations
+    def report(&block)
+      NEAT::controller.report_hook = block
+    end
+
+    # Run the engine. The block is called on each generation.
+    def run_engine(&block)
+      NEAT::controller.end_run_func = block
+      NEAT::controller.run
+    end
+
+    # This is used to handle the details of our DSL.
+    def method_missing(m, *args, &block)
+      # we want to catch parameters settings here.
+      if NEAT::controller.parms.respond_to? (assignment = (m.to_s + '=').to_sym)
+        raise NeatException.new("Missing value(s) to %s" % m) if args.empty?
+        val = (args.size == 1) ? args[0] : args
+        $log.debug { "Caught method %s with parameter of %s" % [assignment, val] }
+        NEAT::controller.parms.send(assignment, val)
+      else
+        super
+      end
+    end
+  end
+end
+
+# FIXME: This needs to better specified for cases in which there may be multiple
+# Controllers.
+require 'rubyneat/default_neat'

data/lib/rubyneat/evaluator.rb

@@ -0,0 +1,51 @@
+require 'rubyneat/rubyneat'
+
+module NEAT
+  #= Evaluator evaluates phenotype of critter for fitness, novelty, etc.
+  # We can have a chain of these evaluators whose outputs are summed, etc.
+  class Evaluator < Operator
+
+    # This is call prior to any sequence evaluation. Here,
+    # we clean up persistent tracking information, etc.
+    def ready_for_evaluation(pop)
+      @crit_hist = {}
+      pop.initialize_for_recurrence!
+    end
+
+    # Evaluate one step of a sequence of evaluations.
+    # For time series and realtime ongoing evaluations,
+    # @controller.seq_num governs where in the sequence
+    # everything is. 
+    #
+    # Returns [vin, vout], where vin is the input vector,
+    # and vout in the output vector from the critter.
+    # 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)
+      @crit_hist[critter] = {} unless @crit_hist.member? critter
+      begin
+        vout = critter.phenotype.stimulate *vin, &@controller.recurrence_func
+        log.debug "Critter #{critter.name}: vin=#{vin}. vout=#{vout}"
+        @crit_hist[critter][@controller.seq_num] = [vin, vout]
+      rescue Exception => e
+        log.error "Exception #{e} on code:\n#{critter.phenotype.code}"
+        @crit_hist[critter][@controller.seq_num] = [vin, :error]
+      end
+    end
+
+    # Analyze the evaluation and compute a fitness for the given critter.
+    # 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) }
+      # Average the fitness vector to get a scalar fitness.
+      critter.fitness = unless @controller.cost_func.nil?
+                          @controller.cost_func.(fitvec, critter.genotype.fitness_cost)
+                        else
+                          fitvec.reduce {|a,r| a+r} / fitvec.size.to_f + critter.genotype.fitness_cost
+                        end
+      log.debug "Fitness Vector: #{fitvec}, fitness of #{critter.fitness} assigned to #{critter}"
+    end
+  end
+end