Changeset 17769 for branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs

Timestamp:

10/02/20 11:38:13 (4 years ago)

Author:

chaider

Message:

#3076

• Added parameter for estimator
• Used IntervalUtil methods for the constraint checking

File:

• branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs (modified) (7 diffs)

branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs

@@ -39 +39 @@
     SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator : SymbolicRegressionMultiObjectiveSplittingEvaluator {
     public const string DimensionsParameterName = "Dimensions";
-
-    public IFixedValueParameter<IntValue> DimensionsParameter => (IFixedValueParameter<IntValue>)Parameters[DimensionsParameterName];
-
+    private const string BoundsEstimatorParameterName = "Bounds estimator";
+
+    public IFixedValueParameter<IntValue> DimensionsParameter =>
+      (IFixedValueParameter<IntValue>) Parameters[DimensionsParameterName];
+
+    public IValueParameter<IBoundsEstimator> BoundsEstimatorParameter =>
+      (IValueParameter<IBoundsEstimator>) Parameters[BoundsEstimatorParameterName];
+
+    public IBoundsEstimator BoundsEstimator {
+      get => BoundsEstimatorParameter.Value;
+      set => BoundsEstimatorParameter.Value = value;
+    }
 
     #region Constructors
+
     public SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator() {
       Parameters.Add(new FixedValueParameter<IntValue>(DimensionsParameterName, new IntValue(2)));
+      Parameters.Add(new ValueParameter<IBoundsEstimator>(BoundsEstimatorParameterName, new IABoundsEstimator()));
     }
 
@@ -58 +69 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if(!Parameters.ContainsKey(DimensionsParameterName))
+      if (!Parameters.ContainsKey(DimensionsParameterName))
         Parameters.Add(new FixedValueParameter<IntValue>(DimensionsParameterName, new IntValue(2)));
+
+      if (!Parameters.ContainsKey(BoundsEstimatorParameterName))
+        Parameters.Add(new ValueParameter<IBoundsEstimator>(BoundsEstimatorParameterName, new IABoundsEstimator()));
     }
 
@@ -68 +82 @@
 
     public override IOperation InstrumentedApply() {
-      var rows                  = GenerateRowsToEvaluate();
-      var solution              = SymbolicExpressionTreeParameter.ActualValue;
-      var problemData           = ProblemDataParameter.ActualValue;
-      var interpreter           = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
-      var estimationLimits      = EstimationLimitsParameter.ActualValue;
-      var minIntervalWidth      = MinSplittingWidth;
-      var maxIntervalSplitDepth = MaxSplittingDepth;
-      var applyLinearScaling  = ApplyLinearScalingParameter.ActualValue.Value;
-
-      if (applyLinearScaling) {
-        //Check for interval arithmetic grammar
-        //remove scaling nodes for linear scaling evaluation
-        var                    rootNode  = new ProgramRootSymbol().CreateTreeNode();
-        var                    startNode = new StartSymbol().CreateTreeNode();
-        SymbolicExpressionTree newTree   = null;
-        foreach (var node in solution.IterateNodesPrefix())
-          if (node.Symbol.Name == "Scaling") {
-            for (var i = 0; i < node.SubtreeCount; ++i) startNode.AddSubtree(node.GetSubtree(i));
-            rootNode.AddSubtree(startNode);
-            newTree = new SymbolicExpressionTree(rootNode);
-            break;
-          }
-
-        //calculate alpha and beta for scaling
-        var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(newTree, problemData.Dataset, rows);
-        var targetValues    = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-        OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out var alpha, out var beta,
-          out var errorState);
-        //Set alpha and beta to the scaling nodes from ia grammar
-        foreach (var node in solution.IterateNodesPrefix())
-          if (node.Symbol.Name == "Offset") {
-            node.RemoveSubtree(1);
-            var alphaNode = new ConstantTreeNode(new Constant()) {Value = alpha};
-            node.AddSubtree(alphaNode);
-          } else if (node.Symbol.Name == "Scaling") {
-            node.RemoveSubtree(1);
-            var betaNode = new ConstantTreeNode(new Constant()) {Value = beta};
-            node.AddSubtree(betaNode);
-          }
-      }
-
-      if (UseConstantOptimization)
+      var rows = GenerateRowsToEvaluate();
+      var solution = SymbolicExpressionTreeParameter.ActualValue;
+      var problemData = ProblemDataParameter.ActualValue;
+      var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
+      var estimationLimits = EstimationLimitsParameter.ActualValue;
+      var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
+
+      if (UseConstantOptimization) {
         SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows,
           false,
@@ -116 +96 @@
           estimationLimits.Lower,
           estimationLimits.Upper);
