Changeset 16589 for branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression

Timestamp:

02/05/19 14:50:21 (6 years ago)

Author:

chaider

Message:

#2971

• Added new Evaluator to evaulate Pearson RSquared with repsect to given constraints
• changes in SymbolicRegressionSolution

Location:

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

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (1 diff)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator.cs (copied) (copied from branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs) (4 diffs)
• SymbolicRegressionSolution.cs (modified) (5 diffs)

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

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

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

@@ -20 +20 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using HeuristicLab.Common;
@@ -28 +29 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  [Item("Pearson R² Evaluator", "Calculates the square of the pearson correlation coefficient (also known as coefficient of determination) of a symbolic regression solution.")]
+  [Item("Pearson R² Constraint Evaluator", "Calculates the square of the pearson correlation coefficient (also known as coefficient of determination) of a symbolic regression solution.")]
   [StorableClass]
-  public class SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
+  public class SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
     [StorableConstructor]
-    protected SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator(bool deserializing) : base(deserializing) { }
-    protected SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator(SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator original, Cloner cloner)
+    protected SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator(bool deserializing) : base(deserializing) { }
+    protected SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator(SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator(this, cloner);
+      return new SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator(this, cloner);
     }
 
-    public SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator() : base() { }
+    public SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator() : base() { }
 
     public override bool Maximization { get { return true; } }
@@ -58 +59 @@
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
       OnlineCalculatorError errorState;
+
+      IntervalConstraintsParser parser = new IntervalConstraintsParser();
+      var constraints = parser.Parse(((RegressionProblemData) problemData).IntervalConstraintsParameter.Value.Value);
+      var intervalInterpreter = new IntervalInterpreter();
+      var variableRanges = ((RegressionProblemData) problemData).VariableRangesParameter.Value.VariableIntervals;
+
+
+      foreach (var constraint in constraints) {
+        if (!variableRanges.ContainsKey(constraint.Variable))
+          throw new ArgumentException($"The given variable {constraint.Variable} in the constraint does not exists in the model.", nameof(IntervalConstraintsParser));
+        if (!constraint.IsDerivation) {
+          var res = intervalInterpreter.GetSymbolicExressionTreeInterval(solution, variableRanges);
+          if (!IntervalInBoundaries(constraint.Interval, res, constraint.InclusiveLowerBound,
+            constraint.InclusiveUpperBound)) {
+            return 0;
+          }
+        } else {
+          var tree = solution;
+          for (var i = 0; i < constraint.NumberOfDerivation; ++i) {
+            tree = DerivativeCalculator.Derive(tree, constraint.Variable);
+          }
+          var res = intervalInterpreter.GetSymbolicExressionTreeInterval(tree, variableRanges);
+          if (!IntervalInBoundaries(constraint.Interval, res, constraint.InclusiveLowerBound,
+            constraint.InclusiveUpperBound)) {
+            return 0;
+          }
+        }
+      }
+
 
       double r;
@@ -86 +116 @@
       return r2;
     }
+
+    private static bool IntervalInBoundaries(Interval i1, Interval i2, bool inclusiveLower, bool inclusiveUpper) {
+      if (inclusiveLower) {
+        if (i2.LowerBound < i1.LowerBound)
+          return false;
+      } else {
+        if (i2.LowerBound <= i1.LowerBound)
+          return false;
+      }
+
+      if (inclusiveUpper) {
+        if (i2.UpperBound > i1.UpperBound)
+          return false;
+      } else {
+        if (i2.UpperBound >= i1.UpperBound)
+          return false;
+      }
+
+      return true;
+    }
   }
 }

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

@@ -49 +49 @@
     private const string TestNaNEvaluationsResultName = "Test NaN Evaluations";
 
-    private const string EstimatedDerivatesResultName = "Derivates of the Model";
+    private const string IntervalEvaluationResultName = "Interval Evaluation";
     private const string EstimatedDerivationInterval = "Interval";
 
@@ -101 +101 @@
     }
 
