Changeset 12891 for branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs

Timestamp:

08/22/15 14:27:37 (9 years ago)

Author:

bburlacu

Message:

#1772: Merge trunk changes. Remove dead code from the genealogy analyzer.

File:

• branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs (modified) (11 diffs)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs

@@ -18 +18 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
-#endregion
+#endregion License Information
 
 using System.Collections.Generic;
@@ -35 +35 @@
   [Item("GenealogyAnalyzer", "An analyzer which performs the necessary instrumentation to record the evolution of a genetic algorithm.")]
   public class GenealogyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer
-  where T : class,IItem {
+  where T : class, IItem {
     #region parameter names
     private const string GenerationsParameterName = "Generations";
@@ -56 +56 @@
     private const string EnableManipulatorTrackingParameterName = "EnableManipulatorTracking";
     private const string EnableSolutionCreatorTrackingParameterName = "EnableSolutionCreatorTracking"; // should always be enabled. maybe superfluous
-    #endregion
+    #endregion parameter names
 
     #region parameter properties
@@ -62 +62 @@
       get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
     }
+
     public IScopeTreeLookupParameter<T> PopulationParameter {
       get { return (IScopeTreeLookupParameter<T>)Parameters[PopulationParameterName]; }
     }
+
     public IValueParameter<ICrossoverOperator<T>> BeforeCrossoverOperatorParameter {
       get { return (IValueParameter<ICrossoverOperator<T>>)Parameters[BeforeCrossoverOperatorParameterName]; }
     }
+
     public IValueParameter<ICrossoverOperator<T>> AfterCrossoverOperatorParameter {
       get { return (IValueParameter<ICrossoverOperator<T>>)Parameters[AfterCrossoverOperatorParameterName]; }
     }
+
     public IValueParameter<IManipulatorOperator<T>> BeforeManipulatorOperatorParameter {
       get { return (IValueParameter<IManipulatorOperator<T>>)Parameters[BeforeManipulatorOperatorParameterName]; }
     }
+
     public IValueParameter<IManipulatorOperator<T>> AfterManipulatorOperatorParameter {
       get { return (IValueParameter<IManipulatorOperator<T>>)Parameters[AfterManipulatorOperatorParameterName]; }
     }
+
     public ILookupParameter<ResultCollection> ResultsParameter {
       get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
     }
+
     public ILookupParameter<IntValue> GenerationsParameter {
       get { return (ILookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
     }
+
     public IValueParameter<BoolValue> EnableCrossoverTrackingParameter {
       get { return (IValueParameter<BoolValue>)Parameters[EnableCrossoverTrackingParameterName]; }
     }
+
     public IValueParameter<BoolValue> EnableManipulatorTrackingParameter {
       get { return (IValueParameter<BoolValue>)Parameters[EnableManipulatorTrackingParameterName]; }
     }
+
     public IValueParameter<BoolValue> EnableSolutionCreatorTrackingParameter {
       get { return (IValueParameter<BoolValue>)Parameters[EnableSolutionCreatorTrackingParameterName]; }
     }
+
     public ILookupParameter<ICrossover> CrossoverParameter {
       get { return (ILookupParameter<ICrossover>)Parameters[CrossoverParameterName]; }
     }
+
     public ILookupParameter<IManipulator> ManipulatorParameter {
       get { return (ILookupParameter<IManipulator>)Parameters[ManipulatorParameterName]; }
@@ -102 +114 @@
       get { return (ILookupParameter<ISolutionCreator>)Parameters[SolutionCreatorParameterName]; }
     }
-    #endregion
+    #endregion parameter properties
 
     #region properties
@@ -108 +120 @@
       get { return BeforeCrossoverOperatorParameter.Value; }
     }
+
     public ICrossoverOperator<T> AfterCrossoverOperator {
       get { return AfterCrossoverOperatorParameter.Value; }
     }
+
     public IManipulatorOperator<T> BeforeManipulatorOperator {
       get { return BeforeManipulatorOperatorParameter.Value; }
     }
+
     public IManipulatorOperator<T> AfterManipulatorOperator {
       get { return AfterManipulatorOperatorParameter.Value; }
     }
+
     public BoolValue EnableCrossoverTracking {
       get { return EnableCrossoverTrackingParameter.Value; }
     }
+
     public BoolValue EnableManipulatorTracking {
       get { return EnableManipulatorTrackingParameter.Value; }
     }
+
     public BoolValue EnableSolutionCreatorTracking {
       get { return EnableSolutionCreatorTrackingParameter.Value; }
     }
-    #endregion
+    #endregion properties
 
     public GenealogyAnalyzer() {
@@ -147 +165 @@
       Parameters.Add(new ValueParameter<IManipulatorOperator<T>>(BeforeManipulatorOperatorParameterName));
       Parameters.Add(new ValueParameter<IManipulatorOperator<T>>(AfterManipulatorOperatorParameterName));
-      #endregion
-    }
+      #endregion add parameters
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new GenealogyAnalyzer<T>(this, cloner);
     }
+
     protected GenealogyAnalyzer(GenealogyAnalyzer<T> original, Cloner cloner)
       : base(original, cloner) {
@@ -276 +296 @@
           ExecutionContext.Scope.SubScopes[index].Variables["Id"].Value = new StringValue(v.Id);
         }
-        #endregion
-
-        //        ComputeSuccessRatios(genealogyGraph);
+        #endregion add elite in the graph and connect it with the previous elite
       }
       // update qualities
@@ -285 +303 @@
         vertex.Quality = qualities[i].Value;
       }
-
       // remove extra graph nodes (added by the instrumented operators in the case of offspring selection)
       var pop = new HashSet<T>(population);
