Package ec.neat

Class NEATNetwork

java.lang.Object
ec.neat.NEATNetwork
All Implemented Interfaces:
Prototype, Setup, Serializable, Cloneable
public class NEATNetwork extends Object implements Prototype
NEATNetwork is the phenotype of NEATIndividual. It share the same copy of nodes and genes (links) with its corresponding NEATIndividual. This class handles all operations that is critical in evaluation of the individuals.
See Also:

  • Field Details

  • Constructor Details

    • NEATNetwork

      public NEATNetwork()

  • Method Details

    • setup

      public void setup(EvolutionState state, Parameter base)
      Description copied from interface: Prototype
      Sets up the object by reading it from the parameters stored in state, built off of the parameter base base. If an ancestor implements this method, be sure to call super.setup(state,base); before you do anything else.

      For prototypes, setup(...) is typically called once for the prototype instance; cloned instances do not receive the setup(...) call. setup(...) may be called more than once; the only guarantee is that it will get called at least once on an instance or some "parent" object from which it was ultimately cloned.

      Specified by:
      setup in interface Prototype
      Specified by:
      setup in interface Setup

    • defaultBase

      public Parameter defaultBase()
      Description copied from interface: Prototype
      Returns the default base for this prototype. This should generally be implemented by building off of the static base() method on the DefaultsForm object for the prototype's package. This should be callable during setup(...).
      Specified by:
      defaultBase in interface Prototype

    • clone

      public Object clone()
      Description copied from interface: Prototype
      Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.

      Typically this should be a full "deep" clone. However, you may share certain elements with other objects rather than clone hem, depending on the situation:

      • If you hold objects which are shared with other instances, don't clone them.
      • If you hold objects which must be unique, clone them.
      • If you hold objects which were given to you as a gesture of kindness, and aren't owned by you, you probably shouldn't clone them.
      • DON'T attempt to clone: Singletons, Cliques, or Populations, or Subpopulation.
      • Arrays are not cloned automatically; you may need to clone an array if you're not sharing it with other instances. Arrays have the nice feature of being copyable by calling clone() on them.

      Implementations.

      • If no ancestor of yours implements clone(), and you have no need to do clone deeply, and you are abstract, then you should not declare clone().
      • If no ancestor of yours implements clone(), and you have no need to do clone deeply, and you are not abstract, then you should implement it as follows: 

         public Object clone() 
     {
     try
         { 
         return super.clone();
         }
     catch ((CloneNotSupportedException e)
         { throw new InternalError(); } // never happens
     }
      • If no ancestor of yours implements clone(), but you need to deep-clone some things, then you should implement it as follows: 

         public Object clone() 
     {
     try
         { 
         MyObject myobj = (MyObject) (super.clone());

         // put your deep-cloning code here...
         }
     catch ((CloneNotSupportedException e)
         { throw new InternalError(); } // never happens
     return myobj;
     }
      • If an ancestor has implemented clone(), and you also need to deep clone some things, then you should implement it as follows: 

         public Object clone() 
     { 
     MyObject myobj = (MyObject) (super.clone());

     // put your deep-cloning code here...

     return myobj;
     }
      Specified by:
      clone in interface Prototype
      Overrides:
      clone in class Object

    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class Object

    • flush

      public void flush()

    • activate

      public void activate(EvolutionState state)
      Activates the net such that all outputs are active.

    • addInput

      public void addInput(NEATNode node)
      Add a new input node.

    • addOutput

      public void addOutput(NEATNode node)
      Add a new output node.

    • loadSensors

      public void loadSensors(double[] vals)
      Takes an array of sensor values and loads it into SENSOR inputs ONLY.

    • getOutputResults

      public double[] getOutputResults()
      Produces an array of activation results, one per output node.

    • hasPath

      public static boolean[] hasPath(EvolutionState state, NEATNode toNode, NEATNode fromNode, int threshold)
      This checks a POTENTIAL link between start from fromNode to toNode to use count and threshold to jump out in the case of an infinite loop.

    • hasPath

      public static void hasPath(EvolutionState state, NEATNode toNode, NEATNode fromNode, HashSet<NEATNode> set, int level, int threshold, boolean[] results)
      The helper function to check if there is a path from fromNode to toNode.

    • outputOff

      public boolean outputOff()
      Check if not all output are active.

    • maxDepth

      public int maxDepth()
      Find the maximum number of neurons between an output and an input.

    • buildNetwork

      public void buildNetwork(NEATIndividual individual)
      Create the phenotype (network) from the genotype (genome). One main task of method is to link the incomingGenes for each nodes.