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

Timestamp:

04/19/19 14:35:08 (6 years ago)

Author:

chaider

Message:

#2791 Refactored Constraint Evaluator and Analyzer

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/SymbolicRegressionConstraintSatisfactionEvaluator.cs (deleted)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptEvaluator.cs (modified) (1 diff)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator.cs (modified) (4 diffs)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveEvaluator.cs (modified) (1 diff)
• SingleObjective/SymbolicRegressionConstraintAnalyzer.cs (modified) (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

@@ -204 +204 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="SingleObjective\ConstantOptimizationAnalyzer.cs" />
-    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionConstraintSatisfactionEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintConstOptEvaluator.cs" />

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

@@ -58 +58 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      OnlineCalculatorError errorState = OnlineCalculatorError.None;
 
-      //var constraints = IntervalConstraintsParser.Parse(((RegressionProblemData)problemData).IntervalConstraintsParameter.Value.Value);
-      var constraints = ((RegressionProblemData)problemData).IntervalConstraintsParameter.Value.Constraints.Where(x => x.Enabled);
-      var intervalInterpreter = new IntervalInterpreter();
-      var variableRanges = ((RegressionProblemData) problemData).VariableRangesParameter.Value.VariableIntervals;
-
+      var constraints = problemData.IntervalConstraints.Constraints.Where(x => x.Enabled);
+      var variableRanges = problemData.VariableRanges.VariableIntervals;
 
       var r2 = SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, problemData.TrainingIndices, applyLinearScaling, 10);
-      if (HasConstraintVioluations(constraints, intervalInterpreter, variableRanges, tree)) {
+      if (SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, tree)) {
         r2 = 0;
       }

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

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HEAL.Attic;
 using HeuristicLab.Common;
@@ -59 +60 @@
       OnlineCalculatorError errorState = OnlineCalculatorError.None;
 
-      //var constraints = IntervalConstraintsParser.Parse(((RegressionProblemData)problemData).IntervalConstraintsParameter.Value.Value);
-      var constraints = ((RegressionProblemData)problemData).IntervalConstraintsParameter.Value.Constraints;
-      var intervalInterpreter = new IntervalInterpreter();
-      var variableRanges = ((RegressionProblemData)problemData).VariableRangesParameter.Value.VariableIntervals;
+      var constraints = problemData.IntervalConstraints.Constraints.Where(x => x.Enabled);
+      var variableRanges = problemData.VariableRanges.VariableIntervals;
+      var tree = solution;
 
       double r;
@@ -70 +70 @@
         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;
+        tree = model.SymbolicExpressionTree;
         errorState = rCalculator.ErrorState;
-        if (CheckConstraintsViolations(constraints, intervalInterpreter, variableRanges, scaledTree, out var val)) {
-          r = val;
-        } else {
-          r = rCalculator.R;
-        }
+        r = rCalculator.R;
       } else {
         IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-        if (CheckConstraintsViolations(constraints, intervalInterpreter, variableRanges, solution, out var val)) {
-          r = val;
-        } else {
-          r = OnlinePearsonsRCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
-        }
+        r = OnlinePearsonsRCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
       }
+
+      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, tree)) {
+        return 0;
+      }
+
       if (errorState != OnlineCalculatorError.None) return double.NaN;
       return r * r;
@@ -107 +103 @@
       return r2;
     }
-
-    private static bool CheckConstraintsViolations(IEnumerable<IntervalConstraint> constraints, IntervalInterpreter intervalInterpreter,
-      IDictionary<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.GetSymbolicExpressionTreeInterval(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.GetSymbolicExpressionTreeInterval(tree, variableRanges);
-          if (!constraint.Interval.Contains(res, constraint.InclusiveLowerBound,
-            constraint.InclusiveUpperBound)) {
-            r = 0;
-            return true;
-          }
-        }
-      }
-      r = 1;
-      return false;
-    }
   }
 }

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

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HEAL.Attic;
-
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   [StorableType("7EB90F03-4385-474F-BDE7-3B133E8FEAAB")]

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

