Changeset 10039

Timestamp:

10/11/13 21:41:17 (11 years ago)

Author:

sawinkle

Message:

#2109:

• Renamed GEEvaluator.cs to GEArtificialAntEvaluator.cs, because a further Evaluator for the Symbolic Regression problem (single objective) is planned to be implemented.
• Excluded the mapping process from GEArtificialAntEvaluator.cs and created several separated mapper classes. Created stubs for breath-first, depth-first, random and PIGE mappers. These mapper implementations should later be easily usable together with different problems. The mapper can be selected in the GUI, via a Problem parameter. The depth-first mapper is already usable, the others still cause exceptions.

Location:

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution

Files:

• GEArtificialAntEvaluator.cs (moved) (moved from branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/GEEvaluator.cs) (5 diffs)
• GEArtificialAntProblem.cs (modified) (5 diffs)
• HeuristicLab.Problems.GrammaticalEvolution-3.3.csproj (modified) (2 diffs)
• Mappers (added)
• Mappers/BreathFirstMapper.cs (added)
• Mappers/DepthFirstMapper.cs (added)
• Mappers/GenotypeToPhenotypeMapper.cs (added)
• Mappers/IGenotypeToPhenotypeMapper.cs (added)
• Mappers/PIGEMapper.cs (added)
• Mappers/RandomMapper.cs (added)

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/GEArtificialAntEvaluator.cs

