Changeset 17792

Timestamp:

12/15/20 14:52:22 (4 years ago)

Author:

dpiringe

Message:

#3076

• updated SymbolicRegressionSingleObjectiveMetaModelAnalyzer to find a meta model with and without constant optimization
• added a new result parameter of type DataTable in SymbolicRegressionConstraintAnalyzer to show the absolute number of unsatisfied individuals
• added soft constraints handling for SymbolicRegressionSingleObjectiveConstraintEvaluator

Location:

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

Files:

• SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintEvaluator.cs (modified) (10 diffs)
• SymbolicRegressionConstraintAnalyzer.cs (modified) (7 diffs)
• SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs (modified) (5 diffs)

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

@@ -25 +25 @@
     private const string UseSoftConstraintsParameterName = "Use Soft Constraints Evaluation";
 
-    private const string PenaltyMultiplierParameterName = "Constraints Penalty Multiplier";
+    //private const string PenaltyMultiplierParameterName = "Constraints Penalty Multiplier";
 
     private const string BoundsEstimatorParameterName = "Bounds estimator";
 
+    private const string MaximumPenaltyFactorParamterName = "Maximum Penalty Factor";
+
 
     public IFixedValueParameter<BoolValue> UseConstantOptimizationParameter =>
-      (IFixedValueParameter<BoolValue>) Parameters[UseConstantOptimizationParameterName];
+      (IFixedValueParameter<BoolValue>)Parameters[UseConstantOptimizationParameterName];
 
     public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter =>
-      (IFixedValueParameter<IntValue>) Parameters[ConstantOptimizationIterationsParameterName];
+      (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName];
 
     public IFixedValueParameter<BoolValue> UseSoftConstraintsParameter =>
-      (IFixedValueParameter<BoolValue>) Parameters[UseSoftConstraintsParameterName];
-
-    public IFixedValueParameter<DoubleValue> PenaltyMultiplierParameter =>
-      (IFixedValueParameter<DoubleValue>) Parameters[PenaltyMultiplierParameterName];
+      (IFixedValueParameter<BoolValue>)Parameters[UseSoftConstraintsParameterName];
+
+    //public IFixedValueParameter<DoubleValue> PenaltyMultiplierParameter =>
+      //(IFixedValueParameter<DoubleValue>)Parameters[PenaltyMultiplierParameterName];
 
     public IValueParameter<IBoundsEstimator> BoundsEstimatorParameter =>
-      (IValueParameter<IBoundsEstimator>) Parameters[BoundsEstimatorParameterName];
+      (IValueParameter<IBoundsEstimator>)Parameters[BoundsEstimatorParameterName];
+    public IFixedValueParameter<DoubleValue> MaximumPenaltyFactorParamter =>
+      (IFixedValueParameter<DoubleValue>)Parameters[MaximumPenaltyFactorParamterName];
 
     public bool UseConstantOptimization {
@@ -61 +65 @@
 
     public double PenaltyMultiplier {
-      get => PenaltyMultiplierParameter.Value.Value;
-      set => PenaltyMultiplierParameter.Value.Value = value;
+      get => 1.0;//PenaltyMultiplierParameter.Value.Value;
+      //set => PenaltyMultiplierParameter.Value.Value = value;
     }
 
@@ -68 +72 @@
       get => BoundsEstimatorParameter.Value;
       set => BoundsEstimatorParameter.Value = value;
+    }
+
+    public double MaximumPenaltyFactor {
+      get => MaximumPenaltyFactorParamter.Value.Value;
+      set => MaximumPenaltyFactorParamter.Value.Value = value;
     }
 
@@ -91 +100 @@
       Parameters.Add(new FixedValueParameter<BoolValue>(UseSoftConstraintsParameterName,
         "Define whether the constraints are penalized by soft or hard constraints.", new BoolValue(false)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(PenaltyMultiplierParameterName,
-        "Specify how hard constraints violations should be punished", new DoubleValue(1.0)));
       Parameters.Add(new ValueParameter<IBoundsEstimator>(BoundsEstimatorParameterName,
         "Select the Boundsestimator.", new IABoundsEstimator()));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MaximumPenaltyFactorParamterName,
+        "Specify how hard constraints violations should be punished", new DoubleValue(1.5)));
     }
 
@@ -114 +123 @@
       }
 
