Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Extensions/NLOptEvaluator.cs @ 17328

Last change on this file since 17328 was 17328, checked in by gkronber, 5 years ago

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

File size: 16.8 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Data;
28using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
29using HeuristicLab.Optimization;
30using HeuristicLab.Parameters;
31using HEAL.Attic;
32using System.Runtime.InteropServices;
33using System.Diagnostics;
34
35namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
36  [Item("NLOpt Evaluator (with constraints)", "")]
37  [StorableType("5FADAE55-3516-4539-8A36-BC9B0D00880D")]
38  public class NLOptEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
39    private const string ConstantOptimizationIterationsParameterName = "ConstantOptimizationIterations";
40    private const string ConstantOptimizationImprovementParameterName = "ConstantOptimizationImprovement";
41    private const string ConstantOptimizationProbabilityParameterName = "ConstantOptimizationProbability";
42    private const string ConstantOptimizationRowsPercentageParameterName = "ConstantOptimizationRowsPercentage";
43    private const string UpdateConstantsInTreeParameterName = "UpdateConstantsInSymbolicExpressionTree";
44    private const string UpdateVariableWeightsParameterName = "Update Variable Weights";
45
46    private const string FunctionEvaluationsResultParameterName = "Constants Optimization Function Evaluations";
47    private const string GradientEvaluationsResultParameterName = "Constants Optimization Gradient Evaluations";
48    private const string CountEvaluationsParameterName = "Count Function and Gradient Evaluations";
49
50
51    private const string AchievedQualityImprovementParameterName = "AchievedQualityImprovment";
52    private const string NumberOfConstraintViolationsBeforeOptimizationParameterName = "NumberOfConstraintViolationsBeforeOptimization";
53    private const string NumberOfConstraintViolationsAfterOptimizationParameterName = "NumberOfConstraintViolationsAfterOptimization";
54    private const string ConstraintsBeforeOptimizationParameterName = "ConstraintsBeforeOptimization";
55    private const string ViolationsAfterOptimizationParameterName = "ConstraintsAfterOptimization";
56    private const string OptimizationDurationParameterName = "OptimizationDuration";
57
58    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
59      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
60    }
61    public IFixedValueParameter<DoubleValue> ConstantOptimizationImprovementParameter {
62      get { return (IFixedValueParameter<DoubleValue>)Parameters[ConstantOptimizationImprovementParameterName]; }
63    }
64    public IFixedValueParameter<PercentValue> ConstantOptimizationProbabilityParameter {
65      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationProbabilityParameterName]; }
66    }
67    public IFixedValueParameter<PercentValue> ConstantOptimizationRowsPercentageParameter {
68      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationRowsPercentageParameterName]; }
69    }
70    public IFixedValueParameter<BoolValue> UpdateConstantsInTreeParameter {
71      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateConstantsInTreeParameterName]; }
72    }
73    public IFixedValueParameter<BoolValue> UpdateVariableWeightsParameter {
74      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateVariableWeightsParameterName]; }
75    }
76
77    public IResultParameter<IntValue> FunctionEvaluationsResultParameter {
78      get { return (IResultParameter<IntValue>)Parameters[FunctionEvaluationsResultParameterName]; }
79    }
80    public IResultParameter<IntValue> GradientEvaluationsResultParameter {
81      get { return (IResultParameter<IntValue>)Parameters[GradientEvaluationsResultParameterName]; }
82    }
83    public IFixedValueParameter<BoolValue> CountEvaluationsParameter {
84      get { return (IFixedValueParameter<BoolValue>)Parameters[CountEvaluationsParameterName]; }
85    }
86    public IConstrainedValueParameter<StringValue> SolverParameter {
87      get { return (IConstrainedValueParameter<StringValue>)Parameters["Solver"]; }
88    }
89
90
91    public ILookupParameter<DoubleValue> AchievedQualityImprovementParameter {
92      get { return (ILookupParameter<DoubleValue>)Parameters[AchievedQualityImprovementParameterName]; }
93    }
94    public ILookupParameter<DoubleValue> NumberOfConstraintViolationsBeforeOptimizationParameter {
95      get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfConstraintViolationsBeforeOptimizationParameterName]; }
96    }
97    public ILookupParameter<DoubleValue> NumberOfConstraintViolationsAfterOptimizationParameter {
98      get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfConstraintViolationsAfterOptimizationParameterName]; }
99    }
100    public ILookupParameter<DoubleArray> ViolationsAfterOptimizationParameter {
101      get { return (ILookupParameter<DoubleArray>)Parameters[ViolationsAfterOptimizationParameterName]; }
102    }
103    public ILookupParameter<DoubleArray> ViolationsBeforeOptimizationParameter {
104      get { return (ILookupParameter<DoubleArray>)Parameters[ConstraintsBeforeOptimizationParameterName]; }
105    }
106    public ILookupParameter<DoubleValue> OptimizationDurationParameter {
107      get { return (ILookupParameter<DoubleValue>)Parameters[OptimizationDurationParameterName]; }
108    }
109
110
111    public IntValue ConstantOptimizationIterations {
112      get { return ConstantOptimizationIterationsParameter.Value; }
113    }
114    public DoubleValue ConstantOptimizationImprovement {
115      get { return ConstantOptimizationImprovementParameter.Value; }
116    }
117    public PercentValue ConstantOptimizationProbability {
118      get { return ConstantOptimizationProbabilityParameter.Value; }
119    }
120    public PercentValue ConstantOptimizationRowsPercentage {
121      get { return ConstantOptimizationRowsPercentageParameter.Value; }
122    }
123    public bool UpdateConstantsInTree {
124      get { return UpdateConstantsInTreeParameter.Value.Value; }
125      set { UpdateConstantsInTreeParameter.Value.Value = value; }
126    }
127
128    public bool UpdateVariableWeights {
129      get { return UpdateVariableWeightsParameter.Value.Value; }
130      set { UpdateVariableWeightsParameter.Value.Value = value; }
131    }
132
133    public bool CountEvaluations {
134      get { return CountEvaluationsParameter.Value.Value; }
135      set { CountEvaluationsParameter.Value.Value = value; }
136    }
137
138    public string Solver {
139      get { return SolverParameter.Value.Value; }
140    }
141    public override bool Maximization {
142      get { return false; }
143    }
144
145    [StorableConstructor]
146    protected NLOptEvaluator(StorableConstructorFlag _) : base(_) { }
147    protected NLOptEvaluator(NLOptEvaluator original, Cloner cloner)
148      : base(original, cloner) {
149    }
150    public NLOptEvaluator()
151      : base() {
152      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
153      Parameters.Add(new FixedValueParameter<DoubleValue>(ConstantOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the constant optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
154      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationProbabilityParameterName, "Determines the probability that the constants are optimized", new PercentValue(1)));
155      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for constant optimization", new PercentValue(1)));
156      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)) { Hidden = true });
157      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)) { Hidden = true });
158
159      Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));
160
161      var validSolvers = new ItemSet<StringValue>(new[] { "MMA", "COBYLA", "CCSAQ", "ISRES" }.Select(s => new StringValue(s).AsReadOnly()));
162      Parameters.Add(new ConstrainedValueParameter<StringValue>("Solver", "The solver algorithm", validSolvers, validSolvers.First()));
163      Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
164      Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
165
166
167
168      Parameters.Add(new LookupParameter<DoubleValue>(AchievedQualityImprovementParameterName));
169      Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsBeforeOptimizationParameterName));
170      Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsAfterOptimizationParameterName));
171      Parameters.Add(new LookupParameter<DoubleArray>(ConstraintsBeforeOptimizationParameterName));
172      Parameters.Add(new LookupParameter<DoubleArray>(ViolationsAfterOptimizationParameterName));
173      Parameters.Add(new LookupParameter<DoubleValue>(OptimizationDurationParameterName));
174    }
175
176    public override IDeepCloneable Clone(Cloner cloner) {
177      return new NLOptEvaluator(this, cloner);
178    }
179
180    [StorableHook(HookType.AfterDeserialization)]
181    private void AfterDeserialization() {
182      if (!Parameters.ContainsKey(AchievedQualityImprovementParameterName)) {
183        Parameters.Add(new LookupParameter<DoubleValue>(AchievedQualityImprovementParameterName));
184        Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsBeforeOptimizationParameterName));
185        Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsAfterOptimizationParameterName));
186      }
187      if(!Parameters.ContainsKey(ConstraintsBeforeOptimizationParameterName)) {
188        Parameters.Add(new LookupParameter<DoubleArray>(ConstraintsBeforeOptimizationParameterName));
189        Parameters.Add(new LookupParameter<DoubleArray>(ViolationsAfterOptimizationParameterName));
190        Parameters.Add(new LookupParameter<DoubleValue>(OptimizationDurationParameterName));
191
192      }
193    }
194
195    private static readonly object locker = new object();
196
197    public override IOperation InstrumentedApply() {
198      var solution = SymbolicExpressionTreeParameter.ActualValue;
199      double quality;
200      if (RandomParameter.ActualValue.NextDouble() < ConstantOptimizationProbability.Value) {
201        IEnumerable<int> constantOptimizationRows = GenerateRowsToEvaluate(ConstantOptimizationRowsPercentage.Value);
202        var counter = new EvaluationsCounter();
203        if (ConstantOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
204          throw new NotSupportedException();
205        }
206
207        var sw = new Stopwatch();
208        sw.Start();
209        quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
210           constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, Solver,
211           out double qDiff, out double[] constraintsBefore, out double[] constraintsAfter,
212           ConstantOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateConstantsInTree: UpdateConstantsInTree, counter: counter);
213
214        AchievedQualityImprovementParameter.ActualValue = new DoubleValue(qDiff);
215        NumberOfConstraintViolationsBeforeOptimizationParameter.ActualValue = new DoubleValue(constraintsBefore.Count(cv => cv > 0));
216        NumberOfConstraintViolationsAfterOptimizationParameter.ActualValue = new DoubleValue(constraintsAfter.Count(cv => cv > 0));
217        ViolationsBeforeOptimizationParameter.ActualValue = new DoubleArray(constraintsBefore);
218        ViolationsAfterOptimizationParameter.ActualValue = new DoubleArray(constraintsAfter);
219        OptimizationDurationParameter.ActualValue = new DoubleValue(sw.Elapsed.TotalSeconds);
220
221        if (CountEvaluations) {
222          lock (locker) {
223            FunctionEvaluationsResultParameter.ActualValue.Value += counter.FunctionEvaluations;
224            GradientEvaluationsResultParameter.ActualValue.Value += counter.GradientEvaluations;
225          }
226        }
227
228      } else {
229        throw new NotSupportedException();
230      }
231      QualityParameter.ActualValue = new DoubleValue(quality);
232
233      return base.InstrumentedApply();
234    }
235
236    public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows) {
237      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
238      EstimationLimitsParameter.ExecutionContext = context;
239      ApplyLinearScalingParameter.ExecutionContext = context;
240      FunctionEvaluationsResultParameter.ExecutionContext = context;
241      GradientEvaluationsResultParameter.ExecutionContext = context;
242
243      // MSE evaluator is used on purpose instead of the const-opt evaluator,
244      // because Evaluate() is used to get the quality of evolved models on
245      // different partitions of the dataset (e.g., best validation model)
246      double mse = SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, double.MinValue, double.MaxValue, problemData, rows, applyLinearScaling: false);
247
248      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
249      EstimationLimitsParameter.ExecutionContext = null;
250      ApplyLinearScalingParameter.ExecutionContext = null;
251      FunctionEvaluationsResultParameter.ExecutionContext = null;
252      GradientEvaluationsResultParameter.ExecutionContext = null;
253
254      return mse;
255    }
256
257    public class EvaluationsCounter {
258      public int FunctionEvaluations = 0;
259      public int GradientEvaluations = 0;
260    }
261
262
263    public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
264      ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
265      string solver, out double qDiff, out double[] constraintsBefore, out double[] constraintsAfter,
266      int maxIterations, bool updateVariableWeights = true,
267      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue,
268      bool updateConstantsInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null
269      ) {
270
271      if (!updateVariableWeights) throw new NotSupportedException("not updating variable weights is not supported");
272      if (!updateConstantsInTree) throw new NotSupportedException("not updating tree parameters is not supported");
273      if (!applyLinearScaling) throw new NotSupportedException("application without linear scaling is not supported");
274
275
276      using (var state = new ConstrainedNLSInternal(solver, tree, maxIterations, problemData, 0, 0, 0)) {
277        constraintsBefore = state.BestConstraintValues;
278        double qBefore = state.BestError;
279        state.Optimize(ConstrainedNLSInternal.OptimizationMode.UpdateParameters);
280        constraintsAfter = state.BestConstraintValues;
281        var qOpt = state.BestError;
282        if (constraintsAfter.Any(cv => cv > 1e-8)) qOpt = qBefore;
283        qDiff = qOpt - qBefore;
284        return qOpt;
285      }
286    }
287
288
289  }
290}
Note: See TracBrowser for help on using the repository browser.