Changeset 15366 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push

Timestamp:

09/17/17 23:27:05 (7 years ago)

Author:

pkimmesw

Message:

#2665 Solution Cleanup

Location:

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

Files:

• Evaluator/PushBenchmarkSuiteEvaluator.cs (modified) (15 diffs)
• Expressions/PushProgram.cs (modified) (1 diff)
• Expressions/StatefulExpression.cs (modified) (1 diff)
• Selector/LexicaseSelector.cs (modified) (3 diffs)
• Views/PushProgramTreeView.cs (modified) (1 diff)

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

@@ -220 +220 @@
       long result;
       if (long.TryParse(printResult, out result)) {
-        var diff = Math.Abs(result - example.OutputInteger[0]);
+        var diff = result.AbsoluteDiff(example.OutputInteger[0]);
 
         return Math.Min(Data.WorstResult, diff);
@@ -236 +236 @@
       double value;
       if (double.TryParse(printResult, NumberStyles.Number | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value)) {
-        var diff = Math.Abs(example.OutputFloat[0] - value);
+        var diff = example.OutputFloat[0].AbsoluteDiff(value);
         diff = Math.Min(diff, Data.WorstResult);
 
@@ -263 +263 @@
       var printResult = interpreter.PrintStack.ToString();
       var distance = example.OutputPrint.LevenshteinDistance(printResult);
-      var lineCountWithCorrectFormat = interpreter.PrintStack.AsStrings().Count(line => {
-        var parts = line.Split(' ');
-
-        if (parts.Length != 3)
-          return false;
-
-        var part0 = parts[0].Trim();
-        if (part0.Length == 0 || !part0.IsNumeric())
-          return false;
-
-        var part1 = parts[1].Trim();
-        if (part1.Length != 1)
-          return false;
-
-        var part2 = parts[2].Trim();
-        if (part2.Length != 1)
-          return false;
-
-        return true;
-      });
+
+      var lineCountWithCorrectFormat = interpreter.PrintStack
+        .AsStrings()
+        .Count(line => {
+          var parts = line.Split(' ');
+
+          if (parts.Length != 3)
+            return false;
+
+          var part0 = parts[0].Trim();
+          if (part0.Length == 0 || !part0.IsNumeric())
+            return false;
+
+          var part1 = parts[1].Trim();
+          if (part1.Length != 1)
+            return false;
+
+          var part2 = parts[2].Trim();
+          if (part2.Length != 1)
+            return false;
+
+          return true;
+        });
 
       var lineCountWithInvalidFormat = example.OutputPrintLineCount - lineCountWithCorrectFormat;
@@ -300 +303 @@
       }
 
-      var distance = example.OutputPrint.LevenshteinDistance(interpreter.PrintStack.ToString());
+      var printResult = interpreter.PrintStack.ToString();
+      var distance = example.OutputPrint.LevenshteinDistance(printResult);
+
       var printLines = interpreter.PrintStack.AsStrings().ToArray();
-      var lineCountWithCorrectFormat = printLines.Count(line => line.IsNumeric());
-      var lineCountWithInvalidFormat = Math.Max(0, example.OutputPrintLineCount - lineCountWithCorrectFormat);
-
-      lineCountWithInvalidFormat = Math.Abs(Math.Min(lineCountWithInvalidFormat, example.OutputPrintLineCount));
+
+      var lineCountWithInvalidFormat = printLines
+        .Take(example.OutputPrintLineCount)
+        .Count(line => !line.IsNumeric());
 
       var compareLength = Math.Min(printLines.Length, example.OutputPrintLineCount);
-      long integerError = 0;
+      var integerError = 0L;
 
       for (var i = 0; i < compareLength; i++) {
         long value;
         if (long.TryParse(printLines[i], out value)) {
-          integerError += Math.Abs(value - example.OutputIntegerVector[0][i]);
-        } else {
-          integerError += example.OutputPrintLineCount > 0
-            ? (long)(Data.WorstResult / example.OutputPrintLineCount)
-            : 0;
+          integerError += value.AbsoluteDiff(example.OutputIntegerVector[0][i]);
         }
       }
 
-      var result = distance + lineCountWithInvalidFormat + integerError;
+      var result = distance + lineCountWithInvalidFormat + integerError / compareLength;
       return Math.Min(result, Data.WorstResult);
     }
@@ -347 +348 @@
 
       // add penalty if length does not match
-      var result = expectedVector.Length > 0
-        ? (expectedVector.Length - comparableLength) * (Data.WorstResult / expectedVector.Length)
-        : 0;
+      //var result = expectedVector.Length > 0
+      //  ? (expectedVector.Length - comparableLength) * (Data.WorstResult / expectedVector.Length)
+      //  : 0;
+
+      if (comparableLength == 0) {
+        return Data.WorstResult;
+      }
+
+      var result = 0d;
 
       for (var i = 0; i < comparableLength; i++) {
-        result += Math.Abs(resultVector[i] - expectedVector[i]);
+        result += resultVector[i].AbsoluteDiff(expectedVector[i]);
+      }
+
+      for (var i = comparableLength; i < expectedVector.Length; i++) {
+        result += expectedVector[i];
       }
 
