Changeset 15341 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis

Timestamp:

08/28/17 09:03:34 (7 years ago)

Author:

pkimmesw

Message:

#2665 Testet Problems, Improved Performance

Location:

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push

Files:

• Configuration/IReadonlyPushConfiguration.cs (modified) (1 diff)
• Configuration/PushConfiguration.cs (modified) (1 diff)
• Encoding/PlushEncoding.cs (modified) (4 diffs)
• Evaluator/PushBenchmarkSuiteEvaluator.cs (modified) (9 diffs)
• Expressions/ExpressionTable.cs (modified) (2 diffs)
• Expressions/FloatExpressions.cs (modified) (1 diff)
• Interpreter/PushInterpreter.cs (modified) (6 diffs)
• Interpreter/PushInterpreterPool.cs (modified) (1 diff)
• Problem/IntegerVectorPushProblem.cs (modified) (1 diff)
• Problem/PlushPushProblem.cs (modified) (3 diffs)
• Stack/PrintStack.cs (modified) (1 diff)

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs

@@ -1 +1 @@
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
+
   using Base.Erc;
 

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs

@@ -96 +96 @@
           MIN_PROGRAM_LENGTH,
           MIN_PROGRAM_LENGTH_PARAMETER_DESCRIPTION,
-          new IntValue(0)) { Hidden = true });
+          new IntValue(0)) { Hidden = false });
 
       if (!Parameters.ContainsKey(MAX_CLOSE_PARAMETER_NAME))

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs

@@ -25 +25 @@
 
     public PlushEncoding(string name) : base(name) {
-      minLengthParameter = new FixedValueParameter<IntValue>(Name + ".MinLength", new IntValue(25));
-      maxLengthParameter = new FixedValueParameter<IntValue>(Name + ".MaxLength", new IntValue(100));
-      maxCloseParameter = new FixedValueParameter<IntValue>(Name + ".MaxClose", new IntValue(3));
-      closeBiasLevelParameter = new FixedValueParameter<DoubleValue>(Name + ".CloseBiasLevel", new DoubleValue(3d));
-      instructionsParameter = new ValueParameter<IExpressionsConfiguration>(Name + ".Instructions");
-      ercOptionsParameter = new ValueParameter<ErcOptions>(Name + ".ErcOptions");
-      inInstructionProbabilityParameter = new FixedValueParameter<PercentValue>(Name + ".InInstructionProbability", new PercentValue(0.1));
-
-      Parameters.Add(minLengthParameter);
-      Parameters.Add(maxLengthParameter);
-      Parameters.Add(maxCloseParameter);
-      Parameters.Add(closeBiasLevelParameter);
-      Parameters.Add(instructionsParameter);
-      Parameters.Add(ercOptionsParameter);
-      Parameters.Add(inInstructionProbabilityParameter);
+      InitParameters();
 
       SolutionCreator = new PlushCreator();
@@ -46 +32 @@
     }
 
