Changeset 11482 for branches/HeuristicLab.EvolutionTracking

Timestamp:

10/21/14 01:31:20 (10 years ago)

Author:

bburlacu

Message:

#1772: Added the ability to ignore variable weights or constant values to the BottomUpSimilarityCalculator and added parameters to the SymbolicDataAnalysisBottomUpDiversityAnalyzer. Added separate methods in the MaxCommonSubtreeSimilarityCalculator for performing matching with full subtrees (including all leaves) or without (like the old - and better - behavior).

Location:

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Analyzers/SymbolicDataAnalysisBottomUpDiversityAnalyzer.cs (modified) (2 diffs)
• Analyzers/SymbolicDataAnalysisMaxCommonSubtreeDiversityAnalyzer.cs (copied) (copied from branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisBottomUpDiversityAnalyzer.cs) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (2 diffs)
• SimilarityCalculators/BottomUpSimilarityCalculator.cs (modified) (6 diffs)
• SimilarityCalculators/MaxCommonSubtreeSimilarityCalculator.cs (modified) (3 diffs)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisBottomUpDiversityAnalyzer.cs

@@ -22 +22 @@
 using HeuristicLab.Analysis;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -28 +30 @@
   [StorableClass]
   public class SymbolicDataAnalysisBottomUpDiversityAnalyzer : SingleObjectivePopulationDiversityAnalyzer {
+    private const string MatchConstantValuesParameterName = "MatchConstantValues";
+    private const string MatchVariableWeightsParameterName = "MatchVariableWeights";
+
+    public IValueParameter<BoolValue> MatchVariableWeightsParameter {
+      get { return (IValueParameter<BoolValue>)Parameters[MatchVariableWeightsParameterName]; }
+    }
+
+    public IValueParameter<BoolValue> MatchConstantValuesParameter {
+      get { return (IValueParameter<BoolValue>)Parameters[MatchConstantValuesParameterName]; }
+    }
+
+    public bool MatchConstantValues {
+      get { return MatchConstantValuesParameter.Value.Value; }
+      set {
+        MatchConstantValuesParameter.Value.Value = value;
+        ((BottomUpSimilarityCalculator)SimilarityCalculator).MatchConstantValues = value;
+      }
+    }
+
+    public bool MatchVariableWeights {
+      get { return MatchVariableWeightsParameter.Value.Value; }
+      set {
+        MatchVariableWeightsParameter.Value.Value = value;
+        ((BottomUpSimilarityCalculator)SimilarityCalculator).MatchVariableWeights = value;
+      }
+    }
+
     [StorableConstructor]
     protected SymbolicDataAnalysisBottomUpDiversityAnalyzer(bool deserializing) : base(deserializing) { }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(MatchConstantValuesParameterName))
