Free cookie consent management tool by TermsFeed Policy Generator

source: branches/3057_DynamicALPS/TestProblems/oesr-alps-master/HeuristicLab.Algorithms.OESRALPS/AlpsGeneticAlgorithm.cs @ 17479

Last change on this file since 17479 was 17479, checked in by kyang, 4 years ago

#3057

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