Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2989_MovingPeaksBenchmark/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithm.cs @ 17717

Last change on this file since 17717 was 15583, checked in by swagner, 7 years ago

#2640: Updated year of copyrights in license headers
File size: 40.7 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2018 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<IntValue> evaluationsTerminator;
288    [Storable]
289    private SingleObjectiveQualityTerminator qualityTerminator;
290    [Storable]
291    private ExecutionTimeTerminator executionTimeTerminator;
292    #endregion
293
294    #region Constructors
295    [StorableConstructor]
296    private AlpsOffspringSelectionGeneticAlgorithm(bool deserializing)
297      : base(deserializing) { }
298    [StorableHook(HookType.AfterDeserialization)]
299    private void AfterDeserialization() {
300      // BackwardsCompatibility3.3
301      #region Backwards compatible code, remove with 3.4
302      var optionalMutatorParameter = MutatorParameter as OptionalConstrainedValueParameter<IManipulator>;
303      if (optionalMutatorParameter != null) {
304        Parameters.Remove(optionalMutatorParameter);
305        Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
306        foreach (var m in optionalMutatorParameter.ValidValues)
307          MutatorParameter.ValidValues.Add(m);
308        if (optionalMutatorParameter.Value == null) MutationProbability = 0; // to guarantee that the old configuration results in the same behavior
309        else Mutator = optionalMutatorParameter.Value;
310        optionalMutatorParameter.ValidValues.Clear(); // to avoid dangling references to the old parameter its valid values are cleared
311      }
312      #endregion
313      Initialize();
314    }
315    private AlpsOffspringSelectionGeneticAlgorithm(AlpsOffspringSelectionGeneticAlgorithm original, Cloner cloner)
316      : base(original, cloner) {
317      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
318      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
319      ageAnalyzer = cloner.Clone(original.ageAnalyzer);
320      layerAgeAnalyzer = cloner.Clone(original.layerAgeAnalyzer);
321      ageDistributionAnalyzer = cloner.Clone(original.ageDistributionAnalyzer);
322      layerAgeDistributionAnalyzer = cloner.Clone(original.layerAgeDistributionAnalyzer);
323      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
324      layerSelectionPressureAnalyzer = cloner.Clone(original.layerSelectionPressureAnalyzer);
325      currentSuccessRatioAnalyzer = cloner.Clone(original.currentSuccessRatioAnalyzer);
326      generationsTerminator = cloner.Clone(original.generationsTerminator);
327      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
328      qualityTerminator = cloner.Clone(original.qualityTerminator);
329      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
330      Initialize();
331    }
332    public override IDeepCloneable Clone(Cloner cloner) {
333      return new AlpsOffspringSelectionGeneticAlgorithm(this, cloner);
334    }
335    public AlpsOffspringSelectionGeneticAlgorithm()
336      : base() {
337      #region Add parameters
338      Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
339      Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
340
341      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze all individuals from all layers combined.", new MultiAnalyzer()));
342      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
343
344      Parameters.Add(new FixedValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
345      Parameters.Add(new FixedValueParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer.", new IntValue(100)));
346
347      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
348      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
349      Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
350      Parameters.Add(new FixedValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
351      Parameters.Add(new FixedValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
352      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 });
353
354      Parameters.Add(new FixedValueParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
355      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)));
356      Parameters.Add(new FixedValueParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
357      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)));
358      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)));
359      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 });
360
361      Parameters.Add(new FixedValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
362      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)));
363      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 });
364      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 });
365
366      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 });
367      Parameters.Add(new FixedValueParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true)) { Hidden = true });
368
369      Parameters.Add(new FixedValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
370      #endregion
371
372      #region Create operators
373      var globalRandomCreator = new RandomCreator();
374      var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
375      var layer0Processor = new SubScopesProcessor();
376      var localRandomCreator = new LocalRandomCreator();
377      var layerSolutionsCreator = new SolutionsCreator();
378      var initializeAgeProcessor = new UniformSubScopesProcessor();
379      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
380      var initializeCurrentPopulationSize = new SubScopesCounter() { Name = "Initialize CurrentPopulationCounter" };
381      var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
382      var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
383      var resultsCollector = new ResultsCollector();
384      var mainLoop = new AlpsOffspringSelectionGeneticAlgorithmMainLoop();
385      #endregion
386
387      #region Create and parameterize operator graph
388      OperatorGraph.InitialOperator = globalRandomCreator;
389
390      globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
391      globalRandomCreator.SeedParameter.Value = null;
392      globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
393      globalRandomCreator.SetSeedRandomlyParameter.Value = null;
394      globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
395      globalRandomCreator.Successor = layer0Creator;
396
397      layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
398      layer0Creator.Successor = layer0Processor;
399
400      layer0Processor.Operators.Add(localRandomCreator);
401      layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
402
403      localRandomCreator.Successor = layerSolutionsCreator;
404
405      layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
406      layerSolutionsCreator.Successor = initializeAgeProcessor;
407
408      initializeAgeProcessor.Operator = initializeAge;
409      initializeAgeProcessor.Successor = initializeCurrentPopulationSize;
410
411      initializeCurrentPopulationSize.ValueParameter.ActualName = "CurrentPopulationSize";
412      initializeCurrentPopulationSize.Successor = initializeLocalEvaluatedSolutions;
413
414      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
415      initializeAge.Successor = null;
416
417      initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
418      initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "CurrentPopulationSize";
419      initializeLocalEvaluatedSolutions.Successor = null;
420
421      initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
422      initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
423      initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
424      initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
425      initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
426
427      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
428      resultsCollector.Successor = mainLoop;
429
430      mainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
431      mainLoop.LocalRandomParameter.ActualName = localRandomCreator.LocalRandomParameter.Name;
432      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
433      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
434      mainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
435      mainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
436      mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
437      mainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
438      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
439      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
440      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
441      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
442      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
443      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
444      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
445      mainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
446      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
447      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
448      mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
449      mainLoop.AgeParameter.ActualName = "Age";
450      mainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
451      mainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
452      mainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
453      mainLoop.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
454      mainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
455      mainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
456      #endregion
457
458      #region Set operators
459      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
460        SelectorParameter.ValidValues.Add(selector);
461      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
462      if (defaultSelector != null) {
463        defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
464        SelectorParameter.Value = defaultSelector;
465      }
466      #endregion
467
468      #region Create analyzers
469      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
470      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
471      ageAnalyzer = new OldestAverageYoungestAgeAnalyzer();
472      layerAgeAnalyzer = new OldestAverageYoungestAgeAnalyzer();
473      ageDistributionAnalyzer = new AgeDistributionAnalyzer();
474      layerAgeDistributionAnalyzer = new AgeDistributionAnalyzer();
475      selectionPressureAnalyzer = new ValueAnalyzer();
476      layerSelectionPressureAnalyzer = new ValueAnalyzer();
477      currentSuccessRatioAnalyzer = new ValueAnalyzer();
478      #endregion
479
480      #region Create terminators
481      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
482      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
483      qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
484      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
485      #endregion
486
487      #region Parameterize
488      UpdateAnalyzers();
489      ParameterizeAnalyzers();
490
491      ParameterizeSelectors();
492
493      UpdateTerminators();
494
495      ParameterizeAgeLimits();
496      #endregion
497
498      Initialize();
499    }
500    #endregion
501
502    #region Events
503    public override void Prepare() {
504      if (Problem != null)
505        base.Prepare();
506    }
507    protected override void OnProblemChanged() {
508      base.OnProblemChanged();
509      ParameterizeStochasticOperator(Problem.SolutionCreator);
510      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
511      foreach (var @operator in Problem.Operators.OfType<IOperator>())
512        ParameterizeStochasticOperator(@operator);
513
514      ParameterizeIterationBasedOperators();
515
516      ParameterizeSolutionsCreator();
517      ParameterizeMainLoop();
518      ParameterizeAnalyzers();
519      ParameterizeSelectors();
520      ParameterizeTerminators();
521
522      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
523
524      UpdateAnalyzers();
525      UpdateCrossovers();
526      UpdateMutators();
527      UpdateTerminators();
528    }
529
530    protected override void RegisterProblemEvents() {
531      base.RegisterProblemEvents();
532      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
533      if (maximizationParameter != null) maximizationParameter.ValueChanged += new EventHandler(MaximizationParameter_ValueChanged);
534    }
535    protected override void DeregisterProblemEvents() {
536      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
537      if (maximizationParameter != null) maximizationParameter.ValueChanged -= new EventHandler(MaximizationParameter_ValueChanged);
538      base.DeregisterProblemEvents();
539    }
540
541    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
542      base.Problem_SolutionCreatorChanged(sender, e);
543      ParameterizeStochasticOperator(Problem.SolutionCreator);
544      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
545
546      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
547
548      ParameterizeSolutionsCreator();
549      ParameterizeAnalyzers();
550    }
551    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
552      base.Problem_EvaluatorChanged(sender, e);
553      foreach (var @operator in Problem.Operators.OfType<IOperator>())
554        ParameterizeStochasticOperator(@operator);
555
556      UpdateAnalyzers();
557
558      ParameterizeSolutionsCreator();
559      ParameterizeMainLoop();
560      ParameterizeSelectors();
561    }
562    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
563      base.Problem_OperatorsChanged(sender, e);
564      ParameterizeIterationBasedOperators();
565      UpdateCrossovers();
566      UpdateMutators();
567      UpdateTerminators();
568    }
569    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
570      ParameterizeMainLoop();
571      ParameterizeAnalyzers();
572      ParameterizeSelectors();
573    }
574    private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
575      ParameterizeTerminators();
576    }
577    private void QualityAnalyzer_CurrentBestQualityParameter_NameChanged(object sender, EventArgs e) {
578      ParameterizeTerminators();
579    }
580
581    private void AgeGap_ValueChanged(object sender, EventArgs e) {
582      ParameterizeAgeLimits();
583    }
584    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
585      ParameterizeAgeLimits();
586    }
587    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
588      ParameterizeAgeLimits();
589    }
590
591    private void AnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
592      foreach (var analyzer in e.Items) {
593        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
594          parameter.Depth = 2;
595        }
596      }
597    }
598    private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
599      foreach (var analyzer in e.Items) {
600        IParameter resultParameter;
601        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
602          var lookupParameter = resultParameter as ILookupParameter;
603          if (lookupParameter != null)
604            lookupParameter.ActualName = "LayerResults";
605        }
606        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
607          parameter.Depth = 1;
608        }
609      }
610    }
611    #endregion
612
613    #region Parameterization
614    private void Initialize() {
615      if (Problem != null)
616        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
617
618      NumberOfLayersParameter.Value.ValueChanged += NumberOfLayers_ValueChanged;
619
620      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
621      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
622
623      AgeGapParameter.Value.ValueChanged += AgeGap_ValueChanged;
624      AgingSchemeParameter.Value.ValueChanged += AgingScheme_ValueChanged;
625
626      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += QualityAnalyzer_CurrentBestQualityParameter_NameChanged;
627    }
628    private void ParameterizeSolutionsCreator() {
629      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
630      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
631    }
632    private void ParameterizeMainLoop() {
633      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
634      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
635      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
636    }
637    private void ParameterizeAnalyzers() {
638      qualityAnalyzer.ResultsParameter.ActualName = "Results";
639      qualityAnalyzer.ResultsParameter.Hidden = true;
640      qualityAnalyzer.QualityParameter.Depth = 2;
641      layerQualityAnalyzer.ResultsParameter.ActualName = "LayerResults";
642      layerQualityAnalyzer.ResultsParameter.Hidden = true;
643      layerQualityAnalyzer.QualityParameter.Depth = 1;
644      selectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
645      selectionPressureAnalyzer.ResultsParameter.ActualName = "Results";
646      selectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
647      selectionPressureAnalyzer.ValueParameter.Depth = 1;
648      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
649      layerSelectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
650      layerSelectionPressureAnalyzer.ResultsParameter.ActualName = "LayerResults";
651      layerSelectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
652      layerSelectionPressureAnalyzer.ValueParameter.Depth = 0;
653      layerSelectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
654      currentSuccessRatioAnalyzer.Name = "CurrentSuccessRatio Analyzer";
655      currentSuccessRatioAnalyzer.ResultsParameter.ActualName = "Results";
656      currentSuccessRatioAnalyzer.ValueParameter.ActualName = "CurrentSuccessRatio";
657      currentSuccessRatioAnalyzer.ValueParameter.Depth = 1;
658      currentSuccessRatioAnalyzer.ValuesParameter.ActualName = "Success Ratio History";
659      if (Problem != null) {
660        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
661        qualityAnalyzer.MaximizationParameter.Hidden = true;
662        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
663        qualityAnalyzer.QualityParameter.Hidden = true;
664        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
665        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
666        layerQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
667        layerQualityAnalyzer.MaximizationParameter.Hidden = true;
668        layerQualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
669        layerQualityAnalyzer.QualityParameter.Hidden = true;
670        layerQualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
671        layerQualityAnalyzer.BestKnownQualityParameter.Hidden = true;
672      }
673    }
674    private void ParameterizeSelectors() {
675      foreach (var selector in SelectorParameter.ValidValues) {
676        selector.CopySelected = new BoolValue(true);
677        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
678        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
679        ParameterizeStochasticOperatorForLayer(selector);
680      }
681      if (Problem != null) {
682        foreach (var selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
683          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
684          selector.MaximizationParameter.Hidden = true;
685          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
686          selector.QualityParameter.Hidden = true;
687        }
688      }
689    }
690    private void ParameterizeTerminators() {
691      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
692    }
693    private void ParameterizeIterationBasedOperators() {
694      if (Problem != null) {
695        foreach (var @operator in Problem.Operators.OfType<IIterationBasedOperator>()) {
696          @operator.IterationsParameter.ActualName = "Generations";
697          @operator.IterationsParameter.Hidden = true;
698          @operator.MaximumIterationsParameter.ActualName = generationsTerminator.ThresholdParameter.Name;
699          @operator.MaximumIterationsParameter.Hidden = true;
700        }
701      }
702    }
703    private void ParameterizeAgeLimits() {
704      AgeLimits = AgingScheme.CalculateAgeLimits(AgeGap, NumberOfLayers);
705    }
706
707    private void ParameterizeStochasticOperator(IOperator @operator) {
708      var stochasticOperator = @operator as IStochasticOperator;
709      if (stochasticOperator != null) {
710        stochasticOperator.RandomParameter.ActualName = "GlobalRandom";
711        stochasticOperator.RandomParameter.Hidden = true;
712      }
713    }
714
715    private void ParameterizeStochasticOperatorForLayer(IOperator @operator) {
716      var stochasticOperator = @operator as IStochasticOperator;
717      if (stochasticOperator != null) {
718        stochasticOperator.RandomParameter.ActualName = "LocalRandom";
719        stochasticOperator.RandomParameter.Hidden = true;
720      }
721    }
722
723    #endregion
724
725    #region Updates
726    private void UpdateAnalyzers() {
727      Analyzer.Operators.Clear();
728      LayerAnalyzer.Operators.Clear();
729
730      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
731      Analyzer.Operators.Add(ageAnalyzer, ageAnalyzer.EnabledByDefault);
732      Analyzer.Operators.Add(ageDistributionAnalyzer, ageDistributionAnalyzer.EnabledByDefault);
733      Analyzer.Operators.Add(selectionPressureAnalyzer, false);
734      selectionPressureAnalyzer.ValueParameter.Depth = 1; // Adding analyzer sets depth to 2
735      Analyzer.Operators.Add(currentSuccessRatioAnalyzer, false);
736      currentSuccessRatioAnalyzer.ValueParameter.Depth = 1; // Adding analyzer sets depth to 2
737      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
738      LayerAnalyzer.Operators.Add(layerAgeAnalyzer, false);
739      LayerAnalyzer.Operators.Add(layerAgeDistributionAnalyzer, false);
740      LayerAnalyzer.Operators.Add(layerSelectionPressureAnalyzer, false);
741      layerSelectionPressureAnalyzer.ValueParameter.Depth = 0; // Adding layer-analyzer sets depth to 1
742
743
744      if (Problem != null) {
745        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
746          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
747          LayerAnalyzer.Operators.Add((IAnalyzer)analyzer.Clone(), false);
748        }
749      }
750    }
751    private void UpdateCrossovers() {
752      var oldCrossover = CrossoverParameter.Value;
753      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
754      CrossoverParameter.ValidValues.Clear();
755      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(c => c.Name)) {
756        ParameterizeStochasticOperatorForLayer(crossover);
757        CrossoverParameter.ValidValues.Add(crossover);
758      }
759      if (oldCrossover != null) {
760        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(c => c.GetType() == oldCrossover.GetType());
761        if (crossover != null)
762          CrossoverParameter.Value = crossover;
763        else
764          oldCrossover = null;
765      }
766      if (oldCrossover == null && defaultCrossover != null)
767        CrossoverParameter.Value = defaultCrossover;
768    }
769    private void UpdateMutators() {
770      IManipulator oldMutator = MutatorParameter.Value;
771      MutatorParameter.ValidValues.Clear();
772      IManipulator defaultMutator = Problem.Operators.OfType<IManipulator>().FirstOrDefault();
773
774      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name)) {
775        ParameterizeStochasticOperatorForLayer(mutator);
776        MutatorParameter.ValidValues.Add(mutator);
777      }
778
779      if (oldMutator != null) {
780        IManipulator mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
781        if (mutator != null) MutatorParameter.Value = mutator;
782        else oldMutator = null;
783      }
784
785      if (oldMutator == null && defaultMutator != null)
786        MutatorParameter.Value = defaultMutator;
787    }
788    private void UpdateTerminators() {
789      var newTerminators = new Dictionary<ITerminator, bool> {
790        {generationsTerminator, !Terminators.Operators.Contains(generationsTerminator) || Terminators.Operators.ItemChecked(generationsTerminator)},
791        {evaluationsTerminator, Terminators.Operators.Contains(evaluationsTerminator) && Terminators.Operators.ItemChecked(evaluationsTerminator)},
792        {qualityTerminator, Terminators.Operators.Contains(qualityTerminator) && Terminators.Operators.ItemChecked(qualityTerminator) },
793        {executionTimeTerminator, Terminators.Operators.Contains(executionTimeTerminator) && Terminators.Operators.ItemChecked(executionTimeTerminator)}
794      };
795      if (Problem != null) {
796        foreach (var terminator in Problem.Operators.OfType<ITerminator>())
797          newTerminators.Add(terminator, !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
798      }
799
800      Terminators.Operators.Clear();
801
802      foreach (var newTerminator in newTerminators)
803        Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
804    }
805    #endregion
806  }
807}
Note: See TracBrowser for help on using the repository browser.