+        Parameters.Add(new ValueParameter<BoolValue>(MatchConstantValuesParameterName, "Specifies if the similarity calculator should match constant values.", new BoolValue(true)));
+      if (!Parameters.ContainsKey(MatchVariableWeightsParameterName))
+        Parameters.Add(new ValueParameter<BoolValue>(MatchVariableWeightsParameterName, "Specifies if the similarity calculator should match variable weights", new BoolValue(true)));
+    }
+
     public SymbolicDataAnalysisBottomUpDiversityAnalyzer() {
       SimilarityCalculator = new BottomUpSimilarityCalculator { SolutionVariableName = "SymbolicExpressionTree" };
+      Parameters.Add(new ValueParameter<BoolValue>(MatchConstantValuesParameterName, "Specifies if the similarity calculator should match constant values.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariableWeightsParameterName, "Specifies if the similarity calculator should match variable weights", new BoolValue(true)));
     }
   }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMaxCommonSubtreeDiversityAnalyzer.cs

@@ -25 +25 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Analyzers {
-  [Item("SymbolicDataAnalysisBottomUpDiversityAnalyzer", "A diversity analyzer based on the bottom-up similarity between trees.")]
+  [Item("SymbolicDataAnalysisMaxCommonSubtreeDiversityAnalyzer", "A diversity analyzer based on the max common subtree similarity between trees.")]
   [StorableClass]
-  public class SymbolicDataAnalysisBottomUpDiversityAnalyzer : SingleObjectivePopulationDiversityAnalyzer {
+  public class SymbolicDataAnalysisMaxCommonSubtreeDiversityAnalyzer : SingleObjectivePopulationDiversityAnalyzer {
     [StorableConstructor]
-    protected SymbolicDataAnalysisBottomUpDiversityAnalyzer(bool deserializing) : base(deserializing) { }
+    protected SymbolicDataAnalysisMaxCommonSubtreeDiversityAnalyzer(bool deserializing) : base(deserializing) { }
 
-    public SymbolicDataAnalysisBottomUpDiversityAnalyzer() {
-      SimilarityCalculator = new BottomUpSimilarityCalculator { SolutionVariableName = "SymbolicExpressionTree" };
+    public SymbolicDataAnalysisMaxCommonSubtreeDiversityAnalyzer() {
+      SimilarityCalculator = new MaxCommonSubtreeSimilarityCalculator { SolutionVariableName = "SymbolicExpressionTree" };
     }
   }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -174 +174 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzers\BuildingBlockAnalyzers\SymbolicDataAnalysisPoly10Analyzer.cs" />
+    <Compile Include="Analyzers\SymbolicDataAnalysisMaxCommonSubtreeDiversityAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisBottomUpDiversityAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisPhenotypicDiversityAnalyzer.cs" />
@@ -191 +193 @@
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionDiversityPreservingCrossover.cs" />
+    <Compile Include="Analyzers\SymbolicDataAnalysisUsefulGenesAnalyzer.cs" />
     <Compile Include="Importer\SymbolicExpressionImporter.cs" />
     <Compile Include="Importer\Token.cs" />

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SimilarityCalculators/BottomUpSimilarityCalculator.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using HeuristicLab.Common;
@@ -34 +35 @@
   public class BottomUpSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator, ISymbolicDataAnalysisExpressionSimilarityCalculator {
     private readonly HashSet<string> commutativeSymbols = new HashSet<string> { "Addition", "Multiplication", "Average", "And", "Or", "Xor" };
+    public bool MatchVariableWeights { get; set; }
+    public bool MatchConstantValues { get; set; }
 
     public BottomUpSimilarityCalculator() { }
+
+    protected BottomUpSimilarityCalculator(BottomUpSimilarityCalculator original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -47 +54 @@
       var map = ComputeBottomUpMapping(t1.Root, t2.Root);
       return 2.0 * map.Count / (t1.Length + t2.Length);
-    }
-
-    protected BottomUpSimilarityCalculator(BottomUpSimilarityCalculator original, Cloner cloner)
-      : base(original, cloner) {
     }
 
@@ -96 +99 @@
           var t = eW.Current;
 
-          if (reverseMap.ContainsKey(t)) {
-            throw new Exception("A mapping to this node already exists.");
-          }
+          Debug.Assert(!reverseMap.ContainsKey(t));
 
           forwardMap[s] = t;
@@ -125 +126 @@
       foreach (var n in nodes) {
         if (n.SubtreeCount == 0) {
-          var label = n.ToString();
+          var label = Label(n);
           if (!labelMap.ContainsKey(label)) {
             var z = new GraphNode { SymbolicExpressionTreeNode = n, Label = label };
@@ -204 +205 @@
     }
 
+    private string Label(ISymbolicExpressionTreeNode node) {
+      var constant = node as ConstantTreeNode;
+      if (constant != null && !MatchConstantValues)
+        return constant.Symbol.Name;
+      var variable = node as VariableTreeNode;
+      if (variable != null && !MatchVariableWeights) {
+        return variable.VariableName;
+      }
+      return node.ToString();
+    }
+
     private class GraphNode {
       public ISymbolicExpressionTreeNode SymbolicExpressionTreeNode;

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SimilarityCalculators/MaxCommonSubtreeSimilarityCalculator.cs

@@ -31 +31 @@
   [Item("MaxCommonSubtreeSimilarityCalculator", "A similarity calculator based on the size of the maximum common subtree between two trees")]
   public class MaxCommonSubtreeSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator, ISymbolicDataAnalysisExpressionSimilarityCalculator {
+    [Storable]
     private readonly SymbolicExpressionTreeNodeSimilarityComparer comparer;
     public bool MatchVariableNames {
@@ -88 +89 @@
     }
 
-    public static double MaxCommonSubtreeSimilarity(ISymbolicExpressionTree a, ISymbolicExpressionTree b, SymbolicExpressionTreeNodeSimilarityComparer comparer) {
+    public static double MaxCommonSubtreeSimilarity(ISymbolicExpressionTree a, ISymbolicExpressionTree b, ISymbolicExpressionTreeNodeSimilarityComparer comparer) {
+      int m = SymbolicExpressionTreeMatching.Match(a.Root, b.Root, comparer);
+      return 2.0 * m / (a.Length + b.Length);
+    }
+
+    public static double MaxCommonSubtreeSimilarityRestricted(ISymbolicExpressionTree a, ISymbolicExpressionTree b, SymbolicExpressionTreeNodeSimilarityComparer comparer) {
       int max = 0;
       var rootA = a.Root.GetSubtree(0).GetSubtree(0);
@@ -99 +105 @@
           if (lenB <= max) continue;
           int matches = SymbolicExpressionTreeMatching.Match(aa, bb, comparer);
+          //          if (max < matches)
           if (matches == lenB && max < matches)
             max = matches;