Changeset 17995

Timestamp:

06/22/21 18:28:36 (3 years ago)

Author:

dpiringe

Message:

#3119

• added additional parameters to enable different evaluation options
• added additive restrictions
• added additional implementations for dynamic restrictions:
  • dynamic intervalls
  • exponatial smoothing
  • rising multiplier
• adapted IntervalUtil to get model bounds and refactored some sections
• adapted ShapeConstraintsParser for added features
• added a ResultCollection in SymbolicRegressionSolution for shape constraint violations

Location:

branches/3119_AdditionalShapeConstraintFeatures

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Plugin.cs.frame (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSEConstraintsEvaluator.cs (modified) (14 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraint.cs (modified) (8 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraintsParser.cs (modified) (8 diffs)

branches/3119_AdditionalShapeConstraintFeatures/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj

@@ -131 +131 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSolutionsAnalyzer.cs" />
+    <Compile Include="SymbolicRegressionMetaModelAnalyzer.cs" />
     <Compile Include="SymbolicRegressionPhenotypicDiversityAnalyzer.cs" />
     <Compile Include="SymbolicRegressionPruningAnalyzer.cs" />
@@ -158 +159 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs" />
     <Compile Include="SymbolicRegressionPruningOperator.cs" />
+    <Compile Include="SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs" />
     <Compile Include="SymbolicRegressionSolution.cs" />
     <Compile Include="SymbolicRegressionSolutionImpactValuesCalculator.cs" />

branches/3119_AdditionalShapeConstraintFeatures/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Plugin.cs.frame

@@ -37 +37 @@
   [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Attic", "1.0")]

branches/3119_AdditionalShapeConstraintFeatures/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSEConstraintsEvaluator.cs

@@ -24 +24 @@
 using System.Linq;
 using HEAL.Attic;
+using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
@@ -39 +42 @@
     private const string OptimizeParametersParameterName = "OptimizeParameters";
     private const string ParameterOptimizationIterationsParameterName = "ParameterOptimizationIterations";
+    private const string UseConstraintsParameterName = "UseConstraintsEvaluation";
     private const string UseSoftConstraintsParameterName = "UseSoftConstraintsEvaluation";
     private const string BoundsEstimatorParameterName = "BoundsEstimator";
     private const string PenaltyFactorParameterName = "PenaltyFactor";
+    private const string GenerationOfConvergenceParameterName = "Generation of Convergence";
+    private const string AlphaParameterName = "Alpha";
+    private const string ResultCollectionParameterName = "Results";
+    private const string GenerationsEntry = "Generations";
+    private const string LPValueParameterName = "Low Pass Value";
+    private const string UseDynamicPenaltyImpl1ParameterName = "UseDynamicPenaltyImpl1";
+    private const string UseDynamicPenaltyImpl2ParameterName = "UseDynamicPenaltyImpl2";
+    private const string UseDynamicPenaltyImpl3ParameterName = "UseDynamicPenaltyImpl3";
+    private const string UseAdditivePenaltyParameterName = "UseAdditivePenalty";
+    private const string RisingPenaltyParameterName = "RisingPenalty";
+    private const string StepSizeParameterName = "Step Size";
+    private const string MaximumStepsParameterName = "Maximum Steps";
+    private const string StartpenaltyParameterName = "Start penalty";
 
 
@@ -50 +67 @@
       (IFixedValueParameter<IntValue>)Parameters[ParameterOptimizationIterationsParameterName];
 
+    public IFixedValueParameter<BoolValue> UseConstraintsParameter =>
+      (IFixedValueParameter<BoolValue>)Parameters[UseConstraintsParameterName];
+
     public IFixedValueParameter<BoolValue> UseSoftConstraintsParameter =>
       (IFixedValueParameter<BoolValue>)Parameters[UseSoftConstraintsParameterName];
@@ -55 +75 @@
     public IValueParameter<IBoundsEstimator> BoundsEstimatorParameter =>
       (IValueParameter<IBoundsEstimator>)Parameters[BoundsEstimatorParameterName];
+
     public IFixedValueParameter<DoubleValue> PenaltyFactorParameter =>
       (IFixedValueParameter<DoubleValue>)Parameters[PenaltyFactorParameterName];
+
+    public IFixedValueParameter<IntValue> GenerationOfConvergenceParameter =>
+      (IFixedValueParameter<IntValue>)Parameters[GenerationOfConvergenceParameterName];
+
+    public IFixedValueParameter<DoubleValue> AlphaParameter =>
+      (IFixedValueParameter<DoubleValue>)Parameters[AlphaParameterName];
+
+    public ILookupParameter<ResultCollection> ResultCollectionParameter =>
+      (ILookupParameter<ResultCollection>)Parameters[ResultCollectionParameterName];
+
+    public IResultParameter<DataTable> LPValueParameter {
+      get {
+        if (Parameters.TryGetValue(LPValueParameterName, out IParameter p))
+          return (IResultParameter<DataTable>)p;
+        return null;
+      }
+    }
+
+    public IFixedValueParameter<BoolValue> UseDynamicPenaltyImpl1Parameter =>
+      (IFixedValueParameter<BoolValue>)Parameters[UseDynamicPenaltyImpl1ParameterName];
+
+    public IFixedValueParameter<BoolValue> UseDynamicPenaltyImpl2Parameter =>
+      (IFixedValueParameter<BoolValue>)Parameters[UseDynamicPenaltyImpl2ParameterName];
+
+    public IFixedValueParameter<BoolValue> UseDynamicPenaltyImpl3Parameter =>
+      (IFixedValueParameter<BoolValue>)Parameters[UseDynamicPenaltyImpl3ParameterName];
+
+    public IFixedValueParameter<BoolValue> UseAdditivePenaltyParameter =>
+      (IFixedValueParameter<BoolValue>)Parameters[UseAdditivePenaltyParameterName];
+
+    public IFixedValueParameter<IntValue> StepSizeParameter =>
+      (IFixedValueParameter<IntValue>)Parameters[StepSizeParameterName];
+
+    public IFixedValueParameter<IntValue> MaximumStepsParameter =>
+      (IFixedValueParameter<IntValue>)Parameters[MaximumStepsParameterName];
+
+    public IResultParameter<DataTable> RisingPenaltyParameter {
+      get {
+        if (Parameters.TryGetValue(RisingPenaltyParameterName, out IParameter p))
+          return (IResultParameter<DataTable>)p;
+        return null;
+      }
+    }
+
+    public IFixedValueParameter<DoubleValue> StartpenaltyParameter =>
+      (IFixedValueParameter<DoubleValue>)Parameters[StartpenaltyParameterName];
 
     public bool OptimizeParameters {
@@ -68 +135 @@
     }
 
+    public bool UseConstraints {
+      get => UseConstraintsParameter.Value.Value;
+      set => UseConstraintsParameter.Value.Value = value;
+    }
+
     public bool UseSoftConstraints {
       get => UseSoftConstraintsParameter.Value.Value;
@@ -78 +150 @@
     }
 
-    public double PenalityFactor {
+    public double PenaltyFactor {
       get => PenaltyFactorParameter.Value.Value;
       set => PenaltyFactorParameter.Value.Value = value;
     }
 
+    public int GenerationOfConvergence {
+      get => GenerationOfConvergenceParameter.Value.Value;
+      set => GenerationOfConvergenceParameter.Value.Value = value;
+    }
+
+    public double Alpha {
+      get => AlphaParameter.Value.Value;
+      set => AlphaParameter.Value.Value = value;
+    }
+
+    public ResultCollection ResultCollection => 
+      ResultCollectionParameter.ActualValue;
+
+    private IntValue Generations {
+      get {
+        IResult result;
+        ResultCollection.TryGetValue(GenerationsEntry, out result);
+        if (result == null) return new IntValue(0);
+        return result.Value == null ? new IntValue(0) : (IntValue)result.Value;
+      }
+    }
 
     public override bool Maximization => false; // NMSE is minimized
@@ -99 +192 @@
       Parameters.Add(new FixedValueParameter<BoolValue>(OptimizeParametersParameterName,
         "Define whether optimization of numeric parameters is active or not (default: false).", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseConstraintsParameterName,
+        "Define whether evaluation of constraints is active or not (default: true).", new BoolValue(true)));
       Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName,
         "Define how many parameter optimization steps should be performed (default: 10).", new IntValue(10)));
@@ -107 +202 @@
       Parameters.Add(new FixedValueParameter<DoubleValue>(PenaltyFactorParameterName,
         "Punishment factor for constraint violations for soft constraint handling (fitness = NMSE + penaltyFactor * avg(violations)) (default: 1.0)", new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<IntValue>(GenerationOfConvergenceParameterName, "", new IntValue(100)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(AlphaParameterName, "", new DoubleValue(0.9)));
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName, "The result collection to store the analysis results."));
+
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseDynamicPenaltyImpl1ParameterName, "", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseDynamicPenaltyImpl2ParameterName, "", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseDynamicPenaltyImpl3ParameterName, "", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseAdditivePenaltyParameterName, "", new BoolValue(false)));
+      
+
+      Parameters.Add(new FixedValueParameter<IntValue>(StepSizeParameterName,
+        "Defines the step size for the increasing penalty multiplier.", new IntValue(1)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumStepsParameterName,
+        "Defines maximum steps for the increasing penalty multiplier.", new IntValue(1000)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(StartpenaltyParameterName,
+        "The start value for the penalty multiplier.", new DoubleValue(0.5)));
+
+      /*
+      Parameters.Add(new ResultParameter<DataTable>(RisingPenaltyParameterName,
+        "Shows the behavior of the penalty multiplier."));
+      RisingPenaltyParameter.DefaultValue = new DataTable(RisingPenaltyParameterName) {
+        VisualProperties = {
+          XAxisTitle = "Generations",
+          YAxisTitle = "penalty Multiplier"
+        }
+      };
+
+
+      Parameters.Add(new ResultParameter<DataTable>(LPValueParameterName,
+        "Low Pass Value"));
+      LPValueParameter.DefaultValue = new DataTable(LPValueParameterName) {
+        VisualProperties = {
+          XAxisTitle = "Generations",
+          YAxisTitle = "Value"
+        }
+      };*/
     }
 
@@ -125 +256 @@
       var estimationLimits = EstimationLimitsParameter.ActualValue;
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
-
+      
       if (OptimizeParameters) {
         SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, rows,
@@ -165 +296 @@
 
       var quality = Calculate(interpreter, tree, estimationLimits.Lower, estimationLimits.Upper, problemData, rows,
-        BoundsEstimator, UseSoftConstraints, PenalityFactor);
+        BoundsEstimator, UseConstraints, UseSoftConstraints, 
+        UseDynamicPenaltyImpl1Parameter.Value.Value, UseDynamicPenaltyImpl2Parameter.Value.Value, 
+        UseDynamicPenaltyImpl3Parameter.Value.Value, UseAdditivePenaltyParameter.Value.Value,
+        PenaltyFactor,
+        StepSizeParameter.Value.Value, StartpenaltyParameter.Value.Value, MaximumStepsParameter.Value.Value, 
+        RisingPenaltyParameter?.ActualValue,
+        Generations.Value, GenerationOfConvergence, Alpha,
+        LPValueParameter);
       QualityParameter.ActualValue = new DoubleValue(quality);
 
       return base.InstrumentedApply();
     }
