Changeset 8797 for branches/HeuristicLab.Analysis.AlgorithmBehavior

Timestamp:

10/11/12 17:17:36 (12 years ago)

Author:

ascheibe

Message:

#1886 added a comparison factor parameter to the crossover analyzer so that it can be defined what a successful crossover is

Location:

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3

Files:

• CrossoverPerformanceAnalyzer.cs (modified) (12 diffs)
• DataTableHelper.cs (modified) (3 diffs)
• DuplicateSolutionsAnalyzer.cs (modified) (1 diff)
• HeuristicLab.Analysis.AlgorithmBehavior.Analyzers-3.3.csproj (modified) (2 diffs)
• InitializableOperator.cs (added)
• MutationPerformanceAnalyzer.cs (modified) (2 diffs)
• PathRelinkerPerformanceAnalyzer.cs (modified) (1 diff)
• ScatterPlotHelper.cs (modified) (1 diff)
• WeightedParentsQualityComparer.cs (added)

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/CrossoverPerformanceAnalyzer.cs

@@ -27 +27 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -35 +34 @@
   [Item("CrossoverPerformanceAnalyzer", "An operator that analyzes the performance of crossovers.")]
   [StorableClass]
-  public class CrossoverPerformanceAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public class CrossoverPerformanceAnalyzer : InitializableOperator, IAnalyzer {
     private const string ResultsParameterName = "Results";
     private const string GenerationsParameterName = "Generations";
+    private const string SuccessfullCrossoversRowName = "Successfull Crossovers per Generation with CompFact ";
 
     #region IAnalyzer Members
@@ -46 +46 @@
 
     #region Parameter properties
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public IValueParameter<ItemCollection<DoubleValue>> ComparisonFactorParameter {
+      get { return (IValueParameter<ItemCollection<DoubleValue>>)Parameters["ComparisonFactor"]; }
+    }
     public ILookupParameter<ResultCollection> ResultsParameter {
       get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
@@ -85 +91 @@
     private int cnt = 0;
     [Storable]
-    private int success = 0;
+    private int[] success;
     [Storable]
     private int lastGeneration = 0;
@@ -98 +104 @@
       : base(original, cloner) {
       cnt = original.cnt;
-      success = original.success;
+      success = (int[])original.success.Clone();
       lastGeneration = original.lastGeneration;
       equalParents = original.equalParents;
@@ -129 +135 @@
       Parameters.Add(new ValueParameter<ISingleObjectiveSolutionSimilarityCalculator>("SimilarityCalculator"));
       Parameters.Add(new LookupParameter<ItemCollection<IItem>>("Operators", "The operators and items that the problem provides to the algorithms."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, false otherwise"));
+      Parameters.Add(new ValueParameter<ItemCollection<DoubleValue>>("ComparisonFactor", "Determines if the quality should be compared to the better parent (1.0), to the worse (0.0) or to any linearly interpolated value between them."));
+      ComparisonFactorParameter.Value.Add(new DoubleValue(0));
+      ComparisonFactorParameter.Value.Add(new DoubleValue(0.5));
+      ComparisonFactorParameter.Value.Add(new DoubleValue(1));
+
 
       plotHelper = new ScatterPlotHelper(false, true);
@@ -142 +154 @@
     }
 
-    public override IOperation Apply() {
+    protected override void InitializeAction() {
       if (SimilarityCalculatorParameter.Value == null) {
         SimilarityCalculatorParameter.Value = OperatorsParameter.ActualValue.OfType<ISingleObjectiveSolutionSimilarityCalculator>().FirstOrDefault();
+      }
+
+      if (success == null) {
+        success = new int[ComparisonFactorParameter.Value.Count];
       }
 
@@ -150 +166 @@
       childDiversityHelper.InitializePlot(Results, "Child Diversity", "Solution Index", "Diversity");
       parentDiversityHelper.InitializePlot(Results, "Parent Diversity", "Solution Index", "Diversity");
-
-      performanceHelper.InitializeChart(Results, "Average Crossover Performance", "Average Crossover Performance per Generation");
-      successHelper.InitializeChart(Results, "Successfull Crossovers", "Successfull Crossovers per Generation");
-      equalParentsHelper.InitializeChart(Results, "Number of equal parents", "Absolut number of equal parents");
+      performanceHelper.InitializeChart(Results, "Average Crossover Performance", new string[] { "Average Crossover Performance per Generation" });
+      equalParentsHelper.InitializeChart(Results, "Number of equal parents", new string[] { "Absolut number of equal parents" });
+
+      List<string> successfullCXRowNames = new List<string>();
+      foreach (var value in ComparisonFactorParameter.Value) {
+        successfullCXRowNames.Add(SuccessfullCrossoversRowName + value.Value.ToString());
+      }
+      successHelper.InitializeChart(Results, "Successfull Crossovers", successfullCXRowNames.ToArray());
+    }
+
+    public override IOperation Apply() {
+      Initialize();
 
       Point2D<double> qualityPoint, diversityPointChild, diversityPointParent;
       var qualityParent1 = ParentsQualityParameter.ActualValue.First().Value;
       var qualityParent2 = ParentsQualityParameter.ActualValue.Last().Value;
+      var qualityChild = QualityParameter.ActualValue.Value;
       var child = ChildParameter.ActualValue;
       var parent1 = ParentsParameter.ActualValue.First();
@@ -163 +188 @@
       var parentDiversity = SimilarityCalculatorParameter.Value.CalculateSolutionSimilarity(ExecutionContext.Scope.SubScopes.First(), ExecutionContext.Scope.SubScopes.Last());
       string curGenStr = GenerationsParameter.ActualValue.Value.ToString();
-
 
       diversityPointParent = new Point2D<double>(cnt, parentDiversity);
@@ -173 +197 @@
       }
 
-      qualityPoint = new Point2D<double>(cnt++, worseQuality - QualityParameter.ActualValue.Value);
-      if ((worseQuality - QualityParameter.ActualValue.Value) > 0) {
-        success++;
-      }
+      qualityPoint = new Point2D<double>(cnt++, worseQuality - qualityChild);
       qualityPoints.Add(qualityPoint.Y);
+
+      //track successfull cx
+      var compFactsArray = ComparisonFactorParameter.Value.ToArray();
+      for (int i = 0; i < compFactsArray.Length; i++) {
+        if (WeightedParentsQualityComparer.Compare(qualityChild, qualityParent1, qualityParent2, compFactsArray[i].Value, MaximizationParameter.ActualValue.Value)) {
+          success[i]++;
+        }
+      }
 
       if (parentDiversity == 1.0) {
@@ -188 +217 @@
 
           performanceHelper.AddPoint(avg);
-          successHelper.AddPoint(success);
           equalParentsHelper.AddPoint(equalParents);
+
+          for (int i = 0; i < compFactsArray.Length; i++) {
+            successHelper.AddPoint(SuccessfullCrossoversRowName + compFactsArray[i].Value.ToString(), success[i]);
+          }
 
           Reset();
@@ -206 +238 @@
     private void Reset() {
       cnt = 0;
-      success = 0;
+      success = new int[ComparisonFactorParameter.Value.Count];
       lastGeneration = GenerationsParameter.ActualValue.Value;
       qualityPoints.Clear();

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/DataTableHelper.cs

@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -35 +36 @@
     private string chartName;
     [Storable]
-    private string dataRowName;
+    private string[] dataRowNames;
     [Storable]
-    private DataRow dtRow;
+    DataTable dt;
 
     [StorableConstructor]
@@ -49 +50 @@
     }
 
-    public void InitializeChart(ResultCollection results, string chartName, string dataRowName) {
+    public void InitializeChart(ResultCollection results, string chartName, string[] dataRowNames) {
       if (!results.ContainsKey(chartName)) {
         this.resultsCol = results;
         this.chartName = chartName;
-        this.dataRowName = dataRowName;
+        this.dataRowNames = dataRowNames;
 
-        DataTable dt = new DataTable(chartName);
-        dtRow = new DataRow(dataRowName);
-        dt.Rows.Add(dtRow);
+        dt = new DataTable(chartName);
+
+        foreach (string dataRowName in dataRowNames) {
+          DataRow dtRow = new DataRow(dataRowName);
+          dt.Rows.Add(dtRow);
+        }
+
         results.Add(new Result(chartName, dt));
       }
     }
 
+    public void AddPoint(string dataRow, double point) {
+      dt.Rows[dataRow].Values.Add(point);
+    }
+
     public void AddPoint(double point) {
-      dtRow.Values.Add(point);
+      // assume that there is only 1 row and therefore the name doesn't have to be provided
+      dt.Rows[dataRowNames[0]].Values.Add(point);
     }
   }

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/DuplicateSolutionsAnalyzer.cs

@@ -87 +87 @@
         SimilarityCalculatorParameter.Value = OperatorsParameter.ActualValue.OfType<ISingleObjectiveSolutionSimilarityCalculator>().FirstOrDefault();
       }
-      chartingHelper.InitializeChart(Results, "Duplicate Solutions", "Duplicate Solutions per Generation");
+      chartingHelper.InitializeChart(Results, "Duplicate Solutions", new string[] { "Duplicate Solutions per Generation" });
 
       var similarities = SimilarityCalculatorParameter.Value.CalculateSolutionCrowdSimilarity(ExecutionContext.Scope);

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers-3.3.csproj

@@ -120 +120 @@
     <Compile Include="AfterCrossoverCombinedOperator.cs" />
     <Compile Include="AfterMutationCombinedOperator.cs" />
+    <Compile Include="InitializableOperator.cs" />
     <Compile Include="PathRelinkerPerformanceAnalyzer.cs" />
     <Compile Include="VariableRemover.cs" />
@@ -137 +138 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="VariableDuplicator.cs" />
+    <Compile Include="WeightedParentsQualityComparer.cs" />
   </ItemGroup>
   <ItemGroup>

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/MutationPerformanceAnalyzer.cs

@@ -31 +31 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.TravelingSalesman;
 
 namespace HeuristicLab.Analysis.AlgorithmBehavior.Analyzers {
@@ -145 +144 @@
         qualityPlotHelper.InitializePlot(Results, "Mutation Quality", "Solution Index", "Absolut Quality Difference");
         diversityPlotHelper.InitializePlot(Results, "Mutation Diversity", "Solution Index", "Diversity");
-        avgDataTableHelper.InitializeChart(Results, "Average Mutation Performance", "Average Mutation Performance per Generation");
+        avgDataTableHelper.InitializeChart(Results, "Average Mutation Performance", new string[] { "Average Mutation Performance per Generation" });
 
         Scope permutationBeforeScope = new Scope();

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/PathRelinkerPerformanceAnalyzer.cs

@@ -164 +164 @@
       parentDiversityHelper.InitializePlot(Results, "Parent Diversity", "Solution Index", "Diversity");
 
-      performanceHelper.InitializeChart(Results, "Average Crossover Performance", "Average Crossover Performance per Generation");
-      successHelper.InitializeChart(Results, "Successfull Crossovers", "Successfull Crossovers per Generation");
-      equalParentsHelper.InitializeChart(Results, "Number of equal parents", "Absolut number of equal parents");
+      performanceHelper.InitializeChart(Results, "Average Crossover Performance", new string[] { "Average Crossover Performance per Generation" });
+      successHelper.InitializeChart(Results, "Successfull Crossovers", new string[] { "Successfull Crossovers per Generation" });
+      equalParentsHelper.InitializeChart(Results, "Number of equal parents", new string[] { "Absolut number of equal parents" });
 
       Point2D<double> qualityPoint, diversityPointChild, diversityPointParent;

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/ScatterPlotHelper.cs

@@ -85 +85 @@
           dataTableHelper = new DataTableHelper();
         }
-        dataTableHelper.InitializeChart(results, chartName + " Chart", yAxisTitle);
+        dataTableHelper.InitializeChart(results, chartName + " Chart", new string[] { yAxisTitle });
       }