+      } else {
+        if (applyLinearScaling) {
+          //Check for interval arithmetic grammar
+          //remove scaling nodes for linear scaling evaluation
+          var rootNode = new ProgramRootSymbol().CreateTreeNode();
+          var startNode = new StartSymbol().CreateTreeNode();
+          SymbolicExpressionTree newTree = null;
+          foreach (var node in solution.IterateNodesPrefix())
+            if (node.Symbol.Name == "Scaling") {
+              for (var i = 0; i < node.SubtreeCount; ++i) startNode.AddSubtree(node.GetSubtree(i));
+              rootNode.AddSubtree(startNode);
+              newTree = new SymbolicExpressionTree(rootNode);
+              break;
+            }
+
+          //calculate alpha and beta for scaling
+          var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(newTree, problemData.Dataset, rows);
+          var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
+          OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out var alpha, out var beta,
+            out var errorState);
+          //Set alpha and beta to the scaling nodes from ia grammar
+          foreach (var node in solution.IterateNodesPrefix())
+            if (node.Symbol.Name == "Offset") {
+              node.RemoveSubtree(1);
+              var alphaNode = new ConstantTreeNode(new Constant()) {Value = alpha};
+              node.AddSubtree(alphaNode);
+            } else if (node.Symbol.Name == "Scaling") {
+              node.RemoveSubtree(1);
+              var betaNode = new ConstantTreeNode(new Constant()) {Value = beta};
+              node.AddSubtree(betaNode);
+            }
+        }
+      }
 
       var qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData,
-        rows, UseIntervalSplitting);
+        rows, BoundsEstimator);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
       return base.InstrumentedApply();
     }
 
-    public override double[] Evaluate(IExecutionContext context, ISymbolicExpressionTree tree,
-                                      IRegressionProblemData problemData,
-                                      IEnumerable<int> rows) {
+    public override double[] Evaluate(
+      IExecutionContext context, ISymbolicExpressionTree tree,
+      IRegressionProblemData problemData,
+      IEnumerable<int> rows) {
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
-      EstimationLimitsParameter.ExecutionContext                    = context;
-      ApplyLinearScalingParameter.ExecutionContext                  = context;
+      EstimationLimitsParameter.ExecutionContext = context;
+      ApplyLinearScalingParameter.ExecutionContext = context;
 
       var quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
         EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
-        problemData, rows, UseIntervalSplitting);
+        problemData, rows, BoundsEstimator);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
-      EstimationLimitsParameter.ExecutionContext                    = null;
-      ApplyLinearScalingParameter.ExecutionContext                  = null;
+      EstimationLimitsParameter.ExecutionContext = null;
+      ApplyLinearScalingParameter.ExecutionContext = null;
 
       return quality;
