Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/29/20 15:12:55 (4 years ago)
Author:
chaider
Message:

#3076

  • Fixed some formating in SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator
  • Added linear scaling check in SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator
  • Added linear scaling for SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs

    r17660 r17705  
    1 using System;
    2 using System.Collections.Generic;
     1using System.Collections.Generic;
    32using HEAL.Attic;
    43using HeuristicLab.Common;
     
    65using HeuristicLab.Data;
    76using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    8 using HeuristicLab.Parameters;
    97
    108namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.SingleObjective.Evaluators {
     
    1311  public class SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator
    1412    : SymbolicRegressionSingleObjectiveEvaluator {
    15 
    1613    [StorableConstructor]
    17     protected SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator(StorableConstructorFlag _) : base(_) {}
     14    protected SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator(StorableConstructorFlag _) : base(_) { }
    1815
    1916    protected SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator(
     
    3128
    3229    public override IOperation InstrumentedApply() {
    33       var rows                                      = GenerateRowsToEvaluate();
    34       var solution                                  = SymbolicExpressionTreeParameter.ActualValue;
    35       var problemData                               = ProblemDataParameter.ActualValue;
    36       var interpreter                               = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
    37       var estimationLimits                          = EstimationLimitsParameter.ActualValue;
    38       var applyLinearScaling                        = false;
    39      
    40      //Check for interval arithmetic grammar
    41      //remove scaling nodes for linear scaling evaluation
    42      var rootNode = new ProgramRootSymbol().CreateTreeNode();
    43      var startNode = new StartSymbol().CreateTreeNode();
    44      SymbolicExpressionTree newTree = null;
    45      foreach (var node in solution.IterateNodesPrefix()) {
    46        if (node.Symbol.Name == "Scaling") {
    47          for (var i = 0; i < node.SubtreeCount; ++i) {
    48            startNode.AddSubtree(node.GetSubtree(i));
    49          }
    50          rootNode.AddSubtree(startNode);
    51          newTree = new SymbolicExpressionTree(rootNode);
    52          break;
    53        }
    54      }
    55      //calculate alpha and beta for scaling
    56      var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(newTree, problemData.Dataset, rows);
    57      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
    58      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out var alpha, out var beta, out var errorState);
    59      var a = alpha;
    60      var b = beta;
    61      //Set alpha and beta to the scaling nodes from ia grammar
    62      foreach (var node in solution.IterateNodesPrefix()) {
    63        if (node.Symbol.Name == "Offset") {
    64          node.RemoveSubtree(1);
    65          var alphaNode = new ConstantTreeNode(new Constant()) {Value = alpha};
    66          node.AddSubtree(alphaNode);
    67        } else if (node.Symbol.Name == "Scaling") {
    68          node.RemoveSubtree(1);
    69          var betaNode = new ConstantTreeNode(new Constant()) {Value = beta};
    70          node.AddSubtree(betaNode);
    71        }
    72      }
     30      var rows               = GenerateRowsToEvaluate();
     31      var solution           = SymbolicExpressionTreeParameter.ActualValue;
     32      var problemData        = ProblemDataParameter.ActualValue;
     33      var interpreter        = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
     34      var estimationLimits   = EstimationLimitsParameter.ActualValue;
     35      var applyLinearScaling = true;
     36
     37      if (applyLinearScaling) {
     38        //Check for interval arithmetic grammar
     39        //remove scaling nodes for linear scaling evaluation
     40        var                    rootNode  = new ProgramRootSymbol().CreateTreeNode();
     41        var                    startNode = new StartSymbol().CreateTreeNode();
     42        SymbolicExpressionTree newTree   = null;
     43        foreach (var node in solution.IterateNodesPrefix())
     44          if (node.Symbol.Name == "Scaling") {
     45            for (var i = 0; i < node.SubtreeCount; ++i) startNode.AddSubtree(node.GetSubtree(i));
     46            rootNode.AddSubtree(startNode);
     47            newTree = new SymbolicExpressionTree(rootNode);
     48            break;
     49          }
     50
     51        //calculate alpha and beta for scaling
     52        var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(newTree, problemData.Dataset, rows);
     53        var targetValues    = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
     54        OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out var alpha, out var beta,
     55          out var errorState);
     56        //Set alpha and beta to the scaling nodes from ia grammar
     57        foreach (var node in solution.IterateNodesPrefix())
     58          if (node.Symbol.Name == "Offset") {
     59            node.RemoveSubtree(1);
     60            var alphaNode = new ConstantTreeNode(new Constant()) {Value = alpha};
     61            node.AddSubtree(alphaNode);
     62          } else if (node.Symbol.Name == "Scaling") {
     63            node.RemoveSubtree(1);
     64            var betaNode = new ConstantTreeNode(new Constant()) {Value = beta};
     65            node.AddSubtree(betaNode);
     66          }
     67      }
     68
    7369
    7470      var quality = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows,
    75         applyLinearScaling);
     71        false);
    7672      QualityParameter.ActualValue = new DoubleValue(quality);
    7773      return base.InstrumentedApply();
     
    8581      var estimatedValues =
    8682        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
    87       var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
    88       var constraints = problemData.IntervalConstraints.EnabledConstraints;
     83      var targetValues   = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
     84      var constraints    = problemData.IntervalConstraints.EnabledConstraints;
    8985      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
    9086
     
    9389
    9490      var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
    95       var nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out var errorState);
     91      var nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues,
     92        out var errorState);
    9693      if (errorState != OnlineCalculatorError.None) nmse = 1.0;
    9794
    9895      return nmse;
    9996    }
    100    
     97
    10198    public override double Evaluate(
    10299      IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData,
     
    108105      var nmse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
    109106        EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
    110         problemData, rows,
    111         ApplyLinearScalingParameter.ActualValue.Value);
     107        problemData, rows, false);
    112108
    113109      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Note: See TracChangeset for help on using the changeset viewer.