@@ -372 +383 @@
       var distance = example.OutputPrint.LevenshteinDistance(printResult);
       var lineCount = interpreter.PrintStack.Count;
-      var lineCountError = Math.Abs(example.OutputPrintLineCount - lineCount);
+      var lineCountError = example.OutputPrintLineCount.AbsoluteDiff(lineCount);
       var totalWordsPerLineError = 0L;
 
       for (var i = 0; i < interpreter.PrintStack.Lines.Count - 1; i++) {
-        totalWordsPerLineError += Math.Abs(interpreter.PrintStack.Lines[i].Split(' ').Length - estimatedWordsPerLineCount);
+        totalWordsPerLineError += interpreter.PrintStack.Lines[i].Split(' ').Length.AbsoluteDiff(estimatedWordsPerLineCount);
       }
 
       // last line
       var lastLine = interpreter.PrintStack.Lines[interpreter.PrintStack.Lines.Count - 1];
-      totalWordsPerLineError += Math.Abs(lastLine.Split(' ').Length - estimatedLastWordCount);
+      totalWordsPerLineError += lastLine.Split(' ').Length.AbsoluteDiff(estimatedLastWordCount);
 
       var result = distance + lineCountError + totalWordsPerLineError;
@@ -396 +407 @@
 
       // add penalty if length does not match
-      var result = expectedVector.Length > 0
-        ? (expectedVector.Length - comparableLength) * (Data.WorstResult / expectedVector.Length)
-        : 0;
+      //var result = expectedVector.Length > 0
+      //  ? (expectedVector.Length - comparableLength) * (Data.WorstResult / expectedVector.Length)
+      //  : 0;
+
+      if (comparableLength == 0) {
+        return Data.WorstResult;
+      }
+
+      var result = 0d;
 
       for (var i = 0; i < comparableLength; i++) {
         var expectedStr = expectedVector[i].ToString();
         var resultStr = resultVector[i].ToString();
+
         result += expectedStr.LevenshteinDistance(resultStr);
+      }
+
+      for (var i = comparableLength; i < expectedVector.Length; i++) {
+        result += expectedVector[i].ToString().Length;
       }
 
@@ -424 +446 @@
       var expectedNumberOfSentences = example.OutputInteger[0];
       statsError += BenchmarkSuite.Problems.WordStats.GetNumberOfSentences(printStr, out numberOfSentences)
-        ? Math.Abs(expectedNumberOfSentences - numberOfSentences)
+        ? expectedNumberOfSentences.AbsoluteDiff(numberOfSentences)
         : Data.WorstResult / 3.0;
 
@@ -430 +452 @@
       var expectedAverageSentenceLength = example.OutputFloat[0];
       statsError += BenchmarkSuite.Problems.WordStats.GetAverageSentenceLength(printStr, out averageSentenceLength)
-        ? Math.Abs(expectedAverageSentenceLength - averageSentenceLength)
+        ? expectedAverageSentenceLength.AbsoluteDiff(averageSentenceLength)
         : Data.WorstResult / 3.0;
 
@@ -445 +467 @@
 
       var expectedLastCharIndex = example.OutputPrint.Length - 1;
+      var resultLastCharIndex = printStr.Length - 1;
       var result = distance;
 
-      if (expectedLastCharIndex >= 0) {
+      if (expectedLastCharIndex >= 0 && resultLastCharIndex >= 0) {
         var expectedLastChar = example.OutputPrint[expectedLastCharIndex];
-        var resultLastCharIndex = printStr.Length - 1;
-
-        if (resultLastCharIndex >= 0) {
-          var resultLastChar = printStr[resultLastCharIndex];
-          result += Math.Abs(expectedLastChar - resultLastChar);
-        }
+        var resultLastChar = printStr[resultLastCharIndex];
+
+        result += expectedLastChar.AbsoluteDiff(resultLastChar);
       }
 
@@ -470 +490 @@
       var expectedNumberOfSyllables = example.OutputInteger[0];
       var numberOfSyllablesError = BenchmarkSuite.Problems.Syllables.GetNumberOfSyllables(printStr, out numberOfSyllables)
-        ? Math.Abs(expectedNumberOfSyllables - numberOfSyllables)
+        ? expectedNumberOfSyllables.AbsoluteDiff(numberOfSyllables)
         : Data.WorstResult / 2.0;
 
@@ -487 +507 @@
       var expectedGrade = example.OutputChar[0];
       var gradeError = BenchmarkSuite.Problems.Grades.GetGrade(printStr, out grade)
-        ? Math.Abs(expectedGrade - grade)
-        : Data.WorstResult / 2;
+        ? expectedGrade.AbsoluteDiff(grade)
+        : char.MaxValue;
 
       var result = distance + gradeError;
@@ -500 +520 @@
       if (result == double.MinValue || double.IsPositiveInfinity(result) ||
           double.IsNaN(result) ||
+          // ReSharper disable once CompareOfFloatsByEqualityOperator
           result == double.MaxValue || double.IsNegativeInfinity(result))
         return worst;
@@ -576 +597 @@
       return double.IsNaN(diff) || double.IsInfinity(diff)
          ? worstResult
-         : diff;
+         : Math.Min(diff, worstResult);
     }
 