+
+    public override void InitializeState() {
+      oldValue = 0.0;
+      actualValue = 0.0;
+      oldGeneration = 0;
+      base.InitializeState();
+    }
+
+    // bei mehrmaligen ausführungen bleibt der state!
+    private static int oldGeneration = 0;
+    private static double oldValue = 0.0;
+    private static double actualValue = 0.0;
 
     public static double Calculate(
@@ -177 +327 @@
       IRegressionProblemData problemData, IEnumerable<int> rows,
       IBoundsEstimator estimator,
-      bool useSoftConstraints = false, double penaltyFactor = 1.0) {
+      bool useConstraints, bool useSoftConstraints = false, 
+      bool useDynamicConstraints1 = false, bool useDynamicConstraints2 = false, bool useDynamicConstraints3 = false,
+      bool useAdditivePenalty = false,
+      double penaltyFactor = 1.0,
+      int stepSize = 1, double startpenalty = 0.5, int maximumSteps = 1000, DataTable penaltyDataTable = null,
+      int generation = 0, int generationOfConvergence = 100, double alpha = 0.9,
+      IResultParameter<DataTable> lpValueParameter = null) {
+
+      double risingPenalty = 1.0;
+      if (useDynamicConstraints1) {
+        risingPenalty = LinearDiscreteDoubleValueModifier.Apply(0, startpenalty, 1.0,
+          (int)(generation / stepSize) * stepSize, 0, maximumSteps);
+      }
+
+      if (oldGeneration != generation) {
+        oldGeneration = generation;
+
+        if(lpValueParameter != null) {
+          var LPValueParameterDataTable = lpValueParameter.ActualValue;
+          if (LPValueParameterDataTable.Rows.Count == 0)
+            LPValueParameterDataTable.Rows.Add(new DataRow(LPValueParameterName));
+
+          LPValueParameterDataTable.Rows[LPValueParameterName]
+            .Values
+            .Add(oldValue);
+        }
+        
+        if (penaltyDataTable != null && useDynamicConstraints1) {
+          if (penaltyDataTable.Rows.Count == 0)
+            penaltyDataTable.Rows.Add(new DataRow("LinearDiscreteDoubleValueModifier"));
+          penaltyDataTable.Rows["LinearDiscreteDoubleValueModifier"].Values.Add(risingPenalty);
+        }
+
+        oldValue = actualValue;
+      }
 
       var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, rows);
