Changeset 9238 for branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreePopulationDiversityAnalyzer.cs

Timestamp:

02/21/13 16:02:47 (11 years ago)

Author:

bburlacu

Message:

#1772: Added base class for the fragment analyzers. Improved analyzers, added SymbolicExpressionTreeRelativeFragmentDepthAnalyzer. Added LineageExplorer.

File:

• branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreePopulationDiversityAnalyzer.cs (modified) (7 diffs)

branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreePopulationDiversityAnalyzer.cs

@@ -30 +30 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
 
 // type definitions for ease of use
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
 
 namespace HeuristicLab.EvolutionaryTracking {
@@ -46 +47 @@
     private const string UpdateCounterParameterName = "UpdateCounter";
     private const string ResultsParameterName = "Results";
-    #endregion
-
-    #region Parameter properties
+    private const string GenerationsParameterName = "Generations";
+    private const string StoreHistoryParameterName = "StoreHistory";
+    // comparer parameters
+    private const string MatchVariablesParameterName = "MatchVariableNames";
+    private const string MatchVariableWeightsParameterName = "MatchVariableWeights";
+    private const string MatchConstantValuesParameterName = "MatchConstantValues";
+    private const string SortSubtreesParameterName = "SortSubtrees";
+    // population graph
+    private const string PopulationGraphParameterName = "PopulationGraph";
+    // clone map
+    private const string GlobalCloneMapParameterName = "GlobalCloneMap";
+    #endregion
+
+    #region Parameters
     public ValueParameter<IntValue> UpdateIntervalParameter {
       get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
@@ -58 +70 @@
       get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
     }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    public ValueParameter<BoolValue> StoreHistoryParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[StoreHistoryParameterName]; }
+    }
     public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
       get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
     }
-    #endregion
-
-    #region Parameters
+    public ValueParameter<BoolValue> MatchVariableNamesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariablesParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableWeightsParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariableWeightsParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchConstantValuesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchConstantValuesParameterName]; }
+    }
+    public ValueParameter<BoolValue> SortSubtreesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[SortSubtreesParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalCloneMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalCloneMapParameterName]; }
+    }
+    #endregion
+
+    #region Parameter properties
     public IntValue UpdateInterval {
       get { return UpdateIntervalParameter.Value; }
@@ -72 +105 @@
     public ResultCollection Results {
       get { return ResultsParameter.ActualValue; }
+    }
+    public CloneMapType GlobalCloneMap {
+      get { return GlobalCloneMapParameter.ActualValue; }
+    }
+    public IntValue Generations {
+      get { return GenerationsParameter.ActualValue; }
+    }
+    public BoolValue StoreHistory {
+      get { return StoreHistoryParameter.Value; }
     }
     #endregion
@@ -87 +129 @@
       Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
       Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
-
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariablesParameterName, "Specify if the symbolic expression tree comparer should match variable names."));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariableWeightsParameterName, "Specify if the symbolic expression tree comparer should match variable weights."));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchConstantValuesParameterName, "Specify if the symbolic expression tree comparer should match constant values."));
+      Parameters.Add(new ValueParameter<BoolValue>(SortSubtreesParameterName, "Specifies whether the subtrees of a tree should be sorted before comparison."));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalCloneMapParameterName, "A global map keeping track of trees and their clones (made during selection)."));
+      Parameters.Add(new ValueParameter<BoolValue>(StoreHistoryParameterName, "True if the tree lengths history of the population should be stored.", new BoolValue(false)));
       UpdateCounterParameter.Hidden = true;
       UpdateIntervalParameter.Hidden = true;
@@ -106 +154 @@
     #endregion
 
