Changeset 7089 for branches/gp-crossover

Timestamp:

11/28/11 17:18:49 (13 years ago)

Author:

bburlacu

Message:

#1682: Fixed a bug affecting the new crossovers

Location:

branches/gp-crossover/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers

Files:

• SymbolicDataAnalysisExpressionContextAwareCrossover.cs (modified) (6 diffs)
• SymbolicDataAnalysisExpressionCrossover.cs (modified) (2 diffs)
• SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs (modified) (5 diffs)
• SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover.cs (modified) (8 diffs)
• SymbolicDataAnalysisExpressionSemanticSimilarityCrossover.cs (modified) (7 diffs)

branches/gp-crossover/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionContextAwareCrossover.cs

@@ -33 +33 @@
 
   [Item("ContextAwareCrossover", "An operator which performs subtree swapping in a deterministic way: it checks all possible cross points in the second parent with the aim of creating the best possible offspring.")]
-  public sealed class SymbolicDataAnalysisExpressionContextAwareCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData 
-  {
+  public sealed class SymbolicDataAnalysisExpressionContextAwareCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData {
     [StorableConstructor]
     private SymbolicDataAnalysisExpressionContextAwareCrossover(bool deserializing) : base(deserializing) { }
@@ -45 +44 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SymbolicDataAnalysisExpressionContextAwareCrossover<T>(this, cloner);
-    } 
+    }
     protected override ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
       if (this.ExecutionContext == null)
@@ -63 +62 @@
       List<CutPoint> crossoverPoints0 = new List<CutPoint>();
       parent0.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent0.Root) 
-          foreach (var child in n.Subtrees) 
+        if (n.Subtrees.Any() && n != parent0.Root)
+          foreach (var child in n.Subtrees)
             crossoverPoints0.Add(new CutPoint(n, child));
       });
@@ -73 +72 @@
       List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
       parent1.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent1.Root) 
+        if (n.Subtrees.Any() && n != parent1.Root)
           foreach (var child in n.Subtrees)
             if (crossoverPoint0.IsMatchingPointType(child) && (child.GetDepth() + level <= maxDepth) && (child.GetLength() + length <= maxLength))
-              allowedBranches.Add(n);
+              allowedBranches.Add(child);
       });
 
@@ -82 +81 @@
       if (crossoverPoint0.IsMatchingPointType(null)) allowedBranches.Add(null);
 
-      if (allowedBranches.Count == 0) 
+      if (allowedBranches.Count == 0)
         return parent0;
 
@@ -90 +89 @@
       ISymbolicExpressionTreeNode selectedBranch = null;
 
-      var nodeQualities = new List<Tuple<ISymbolicExpressionTreeNode,double>>();
+      var nodeQualities = new List<Tuple<ISymbolicExpressionTreeNode, double>>();
 
       foreach (var node in allowedBranches) {

branches/gp-crossover/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionCrossover.cs

@@ -54 +54 @@
     }
     public ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>> EvaluatorParameter {
-      get { return (ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>) Parameters[EvaluatorParameterName]; }
+      get { return (ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>)Parameters[EvaluatorParameterName]; }
     }
     public IValueLookupParameter<IntRange> SymbolicDataAnalysisEvaluationPartitionParameter {
@@ -107 +107 @@
     /// <param name="startSymbol"></param>
     /// <returns></returns>
-    protected static ISymbolicExpressionTree CreateTreeFromNode(IRandom random, ISymbolicExpressionTreeNode node, ISymbolicExpressionGrammar grammar) {
-      SymbolicExpressionTree tree = new SymbolicExpressionTree();
-      var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode();
-      if (rootNode.HasLocalParameters)
-        rootNode.ResetLocalParameters(random);
-      rootNode.SetGrammar((ISymbolicExpressionTreeGrammar)grammar);
-      var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode();
-      startNode.SetGrammar((ISymbolicExpressionTreeGrammar)grammar);
-      if (startNode.HasLocalParameters)
-        startNode.ResetLocalParameters(random);
+    protected static ISymbolicExpressionTree CreateTreeFromNode(IRandom random, ISymbolicExpressionTreeNode node, ISymbol rootSymbol, ISymbol startSymbol) {
+      var rootNode = new SymbolicExpressionTreeTopLevelNode(rootSymbol);
+      if (rootNode.HasLocalParameters) rootNode.ResetLocalParameters(random);
+
+      //if (node.Symbol.Name == startSymbol.Name) {
+      //  rootNode.AddSubtree(node);
+      //} else {
+      //  var startNode = new SymbolicExpressionTreeTopLevelNode(startSymbol);
+      //  if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random);
+
+      //  startNode.AddSubtree(node);
+      //  rootNode.AddSubtree(startNode);
+      //}
+      var startNode = new SymbolicExpressionTreeTopLevelNode(startSymbol);
+      if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random);
+
+      startNode.AddSubtree(node);
       rootNode.AddSubtree(startNode);
 
-      rootNode.AddSubtree(startNode); 
-      if (startNode.Grammar.IsAllowedChildSymbol(startNode.Symbol, node.Symbol))
-        startNode.AddSubtree(node);
-      else
-        throw new InvalidOperationException("The given node cannot be a child of the start symbol.");
       return new SymbolicExpressionTree(rootNode);
     }

branches/gp-crossover/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs

@@ -33 +33 @@
 
   [Item("DepthConstrainedCrossover", "An operator which performs subtree swapping only within a specific depth range.")]
-  public sealed class SymbolicDataAnalysisExpressionDepthConstrainedCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData 
-  {
+  public sealed class SymbolicDataAnalysisExpressionDepthConstrainedCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData {
     [StorableConstructor]
     private SymbolicDataAnalysisExpressionDepthConstrainedCrossover(bool deserializing) : base(deserializing) { }
@@ -41 +40 @@
     public SymbolicDataAnalysisExpressionDepthConstrainedCrossover() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicDataAnalysisExpressionDepthConstrainedCrossover<T>(this, cloner); }
- 
+
     protected override ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
@@ -56 +55 @@
       List<CutPoint> crossoverPoints0 = new List<CutPoint>();
       parent0.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent0.Root) 
-          foreach (var child in n.Subtrees) 
+        if (n.Subtrees.Any() && n != parent0.Root)
+          foreach (var child in n.Subtrees)
             crossoverPoints0.Add(new CutPoint(n, child));
       });
