rubyneat 0.3.5.alpha.2

data/lib/rubyneat/evolver.rb

@@ -0,0 +1,315 @@
+require 'rubyneat'
+require 'distribution'
+module NEAT
+  #= Evolver -- Basis of all evolvers.
+  # All evolvers shall derive from this basic evolver (or this one can be
+  # used as is). Here, we'll have many different evolutionary operators
+  # that will perform operations on the various critters in the population.
+  #
+  
+  class Evolver < Operator
+    attr_reader :npop
+
+    def initialize(c)
+      super
+      @critter_op = CritterOp.new self
+    end
+
+    # Generate the initial genes for a given genotype.
+    # We key genes off their innovation numbers.
+    def gen_initial_genes!(genotype)
+      genotype.genes = {}
+      genotype.neural_inputs.each do |s1, input|
+        genotype.neural_outputs.each do |s2, output|
+          g = Critter::Genotype::Gene[genotype, input, output, NEAT::controller.gaussian]
+          genotype.genes[g.innovation] = g
+        end
+      end
+    end
+
+    # Here we mutate the population.
+    def mutate!(population)
+      @npop = population
+
+      if @controller.parms.mate_only_prob.nil? or rand > @controller.parms.mate_only_prob
+        log.debug "[[[ Neuron and Gene Giggling!"
+        mutate_perturb_gene_weights!
+        mutate_change_gene_weights!
+        mutate_add_neurons!
+        mutate_change_neurons!
+        mutate_add_genes!
+        mutate_disable_genes!
+        mutate_reenable_genes!
+        log.debug "]]] End Neuron and Gene Giggling!\n"
+      else
+        log.debug "*** Mating only!"
+      end
+    end
+
+    # Here we clone the population and then evolve it
+    # on the basis of fitness and novelty, etc.
+    #
+    # Returns  the newly-evolved population.
+    def evolve(population)
+      @npop = population.dclone
+      
+      # Population sorting and evaluation for breeding, mutations, etc.
+      prepare_speciation!
+      prepare_fitness!
+      prepare_novelty!
+
+      mate!
+
+      return @npop
+    end
+    
+    # Here we specify evolutionary operators.
+    protected
+    
+    def prepare_speciation!
+      @npop.speciate!
+      log.debug "SPECIES:"
+      NEAT::dpp @npop.species
+    end
+
+    # Sort species within the basis of fitness.
+    # Think of the fitness as an error / cost function.
+    # The better fit, the closer to zero the fitness parameter will be.
+    #
+    # If a compare block is specified in the DSL, then that function is called
+    # with the *fitness values* from critters c1 and c2. The default valuation
+    # is c1.fitness <=> c2.fitness. You may elect to evaluate them differently.
+    def prepare_fitness!
+      @npop.species.each do |k, sp|
+        sp.sort!{|c1, c2|
+          unless @controller.compare_func.nil?
+            @controller.compare_func.(c1.fitness, c2.fitness)
+          else
+            c1.fitness <=> c2.fitness
+          end
+        }
+      end
+    end
+
+    #TODO: write novelty code
+    def prepare_novelty!
+    end
+
+    # Perturb existing gene weights by adding a guassian to them.
+    def mutate_perturb_gene_weights!
+      @gperturb = Distribution::Normal::rng(0, @controller.parms.mutate_perturb_gene_weights_sd) if @gperturb.nil?
+      @npop.critters.each do |critter|
+        critter.genotype.genes.each { |innov, gene|
+          if rand < @controller.parms.mutate_perturb_gene_weights_prob
+            gene.weight += per = @gperturb.()
+            log.debug { "Peturbed gene #{gene}.#{innov} by #{per}" }
+          end
+        }
+      end
+    end
+
+    # Totally change weights to something completely different
+    def mutate_change_gene_weights!
+      @gchange = Distribution::Normal::rng(0, @controller.parms.mutate_change_gene_weights_sd) if @gchange.nil?
+      @npop.critters.each do |critter|
+        critter.genotype.genes.each { |innov, gene|
+          if rand < @controller.parms.mutate_change_gene_weights_prob
+            gene.weight = chg = @gchange.()
+            log.debug { "Change gene #{gene}.#{innov} by #{chg}" }
+          end
+        }
+      end
+    end
+
+    def mutate_add_genes!
+      @npop.critters.each do |critter|
+        if rand < @controller.parms.mutate_add_gene_prob
+          log.debug "mutate_add_genes! for #{critter}"
+          @critter_op.add_gene! critter
+        end
+      end
+    end
+
+    def mutate_disable_genes!
+      @npop.critters.each do |critter|
+        if rand < @controller.parms.mutate_gene_disable_prob
+          log.debug "mutate_disable_genes! for #{critter}"
+          @critter_op.disable_gene! critter
+        end
+      end
+    end
+
+    def mutate_reenable_genes!
+      @npop.critters.each do |critter|
+        if rand < @controller.parms.mutate_gene_reenable_prob
+          log.debug "mutate_reenable_genes! for #{critter}"
+          @critter_op.reenable_gene! critter
+        end
+      end
+    end
+
+    def mutate_add_neurons!
+      @npop.critters.each do |critter|
+        if rand < @controller.parms.mutate_add_neuron_prob
+          log.debug "mutate_add_neurons! for #{critter}"
+          @critter_op.add_neuron! critter
+        end
+      end
+    end
+
+    # TODO Finish mutate_change_neurons!
+    def mutate_change_neurons!
+      log.error "mutate_change_neurons! NIY"
+    end
+
+    # Here we select candidates for mating. We must look at species and fitness
+    # to make the selection for mating.
+    def mate!
+      parm = @controller.parms
+      popsize = parm.population_size
+      surv = parm.survival_threshold
+      survmin = parm.survival_mininum_per_species
+      mlist = [] # list of chosen mating pairs of critters [crit1, crit2], or [:carryover, crit]
+
+      # species list already sorted in descending order of fitness.
+      # We will generate the approximate number of  pairs that correspond
+      # to the survivial_threshold percentage of the population,
+      # then backfill with the most fit out of the top original population.
+      @npop.species.each do |k, sp|
+        crem = [(sp.size * surv).ceil, survmin].max
+        log.warn "Minumum per species hit -- #{survmin}" unless crem > survmin
+        spsel = sp[0, crem]
+        spsel = sp if spsel.empty?
+        crem.times do
+          mlist << [spsel[rand spsel.size], spsel[rand spsel.size]]
+        end
+      end
+
+      # And now for the backfilling
+      unless mlist.size >= @npop.critters.size
+        mlist += @npop.critters[0, @npop.critters.size - mlist.size].map{|crit| [:carryover, crit]}
+      end
+
+      @npop.critters = mlist.map do |crit1, crit2|
+        (crit1 == :carryover) ? crit2 : sex(crit1, crit2)
+      end
+    end
+    
+    protected
+    # Mate the given critters and return a baby.
+    # This is rather involved, and relies heavily on the Innovation Numbers.
+    #
+    # Some definitions:
+    #
+    ## Matching Gene
+    ### 2 genes with matching innovation numbers.
+    #
+    ## Disjoint Gene
+    ### A gene in one has an innovation number in the range of innovation numbers
+    ### of the other.
+    #
+    ## Excess Gene
+    ### Gene in one critter that has an innovation number outside of the range
+    ### of innovation numbers of the other.
+    #
+    ## Neurons
+    ### Distinct Neurons from both crit1 and crit2 must be present in
+    ### the baby.
+    #
+    # Excess and Disjoint genes are always included from the more fit parent.
+    # Matching genes are randomly chosen. For now, we make it 50/50.
+    def sex(crit1, crit2)
+      Critter.new(@npop, true) do |baby|
+        fitcrit = if crit1.fitness > crit2.fitness
+                    crit1
+                  elsif crit2.fitness > crit1.fitness
+                    crit2
+                  else
+                    (rand(2) == 1) ? crit1 : crit2
+                  end
+        a = crit1.genotype.genes.keys.to_set
+        b = crit2.genotype.genes.keys.to_set
+        disjoint = (a - b) + (b - a)
+        joint = (a + b) - disjoint
+        baby.genotype.neucleate { |gtype|
+          joint.map { |innov|
+            g1 = crit1.genotype.genes[innov]
+            g2 = crit2.genotype.genes[innov]
+            Critter::Genotype::Gene[gtype,
+                                    g1.in_neuron, g1.out_neuron,
+                                    (rand(2) == 1) ? g1.weight : g2.weight,
+                                    innov]
+          } + disjoint.map { |innov|
+            fitcrit.genotype.genes[innov].clone unless fitcrit.genotype.genes[innov].nil?
+          }.reject{|i| i.nil? }
+        }
+        baby.genotype.innervate! crit1.genotype.neurons, crit2.genotype.neurons
+        baby.genotype.prune!
+        baby.genotype.wire!
+      end
+    end
+
+    # A set of Critter Genotype operators.
+    class CritterOp < NeatOb
+      def initialize(evol)
+        super evol.controller
+        @evolver = evol
+        @npop = evol.npop
+      end
+
+      #= Add a neuron to given critter
+      # Here, we add a neuron by randomly picking a
+      # gene, and split it into two genes with an intervening
+      # neuron. The old gene is not replaced, but disabled. 2 new genes are
+      # created along with the new neuron.
+      def add_neuron!(crit)
+        gene = crit.genotype.genes.values.sample
+        neu = controller.neural_hidden.values.sample.new(controller)
+        g1 = Critter::Genotype::Gene[crit.genotype, gene.in_neuron, neu.name, gene.weight]
+        g2 = Critter::Genotype::Gene[crit.genotype, neu.name, gene.out_neuron, gene.weight]
+        gene.enabled = false
+        crit.genotype.add_neurons neu
+        crit.genotype.add_genes g1, g2
+        log.debug "add_neuron!: neu #{neu}, g1 #{g1}, g2 #{g2}"
+      end
+
+      #= Add a gene to the genome
+      # Unlike adding a new neuron, adding a new gene
+      # could result in a circular dependency. If so,
+      # and if recurrency is switched off, we must detect
+      # this condition and switch off the offending neurons.
+      #
+      # Obviously, this might result in a loss of functionality, but
+      # oh well.
+      #
+      # An easy and obvious check is to make sure we don't
+      # accept any inputs from output neurons, and we don't
+      # do any outputs to input neurons.
+      #
+      # Constructs for handling recurrency are present in Expressor.
+      def add_gene!(crit)
+        n1 = crit.genotype.neurons.values.sample # input
+        n2 = crit.genotype.neurons.values.sample # output
+
+        # Sanity checks!
+        unless n1 == n2 or n1.output? or n2.input?
+          gene = Critter::Genotype::Gene[crit.genotype, n1.name, n2.name, NEAT::controller.gaussian]
+          crit.genotype.add_genes gene
+          log.debug "add_gene! Added gene #{gene}(#{n1.name} -> #{n2.name}) to #{crit}"
+        end
+      end
+
+      # Pick an enabled gene at random and disable it.
+      def disable_gene!(crit)
+        gene = crit.genotype.genes.values.reject{|gene| gene.disabled? }.sample
+        gene.enabled = false unless gene.nil?
+      end
+
+      # Pick a disabled gene at random and reenable it.
+      def reenable_gene!(crit)
+        gene = crit.genotype.genes.values.reject{|gene| gene.enabled? }.sample
+        gene.enabled = true unless gene.nil?
+      end
+    end
+  end
+end