@@ -22 +22 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -34 +35 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   [StorableType("4318C6BD-E0A1-45FE-AC30-96E7F73B51FB")]
-  public class SymbolicRegressionConstraintAnalyzer : SymbolicDataAnalysisAnalyzer, ISymbolicDataAnalysisInterpreterOperator, ISymbolicExpressionTreeAnalyzer {
+  public class SymbolicRegressionConstraintAnalyzer : SymbolicDataAnalysisAnalyzer, ISymbolicExpressionTreeAnalyzer {
     private const string ConstraintViolationsResultName = "Constraint Violations";
     private const string ProblemDataParameterName = "ProblemData";
-    private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
 
     #region parameter properties
-
-    public ILookupParameter<RegressionProblemData> RegressionProblemDataParameter {
-      get { return (ILookupParameter<RegressionProblemData>) Parameters[ProblemDataParameterName]; }
+    public ILookupParameter<IRegressionProblemData> RegressionProblemDataParameter {
+      get { return (ILookupParameter<IRegressionProblemData>) Parameters[ProblemDataParameterName]; }
     }
-
-    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicDataAnalysisTreeInterpreterParameter {
-      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>) Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
-    }
-
-    #endregion
-
-    #region properties
-
-    public RegressionProblemData RegressionProblemData {
-      get { return RegressionProblemDataParameter.ActualValue; }
-    }
-
-    public ISymbolicDataAnalysisExpressionTreeInterpreter Interpreter {
-      get { return SymbolicDataAnalysisTreeInterpreterParameter.ActualValue; }
-    }
-
     #endregion
 
@@ -76 +58 @@
     }
 
-    public SymbolicRegressionConstraintAnalyzer() {
-      Parameters.Add(new LookupParameter<RegressionProblemData>(ProblemDataParameterName, "The problem data of the symbolic data analysis problem."));
-      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The interpreter for symbolic data analysis expression trees."));
+    public SymbolicRegressionConstraintAnalyzer() : base(){
+      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The problem data of the symbolic data analysis problem."));
     }
 
@@ -85 +66 @@
     }
 
-    public static Dictionary<IntervalConstraint, bool> CheckConstraints(ISymbolicExpressionTree model, IRegressionProblemData problemData) {
+    public override IOperation Apply() {
+      var problemData = RegressionProblemDataParameter.ActualValue;
+      var trees = SymbolicExpressionTreeParameter.ActualValue;
+
+      var results = ResultCollectionParameter.ActualValue;
       var constraints = problemData.IntervalConstraints.Constraints.Where(x => x.Enabled);
-      var constraintViolations = new Dictionary<IntervalConstraint, bool>();
       var variableRanges = problemData.VariableRanges.VariableIntervals;
-      foreach (var constraint in constraints) {
-        if (!constraintViolations.ContainsKey(constraint)) {
-          constraintViolations.Add(constraint, CheckConstraint(model, variableRanges, constraint));
-        }
-      }
 
-      return constraintViolations;
-    }
-
-    public static Dictionary<IntervalConstraint, bool> CheckConstraints(ISymbolicRegressionModel model, IRegressionProblemData problemData) {
-      return CheckConstraints(model.SymbolicExpressionTree, problemData);
-    }
-
-    public static bool CheckConstraint(ISymbolicExpressionTree model, IDictionary<string, Interval> variableRanges, IntervalConstraint constraint) {
-      var intervalInterpreter = new IntervalInterpreter();
-      if (!constraint.IsDerivation) {
-        var res = intervalInterpreter.GetSymbolicExpressionTreeInterval(model, variableRanges);
-        if (!constraint.Interval.Contains(res, constraint.InclusiveLowerBound, constraint.InclusiveUpperBound)) {
-          return false;
-        }
-      } else {
-        var dTree = model;
-        for (var i = 0; i < constraint.NumberOfDerivation; ++i) {
-          dTree = DerivativeCalculator.Derive(dTree, constraint.Variable);
-        }
-
-        var res = intervalInterpreter.GetSymbolicExpressionTreeInterval(dTree, variableRanges);
-        if (!constraint.Interval.Contains(res, constraint.InclusiveLowerBound, constraint.InclusiveUpperBound)) {
-          return false;
-        }
-      }
-
-      return true;
-    }
-
-    public static bool CheckConstraint(ISymbolicRegressionModel model, IDictionary<string, Interval> variableRanges, IntervalConstraint constraint) {
-      return CheckConstraint(model.SymbolicExpressionTree, variableRanges, constraint);
-    }
-
-    public override IOperation Apply() {
-      var results = ResultCollectionParameter.ActualValue;
       if (!results.ContainsKey(ConstraintViolationsResultName)) {
         var newDataTable = new DataTable(ConstraintViolationsResultName);
+          foreach (var constraint in constraints) {
+              newDataTable.Rows.Add(new DataRow(constraint.Expression));
+        }
         results.Add(new Result(ConstraintViolationsResultName, "Chart displaying the constraint violations.", newDataTable));
       }
+      var dataTable = (DataTable)results[ConstraintViolationsResultName].Value;
 
-      var dataTable = (DataTable) results[ConstraintViolationsResultName].Value;
-      var problemData = RegressionProblemData;
-      var constraintViolations = new Dictionary<string, int>();
-      var constraints = problemData.IntervalConstraintsParameter.Value.Constraints.Where(x => x.Enabled);
-      if (dataTable.Rows.Count == 0) {
-        foreach (var constraint in constraints) {
-          if (!dataTable.Rows.ContainsKey(constraint.Expression)) {
-            dataTable.Rows.Add(new DataRow(constraint.Expression));
-          }
+      var interpreter = new IntervalInterpreter();
+      foreach (var constraint in constraints) {
+        int violations = 0;
+        foreach (var tree in trees) {
+          var satisfied = SymbolicRegressionConstraintAnalyzer.ConstraintSatisfied(constraint, interpreter, variableRanges, tree);
+          if (!satisfied) violations++;
         }
+        dataTable.Rows[constraint.Expression].Values.Add(violations);
       }
-
-      foreach (var constraint in constraints) {
-        constraintViolations.Add(constraint.Expression, 0);
-      }
-
-      foreach (var tree in this.SymbolicExpressionTree) {
-        var checkedConstraints = CheckConstraints(tree, problemData);
-        foreach (var kvp in checkedConstraints) {
-          if (!kvp.Value) constraintViolations[kvp.Key.Expression]++;
-        }
-      }
-
-      foreach (var kvp in constraintViolations) {
-        dataTable.Rows[kvp.Key].Values.Add(kvp.Value);
-      }
+      
 
       return base.Apply();
     }
+
+    public static bool ConstraintSatisfied(IntervalConstraint constraint, IntervalInterpreter intervalInterpreter,
+      IDictionary<string, Interval> variableRanges, ISymbolicExpressionTree solution) {
+
+      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));
+
+      Interval resultInterval;
+
+      if (!constraint.IsDerivation) {
+        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(solution, variableRanges);
+      } else {
+        var tree = solution;
+        for (var i = 0; i < constraint.NumberOfDerivation; ++i) {
+          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
+        }
+        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(tree, variableRanges);
+      }
+
+      var satisfied = constraint.Interval.Contains(resultInterval, constraint.InclusiveLowerBound, constraint.InclusiveUpperBound);
+      return satisfied;
+    }
+
+    public static bool ConstraintsSatisfied(IEnumerable<IntervalConstraint> constraints, IDictionary<string, Interval> variableRanges, ISymbolicExpressionTree solution) {
+      var intervalInterpreter = new IntervalInterpreter();
+      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 satisfied = ConstraintSatisfied(constraint, intervalInterpreter, variableRanges, solution);
+        if (!satisfied) return false;
+      }
+      return true;
+    }
   }
 }

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

