Changeset 14073 for branches/HeuristicLab.Problems.MultiObjectiveTestFunctions

Timestamp:

07/14/16 17:40:54 (8 years ago)

Author:

mkommend

Message:

#1087: Worked on Multi-objective test function problem and adapted plugin dependencies.

Location:

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3

Files:

• MultiObjectiveTestFunctionProblem.cs (modified) (11 diffs)
• Plugin.cs.frame (modified) (1 diff)

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs

@@ -33 +33 @@
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
   [StorableClass]
+  [Creatable(CreatableAttribute.Categories.Problems, Priority = 95)]
+  [Item("Test Function (multi-objective)", "Test functions with real valued inputs and multiple objectives.")]
   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 {
+    public IValueParameter<BoolArray> MaximizationParameter {
+      get { return (IValueParameter<BoolArray>)Parameters["Maximization"]; }
+    }
+    public IFixedValueParameter<IntValue> ProblemSizeParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }
     }
-
-    /// <summary>
-    /// The number of objectives that are to be optimized
-    /// </summary>
-    private IFixedValueParameter<IntValue> ObjectivesParameter {
+    public IFixedValueParameter<IntValue> ObjectivesParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["Objectives"]; }
     }
-
-    /// <summary>
-    /// The bounds for the entries of the solution candidate
-    /// </summary>
-    private IValueParameter<DoubleMatrix> BoundsParameter {
+    public 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
+    public override bool[] Maximization {
       get {
-        return (IValueParameter<DoubleMatrix>)Parameters["BestKnownFront"];
-      }
-    }
-
-    #endregion
-
-    #region Properties
-    private IEnumerable<IMultiObjectiveTestFunctionAnalyzer> Analyzers {
-      get { return Operators.OfType<IMultiObjectiveTestFunctionAnalyzer>(); }
+        //necessary because of virtual member call in base ctor to this property
+        if (!Parameters.ContainsKey("TestFunction")) return new bool[2];
+        return TestFunction.Maximization(Objectives);
+      }
     }
 
@@ -113 +87 @@
       set { TestFunctionParameter.Value = value; }
     }
+    public IEnumerable<double[]> BestKnownFront {
+      get { return Parameters.ContainsKey("BestKnownFront") ? TestFunction.OptimalParetoFront(Objectives) : null; }
+    }
     #endregion
 
     [StorableConstructor]
     protected MultiObjectiveTestFunctionProblem(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
     protected MultiObjectiveTestFunctionProblem(MultiObjectiveTestFunctionProblem original, Cloner cloner)
       : base(original, cloner) {
       RegisterEventHandlers();
     }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveTestFunctionProblem(this, cloner);
+    }
+
     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)));
@@ -135 +119 @@
       BestKnownFrontParameter.Hidden = true;
 
+      UpdateParameterValues();
       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;
+      ObjectivesParameter.Value.ValueChanged += ObjectivesOnValueChanged;
+    }
+
 
     public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
@@ -150 +135 @@
       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;
       }
     }
@@ -178 +151 @@
     }
 
-    public double[] Evaluate(RealVector individual, IRandom random) {
+    public double[] Evaluate(RealVector individual) {
       return TestFunction.Evaluate(individual, Objectives);
     }
 
     public override double[] Evaluate(Individual individual, IRandom random) {
-      return Evaluate(individual.RealVector(), random);
+      return Evaluate(individual.RealVector());
     }
 
@@ -190 +163 @@
     }
 
-    private void RegisterEventHandlers() {
-      TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
-      ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
-      ObjectivesParameter.Value.ValueChanged += ObjectivesOnValueChanged;
-      BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;
-    }
-
     #region Events
+    private void UpdateParameterValues() {
+      MaximizationParameter.ActualValue = (BoolArray)new BoolArray(Maximization).AsReadOnly();
+      var front = BestKnownFront;
+      if (front != null) { BestKnownFrontParameter.Value = (DoubleMatrix)new DoubleMatrix(To2D(front.ToArray())).AsReadOnly(); }
+
+    }
+
     protected override void OnEncodingChanged() {
       base.OnEncodingChanged();
-      Parameterize();
+      UpdateParameterValues();
       ParameterizeAnalyzers();
     }
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
-      Parameterize();
+      UpdateParameterValues();
       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));
-      }
+      ProblemSize = Math.Max(TestFunction.MinimumSolutionLength, Math.Min(ProblemSize, TestFunction.MaximumSolutionLength));
+      Objectives = Math.Max(TestFunction.MinimumObjectives, Math.Min(Objectives, TestFunction.MaximumObjectives));
 
       Bounds = (DoubleMatrix)new DoubleMatrix(TestFunction.Bounds(Objectives)).Clone();
       ParameterizeAnalyzers();
-      Parameterize();
+      UpdateParameterValues();
       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();
+      ProblemSize = Math.Min(TestFunction.MaximumSolutionLength, Math.Max(TestFunction.MinimumSolutionLength, ProblemSize));
+      UpdateParameterValues();
     }
 
     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();
-    }
+      Objectives = Math.Min(TestFunction.MaximumObjectives, Math.Max(TestFunction.MinimumObjectives, Objectives));
+      UpdateParameterValues();
+    }
+
     #endregion
 
@@ -264 +213 @@
       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[]>())); }
-
+
+      ParameterizeAnalyzers();
+    }
+
+    private IEnumerable<IMultiObjectiveTestFunctionAnalyzer> Analyzers {
+      get { return Operators.OfType<IMultiObjectiveTestFunctionAnalyzer>(); }
     }
 
@@ -282 +228 @@
         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) {
@@ -295 +236 @@
         var normalizedHyperVolumeAnalyzer = analyzer as NormalizedHypervolumeAnalyzer;
         if (normalizedHyperVolumeAnalyzer != null) {
-          normalizedHyperVolumeAnalyzer.OptimalFrontParameter.ActualValue = (DoubleMatrix)BestKnownFrontParameter.ActualValue;
+          normalizedHyperVolumeAnalyzer.OptimalFrontParameter.Value = (DoubleMatrix)BestKnownFrontParameter.ActualValue;
         }
 
@@ -302 +243 @@
           scatterPlotAnalyzer.IndividualsParameter.ActualName = Encoding.Name;
         }
-
       }
     }
@@ -308 +248 @@
     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)
+        int firstDimension = source.Length;
+        int secondDimension = source.GroupBy(row => row.Length).Single().Key; // throws InvalidOperationException if source is not rectangular
+
+        var result = new T[firstDimension, secondDimension];
+        for (int i = 0; i < firstDimension; ++i)
+          for (int j = 0; j < secondDimension; ++j)
             result[i, j] = source[i][j];
 

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Plugin.cs.frame

@@ -27 +27 @@
   [PluginDependency("HeuristicLab.Collections", "3.3")] 
   [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]  
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")] 
+  [PluginDependency("HeuristicLab.Parameters", "3.3")] 
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
-  public class HeuristicLabScriptingPlugin : PluginBase {
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+
+  [PluginDependency("HeuristicLab.Core.Views", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3")]
+  [PluginDependency("HeuristicLab.Visualization.ChartControlsExtensions", "3.3")]
+  public class Plugin : PluginBase {
   }
 }