Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs @ 5184

Last change on this file since 5184 was 5184, checked in by cneumuel, 13 years ago

#1215

  • enhanced combinations generator (now with batchruns!)
  • fixed ActualNames for metaopt-alg
  • added penalty for invalid solution-candidates (algs which throw exceptions)
  • migrated to .NET 4.0
File size: 10.5 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Linq;
24using HeuristicLab.Common;
25using HeuristicLab.Core;
26using HeuristicLab.Data;
27using HeuristicLab.Optimization;
28using HeuristicLab.Parameters;
29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
30using HeuristicLab.PluginInfrastructure;
31using HeuristicLab.Algorithms.GeneticAlgorithm;
32using HeuristicLab.Problems.TestFunctions;
33
34namespace HeuristicLab.Problems.MetaOptimization {
35  [Item("Meta Optimization Problem", "Represents a Meta Optimization Problem.")]
36  [Creatable("Problems")]
37  [StorableClass]
38  public sealed class MetaOptimizationProblem : SingleObjectiveProblem<IParameterConfigurationEvaluator, IParameterConfigurationCreator> {
39    public const string AlgorithmTypeParameterName = "AlgorithmType";
40    public const string ProblemTypeParameterName = "ProblemType";
41    public const string ProblemsParameterName = "Problems";
42    public const string ParameterConfigurationTreeParameterName = "InitialParameterConfigurationTree";
43    public const string RepetitionsParameterName = "Repetitions";
44
45    public const string IntValueManipulatorParameterName = "IntValueManipulator";
46    public const string DoubleValueManipulatorParameterName = "DoubleValueManipulator";
47    public const string IntValueCrossoverParameterName = "IntValueCrossover";
48    public const string DoubleValueCrossoverParameterName = "DoubleValueCrossover";
49
50    #region Parameter Properties
51    public IValueParameter<EngineAlgorithm> AlgorithmTypeParameter {
52      get { return (ValueParameter<EngineAlgorithm>)Parameters[AlgorithmTypeParameterName]; }
53    }
54    public IValueParameter<ISingleObjectiveProblem> ProblemTypeParameter {
55      get { return (ValueParameter<ISingleObjectiveProblem>)Parameters[ProblemTypeParameterName]; }
56    }
57    public IValueParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
58      get { return (ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
59    }
60    public IValueParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter {
61      get { return (ValueParameter<ParameterConfigurationTree>)Parameters[ParameterConfigurationTreeParameterName]; }
62    }
63    public IValueParameter<IntValue> RepetitionsParameter {
64      get { return (ValueParameter<IntValue>)Parameters[RepetitionsParameterName]; }
65    }
66
67    public IValueParameter<IIntValueManipulator> IntValueManipulatorParameter {
68      get { return (ValueParameter<IIntValueManipulator>)Parameters[IntValueManipulatorParameterName]; }
69    }
70
71    public IValueParameter<IDoubleValueManipulator> DoubleValueManipulatorParameter {
72      get { return (ValueParameter<IDoubleValueManipulator>)Parameters[DoubleValueManipulatorParameterName]; }
73    }
74    #endregion
75
76    #region Properties
77    public EngineAlgorithm Algorithm {
78      get { return AlgorithmTypeParameter.Value; }
79      set { AlgorithmTypeParameter.Value = value; }
80    }
81    public ISingleObjectiveProblem Problem {
82      get { return ProblemTypeParameter.Value; }
83      set { ProblemTypeParameter.Value = value; }
84    }
85    public ConstrainedItemList<ISingleObjectiveProblem> Problems {
86      get { return ProblemsParameter.Value; }
87      set { ProblemsParameter.Value = value; }
88    }
89    public ParameterConfigurationTree ParameterConfigurationTree {
90      get { return ParameterConfigurationTreeParameter.Value; }
91      set { ParameterConfigurationTreeParameter.Value = value; }
92    }
93    public IntValue Repetitions {
94      get { return RepetitionsParameter.Value; }
95      set { RepetitionsParameter.Value = value; }
96    }
97    private BestParameterConfigurationAnalyzer BestParameterConfigurationAnalyzer {
98      get { return Operators.OfType<BestParameterConfigurationAnalyzer>().FirstOrDefault(); }
99    }
100    #endregion
101
102    public MetaOptimizationProblem() : base() {
103      Parameters.Add(new ValueParameter<EngineAlgorithm>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new GeneticAlgorithm()));
104      Parameters.Add(new ValueParameter<ISingleObjectiveProblem>(ProblemTypeParameterName, "The problem type.", new SingleObjectiveTestFunctionProblem()));
105      Parameters.Add(new ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<ISingleObjectiveProblem>()));
106      Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "Tree of algorithm parameters that should be optimized."));
107      Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "The number of evaluations for each problem.", new IntValue(3)));
108
109      var validIntManipulators = new ItemSet<IIntValueManipulator>( ApplicationManager.Manager.GetInstances<IIntValueManipulator>());
110      var validDoubleManipulators = new ItemSet<IDoubleValueManipulator>(ApplicationManager.Manager.GetInstances<IDoubleValueManipulator>());
111      Parameters.Add(new ConstrainedValueParameter<IIntValueManipulator>(IntValueManipulatorParameterName, "", validIntManipulators, new UniformIntValueManipulator()));
112      Parameters.Add(new ConstrainedValueParameter<IDoubleValueManipulator>(DoubleValueManipulatorParameterName, "", validDoubleManipulators, new NormalDoubleValueManipulator()));
113
114      Maximization = new BoolValue(false);
115      SolutionCreator = new RandomParameterConfigurationCreator();
116      Evaluator = new ParameterConfigurationEvaluator();
117
118      InitializeOperators();
119      RegisterParameterEvents();
120      ParameterizeAnalyzer();
121      ParameterizeSolutionCreator();
122      ParameterizeEvaluator();
123      ParameterizeOperators();
124
125      Problems.Type = Problem.GetType();
126      Algorithm.Problem = Problem;
127      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
128    }
129
130    [StorableConstructor]
131    private MetaOptimizationProblem(bool deserializing) : base(deserializing) { }
132    private MetaOptimizationProblem(MetaOptimizationProblem original, Cloner cloner) : base(original, cloner) {
133      // todo
134      this.RegisterParameterEvents();
135    }
136    public override IDeepCloneable Clone(Cloner cloner) {
137      return new MetaOptimizationProblem(this, cloner);
138    }
139
140    #region Helpers
141    [StorableHook(HookType.AfterDeserialization)]
142    private void AfterDeserializationHook() {
143      RegisterParameterEvents();
144    }
145    private void RegisterParameterEvents() {
146      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
147      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
148      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
149      AlgorithmTypeParameter.ValueChanged += new EventHandler(AlgorithmTypeParameter_ValueChanged);
150      ProblemTypeParameter.ValueChanged += new EventHandler(ProblemTypeParameter_ValueChanged);
151    }
152   
153    private void InitializeOperators() {
154      Operators.AddRange(ApplicationManager.Manager.GetInstances<IParameterConfigurationOperator>().Cast<IOperator>());
155      Operators.Add(new BestParameterConfigurationAnalyzer());
156    }
157    private void ParameterizeSolutionCreator() {
158    }
159    private void ParameterizeEvaluator() {
160      ((ParameterConfigurationEvaluator)Evaluator).ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
161    }
162    private void ParameterizeAnalyzer() {
163      if (BestParameterConfigurationAnalyzer != null) {
164        BestParameterConfigurationAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
165      }
166    }
167    private void ParameterizeOperators() {
168      foreach (IParameterConfigurationCrossover op in Operators.OfType<IParameterConfigurationCrossover>()) {
169        op.ParentsParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
170        op.ChildParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
171      }
172      foreach (IParameterConfigurationManipulator op in Operators.OfType<IParameterConfigurationManipulator>()) {
173        op.ParameterConfigurationTreeParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
174      }
175    }
176
177    #endregion
178
179    #region Events
180
181    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
182      ParameterizeSolutionCreator();
183      ParameterizeEvaluator();
184      ParameterizeAnalyzer();
185      ParameterizeOperators();
186      OnSolutionCreatorChanged();
187    }
188    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
189      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
190      ParameterizeEvaluator();
191      ParameterizeAnalyzer();
192      OnEvaluatorChanged();
193    }
194    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
195      ParameterizeAnalyzer();
196    }
197    void AlgorithmTypeParameter_ValueChanged(object sender, EventArgs e) {
198      Algorithm.Problem = Problem;
199      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
200    }
201    void ProblemTypeParameter_ValueChanged(object sender, EventArgs e) {
202      Problems.Type = Problem.GetType();
203      Algorithm.Problem = Problem;
204      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
205    }
206    #endregion
207  }
208}
Note: See TracBrowser for help on using the repository browser.