Changeset 16590

Timestamp:

02/06/19 14:37:02 (6 years ago)

Author:

chaider

Message:

#2971
Interval-Parser:

• Changed Parser ==> after last group there can be now an infinite amount of whitepsaces
• Save userinput as property
• Save variable case-sensitive

NamedIntervals

• Changed Storable attribute from IEnumerable to KeyValuePair, because old Persistance cant handle IEnumerable

Added SymbolicRegressionConstraintAnalyzer
SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator

• Fixed checking if a given interval is in another interval

Location:

branches/2971_named_intervals

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionConstraintAnalyzer.cs (copied) (copied from branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSolutionsAnalyzer.cs) (4 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/NamedIntervals.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraint.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraintsParser.cs (modified) (6 diffs)

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj

@@ -184 +184 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator.cs" />
+    <Compile Include="SingleObjective\SymbolicRegressionConstraintAnalyzer.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSolutionsAnalyzer.cs" />
     <Compile Include="SymbolicRegressionPhenotypicDiversityAnalyzer.cs" />

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionConstraintAnalyzer.cs

@@ -28 +28 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -35 +36 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   [StorableClass]
-  public class SymbolicRegressionSolutionsAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public class SymbolicRegressionConstraintAnalyzer : SingleSuccessorOperator, IAnalyzer {
     private const string ResultCollectionParameterName = "Results";
-    private const string RegressionSolutionQualitiesResultName = "Regression Solution Qualities";
-    private const string TrainingQualityParameterName = "TrainingRSquared";
-    private const string TestQualityParameterName = "TestRSquared";
+    private const string RegressionSolutionQualitiesResultName = "Constraint Violations";
+
 
     public ILookupParameter<ResultCollection> ResultCollectionParameter {
       get { return (ILookupParameter<ResultCollection>)Parameters[ResultCollectionParameterName]; }
     }
-    public ILookupParameter<DoubleValue> TrainingQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters[TrainingQualityParameterName]; }
-    }
-    public ILookupParameter<DoubleValue> TestQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters[TestQualityParameterName]; }
-    }
+
 
     public virtual bool EnabledByDefault {
@@ -56 +51 @@
 
     [StorableConstructor]
-    protected SymbolicRegressionSolutionsAnalyzer(bool deserializing) : base(deserializing) { }
-    protected SymbolicRegressionSolutionsAnalyzer(SymbolicRegressionSolutionsAnalyzer original, Cloner cloner)
-      : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicRegressionSolutionsAnalyzer(this, cloner);
+    protected SymbolicRegressionConstraintAnalyzer(bool deserializing) : base(deserializing) {
     }
 
-    public SymbolicRegressionSolutionsAnalyzer() {
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName, "The result collection to store the analysis results."));
-      Parameters.Add(new LookupParameter<DoubleValue>(TrainingQualityParameterName));
-      Parameters.Add(new LookupParameter<DoubleValue>(TestQualityParameterName));
+    protected SymbolicRegressionConstraintAnalyzer(SymbolicRegressionConstraintAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicRegressionConstraintAnalyzer(this, cloner);
+    }
+
+    public SymbolicRegressionConstraintAnalyzer() {
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName,
+        "The result collection to store the analysis results."));
+
     }
 
