Changeset 17328 for branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Extensions/NLOptEvaluator.cs

Timestamp:

10/11/19 20:55:22 (5 years ago)

Author:

gkronber

Message:

#2994 made some fixes in the const-opt evaluator with constraints and added some debugging capabilities

File:

• branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Extensions/NLOptEvaluator.cs (modified) (8 diffs)

branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Extensions/NLOptEvaluator.cs

@@ -31 +31 @@
 using HEAL.Attic;
 using System.Runtime.InteropServices;
+using System.Diagnostics;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -47 +48 @@
     private const string CountEvaluationsParameterName = "Count Function and Gradient Evaluations";
 
+
+    private const string AchievedQualityImprovementParameterName = "AchievedQualityImprovment";
+    private const string NumberOfConstraintViolationsBeforeOptimizationParameterName = "NumberOfConstraintViolationsBeforeOptimization";
+    private const string NumberOfConstraintViolationsAfterOptimizationParameterName = "NumberOfConstraintViolationsAfterOptimization";
+    private const string ConstraintsBeforeOptimizationParameterName = "ConstraintsBeforeOptimization";
+    private const string ViolationsAfterOptimizationParameterName = "ConstraintsAfterOptimization";
+    private const string OptimizationDurationParameterName = "OptimizationDuration";
+
     public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
@@ -77 +86 @@
     public IConstrainedValueParameter<StringValue> SolverParameter {
       get { return (IConstrainedValueParameter<StringValue>)Parameters["Solver"]; }
+    }
+
+
+    public ILookupParameter<DoubleValue> AchievedQualityImprovementParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[AchievedQualityImprovementParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> NumberOfConstraintViolationsBeforeOptimizationParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfConstraintViolationsBeforeOptimizationParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> NumberOfConstraintViolationsAfterOptimizationParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfConstraintViolationsAfterOptimizationParameterName]; }
+    }
+    public ILookupParameter<DoubleArray> ViolationsAfterOptimizationParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[ViolationsAfterOptimizationParameterName]; }
+    }
+    public ILookupParameter<DoubleArray> ViolationsBeforeOptimizationParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[ConstraintsBeforeOptimizationParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> OptimizationDurationParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[OptimizationDurationParameterName]; }
     }
 
@@ -134 +163 @@
       Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
       Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
+
+
+
+      Parameters.Add(new LookupParameter<DoubleValue>(AchievedQualityImprovementParameterName));
+      Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsBeforeOptimizationParameterName));
+      Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsAfterOptimizationParameterName));
+      Parameters.Add(new LookupParameter<DoubleArray>(ConstraintsBeforeOptimizationParameterName));
+      Parameters.Add(new LookupParameter<DoubleArray>(ViolationsAfterOptimizationParameterName));
+      Parameters.Add(new LookupParameter<DoubleValue>(OptimizationDurationParameterName));
     }
 
@@ -141 +179 @@
 
     [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() { }
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(AchievedQualityImprovementParameterName)) {
+        Parameters.Add(new LookupParameter<DoubleValue>(AchievedQualityImprovementParameterName));
+        Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsBeforeOptimizationParameterName));
+        Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsAfterOptimizationParameterName));
+      }
+      if(!Parameters.ContainsKey(ConstraintsBeforeOptimizationParameterName)) {
+        Parameters.Add(new LookupParameter<DoubleArray>(ConstraintsBeforeOptimizationParameterName));
+        Parameters.Add(new LookupParameter<DoubleArray>(ViolationsAfterOptimizationParameterName));
+        Parameters.Add(new LookupParameter<DoubleValue>(OptimizationDurationParameterName));
+
+      }
+    }
 
     private static readonly object locker = new object();
@@ -151 +201 @@
         IEnumerable<int> constantOptimizationRows = GenerateRowsToEvaluate(ConstantOptimizationRowsPercentage.Value);
         var counter = new EvaluationsCounter();
-        quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
-           constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, Solver, ConstantOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateConstantsInTree: UpdateConstantsInTree, counter: counter);
-
         if (ConstantOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
           throw new NotSupportedException();
         }
+
+        var sw = new Stopwatch();
+        sw.Start();
+        quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
+           constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, Solver, 
+           out double qDiff, out double[] constraintsBefore, out double[] constraintsAfter,
+           ConstantOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateConstantsInTree: UpdateConstantsInTree, counter: counter);
+
+        AchievedQualityImprovementParameter.ActualValue = new DoubleValue(qDiff);
+        NumberOfConstraintViolationsBeforeOptimizationParameter.ActualValue = new DoubleValue(constraintsBefore.Count(cv => cv > 0));
+        NumberOfConstraintViolationsAfterOptimizationParameter.ActualValue = new DoubleValue(constraintsAfter.Count(cv => cv > 0));
+        ViolationsBeforeOptimizationParameter.ActualValue = new DoubleArray(constraintsBefore);
+        ViolationsAfterOptimizationParameter.ActualValue = new DoubleArray(constraintsAfter);
+        OptimizationDurationParameter.ActualValue = new DoubleValue(sw.Elapsed.TotalSeconds);
 
         if (CountEvaluations) {
@@ -202 +263 @@
     public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
       ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
-      string solver,
+      string solver, out double qDiff, out double[] constraintsBefore, out double[] constraintsAfter,
       int maxIterations, bool updateVariableWeights = true,
       double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue,
-      bool updateConstantsInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null) {
+      bool updateConstantsInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null
+      ) {
 
       if (!updateVariableWeights) throw new NotSupportedException("not updating variable weights is not supported");
@@ -213 +275 @@
 
       using (var state = new ConstrainedNLSInternal(solver, tree, maxIterations, problemData, 0, 0, 0)) {
+        constraintsBefore = state.BestConstraintValues;
+        double qBefore = state.BestError;
         state.Optimize(ConstrainedNLSInternal.OptimizationMode.UpdateParameters);
-        return state.BestError;
+        constraintsAfter = state.BestConstraintValues;
+        var qOpt = state.BestError;
+        if (constraintsAfter.Any(cv => cv > 1e-8)) qOpt = qBefore;
+        qDiff = qOpt - qBefore;
+        return qOpt;
       }
     }