Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterConfigurationTree.cs @ 6018

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

#1215

  • support for maximization problems
  • made base level algorithms stoppable
  • optimization for multiple goals possible (AverageQuality, AverageDeviation, AverageEvaluatedSolutions)
  • lots of fixes
File size: 11.3 KB
Line 
1using System;
2using System.Collections;
3using System.Collections.Generic;
4using System.Linq;
5using System.Text;
6using HeuristicLab.Common;
7using HeuristicLab.Core;
8using HeuristicLab.Data;
9using HeuristicLab.Optimization;
10using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
11
12namespace HeuristicLab.Problems.MetaOptimization {
13  // todo: storable, name, descr, ...
14  [StorableClass]
15  public class ParameterConfigurationTree : ParameterizedValueConfiguration, IEnumerable {
16
17    [Storable]
18    private DoubleValue quality;
19    public DoubleValue Quality {
20      get { return quality; }
21      set {
22        if (quality != value) {
23          quality = value;
24          OnQualityChanged();
25        }
26      }
27    }
28
29    [Storable]
30    private DoubleArray normalizedQualityAverages;
31    public DoubleArray NormalizedQualityAverages {
32      get { return normalizedQualityAverages; }
33      set {
34        if (normalizedQualityAverages != value) {
35          normalizedQualityAverages = value;
36        }
37      }
38    }
39
40    [Storable]
41    private DoubleArray normalizedQualityDeviations;
42    public DoubleArray NormalizedQualityDeviations {
43      get { return normalizedQualityDeviations; }
44      set {
45        if (normalizedQualityDeviations != value) {
46          normalizedQualityDeviations = value;
47        }
48      }
49    }
50
51    [Storable]
52    private DoubleArray normalizedEvaluatedSolutions;
53    public DoubleArray NormalizedEvaluatedSolutions {
54      get { return normalizedEvaluatedSolutions; }
55      set {
56        if (normalizedEvaluatedSolutions != value) {
57          normalizedEvaluatedSolutions = value;
58        }
59      }
60    }
61   
62    [Storable]
63    private DoubleArray bestQualities;
64    public DoubleArray BestQualities {
65      get { return bestQualities; }
66      set {
67        if (bestQualities != value) {
68          bestQualities = value;
69        }
70      }
71    }
72
73    [Storable]
74    private DoubleArray averageQualities;
75    public DoubleArray AverageQualities {
76      get { return averageQualities; }
77      set { averageQualities = value; }
78    }
79
80    [Storable]
81    private DoubleArray worstQualities;
82    public DoubleArray WorstQualities {
83      get { return worstQualities; }
84      set { worstQualities = value; }
85    }
86
87    [Storable]
88    private DoubleArray qualityVariances;
89    public DoubleArray QualityVariances {
90      get { return qualityVariances; }
91      set { qualityVariances = value; }
92    }
93
94    [Storable]
95    private DoubleArray qualityStandardDeviations;
96    public DoubleArray QualityStandardDeviations {
97      get { return qualityStandardDeviations; }
98      set { qualityStandardDeviations = value; }
99    }
100
101    [Storable]
102    private ItemList<TimeSpanValue> averageExecutionTimes;
103    public ItemList<TimeSpanValue> AverageExecutionTimes {
104      get { return averageExecutionTimes; }
105      set { averageExecutionTimes = value; }
106    }
107
108    [Storable]
109    private DoubleArray averageEvaluatedSolutions;
110    public DoubleArray AverageEvaluatedSolutions {
111      get { return averageEvaluatedSolutions; }
112      set { averageEvaluatedSolutions = value; }
113    }
114
115    [Storable]
116    private IntValue repetitions;
117    public IntValue Repetitions {
118      get { return repetitions; }
119      set { repetitions = value; }
120    }
121
122    [Storable]
123    protected RunCollection runs;
124    public RunCollection Runs {
125      get { return runs; }
126      set { runs = value; }
127    }
128
129    [Storable]
130    protected IDictionary<string, IItem> parameters;
131    public IDictionary<string, IItem> Parameters {
132      get { return parameters; }
133      set { parameters = value; }
134    }
135
136    public ParameterizedValueConfiguration AlgorithmConfiguration {
137      get {
138        return this.ParameterConfigurations.ElementAt(0).ValueConfigurations.First() as ParameterizedValueConfiguration;
139      }
140    }
141
142    public ParameterizedValueConfiguration ProblemConfiguration {
143      get {
144        return this.ParameterConfigurations.ElementAt(1).ValueConfigurations.First() as ParameterizedValueConfiguration;
145      }
146    }
147
148    #region constructors and cloning
149    public ParameterConfigurationTree(IAlgorithm algorithm, IProblem problem)
150      : base(null, algorithm.GetType(), false) {
151      this.Optimize = false;
152      this.IsOptimizable = false;
153      this.parameters = new Dictionary<string, IItem>();
154      this.Name = algorithm.ItemName;
155
156      var algproblemitem = new AlgorithmProblemItem();
157      algproblemitem.AlgorithmParameter.Value = algorithm;
158      algproblemitem.ProblemParameter.Value = problem;
159      this.discoverValidValues = false;
160
161      this.parameterConfigurations.Add(new SingleValuedParameterConfiguration("Algorithm", algproblemitem.AlgorithmParameter));
162      this.parameterConfigurations.Add(new SingleValuedParameterConfiguration("Problem", algproblemitem.ProblemParameter));
163    }
164    public ParameterConfigurationTree() { }
165    [StorableConstructor]
166    protected ParameterConfigurationTree(bool deserializing) : base(deserializing) { }
167    protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner)
168      : base(original, cloner) {
169      this.quality = cloner.Clone(original.quality);
170      this.normalizedQualityAverages = cloner.Clone(original.normalizedQualityAverages);
171      this.normalizedQualityDeviations = cloner.Clone(original.normalizedQualityDeviations);
172      this.normalizedEvaluatedSolutions = cloner.Clone(original.normalizedEvaluatedSolutions);
173      this.bestQualities = cloner.Clone(original.BestQualities);
174      this.averageQualities = cloner.Clone(original.averageQualities);
175      this.worstQualities = cloner.Clone(original.worstQualities);
176      this.qualityStandardDeviations = cloner.Clone(original.qualityStandardDeviations);
177      this.qualityVariances = cloner.Clone(original.qualityVariances);
178      this.averageExecutionTimes = cloner.Clone(original.averageExecutionTimes);
179      this.averageEvaluatedSolutions = cloner.Clone(original.averageEvaluatedSolutions);
180      this.repetitions = cloner.Clone(original.repetitions);
181      this.runs = cloner.Clone(original.runs);
182      this.parameters = new Dictionary<string, IItem>();
183      foreach (var p in original.parameters) {
184        this.parameters.Add(p.Key, cloner.Clone(p.Value));
185      }
186      //this.name = original.name;
187    }
188    public override IDeepCloneable Clone(Cloner cloner) {
189      return new ParameterConfigurationTree(this, cloner);
190    }
191    [StorableHook(HookType.AfterDeserialization)]
192    private void AfterDeserialization() {
193    }
194    #endregion
195
196    public virtual void CollectResultValues(IDictionary<string, IItem> values) {
197      values.Add("RunsAverageExecutionTimes", AverageExecutionTimes);
198      values.Add("RunsAverageEvaluatedSolutions", AverageEvaluatedSolutions);
199      values.Add("Repetitions", Repetitions);
200      values.Add("RunsBestQualities", BestQualities);
201      values.Add("RunsAverageQualities", AverageQualities);
202      values.Add("RunsWorstQualities", WorstQualities);
203      values.Add("RunsQualityVariances", QualityVariances);
204      values.Add("RunsQualityStandardDeviations", QualityStandardDeviations);
205      values.Add("QualitiesNormalized", NormalizedQualityAverages);
206      values.Add("AverageQualityNormalized", Quality);
207      values.Add("Runs", Runs);
208    }
209
210    public virtual void CollectParameterValues(IDictionary<string, IItem> values) {
211      foreach (var p in parameters) {
212        values.Add(p);
213      }
214    }
215
216    #region Events
217    public event EventHandler QualityChanged;
218    private void OnQualityChanged() {
219      var handler = QualityChanged;
220      if (handler != null) handler(this, EventArgs.Empty);
221    }
222
223    private void Quality_ValueChanged(object sender, EventArgs e) {
224      OnQualityChanged();
225    }
226    #endregion
227
228    public override void Parameterize(IParameterizedItem item) {
229      this.parameters.Clear();
230      var algorithm = item as IAlgorithm;
231      var problem = algorithm.Problem;
232
233      AlgorithmConfiguration.Parameterize(algorithm);
234      ProblemConfiguration.Parameterize(problem);
235
236      algorithm.CollectParameterValues(this.Parameters);
237    }
238
239    public Experiment GenerateExperiment(IAlgorithm algorithm, bool createBatchRuns, int repetitions) {
240      Experiment experiment = new Experiment();
241      foreach (ParameterizedValueConfiguration combination in this) {
242        IAlgorithm clonedAlg = (IAlgorithm)algorithm.Clone();
243        clonedAlg.Name = combination.ParameterInfoString;
244        combination.Parameterize(clonedAlg);
245        clonedAlg.StoreAlgorithmInEachRun = false;
246        if (createBatchRuns) {
247          BatchRun batchRun = new BatchRun(string.Format("BatchRun: {0}", combination.ParameterInfoString));
248          batchRun.Optimizer = clonedAlg;
249          batchRun.Repetitions = repetitions;
250          experiment.Optimizers.Add(batchRun);
251        } else {
252          experiment.Optimizers.Add(clonedAlg);
253        }
254      }
255      return experiment;
256    }
257
258    public Experiment GenerateExperiment(IAlgorithm algorithm) {
259      return GenerateExperiment(algorithm, false, 0);
260    }
261
262    public IEnumerator GetEnumerator() {
263      IEnumerator enumerator = new ParameterCombinationsEnumerator(this);
264      enumerator.Reset();
265      return enumerator;
266    }
267
268    /// <summary>
269    /// returns the number of possible parameter combinations
270    /// </summary>
271    /// <param name="max">algorithm stops counting when max is reached. zero for infinite counting</param>
272    /// <returns></returns>
273    public long GetCombinationCount(long max) {
274      long cnt = 0;
275      foreach (var c in this) {
276        cnt++;
277        if (max > 0 && cnt >= max) {
278          return cnt;
279        }
280      }
281      return cnt;
282    }
283
284    public IOptimizable GetRandomOptimizable(IRandom random) {
285      List<IOptimizable> allOptimizables = GetAllOptimizables();
286      return allOptimizables[random.Next(allOptimizables.Count)];
287    }
288
289    public override string ToString() {
290      return this.Name;
291    }
292
293    public IRun ToRun() {
294      return ToRun(this.ParameterInfoString);
295    }
296
297    public IRun ToRun(string name) {
298      IRun run = new Run();
299      run.Name = name;
300      this.CollectResultValues(run.Results);
301      this.CollectParameterValues(run.Parameters);
302      MetaOptimizationUtil.ClearParameters(run, this.GetOptimizedParameterNames());
303      return run;
304    }
305
306    public override string ParameterInfoString {
307      get {
308        string algorithmInfo = this.AlgorithmConfiguration.ParameterInfoString;
309        string problemInfo = this.ProblemConfiguration.ParameterInfoString;
310        var sb = new StringBuilder();
311        if (!string.IsNullOrEmpty(algorithmInfo)) {
312          sb.Append("Algorithm (");
313          sb.Append(algorithmInfo);
314          sb.Append(")");
315        }
316        if (!string.IsNullOrEmpty(problemInfo)) {
317          if (sb.Length > 0)
318            sb.Append(", ");
319          sb.Append("Problem( ");
320          sb.Append(problemInfo);
321          sb.Append(")");
322        }
323        return sb.ToString();
324      }
325    }
326
327    public override void CollectOptimizedParameterNames(List<string> parameterNames, string prefix) {
328      AlgorithmConfiguration.CollectOptimizedParameterNames(parameterNames, string.Empty);
329      ProblemConfiguration.CollectOptimizedParameterNames(parameterNames, string.Empty);
330    }
331  }
332}
Note: See TracBrowser for help on using the repository browser.