@@ -72 +71 @@
     private void AfterDeserialization() {
       // BackwardsCompatibility3.3
-
-      #region Backwards compatible code, remove with 3.4
-      if (!Parameters.ContainsKey(TrainingQualityParameterName))
-        Parameters.Add(new LookupParameter<DoubleValue>(TrainingQualityParameterName));
-      if (!Parameters.ContainsKey(TestQualityParameterName))
-        Parameters.Add(new LookupParameter<DoubleValue>(TestQualityParameterName));
-      #endregion
     }
 
     public override IOperation Apply() {
       var results = ResultCollectionParameter.ActualValue;
-
+      IntervalConstraintsParser parser = new IntervalConstraintsParser();
+      var intervalInterpreter = new IntervalInterpreter();
       if (!results.ContainsKey(RegressionSolutionQualitiesResultName)) {
         var newDataTable = new DataTable(RegressionSolutionQualitiesResultName);
-        results.Add(new Result(RegressionSolutionQualitiesResultName, "Chart displaying the training and test qualities of the regression solutions.", newDataTable));
+        results.Add(new Result(RegressionSolutionQualitiesResultName, "Chart displaying the constraint violatoins.",
+          newDataTable));
       }
 
       var dataTable = (DataTable)results[RegressionSolutionQualitiesResultName].Value;
 
-      // only if the parameters are available (not available in old persisted code)
-      ILookupParameter<DoubleValue> trainingQualityParam = null;
-      ILookupParameter<DoubleValue> testQualityParam = null;
-      // store actual names of parameter because it is changed below
-      trainingQualityParam = TrainingQualityParameter;
-      string prevTrainingQualityParamName = trainingQualityParam.ActualName;
-      testQualityParam = TestQualityParameter;
-      string prevTestQualityParamName = testQualityParam.ActualName;
       foreach (var result in results.Where(r => r.Value is IRegressionSolution)) {
-        var solution = (IRegressionSolution)result.Value;
+        var solution = (ISymbolicRegressionSolution)result.Value;
+        var constraints =
+          parser.Parse(((RegressionProblemData)solution.ProblemData).IntervalConstraintsParameter.Value.Value);
+        var variableRanges = ((RegressionProblemData)solution.ProblemData).VariableRangesParameter.Value
+          .VariableIntervals;
 
-        var trainingR2Name = result.Name + " Training R²";
-        if (!dataTable.Rows.ContainsKey(trainingR2Name))
-          dataTable.Rows.Add(new DataRow(trainingR2Name));
+        if (dataTable.Rows.Count == 0) {
+          foreach (var constraint in constraints) {
+            if (!dataTable.Rows.ContainsKey(constraint.Derivaiton)) {
+              dataTable.Rows.Add(new DataRow(constraint.Derivaiton));
+            }
+          }
+        }
 
-        var testR2Name = result.Name + " Test R²";
-        if (!dataTable.Rows.ContainsKey(testR2Name))
-          dataTable.Rows.Add(new DataRow(testR2Name));
+        foreach (var constraint in constraints) {
+          if (constraint.Variable != null && !variableRanges.ContainsKey(constraint.Variable))
+            throw new ArgumentException(
+              $"The given variable {constraint.Variable} in the constraint does not exists in the model.",
+              nameof(IntervalConstraintsParser));
+          var numberOfViolations = dataTable.Rows[constraint.Derivaiton].Values.Count > 0
+            ? dataTable.Rows[constraint.Derivaiton].Values.Last()
+            : 0;
+          if (!constraint.IsDerivation) {
+            var res = intervalInterpreter.GetSymbolicExressionTreeInterval(solution.Model.SymbolicExpressionTree,
+              variableRanges);
+            if (!IntervalInBoundaries(constraint.Interval, res, constraint.InclusiveLowerBound,
+              constraint.InclusiveUpperBound)) {
+              dataTable.Rows[constraint.Derivaiton].Values.Add(numberOfViolations + 1);
+            } else {
+              dataTable.Rows[constraint.Derivaiton].Values.Add(numberOfViolations);
+            }
+          } else {
+            var tree = solution.Model.SymbolicExpressionTree;
+            for (var i = 0; i < constraint.NumberOfDerivation; ++i) {
+              tree = DerivativeCalculator.Derive(tree, constraint.Variable);
+            }
 
-        dataTable.Rows[trainingR2Name].Values.Add(solution.TrainingRSquared);
-        dataTable.Rows[testR2Name].Values.Add(solution.TestRSquared);
+            var res = intervalInterpreter.GetSymbolicExressionTreeInterval(solution.Model.SymbolicExpressionTree,
+              variableRanges);
+            if (!IntervalInBoundaries(constraint.Interval, res, constraint.InclusiveLowerBound,
+              constraint.InclusiveUpperBound)) {
+              dataTable.Rows[constraint.Derivaiton].Values.Add(numberOfViolations + 1);
+            } else {
+              dataTable.Rows[constraint.Derivaiton].Values.Add(numberOfViolations);
+            }
+          }
+        }
 
-        // also add training and test R² to the scope using the parameters
-        // HACK: we change the ActualName of the parameter to write two variables for each solution in the results collection
-        trainingQualityParam.ActualName = trainingR2Name;
-        trainingQualityParam.ActualValue = new DoubleValue(solution.TrainingRSquared);
-        testQualityParam.ActualName = testR2Name;
-        testQualityParam.ActualValue = new DoubleValue(solution.TestRSquared);
+      }
+      return base.Apply();
+    }
+
+    private static bool IntervalInBoundaries(Interval i1, Interval i2, bool inclusiveLower, bool inclusiveUpper) {
+      if (double.IsNegativeInfinity(i1.LowerBound) && double.IsPositiveInfinity(i1.UpperBound))
+        return true;
+      //Left-unbounded and right-bounded:
+      if (double.IsNegativeInfinity(i1.LowerBound)) {
+        if (inclusiveUpper)
+          return i2.LowerBound <= i1.UpperBound && i2.UpperBound <= i1.UpperBound;
+        return i2.LowerBound < i1.UpperBound && i2.UpperBound < i1.UpperBound;
       }
 
-      trainingQualityParam.ActualName = prevTrainingQualityParamName;
-      testQualityParam.ActualName = prevTestQualityParamName;
+      //Left-bounded and right-unbounded:
+      if (double.IsPositiveInfinity(i1.UpperBound)) {
+        if (inclusiveLower)
+          return i2.LowerBound >= i1.LowerBound && i2.UpperBound >= i1.LowerBound;
+        return i2.LowerBound > i1.LowerBound && i2.UpperBound > i1.LowerBound;
+      }
 
-      return base.Apply();
+      //Proper and bounded:
+      //Closed:
+      if (inclusiveLower && inclusiveUpper) {
+        return i1.LowerBound <= i2.LowerBound && i2.UpperBound <= i1.UpperBound;
+      }
+
+      //Open:
+      if (!inclusiveLower && !inclusiveUpper) {
+        return i1.LowerBound < i2.LowerBound && i2.UpperBound < i1.UpperBound;
+      }
+
+      //Left-closed, right-open:
+      if (inclusiveLower) {
+        return i1.LowerBound <= i2.LowerBound && i2.UpperBound < i1.UpperBound;
+      }
+
+      //Left-open, right-closed:
+      return i1.LowerBound < i2.LowerBound && i2.UpperBound <= i1.UpperBound;
     }
   }

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/NamedIntervals.cs