@@ -66 +65 @@
       List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
       parent1.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent1.Root) 
+        if (n.Subtrees.Any() && n != parent1.Root)
           foreach (var child in n.Subtrees)
             if (crossoverPoint0.IsMatchingPointType(child) && (child.GetDepth() + level <= maxDepth) && (child.GetLength() + length <= maxLength))
-              allowedBranches.Add(n);
+              allowedBranches.Add(child);
       });
 
@@ -75 +74 @@
       if (crossoverPoint0.IsMatchingPointType(null)) allowedBranches.Add(null);
 
-      if (allowedBranches.Count == 0) 
+      if (allowedBranches.Count == 0)
         return parent0;
 

branches/gp-crossover/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover.cs

@@ -33 +33 @@
 
   [Item("ProbabilisticFunctionalCrossover", "An operator which performs subtree swapping based on behavioral similarity")]
-  public sealed class SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData 
-  {
+  public sealed class SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData {
     [StorableConstructor]
     private SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover(bool deserializing) : base(deserializing) { }
-    private SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover(SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T> original, Cloner cloner) 
+    private SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover(SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T> original, Cloner cloner)
       : base(original, cloner) { }
     public SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T>(this, cloner); }
- 
+
     protected override ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
@@ -47 +46 @@
       T problemData = ProblemDataParameter.ActualValue;
       var grammar = parent0.Root.Grammar;
-      return Cross(random, parent0, parent1, interpreter, problemData, 
+      return Cross(random, parent0, parent1, interpreter, problemData,
                    rows, MaximumSymbolicExpressionTreeDepth.Value, MaximumSymbolicExpressionTreeLength.Value);
     }
@@ -58 +57 @@
     /// choose the second crosspoint via a random weighted selection procedure.
     /// </summary>
-    public static ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1, 
+    public static ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1,
                                                 ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, T problemData, IEnumerable<int> rows, int maxDepth, int maxLength) {
       List<CutPoint> crossoverPoints0 = new List<CutPoint>();
       parent0.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent0.Root) 
-          foreach (var child in n.Subtrees) 
+        if (n.Subtrees.Any() && n != parent0.Root)
+          foreach (var child in n.Subtrees)
             crossoverPoints0.Add(new CutPoint(n, child));
       });
@@ -72 +71 @@
       List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
       parent1.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent1.Root) 
+        if (n.Subtrees.Any() && n != parent1.Root)
           foreach (var child in n.Subtrees)
             if (crossoverPoint0.IsMatchingPointType(child) && (child.GetDepth() + level <= maxDepth) && (child.GetLength() + length <= maxLength))
-              allowedBranches.Add(n);
+              allowedBranches.Add(child);
       });
 
@@ -81 +80 @@
       if (crossoverPoint0.IsMatchingPointType(null)) allowedBranches.Add(null);
 
-      if (allowedBranches.Count == 0) 
+      if (allowedBranches.Count == 0)
         return parent0;
 
@@ -87 +86 @@
 
       // create symbols in order to improvize an ad-hoc tree so that the child can be evaluated