-    private ResultCollection EstimatedDerivateResultCollection => 
-      (ResultCollection) this[EstimatedDerivatesResultName].Value;
-
-    public NamedIntervals EstimationInterval =>
-      (NamedIntervals) EstimatedDerivateResultCollection[EstimatedDerivationInterval].Value;
+    private NamedIntervals IntervalEvaluaitonCollection => 
+      (NamedIntervals) this[IntervalEvaluationResultName].Value;
+
 
 
@@ -132 +130 @@
       RecalculateResults();
 
-      var estimationDerivatesResult = new ResultCollection();
-      Add(new Result(EstimatedDerivatesResultName, "Results concerning the derivation of symbolic regression solution", estimationDerivatesResult));
-      CalculateDerivates(estimationDerivatesResult);
+      var namedIntervalCollection = new NamedIntervals();
+      Add(new Result(IntervalEvaluationResultName, "Results concerning the derivation of symbolic regression solution", namedIntervalCollection));
+      GetIntervalEvaulations(namedIntervalCollection);
     }
 
@@ -155 +153 @@
         CalculateResults();
 
-        var estimationDerivatesResult = new ResultCollection();
-        Add(new Result(EstimatedDerivatesResultName, "Results concerning the derivation of symbolic regression solution", estimationDerivatesResult));
-        CalculateDerivates(estimationDerivatesResult);
+        var namedIntervalCollection = new NamedIntervals();
+        Add(new Result(IntervalEvaluationResultName, "Results concerning the derivation of symbolic regression solution", namedIntervalCollection));
+        GetIntervalEvaulations(namedIntervalCollection);
       }
     }
@@ -166 +164 @@
     }
 
-    private void CalculateDerivates(ResultCollection estimationDerivatesResults) {
+    private void GetIntervalEvaulations(NamedIntervals intervalEvaluation) {
       var interpreter = new IntervalInterpreter();
-      var variableRanges = (ProblemData as RegressionProblemData).VariableRangesParameter.Value.VariableIntervals;
-      var customIntervals = new Dictionary<string, Interval>();
-      var intervals = new NamedIntervals();
-
-      foreach (var variable in variableRanges) {
-        customIntervals.Add(variable.Key, new Interval(variable.Value.LowerBound, variable.Value.UpperBound));
-      }
-
-      foreach (var derivate in customIntervals) {
-        if (derivate.Key != ProblemData.TargetVariable) {
-          var derived = DerivativeCalculator.Derive(Model.SymbolicExpressionTree, derivate.Key);
-          var derivedResultInterval = interpreter.GetSymbolicExressionTreeInterval(derived, customIntervals);
-          intervals.Add(" ∂f/∂" + derivate.Key,
-            new Interval(derivedResultInterval.LowerBound, derivedResultInterval.UpperBound));
+      var variableRanges = (ProblemData as RegressionProblemData)?.VariableRangesParameter.Value.VariableIntervals;
+
+      if (variableRanges != null) {
+        intervalEvaluation.Add($"Target {ProblemData.TargetVariable}", new Interval(variableRanges[ProblemData.TargetVariable].LowerBound, variableRanges[ProblemData.TargetVariable].UpperBound));
+        intervalEvaluation.Add("Modell Interval", interpreter.GetSymbolicExressionTreeInterval(Model.SymbolicExpressionTree, variableRanges));
+
+        foreach (var derivate in variableRanges) {
+          if (derivate.Key != ProblemData.TargetVariable) {
+            var derived = DerivativeCalculator.Derive(Model.SymbolicExpressionTree, derivate.Key);
+            var derivedResultInterval = interpreter.GetSymbolicExressionTreeInterval(derived, variableRanges);
+            intervalEvaluation.Add(" ∂f/∂" + derivate.Key,
+              new Interval(derivedResultInterval.LowerBound, derivedResultInterval.UpperBound));
+          }
         }
       }
-      estimationDerivatesResults.AddOrUpdateResult("Derived Intervals", intervals);
-
     }