Changeset 12231 for branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking

Timestamp:

03/20/15 18:20:59 (10 years ago)

Author:

bburlacu

Message:

#1772: Changed the way node highlighting is performed (taking into account sampling count relative to current generation). Made NodeWeight field storable in the SymbolicExpressionTreeNode. Updated the statistics counting in the TraceCalculator.

Location:

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

Files:

• Analyzers/SymbolicDataAnalysisSubtreeSampleCountAnalyzer.cs (copied) (copied from branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/Analyzers/SymbolicDataAnalysisTraceOverlapAnalyzer.cs) (3 diffs)
• TraceCalculator.cs (modified) (1 diff)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/Analyzers/SymbolicDataAnalysisSubtreeSampleCountAnalyzer.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Linq;
-using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28 +26 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.EvolutionTracking;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tracking.Analyzers {
-  [Item("SymbolicDataAnalysisTraceOverlapAnalyzer", "An analyzer for trace graph overlap.")]
+  [Item("SymbolicDataAnalysisSubtreeSampleCountAnalyzer", "An analyzer for trace graph overlap.")]
   [StorableClass]
-  public class SymbolicDataAnalysisTraceOverlapAnalyzer : EvolutionTrackingAnalyzer<ISymbolicExpressionTree> {
-    private const string PercentageOfBestSolutionsParameterName = "PercentageOfBestSolutions";
+  public class SymbolicDataAnalysisSubtreeSampleCountAnalyzer : EvolutionTrackingAnalyzer<ISymbolicExpressionTree> {
+    private const string CacheTraceNodesParameterName = "CacheTraceNodes";
+    private readonly TraceCalculator traceCalculator = new TraceCalculator { UpdateVertexWeights = true, UpdateSubtreeWeights = true, CacheTraceNodes = true };
 
     #region parameters
-    public IFixedValueParameter<DoubleValue> PercentageOfBestSolutionsParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[PercentageOfBestSolutionsParameterName]; }
+    public IFixedValueParameter<BoolValue> CacheTraceNodesParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[CacheTraceNodesParameterName]; }
     }
     #endregion
 
-    public SymbolicDataAnalysisTraceOverlapAnalyzer() {
-      UpdateCounterParameter.ActualName = "TraceOverlapAnalyzerUpdateCounter";
-      Parameters.Add(new FixedValueParameter<DoubleValue>(PercentageOfBestSolutionsParameterName, new DoubleValue(1.0)));
+    #region parameter properties
+    public bool CacheTraceNodes {
+      get { return CacheTraceNodesParameter.Value.Value; }
+      set { CacheTraceNodesParameter.Value.Value = value; }
+    }
+    #endregion
+
+    public SymbolicDataAnalysisSubtreeSampleCountAnalyzer() {
+      UpdateCounterParameter.ActualName = "SubtreeSampleCountAnalyzerUpdateCounter";
+
+      Parameters.Add(new FixedValueParameter<BoolValue>(CacheTraceNodesParameterName, new BoolValue(true)));
     }
 
-    private SymbolicDataAnalysisTraceOverlapAnalyzer(SymbolicDataAnalysisTraceOverlapAnalyzer original, Cloner cloner)
+    private SymbolicDataAnalysisSubtreeSampleCountAnalyzer(SymbolicDataAnalysisSubtreeSampleCountAnalyzer original, Cloner cloner)
       : base(original, cloner) {
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicDataAnalysisTraceOverlapAnalyzer(this, cloner);
+      return new SymbolicDataAnalysisSubtreeSampleCountAnalyzer(this, cloner);
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      traceCalculator.ResetState();
+    }
+
+    public override void InitializeState() {
+      traceCalculator.ResetState();
     }
 
     [StorableConstructor]
-    private SymbolicDataAnalysisTraceOverlapAnalyzer(bool deserializing) : base(deserializing) { }
+    private SymbolicDataAnalysisSubtreeSampleCountAnalyzer(bool deserializing) : base(deserializing) { }
 
     public override IOperation Apply() {
@@ -79 +94 @@
         return base.Apply();
 
-      var bestSolutionsPercentage = PercentageOfBestSolutionsParameter.Value.Value;
-      int n = (int)Math.Round(bestSolutionsPercentage * PopulationSize.Value);
-      double avgTraceOverlap = 0;
+      traceCalculator.CacheTraceNodes = CacheTraceNodes;
+      if (Generation.Value > 0) {
+        var rank = PopulationGraph.GetByRank(Generation.Value).Cast<IGenealogyGraphNode<ISymbolicExpressionTree>>().ToList();
+        foreach (var n in rank)
+          traceCalculator.Trace(n, 2, false); // during this call weights will be updated
 
-      if (Generation.Value > 0) {
-        var nodes = PopulationGraph.GetByRank(Generation.Value).Cast<IGenealogyGraphNode<ISymbolicExpressionTree>>().OrderByDescending(x => x.Quality).Take(n);
-        avgTraceOverlap = nodes.Average(x => TraceCalculator.TraceSubtree(x, 2).Vertices.Count());
-      }
-
-      DataTable table;
-      if (!Results.ContainsKey("AverageTraceOverlap")) {
-        table = new DataTable("Average trace overlap");
-        var row = new DataRow("Average trace overlap") { VisualProperties = { StartIndexZero = true } };
-        row.Values.Add(avgTraceOverlap);
-        table.Rows.Add(row);
-        Results.Add(new Result("AverageTraceOverlap", table));
-      } else {
-        table = (DataTable)Results["AverageTraceOverlap"].Value;
-        table.Rows["Average trace overlap"].Values.Add(avgTraceOverlap);
+        foreach (var v in traceCalculator.TraceGraph.Vertices) {
+          var g = PopulationGraph.GetByContent(v.Data);
+          g.Weight = v.Weight;
+        }
       }
       return base.Apply();

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/TraceCalculator.cs

@@ -160 +160 @@
               if (UpdateSubtreeWeights) {
                 var arcs = (List<IArc>)((IVertex)n).InArcs; // at this moment n will have been added as a child to the next trace node
+
+                // TODO: try to simplify the code below
                 for (int i = 0; i < arcs.Count; ++i) {
                   var td = (TraceData)((IArc<IDeepCloneable>)arcs[i]).Data;
                   var p = (IGenealogyGraphNode<ISymbolicExpressionTree>)arcs[i].Source;
-                  // TODO: the first part of the check below represents a necessary but not sufficient condition
-                  // TODO: therefore, a Difference check is also performed, it would be nice to make this code more ellegant
-                  if (td.LastFragmentIndex == td.SubtreeIndex && fragment.Root.Difference(NodeAt(p.Data, td.SubtreeIndex)) == null) {
-                    arcs[i].Weight++;
+                  var s = NodeAt(p.Data, td.SubtreeIndex);
+                  if (td.LastFragmentIndex == td.SubtreeIndex && fragment.Root.Difference(s) == null) {
+                    foreach (var ss in s.IterateNodesPrefix()) ss.NodeWeight++; // the node weight will represent the total sample count for a given node
+                    arcs[i].Weight++; // the arc weights (since there are multiple arcs) will sum up to the same count but give more detail
                     break;
                   }