Changeset 5110 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs

Timestamp:

12/15/10 15:43:43 (13 years ago)

Author:

cneumuel

Message:

#1215

• optional parameter values now can be null
• problem type can now be set specifically
• values are constrained to the encoding of the Problem
• moved repetitions parameter to MetaOptimizationProblem

File:

• branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs (modified) (7 diffs)

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs

@@ -29 +29 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Algorithms.GeneticAlgorithm;
+using HeuristicLab.Problems.TestFunctions;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -35 +37 @@
   [StorableClass]
   public sealed class MetaOptimizationProblem : SingleObjectiveProblem<IMetaOptimizationEvaluator, IParameterConfigurationCreator> {
-    private const string AlgorithmParameterName = "Algorithm";
-    private const string ProblemsParameterName = "Problems";
-    private const string AlgorithmParameterConfigurationParameterName = "InitialParameterConfigurationTree";
-    //private const string ProblemParametersConfigurationParameterName = "ProblemParametersConfiguration";
+    public const string AlgorithmTypeParameterName = "AlgorithmType";
+    public const string ProblemTypeParameterName = "ProblemType";
+    public const string ProblemsParameterName = "Problems";
+    public const string ParameterConfigurationParameterName = "InitialParameterConfigurationTree";
+    public const string RepetitionsParameterName = "Repetitions";
 
     #region Parameter Properties
-    public IValueParameter<EngineAlgorithm> AlgorithmParameter {
-      get { return (ValueParameter<EngineAlgorithm>)Parameters[AlgorithmParameterName]; }
+    public IValueParameter<EngineAlgorithm> AlgorithmTypeParameter {
+      get { return (ValueParameter<EngineAlgorithm>)Parameters[AlgorithmTypeParameterName]; }
     }
-    public IValueParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
-      get { return (ValueParameter<IItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
+    public IValueParameter<ISingleObjectiveProblem> ProblemTypeParameter {
+      get { return (ValueParameter<ISingleObjectiveProblem>)Parameters[ProblemTypeParameterName]; }
     }
-    public IValueParameter<ParameterConfigurationTree> AlgorithmParameterConfigurationParameter {
-      get { return (ValueParameter<ParameterConfigurationTree>)Parameters[AlgorithmParameterConfigurationParameterName]; }
+    public IValueParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
+      get { return (ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
     }
-    //public ValueParameter<IItemList<IParameterConfiguration>> ProblemParametersConfigurationParameter {
-    //  get { return (ValueParameter<IItemList<IParameterConfiguration>>)Parameters[ProblemParametersConfigurationParameterName]; }
-    //}
+    public IValueParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
+      get { return (ValueParameter<ParameterConfigurationTree>)Parameters[ParameterConfigurationParameterName]; }
+    }
+    public IValueParameter<IntValue> RepetitionsParameter {
+      get { return (ValueParameter<IntValue>)Parameters[RepetitionsParameterName]; }
+    }
     #endregion
 
     #region Properties
     public EngineAlgorithm Algorithm {
-      get { return AlgorithmParameter.Value; }
-      set { AlgorithmParameter.Value = value; }
+      get { return AlgorithmTypeParameter.Value; }
+      set { AlgorithmTypeParameter.Value = value; }
     }
-    public IItemList<ISingleObjectiveProblem> Problems {
+    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 AlgorithmParameterConfiguration {
-      get { return AlgorithmParameterConfigurationParameter.Value; }
-      set { AlgorithmParameterConfigurationParameter.Value = value; }
+      get { return ParameterConfigurationParameter.Value; }
+      set { ParameterConfigurationParameter.Value = value; }
     }
-    //public IItemList<IParameterConfiguration> ProblemParametersConfiguration {
-    //  get { return ProblemParametersConfigurationParameter.Value; }
-    //  set { ProblemParametersConfigurationParameter.Value = value; }
-    //}
+    public IntValue Repetitions {
+      get { return RepetitionsParameter.Value; }
+      set { RepetitionsParameter.Value = value; }
+    }
     #endregion
 
     public MetaOptimizationProblem() : base() {
-      Parameters.Add(new ValueParameter<EngineAlgorithm>(AlgorithmParameterName, "The algorithm which's parameters should be optimized."));
-      Parameters.Add(new ValueParameter<IItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ItemList<ISingleObjectiveProblem>()));
-      Parameters.Add(new ValueParameter<ParameterConfigurationTree>(AlgorithmParameterConfigurationParameterName, "List of algorithm parameters that should be optimized."));
-      //Parameters.Add(new ValueParameter<IItemList<IParameterConfiguration>>(ProblemParametersConfigurationParameterName, "List of problem parameters that should be optimized.", new ItemList<IParameterConfiguration>()));
-      
+      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>(ParameterConfigurationParameterName, "List of algorithm parameters that should be optimized."));
+      Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "The number of evaluations for each problem.", new IntValue(3)));
+
       Maximization = new BoolValue(false);
       SolutionCreator = new RandomParameterConfigurationCreator();
@@ -89 +100 @@
       ParameterizeEvaluator();
       ParameterizeOperators();
+
+      Problems.Type = Problem.GetType();
+      Algorithm.Problem = Problem;
+      ParameterConfigurationParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
     }
 
@@ -110 +125 @@
       EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
       Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      AlgorithmParameter.ValueChanged += new EventHandler(BaseLevelAlgorithmParameter_ValueChanged);
+      AlgorithmTypeParameter.ValueChanged += new EventHandler(AlgorithmTypeParameter_ValueChanged);
+      ProblemTypeParameter.ValueChanged += new EventHandler(ProblemTypeParameter_ValueChanged);
     }
+    
     private void InitializeOperators() {
       Operators.AddRange(ApplicationManager.Manager.GetInstances<IParameterConfigurationOperator>().Cast<IOperator>());
@@ -117 +134 @@
     }
     private void ParameterizeSolutionCreator() {
-      //SolutionCreator.ParametersToOptimize = this.ParametersToOptimize;
-      
     }
     private void ParameterizeEvaluator() {
@@ -124 +139 @@
     }
     private void ParameterizeAnalyzer() {
-      //BestQualityAnalyzer.ResultsParameter.ActualName = "Results";
     }
     private void ParameterizeOperators() {
@@ -150 +164 @@
       ParameterizeAnalyzer();
     }
-    void BaseLevelAlgorithmParameter_ValueChanged(object sender, EventArgs e) {
-      AlgorithmParameterConfiguration = new ParameterConfigurationTree(Algorithm);
-
-      //Algorithm.ProblemChanged += new EventHandler(BaseLevelAlgorithm_ProblemChanged); // when to deregister?
-      //BaseLevelAlgorithm_ProblemChanged(sender, e);
+    void AlgorithmTypeParameter_ValueChanged(object sender, EventArgs e) {
+      Algorithm.Problem = Problem;
+      ParameterConfigurationParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
     }
-
-    void BaseLevelAlgorithm_ProblemChanged(object sender, EventArgs e) {
-      //if (Algorithm != null && Algorithm.Problem != null) {
-      //  AlgorithmParameterConfiguration = new ParameterConfigurationTree(Algorithm);
-      //}
+    void ProblemTypeParameter_ValueChanged(object sender, EventArgs e) {
+      Problems.Type = Problem.GetType();
+      Algorithm.Problem = Problem;
+      ParameterConfigurationParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
     }
     #endregion