Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithm.cs @ 13820

Last change on this file since 13820 was 13402, checked in by pfleck, 9 years ago

#2527 Implemented ALPS-OSGA on the base of the AlpsGeneticAlgorithm and and the OffspringSelectionGeneticAlgorithmMainOperator.
File size: 40.1 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2015 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.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Analysis;
26using HeuristicLab.Collections;
27using HeuristicLab.Common;
28using HeuristicLab.Core;
29using HeuristicLab.Data;
30using HeuristicLab.Operators;
31using HeuristicLab.Optimization;
32using HeuristicLab.Optimization.Operators;
33using HeuristicLab.Parameters;
34using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
35using HeuristicLab.PluginInfrastructure;
36using HeuristicLab.Random;
37using HeuristicLab.Selection;
38
39namespace HeuristicLab.Algorithms.ALPS {
40  [Item("ALPS OffspringSelection Genetic Algorithm", "An offspring selection genetic algorithm within an age-layered population structure.")]
41  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 162)]
42  [StorableClass]
43  public sealed class AlpsOffspringSelectionGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
44    public string Filename { get; set; }
45
46    #region Problem Properties
47    public override Type ProblemType {
48      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
49    }
50    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
51      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
52      set { base.Problem = value; }
53    }
54    #endregion
55
56    #region Parameter Properties
57    private IFixedValueParameter<IntValue> SeedParameter {
58      get { return (IFixedValueParameter<IntValue>)Parameters["Seed"]; }
59    }
60    private IFixedValueParameter<BoolValue> SetSeedRandomlyParameter {
61      get { return (IFixedValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
62    }
63
64    private IFixedValueParameter<MultiAnalyzer> AnalyzerParameter {
65      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
66    }
67    private IFixedValueParameter<MultiAnalyzer> LayerAnalyzerParameter {
68      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["LayerAnalyzer"]; }
69    }
70
71    private IFixedValueParameter<IntValue> NumberOfLayersParameter {
72      get { return (IFixedValueParameter<IntValue>)Parameters["NumberOfLayers"]; }
73    }
74    private IFixedValueParameter<IntValue> PopulationSizeParameter {
75      get { return (IFixedValueParameter<IntValue>)Parameters["PopulationSize"]; }
76    }
77
78    public IConstrainedValueParameter<ISelector> SelectorParameter {
79      get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
80    }
81    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
82      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
83    }
84    public IConstrainedValueParameter<IManipulator> MutatorParameter {
85      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
86    }
87    private IFixedValueParameter<PercentValue> MutationProbabilityParameter {
88      get { return (IFixedValueParameter<PercentValue>)Parameters["MutationProbability"]; }
89    }
90    private IFixedValueParameter<IntValue> ElitesParameter {
91      get { return (IFixedValueParameter<IntValue>)Parameters["Elites"]; }
92    }
93    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
94      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
95    }
96
97    private IFixedValueParameter<DoubleValue> SuccessRatioParameter {
98      get { return (IFixedValueParameter<DoubleValue>)Parameters["SuccessRatio"]; }
99    }
100    private IFixedValueParameter<DoubleValue> ComparisonFactorParameter {
101      get { return (IFixedValueParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
102    }
103    private IFixedValueParameter<DoubleValue> MaximumSelectionPressureParameter {
104      get { return (IFixedValueParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
105    }
106    private IFixedValueParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
107      get { return (IFixedValueParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
108    }
109    private IFixedValueParameter<IntValue> SelectedParentsParameter {
110      get { return (IFixedValueParameter<IntValue>)Parameters["SelectedParents"]; }
111    }
112    private IFixedValueParameter<BoolValue> FillPopulationWithParentsParameter {
113      get { return (IFixedValueParameter<BoolValue>)Parameters["FillPopulationWithParents"]; }
114    }
115
116    private IFixedValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter {
117      get { return (IFixedValueParameter<EnumValue<AgingScheme>>)Parameters["AgingScheme"]; }
118    }
119    private IFixedValueParameter<IntValue> AgeGapParameter {
120      get { return (IFixedValueParameter<IntValue>)Parameters["AgeGap"]; }
121    }
122    private IFixedValueParameter<DoubleValue> AgeInheritanceParameter {
123      get { return (IFixedValueParameter<DoubleValue>)Parameters["AgeInheritance"]; }
124    }
125    private IFixedValueParameter<IntArray> AgeLimitsParameter {
126      get { return (IFixedValueParameter<IntArray>)Parameters["AgeLimits"]; }
127    }
128
129    private IFixedValueParameter<IntValue> MatingPoolRangeParameter {
130      get { return (IFixedValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
131    }
132    private IFixedValueParameter<BoolValue> ReduceToPopulationSizeParameter {
133      get { return (IFixedValueParameter<BoolValue>)Parameters["ReduceToPopulationSize"]; }
134    }
135
136    private IFixedValueParameter<MultiTerminator> TerminatorParameter {
137      get { return (IFixedValueParameter<MultiTerminator>)Parameters["Terminator"]; }
138    }
139    #endregion
140
141    #region Properties
142    public int Seed {
143      get { return SeedParameter.Value.Value; }
144      set { SeedParameter.Value.Value = value; }
145    }
146    public bool SetSeedRandomly {
147      get { return SetSeedRandomlyParameter.Value.Value; }
148      set { SetSeedRandomlyParameter.Value.Value = value; }
149    }
150
151    public MultiAnalyzer Analyzer {
152      get { return AnalyzerParameter.Value; }
153    }
154    public MultiAnalyzer LayerAnalyzer {
155      get { return LayerAnalyzerParameter.Value; }
156    }
157
158    public int NumberOfLayers {
159      get { return NumberOfLayersParameter.Value.Value; }
160      set { NumberOfLayersParameter.Value.Value = value; }
161    }
162    public int PopulationSize {
163      get { return PopulationSizeParameter.Value.Value; }
164      set { PopulationSizeParameter.Value.Value = value; }
165    }
166
167    public ISelector Selector {
168      get { return SelectorParameter.Value; }
169      set { SelectorParameter.Value = value; }
170    }
171    public ICrossover Crossover {
172      get { return CrossoverParameter.Value; }
173      set { CrossoverParameter.Value = value; }
174    }
175    public IManipulator Mutator {
176      get { return MutatorParameter.Value; }
177      set { MutatorParameter.Value = value; }
178    }
179    public double MutationProbability {
180      get { return MutationProbabilityParameter.Value.Value; }
181      set { MutationProbabilityParameter.Value.Value = value; }
182    }
183    public int Elites {
184      get { return ElitesParameter.Value.Value; }
185      set { ElitesParameter.Value.Value = value; }
186    }
187    public bool ReevaluteElites {
188      get { return ReevaluateElitesParameter.Value.Value; }
189      set { ReevaluateElitesParameter.Value.Value = value; }
190    }
191
192    public double SuccessRatio {
193      get { return SuccessRatioParameter.Value.Value; }
194      set { SuccessRatioParameter.Value.Value = value; }
195    }
196    public double ComparisonFactor {
197      get { return ComparisonFactorParameter.Value.Value; }
198      set { ComparisonFactorParameter.Value.Value = value; }
199    }
200    public double MaximumSelectionPressure {
201      get { return MaximumSelectionPressureParameter.Value.Value; }
202      set { MaximumSelectionPressureParameter.Value.Value = value; }
203    }
204    public bool OffspringSelectionBeforeMutation {
205      get { return OffspringSelectionBeforeMutationParameter.Value.Value; }
206      set { OffspringSelectionBeforeMutationParameter.Value.Value = value; }
207    }
208    public int SelectedParents {
209      get { return SelectedParentsParameter.Value.Value; }
210      set { SelectedParentsParameter.Value.Value = value; }
211    }
212    public bool FillPopulationWithParents {
213      get { return FillPopulationWithParentsParameter.Value.Value; }
214      set { FillPopulationWithParentsParameter.Value.Value = value; }
215    }
216
217    public AgingScheme AgingScheme {
218      get { return AgingSchemeParameter.Value.Value; }
219      set { AgingSchemeParameter.Value.Value = value; }
220    }
221    public int AgeGap {
222      get { return AgeGapParameter.Value.Value; }
223      set { AgeGapParameter.Value.Value = value; }
224    }
225    public double AgeInheritance {
226      get { return AgeInheritanceParameter.Value.Value; }
227      set { AgeInheritanceParameter.Value.Value = value; }
228    }
229    public IntArray AgeLimits {
230      get { return AgeLimitsParameter.Value; }
231      set {
232        AgeLimits.Length = value.Length;
233        for (int i = 0; i < value.Length; i++)
234          AgeLimits[i] = value[i];
235      }
236    }
237
238    public int MatingPoolRange {
239      get { return MatingPoolRangeParameter.Value.Value; }
240      set { MatingPoolRangeParameter.Value.Value = value; }
241    }
242
243    public MultiTerminator Terminators {
244      get { return TerminatorParameter.Value; }
245    }
246
247    public int MaximumGenerations {
248      get { return generationsTerminator.Threshold.Value; }
249      set { generationsTerminator.Threshold.Value = value; }
250    }
251    #endregion
252
253    #region Helper Properties
254    private SolutionsCreator SolutionsCreator {
255      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
256    }
257    private AlpsOffspringSelectionGeneticAlgorithmMainLoop MainLoop {
258      get { return OperatorGraph.Iterate().OfType<AlpsOffspringSelectionGeneticAlgorithmMainLoop>().First(); }
259    }
260    #endregion
261
262    #region Preconfigured Analyzers
263    [Storable]
264    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
265    [Storable]
266    private BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
267    [Storable]
268    private OldestAverageYoungestAgeAnalyzer ageAnalyzer;
269    [Storable]
270    private OldestAverageYoungestAgeAnalyzer layerAgeAnalyzer;
271    [Storable]
272    private AgeDistributionAnalyzer ageDistributionAnalyzer;
273    [Storable]
274    private AgeDistributionAnalyzer layerAgeDistributionAnalyzer;
275    [Storable]
276    private ValueAnalyzer selectionPressureAnalyzer;
277    [Storable]
278    private ValueAnalyzer layerSelectionPressureAnalyzer;
279    [Storable]
280    private ValueAnalyzer currentSuccessRatioAnalyzer;
281    #endregion
282
283    #region Preconfigured Terminators
284    [Storable]
285    private ComparisonTerminator<IntValue> generationsTerminator;
286    //[Storable]
287    //private ComparisonTerminator<DoubleValue> selectionPressureTerminator;
288    [Storable]
289    private ComparisonTerminator<IntValue> evaluationsTerminator;
290    [Storable]
291    private SingleObjectiveQualityTerminator qualityTerminator;
292    [Storable]
293    private ExecutionTimeTerminator executionTimeTerminator;
294    #endregion
295
296    #region Constructors
297    [StorableConstructor]
298    private AlpsOffspringSelectionGeneticAlgorithm(bool deserializing)
299      : base(deserializing) { }
300    [StorableHook(HookType.AfterDeserialization)]
301    private void AfterDeserialization() {
302      Initialize();
303    }
304    private AlpsOffspringSelectionGeneticAlgorithm(AlpsOffspringSelectionGeneticAlgorithm original, Cloner cloner)
305      : base(original, cloner) {
306      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
307      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
308      ageAnalyzer = cloner.Clone(original.ageAnalyzer);
309      layerAgeAnalyzer = cloner.Clone(original.layerAgeAnalyzer);
310      ageDistributionAnalyzer = cloner.Clone(original.ageDistributionAnalyzer);
311      layerAgeDistributionAnalyzer = cloner.Clone(original.layerAgeDistributionAnalyzer);
312      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
313      layerSelectionPressureAnalyzer = cloner.Clone(original.layerSelectionPressureAnalyzer);
314      currentSuccessRatioAnalyzer = cloner.Clone(original.currentSuccessRatioAnalyzer);
315      generationsTerminator = cloner.Clone(original.generationsTerminator);
316      //selectionPressureTerminator = cloner.Clone(original.selectionPressureTerminator);
317      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
318      qualityTerminator = cloner.Clone(original.qualityTerminator);
319      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
320      Initialize();
321    }
322    public override IDeepCloneable Clone(Cloner cloner) {
323      return new AlpsOffspringSelectionGeneticAlgorithm(this, cloner);
324    }
325    public AlpsOffspringSelectionGeneticAlgorithm()
326      : base() {
327      #region Add parameters
328      Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
329      Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
330
331      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze all individuals from all layers combined.", new MultiAnalyzer()));
332      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
333
334      Parameters.Add(new FixedValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
335      Parameters.Add(new FixedValueParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer.", new IntValue(100)));
336
337      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
338      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
339      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
340      Parameters.Add(new FixedValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
341      Parameters.Add(new FixedValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
342      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
343
344      Parameters.Add(new FixedValueParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
345      Parameters.Add(new FixedValueParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1].", new DoubleValue(1)));
346      Parameters.Add(new FixedValueParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
347      Parameters.Add(new FixedValueParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
348      Parameters.Add(new FixedValueParameter<IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems.", new IntValue(200)));
349      Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false)) { Hidden = true });
350
351      Parameters.Add(new FixedValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
352      Parameters.Add(new FixedValueParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(20)));
353      Parameters.Add(new FixedValueParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(1.0)) { Hidden = true });
354      Parameters.Add(new FixedValueParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0])) { Hidden = true });
355
356      Parameters.Add(new FixedValueParameter<IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1)) { Hidden = true });
357      Parameters.Add(new FixedValueParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true)) { Hidden = true });
358
359      Parameters.Add(new FixedValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
360      #endregion
361
362      #region Create operators
363      var globalRandomCreator = new RandomCreator();
364      var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
365      var layer0Processor = new SubScopesProcessor();
366      var localRandomCreator = new LocalRandomCreator();
367      var layerSolutionsCreator = new SolutionsCreator();
368      var initializeAgeProcessor = new UniformSubScopesProcessor();
369      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
370      var initializeCurrentPopulationSize = new SubScopesCounter() { Name = "Initialize CurrentPopulationCounter" };
371      var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
372      var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
373      var resultsCollector = new ResultsCollector();
374      var mainLoop = new AlpsOffspringSelectionGeneticAlgorithmMainLoop();
375      #endregion
376
377      #region Create and parameterize operator graph
378      OperatorGraph.InitialOperator = globalRandomCreator;
379
380      globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
381      globalRandomCreator.SeedParameter.Value = null;
382      globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
383      globalRandomCreator.SetSeedRandomlyParameter.Value = null;
384      globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
385      globalRandomCreator.Successor = layer0Creator;
386
387      layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
388      layer0Creator.Successor = layer0Processor;
389
390      layer0Processor.Operators.Add(localRandomCreator);
391      layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
392
393      localRandomCreator.Successor = layerSolutionsCreator;
394
395      layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
396      layerSolutionsCreator.Successor = initializeAgeProcessor;
397
398      initializeAgeProcessor.Operator = initializeAge;
399      initializeAgeProcessor.Successor = initializeCurrentPopulationSize;
400
401      initializeCurrentPopulationSize.ValueParameter.ActualName = "CurrentPopulationSize";
402      initializeCurrentPopulationSize.Successor = initializeLocalEvaluatedSolutions;
403
404      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
405      initializeAge.Successor = null;
406
407      initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
408      initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "CurrentPopulationSize";
409      initializeLocalEvaluatedSolutions.Successor = null;
410
411      initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
412      initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
413      initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
414      initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
415      initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
416
417      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
418      resultsCollector.Successor = mainLoop;
419
420      mainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
421      mainLoop.LocalRandomParameter.ActualName = localRandomCreator.LocalRandomParameter.Name;
422      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
423      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
424      mainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
425      mainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
426      mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
427      mainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
428      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
429      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
430      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
431      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
432      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
433      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
434      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
435      mainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
436      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
437      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
438      mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
439      mainLoop.AgeParameter.ActualName = "Age";
440      mainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
441      mainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
442      mainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
443      mainLoop.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
444      mainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
445      mainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
446      #endregion
447
448      #region Set operators
449      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
450        SelectorParameter.ValidValues.Add(selector);
451      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
452      if (defaultSelector != null) {
453        defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
454        SelectorParameter.Value = defaultSelector;
455      }
456      #endregion
457
458      #region Create analyzers
459      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
460      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
461      ageAnalyzer = new OldestAverageYoungestAgeAnalyzer();
462      layerAgeAnalyzer = new OldestAverageYoungestAgeAnalyzer();
463      ageDistributionAnalyzer = new AgeDistributionAnalyzer();
464      layerAgeDistributionAnalyzer = new AgeDistributionAnalyzer();
465      selectionPressureAnalyzer = new ValueAnalyzer();
466      layerSelectionPressureAnalyzer = new ValueAnalyzer();
467      currentSuccessRatioAnalyzer = new ValueAnalyzer();
468      #endregion
469
470      #region Create terminators
471      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
472      //selectionPressureTerminator = new ComparisonTerminator<DoubleValue>("SelectionPressure", ComparisonType.Less, MaximumSelectionPressureParameter);
473      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
474      qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
475      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
476      #endregion
477
478      #region Parameterize
479      UpdateAnalyzers();
480      ParameterizeAnalyzers();
481
482      ParameterizeSelectors();
483
484      UpdateTerminators();
485
486      ParameterizeAgeLimits();
487      #endregion
488
489      Initialize();
490    }
491    #endregion
492
493    #region Events
494    public override void Prepare() {
495      if (Problem != null)
496        base.Prepare();
497    }
498    protected override void OnProblemChanged() {
499      base.OnProblemChanged();
500      ParameterizeStochasticOperator(Problem.SolutionCreator);
501      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
502      foreach (var @operator in Problem.Operators.OfType<IOperator>())
503        ParameterizeStochasticOperator(@operator);
504
505      ParameterizeIterationBasedOperators();
506
507      ParameterizeSolutionsCreator();
508      ParameterizeMainLoop();
509      ParameterizeAnalyzers();
510      ParameterizeSelectors();
511      ParameterizeTerminators();
512
513      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
514
515      UpdateAnalyzers();
516      UpdateCrossovers();
517      UpdateMutators();
518      UpdateTerminators();
519    }
520
521    protected override void RegisterProblemEvents() {
522      base.RegisterProblemEvents();
523      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
524      if (maximizationParameter != null) maximizationParameter.ValueChanged += new EventHandler(MaximizationParameter_ValueChanged);
525    }
526    protected override void DeregisterProblemEvents() {
527      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
528      if (maximizationParameter != null) maximizationParameter.ValueChanged -= new EventHandler(MaximizationParameter_ValueChanged);
529      base.DeregisterProblemEvents();
530    }
531
532    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
533      base.Problem_SolutionCreatorChanged(sender, e);
534      ParameterizeStochasticOperator(Problem.SolutionCreator);
535      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
536
537      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
538
539      ParameterizeSolutionsCreator();
540      ParameterizeAnalyzers();
541    }
542    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
543      base.Problem_EvaluatorChanged(sender, e);
544      foreach (var @operator in Problem.Operators.OfType<IOperator>())
545        ParameterizeStochasticOperator(@operator);
546
547      UpdateAnalyzers();
548
549      ParameterizeSolutionsCreator();
550      ParameterizeMainLoop();
551      ParameterizeSelectors();
552    }
553    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
554      base.Problem_OperatorsChanged(sender, e);
555      ParameterizeIterationBasedOperators();
556      UpdateCrossovers();
557      UpdateMutators();
558      UpdateTerminators();
559    }
560    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
561      ParameterizeMainLoop();
562      ParameterizeAnalyzers();
563      ParameterizeSelectors();
564    }
565    private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
566      ParameterizeTerminators();
567    }
568    private void QualityAnalyzer_CurrentBestQualityParameter_NameChanged(object sender, EventArgs e) {
569      ParameterizeTerminators();
570    }
571
572    private void AgeGap_ValueChanged(object sender, EventArgs e) {
573      ParameterizeAgeLimits();
574    }
575    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
576      ParameterizeAgeLimits();
577    }
578    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
579      ParameterizeAgeLimits();
580    }
581
582    private void AnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
583      foreach (var analyzer in e.Items) {
584        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
585          parameter.Depth = 2;
586        }
587      }
588    }
589    private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
590      foreach (var analyzer in e.Items) {
591        IParameter resultParameter;
592        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
593          var lookupParameter = resultParameter as ILookupParameter;
594          if (lookupParameter != null)
595            lookupParameter.ActualName = "LayerResults";
596        }
597        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
598          parameter.Depth = 1;
599        }
600      }
601    }
602    #endregion
603
604    #region Parameterization
605    private void Initialize() {
606      if (Problem != null)
607        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
608
609      NumberOfLayersParameter.Value.ValueChanged += NumberOfLayers_ValueChanged;
610
611      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
612      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
613
614      AgeGapParameter.Value.ValueChanged += AgeGap_ValueChanged;
615      AgingSchemeParameter.Value.ValueChanged += AgingScheme_ValueChanged;
616
617      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += QualityAnalyzer_CurrentBestQualityParameter_NameChanged;
618    }
619    private void ParameterizeSolutionsCreator() {
620      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
621      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
622    }
623    private void ParameterizeMainLoop() {
624      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
625      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
626      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
627    }
628    private void ParameterizeAnalyzers() {
629      qualityAnalyzer.ResultsParameter.ActualName = "Results";
630      qualityAnalyzer.ResultsParameter.Hidden = true;
631      qualityAnalyzer.QualityParameter.Depth = 2;
632      layerQualityAnalyzer.ResultsParameter.ActualName = "LayerResults";
633      layerQualityAnalyzer.ResultsParameter.Hidden = true;
634      layerQualityAnalyzer.QualityParameter.Depth = 1;
635      selectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
636      selectionPressureAnalyzer.ResultsParameter.ActualName = "Results";
637      selectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
638      selectionPressureAnalyzer.ValueParameter.Depth = 1;
639      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
640      layerSelectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
641      layerSelectionPressureAnalyzer.ResultsParameter.ActualName = "LayerResults";
642      layerSelectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
643      layerSelectionPressureAnalyzer.ValueParameter.Depth = 0;
644      layerSelectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
645      currentSuccessRatioAnalyzer.Name = "CurrentSuccessRatio Analyzer";
646      currentSuccessRatioAnalyzer.ResultsParameter.ActualName = "Results";
647      currentSuccessRatioAnalyzer.ValueParameter.ActualName = "CurrentSuccessRatio";
648      currentSuccessRatioAnalyzer.ValueParameter.Depth = 1;
649      currentSuccessRatioAnalyzer.ValuesParameter.ActualName = "Success Ratio History";
650      if (Problem != null) {
651        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
652        qualityAnalyzer.MaximizationParameter.Hidden = true;
653        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
654        qualityAnalyzer.QualityParameter.Hidden = true;
655        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
656        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
657        layerQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
658        layerQualityAnalyzer.MaximizationParameter.Hidden = true;
659        layerQualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
660        layerQualityAnalyzer.QualityParameter.Hidden = true;
661        layerQualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
662        layerQualityAnalyzer.BestKnownQualityParameter.Hidden = true;
663      }
664    }
665    private void ParameterizeSelectors() {
666      foreach (var selector in SelectorParameter.ValidValues) {
667        selector.CopySelected = new BoolValue(true);
668        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
669        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
670        ParameterizeStochasticOperatorForLayer(selector);
671      }
672      if (Problem != null) {
673        foreach (var selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
674          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
675          selector.MaximizationParameter.Hidden = true;
676          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
677          selector.QualityParameter.Hidden = true;
678        }
679      }
680    }
681    private void ParameterizeTerminators() {
682      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
683    }
684    private void ParameterizeIterationBasedOperators() {
685      if (Problem != null) {
686        foreach (var @operator in Problem.Operators.OfType<IIterationBasedOperator>()) {
687          @operator.IterationsParameter.ActualName = "Generations";
688          @operator.IterationsParameter.Hidden = true;
689          @operator.MaximumIterationsParameter.ActualName = generationsTerminator.ThresholdParameter.Name;
690          @operator.MaximumIterationsParameter.Hidden = true;
691        }
692      }
693    }
694    private void ParameterizeAgeLimits() {
695      AgeLimits = AgingScheme.CalculateAgeLimits(AgeGap, NumberOfLayers);
696    }
697
698    private void ParameterizeStochasticOperator(IOperator @operator) {
699      var stochasticOperator = @operator as IStochasticOperator;
700      if (stochasticOperator != null) {
701        stochasticOperator.RandomParameter.ActualName = "GlobalRandom";
702        stochasticOperator.RandomParameter.Hidden = true;
703      }
704    }
705
706    private void ParameterizeStochasticOperatorForLayer(IOperator @operator) {
707      var stochasticOperator = @operator as IStochasticOperator;
708      if (stochasticOperator != null) {
709        stochasticOperator.RandomParameter.ActualName = "LocalRandom";
710        stochasticOperator.RandomParameter.Hidden = true;
711      }
712    }
713
714    #endregion
715
716    #region Updates
717    private void UpdateAnalyzers() {
718      Analyzer.Operators.Clear();
719      LayerAnalyzer.Operators.Clear();
720
721      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
722      Analyzer.Operators.Add(ageAnalyzer, ageAnalyzer.EnabledByDefault);
723      Analyzer.Operators.Add(ageDistributionAnalyzer, ageDistributionAnalyzer.EnabledByDefault);
724      Analyzer.Operators.Add(selectionPressureAnalyzer, false); // find way to make history "pretty"
725      selectionPressureAnalyzer.ValueParameter.Depth = 1; // Adding analyzer sets depth to 2
726      Analyzer.Operators.Add(currentSuccessRatioAnalyzer, false);
727      currentSuccessRatioAnalyzer.ValueParameter.Depth = 1; // Adding analyzer sets depth to 2
728      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
729      LayerAnalyzer.Operators.Add(layerAgeAnalyzer, false);
730      LayerAnalyzer.Operators.Add(layerAgeDistributionAnalyzer, false);
731      LayerAnalyzer.Operators.Add(layerSelectionPressureAnalyzer, false);
732      layerSelectionPressureAnalyzer.ValueParameter.Depth = 0; // Adding layer-analyzer sets depth to 1
733
734
735      if (Problem != null) {
736        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
737          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
738          LayerAnalyzer.Operators.Add((IAnalyzer)analyzer.Clone(), false);
739        }
740      }
741    }
742    private void UpdateCrossovers() {
743      var oldCrossover = CrossoverParameter.Value;
744      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
745      CrossoverParameter.ValidValues.Clear();
746      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(c => c.Name)) {
747        ParameterizeStochasticOperatorForLayer(crossover);
748        CrossoverParameter.ValidValues.Add(crossover);
749      }
750      if (oldCrossover != null) {
751        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(c => c.GetType() == oldCrossover.GetType());
752        if (crossover != null)
753          CrossoverParameter.Value = crossover;
754        else
755          oldCrossover = null;
756      }
757      if (oldCrossover == null && defaultCrossover != null)
758        CrossoverParameter.Value = defaultCrossover;
759    }
760    private void UpdateMutators() {
761      var oldMutator = MutatorParameter.Value;
762      MutatorParameter.ValidValues.Clear();
763      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(m => m.Name)) {
764        ParameterizeStochasticOperatorForLayer(mutator);
765        MutatorParameter.ValidValues.Add(mutator);
766      }
767      if (oldMutator != null) {
768        var mutator = MutatorParameter.ValidValues.FirstOrDefault(m => m.GetType() == oldMutator.GetType());
769        if (mutator != null)
770          MutatorParameter.Value = mutator;
771      }
772    }
773    private void UpdateTerminators() {
774      var newTerminators = new Dictionary<ITerminator, bool> {
775        {generationsTerminator, !Terminators.Operators.Contains(generationsTerminator) || Terminators.Operators.ItemChecked(generationsTerminator)},
776        //{selectionPressureTerminator, !Terminators.Operators.Contains(selectionPressureTerminator) || Terminators.Operators.ItemChecked(selectionPressureTerminator)},
777        {evaluationsTerminator, Terminators.Operators.Contains(evaluationsTerminator) && Terminators.Operators.ItemChecked(evaluationsTerminator)},
778        {qualityTerminator, Terminators.Operators.Contains(qualityTerminator) && Terminators.Operators.ItemChecked(qualityTerminator) },
779        {executionTimeTerminator, Terminators.Operators.Contains(executionTimeTerminator) && Terminators.Operators.ItemChecked(executionTimeTerminator)}
780      };
781      if (Problem != null) {
782        foreach (var terminator in Problem.Operators.OfType<ITerminator>())
783          newTerminators.Add(terminator, !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
784      }
785
786      Terminators.Operators.Clear();
787
788      foreach (var newTerminator in newTerminators)
789        Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
790    }
791    #endregion
792  }
793}
Note: See TracBrowser for help on using the repository browser.