Changeset 5686 for branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs

Timestamp:

03/15/11 13:34:38 (13 years ago)

Author:

mkommend

Message:

#1418: Finally added results from the grammar refactoring.

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs (modified) (12 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs

@@ -27 +27 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -61 +61 @@
     private SubroutineCreater(bool deserializing) : base(deserializing) { }
     private SubroutineCreater(SubroutineCreater original, Cloner cloner) : base(original, cloner) { }
-    public SubroutineCreater() : base() {
+    public SubroutineCreater()
+      : base() {
       Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
       Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
@@ -109 +110 @@
 
       // select a random cut point in the selected branch
-      var allCutPoints = from parent in selectedBody.IterateNodesPrefix()
-                         from subtree in parent.SubTrees
-                         select new { Parent = parent, ReplacedBranchIndex = parent.IndexOfSubTree(subtree), ReplacedBranch = subtree };
+      var allCutPoints = (from parent in selectedBody.IterateNodesPrefix()
+                          from subtree in parent.SubTrees
+                          select new CutPoint(parent, subtree)).ToList();
       if (allCutPoints.Count() == 0)
         // no cut points => abort
@@ -118 +119 @@
       var selectedCutPoint = allCutPoints.SelectRandom(random);
       // select random branches as argument cut-off points (replaced by argument terminal nodes in the function)
-      List<ISymbolicExpressionTreeNode> argumentBranches = SelectRandomArgumentBranches(selectedCutPoint.ReplacedBranch, random, ARGUMENT_CUTOFF_PROBABILITY, maxFunctionArguments);
-      ISymbolicExpressionTreeNode functionBody = selectedCutPoint.ReplacedBranch;
+      List<CutPoint> argumentCutPoints = SelectRandomArgumentBranches(selectedCutPoint.Child, random, ARGUMENT_CUTOFF_PROBABILITY, maxFunctionArguments);
+      ISymbolicExpressionTreeNode functionBody = selectedCutPoint.Child;
       // disconnect the function body from the tree
-      selectedCutPoint.Parent.RemoveSubTree(selectedCutPoint.ReplacedBranchIndex);
+      selectedCutPoint.Parent.RemoveSubTree(selectedCutPoint.ChildIndex);
       // disconnect the argument branches from the function
-      functionBody = DisconnectBranches(functionBody, argumentBranches);
+      functionBody = DisconnectBranches(functionBody, argumentCutPoints);
       // insert a function invocation symbol instead
       var invokeNode = (InvokeFunctionTreeNode)(new InvokeFunction(newFunctionName)).CreateTreeNode();
-      selectedCutPoint.Parent.InsertSubTree(selectedCutPoint.ReplacedBranchIndex, invokeNode);
+      selectedCutPoint.Parent.InsertSubTree(selectedCutPoint.ChildIndex, invokeNode);
       // add the branches selected as argument as subtrees of the function invocation node
-      foreach (var argumentBranch in argumentBranches)
-        invokeNode.AddSubTree(argumentBranch);
+      foreach (var argumentCutPoint in argumentCutPoints)
+        invokeNode.AddSubTree(argumentCutPoint.Child);
 
       // insert a new function defining branch
@@ -138 +139 @@
       // the grammar in the newly defined function is a clone of the grammar of the originating branch
       defunNode.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBody.Grammar.Clone());
-      // remove all argument symbols from grammar
-      var oldArgumentSymbols = defunNode.Grammar.Symbols.OfType<Argument>().ToList();
+      // remove all argument symbols from grammar except that one contained in cutpoints
+      var oldArgumentSymbols = selectedBody.Grammar.Symbols.OfType<Argument>().ToList();
       foreach (var oldArgSymb in oldArgumentSymbols)
         defunNode.Grammar.RemoveSymbol(oldArgSymb);
@@ -146 +147 @@
                                 select node.Symbol.ArgumentIndex).Distinct();
       // add argument symbols to grammar of function defining branch
-      GrammarModifier.AddDynamicArguments(defunNode.Grammar, defunNode.Symbol, newArgumentIndexes);
+      GrammarModifier.AddArgumentSymbol(selectedBody.Grammar, defunNode.Grammar, newArgumentIndexes, argumentCutPoints);
       defunNode.NumberOfArguments = newArgumentIndexes.Count();
-      if (defunNode.NumberOfArguments != argumentBranches.Count) throw new InvalidOperationException();
+      if (defunNode.NumberOfArguments != argumentCutPoints.Count) throw new InvalidOperationException();
       // add invoke symbol for newly defined function to the original branch 
-      var allowedParents = from symb in selectedBody.Grammar.Symbols
-                           where !(symb is ProgramRootSymbol)
-                           select symb;
-      var allowedChildren = from symb in selectedBody.Grammar.Symbols
-                            where selectedBody.Grammar.IsAllowedChild(selectedBody.Symbol, symb, 0)
-                            select symb;
-      GrammarModifier.AddDynamicSymbol(selectedBody.Grammar, selectedBody.Symbol, defunNode.FunctionName, defunNode.NumberOfArguments);
+      GrammarModifier.AddInvokeSymbol(selectedBody.Grammar, defunNode.FunctionName, defunNode.NumberOfArguments, selectedCutPoint, argumentCutPoints);
 
       // when the new function body was taken from another function definition
@@ -168 +163 @@
           // when the original branch can be invoked from the subtree then also allow invocation of the function
           if (originalBranchInvokeSymbol != null) {
-            allowedParents = from symb in subtree.Grammar.Symbols
-                             where !(symb is ProgramRootSymbol)
-                             select symb;
-            allowedChildren = from symb in subtree.Grammar.Symbols
-                              where subtree.Grammar.IsAllowedChild(subtree.Symbol, symb, 0)
-                              select symb;
-            GrammarModifier.AddDynamicSymbol(subtree.Grammar, subtree.Symbol, defunNode.FunctionName, defunNode.NumberOfArguments);
+            GrammarModifier.AddInvokeSymbol(subtree.Grammar, defunNode.FunctionName, defunNode.NumberOfArguments, selectedCutPoint, argumentCutPoints);
           }
         }
