Changeset 17821 for branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression

Timestamp:

01/19/21 10:22:50 (3 years ago)

Author:

chaider

Message:

#3076 Refactoring Evaluators and Analyzers

Location:

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

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (2 diffs)
• MultiObjective/SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs (modified) (6 diffs)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs (deleted)
• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs (deleted)
• SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs (modified) (2 diffs)
• SymbolicRegressionConstraintAnalyzer.cs (modified) (7 diffs)
• SymbolicRegressionMetaModelAnalyzer.cs (deleted)
• SymbolicRegressionMultiObjectiveMetaModelAnalyzer.cs (deleted)
• SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs (deleted)
• SymbolicRegressionSplittingAnalyzer.cs (added)

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

@@ -176 +176 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintEvaluator.cs" />
-    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs" />
-    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSolutionsAnalyzer.cs" />
+    <Compile Include="SymbolicRegressionSplittingAnalyzer.cs" />
     <Compile Include="SymbolicRegressionConstraintAnalyzer.cs" />
-    <Compile Include="SymbolicRegressionMetaModelAnalyzer.cs" />
-    <Compile Include="SymbolicRegressionMultiObjectiveMetaModelAnalyzer.cs" />
     <Compile Include="SymbolicRegressionPhenotypicDiversityAnalyzer.cs" />
     <Compile Include="SymbolicRegressionPruningAnalyzer.cs" />
@@ -209 +206 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs" />
     <Compile Include="SymbolicRegressionPruningOperator.cs" />
-    <Compile Include="SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs" />
     <Compile Include="SymbolicRegressionSolution.cs" />
     <Compile Include="SymbolicRegressionSolutionImpactValuesCalculator.cs" />

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

@@ -11 +11 @@
   [StorableType("9397A63D-0C6B-4733-BD1A-59AAE9A9F006")]
   public class SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator : SymbolicRegressionMultiObjectiveEvaluator {
+    private const string BoundsEstimatorParameterName = "Bounds estimator";
+    public IValueParameter<IBoundsEstimator> BoundsEstimatorParameter =>
+      (IValueParameter<IBoundsEstimator>)Parameters[BoundsEstimatorParameterName];
+
+    public IBoundsEstimator BoundsEstimator {
+      get => BoundsEstimatorParameter.Value;
+      set => BoundsEstimatorParameter.Value = value;
+    }
+
     #region Constructors
 
@@ -47 +56 @@
 
       var qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData,
-                                rows, applyLinearScaling, DecimalPlaces);
+                                rows, applyLinearScaling, DecimalPlaces, BoundsEstimator);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
       return base.InstrumentedApply();
@@ -62 +71 @@
                               EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
                               problemData, rows,
-                              ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces);
+                              ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces, BoundsEstimator);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
@@ -75 +84 @@
                                      double upperEstimationLimit,
                                      IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
-                                     int decimalPlaces) {
+                                     int decimalPlaces, IBoundsEstimator estimator) {
       OnlineCalculatorError errorState;
       var estimatedValues =
@@ -91 +100 @@
 
       var constraints    = problemData.IntervalConstraints.Constraints.Where(c => c.Enabled);
-      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
+      var intervalCollection = problemData.VariableRanges;
 
       var objectives = new List<double> {nmse}; //Add r² to resultlist
       var constraintObjectives = constraints.Select(constraint =>
-                                                      ConstraintExceeded(constraint, new IntervalInterpreter(),
-                                                                         variableRanges, solution));
+        IntervalUtil.IntervalConstraintViolation(constraint, estimator, intervalCollection, solution) > 0 ? 0.0 : 1.0);
+
       objectives.AddRange(constraintObjectives); //Add hardconstraints for each constraint
 
@@ -102 +111 @@
     }
 
