Free cookie consent management tool by TermsFeed Policy Generator

source: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs @ 12040

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

#2269
Introduced a parameter to adjust the range of layers used for creating a mating pool.
File size: 28.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Analysis;
26using HeuristicLab.Common;
27using HeuristicLab.Core;
28using HeuristicLab.Data;
29using HeuristicLab.Operators;
30using HeuristicLab.Optimization;
31using HeuristicLab.Optimization.Operators;
32using HeuristicLab.Parameters;
33using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
34using HeuristicLab.PluginInfrastructure;
35using HeuristicLab.Random;
36using HeuristicLab.Selection;
37
38namespace HeuristicLab.Algorithms.ALPS {
39  [Item("ALPS Genetic Algorithm", "A genetic algorithm with an age-layered population structure.")]
40  [Creatable("Algorithms")]
41  [StorableClass]
42  public sealed class AlpsGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
43    public string Filename { get; set; }
44
45    #region Problem Properties
46    public override Type ProblemType {
47      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
48    }
49    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
50      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
51      set { base.Problem = value; }
52    }
53    #endregion
54
55    #region Parameter Properties
56    private IValueParameter<IntValue> SeedParameter {
57      get { return (IValueParameter<IntValue>)Parameters["Seed"]; }
58    }
59    private IValueParameter<BoolValue> SetSeedRandomlyParameter {
60      get { return (IValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
61    }
62    private IValueParameter<MultiAnalyzer> AnalyzerParameter {
63      get { return (IValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
64    }
65    private IValueParameter<MultiAnalyzer> LayerAnalyzerParameter {
66      get { return (IValueParameter<MultiAnalyzer>)Parameters["LayerAnalyzer"]; }
67    }
68    private IValueParameter<IntValue> NumberOfLayersParameter {
69      get { return (IValueParameter<IntValue>)Parameters["NumberOfLayers"]; }
70    }
71    private IValueParameter<IntArray> PopulationSizeParameter {
72      get { return (IValueParameter<IntArray>)Parameters["PopulationSize"]; }
73    }
74    private IValueParameter<IntValue> MaximumGenerationsParameter {
75      get { return (IValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
76    }
77    private IValueParameter<AgingScheme> AgingSchemeParameter {
78      get { return (IValueParameter<AgingScheme>)Parameters["AgingScheme"]; }
79    }
80    private IValueParameter<IntValue> AgeGapParameter {
81      get { return (IValueParameter<IntValue>)Parameters["AgeGap"]; }
82    }
83    private IValueParameter<IntArray> AgeLimitsParameter {
84      get { return (IValueParameter<IntArray>)Parameters["AgeLimits"]; }
85    }
86    private IValueParameter<ReductionOperation> AgeInheritanceParameter {
87      get { return (IValueParameter<ReductionOperation>)Parameters["AgeInheritance"]; }
88    }
89    private IValueParameter<IntValue> MatingPoolRangeParameter {
90      get { return (IValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
91    }
92    public IConstrainedValueParameter<ISelector> SelectorParameter {
93      get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
94    }
95    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
96      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
97    }
98    private IValueParameter<PercentValue> MutationProbabilityParameter {
99      get { return (IValueParameter<PercentValue>)Parameters["MutationProbability"]; }
100    }
101    public IConstrainedValueParameter<IManipulator> MutatorParameter {
102      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
103    }
104    private IValueParameter<IntValue> ElitesParameter {
105      get { return (IValueParameter<IntValue>)Parameters["Elites"]; }
106    }
107    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
108      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
109    }
110    #endregion
111
112    #region Properties
113    public IntValue Seed {
114      get { return SeedParameter.Value; }
115      set { SeedParameter.Value = value; }
116    }
117    public BoolValue SetSeedRandomly {
118      get { return SetSeedRandomlyParameter.Value; }
119      set { SetSeedRandomlyParameter.Value = value; }
120    }
121    public MultiAnalyzer Analyzer {
122      get { return AnalyzerParameter.Value; }
123      set { AnalyzerParameter.Value = value; }
124    }
125    public MultiAnalyzer LayerAnalyzer {
126      get { return LayerAnalyzerParameter.Value; }
127      set { LayerAnalyzerParameter.Value = value; }
128    }
129    public IntValue NumberOfLayers {
130      get { return NumberOfLayersParameter.Value; }
131      set { NumberOfLayersParameter.Value = value; }
132    }
133
134    public IntArray PopulationSize {
135      get { return PopulationSizeParameter.Value; }
136      set { PopulationSizeParameter.Value = value; }
137    }
138    public IntValue MaximumGenerations {
139      get { return MaximumGenerationsParameter.Value; }
140      set { MaximumGenerationsParameter.Value = value; }
141    }
142    public AgingScheme AgingScheme {
143      get { return AgingSchemeParameter.Value; }
144      set { AgingSchemeParameter.Value = value; }
145    }
146    public IntValue AgeGap {
147      get { return AgeGapParameter.Value; }
148      set { AgeGapParameter.Value = value; }
149    }
150    public IntArray AgeLimits {
151      get { return AgeLimitsParameter.Value; }
152      set { AgeLimitsParameter.Value = value; }
153    }
154    public ReductionOperation AgeInheritance {
155      get { return AgeInheritanceParameter.Value; }
156      set { AgeInheritanceParameter.Value = value; }
157    }
158    public IntValue MatingPoolRange {
159      get { return MatingPoolRangeParameter.Value; }
160      set { MatingPoolRangeParameter.Value = value; }
161    }
162    public ISelector Selector {
163      get { return SelectorParameter.Value; }
164      set { SelectorParameter.Value = value; }
165    }
166    public ICrossover Crossover {
167      get { return CrossoverParameter.Value; }
168      set { CrossoverParameter.Value = value; }
169    }
170    public PercentValue MutationProbability {
171      get { return MutationProbabilityParameter.Value; }
172      set { MutationProbabilityParameter.Value = value; }
173    }
174    public IManipulator Mutator {
175      get { return MutatorParameter.Value; }
176      set { MutatorParameter.Value = value; }
177    }
178    public IntValue Elites {
179      get { return ElitesParameter.Value; }
180      set { ElitesParameter.Value = value; }
181    }
182    public bool ReevaluteElites {
183      get { return ReevaluateElitesParameter.Value.Value; }
184      set { ReevaluateElitesParameter.Value.Value = value; }
185    }
186
187    private RandomCreator GlobalRandomCreator {
188      get { return (RandomCreator)OperatorGraph.InitialOperator; }
189    }
190    private SolutionsCreator SolutionsCreator {
191      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
192    }
193    private AlpsGeneticAlgorithmMainLoop MainLoop {
194      get { return OperatorGraph.Iterate().OfType<AlpsGeneticAlgorithmMainLoop>().First(); }
195    }
196
197    #endregion
198
199    #region Preconfigured Analyzers
200    [Storable]
201    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
202    [Storable]
203    private BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
204    #endregion
205
206    [StorableConstructor]
207    private AlpsGeneticAlgorithm(bool deserializing)
208      : base(deserializing) { }
209    private AlpsGeneticAlgorithm(AlpsGeneticAlgorithm original, Cloner cloner)
210      : base(original, cloner) {
211      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
212      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
213      Initialize();
214    }
215    public override IDeepCloneable Clone(Cloner cloner) {
216      return new AlpsGeneticAlgorithm(this, cloner);
217    }
218    public AlpsGeneticAlgorithm()
219      : base() {
220      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
221      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
222      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
223      Parameters.Add(new ValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
224      Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(5)));
225      Parameters.Add(new ValueParameter<IntArray>("PopulationSize", "The size of the population of solutions each layer.", new IntArray(new[] { 5, 10, 20, 50, 100 })));
226      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations that should be processed.", new IntValue(1000)));
227      Parameters.Add(new ValueParameter<AgingScheme>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new AgingScheme(AgingSchemes.Polynomial)));
228      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(5)));
229      Parameters.Add(new ValueParameter<IntArray>("AgeLimits", new IntArray(new[] { 5, 20, 45, 80, 125 })) { Hidden = true });
230      Parameters.Add(new ValueParameter<ReductionOperation>("AgeInheritance", "The operator for determining the age of an offspring based the parents' age.", new ReductionOperation(ReductionOperations.Max)) { Hidden = true });
231      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 });
232      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
233      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
234      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
235      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
236      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
237      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 });
238
239      var globalRandomCreator = new RandomCreator();
240      var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
241      var layer0Processor = new LayerUniformSubScopesProcessor();
242      var localRandomCreator = new LocalRandomCreator();
243      var layerVariableCreator = new VariableCreator();
244      var layerSolutionsCreator = new SolutionsCreator();
245      var initializeAgeProcessor = new UniformSubScopesProcessor();
246      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
247      var initializeLayerPopulationSize = new SubScopesCounter() { Name = "Init LayerPopulationCounter" };
248      var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
249      var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
250      var resultsCollector = new ResultsCollector();
251      var mainLoop = new AlpsGeneticAlgorithmMainLoop();
252
253      OperatorGraph.InitialOperator = globalRandomCreator;
254
255      globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
256      globalRandomCreator.SeedParameter.Value = null;
257      globalRandomCreator.SetSeedRandomlyParameter.Value = null;
258      globalRandomCreator.Successor = layer0Creator;
259
260      layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
261      layer0Creator.Successor = layer0Processor;
262
263      layer0Processor.Operator = localRandomCreator;
264      layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
265
266      localRandomCreator.Successor = layerVariableCreator;
267
268      layerVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Layer", new IntValue(0)));
269      //layerVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("Results", new ResultCollection()));
270      layerVariableCreator.Successor = layerSolutionsCreator;
271
272      layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
273      layerSolutionsCreator.Successor = initializeAgeProcessor;
274
275      initializeAgeProcessor.Operator = initializeAge;
276      initializeAgeProcessor.Successor = initializeLayerPopulationSize;
277
278      initializeLayerPopulationSize.ValueParameter.ActualName = "LayerPopulationSize";
279      initializeLayerPopulationSize.Successor = initializeLocalEvaluatedSolutions;
280
281      initializeAge.CollectedValues.Add(new ValueParameter<IntValue>("Age", new IntValue(0)));
282      initializeAge.Successor = null;
283
284      initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
285      initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "LayerPopulationSize";
286      initializeLocalEvaluatedSolutions.Successor = null;
287
288      initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
289      initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
290      initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
291      initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
292      initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
293
294      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
295      resultsCollector.Successor = mainLoop;
296
297      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
298        SelectorParameter.ValidValues.Add(selector);
299      var porportionalSelector = SelectorParameter.ValidValues.FirstOrDefault(s => s is ProportionalSelector);
300      if (porportionalSelector != null) SelectorParameter.Value = porportionalSelector;
301
302      ParameterizeSelectors();
303
304      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
305      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
306      ParameterizeAnalyzers();
307      UpdateAnalyzers();
308
309      Initialize();
310    }
311
312    public override void Prepare() {
313      if (Problem != null)
314        base.Prepare();
315    }
316
317    #region Events
318    protected override void OnProblemChanged() {
319      ParameterizeStochasticOperator(Problem.SolutionCreator);
320      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
321      foreach (var @operator in Problem.Operators.OfType<IOperator>())
322        ParameterizeStochasticOperator(@operator);
323      ParameterizeSolutionsCreator();
324      ParameterizeMainLoop();
325      ParameterizeSelectors();
326      ParameterizeAnalyzers();
327      ParameterizeIterationBasedOperators();
328      UpdateCrossovers();
329      UpdateMutators();
330      UpdateAnalyzers();
331      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
332      base.OnProblemChanged();
333    }
334
335    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
336      ParameterizeStochasticOperator(Problem.SolutionCreator);
337      ParameterizeSolutionsCreator();
338      base.Problem_SolutionCreatorChanged(sender, e);
339    }
340    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
341      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
342      ParameterizeSolutionsCreator();
343      ParameterizeMainLoop();
344      ParameterizeSelectors();
345      ParameterizeAnalyzers();
346      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
347      base.Problem_EvaluatorChanged(sender, e);
348    }
349    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
350      foreach (var @operator in Problem.Operators.OfType<IOperator>())
351        ParameterizeStochasticOperator(@operator);
352      ParameterizeIterationBasedOperators();
353      UpdateCrossovers();
354      UpdateMutators();
355      UpdateAnalyzers();
356      base.Problem_OperatorsChanged(sender, e);
357    }
358    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
359      ParameterizeMainLoop();
360      ParameterizeSelectors();
361      ParameterizeAnalyzers();
362    }
363
364    void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
365      PopulationSizeParameter.ValueChanged += PopulationSize_ValueChanged;
366      ParameterizeSelectors();
367    }
368    void PopulationSize_ValueChanged(object sender, EventArgs e) {
369      ParameterizeSelectors();
370    }
371    void ElitesParameter_ValueChanged(object sender, EventArgs e) {
372      Elites.ValueChanged += ElitesParameter_ValueChanged;
373      ParameterizeSelectors();
374    }
375    void Elites_ValueChanged(object sender, EventArgs e) {
376      ParameterizeSelectors();
377    }
378    private void AgeGapParameter_ValueChanged(object sender, EventArgs e) {
379      AgeGap.ValueChanged += AgeGap_ValueChanged;
380      RecalculateAgeLimits();
381    }
382    private void AgeGap_ValueChanged(object sender, EventArgs e) {
383      RecalculateAgeLimits();
384    }
385    private void AgingSchemeParameter_ValueChanged(object sender, EventArgs e) {
386      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
387      RecalculateAgeLimits();
388    }
389    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
390      RecalculateAgeLimits();
391    }
392    private void NumberOfLayersParameter_ValueChanged(object sender, EventArgs e) {
393      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
394      RecalculateAgeLimits();
395    }
396    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
397      RecalculateAgeLimits();
398    }
399    #endregion
400
401    #region Parameterization
402    private void Initialize() {
403      PopulationSizeParameter.ValueChanged += PopulationSizeParameter_ValueChanged;
404      //PopulationSize.ValueChanged += PopulationSize_ValueChanged; TODO
405      ElitesParameter.ValueChanged += ElitesParameter_ValueChanged;
406      Elites.ValueChanged += Elites_ValueChanged;
407      if (Problem != null)
408        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
409      AgeGapParameter.ValueChanged += AgeGapParameter_ValueChanged;
410      AgeGap.ValueChanged += AgeGap_ValueChanged;
411      AgingSchemeParameter.ValueChanged += AgingSchemeParameter_ValueChanged;
412      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
413      NumberOfLayersParameter.ValueChanged += NumberOfLayersParameter_ValueChanged;
414      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
415    }
416    private void ParameterizeSolutionsCreator() {
417      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
418      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
419      MainLoop.LayerUpdator.SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
420      MainLoop.LayerUpdator.SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
421    }
422    private void ParameterizeMainLoop() {
423      MainLoop.MainOperator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
424      MainLoop.MainOperator.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
425      MainLoop.MainOperator.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
426      MainLoop.EldersEmigrator.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
427      MainLoop.EldersEmigrator.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
428      MainLoop.LayerUpdator.SolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
429    }
430    private void ParameterizeSelectors() {
431
432      foreach (var selector in SelectorParameter.ValidValues) {
433        selector.CopySelected = new BoolValue(true);
434        // Explicit setting of NumberOfSelectedSubScopesParameter is not required anymore because the NumberOfSelectedSubScopesCalculator calculates it itself
435        //selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(2 * (PopulationSize - Elites.Value));
436        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
437        ParameterizeStochasticOperatorForLayer(selector);
438      }
439      if (Problem != null) {
440        foreach (var selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
441          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
442          selector.MaximizationParameter.Hidden = true;
443          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
444          selector.QualityParameter.Hidden = true;
445        }
446      }
447    }
448    private void ParameterizeAnalyzers() {
449      qualityAnalyzer.ResultsParameter.ActualName = "Results";
450      qualityAnalyzer.ResultsParameter.Hidden = true;
451      qualityAnalyzer.QualityParameter.Depth = 2;
452      layerQualityAnalyzer.ResultsParameter.ActualName = "Results";
453      layerQualityAnalyzer.ResultsParameter.Hidden = true;
454      layerQualityAnalyzer.QualityParameter.Depth = 1;
455      if (Problem != null) {
456        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
457        qualityAnalyzer.MaximizationParameter.Hidden = true;
458        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
459        qualityAnalyzer.QualityParameter.Hidden = true;
460        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
461        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
462        layerQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
463        layerQualityAnalyzer.MaximizationParameter.Hidden = true;
464        layerQualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
465        layerQualityAnalyzer.QualityParameter.Hidden = true;
466        layerQualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
467        layerQualityAnalyzer.BestKnownQualityParameter.Hidden = true;
468      }
469    }
470    private void ParameterizeIterationBasedOperators() {
471      if (Problem != null) {
472        foreach (var @operator in Problem.Operators.OfType<IIterationBasedOperator>()) {
473          @operator.IterationsParameter.ActualName = "Generations";
474          @operator.IterationsParameter.Hidden = true;
475          @operator.MaximumIterationsParameter.ActualName = "MaximumGenerations";
476          @operator.MaximumIterationsParameter.Hidden = true;
477        }
478      }
479    }
480    private void ParameterizeStochasticOperator(IOperator @operator) {
481      var stochasticOperator = @operator as IStochasticOperator;
482      if (stochasticOperator != null) {
483        stochasticOperator.RandomParameter.ActualName = GlobalRandomCreator.RandomParameter.ActualName;
484        stochasticOperator.RandomParameter.Hidden = true;
485      }
486    }
487    private void ParameterizeStochasticOperatorForLayer(IOperator @operator) {
488      var stochasticOperator = @operator as IStochasticOperator;
489      if (stochasticOperator != null) {
490        stochasticOperator.RandomParameter.ActualName = "LocalRandom";
491        stochasticOperator.RandomParameter.Hidden = true;
492      }
493    }
494    #endregion
495
496    #region Updates
497    private void UpdateCrossovers() {
498      var oldCrossover = CrossoverParameter.Value;
499      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
500      CrossoverParameter.ValidValues.Clear();
501      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(c => c.Name)) {
502        ParameterizeStochasticOperatorForLayer(crossover);
503        CrossoverParameter.ValidValues.Add(crossover);
504      }
505      if (oldCrossover != null) {
506        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(c => c.GetType() == oldCrossover.GetType());
507        if (crossover != null)
508          CrossoverParameter.Value = crossover;
509        else
510          oldCrossover = null;
511      }
512      if (oldCrossover == null && defaultCrossover != null)
513        CrossoverParameter.Value = defaultCrossover;
514    }
515    private void UpdateMutators() {
516      var oldMutator = MutatorParameter.Value;
517      MutatorParameter.ValidValues.Clear();
518      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(m => m.Name)) {
519        ParameterizeStochasticOperatorForLayer(mutator);
520        MutatorParameter.ValidValues.Add(mutator);
521      }
522      if (oldMutator != null) {
523        var mutator = MutatorParameter.ValidValues.FirstOrDefault(m => m.GetType() == oldMutator.GetType());
524        if (mutator != null)
525          MutatorParameter.Value = mutator;
526      }
527    }
528    private void UpdateAnalyzers() {
529      Analyzer.Operators.Clear();
530      LayerAnalyzer.Operators.Clear();
531
532      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
533      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, layerQualityAnalyzer.EnabledByDefault);
534
535      if (Problem != null) {
536        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
537          foreach (var parameter in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
538            parameter.Depth = 2;
539          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
540        }
541      }
542    }
543    #endregion
544
545    #region AgeLimits calculation
546    private void RecalculateAgeLimits() {
547      IEnumerable<int> scheme;
548      switch (AgingScheme.Value) {
549        case AgingSchemes.Linear: scheme = LinearAgingScheme(); break;
550        case AgingSchemes.Fibonacci: scheme = FibonacciAgingScheme(); break;
551        case AgingSchemes.Polynomial: scheme = PolynomialAgingScheme(2); break;
552        case AgingSchemes.Exponential: scheme = ExponentialAgingScheme(2); break;
553        default: throw new NotSupportedException("Aging Scheme " + AgingScheme.Value + " is not supported.");
554      }
555
556      int ageGap = AgeGap.Value;
557      AgeLimits = new IntArray(scheme.Select(a => a * ageGap).Take(NumberOfLayers.Value).ToArray());
558    }
559
560    // 1 2 3 4 5 6 7
561    private static IEnumerable<int> LinearAgingScheme() {
562      for (int i = 0; ; i++)
563        yield return i + 1;
564    }
565    // 1 2 3 5 8 13 21
566    private static IEnumerable<int> FibonacciAgingScheme() {
567      for (int i = 1, next = 2, temp; ; temp = next, next = i + next, i = temp)
568        yield return i;
569    }
570    // (n^2): 1 2 4 9 16 25 36
571    private static IEnumerable<int> PolynomialAgingScheme(double exp) {
572      yield return 1;
573      yield return 2;
574      for (int i = 2; ; i++)
575        yield return (int)Math.Pow(i, exp);
576
577    }
578    // 1 2 4 8 16 32 64
579    private static IEnumerable<int> ExponentialAgingScheme(double @base) {
580      for (int i = 0; ; i++)
581        yield return (int)Math.Pow(@base, i);
582    }
583    #endregion
584  }
585}
Note: See TracBrowser for help on using the repository browser.