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

Last change on this file since 16783 was 16783, checked in by abeham, 11 months ago

#2740: Fixed wiring issue in OS-ALPS too

File size: 40.8 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2019 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 HEAL.Attic;
26using HeuristicLab.Analysis;
27using HeuristicLab.Collections;
28using HeuristicLab.Common;
29using HeuristicLab.Core;
30using HeuristicLab.Data;
31using HeuristicLab.Operators;
32using HeuristicLab.Optimization;
33using HeuristicLab.Optimization.Operators;
34using HeuristicLab.Parameters;
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  [StorableType("4CA6AFE2-8EE9-4724-AA5C-624C734703FD")]
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(StorableConstructorFlag _) : base(_) { }
297    [StorableHook(HookType.AfterDeserialization)]
298    private void AfterDeserialization() {
299      // BackwardsCompatibility3.3
300      #region Backwards compatible code, remove with 3.4
301      var optionalMutatorParameter = MutatorParameter as OptionalConstrainedValueParameter<IManipulator>;
302      if (optionalMutatorParameter != null) {
303        Parameters.Remove(optionalMutatorParameter);
304        Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
305        foreach (var m in optionalMutatorParameter.ValidValues)
306          MutatorParameter.ValidValues.Add(m);
307        if (optionalMutatorParameter.Value == null) MutationProbability = 0; // to guarantee that the old configuration results in the same behavior
308        else Mutator = optionalMutatorParameter.Value;
309        optionalMutatorParameter.ValidValues.Clear(); // to avoid dangling references to the old parameter its valid values are cleared
310      }
311      #endregion
312      Initialize();
313    }
314    private AlpsOffspringSelectionGeneticAlgorithm(AlpsOffspringSelectionGeneticAlgorithm original, Cloner cloner)
315      : base(original, cloner) {
316      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
317      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
318      ageAnalyzer = cloner.Clone(original.ageAnalyzer);
319      layerAgeAnalyzer = cloner.Clone(original.layerAgeAnalyzer);
320      ageDistributionAnalyzer = cloner.Clone(original.ageDistributionAnalyzer);
321      layerAgeDistributionAnalyzer = cloner.Clone(original.layerAgeDistributionAnalyzer);
322      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
323      layerSelectionPressureAnalyzer = cloner.Clone(original.layerSelectionPressureAnalyzer);
324      currentSuccessRatioAnalyzer = cloner.Clone(original.currentSuccessRatioAnalyzer);
325      generationsTerminator = cloner.Clone(original.generationsTerminator);
326      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
327      qualityTerminator = cloner.Clone(original.qualityTerminator);
328      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
329      Initialize();
330    }
331    public override IDeepCloneable Clone(Cloner cloner) {
332      return new AlpsOffspringSelectionGeneticAlgorithm(this, cloner);
333    }
334    public AlpsOffspringSelectionGeneticAlgorithm()
335      : base() {
336      #region Add parameters
337      Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
338      Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
339
340      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze all individuals from all layers combined.", new MultiAnalyzer()));
341      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
342
343      Parameters.Add(new FixedValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
344      Parameters.Add(new FixedValueParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer.", new IntValue(100)));
345
346      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
347      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
348      Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
349      Parameters.Add(new FixedValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
350      Parameters.Add(new FixedValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
351      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 });
352
353      Parameters.Add(new FixedValueParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
354      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)));
355      Parameters.Add(new FixedValueParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
356      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)));
357      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)));
358      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 });
359
360      Parameters.Add(new FixedValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
361      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)));
362      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 });
363      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 });
364
365      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 });
366      Parameters.Add(new FixedValueParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true)) { Hidden = true });
367
368      Parameters.Add(new FixedValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
369      #endregion
370
371      #region Create operators
372      var globalRandomCreator = new RandomCreator();
373      var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
374      var layer0Processor = new SubScopesProcessor();
375      var localRandomCreator = new LocalRandomCreator();
376      var layerSolutionsCreator = new SolutionsCreator();
377      var initializeAgeProcessor = new UniformSubScopesProcessor();
378      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
379      var initializeCurrentPopulationSize = new SubScopesCounter() { Name = "Initialize CurrentPopulationCounter" };
380      var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
381      var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
382      var resultsCollector = new ResultsCollector();
383      var mainLoop = new AlpsOffspringSelectionGeneticAlgorithmMainLoop();
384      #endregion
385
386      #region Create and parameterize operator graph
387      OperatorGraph.InitialOperator = globalRandomCreator;
388
389      globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
390      globalRandomCreator.SeedParameter.Value = null;
391      globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
392      globalRandomCreator.SetSeedRandomlyParameter.Value = null;
393      globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
394      globalRandomCreator.Successor = layer0Creator;
395
396      layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
397      layer0Creator.Successor = layer0Processor;
398
399      layer0Processor.Operators.Add(localRandomCreator);
400      layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
401
402      localRandomCreator.Successor = layerSolutionsCreator;
403
404      layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
405      layerSolutionsCreator.Successor = initializeAgeProcessor;
406
407      initializeAgeProcessor.Operator = initializeAge;
408      initializeAgeProcessor.Successor = initializeCurrentPopulationSize;
409
410      initializeCurrentPopulationSize.ValueParameter.ActualName = "CurrentPopulationSize";
411      initializeCurrentPopulationSize.Successor = initializeLocalEvaluatedSolutions;
412
413      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
414      initializeAge.Successor = null;
415
416      initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
417      initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "CurrentPopulationSize";
418      initializeLocalEvaluatedSolutions.Successor = null;
419
420      initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
421      initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
422      initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
423      initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
424      initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
425
426      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
427      resultsCollector.Successor = mainLoop;
428
429      mainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
430      mainLoop.LocalRandomParameter.ActualName = localRandomCreator.LocalRandomParameter.Name;
431      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
432      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
433      mainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
434      mainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
435      mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
436      mainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
437      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
438      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
439      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
440      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
441      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
442      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
443      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
444      mainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
445      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
446      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
447      mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
448      mainLoop.AgeParameter.ActualName = "Age";
449      mainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
450      mainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
451      mainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
452      mainLoop.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
453      mainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
454      mainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
455      #endregion
456
457      #region Set operators
458      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
459        SelectorParameter.ValidValues.Add(selector);
460      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
461      if (defaultSelector != null) {
462        defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
463        SelectorParameter.Value = defaultSelector;
464      }
465      #endregion
466
467      #region Create analyzers
468      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
469      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
470      ageAnalyzer = new OldestAverageYoungestAgeAnalyzer();
471      layerAgeAnalyzer = new OldestAverageYoungestAgeAnalyzer();
472      ageDistributionAnalyzer = new AgeDistributionAnalyzer();
473      layerAgeDistributionAnalyzer = new AgeDistributionAnalyzer();
474      selectionPressureAnalyzer = new ValueAnalyzer();
475      layerSelectionPressureAnalyzer = new ValueAnalyzer();
476      currentSuccessRatioAnalyzer = new ValueAnalyzer();
477      #endregion
478
479      #region Create terminators
480      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
481      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
482      qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
483      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
484      #endregion
485
486      #region Parameterize
487      UpdateAnalyzers();
488      ParameterizeAnalyzers();
489
490      ParameterizeSelectors();
491
492      UpdateTerminators();
493
494      ParameterizeAgeLimits();
495      #endregion
496
497      Initialize();
498    }
499    #endregion
500
501    #region Events
502    public override void Prepare() {
503      if (Problem != null)
504        base.Prepare();
505    }
506    protected override void OnProblemChanged() {
507      base.OnProblemChanged();
508      ParameterizeStochasticOperator(Problem.SolutionCreator);
509      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
510      foreach (var @operator in Problem.Operators.OfType<IOperator>())
511        ParameterizeStochasticOperator(@operator);
512
513      ParameterizeIterationBasedOperators();
514
515      ParameterizeSolutionsCreator();
516      ParameterizeMainLoop();
517      ParameterizeAnalyzers();
518      ParameterizeSelectors();
519      ParameterizeTerminators();
520
521      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
522
523      UpdateAnalyzers();
524      UpdateCrossovers();
525      UpdateMutators();
526      UpdateTerminators();
527    }
528
529    protected override void RegisterProblemEvents() {
530      base.RegisterProblemEvents();
531      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
532      if (maximizationParameter != null) maximizationParameter.ValueChanged += new EventHandler(MaximizationParameter_ValueChanged);
533    }
534    protected override void DeregisterProblemEvents() {
535      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
536      if (maximizationParameter != null) maximizationParameter.ValueChanged -= new EventHandler(MaximizationParameter_ValueChanged);
537      base.DeregisterProblemEvents();
538    }
539
540    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
541      base.Problem_SolutionCreatorChanged(sender, e);
542      ParameterizeStochasticOperator(Problem.SolutionCreator);
543      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
544
545      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
546
547      ParameterizeSolutionsCreator();
548      ParameterizeAnalyzers();
549    }
550    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
551      base.Problem_EvaluatorChanged(sender, e);
552      foreach (var @operator in Problem.Operators.OfType<IOperator>())
553        ParameterizeStochasticOperator(@operator);
554
555      UpdateAnalyzers();
556
557      ParameterizeSolutionsCreator();
558      ParameterizeMainLoop();
559      ParameterizeSelectors();
560    }
561    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
562      base.Problem_OperatorsChanged(sender, e);
563      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
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.