@@ -189 +373 @@
 
       if (errorState != OnlineCalculatorError.None) {
-        return 1.0;
+        actualValue = alpha * 1.0 + (1.0 - alpha) * actualValue;
+        return 10000.0;
+      }
+
+      if (!useConstraints)
+        return nmse;
+
+
+      if(useDynamicConstraints2) {
+        foreach(var c in constraints) {
+          if(!double.IsNegativeInfinity(c.DynInterval.LowerBound) && !double.IsPositiveInfinity(c.DynInterval.UpperBound)) {
+            int step = (int)(generation / stepSize) * stepSize;
+            var lb = LinearDiscreteDoubleValueModifier.Apply(0, c.DynInterval.LowerBound, c.TargetInterval.LowerBound, step, 0, maximumSteps);
+            var ub = LinearDiscreteDoubleValueModifier.Apply(0, c.DynInterval.UpperBound, c.TargetInterval.UpperBound, step, 0, maximumSteps);
+            c.Interval = new Interval(lb, ub);
+          }
+        }
+      } else {
+        foreach (var c in constraints) {
+          c.Interval = new Interval(c.TargetInterval.LowerBound, c.TargetInterval.UpperBound);
+        }
       }
 
       var constraintViolations = IntervalUtil.GetConstraintViolations(constraints, estimator, intervalCollection, tree);
