Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
08/27/20 13:01:18 (4 years ago)
Author:
dpiringe
Message:

#3076

  • modified SymbolicRegressionConstraintAnalyzer to calculate an error (as out parameter)
    • added an ILookupParameter to write a penality multiplier into the scope
  • changed a lot of evaluators to match the changed analyzer method
  • changed SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator to use a rising penality (instead of setting an unsatisfied solution to 1.0)
Location:
branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs

    r17652 r17733  
    106106                                             ISymbolicExpressionTree solution) {
    107107      return SymbolicRegressionConstraintAnalyzer.ConstraintSatisfied(constraint, new IntervalInterpreter(),
    108                                                                       variableRanges, solution) ? 0 : 1;
     108                                                                      variableRanges, solution, out double error) ? 0 : 1;
    109109    }
    110110
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs

    r17722 r17733  
    4141
    4242    public IFixedValueParameter<IntValue> DimensionsParameter => (IFixedValueParameter<IntValue>)Parameters[DimensionsParameterName];
     43
    4344
    4445    #region Constructors
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptEvaluator.cs

    r17636 r17733  
    4646      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
    4747
    48       if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, tree)) return 0;
     48      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, tree, out double error)) return 0;
    4949
    5050      var r2 = SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData,
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs

    r17660 r17733  
    1515    private const string UseConstOptParameterName = "Use ConstOpt";
    1616    private const string ConstOptIterationsParameterName = "ConstOpt Iterations";
     17    private const string PenalityMultiplierParameterName = "ConstraintsPenalityMultiplier";
    1718
    1819    public IFixedValueParameter<BoolValue> UseConstOptParamerter =>
     
    2122    public IFixedValueParameter<IntValue> ConstOpterIterationsParameter =>
    2223      (IFixedValueParameter<IntValue>) Parameters[ConstOptIterationsParameterName];
     24
     25    public ILookupParameter<DoubleValue> PenalityMultiplierParameter =>
     26      (ILookupParameter<DoubleValue>)Parameters[PenalityMultiplierParameterName];
    2327
    2428    public bool UseConstOpt {
     
    4852      Parameters.Add(new FixedValueParameter<IntValue>(ConstOptIterationsParameterName,
    4953        "Define how many constOpt iterations should be performed.", new IntValue(10)));
     54      Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
     55        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
    5056    }
    5157
     
    6369          "Define how many constOpt iterations should be performed.", new IntValue(10)));
    6470      }
     71
     72      if (!Parameters.ContainsKey(PenalityMultiplierParameterName))
     73        Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
     74          "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
    6575    }
    6676
     
    8191          estimationLimits.Lower, estimationLimits.Upper);
    8292
     93      var penalityMultiplier = PenalityMultiplierParameter.ActualValue?.Value ?? 1.0;
     94
    8395      var quality = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows,
    84         applyLinearScaling);
     96        applyLinearScaling, penalityMultiplier);
    8597      QualityParameter.ActualValue = new DoubleValue(quality);
     98
     99
    86100      return base.InstrumentedApply();
    87101    }
     
    91105      ISymbolicExpressionTree solution, double lowerEstimationLimit,
    92106      double upperEstimationLimit,
    93       IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling) {
     107      IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
     108      double penalityMultiplier) {
    94109      var estimatedValues =
    95110        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
     
    98113      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
    99114
    100       if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution))
    101         return 1.0;
    102 
    103115      var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
    104116      var nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out var errorState);
     117      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, out double error))
     118      {
     119        if (double.IsNaN(error) || double.IsInfinity(error))
     120          nmse += penalityMultiplier * 1.0;
     121        else
     122          nmse += penalityMultiplier * error;
     123        nmse = Math.Min(1.0, nmse);
     124      }
     125
    105126      if (errorState != OnlineCalculatorError.None) nmse = 1.0;
    106127
     
    115136      ApplyLinearScalingParameter.ExecutionContext                  = context;
    116137
     138      var penalityMultiplier = PenalityMultiplierParameter.ActualValue?.Value ?? 1.0;
     139
    117140      var nmse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
    118141        EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
    119142        problemData, rows,
    120         ApplyLinearScalingParameter.ActualValue.Value);
     143        ApplyLinearScalingParameter.ActualValue.Value,
     144        penalityMultiplier);
    121145
    122146      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintPearsonRSquaredEvaluator.cs

    r17652 r17733  
    5050      var tree           = solution;
    5151
    52       if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, tree)) return 0;
     52      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, tree, out double error)) return 0;
    5353
    5454      var r2 = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, solution,
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs

    r17705 r17733  
    8585      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
    8686
    87       if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution))
     87      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, out double error))
    8888        return 1.0;
    8989
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionConstraintAnalyzer.cs

    r17722 r17733  
    33using System.Collections.ObjectModel;
    44using System.Linq;
     5using System.Threading;
    56using HEAL.Attic;
    67using HeuristicLab.Analysis;
    78using HeuristicLab.Common;
    89using HeuristicLab.Core;
     10using HeuristicLab.Data;
    911using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    1012using HeuristicLab.Optimization;
     13using HeuristicLab.Optimization.Operators;
    1114using HeuristicLab.Parameters;
    1215
     
    1720    private const string ProblemDataParameterName         = "ProblemData";
    1821    private const string ConstraintViolationParameterName = "ConstraintViolations";
     22    private const string PenalityMultiplierParameterName = "ConstraintsPenalityMultiplier";
    1923
    2024    #region parameter properties
     
    2630      (IResultParameter<DataTable>) Parameters[ConstraintViolationParameterName];
    2731
     32    public ILookupParameter<DoubleValue> PenalityMultiplierParameter =>
     33      (ILookupParameter<DoubleValue>)Parameters[PenalityMultiplierParameterName];
     34
    2835    #endregion
    2936
    3037    public override bool EnabledByDefault => false;
     38    public static int Iterations { get; set; } = 0;
    3139
    3240    [StorableConstructor]
     
    4250    public SymbolicRegressionConstraintAnalyzer() {
    4351      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName,
    44                                                                  "The problem data of the symbolic data analysis problem."));
     52        "The problem data of the symbolic data analysis problem."));
    4553      Parameters.Add(new ResultParameter<DataTable>(ConstraintViolationParameterName,
    46                                                     "Shows the number of constraint violations!"));
     54        "Shows the number of constraint violations!"));
     55      Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
     56        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
     57
    4758      ConstraintViolationParameter.DefaultValue = new DataTable(ConstraintViolationParameterName) {
    48                                                                                                     VisualProperties = {
    49                                                                                                                          XAxisTitle
    50                                                                                                                            = "Generations",
    51                                                                                                                          YAxisTitle
    52                                                                                                                            = "Constraint Violations"
    53                                                                                                                        }
    54                                                                                                   };
     59        VisualProperties =
     60          {
     61            XAxisTitle = "Generations",
     62            YAxisTitle = "Constraint Violations"
     63          }
     64      };
    5565    }
    5666
     67    public override void InitializeState()
     68    {
     69      Iterations = 0;
     70      base.InitializeState();
     71    }
     72
     73    public override void ClearState()
     74    {
     75      Iterations = 0;
     76      base.ClearState();
     77    }
     78
     79
    5780    [StorableHook(HookType.AfterDeserialization)]
    58     private void AfterDeserialization() { }
     81    private void AfterDeserialization() {
     82      if (!Parameters.ContainsKey(PenalityMultiplierParameterName))
     83        Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
     84        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
     85    }
    5986
    60     public override IOperation Apply() {
     87    public override IOperation Apply()
     88    {
     89      Iterations++;
     90
     91      PenalityMultiplierParameter.ActualValue = new DoubleValue(QuadraticDiscreteDoubleValueModifier.Calculate(0, 0.05, 1.0, Iterations, 0, 2000));
     92      //GeneralizedExponentialDiscreteDoubleValueModifier
     93
    6194      var problemData = RegressionProblemDataParameter.ActualValue;
    6295      var trees       = SymbolicExpressionTreeParameter.ActualValue;
     
    73106      var interpreter = new IntervalInterpreter();
    74107      foreach (var constraint in constraints) {
    75         var violations = trees.Select(tree => ConstraintSatisfied(constraint, interpreter, variableRanges, tree))
     108        var violations = trees.Select(tree => ConstraintSatisfied(constraint, interpreter, variableRanges, tree, out double error))
    76109                              .Count(satisfied => !satisfied);
    77110        newDataTable.Rows[constraint.Expression].Values.Add(violations);
     
    81114    }
    82115
    83     public static bool ConstraintSatisfied(IntervalConstraint            constraint,
    84                                            IntervalInterpreter           intervalInterpreter,
     116    public static bool ConstraintSatisfied(IntervalConstraint constraint,
     117                                           IntervalInterpreter intervalInterpreter,
    85118                                           IReadOnlyDictionary<string, Interval> variableRanges,
    86                                            ISymbolicExpressionTree       solution) {
     119                                           ISymbolicExpressionTree solution,
     120                                           out double error) {
    87121      if (constraint.Variable != null && !variableRanges.ContainsKey(constraint.Variable))
    88122        throw new
     
    121155      }
    122156
    123       var satisfied = constraint.Interval.Contains(resultInterval);
     157      error = 0.0;
     158      bool satisfied = true;
     159      if(!constraint.Interval.Contains(resultInterval.LowerBound))
     160      {
     161        satisfied = false;
     162        error += Math.Abs(resultInterval.LowerBound - constraint.Interval.LowerBound);
     163      }
     164
     165      if (!constraint.Interval.Contains(resultInterval.UpperBound))
     166      {
     167        satisfied = false;
     168        error += Math.Abs(resultInterval.UpperBound - constraint.Interval.UpperBound);
     169      }
     170
     171      error *= constraint.Weight;
     172
     173      //var satisfied = constraint.Interval.Contains(resultInterval);
    124174      return satisfied;
    125175    }
    126176
    127177    public static bool ConstraintsSatisfied(IEnumerable<IntervalConstraint> constraints,
    128                                             IReadOnlyDictionary<string, Interval>   variableRanges,
    129                                             ISymbolicExpressionTree         solution) {
     178                                            IReadOnlyDictionary<string, Interval> variableRanges,
     179                                            ISymbolicExpressionTree solution,
     180                                            out double error) {
    130181      var intervalInterpreter = new IntervalInterpreter();
     182      error = 0.0;
     183      var satisfied = true;
    131184      foreach (var constraint in constraints) {
    132185        if (constraint.Variable != null && !variableRanges.ContainsKey(constraint.Variable))
     
    135188                              nameof(IntervalConstraintsParser));
    136189
    137         var satisfied = ConstraintSatisfied(constraint, intervalInterpreter, variableRanges, solution);
    138         if (!satisfied) return false;
     190        satisfied = ConstraintSatisfied(constraint, intervalInterpreter, variableRanges, solution, out double e) && satisfied;
     191        error += e;
     192        //if (!satisfied) return false;
    139193      }
    140194
    141       return true;
     195      return satisfied;
    142196    }
    143197  }
Note: See TracChangeset for help on using the changeset viewer.