@@ -13 +13 @@
   [Item("NamedIntervals", "Represents variables with their interval ranges.")]
   [StorableClass]
-  public class NamedIntervals : Item {   
+  public class NamedIntervals : Item {
     Dictionary<string, Interval> variableIntervals = new Dictionary<string, Interval>();
     public Dictionary<string, Interval> VariableIntervals => variableIntervals;
 
     [Storable(Name = "StorableIntervalInformation")]
-    private IEnumerable<Tuple<string, double, double>> StorableIntervalInformation {
+    private KeyValuePair<string, double[]>[] StorableIntervalInformation {
       get {
+        var l = new List<KeyValuePair<string, double[]>>();
         foreach (var varInt in variableIntervals)
-          yield return Tuple.Create(varInt.Key, varInt.Value.LowerBound, varInt.Value.UpperBound);
+
+          l.Add(new KeyValuePair<string, double[]>(varInt.Key,
+            new double[] { varInt.Value.LowerBound, varInt.Value.UpperBound }));
+        return l.ToArray();
       }
 
       set {
         foreach (var varInt in value)
-          variableIntervals.Add(varInt.Item1,new Interval(varInt.Item2,varInt.Item3));
+          variableIntervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
       }
     }
 
-    public NamedIntervals() : base(){}
+    public NamedIntervals() : base() { }
     protected NamedIntervals(bool deserializing) : base(deserializing) { }
 
@@ -62 +66 @@
       return true;
     }
-   
+
   }
 }

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraint.cs

@@ -7 +7 @@
 namespace HeuristicLab.Problems.DataAnalysis {
   public class IntervalConstraint {
+    public string Derivaiton { get; set; }
     public string Definition { get; set; }
     public Interval Interval { get; set; }

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraintsParser.cs

@@ -1 +1 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -14 +15 @@
     public List<IntervalConstraint> Parse(string input) {
       var options = RegexOptions.Multiline | RegexOptions.IgnoreCase;
-      var matches = Regex.Matches(input, @"^(.*)\bin\b\s*([\[\]])(.*[^\s])(\s*\.\.\s*)([^\s].*)([\[\]])\r?$", options);
+      var matches = Regex.Matches(input, @"^(.*)\bin\b\s*([\[\]])(.*[^\s])(\s*\.\.\s*)([^\s].*)([\[\]])\r?\s*$", options);
 
       for (var i = 0; i < matches.Count; ++i) {
@@ -22 +23 @@
           var definition = Regex.Replace(matches[i].Groups[1].Value, @"\s *", "");
           if (Regex.IsMatch(definition, @"\/")) {
-            var splitted = Regex.Split(definition.ToLower().Replace(" ", string.Empty), @"\/");
+            var splitted = Regex.Split(definition.Replace(" ", string.Empty), @"\/");
             var match = Regex.Match(splitted[0], @"([d∂])([0-9]|[²³])?(.*[^\s*])");
             if (match.Success) {
@@ -28 +29 @@
               intervalConstraint.Definition = match.Groups[3].Value;
               intervalConstraint.IsDerivation = true;
-              var formulation = Regex.Match(splitted[1], @"([d∂])(.*[^\s*][^²³])([²³])?");
+              var formulation = Regex.Match(splitted[1], @"([d∂])(.*[^²³])([²³])?");
               if (formulation.Success) {
                 intervalConstraint.Variable = formulation.Groups[2].Success ? formulation.Groups[2].Value : "";
@@ -38 +39 @@
             intervalConstraint.Definition = Regex.Match(definition, @".*[^.\s]*").Value;
             intervalConstraint.IsDerivation = false;
-          }     
+          }
+          intervalConstraint.Derivaiton = matches[i].Groups[0].Value;
           intervalConstraint.InclusiveLowerBound = (matches[i].Groups[2].Value == "[");
           intervalConstraint.InclusiveUpperBound = (matches[i].Groups[6].Value == "]");
@@ -62 +64 @@
           return double.NegativeInfinity;
         default: {
-          if (double.TryParse(input, out var value)) {
+          if (double.TryParse(input, NumberStyles.Any, CultureInfo.InvariantCulture, out var value)) {
             return value;
           } else {