+      var constraintBounds = IntervalUtil.GetModelBounds(constraints, estimator, intervalCollection, tree);
 
       if (constraintViolations.Any(x => double.IsNaN(x) || double.IsInfinity(x))) {
-        return 1.0;
-      }
+        actualValue = alpha * 1.0 + (1.0 - alpha) * actualValue;
+        return 10000.0;
+      }
+
+
+      /*
+      if(constraintViolations.Any(x => x > 0.0)) {
+        actualValue = alpha * 1.0 + (1.0 - alpha) * actualValue;
+      } else {
+        actualValue *= (1.0 - alpha);
+      }*/
 
       if (useSoftConstraints) {
@@ -202 +416 @@
           throw new ArgumentException("The parameter has to be greater or equal 0.0!", nameof(penaltyFactor));
 
+
+        var errors = constraints
+          .Zip(constraintBounds, CalcSoftConstraintError);
+
+        var weightedViolationSum = constraints
+          .Zip(errors, (c, e) => c.Weight * e)
+          .Average();
+
+        /*
         var weightedViolationSum = constraints
           .Zip(constraintViolations, (c, v) => c.Weight * v)
           .Average();
-
-        return Math.Min(nmse, 1.0) + penaltyFactor * weightedViolationSum;
+        */
+
+        actualValue = alpha * errors.Average() + (1.0 - alpha) * actualValue;
+
+        var violation = (weightedViolationSum * penaltyFactor);
+        if (useDynamicConstraints1)
+          violation *= risingPenalty;
+
+
+        if (useDynamicConstraints3)
+          violation *= oldValue;
+
+        if (useAdditivePenalty)
+          nmse += violation;
+        else
+          nmse += nmse * violation;
+
+
+        return nmse;
+          //Math.Min(nmse, 1.0) + 
+          //(Math.Min(nmse, 1.0) * 
+          //(//(penaltyFactor * oldValue) * 
+          /*Math.Min(penaltyFactor, penaltyFactor * ((generation + 1) / generationOfConvergence)) * */ /* penaltyFactor rises over time */
+          //penaltyFactor * weightedViolationSum);
       } else if (constraintViolations.Any(x => x > 0.0)) {
         return 1.0;
-      }
+      } // globale constraints -> wenn diese verletzt werden -> nmse = 1.0 ????
+        // analyzer -> avg. quality von lösung die nix verletzen
+
 
       return nmse;
+    }
+
+    private static double CalcSoftConstraintError(ShapeConstraint constraint, Interval bounds) {
+      if (!constraint.Interval.Contains(bounds)) {
+
+        // get the absolute threshold bounds
+        var thresholdLb = Math.Abs(constraint.Threshold.LowerBound);
+        var thresholdUb = Math.Abs(constraint.Threshold.UpperBound);
+
+        // calc the absolute bound errors
+        var errorLb = 0.0;//Math.Abs(Math.Abs(b.LowerBound) - Math.Abs(c.Interval.LowerBound));
+        var errorUb = 0.0;//Math.Abs(Math.Abs(b.UpperBound) - Math.Abs(c.Interval.UpperBound));
+
+        if (!constraint.Interval.Contains(bounds.LowerBound)) {
+          errorLb = Math.Abs(bounds.LowerBound - constraint.Interval.LowerBound); // immer einfach 0 als "Mitte"?
+        }
+
+        if (!constraint.Interval.Contains(bounds.UpperBound)) {
+          errorUb = Math.Abs(bounds.UpperBound - constraint.Interval.UpperBound);
+        }
+
+        double relativeLb;
+        if (double.IsInfinity(thresholdLb))
+          relativeLb = 0.0;
+        if (thresholdLb > 0.0) {
+          relativeLb = errorLb / thresholdLb;
+          relativeLb = double.IsNaN(relativeLb) ? 1.0 : Math.Min(relativeLb, 1.0);
+        } else
+          relativeLb = 1.0;
+
+        double relativeUb;
+        if (double.IsInfinity(thresholdUb))
+          relativeUb = 0.0;
+        else if (thresholdUb > 0.0) {
+          relativeUb = errorUb / thresholdUb;
+          relativeUb = double.IsNaN(relativeUb) ? 1.0 : Math.Min(relativeUb, 1.0);
+        } else
+          relativeUb = 1.0;
+
+        var error = (relativeLb + relativeUb) / 2.0;
+        //actualValue = alpha * error + (1.0 - alpha) * actualValue;
+        return error; //* constraint.Weight;
+      }
+      //actualValue *= (1.0 - alpha);
+      return 0.0;
     }
 