-      if (!Parameters.ContainsKey(PenaltyMultiplierParameterName)) {
-        Parameters.Add(new FixedValueParameter<DoubleValue>(PenaltyMultiplierParameterName,
-          "Specify how hard constraints violations should be punished", new DoubleValue(1.0)));
-      }
+      //if (!Parameters.ContainsKey(PenaltyMultiplierParameterName)) {
+      //  Parameters.Add(new FixedValueParameter<DoubleValue>(PenaltyMultiplierParameterName,
+      //    "Specify how hard constraints violations should be punished", new DoubleValue(1.0)));
+      //}
 
       if (!Parameters.ContainsKey(BoundsEstimatorParameterName))
         Parameters.Add(new ValueParameter<IBoundsEstimator>(BoundsEstimatorParameterName,
           "Select the Boundsestimator.", new IABoundsEstimator()));
+
+      if (!Parameters.ContainsKey(MaximumPenaltyFactorParamterName)) {
+        Parameters.Add(new FixedValueParameter<DoubleValue>(MaximumPenaltyFactorParamterName,
+          "Specify how hard constraints violations should be punished", new DoubleValue(1.5)));
+      }
     }
 
@@ -166 +180 @@
             if (node.Symbol.Name == "Offset") {
               node.RemoveSubtree(1);
-              var alphaNode = new ConstantTreeNode(new Constant()) {Value = alpha};
+              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};
+              var betaNode = new ConstantTreeNode(new Constant()) { Value = beta };
               node.AddSubtree(betaNode);
             }
@@ -177 +191 @@
 
       var quality = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows,
-        PenaltyMultiplier, BoundsEstimator);
+        PenaltyMultiplier, BoundsEstimator, UseSoftConstraints, MaximumPenaltyFactor);
       QualityParameter.ActualValue = new DoubleValue(quality);
 
@@ -188 +202 @@
       double upperEstimationLimit,
       IRegressionProblemData problemData, IEnumerable<int> rows,
-      double penaltyMultiplier, IBoundsEstimator estimator) {
+      double penaltyMultiplier, IBoundsEstimator estimator,
+      bool useSoftConstraints, double maximumPenaltyFactor) {
+
       var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
@@ -202 +218 @@
       }
 
-      //if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution,
-      //  out var error)) {
-      //  if (useSoftConstraints) {
-      //    if (double.IsNaN(error) || double.IsInfinity(error)) {
-      //      nmse += penaltyMultiplier * 1.0;
-      //    } else {
-      //      nmse += penaltyMultiplier * error;
-      //    }
-
-      //    nmse = Math.Min(1.0, nmse);
-      //  } else {
-      //    nmse = 1.0;
-      //  }
-      //}
-
-
-      if (IntervalUtil.IntervalConstraintsViolation(constraints, estimator, intervalCollection, solution)
-                      .Any(x => x != 0.0)) {
+      var constraintResults = IntervalUtil.IntervalConstraintsViolation(constraints, estimator, intervalCollection, solution);
+
+      if (constraintResults.Any(x => double.IsNaN(x) || double.IsInfinity(x))) {
+        return 1.0;
+      }
+
+
+      if (useSoftConstraints) {
+        if (maximumPenaltyFactor < 0.0)
+          throw new ArgumentException("The parameter 'Maximum Penalty Factor' has to be greater or equal 0.0!");
+
+        var zip = constraints.Zip(constraintResults, (c, e) => new { Constraint = c, Error = e });
+        double sum = 0.0;
+
+        foreach (var x in zip) {
+          if (x.Constraint.Weight <= 0)
+            throw new ArgumentException("Constraint weights <= 0 are not allowed!");
+
+          double e = x.Error / x.Constraint.Weight;
+
+          e = double.IsNaN(e) ? 0.0 : e;
+          e = e > 1.0 ? 1.0 : e;
+
+          sum += Math.Sqrt(e) * maximumPenaltyFactor;
+        }
+
+        double avgError = sum / zip.Count();
+        nmse = nmse * avgError + nmse;
+        nmse = Math.Min(1.0, nmse);
+      } else if (constraintResults.Any(x => x != 0.0)) {
         nmse = 1.0;
       }
@@ -235 +263 @@
       var nmse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
         EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
-        problemData, rows, PenaltyMultiplier, BoundsEstimator);
+        problemData, rows, PenaltyMultiplier, BoundsEstimator, UseSoftConstraints, MaximumPenaltyFactor);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;

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

@@ -25 +25 @@
     private const string MaximumStepsParameterName = "Maximum Steps";
     private const string StartPenalityParameterName = "Start Penality";