@@ -294 +311 @@
           var p = v.Parents.First();
           if (p.Rank.Equals(generation - 0.5))
-            // the individual was a product of mutation. since it wasn't selected, we must remove both it and its parent 
+            // the individual was a product of mutation. since it wasn't selected, we must remove both it and its parent
             // ("intermediate" vertex result of crossover)
             discarded.Add(v.Parents.First());
@@ -303 +320 @@
       return base.Apply();
     }
-
-    // for accurate statistics this method should be called before the discarded offspring are removed from the genealogy graph
-    private void ComputeSuccessRatios(IGenealogyGraph<T> genealogyGraph) {
-      const string successfulOffspringRatioTableHistoryName = "Successful offspring ratios history";
-      const string successfulOffspringAbsoluteValuesTableHistoryName = "Successful offspring values history";
-      const string successfulOffspringRatioHeatMapName = "Successful offspring ratios heatmap";
-      const string successfulOffspringValuesHeatMapName = "Successful offspring values heatmap";
-
-      var population = PopulationParameter.ActualValue;
-      var generation = GenerationsParameter.ActualValue.Value;
-      // compute the weight of each genealogy graph node as the ratio (produced offspring) / (surviving offspring)
-      foreach (var ind in population) {
-        var v = genealogyGraph.GetByContent(ind);
-        if (v.Parents.Count() == 1) {
-          var p = v.Parents.First();
-          foreach (var pp in p.Parents)
-            pp.Weight++;
-        } else {
-          foreach (var p in v.Parents) {
-            p.Weight++;
-          }
-        }
-      }
-
-      var results = ResultsParameter.ActualValue;
-
-      DataTableHistory successfulOffspringRatioHistory;
-      DataTableHistory successfulOffspringAbsoluteHistory;
-      if (!results.ContainsKey(successfulOffspringRatioTableHistoryName)) {
-        successfulOffspringRatioHistory = new DataTableHistory();
-        successfulOffspringAbsoluteHistory = new DataTableHistory();
-        results.Add(new Result(successfulOffspringRatioTableHistoryName, successfulOffspringRatioHistory));
-        results.Add(new Result(successfulOffspringAbsoluteValuesTableHistoryName, successfulOffspringAbsoluteHistory));
-      } else {
-        successfulOffspringRatioHistory = (DataTableHistory)results[successfulOffspringRatioTableHistoryName].Value;
-        successfulOffspringAbsoluteHistory = (DataTableHistory)results[successfulOffspringAbsoluteValuesTableHistoryName].Value;
-      }
-      var successfulOffspringRatioTable = new DataTable();
-      var successfulOffspringRatioRow = new DataRow("Successful Offspring Ratio") {
-        VisualProperties = { ChartType = DataRowVisualProperties.DataRowChartType.Columns, StartIndexZero = true }
-      };
-      successfulOffspringRatioRow.Values.Replace(genealogyGraph.GetByRank(generation).OrderByDescending(x => x.Quality).Select(x => x.OutDegree > 0 ? x.Weight / x.OutDegree : 0));
-      successfulOffspringRatioTable.Rows.Add(successfulOffspringRatioRow);
-      successfulOffspringRatioHistory.Add(successfulOffspringRatioTable);
-      // create heatmap
-      double[,] ratios = new double[population.Length, successfulOffspringRatioHistory.Count];
-      var ratiosHistoryList = successfulOffspringRatioHistory.AsReadOnly().ToList();
-      for (int i = 0; i < ratiosHistoryList.Count; ++i) {
-        var values = ratiosHistoryList[i].Rows.First().Values;
-        for (int j = 0; j < values.Count; ++j) {
-          ratios[j, i] = values[j];
-        }
-      }
-      var successfulOffspringRatios = new HeatMap(ratios);
-      if (!results.ContainsKey(successfulOffspringRatioHeatMapName)) {
-        results.Add(new Result(successfulOffspringRatioHeatMapName, successfulOffspringRatios));
-      } else {
-        results[successfulOffspringRatioHeatMapName].Value = successfulOffspringRatios;
-      }
-
-      var successfulOffspringValuesTable = new DataTable();
-      var successfulOffspringValuesRow = new DataRow("Successful Offspring Values") {
-        VisualProperties = { ChartType = DataRowVisualProperties.DataRowChartType.Columns, StartIndexZero = true }
-      };
-      successfulOffspringValuesRow.Values.Replace(genealogyGraph.GetByRank(generation).OrderByDescending(x => x.Quality).Select(x => x.Weight));
-      successfulOffspringValuesTable.Rows.Add(successfulOffspringValuesRow);
-      successfulOffspringAbsoluteHistory.Add(successfulOffspringValuesTable);
-      // create heatmap
-      double min = 0, max = 0;
-      double[,] elements = new double[population.Length, successfulOffspringAbsoluteHistory.Count];
-      var absoluteHistoryList = successfulOffspringAbsoluteHistory.AsReadOnly().ToList();
-      for (int i = 0; i < absoluteHistoryList.Count; ++i) {
-        var values = absoluteHistoryList[i].Rows.First().Values;
-        for (int j = 0; j < values.Count; ++j) {
-          elements[j, i] = values[j];
-          if (max < values[j])
-            max = values[j];
-          if (min > values[j])
-            min = values[j];
-        }
-      }
-      var heatmap = new HeatMap(elements);
-      heatmap.Maximum = max;
-      heatmap.Minimum = min;
-      if (!results.ContainsKey(successfulOffspringValuesHeatMapName)) {
-        results.Add(new Result(successfulOffspringValuesHeatMapName, heatmap));
-      } else {
-        results[successfulOffspringValuesHeatMapName].Value = heatmap;
-      }
-    }
   }
 }