@@ -223 +515 @@
       var nmse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
         EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
-        problemData, rows, BoundsEstimator, UseSoftConstraints, PenalityFactor);
+        problemData, rows, BoundsEstimator, UseConstraints, UseSoftConstraints, 
+        UseDynamicPenaltyImpl1Parameter.Value.Value, UseDynamicPenaltyImpl2Parameter.Value.Value,
+        UseDynamicPenaltyImpl3Parameter.Value.Value, UseAdditivePenaltyParameter.Value.Value,
+        PenaltyFactor,
+        StepSizeParameter.Value.Value, StartpenaltyParameter.Value.Value, MaximumStepsParameter.Value.Value);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;

branches/3119_AdditionalShapeConstraintFeatures/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs

@@ -38 +38 @@
     private const string ModelDepthResultName = "Model Depth";
 
+    private const string ConstraintViolationsResultsResultName = "Constraint Violations Results";
+
     private const string EstimationLimitsResultsResultName = "Estimation Limits Results";
     private const string EstimationLimitsResultName = "Estimation Limits";
@@ -64 +66 @@
       get { return ((IntValue)this[ModelDepthResultName].Value).Value; }
       private set { ((IntValue)this[ModelDepthResultName].Value).Value = value; }
+    }
+
+    public ResultCollection ConstraintViolationsResults {
+      get { return (ResultCollection)this[ConstraintViolationsResultsResultName].Value; }
     }
 
@@ -136 +142 @@
       estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
       Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
+
+
+      ResultCollection constraintViolationResults = new ResultCollection();
+      constraintViolationResults.Add(new Result("Violations", "Count of constraint violations", new IntValue()));
+      foreach (var constraint in problemData.ShapeConstraints.EnabledConstraints)
+        constraintViolationResults.Add(new Result(constraint.ToString(), "", new DoubleValue()));
+      Add(new Result(ConstraintViolationsResultsResultName, "Results concerning the constraint violations of symbolic regression solution", constraintViolationResults));
 
       if (IntervalInterpreter.IsCompatible(Model.SymbolicExpressionTree))
@@ -159 +172 @@
         estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
         Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
+
         CalculateResults();
       }
@@ -178 +192 @@
       ModelLength = Model.SymbolicExpressionTree.Length;
       ModelDepth = Model.SymbolicExpressionTree.Depth;
+
+      var constraints = ProblemData.ShapeConstraints.EnabledConstraints;
+      var estimator = new IntervalArithBoundsEstimator();
+      int violationCounter = 0;
+      foreach (var constraint in constraints) {
+        constraint.Interval = new Interval(constraint.TargetInterval.LowerBound, constraint.TargetInterval.UpperBound);
+        var v = IntervalUtil.GetConstraintViolation(constraint, estimator, ProblemData.VariableRanges, Model.SymbolicExpressionTree);
+        ((DoubleValue)ConstraintViolationsResults[constraint.ToString()].Value).Value = v;
+        if(double.IsNaN(v) || double.IsInfinity(v) || v > 0) {
+          violationCounter++;
+        }
+      }
+      ((IntValue)ConstraintViolationsResults["Violations"].Value).Value = violationCounter;
+
+
+      /*
+      if(constraints.Count() > 0)
+        ConstraintViolationsResults = 
+          IntervalUtil.GetConstraintViolations(
+            constraints, 
+            new IntervalArithBoundsEstimator(), 
+            ProblemData.VariableRanges, 
+            Model.SymbolicExpressionTree)
+          .Where(x => x > 0.0).Count();
+      */
 
       EstimationLimits.Lower = Model.LowerEstimationLimit;

branches/3119_AdditionalShapeConstraintFeatures/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs

@@ -28 +28 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   public static class IntervalUtil {
+    public static IEnumerable<Interval> GetModelBounds(
+      IEnumerable<ShapeConstraint> constraints, IBoundsEstimator estimator, IntervalCollection intervalCollection,
+      ISymbolicExpressionTree solution) {
+      return constraints.Select(constraint => GetModelBound(constraint, estimator, intervalCollection, solution)).ToList();
+    }
+
+    public static Interval GetModelBound(
+      ShapeConstraint constraint, IBoundsEstimator estimator, IntervalCollection variableRanges,
+      ISymbolicExpressionTree tree) {
+      var regionRanges = GetRegionRanges(constraint, variableRanges);
+      tree = DeriveTree(tree, constraint, estimator);
+      return estimator.GetModelBound(tree, regionRanges);
+    }
+
     public static IEnumerable<double> GetConstraintViolations(
       IEnumerable<ShapeConstraint> constraints, IBoundsEstimator estimator, IntervalCollection intervalCollection,
@@ -37 +51 @@
       ShapeConstraint constraint, IBoundsEstimator estimator, IntervalCollection variableRanges,
       ISymbolicExpressionTree tree) {
+
+      var regionRanges = GetRegionRanges(constraint, variableRanges);
+      tree = DeriveTree(tree, constraint, estimator);
+      return estimator.GetConstraintViolation(tree, regionRanges, constraint);
+      /*
+      if (!constraint.IsDerivative) {
+        return estimator.GetConstraintViolation(tree, regionRanges, constraint);
+      } else {
+        for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
+          if (!estimator.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree)) {
+            throw new ArgumentException("The tree contains an unsupported symbol.");
+          }
+
+          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
+        }
+
+        return estimator.GetConstraintViolation(tree, regionRanges, constraint);
+      }
+      */
+    }
+
+    private static ISymbolicExpressionTree DeriveTree(ISymbolicExpressionTree tree, ShapeConstraint constraint, IBoundsEstimator estimator) {
+      if (constraint.IsDerivative) {
+        for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
+          if (!estimator.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree))
+            throw new ArgumentException("The tree contains an unsupported symbol.");
+          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
+        }
+      }
+      return tree;
+    }
+
+    private static IntervalCollection GetRegionRanges(ShapeConstraint constraint, IntervalCollection variableRanges) {
       var varRanges = variableRanges.GetReadonlyDictionary();
 
@@ -55 +102 @@
       }
 
-      if (!constraint.IsDerivative) {
-        return estimator.GetConstraintViolation(tree, regionRanges, constraint);
-      } else {
-        for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
-          if (!estimator.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree)) {
-            throw new ArgumentException("The tree contains an unsupported symbol.");
-          }
-
-          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
-        }
-
-        return estimator.GetConstraintViolation(tree, regionRanges, constraint);
-      }
+      return regionRanges;
     }
   }

branches/3119_AdditionalShapeConstraintFeatures/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraint.cs

@@ -107 +107 @@
 
     [Storable]
-    private Interval threshold;
+    private Interval threshold = new Interval(0, 0);
     public Interval Threshold {
       get => threshold;
@@ -114 +114 @@
           return;
         threshold = value;
+        OnToStringChanged();
+        OnChanged();
+      }
+    }
+
+
+    [Storable]
+    private Interval targetInterval;
+    public Interval TargetInterval {
+      get => targetInterval;
+      set {
+        if (targetInterval == value)
+          return;
+        targetInterval = value;
+        OnToStringChanged();
+        OnChanged();
+      }
+    }
+
+    [Storable]
+    private Interval dynInterval = new Interval(double.NegativeInfinity, double.PositiveInfinity);
+    public Interval DynInterval {
+      get => dynInterval;
+      set {
+        if (dynInterval == value)
+          return;
+        dynInterval = value;
         OnToStringChanged();
         OnChanged();
@@ -125 +152 @@
     private void AfterDeserialization() {
       if (regions != null) regions.Changed += regions_Changed;
+      if (TargetInterval == null)
+        TargetInterval = new Interval(interval.LowerBound, interval.UpperBound);
     }
 
     // without derivation
-    public ShapeConstraint(Interval interval, double weight, Interval threshold)
+    public ShapeConstraint(Interval interval, double weight, Interval threshold, Interval dynInterval)
       : this(string.Empty, 0,
-         interval, new IntervalCollection(), weight, threshold) { }
-
-    public ShapeConstraint(Interval interval, IntervalCollection regions, double weight, Interval threshold)
+         interval, new IntervalCollection(), weight, threshold, dynInterval) { }
+
+    public ShapeConstraint(Interval interval, IntervalCollection regions, double weight, Interval threshold, Interval dynInterval)
       : this(string.Empty, 0,
-         interval, regions, weight, threshold) { }
+         interval, regions, weight, threshold, dynInterval) { }
 
     public ShapeConstraint(string variable, int numberOfDerivations,
-                              Interval interval, double weight, Interval threshold)
+                              Interval interval, double weight, Interval threshold, Interval dynInterval)
       : this(variable, numberOfDerivations,
-             interval, new IntervalCollection(), weight, threshold) { }
+             interval, new IntervalCollection(), weight, threshold, dynInterval) { }
 
     public ShapeConstraint(string variable, int numberOfDerivations,
-                              Interval interval, IntervalCollection regions, double weight, Interval threshold) {
+                              Interval interval, IntervalCollection regions, double weight, Interval threshold, Interval dynInterval) {
       Variable = variable;
       NumberOfDerivations = numberOfDerivations;
@@ -149 +178 @@
       Weight = weight;
       Threshold = threshold;
+      DynInterval = dynInterval;
+      TargetInterval = new Interval(interval.LowerBound, interval.UpperBound);
     }
 
