source: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs @ 13620

using System;
using System.Collections.Generic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.RealVectorEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.Instances;
using HeuristicLab.Problems.MultiObjectiveTestFunctions;
using HeuristicLab.Problems.MultiObjectiveTestFunctions.Drawings;

namespace HeuristicLab.Problems.MultiObjectiveTestFunction {
  [StorableClass]
  public class MultiObjectiveTestFunctionProblem : MultiObjectiveBasicProblem<RealVectorEncoding>, IProblemInstanceConsumer<MOTFData> {


    //TODO update of Maximisatzion when SolutionSize or TestFunction changes
    public override bool[] Maximization {
      get {
        return Parameters.ContainsKey("TestFunction") ? TestFunction.Maximization(Objectives) : new bool[2];
      }
    }

    #region Parameter Properties

    /// <summary>
    /// The dimensionality of the solution candidates
    /// </summary>
    private IFixedValueParameter<IntValue> ProblemSizeParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }
    }

    /// <summary>
    /// The number of objectives that are to be optimized
    /// </summary>
    private IFixedValueParameter<IntValue> SolutionSizeParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters["SolutionSize"]; }
    }

    /// <summary>
    /// The bounds for the entries of the solution candidate
    /// </summary>
    private IValueParameter<DoubleMatrix> BoundsParameter {
      get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
    }

    /// <summary>
    /// The testfunction 
    /// </summary>
    public IValueParameter<IMultiObjectiveTestFunction> TestFunctionParameter {
      get { return (IValueParameter<IMultiObjectiveTestFunction>)Parameters["TestFunction"]; }
    }
    #endregion

    #region Properties
    public int SolutionLength {
      get { return ProblemSizeParameter.Value.Value; }
      set { ProblemSizeParameter.Value.Value = value; }
    }
    public int Objectives {
      get { return SolutionSizeParameter.Value.Value; }
      set { SolutionSizeParameter.Value.Value = value; }
    }
    public DoubleMatrix Bounds {
      get { return BoundsParameter.Value; }
      set { BoundsParameter.Value = value; }
    }
    public IMultiObjectiveTestFunction TestFunction {
      get { return TestFunctionParameter.Value; }
      set { TestFunctionParameter.Value = value; }
    }
    #endregion

    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
      base.Analyze(individuals, qualities, results, random);
      //if (qualities[0].Length != 2) { throw new Exception(); }




      IEnumerable<double[]> opf = null;
      try {
        opf = TestFunction.OptimalParetoFront(Objectives);

        //Genearational Distance
        if (!results.ContainsKey("GenerationalDistance")) results.Add(new Result("GenerationalDistance", typeof(DoubleValue)));
        GenerationalDistance gd = new GenerationalDistance(1);
        results["GenerationalDistance"].Value = new DoubleValue(gd.Compare(qualities, opf));

        //Inverted Generational Distance 
        if (!results.ContainsKey("InvertedGenerationalDistance")) results.Add(new Result("InvertedGenerationalDistance", typeof(DoubleValue)));
        InvertedGenerationalDistance igd = new InvertedGenerationalDistance(1);
        results["InvertedGenerationalDistance"].Value = new DoubleValue(igd.Compare(qualities, opf));


      }
      catch (NotImplementedException) { } // only do this if the optimal Front is known



      //Graphical analysis
      if (!results.ContainsKey("Front")) results.Add(new Result("Front", typeof(IMOQualities)));
      results["Front"].Value = new IMOSolution(qualities, individuals, opf, Objectives);


      //Hypervolume analysis
      if (!results.ContainsKey("Hypervolume")) results.Add(new Result("Hypervolume", typeof(DoubleValue)));
      IEnumerable<double[]> front = NonDominatedSelect.selectNonDominatedVectors(qualities, Maximization, true);
      if (!results.ContainsKey("BestKnownHypervolume")) results.Add(new Result("BestKnownHypervolume", typeof(DoubleValue)));
      if (!results.ContainsKey("Absolute Distance to BestKnownHypervolume")) results.Add(new Result("Absolute Distance to BestKnownHypervolume", typeof(DoubleValue)));


      if (Objectives == 2) { //Hypervolume analysis only with 2 objectives for now
        Hypervolume comp = new Hypervolume(TestFunction.ReferencePoint(Objectives), Maximization);
        try {
          double hv = comp.GetHypervolume(front);
          results["Hypervolume"].Value = new DoubleValue(hv);
          double best; double diff; 
          if (TestFunction.BestKnownHypervolume(Objectives) > 0) {   // if best HV is known at all
            best = TestFunction.BestKnownHypervolume(Objectives);
            diff = best - hv;
            if (diff < 0) {  //replace best known Hypervolume 
              diff = 0;
              best = hv;
            } 
          } else {  //initalize best known Hypervolume
            best = hv;
            diff = 0;
          }

          results["BestKnownHypervolume"].Value = new DoubleValue(best);
          results["Absolute Distance to BestKnownHypervolume"].Value = new DoubleValue(diff);

        }
        catch (ArgumentException) {
          results["Hypervolume"].Value = new DoubleValue(Double.NaN);
        }

      }
      //Experimental HV
      if(Objectives != 2) {
        FastHypervolume fcomp = new FastHypervolume(TestFunction.ReferencePoint(Objectives), Maximization);
        try {
          double hv = fcomp.GetHypervolume(front, TestFunction.Bounds(Objectives));
          results["Hypervolume"].Value = new DoubleValue(hv);
          double best; double diff;
          if (TestFunction.BestKnownHypervolume(Objectives) > 0) {   // if best HV is known at all
            best = TestFunction.BestKnownHypervolume(Objectives);
            diff = best - hv;
            if (diff < 0) {  //replace best known Hypervolume 
              diff = 0;
              best = hv;
            }
          } else {  //initalize best known Hypervolume
            best = hv;
            diff = 0;
          }

          results["BestKnownHypervolume"].Value = new DoubleValue(best);
          results["Absolute Distance to BestKnownHypervolume"].Value = new DoubleValue(diff);
        }
        catch (ArgumentException) {
          results["Hypervolume"].Value = new DoubleValue(Double.NaN);
        }
      }


      //Spacing analysis 
      if (!results.ContainsKey("Spacing")) results.Add(new Result("Spacing", typeof(DoubleValue)));
      Spacing s = new Spacing();
      results["Spacing"].Value = new DoubleValue(s.Get(qualities));

      //Crowding
      if (!results.ContainsKey("Crowding")) results.Add(new Result("Crowding", typeof(DoubleValue)));
      Crowding c = new Crowding(TestFunction.Bounds(Objectives));
      results["Crowding"].Value = new DoubleValue(c.Get(qualities));



    }

    [StorableConstructor]
    private MultiObjectiveTestFunctionProblem(bool deserializing) : base(deserializing) { }
    private MultiObjectiveTestFunctionProblem(MultiObjectiveTestFunctionProblem original, Cloner cloner)
      : base(original, cloner) {
      RegisterEventHandlers();
    }
    public MultiObjectiveTestFunctionProblem()
      : base() {
      Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));
      Parameters.Add(new FixedValueParameter<IntValue>("SolutionSize", "The dimensionality of the solution vector (number of objectives).", new IntValue(2)));
      Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound.", new DoubleMatrix(new double[,] { { -4, 4 } })));
      Parameters.Add(new ValueParameter<IMultiObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Fonseca()));

      Encoding.LengthParameter = ProblemSizeParameter;
      Encoding.BoundsParameter = BoundsParameter;

      InitializeOperators();
      RegisterEventHandlers();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MultiObjectiveTestFunctionProblem(this, cloner);
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterEventHandlers();
    }

    private void RegisterEventHandlers() {
      TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
      ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
      SolutionSizeParameter.Value.ValueChanged += SolutionSizeOnValueChanged;
      BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;
    }

    public double[] Evaluate(RealVector individual, IRandom random) {
      return TestFunction.Evaluate(individual, Objectives);
    }

    public override double[] Evaluate(Individual individual, IRandom random) {
      return Evaluate(individual.RealVector(), random);
    }

    public void Load(MOTFData data) {
      TestFunction = data.Evaluator;
    }

    #region Events
    protected override void OnEncodingChanged() {
      base.OnEncodingChanged();
      Parameterize();
    }
    protected override void OnEvaluatorChanged() {
      base.OnEvaluatorChanged();
      Parameterize();
    }

    private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) {
      var problemSizeChange = SolutionLength < TestFunction.MinimumSolutionLength
                              || SolutionLength > TestFunction.MaximumSolutionLength;
      if (problemSizeChange) {
        SolutionLength = Math.Max(TestFunction.MinimumSolutionLength, Math.Min(SolutionLength, TestFunction.MaximumSolutionLength));
      }

      var solutionSizeChange = Objectives < TestFunction.MinimumObjectives
                              || Objectives > TestFunction.MaximumObjectives;
      if (solutionSizeChange) {
        SolutionLength = Math.Max(TestFunction.MinimumObjectives, Math.Min(Objectives, TestFunction.MaximumObjectives));
      }
      Bounds = (DoubleMatrix)new DoubleMatrix(TestFunction.Bounds(Objectives)).Clone();
      OnReset();
    }

    private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {
      if (SolutionLength < TestFunction.MinimumSolutionLength
        || SolutionLength > TestFunction.MaximumSolutionLength)
        SolutionLength = Math.Min(TestFunction.MaximumSolutionLength, Math.Max(TestFunction.MinimumSolutionLength, SolutionLength));
      if (Objectives < TestFunction.MinimumObjectives
        || Objectives > TestFunction.MaximumObjectives)
        Objectives = Math.Min(TestFunction.MaximumObjectives, Math.Max(TestFunction.MinimumObjectives, Objectives));
    }

    private void SolutionSizeOnValueChanged(object sender, EventArgs eventArgs) {
      if (Objectives < TestFunction.MinimumObjectives
        || Objectives > TestFunction.MaximumObjectives)
        Objectives = Math.Min(TestFunction.MaximumObjectives, Math.Max(TestFunction.MinimumObjectives, Objectives));
      if (SolutionLength < TestFunction.MinimumSolutionLength
        || SolutionLength > TestFunction.MaximumSolutionLength)
        SolutionLength = Math.Min(TestFunction.MaximumSolutionLength, Math.Max(TestFunction.MinimumSolutionLength, SolutionLength));
    }

    private void BoundsParameterOnValueChanged(object sender, EventArgs eventArgs) {
      Parameterize();
    }
    #endregion

    #region Helpers
    private void InitializeOperators() {
      //empty for now
      Parameterize();
    }

    private void Parameterize() {
      //empty for now
    }
    #endregion
  }
}