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

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/IndividualZeroErrorAnalyzer.cs (modified) (10 diffs)
• HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs (modified) (8 diffs)
• HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs (modified) (8 diffs)

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

@@ -19 +19 @@
     private const string RESULTS_PARAMETER_NAME = "Results";
     private const string INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME = "ZeroErrorIndividualsPerCase";
+    private const string INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME = INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME + "History";
 
     private const string RESULT_PARAMETER_NAME = "Zero Error Individuals Per Case";
     private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
     private const string Y_AXIS_TITLE = "Count of zero error individuals";
-    private const string X_AXIS_TITLE = "Case Index";
+    private const string X_AXIS_TITLE = "Case Nr";
     private const string ROW_NAME = "Cases";
+    private const string HISTORY_TABLE_NAME = "Individual Zero Error history";
 
     public IndividualZeroErrorAnalyzer() {
@@ -31 +33 @@
         "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>(
         RESULTS_PARAMETER_NAME,
@@ -38 +44 @@
        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)));
+
+      IndividualZeroErrorParameter.Hidden = true;
+      IndividualZeroErrorHistoryParameter.Hidden = true;
+      ResultsParameter.Hidden = true;
+      UpdateCounterParameter.Hidden = true;
     }
 
@@ -51 +77 @@
     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> IndividualZeroErrorParameter
     {
@@ -56 +95 @@
     }
 
+    public ValueLookupParameter<DataTableHistory> IndividualZeroErrorHistoryParameter
+    {
+      get { return (ValueLookupParameter<DataTableHistory>)Parameters[INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME]; }
+    }
+
     public ILookupParameter<ResultCollection> ResultsParameter
     {
@@ -67 +111 @@
 
     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 caseCount = caseQualitiesPerIndividual[0].Length;
@@ -80 +131 @@
             YAxisTitle = Y_AXIS_TITLE,
             XAxisTitle = X_AXIS_TITLE,
-            XAxisMinimumFixedValue = 0,
+            YAxisMinimumFixedValue = 0,
+            YAxisMaximumFixedValue = 1,
+            YAxisMinimumAuto = false,
+            SecondYAxisMaximumAuto = false,
+            XAxisMinimumFixedValue = 1,
             XAxisMaximumFixedValue = caseCount,
             XAxisMaximumAuto = false,
@@ -100 +155 @@
               StartIndexZero = true,
               IsVisibleInLegend = false,
-              ChartType = DataRowVisualProperties.DataRowChartType.Bars,
+              ChartType = DataRowVisualProperties.DataRowChartType.Columns,
             }
         };
@@ -107 +162 @@
       }
 
-      var caseCountChanged = row.Values.Count != caseCount;
-
-      if (caseCountChanged) {
-        individualZeroErrorCounts.VisualProperties.XAxisMaximumFixedValue = caseCount;
-        row.Values.Clear();
-      }
+      row.Values.Clear();
 
       for (var i = 0; i < caseCount; i++) {
@@ -124 +174 @@
         }
 
-        if (caseCountChanged)
-          row.Values.Add(count);
-        else
-          row.Values[i] = count;
+        var relativeCount = count / (double)caseQualitiesPerIndividual.Length;
+
+        row.Values.Add(relativeCount);
+      }
+
+      var storeHistory = StoreHistoryParameter.Value.Value;
+
+      if (storeHistory) {
+        var history = IndividualZeroErrorHistoryParameter.ActualValue;
+
+        if (history == null) {
+          history = new DataTableHistory();
+          IndividualZeroErrorHistoryParameter.ActualValue = history;
+        }
+
+        history.Add((DataTable)individualZeroErrorCounts.Clone());
+
+        if (!results.ContainsKey(HISTORY_TABLE_NAME)) {
+          results.Add(new Result(HISTORY_TABLE_NAME, history));
+        } else {
+          results[HISTORY_TABLE_NAME].Value = history;
+        }
       }
 

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;
+        }
       }
 

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

@@ -1 +1 @@
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer {
   using System;
+  using System.Collections.Generic;
   using System.Linq;
 
@@ -14 +15 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
 
   /// <summary>
@@ -24 +25 @@
   [StorableClass]
   public class PushExpressionFrequencyAnalyzer : SingleSuccessorOperator, IPushExpressionAnalyzer {
-    private readonly SeededRandomPool randomPool = new SeededRandomPool();
 
     private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";
@@ -40 +40 @@
       Parameters.Add(new LookupParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, "The current specified push configuration."));
       Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>(INTEGER_VECTOR_PARAMETER_NAME, "The integer vectors to analyze."));
+      Parameters.Add(new ScopeTreeLookupParameter<PlushVector>("Plush", "The plush vectors to analyze."));
       Parameters.Add(new LookupParameter<DataTable>(EXPRESSION_FREQUENCIES_PARAMETER_NAME, "The data table to store the instruction frequencies."));
       Parameters.Add(new LookupParameter<ResultCollection>(RESULTS_PARAMETER_NAME, "The result collection where the symbol frequencies should be stored."));
@@ -60 +61 @@
     {
       get { return (ILookupParameter<IReadOnlyPushConfiguration>)Parameters[PUSH_CONFIGURATION_PARAMETER_NAME]; }
+    }
+
+    public IScopeTreeLookupParameter<PlushVector> PlushVectorParameter
+    {
+      get { return (IScopeTreeLookupParameter<PlushVector>)Parameters["Plush"]; }
     }
 
@@ -95 +101 @@
     public override IOperation Apply() {
       var config = PushConfigurationParameter.ActualValue;
-      var integerVectors = IntegerVectorParameter.ActualValue;
 
-      randomPool.Seed = config.Seed;
+      IReadOnlyList<PushProgram> pushPrograms = null;
 
-      var pushPrograms = integerVectors.Select(iv => {
-        var random = randomPool.ResetAndAllocate();
-        var program = iv.ToPushProgram(config, random);
-        randomPool.Free(random);
-
-        return program;
-      });
+      if (IntegerVectorParameter.ActualValue.Length > 0) {
+        pushPrograms = IntegerVectorParameter.ActualValue.Select(iv => iv.ToPushProgram(config)).ToList();
+      } else if (PlushVectorParameter.ActualValue.Length > 0) {
+        pushPrograms = PlushVectorParameter.ActualValue.Select(pv => pv.PushProgram).ToList();
+      } else {
+        // nothing to do
+        return base.Apply();
+      }
 
       var results = ResultsParameter.ActualValue;
@@ -136 +142 @@
           group => group.Count());
 
-      var totalNumberofExpressions = Math.Max(1.0, expressionFrequencies.Values.Sum());
+      var totalNumberOfExpressions = Math.Max(1.0, expressionFrequencies.Values.Sum());
 
       // all rows must have the same number of values so we can just take the first
@@ -152 +158 @@
         }
 
-        frequencies.Rows[pair.Key].Values.Add(Math.Round(pair.Value / totalNumberofExpressions, 3));
+        frequencies.Rows[pair.Key].Values.Add(Math.Round(pair.Value / totalNumberOfExpressions, 3));
       }