Changeset 14834 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushEvaluator.cs

Timestamp:

04/10/17 00:27:31 (7 years ago)

Author:

pkimmesw

Message:

#2665 LexicaseSelector, Performance improvements, UI Fixes, Debugger only shows used stacks, fixed Debugger stepping, Added vector expressions, ERCOptions,

File:

• branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushEvaluator.cs (modified) (3 diffs)

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

@@ -6 +6 @@
   using HeuristicLab.BenchmarkSuite.Problems;
   using HeuristicLab.Core;
-  using HeuristicLab.Optimization;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
@@ -19 +18 @@
       interpreter.Run(program);
 
-      return GetDiff(example.OutputInt, interpreter.IntegerStack, worstResult, LongDiffer)
-           + GetDiff(example.OutputFloat, interpreter.FloatStack, worstResult, DoubleDiffer)
-           + GetDiff(example.OutputBoolean, interpreter.BooleanStack, worstResult, BooleanDiffer);
+      var result = GetDiff(example.OutputInt, interpreter.IntegerStack, worstResult, LongDiffer)
+                 + GetDiff(example.OutputFloat, interpreter.FloatStack, worstResult, DoubleDiffer)
+                 + GetDiff(example.OutputBoolean, interpreter.BooleanStack, worstResult, BooleanDiffer);
+
+      return result;
     }
 
-    public static double Evaluate(PushProgram program, PushInterpreterPool pool, IRandom random, Data data, int startIndex, int endIndex) {
-      if (endIndex - startIndex <= 0) return default(double);
-      var result = 0d;
+    public static EvaluationResult Evaluate(PushProgram program, PushInterpreterPool pool, IRandom random, Data data, int startIndex, int endIndex) {
+      var length = endIndex - startIndex;
+      if (length <= 0) return null;
+
+      var evaluationResult = new EvaluationResult(length);
 
       using (var interpreter = pool.Create(random)) {
         for (var i = startIndex; i < endIndex; i++) {
-          result += Evaluate(interpreter, program, data.Examples[i], data.WorstResult);
-          interpreter.Clear();
+          var result = Evaluate(interpreter, program, data.Examples[i], data.WorstResult);
+          evaluationResult.ExampleQualities[i - startIndex] = result;
+          evaluationResult.TotalQuality += result;
+          interpreter.Reset();
         }
       }
 
-      return result / (endIndex - startIndex);
+      evaluationResult.TotalQuality /= length;
+
+      return evaluationResult;
     }
 
-    public static double Evaluate(Individual individual, PushInterpreterPool pool, IRandom random, Data data, int startIndex, int endIndex) {
-      var program = individual.PushProgram(pool.PushGpConfiguration.EnabledExpressions as IReadOnlyList<string>);
-      return Evaluate(program, pool, random, data, startIndex, endIndex);
-    }
+    //public static EvaluationResult Evaluate(Individual individual, PushInterpreterPool pool, IRandom random, Data data, int startIndex, int endIndex) {
+    //  var program = individual.ToPushProgram(pool.PushGpConfiguration);
+    //  return Evaluate(program, pool, random, data, startIndex, endIndex);
+    //}
 
     private static double DoubleDiffer(double a, double b) {
       var result = a - b;
 
-      return result == double.MinValue ? double.MaxValue : Math.Abs(result);
+      if (result == double.MinValue || double.IsPositiveInfinity(result) || double.IsNaN(result))
+        return double.MaxValue;
+
+      if (result == double.MaxValue || double.IsNegativeInfinity(result))
+        return double.MinValue;
+
+      return Math.Abs(result);
     }
 
@@ -59 +72 @@
     }
 
-    private static double GetDiff<T>(IReadOnlyList<T> estimated, IStack<T> resultStack, double worstResult, Func<T, T, double> differ)
+    private static double GetDiff<T>(IReadOnlyList<T> estimated, IPushStack<T> resultStack, double worstResult, Func<T, T, double> differ)
       where T : IComparable {
+      if (estimated.Count == 0) return 0d;
 
-      var count = Math.Min(estimated.Count, resultStack.Count);
-      var result = resultStack.Peek(count);
-      var comparableLength = Math.Min(estimated.Count, result.Length);
       var diff = 0d;
+      var comparableLength = 0;
 
-      for (var i = 0; i < comparableLength; i++) {
-        diff += Math.Min(differ(estimated[i], result[0]), worstResult);
+      if (!resultStack.IsEmpty) {
+        var count = Math.Min(estimated.Count, resultStack.Count);
+        var result = resultStack.Peek(count);
+        comparableLength = Math.Min(estimated.Count, result.Length);
+
+        for (var i = 0; i < comparableLength; i++) {
+          diff += Math.Min(differ(estimated[i], result[i]), worstResult);
+        }
       }
 
-      if (estimated.Count > result.Length) {
-        diff += worstResult * (estimated.Count - comparableLength);
+      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
+        diff += differ(estimated[i], default(T));
       }