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

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 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.Collections.Generic;
using System.Linq;
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;

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

    #region Parameter Properties

    /// <summary>
    /// Whether an objective is to be maximized or minimized 
    /// </summary>
    private IValueParameter<BoolArray> MaximizationParameter {
      get {
        return (IValueParameter<BoolArray>)Parameters["Maximization"];
      }
      set {
        Parameters["Maximization"].ActualValue = value;
      }
    }

    /// <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> ObjectivesParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters["Objectives"]; }
    }

    /// <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"]; }
    }

    /// <summary>
    /// The testfunction 
    /// </summary>
    public IValueParameter<DoubleArray> ReferencePointParameter {
      get { return (IValueParameter<DoubleArray>)Parameters["ReferencePoint"]; }
    }

    public IValueParameter<DoubleMatrix> BestKnownFrontParameter {
      get {
        return (IValueParameter<DoubleMatrix>)Parameters["BestKnownFront"];
      }
    }

    #endregion

    #region Properties
    private IEnumerable<IMultiObjectiveTestFunctionAnalyzer> Analyzers {
      get { return Operators.OfType<IMultiObjectiveTestFunctionAnalyzer>(); }
    }

    public int ProblemSize {
      get { return ProblemSizeParameter.Value.Value; }
      set { ProblemSizeParameter.Value.Value = value; }
    }
    public int Objectives {
      get { return ObjectivesParameter.Value.Value; }
      set { ObjectivesParameter.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

    [StorableConstructor]
    protected MultiObjectiveTestFunctionProblem(bool deserializing) : base(deserializing) { }
    protected MultiObjectiveTestFunctionProblem(MultiObjectiveTestFunctionProblem original, Cloner cloner)
      : base(original, cloner) {
      RegisterEventHandlers();
    }
    public MultiObjectiveTestFunctionProblem()
      : base() {
      Parameters.Remove("Maximization");
      Parameters.Add(new ValueParameter<BoolArray>("Maximization", "", new BoolArray(new bool[] { false, false })));
      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>("Objectives", "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()));
      Parameters.Add(new ValueParameter<DoubleMatrix>("BestKnownFront", "The currently best known Pareto front"));

      Encoding.LengthParameter = ProblemSizeParameter;
      Encoding.BoundsParameter = BoundsParameter;
      BestKnownFrontParameter.Hidden = true;

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

    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
      base.Analyze(individuals, qualities, results, random);
      if (results.ContainsKey("Pareto Front")) {
        ((DoubleMatrix)results["Pareto Front"].Value).SortableView = true;
      }
    }

    public override bool[] Maximization {
      get {
        return Parameters.ContainsKey("TestFunction") ? TestFunction.Maximization(Objectives) : new bool[2];
      }
    }

    public IEnumerable<double[]> BestKnownFront {
      get {
        return Parameters.ContainsKey("BestKnownFront") ? TestFunction.OptimalParetoFront(Objectives) : null;
      }
    }

    /// <summary>
    /// Checks whether a given solution violates the contraints of this function.
    /// </summary>
    /// <param name="individual"></param>
    /// <returns>a double array that holds the distances that describe how much every contraint is violated (0 is not violated). If the current TestFunction does not have constraints an array of length 0 is returned</returns>
    public double[] CheckContraints(RealVector individual) {
      var constrainedTestFunction = (IConstrainedTestFunction)TestFunction;
      if (constrainedTestFunction != null) {
        return constrainedTestFunction.CheckConstraints(individual, Objectives);
      }
      return new double[0];
    }

    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.TestFunction;
    }

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

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

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

      var solutionSizeChange = Objectives < TestFunction.MinimumObjectives
                              || Objectives > TestFunction.MaximumObjectives;
      if (solutionSizeChange) {
        ProblemSize = Math.Max(TestFunction.MinimumObjectives, Math.Min(Objectives, TestFunction.MaximumObjectives));
      }

      Bounds = (DoubleMatrix)new DoubleMatrix(TestFunction.Bounds(Objectives)).Clone();
      ParameterizeAnalyzers();
      Parameterize();
      OnReset();
    }

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

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


      Parameterize();
    }

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

    #region Helpers
    private void InitializeOperators() {
      Operators.Add(new CrowdingAnalyzer());
      Operators.Add(new GenerationalDistanceAnalyzer());
      Operators.Add(new InvertedGenerationalDistanceAnalyzer());
      Operators.Add(new HypervolumeAnalyzer());
      Operators.Add(new SpacingAnalyzer());
      Operators.Add(new ScatterPlotAnalyzer());
      Operators.Add(new NormalizedHypervolumeAnalyzer());
      ParameterizeAnalyzers();
      Parameterize();
    }

    private void Parameterize() {
      MaximizationParameter.ActualValue = new BoolArray(Maximization);
      var front = BestKnownFront;
      if (front != null) { BestKnownFrontParameter.ActualValue = new DoubleMatrix(To2D(front.ToArray<double[]>())); }

    }

    private void ParameterizeAnalyzers() {
      foreach (var analyzer in Analyzers) {
        analyzer.ResultsParameter.ActualName = "Results";
        analyzer.QualitiesParameter.ActualName = Evaluator.QualitiesParameter.ActualName;
        analyzer.TestFunctionParameter.ActualName = TestFunctionParameter.Name;
        analyzer.BestKnownFrontParameter.ActualName = BestKnownFrontParameter.Name;


        var front = BestKnownFront;
        if (front != null) { BestKnownFrontParameter.ActualValue = new DoubleMatrix(To2D(front.ToArray<double[]>())); }


        var hyperVolumeAnalyzer = analyzer as HypervolumeAnalyzer;
        if (hyperVolumeAnalyzer != null) {
          hyperVolumeAnalyzer.ReferencePointParameter.Value = new DoubleArray(TestFunction.ReferencePoint(Objectives));
          hyperVolumeAnalyzer.BestKnownHyperVolume = TestFunction.BestKnownHypervolume(Objectives);
        }

        var normalizedHyperVolumeAnalyzer = analyzer as NormalizedHypervolumeAnalyzer;
        if (normalizedHyperVolumeAnalyzer != null) {
          normalizedHyperVolumeAnalyzer.OptimalFrontParameter.ActualValue = (DoubleMatrix)BestKnownFrontParameter.ActualValue;
        }

        var scatterPlotAnalyzer = analyzer as ScatterPlotAnalyzer;
        if (scatterPlotAnalyzer != null) {
          scatterPlotAnalyzer.IndividualsParameter.ActualName = Encoding.Name;
        }

      }
    }

    public static T[,] To2D<T>(T[][] source) {
      try {
        int FirstDim = source.Length;
        int SecondDim = source.GroupBy(row => row.Length).Single().Key; // throws InvalidOperationException if source is not rectangular

        var result = new T[FirstDim, SecondDim];
        for (int i = 0; i < FirstDim; ++i)
          for (int j = 0; j < SecondDim; ++j)
            result[i, j] = source[i][j];

        return result;
      }
      catch (InvalidOperationException) {
        throw new InvalidOperationException("The given jagged array is not rectangular.");
      }
    }

    #endregion
  }
}