+    public bool EnabledByDefault { get { return true; } }
+
     public override IOperation Apply() {
       UpdateCounter.Value++;
@@ -113 +163 @@
 
         var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
-        var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
-        foreach (var t in trees) canonicalSorter.SortSubtrees(t);
-
-        var comparer = new SymbolicExpressionTreeNodeSimilarityComparer { MatchConstantValues = false, MatchVariableNames = false, MatchVariableWeights = false };
-
-        var distinct = 1.0 - trees.Select(x => x.Root).Distinct(comparer).Count() / (double)trees.Count;
-
-        var results = ResultsParameter.ActualValue;
-
-        if (!results.ContainsKey("PopulationDiversity"))
-          results.Add(new Result("PopulationDiversity", new DataTable("PopulationDiversity") { VisualProperties = { YAxisTitle = "Count" } }));
-        var populationDiversityTable = results["PopulationDiversity"].Value as DataTable;
-
-        if (populationDiversityTable == null) return base.Apply(); // should never happen
-
+        if (SortSubtreesParameter.Value.Value) {
+          var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
+          foreach (var t in trees) canonicalSorter.SortSubtrees(t);
+        }
+
+        bool matchConstants = MatchConstantValuesParameter.Value.Value;
+        bool matchVarNames = MatchVariableNamesParameter.Value.Value;
+        bool matchVarWeights = MatchVariableWeightsParameter.Value.Value;
+
+        var comparer = new SymbolicExpressionTreeEqualityComparer {
+          SimilarityComparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+            MatchConstantValues = matchConstants, MatchVariableNames = matchVarNames, MatchVariableWeights = matchVarWeights
+          }
+        };
+        ResultCollection results = ResultsParameter.ActualValue;
+        // population diversity
+        DataTable populationDiversityTable;
+        if (!results.ContainsKey("PopulationDiversity")) {
+          populationDiversityTable = new DataTable("PopulationDiversity") { VisualProperties = { YAxisTitle = "Diversity" } };
+          results.Add(new Result("PopulationDiversity", populationDiversityTable));
+        }
+        populationDiversityTable = (DataTable)results["PopulationDiversity"].Value;
         if (!populationDiversityTable.Rows.ContainsKey("Diversity"))
           populationDiversityTable.Rows.Add(new DataRow("Diversity") { VisualProperties = { StartIndexZero = true } });
-
+        double distinct = trees.Distinct(comparer).Count() / (double)trees.Count;
         populationDiversityTable.Rows["Diversity"].Values.Add(distinct);
+        // selection diversity
+        if (GlobalCloneMap == null) return base.Apply();
+
+        DataTable relativeSelectionCountsTable;
+        if (!results.ContainsKey("SelectedIndividuals")) {
+          relativeSelectionCountsTable = new DataTable("SelectedIndividuals") { VisualProperties = { YAxisTitle = "% Selected Individuals" } };
+          results.Add(new Result("SelectedIndividuals", relativeSelectionCountsTable));
+        }
+        relativeSelectionCountsTable = (DataTable)Results["SelectedIndividuals"].Value;
+        if (!relativeSelectionCountsTable.Rows.ContainsKey("SelectedIndividuals")) {
+          relativeSelectionCountsTable.Rows.Add(new DataRow("SelectedIndividuals") { VisualProperties = { StartIndexZero = true } });
+        }
+        double relativeSelectionCount = GlobalCloneMap.Values.Distinct().Count() / (double)trees.Count;
+        relativeSelectionCountsTable.Rows["SelectedIndividuals"].Values.Add(relativeSelectionCount);
+
+        // do a histogram of selection frequency for each individual in the population
+        DataTable selectionFrequenciesTable;
+        if (!results.ContainsKey("SelectionFrequencies")) {
+          selectionFrequenciesTable = new DataTable("Selection Frequencies") { VisualProperties = { YAxisTitle = "Selection Count" } };
+          results.Add(new Result("SelectionFrequencies", selectionFrequenciesTable));
+        }
+        selectionFrequenciesTable = (DataTable)results["SelectionFrequencies"].Value;
+        DataRow histoRow;
+        if (!selectionFrequenciesTable.Rows.ContainsKey("SelectionFrequencies")) {
+          histoRow = new DataRow("SelectionFrequencies") { VisualProperties = { StartIndexZero = true } };
+          selectionFrequenciesTable.Rows.Add(histoRow);
+        }
+        histoRow = selectionFrequenciesTable.Rows["SelectionFrequencies"];
+        var frequencies = new double[trees.Count];
+
+        var graph = (SymbolicExpressionTreeGenealogyGraph)results[PopulationGraphParameterName].Value;
+        // get graph nodes corresponding to individuals of the previous generation
+        var prevGen = graph.Nodes.Where(node => node.Rank == Generations.Value - 1).OrderByDescending(n => n.Quality).ToList();
+        for (int i = 0; i != prevGen.Count; ++i) {
+          int selFreq = GlobalCloneMap.Values.Count(t => t == prevGen[i].SymbolicExpressionTree);
+          frequencies[i] = selFreq;
+        }
+        histoRow.Values.Replace(frequencies);
+
+        bool storeHistory = StoreHistory.Value;
+        if (storeHistory) {
+          DataTableHistory selectionFrequenciesHistory;
+          if (!results.ContainsKey("SelectionFrequenciesHistory")) {
+            selectionFrequenciesHistory = new DataTableHistory();
+            results.Add(new Result("SelectionFrequenciesHistory", selectionFrequenciesHistory));
+          }
+          selectionFrequenciesHistory = (DataTableHistory)results["SelectionFrequenciesHistory"].Value;
+          selectionFrequenciesHistory.Add((DataTable)selectionFrequenciesTable.Clone());
+        }
       }
       return base.Apply();
     }
-
-    public bool EnabledByDefault { get { return true; } }
   }
 }