Changeset 8292 for branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMultiMoveGenerator.cs

Timestamp:

07/16/12 09:06:27 (12 years ago)

Author:

gkronber

Message:

#1847: worked on move operators. version of the final EMSS submission

File:

• branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMultiMoveGenerator.cs (modified) (11 diffs)

branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMultiMoveGenerator.cs

@@ -94 +94 @@
       get { return (IValueLookupParameter<BoolValue>)Parameters["Semantic"]; }
     }
-
-    private IList<ISymbolicExpressionTree> fragments;
-    private IList<double[]> fragmentOutput;
+    public ILookupParameter<ItemList<ISymbolicExpressionTree>> FragmentsParameter {
+      get { return (ILookupParameter<ItemList<ISymbolicExpressionTree>>)Parameters["Fragments"]; }
+    }
+    public ILookupParameter<ItemList<DoubleArray>> FragmentOutputsParameter {
+      get { return (ILookupParameter<ItemList<DoubleArray>>)Parameters["FragmentOutputs"]; }
+    }
 
     [StorableConstructor]
@@ -119 +122 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("NeighbourhoodSize", new IntValue(5)));
       Parameters.Add(new ValueLookupParameter<BoolValue>("Semantic", new BoolValue()));
+      Parameters.Add(new LookupParameter<ItemList<ISymbolicExpressionTree>>("Fragments"));
+      Parameters.Add(new LookupParameter<ItemList<DoubleArray>>("FragmentOutputs"));
     }
 
@@ -139 +144 @@
     }
 
