Changeset 16596 for branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective

Timestamp:

02/08/19 14:11:07 (6 years ago)

Author:

chaider

Message:

#2971

• Extended evaluator with linear scaling
• Added constructor to IntervalConstraint

File:

• branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator.cs (modified) (4 diffs)

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

@@ -57 +57 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      OnlineCalculatorError errorState;
+      OnlineCalculatorError errorState = OnlineCalculatorError.None;
 
       IntervalConstraintsParser parser = new IntervalConstraintsParser();
@@ -65 +65 @@
 
 
-      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));
-        if (!constraint.IsDerivation) {
-          var res = intervalInterpreter.GetSymbolicExressionTreeInterval(solution, variableRanges);
-          if (!constraint.Interval.Contains(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 (!constraint.Interval.Contains(res, constraint.InclusiveLowerBound,
-            constraint.InclusiveUpperBound)) {
-            return 0;
-          }
-        }
-      }
+      //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));
+      //  if (!constraint.IsDerivation) {
+      //    var res = intervalInterpreter.GetSymbolicExressionTreeInterval(solution, variableRanges);
+      //    if (!constraint.Interval.Contains(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 (!constraint.Interval.Contains(res, constraint.InclusiveLowerBound,
+      //      constraint.InclusiveUpperBound)) {
+      //      return 0;
+      //    }
+      //  }
+      //}
       // TODO
       // m = new SymbolicRegressionModel(...)
@@ -97 +97 @@
       // constraints mit scaledTree berechnen (auch die Ableitungen)
 
-
-
       double r;
       if (applyLinearScaling) {
         var rCalculator = new OnlinePearsonsRCalculator();
         CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, rCalculator, problemData.Dataset.Rows);
+        var model = new SymbolicRegressionModel(problemData.TargetVariable, solution, interpreter, lowerEstimationLimit, upperEstimationLimit);
+        model.Scale(problemData);
+        var e = model.GetEstimatedValues(problemData.Dataset, problemData.TrainingIndices);
+        var scaledTree = model.SymbolicExpressionTree;
         errorState = rCalculator.ErrorState;
-        r = rCalculator.R;
+        if (CheckConstraintsViolations(constraints, intervalInterpreter, variableRanges, scaledTree, out var val)) {
+          r = val;
+        } else {
+          r = rCalculator.R;
+        }
       } else {
         IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-        r = OnlinePearsonsRCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
+        if (CheckConstraintsViolations(constraints, intervalInterpreter, variableRanges, solution, out var val)) {
+          r = val;
+        } else {
+          r = OnlinePearsonsRCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
+        }
       }
       if (errorState != OnlineCalculatorError.None) return double.NaN;
       return r*r;
     }
+
 
     public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree,
@@ -129 +140 @@
       return r2;
     }
+
+    private static bool CheckConstraintsViolations(List<IntervalConstraint> constraints, IntervalInterpreter intervalInterpreter,
+      Dictionary<string, Interval> variableRanges, ISymbolicExpressionTree solution, out double r) {
+      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));
+        if (!constraint.IsDerivation) {
+          var res = intervalInterpreter.GetSymbolicExressionTreeInterval(solution, variableRanges);
+          if (!constraint.Interval.Contains(res, constraint.InclusiveLowerBound,
+            constraint.InclusiveUpperBound)) {
+            r = 0;
+            return true;
+          }
+        } 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 (!constraint.Interval.Contains(res, constraint.InclusiveLowerBound,
+            constraint.InclusiveUpperBound)) {
+            r = 0;
+            return true;
+          }
+        }
+      }
+      r = 1;
+      return false;
+    }
   }
 }