{~: rooto:"YARD::CodeObjects::RootObject:@childrenIC:&YARD::CodeObjects::CodeObjectList[o:$YARD::CodeObjects::ModuleObject;IC;[o; ;IC;[o:$YARD::CodeObjects::MethodObject:@module_functionF: @scope:
instance:@visibility: public:
@pathI"NEAT::DSL#define:EF:@parameters[[I" name;TI" NEAT.random_name_generator;T[I" █T0: @files[[I"lib/rubyneat/dsl.rb;Ti: @current_file_has_commentsT:
@name: define:@source_type: ruby:
@tags[�:@docstrings{�:@docstringIC:YARD::Docstring"<DSL -- Define defines the parameters to the controller.
;T:@ref_tags[�;[�: @allI"<DSL -- Define defines the parameters to the controller.;T:@unresolved_reference0: @object@ :@hash_flagF:@line_rangeo:
Range: exclF:
begini:endi:@namespace@
:@signatureI":def define(name = NEAT.random_name_generator, &block);T:@explicitT: @sourceI"�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;T:
@dynamicTo;
; F; ;
;;;I"NEAT::DSL#evolve;F;[[I" █T0;[[@i,;T;: evolve;;;[�;{�;IC; "DSL -- Run evolution
;T; [�;[�; I"DSL -- Run evolution;T; 0; @ ;!F;"o;#;$F;%i+;&i+;'@
;(I"def evolve(&block);T;)T;*I";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;T;+To;
; F; ;
;;;I"NEAT::DSL#query;F;[[I" █T0;[[@i1;T;:
query;;;[�;{�;IC; "�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.
;T; [�;[�; I"�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.;T; 0; @0;!F;"o;#;$F;%i-;&i0;'@
;(I"def query(&block);T;)T;*I"@def query(&block)
NEAT::controller.query_func = block
end;T;+To;
; F; ;
;;;I"NEAT::DSL#recurrence;F;[[I" █T0;[[@i5;F;:recurrence;;;[�;{�;IC; "�
;T; @@:
@summary0;!F; [�;[�; I"�;T; 0;'@
;(I"def recurrence(&block);T;)T;*I"Jdef recurrence(&block)
NEAT::controller.recurrence_func = block
end;T;+To;
; F; ;
;;;I"NEAT::DSL#fitness;F;[[I" █T0;[[@i=;T;: fitness;;;[�;{�;IC; "�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|
;T; [�;[�; I"�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|;T; 0; @O;!F;"o;#;$F;%i9;&i<;'@
;(I"def fitness(&block);T;)T;*I"Ddef fitness(&block)
NEAT::controller.fitness_func = block
end;T;+To;
; F; ;
;;;I"NEAT::DSL#compare;F;[[I" █T0;[[@iD;T;: compare;;;[�;{�;IC; "�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 <=>)
;T; [�;[�; I"�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 <=>);T; 0; @_;!F;"o;#;$F;%iA;&iC;'@
;(I"def compare(&block);T;)T;*I"Ddef compare(&block)
NEAT::controller.compare_func = block
end;T;+To;
; F; ;
;;;I"NEAT::DSL#cost;F;[[I" █T0;[[@iJ;T;: cost;;;[�;{�;IC; "xCalculation to add the cost to the fitness, resulting in a fitness
that incorporates the cost for sorting purposes.
;T; [�;[�; I"xCalculation to add the cost to the fitness, resulting in a fitness
that incorporates the cost for sorting purposes.;T; 0; @o;!F;"o;#;$F;%iH;&iI;'@
;(I"def cost(&block);T;)T;*I">def cost(&block)
NEAT::controller.cost_func = block
end;T;+To;
; F; ;
;;;I" NEAT::DSL#stop_on_fitness;F;[[I" █T0;[[@iP;T;:stop_on_fitness;;;[�;{�;IC; "WStop the progression once the fitness criteria is reached
for the most fit critter
;T; [�;[�; I"WStop the progression once the fitness criteria is reached
for the most fit critter;T; 0; @;!F;"o;#;$F;%iN;&iO;'@
;(I" def stop_on_fitness(&block);T;)T;*I"Pdef stop_on_fitness(&block)
NEAT::controller.stop_on_fit_func = block
end;T;+To;
; F; ;
;;;I"'NEAT::DSL#condition_boolean_vector;F;[[I"vec;T0[I"sig;TI"
:tanh;T;[[@iV;T;: condition_boolean_vector;;;[�;{�;IC; "^Helper function to
Condition boolean vectors to be +1 if true, -1 if false (0 if sigmoid)
;T; [�;[�; I"^Helper function to
Condition boolean vectors to be +1 if true, -1 if false (0 if sigmoid);T; 0; @�;!F;"o;#;$F;%iT;&iU;'@
;(I"3def condition_boolean_vector(vec, sig = :tanh);T;)T;*I"kdef condition_boolean_vector(vec, sig = :tanh)
vec.map{|b| b ? 1 : ((sig == :sigmoid) ? 0 : -1)}
end;T;+To;
; F; ;
;;;I")NEAT::DSL#uncondition_boolean_vector;F;[[I"vec;T0[I"sig;TI"
:tanh;T;[[@i];T;: uncondition_boolean_vector;;;[�;{�;IC; "{Helper function to
Uncondition boolean vectors to be +1 if true, -1 if false
FIXME we need a better discrimination function
;T; [�;[�; I"{Helper function to
Uncondition boolean vectors to be +1 if true, -1 if false
FIXME we need a better discrimination function;T; 0; @�;!F;"o;#;$F;%iZ;&i\;'@
;(I"5def uncondition_boolean_vector(vec, sig = :tanh);T;)T;*I"ydef uncondition_boolean_vector(vec, sig = :tanh)
vec.map{|o| o > ((sig == :sigmoid) ? 0.5 : 0) ? true : false}
end;T;+To;
; F; ;
;;;I"#NEAT::DSL#simple_fitness_error;F;[[I"v1;T0[I"v2;T0;[[@id;T;:simple_fitness_error;;;[�;{�;IC; "�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.
;T; [�;[�; I"�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.;T; 0; @�;!F;"o;#;$F;%ia;⁣'@
;(I"%def simple_fitness_error(v1, v2);T;)T;*I"kdef simple_fitness_error(v1, v2)
sqrt v1.zip(v2).map{|a, b| (a - b) ** 2.0}.reduce{|m, c| m + c}
end;T;+To;
; F; ;
;;;I"NEAT::DSL#report;F;[[I" █T0;[[@il;T;: report;;;[�;{�;IC; "Report on evaluations
;T; [�;[�; I"Report on evaluations;T; 0; @�;!F;"o;#;$F;%ik;&ik;'@
;(I"def report(&block);T;)T;*I"Bdef report(&block)
NEAT::controller.report_hook = block
end;T;+To;
; F; ;
;;;I"NEAT::DSL#run_engine;F;[[I" █T0;[[@iq;T;:run_engine;;;[�;{�;IC; "<Run the engine. The block is called on each generation.
;T; [�;[�; I"<Run the engine. The block is called on each generation.;T; 0; @�;!F;"o;#;$F;%ip;&ip;'@
;(I"def run_engine(&block);T;)T;*I"^def run_engine(&block)
NEAT::controller.end_run_func = block
NEAT::controller.run
end;T;+To;
; F; ;
;;;I" NEAT::DSL#method_missing;F;[[I"m;T0[I"
*args;T0[I" █T0;[[@iw;T;:method_missing;;;[�;{�;IC; "3This is used to handle the details of our DSL.
;T; [�;[�; I"3This is used to handle the details of our DSL.;T; 0; @�;!F;"o;#;$F;%iv;&iv;'@
;(I")def method_missing(m, *args, &block);T;)T;*I"�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;T;+T: @owner@
:@class_mixinsIC;[�;:@
:@instance_mixinsIC;[o: YARD::CodeObjects::Proxy :
@imethod0:@origname0:@orignamespace0;: Math;'@
: @obj0:
@type: moduleo;= ;>0;?I"NEAT::BasicNeuronTypes;T;@@
;:BasicNeuronTypes;'@;Bo; ;IC;[ o:#YARD::CodeObjects::ClassObject;IC;[o;
; F; :
class;;;I"/NEAT::BasicNeuronTypes::InputNeuron.input?;F;[�;[[I"lib/rubyneat/neuron.rb;TiQ;F;: input?;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o:YARD::Tags::Tag
:@tag_nameI" return;F:
@textI"�;T;0: @types[I" Boolean;T; @�; I"�;T; 0;'@�;(I"!def self.input? ; true ; end;T;)T;*I"!def self.input? ; true ; end;T;+To;
; F; ;
;;;I"0NEAT::BasicNeuronTypes::InputNeuron#express;F;[[I"
instance;T0;[[@iT;T;: express;;;[�;{�;IC; ".Takes a single input and passes it as is.
;T; [�;[�; I".Takes a single input and passes it as is.;T; 0; @;!F;"o;#;$F;%iS;&iS;'@�;(I"def express(instance);T;)T;*I"_def express(instance)
instance.define_singleton_method(@name) {|input|
input
}
end;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�:@attributesIC:SymbolHash{;GIC;O{�:@symbolize_valueT;
IC;O{�;PT;PT:
@aliases{�: @groups[�;[[@iP;T;:InputNeuron;;;;;[�;{�;IC; "�= 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.
;T; [�;[�; I"�= 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.;T; 0; @�;!F;"o;#;$F;%iK;&iO;'@�;I"(NEAT::BasicNeuronTypes::InputNeuron;F:@superclasso;= ;>0;?I"NEAT::Neuron;T;@@�;: Neuron;'@;Bo;F;IC;[o;
; F; ;
;;;I"NEAT::Neuron#genotype;F;[�;[[@i;T;:
genotype;;;[�;{�;IC; " Genotype to which we belong
;T; [�;[�; I" Genotype to which we belong;T; 0; @7;!F;"o;#;$F;%i;&i;'@5;(I"def genotype;T;*I"!def genotype
@genotype
end;T;+To;
; F; ;
;;;I"NEAT::Neuron#trait;F;[�;[[@i;F;:
trait;;;[�;{�;IC; ")Returns the value of attribute trait
;T; @E;/0;!F; [�;[�; I")Returns the value of attribute trait;T; 0;'@5;(I"def trait;T;*I"def trait
@trait
end;T;+To;
; F; ;
;;;I"NEAT::Neuron#trait=;F;[[I"
value;T0;[[@i;F;: trait=;;;[�;{�;IC; " Sets the attribute trait
;T; @R;/0;!F; [�;[o;I
;JI"
param;F;KI"-the value to set the attribute trait to.;T;I"
value;T;L0; @R; I"SSets the attribute trait
@param value the value to set the attribute trait to.;T; 0;'@5;(I"def trait=(value);T;*I"+def trait=(value)
@trait = value
end;T;+To;
; F; ;
;;;I""NEAT::Neuron#heirarchy_number;F;[�;[[@i ;T;:heirarchy_number;;;[�;{�;IC; "�(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.
;T; [�;[�; I"�(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.;T; 0; @e;!F;"o;#;$F;%i;&i ;'@5;(I"def heirarchy_number;T;*I"1def heirarchy_number
@heirarchy_number
end;T;+To;
; F; ;
;;;I"#NEAT::Neuron#heirarchy_number=;F;[[I"
value;T0;[[@i ;T;:heirarchy_number=;;;[�;{�;IC; "�(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.
;T; [�;[�; @o; 0; @s;!F;"@p;'@5;(I"!def heirarchy_number=(value);T;*I"Adef heirarchy_number=(value)
@heirarchy_number = value
end;T;+To;
; F; ;
;;;I"NEAT::Neuron#output;F;[�;[[@i!;T;: output;;;[�;{�;IC; ".This is true if this is an output neuron.
;T; [�;[�; I".This is true if this is an output neuron.;T; 0; @�;!F;"o;#;$F;%i ;&i ;'@5;(I"def output;T;*I" def output
@output
end;T;+To;
; F; ;
;;;I"NEAT::Neuron#output=;F;[[I"
value;T0;[[@i!;T;: output=;;;[�;{�;IC; ".This is true if this is an output neuron.
;T; [�;[�; @�; 0; @�;!F;"@�;'@5;(I"def output=(value);T;*I"-def output=(value)
@output = value
end;T;+To:+YARD::CodeObjects::ClassVariableObject;[[@i$;T;:@@neuron_types;;;;;[�;{�;IC; ""List of neuron types defined.
;T; [�;[�; I""List of neuron types defined.;T; 0; @�;!F;"o;#;$F;%i#;&i#;'@5;I"!NEAT::Neuron::@@neuron_types;F;(I"@@neuron_types = [];T;*I"@@neuron_types = [];T: @valueI"[];T;+To;
; F; ;G;;;I"NEAT::Neuron.input?;F;[�;[[@i';T;;H;;;[�;{�;IC; " Class is is of Input type?
;T; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I" Class is is of Input type?;T; 0; @�;!F;"o;#;$F;%i&;&i&;'@5;(I""def self.input? ; false ; end;T;)T;*I""def self.input? ; false ; end;T;+To;
; F; ;
;;;I"NEAT::Neuron#input?;F;[�;[[@i(;F;;H;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"�;T; 0;'@5;(I")def input? ; self.class.input? ; end;T;)T;*I")def input? ; self.class.input? ; end;T;+To;
; F; ;G;;;I"NEAT::Neuron.bias?;F;[�;[[@i*;F;:
bias?;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"�;T; 0;'@5;(I"!def self.bias? ; false ; end;T;)T;*I"!def self.bias? ; false ; end;T;+To;
; F; ;
;;;I"NEAT::Neuron#bias?;F;[�;[[@i+;F;;`;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"�;T; 0;'@5;(I"'def bias? ; self.class.bias? ; end;T;)T;*I"'def bias? ; self.class.bias? ; end;T;+To;
; F; ;
;;;I"NEAT::Neuron#output?;F;[�;[[@i.;T;: output?;;;[�;{�;IC; "%Instantiation is of outout type?
;T; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"%Instantiation is of outout type?;T; 0; @�;!F;"o;#;$F;%i-;&i-;'@5;(I""def output? ; !!@output ; end;T;)T;*I""def output? ; !!@output ; end;T;+To;
; F; ;G;;;I"NEAT::Neuron.inherited;F;[[I"
clazz;T0;[[@i0;F;:inherited;;;[�;{�;IC; "�
;T; @;/0;!F; [�;[o;I
;JI" private;F;K0;0;L0; @; I"�;T; 0;'@5;(I" def self.inherited(clazz);T;)T;*I"<def self.inherited(clazz)
@@neuron_types << clazz
end;T;+To;
; F; ;G;;;I" NEAT::Neuron.neuron_types;F;[�;[[@i5;T;:neuron_types;;;[�;{�;IC; ",List of distinct neuron types (classes)
;T; [�;[�; I",List of distinct neuron types (classes);T; 0; @;!F;"o;#;$F;%i4;&i4;'@5;(I"0def self.neuron_types; @@neuron_types ; end;T;)T;*I"0def self.neuron_types; @@neuron_types ; end;T;+To;
; F; ;
;;;I"NEAT::Neuron#express;F;[[I"
instance;T0;[[@i;;T;;M;;;[�;{�;IC; "�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.
;T; [�;[�; I"�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.;T; 0; @&;!F;"o;#;$F;%i7;&i:;'@5;(I"def express(instance);T;)T;*I"edef express(instance)
raise NeatException.new "express() must be implemented by subclass."
end;T;+T;:@5;;IC;[�;:@5;<IC;[o;= ;>0;?0;@0;:
Graph;'@;Bo; ;IC;[ o;F;IC;[�;:@;;;IC;[�;:@;;<IC;[�;:@;;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[I"lib/rubyneat/graph.rb;Ti;F;:GraphException;;;;;[�;{�;IC; "�
;T; @;;/0;!F; [�;[�; I"�;T; 0;'@9;I" NEAT::Graph::GraphException;F;To;= ;>0;?0;@0;:Exception;'@9;B0;C;G;+To;
; F; ;
;;;I" NEAT::Graph#clear_graph;F;[�;[[@Fi;T;:clear_graph;;;[�;{�;IC; "$clear and initialize the graph.
;T; [�;[�; I"$clear and initialize the graph.;T; 0; @O;!F;"o;#;$F;%i;&i;'@9;(I"def clear_graph;T;)T;*I")def clear_graph
@g_inputs = []
end;T;+To;
; F; ;
;;;I"NEAT::Graph#<<;F;[[I"
input;T0;[[@Fi;F;:<<;;;[�;{�;IC; "�
;T; @];/0;!F; [�;[�; I"�;T; 0;'@9;(I"def << (input);T;)T;*I"3def << (input)
@g_inputs << input
self
end;T;+To;
; F; ;
;;;I"NEAT::Graph#add;F;[[I"
input;T0;[[@Fi ;T;:add;;;[�;{�;IC; "Add a single input
;T; [�;[�; I"Add a single input;T; 0; @l;!F;"o;#;$F;%i ;&i ;'@9;(I"def add (input);T;)T;*I"-def add (input)
@g_inputs << input
end;T;+To;
; F; ;
;;;I"NEAT::Graph#inputs;F;[�;[[@Fi#;T;: inputs;;;[�;{�;IC; "Get list of inputs
;T; [�;[�; I"Get list of inputs;T; 0; @|;!F;"o;#;$F;%i";&i";'@9;(I"def inputs;T;)T;*I"ldef inputs
raise GraphException.new "Graph Failure -- input is nil" if @g_inputs.nil?
@g_inputs
end;T;+To;F;IC;[
o;
; F; ;
;;;I"/NEAT::Graph::DependencyResolver#initialize;F;[[I" outputs;T0[I" █T0;[[@Fi-;T;:initialize;;;[�;{�;IC; "cGiven a list of output nodes, we shall work backwards
from them to resolve their dependencies.
;T; [�;[o;I
;JI" return;F;KI")a new instance of DependencyResolver;T;0;L[I"DependencyResolver;F; @�; I"cGiven a list of output nodes, we shall work backwards
from them to resolve their dependencies.;T; 0; @�;!F;"o;#;$F;%i+;&i,;'@�;(I"$def initialize(outputs, &block);T;)T;*I"fdef initialize(outputs, &block)
@outputs = outputs
super
block.(self) unless block.nil?
end;T;+To;
; F; ;G;;;I"'NEAT::Graph::DependencyResolver.[];F;[[I"
*outs;T0;[[@Fi5;T;:[];;;[�;{�;IC; "`Create a DependencyResolver from either
an array of outputs or a parameter list of outputs.
;T; [�;[�; I"`Create a DependencyResolver from either
an array of outputs or a parameter list of outputs.;T; 0; @�;!F;"o;#;$F;%i3;&i4;'@�;(I"def self.[](*outs);T;)T;*I"jdef self.[](*outs)
outs = outs.first if outs.first.kind_of? Array
DependencyResolver.new outs
end;T;+To;
; F; ;
;;;I",NEAT::Graph::DependencyResolver#resolve;F;[�;[[@Fi=;T;: resolve;;;[�;{�;IC; "�Resolve dependencies, and return [dependency_list, circular_ref_node_list]
Note that circular_ref_node_list shall be nil if there are no dependencies!
;T; [�;[�; I"�Resolve dependencies, and return [dependency_list, circular_ref_node_list]
Note that circular_ref_node_list shall be nil if there are no dependencies!;T; 0; @�;!F;"o;#;$F;%i;;&i<;'@�;(I"def resolve;T;)T;*I"�def resolve
@resolved = []
@unresolved = []
@circular = []
@outputs.each do |onode|
rdep onode
end
[@resolved, @circular.empty? ? nil : @circular]
end;T;+To;
; F; ;
;;;I"-NEAT::Graph::DependencyResolver#resolve!;F;[�;[[@FiJ;T;:
resolve!;;;[�;{�;IC; "�Throw an exception if dependencies are found.
We only return the dependency list since we throw an exception on circular
dependencies.
;T; [�;[�; I"�Throw an exception if dependencies are found.
We only return the dependency list since we throw an exception on circular
dependencies.;T; 0; @�;!F;"o;#;$F;%iG;&iI;'@�;(I"def resolve!;T;)T;*I"|def resolve!
dl, cl = resolve
raise GraphException("Circular Dependency Detected: %s" % cl) unless cl.nil?
dl
end;T;+To;
; F; ;
;: private;I")NEAT::Graph::DependencyResolver#rdep;F;[[I" node;T0;[[@FiR;T;: rdep;;;[�;{�;IC; ""recursive resolution of nodes
;T; [�;[�; I""recursive resolution of nodes;T; 0; @�;!F;"o;#;$F;%iQ;&iQ;'@�;(I"def rdep(node);T;)T;*I"fdef 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;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@Fi);T;:DependencyResolver;;;;;[�;{�;IC; "LCreate an instantiation of this and pass it a list of nodes to resolve.
;T; [�;[�; I"LCreate an instantiation of this and pass it a list of nodes to resolve.;T; 0; @�;!F;"o;#;$F;%i(;&i(;'@9;I"$NEAT::Graph::DependencyResolver;F;To;= ;>0;?0;@0;: NeatOb;'@;Bo;F;IC;[ o;
; F; ;
;;;I"NEAT::NeatOb#name;F;[�;[[I" lib/rubyneat/rubyneat.rb;Ti\;T;: name;;;[�;{�;IC; "3Designation of this particular object instance
;T; [�;[�; I"3Designation of this particular object instance;T; 0; @�;!F;"o;#;$F;%i[;&i[;'@�;(I"
def name;T;*I"def name
@name
end;T;+To;
; F; ;
;;;I" NEAT::NeatOb#controller;F;[�;[[@�i_;T;:controller;;;[�;{�;IC; "Who's your daddy?
;T; [�;[�; I"Who's your daddy?;T; 0; @;!F;"o;#;$F;%i^;&i^;'@�;(I"def controller;T;*I"%def controller
@controller
end;T;+To;
; F; ;
;;;I"NEAT::NeatOb#log;F;[�;[[@�ia;F;:log;;;[�;{�;IC; "�
;T; @;/0;!F; [�;[�; I"�;T; 0;'@�;(I"def log ; $log ; end;T;)T;*I"def log ; $log ; end;T;+To;
; F; ;G;;;I"NEAT::NeatOb.log;F;[�;[[@�ib;F;;u;;;[�;{�;IC; "�
;T; @ ;/0;!F; [�;[�; I"�;T; 0;'@�;(I" def self.log ; $log; end;T;)T;*I" def self.log ; $log; end;T;+To;
; F; ;
;;;I" NEAT::NeatOb#initialize;F;[[I"controller;TI"nil;T[I" name;TI"nil;T;[[@�ih;T;;k;;;[�;{�;IC; "�Initializer for all NEAT objects. Requires that
the controller object is specified for all classes
with the exception of the Controller itself or the
Controller's NeatSettings.
;T; [�;[o;I
;JI" return;F;KI" a new instance of NeatOb;T;0;L[I" NeatOb;F; @*; I"�Initializer for all NEAT objects. Requires that
the controller object is specified for all classes
with the exception of the Controller itself or the
Controller's NeatSettings.;T; 0; @*;!F;"o;#;$F;%id;&ig;'@�;(I"1def initialize(controller = nil, name = nil);T;)T;*I"�def initialize(controller = nil, name = nil)
@name = unless name.nil?
name.to_sym
else
NEAT::random_name_generator
end
unless controller.nil?
@controller = controller
else
raise NeatException.new "Controller Needed!" unless self.is_a?(Controller) or self.is_a?(Controller::NeatSettings)
@controller = self unless self.is_a? Controller::NeatSettings
end
end;T;+To;
; F; ;
;;;I"NEAT::NeatOb#to_s;F;[�;[[@�iv;F;: to_s;;;[�;{�;IC; "�
;T; @C;/0;!F; [�;[�; I"�;T; 0;'@�;(I"
def to_s;T;)T;*I"6def to_s
"%s<%s>" % [self.class, self.name]
end;T;+T;:@�;;IC;[�;:@�;<IC;[o;= ;>0;?0;@0;:
DeepDive;'@�;B0;C;D;:@�;NIC;O{;GIC;O{�;PT;
IC;O{;sIC;O{: read@�:
write0;PT;tIC;O{;x@;y0;PT;PT;PT;Q{�;R[�;[[@�iW;T;;r;;;;;[�;{�;IC; " Basis of all NEAT objects
;T; [�;[�; I" Basis of all NEAT objects;T; 0; @�;!F;"o;#;$F;%iV;&iV;'@;I"NEAT::NeatOb;F;To;= ;>0;?0;@0;: Object;'@;B0;C;G;+T;C;G;+T;:@9;;IC;[�;:@9;<IC;[�;:@9;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@Fi;T;;d;;;;;[�;{�;IC; "�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.
;T; [�;[�; I"�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.;T; 0; @9;!F;"o;#;$F;%i ;&i;'@;I"NEAT::Graph;F;+T;C;Do;= ;>0;?0;@0;;A;'@5;B0;C;D;:@5;NIC;O{;GIC;O{�;PT;
IC;O{ ;VIC;O{;x@7;y0;PT;WIC;O{;x@E;y@R;PT;YIC;O{;x@e;y@s;PT;[IC;O{;x@�;y@�;PT;PT;PT;Q{�;R[�;[[@i;T;;U;;;;;[�;{�;IC; "�= 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.
;T; [�;[�; I"�= 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.;T; 0; @5;!F;"o;#;$F;%i;&i;'@;I"NEAT::Neuron;F;To;= ;>0;?0;@0;;r;'@;B@�;C;G;+T;C0;+To;F;IC;[
o;
; F; ;G;;;I"-NEAT::BasicNeuronTypes::BiasNeuron.bias?;F;[�;[[@i_;F;;`;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"�;T; 0;'@�;(I" def self.bias? ; true ; end;T;)T;*I" def self.bias? ; true ; end;T;+To;
; F; ;
;;;I"0NEAT::BasicNeuronTypes::BiasNeuron#neu_bias;F;[�;[[@i`;F;:
neu_bias;;;[�;{�;IC; ",Returns the value of attribute neu_bias
;T; @�;/0;!F; [�;[�; I",Returns the value of attribute neu_bias;T; 0;'@�;(I"def neu_bias;T;*I"!def neu_bias
@neu_bias
end;T;+To;
; F; ;
;;;I"1NEAT::BasicNeuronTypes::BiasNeuron#neu_bias=;F;[[I"
value;T0;[[@i`;F;:neu_bias=;;;[�;{�;IC; " Sets the attribute neu_bias
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"0the value to set the attribute neu_bias to.;T;I"
value;T;L0; @�; I"YSets the attribute neu_bias
@param value the value to set the attribute neu_bias to.;T; 0;'@�;(I"def neu_bias=(value);T;*I"1def neu_bias=(value)
@neu_bias = value
end;T;+To;
; F; ;
;;;I"2NEAT::BasicNeuronTypes::BiasNeuron#initialize;F;[[I"c;TI"nil;T[I"n;TI"nil;T;[[@ib;F;;k;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"!a new instance of BiasNeuron;T;0;L[I"BiasNeuron;F; @�; I"�;T; 0;'@�;(I"!def initialize(c=nil, n=nil);T;)T;*I"@def initialize(c=nil, n=nil)
super
@neu_bias = 1.00
end;T;+To;
; F; ;
;;;I"/NEAT::BasicNeuronTypes::BiasNeuron#express;F;[[I"
instance;T0;[[@ij;T;;M;;;[�;{�;IC; "�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
;T; [�;[�; I"�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;T; 0; @�;!F;"o;#;$F;%ig;ⅈ'@�;(I"def express(instance);T;)T;*I"Qdef express(instance)
instance.define_singleton_method(@name) { 1.00 }
end;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{;{IC;O{;x@�;y@�;PT;PT;PT;Q{�;R[�;[[@i^;T;:BiasNeuron;;;;;[�;{�;IC; "�= 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.
;T; [�;[�; I"�= 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.;T; 0; @�;!F;"o;#;$F;%i[;&i];'@�;I"'NEAT::BasicNeuronTypes::BiasNeuron;F;To;= ;>0;?0;@0;;S;'@�;B@�;C0;+To;F;IC;[o;
; F; ;
;;;I"2NEAT::BasicNeuronTypes::SigmoidNeuron#express;F;[[I"
instance;T0;[[@it;T;;M;;;[�;{�;IC; "screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh)
;T; [�;[�; I"screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh);T; 0; @�;!F;"o;#;$F;%ir;&is;'@�;(I"def express(instance);T;)T;*I"�def express(instance)
instance.define_singleton_method(@name) {|*inputs|
1.0 / (1.0 + exp(-4.9 * inputs.reduce {|p, q| p + q}))
}
end;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@iq;T;:SigmoidNeuron;;;;;[�;{�;IC; "rThe most commonly-used neuron for the hidden and output layers.
We use the Logistic Function for the Sigmoid.
;T; [�;[�; I"rThe most commonly-used neuron for the hidden and output layers.
We use the Logistic Function for the Sigmoid.;T; 0; @�;!F;"o;#;$F;%io;&ip;'@�;I"*NEAT::BasicNeuronTypes::SigmoidNeuron;F;To;= ;>0;?0;@0;;U;'@;B@5;C0;+To;F;IC;[o;
; F; ;
;;;I"/NEAT::BasicNeuronTypes::TanhNeuron#express;F;[[I"
instance;T0;[[@i;T;;M;;;[�;{�;IC; "screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh)
;T; [�;[�; I"screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh);T; 0; @ ;!F;"o;#;$F;%i};&i~;'@ ;(I"def express(instance);T;)T;*I"def express(instance)
instance.define_singleton_method(@name) {|*inputs|
tanh(2.4 * inputs.reduce {|p, q| p + q})
}
end;T;+T;:@ ;;IC;[�;:@ ;<IC;[�;:@ ;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@i|;T;:TanhNeuron;;;;;[�;{�;IC; "9An alternative Sigmoid Function, but ranges -1 to +1
;T; [�;[�; I"9An alternative Sigmoid Function, but ranges -1 to +1;T; 0; @ ;!F;"o;#;$F;%i{;&i{;'@�;I"'NEAT::BasicNeuronTypes::TanhNeuron;F;To;= ;>0;?0;@0;;U;'@;B@5;C0;+To;F;IC;[o;
; F; ;
;;;I"/NEAT::BasicNeuronTypes::SineNeuron#express;F;[[I"
instance;T0;[[@i�;T;;M;;;[�;{�;IC; "screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh)
;T; [�;[�; I"screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh);T; 0; @D;!F;"o;#;$F;%i�;&i�;'@B;(I"def express(instance);T;)T;*I"~def express(instance)
instance.define_singleton_method(@name) {|*inputs|
sin(1.6 * inputs.reduce {|p, q| p + q})
}
end;T;+T;:@B;;IC;[�;:@B;<IC;[�;:@B;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@i�;T;:SineNeuron;;;;;[�;{�;IC; "JSin function (CPPN) -- adjusted to have its +1 and -1 near TanhNeuron
;T; [�;[�; I"JSin function (CPPN) -- adjusted to have its +1 and -1 near TanhNeuron;T; 0; @B;!F;"o;#;$F;%i�;&i�;'@�;I"'NEAT::BasicNeuronTypes::SineNeuron;F;To;= ;>0;?0;@0;;U;'@;B@5;C0;+To;F;IC;[o;
; F; ;
;;;I"1NEAT::BasicNeuronTypes::CosineNeuron#express;F;[[I"
instance;T0;[[@i�;T;;M;;;[�;{�;IC; "screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh)
;T; [�;[�; I"screate a function on the instance with our name
that sums all inputs and produce a sigmoid output (using tanh);T; 0; @h;!F;"o;#;$F;%i�;&i�;'@f;(I"def express(instance);T;)T;*I"~def express(instance)
instance.define_singleton_method(@name) {|*inputs|
cos(1.6 * inputs.reduce {|p, q| p + q})
}
end;T;+T;:@f;;IC;[�;:@f;<IC;[�;:@f;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@i�;T;:CosineNeuron;;;;;[�;{�;IC; "MCosine function (CPPN) -- adjusted to have its +1 and -1 near TanhNeuron
;T; [�;[�; I"MCosine function (CPPN) -- adjusted to have its +1 and -1 near TanhNeuron;T; 0; @f;!F;"o;#;$F;%i�;&i�;'@�;I")NEAT::BasicNeuronTypes::CosineNeuron;F;To;= ;>0;?0;@0;;U;'@;B@5;C0;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@iJ;T;;E;;;;;[�;{�;IC; "�= 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.
;T; [�;[�; I"�= 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.
;T; 0; @�;!F;"o;#;$F;%iC;&iI;'@;I"NEAT::BasicNeuronTypes;F;+T;C;Do;= ;>0;?0;@0;: NEAT;'@;B@;C;D;:@
;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@i;F;:DSL;;;;;[�;{�;IC; "�
;T; @
;/0;!F; [�;[�; I"�;T; 0;'@;I"NEAT::DSL;F;+T@9@5@�o;F;IC;[o;
; F; ;
;;;I" NEAT::Critter#population;F;[�;[[I" lib/rubyneat/critter.rb;Ti;F;:population;;;[�;{�;IC; ".Returns the value of attribute population
;T; @�;/0;!F; [�;[�; I".Returns the value of attribute population;T; 0;'@�;(I"def population;T;*I"%def population
@population
end;T;+To;
; F; ;
;;;I"NEAT::Critter#genotype;F;[�;[[@�i;F;;V;;;[�;{�;IC; ",Returns the value of attribute genotype
;T; @�;/0;!F; [�;[�; I",Returns the value of attribute genotype;T; 0;'@�;(I"def genotype;T;*I"!def genotype
@genotype
end;T;+To;
; F; ;
;;;I" NEAT::Critter#genotype=;F;[[I"
value;T0;[[@�i;F;:genotype=;;;[�;{�;IC; " Sets the attribute genotype
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"0the value to set the attribute genotype to.;T;I"
value;T;L0; @�; I"YSets the attribute genotype
@param value the value to set the attribute genotype to.;T; 0;'@�;(I"def genotype=(value);T;*I"1def genotype=(value)
@genotype = value
end;T;+To;
; F; ;
;;;I" NEAT::Critter#phenotype;F;[�;[[@�i;F;:phenotype;;;[�;{�;IC; "-Returns the value of attribute phenotype
;T; @�;/0;!F; [�;[�; I"-Returns the value of attribute phenotype;T; 0;'@�;(I"def phenotype;T;*I"#def phenotype
@phenotype
end;T;+To;
; F; ;
;;;I" NEAT::Critter#phenotype=;F;[[I"
value;T0;[[@�i;F;:phenotype=;;;[�;{�;IC; "!Sets the attribute phenotype
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"1the value to set the attribute phenotype to.;T;I"
value;T;L0; @�; I"[Sets the attribute phenotype
@param value the value to set the attribute phenotype to.;T; 0;'@�;(I"def phenotype=(value);T;*I"3def phenotype=(value)
@phenotype = value
end;T;+To;
; F; ;
;;;I"NEAT::Critter#fitness;F;[�;[[@�i;T;;0;;;[�;{�;IC; ""Ratings assigned by Evaluator
;T; [�;[�; I""Ratings assigned by Evaluator;T; 0; @�;!F;"o;#;$F;%i;&i;'@�;(I"def fitness;T;*I" def fitness
@fitness
end;T;+To;
; F; ;
;;;I"NEAT::Critter#fitness=;F;[[I"
value;T0;[[@�i;T;:
fitness=;;;[�;{�;IC; ""Ratings assigned by Evaluator
;T; [�;[�; @; 0; @;!F;"@;'@�;(I"def fitness=(value);T;*I"/def fitness=(value)
@fitness = value
end;T;+To;
; F; ;
;;;I"NEAT::Critter#novelty;F;[�;[[@�i;T;: novelty;;;[�;{�;IC; ""Ratings assigned by Evaluator
;T; [�;[�; @; 0; @;!F;"@;'@�;(I"def novelty;T;*I" def novelty
@novelty
end;T;+To;
; F; ;
;;;I"NEAT::Critter#novelty=;F;[[I"
value;T0;[[@�i;T;:
novelty=;;;[�;{�;IC; ""Ratings assigned by Evaluator
;T; [�;[�; @; 0; @";!F;"@;'@�;(I"def novelty=(value);T;*I"/def novelty=(value)
@novelty = value
end;T;+To;
; F; ;
;;;I" NEAT::Critter#initialize;F;[[I"pop;T0[I" mating;TI"
false;T[I" █T0;[[@�i;T;;k;;;[�;{�;IC; "rCritter construction. We construct the genotype.
The phenotype will be constructed by the Expressor operator.
;T; [�;[o;I
;JI" return;F;KI" a new instance of Critter;T;0;L[I" Critter;F; @0; I"rCritter construction. We construct the genotype.
The phenotype will be constructed by the Expressor operator.;T; 0; @0;!F;"o;#;$F;%i;&i;'@�;(I"0def initialize(pop, mating = false, &block);T;)T;*I"�def initialize(pop, mating = false, &block)
super pop.controller
@population = pop
@genotype = Genotype.new(self, mating)
block.(self) unless block.nil?
end;T;+To;
; F; ;
;;;I"(NEAT::Critter#ready_for_expression!;F;[�;[[@�i";T;:ready_for_expression!;;;[�;{�;IC; "FGet the Critter ready for the Expressor to
express the geneotype.
;T; [�;[�; I"FGet the Critter ready for the Expressor to
express the geneotype.;T; 0; @J;!F;"o;#;$F;%i ;&i!;'@�;(I" def ready_for_expression!;T;)T;*I"odef ready_for_expression!
@genotype.wire!
@phenotype = NEAT::Critter::Phenotype[self]
@phenotype
end;T;+To;
; F; ;
;;;I"NEAT::Critter#express!;F;[�;[[@�i);T;:
express!;;;[�;{�;IC; "5Exoress this critter using the Expressor plugin.
;T; [�;[�; I"5Exoress this critter using the Expressor plugin.;T; 0; @X;!F;"o;#;$F;%i(;&i(;'@�;(I"def express!;T;)T;*I";def express!
@controller.expressor.express! self
end;T;+To;
; F; ;
;;;I"&NEAT::Critter#initialize_neurons!;F;[�;[[@�i0;T;:initialize_neurons!;;;[�;{�;IC; "�This initializes neurons in preparation for recurrence.
Note that the Critter should already have expressed its
genotype before this is called.
;T; [�;[�; I"�This initializes neurons in preparation for recurrence.
Note that the Critter should already have expressed its
genotype before this is called.;T; 0; @f;!F;"o;#;$F;%i-;&i/;'@�;(I" def initialize_neurons!;T;)T;*I"@def initialize_neurons!
@phenotype.initialize_neurons
end;T;+To;
; F; ;
;;;I" NEAT::Critter#evaluate!;F;[�;[[@�i7;T;:evaluate!;;;[�;{�;IC; "_A single evaluation step. Evaluate and
generate fitness, novelty, etc.
Returns the result.
;T; [�;[�; I"_A single evaluation step. Evaluate and
generate fitness, novelty, etc.
Returns the result.;T; 0; @t;!F;"o;#;$F;%i4;&i6;'@�;(I"def evaluate!;T;)T;*I"=def evaluate!
@controller.evaluator.evaluate! self
end;T;+To;F;IC;[ o;
; F; ;
;;;I"$NEAT::Critter::Genotype#critter;F;[�;[[@�iH;T;: critter;;;[�;{�;IC; " Critter to which we belong
;T; [�;[�; I" Critter to which we belong;T; 0; @�;!F;"o;#;$F;%iG;&iG;'@�;(I"def critter;T;*I" def critter
@critter
end;T;+To;
; F; ;
;;;I"%NEAT::Critter::Genotype#critter=;F;[[I"
value;T0;[[@�iH;T;:
critter=;;;[�;{�;IC; " Critter to which we belong
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I"def critter=(value);T;*I"/def critter=(value)
@critter = value
end;T;+To;
; F; ;
;;;I""NEAT::Critter::Genotype#genes;F;[�;[[@�iK;T;:
genes;;;[�;{�;IC; "&Genes keyed by innovation numbers
;T; [�;[�; I"&Genes keyed by innovation numbers;T; 0; @�;!F;"o;#;$F;%iJ;&iJ;'@�;(I"def genes;T;*I"def genes
@genes
end;T;+To;
; F; ;
;;;I"#NEAT::Critter::Genotype#genes=;F;[[I"
value;T0;[[@�iK;T;: genes=;;;[�;{�;IC; "&Genes keyed by innovation numbers
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I"def genes=(value);T;*I"+def genes=(value)
@genes = value
end;T;+To;
; F; ;
;;;I"$NEAT::Critter::Genotype#neurons;F;[�;[[@�iN;T;: neurons;;;[�;{�;IC; "#List of neurons hashed by name
;T; [�;[�; I"#List of neurons hashed by name;T; 0; @�;!F;"o;#;$F;%iM;&iM;'@�;(I"def neurons;T;*I" def neurons
@neurons
end;T;+To;
; F; ;
;;;I"%NEAT::Critter::Genotype#neurons=;F;[[I"
value;T0;[[@�iN;T;:
neurons=;;;[�;{�;IC; "#List of neurons hashed by name
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I"def neurons=(value);T;*I"/def neurons=(value)
@neurons = value
end;T;+To;
; F; ;
;;;I"*NEAT::Critter::Genotype#neural_inputs;F;[�;[[@�iQ;T;:neural_inputs;;;[�;{�;IC; "0Instantiations of neural inputs and outputs
;T; [�;[�; I"0Instantiations of neural inputs and outputs;T; 0; @�;!F;"o;#;$F;%iP;&iP;'@�;(I"def neural_inputs;T;*I"+def neural_inputs
@neural_inputs
end;T;+To;
; F; ;
;;;I"+NEAT::Critter::Genotype#neural_outputs;F;[�;[[@�iQ;T;:neural_outputs;;;[�;{�;IC; "0Instantiations of neural inputs and outputs
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I"def neural_outputs;T;*I"-def neural_outputs
@neural_outputs
end;T;+To;
; F; ;
;;;I"-NEAT::Critter::Genotype#dangling_neurons;F;[�;[[@�iT;T;:dangling_neurons;;;[�;{�;IC; "<This will be set to true if there are dangling neurons.
;T; [�;[�; I"<This will be set to true if there are dangling neurons.;T; 0; @�;!F;"o;#;$F;%iS;&iS;'@�;(I"def dangling_neurons;T;*I"1def dangling_neurons
@dangling_neurons
end;T;+To;
; F; ;
;;;I".NEAT::Critter::Genotype#dangling_neurons=;F;[[I"
value;T0;[[@�iT;T;:dangling_neurons=;;;[�;{�;IC; "<This will be set to true if there are dangling neurons.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I"!def dangling_neurons=(value);T;*I"Adef dangling_neurons=(value)
@dangling_neurons = value
end;T;+To;
; F; ;
;;;I".NEAT::Critter::Genotype#dangling_neurons?;F;[�;[[@�iU;F;:dangling_neurons?;;;[�;{�;IC; "<This will be set to true if there are dangling neurons.;T; @;/0;!F; [�;[�; I"=This will be set to true if there are dangling neurons.
;T; 0;"0;'@�;(@�;*I"1def dangling_neurons
@dangling_neurons
end;T;+To;
; F; ;
;;;I",NEAT::Critter::Genotype#neural_gene_map;F;[�;[[@�i[;T;:neural_gene_map;;;[�;{�;IC; "�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
;T; [�;[�; I"�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;T; 0; @;!F;"o;#;$F;%iW;&iZ;'@�;(I"def neural_gene_map;T;*I"/def neural_gene_map
@neural_gene_map
end;T;+To;
; F; ;
;;;I"'NEAT::Critter::Genotype#initialize;F;[[I" critter;T0[I" mating;TI"
false;T[I" █T0;[[@�i];F;;k;;;[�;{�;IC; "�
;T; @(;/0;!F; [�;[o;I
;JI" return;F;KI" a new instance of Genotype;T;0;L[I"
Genotype;F; @(; I"�;T; 0;'@�;(I"4def initialize(critter, mating = false, &block);T;)T;*I"�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;T;+To;
; F; ;
;;;I"&NEAT::Critter::Genotype#neucleate;F;[[I" clean:;TI" true;T[I" █T0;[[@�iv;T;:neucleate;;;[�;{�;IC; "sWe add genes given here to the genome.
An array of genes is returned from the block
and we simply add them in.
;T; [�;[o;I
;JI"
param;F;K0;I"
clean;T;L[I" boolean;T; @Ao;I
;JI"
param;F;K0;I"
block;T;L[I" Proc;T; @A; I"�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;T; 0; @A;!F;"o;#;$F;%iq;&iu;'@�;(I"'def neucleate(clean: true, &block);T;)T;*I"�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;T;+To;
; F; ;
;;;I"/NEAT::Critter::Genotype#nuke_redundancies!;F;[�;[[@�i�;T;:nuke_redundancies!;;;[�;{�;IC; "�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!
;T; [�;[�; I"�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!;T; 0; @^;!F;"o;#;$F;%i};&i�;'@�;(I"def nuke_redundancies!;T;)T;*I"Cdef nuke_redundancies!
log.warn 'nuke_redundancies! NIY'
end;T;+To;
; F; ;
;;;I"$NEAT::Critter::Genotype#forget!;F;[�;[[@�i�;T;: forget!;;;[�;{�;IC; "*Make the neurons forget their wiring.
;T; [�;[�; I"*Make the neurons forget their wiring.;T; 0; @l;!F;"o;#;$F;%i�;&i�;'@�;(I"def forget!;T;)T;*I"vdef forget!
@neurons.each { |name, neu| neu.clear_graph }
@neural_gene_map = Hash.new {|h, k| h[k] = [] }
end;T;+To;
; F; ;
;;;I""NEAT::Critter::Genotype#wire!;F;[�;[[@�i�;T;:
wire!;;;[�;{�;IC; ",Wire up the neurons based on the genes.
;T; [�;[�; I",Wire up the neurons based on the genes.;T; 0; @z;!F;"o;#;$F;%i�;&i�;'@�;(I"def wire!;T;)T;*I"�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;T;+To;
; F; ;
;;;I"(NEAT::Critter::Genotype#add_neurons;F;[[I"
*neus;T0;[[@�i�;T;:add_neurons;;;[�;{�;IC; " Add new neurons to the fold
;T; [�;[�; I" Add new neurons to the fold;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;(I"def add_neurons(*neus);T;)T;*I"Wdef add_neurons(*neus)
neus.each do |neu|
@neurons[neu.name] = neu
end
end;T;+To;
; F; ;
;;;I"&NEAT::Critter::Genotype#add_genes;F;[[I" *genes;T0;[[@�i�;T;:add_genes;;;[�;{�;IC; "bGenes added here MUST correspond to pre-existing neurons.
Be sure to do add_neurons first!!!!
;T; [�;[�; I"bGenes added here MUST correspond to pre-existing neurons.
Be sure to do add_neurons first!!!!;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;(I"def add_genes(*genes);T;)T;*I"'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;T;+To;
; F; ;
;;;I"'NEAT::Critter::Genotype#innervate!;F;[[I" *hneus;T0;[[@�i�;T;:innervate!;;;[�;{�;IC; "�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.
;T; [�;[o;I
;JI"
param;F;KI"&-- hashes of neurons to innervate;T;I"
hneus;T;L[I" Hash;T; @�; I"�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;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;(I"def innervate!(*hneus);T;)T;*I"\def innervate!(*hneus)
hneus.each do |neus|
@neurons.merge! neus.dclone
end
end;T;+To;
; F; ;
;;;I"#NEAT::Critter::Genotype#prune!;F;[�;[[@�i�;T;: prune!;;;[�;{�;IC; ":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!
;T; [�;[�; I":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!;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;(I"def prune!;T;)T;*I"�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;T;+To;
; F; ;
;;;I")NEAT::Critter::Genotype#fitness_cost;F;[�;[[@�i�;T;:fitness_cost;;;[�;{�;IC; ")Calculate the cost of this genotype.
;T; [�;[�; I")Calculate the cost of this genotype.;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;(I"def fitness_cost;T;)T;*I"�def fitness_cost
p = @controller.parms
p.fitness_cost_per_neuron * @neurons.size + p.fitness_cost_per_gene * @genes.size
end;T;+To;
; F; ;
;;;I"#NEAT::Critter::Genotype#dump_s;F;[�;[[@�i�;F;: dump_s;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@�;(I"def dump_s;T;)T;*I"�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;T;+To;F;IC;[o;
; F; ;
;;;I"+NEAT::Critter::Genotype::Gene#genotype;F;[�;[[@�i�;T;;V;;;[�;{�;IC; "parent genotype
;T; [�;[�; I"parent genotype;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;(I"def genotype;T;*I"!def genotype
@genotype
end;T;+To;
; F; ;
;;;I",NEAT::Critter::Genotype::Gene#genotype=;F;[[I"
value;T0;[[@�i�;T;;�;;;[�;{�;IC; "parent genotype
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I"def genotype=(value);T;*I"1def genotype=(value)
@genotype = value
end;T;+To;
; F; ;
;;;I"-NEAT::Critter::Genotype::Gene#innovation;F;[�;[[@�i�;T;:innovation;;;[�;{�;IC; "innovation number
;T; [�;[�; I"innovation number;T; 0; @;!F;"o;#;$F;%i�;&i�;'@�;(I"def innovation;T;*I"%def innovation
@innovation
end;T;+To;
; F; ;
;;;I".NEAT::Critter::Genotype::Gene#innovation=;F;[[I"
value;T0;[[@�i�;T;:innovation=;;;[�;{�;IC; "innovation number
;T; [�;[�; @; 0; @;!F;"@;'@�;(I"def innovation=(value);T;*I"5def innovation=(value)
@innovation = value
end;T;+To;
; F; ;
;;;I",NEAT::Critter::Genotype::Gene#in_neuron;F;[�;[[@�i�;T;:in_neuron;;;[�;{�;IC; "\input neuron's name (where our output goes)
ouptut neuron's name (neuron to be queried)
;T; [�;[�; I"\input neuron's name (where our output goes)
ouptut neuron's name (neuron to be queried);T; 0; @!;!F;"o;#;$F;%i�;&i�;'@�;(I"def in_neuron;T;*I"#def in_neuron
@in_neuron
end;T;+To;
; F; ;
;;;I"-NEAT::Critter::Genotype::Gene#in_neuron=;F;[[I"
value;T0;[[@�i�;T;:in_neuron=;;;[�;{�;IC; "\input neuron's name (where our output goes)
ouptut neuron's name (neuron to be queried)
;T; [�;[�; @+; 0; @/;!F;"@,;'@�;(I"def in_neuron=(value);T;*I"3def in_neuron=(value)
@in_neuron = value
end;T;+To;
; F; ;
;;;I"-NEAT::Critter::Genotype::Gene#out_neuron;F;[�;[[@�i�;T;:out_neuron;;;[�;{�;IC; "\input neuron's name (where our output goes)
ouptut neuron's name (neuron to be queried)
;T; [�;[�; @+; 0; @=;!F;"@,;'@�;(I"def out_neuron;T;*I"%def out_neuron
@out_neuron
end;T;+To;
; F; ;
;;;I".NEAT::Critter::Genotype::Gene#out_neuron=;F;[[I"
value;T0;[[@�i�;T;:out_neuron=;;;[�;{�;IC; "\input neuron's name (where our output goes)
ouptut neuron's name (neuron to be queried)
;T; [�;[�; @+; 0; @I;!F;"@,;'@�;(I"def out_neuron=(value);T;*I"5def out_neuron=(value)
@out_neuron = value
end;T;+To;
; F; ;
;;;I")NEAT::Critter::Genotype::Gene#weight;F;[�;[[@�i�;T;: weight;;;[�;{�;IC; " weight of the connection
;T; [�;[�; I" weight of the connection;T; 0; @W;!F;"o;#;$F;%i�;&i�;'@�;(I"def weight;T;*I" def weight
@weight
end;T;+To;
; F; ;
;;;I"*NEAT::Critter::Genotype::Gene#weight=;F;[[I"
value;T0;[[@�i�;T;: weight=;;;[�;{�;IC; " weight of the connection
;T; [�;[�; @a; 0; @e;!F;"@b;'@�;(I"def weight=(value);T;*I"-def weight=(value)
@weight = value
end;T;+To;
; F; ;
;;;I"*NEAT::Critter::Genotype::Gene#enabled;F;[�;[[@�i�;T;: enabled;;;[�;{�;IC; "Is this gene enabled?
;T; [�;[�; I"Is this gene enabled?;T; 0; @s;!F;"o;#;$F;%i�;&i�;'@�;(I"def enabled;T;*I" def enabled
@enabled
end;T;+To;
; F; ;
;;;I"+NEAT::Critter::Genotype::Gene#enabled=;F;[[I"
value;T0;[[@�i�;T;:
enabled=;;;[�;{�;IC; "Is this gene enabled?
;T; [�;[�; @}; 0; @�;!F;"@~;'@�;(I"def enabled=(value);T;*I"/def enabled=(value)
@enabled = value
end;T;+To;
; F; ;
;;;I"-NEAT::Critter::Genotype::Gene#initialize;F;[[I"
genotype;T0[I" █T0;[[@�i�;F;;k;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"a new instance of Gene;T;0;L[I" Gene;F; @�; I"�;T; 0;'@�;(I"%def initialize(genotype, &block);T;)T;*I"�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;T;+To;
; F; ;
;;;I"+NEAT::Critter::Genotype::Gene#enabled?;F;[�;[[@�i�;F;:
enabled?;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"�;T; 0;'@�;(I""def enabled? ; @enabled ; end;T;)T;*I""def enabled? ; @enabled ; end;T;+To;
; F; ;
;;;I",NEAT::Critter::Genotype::Gene#disabled?;F;[�;[[@�i;F;:disabled?;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"�;T; 0;'@�;(I"'def disabled? ; not enabled? ; end;T;)T;*I"'def disabled? ; not enabled? ; end;T;+To;
; F; ;G;;;I"%NEAT::Critter::Genotype::Gene.[];F;[
[I"
genotype;T0[I"
input;T0[I" output;T0[I" weight;TI"0.0;T[I"
innov;TI"nil;T;[[@�i ;T;;l;;;[�;{�;IC; "�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)
;T; [�;[�; I"�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);T; 0; @�;!F;"o;#;$F;%i;&i;'@�;(I"Ddef self.[](genotype, input, output, weight = 0.0, innov = nil);T;)T;*I"!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;T;+To;
; F; ;
;;;I"'NEAT::Critter::Genotype::Gene#to_s;F;[�;[[@�i;F;;v;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@�;(I"
def to_s;T;)T;*I"Rdef to_s
super + "[i%s,w%s,%s]" % [@innovation, @weight, self.enabled?]
end;T;+To;
; F; ;
;;;I")NEAT::Critter::Genotype::Gene#dump_s;F;[�;[[@�i;F;;�;;;[�;{�;IC; "�;T; @�;/0;!F; [�;[�; I"
;T; 0;"0;'@�;(@�;*I"Rdef to_s
super + "[i%s,w%s,%s]" % [@innovation, @weight, self.enabled?]
end;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{ ;VIC;O{;x@�;y@�;PT;�IC;O{;x@;y@;PT;�IC;O{;x@!;y@/;PT;�IC;O{;x@=;y@I;PT;�IC;O{;x@W;y@e;PT;�IC;O{;x@s;y@�;PT;PT;PT;Q{@�;v;R[�;[[@�i�;T;: Gene;;;;;[�;{�;IC; "�= 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
;T; [�;[�; I"�= 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;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;I""NEAT::Critter::Genotype::Gene;F;To;= ;>0;?0;@0;;r;'@;B@�;C;G;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{ ;�IC;O{;x@�;y@�;PT;�IC;O{;x@�;y@�;PT;�IC;O{;x@�;y@�;PT;�IC;O{;x@�;y0;PT;�IC;O{;x@�;y0;PT;�IC;O{;x@�;y@�;PT;�IC;O{;x@;y0;PT;PT;PT;Q{@;�;R[�;[[@�iF;T;:
Genotype;;;;;[�;{�;IC; ",= 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.
;T; [�;[�; I"-= 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.
;T; 0; @�;!F;"o;#;$F;%i;;&iE;'@�;I" NEAT::Critter::Genotype;F;To;= ;>0;?0;@0;;r;'@;B@�;C;G;+To;F;IC;[
o;
; F; ;
;;;I"%NEAT::Critter::Phenotype#critter;F;[�;[[@�i!;T;;�;;;[�;{�;IC; " Critter to which we belong
;T; [�;[�; I" Critter to which we belong;T; 0; @/;!F;"o;#;$F;%i ;&i ;'@-;(I"def critter;T;*I" def critter
@critter
end;T;+To;
; F; ;
;;;I"&NEAT::Critter::Phenotype#critter=;F;[[I"
value;T0;[[@�i!;T;;�;;;[�;{�;IC; " Critter to which we belong
;T; [�;[�; @9; 0; @=;!F;"@:;'@-;(I"def critter=(value);T;*I"/def critter=(value)
@critter = value
end;T;+To;
; F; ;
;;;I""NEAT::Critter::Phenotype#code;F;[�;[[@�i$;T;: code;;;[�;{�;IC; "<Expressed code as a string (that was instance_eval()ed)
;T; [�;[�; I"<Expressed code as a string (that was instance_eval()ed);T; 0; @K;!F;"o;#;$F;%i#;&i#;'@-;(I"
def code;T;*I"def code
@code
end;T;+To;
; F; ;
;;;I"#NEAT::Critter::Phenotype#code=;F;[[I"
value;T0;[[@�i$;T;:
code=;;;[�;{�;IC; "<Expressed code as a string (that was instance_eval()ed)
;T; [�;[�; @U; 0; @Y;!F;"@V;'@-;(I"def code=(value);T;*I")def code=(value)
@code = value
end;T;+To;
; F; ;G;;;I" NEAT::Critter::Phenotype.[];F;[[I" critter;T0;[[@�i&;F;;l;;;[�;{�;IC; "�
;T; @g;/0;!F; [�;[�; I"�;T; 0;'@-;(I"def self.[](critter);T;)T;*I"�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;T;+To;
; F; ;
;;;I"&NEAT::Critter::Phenotype#express!;F;[�;[[@�i.;T;;�;;;[�;{�;IC; "+Take what is in code and express that!
;T; [�;[�; I"+Take what is in code and express that!;T; 0; @v;!F;"o;#;$F;%i-;&i-;'@-;(I"def express!;T;)T;*I"2def express!
instance_eval @code
self
end;T;+To;
; F; ;
;;;I"'NEAT::Critter::Phenotype#stimulate;F;[�;[[@�i6;T;:stimulate;;;[�;{�;IC; "�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...
;T; [�;[�; I"�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...;T; 0; @�;!F;"o;#;$F;%i3;&i5;'@-;(I"def stimulate;T;)T;*I" def stimulate
nil
end;T;+To;
; F; ;
;;;I""NEAT::Critter::Phenotype#to_s;F;[�;[[@�i;;T;;v;;;[�;{�;IC; " This gives us a complete
;T; [�;[�; I" This gives us a complete;T; 0; @�;!F;"o;#;$F;%i:;&i:;'@-;(I"
def to_s;T;)T;*I"0def to_s
"## %s\n%s" % [super, @code]
end;T;+T;:@-;;IC;[�;:@-;<IC;[o;= ;>0;?0;@0;;A;'@-;B0;C;D;:@-;NIC;O{;GIC;O{�;PT;
IC;O{;�IC;O{;x@/;y@=;PT;�IC;O{;x@K;y@Y;PT;PT;PT;Q{�;R[�;[[@�i ;T;:Phenotype;;;;;[�;{�;IC; "@= Phenotype part of the Critter
This is created by Evolver.
;T; [�;[�; I"A= Phenotype part of the Critter
This is created by Evolver. ;T; 0; @-;!F;"o;#;$F;%i;&i ;'@�;I" NEAT::Critter::Phenotype;F;To;= ;>0;?0;@0;;r;'@;B@�;C;G;+To;
; F; ;
;;;I"NEAT::Critter#compare;F;[[I"oc;T0;[[@�iM;T;;1;;;[�;{�;IC; "�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.
;T; [�;[�; I"�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.;T; 0; @�;!F;"o;#;$F;%i@;&iL;'@�;(I"def compare(oc);T;)T;*I"�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;T;+To;
; F; ;
;;;I"NEAT::Critter#dump_s;F;[�;[[@�iX;T;;�;;;[�;{�;IC; "Critter print
;T; [�;[�; I"Critter print;T; 0; @�;!F;"o;#;$F;%iW;&iW;'@�;(I"def dump_s;T;)T;*I"Mdef dump_s
to_s + @genotype.dump_s + "\n" + @phenotype.to_s + "\n"
end;T;+To;
; F; ;
;;o;I"NEAT::Critter#excess;F;[[I"oc;T0;[[@�i^;T;: excess;;;[�;{�;IC; " Return a count of excesses.
;T; [�;[�; I" Return a count of excesses.;T; 0; @�;!F;"o;#;$F;%i];&i];'@�;(I"def excess(oc);T;)T;*I"Mdef excess(oc)
(@genotype.genes.size - oc.genotype.genes.size).abs
end;T;+To;
; F; ;
;;o;I"NEAT::Critter#disjoint;F;[[I"oc;T0;[[@�ic;T;:
disjoint;;;[�;{�;IC; "'Return the count of disjoint genes
;T; [�;[�; I"'Return the count of disjoint genes;T; 0; @�;!F;"o;#;$F;%ib;&ib;'@�;(I"def disjoint(oc);T;)T;*I"|def disjoint(oc)
a = @genotype.genes.keys
b = oc.genotype.genes.keys
(a - b).size + (b - a).size - excess(oc)
end;T;+To;
; F; ;
;;o;I" NEAT::Critter#weight_diff;F;[[I"oc;T0;[[@�ij;F;:weight_diff;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@�;(I"def weight_diff(oc);T;)T;*I"�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;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{
;IC;O{;x@�;y0;PT;VIC;O{;x@�;y@�;PT;�IC;O{;x@�;y@�;PT;0IC;O{;x@�;y@;PT;�IC;O{;x@;y@";PT;PT;PT;Q{�;R[�;[[@�i;T;: Critter;;;;;[�;{�;IC; "z= Critters for NEAT
The Critter class comprises a Genotype and a Phenotype.
The Genotype comprises Genes and Neurons.
;T; [�;[�; I"z= Critters for NEAT
The Critter class comprises a Genotype and a Phenotype.
The Genotype comprises Genes and Neurons.;T; 0; @�;!F;"o;#;$F;%i
;&i;'@;I"NEAT::Critter;F;To;= ;>0;?0;@0;;r;'@;B@�;C;G;+To;F;IC;[o;
; F; ;
;;;I"NEAT::Evolver#npop;F;[�;[[I" lib/rubyneat/evolver.rb;Ti;F;: npop;;;[�;{�;IC; "(Returns the value of attribute npop
;T; @ ;/0;!F; [�;[�; I"(Returns the value of attribute npop;T; 0;'@ ;(I"
def npop;T;*I"def npop
@npop
end;T;+To;
; F; ;
;;;I" NEAT::Evolver#initialize;F;[[I"c;T0;[[@ i;F;;k;;;[�;{�;IC; "�
;T; @) ;/0;!F; [�;[o;I
;JI" return;F;KI" a new instance of Evolver;T;0;L[I" Evolver;F; @) ; I"�;T; 0;'@ ;(I"def initialize(c);T;)T;*I"Edef initialize(c)
super
@critter_op = CritterOp.new self
end;T;+To;
; F; ;
;;;I"%NEAT::Evolver#gen_initial_genes!;F;[[I"
genotype;T0;[[@ i;T;:gen_initial_genes!;;;[�;{�;IC; "`Generate the initial genes for a given genotype.
We key genes off their innovation numbers.
;T; [�;[�; I"`Generate the initial genes for a given genotype.
We key genes off their innovation numbers.;T; 0; @= ;!F;"o;#;$F;%i;&i;'@ ;(I"%def gen_initial_genes!(genotype);T;)T;*I"#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;T;+To;
; F; ;
;;;I"NEAT::Evolver#mutate!;F;[[I"population;T0;[[@ i$;T;: mutate!;;;[�;{�;IC; "#Here we mutate the population.
;T; [�;[�; I"#Here we mutate the population.;T; 0; @M ;!F;"o;#;$F;%i#;&i#;'@ ;(I" def mutate!(population);T;)T;*I"�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;T;+To;
; F; ;
;;;I"NEAT::Evolver#evolve;F;[[I"population;T0;[[@ i:;T;;,;;;[�;{�;IC; "�Here we clone the population and then evolve it
on the basis of fitness and novelty, etc.
Returns the newly-evolved population.
;T; [�;[�; I"�Here we clone the population and then evolve it
on the basis of fitness and novelty, etc.
Returns the newly-evolved population.;T; 0; @] ;!F;"o;#;$F;%i6;&i9;'@ ;(I"def evolve(population);T;)T;*I"�def evolve(population)
@npop = population.dclone
# Population sorting and evaluation for breeding, mutations, etc.
prepare_speciation!
prepare_fitness!
prepare_novelty!
mate!
return @npop
end;T;+To;
; F; ;
;:protected;I"&NEAT::Evolver#prepare_speciation!;F;[�;[[@ iJ;F;:prepare_speciation!;;;[�;{�;IC; "�
;T; @m ;/0;!F; [�;[�; I"�;T; 0;'@ ;(I" def prepare_speciation!;T;)T;*I"cdef prepare_speciation!
@npop.speciate!
log.debug "SPECIES:"
NEAT::dpp @npop.species
end;T;+To;
; F; ;
;;�;I"#NEAT::Evolver#prepare_fitness!;F;[�;[[@ iW;T;:prepare_fitness!;;;[�;{�;IC; "zSort 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.
;T; [�;[�; I"zSort 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.;T; 0; @z ;!F;"o;#;$F;%iP;&iV;'@ ;(I"def prepare_fitness!;T;)T;*I"�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;T;+To;
; F; ;
;;�;I"#NEAT::Evolver#prepare_novelty!;F;[�;[[@ id;T;:prepare_novelty!;;;[�;{�;IC; " TODO: write novelty code
;T; [�;[�; I" TODO: write novelty code;T; 0; @� ;!F;"o;#;$F;%ic;⁣'@ ;(I"def prepare_novelty!;T;)T;*I" def prepare_novelty!
end;T;+To;
; F; ;
;;�;I"/NEAT::Evolver#mutate_perturb_gene_weights!;F;[�;[[@ ih;T;:!mutate_perturb_gene_weights!;;;[�;{�;IC; "@Perturb existing gene weights by adding a guassian to them.
;T; [�;[�; I"@Perturb existing gene weights by adding a guassian to them.;T; 0; @� ;!F;"o;#;$F;%ig;&ig;'@ ;(I"%def mutate_perturb_gene_weights!;T;)T;*I"�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;T;+To;
; F; ;
;;�;I".NEAT::Evolver#mutate_change_gene_weights!;F;[�;[[@ iu;T;: mutate_change_gene_weights!;;;[�;{�;IC; "=Totally change weights to something completely different
;T; [�;[�; I"=Totally change weights to something completely different;T; 0; @� ;!F;"o;#;$F;%it;⁢'@ ;(I"$def mutate_change_gene_weights!;T;)T;*I"�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;T;+To;
; F; ;
;;�;I"$NEAT::Evolver#mutate_add_genes!;F;[�;[[@ i|;F;:mutate_add_genes!;;;[�;{�;IC; "�
;T; @� ;/0;!F; [�;[�; I"�;T; 0;'@ ;(I"def mutate_add_genes!;T;)T;*I"�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;T;+To;
; F; ;
;;�;I"(NEAT::Evolver#mutate_disable_genes!;F;[�;[[@ i�;F;:mutate_disable_genes!;;;[�;{�;IC; "�
;T; @� ;/0;!F; [�;[�; I"�;T; 0;'@ ;(I" def mutate_disable_genes!;T;)T;*I"�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;T;+To;
; F; ;
;;�;I")NEAT::Evolver#mutate_reenable_genes!;F;[�;[[@ i�;F;:mutate_reenable_genes!;;;[�;{�;IC; "�
;T; @� ;/0;!F; [�;[�; I"�;T; 0;'@ ;(I" def mutate_reenable_genes!;T;)T;*I"�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;T;+To;
; F; ;
;;�;I"&NEAT::Evolver#mutate_add_neurons!;F;[�;[[@ i�;F;:mutate_add_neurons!;;;[�;{�;IC; "�
;T; @� ;/0;!F; [�;[�; I"�;T; 0;'@ ;(I" def mutate_add_neurons!;T;)T;*I"�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;T;+To;
; F; ;
;;�;I")NEAT::Evolver#mutate_change_neurons!;F;[�;[[@ i�;T;:mutate_change_neurons!;;;[�;{�;IC; "'TODO Finish mutate_change_neurons!
;T; [�;[�; I"'TODO Finish mutate_change_neurons!;T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I" def mutate_change_neurons!;T;)T;*I"Ldef mutate_change_neurons!
log.error "mutate_change_neurons! NIY"
end;T;+To;
; F; ;
;;�;I"NEAT::Evolver#mate!;F;[�;[[@ i�;T;:
mate!;;;[�;{�;IC; "pHere we select candidates for mating. We must look at species and fitness
to make the selection for mating.
;T; [�;[�; I"pHere we select candidates for mating. We must look at species and fitness
to make the selection for mating.;T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def mate!;T;)T;*I"Qdef 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;T;+To;
; F; ;
;;�;I"NEAT::Evolver#sex;F;[[I"
crit1;T0[I"
crit2;T0;[[@ i�;T;:sex;;;[�;{�;IC; "uMate 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.
;T; [�;[�; I"uMate 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.;T; 0; @
;!F;"o;#;$F;%i�;&i�;'@ ;(I"def sex(crit1, crit2);T;)T;*I"2def 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;T;+To;F;IC;[
o;
; F; ;
;;;I"(NEAT::Evolver::CritterOp#initialize;F;[[I" evol;T0;[[@ i�;F;;k;;;[�;{�;IC; "�
;T; @
;/0;!F; [�;[o;I
;JI" return;F;KI" a new instance of CritterOp;T;0;L[I"CritterOp;F; @
; I"�;T; 0;'@
;(I"def initialize(evol);T;)T;*I"[def initialize(evol)
super evol.controller
@evolver = evol
@npop = evol.npop
end;T;+To;
; F; ;
;;;I")NEAT::Evolver::CritterOp#add_neuron!;F;[[I" crit;T0;[[@ i ;T;:add_neuron!;;;[�;{�;IC; "�= 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.
;T; [�;[�; I"�= 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.;T; 0; @*
;!F;"o;#;$F;%i;&i;'@
;(I"def add_neuron!(crit);T;)T;*I"�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;T;+To;
; F; ;
;;;I"'NEAT::Evolver::CritterOp#add_gene!;F;[[I" crit;T0;[[@ i";T;:add_gene!;;;[�;{�;IC; "�= 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.
;T; [�;[�; I"�= 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.;T; 0; @:
;!F;"o;#;$F;%i;&i!;'@
;(I"def add_gene!(crit);T;)T;*I"�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;T;+To;
; F; ;
;;;I"+NEAT::Evolver::CritterOp#disable_gene!;F;[[I" crit;T0;[[@ i/;T;:disable_gene!;;;[�;{�;IC; "3Pick an enabled gene at random and disable it.
;T; [�;[�; I"3Pick an enabled gene at random and disable it.;T; 0; @J
;!F;"o;#;$F;%i.;&i.;'@
;(I" def disable_gene!(crit);T;)T;*I"�def disable_gene!(crit)
gene = crit.genotype.genes.values.reject{|gene| gene.disabled? }.sample
gene.enabled = false unless gene.nil?
end;T;+To;
; F; ;
;;;I",NEAT::Evolver::CritterOp#reenable_gene!;F;[[I" crit;T0;[[@ i5;T;:reenable_gene!;;;[�;{�;IC; "4Pick a disabled gene at random and reenable it.
;T; [�;[�; I"4Pick a disabled gene at random and reenable it.;T; 0; @Z
;!F;"o;#;$F;%i4;&i4;'@
;(I" def reenable_gene!(crit);T;)T;*I"�def reenable_gene!(crit)
gene = crit.genotype.genes.values.reject{|gene| gene.enabled? }.sample
gene.enabled = true unless gene.nil?
end;T;+T;:@
;;IC;[�;:@
;<IC;[�;:@
;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@ i�;T;:CritterOp;;;;;[�;{�;IC; ")A set of Critter Genotype operators.
;T; [�;[�; I")A set of Critter Genotype operators.;T; 0; @
;!F;"o;#;$F;%i�;&i�;'@ ;I" NEAT::Evolver::CritterOp;F;To;= ;>0;?0;@0;;r;'@;B@�;C;G;+T;:@ ;;IC;[�;:@ ;<IC;[�;:@ ;NIC;O{;GIC;O{�;PT;
IC;O{;�IC;O{;x@ ;y0;PT;PT;PT;Q{�;R[�;[[@ i;T;: Evolver;;;;;[�;{�;IC; "�= 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.
;T; [�;[�; I"�= 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.
;T; 0; @ ;!F;"o;#;$F;%i ;&i
;'@;I"NEAT::Evolver;F;To;= ;>0;?0;@0;:
Operator;'@;Bo;F;IC;[�;:@�
;;IC;[�;:@�
;<IC;[�;:@�
;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@�i{;T;;�;;;;;[�;{�;IC; "A= Base class of operators in RubyNEAT,
Such as Evolver, etc.
;T; [�;[�; I"A= Base class of operators in RubyNEAT,
Such as Evolver, etc.;T; 0; @�
;!F;"o;#;$F;%i~;&i;'@;I"NEAT::Operator;F;To;= ;>0;?0;@0;;r;'@;B@�;C0;+T;C;G;+To;
; F; ;G;;;I" NEAT.random_name_generator;F;[�;[[@�iA;F;:random_name_generator;;;[�;{�;IC; "�
;T; @�
;/0;!F; [�;[�; I"�;T; 0;'@;(I"#def self.random_name_generator;T;)T;*I"�def self.random_name_generator
(1..3).map {
@rng_names[rand @rng_names.size]
}.push(@rng_count += 1).join('_').to_sym
end;T;+To:&YARD::CodeObjects::ConstantObject;[[@�iI;T;:
STIMULUS;;;;;[�;{�;IC; "wName of the stimulus method in NEAT::Critter::Phenotype to use
for the singleton method expression of the critter.
;T; [�;[�; I"wName of the stimulus method in NEAT::Critter::Phenotype to use
for the singleton method expression of the critter.;T; 0; @�
;!F;"o;#;$F;%iG;&iH;'@;I"NEAT::STIMULUS;F;(I"STIMULUS = :stimulate;T;*I"STIMULUS = :stimulate;T;_I":stimulate;T;+To;
; F; ;G;;;I"NEAT.new_innovation;F;[�;[[@�iL;T;:new_innovation;;;[�;{�;IC; "&Mixin for new innovation numbers.
;T; [�;[�; I"&Mixin for new innovation numbers.;T; 0; @�
;!F;"o;#;$F;%iK;&iK;'@;(I"=def self.new_innovation; @controller.new_innovation; end;T;)T;*I"=def self.new_innovation; @controller.new_innovation; end;T;+To;
; F; ;G;;;I"NEAT.gaussian;F;[�;[[@�iO;T;:
gaussian;;;[�;{�;IC; "#Mixin for the gaussian object.
;T; [�;[�; I"#Mixin for the gaussian object.;T; 0; @�
;!F;"o;#;$F;%iN;&iN;'@;(I"2def self.gaussian ; @controller.gaussian; end;T;)T;*I"2def self.gaussian ; @controller.gaussian; end;T;+To;
; F; ;G;;;I"
NEAT.dpp;F;[[I"ob;T0;[[@�iR;T;:dpp;;;[�;{�;IC; " PrettyPrint to log.debug
;T; [�;[�; I" PrettyPrint to log.debug;T; 0; @�
;!F;"o;#;$F;%iQ;&iQ;'@;(I"def self.dpp ob;T;)T;*I"&def self.dpp ob
#$log.ap ob
end;T;+T@�o;F;IC;[�;:@�
;;IC;[�;:@�
;<IC;[�;:@�
;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@�i{;F;:NeatException;;;;;[�;{�;IC; "�
;T; @�
;/0;!F; [�;[�; I"�;T; 0;'@;I"NEAT::NeatException;F;To;= ;>0;?0;@0;;f;'@;B0;C;G;+T@�
o;F;IC;[�;:@�
;;IC;[�;:@�
;<IC;[�;:@�
;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@�i�;T;:
Trait;;;;;[�;{�;IC; "�= Traits
A Trait is a group of parameters that can be expressed
as a group more than one time. Traits save a genetic
algorithm from having to search vast parameter landscapes
on every node. Instead, each node can simply point to a trait
and those traits can evolve on their own. (Taken from the C version of NEAT)
Since we wish to allow for different classes of Neurons, this trait idea is
super, since all we need to do is have a different trait species for the
different node types.
;T; [�;[�; I"�= Traits
A Trait is a group of parameters that can be expressed
as a group more than one time. Traits save a genetic
algorithm from having to search vast parameter landscapes
on every node. Instead, each node can simply point to a trait
and those traits can evolve on their own. (Taken from the C version of NEAT)
Since we wish to allow for different classes of Neurons, this trait idea is
super, since all we need to do is have a different trait species for the
different node types.;T; 0; @�
;!F;"o;#;$F;%i~;&i�;'@;I"NEAT::Trait;F;To;= ;>0;?0;@0;;r;'@;B@�;C0;+To;F;IC;[:o;
; F; ;
;;;I"$NEAT::Controller#glob_innov_num;F;[�;[[@�i�;T;:glob_innov_num;;;[�;{�;IC; " global innovation number
;T; [�;[�; I" global innovation number;T; 0; @ ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def glob_innov_num;T;*I"-def glob_innov_num
@glob_innov_num
end;T;+To;
; F; ;
;;;I" NEAT::Controller#seq_num;F;[�;[[@�i�;T;: seq_num;;;[�;{�;IC; ",current sequence number being evaluated
;T; [�;[�; I",current sequence number being evaluated;T; 0; @! ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def seq_num;T;*I" def seq_num
@seq_num
end;T;+To;
; F; ;
;;;I"$NEAT::Controller#generation_num;F;[�;[[@�i�;T;:generation_num;;;[�;{�;IC; " Current generation count
;T; [�;[�; I" Current generation count;T; 0; @/ ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def generation_num;T;*I"-def generation_num
@generation_num
end;T;+To;
; F; ;
;;;I"$NEAT::Controller#neuron_catalog;F;[�;[[@�i�;T;:neuron_catalog;;;[�;{�;IC; "@catalog of neurons classes to use { weight => nclass, ... }
;T; [�;[�; I"@catalog of neurons classes to use { weight => nclass, ... };T; 0; @= ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def neuron_catalog;T;*I"-def neuron_catalog
@neuron_catalog
end;T;+To;
; F; ;
;;;I"%NEAT::Controller#neuron_catalog=;F;[[I"
value;T0;[[@�i�;T;:neuron_catalog=;;;[�;{�;IC; "@catalog of neurons classes to use { weight => nclass, ... }
;T; [�;[�; @G ; 0; @K ;!F;"@H ;'@ ;(I" def neuron_catalog=(value);T;*I"=def neuron_catalog=(value)
@neuron_catalog = value
end;T;+To;
; F; ;
;;;I"#NEAT::Controller#neural_inputs;F;[�;[[@�i�;T;;�;;;[�;{�;IC; "�Class map of named input and output neurons (each critter will have
instantiations of these) name: InputNeuralClass (usually InputNeuron)
;T; [�;[�; I"�Class map of named input and output neurons (each critter will have
instantiations of these) name: InputNeuralClass (usually InputNeuron);T; 0; @Y ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def neural_inputs;T;*I"+def neural_inputs
@neural_inputs
end;T;+To;
; F; ;
;;;I"$NEAT::Controller#neural_inputs=;F;[[I"
value;T0;[[@�i�;T;:neural_inputs=;;;[�;{�;IC; "�Class map of named input and output neurons (each critter will have
instantiations of these) name: InputNeuralClass (usually InputNeuron)
;T; [�;[�; @c ; 0; @g ;!F;"@d ;'@ ;(I" def neural_inputs=(value);T;*I";def neural_inputs=(value)
@neural_inputs = value
end;T;+To;
; F; ;
;;;I"$NEAT::Controller#neural_outputs;F;[�;[[@�i�;T;;�;;;[�;{�;IC; "�Class map of named input and output neurons (each critter will have
instantiations of these) name: InputNeuralClass (usually InputNeuron)
;T; [�;[�; @c ; 0; @u ;!F;"@d ;'@ ;(I"def neural_outputs;T;*I"-def neural_outputs
@neural_outputs
end;T;+To;
; F; ;
;;;I"%NEAT::Controller#neural_outputs=;F;[[I"
value;T0;[[@�i�;T;:neural_outputs=;;;[�;{�;IC; "�Class map of named input and output neurons (each critter will have
instantiations of these) name: InputNeuralClass (usually InputNeuron)
;T; [�;[�; @c ; 0; @� ;!F;"@d ;'@ ;(I" def neural_outputs=(value);T;*I"=def neural_outputs=(value)
@neural_outputs = value
end;T;+To;
; F; ;
;;;I"#NEAT::Controller#neural_hidden;F;[�;[[@�i�;T;:neural_hidden;;;[�;{�;IC; "�Class map of named input and output neurons (each critter will have
instantiations of these) name: InputNeuralClass (usually InputNeuron)
;T; [�;[�; @c ; 0; @� ;!F;"@d ;'@ ;(I"def neural_hidden;T;*I"+def neural_hidden
@neural_hidden
end;T;+To;
; F; ;
;;;I"$NEAT::Controller#neural_hidden=;F;[[I"
value;T0;[[@�i�;T;:neural_hidden=;;;[�;{�;IC; "�Class map of named input and output neurons (each critter will have
instantiations of these) name: InputNeuralClass (usually InputNeuron)
;T; [�;[�; @c ; 0; @� ;!F;"@d ;'@ ;(I" def neural_hidden=(value);T;*I";def neural_hidden=(value)
@neural_hidden = value
end;T;+To;
; F; ;
;;;I"NEAT::Controller#parms;F;[�;[[@�i�;T;:
parms;;;[�;{�;IC; ".Parameters for evolution (NeatParameters)
;T; [�;[�; I".Parameters for evolution (NeatParameters);T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def parms;T;*I"def parms
@parms
end;T;+To;
; F; ;
;;;I" NEAT::Controller#parms=;F;[[I"
value;T0;[[@�i�;T;: parms=;;;[�;{�;IC; ".Parameters for evolution (NeatParameters)
;T; [�;[�; @� ; 0; @� ;!F;"@� ;'@ ;(I"def parms=(value);T;*I"+def parms=(value)
@parms = value
end;T;+To;
; F; ;
;;;I" NEAT::Controller#population;F;[�;[[@�i�;T;;;;;[�;{�;IC; ".population object and class specification
;T; [�;[�; I".population object and class specification;T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def population;T;*I"%def population
@population
end;T;+To;
; F; ;
;;;I"(NEAT::Controller#population_history;F;[�;[[@�i�;T;:population_history;;;[�;{�;IC; ".population object and class specification
;T; [�;[�; @� ; 0; @� ;!F;"@� ;'@ ;(I"def population_history;T;*I"5def population_history
@population_history
end;T;+To;
; F; ;
;;;I"&NEAT::Controller#population_class;F;[�;[[@�i�;T;:population_class;;;[�;{�;IC; ".population object and class specification
;T; [�;[�; @� ; 0; @� ;!F;"@� ;'@ ;(I"def population_class;T;*I"1def population_class
@population_class
end;T;+To;
; F; ;
;;;I" NEAT::Controller#expressor;F;[�;[[@�i�;F;:expressor;;;[�;{�;IC; "-Returns the value of attribute expressor
;T; @� ;/0;!F; [�;[�; I"-Returns the value of attribute expressor;T; 0;'@ ;(I"def expressor;T;*I"#def expressor
@expressor
end;T;+To;
; F; ;
;;;I" NEAT::Controller#expressor=;F;[[I"
value;T0;[[@�i�;F;:expressor=;;;[�;{�;IC; "!Sets the attribute expressor
;T; @� ;/0;!F; [�;[o;I
;JI"
param;F;KI"1the value to set the attribute expressor to.;T;I"
value;T;L0; @� ; I"[Sets the attribute expressor
@param value the value to set the attribute expressor to.;T; 0;'@ ;(I"def expressor=(value);T;*I"3def expressor=(value)
@expressor = value
end;T;+To;
; F; ;
;;;I"%NEAT::Controller#expressor_class;F;[�;[[@�i�;F;:expressor_class;;;[�;{�;IC; "3Returns the value of attribute expressor_class
;T; @ ;/0;!F; [�;[�; I"3Returns the value of attribute expressor_class;T; 0;'@ ;(I"def expressor_class;T;*I"/def expressor_class
@expressor_class
end;T;+To;
; F; ;
;;;I"&NEAT::Controller#expressor_class=;F;[[I"
value;T0;[[@�i�;F;:expressor_class=;;;[�;{�;IC; "'Sets the attribute expressor_class
;T; @ ;/0;!F; [�;[o;I
;JI"
param;F;KI"7the value to set the attribute expressor_class to.;T;I"
value;T;L0; @ ; I"gSets the attribute expressor_class
@param value the value to set the attribute expressor_class to.;T; 0;'@ ;(I" def expressor_class=(value);T;*I"?def expressor_class=(value)
@expressor_class = value
end;T;+To;
; F; ;
;;;I" NEAT::Controller#evaluator;F;[�;[[@�i�;F;:evaluator;;;[�;{�;IC; "-Returns the value of attribute evaluator
;T; @+ ;/0;!F; [�;[�; I"-Returns the value of attribute evaluator;T; 0;'@ ;(I"def evaluator;T;*I"#def evaluator
@evaluator
end;T;+To;
; F; ;
;;;I" NEAT::Controller#evaluator=;F;[[I"
value;T0;[[@�i�;F;:evaluator=;;;[�;{�;IC; "!Sets the attribute evaluator
;T; @8 ;/0;!F; [�;[o;I
;JI"
param;F;KI"1the value to set the attribute evaluator to.;T;I"
value;T;L0; @8 ; I"[Sets the attribute evaluator
@param value the value to set the attribute evaluator to.;T; 0;'@ ;(I"def evaluator=(value);T;*I"3def evaluator=(value)
@evaluator = value
end;T;+To;
; F; ;
;;;I"%NEAT::Controller#evaluator_class;F;[�;[[@�i�;F;:evaluator_class;;;[�;{�;IC; "3Returns the value of attribute evaluator_class
;T; @K ;/0;!F; [�;[�; I"3Returns the value of attribute evaluator_class;T; 0;'@ ;(I"def evaluator_class;T;*I"/def evaluator_class
@evaluator_class
end;T;+To;
; F; ;
;;;I"&NEAT::Controller#evaluator_class=;F;[[I"
value;T0;[[@�i�;F;:evaluator_class=;;;[�;{�;IC; "'Sets the attribute evaluator_class
;T; @X ;/0;!F; [�;[o;I
;JI"
param;F;KI"7the value to set the attribute evaluator_class to.;T;I"
value;T;L0; @X ; I"gSets the attribute evaluator_class
@param value the value to set the attribute evaluator_class to.;T; 0;'@ ;(I" def evaluator_class=(value);T;*I"?def evaluator_class=(value)
@evaluator_class = value
end;T;+To;
; F; ;
;;;I" NEAT::Controller#evolver;F;[�;[[@�i�;F;: evolver;;;[�;{�;IC; "+Returns the value of attribute evolver
;T; @k ;/0;!F; [�;[�; I"+Returns the value of attribute evolver;T; 0;'@ ;(I"def evolver;T;*I" def evolver
@evolver
end;T;+To;
; F; ;
;;;I" NEAT::Controller#evolver=;F;[[I"
value;T0;[[@�i�;F;:
evolver=;;;[�;{�;IC; " Sets the attribute evolver
;T; @x ;/0;!F; [�;[o;I
;JI"
param;F;KI"/the value to set the attribute evolver to.;T;I"
value;T;L0; @x ; I"WSets the attribute evolver
@param value the value to set the attribute evolver to.;T; 0;'@ ;(I"def evolver=(value);T;*I"/def evolver=(value)
@evolver = value
end;T;+To;
; F; ;
;;;I"#NEAT::Controller#evolver_class;F;[�;[[@�i�;F;:evolver_class;;;[�;{�;IC; "1Returns the value of attribute evolver_class
;T; @� ;/0;!F; [�;[�; I"1Returns the value of attribute evolver_class;T; 0;'@ ;(I"def evolver_class;T;*I"+def evolver_class
@evolver_class
end;T;+To;
; F; ;
;;;I"$NEAT::Controller#evolver_class=;F;[[I"
value;T0;[[@�i�;F;:evolver_class=;;;[�;{�;IC; "%Sets the attribute evolver_class
;T; @� ;/0;!F; [�;[o;I
;JI"
param;F;KI"5the value to set the attribute evolver_class to.;T;I"
value;T;L0; @� ; I"cSets the attribute evolver_class
@param value the value to set the attribute evolver_class to.;T; 0;'@ ;(I" def evolver_class=(value);T;*I";def evolver_class=(value)
@evolver_class = value
end;T;+To;
; F; ;
;;;I" NEAT::Controller#verbosity;F;[�;[[@�i�;T;:verbosity;;;[�;{�;IC; "{Global verbosity level:
1 - normal (the default)
2 - really verbose
3 - maximally verbose
Use in conjunction with log.debug
;T; [�;[�; I"{Global verbosity level:
1 - normal (the default)
2 - really verbose
3 - maximally verbose
Use in conjunction with log.debug;T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def verbosity;T;*I"#def verbosity
@verbosity
end;T;+To;
; F; ;
;;;I" NEAT::Controller#verbosity=;F;[[I"
value;T0;[[@�i�;T;:verbosity=;;;[�;{�;IC; "{Global verbosity level:
1 - normal (the default)
2 - really verbose
3 - maximally verbose
Use in conjunction with log.debug
;T; [�;[�; @� ; 0; @� ;!F;"@� ;'@ ;(I"def verbosity=(value);T;*I"3def verbosity=(value)
@verbosity = value
end;T;+To;
; F; ;
;;;I" NEAT::Controller#query_func;F;[�;[[@�i�;T;:query_func;;;[�;{�;IC; "-Query function that Critters shall call.
;T; [�;[�; I"-Query function that Critters shall call.;T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def query_func;T;*I"%def query_func
@query_func
end;T;+To;
; F; ;
;;;I"!NEAT::Controller#query_func=;F;[[I"
value;T0;[[@�i�;T;:query_func=;;;[�;{�;IC; "-Query function that Critters shall call.
;T; [�;[�; @� ; 0; @� ;!F;"@� ;'@ ;(I"def query_func=(value);T;*I"5def query_func=(value)
@query_func = value
end;T;+To;
; F; ;
;;;I""NEAT::Controller#fitness_func;F;[�;[[@�i�;T;:fitness_func;;;[�;{�;IC; "6Fitness function that Critters shall be rated on.
;T; [�;[�; I"6Fitness function that Critters shall be rated on.;T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def fitness_func;T;*I")def fitness_func
@fitness_func
end;T;+To;
; F; ;
;;;I"#NEAT::Controller#fitness_func=;F;[[I"
value;T0;[[@�i�;T;:fitness_func=;;;[�;{�;IC; "6Fitness function that Critters shall be rated on.
;T; [�;[�; @� ; 0; @� ;!F;"@� ;'@ ;(I" def fitness_func=(value);T;*I"9def fitness_func=(value)
@fitness_func = value
end;T;+To;
; F; ;
;;;I"%NEAT::Controller#recurrence_func;F;[�;[[@�i�;T;:recurrence_func;;;[�;{�;IC; "5Recurrence function that Critters will yield to.
;T; [�;[�; I"5Recurrence function that Critters will yield to.;T; 0; @� ;!F;"o;#;$F;%i�;&i�;'@ ;(I"def recurrence_func;T;*I"/def recurrence_func
@recurrence_func
end;T;+To;
; F; ;
;;;I"&NEAT::Controller#recurrence_func=;F;[[I"
value;T0;[[@�i�;T;:recurrence_func=;;;[�;{�;IC; "5Recurrence function that Critters will yield to.
;T; [�;[�; @
; 0; @
;!F;"@
;'@ ;(I" def recurrence_func=(value);T;*I"?def recurrence_func=(value)
@recurrence_func = value
end;T;+To;
; F; ;
;;;I""NEAT::Controller#compare_func;F;[�;[[@�i�;T;:compare_func;;;[�;{�;IC; "bCompare function for fitness
Cost function for integrating in the cost to the fitness scalar.
;T; [�;[�; I"bCompare function for fitness
Cost function for integrating in the cost to the fitness scalar.;T; 0; @
;!F;"o;#;$F;%i�;&i�;'@ ;(I"def compare_func;T;*I")def compare_func
@compare_func
end;T;+To;
; F; ;
;;;I"#NEAT::Controller#compare_func=;F;[[I"
value;T0;[[@�i�;T;:compare_func=;;;[�;{�;IC; "bCompare function for fitness
Cost function for integrating in the cost to the fitness scalar.
;T; [�;[�; @%
; 0; @)
;!F;"@&
;'@ ;(I" def compare_func=(value);T;*I"9def compare_func=(value)
@compare_func = value
end;T;+To;
; F; ;
;;;I" NEAT::Controller#cost_func;F;[�;[[@�i�;T;:cost_func;;;[�;{�;IC; "bCompare function for fitness
Cost function for integrating in the cost to the fitness scalar.
;T; [�;[�; @%
; 0; @7
;!F;"@&
;'@ ;(I"def cost_func;T;*I"#def cost_func
@cost_func
end;T;+To;
; F; ;
;;;I" NEAT::Controller#cost_func=;F;[[I"
value;T0;[[@�i�;T;:cost_func=;;;[�;{�;IC; "bCompare function for fitness
Cost function for integrating in the cost to the fitness scalar.
;T; [�;[�; @%
; 0; @C
;!F;"@&
;'@ ;(I"def cost_func=(value);T;*I"3def cost_func=(value)
@cost_func = value
end;T;+To;
; F; ;
;;;I"&NEAT::Controller#stop_on_fit_func;F;[�;[[@�i�;T;:stop_on_fit_func;;;[�;{�;IC; "bCompare function for fitness
Cost function for integrating in the cost to the fitness scalar.
;T; [�;[�; @%
; 0; @Q
;!F;"@&
;'@ ;(I"def stop_on_fit_func;T;*I"1def stop_on_fit_func
@stop_on_fit_func
end;T;+To;
; F; ;
;;;I"'NEAT::Controller#stop_on_fit_func=;F;[[I"
value;T0;[[@�i�;T;:stop_on_fit_func=;;;[�;{�;IC; "bCompare function for fitness
Cost function for integrating in the cost to the fitness scalar.
;T; [�;[�; @%
; 0; @]
;!F;"@&
;'@ ;(I"!def stop_on_fit_func=(value);T;*I"Adef stop_on_fit_func=(value)
@stop_on_fit_func = value
end;T;+To;
; F; ;
;;;I""NEAT::Controller#end_run_func;F;[�;[[@�i�;T;:end_run_func;;;[�;{�;IC; "uEnd run function to call at the end of each generational run
Also report_hook to dump reports for the user, etc.
;T; [�;[�; I"uEnd run function to call at the end of each generational run
Also report_hook to dump reports for the user, etc.;T; 0; @k
;!F;"o;#;$F;%i�;&i�;'@ ;(I"def end_run_func;T;*I")def end_run_func
@end_run_func
end;T;+To;
; F; ;
;;;I"#NEAT::Controller#end_run_func=;F;[[I"
value;T0;[[@�i�;T;:end_run_func=;;;[�;{�;IC; "uEnd run function to call at the end of each generational run
Also report_hook to dump reports for the user, etc.
;T; [�;[�; @u
; 0; @y
;!F;"@v
;'@ ;(I" def end_run_func=(value);T;*I"9def end_run_func=(value)
@end_run_func = value
end;T;+To;
; F; ;
;;;I"!NEAT::Controller#report_hook;F;[�;[[@�i�;T;:report_hook;;;[�;{�;IC; "uEnd run function to call at the end of each generational run
Also report_hook to dump reports for the user, etc.
;T; [�;[�; @u
; 0; @�
;!F;"@v
;'@ ;(I"def report_hook;T;*I"'def report_hook
@report_hook
end;T;+To;
; F; ;
;;;I""NEAT::Controller#report_hook=;F;[[I"
value;T0;[[@�i�;T;:report_hook=;;;[�;{�;IC; "uEnd run function to call at the end of each generational run
Also report_hook to dump reports for the user, etc.
;T; [�;[�; @u
; 0; @�
;!F;"@v
;'@ ;(I" def report_hook=(value);T;*I"7def report_hook=(value)
@report_hook = value
end;T;+To;
; F; ;
;;;I"NEAT::Controller#log;F;[�;[[@�i�;T;;u;;;[�;{�;IC; "&Logger object for all of RubyNEAT
;T; [�;[�; I"&Logger object for all of RubyNEAT;T; 0; @�
;!F;"o;#;$F;%i�;&i�;'@ ;(I" def log;T;*I"def log
@log
end;T;+To;F;IC;[po;
; F; ;
;;;I"3NEAT::Controller::NeatSettings#hash_on_fitness;F;[�;[[@�i�;T;:hash_on_fitness;;;[�;{�;IC; "uSet to true to returned named parameters as hashes to the fitness function
(the default is to do ordered arrays)
;T; [�;[�; I"uSet to true to returned named parameters as hashes to the fitness function
(the default is to do ordered arrays);T; 0; @�
;!F;"o;#;$F;%i�;&i�;'@�
;(I"def hash_on_fitness;T;*I"/def hash_on_fitness
@hash_on_fitness
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#hash_on_fitness=;F;[[I"
value;T0;[[@�i�;T;:hash_on_fitness=;;;[�;{�;IC; "uSet to true to returned named parameters as hashes to the fitness function
(the default is to do ordered arrays)
;T; [�;[�; @�
; 0; @�
;!F;"@�
;'@�
;(I" def hash_on_fitness=(value);T;*I"?def hash_on_fitness=(value)
@hash_on_fitness = value
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#age_significance;F;[�;[[@�i�;T;:age_significance;;;[�;{�;IC; "#based on the C version of NEAT
;T; [�;[�; I"#based on the C version of NEAT;T; 0; @�
;!T;"o;#;$F;%i�;&i�;'@�
;(I"def age_significance;T;*I"1def age_significance
@age_significance
end;T;+To;
; F; ;
;;;I"5NEAT::Controller::NeatSettings#age_significance=;F;[[I"
value;T0;[[@�i�;T;:age_significance=;;;[�;{�;IC; "#based on the C version of NEAT
;T; [�;[�; @�
; 0; @�
;!T;"@�
;'@�
;(I"!def age_significance=(value);T;*I"Adef age_significance=(value)
@age_significance = value
end;T;+To;
; F; ;
;;;I"1NEAT::Controller::NeatSettings#babies_stolen;F;[�;[[@�i�;F;:babies_stolen;;;[�;{�;IC; "1Returns the value of attribute babies_stolen
;T; @�
;/0;!F; [�;[�; I"1Returns the value of attribute babies_stolen;T; 0;'@�
;(I"def babies_stolen;T;*I"+def babies_stolen
@babies_stolen
end;T;+To;
; F; ;
;;;I"2NEAT::Controller::NeatSettings#babies_stolen=;F;[[I"
value;T0;[[@�i�;F;:babies_stolen=;;;[�;{�;IC; "%Sets the attribute babies_stolen
;T; @�
;/0;!F; [�;[o;I
;JI"
param;F;KI"5the value to set the attribute babies_stolen to.;T;I"
value;T;L0; @�
; I"cSets the attribute babies_stolen
@param value the value to set the attribute babies_stolen to.;T; 0;'@�
;(I" def babies_stolen=(value);T;*I";def babies_stolen=(value)
@babies_stolen = value
end;T;+To;
; F; ;
;;;I";NEAT::Controller::NeatSettings#compatibility_threshold;F;[�;[[@�i�;T;: compatibility_threshold;;;[�;{�;IC; "$Species compatability threshold
;T; [�;[�; I"$Species compatability threshold;T; 0; @ ;!F;"o;#;$F;%i�;&i�;'@�
;(I" def compatibility_threshold;T;*I"?def compatibility_threshold
@compatibility_threshold
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#compatibility_threshold=;F;[[I"
value;T0;[[@�i�;T;: compatibility_threshold=;;;[�;{�;IC; "$Species compatability threshold
;T; [�;[�; @; 0; @;!F;"@;'@�
;(I"(def compatibility_threshold=(value);T;*I"Odef compatibility_threshold=(value)
@compatibility_threshold = value
end;T;+To;
; F; ;
;;;I"8NEAT::Controller::NeatSettings#disjoint_coefficient;F;[�;[[@�i�;T;:disjoint_coefficient;;;[�;{�;IC; "Speciation coffficient
;T; [�;[�; I"Speciation coffficient;T; 0; @%;!F;"o;#;$F;%i�;&i�;'@�
;(I" def disjoint_coefficient;T;*I"9def disjoint_coefficient
@disjoint_coefficient
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#disjoint_coefficient=;F;[[I"
value;T0;[[@�i�;T;:disjoint_coefficient=;;;[�;{�;IC; "Speciation coffficient
;T; [�;[�; @/; 0; @3;!F;"@0;'@�
;(I"%def disjoint_coefficient=(value);T;*I"Idef disjoint_coefficient=(value)
@disjoint_coefficient = value
end;T;+To;
; F; ;
;;;I"6NEAT::Controller::NeatSettings#excess_coefficient;F;[�;[[@�i�;T;:excess_coefficient;;;[�;{�;IC; "Speciation coffficient
;T; [�;[�; @/; 0; @A;!F;"@0;'@�
;(I"def excess_coefficient;T;*I"5def excess_coefficient
@excess_coefficient
end;T;+To;
; F; ;
;;;I"7NEAT::Controller::NeatSettings#excess_coefficient=;F;[[I"
value;T0;[[@�i�;T;:excess_coefficient=;;;[�;{�;IC; "Speciation coffficient
;T; [�;[�; @/; 0; @M;!F;"@0;'@�
;(I"#def excess_coefficient=(value);T;*I"Edef excess_coefficient=(value)
@excess_coefficient = value
end;T;+To;
; F; ;
;;;I"6NEAT::Controller::NeatSettings#weight_coefficient;F;[�;[[@�i�;T;:weight_coefficient;;;[�;{�;IC; "Speciation coffficient
;T; [�;[�; @/; 0; @[;!F;"@0;'@�
;(I"def weight_coefficient;T;*I"5def weight_coefficient
@weight_coefficient
end;T;+To;
; F; ;
;;;I"7NEAT::Controller::NeatSettings#weight_coefficient=;F;[[I"
value;T0;[[@�i�;T;:weight_coefficient=;;;[�;{�;IC; "Speciation coffficient
;T; [�;[�; @/; 0; @g;!F;"@0;'@�
;(I"#def weight_coefficient=(value);T;*I"Edef weight_coefficient=(value)
@weight_coefficient = value
end;T;+To;
; F; ;
;;;I"/NEAT::Controller::NeatSettings#max_species;F;[�;[[@�i�;T;:max_species;;;[�;{�;IC; "mMax target number of species (will result in the compatability_coeifficient
being adjusted automatically
;T; [�;[�; I"mMax target number of species (will result in the compatability_coeifficient
being adjusted automatically;T; 0; @u;!F;"o;#;$F;%i�;&i�;'@�
;(I"def max_species;T;*I"'def max_species
@max_species
end;T;+To;
; F; ;
;;;I"0NEAT::Controller::NeatSettings#max_species=;F;[[I"
value;T0;[[@�i�;T;:max_species=;;;[�;{�;IC; "mMax target number of species (will result in the compatability_coeifficient
being adjusted automatically
;T; [�;[�; @; 0; @�;!F;"@�;'@�
;(I" def max_species=(value);T;*I"7def max_species=(value)
@max_species = value
end;T;+To;
; F; ;
;;;I"/NEAT::Controller::NeatSettings#dropoff_age;F;[�;[[@�i�;T;:dropoff_age;;;[�;{�;IC; "0Species Peality age for not making progress
;T; [�;[�; I"0Species Peality age for not making progress;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�
;(I"def dropoff_age;T;*I"'def dropoff_age
@dropoff_age
end;T;+To;
; F; ;
;;;I"0NEAT::Controller::NeatSettings#dropoff_age=;F;[[I"
value;T0;[[@�i�;T;:dropoff_age=;;;[�;{�;IC; "0Species Peality age for not making progress
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I" def dropoff_age=(value);T;*I"7def dropoff_age=(value)
@dropoff_age = value
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#smallest_species;F;[�;[[@�i�;T;:smallest_species;;;[�;{�;IC; "JSpecies smallest population allowed (coalse smaller species into one)
;T; [�;[�; I"JSpecies smallest population allowed (coalse smaller species into one);T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�
;(I"def smallest_species;T;*I"1def smallest_species
@smallest_species
end;T;+To;
; F; ;
;;;I"5NEAT::Controller::NeatSettings#smallest_species=;F;[[I"
value;T0;[[@�i�;T;:smallest_species=;;;[�;{�;IC; "JSpecies smallest population allowed (coalse smaller species into one)
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"!def smallest_species=(value);T;*I"Adef smallest_species=(value)
@smallest_species = value
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#interspecies_mate_rate;F;[�;[[@�i�;T;:interspecies_mate_rate;;;[�;{�;IC; ".Ratio of mating are actually interspecies
;T; [�;[�; I".Ratio of mating are actually interspecies;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�
;(I" def interspecies_mate_rate;T;*I"=def interspecies_mate_rate
@interspecies_mate_rate
end;T;+To;
; F; ;
;;;I";NEAT::Controller::NeatSettings#interspecies_mate_rate=;F;[[I"
value;T0;[[@�i�;T;: interspecies_mate_rate=;;;[�;{�;IC; ".Ratio of mating are actually interspecies
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"'def interspecies_mate_rate=(value);T;*I"Mdef interspecies_mate_rate=(value)
@interspecies_mate_rate = value
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#linktrait_mutation_sig;F;[�;[[@�i�;F;:linktrait_mutation_sig;;;[�;{�;IC; ":Returns the value of attribute linktrait_mutation_sig
;T; @�;/0;!F; [�;[�; I":Returns the value of attribute linktrait_mutation_sig;T; 0;'@�
;(I" def linktrait_mutation_sig;T;*I"=def linktrait_mutation_sig
@linktrait_mutation_sig
end;T;+To;
; F; ;
;;;I";NEAT::Controller::NeatSettings#linktrait_mutation_sig=;F;[[I"
value;T0;[[@�i�;F;: linktrait_mutation_sig=;;;[�;{�;IC; ".Sets the attribute linktrait_mutation_sig
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI">the value to set the attribute linktrait_mutation_sig to.;T;I"
value;T;L0; @�; I"uSets the attribute linktrait_mutation_sig
@param value the value to set the attribute linktrait_mutation_sig to.;T; 0;'@�
;(I"'def linktrait_mutation_sig=(value);T;*I"Mdef linktrait_mutation_sig=(value)
@linktrait_mutation_sig = value
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#mate_multipoint_avg_prob;F;[�;[[@�i�;F;: mate_multipoint_avg_prob;;;[�;{�;IC; "<Returns the value of attribute mate_multipoint_avg_prob
;T; @;/0;!F; [�;[�; I"<Returns the value of attribute mate_multipoint_avg_prob;T; 0;'@�
;(I"!def mate_multipoint_avg_prob;T;*I"Adef mate_multipoint_avg_prob
@mate_multipoint_avg_prob
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#mate_multipoint_avg_prob=;F;[[I"
value;T0;[[@�i�;F;: mate_multipoint_avg_prob=;;;[�;{�;IC; "0Sets the attribute mate_multipoint_avg_prob
;T; @;/0;!F; [�;[o;I
;JI"
param;F;KI"@the value to set the attribute mate_multipoint_avg_prob to.;T;I"
value;T;L0; @; I"ySets the attribute mate_multipoint_avg_prob
@param value the value to set the attribute mate_multipoint_avg_prob to.;T; 0;'@�
;(I")def mate_multipoint_avg_prob=(value);T;*I"Qdef mate_multipoint_avg_prob=(value)
@mate_multipoint_avg_prob = value
end;T;+To;
; F; ;
;;;I"8NEAT::Controller::NeatSettings#mate_multipoint_prob;F;[�;[[@�i�;F;:mate_multipoint_prob;;;[�;{�;IC; "8Returns the value of attribute mate_multipoint_prob
;T; @%;/0;!F; [�;[�; I"8Returns the value of attribute mate_multipoint_prob;T; 0;'@�
;(I" def mate_multipoint_prob;T;*I"9def mate_multipoint_prob
@mate_multipoint_prob
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#mate_multipoint_prob=;F;[[I"
value;T0;[[@�i�;F;:mate_multipoint_prob=;;;[�;{�;IC; ",Sets the attribute mate_multipoint_prob
;T; @2;/0;!F; [�;[o;I
;JI"
param;F;KI"<the value to set the attribute mate_multipoint_prob to.;T;I"
value;T;L0; @2; I"qSets the attribute mate_multipoint_prob
@param value the value to set the attribute mate_multipoint_prob to.;T; 0;'@�
;(I"%def mate_multipoint_prob=(value);T;*I"Idef mate_multipoint_prob=(value)
@mate_multipoint_prob = value
end;T;+To;
; F; ;
;;;I"2NEAT::Controller::NeatSettings#mate_only_prob;F;[�;[[@�i�;F;:mate_only_prob;;;[�;{�;IC; "2Returns the value of attribute mate_only_prob
;T; @E;/0;!F; [�;[�; I"2Returns the value of attribute mate_only_prob;T; 0;'@�
;(I"def mate_only_prob;T;*I"-def mate_only_prob
@mate_only_prob
end;T;+To;
; F; ;
;;;I"3NEAT::Controller::NeatSettings#mate_only_prob=;F;[[I"
value;T0;[[@�i�;F;:mate_only_prob=;;;[�;{�;IC; "&Sets the attribute mate_only_prob
;T; @R;/0;!F; [�;[o;I
;JI"
param;F;KI"6the value to set the attribute mate_only_prob to.;T;I"
value;T;L0; @R; I"eSets the attribute mate_only_prob
@param value the value to set the attribute mate_only_prob to.;T; 0;'@�
;(I" def mate_only_prob=(value);T;*I"=def mate_only_prob=(value)
@mate_only_prob = value
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#mate_singlepoint_prob;F;[�;[[@�i�;F;:mate_singlepoint_prob;;;[�;{�;IC; "9Returns the value of attribute mate_singlepoint_prob
;T; @e;/0;!F; [�;[�; I"9Returns the value of attribute mate_singlepoint_prob;T; 0;'@�
;(I" def mate_singlepoint_prob;T;*I";def mate_singlepoint_prob
@mate_singlepoint_prob
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#mate_singlepoint_prob=;F;[[I"
value;T0;[[@�i�;F;:mate_singlepoint_prob=;;;[�;{�;IC; "-Sets the attribute mate_singlepoint_prob
;T; @r;/0;!F; [�;[o;I
;JI"
param;F;KI"=the value to set the attribute mate_singlepoint_prob to.;T;I"
value;T;L0; @r; I"sSets the attribute mate_singlepoint_prob
@param value the value to set the attribute mate_singlepoint_prob to.;T; 0;'@�
;(I"&def mate_singlepoint_prob=(value);T;*I"Kdef mate_singlepoint_prob=(value)
@mate_singlepoint_prob = value
end;T;+To;
; F; ;
;;;I"3NEAT::Controller::NeatSettings#max_generations;F;[�;[[@�i�;T;:max_generations;;;[�;{�;IC; "4Maximum number of generations to run, if given.
;T; [�;[�; I"4Maximum number of generations to run, if given.;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�
;(I"def max_generations;T;*I"/def max_generations
@max_generations
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#max_generations=;F;[[I"
value;T0;[[@�i�;T;:max_generations=;;;[�;{�;IC; "4Maximum number of generations to run, if given.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I" def max_generations=(value);T;*I"?def max_generations=(value)
@max_generations = value
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#max_population_history;F;[�;[[@�i�;T;:max_population_history;;;[�;{�;IC; "EMaximun number of populations to maintain in the history buffer.
;T; [�;[�; I"EMaximun number of populations to maintain in the history buffer.;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�
;(I" def max_population_history;T;*I"=def max_population_history
@max_population_history
end;T;+To;
; F; ;
;;;I";NEAT::Controller::NeatSettings#max_population_history=;F;[[I"
value;T0;[[@�i�;T;: max_population_history=;;;[�;{�;IC; "EMaximun number of populations to maintain in the history buffer.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"'def max_population_history=(value);T;*I"Mdef max_population_history=(value)
@max_population_history = value
end;T;+To;
; F; ;
;;;I"8NEAT::Controller::NeatSettings#mutate_add_gene_prob;F;[�;[[@�i�;F;:mutate_add_gene_prob;;;[�;{�;IC; "8Returns the value of attribute mutate_add_gene_prob
;T; @�;/0;!F; [�;[�; I"8Returns the value of attribute mutate_add_gene_prob;T; 0;'@�
;(I" def mutate_add_gene_prob;T;*I"9def mutate_add_gene_prob
@mutate_add_gene_prob
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#mutate_add_gene_prob=;F;[[I"
value;T0;[[@�i�;F;:mutate_add_gene_prob=;;;[�;{�;IC; ",Sets the attribute mutate_add_gene_prob
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"<the value to set the attribute mutate_add_gene_prob to.;T;I"
value;T;L0; @�; I"qSets the attribute mutate_add_gene_prob
@param value the value to set the attribute mutate_add_gene_prob to.;T; 0;'@�
;(I"%def mutate_add_gene_prob=(value);T;*I"Idef mutate_add_gene_prob=(value)
@mutate_add_gene_prob = value
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#mutate_add_neuron_prob;F;[�;[[@�i�;F;:mutate_add_neuron_prob;;;[�;{�;IC; ":Returns the value of attribute mutate_add_neuron_prob
;T; @�;/0;!F; [�;[�; I":Returns the value of attribute mutate_add_neuron_prob;T; 0;'@�
;(I" def mutate_add_neuron_prob;T;*I"=def mutate_add_neuron_prob
@mutate_add_neuron_prob
end;T;+To;
; F; ;
;;;I";NEAT::Controller::NeatSettings#mutate_add_neuron_prob=;F;[[I"
value;T0;[[@�i�;F;: mutate_add_neuron_prob=;;;[�;{�;IC; ".Sets the attribute mutate_add_neuron_prob
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI">the value to set the attribute mutate_add_neuron_prob to.;T;I"
value;T;L0; @�; I"uSets the attribute mutate_add_neuron_prob
@param value the value to set the attribute mutate_add_neuron_prob to.;T; 0;'@�
;(I"'def mutate_add_neuron_prob=(value);T;*I"Mdef mutate_add_neuron_prob=(value)
@mutate_add_neuron_prob = value
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#mutate_gene_disable_prob;F;[�;[[@�i�;F;: mutate_gene_disable_prob;;;[�;{�;IC; "<Returns the value of attribute mutate_gene_disable_prob
;T; @�;/0;!F; [�;[�; I"<Returns the value of attribute mutate_gene_disable_prob;T; 0;'@�
;(I"!def mutate_gene_disable_prob;T;*I"Adef mutate_gene_disable_prob
@mutate_gene_disable_prob
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#mutate_gene_disable_prob=;F;[[I"
value;T0;[[@�i�;F;: mutate_gene_disable_prob=;;;[�;{�;IC; "0Sets the attribute mutate_gene_disable_prob
;T; @
;/0;!F; [�;[o;I
;JI"
param;F;KI"@the value to set the attribute mutate_gene_disable_prob to.;T;I"
value;T;L0; @
; I"ySets the attribute mutate_gene_disable_prob
@param value the value to set the attribute mutate_gene_disable_prob to.;T; 0;'@�
;(I")def mutate_gene_disable_prob=(value);T;*I"Qdef mutate_gene_disable_prob=(value)
@mutate_gene_disable_prob = value
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#mutate_gene_reenable_prob;F;[�;[[@�i�;F;: mutate_gene_reenable_prob;;;[�;{�;IC; "=Returns the value of attribute mutate_gene_reenable_prob
;T; @ ;/0;!F; [�;[�; I"=Returns the value of attribute mutate_gene_reenable_prob;T; 0;'@�
;(I""def mutate_gene_reenable_prob;T;*I"Cdef mutate_gene_reenable_prob
@mutate_gene_reenable_prob
end;T;+To;
; F; ;
;;;I">NEAT::Controller::NeatSettings#mutate_gene_reenable_prob=;F;[[I"
value;T0;[[@�i�;F;: mutate_gene_reenable_prob=;;;[�;{�;IC; "1Sets the attribute mutate_gene_reenable_prob
;T; @*;/0;!F; [�;[o;I
;JI"
param;F;KI"Athe value to set the attribute mutate_gene_reenable_prob to.;T;I"
value;T;L0; @*; I"{Sets the attribute mutate_gene_reenable_prob
@param value the value to set the attribute mutate_gene_reenable_prob to.;T; 0;'@�
;(I"*def mutate_gene_reenable_prob=(value);T;*I"Sdef mutate_gene_reenable_prob=(value)
@mutate_gene_reenable_prob = value
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#mutate_gene_trait_prob;F;[�;[[@�i;F;:mutate_gene_trait_prob;;;[�;{�;IC; ":Returns the value of attribute mutate_gene_trait_prob
;T; @=;/0;!F; [�;[�; I":Returns the value of attribute mutate_gene_trait_prob;T; 0;'@�
;(I" def mutate_gene_trait_prob;T;*I"=def mutate_gene_trait_prob
@mutate_gene_trait_prob
end;T;+To;
; F; ;
;;;I";NEAT::Controller::NeatSettings#mutate_gene_trait_prob=;F;[[I"
value;T0;[[@�i;F;: mutate_gene_trait_prob=;;;[�;{�;IC; ".Sets the attribute mutate_gene_trait_prob
;T; @J;/0;!F; [�;[o;I
;JI"
param;F;KI">the value to set the attribute mutate_gene_trait_prob to.;T;I"
value;T;L0; @J; I"uSets the attribute mutate_gene_trait_prob
@param value the value to set the attribute mutate_gene_trait_prob to.;T; 0;'@�
;(I"'def mutate_gene_trait_prob=(value);T;*I"Mdef mutate_gene_trait_prob=(value)
@mutate_gene_trait_prob = value
end;T;+To;
; F; ;
;;;I"DNEAT::Controller::NeatSettings#mutate_perturb_gene_weights_prob;F;[�;[[@�i;T;:%mutate_perturb_gene_weights_prob;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; I"EFor gene weights perturbations and changes (complete overwrites);T; 0; @];!F;"o;#;$F;%i;&i;'@�
;(I")def mutate_perturb_gene_weights_prob;T;*I"Qdef mutate_perturb_gene_weights_prob
@mutate_perturb_gene_weights_prob
end;T;+To;
; F; ;
;;;I"ENEAT::Controller::NeatSettings#mutate_perturb_gene_weights_prob=;F;[[I"
value;T0;[[@�i;T;:&mutate_perturb_gene_weights_prob=;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; @g; 0; @k;!F;"@h;'@�
;(I"1def mutate_perturb_gene_weights_prob=(value);T;*I"adef mutate_perturb_gene_weights_prob=(value)
@mutate_perturb_gene_weights_prob = value
end;T;+To;
; F; ;
;;;I"BNEAT::Controller::NeatSettings#mutate_perturb_gene_weights_sd;F;[�;[[@�i;T;:#mutate_perturb_gene_weights_sd;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; @g; 0; @y;!F;"@h;'@�
;(I"'def mutate_perturb_gene_weights_sd;T;*I"Mdef mutate_perturb_gene_weights_sd
@mutate_perturb_gene_weights_sd
end;T;+To;
; F; ;
;;;I"CNEAT::Controller::NeatSettings#mutate_perturb_gene_weights_sd=;F;[[I"
value;T0;[[@�i;T;:$mutate_perturb_gene_weights_sd=;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; @g; 0; @�;!F;"@h;'@�
;(I"/def mutate_perturb_gene_weights_sd=(value);T;*I"]def mutate_perturb_gene_weights_sd=(value)
@mutate_perturb_gene_weights_sd = value
end;T;+To;
; F; ;
;;;I"CNEAT::Controller::NeatSettings#mutate_change_gene_weights_prob;F;[�;[[@�i;T;:$mutate_change_gene_weights_prob;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; @g; 0; @�;!F;"@h;'@�
;(I"(def mutate_change_gene_weights_prob;T;*I"Odef mutate_change_gene_weights_prob
@mutate_change_gene_weights_prob
end;T;+To;
; F; ;
;;;I"DNEAT::Controller::NeatSettings#mutate_change_gene_weights_prob=;F;[[I"
value;T0;[[@�i;T;:%mutate_change_gene_weights_prob=;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; @g; 0; @�;!F;"@h;'@�
;(I"0def mutate_change_gene_weights_prob=(value);T;*I"_def mutate_change_gene_weights_prob=(value)
@mutate_change_gene_weights_prob = value
end;T;+To;
; F; ;
;;;I"ANEAT::Controller::NeatSettings#mutate_change_gene_weights_sd;F;[�;[[@�i;T;:"mutate_change_gene_weights_sd;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; @g; 0; @�;!F;"@h;'@�
;(I"&def mutate_change_gene_weights_sd;T;*I"Kdef mutate_change_gene_weights_sd
@mutate_change_gene_weights_sd
end;T;+To;
; F; ;
;;;I"BNEAT::Controller::NeatSettings#mutate_change_gene_weights_sd=;F;[[I"
value;T0;[[@�i;T;:#mutate_change_gene_weights_sd=;;;[�;{�;IC; "EFor gene weights perturbations and changes (complete overwrites)
;T; [�;[�; @g; 0; @�;!F;"@h;'@�
;(I".def mutate_change_gene_weights_sd=(value);T;*I"[def mutate_change_gene_weights_sd=(value)
@mutate_change_gene_weights_sd = value
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#mutate_neuron_trait_prob;F;[�;[[@�i ;F;: mutate_neuron_trait_prob;;;[�;{�;IC; "<Returns the value of attribute mutate_neuron_trait_prob
;T; @�;/0;!F; [�;[�; I"<Returns the value of attribute mutate_neuron_trait_prob;T; 0;'@�
;(I"!def mutate_neuron_trait_prob;T;*I"Adef mutate_neuron_trait_prob
@mutate_neuron_trait_prob
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#mutate_neuron_trait_prob=;F;[[I"
value;T0;[[@�i ;F;: mutate_neuron_trait_prob=;;;[�;{�;IC; "0Sets the attribute mutate_neuron_trait_prob
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"@the value to set the attribute mutate_neuron_trait_prob to.;T;I"
value;T;L0; @�; I"ySets the attribute mutate_neuron_trait_prob
@param value the value to set the attribute mutate_neuron_trait_prob to.;T; 0;'@�
;(I")def mutate_neuron_trait_prob=(value);T;*I"Qdef mutate_neuron_trait_prob=(value)
@mutate_neuron_trait_prob = value
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#mutate_only_prob;F;[�;[[@�i
;F;:mutate_only_prob;;;[�;{�;IC; "4Returns the value of attribute mutate_only_prob
;T; @�;/0;!F; [�;[�; I"4Returns the value of attribute mutate_only_prob;T; 0;'@�
;(I"def mutate_only_prob;T;*I"1def mutate_only_prob
@mutate_only_prob
end;T;+To;
; F; ;
;;;I"5NEAT::Controller::NeatSettings#mutate_only_prob=;F;[[I"
value;T0;[[@�i
;F;:mutate_only_prob=;;;[�;{�;IC; "(Sets the attribute mutate_only_prob
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"8the value to set the attribute mutate_only_prob to.;T;I"
value;T;L0; @�; I"iSets the attribute mutate_only_prob
@param value the value to set the attribute mutate_only_prob to.;T; 0;'@�
;(I"!def mutate_only_prob=(value);T;*I"Adef mutate_only_prob=(value)
@mutate_only_prob = value
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#mutate_random_trait_prob;F;[�;[[@�i ;F;: mutate_random_trait_prob;;;[�;{�;IC; "<Returns the value of attribute mutate_random_trait_prob
;T; @;/0;!F; [�;[�; I"<Returns the value of attribute mutate_random_trait_prob;T; 0;'@�
;(I"!def mutate_random_trait_prob;T;*I"Adef mutate_random_trait_prob
@mutate_random_trait_prob
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#mutate_random_trait_prob=;F;[[I"
value;T0;[[@�i ;F;: mutate_random_trait_prob=;;;[�;{�;IC; "0Sets the attribute mutate_random_trait_prob
;T; @;/0;!F; [�;[o;I
;JI"
param;F;KI"@the value to set the attribute mutate_random_trait_prob to.;T;I"
value;T;L0; @; I"ySets the attribute mutate_random_trait_prob
@param value the value to set the attribute mutate_random_trait_prob to.;T; 0;'@�
;(I")def mutate_random_trait_prob=(value);T;*I"Qdef mutate_random_trait_prob=(value)
@mutate_random_trait_prob = value
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#mutate_toggle_enable_prob;F;[�;[[@�i ;F;: mutate_toggle_enable_prob;;;[�;{�;IC; "=Returns the value of attribute mutate_toggle_enable_prob
;T; @';/0;!F; [�;[�; I"=Returns the value of attribute mutate_toggle_enable_prob;T; 0;'@�
;(I""def mutate_toggle_enable_prob;T;*I"Cdef mutate_toggle_enable_prob
@mutate_toggle_enable_prob
end;T;+To;
; F; ;
;;;I">NEAT::Controller::NeatSettings#mutate_toggle_enable_prob=;F;[[I"
value;T0;[[@�i ;F;: mutate_toggle_enable_prob=;;;[�;{�;IC; "1Sets the attribute mutate_toggle_enable_prob
;T; @4;/0;!F; [�;[o;I
;JI"
param;F;KI"Athe value to set the attribute mutate_toggle_enable_prob to.;T;I"
value;T;L0; @4; I"{Sets the attribute mutate_toggle_enable_prob
@param value the value to set the attribute mutate_toggle_enable_prob to.;T; 0;'@�
;(I"*def mutate_toggle_enable_prob=(value);T;*I"Sdef mutate_toggle_enable_prob=(value)
@mutate_toggle_enable_prob = value
end;T;+To;
; F; ;
;;;I"7NEAT::Controller::NeatSettings#mutdiff_coefficient;F;[�;[[@�i
;F;:mutdiff_coefficient;;;[�;{�;IC; "7Returns the value of attribute mutdiff_coefficient
;T; @G;/0;!F; [�;[�; I"7Returns the value of attribute mutdiff_coefficient;T; 0;'@�
;(I" def mutdiff_coefficient;T;*I"7def mutdiff_coefficient
@mutdiff_coefficient
end;T;+To;
; F; ;
;;;I"8NEAT::Controller::NeatSettings#mutdiff_coefficient=;F;[[I"
value;T0;[[@�i
;F;:mutdiff_coefficient=;;;[�;{�;IC; "+Sets the attribute mutdiff_coefficient
;T; @T;/0;!F; [�;[o;I
;JI"
param;F;KI";the value to set the attribute mutdiff_coefficient to.;T;I"
value;T;L0; @T; I"oSets the attribute mutdiff_coefficient
@param value the value to set the attribute mutdiff_coefficient to.;T; 0;'@�
;(I"$def mutdiff_coefficient=(value);T;*I"Gdef mutdiff_coefficient=(value)
@mutdiff_coefficient = value
end;T;+To;
; F; ;
;;;I"1NEAT::Controller::NeatSettings#newlink_tries;F;[�;[[@�i;F;:newlink_tries;;;[�;{�;IC; "1Returns the value of attribute newlink_tries
;T; @g;/0;!F; [�;[�; I"1Returns the value of attribute newlink_tries;T; 0;'@�
;(I"def newlink_tries;T;*I"+def newlink_tries
@newlink_tries
end;T;+To;
; F; ;
;;;I"2NEAT::Controller::NeatSettings#newlink_tries=;F;[[I"
value;T0;[[@�i;F;:newlink_tries=;;;[�;{�;IC; "%Sets the attribute newlink_tries
;T; @t;/0;!F; [�;[o;I
;JI"
param;F;KI"5the value to set the attribute newlink_tries to.;T;I"
value;T;L0; @t; I"cSets the attribute newlink_tries
@param value the value to set the attribute newlink_tries to.;T; 0;'@�
;(I" def newlink_tries=(value);T;*I";def newlink_tries=(value)
@newlink_tries = value
end;T;+To;
; F; ;
;;;I"8NEAT::Controller::NeatSettings#neuron_trait_mut_sig;F;[�;[[@�i;F;:neuron_trait_mut_sig;;;[�;{�;IC; "8Returns the value of attribute neuron_trait_mut_sig
;T; @�;/0;!F; [�;[�; I"8Returns the value of attribute neuron_trait_mut_sig;T; 0;'@�
;(I" def neuron_trait_mut_sig;T;*I"9def neuron_trait_mut_sig
@neuron_trait_mut_sig
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#neuron_trait_mut_sig=;F;[[I"
value;T0;[[@�i;F;:neuron_trait_mut_sig=;;;[�;{�;IC; ",Sets the attribute neuron_trait_mut_sig
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"<the value to set the attribute neuron_trait_mut_sig to.;T;I"
value;T;L0; @�; I"qSets the attribute neuron_trait_mut_sig
@param value the value to set the attribute neuron_trait_mut_sig to.;T; 0;'@�
;(I"%def neuron_trait_mut_sig=(value);T;*I"Idef neuron_trait_mut_sig=(value)
@neuron_trait_mut_sig = value
end;T;+To;
; F; ;
;;;I";NEAT::Controller::NeatSettings#fitness_cost_per_neuron;F;[�;[[@�i;T;: fitness_cost_per_neuron;;;[�;{�;IC; "�fitness costs, if given, use in the computation of fitness
AFTER the overall fitness for the applied stimuli have been
caclulated.
;T; [�;[�; I"�fitness costs, if given, use in the computation of fitness
AFTER the overall fitness for the applied stimuli have been
caclulated.;T; 0; @�;!F;"o;#;$F;%i;&i;'@�
;(I" def fitness_cost_per_neuron;T;*I"?def fitness_cost_per_neuron
@fitness_cost_per_neuron
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#fitness_cost_per_neuron=;F;[[I"
value;T0;[[@�i;T;: fitness_cost_per_neuron=;;;[�;{�;IC; "�fitness costs, if given, use in the computation of fitness
AFTER the overall fitness for the applied stimuli have been
caclulated.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"(def fitness_cost_per_neuron=(value);T;*I"Odef fitness_cost_per_neuron=(value)
@fitness_cost_per_neuron = value
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#fitness_cost_per_gene;F;[�;[[@�i;F;:fitness_cost_per_gene;;;[�;{�;IC; "9Returns the value of attribute fitness_cost_per_gene
;T; @�;/0;!F; [�;[�; I"9Returns the value of attribute fitness_cost_per_gene;T; 0;'@�
;(I" def fitness_cost_per_gene;T;*I";def fitness_cost_per_gene
@fitness_cost_per_gene
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#fitness_cost_per_gene=;F;[[I"
value;T0;[[@�i;F;:fitness_cost_per_gene=;;;[�;{�;IC; "-Sets the attribute fitness_cost_per_gene
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"=the value to set the attribute fitness_cost_per_gene to.;T;I"
value;T;L0; @�; I"sSets the attribute fitness_cost_per_gene
@param value the value to set the attribute fitness_cost_per_gene to.;T; 0;'@�
;(I"&def fitness_cost_per_gene=(value);T;*I"Kdef fitness_cost_per_gene=(value)
@fitness_cost_per_gene = value
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#start_population_size;F;[�;[[@�i;T;:start_population_size;;;[�;{�;IC; "YIf set, will start off at the specified size and
grow to the bigger population size
;T; [�;[�; I"YIf set, will start off at the specified size and
grow to the bigger population size;T; 0; @�;!F;"o;#;$F;%i;&i;'@�
;(I" def start_population_size;T;*I";def start_population_size
@start_population_size
end;T;+To;
; F; ;
;;;I":NEAT::Controller::NeatSettings#start_population_size=;F;[[I"
value;T0;[[@�i;T;:start_population_size=;;;[�;{�;IC; "YIf set, will start off at the specified size and
grow to the bigger population size
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"&def start_population_size=(value);T;*I"Kdef start_population_size=(value)
@start_population_size = value
end;T;+To;
; F; ;
;;;I"3NEAT::Controller::NeatSettings#population_size;F;[�;[[@�i;T;:population_size;;;[�;{�;IC; "YIf set, will start off at the specified size and
grow to the bigger population size
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"def population_size;T;*I"/def population_size
@population_size
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#population_size=;F;[[I"
value;T0;[[@�i;T;:population_size=;;;[�;{�;IC; "YIf set, will start off at the specified size and
grow to the bigger population size
;T; [�;[�; @�; 0; @ ;!F;"@�;'@�
;(I" def population_size=(value);T;*I"?def population_size=(value)
@population_size = value
end;T;+To;
; F; ;
;;;I"5NEAT::Controller::NeatSettings#start_sequence_at;F;[�;[[@�i;F;:start_sequence_at;;;[�;{�;IC; "5Returns the value of attribute start_sequence_at
;T; @;/0;!F; [�;[�; I"5Returns the value of attribute start_sequence_at;T; 0;'@�
;(I"def start_sequence_at;T;*I"3def start_sequence_at
@start_sequence_at
end;T;+To;
; F; ;
;;;I"6NEAT::Controller::NeatSettings#start_sequence_at=;F;[[I"
value;T0;[[@�i;F;:start_sequence_at=;;;[�;{�;IC; ")Sets the attribute start_sequence_at
;T; @&;/0;!F; [�;[o;I
;JI"
param;F;KI"9the value to set the attribute start_sequence_at to.;T;I"
value;T;L0; @&; I"kSets the attribute start_sequence_at
@param value the value to set the attribute start_sequence_at to.;T; 0;'@�
;(I""def start_sequence_at=(value);T;*I"Cdef start_sequence_at=(value)
@start_sequence_at = value
end;T;+To;
; F; ;
;;;I"3NEAT::Controller::NeatSettings#end_sequence_at;F;[�;[[@�i;F;:end_sequence_at;;;[�;{�;IC; "3Returns the value of attribute end_sequence_at
;T; @9;/0;!F; [�;[�; I"3Returns the value of attribute end_sequence_at;T; 0;'@�
;(I"def end_sequence_at;T;*I"/def end_sequence_at
@end_sequence_at
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#end_sequence_at=;F;[[I"
value;T0;[[@�i;F;:end_sequence_at=;;;[�;{�;IC; "'Sets the attribute end_sequence_at
;T; @F;/0;!F; [�;[o;I
;JI"
param;F;KI"7the value to set the attribute end_sequence_at to.;T;I"
value;T;L0; @F; I"gSets the attribute end_sequence_at
@param value the value to set the attribute end_sequence_at to.;T; 0;'@�
;(I" def end_sequence_at=(value);T;*I"?def end_sequence_at=(value)
@end_sequence_at = value
end;T;+To;
; F; ;
;;;I"/NEAT::Controller::NeatSettings#print_every;F;[�;[[@�i ;F;:print_every;;;[�;{�;IC; "/Returns the value of attribute print_every
;T; @Y;/0;!F; [�;[�; I"/Returns the value of attribute print_every;T; 0;'@�
;(I"def print_every;T;*I"'def print_every
@print_every
end;T;+To;
; F; ;
;;;I"0NEAT::Controller::NeatSettings#print_every=;F;[[I"
value;T0;[[@�i ;F;:print_every=;;;[�;{�;IC; "#Sets the attribute print_every
;T; @f;/0;!F; [�;[o;I
;JI"
param;F;KI"3the value to set the attribute print_every to.;T;I"
value;T;L0; @f; I"_Sets the attribute print_every
@param value the value to set the attribute print_every to.;T; 0;'@�
;(I" def print_every=(value);T;*I"7def print_every=(value)
@print_every = value
end;T;+To;
; F; ;
;;;I"3NEAT::Controller::NeatSettings#recur_only_prob;F;[�;[[@�i ;F;:recur_only_prob;;;[�;{�;IC; "3Returns the value of attribute recur_only_prob
;T; @y;/0;!F; [�;[�; I"3Returns the value of attribute recur_only_prob;T; 0;'@�
;(I"def recur_only_prob;T;*I"/def recur_only_prob
@recur_only_prob
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#recur_only_prob=;F;[[I"
value;T0;[[@�i ;F;:recur_only_prob=;;;[�;{�;IC; "'Sets the attribute recur_only_prob
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"7the value to set the attribute recur_only_prob to.;T;I"
value;T;L0; @�; I"gSets the attribute recur_only_prob
@param value the value to set the attribute recur_only_prob to.;T; 0;'@�
;(I" def recur_only_prob=(value);T;*I"?def recur_only_prob=(value)
@recur_only_prob = value
end;T;+To;
; F; ;
;;;I".NEAT::Controller::NeatSettings#recur_prob;F;[�;[[@�i ;F;:recur_prob;;;[�;{�;IC; ".Returns the value of attribute recur_prob
;T; @�;/0;!F; [�;[�; I".Returns the value of attribute recur_prob;T; 0;'@�
;(I"def recur_prob;T;*I"%def recur_prob
@recur_prob
end;T;+To;
; F; ;
;;;I"/NEAT::Controller::NeatSettings#recur_prob=;F;[[I"
value;T0;[[@�i ;F;:recur_prob=;;;[�;{�;IC; ""Sets the attribute recur_prob
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"2the value to set the attribute recur_prob to.;T;I"
value;T;L0; @�; I"]Sets the attribute recur_prob
@param value the value to set the attribute recur_prob to.;T; 0;'@�
;(I"def recur_prob=(value);T;*I"5def recur_prob=(value)
@recur_prob = value
end;T;+To;
; F; ;
;;;I"6NEAT::Controller::NeatSettings#survival_threshold;F;[�;[[@�i#;T;:survival_threshold;;;[�;{�;IC; "Qfactor (0 to 1) of the top percentage of the species that's
allowed to mate.
;T; [�;[�; I"Qfactor (0 to 1) of the top percentage of the species that's
allowed to mate.;T; 0; @�;!F;"o;#;$F;%i!;&i";'@�
;(I"def survival_threshold;T;*I"5def survival_threshold
@survival_threshold
end;T;+To;
; F; ;
;;;I"7NEAT::Controller::NeatSettings#survival_threshold=;F;[[I"
value;T0;[[@�i#;T;:survival_threshold=;;;[�;{�;IC; "Qfactor (0 to 1) of the top percentage of the species that's
allowed to mate.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"#def survival_threshold=(value);T;*I"Edef survival_threshold=(value)
@survival_threshold = value
end;T;+To;
; F; ;
;;;I"@NEAT::Controller::NeatSettings#survival_mininum_per_species;F;[�;[[@�i$;F;:!survival_mininum_per_species;;;[�;{�;IC; "@Returns the value of attribute survival_mininum_per_species
;T; @�;/0;!F; [�;[�; I"@Returns the value of attribute survival_mininum_per_species;T; 0;'@�
;(I"%def survival_mininum_per_species;T;*I"Idef survival_mininum_per_species
@survival_mininum_per_species
end;T;+To;
; F; ;
;;;I"ANEAT::Controller::NeatSettings#survival_mininum_per_species=;F;[[I"
value;T0;[[@�i$;F;:"survival_mininum_per_species=;;;[�;{�;IC; "4Sets the attribute survival_mininum_per_species
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI"Dthe value to set the attribute survival_mininum_per_species to.;T;I"
value;T;L0; @�; I"|Sets the attribute survival_mininum_per_species
@param value the value to set the attribute survival_mininum_per_species to.;T; 0;'@�
;(I"-def survival_mininum_per_species=(value);T;*I"Ydef survival_mininum_per_species=(value)
@survival_mininum_per_species = value
end;T;+To;
; F; ;
;;;I"8NEAT::Controller::NeatSettings#trait_mutation_power;F;[�;[[@�i&;F;:trait_mutation_power;;;[�;{�;IC; "8Returns the value of attribute trait_mutation_power
;T; @�;/0;!F; [�;[�; I"8Returns the value of attribute trait_mutation_power;T; 0;'@�
;(I" def trait_mutation_power;T;*I"9def trait_mutation_power
@trait_mutation_power
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#trait_mutation_power=;F;[[I"
value;T0;[[@�i&;F;:trait_mutation_power=;;;[�;{�;IC; ",Sets the attribute trait_mutation_power
;T; @;/0;!F; [�;[o;I
;JI"
param;F;KI"<the value to set the attribute trait_mutation_power to.;T;I"
value;T;L0; @; I"qSets the attribute trait_mutation_power
@param value the value to set the attribute trait_mutation_power to.;T; 0;'@�
;(I"%def trait_mutation_power=(value);T;*I"Idef trait_mutation_power=(value)
@trait_mutation_power = value
end;T;+To;
; F; ;
;;;I"8NEAT::Controller::NeatSettings#trait_param_mut_prob;F;[�;[[@�i';F;:trait_param_mut_prob;;;[�;{�;IC; "8Returns the value of attribute trait_param_mut_prob
;T; @;/0;!F; [�;[�; I"8Returns the value of attribute trait_param_mut_prob;T; 0;'@�
;(I" def trait_param_mut_prob;T;*I"9def trait_param_mut_prob
@trait_param_mut_prob
end;T;+To;
; F; ;
;;;I"9NEAT::Controller::NeatSettings#trait_param_mut_prob=;F;[[I"
value;T0;[[@�i';F;:trait_param_mut_prob=;;;[�;{�;IC; ",Sets the attribute trait_param_mut_prob
;T; @";/0;!F; [�;[o;I
;JI"
param;F;KI"<the value to set the attribute trait_param_mut_prob to.;T;I"
value;T;L0; @"; I"qSets the attribute trait_param_mut_prob
@param value the value to set the attribute trait_param_mut_prob to.;T; 0;'@�
;(I"%def trait_param_mut_prob=(value);T;*I"Idef trait_param_mut_prob=(value)
@trait_param_mut_prob = value
end;T;+To;
; F; ;
;;;I"3NEAT::Controller::NeatSettings#weigh_mut_power;F;[�;[[@�i(;F;:weigh_mut_power;;;[�;{�;IC; "3Returns the value of attribute weigh_mut_power
;T; @5;/0;!F; [�;[�; I"3Returns the value of attribute weigh_mut_power;T; 0;'@�
;(I"def weigh_mut_power;T;*I"/def weigh_mut_power
@weigh_mut_power
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#weigh_mut_power=;F;[[I"
value;T0;[[@�i(;F;:weigh_mut_power=;;;[�;{�;IC; "'Sets the attribute weigh_mut_power
;T; @B;/0;!F; [�;[o;I
;JI"
param;F;KI"7the value to set the attribute weigh_mut_power to.;T;I"
value;T;L0; @B; I"gSets the attribute weigh_mut_power
@param value the value to set the attribute weigh_mut_power to.;T; 0;'@�
;(I" def weigh_mut_power=(value);T;*I"?def weigh_mut_power=(value)
@weigh_mut_power = value
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#feature_selection_switch;F;[�;[[@�i+;T;: feature_selection_switch;;;[�;{�;IC; "Enable FS-NEAT
;T; [�;[�; I"Enable FS-NEAT;T; 0; @U;!F;"o;#;$F;%i*;&i*;'@�
;(I"!def feature_selection_switch;T;*I"Adef feature_selection_switch
@feature_selection_switch
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#feature_selection_switch=;F;[[I"
value;T0;[[@�i+;T;: feature_selection_switch=;;;[�;{�;IC; "Enable FS-NEAT
;T; [�;[�; @_; 0; @c;!F;"@`;'@�
;(I")def feature_selection_switch=(value);T;*I"Qdef feature_selection_switch=(value)
@feature_selection_switch = value
end;T;+To;
; F; ;
;;;I"0NEAT::Controller::NeatSettings#hyper_switch;F;[�;[[@�i0;T;:hyper_switch;;;[�;{�;IC; "�Enable HyperNEAT. This will result in the critters
being interpreted as CPPNs for substrate weights. Additional
setup will be necessary.
;T; [�;[�; I"�Enable HyperNEAT. This will result in the critters
being interpreted as CPPNs for substrate weights. Additional
setup will be necessary.;T; 0; @q;!F;"o;#;$F;%i-;&i/;'@�
;(I"def hyper_switch;T;*I")def hyper_switch
@hyper_switch
end;T;+To;
; F; ;
;;;I"1NEAT::Controller::NeatSettings#hyper_switch=;F;[[I"
value;T0;[[@�i0;T;:hyper_switch=;;;[�;{�;IC; "�Enable HyperNEAT. This will result in the critters
being interpreted as CPPNs for substrate weights. Additional
setup will be necessary.
;T; [�;[�; @{; 0; @;!F;"@|;'@�
;(I" def hyper_switch=(value);T;*I"9def hyper_switch=(value)
@hyper_switch = value
end;T;+To;
; F; ;
;;;I"<NEAT::Controller::NeatSettings#evolved_substrate_switch;F;[�;[[@�i4;T;: evolved_substrate_switch;;;[�;{�;IC; "YEnable Evolved Substrate HyperNEAT. Meaningless unless
hyper_switch is also enabled.
;T; [�;[�; I"YEnable Evolved Substrate HyperNEAT. Meaningless unless
hyper_switch is also enabled.;T; 0; @�;!F;"o;#;$F;%i2;&i3;'@�
;(I"!def evolved_substrate_switch;T;*I"Adef evolved_substrate_switch
@evolved_substrate_switch
end;T;+To;
; F; ;
;;;I"=NEAT::Controller::NeatSettings#evolved_substrate_switch=;F;[[I"
value;T0;[[@�i4;T;: evolved_substrate_switch=;;;[�;{�;IC; "YEnable Evolved Substrate HyperNEAT. Meaningless unless
hyper_switch is also enabled.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I")def evolved_substrate_switch=(value);T;*I"Qdef evolved_substrate_switch=(value)
@evolved_substrate_switch = value
end;T;+To;
; F; ;
;;;I"4NEAT::Controller::NeatSettings#real_time_switch;F;[�;[[@�i8;T;:real_time_switch;;;[�;{�;IC; "bEnable RT-NEAT, for gradual evolution suitable for
games and other human-interactive systems.
;T; [�;[�; I"bEnable RT-NEAT, for gradual evolution suitable for
games and other human-interactive systems.;T; 0; @�;!F;"o;#;$F;%i6;&i7;'@�
;(I"def real_time_switch;T;*I"1def real_time_switch
@real_time_switch
end;T;+To;
; F; ;
;;;I"5NEAT::Controller::NeatSettings#real_time_switch=;F;[[I"
value;T0;[[@�i8;T;:real_time_switch=;;;[�;{�;IC; "bEnable RT-NEAT, for gradual evolution suitable for
games and other human-interactive systems.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I"!def real_time_switch=(value);T;*I"Adef real_time_switch=(value)
@real_time_switch = value
end;T;+To;
; F; ;
;;;I"5NEAT::Controller::NeatSettings#recurrency_switch;F;[�;[[@�i;;T;:recurrency_switch;;;[�;{�;IC; "+If true, allow for recurrent networks.
;T; [�;[�; I"+If true, allow for recurrent networks.;T; 0; @�;!F;"o;#;$F;%i:;&i:;'@�
;(I"def recurrency_switch;T;*I"3def recurrency_switch
@recurrency_switch
end;T;+To;
; F; ;
;;;I"6NEAT::Controller::NeatSettings#recurrency_switch=;F;[[I"
value;T0;[[@�i;;T;:recurrency_switch=;;;[�;{�;IC; "+If true, allow for recurrent networks.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�
;(I""def recurrency_switch=(value);T;*I"Cdef recurrency_switch=(value)
@recurrency_switch = value
end;T;+To;
; F; ;
;;;I".NEAT::Controller::NeatSettings#initialize;F;[�;[[@�i>;T;;k;;;[�;{�;IC; "+Set up defaults for mandatory entries.
;T; [�;[o;I
;JI" return;F;KI"#a new instance of NeatSettings;T;0;L[I"NeatSettings;F; @�; I"+Set up defaults for mandatory entries.;T; 0; @�;!F;"o;#;$F;%i=;&i=;'@�
;(I"def initialize;T;)T;*I"�def initialize
super
@start_sequence_at = 0
@end_sequence_at = 100
@max_generations = 1000
# Default operators
@evaluator = Evaluator.new self
@expressor = Expressor.new self
@evolver = Evolver.new self
end;T;+T;:@�
;;IC;[�;:@�
;<IC;[�;:@�
;NIC;O{;GIC;O{�;PT;
IC;O{:;�IC;O{;x@�
;y@�
;PT;IC;O{;x@�
;y@�
;PT;IC;O{;x@�
;y@�
;PT;IC;O{;x@ ;y@;PT;IC;O{;x@%;y@3;PT;
IC;O{;x@A;y@M;PT; IC;O{;x@[;y@g;PT;IC;O{;x@u;y@�;PT;IC;O{;x@�;y@�;PT;IC;O{;x@�;y@�;PT;IC;O{;x@�;y@�;PT;IC;O{;x@�;y@�;PT;IC;O{;x@;y@;PT;IC;O{;x@%;y@2;PT; IC;O{;x@E;y@R;PT; IC;O{;x@e;y@r;PT; IC;O{;x@�;y@�;PT;"IC;O{;x@�;y@�;PT;$IC;O{;x@�;y@�;PT;&IC;O{;x@�;y@�;PT;(IC;O{;x@�;y@
;PT;*IC;O{;x@ ;y@*;PT;,IC;O{;x@=;y@J;PT;.IC;O{;x@];y@k;PT;0IC;O{;x@y;y@�;PT;2IC;O{;x@�;y@�;PT;4IC;O{;x@�;y@�;PT;6IC;O{;x@�;y@�;PT;8IC;O{;x@�;y@�;PT;:IC;O{;x@;y@;PT;<IC;O{;x@';y@4;PT;>IC;O{;x@G;y@T;PT;@IC;O{;x@g;y@t;PT;BIC;O{;x@�;y@�;PT;DIC;O{;x@�;y@�;PT;FIC;O{;x@�;y@�;PT;HIC;O{;x@�;y@�;PT;JIC;O{;x@�;y@ ;PT;LIC;O{;x@;y@&;PT;NIC;O{;x@9;y@F;PT;PIC;O{;x@Y;y@f;PT;RIC;O{;x@y;y@�;PT;TIC;O{;x@�;y@�;PT;VIC;O{;x@�;y@�;PT;XIC;O{;x@�;y@�;PT;ZIC;O{;x@�;y@;PT;\IC;O{;x@;y@";PT;^IC;O{;x@5;y@B;PT;`IC;O{;x@U;y@c;PT;bIC;O{;x@q;y@;PT;dIC;O{;x@�;y@�;PT;fIC;O{;x@�;y@�;PT;hIC;O{;x@�;y@�;PT;PT;PT;Q{�;R[�;[[@�i�;T;:NeatSettings;;;;;[�;{�;IC; "�Various parameters affecting evolution.
Based somewhat on the C version of NEAT.
TODO not all of these parameters are implemented yet!!!
;T; [�;[�; I"�Various parameters affecting evolution.
Based somewhat on the C version of NEAT.
TODO not all of these parameters are implemented yet!!!;T; 0; @�
;!F;"o;#;$F;%i�;&i�;'@ ;I"#NEAT::Controller::NeatSettings;F;To;= ;>0;?0;@0;;r;'@;B@�;C0;+To;
; F; ;
;;;I" NEAT::Controller#initialize;F;[
[I"neural_inputs:;TI"nil;T[I"neural_outputs:;TI"nil;T[I"neural_hidden:;TI"nil;T[I"parameters:;TI"NeatSettings.new;T[I" █T0;[[@�iN;T;;k;;;[�;{�;IC; "�- neural_inputs -- array of input classes
- neural_outputs -- array of output classes
- parameters -- NeatParameters object, or a path to a YAML file to create this.
;T; [�;[o;I
;JI" return;F;KI"!a new instance of Controller;T;0;L[I"Controller;F; @;; I"�- neural_inputs -- array of input classes
- neural_outputs -- array of output classes
- parameters -- NeatParameters object, or a path to a YAML file to create this.;T; 0; @;;!F;"o;#;$F;%iK;&iM;'@ ;(I"'def initialize(neural_inputs: nil,;T;)T;*I"�def initialize(neural_inputs: nil,
neural_outputs: nil,
neural_hidden: nil,
parameters: NeatSettings.new,
&block)
super(self)
@verbosity = 1
@glob_innov_num = 0
@gaussian = Distribution::Normal.rng
@population_history = []
@evolver = Evolver.new self
@expressor = Expressor.new self
@neuron_catalog = Neuron::neuron_types.clone
@neural_inputs = neural_inputs
@neural_outputs = neural_outputs
@neural_hidden = neural_hidden
# Default classes for population and operators, etc.
@population_class = NEAT::Population
@evaluator_class = NEAT::Evaluator
@expressor_class = NEAT::Expressor
@evolver_class = NEAT::Evolver
# Handle the parameters parameter. :-)
@parms = unless parameters.kind_of? String
parameters
else # load it from a file
open(parameters, 'r') { |fd| YAML::load fd.read }
end
block.(self) unless block.nil?
end;T;+To;
; F; ;
;;;I"$NEAT::Controller#new_innovation;F;[�;[[@�io;F;;�;;;[�;{�;IC; "�
;T; @\;/0;!F; [�;[�; I"�;T; 0;'@ ;(I"3def new_innovation ; @glob_innov_num += 1; end;T;)T;*I"3def new_innovation ; @glob_innov_num += 1; end;T;+To;
; F; ;
;;;I" NEAT::Controller#gaussian;F;[�;[[@�ip;F;;�;;;[�;{�;IC; "�
;T; @i;/0;!F; [�;[�; I"�;T; 0;'@ ;(I"&def gaussian ; @gaussian.() ; end;T;)T;*I"&def gaussian ; @gaussian.() ; end;T;+To;
; F; ;
;;;I"NEAT::Controller#run;F;[�;[[@�is;T;:run;;;[�;{�;IC; "Run this evolution.
;T; [�;[�; I"Run this evolution.;T; 0; @v;!F;"o;#;$F;%ir;&ir;'@ ;(I" def run;T;)T;*I"�def run
pre_run_initialize
(1..@parms.max_generations).each do |gen_number|
@generation_num = gen_number
@population_history << unless @population.nil?
@population
else
@population = @population_class.new(self)
end
@population_history.shift unless @population_history.size <= @parms.max_population_history
@population.mutate!
@population.express!
## Evaluate population
@evaluator.ready_for_evaluation @population
(@parms.start_sequence_at .. @parms.end_sequence_at).each do |snum|
@seq_num = snum
@population.evaluate!
end
@population.analyze!
@population.speciate!
$log.debug @population.dump_s unless @verbosity < 3
new_pop = @population.evolve
## Report hook for evaluation
@report_hook.(@population.report) unless @report_hook.nil?
## Exit if fitness criteria is reached
#FIXME handle this exit condition better!!!!!
exit if @stop_on_fit_func.(@population.report[:fitness], self) unless @stop_on_fit_func.nil?
## Evolve population
@population = new_pop
## Finish up this run
@end_run_func.(self) unless @end_run_func.nil?
end
end;T;+To;
; F; ;
;;o;I"(NEAT::Controller#pre_run_initialize;F;[�;[[@�i�;T;:pre_run_initialize;;;[�;{�;IC; "EWe must set up the objects we need prior to the run, if not set.
;T; [�;[�; I"EWe must set up the objects we need prior to the run, if not set.;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@ ;(I"def pre_run_initialize;T;)T;*I"�def pre_run_initialize
@evaluator = @evaluator_class.new(self) if @evaluator.nil?
@evolver = @evolver_class.new(self) if @evolver.nil?
end;T;+T;:@ ;;IC;[�;:@ ;<IC;[�;:@ ;NIC;O{;GIC;O{�;PT;
IC;O{ ;�IC;O{;x@ ;y0;PT;�IC;O{;x@! ;y0;PT;�IC;O{;x@/ ;y0;PT;�IC;O{;x@= ;y@K ;PT;�IC;O{;x@Y ;y@g ;PT;�IC;O{;x@u ;y@� ;PT;�IC;O{;x@� ;y@� ;PT;�IC;O{;x@� ;y@� ;PT;IC;O{;x@� ;y0;PT;�IC;O{;x@� ;y0;PT;�IC;O{;x@� ;y0;PT;�IC;O{;x@� ;y@� ;PT;�IC;O{;x@ ;y@ ;PT;�IC;O{;x@+ ;y@8 ;PT;�IC;O{;x@K ;y@X ;PT;�IC;O{;x@k ;y@x ;PT;�IC;O{;x@� ;y@� ;PT;�IC;O{;x@� ;y@� ;PT;�IC;O{;x@� ;y@� ;PT;�IC;O{;x@� ;y@� ;PT;�IC;O{;x@� ;y@
;PT;�IC;O{;x@
;y@)
;PT;�IC;O{;x@7
;y@C
;PT;�IC;O{;x@Q
;y@]
;PT;�IC;O{;x@k
;y@y
;PT;�IC;O{;x@�
;y@�
;PT;uIC;O{;x@�
;y0;PT;PT;PT;Q{�;R[�;[[@�i�;T;:Controller;;;;;[�;{�;IC; " = Controller for all operations of RubyNEAT
This object contains all the specifications and details for
evolving and evaluation of the RubyNEAT system. It is
a type of "World", if you will, for the entire enterprise.
Your application shall only have one Controller.
;T; [�;[�; I" = Controller for all operations of RubyNEAT
This object contains all the specifications and details for
evolving and evaluation of the RubyNEAT system. It is
a type of "World", if you will, for the entire enterprise.
Your application shall only have one Controller.;T; 0; @ ;!F;"o;#;$F;%i�;&i�;'@;I"NEAT::Controller;F;To;= ;>0;?0;@0;;r;'@;B@�;C0;+To;
; F; ;G;;;I"NEAT.controller;F;[�;[[@�i�;F;;t;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@;(I",def self.controller ; @controller ; end;T;)T;*I",def self.controller ; @controller ; end;T;+To;
; F; ;G;;;I"NEAT.controller=;F;[[I"controller;T0;[[@�i�;F;:controller=;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@;(I"Fdef self.controller=(controller) ; @controller = controller ; end;T;)T;*I"Fdef self.controller=(controller) ; @controller = controller ; end;T;+To;
; F; ;G;;;I"NEAT.create_controller;F;[[I" *parms;T0;[[@�i�;F;:create_controller;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@;(I"Rdef self.create_controller(*parms); @controller = Controller.new(*parms); end;T;)T;*I"Rdef self.create_controller(*parms); @controller = Controller.new(*parms); end;T;+To;F;IC;[
o;
; F; ;
;;;I" NEAT::Expressor#initialize;F;[[I"c;T0;[[I" lib/rubyneat/expressor.rb;Ti
;F;;k;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[o;I
;JI" return;F;KI" a new instance of Expressor;T;0;L[I"Expressor;F; @�; I"�;T; 0;'@�;(I"def initialize(c);T;)T;*I"(def initialize(c)
super
end;T;+To;
; F; ;
;;;I" NEAT::Expressor#express!;F;[[I" critter;T0;[[@�i ;T;;�;;;[�;{�;IC; "�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.
;T; [�;[�; I"�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.;T; 0; @;!F;"o;#;$F;%i;&i;'@�;(I"def express!(critter);T;)T;*I"�def express!(critter)
critter.ready_for_expression!
express_neurons! critter
express_genes! critter
express_expression! critter
end;T;+To;
; F; ;
;;�;I"%NEAT::Expressor#express_neurons!;F;[[I" critter;T0;[[@�i%;T;:express_neurons!;;;[�;{�;IC; " Express Neurons as methods
;T; [�;[�; I" Express Neurons as methods;T; 0; @;!F;"o;#;$F;%i$;&i$;'@�;(I""def express_neurons!(critter);T;)T;*I"�def express_neurons!(critter)
critter.genotype.neurons.each do |name, neuron|
neuron.express(critter.phenotype) unless neuron.input? and not neuron.bias?
end
end;T;+To;
; F; ;
;;�;I"#NEAT::Expressor#express_genes!;F;[[I" critter;T0;[[@�i?;T;:express_genes!;;;[�;{�;IC; "m= 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.
;T; [�;[�; I"m= 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.;T; 0; @!;!F;"o;#;$F;%i+;&i>;'@�;(I" def express_genes!(critter);T;)T;*I"~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;T;+To;
; F; ;
;;�;I"(NEAT::Expressor#express_expression!;F;[[I" critter;T0;[[@�io;F;:express_expression!;;;[�;{�;IC; "�
;T; @1;/0;!F; [�;[�; I"�;T; 0;'@�;(I"%def express_expression!(critter);T;)T;*I"Ldef express_expression!(critter)
critter.phenotype.express!
end;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@�i ;T;:Expressor;;;;;[�;{�;IC; "Q= Basis of all expressors.
Expressor object turn genotypes into phenotypes.
;T; [�;[�; I"Q= Basis of all expressors.
Expressor object turn genotypes into phenotypes.;T; 0; @�;!F;"o;#;$F;%i
;&i ;'@;I"NEAT::Expressor;F;To;= ;>0;?0;@0;;�;'@;B@�
;C0;+To;F;IC;[o;
; F; ;
;;;I")NEAT::Evaluator#ready_for_evaluation;F;[[I"pop;T0;[[I" lib/rubyneat/evaluator.rb;Ti;T;:ready_for_evaluation;;;[�;{�;IC; "kThis is call prior to any sequence evaluation. Here,
we clean up persistent tracking information, etc.
;T; [�;[�; I"kThis is call prior to any sequence evaluation. Here,
we clean up persistent tracking information, etc.;T; 0; @T;!F;"o;#;$F;%i
;&i;'@R;(I""def ready_for_evaluation(pop);T;)T;*I"Ydef ready_for_evaluation(pop)
@crit_hist = {}
pop.initialize_for_recurrence!
end;T;+To;
; F; ;
;;;I" NEAT::Evaluator#evaluate!;F;[[I" critter;T0;[[@[i ;T;;�;;;[�;{�;IC; "GEvaluate one step of a sequence of evaluations.
For time series and realtime ongoing evaluations,
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.
;T; [�;[�; I"yEvaluate 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.;T; 0; @e;!F;"o;#;$F;%i;&i ;'@R;(I"def evaluate!(critter);T;)T;*I"�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;T;+To;
; F; ;
;;;I")NEAT::Evaluator#analyze_for_fitness!;F;[[I" critter;T0;[[@[i-;T;:analyze_for_fitness!;;;[�;{�;IC; "�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.
;T; [�;[�; I"�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.;T; 0; @u;!F;"o;#;$F;%i*;&i,;'@R;(I"&def analyze_for_fitness!(critter);T;)T;*I"8def 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;T;+T;:@R;;IC;[�;:@R;<IC;[�;:@R;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@[i ;T;:Evaluator;;;;;[�;{�;IC; "�= Evaluator evaluates phenotype of critter for fitness, novelty, etc.
We can have a chain of these evaluators whose outputs are summed, etc.
;T; [�;[�; I"�= Evaluator evaluates phenotype of critter for fitness, novelty, etc.
We can have a chain of these evaluators whose outputs are summed, etc.;T; 0; @R;!F;"o;#;$F;%i ;&i
;'@;I"NEAT::Evaluator;F;To;= ;>0;?0;@0;;�;'@;B@�
;C0;+To;F;IC;[%o;
; F; ;
;;;I"#NEAT::Population#input_neurons;F;[�;[[I" lib/rubyneat/population.rb;Ti;T;:input_neurons;;;[�;{�;IC; "`Ordered list or hash of input neuron classes
(all critters generated here shall have this)
;T; [�;[�; I"`Ordered list or hash of input neuron classes
(all critters generated here shall have this);T; 0; @�;!F;"o;#;$F;%i;&i;'@�;(I"def input_neurons;T;*I"+def input_neurons
@input_neurons
end;T;+To;
; F; ;
;;;I"$NEAT::Population#input_neurons=;F;[[I"
value;T0;[[@�i;T;:input_neurons=;;;[�;{�;IC; "`Ordered list or hash of input neuron classes
(all critters generated here shall have this)
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I" def input_neurons=(value);T;*I";def input_neurons=(value)
@input_neurons = value
end;T;+To;
; F; ;
;;;I"$NEAT::Population#hidden_neurons;F;[�;[[@�i;T;:hidden_neurons;;;[�;{�;IC; "8List of possible neuron classes for hidden neurons.
;T; [�;[�; I"8List of possible neuron classes for hidden neurons.;T; 0; @�;!F;"o;#;$F;%i;&i;'@�;(I"def hidden_neurons;T;*I"-def hidden_neurons
@hidden_neurons
end;T;+To;
; F; ;
;;;I"%NEAT::Population#hidden_neurons=;F;[[I"
value;T0;[[@�i;T;:hidden_neurons=;;;[�;{�;IC; "8List of possible neuron classes for hidden neurons.
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I" def hidden_neurons=(value);T;*I"=def hidden_neurons=(value)
@hidden_neurons = value
end;T;+To;
; F; ;
;;;I"$NEAT::Population#output_neurons;F;[�;[[@�i;T;:output_neurons;;;[�;{�;IC; "`Ordered list or hash of output neuron classes
(all critters generated here shall have this)
;T; [�;[�; I"`Ordered list or hash of output neuron classes
(all critters generated here shall have this);T; 0; @�;!F;"o;#;$F;%i;&i;'@�;(I"def output_neurons;T;*I"-def output_neurons
@output_neurons
end;T;+To;
; F; ;
;;;I"%NEAT::Population#output_neurons=;F;[[I"
value;T0;[[@�i;T;:output_neurons=;;;[�;{�;IC; "`Ordered list or hash of output neuron classes
(all critters generated here shall have this)
;T; [�;[�; @�; 0; @�;!F;"@�;'@�;(I" def output_neurons=(value);T;*I"=def output_neurons=(value)
@output_neurons = value
end;T;+To;
; F; ;
;;;I" NEAT::Population#traits;F;[�;[[@�i;F;: traits;;;[�;{�;IC; "*Returns the value of attribute traits
;T; @�;/0;!F; [�;[�; I"*Returns the value of attribute traits;T; 0;'@�;(I"def traits;T;*I" def traits
@traits
end;T;+To;
; F; ;
;;;I" NEAT::Population#traits=;F;[[I"
value;T0;[[@�i;F;: traits=;;;[�;{�;IC; " Sets the attribute traits
;T; @�;/0;!F; [�;[o;I
;JI"
param;F;KI".the value to set the attribute traits to.;T;I"
value;T;L0; @�; I"USets the attribute traits
@param value the value to set the attribute traits to.;T; 0;'@�;(I"def traits=(value);T;*I"-def traits=(value)
@traits = value
end;T;+To;
; F; ;
;;;I" NEAT::Population#critters;F;[�;[[@�i ;T;:
critters;;;[�;{�;IC; "'list of critter in this population
;T; [�;[�; I"'list of critter in this population;T; 0; @;!F;"o;#;$F;%i ;&i ;'@�;(I"def critters;T;*I"!def critters
@critters
end;T;+To;
; F; ;
;;;I" NEAT::Population#critters=;F;[[I"
value;T0;[[@�i ;T;:critters=;;;[�;{�;IC; "'list of critter in this population
;T; [�;[�; @; 0; @ ;!F;"@;'@�;(I"def critters=(value);T;*I"1def critters=(value)
@critters = value
end;T;+To;
; F; ;
;;;I" NEAT::Population#fitness;F;[�;[[@�i!;T;;0;;;[�;{�;IC; "+Overall population fitness and novelty
;T; [�;[�; I"+Overall population fitness and novelty;T; 0; @*;!F;"o;#;$F;%i ;&i ;'@�;(I"def fitness;T;*I" def fitness
@fitness
end;T;+To;
; F; ;
;;;I" NEAT::Population#novelty;F;[�;[[@�i!;T;;�;;;[�;{�;IC; "+Overall population fitness and novelty
;T; [�;[�; @4; 0; @8;!F;"@5;'@�;(I"def novelty;T;*I" def novelty
@novelty
end;T;+To;
; F; ;
;;;I" NEAT::Population#species;F;[�;[[@�i$;T;: species;;;[�;{�;IC; " Hash list of species lists
;T; [�;[�; I" Hash list of species lists;T; 0; @D;!F;"o;#;$F;%i#;&i#;'@�;(I"def species;T;*I" def species
@species
end;T;+To;
; F; ;
;;;I" NEAT::Population#initialize;F;[[I"c;T0[I" █T0;[[@�i*;T;;k;;;[�;{�;IC; "3Create initial (ramdom) population of critters
;T; [�;[o;I
;JI" return;F;KI"!a new instance of Population;T;0;L[I"Population;F; @R; I"3Create initial (ramdom) population of critters;T; 0; @R;!F;"o;#;$F;%i);&i);'@�;(I" def initialize(c, &block);T;)T;*I"�def initialize(c, &block)
super
@input_neurons = c.neural_inputs.clone
@output_neurons = c.neural_outputs.clone
@hidden_neurons = unless c.neural_hidden.nil?
c.neural_hidden
else
c.neuron_catalog.keep_if {|n| not n.input?}
end
@critters = (0 ... c.parms.start_population_size || c.parms.population_size).map do
Critter.new(self)
end
block.(self) unless block.nil?
end;T;+To;
; F; ;
;;;I"0NEAT::Population#initialize_for_recurrence!;F;[�;[[@�i;;T;: initialize_for_recurrence!;;;[�;{�;IC; "TMake sure all critters are reset and prepared for
recurrent network evaluation.
;T; [�;[�; I"TMake sure all critters are reset and prepared for
recurrent network evaluation.;T; 0; @i;!F;"o;#;$F;%i9;&i:;'@�;(I"#def initialize_for_recurrence!;T;)T;*I"Zdef initialize_for_recurrence!
@critters.each {|crit| crit.initialize_neurons!}
end;T;+To;
; F; ;
;;;I" NEAT::Population#mutate!;F;[�;[[@�i@;T;;�;;;[�;{�;IC; ""Mutate the genes and neurons.
;T; [�;[�; I""Mutate the genes and neurons.;T; 0; @w;!F;"o;#;$F;%i?;&i?;'@�;(I"def mutate!;T;)T;*I"7def mutate!
@controller.evolver.mutate! self
end;T;+To;
; F; ;
;;;I" NEAT::Population#express!;F;[�;[[@�iE;T;;�;;;[�;{�;IC; "#Express the entire population.
;T; [�;[�; I"#Express the entire population.;T; 0; @�;!F;"o;#;$F;%iD;&iD;'@�;(I"def express!;T;)T;*I"Fdef express!
@critters.each { |critter| critter.express! }
end;T;+To;
; F; ;
;;;I" NEAT::Population#evaluate!;F;[�;[[@�iJ;T;;�;;;[�;{�;IC; " Called for each sequence.
;T; [�;[�; I" Called for each sequence.;T; 0; @�;!F;"o;#;$F;%iI;&iI;'@�;(I"def evaluate!;T;)T;*I"Hdef evaluate!
@critters.each { |critter| critter.evaluate! }
end;T;+To;
; F; ;
;;;I" NEAT::Population#analyze!;F;[�;[[@�iO;T;:
analyze!;;;[�;{�;IC; " Alalyze evaluation results.
;T; [�;[�; I" Alalyze evaluation results.;T; 0; @�;!F;"o;#;$F;%iN;&iN;'@�;(I"def analyze!;T;)T;*I"hdef analyze!
@critters.each { |critter| @controller.evaluator.analyze_for_fitness! critter }
end;T;+To;
; F; ;
;;;I" NEAT::Population#evolve;F;[�;[[@�iU;T;;,;;;[�;{�;IC; "DCall this after evaluation.
Returns a newly-evolved population.
;T; [�;[�; I"DCall this after evaluation.
Returns a newly-evolved population.;T; 0; @�;!F;"o;#;$F;%iS;&iT;'@�;(I"def evolve;T;)T;*I"5def evolve
@controller.evolver.evolve self
end;T;+To;
; F; ;
;;;I" NEAT::Population#speciate!;F;[�;[[@�i^;T;:speciate!;;;[�;{�;IC; "�Group critters into species
Note that the @species objects
have useful singleton methods:
* @species.member? -- checks all of the lists for membership, not just the hash
* @species[crit].fitness -- fitness of the entire species
;T; [�;[�; I"�Group critters into species
Note that the @species objects
have useful singleton methods:
* @species.member? -- checks all of the lists for membership, not just the hash
* @species[crit].fitness -- fitness of the entire species;T; 0; @�;!F;"o;#;$F;%iY;&i];'@�;(I"def speciate!;T;)T;*I"�def speciate!
# We blow away existing species and create our own member? function
@species = {} # lists keyed by representative critter
def @species.member?(crit)
super.member?(crit) or self.map{|k, li| li.member? crit}.reduce{|t1, t2| t1 or t2 }
end
def @species.evaluate!
self.each do |k, sp|
sp.fitness = sp.map{|crit| crit.fitness}.reduce{|a,b| a+b} / sp.size
end
end
def @species.compactify!(parm)
mutt = self[:mutt] = self.map { |k, splist| [k, splist]}.reject {|k, splist|
splist.size >= parm.smallest_species
}.map { |k, splist|
self.delete k
splist
}.flatten
# FIXME this code is not dry!!!!
def mutt.fitness=(fit)
@fitness = fit
end
def mutt.fitness
@fitness
end
self.delete :mutt if self[:mutt].empty?
end
# Some convience parms
parm = @controller.parms
# And so now we iterate...
@critters.each do |crit|
wearein = false
@species.each do |ck, list|
delta = crit.compare(ck)
#log.debug { "delta for #{crit} and #{ck} is #{delta}" }
if delta < parm.compatibility_threshold
list << crit
wearein = true
break
end
end
# New species?
unless wearein
@species[crit] = species = [crit]
def species.fitness=(fit)
@fitness = fit
end
def species.fitness
@fitness
end
end
end
# Compactify the species if less than smallest_species
@species.compactify! parm
# And now we evaluate all species for fitness...
@species.evaluate!
# Dump for debugging reasons
@species.each do |k, sp|
log.debug ">> Species #{k} has #{sp.size} members with a #{sp.fitness} fitness"
end
end;T;+To;
; F; ;G;;;I" NEAT::Population.member?;F;[[I" crit;T0;[[@�ia;T;: member?;;;[�;{�;IC; "*lists keyed by representative critter
;T; [�;[o;I
;JI" return;F;KI"�;T;0;L[I" Boolean;T; @�; I"*lists keyed by representative critter;T; 0; @�;!F;"o;#;$F;%i`;&i`;'@�;(I" def @species.member?(crit);T;)T;*I"ydef @species.member?(crit)
super.member?(crit) or self.map{|k, li| li.member? crit}.reduce{|t1, t2| t1 or t2 }
end;T;+To;
; F; ;G;;;I" NEAT::Population.evaluate!;F;[�;[[@�ie;F;;�;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@�;(I"def @species.evaluate!;T;)T;*I"�def @species.evaluate!
self.each do |k, sp|
sp.fitness = sp.map{|crit| crit.fitness}.reduce{|a,b| a+b} / sp.size
end
end;T;+To;
; F; ;G;;;I"!NEAT::Population.compactify!;F;[[I" parm;T0;[[@�ik;F;:compactify!;;;[�;{�;IC; "�
;T; @�;/0;!F; [�;[�; I"�;T; 0;'@�;(I"#def @species.compactify!(parm);T;)T;*I"�def @species.compactify!(parm)
mutt = self[:mutt] = self.map { |k, splist| [k, splist]}.reject {|k, splist|
splist.size >= parm.smallest_species
}.map { |k, splist|
self.delete k
splist
}.flatten
# FIXME this code is not dry!!!!
def mutt.fitness=(fit)
@fitness = fit
end
def mutt.fitness
@fitness
end
self.delete :mutt if self[:mutt].empty?
end;T;+To;
; F; ;
;;;I" NEAT::Population#report;F;[�;[[@�i�;T;;7;;;[�;{�;IC; ":== Generate a report on the state of this population.
;T; [�;[�; I";== Generate a report on the state of this population.
;T; 0; @�;!F;"o;#;$F;%i�;&i�;'@�;(I"def report;T;)T;*I"�def report
{
fitness: report_fitness,
fitness_species: report_fitness_species,
best_critter: report_best_fit,
worst_critter: report_worst_fit,
}
end;T;+To;
; F; ;
;;;I""NEAT::Population#best_critter;F;[�;[[@�i�;T;:best_critter;;;[�;{�;IC; "WThe "best critter" is the critter with the lowest (closet to zero)
fitness rating.
;T; [�;[�; I"WThe "best critter" is the critter with the lowest (closet to zero)
fitness rating.;T; 0; @
;!F;"o;#;$F;%i�;&i�;'@�;(I"def best_critter;T;)T;*I"�def best_critter
unless @controller.compare_func.nil?
@critters.min {|a, b| @controller.compare_func.(a.fitness, b.fitness) }
else
@critters.min {|a, b| a.fitness <=> b.fitness}
end
end;T;+To;
; F; ;
;;;I"#NEAT::Population#worst_critter;F;[�;[[@�i�;T;:worst_critter;;;[�;{�;IC; "YThe "worst critter" is the critter with the highest (away from zero)
fitness rating.
;T; [�;[�; I"YThe "worst critter" is the critter with the highest (away from zero)
fitness rating.;T; 0; @;!F;"o;#;$F;%i�;&i�;'@�;(I"def worst_critter;T;)T;*I"�def worst_critter
unless @controller.compare_func.nil?
@critters.max {|a, b| @controller.compare_func.(a.fitness, b.fitness) }
else
@critters.max {|a, b| a.fitness <=> b.fitness}
end
end;T;+To;
; F; ;
;;;I" NEAT::Population#dump_s;F;[�;[[@�i�;F;;�;;;[�;{�;IC; "�
;T; @&;/0;!F; [�;[�; I"�;T; 0;'@�;(I"def dump_s;T;)T;*I"^def dump_s
to_s + "\npopulation:\n" + @critters.map{|crit| crit.dump_s }.join("\n")
end;T;+To;
; F; ;
;;�;I"$NEAT::Population#report_fitness;F;[�;[[@�i�;T;:report_fitness;;;[�;{�;IC; "#report on many fitness metrics
;T; [�;[�; I"#report on many fitness metrics;T; 0; @3;!F;"o;#;$F;%i�;&i�;'@�;(I"def report_fitness;T;)T;*I"�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;T;+To;
; F; ;
;;�;I",NEAT::Population#report_fitness_species;F;[�;[[@�i�;T;:report_fitness_species;;;[�;{�;IC; ")report on the best and worst species
;T; [�;[�; I")report on the best and worst species;T; 0; @A;!F;"o;#;$F;%i�;&i�;'@�;(I" def report_fitness_species;T;)T;*I"Jdef report_fitness_species
{
best: nil,
worst: nil,
}
end;T;+To;
; F; ;
;;�;I"%NEAT::Population#report_best_fit;F;[�;[[@�i�;T;:report_best_fit;;;[�;{�;IC; " Find the best fit critter
;T; [�;[�; I" Find the best fit critter;T; 0; @O;!F;"o;#;$F;%i�;&i�;'@�;(I"def report_best_fit;T;)T;*I":def report_best_fit
best_critter.phenotype.code
end;T;+To;
; F; ;
;;�;I"&NEAT::Population#report_worst_fit;F;[�;[[@�i�;T;:report_worst_fit;;;[�;{�;IC; " Find the worst fit critter
;T; [�;[�; I" Find the worst fit critter;T; 0; @];!F;"o;#;$F;%i�;&i�;'@�;(I"def report_worst_fit;T;)T;*I"<def report_worst_fit
worst_critter.phenotype.code
end;T;+T;:@�;;IC;[�;:@�;<IC;[�;:@�;NIC;O{;GIC;O{�;PT;
IC;O{
;wIC;O{;x@�;y@�;PT;yIC;O{;x@�;y@�;PT;{IC;O{;x@�;y@�;PT;}IC;O{;x@�;y@�;PT;IC;O{;x@;y@ ;PT;0IC;O{;x@*;y0;PT;�IC;O{;x@8;y0;PT;�IC;O{;x@D;y0;PT;PT;PT;Q{�;R[�;[[@�i;T;:Population;;;;;[�;{�;IC; "�= Population of NEAT Critters.
The Population
In ourselves we have the pool of neurons the critters all use.
the pool of neurons are indirects, of course, as during phenotype
expression, all the phenotypes shall be created individually.
;T; [�;[�; I"�= Population of NEAT Critters.
The Population
In ourselves we have the pool of neurons the critters all use.
the pool of neurons are indirects, of course, as during phenotype
expression, all the phenotypes shall be created individually.
;T; 0; @�;!F;"o;#;$F;%i ;&i;'@;I"NEAT::Population;F;To;= ;>0;?0;@0;;r;'@;B@�;C0;+T;:@;;IC;[�;:@;<IC;[�;:@;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[[@i
[@Fi[@i[@�i [@ i[@�i6[@�i [@[i[@�i;T;;};;;;;[�;{�;IC; "�= NEAT -- Module for RubyNEAT.
== Synopsis
We have a Population of Critters, and each Critter
represents a network of Neurons and a connection list specifying
how those Neurons are connected.
Each Neuron has an inplicit genotype and phenotype component. Neurons,
from the Ruby persoective, contain their own code to produce their own
phenotypes.
There are input Neurons and output Neurons. The input Neurons are special, as
they do not contain any input from other nodes, but serve as interfaces
from the "real world". Thier range of inputs are open, and it shall be up to
the input Neuron's phenotype generators to condition those inputs, if need be,
to someething more suiable for the neural network.
== Issues
=== Multicore / Cloud Computing
Some thought needs to be given to how to make this anenable to multiple
processes so that we can leverage the power of multicore systems as well
as multiple computers in the Cloud, etc.
Our initial inclination is to put all of that functionality in the Conroller.
;T; [�;[�; I"�= NEAT -- Module for RubyNEAT.
== Synopsis
We have a Population of Critters, and each Critter
represents a network of Neurons and a connection list specifying
how those Neurons are connected.
Each Neuron has an inplicit genotype and phenotype component. Neurons,
from the Ruby persoective, contain their own code to produce their own
phenotypes.
There are input Neurons and output Neurons. The input Neurons are special, as
they do not contain any input from other nodes, but serve as interfaces
from the "real world". Thier range of inputs are open, and it shall be up to
the input Neuron's phenotype generators to condition those inputs, if need be,
to someething more suiable for the neural network.
== Issues
=== Multicore / Cloud Computing
Some thought needs to be given to how to make this anenable to multiple
processes so that we can leverage the power of multicore systems as well
as multiple computers in the Cloud, etc.
Our initial inclination is to put all of that functionality in the Conroller.
;T; 0; @;!F;"o;#;$F;%i ;&i5;'@;I" NEAT;F;:@;;IC;[�;:@;<IC;[o;= ;>0;?I"NEAT::DSL;T;@@;;~;'@;B@
;C;D;:@;NIC;O{;GIC;O{�;PT;
IC;O{�;PT;PT;Q{�;R[�;[�;F;;�;;;;;[�;{�;IC; "�
;T; @;/0;!F; [�;[�; I"�;T; 0;'0;I"�;T;}@:NEAT::DSL@
:NEAT::DSL#define@ :NEAT::DSL#evolve@ :NEAT::DSL#query@0:NEAT::DSL#recurrence@@:NEAT::DSL#fitness@O:NEAT::DSL#compare@_:NEAT::DSL#cost@o: NEAT::DSL#stop_on_fitness@:'NEAT::DSL#condition_boolean_vector@�:)NEAT::DSL#uncondition_boolean_vector@�:#NEAT::DSL#simple_fitness_error@�:NEAT::DSL#report@�:NEAT::DSL#run_engine@�: NEAT::DSL#method_missing@�:NEAT::Graph@9: NEAT::Graph::GraphException@;: NEAT::Graph#clear_graph@O:NEAT::Graph#<<@]:NEAT::Graph#add@l:NEAT::Graph#inputs@|:$NEAT::Graph::DependencyResolver@�:/NEAT::Graph::DependencyResolver#initialize@�:'NEAT::Graph::DependencyResolver.[]@�:,NEAT::Graph::DependencyResolver#resolve@�:-NEAT::Graph::DependencyResolver#resolve!@�:)NEAT::Graph::DependencyResolver#rdep@�:NEAT::Neuron@5:NEAT::Neuron#genotype@7:NEAT::Neuron#trait@E:NEAT::Neuron#trait=@R:"NEAT::Neuron#heirarchy_number@e:#NEAT::Neuron#heirarchy_number=@s:NEAT::Neuron#output@�:NEAT::Neuron#output=@�:!NEAT::Neuron::@@neuron_types@�:NEAT::Neuron.input?@�:NEAT::Neuron#input?@�:NEAT::Neuron.bias?@�:NEAT::Neuron#bias?@�:NEAT::Neuron#output?@�:NEAT::Neuron.inherited@: NEAT::Neuron.neuron_types@:NEAT::Neuron#express@&:NEAT::BasicNeuronTypes@�:(NEAT::BasicNeuronTypes::InputNeuron@�:/NEAT::BasicNeuronTypes::InputNeuron.input?@�:0NEAT::BasicNeuronTypes::InputNeuron#express@:'NEAT::BasicNeuronTypes::BiasNeuron@�:-NEAT::BasicNeuronTypes::BiasNeuron.bias?@�:0NEAT::BasicNeuronTypes::BiasNeuron#neu_bias@�:1NEAT::BasicNeuronTypes::BiasNeuron#neu_bias=@�:2NEAT::BasicNeuronTypes::BiasNeuron#initialize@�:/NEAT::BasicNeuronTypes::BiasNeuron#express@�:*NEAT::BasicNeuronTypes::SigmoidNeuron@�:2NEAT::BasicNeuronTypes::SigmoidNeuron#express@�:'NEAT::BasicNeuronTypes::TanhNeuron@ :/NEAT::BasicNeuronTypes::TanhNeuron#express@ :'NEAT::BasicNeuronTypes::SineNeuron@B:/NEAT::BasicNeuronTypes::SineNeuron#express@D:)NEAT::BasicNeuronTypes::CosineNeuron@f:1NEAT::BasicNeuronTypes::CosineNeuron#express@h:NEAT::Critter@�: NEAT::Critter#population@�:NEAT::Critter#genotype@�: NEAT::Critter#genotype=@�: NEAT::Critter#phenotype@�: NEAT::Critter#phenotype=@�:NEAT::Critter#fitness@�:NEAT::Critter#fitness=@:NEAT::Critter#novelty@:NEAT::Critter#novelty=@": NEAT::Critter#initialize@0:(NEAT::Critter#ready_for_expression!@J:NEAT::Critter#express!@X:&NEAT::Critter#initialize_neurons!@f: NEAT::Critter#evaluate!@t: NEAT::Critter::Genotype@�:$NEAT::Critter::Genotype#critter@�:%NEAT::Critter::Genotype#critter=@�:"NEAT::Critter::Genotype#genes@�:#NEAT::Critter::Genotype#genes=@�:$NEAT::Critter::Genotype#neurons@�:%NEAT::Critter::Genotype#neurons=@�:*NEAT::Critter::Genotype#neural_inputs@�:+NEAT::Critter::Genotype#neural_outputs@�:-NEAT::Critter::Genotype#dangling_neurons@�:.NEAT::Critter::Genotype#dangling_neurons=@�:.NEAT::Critter::Genotype#dangling_neurons?@:,NEAT::Critter::Genotype#neural_gene_map@:'NEAT::Critter::Genotype#initialize@(:&NEAT::Critter::Genotype#neucleate@A:/NEAT::Critter::Genotype#nuke_redundancies!@^:$NEAT::Critter::Genotype#forget!@l:"NEAT::Critter::Genotype#wire!@z:(NEAT::Critter::Genotype#add_neurons@�:&NEAT::Critter::Genotype#add_genes@�:'NEAT::Critter::Genotype#innervate!@�:#NEAT::Critter::Genotype#prune!@�:)NEAT::Critter::Genotype#fitness_cost@�:#NEAT::Critter::Genotype#dump_s@�:"NEAT::Critter::Genotype::Gene@�:+NEAT::Critter::Genotype::Gene#genotype@�:,NEAT::Critter::Genotype::Gene#genotype=@�:-NEAT::Critter::Genotype::Gene#innovation@:.NEAT::Critter::Genotype::Gene#innovation=@:,NEAT::Critter::Genotype::Gene#in_neuron@!:-NEAT::Critter::Genotype::Gene#in_neuron=@/:-NEAT::Critter::Genotype::Gene#out_neuron@=:.NEAT::Critter::Genotype::Gene#out_neuron=@I:)NEAT::Critter::Genotype::Gene#weight@W:*NEAT::Critter::Genotype::Gene#weight=@e:*NEAT::Critter::Genotype::Gene#enabled@s:+NEAT::Critter::Genotype::Gene#enabled=@�:-NEAT::Critter::Genotype::Gene#initialize@�:+NEAT::Critter::Genotype::Gene#enabled?@�:,NEAT::Critter::Genotype::Gene#disabled?@�:%NEAT::Critter::Genotype::Gene.[]@�:'NEAT::Critter::Genotype::Gene#to_s@�:)NEAT::Critter::Genotype::Gene#dump_s@�: NEAT::Critter::Phenotype@-:%NEAT::Critter::Phenotype#critter@/:&NEAT::Critter::Phenotype#critter=@=:"NEAT::Critter::Phenotype#code@K:#NEAT::Critter::Phenotype#code=@Y: NEAT::Critter::Phenotype.[]@g:&NEAT::Critter::Phenotype#express!@v:'NEAT::Critter::Phenotype#stimulate@�:"NEAT::Critter::Phenotype#to_s@�:NEAT::Critter#compare@�:NEAT::Critter#dump_s@�:NEAT::Critter#excess@�:NEAT::Critter#disjoint@�: NEAT::Critter#weight_diff@�:NEAT::Evolver@ :NEAT::Evolver#npop@ : NEAT::Evolver#initialize@) :%NEAT::Evolver#gen_initial_genes!@= :NEAT::Evolver#mutate!@M :NEAT::Evolver#evolve@] :&NEAT::Evolver#prepare_speciation!@m :#NEAT::Evolver#prepare_fitness!@z :#NEAT::Evolver#prepare_novelty!@� :/NEAT::Evolver#mutate_perturb_gene_weights!@� :.NEAT::Evolver#mutate_change_gene_weights!@� :$NEAT::Evolver#mutate_add_genes!@� :(NEAT::Evolver#mutate_disable_genes!@� :)NEAT::Evolver#mutate_reenable_genes!@� :&NEAT::Evolver#mutate_add_neurons!@� :)NEAT::Evolver#mutate_change_neurons!@� :NEAT::Evolver#mate!@� :NEAT::Evolver#sex@
: NEAT::Evolver::CritterOp@
:(NEAT::Evolver::CritterOp#initialize@
:)NEAT::Evolver::CritterOp#add_neuron!@*
:'NEAT::Evolver::CritterOp#add_gene!@:
:+NEAT::Evolver::CritterOp#disable_gene!@J
:,NEAT::Evolver::CritterOp#reenable_gene!@Z
: NEAT.random_name_generator@�
:NEAT::STIMULUS@�
:NEAT.new_innovation@�
:NEAT.gaussian@�
:
NEAT.dpp@�
:NEAT::NeatOb@�:NEAT::NeatOb#name@�: NEAT::NeatOb#controller@:NEAT::NeatOb#log@:NEAT::NeatOb.log@ : NEAT::NeatOb#initialize@*:NEAT::NeatOb#to_s@C:NEAT::NeatException@�
:NEAT::Operator@�
:NEAT::Trait@�
:NEAT::Controller@ :$NEAT::Controller#glob_innov_num@ : NEAT::Controller#seq_num@! :$NEAT::Controller#generation_num@/ :$NEAT::Controller#neuron_catalog@= :%NEAT::Controller#neuron_catalog=@K :#NEAT::Controller#neural_inputs@Y :$NEAT::Controller#neural_inputs=@g :$NEAT::Controller#neural_outputs@u :%NEAT::Controller#neural_outputs=@� :#NEAT::Controller#neural_hidden@� :$NEAT::Controller#neural_hidden=@� :NEAT::Controller#parms@� : NEAT::Controller#parms=@� : NEAT::Controller#population@� :(NEAT::Controller#population_history@� :&NEAT::Controller#population_class@� : NEAT::Controller#expressor@� : NEAT::Controller#expressor=@� :%NEAT::Controller#expressor_class@ :&NEAT::Controller#expressor_class=@ : NEAT::Controller#evaluator@+ : NEAT::Controller#evaluator=@8 :%NEAT::Controller#evaluator_class@K :&NEAT::Controller#evaluator_class=@X : NEAT::Controller#evolver@k : NEAT::Controller#evolver=@x :#NEAT::Controller#evolver_class@� :$NEAT::Controller#evolver_class=@� : NEAT::Controller#verbosity@� : NEAT::Controller#verbosity=@� : NEAT::Controller#query_func@� :!NEAT::Controller#query_func=@� :"NEAT::Controller#fitness_func@� :#NEAT::Controller#fitness_func=@� :%NEAT::Controller#recurrence_func@� :&NEAT::Controller#recurrence_func=@
:"NEAT::Controller#compare_func@
:#NEAT::Controller#compare_func=@)
: NEAT::Controller#cost_func@7
: NEAT::Controller#cost_func=@C
:&NEAT::Controller#stop_on_fit_func@Q
:'NEAT::Controller#stop_on_fit_func=@]
:"NEAT::Controller#end_run_func@k
:#NEAT::Controller#end_run_func=@y
:!NEAT::Controller#report_hook@�
:"NEAT::Controller#report_hook=@�
:NEAT::Controller#log@�
:#NEAT::Controller::NeatSettings@�
:3NEAT::Controller::NeatSettings#hash_on_fitness@�
:4NEAT::Controller::NeatSettings#hash_on_fitness=@�
:4NEAT::Controller::NeatSettings#age_significance@�
:5NEAT::Controller::NeatSettings#age_significance=@�
:1NEAT::Controller::NeatSettings#babies_stolen@�
:2NEAT::Controller::NeatSettings#babies_stolen=@�
:;NEAT::Controller::NeatSettings#compatibility_threshold@ :<NEAT::Controller::NeatSettings#compatibility_threshold=@:8NEAT::Controller::NeatSettings#disjoint_coefficient@%:9NEAT::Controller::NeatSettings#disjoint_coefficient=@3:6NEAT::Controller::NeatSettings#excess_coefficient@A:7NEAT::Controller::NeatSettings#excess_coefficient=@M:6NEAT::Controller::NeatSettings#weight_coefficient@[:7NEAT::Controller::NeatSettings#weight_coefficient=@g:/NEAT::Controller::NeatSettings#max_species@u:0NEAT::Controller::NeatSettings#max_species=@�:/NEAT::Controller::NeatSettings#dropoff_age@�:0NEAT::Controller::NeatSettings#dropoff_age=@�:4NEAT::Controller::NeatSettings#smallest_species@�:5NEAT::Controller::NeatSettings#smallest_species=@�::NEAT::Controller::NeatSettings#interspecies_mate_rate@�:;NEAT::Controller::NeatSettings#interspecies_mate_rate=@�::NEAT::Controller::NeatSettings#linktrait_mutation_sig@�:;NEAT::Controller::NeatSettings#linktrait_mutation_sig=@�:<NEAT::Controller::NeatSettings#mate_multipoint_avg_prob@:=NEAT::Controller::NeatSettings#mate_multipoint_avg_prob=@:8NEAT::Controller::NeatSettings#mate_multipoint_prob@%:9NEAT::Controller::NeatSettings#mate_multipoint_prob=@2:2NEAT::Controller::NeatSettings#mate_only_prob@E:3NEAT::Controller::NeatSettings#mate_only_prob=@R:9NEAT::Controller::NeatSettings#mate_singlepoint_prob@e::NEAT::Controller::NeatSettings#mate_singlepoint_prob=@r:3NEAT::Controller::NeatSettings#max_generations@�:4NEAT::Controller::NeatSettings#max_generations=@�::NEAT::Controller::NeatSettings#max_population_history@�:;NEAT::Controller::NeatSettings#max_population_history=@�:8NEAT::Controller::NeatSettings#mutate_add_gene_prob@�:9NEAT::Controller::NeatSettings#mutate_add_gene_prob=@�::NEAT::Controller::NeatSettings#mutate_add_neuron_prob@�:;NEAT::Controller::NeatSettings#mutate_add_neuron_prob=@�:<NEAT::Controller::NeatSettings#mutate_gene_disable_prob@�:=NEAT::Controller::NeatSettings#mutate_gene_disable_prob=@
:=NEAT::Controller::NeatSettings#mutate_gene_reenable_prob@ :>NEAT::Controller::NeatSettings#mutate_gene_reenable_prob=@*::NEAT::Controller::NeatSettings#mutate_gene_trait_prob@=:;NEAT::Controller::NeatSettings#mutate_gene_trait_prob=@J:DNEAT::Controller::NeatSettings#mutate_perturb_gene_weights_prob@]:ENEAT::Controller::NeatSettings#mutate_perturb_gene_weights_prob=@k:BNEAT::Controller::NeatSettings#mutate_perturb_gene_weights_sd@y:CNEAT::Controller::NeatSettings#mutate_perturb_gene_weights_sd=@�:CNEAT::Controller::NeatSettings#mutate_change_gene_weights_prob@�:DNEAT::Controller::NeatSettings#mutate_change_gene_weights_prob=@�:ANEAT::Controller::NeatSettings#mutate_change_gene_weights_sd@�:BNEAT::Controller::NeatSettings#mutate_change_gene_weights_sd=@�:<NEAT::Controller::NeatSettings#mutate_neuron_trait_prob@�:=NEAT::Controller::NeatSettings#mutate_neuron_trait_prob=@�:4NEAT::Controller::NeatSettings#mutate_only_prob@�:5NEAT::Controller::NeatSettings#mutate_only_prob=@�:<NEAT::Controller::NeatSettings#mutate_random_trait_prob@:=NEAT::Controller::NeatSettings#mutate_random_trait_prob=@:=NEAT::Controller::NeatSettings#mutate_toggle_enable_prob@':>NEAT::Controller::NeatSettings#mutate_toggle_enable_prob=@4:7NEAT::Controller::NeatSettings#mutdiff_coefficient@G:8NEAT::Controller::NeatSettings#mutdiff_coefficient=@T:1NEAT::Controller::NeatSettings#newlink_tries@g:2NEAT::Controller::NeatSettings#newlink_tries=@t:8NEAT::Controller::NeatSettings#neuron_trait_mut_sig@�:9NEAT::Controller::NeatSettings#neuron_trait_mut_sig=@�:;NEAT::Controller::NeatSettings#fitness_cost_per_neuron@�:<NEAT::Controller::NeatSettings#fitness_cost_per_neuron=@�:9NEAT::Controller::NeatSettings#fitness_cost_per_gene@�::NEAT::Controller::NeatSettings#fitness_cost_per_gene=@�:9NEAT::Controller::NeatSettings#start_population_size@�::NEAT::Controller::NeatSettings#start_population_size=@�:3NEAT::Controller::NeatSettings#population_size@�:4NEAT::Controller::NeatSettings#population_size=@ :5NEAT::Controller::NeatSettings#start_sequence_at@:6NEAT::Controller::NeatSettings#start_sequence_at=@&:3NEAT::Controller::NeatSettings#end_sequence_at@9:4NEAT::Controller::NeatSettings#end_sequence_at=@F:/NEAT::Controller::NeatSettings#print_every@Y:0NEAT::Controller::NeatSettings#print_every=@f:3NEAT::Controller::NeatSettings#recur_only_prob@y:4NEAT::Controller::NeatSettings#recur_only_prob=@�:.NEAT::Controller::NeatSettings#recur_prob@�:/NEAT::Controller::NeatSettings#recur_prob=@�:6NEAT::Controller::NeatSettings#survival_threshold@�:7NEAT::Controller::NeatSettings#survival_threshold=@�:@NEAT::Controller::NeatSettings#survival_mininum_per_species@�:ANEAT::Controller::NeatSettings#survival_mininum_per_species=@�:8NEAT::Controller::NeatSettings#trait_mutation_power@�:9NEAT::Controller::NeatSettings#trait_mutation_power=@:8NEAT::Controller::NeatSettings#trait_param_mut_prob@:9NEAT::Controller::NeatSettings#trait_param_mut_prob=@":3NEAT::Controller::NeatSettings#weigh_mut_power@5:4NEAT::Controller::NeatSettings#weigh_mut_power=@B:<NEAT::Controller::NeatSettings#feature_selection_switch@U:=NEAT::Controller::NeatSettings#feature_selection_switch=@c:0NEAT::Controller::NeatSettings#hyper_switch@q:1NEAT::Controller::NeatSettings#hyper_switch=@:<NEAT::Controller::NeatSettings#evolved_substrate_switch@�:=NEAT::Controller::NeatSettings#evolved_substrate_switch=@�:4NEAT::Controller::NeatSettings#real_time_switch@�:5NEAT::Controller::NeatSettings#real_time_switch=@�:5NEAT::Controller::NeatSettings#recurrency_switch@�:6NEAT::Controller::NeatSettings#recurrency_switch=@�:.NEAT::Controller::NeatSettings#initialize@�: NEAT::Controller#initialize@;:$NEAT::Controller#new_innovation@\: NEAT::Controller#gaussian@i:NEAT::Controller#run@v:(NEAT::Controller#pre_run_initialize@�:NEAT.controller@�:NEAT.controller=@�:NEAT.create_controller@�:NEAT::Expressor@�: NEAT::Expressor#initialize@�: NEAT::Expressor#express!@:%NEAT::Expressor#express_neurons!@:#NEAT::Expressor#express_genes!@!:(NEAT::Expressor#express_expression!@1:NEAT::Evaluator@R:)NEAT::Evaluator#ready_for_evaluation@T: NEAT::Evaluator#evaluate!@e:)NEAT::Evaluator#analyze_for_fitness!@u:NEAT::Population@�:#NEAT::Population#input_neurons@�:$NEAT::Population#input_neurons=@�:$NEAT::Population#hidden_neurons@�:%NEAT::Population#hidden_neurons=@�:$NEAT::Population#output_neurons@�:%NEAT::Population#output_neurons=@�: NEAT::Population#traits@�: NEAT::Population#traits=@�: NEAT::Population#critters@: NEAT::Population#critters=@ : NEAT::Population#fitness@*: NEAT::Population#novelty@8: NEAT::Population#species@D: NEAT::Population#initialize@R:0NEAT::Population#initialize_for_recurrence!@i: NEAT::Population#mutate!@w: NEAT::Population#express!@�: NEAT::Population#evaluate!@�: NEAT::Population#analyze!@�: NEAT::Population#evolve@�: NEAT::Population#speciate!@�: NEAT::Population.member?@�: NEAT::Population.evaluate!@�:!NEAT::Population.compactify!@�: NEAT::Population#report@�:"NEAT::Population#best_critter@
:#NEAT::Population#worst_critter@: NEAT::Population#dump_s@&:$NEAT::Population#report_fitness@3:,NEAT::Population#report_fitness_species@A:%NEAT::Population#report_best_fit@O:&NEAT::Population#report_worst_fit@]