@@ -98 +98 @@
     }
 
-
     public NamedIntervals IntervalEvaluationCollection {
       get { return (NamedIntervals)this[IntervalEvaluationResultName].Value; }
@@ -128 +127 @@
       estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
       Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
-      Add(new Result(IntervalEvaluationResultName, "Results concerning the derivation of symbolic regression solution", GetIntervalEvaluations()));
+      Add(new Result(IntervalEvaluationResultName, "Results concerning the derivation of symbolic regression solution", new NamedIntervals()));
       RecalculateResults();
     }
@@ -148 +147 @@
         estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
         Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
-        Add(new Result(IntervalEvaluationResultName, "Results concerning the derivation of symbolic regression solution", GetIntervalEvaluations()));
+        Add(new Result(IntervalEvaluationResultName, "Results concerning the derivation of symbolic regression solution", new NamedIntervals()));
         CalculateResults();
       }
@@ -156 +155 @@
       base.RecalculateResults();
       CalculateResults();
-    }
-
-    private NamedIntervals GetIntervalEvaluations() {
-      var intervalEvaluation = new NamedIntervals();
-      var interpreter = new IntervalInterpreter();
-      var variableRanges = ProblemData.VariableRanges.VariableIntervals;
-
-      if (variableRanges != null) {
-        intervalEvaluation.VariableIntervals.Add($"Target {ProblemData.TargetVariable}", new Interval(variableRanges[ProblemData.TargetVariable].LowerBound, variableRanges[ProblemData.TargetVariable].UpperBound));
-        intervalEvaluation.VariableIntervals.Add("Modell Interval", interpreter.GetSymbolicExpressionTreeInterval(Model.SymbolicExpressionTree, variableRanges));
-     
-        foreach (var derivate in variableRanges) {
-          if (derivate.Key != ProblemData.TargetVariable) {
-            var derived = DerivativeCalculator.Derive(Model.SymbolicExpressionTree, derivate.Key);
-            var derivedResultInterval = interpreter.GetSymbolicExpressionTreeInterval(derived, variableRanges);
-
-            intervalEvaluation.VariableIntervals.Add(" \u2202f/\u2202" + derivate.Key,
-              new Interval(derivedResultInterval.LowerBound, derivedResultInterval.UpperBound));
-          }
-        }
-      }
-      return intervalEvaluation;
     }
 