+    private const string ConstraintUnsatisfiedSolutionsParameterName = "Constraint Unsatisfied Solutions";
 
     #region parameter properties
@@ -49 +50 @@
       (IValueParameter<DoubleValue>) Parameters[StartPenalityParameterName];
 
+    public IResultParameter<DataTable> ConstraintUnsatisfiedSolutionsParameter =>
+      (IResultParameter<DataTable>)Parameters[ConstraintUnsatisfiedSolutionsParameterName];
+
     #endregion
 
     public override bool EnabledByDefault => false;
     public static int Iterations { get; set; } = 0;
+
+    public IBoundsEstimator BoundsEstimator { get; set; } = new IABoundsEstimator();
 
     [StorableConstructor]
@@ -79 +85 @@
       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."));
 
 
@@ -92 +100 @@
           XAxisTitle = "Generations",
           YAxisTitle = "Penality Multiplier"
+        }
+      };
+
+      ConstraintUnsatisfiedSolutionsParameter.DefaultValue = new DataTable(ConstraintUnsatisfiedSolutionsParameterName) {
+        VisualProperties = {
+          XAxisTitle = "Generations",
+          YAxisTitle = "Constraint Unsatisfied Solutions"
         }
       };
@@ -137 +152 @@
         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"
+          }
+        };
+      }
     }
 
@@ -158 +186 @@
       var constraints = problemData.IntervalConstraints.EnabledConstraints;
       var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
+      var intervalCollection = problemData.VariableRanges;
       var newDataTable = ConstraintViolationParameter.ActualValue;
+      var solutions = this.SymbolicExpressionTree.ToArray();
 
       if (newDataTable.Rows.Count == 0)
@@ -176 +206 @@
         penalityDataTable.Rows.Add(new DataRow(rowName));
       penalityDataTable.Rows[rowName].Values.Add(penalityMultiplier.Value);
+
+      var constraintUnsatisfiedSolutionsDataTable = ConstraintUnsatisfiedSolutionsParameter.ActualValue;
+      if (constraintUnsatisfiedSolutionsDataTable.Rows.Count == 0)
+        constraintUnsatisfiedSolutionsDataTable.Rows.Add(new DataRow(ConstraintUnsatisfiedSolutionsParameterName));
+
+      constraintUnsatisfiedSolutionsDataTable.Rows[ConstraintUnsatisfiedSolutionsParameterName]
+        .Values
+        .Add(
+          solutions
+          .Where(s => IntervalUtil.IntervalConstraintsViolation(constraints, BoundsEstimator, intervalCollection, s).Any(x => x != 0.0))
+          .Count());
 
       return base.Apply();

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

@@ -10 +10 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -21 +22 @@
 
     #region parameter properties
-    public IResultParameter<ISymbolicRegressionSolution> BestMetaModelParameter =>
-      (IResultParameter<ISymbolicRegressionSolution>)Parameters[BestMetaModelParameterName];
+    public IResultParameter<ItemList<ISymbolicRegressionSolution>> BestMetaModelParameter =>
+      (IResultParameter<ItemList<ISymbolicRegressionSolution>>)Parameters[BestMetaModelParameterName];
     #endregion
 
@@ -32 +33 @@
 
     public SymbolicRegressionSingleObjectiveMetaModelAnalyzer() {
-      Parameters.Add(new ResultParameter<ISymbolicRegressionSolution>(BestMetaModelParameterName,
-        "The best meta model found."));
+      Parameters.Add(new ResultParameter<ItemList<ISymbolicRegressionSolution>>(BestMetaModelParameterName,
+        "A list with the meta model for all problems."));
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      Parameters.Remove(BestMetaModelParameterName);
+
       if (!Parameters.ContainsKey(BestMetaModelParameterName))
-        Parameters.Add(new ResultParameter<ISymbolicRegressionSolution>(BestMetaModelParameterName,
-          "The best meta model found."));
+        Parameters.Add(new ResultParameter<ItemList<ISymbolicRegressionSolution>>(BestMetaModelParameterName,
+          "A list with all meta models for the problems."));
     }
 
@@ -52 +55 @@
       // init
       var solutions = this.SymbolicExpressionTree.ToArray();
+      var bestQualityWithConstantOpt = baseProblem.Maximization.Value ? double.MinValue : double.MaxValue;
+      var bestQualityWithoutConstantOpt = baseProblem.Maximization.Value ? double.MinValue : double.MaxValue;
       var evaluator = baseProblem.Evaluator;