-    public override void ClearState() {
-      fragments = null;
-      fragmentOutput = null;
-      base.ClearState();
-    }
-    public override void InitializeState() {
-      fragments = null;
-      fragmentOutput = null;
-      base.InitializeState();
-    }
-
     public override IOperation Apply() {
       var random = RandomParameter.ActualValue;
-      if (fragments == null || fragmentOutput == null) {
+      if (FragmentsParameter.ActualValue == null || FragmentOutputsParameter.ActualValue == null) {
         InitializeOperator();
       }
@@ -176 +170 @@
       int maxDepth = MaximumSymbolicExpressionTreeDepthParameter.ActualValue.Value;
       int maxLength = MaximumSymbolicExpressionTreeLengthParameter.ActualValue.Value;
-      var possibleInternalChildren = (from parent in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix()
+      var possibleInternalChildren = (from parent in tree.Root.GetSubtree(0).IterateNodesPrefix()
                                       from i in Enumerable.Range(0, parent.SubtreeCount)
                                       let currentChild = parent.GetSubtree(i)
                                       where currentChild.SubtreeCount > 0
-                                      where tree.Root.GetBranchLevel(currentChild) <= maxDepth + 2
+                                      where tree.Root.GetBranchLevel(currentChild) < maxDepth + 2
                                       where tree.Length - currentChild.GetLength() < maxLength
                                       select new CutPoint(parent, i)).ToArray();
 
-      var possibleLeaveChildren = (from parent in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix()
+      var possibleLeaveChildren = (from parent in tree.Root.GetSubtree(0).IterateNodesPrefix()
                                    from i in Enumerable.Range(0, parent.SubtreeCount)
                                    let currentChild = parent.GetSubtree(i)
                                    where currentChild.SubtreeCount == 0
-                                   where tree.Root.GetBranchLevel(currentChild) <= maxDepth + 2
+                                   where tree.Root.GetBranchLevel(currentChild) < maxDepth + 2
                                    where tree.Length - 1 < maxLength
                                    select new CutPoint(parent, i)).ToArray();
-
+      if (possibleInternalChildren.Length == 0) possibleInternalChildren = possibleLeaveChildren;
+      if (possibleLeaveChildren.Length == 0) possibleLeaveChildren = possibleInternalChildren;
 
       var root = (new ProgramRootSymbol()).CreateTreeNode();
@@ -202 +197 @@
 
       bool semantic = SemanticParameter.ActualValue.Value;
-
-      // select a random replacement point
-      CutPoint[] possibleChildren;
-      if (random.NextDouble() < 0.9)
-        possibleChildren = possibleInternalChildren;
-      else possibleChildren = possibleLeaveChildren;
-      var selected = possibleChildren[random.Next(possibleChildren.Length)];
-      // evaluate 
-      start.AddSubtree(selected.Parent.GetSubtree(selected.ChildIndex));
-      var output = interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray();
-      start.RemoveSubtree(0);
-
-      if (semantic) {
-        return FindMostSimilarFragments(tree, maxLength, maxDepth, selected, random, n, output);
-      } else {
-        return FindRandomFragments(tree, maxLength, maxDepth, selected, random, n, output);
+      int maxNeighbours = NeighbourhoodSizeParameter.ActualValue.Value;
+      var count = 0;
+      while (count < n) {
+        // select a random replacement point
+        CutPoint[] possibleChildren;
+        if (random.NextDouble() < 0.9)
+          possibleChildren = possibleInternalChildren;
+        else possibleChildren = possibleLeaveChildren;
+        var selected = possibleChildren[random.Next(possibleChildren.Length)];
+        // evaluate 
+        start.AddSubtree(selected.Parent.GetSubtree(selected.ChildIndex));
+        var output = interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray();
+        start.RemoveSubtree(0);
+
+        if (semantic) {
+          foreach (var m in FindMostSimilarFragments(tree, maxLength, maxDepth, selected, random, maxNeighbours, output)) {
+            yield return m;
+            count++;
+          }
+        } else {
+          foreach (var m in FindRandomFragments(tree, maxLength, maxDepth, selected, random, maxNeighbours, output)) {
+            yield return m;
+            count++;
+          }
+        }
       }
     }
@@ -223 +227 @@
     private IEnumerable<ReplaceBranchMove> FindRandomFragments(ISymbolicExpressionTree tree, int maxLength, int maxDepth, CutPoint selected,
   IRandom random, int maxNeighbours, double[] output) {
-      var selectedFragments = new List<Tuple<ISymbolicExpressionTree, double[]>>(maxNeighbours);
+      var selectedFragments = new List<int>(maxNeighbours);
       int treeLength = tree.Length;
       int removedFragementLength = selected.Parent.GetSubtree(selected.ChildIndex).GetLength();
@@ -229 +233 @@
       int iterations = 0;
       int maxIterations = maxNeighbours + 100;
+      var fragments = FragmentsParameter.ActualValue;
+      var fragmentOutput = FragmentOutputsParameter.ActualValue;
       // select random fragments
       while (selectedFragments.Count < maxNeighbours && iterations++ < maxIterations) {
@@ -238 +244 @@
           parentBranchLevel + selectedFragment.Depth - 2 <= maxDepth + 2 &&
           tree.Root.Grammar.IsAllowedChildSymbol(selected.Parent.Symbol, selectedFragment.Root.GetSubtree(0).GetSubtree(0).Symbol, selected.ChildIndex)) {
-          selectedFragments.Add(Tuple.Create(selectedFragment, selectedFragmentOutput));
+          selectedFragments.Add(r);
         }
       }
       // yield moves (we need to add linear scaling parameters for the inserted tree)
       return selectedFragments
-        .Select(pair => new ReplaceBranchMove(tree, selected.Parent, selected.ChildIndex, pair.Item1.Root.GetSubtree(0).GetSubtree(0), output, pair.Item2));
+        .Select(i => new ReplaceBranchMove(tree, selected.Parent, selected.ChildIndex, fragments[i].Root.GetSubtree(0).GetSubtree(0), output, fragmentOutput[i].ToArray(), i));
     }
 
     private IEnumerable<ReplaceBranchMove> FindMostSimilarFragments(ISymbolicExpressionTree tree, int maxLength, int maxDepth, CutPoint selected,
       IRandom random, int maxNeighbours, double[] output) {
-      var bestTrees = new SortedList<double, List<Tuple<ISymbolicExpressionTree, double[]>>>(fragments.Count);
+      var fragments = FragmentsParameter.ActualValue;
+      var fragmentOutput = FragmentOutputsParameter.ActualValue;
+      var bestTrees = new SortedList<double, List<int>>(fragments.Count);
       int treeLength = tree.Length;
       int removedFragementLength = selected.Parent.GetSubtree(selected.ChildIndex).GetLength();
@@ -266 +274 @@
           if (similarity < 1 && ((bestTrees.Count < maxNeighbours) || similarity > bestTrees.ElementAt(0).Key)) {
             if (!bestTrees.ContainsKey(similarity)) {
-              var l = new List<Tuple<ISymbolicExpressionTree, double[]>>();
+              var l = new List<int>();
               bestTrees.Add(similarity, l);
             }
-            bestTrees[similarity].Add(Tuple.Create(fragments[i], fragmentOutput[i]));
+            bestTrees[similarity].Add(i);
             if (bestTrees.Count > maxNeighbours) bestTrees.RemoveAt(0);
           }
@@ -278 +286 @@
       while (c < maxNeighbours) {
         var l = bestTrees.ElementAt(c % bestTrees.Count).Value;
-        var pair = l[random.Next(l.Count)];
+        var index = l[random.Next(l.Count)];
         yield return
-          new ReplaceBranchMove(tree, selected.Parent, selected.ChildIndex, pair.Item1.Root.GetSubtree(0).GetSubtree(0),
-                                output, pair.Item2);
+          new ReplaceBranchMove(tree, selected.Parent, selected.ChildIndex, fragments[index].Root.GetSubtree(0).GetSubtree(0),
+                                output, fragmentOutput[index].ToArray(), index);
         c++;
       }
@@ -313 +321 @@
       // enable constants again
       constSym.InitialFrequency = oldConstFreq;
-      this.fragments = trees;
-      this.fragmentOutput = treeOutput;
+      // set parameters
+      FragmentsParameter.ActualValue = new ItemList<ISymbolicExpressionTree>(trees);
+      FragmentOutputsParameter.ActualValue = new ItemList<DoubleArray>(treeOutput.Select(a => new DoubleArray(a)));
     }
   }