@@ -194 +171 @@
       TestNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TestIndices).Count(double.IsNaN);
 
-      IntervalEvaluationCollection = GetIntervalEvaluations();
+      IntervalEvaluationCollection = CalculateModelIntervals(this);
+    }
+
+    private static NamedIntervals CalculateModelIntervals(ISymbolicRegressionSolution solution) {
+      var intervalEvaluation = new NamedIntervals();
+      var interpreter = new IntervalInterpreter();
+      var problemData = solution.ProblemData;
+      var model = solution.Model;
+      var variableRanges = problemData.VariableRanges.VariableIntervals;
+
+      intervalEvaluation.VariableIntervals.Add($"Target {problemData.TargetVariable}", new Interval(variableRanges[problemData.TargetVariable].LowerBound, variableRanges[problemData.TargetVariable].UpperBound));
+      intervalEvaluation.VariableIntervals.Add("Model Interval", interpreter.GetSymbolicExpressionTreeInterval(model.SymbolicExpressionTree, variableRanges));
+
+      foreach (var inputVariable in model.VariablesUsedForPrediction.OrderBy(v => v, new NaturalStringComparer())) {
+        var derivedModel = DerivativeCalculator.Derive(model.SymbolicExpressionTree, inputVariable);
+        var derivedResultInterval = interpreter.GetSymbolicExpressionTreeInterval(derivedModel, variableRanges);
+
+        intervalEvaluation.VariableIntervals.Add(" \u2202f/\u2202" + inputVariable,
+          new Interval(derivedResultInterval.LowerBound, derivedResultInterval.UpperBound));
+      }
+
+      return intervalEvaluation;
     }
   }