@@ -181 +170 @@
     }
 
-    private static ISymbolicExpressionTreeNode DisconnectBranches(ISymbolicExpressionTreeNode node, List<ISymbolicExpressionTreeNode> argumentBranches) {
-      if (argumentBranches.Contains(node)) {
-        var argumentIndex = argumentBranches.IndexOf(node);
+    private static ISymbolicExpressionTreeNode DisconnectBranches(ISymbolicExpressionTreeNode node, List<CutPoint> argumentCutPoints) {
+      int argumentIndex = argumentCutPoints.FindIndex(x => x.Child == node);
+      if (argumentIndex != -1) {
         var argSymbol = new Argument(argumentIndex);
         return argSymbol.CreateTreeNode();
@@ -192 +181 @@
       // recursively apply function for subtrees or append a argument terminal node
       foreach (var subtree in subtrees) {
-        node.AddSubTree(DisconnectBranches(subtree, argumentBranches));
+        node.AddSubTree(DisconnectBranches(subtree, argumentCutPoints));
       }
       return node;
     }
 
-    private static List<ISymbolicExpressionTreeNode> SelectRandomArgumentBranches(ISymbolicExpressionTreeNode selectedRoot,
+    private static List<CutPoint> SelectRandomArgumentBranches(ISymbolicExpressionTreeNode selectedRoot,
       IRandom random,
       double cutProbability,
@@ -203 +192 @@
       // breadth first determination of argument cut-off points
       // we must make sure that we cut off all original argument nodes and that the number of new argument is smaller than the limit
-      List<ISymbolicExpressionTreeNode> argumentBranches = new List<ISymbolicExpressionTreeNode>();
+      List<CutPoint> argumentBranches = new List<CutPoint>();
       if (selectedRoot is ArgumentTreeNode) {
-        argumentBranches.Add(selectedRoot);
+        argumentBranches.Add(new CutPoint(selectedRoot.Parent, selectedRoot));
         return argumentBranches;
       } else {
@@ -213 +202 @@
                                            select nArgumentsInTree).ToList();
         // determine the minimal number of new argument nodes for each sub-tree
+        //if we exceed the maxArguments return the same cutpoint as the start cutpoint to create a ADF that returns only its argument
         var minNewArgumentsForSubtrees = numberOfArgumentsInSubtrees.Select(x => x > 0 ? 1 : 0).ToList();
         if (minNewArgumentsForSubtrees.Sum() > maxArguments) {
-          argumentBranches.Add(selectedRoot);
+          argumentBranches.Add(new CutPoint(selectedRoot.Parent, selectedRoot));
           return argumentBranches;
         }
         // cut-off in the sub-trees in random order
         var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.SubTrees.Count())
-                             select new { Index = index, OrderValue = random.NextDouble() }).OrderBy(x => x.OrderValue).Select(x => x.Index);
+                             select new { Index = index, OrderValue = random.NextDouble() })
+                             .OrderBy(x => x.OrderValue)
+                             .Select(x => x.Index);
         foreach (var subtreeIndex in randomIndexes) {
           var subtree = selectedRoot.GetSubTree(subtreeIndex);
@@ -237 +229 @@
           } else {
             // cut-off at current sub-tree
-            argumentBranches.Add(subtree);
+            argumentBranches.Add(new CutPoint(subtree.Parent, subtree));
           }
         }