@@ -162 +193 @@
       Regions = cloner.Clone(original.Regions);
       Weight = original.weight;
-    }
-
+      Threshold = original.Threshold;
+      DynInterval = original.DynInterval;
+      TargetInterval = original.TargetInterval;
+    }
 
     public event EventHandler Changed;
@@ -188 +221 @@
       string write(double val) => double.IsPositiveInfinity(val) ? "inf." : double.IsNegativeInfinity(val) ? "-inf." : $"{val}";
       if (!IsDerivative) {
-        expression = string.Format($"f in [{write(Interval.LowerBound)} .. {write(Interval.UpperBound)}]");
+        expression = string.Format($"f in [{write(TargetInterval.LowerBound)} .. {write(TargetInterval.UpperBound)}]");
       } else {
         var derivationString = string.Empty;
@@ -199 +232 @@
             derivationString = "³"; break;
         }
-        expression = string.Format($"∂{derivationString}f/∂{Variable}{derivationString} in [{write(Interval.LowerBound)} .. {write(Interval.UpperBound)}]");
+        expression = string.Format($"∂{derivationString}f/∂{Variable}{derivationString} in [{write(TargetInterval.LowerBound)} .. {write(TargetInterval.UpperBound)}]");
       }
 
@@ -209 +242 @@
         expression += $" weight: {weight}";
       }
+
       if (!double.IsNegativeInfinity(Threshold.LowerBound) || !double.IsPositiveInfinity(Threshold.UpperBound))
-        expression += $" threshold: [{write(Threshold.LowerBound)} .. {write(Threshold.UpperBound)}]";
+        expression += $" threshold in [{write(Threshold.LowerBound)} .. {write(Threshold.UpperBound)}]";
+
+      if (!double.IsNegativeInfinity(DynInterval.LowerBound) && !double.IsPositiveInfinity(DynInterval.UpperBound))
+        expression += $" start in [{write(DynInterval.LowerBound)} .. {write(DynInterval.UpperBound)}]";
 
       return expression;

branches/3119_AdditionalShapeConstraintFeatures/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraintsParser.cs

@@ -76 +76 @@
     private const string weightRegex = @"\s*(weight:\s*(?<weight>\S*))?";
     private const string thresholdRegex = @"\s*(threshold\s*in\s*(?<threshold> "+ intervalRegex + @"))?";
+    private const string dynIntervalStartRegex = @"\s*(start\s*in\s*(?<dynInterval> " + intervalRegex + @"))?";
     public static ShapeConstraint ParseFunctionRangeConstraint(string expr) {
       if (!expr.StartsWith("f")) throw new ArgumentException($"Invalid function range constraint {expr} (e.g. f in [1..2])");
@@ -90 +91 @@
       // df/d'x' in [0 .. 10] weight: 2.0
       // df / d'x' in [0..10], 'x' in [1 .. 3]
-      // df / d'x' in [0..10], 'x' in [1 .. 3], y in [10..30] weight: 1.2
-      // df / d'x' in [0..10], 'x' in [1 .. 3], y in [10..30] weight: 1.2 threshold in [-10 .. 10]
+      // df / d'x' in [0..10], 'x' in [1 .. 3], 'y' in [10..30] weight: 1.2
+      // df / d'x' in [0..10], 'x' in [1 .. 3], 'y' in [10..30] weight: 1.2 threshold in [-10 .. 10]
       var match = Regex.Match(targetConstraint,
                     @"\s*\bin\b" +
@@ -101 +102 @@
                     @")*" +
                     weightRegex +
-                    thresholdRegex
+                    thresholdRegex +
+                    dynIntervalStartRegex
                     );
 
@@ -112 +114 @@
         var interval = new Interval(lowerBound, upperBound);
         var weight = 1.0;
-        var threshold = new Interval(double.NegativeInfinity, double.PositiveInfinity);
+        var threshold = new Interval(0, 0);
+        Interval dynInterval = new Interval(double.NegativeInfinity, double.PositiveInfinity);
+        int intervalIdx = 1;
+        var lowerboundCount = match.Groups["lowerBound"].Captures.Count;
+        var upperboundCount = match.Groups["upperBound"].Captures.Count;
 
         if (match.Groups["weight"].Success && !string.IsNullOrWhiteSpace(match.Groups["weight"].Value))
           weight = ParseAndValidateDouble(match.Groups["weight"].Value);
 
-        if(match.Groups["threshold"].Success) {
-          var lowerboundCount = match.Groups["lowerBound"].Captures.Count;
-          var upperboundCount = match.Groups["upperBound"].Captures.Count;
-          var thresholdLb = ParseIntervalBounds(match.Groups["lowerBound"].Captures[lowerboundCount - 1].Value);
-          var thresholdUb = ParseIntervalBounds(match.Groups["upperBound"].Captures[upperboundCount - 1].Value);
+        if (match.Groups["dynInterval"].Success) {
+          var dynIntervalLb = ParseIntervalBounds(match.Groups["lowerBound"].Captures[lowerboundCount - intervalIdx].Value);
+          var dynIntervalUb = ParseIntervalBounds(match.Groups["upperBound"].Captures[upperboundCount - intervalIdx].Value);
+          intervalIdx++;
+          dynInterval = new Interval(dynIntervalLb, dynIntervalUb);
+        }
+
+        if (match.Groups["threshold"].Success) {
+          var thresholdLb = ParseIntervalBounds(match.Groups["lowerBound"].Captures[lowerboundCount - intervalIdx].Value);
+          var thresholdUb = ParseIntervalBounds(match.Groups["upperBound"].Captures[upperboundCount - intervalIdx].Value);
+          intervalIdx++;
           threshold = new Interval(thresholdLb, thresholdUb);
         }
+
 
         if (match.Groups["varName"].Success) {
@@ -138 +151 @@
               throw new ArgumentException($"The constraint {expr} has multiple regions of the same variable.");
           }
-          return new ShapeConstraint(interval, regions, weight, threshold);
+          return new ShapeConstraint(interval, regions, weight, threshold, dynInterval);
         } else
-          return new ShapeConstraint(interval, weight, threshold);
+          return new ShapeConstraint(interval, weight, threshold, dynInterval);
       } else
         throw new ArgumentException($"The target constraint {expr} is not valid.");
