[5500]  1  #region License Information


 2  /* HeuristicLab


[17180]  3  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)


[5500]  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 


 22  using System.Collections.Generic;


 23  using HeuristicLab.Common;


 24  using HeuristicLab.Core;


 25  using HeuristicLab.Data;


 26  using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;


[16565]  27  using HEAL.Attic;


[5500]  28 


 29  namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {


[7677]  30  [Item("Maximum absolute error Evaluator", "Calculates the maximum squared error of a symbolic regression solution.")]


[16565]  31  [StorableType("256A6405D1EE4D8D963A42C56FEE8571")]


[7677]  32  public class SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator : SymbolicRegressionSingleObjectiveEvaluator {


[7672]  33  public override bool Maximization { get { return false; } }


[5500]  34  [StorableConstructor]


[16565]  35  protected SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator(StorableConstructorFlag _) : base(_) { }


[7677]  36  protected SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator(SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator original, Cloner cloner)


[5500]  37  : base(original, cloner) {


 38  }


 39  public override IDeepCloneable Clone(Cloner cloner) {


[7677]  40  return new SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator(this, cloner);


[5500]  41  }


[7677]  42  public SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator() : base() { }


[5505]  43 


[10291]  44  public override IOperation InstrumentedApply() {


[5851]  45  var solution = SymbolicExpressionTreeParameter.ActualValue;


[5500]  46  IEnumerable<int> rows = GenerateRowsToEvaluate();


[5851]  47 


[12977]  48  double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value);


[5851]  49  QualityParameter.ActualValue = new DoubleValue(quality);


 50 


[10291]  51  return base.InstrumentedApply();


[5500]  52  }


 53 


[7672]  54  public static double Calculate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling) {


[5500]  55  IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);


[7677]  56  IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);


[5942]  57  OnlineCalculatorError errorState;


[7672]  58 


 59  double mse;


 60  if (applyLinearScaling) {


[7677]  61  var maeCalculator = new OnlineMaxAbsoluteErrorCalculator();


[8113]  62  CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, maeCalculator, problemData.Dataset.Rows);


[7677]  63  errorState = maeCalculator.ErrorState;


 64  mse = maeCalculator.MaxAbsoluteError;


[8113]  65  } else {


 66  IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);


[7677]  67  mse = OnlineMaxAbsoluteErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);


[8113]  68  }


[8664]  69  if (errorState != OnlineCalculatorError.None) return double.NaN;


 70  return mse;


[5500]  71  }


[5607]  72 


[5613]  73  public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows) {


[5722]  74  SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;


[5770]  75  EstimationLimitsParameter.ExecutionContext = context;


[8664]  76  ApplyLinearScalingParameter.ExecutionContext = context;


[5722]  77 


[8664]  78  double mse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value);


[5722]  79 


 80  SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;


[5770]  81  EstimationLimitsParameter.ExecutionContext = null;


[8664]  82  ApplyLinearScalingParameter.ExecutionContext = null;


[5722]  83 


 84  return mse;


[5607]  85  }


[18095]  86 


 87  public override double Evaluate(IRegressionProblemData problemData,


 88  ISymbolicExpressionTree solution,


 89  ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,


 90  IEnumerable<int> rows = null,


 91  bool applyLinearScaling = true,


 92  double lowerEstimationLimit = double.MinValue,


 93  double upperEstimationLimit = double.MaxValue) {


 94  return Calculate(interpreter, solution, lowerEstimationLimit, upperEstimationLimit, problemData, rows ?? problemData.TrainingIndices, applyLinearScaling);


 95  }


[5500]  96  }


[8664]  97  } 