@@ -599 +620 @@
       return double.IsNaN(diff) || double.IsInfinity(diff)
         ? worstResult
-        : diff;
+        : Math.Min(diff, worstResult);
     }
   }

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

@@ -228 +228 @@
 
     [NonSerialized]
-    private int? totalExpressionCount;
+    private int? totalInstructionCount;
     /// <summary>
     /// Returns the amount of none program expressions
     /// </summary>
     /// <returns></returns>
-    public int TotalExpressionCount
-    {
-      get
-      {
-        if (totalExpressionCount == null) {
-          totalExpressionCount = 0;
+    public int TotalInstructionCount
+    {
+      get
+      {
+        if (totalInstructionCount == null) {
+          totalInstructionCount = 0;
 
           for (var i = 0; i < Count; i++) {
             var expression = expressions[i];
 
-            totalExpressionCount += expression.IsProgram
-              ? ((PushProgram)expression).TotalExpressionCount
+            totalInstructionCount += expression.IsProgram
+              ? ((PushProgram)expression).TotalInstructionCount
               : 1;
           }
         }
 
-        return totalExpressionCount.Value;
+        return totalInstructionCount.Value;
       }
     }

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

@@ -1 +1 @@
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
   using System;
+
+  using HeuristicLab.Common;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs

@@ -64 +64 @@
       var random = RandomParameter.ActualValue;
       var maximization = MaximizationParameter.ActualValue.Value;
-
-      //var qualities = QualityParameter.ActualValue;
-      //.Where(x => IsValidQuality(x.Value))
-      //.Select(x => x.Value)
-      //.ToList();
-
       var caseQualities = CaseQualitiesParameter.ActualValue.ToList();
 
@@ -98 +92 @@
       }
 
-      if (caseQualities.Any(x => x.Length != caseQualities[0].Length)) {
+      var qualitiesLength = caseQualities[0].Length;
+
+      if (caseQualities.Any(x => x.Length != qualitiesLength)) {
         throw new ArgumentException("Not all case qualities have the same length");
       }
 
       var selected = new IScope[count];
-      var candidates = Enumerable.Range(0, caseQualities.Count).ToList();
-      var orderSource = Enumerable.Range(0, caseQualities[0].Length).ToList();
+
+      var candidates = new List<int>(caseQualities.Count);
+      for (var i = 0; i < caseQualities.Count; i++) candidates.Add(i);
+
+      var orderSource = new List<int>(qualitiesLength);
+      for (var i = 0; i < qualitiesLength; i++) orderSource.Add(i);
 
       for (var i = 0; i < count; i++) {
@@ -140 +140 @@
           : double.PositiveInfinity;
 
-        foreach (var candidate in candidates) {
-          if (caseQualities[candidate][curCase].IsAlmost(best)) {
+        for (var i = 0; i < candidates.Count; i++) {
+          var candidate = candidates[i];
+          var caseQuality = caseQualities[candidate][curCase];
+
+          if (caseQuality.IsAlmost(best)) {
             // if the individuals is as good as the best one, add it
             nextCandidates.Add(candidate);
           } else if (
-             (maximization && (caseQualities[candidate][curCase] > best)) ||
-             (!maximization && (caseQualities[candidate][curCase] < best))) {
-            // if the individuals is better than the best one, remove all previous candidates and add the new one
+             (maximization && (caseQuality > best)) ||
+             (!maximization && (caseQuality < best))) {
+            // if the individual is better than the best one, remove all previous candidates and add the new one
             nextCandidates.Clear();
             nextCandidates.Add(candidate);
             // also set the next best quality value
-            best = caseQualities[candidate][curCase];
+            best = caseQuality;
           }
           // else {do nothing}

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramTreeView.cs

@@ -55 +55 @@
           return EmptyList;
 
-        return string.Format(PushProgramStringFormat, program.TotalExpressionCount, program.Depth);
+        return string.Format(PushProgramStringFormat, program.TotalInstructionCount, program.Depth);
       }