source: branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs @ 17821

using System;
using System.Collections.Generic;
using System.Linq;
using HEAL.Attic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
  [StorableType("9397A63D-0C6B-4733-BD1A-59AAE9A9F006")]
  public class SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator : SymbolicRegressionMultiObjectiveEvaluator {
    private const string BoundsEstimatorParameterName = "Bounds estimator";
    public IValueParameter<IBoundsEstimator> BoundsEstimatorParameter =>
      (IValueParameter<IBoundsEstimator>)Parameters[BoundsEstimatorParameterName];

    public IBoundsEstimator BoundsEstimator {
      get => BoundsEstimatorParameter.Value;
      set => BoundsEstimatorParameter.Value = value;
    }

    #region Constructors

    public SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator() { }

    [StorableConstructor]
    protected SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator(StorableConstructorFlag _) : base(_) { }

    protected SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator(
      SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator original, Cloner cloner) :
      base(original, cloner) { }

    #endregion

    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator(this, cloner);
    }


    public override IOperation InstrumentedApply() {
      var rows               = GenerateRowsToEvaluate();
      var solution           = SymbolicExpressionTreeParameter.ActualValue;
      var problemData        = ProblemDataParameter.ActualValue;
      var interpreter        = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
      var estimationLimits   = EstimationLimitsParameter.ActualValue;
      var applyLinearScaling = false;

      if (UseConstantOptimization)
        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows,
                                                                          applyLinearScaling,
                                                                          ConstantOptimizationIterations,
                                                                          updateVariableWeights:
                                                                          ConstantOptimizationUpdateVariableWeights,
                                                                          lowerEstimationLimit: estimationLimits.Lower,
                                                                          upperEstimationLimit: estimationLimits.Upper);

      var qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData,
                                rows, applyLinearScaling, DecimalPlaces, BoundsEstimator);
      QualitiesParameter.ActualValue = new DoubleArray(qualities);
      return base.InstrumentedApply();
    }

    public override double[] Evaluate(IExecutionContext context, ISymbolicExpressionTree tree,
                                      IRegressionProblemData problemData,
                                      IEnumerable<int> rows) {
      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
      EstimationLimitsParameter.ExecutionContext                    = context;
      ApplyLinearScalingParameter.ExecutionContext                  = context;

      var quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
                              EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
                              problemData, rows,
                              ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces, BoundsEstimator);

      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
      EstimationLimitsParameter.ExecutionContext                    = null;
      ApplyLinearScalingParameter.ExecutionContext                  = null;

      return quality;
    }

    public static double[] Calculate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
                                     ISymbolicExpressionTree solution, double lowerEstimationLimit,
                                     double upperEstimationLimit,
                                     IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
                                     int decimalPlaces, IBoundsEstimator estimator) {
      OnlineCalculatorError errorState;
      var estimatedValues =
        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);

      double nmse;

      var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
      nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
      if (errorState != OnlineCalculatorError.None) nmse = double.NaN;

      if (nmse > 1)
        nmse = 1;

      var constraints    = problemData.IntervalConstraints.Constraints.Where(c => c.Enabled);
      var intervalCollection = problemData.VariableRanges;

      var objectives = new List<double> {nmse}; //Add r² to resultlist
      var constraintObjectives = constraints.Select(constraint =>
        IntervalUtil.IntervalConstraintViolation(constraint, estimator, intervalCollection, solution) > 0 ? 0.0 : 1.0);

      objectives.AddRange(constraintObjectives); //Add hardconstraints for each constraint

      return objectives.ToArray();
    }


    /*
     * First objective is to maximize the Pearson R² value
     * All following objectives have to be minimized ==> Constraints
     */
    public override IEnumerable<bool> Maximization {
      get {
        var objectives = new List<bool> {true};           //Max the pearson r² value
        objectives.AddRange(Enumerable.Repeat(false, 6)); //Min the constraints
        return objectives;
      }
    }
  }
}