@@ -30 +30 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Random;
+using HeuristicLab.Problems.GrammaticalEvolution.Mappers;
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {
   [Item("GEArtificialAntEvaluator", "Evaluates an artificial ant solution, implemented in Grammatical Evolution.")]
   [StorableClass]
-  public class GEEvaluator : SingleSuccessorOperator,
+  public class GEArtificialAntEvaluator : SingleSuccessorOperator,
     ISingleObjectiveEvaluator, ISymbolicExpressionTreeGrammarBasedOperator {
 
@@ -44 +42 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
+    // genotype:
     public ILookupParameter<IntegerVector> IntegerVectorParameter {
       get { return (ILookupParameter<IntegerVector>)Parameters["IntegerVector"]; }
     }
+    // phenotype:
     public ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
       get { return (ILookupParameter<SymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
@@ -59 +59 @@
       get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters["SymbolicExpressionTreeGrammar"]; }
     }
+    // genotype-to-phenotype-mapper:
+    public ILookupParameter<IGenotypeToPhenotypeMapper> GenotypeToPhenotypeMapperParameter {
+      get { return (ILookupParameter<IGenotypeToPhenotypeMapper>)Parameters["GenotypeToPhenotypeMapper"]; }
+    }
     #endregion
   
     [StorableConstructor]
-    protected GEEvaluator(bool deserializing) : base(deserializing) { }
-    protected GEEvaluator(GEEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new GEEvaluator(this, cloner); }
-    public GEEvaluator()
+    protected GEArtificialAntEvaluator(bool deserializing) : base(deserializing) { }
+    protected GEArtificialAntEvaluator(GEArtificialAntEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new GEArtificialAntEvaluator(this, cloner); }
+    public GEArtificialAntEvaluator()
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the evaluated artificial ant solution."));
@@ -73 +77 @@
       Parameters.Add(new LookupParameter<IntValue>("MaxTimeSteps", "The maximal number of time steps that the artificial ant should be simulated."));
       Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>("SymbolicExpressionTreeGrammar", "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
+      Parameters.Add(new LookupParameter<IGenotypeToPhenotypeMapper>("GenotypeToPhenotypeMapper", "Maps the genotype (an integer vector) to the phenotype (a symbolic expression tree)."));
     }
 
     public sealed override IOperation Apply() {
-      SymbolicExpressionTree expression = MapIntegerVectorToSymbolicExpressionTree();
+      SymbolicExpressionTree expression = GenotypeToPhenotypeMapperParameter.ActualValue.Map (
+        SymbolicExpressionTreeGrammarParameter.ActualValue,
+        IntegerVectorParameter.ActualValue        
+      );
+      SymbolicExpressionTreeParameter.ActualValue = expression;
       BoolMatrix world = WorldParameter.ActualValue;
       IntValue maxTimeSteps = MaxTimeStepsParameter.ActualValue;
@@ -89 +98 @@
       return null;
     }
-    
-    
-    /// <summary>
-    /// Maps an integer vector to a symbolic expression tree, using a 
-    /// genotype-to-phenotype mapper.
-    /// </summary>
-    /// <returns>solution tree</returns>
-    private SymbolicExpressionTree MapIntegerVectorToSymbolicExpressionTree() {
-      
-      ISymbolicExpressionGrammar grammar = SymbolicExpressionTreeGrammarParameter.ActualValue;
-      SymbolicExpressionTree     tree    = new SymbolicExpressionTree();
-      IntegerVector integerVectorGenome  = IntegerVectorParameter.ActualValue;
-      var rootNode  = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode();
-      var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode();
-      rootNode.AddSubtree(startNode);
-      tree.Root = rootNode;
-      
-      int genotypeIndex    = 0;
-      int currSubtreeCount = 1;
-      
-      MapGenoToPhenoDepthFirstRec(startNode, integerVectorGenome,
-                                  grammar, integerVectorGenome.Length,
-                                  ref genotypeIndex, ref currSubtreeCount);
-     
-      SymbolicExpressionTreeParameter.ActualValue = tree;
-      return tree;
-    }
-    
-    
-    /// <summary>
-    /// Genotype-to-Phenotype mapper (recursive depth-first approach).
-    /// Appends maximum allowed children (non-terminal symbols) to
-    /// <paramref name="currentNode"/>, as long as <paramref name="currSubtreeCount"/>
-    /// doesn't exceed <paramref name="maxSubtreeCount"/>.
-    /// If at most <paramref name="maxSubtreeCount"/> subtrees were created,
-    /// each non-full node is filled with randomly chosen nodes
-    /// (non-terminal and terminal), and each non-terminal node is again filled with a terminal node.
-    /// </summary>
-    /// <param name="currentNode">current parent node</param>
-    /// <param name="integerVectorGenome">integer vector used for mapping</param>
-    /// <param name="grammar">grammar definition to determine the allowed child symbols for currentNode </param>
-    /// <param name="maxSubtreeCount">maximum allowed subtrees (= number of used genomes)</param>
-    /// <param name="genotypeIndex">current index in integer vector</param>
-    /// <param name="currSubtreeCount">number of already determined subtrees (filled or still incomplete)</param>
-    private void MapGenoToPhenoDepthFirstRec(ISymbolicExpressionTreeNode currentNode,
-                                             IntegerVector integerVectorGenome,
-                                             ISymbolicExpressionGrammar grammar,
-                                             int maxSubtreeCount,
-                                             ref int genotypeIndex,
-                                             ref int currSubtreeCount) {
-      if (currSubtreeCount < maxSubtreeCount) {
-      
-        var newNode = GetNewChildNode(currentNode, integerVectorGenome, grammar, genotypeIndex);
-        
-        if ((currSubtreeCount + newNode.Symbol.MaximumArity) > maxSubtreeCount) {
-          // TODO: maybe check, if there is any node, which fits in the tree yet
-          currentNode.AddSubtree(GetRandomTerminalNode(currentNode, grammar));
-        } else {
-          currentNode.AddSubtree(newNode);
-          genotypeIndex++;
-          currSubtreeCount += newNode.Symbol.MaximumArity;
-        
-          while (newNode.Symbol.MaximumArity > newNode.SubtreeCount) {
-            MapGenoToPhenoDepthFirstRec(newNode, integerVectorGenome, 
-                                        grammar, maxSubtreeCount,
-                                        ref genotypeIndex, ref currSubtreeCount);
-          }
-        }
-        
-      } else {
-        while (currentNode.Symbol.MaximumArity > currentNode.SubtreeCount) {
-          var newNode = GetNewChildNode(currentNode, integerVectorGenome, grammar, genotypeIndex);
-          currentNode.AddSubtree(newNode);
-          genotypeIndex++;
-          while (newNode.Symbol.MaximumArity > newNode.SubtreeCount) {
-            newNode.AddSubtree(GetRandomTerminalNode(newNode, grammar));
-          }
-        }
-      }
-    }
-    
-    
-    /// <summary>
-    /// Randomly returns a terminal node for the given <paramref name="parentNode"/>.
-    /// (A terminal has got a minimum and maximum arity of 0.)
-    /// </summary>
-    /// <param name="parentNode">parent node for which a child node is returned randomly</param>
-    /// <param name="grammar">grammar definition to determine the allowed child symbols for parentNode</param>
-    /// <returns>randomly chosen terminal node with arity 0</returns>
-    private ISymbolicExpressionTreeNode GetRandomTerminalNode(ISymbolicExpressionTreeNode parentNode,
-                                                              ISymbolicExpressionGrammar  grammar) {
-      var possibleSymbolsList = from   s in grammar.GetAllowedChildSymbols(parentNode.Symbol)
-                                where  s.MaximumArity == 0
-                                where  s.MinimumArity == 0
-                                select s;
-      // TODO: Check, if symbol list is empty (no terminal nodes found) - what should happen? 
-      return possibleSymbolsList.SelectRandom(new MersenneTwister()).CreateTreeNode();
-    }
-    
-    
-    /// <summary>
-    /// Utility method, which returns the number of elements of <paramref name="symbolList"/>.
-    /// </summary>
-    /// <param name="symbolList">enumerable symbol list to count the elements for</param>
-    /// <returns>number of elements in parameter symbolList</returns>
-    private int GetNumberOfAllowedChildSymbols(IEnumerable<ISymbol> symbolList) {
-      int count = 0;
-      using (IEnumerator<ISymbol> enumerator = symbolList.GetEnumerator()) {
-        while (enumerator.MoveNext()) {
-          count++;
-        }
-      }
-      return count;
-    }
-    
-    
-    /// <summary>
-    /// Returns a randomly chosen child node for the given <paramref name="parentNode"/>.
-    /// </summary>
-    /// <param name="parentNode">parent node to find a child node randomly for</param>
-    /// <param name="integerVectorGenome">integer vector to map to production rules</param>
-    /// <param name="grammar">grammar definition used to define the allowed child symbols</param>
-    /// <param name="genotypeIndex">index in the integer vector; can be greater than vector length</param>
-    /// <returns></returns>
-    private ISymbolicExpressionTreeNode GetNewChildNode(ISymbolicExpressionTreeNode parentNode,
-                                                        IntegerVector integerVectorGenome,
-                                                        ISymbolicExpressionGrammar grammar,
-                                                        int genotypeIndex) {
-      
-      var symbolList    = grammar.GetAllowedChildSymbols(parentNode.Symbol);
-      int prodRuleCount = GetNumberOfAllowedChildSymbols(symbolList);
-      int prodRuleIndex = integerVectorGenome[genotypeIndex % integerVectorGenome.Length] % prodRuleCount;
-      int currentIndex  = 0;
-      
-      using (IEnumerator<ISymbol> enumerator = symbolList.GetEnumerator()) {
-        while (enumerator.MoveNext() && (currentIndex != prodRuleIndex)) {
-          currentIndex++;
-        }
-        return enumerator.Current.CreateTreeNode();
-      }
-    }
   }
 }

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/GEArtificialAntProblem.cs