+    [StorableConstructor]
     public PlushEncoding(bool deserializing)
       : base(deserializing) {
@@ -54 +41 @@
       minLengthParameter = cloner.Clone(original.minLengthParameter);
       maxLengthParameter = cloner.Clone(original.maxLengthParameter);
+      maxCloseParameter = cloner.Clone(original.maxCloseParameter);
+      closeBiasLevelParameter = cloner.Clone(original.closeBiasLevelParameter);
+      instructionsParameter = cloner.Clone(original.instructionsParameter);
+      ercOptionsParameter = cloner.Clone(original.ercOptionsParameter);
+      inInstructionProbabilityParameter = cloner.Clone(original.inInstructionProbabilityParameter);
+
+      RegisterParameterEvents();
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      InitParameters();
       RegisterParameterEvents();
       DiscoverOperators();
@@ -64 +59 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new PlushEncoding(this, cloner);
+    }
+
+    private void InitParameters() {
+      if (!Parameters.ContainsKey(Name + ".MinLength")) {
+        minLengthParameter = new FixedValueParameter<IntValue>(Name + ".MinLength", new IntValue(0));
+        Parameters.Add(minLengthParameter);
+      }
+
+      if (!Parameters.ContainsKey(Name + ".MaxLength")) {
+        maxLengthParameter = new FixedValueParameter<IntValue>(Name + ".MaxLength", new IntValue(100));
+        Parameters.Add(maxLengthParameter);
+      }
+
+      if (!Parameters.ContainsKey(Name + ".MaxClose")) {
+        maxCloseParameter = new FixedValueParameter<IntValue>(Name + ".MaxClose", new IntValue(3));
+        Parameters.Add(maxCloseParameter);
+      }
+
+      if (!Parameters.ContainsKey(Name + ".CloseBiasLevel")) {
+        closeBiasLevelParameter = new FixedValueParameter<DoubleValue>(Name + ".CloseBiasLevel", new DoubleValue(3d));
+        Parameters.Add(closeBiasLevelParameter);
+      }
+
+      if (!Parameters.ContainsKey(Name + ".Instructions")) {
+        instructionsParameter = new ValueParameter<IExpressionsConfiguration>(Name + ".Instructions");
+        Parameters.Add(instructionsParameter);
+      }
+
+      if (!Parameters.ContainsKey(Name + ".ErcOptions")) {
+        ercOptionsParameter = new ValueParameter<ErcOptions>(Name + ".ErcOptions");
+        Parameters.Add(ercOptionsParameter);
+      }
+
+      if (!Parameters.ContainsKey(Name + ".InInstructionProbability")) {
+        inInstructionProbabilityParameter = new FixedValueParameter<PercentValue>(Name + ".InInstructionProbability", new PercentValue(0.1));
+        Parameters.Add(inInstructionProbabilityParameter);
+      }
     }
 

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/PushBenchmarkSuiteEvaluator.cs

@@ -156 +156 @@
 
         // float error
-        case ProblemType.VectorAverage: return GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision));
+        case ProblemType.VectorAverage: return GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision, Data.WorstResult));
 
         // integer error
@@ -184 +184 @@
     private double Default(IPushInterpreter interpreter, Example example) {
       var integerDiff = GetDiff(example.OutputInteger, interpreter.IntegerStack, Data.WorstResult, IntegerDiffer);
-      var floatDiff = GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision));
+      var floatDiff = GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision, Data.WorstResult));
       var booleanDiff = GetDiff(example.OutputBoolean, interpreter.BooleanStack, Data.WorstResult, BooleanDiffer);
       var stringDiff = GetDiff(example.OutputString, interpreter.StringStack, Data.WorstResult, StringDiffer);
@@ -190 +190 @@
       var printDiff = GetPrintDiffer(example.OutputPrint, interpreter.PrintStack, Data.WorstResult);
       var integerVectorDiff = GetVectorDiff(example.OutputIntegerVector, interpreter.IntegerVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, IntegerDiffer));
-      var floatVectorDiff = GetVectorDiff(example.OutputFloatVector, interpreter.FloatVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, (x, y) => FloatDiffer(x, y, example.OutputFloatVectorPrecision)));
+      var floatVectorDiff = GetVectorDiff(example.OutputFloatVector, interpreter.FloatVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, (x, y) => FloatDiffer(x, y, example.OutputFloatVectorPrecision, Data.WorstResult)));
       var stringVectorDiff = GetVectorDiff(example.OutputStringVector, interpreter.StringVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, StringDiffer));
 
@@ -315 +315 @@
         return Data.WorstResult;
 
-      var floatDiff = GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision));
+      var floatDiff = GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision, Data.WorstResult));
       var expectedStr = example.OutputFloat[0].ToString(Data.FloatStringFormat, CultureInfo.CurrentCulture);
       var resultStr = interpreter.FloatStack.TopOrDefault.ToString(Data.FloatStringFormat, CultureInfo.CurrentCulture);
@@ -480 +480 @@
     }
 