data/lib/rubyneat/expressor.rb

@@ -0,0 +1,110 @@
+require 'rubyneat/rubyneat'
+require 'pp'
+
+module NEAT
+  #= Basis of all expressors. 
+  # Expressor object turn genotypes into phenotypes.
+  class Expressor < Operator
+    def initialize(c)
+      super      
+    end
+
+    # Take the genotype of the critter and
+    # create a phenotype from the genotype.
+    # 
+    # In the phenotype, it creates a function called stimulate(),
+    # which is called with the input parameters and returns a response
+    # in the form of a response hash (which corresponds directly to the
+    # output neurons).
+    #
+    # This implementation assumes an acyclic graph (feed forward)
+    # and cannot handle cycles at all. Later we may fix this or create
+    # a type of Expressor that can.
+    def express!(critter)
+      critter.ready_for_expression!
+      express_neurons! critter
+      express_genes! critter
+      express_expression! critter
+    end
+
+    protected
+    # Express Neurons as methods
+    def express_neurons!(critter)
+      critter.genotype.neurons.each do |name, neuron|
+        neuron.express(critter.phenotype) unless neuron.input? and not neuron.bias?
+      end
+    end
+    
+    #= Expression of the Genotype as a Phenotype.
+    # What this really does is create the function that calls
+    # all the functions. 
+    #
+    # This makes use of the Graph plugin for Neurons.
+    #= Recurrency and Expression of Genes
+    # A simple approach has been taken here to allow for recurrency in
+    # our Critters. Basically, a looping construct has been put around the
+    # activation of the neurons so that recurrency can be done in 2 ways:
+    ## 1) Via yielding, thus treating the stimulus function as a enumerable.
+    ### In this approach, one would call the Critter's phenotype with a block of
+    ### code that would accept the output of the net. It would return 'true' to
+    ### continue the iteration, or 'false' to end the iteration.
+    ## 2) Via multiple calls to the Pheontype instance:
+    ### Since the value of the prior activation is preserved in the instance variables
+    ### of the phenotype, subsequent activations will iterate the network.
+    #== Cavets to recurrent activation
+    # For (2) above, the input neurons would be overwritten on each subsequent call.
+    # Since we do not allow recurrent connections to input neurons anyway, this should
+    # not be an issue, though we may allow for this at a future date.
+    def express_genes!(critter)
+      g = critter.genotype
+      p = critter.phenotype
+
+      init_code = "\n  def initialize_neurons\n"
+
+      # 'stimulate' function call (really should be 'activate', but we'll reserve this for something else)
+      p.code += "  def #{NEAT::STIMULUS}("
+      p.code += g.neural_inputs.reject{ |sym| g.neural_inputs[sym].bias? }.map{|sym, neu| sym}.join(", ")
+      p.code += ")\n"
+
+      # Assign all the parameters to instance variables.
+      p.code += g.neural_inputs.map{|sym, neu| "    @#{sym} = #{sym}\n"}.join("")
+      p.code += "    loop {\n"
+
+      # Resolve the order in which we shall call the neurons
+      # TODO handle the dependency list if it comes back!
+      @resolved, @dependencies = NEAT::Graph::DependencyResolver[g.neural_outputs.map{|s, neu| neu}].resolve
+
+      # And now call them in that order!
+      @resolved.each do |neu|
+        unless neu.input?
+          init_code += "    @#{neu.name} = 0\n"
+          if g.neural_gene_map.member? neu.name
+            p.code += "      @#{neu.name} = #{neu.name}("
+            p.code += g.neural_gene_map[neu.name].map{ |gene|
+              "%s * @%s" % [gene.weight, gene.in_neuron]
+            }.join(", ") + ")\n"
+          else
+            g.dangling_neurons = true
+            log.debug "Dangling neuron in critter #{critter} -- #{neu}"
+          end
+        end
+      end
+      init_code += "  end\n"
+
+      # And now return the result as a vector of outputs.
+      p.code += "     @_outvec = [" + g.neural_outputs.map{|sym, neu| "@#{sym}"}.join(',') + "]\n"
+      p.code += "     break unless block_given?\n"
+      p.code += "     break unless yield @_outvec\n"
+      p.code += "  }\n"
+      p.code += "  @_outvec\n"
+      p.code += "  end\n"
+      p.code += init_code
+      log.debug p.code
+      p.express!
+    end
+
+    def express_expression!(critter)
+      critter.phenotype.express!      
+    end
+  end
+end

