source: branches/2993_UserDefinedEvaluators/HeuristicLab.Problems.DataAnalysis.Symbolic.UserDefinedEval/SymbolicDataAnalysisSingleObjectiveUserDefinedEvaluator.cs

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

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  [Item("User-defined Single-objective Evaluator", "A single-objective evaluator that aggregates the output of its evaluator collection.")]
  [StorableType("1E668115-AF2A-4037-8E3C-7B279EC72770")]
  public class SymbolicDataAnalysisSingleObjectiveUserDefinedEvaluator<T> : SymbolicDataAnalysisSingleObjectiveEvaluator<T> where T : class, IDataAnalysisProblemData {
    private const string EvaluatorsParameterName = "Evaluators";
    private const string MaximizationParameterName = "Maximization";
    private const string ObjectiveWeightsParameterName = "Weights";

    public IValueParameter<DoubleArray> ObjectiveWeightsParameter {
      get { return (IValueParameter<DoubleArray>)Parameters[ObjectiveWeightsParameterName]; }
    }

    public IFixedValueParameter<ItemList<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>> EvaluatorsParameter {
      get { return (IFixedValueParameter<ItemList<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>>)Parameters[EvaluatorsParameterName]; }
    }

    public IFixedValueParameter<BoolValue> MaximizationParameter {
      get { return (IFixedValueParameter<BoolValue>)Parameters[MaximizationParameterName]; }
    }

    public ItemList<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>> Evaluators {
      get { return EvaluatorsParameter.Value; }
    }

    public DoubleArray ObjectiveWeights => ObjectiveWeightsParameter.Value;

    public override bool Maximization => false;

    public SymbolicDataAnalysisSingleObjectiveUserDefinedEvaluator() : base() {
      Parameters.Add(new FixedValueParameter<ItemList<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>>(EvaluatorsParameterName, new ItemList<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>()));
      Parameters.Add(new FixedValueParameter<BoolValue>(MaximizationParameterName, new BoolValue(false)));
      Parameters.Add(new ValueParameter<DoubleArray>(ObjectiveWeightsParameterName, new DoubleArray()));
    }

    public SymbolicDataAnalysisSingleObjectiveUserDefinedEvaluator(SymbolicDataAnalysisSingleObjectiveUserDefinedEvaluator<T> original, Cloner cloner) : base(original, cloner) { }

    [StorableConstructor]
    protected SymbolicDataAnalysisSingleObjectiveUserDefinedEvaluator(StorableConstructorFlag deserializing) : base(deserializing) { }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolicDataAnalysisSingleObjectiveUserDefinedEvaluator<T>(this, cloner);
    }

    public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, T problemData, IEnumerable<int> rows) {
      var weights = ObjectiveWeights;

      double eval(ISymbolicDataAnalysisSingleObjectiveEvaluator<T> e) {
        var q = e.Evaluate(context, tree, problemData, rows);
        return e.Maximization ? -q : q;
      }

      var quality = 0d;
      for (int i = 0; i < weights.Length; ++i) {
        quality += weights[i] * eval(Evaluators[i]);
      }

      if (double.IsNaN(quality) || double.IsInfinity(quality)) {
        quality = double.MaxValue;
      }

      if (DecimalPlaces >= 0) {
        quality = Math.Round(quality, DecimalPlaces);
      }

      return quality;
    }

    public override IOperation InstrumentedApply() {
      var solution = SymbolicExpressionTreeParameter.ActualValue;
      var problemData = ProblemDataParameter.ActualValue;

      var quality = Evaluate(ExecutionContext, solution, problemData, problemData.TrainingIndices);
      QualityParameter.ActualValue = new DoubleValue(quality);
      return base.InstrumentedApply();
    }
  }
}