@@ -160 +173 @@
                                   @")*" +
                                 weightRegex +
-                                thresholdRegex
+                                thresholdRegex +
+                                dynIntervalStartRegex
                                 );
 
@@ -184 +198 @@
         var interval = new Interval(lowerBound, upperBound);
         var weight = 1.0;
-        var threshold = new Interval(double.NegativeInfinity, double.PositiveInfinity);
+        var threshold = new Interval(0, 0);
+        Interval dynInterval = new Interval(double.NegativeInfinity, double.PositiveInfinity);
+        int intervalIdx = 1;
+        var lowerboundCount = match.Groups["lowerBound"].Captures.Count;
+        var upperboundCount = match.Groups["upperBound"].Captures.Count;
 
         if (match.Groups["weight"].Success && !string.IsNullOrWhiteSpace(match.Groups["weight"].Value))
           weight = ParseAndValidateDouble(match.Groups["weight"].Value);
 
+        if (match.Groups["dynInterval"].Success) {
+          var dynIntervalLb = ParseIntervalBounds(match.Groups["lowerBound"].Captures[lowerboundCount - intervalIdx].Value);
+          var dynIntervalUb = ParseIntervalBounds(match.Groups["upperBound"].Captures[upperboundCount - intervalIdx].Value);
+          intervalIdx++;
+          dynInterval = new Interval(dynIntervalLb, dynIntervalUb);
+        }
+
         if (match.Groups["threshold"].Success) {
-          var lowerboundCount = match.Groups["lowerBound"].Captures.Count;
-          var upperboundCount = match.Groups["upperBound"].Captures.Count;
-          var thresholdLb = ParseIntervalBounds(match.Groups["lowerBound"].Captures[lowerboundCount - 1].Value);
-          var thresholdUb = ParseIntervalBounds(match.Groups["upperBound"].Captures[upperboundCount - 1].Value);
+          var thresholdLb = ParseIntervalBounds(match.Groups["lowerBound"].Captures[lowerboundCount - intervalIdx].Value);
+          var thresholdUb = ParseIntervalBounds(match.Groups["upperBound"].Captures[upperboundCount - intervalIdx].Value);
+          intervalIdx++;
           threshold = new Interval(thresholdLb, thresholdUb);
         }
@@ -210 +234 @@
               throw new ArgumentException($"The constraint {expr} has multiple regions of the same variable.");
           }
-          return new ShapeConstraint(variable, numberOfDerivation, interval, regions, weight, threshold);
+          return new ShapeConstraint(variable, numberOfDerivation, interval, regions, weight, threshold, dynInterval);
         } else
-          return new ShapeConstraint(variable, numberOfDerivation, interval, weight, threshold);
+          return new ShapeConstraint(variable, numberOfDerivation, interval, weight, threshold, dynInterval);
       } else
         throw new ArgumentException($"The derivation constraint {expr} is not valid.");