@@ -34 +34 @@
 using HeuristicLab.Problems.ArtificialAnt;
 using HeuristicLab.Problems.ArtificialAnt.Analyzers;
-
-namespace HeuristicLab.Problems.GrammaticalEvolution.ArtificialAnt {
+using HeuristicLab.Problems.GrammaticalEvolution.Mappers;
+
+namespace HeuristicLab.Problems.GrammaticalEvolution {
   [Item("Grammatical Evolution Artificial Ant Problem", "Represents the Artificial Ant problem, implemented in Grammatical Evolution.")]
   [Creatable("Problems")]
   [StorableClass]
-  public sealed class GEArtificialAntProblem : SingleObjectiveHeuristicOptimizationProblem<GEEvaluator, IIntegerVectorCreator>, IStorableContent {
+  public sealed class GEArtificialAntProblem : SingleObjectiveHeuristicOptimizationProblem<GEArtificialAntEvaluator, IIntegerVectorCreator>, IStorableContent {
     public string Filename { get; set; }
-
+    
     #region constant for default world (Santa Fe)
     private readonly bool[,] santaFeAntTrail = new bool[,] {
@@ -101 +102 @@
       get { return (IValueParameter<IntMatrix>)Parameters["Bounds"]; }
     }
+    public IValueParameter<IGenotypeToPhenotypeMapper> GenotypeToPhenotypeMapperParameter {
+      get { return (IValueParameter<IGenotypeToPhenotypeMapper>)Parameters["GenotypeToPhenotypeMapper"]; }
+    }
     #endregion
 
@@ -164 +168 @@
     }
     public GEArtificialAntProblem()
-      : base(new GEEvaluator(), new UniformRandomIntegerVectorCreator()) {
+      : base(new GEArtificialAntEvaluator(), new UniformRandomIntegerVectorCreator()) {
       BoolMatrix world = new BoolMatrix(santaFeAntTrail);
       Parameters.Add(new ValueParameter<IntValue>("MaximumExpressionLength", "Maximal length of the expression to control the artificial ant.", new IntValue(30)));
@@ -174 +178 @@
       IntMatrix m = new IntMatrix(new int[,]{{0,100}});
       Parameters.Add(new ValueParameter<IntMatrix>("Bounds", "The integer number range in which the single genomes of a genotype are created.", m));
+      Parameters.Add(new ValueParameter<IGenotypeToPhenotypeMapper>("GenotypeToPhenotypeMapper", "Maps the genotype (an integer vector) to the phenotype (a symbolic expression tree).", new DepthFirstMapper()));
       
       Maximization.Value = true;
@@ -285 +290 @@
         op.SymbolicExpressionTreeGrammarParameter.ActualName = ArtificialAntExpressionGrammarParameter.Name;
       }
-      foreach (GEEvaluator op in operators.OfType<GEEvaluator>()) {
+      foreach (GEArtificialAntEvaluator op in operators.OfType<GEArtificialAntEvaluator>()) {
         op.IntegerVectorParameter.ActualName = SolutionCreator.IntegerVectorParameter.ActualName;
         op.MaxTimeStepsParameter.ActualName = MaxTimeStepsParameter.Name;

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution-3.3.csproj

@@ -172 +172 @@
   <ItemGroup>
     <None Include="HeuristicLab.snk" />
+    <Compile Include="GEArtificialAntEvaluator.cs" />
     <Compile Include="GEArtificialAntProblem.cs" />
-    <Compile Include="GEEvaluator.cs" />
+    <Compile Include="Mappers\BreathFirstMapper.cs" />
+    <Compile Include="Mappers\DepthFirstMapper.cs" />
+    <Compile Include="Mappers\GenotypeToPhenotypeMapper.cs" />
+    <Compile Include="Mappers\IGenotypeToPhenotypeMapper.cs" />
+    <Compile Include="Mappers\PIGEMapper.cs" />
+    <Compile Include="Mappers\RandomMapper.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -196 +202 @@
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Mappers" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.