source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs @ 5303

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Algorithms.GeneticAlgorithm;
using HeuristicLab.Problems.TestFunctions;

namespace HeuristicLab.Problems.MetaOptimization {
  [Item("Meta Optimization Problem", "Represents a Meta Optimization Problem.")]
  [Creatable("Problems")]
  [StorableClass]
  public sealed class MetaOptimizationProblem : SingleObjectiveProblem<IParameterConfigurationEvaluator, IParameterConfigurationCreator> {
    public const string AlgorithmTypeParameterName = "AlgorithmType";
    public const string ProblemTypeParameterName = "ProblemType";
    public const string ProblemsParameterName = "Problems";
    public const string ParameterConfigurationTreeParameterName = "InitialParameterConfigurationTree";
    public const string RepetitionsParameterName = "Repetitions";

    public const string IntValueManipulatorParameterName = "IntValueManipulator";
    public const string DoubleValueManipulatorParameterName = "DoubleValueManipulator";
    public const string IntValueCrossoverParameterName = "IntValueCrossover";
    public const string DoubleValueCrossoverParameterName = "DoubleValueCrossover";

    #region Parameter Properties
    public IValueParameter<EngineAlgorithm> AlgorithmTypeParameter {
      get { return (ValueParameter<EngineAlgorithm>)Parameters[AlgorithmTypeParameterName]; }
    }
    public IValueParameter<ISingleObjectiveProblem> ProblemTypeParameter {
      get { return (ValueParameter<ISingleObjectiveProblem>)Parameters[ProblemTypeParameterName]; }
    }
    public IValueParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
      get { return (ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
    }
    public IValueParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter {
      get { return (ValueParameter<ParameterConfigurationTree>)Parameters[ParameterConfigurationTreeParameterName]; }
    }
    public IValueParameter<IntValue> RepetitionsParameter {
      get { return (ValueParameter<IntValue>)Parameters[RepetitionsParameterName]; }
    }

    public IValueParameter<IIntValueManipulator> IntValueManipulatorParameter {
      get { return (ValueParameter<IIntValueManipulator>)Parameters[IntValueManipulatorParameterName]; }
    }

    public IValueParameter<IDoubleValueManipulator> DoubleValueManipulatorParameter {
      get { return (ValueParameter<IDoubleValueManipulator>)Parameters[DoubleValueManipulatorParameterName]; }
    }
    #endregion

    #region Properties
    public EngineAlgorithm Algorithm {
      get { return AlgorithmTypeParameter.Value; }
      set { AlgorithmTypeParameter.Value = value; }
    }
    public ISingleObjectiveProblem Problem {
      get { return ProblemTypeParameter.Value; }
      set { ProblemTypeParameter.Value = value; }
    }
    public ConstrainedItemList<ISingleObjectiveProblem> Problems {
      get { return ProblemsParameter.Value; }
      set { ProblemsParameter.Value = value; }
    }
    public ParameterConfigurationTree ParameterConfigurationTree {
      get { return ParameterConfigurationTreeParameter.Value; }
      set { ParameterConfigurationTreeParameter.Value = value; }
    }
    public IntValue Repetitions {
      get { return RepetitionsParameter.Value; }
      set { RepetitionsParameter.Value = value; }
    }
    private BestParameterConfigurationAnalyzer BestParameterConfigurationAnalyzer {
      get { return Operators.OfType<BestParameterConfigurationAnalyzer>().FirstOrDefault(); }
    }
    private ReferenceQualityAnalyzer ReferenceQualityAnalyzer {
      get { return Operators.OfType<ReferenceQualityAnalyzer>().FirstOrDefault(); }
    }
    private RunsAnalyzer RunsAnalyzer {
      get { return Operators.OfType<RunsAnalyzer>().FirstOrDefault(); }
    }
    #endregion

    public MetaOptimizationProblem()
      : base() {
      Parameters.Add(new ValueParameter<EngineAlgorithm>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new GeneticAlgorithm()));
      Parameters.Add(new ValueParameter<ISingleObjectiveProblem>(ProblemTypeParameterName, "The problem type.", new SingleObjectiveTestFunctionProblem()));
      Parameters.Add(new ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<ISingleObjectiveProblem>()));
      Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "Tree of algorithm parameters that should be optimized."));
      Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "The number of evaluations for each problem.", new IntValue(3)));

      var validIntManipulators = new ItemSet<IIntValueManipulator>(ApplicationManager.Manager.GetInstances<IIntValueManipulator>());
      var validDoubleManipulators = new ItemSet<IDoubleValueManipulator>(ApplicationManager.Manager.GetInstances<IDoubleValueManipulator>());
      var validIntCrossovers = new ItemSet<IIntValueCrossover>(ApplicationManager.Manager.GetInstances<IIntValueCrossover>());
      var validDoubleCrossovers = new ItemSet<IDoubleValueCrossover>(ApplicationManager.Manager.GetInstances<IDoubleValueCrossover>());
      Parameters.Add(new ConstrainedValueParameter<IIntValueManipulator>(IntValueManipulatorParameterName, "", validIntManipulators, validIntManipulators.Where(x => x.GetType() == typeof(NormalIntValueManipulator)).SingleOrDefault()));
      Parameters.Add(new ConstrainedValueParameter<IDoubleValueManipulator>(DoubleValueManipulatorParameterName, "", validDoubleManipulators, validDoubleManipulators.Where(x => x.GetType() == typeof(NormalDoubleValueManipulator)).SingleOrDefault()));
      Parameters.Add(new ConstrainedValueParameter<IIntValueCrossover>(IntValueCrossoverParameterName, "", validIntCrossovers, validIntCrossovers.Where(x => x.GetType() == typeof(NormalIntValueCrossover)).SingleOrDefault()));
      Parameters.Add(new ConstrainedValueParameter<IDoubleValueCrossover>(DoubleValueCrossoverParameterName, "", validDoubleCrossovers, validDoubleCrossovers.Where(x => x.GetType() == typeof(NormalDoubleValueCrossover)).SingleOrDefault()));

      Maximization = new BoolValue(false);
      SolutionCreator = new RandomParameterConfigurationCreator();
      Evaluator = new ParameterConfigurationEvaluator();

      InitializeOperators();
      RegisterParameterEvents();
      ParameterizeAnalyzer();
      ParameterizeSolutionCreator();
      ParameterizeEvaluator();
      ParameterizeOperators();

      Problems.Type = Problem.GetType();
      Algorithm.Problem = Problem;
      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
    }

    [StorableConstructor]
    private MetaOptimizationProblem(bool deserializing) : base(deserializing) { }
    private MetaOptimizationProblem(MetaOptimizationProblem original, Cloner cloner)
      : base(original, cloner) {
      // todo
      this.RegisterParameterEvents();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MetaOptimizationProblem(this, cloner);
    }

    #region Helpers
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserializationHook() {
      RegisterParameterEvents();
    }
    private void RegisterParameterEvents() {
      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
      AlgorithmTypeParameter.ValueChanged += new EventHandler(AlgorithmTypeParameter_ValueChanged);
      ProblemTypeParameter.ValueChanged += new EventHandler(ProblemTypeParameter_ValueChanged);
    }

    private void InitializeOperators() {
      Operators.AddRange(ApplicationManager.Manager.GetInstances<IParameterConfigurationOperator>().Cast<IOperator>());
      Operators.Add(new BestParameterConfigurationAnalyzer());
      Operators.Add(new ReferenceQualityAnalyzer());
      Operators.Add(new RunsAnalyzer());
    }
    private void ParameterizeSolutionCreator() {
    }
    private void ParameterizeEvaluator() {
      ((ParameterConfigurationEvaluator)Evaluator).ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
    }
    private void ParameterizeAnalyzer() {
      if (BestParameterConfigurationAnalyzer != null) {
        BestParameterConfigurationAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
      }
      if (ReferenceQualityAnalyzer != null) {
        ReferenceQualityAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
      }
      if (RunsAnalyzer != null) {
        RunsAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
      }
    }
    private void ParameterizeOperators() {
      foreach (IParameterConfigurationCrossover op in Operators.OfType<IParameterConfigurationCrossover>()) {
        op.ParentsParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
        op.ChildParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
      }
      foreach (IParameterConfigurationManipulator op in Operators.OfType<IParameterConfigurationManipulator>()) {
        op.ParameterConfigurationTreeParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
      }
    }

    #endregion

    #region Events

    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
      ParameterizeSolutionCreator();
      ParameterizeEvaluator();
      ParameterizeAnalyzer();
      ParameterizeOperators();
      OnSolutionCreatorChanged();
    }
    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
      ParameterizeEvaluator();
      ParameterizeAnalyzer();
      OnEvaluatorChanged();
    }
    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
      ParameterizeAnalyzer();
    }
    void AlgorithmTypeParameter_ValueChanged(object sender, EventArgs e) {
      Algorithm.Problem = Problem;
      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
    }
    void ProblemTypeParameter_ValueChanged(object sender, EventArgs e) {
      Problems.Type = Problem.GetType();
      Algorithm.Problem = Problem;
      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
    }
    #endregion
  }
}