data/lib/rubyneat/graph.rb

@@ -0,0 +1,95 @@
+require 'rubyneat'
+
+module NEAT
+  # General graph representation
+  # (mainly used for Neurons, but could be used
+  # for other structures.)
+  #
+  # This is a mixin for Neuron and whatever else you'd like.
+  # the contained class is for evaluation, and may be instantiated separately.
+  module Graph
+    class GraphException < Exception
+    end
+
+    # clear and initialize the graph.
+    def clear_graph
+      @g_inputs = []
+    end
+
+    def << (input)
+      @g_inputs << input
+      self
+    end
+
+    # Add a single input
+    def add (input)
+      @g_inputs << input
+    end
+
+    # Get list of inputs
+    def inputs
+      raise GraphException.new "Graph Failure -- input is nil" if @g_inputs.nil?
+      @g_inputs
+    end
+
+    # Create an instantiation of this and pass it a list of nodes to resolve.
+    class DependencyResolver < NeatOb
+
+      # Given a list of output nodes, we shall work backwards
+      # from them to resolve their dependencies.
+      def initialize(outputs, &block)
+        @outputs = outputs
+        super
+        block.(self) unless block.nil?
+      end
+
+      # Create a DependencyResolver from either
+      # an array of outputs or a parameter list of outputs.
+      def self.[](*outs)
+        outs = outs.first if outs.first.kind_of? Array
+        DependencyResolver.new outs
+      end
+
+
+      # Resolve dependencies, and return [dependency_list, circular_ref_node_list]
+      # Note that circular_ref_node_list shall be nil if there are no dependencies!
+      def resolve
+        @resolved = []
+        @unresolved = []
+        @circular = []
+        @outputs.each do |onode|
+          rdep onode
+        end
+        [@resolved, @circular.empty? ? nil : @circular]
+      end
+
+      # Throw an exception if dependencies are found.
+      # We only return the dependency list since we throw an exception on circular
+      # dependencies.
+      def resolve!
+        dl, cl = resolve
+        raise GraphException("Circular Dependency Detected: %s" % cl) unless cl.nil?
+        dl
+      end
+
+      private
+      # recursive resolution of nodes
+      def rdep(node)
+        @unresolved << node
+        node.inputs.each { |inode|
+          if not @resolved.member? inode
+            unless @unresolved.member? inode
+              rdep inode
+            else
+              # we found a circular reference.
+              @circular << inode
+              #log.warn "Dependency found: %s" % inode
+            end
+          end
+        }
+        @resolved << node
+        @unresolved.delete node
+      end
+    end
+  end
+end

