Changeset 14777 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs

Timestamp:

03/23/17 01:11:18 (8 years ago)

Author:

pkimmesw

Message:

#2665 simplifier, push solution results view, performance improvements, small bug fixes, ui fixes

File:

• branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs (modified) (10 diffs)

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs

@@ -10 +10 @@
 
   using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.BenchmarkSuite.Problems;
   using HeuristicLab.Data;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
 
   using Instances;
@@ -17 +20 @@
   using Parameters;
   using Persistence.Default.CompositeSerializers.Storable;
-  using Stack;
 
   [StorableClass]
   [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 180)]
   [Item("Push Problem", "")]
-  public class PushProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding>, IProblemInstanceConsumer<IBenchmarkSuiteDataDescriptor> {
+  public class PushProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding>, IProblemInstanceConsumer<Data> {
     [Storable]
     private readonly PushConfiguration config;
     private PushInterpreterPool pool;
+    private IBenchmarkSuiteDataDescriptor dataDescriptor;
 
     public PushProblem() {
       config = new PushConfiguration();
-      pool = new PushInterpreterPool(10000, 1024, 65536, config);
+      pool = new PushInterpreterPool(10000, 4096, 65536, config);
 
       InitEvents();
@@ -98 +101 @@
     private const string MaxPointsInRandomInstructionParameterDescription = "MaxPointsInRandomInstruction";
     private const string DataBoundsParameterName = "DataBounds";
+    private const string MaxProgramDepthParameterName = "MaxProgramDepth";
+    private const string MaxProgramDepthParameterDescription = "";
 
     private void InitParameters() {
-      var bounds = new IntMatrix(1, 3, new[] { "Training Start", "Training End | Test Start", "Test End" });
-      bounds.ItemChanged += (s, e) => {
-        if (this.DataDescriptor == null)
-          return;
-
-        var max = this.DataDescriptor.OriginalTestCount + this.DataDescriptor.OriginalTrainingCount - 1;
-        bounds[0, 0] = Math.Min(Math.Max(bounds[0, 0], 0), max);
-        bounds[0, 2] = Math.Max(Math.Min(bounds[0, 2], max), 0);
-        bounds[0, 1] = Math.Min(Math.Max(bounds[0, 0], bounds[0, 1]), bounds[0, 2]);
-      };
-
-      Parameters.Add(new FixedValueParameter<IntMatrix>(
-        DataBoundsParameterName,
-        bounds));
+
+      Parameters.Add(new FixedValueParameter<DataBounds>(DataBoundsParameterName));
 
       Parameters.Add(new FixedValueParameter<IntValue>(
@@ -174 +167 @@
         new IntValue(config.MaxPointsInRandomExpression)) { Hidden = true });
 
-      Parameters.Add(new ValueParameter<IBenchmarkSuiteDataDescriptor>(DataParameterName, DataParameterDescription));
+      Parameters.Add(
+        new FixedValueParameter<IntValue>(
+          MaxProgramDepthParameterName,
+          MaxProgramDepthParameterDescription,
+          new IntValue(config.MaxDepth)));
+
+      Parameters.Add(new ValueParameter<Data>(
+        DataParameterName,
+        DataParameterDescription));
 
       Encoding.Bounds[0, 0] = 0;
@@ -181 +182 @@
     }
 
-    public IValueParameter<IntMatrix> DataBoundsParameter
-    {
-      get { return (IValueParameter<IntMatrix>)Parameters[DataBoundsParameterName]; }
-    }
-
-    public IntMatrix DataBounds
+    public IValueParameter<DataBounds> DataBoundsParameter
+    {
+      get { return (IValueParameter<DataBounds>)Parameters[DataBoundsParameterName]; }
+    }
+
+    public DataBounds DataBounds
     {
       get { return DataBoundsParameter.Value; }
@@ -204 +205 @@
     }
 
-    public IValueParameter<IBenchmarkSuiteDataDescriptor> DataParameter
-    {
-      get { return (IValueParameter<IBenchmarkSuiteDataDescriptor>)Parameters[DataParameterName]; }
-    }
-
-    public IBenchmarkSuiteDataDescriptor DataDescriptor
+    public IValueParameter<Data> DataParameter
+    {
+      get { return (IValueParameter<Data>)Parameters[DataParameterName]; }
+    }
+
+    public Data Data
     {
       get { return DataParameter.Value; }
@@ -217 +218 @@
     public IValueParameter<IntValue> EvalPushLimitParameter
     {
-      get { return (IValueParameter<IntValue>)this.Parameters[EvalPushLimitParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[EvalPushLimitParameterName]; }
     }
 
@@ -227 +228 @@
         this.EvalPushLimitParameter.Value.Value = value;
         config.EvalPushLimit = value;
+      }
+    }
+
+    public IValueParameter<IntValue> MaxDepthParameter
+    {
+      get { return (IValueParameter<IntValue>)this.Parameters[MaxProgramDepthParameterName]; }
+    }
+
+    public int MaxDepth
+    {
+      get { return config.MaxDepth; }
+      set
+      {
+        this.MaxDepthParameter.Value.Value = value;
+        config.MaxDepth = value;
       }
     }
@@ -394 +410 @@
       var bestIdx = Array.IndexOf(qualities, bestQuality);
       var bestIndividual = individuals[bestIdx];
-      var solution = new PushSolution(bestIndividual.IntegerVector(), bestQuality, DataDescriptor, random, config);
+      var solution = new PushSolution(bestIndividual.IntegerVector(), bestQuality, Data, random, config, DataBounds.TrainingRange.Start, DataBounds.TrainingRange.End);
 
       if (!results.ContainsKey(bestSolutionResultName)) {
@@ -404 +420 @@
 
     public override double Evaluate(Individual individual, IRandom random) {
-      if (DataBounds[0, 1] <= 0) return default(double);
-
-      var program = individual.PushProgram(config.EnabledExpressions as IReadOnlyList<string>);
-      var result = 0d;
-
-      using (var interpreter = pool.GetInstance(random)) {
-        for (var i = DataBounds[0, 0]; i < DataBounds[0, 1]; i++) {
-          var example = DataDescriptor.Examples[i];
-
-          interpreter.BooleanStack.Push(example.InputBoolean);
-          interpreter.IntegerStack.Push(example.InputInt);
-          interpreter.FloatStack.Push(example.InputFloat);
-
-          interpreter.Run(program);
-
-          result += GetDiff(example.OutputInt, interpreter.IntegerStack, DataDescriptor.WorstResult, LongDiffer)
-                  + GetDiff(example.OutputFloat, interpreter.FloatStack, DataDescriptor.WorstResult, DoubleDiffer)
-                  + GetDiff(example.OutputBoolean, interpreter.BooleanStack, DataDescriptor.WorstResult, BooleanDiffer);
-
-          interpreter.Clear();
-        }
-      }
-
-      return result / DataBounds[0, 1];
-    }
-
-    private static double DoubleDiffer(double a, double b) {
-      var result = a - b;
-
-      return result == double.MinValue ? double.MaxValue : Math.Abs(result);
-    }
-
-    private static double LongDiffer(long a, long b) {
-      var result = a - b;
-
-      return result == long.MinValue ? long.MaxValue : Math.Abs(result);
-    }
-
-    private static double BooleanDiffer(bool a, bool b) {
-      return a && b ? 0 : a || b ? 1 : 2;
-    }
-
-    private static double GetDiff<T>(IReadOnlyList<T> estimated, IStack<T> resultStack, double worstResult, Func<T, T, double> differ)
-      where T : IComparable {
-
-      var count = Math.Min(estimated.Count, resultStack.Count);
-      var result = resultStack.Peek(count);
-      var comparableLength = Math.Min(estimated.Count, result.Length);
-      var diff = 0d;
-
-      for (var i = 0; i < comparableLength; i++) {
-        diff += Math.Min(differ(estimated[i], result[0]), worstResult);
-      }
-
-      if (estimated.Count > result.Length) {
-        diff += worstResult * (estimated.Count - comparableLength);
-      }
-
-      return diff;
-    }
-
-    public void Load(IBenchmarkSuiteDataDescriptor descriptor) {
-      this.DataDescriptor = descriptor;
-      BestKnownQuality = descriptor.BestResult;
-
-      DataBounds[0, 0] = 0;
-      DataBounds[0, 2] = this.DataDescriptor.OriginalTrainingCount + this.DataDescriptor.OriginalTestCount;
-      DataBounds[0, 1] = this.DataDescriptor.OriginalTrainingCount;
+      return PushEvaluator.Evaluate(individual, pool, random, Data, DataBounds.TrainingRange.Start, DataBounds.TrainingRange.End);
+    }
+
+    public void Load(Data data) {
+      Data = data;
+      BestKnownQuality = data.BestResult;
+      MaxProgramLength = data.MaxSize;
+      EvalPushLimit = data.EvalLimit;
+
+      config.EnabledExpressions = (IList<string>)ExpressionTable.GetEnabledExpressionsByStackTypes((StackTypes)data.EnabledDataTypes);
+
+      // update enabled stack types
+      foreach (var stackType in ExpressionTable.StackTypeToNamesTable.Keys) {
+        var enabledStackExpressions = config.EnabledExpressions.Intersect(ExpressionTable.StackTypeToNamesTable[stackType]);
+        config.SetStack(stackType, enabledStackExpressions.Any());
+      }
+
+      Encoding.Bounds[0, 0] = 0;
+      Encoding.Bounds[0, 1] = config.EnabledExpressions.Count - 1;
+      Encoding.Length = config.MaxPointsInProgram;
+
+      // TODO
+      // data.MaxGenerations
+      // data.ProgEvalBudget
+
+      DataBounds.TrainingRange.Start = 0;
+      DataBounds.TrainingRange.End = Data.OriginalTrainingCount - 1;
+      DataBounds.TestRange.Start = Data.OriginalTrainingCount;
+      DataBounds.TestRange.End = Data.OriginalTrainingCount + Data.OriginalTestCount;
     }
   }