-      var bestQuality = baseProblem.Maximization.Value ? double.MinValue : double.MaxValue;
-      SymbolicRegressionSolution bestMetaModel = null;
-
+      var interpreter = baseProblem.SymbolicExpressionTreeInterpreter;
+      ISymbolicExpressionTree bestSolutionWithConstantOpt = null;
+      ISymbolicExpressionTree bestSolutionWithoutConstantOpt = null;
+      var metaModels = new ItemList<ISymbolicRegressionSolution>();
       // iterate solutions
       foreach (var solution in solutions) {
-        double qualityAvg = CalculateAverageQuality(solution, evaluator, problems);
+        // calculate with constant optimization
+        var tmpSolution = (ISymbolicExpressionTree) solution.Clone();
+        double qualityAvg = CalculateAverageQuality(tmpSolution, evaluator, problems, interpreter, true);
+        // check if this solution is the best
+        bool isBest = baseProblem.Maximization.Value ? (bestQualityWithConstantOpt < qualityAvg) : (bestQualityWithConstantOpt > qualityAvg);
+        if (isBest) {
+          bestQualityWithConstantOpt = qualityAvg;
+          bestSolutionWithConstantOpt = tmpSolution;
+        }
 
+        // calculate it again without constant optimization to have a comparison
+        tmpSolution = (ISymbolicExpressionTree) solution.Clone();
+        qualityAvg = CalculateAverageQuality(tmpSolution, evaluator, problems, interpreter, false);
         // check if this solution is the best
-        bool isBest = baseProblem.Maximization.Value ? (bestQuality < qualityAvg) : (bestQuality > qualityAvg);
+        isBest = baseProblem.Maximization.Value ? (bestQualityWithoutConstantOpt < qualityAvg) : (bestQualityWithoutConstantOpt > qualityAvg);
         if (isBest) {
-          bestQuality = qualityAvg;
-          bestMetaModel = BuildSolution(solution, targetVariable, baseProblem);
+          bestQualityWithoutConstantOpt = qualityAvg;
+          bestSolutionWithoutConstantOpt = tmpSolution;
         }
       }
-      BestMetaModelParameter.ActualValue = bestMetaModel;
+
+      foreach(var problem in problems) {
+        metaModels.Add(BuildSolution(bestSolutionWithConstantOpt, targetVariable, problem, "withConstantOpt"));
+        metaModels.Add(BuildSolution(bestSolutionWithoutConstantOpt, targetVariable, problem, "withoutConstantOpt"));
+      }
+        
+      BestMetaModelParameter.ActualValue = metaModels;
     }
 
@@ -73 +96 @@
       ISymbolicExpressionTree solution, 
       string targetVariable,
-      SymbolicRegressionSingleObjectiveProblem baseProblem) {
+      SymbolicRegressionSingleObjectiveProblem problem,
+      string suffix) {
       var model = new SymbolicRegressionModel(
             targetVariable,
             (ISymbolicExpressionTree)solution.Clone(),
             new SymbolicDataAnalysisExpressionTreeInterpreter());
-      return new SymbolicRegressionSolution(model, baseProblem.ProblemData);
+      return new SymbolicRegressionSolution(model, problem.ProblemData) { Name = $"{problem.Name}_solution_{suffix}" };
     }
 
     private double CalculateAverageQuality(
       ISymbolicExpressionTree solution,
-      ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData> evaluator, 
-      IEnumerable<SymbolicRegressionSingleObjectiveProblem> problems) {
+      ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData> evaluator,
+      IEnumerable<SymbolicRegressionSingleObjectiveProblem> problems,
+      ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+      bool useConstantOptimization) {
       double qualitySum = 0.0;
       // iterate problems
       foreach (var problem in problems) {
-        IDataset dataset = problem.ProblemData.Dataset;
-        IEnumerable<int> rows = Enumerable.Range(0, dataset.Rows);
-        // evalute problem with the evaluator of the base problem
-        qualitySum += evaluator.Evaluate(ExecutionContext, solution, problem.ProblemData, rows);
+        var problemData = problem.ProblemData;
+
+        if (useConstantOptimization) {
+          SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(
+            interpreter, 
+            solution, 
+            problemData, 
+            problemData.TrainingIndices,
+            false, 10, true);
+        }
+
+        qualitySum += evaluator.Evaluate(
+          ExecutionContext,
+          solution,
+          problemData,
+          problemData.TrainingIndices);
       }
+        
       // calculate the average quality
       return qualitySum / problems.Count();