-    private static double ConstraintExceeded(IntervalConstraint constraint, IntervalInterpreter intervalInterpreter,
-                                             IReadOnlyDictionary<string, Interval> variableRanges,
-                                             ISymbolicExpressionTree solution) {
-      return SymbolicRegressionConstraintAnalyzer.ConstraintSatisfied(constraint, new IntervalInterpreter(),
-                                                                      variableRanges, solution, out double error) ? 0 : 1;
-    }
 
     /*

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

@@ -96 +96 @@
         changed = true;
       }
+
+      if (!Operators.OfType<SymbolicRegressionSplittingAnalyzer>().Any()) {
+        Operators.Add(new SymbolicRegressionSplittingAnalyzer());
+        changed = true;
+      }
       if (changed) {
         ParameterizeOperators();
@@ -119 +124 @@
       Operators.Add(new SymbolicExpressionTreePhenotypicSimilarityCalculator());
       Operators.Add(new SymbolicRegressionConstraintAnalyzer());
+      Operators.Add(new SymbolicRegressionSplittingAnalyzer());
       Operators.Add(new SymbolicRegressionPhenotypicDiversityAnalyzer(Operators.OfType<SymbolicExpressionTreePhenotypicSimilarityCalculator>()) { DiversityResultName = "Phenotypic Diversity" });
       ParameterizeOperators();

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

@@ -17 +17 @@
   [StorableType("4318C6BD-E0A1-45FE-AC30-96E7F73B51FB")]
   public class SymbolicRegressionConstraintAnalyzer : SymbolicDataAnalysisAnalyzer, ISymbolicExpressionTreeAnalyzer {
-    private const string ConstraintViolationsResultName = "Constraint Violations";
     private const string ProblemDataParameterName = "ProblemData";
     private const string ConstraintViolationParameterName = "ConstraintViolations";
-    private const string PenalityMultiplierParameterName = "ConstraintsPenalityMultiplier";
-    private const string PenalityMultiplierResultParameterName = "PenalityMultiplierResultParameter";
-    private const string StepSizeParameterName = "Step Size";
-    private const string MaximumStepsParameterName = "Maximum Steps";
-    private const string StartPenalityParameterName = "Start Penality";
     private const string ConstraintUnsatisfiedSolutionsParameterName = "Constraint Unsatisfied Solutions";
 
@@ -34 +28 @@
     public IResultParameter<DataTable> ConstraintViolationParameter =>
       (IResultParameter<DataTable>) Parameters[ConstraintViolationParameterName];
-
-    public ILookupParameter<DoubleValue> PenalityMultiplierParameter =>
-      (ILookupParameter<DoubleValue>) Parameters[PenalityMultiplierParameterName];
-
-    public IValueParameter<IntValue> StepSizeParameter =>
-      (IValueParameter<IntValue>) Parameters[StepSizeParameterName];
-
-    public IValueParameter<IntValue> MaximumStepsParameter =>
-      (IValueParameter<IntValue>) Parameters[MaximumStepsParameterName];
-
-    public IResultParameter<DataTable> PenalityMultiplierResultParameter =>
-      (IResultParameter<DataTable>) Parameters[PenalityMultiplierResultParameterName];
-
-    public IValueParameter<DoubleValue> StartPenalityParameter =>
-      (IValueParameter<DoubleValue>) Parameters[StartPenalityParameterName];
 
     public IResultParameter<DataTable> ConstraintUnsatisfiedSolutionsParameter =>
@@ -75 +54 @@
       Parameters.Add(new ResultParameter<DataTable>(ConstraintViolationParameterName,
         "Shows the number of constraint violations!"));
-      Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
-        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
-      Parameters.Add(new ResultParameter<DataTable>(PenalityMultiplierResultParameterName,
-        "Shows the behavior of the penality multiplier."));
-      Parameters.Add(new ValueParameter<IntValue>(StepSizeParameterName,
-        "Defines the step size for the increasing penality multiplier.", new IntValue(1)));
-      Parameters.Add(new ValueParameter<IntValue>(MaximumStepsParameterName,
-        "Defines maximum steps for the increasing penality multiplier.", new IntValue(1000)));
-      Parameters.Add(new ValueParameter<DoubleValue>(StartPenalityParameterName,
-        "The start value for the penality multiplier.", new DoubleValue(0.5)));
       Parameters.Add(new ResultParameter<DataTable>(ConstraintUnsatisfiedSolutionsParameterName,
         "Shows the number of solutions with unsatisfied constraints."));
@@ -93 +62 @@
           XAxisTitle = "Generations",
           YAxisTitle = "Constraint Violations"
-        }
-      };
-
-      PenalityMultiplierResultParameter.DefaultValue = new DataTable(PenalityMultiplierResultParameterName) {
-        VisualProperties = {
-          XAxisTitle = "Generations",
-          YAxisTitle = "Penality Multiplier"
         }
       };
@@ -124 +86 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(PenalityMultiplierParameterName))
-        Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
-          "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
+      if (Parameters.ContainsKey(ConstraintUnsatisfiedSolutionsParameterName)) return;
+      Parameters.Add(new ResultParameter<DataTable>(ConstraintUnsatisfiedSolutionsParameterName,
+        "Shows the number of solutions with unsatisfied constraints."));
 
-      if (!Parameters.ContainsKey(PenalityMultiplierResultParameterName)) {
-        Parameters.Add(new ResultParameter<DataTable>(PenalityMultiplierResultParameterName,
-          "Shows the behavior of the penality multiplier."));
-
-        PenalityMultiplierResultParameter.DefaultValue = new DataTable(PenalityMultiplierResultParameterName) {
-          VisualProperties = {
-            XAxisTitle = "Generations",
-            YAxisTitle = "Penality Multiplier"
-          }
-        };
-      }
-
-      if (!Parameters.ContainsKey(StepSizeParameterName))
-        Parameters.Add(new ValueParameter<IntValue>(StepSizeParameterName,
-          "Defines the step size for the increasing penality multiplier.", new IntValue(1)));
-
-      if (!Parameters.ContainsKey(MaximumStepsParameterName))
-        Parameters.Add(new ValueParameter<IntValue>(MaximumStepsParameterName,
-          "Defines maximum steps for the increasing penality multiplier.", new IntValue(1000)));
-
-
-      if (!Parameters.ContainsKey(StartPenalityParameterName))
-        Parameters.Add(new ValueParameter<DoubleValue>(StartPenalityParameterName,
-          "The start value for the penality multiplier.", new DoubleValue(0.5)));
-
-
-      if(!Parameters.ContainsKey(ConstraintUnsatisfiedSolutionsParameterName)) {
-        Parameters.Add(new ResultParameter<DataTable>(ConstraintUnsatisfiedSolutionsParameterName,
-          "Shows the number of solutions with unsatisfied constraints."));
-
-        ConstraintUnsatisfiedSolutionsParameter.DefaultValue = new DataTable(ConstraintUnsatisfiedSolutionsParameterName) {
-            VisualProperties = {
-            XAxisTitle = "Generations",
-            YAxisTitle = "Constraint Unsatisfied Solutions"
-          }
-        };
-      }
+      ConstraintUnsatisfiedSolutionsParameter.DefaultValue = new DataTable(ConstraintUnsatisfiedSolutionsParameterName) {
+        VisualProperties = {
+          XAxisTitle = "Generations",
+          YAxisTitle = "Constraint Unsatisfied Solutions"
+        }
+      };
     }
 
     public override IOperation Apply() {
       Iterations++;
-      var rowName = "GeneralizedExponentialDiscreteDoubleValueModifier";
-      var stepSize = StepSizeParameter?.Value?.Value ?? 1;
-      var startValue = StartPenalityParameter?.Value?.Value ?? 0.5;
-      var maximumSteps = MaximumStepsParameter?.Value?.Value ?? 1000;
-      var penalityMultiplier = new DoubleValue(LinearDiscreteDoubleValueModifier.Apply(0, startValue, 1.0,
-        (int) (Iterations / stepSize) * stepSize, 0, maximumSteps));
-      PenalityMultiplierParameter.ActualValue = penalityMultiplier;
-      //GeneralizedExponentialDiscreteDoubleValueModifier
-      //QuadraticDiscreteDoubleValueModifier
-      //LinearDiscreteDoubleValueModifier
 
       var problemData = RegressionProblemDataParameter.ActualValue;
@@ -194 +115 @@
           newDataTable.Rows.Add(new DataRow(constraint.Expression));
 
-      var interpreter = new IntervalInterpreter();
       foreach (var constraint in constraints) {
-        var violations = trees.Select(tree =>
-                                 ConstraintSatisfied(constraint, interpreter, variableRanges, tree, out double error))
-                              .Count(satisfied => !satisfied);
+        var violations = trees.Count(tree => IntervalUtil.IntervalConstraintViolation(constraint, BoundsEstimator, intervalCollection, tree) > 0.0);
+
         newDataTable.Rows[constraint.Expression].Values.Add(violations);
       }
-
-      var penalityDataTable = PenalityMultiplierResultParameter.ActualValue;
-      if (penalityDataTable.Rows.Count == 0)
-        penalityDataTable.Rows.Add(new DataRow(rowName));
-      penalityDataTable.Rows[rowName].Values.Add(penalityMultiplier.Value);
 
       var constraintUnsatisfiedSolutionsDataTable = ConstraintUnsatisfiedSolutionsParameter.ActualValue;
@@ -213 +127 @@
       constraintUnsatisfiedSolutionsDataTable.Rows[ConstraintUnsatisfiedSolutionsParameterName]
         .Values
-        .Add(
-          solutions
-          .Where(s => IntervalUtil.IntervalConstraintsViolation(constraints, BoundsEstimator, intervalCollection, s).Any(x => x != 0.0))
-          .Count());
+        .Add(solutions.Count(s => IntervalUtil.IntervalConstraintsViolation(constraints, BoundsEstimator, intervalCollection, s).Any(x => x != 0.0)));
 
       return base.Apply();
     }
 
-    public static bool ConstraintSatisfied(IntervalConstraint constraint,
-                                           IntervalInterpreter intervalInterpreter,
-                                           IReadOnlyDictionary<string, Interval> variableRanges,
-                                           ISymbolicExpressionTree solution,
-                                           out double error) {
-      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;
-
-      //Create new variable ranges for defined regions
-      var regionRanges = new IntervalCollection();
-      foreach (var kvp in variableRanges) {
-        if (kvp.Key != constraint.Target &&
-            constraint.Regions.GetReadonlyDictionary().TryGetValue(kvp.Key, out Interval val)) {
-          regionRanges.AddInterval(kvp.Key, val);
-        } else {
-          regionRanges.AddInterval(kvp.Key, kvp.Value);
-        }
-      }
-
-      // calculate result interval
-      if (!constraint.IsDerivative) {
-        resultInterval =
-          intervalInterpreter.GetSymbolicExpressionTreeInterval(solution,
-            regionRanges.GetReadonlyDictionary());
-      } else {
-        var tree = solution;
-        for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
-          if (!IntervalInterpreter.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree))
-            throw new ArgumentException("Cube, Root, Power Symbols are not supported.");
-          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
-        }
-
-        resultInterval =
-          intervalInterpreter.GetSymbolicExpressionTreeInterval(tree,
-            regionRanges.GetReadonlyDictionary());
-      }
-
-      error = 0.0;
-      bool satisfied = true;
-      if (!constraint.Interval.Contains(resultInterval.LowerBound)) {
-        satisfied = false;
-        error += Math.Abs(resultInterval.LowerBound - constraint.Interval.LowerBound);
-      }
-
-      if (!constraint.Interval.Contains(resultInterval.UpperBound)) {
-        satisfied = false;
-        error += Math.Abs(resultInterval.UpperBound - constraint.Interval.UpperBound);
-      }
-
-      error *= constraint.Weight;
-
-      //var satisfied = constraint.Interval.Contains(resultInterval);
-      return satisfied;
-    }
-
-    public static bool ConstraintsSatisfied(IEnumerable<IntervalConstraint> constraints,
-                                            IReadOnlyDictionary<string, Interval> variableRanges,
-                                            ISymbolicExpressionTree solution,
-                                            out double error) {
-      var intervalInterpreter = new IntervalInterpreter();
-      error = 0.0;
-      var satisfied = true;
-      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));
-
-        satisfied = ConstraintSatisfied(constraint, intervalInterpreter, variableRanges, solution, out double e) &&
-                    satisfied;
-        error += e;
-        //if (!satisfied) return false;
-      }
-
-      return satisfied;
-    }
+    
   }
 }