Changeset 17309


Ignore:
Timestamp:
10/03/19 17:43:11 (11 days ago)
Author:
abeham
Message:

#2521: Refactored maximization property for multi-objective problems

Location:
branches/2521_ProblemRefactoring
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • branches/2521_ProblemRefactoring/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/HypervolumeIndicator.cs

    r17226 r17309  
    2626using HeuristicLab.Core;
    2727using HeuristicLab.Optimization;
    28 using HeuristicLab.Problems.TestFunctions.MultiObjective;
    2928
    3029namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
     
    5352
    5453    #region Helpers
    55     private static double Contribution(IList<double[]> front, int idx, bool[] maximization, double[] refPoint) {
     54    private static double Contribution(IList<double[]> front, int idx, IReadOnlyList<bool> maximization, double[] refPoint) {
    5655      var point = front[idx];
    5756      front.RemoveAt(idx);
  • branches/2521_ProblemRefactoring/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs

    r17261 r17309  
    376376      var bkf = problem.BestKnownFront == null ? null : problem.BestKnownFront.ToArray();
    377377      if (bkf != null && problem.ReferencePoint != null) {
    378         ResultsBestKnownHypervolume = HypervolumeCalculator.CalculateHypervolume(bkf, problem.ReferencePoint, Problem.Maximization);
     378        ResultsBestKnownHypervolume = HypervolumeCalculator.CalculateHypervolume(bkf, problem.ReferencePoint, Problem.Maximization.CloneAsArray());
    379379        ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
    380380      }
     
    456456      //perform a non-dominated sort to assign the rank to every element
    457457      int[] ranks;
    458       var fronts = DominationCalculator.CalculateAllParetoFronts(parents.ToArray(), parents.Select(i => i.PenalizedFitness).ToArray(), Problem.Maximization, out ranks);
     458      var fronts = DominationCalculator.CalculateAllParetoFronts(parents.ToArray(), parents.Select(i => i.PenalizedFitness).ToArray(), Problem.Maximization.CloneAsArray(), out ranks);
    459459
    460460      //deselect the highest rank fronts until we would end up with less or equal mu elements
  • branches/2521_ProblemRefactoring/HeuristicLab.Data/3.3/BoolArray.cs

    r17253 r17309  
    2020#endregion
    2121
     22using System.Collections.Generic;
    2223using System.Text;
    2324using HEAL.Attic;
     
    3738    public BoolArray(int length) : base(length) { }
    3839    public BoolArray(bool[] elements, bool @readonly = false) : base(elements, @readonly) { }
     40    public BoolArray(IReadOnlyList<bool> elements) : base(elements) { }
    3941
    4042    public override IDeepCloneable Clone(Cloner cloner) {
  • branches/2521_ProblemRefactoring/HeuristicLab.Data/3.3/StringConvertibleArray.cs

    r17253 r17309  
    2222#endregion
    2323
     24using System.Collections.Generic;
    2425using HEAL.Attic;
    2526using HeuristicLab.Common;
     
    3839    protected StringConvertibleArray(int length) : base(length) { }
    3940    protected StringConvertibleArray(T[] elements, bool @readonly = false) : base(elements, @readonly) { }
     41    protected StringConvertibleArray(IReadOnlyList<T> elements) : base(elements) { }
    4042
    4143    protected abstract bool Validate(string value, out string errorMessage);
  • branches/2521_ProblemRefactoring/HeuristicLab.Data/3.3/ValueTypeArray.cs

    r17253 r17309  
    138138    }
    139139    protected ValueTypeArray(T[] elements, bool @readonly = false) {
    140       if (elements == null) throw new ArgumentNullException();
     140      if (elements == null) throw new ArgumentNullException(nameof(elements));
    141141      array = (T[])elements.Clone();
    142142      readOnly = @readonly;
    143143      resizable = true;
    144144      elementNames = new List<string>();
     145    }
     146   
     147    protected ValueTypeArray(IReadOnlyList<T> elements) {
     148      if (elements == null) throw new ArgumentNullException(nameof(elements));
     149      array = elements.ToArray(); // TODO: array should be an IList<T>
     150      readOnly = true;
     151      resizable = true; // TODO: really?
     152      elementNames = new List<string>(); // TODO: wasteful
    145153    }
    146154
  • branches/2521_ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeMultiObjectiveProblem.cs

    r17230 r17309  
    5454      base.Analyze(trees, qualities, results, random);
    5555
    56       var fronts = DominationCalculator.CalculateAllParetoFrontsIndices(trees, qualities, Maximization);
     56      var fronts = DominationCalculator.CalculateAllParetoFrontsIndices(trees, qualities, Maximization.CloneAsArray());
    5757      var plot = new ParetoFrontScatterPlot<ISymbolicExpressionTree>(fronts, trees, qualities, Objectives, BestKnownFront);
    5858      results.AddOrUpdateResult("Pareto Front Scatter Plot", plot);
  • branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs

    r17257 r17309  
    2828  public interface IMultiObjectiveProblemDefinition {
    2929    int Objectives { get; }
    30     bool[] Maximization { get; }
     30    IReadOnlyList<bool> Maximization { get; }
    3131    IReadOnlyList<double[]> BestKnownFront { get; }
    3232    double[] ReferencePoint { get; }
  • branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs

    r17226 r17309  
    3737    where TEncodedSolution : class, IEncodedSolution {
    3838    #region Parameternames
    39     public const string MaximizationParameterName = "Maximization";
    4039    public const string BestKnownFrontParameterName = "BestKnownFront";
    4140    public const string ReferencePointParameterName = "ReferencePoint";
     
    4342
    4443    #region Parameterproperties
    45     public IValueParameter<BoolArray> MaximizationParameter {
    46       get { return (IValueParameter<BoolArray>)Parameters[MaximizationParameterName]; }
    47     }
     44    [Storable] protected IValueParameter<BoolArray> MaximizationParameter { get; }
    4845    public IValueParameter<DoubleMatrix> BestKnownFrontParameter {
    4946      get { return (IValueParameter<DoubleMatrix>)Parameters[BestKnownFrontParameterName]; }
     
    6057    protected MultiObjectiveProblem(MultiObjectiveProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
    6158      : base(original, cloner) {
     59      MaximizationParameter = cloner.Clone(original.MaximizationParameter);
    6260      ParameterizeOperators();
    6361    }
    6462
    6563    protected MultiObjectiveProblem() : base() {
    66       Parameters.Add(new ValueParameter<BoolArray>(MaximizationParameterName, "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()));
     64      MaximizationParameter = new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", new BoolArray(new[] { false, false }).AsReadOnly()) { Hidden = true, ReadOnly = true };
     65      Parameters.Add(MaximizationParameter);
    6766      Parameters.Add(new OptionalValueParameter<DoubleMatrix>(BestKnownFrontParameterName, "A double matrix representing the best known qualites for this problem (aka points on the Pareto front). Points are to be given in a row-wise fashion."));
    6867      Parameters.Add(new OptionalValueParameter<DoubleArray>(ReferencePointParameterName, "The refrence point for hypervolume calculations on this problem"));
     
    7372
    7473    protected MultiObjectiveProblem(TEncoding encoding) : base(encoding) {
    75       Parameters.Add(new ValueParameter<BoolArray>(MaximizationParameterName, "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()));
     74      MaximizationParameter = new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", new BoolArray(new[] { false, false }).AsReadOnly()) { Hidden = true, ReadOnly = true };
     75      Parameters.Add(MaximizationParameter);
    7676      Parameters.Add(new OptionalValueParameter<DoubleMatrix>(BestKnownFrontParameterName, "A double matrix representing the best known qualites for this problem (aka points on the Pareto front). Points are to be given in a row-wise fashion."));
    7777      Parameters.Add(new OptionalValueParameter<DoubleArray>(ReferencePointParameterName, "The refrence point for hypervolume calculations on this problem"));
     
    8989      get { return Maximization.Length; }
    9090    }
    91     public abstract bool[] Maximization { get; }
     91    IReadOnlyList<bool> IMultiObjectiveProblemDefinition.Maximization {
     92      get { return Maximization.CloneAsArray(); }
     93    }
     94    public BoolArray Maximization {
     95      get { return MaximizationParameter.Value; }
     96      set {
     97        if (Maximization == value) return;
     98        MaximizationParameter.ReadOnly = false;
     99        MaximizationParameter.Value = value.AsReadOnly();
     100        MaximizationParameter.ReadOnly = true;
     101      }
     102    }
    92103
    93104    public virtual IReadOnlyList<double[]> BestKnownFront {
     
    168179    #region IMultiObjectiveHeuristicOptimizationProblem Members
    169180    IParameter IMultiObjectiveHeuristicOptimizationProblem.MaximizationParameter {
    170       get { return Parameters[MaximizationParameterName]; }
     181      get { return MaximizationParameter; }
    171182    }
    172183    IMultiObjectiveEvaluator IMultiObjectiveHeuristicOptimizationProblem.Evaluator {
  • branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/DominationCalculator.cs

    r17230 r17309  
    4747    /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
    4848    /// <returns>The pareto front containing the best solutions and their associated quality resp. fitness.</returns>
    49     public static List<Tuple<T, double[]>> CalculateBestParetoFront<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities = true) {
     49    public static List<Tuple<T, double[]>> CalculateBestParetoFront<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, bool dominateOnEqualQualities = true) {
    5050      var populationSize = solutions.Length;
    5151      Dictionary<T, List<int>> dominatedIndividuals;
     
    7272    /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
    7373    /// <returns>A sorted list of the pareto fronts from best to worst.</returns>
    74     public static List<List<Tuple<T, double[]>>> CalculateAllParetoFronts<T>(T[] solutions, double[][] qualities, bool[] maximization, out int[] rank, bool dominateOnEqualQualities = true) {
     74    public static List<List<Tuple<T, double[]>>> CalculateAllParetoFronts<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, out int[] rank, bool dominateOnEqualQualities = true) {
    7575      var populationSize = solutions.Length;
    7676
     
    101101    }
    102102
    103     private static List<Tuple<T, double[]>> CalculateBestFront<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities, int populationSize, out Dictionary<T, List<int>> dominatedIndividuals, out int[] dominationCounter, out int[] rank) {
     103    private static List<Tuple<T, double[]>> CalculateBestFront<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, bool dominateOnEqualQualities, int populationSize, out Dictionary<T, List<int>> dominatedIndividuals, out int[] dominationCounter, out int[] rank) {
    104104      var front = new List<Tuple<T, double[]>>();
    105105      dominatedIndividuals = new Dictionary<T, List<int>>();
     
    155155    /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
    156156    /// <returns>A sorted list of the pareto fronts where each front contains the indices of the <paramref name="solutions"/> and <paramref name="qualities"/>.</returns>
    157     public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities = true) {
     157    public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, bool dominateOnEqualQualities = true) {
    158158      return CalculateAllParetoFrontsIndices(solutions, qualities, maximization, out var rank, dominateOnEqualQualities);
    159159    }
     
    178178    /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
    179179    /// <returns>A sorted list of the pareto fronts where each front contains the indices of the <paramref name="solutions"/> and <paramref name="qualities"/>.</returns>
    180     public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, bool[] maximization, out int[] rank, bool dominateOnEqualQualities = true) {
     180    public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, out int[] rank, bool dominateOnEqualQualities = true) {
    181181      var populationSize = solutions.Length;
    182182
     
    207207    }
    208208
    209     private static List<int> CalculateBestFrontIndices<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities, int populationSize, List<int>[] dominatedIndividuals, int[] dominationCounter, int[] rank) {
     209    private static List<int> CalculateBestFrontIndices<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, bool dominateOnEqualQualities, int populationSize, List<int>[] dominatedIndividuals, int[] dominationCounter, int[] rank) {
    210210      var front = new List<int>();
    211211      for (var pI = 0; pI < populationSize - 1; pI++) {
     
    244244    /// <param name="dominateOnEqualQualities">Whether the result should be Dominates in case both fitness vectors are exactly equal</param>
    245245    /// <returns>Dominates if left dominates right, IsDominated if right dominates left and IsNonDominated otherwise.</returns>
    246     public static DominationResult Dominates(double[] left, double[] right, bool[] maximizations, bool dominateOnEqualQualities) {
     246    public static DominationResult Dominates(double[] left, double[] right, IReadOnlyList<bool> maximizations, bool dominateOnEqualQualities) {
    247247      //mkommend Caution: do not use LINQ.SequenceEqual for comparing the two quality arrays (left and right) due to performance reasons
    248248      if (dominateOnEqualQualities) {
  • branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs

    r17225 r17309  
    2626namespace HeuristicLab.Optimization {
    2727  public static class HypervolumeCalculator {
    28     public static double[] CalculateNadirPoint(IEnumerable<double[]> qualities, bool[] maximization) {
     28    public static double[] CalculateNadirPoint(IEnumerable<double[]> qualities, IReadOnlyList<bool> maximization) {
    2929      var res = maximization.Select(m => m ? double.MaxValue : double.MinValue).ToArray();
    3030      foreach (var quality in qualities)
     
    5959    /// </summary>
    6060    ///
    61     public static double CalculateHypervolume(IList<double[]> qualities, double[] referencePoint, bool[] maximization) {
     61    public static double CalculateHypervolume(IList<double[]> qualities, double[] referencePoint, IReadOnlyList<bool> maximization) {
    6262      qualities = qualities.Where(vec => DominationCalculator.Dominates(vec, referencePoint, maximization, false) == DominationResult.Dominates).ToArray();
    6363      if (qualities.Count== 0) return 0; //TODO computation for negative hypervolume?
    64       if (maximization.Length == 2)
     64      if (maximization.Count == 2)
    6565        return Calculate2D(qualities, referencePoint, maximization);
    6666
    67       if (Array.TrueForAll(maximization, x => !x))
     67      if (maximization.All(x => !x))
    6868        return CalculateMultiDimensional(qualities, referencePoint);
    6969      throw new NotImplementedException("HypervolumeCalculator calculation for more than two dimensions is supported only with minimization problems.");
     
    7878    /// <param name="maximization"></param>
    7979    /// <returns></returns>
    80     public static double Calculate2D(IList<double[]> front, double[] referencePoint, bool[] maximization) {
     80    public static double Calculate2D(IList<double[]> front, double[] referencePoint, IReadOnlyList<bool> maximization) {
    8181      if (front == null) throw new ArgumentNullException("front");
    8282      if (referencePoint == null) throw new ArgumentNullException("referencePoint");
  • branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/MultiObjectiveExternalEvaluationProblem.cs

    r17226 r17309  
    9090    public MultiObjectiveExternalEvaluationProblem(TEncoding encoding)
    9191      : base(encoding) {
    92       Parameters.Remove("Maximization"); // readonly in base class
    93       Parameters.Add(new FixedValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", new BoolArray()));
     92      MaximizationParameter.ReadOnly = false;
     93      MaximizationParameter.Value = new BoolArray(new [] { false, false });
    9494      Parameters.Add(new OptionalValueParameter<EvaluationCache>("Cache", "Cache of previously evaluated solutions."));
    9595      Parameters.Add(new ValueParameter<CheckedItemCollection<IEvaluationServiceClient>>("Clients", "The clients that are used to communicate with the external application.", new CheckedItemCollection<IEvaluationServiceClient>() { new EvaluationServiceClient() }));
     
    9999
    100100    #region Multi Objective Problem Overrides
    101     public override bool[] Maximization {
    102       get {
    103         return Parameters.ContainsKey("Maximization") ? ((IValueParameter<BoolArray>)Parameters["Maximization"]).Value.ToArray() : new bool[0];
    104       }
    105     }
    106 
    107101    public virtual void SetMaximization(bool[] maximization) {
    108102      ((IStringConvertibleArray)MaximizationParameter.Value).Length = maximization.Length;
  • branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs

    r17226 r17309  
    2323using System.Collections.Generic;
    2424using HeuristicLab.Core;
    25 using HeuristicLab.Data;
    2625using HeuristicLab.Optimization;
    2726
     
    7877
    7978    #region ISingleObjectiveProblemDefinition<TEncoding,TEncodedSolution> Members
    80     public int Objectives => Maximization.Length;
    81     public abstract bool[] Maximization { get; }
     79    public int Objectives => Maximization.Count;
     80    public abstract IReadOnlyList<bool> Maximization { get; }
    8281    public abstract IReadOnlyList<double[]> BestKnownFront { get; }
    8382    public abstract double[] ReferencePoint { get; }
  • branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinitionScript.cs

    r17226 r17309  
    2424using HeuristicLab.Common;
    2525using HeuristicLab.Core;
    26 using HeuristicLab.Data;
    2726using HeuristicLab.Optimization;
    2827
     
    5251    public IReadOnlyList<double[]> BestKnownFront => CompiledProblemDefinition.BestKnownFront;
    5352    public double[] ReferencePoint => CompiledProblemDefinition.ReferencePoint;
    54     public bool[] Maximization => CompiledProblemDefinition.Maximization;
     53    public IReadOnlyList<bool> Maximization => CompiledProblemDefinition.Maximization;
    5554
    5655
  • branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs

    r17226 r17309  
    9494
    9595    private void OnProblemDefinitionChanged() {
    96       Parameters.Remove("Maximization");
    97       Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()) {Hidden = true});
     96      Maximization = new BoolArray(ProblemDefinition.Maximization);
    9897      Encoding = (TEncoding)ProblemScript.Encoding.Clone();
    9998
     
    107106    private void OnProblemScriptNameChanged() {
    108107      Name = ProblemScript.Name;
    109     }
    110 
    111     public override bool[] Maximization {
    112       get { return Parameters.ContainsKey("ProblemScript") ? ProblemDefinition.Maximization : new[] {false}; }
    113108    }
    114109
  • branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/Templates/MultiObjectiveCombinedEncodingProblem_Template.cs

    r17225 r17309  
    1616namespace HeuristicLab.Problems.Programmable {
    1717  public class CompiledMultiObjectiveProblemDefinition : CompiledMultiObjectiveProblemDefinition<CombinedEncoding, CombinedSolution> {
    18     public override bool[] Maximization { get { return new[] { true, false }; } }
     18    public override IReadOnlyList<bool> Maximization { get { return new[] { true, false }; } }
    1919    public override double[] ReferencePoint { get { return null; } }
    2020    public override IReadOnlyList<double[]> BestKnownFront { get { return null; } }
  • branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/MultiObjectiveTestFunctionProblem.cs

    r17261 r17309  
    2020#endregion
    2121using System;
    22 using System.Linq;
    2322using HEAL.Attic;
    2423using HeuristicLab.Analysis;
     
    5251
    5352    #region Properties
    54     public override bool[] Maximization {
    55       get {
    56         //necessary because of virtual member call in base ctor
    57         if (!Parameters.ContainsKey("TestFunction")) return new bool[0];
    58         return TestFunction.Maximization(Objectives).ToArray();
    59       }
    60     }
    61 
    6253    public int ProblemSize {
    6354      get { return ProblemSizeParameter.Value.Value; }
     
    141132    #region Events
    142133    private void UpdateParameterValues() {
    143       Parameters.Remove(MaximizationParameterName);
    144       Parameters.Add(new FixedValueParameter<BoolArray>(MaximizationParameterName, "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(TestFunction.Maximization(Objectives)).AsReadOnly()));
     134      Maximization = new BoolArray(TestFunction.Maximization(Objectives));
    145135
    146136      Parameters.Remove(BestKnownFrontParameterName);
Note: See TracChangeset for help on using the changeset viewer.