-    private static double FloatDiffer(double a, double b, int digits) {
+    private static double FloatDiffer(double a, double b, int digits, double worst) {
       var result = Math.Round(a, digits) - Math.Round(b, digits);
 
       // ReSharper disable once CompareOfFloatsByEqualityOperator
-      if (result == double.MinValue || double.IsPositiveInfinity(result) || double.IsNaN(result))
-        return double.MaxValue;
-
-      // ReSharper disable once CompareOfFloatsByEqualityOperator
-      if (result == double.MaxValue || double.IsNegativeInfinity(result))
-        return double.MinValue;
+      if (result == double.MinValue || double.IsPositiveInfinity(result) ||
+          double.IsNaN(result) ||
+          result == double.MaxValue || double.IsNegativeInfinity(result))
+        return worst;
 
       return Math.Abs(result);
@@ -545 +543 @@
       where T : IComparable {
       if (estimated.Count == 0) return 0d;
+      if (resultStack.IsEmpty && estimated.Count > 0) return worstResult;
 
       var diff = 0d;
@@ -551 +550 @@
       if (!resultStack.IsEmpty) {
 
-        for (var i = 0; i < comparableLength; i++) {
-          diff += Math.Min(differ(estimated[i], resultStack[i]), worstResult);
+        for (var i = 0; i < comparableLength && diff < worstResult; i++) {
+          diff += differ(estimated[i], resultStack[i]);
         }
       }
 
       var emptyTArray = new T[0];
-      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
+      for (var i = comparableLength; i < estimated.Count - comparableLength && diff < worstResult; i++) {
         diff += differ(estimated[i], emptyTArray);
       }
@@ -567 +566 @@
       where T : IComparable {
       if (estimated.Count == 0) return 0d;
+      if (resultStack.IsEmpty && estimated.Count > 0) return worstResult;
 
       var diff = 0d;
@@ -572 +572 @@
 
       if (!resultStack.IsEmpty) {
-        for (var i = 0; i < comparableLength; i++) {
-          diff += Math.Min(differ(estimated[i], resultStack[i]), worstResult);
+        for (var i = 0; i < comparableLength && diff < worstResult; i++) {
+          diff += differ(estimated[i], resultStack[i]);
         }
       }
 
-      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
+      for (var i = comparableLength; i < estimated.Count - comparableLength && diff < worstResult; i++) {
         diff += differ(estimated[i], default(T));
       }

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs

@@ -175 +175 @@
 
     public static Expression GetStatelessExpression<T>() where T : StatelessExpression {
-      return GetStatelessExpression(typeToNameTable[typeof(T)]);
+      Expression expression;
+      var type = typeof(T);
+
+      if (StatelessExpressionTable.TryGetValue(type, out expression))
+        return expression;
+
+      throw new NotSupportedException("Expression not supported: " + type.Name);
     }
 
     public static Expression GetStatelessExpression(string name) {
-      if (NameToTypeTable.ContainsKey(name) && StatelessExpressionTable.ContainsKey(NameToTypeTable[name]))
-        return StatelessExpressionTable[NameToTypeTable[name]];
+      Type type;
+      Expression expression;
+
+      if (NameToTypeTable.TryGetValue(name, out type) && StatelessExpressionTable.TryGetValue(type, out expression))
+        return expression;
+
       throw new NotSupportedException("Expression not supported: " + name);
     }
 
     public static bool TryGetStatelessExpression(string name, out Expression expression) {
-      if (!NameToTypeTable.ContainsKey(name) || !StatelessExpressionTable.ContainsKey(NameToTypeTable[name])) {
+      Type type;
+      if (!NameToTypeTable.TryGetValue(name, out type) || !StatelessExpressionTable.TryGetValue(type, out expression)) {
         expression = null;
         return false;
       }
 
-      expression = StatelessExpressionTable[NameToTypeTable[name]];
       return true;
     }
@@ -199 +209 @@
 
     public static Expression GetStatefulExpression(string name) {
-      if (NameToTypeTable.ContainsKey(name)) {
-        Func<Expression> creator;
-        var type = NameToTypeTable[name];
-
-        if (StatefulExpressionFactory.TryGetValue(type, out creator))
-          return creator();
+      Type type;
+      Func<Expression> creator;
+
+      if (NameToTypeTable.TryGetValue(name, out type) && StatefulExpressionFactory.TryGetValue(type, out creator)) {
+        return creator();
       }
 

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FloatExpressions.cs

@@ -449 +449 @@
       return interpreter.StringStack.IsEmpty ||
              interpreter.StringStack.Top.Length == 0 ||
-             !double.TryParse(interpreter.StringStack.Top, out tmp);
+             !double.TryParse(
+               interpreter.StringStack.Top,
+               NumberStyles.AllowDecimalPoint | NumberStyles.Float,
+               CultureInfo.InvariantCulture,
+               out tmp);
     }
 
     public override void Eval(IInternalPushInterpreter interpreter) {
       var str = interpreter.StringStack.Pop();
-      var value = double.Parse(str, CultureInfo.InvariantCulture);
+      var value = double.Parse(str, NumberStyles.AllowDecimalPoint | NumberStyles.Float, CultureInfo.InvariantCulture);
 
       interpreter.FloatStack.Push(value);

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs

@@ -17 +17 @@
   public class PushInterpreter : IInternalPushInterpreter, IDisposable {
     private Task currentTask;
-    private Expression currentProgram;
+    private int evalPushLimit;
 
     /// <summary>
@@ -30 +30 @@
       Configuration = config ?? new PushConfiguration();
 
-      // setting the capacity of the Stacks to max points ensures that there will be enough memory at runtime
       ExecStack = new PushStack<Expression>(Configuration.MaxProgramLength);
       CodeStack = new PushStack<Expression>();
@@ -66 +65 @@
       PoolContainer = poolContainer ?? new InterpreterPoolContainer();
 
+      InitEvalPushLimit();
       ConfigureStacks();
     }
@@ -92 +92 @@
                !IsPaused &&
                !IsAborted &&
-               (ExecCounter < Configuration.EvalPushLimit);
+               (ExecCounter < evalPushLimit);
       }
     }
@@ -261 +261 @@
     public void Run(Expression expression, bool stepwise = false) {
       IsPaused = stepwise;
-      currentProgram = expression;
 
       /* Push top expression so the loop is able to enter
@@ -347 +346 @@
       Random = (IRandom)randomOrigin.Clone();
 
+      InitEvalPushLimit();
+
       ExecCounter = 0;
       IsAborted = false;
       IsPaused = false;
       currentTask = null;
-      currentProgram = null;
 
       inputExpressions.Clear();
       ClearStacks();
       ConfigureStacks();
+    }
+
+    private void InitEvalPushLimit() {
+      // evalPushLimit is accessed very often and using the getter of the configuration object is rather expensive as the values is capsuled within a parameter
+      evalPushLimit = Configuration.EvalPushLimit;
+    }
+
+    private void EvalPushLimitChanged(object sender, EventArgs e) {
+      this.evalPushLimit = Configuration.EvalPushLimit;
     }
 

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs

@@ -33 +33 @@
 
     public PooledPushInterpreter Create(IRandom random = null) {
-      //var interpreter = pool.Allocate();
-      //interpreter.Reset(random);
-
-      var poolContainer = new InterpreterPoolContainer(PushProgramPoolProvider, ExpressionListPoolProvider);
-      var interpreter = new PooledPushInterpreter(this, PushConfiguration, poolContainer, random);
+      var interpreter = pool.Allocate();
+      interpreter.Reset(random);
 
       return interpreter;

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

@@ -59 +59 @@
       Encoding.Bounds[0, 0] = 0;
       Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
-      Encoding.Length = Config.MaxProgramLength;
     }
 

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

@@ -1 +1 @@
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
+  using System.Diagnostics;
   using System.Linq;
 
@@ -29 +30 @@
       Encoding.ErcOptionsParameter = Config.ErcOptionsParameter;
       Encoding.InstructionsParameter = Config.InstructionsParameter;
-      Encoding.MinLengthParameter = Config.MinProgramLengthParameter;
-      Encoding.MaxLengthParameter = Config.MaxProgramLengthParameter;
       Encoding.MaxCloseParameter = Config.MaxCloseParameter;
       Encoding.CloseBiasLevelParameter = Config.CloseBiasLevelParameter;
@@ -49 +48 @@
       var program = plushVector.PushProgram;
 
+      if (program == null)
+        Debugger.Break();
+
       return program;
     }

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PrintStack.cs

@@ -36 +36 @@
       get
       {
-        if (stringBuilder.Length == length) return lines;
+        if (lines != null && stringBuilder.Length == length)
+          return lines;
+
         length = stringBuilder.Length;
         lines = stringBuilder.ToString().Split(PushEnvironment.NewLine);