@@ -142 +156 @@
 
 
-    public static double[] Calculate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-                                     ISymbolicExpressionTree solution, double lowerEstimationLimit,
-                                     double upperEstimationLimit,
-                                     IRegressionProblemData problemData, IEnumerable<int> rows, bool splitting) {
+    public static double[] Calculate(
+      ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+      ISymbolicExpressionTree solution, double lowerEstimationLimit,
+      double upperEstimationLimit,
+      IRegressionProblemData problemData, IEnumerable<int> rows, IBoundsEstimator estimator) {
       OnlineCalculatorError errorState;
-      var estimatedValues =
-        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
+      var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
+      var constraints = problemData.IntervalConstraints.Constraints.Where(c => c.Enabled);
+      var intervalCollection = problemData.VariableRanges;
 
       double nmse;
@@ -160 +176 @@
         nmse = 1.0;
 
-      var constraints    = problemData.IntervalConstraints.Constraints.Where(c => c.Enabled);
-      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
-
-      var objectives          = new List<double> {nmse};
-      var intervalInterpreter = new IntervalInterpreter(){UseIntervalSplitting = splitting};
-
-      var constraintObjectives = new List<double>();
-      foreach (var c in constraints) {
-        var penalty = ConstraintExceeded(c, intervalInterpreter, variableRanges,
-          solution);
-        var maxP = 0.1;
-
-        if (double.IsNaN(penalty) || double.IsInfinity(penalty) || penalty > maxP)
-          penalty = maxP;
-
-        constraintObjectives.Add(penalty);
-      }
-
-      objectives.AddRange(constraintObjectives);
-
+
+      var objectives = new List<double> {nmse};
+      ////var intervalInterpreter = new IntervalInterpreter() {UseIntervalSplitting = splitting};
+
+      //var constraintObjectives = new List<double>();
+      //foreach (var c in constraints) {
+      //  var penalty = ConstraintExceeded(c, intervalInterpreter, variableRanges,
+      //    solution);
+      //  var maxP = 0.1;
+
+      //  if (double.IsNaN(penalty) || double.IsInfinity(penalty) || penalty > maxP)
+      //    penalty = maxP;
+
+      //  constraintObjectives.Add(penalty);
+      //}
+
+      //objectives.AddRange(constraintObjectives);
+
+      //return objectives.ToArray();
+
+      var results = IntervalUtil.IntervalConstraintsViolation(constraints, estimator, intervalCollection, solution);
+      objectives.AddRange(results);
       return objectives.ToArray();
-    }
-
-    public static double ConstraintExceeded(IntervalConstraint constraint, IntervalInterpreter intervalInterpreter,
-                                            IReadOnlyDictionary<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.IsDerivative) {
-        resultInterval =
-          intervalInterpreter.GetSymbolicExpressionTreeInterval(solution, variableRanges);
-      }
-      else {
-        var tree = solution;
-        for (var i = 0; i < constraint.NumberOfDerivations; ++i)
-          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
-
-        resultInterval =
-          intervalInterpreter.GetSymbolicExpressionTreeInterval(tree, variableRanges);
-      }
-      
-      //Calculate soft-constraints for intervals
-      if (constraint.Interval.Contains(resultInterval)) return 0;
-      var pLower = 0.0;
-      var pUpper = 0.0;
-      if (constraint.Interval.Contains(resultInterval.LowerBound))
-        pLower = 0;
-      else
-        pLower = constraint.Interval.LowerBound - resultInterval.LowerBound;
-
-      if (constraint.Interval.Contains(resultInterval.UpperBound))
-        pUpper = 0;
-      else
-        pUpper = resultInterval.UpperBound - constraint.Interval.UpperBound;
-      var penalty = Math.Abs(pLower) + Math.Abs(pUpper);
-
-      return penalty;
     }
 
@@ -226 +205 @@
      * All following objectives have to be minimized ==> Constraints
      */
+
     public override IEnumerable<bool> Maximization {
       get {
-        var objectives = new List<bool> {false};          //First NMSE ==> min
+        var objectives = new List<bool> {false}; //First NMSE ==> min
         objectives.AddRange(Enumerable.Repeat(false, DimensionsParameter.Value.Value)); //Constraints ==> min
-        
+
         return objectives;
       }