data/lib/rubyneat/neuron.rb

@@ -0,0 +1,152 @@
+require 'rubyneat'
+require 'rubyneat/graph'
+
+=begin rdoc
+= Neuron Types
+
+We create all the neuron types for this system here.
+
+=end
+module NEAT
+  #= Neuron -- Basis of all Neat Neuron types.
+  # Normally contains primatives which aids in its
+  # own expression, but the details of this remains to be worked out.
+  class Neuron < NeatOb
+    include Math
+    include Graph
+
+    # Genotype to which we belong
+    attr_reader :genotype
+    attr_accessor :trait
+
+    # (assigned by wire!) Heirarchy number in the Genome / Critter
+    # We need this to assure we add genes in the proper order.
+    # This will be recalculated every time a new neuron is added.
+    attr_accessor :heirarchy_number
+
+    # This is true if this is an output neuron.
+    attr_accessor :output
+
+    # List of neuron types defined.
+    @@neuron_types = []
+
+    # Class is is of Input type?
+    def self.input? ; false ; end
+    def input? ; self.class.input? ; end
+
+    def self.bias? ; false ; end
+    def bias? ; self.class.bias? ; end
+
+    # Instantiation is of outout type?
+    def output? ; !!@output ; end
+
+    def self.inherited(clazz)
+      @@neuron_types << clazz
+    end
+
+    # List of distinct neuron types (classes)
+    def self.neuron_types; @@neuron_types ; end
+
+    # Function must be implemented by subclasses for phenotype
+    # generation. Basically, an instance is passed to this function
+    # and it will add a function to sum all inputs
+    # and a apply an operator to the sum.
+    def express(instance)
+      raise NeatException.new "express() must be implemented by subclass."
+    end
+  end
+
+
+
+=begin rdoc
+= Basic Neuron Types
+
+Basically, the neurons (nodes) will have an instantiation to represent their places in the
+neural net, and way to spin up the phenotypic representation.
+
+The basic types to RubyNEAT are represented here.
+=end
+  module BasicNeuronTypes
+    #= Special class of Neuron that takes input from the "real world"
+    # Name of this neuron equates to the parameter name of the input.
+    #
+    # All inputs are handled with this neuron. This type of 
+    # neuron only has one input -- from the outside world.
+    class InputNeuron < NEAT::Neuron
+      def self.input? ; true ; end
+      
+      # Takes a single input and passes it as is.
+      def express(instance)
+        instance.define_singleton_method(@name) {|input|
+          input
+        }
+      end
+    end
+
+    #= Special class of neuron that provides a bias signal.
+    # FIXME: The bias value is not behaving as expected because
+    # FIXME: the instance is not the neuron, but the phenotype.
+    class BiasNeuron < InputNeuron
+      def self.bias? ; true ; end
+      attr_accessor :neu_bias
+
+      def initialize(c=nil, n=nil)
+        super
+        @neu_bias = 1.00
+      end
+      
+      # Just provides a bias signal
+      # FIXME: we had to hard-code the value here for now. Not a biggie,
+      # FIXME: but really should be @neu_bias
+      def express(instance)
+        instance.define_singleton_method(@name) { 1.00 }
+      end
+    end
+
+    # The most commonly-used neuron for the hidden and output layers.
+    # We use the Logistic Function for the Sigmoid.
+    class SigmoidNeuron < Neuron
+      # create a function on the instance with our name
+      # that sums all inputs and produce a sigmoid output (using tanh)
+      def express(instance)
+        instance.define_singleton_method(@name) {|*inputs|
+          1.0 / (1.0 + exp(-4.9 * inputs.reduce {|p, q| p + q}))
+        }
+      end
+    end
+
+    # An alternative Sigmoid Function, but ranges -1 to +1
+    class TanhNeuron < Neuron
+      # create a function on the instance with our name
+      # that sums all inputs and produce a sigmoid output (using tanh)
+      def express(instance)
+        instance.define_singleton_method(@name) {|*inputs|
+          tanh(2.4 * inputs.reduce {|p, q| p + q})
+        }
+      end
+    end
+
+    # Sin function (CPPN) -- adjusted to have its +1 and -1 near TanhNeuron
+    class SineNeuron < Neuron
+      # create a function on the instance with our name
+      # that sums all inputs and produce a sigmoid output (using tanh)
+      def express(instance)
+        instance.define_singleton_method(@name) {|*inputs|
+          sin(1.6 * inputs.reduce {|p, q| p + q})
+        }
+      end
+    end
+
+    # Cosine function (CPPN) -- adjusted to have its +1 and -1 near TanhNeuron
+    class CosineNeuron < Neuron
+      # create a function on the instance with our name
+      # that sums all inputs and produce a sigmoid output (using tanh)
+      def express(instance)
+        instance.define_singleton_method(@name) {|*inputs|
+          cos(1.6 * inputs.reduce {|p, q| p + q})
+        }
+      end
+    end
+
+  end
+end