source: branches/HeuristicLab.Problems.GaussianProcessTuning/HeuristicLab.Problems.GaussianProcessTuning/BestSolutionAnalyzer.cs @ 10757

using HeuristicLab.Algorithms.DataAnalysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Problems.GaussianProcessTuning {
  [StorableClass]
  [Item("Gaussian Process Solution Analyzer", "Analyzer that stores the best Gaussian process tuning solution.")]
  public class BestSolutionAnalyzer : SingleSuccessorOperator, ISymbolicExpressionTreeAnalyzer {

    private const string QualityParameterName = "Quality";
    private const string SymbolicExpressionTreeParameterName = "GaussianProcessConfiguration";
    private const string ResultsParameterName = "Results";
    private const string ProblemDataParameterName = "ProblemData";
    private const string InterpreterParameterName = "Interpreter";
    private const string SolutionParameterName = "Solution";
    private const string TreeParameterName = "Covariance function";

    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
    }
    public IScopeTreeLookupParameter<IGaussianProcessSolution> SolutionParameter {
      get { return (IScopeTreeLookupParameter<IGaussianProcessSolution>)Parameters[SolutionParameterName]; }
    }
    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
    }
    public ILookupParameter<ResultCollection> ResultParameter {
      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
    }
    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
      get { return (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
    }
    public ILookupParameter<Interpreter> InterpreterParameter {
      get { return (ILookupParameter<Interpreter>)Parameters[InterpreterParameterName]; }
    }

    [StorableConstructor]
    protected BestSolutionAnalyzer(bool deserializing) : base(deserializing) { }
    protected BestSolutionAnalyzer(BestSolutionAnalyzer original, Cloner cloner)
      : base(original, cloner) {
    }

    public BestSolutionAnalyzer() {
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The solution quality of the Gaussian process configuration."));
      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The Gaussian process configuration to evaluate represented as symbolic expression tree."));
      Parameters.Add(new ScopeTreeLookupParameter<IGaussianProcessSolution>(SolutionParameterName, "The solution of the Gaussian process algorithm."));
      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection of the algorithm."));
      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName, ""));
      Parameters.Add(new LookupParameter<Interpreter>(InterpreterParameterName, ""));
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

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

    public override IOperation Apply() {
      var trees = SymbolicExpressionTreeParameter.ActualValue;
      var qualities = QualityParameter.ActualValue;
      var solutions = SolutionParameter.ActualValue;
      // find max tree
      double maxQuality = double.PositiveInfinity;
      ISymbolicExpressionTree bestTree = null;
      IGaussianProcessSolution bestSolution = null;
      for (int i = 0; i < qualities.Length; i++) {
        if (qualities[i].Value < maxQuality) {
          maxQuality = qualities[i].Value;
          bestTree = trees[i];
          bestSolution = solutions[i];
        }
      }
      var cloner = new Cloner();
      bestTree = cloner.Clone(bestTree);

      var resultCollection = ResultParameter.ActualValue;
      if (!resultCollection.ContainsKey(SolutionParameterName)) {
        resultCollection.Add(new Result(SolutionParameterName, "The Gaussian process algorithm solution", bestSolution));
        resultCollection.Add(new Result(TreeParameterName, "The best covariance function", bestTree));
      } else {
        resultCollection[SolutionParameterName].Value = bestSolution;
        resultCollection[TreeParameterName].Value = bestTree;
      }

      return base.Apply();
    }
    public bool EnabledByDefault {
      get { return true; }
    }
  }
}