Changeset 17751 for branches/3076_IA_evaluators_analyzers

Timestamp:

09/20/20 22:21:24 (4 years ago)

Author:

chaider

Message:

#3076 Added Splitting-Parameter

Location:

branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4

Files:

• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs (modified) (1 diff)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintEvaluator.cs (modified) (13 diffs)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs (modified) (1 diff)
• SymbolicRegressionConstraintAnalyzer.cs (modified) (3 diffs)

branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs

@@ -115 +115 @@
       var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       var nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out var errorState);
-      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, out double error))
+      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, false, out double error))
       {
         if (double.IsNaN(error) || double.IsInfinity(error))

branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintEvaluator.cs

@@ -1 +1 @@
 using System;
+using System.CodeDom;
 using System.Collections.Generic;
 using System.Linq;
@@ -26 +27 @@
     private const string PenaltyMultiplierParameterName = "Constraints Penalty Multiplier";
 
+    private const string UseIntervalSplittingParameterName = "Use Interval Splitting";
+
     public IFixedValueParameter<BoolValue> UseConstantOptimizationParameter =>
       (IFixedValueParameter<BoolValue>) Parameters[UseConstantOptimizationParameterName];
@@ -37 +40 @@
     public IFixedValueParameter<DoubleValue> PenaltyMultiplierParameter =>
       (IFixedValueParameter<DoubleValue>) Parameters[PenaltyMultiplierParameterName];
+
+    public IFixedValueParameter<BoolValue> UseIntervalSplittingParameter =>
+      (IFixedValueParameter<BoolValue>) Parameters[UseIntervalSplittingParameterName];
 
     public bool UseConstantOptimization {
@@ -56 +62 @@
       get => PenaltyMultiplierParameter.Value.Value;
       set => PenaltyMultiplierParameter.Value.Value = value;
+    }
+
+    public bool UseIntervalSplitting {
+      get => UseIntervalSplittingParameter.Value.Value;
+      set => UseIntervalSplittingParameter.Value.Value = value;
     }
 
@@ -80 +91 @@
       Parameters.Add(new FixedValueParameter<DoubleValue>(PenaltyMultiplierParameterName,
         "Specify how hard constraints violations should be punished", new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseIntervalSplittingParameterName,
+        "Define whether interval splitting is used or not.", new BoolValue(false)));
     }
 
@@ -103 +116 @@
           "Specify how hard constraints violations should be punished", new DoubleValue(1.0)));
       }
+
+      if (!Parameters.ContainsKey(UseIntervalSplittingParameterName)) {
+        Parameters.Add(new FixedValueParameter<BoolValue>(UseIntervalSplittingParameterName,
+          "Define whether interval splitting is used or not.", new BoolValue(false)));
+      }
     }
 
@@ -112 +130 @@
 
     public override IOperation InstrumentedApply() {
-      var rows               = GenerateRowsToEvaluate();
-      var solution           = SymbolicExpressionTreeParameter.ActualValue;
-      var problemData        = ProblemDataParameter.ActualValue;
-      var interpreter        = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
-      var estimationLimits   = EstimationLimitsParameter.ActualValue;
+      var rows = GenerateRowsToEvaluate();
+      var solution = SymbolicExpressionTreeParameter.ActualValue;
+      var problemData = ProblemDataParameter.ActualValue;
+      var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
+      var estimationLimits = EstimationLimitsParameter.ActualValue;
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
@@ -127 +145 @@
           //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;
+          var rootNode = new ProgramRootSymbol().CreateTreeNode();
+          var startNode = new StartSymbol().CreateTreeNode();
+          SymbolicExpressionTree newTree = null;
           foreach (var node in solution.IterateNodesPrefix())
             if (node.Symbol.Name == "Scaling") {
@@ -140 +158 @@
           //calculate alpha and beta for scaling
           var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(newTree, problemData.Dataset, rows);
-          var targetValues    = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
+          var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
           OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out var alpha, out var beta,
             out var errorState);
@@ -159 +177 @@
       var quality = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows,
         UseSoftConstraints,
-        PenaltyMultiplier);
+        PenaltyMultiplier, UseIntervalSplitting);
       QualityParameter.ActualValue = new DoubleValue(quality);
 
@@ -170 +188 @@
       double upperEstimationLimit,
       IRegressionProblemData problemData, IEnumerable<int> rows, bool useSoftConstraints,
-      double penaltyMultiplier) {
+      double penaltyMultiplier, bool useSplitting) {
       var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      var targetValues    = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      var constraints     = problemData.IntervalConstraints.EnabledConstraints;
-      var variableRanges  = problemData.VariableRanges.GetReadonlyDictionary();
-      
+      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
+      var constraints = problemData.IntervalConstraints.EnabledConstraints;
+      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
+
       var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       var nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues,
         out var errorState);
 
-      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution,
+      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, useSplitting,
         out var error)) {
         if (useSoftConstraints) {
@@ -188 +206 @@
             nmse += penaltyMultiplier * error;
           }
-          
+
           nmse = Math.Min(1.0, nmse);
         } else {
@@ -206 +224 @@
       IEnumerable<int> rows) {
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
-      EstimationLimitsParameter.ExecutionContext                    = context;
-      ApplyLinearScalingParameter.ExecutionContext                  = context;
+      EstimationLimitsParameter.ExecutionContext = context;
+      ApplyLinearScalingParameter.ExecutionContext = context;
 
       var nmse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
         EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
-        problemData, rows, UseSoftConstraints, PenaltyMultiplier);
+        problemData, rows, UseSoftConstraints, PenaltyMultiplier, UseIntervalSplitting);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
-      EstimationLimitsParameter.ExecutionContext                    = null;
-      ApplyLinearScalingParameter.ExecutionContext                  = null;
+      EstimationLimitsParameter.ExecutionContext = null;
+      ApplyLinearScalingParameter.ExecutionContext = null;
 
       return nmse;

branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs

@@ -85 +85 @@
       var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
 
-      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, out double error))
+      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, false, out double error))
         return 1.0;
 

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

@@ -191 +191 @@
       // calculate result interval
       if (!constraint.IsDerivative) {
-        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(solution, new ReadOnlyDictionary<string, Interval>(regionRanges));
+        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(solution, new ReadOnlyDictionary<string, Interval>(regionRanges), 0);
       }
       else {
@@ -201 +201 @@
         }
 
-        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(tree, new ReadOnlyDictionary<string, Interval>(regionRanges));
+        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(tree, new ReadOnlyDictionary<string, Interval>(regionRanges), 0);
       }
 
@@ -226 +226 @@
     public static bool ConstraintsSatisfied(IEnumerable<IntervalConstraint> constraints,
                                             IReadOnlyDictionary<string, Interval> variableRanges,
-                                            ISymbolicExpressionTree solution,
+                                            ISymbolicExpressionTree solution, bool useSplitting,
                                             out double error) {
-      var intervalInterpreter = new IntervalInterpreter();
+      var intervalInterpreter = new IntervalInterpreter() {UseIntervalSplitting = useSplitting};
       error = 0.0;
       var satisfied = true;