Changeset 5567 for branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators

Timestamp:

02/28/11 17:11:56 (14 years ago)

Author:

gkronber

Message:

#1418 improved ChangeNodeTypeManipulation operator to make unit test succeed.

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs (modified) (2 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs

@@ -46 +46 @@
 
     public static void ChangeNodeType(IRandom random, ISymbolicExpressionTree symbolicExpressionTree) {
+      // select any node as parent (except the root node)
+      var manipulationPoints = (from parent in symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1)
+                                let subtreeCount = parent.SubTrees.Count()
+                                from subtreeIndex in Enumerable.Range(0, subtreeCount)
+                                let subtree = parent.GetSubTree(subtreeIndex)
+                                let existingSubtreeCount = subtree.SubTrees.Count()
+                                // find possible symbols for the node (also considering the existing branches below it)
+                                let allowedSymbols = (from symbol in parent.Grammar.GetAllowedSymbols(parent.Symbol, subtreeIndex)
+                                                      // do not replace the existing symbol with itself
+                                                      where symbol.Name != subtree.Symbol.Name
+                                                      where existingSubtreeCount <= parent.Grammar.GetMaxSubtreeCount(symbol)
+                                                      where existingSubtreeCount >= parent.Grammar.GetMinSubtreeCount(symbol)
+                                                      // keep only symbols that are still possible considering the existing sub-trees
+                                                      where (from existingSubtreeIndex in Enumerable.Range(0, existingSubtreeCount)
+                                                             let existingSubtree = subtree.GetSubTree(existingSubtreeIndex)
+                                                             select parent.Grammar.IsAllowedChild(symbol, existingSubtree.Symbol, existingSubtreeIndex))
+                                                             .All(x => x == true)
+                                                      select symbol)
+                                                      .ToList()
+                                where allowedSymbols.Count() > 0
+                                select new { Parent = parent, Child = subtree, Index = subtreeIndex, AllowedSymbols = allowedSymbols })
+                               .ToList();
+      if (manipulationPoints.Count == 0) { return; }
+      var selectedManipulationPoint = manipulationPoints.SelectRandom(random);
 
-      // select any node as parent (except the root node)
-      var manipulationPoint = (from parent in symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1)
-                               from subtree in parent.SubTrees
-                               select new { Parent = parent, Node = subtree, Index = parent.IndexOfSubTree(subtree) })
-                               .SelectRandom(random);
-      int subTreeCount = manipulationPoint.Node.SubTrees.Count();
-      // find possible symbols for the node (also considering the existing branches below it)
-      var allowedSymbols = from symbol in manipulationPoint.Parent.Grammar.GetAllowedSymbols(manipulationPoint.Parent.Symbol, manipulationPoint.Index)
-                           where subTreeCount <= manipulationPoint.Node.Grammar.GetMaxSubtreeCount(symbol)
-                           where subTreeCount >= manipulationPoint.Node.Grammar.GetMinSubtreeCount(symbol)
-                           select symbol;
-
-      if (allowedSymbols.Count() == 0) {
-        return;
-      }
-      var node = manipulationPoint.Node;
-      // keep only symbols that are still possible considering the existing sub-trees
-      var constrainedSymbols = (from symbol in allowedSymbols
-                                let disallowedSubtrees =
-                                      from subtree in node.SubTrees
-                                      where !node.Grammar.IsAllowedChild(symbol, subtree.Symbol, node.IndexOfSubTree(subtree))
-                                      select subtree
-                                where disallowedSubtrees.Count() == 0
-                                select symbol)
-                               .ToList();
-      if (constrainedSymbols.Count() == 0) {
-        return;
-      }
-      var weights = constrainedSymbols.Select(s => s.InitialFrequency).ToList();
-      var newSymbol =  constrainedSymbols.SelectRandom(weights, random);
+      var weights = selectedManipulationPoint.AllowedSymbols.Select(s => s.InitialFrequency).ToList();
+      var newSymbol = selectedManipulationPoint.AllowedSymbols.SelectRandom(weights, random);
 
       // replace the old node with the new node
@@ -82 +78 @@
       if (newNode.HasLocalParameters)
         newNode.ResetLocalParameters(random);
-      foreach (var subtree in node.SubTrees)
+      foreach (var subtree in selectedManipulationPoint.Child.SubTrees)
         newNode.AddSubTree(subtree);
-      manipulationPoint.Parent.RemoveSubTree(manipulationPoint.Index);
-      manipulationPoint.Parent.InsertSubTree(manipulationPoint.Index, newNode);
+      selectedManipulationPoint.Parent.RemoveSubTree(selectedManipulationPoint.Index);
+      selectedManipulationPoint.Parent.InsertSubTree(selectedManipulationPoint.Index, newNode);
     }
   }