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

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.Instances;

namespace HeuristicLab.Problems.GaussianProcessTuning {
  [StorableClass]
  [Creatable("Problems")]
  [Item("Gaussian Process Configuration Problem", "The Gaussian process configuration problem for genetic programming.")]
  public class Problem : SingleObjectiveHeuristicOptimizationProblem<Evaluator, ISymbolicExpressionTreeCreator>,
    IProblemInstanceConsumer<IRegressionProblemData>, IProblemInstanceExporter<IRegressionProblemData> {
    private const string GaussianProcessConfigurationParameterName = "GaussianProcessConfiguration";
    private const string MaxGaussianProcessConfigurationLengthParameterName = "MaxConfigurationLength";
    private const string MaxGaussianProcessConfigurationParameterName = "MaxConfigurationDepth";
    private const string GaussianProcessConfigurationGrammarParameterName = "Grammar";
    private const string DimensionParameterName = "Dimension";
    private const string InterpreterParameterName = "Interpreter";
    private const string ProblemDataParameterName = "ProblemData";
    private const string IterationsParameterName = "Iterations";


    public IFixedValueParameter<IntValue> MaxGaussianProcessConfigurationLengthParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters[MaxGaussianProcessConfigurationLengthParameterName]; }
    }
    public IFixedValueParameter<IntValue> MaxGaussianProcessConfigurationDepthParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters[MaxGaussianProcessConfigurationParameterName]; }
    }
    public IValueParameter<Grammar> GrammarParameter {
      get { return (IValueParameter<Grammar>)Parameters[GaussianProcessConfigurationGrammarParameterName]; }
    }
    public IFixedValueParameter<IntValue> DimensionParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters[DimensionParameterName]; }
    }
    public IValueParameter<Interpreter> InterpreterParameter {
      get { return (IValueParameter<Interpreter>)Parameters[InterpreterParameterName]; }
    }
    public IValueParameter<IRegressionProblemData> ProblemDataParameter {
      get { return (IValueParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
    }
    public IFixedValueParameter<IntValue> IterationsParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters[IterationsParameterName]; }
    }

    [StorableConstructor]
    protected Problem(bool deserializing)
      : base(deserializing) {
    }
    protected Problem(Problem original, Cloner cloner)
      : base(original, cloner) {
      RegisterEventHandlers();
    }
    public Problem()
      : base(new Evaluator(), new ProbabilisticTreeCreator()) {
      Parameters.Add(new ValueParameter<Interpreter>(InterpreterParameterName, "The interpreter for Gaussian process configurations represented as trees.", new Interpreter()));
      Parameters.Add(new FixedValueParameter<IntValue>(DimensionParameterName, "The dimension parameter for the Gaussian process configuration.", new IntValue(1)));
      Parameters.Add(new FixedValueParameter<IntValue>(MaxGaussianProcessConfigurationParameterName, "Maximal depth of the Gaussian process configuration.", new IntValue(7)));
      Parameters.Add(new FixedValueParameter<IntValue>(MaxGaussianProcessConfigurationLengthParameterName, "Maximal length of the Gaussian process configuration.", new IntValue(25)));
      Parameters.Add(new ValueParameter<Grammar>(GaussianProcessConfigurationGrammarParameterName, "Grammar for the Gaussian process configuration.",
                     new Grammar()));
      Parameters.Add(new ValueParameter<IRegressionProblemData>(ProblemDataParameterName, "The problem data to learn a Gaussian process for.", new RegressionProblemData()));
      Parameters.Add(new FixedValueParameter<IntValue>(IterationsParameterName, "The number of LM-BFGS iterations for hyper-parameter tuning.", new IntValue(50)));
      Maximization.Value = false;
      InitializeOperators();

      RegisterEventHandlers();
    }


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

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

    private void InitializeOperators() {
      Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
      Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
      Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
      Operators.Add(new BestSolutionAnalyzer());
      ParameterizeOperators();
      ParameterizeAnalyzers();
    }


    private void RegisterEventHandlers() {
      Evaluator.QualityParameter.ActualNameChanged += QualityParameterOnActualNameChanged;
      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged +=
        SymbolicExpressionTreeParameterOnActualNameChanged;
      DimensionParameter.Value.ValueChanged += DimensionParameterOnValueChanged;
      GrammarParameter.ValueChanged += new EventHandler(GrammarParameter_ValueChanged);
    }

    void GrammarParameter_ValueChanged(object sender, EventArgs e) {
      GrammarParameter.Value.Dimension = DimensionParameter.Value.Value;
    }

    private void DimensionParameterOnValueChanged(object sender, EventArgs eventArgs) {
      GrammarParameter.Value.Dimension = DimensionParameter.Value.Value;
    }


    protected override void OnEvaluatorChanged() {
      base.OnEvaluatorChanged();
      Evaluator.GaussianProcessConfigurationParameter.ActualName = GaussianProcessConfigurationParameterName;
      Evaluator.QualityParameter.ActualNameChanged += QualityParameterOnActualNameChanged;
      ParameterizeAnalyzers();
      ParameterizeOperators();
    }

    protected override void OnSolutionCreatorChanged() {
      base.OnSolutionCreatorChanged();
      SolutionCreator.SymbolicExpressionTreeParameter.ActualName = GaussianProcessConfigurationParameterName;
      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += SymbolicExpressionTreeParameterOnActualNameChanged;
      ParameterizeAnalyzers();
      ParameterizeOperators();
    }

    private void SymbolicExpressionTreeParameterOnActualNameChanged(object sender, EventArgs eventArgs) {
      ParameterizeAnalyzers();
      ParameterizeOperators();
    }

    private void QualityParameterOnActualNameChanged(object sender, EventArgs eventArgs) {
      ParameterizeAnalyzers();
      ParameterizeOperators();
    }

    private void ParameterizeAnalyzers() {
      var analyzers = Operators.OfType<IAnalyzer>();
      foreach (var o in analyzers.OfType<ISymbolicExpressionTreeAnalyzer>()) {
        o.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
      }
      foreach (var o in analyzers.OfType<BestSolutionAnalyzer>()) {
        o.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
      }
    }

    private void ParameterizeOperators() {
      var operators = Parameters
        .OfType<IValueParameter>()
        .Select(p => p.Value)
        .OfType<IOperator>()
        .Union(Operators);
      foreach (var o in operators.OfType<ISymbolicExpressionTreeGrammarBasedOperator>()) {
        o.SymbolicExpressionTreeGrammarParameter.ActualName = GaussianProcessConfigurationGrammarParameterName;
      }
      foreach (var o in operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>()) {
        o.MaximumSymbolicExpressionTreeDepthParameter.ActualName = MaxGaussianProcessConfigurationParameterName;
        o.MaximumSymbolicExpressionTreeLengthParameter.ActualName = MaxGaussianProcessConfigurationLengthParameterName;
      }
      foreach (var op in operators.OfType<Evaluator>()) {
        op.GaussianProcessConfigurationParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
      }
      foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
        op.ParentsParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
        op.ChildParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
      }
      foreach (var op in operators.OfType<ISymbolicExpressionTreeManipulator>()) {
        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
      }
      foreach (var op in operators.OfType<ISymbolicExpressionTreeCreator>()) {
        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
      }
    }

    public void Load(IRegressionProblemData data) {
      Name = data.Name;
      Description = data.Description;
      ProblemDataParameter.Value = data;
    }

    public IRegressionProblemData Export() {
      return ProblemDataParameter.Value;
    }
  }
}