-      var tree0 = CreateTreeFromNode(random, crossoverPoint0.Child, (ISymbolicExpressionGrammar)parent0.Root.Grammar);
+      var rootSymbol = new ProgramRootSymbol();
+      var startSymbol = new StartSymbol();
+      var tree0 = CreateTreeFromNode(random, crossoverPoint0.Child, rootSymbol, startSymbol);
       IEnumerable<double> estimatedValues0 = interpreter.GetSymbolicExpressionTreeValues(tree0, dataset, rows);
       double min0 = estimatedValues0.Min();
@@ -94 +95 @@
       List<double> weights = new List<double>();
       foreach (var node in allowedBranches) {
-        var tree1 = CreateTreeFromNode(random, node, (ISymbolicExpressionGrammar)parent0.Root.Grammar);
+        var tree1 = CreateTreeFromNode(random, node, rootSymbol, startSymbol);
         IEnumerable<double> estimatedValues1 = interpreter.GetSymbolicExpressionTreeValues(tree1, dataset, rows);
         double min1 = estimatedValues1.Min();
@@ -133 +134 @@
       double r = weights.Sum() * random.NextDouble();
       for (int i = 0; i != nodes.Count; ++i) {
-        if (r < weights[i]) 
-          return nodes[i];        
+        if (r < weights[i])
+          return nodes[i];
         r -= weights[i];
       }

branches/gp-crossover/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionSemanticSimilarityCrossover.cs

@@ -33 +33 @@
 
   [Item("SemanticSimilarityCrossover", "An operator which performs subtree swapping based on semantic similarity.")]
-  public sealed class SymbolicDataAnalysisExpressionSemanticSimilarityCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData 
-  {
+  public sealed class SymbolicDataAnalysisExpressionSemanticSimilarityCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData {
     [StorableConstructor]
     private SymbolicDataAnalysisExpressionSemanticSimilarityCrossover(bool deserializing) : base(deserializing) { }
@@ -40 +39 @@
     public SymbolicDataAnalysisExpressionSemanticSimilarityCrossover() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicDataAnalysisExpressionSemanticSimilarityCrossover<T>(this, cloner); }
- 
+
     protected override ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
@@ -51 +50 @@
     /// Randomly choose a node i from the first parent, then get a node j from the second parent that matches the semantic similarity criteria.
     /// </summary>
-    public static ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1, 
+    public static ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1,
                                                 ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, T problemData, IEnumerable<int> rows, int maxDepth, int maxLength) {
       List<CutPoint> crossoverPoints0 = new List<CutPoint>();
       parent0.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent0.Root) 
-          foreach (var child in n.Subtrees) 
+        if (n.Subtrees.Any() && n != parent0.Root)
+          foreach (var child in n.Subtrees)
             crossoverPoints0.Add(new CutPoint(n, child));
       });
@@ -65 +64 @@
       List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
       parent1.Root.ForEachNodePostfix((n) => {
-        if (n.Subtrees.Any() && n != parent1.Root) 
+        if (n.Subtrees.Any() && n != parent1.Root)
           foreach (var child in n.Subtrees)
             if (crossoverPoint0.IsMatchingPointType(child) && (child.GetDepth() + level <= maxDepth) && (child.GetLength() + length <= maxLength))
-              allowedBranches.Add(n);
+              allowedBranches.Add(child);
       });
 
@@ -74 +73 @@
       if (crossoverPoint0.IsMatchingPointType(null)) allowedBranches.Add(null);
 
-      if (allowedBranches.Count == 0) 
+      if (allowedBranches.Count == 0)
         return parent0;
 
@@ -80 +79 @@
 
       // create symbols in order to improvize an ad-hoc tree so that the child can be evaluated
-      //var rootSymbol = new ProgramRootSymbol();
-      //var startSymbol = new StartSymbol();
-      var tree0 = CreateTreeFromNode(random, crossoverPoint0.Child, (ISymbolicExpressionGrammar)parent0.Root.Grammar);
+      var rootSymbol = new ProgramRootSymbol();
+      var startSymbol = new StartSymbol();
+      var tree0 = CreateTreeFromNode(random, crossoverPoint0.Child, rootSymbol, startSymbol);
       IEnumerable<double> estimatedValues0 = interpreter.GetSymbolicExpressionTreeValues(tree0, dataset, rows);
 
@@ -89 +88 @@
       // pick the first node that fulfills the semantic similarity conditions
       foreach (var node in allowedBranches) {
-        var tree1 = CreateTreeFromNode(random, node, (ISymbolicExpressionGrammar)parent0.Root.Grammar);
+        var tree1 = CreateTreeFromNode(random, node, startSymbol, rootSymbol);
         IEnumerable<double> estimatedValues1 = interpreter.GetSymbolicExpressionTreeValues(tree1, dataset, rows);