Changeset 15289 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs

Timestamp:

07/26/17 19:34:13 (7 years ago)

Author:

pkimmesw

Message:

#2665 Fixed analyzer, fixed Plush encoding + operators, adpated print evaluation according to McPhee

Location:

branches/PushGP/HeuristicLab.PushGP

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs (modified) (8 diffs)

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs

@@ -20 +20 @@
     private const string RESULTS_PARAMETER_NAME = "Results";
     private const string INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME = "ZeroErrorIndividualsPerCaseDistribution";
+    private const string INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME = "ZeroErrorIndividualsPerCaseDistributionHistory";
 
+    private const string HISTORY_TABLE_NAME = "Individual Zero Error Distribution History";
     private const string RESULT_PARAMETER_NAME = "Zero Error Individual Per Case Distribution";
     private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
     private const string Y_AXIS_TITLE = "Number of zero error cases";
-    private const string X_AXIS_TITLE = "Number of individuals";
+    private const string X_AXIS_TITLE = "Individuals Nr";
     private const string ROW_NAME = "Cases";
 
@@ -31 +33 @@
         INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME,
         "The data table to store the count of individuals with zero error."));
+
+      Parameters.Add(new ValueLookupParameter<DataTableHistory>(
+        INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME,
+        "The data table to store the history."));
 
       Parameters.Add(new LookupParameter<ResultCollection>(
@@ -39 +45 @@
        IntegerVectorPushProblem.CaseQualitiesScopeParameterName,
        "The quality of every single training case for each individual."));
+
+      Parameters.Add(new ValueParameter<BoolValue>(
+        "StoreHistory",
+        "True if the history of the analysis should be stored.",
+        new BoolValue(false)));
+
+      Parameters.Add(new ValueParameter<IntValue>(
+        "UpdateInterval",
+        "The interval in which the analysis should be applied.",
+        new IntValue(1)));
+
+      Parameters.Add(new ValueParameter<IntValue>(
+        "UpdateCounter",
+        "The value which counts how many times the operator was called since the last update.",
+        new IntValue(0)));
+
+      IndividualZeroErrorDistributionParameter.Hidden = true;
+      IndividualZeroErrorDistributionHistoryParameter.Hidden = true;
+      ResultsParameter.Hidden = true;
+      UpdateCounterParameter.Hidden = true;
     }
 
-    [StorableConstructorAttribute]
+    [StorableConstructor]
     public IndividualZeroErrorDistributionAnalyzer(bool deserializing) : base(deserializing) { }
 
@@ -52 +78 @@
     public bool EnabledByDefault { get { return true; } }
 
+    public ValueParameter<BoolValue> StoreHistoryParameter
+    {
+      get { return (ValueParameter<BoolValue>)Parameters["StoreHistory"]; }
+    }
+    public ValueParameter<IntValue> UpdateIntervalParameter
+    {
+      get { return (ValueParameter<IntValue>)Parameters["UpdateInterval"]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter
+    {
+      get { return (ValueParameter<IntValue>)Parameters["UpdateCounter"]; }
+    }
+
     public ILookupParameter<DataTable> IndividualZeroErrorDistributionParameter
     {
       get { return (ILookupParameter<DataTable>)Parameters[INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME]; }
+    }
+
+    public ValueLookupParameter<DataTableHistory> IndividualZeroErrorDistributionHistoryParameter
+    {
+      get { return (ValueLookupParameter<DataTableHistory>)Parameters[INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME]; }
     }
 
@@ -68 +112 @@
 
     public override IOperation Apply() {
+      UpdateCounterParameter.Value.Value++;
+      // the analyzer runs periodically, every 'updateInterval' times
+      if (UpdateCounterParameter.Value.Value != UpdateIntervalParameter.Value.Value)
+        return base.Apply();
+
+      UpdateCounterParameter.Value.Value = 0; // reset counter
+
       var caseQualitiesPerIndividual = CaseQualitiesParameter.ActualValue;
       var individualCount = caseQualitiesPerIndividual.Length;
@@ -82 +133 @@
             YAxisTitle = Y_AXIS_TITLE,
             XAxisTitle = X_AXIS_TITLE,
-            XAxisMinimumFixedValue = 0,
-            XAxisMaximumAuto = true,
+            YAxisMaximumFixedValue = 1,
+            YAxisMinimumFixedValue = 0,
+            YAxisMaximumAuto = false,
+            YAxisMinimumAuto = false,
+            XAxisMinimumFixedValue = 1,
+            XAxisMaximumFixedValue = individualCount,
+            XAxisMaximumAuto = false,
             XAxisMinimumAuto = false,
           }
@@ -101 +157 @@
               StartIndexZero = true,
               IsVisibleInLegend = false,
-              ChartType = DataRowVisualProperties.DataRowChartType.Histogram,
+              ChartType = DataRowVisualProperties.DataRowChartType.Columns,
             }
         };
@@ -108 +164 @@
       }
 
-      var caseCountChanged = row.Values.Count != caseCount;
+      row.Values.Clear();
 
-      if (caseCountChanged) {
-        row.Values.Clear();
+      for (var i = 0; i < caseQualitiesPerIndividual.Length; i++) {
+        var count = caseQualitiesPerIndividual[i].Count(q => q == 0.0);
+        var ratio = count / (double)caseCount;
+
+        row.Values.Add(ratio);
       }
 
-      // key represents the number of cases with zero error
-      // value represents the number of individuals with key cases with zero error
-      var distribution = caseQualitiesPerIndividual
-              .Select(individual => individual.Count(x => x == 0.0))
-              .GroupBy(x => x)
-              .ToDictionary(x => x.Key, x => x.Count());
+      var storeHistory = StoreHistoryParameter.Value.Value;
 
-      for (var i = 0; i < caseCount; i++) {
-        int count;
-        distribution.TryGetValue(i, out count);
-        var x = count / (double)individualCount;
+      if (storeHistory) {
+        var history = IndividualZeroErrorDistributionHistoryParameter.ActualValue;
 
-        if (caseCountChanged)
-          row.Values.Add(x);
-        else
-          row.Values[i] = x;
+        if (history == null) {
+          history = new DataTableHistory();
+          IndividualZeroErrorDistributionHistoryParameter.ActualValue = history;
+        }
+
+        history.Add((DataTable)individualZeroErrorDistribution.Clone());
+
+        if (!results.ContainsKey(HISTORY_TABLE_NAME)) {
+          results.Add(new Result(HISTORY_TABLE_NAME, history));
+        } else {
+          results[HISTORY_TABLE_NAME].Value = history;
+        }
       }