Free cookie consent management tool by TermsFeed Policy Generator

source: branches/IslandALPS/IslandALPS/3.3/Offspring Selection/IslandAlpsOffspringSelectionAlgorithm.cs @ 13778

Last change on this file since 13778 was 13778, checked in by pkuelzer, 8 years ago

#2558 added wiring of island alps offspring selection
File size: 43.5 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using HeuristicLab.Algorithms.ALPS;
5using HeuristicLab.Analysis;
6using HeuristicLab.Collections;
7using HeuristicLab.Common;
8using HeuristicLab.Core;
9using HeuristicLab.Data;
10using HeuristicLab.Operators;
11using HeuristicLab.Optimization;
12using HeuristicLab.Optimization.Operators;
13using HeuristicLab.Parameters;
14using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
15using HeuristicLab.PluginInfrastructure;
16using HeuristicLab.Random;
17using HeuristicLab.Selection;
18
19namespace HeuristicLab.Algorithms.IslandALPS {
20  [Item("IslandAlpsOffspringSelectionAlgorithm", "An island version of ALPS with offspring selection")]
21  [StorableClass]
22  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 100)]
23  public class IslandAlpsOffspringSelectionAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
24    public string Filename { get; set; }
25
26    #region Problem Properties
27
28    public override Type ProblemType {
29      get { return typeof (ISingleObjectiveHeuristicOptimizationProblem); }
30    }
31
32    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
33      get { return (ISingleObjectiveHeuristicOptimizationProblem) base.Problem; }
34      set { base.Problem = value; }
35    }
36
37    #endregion
38
39    #region Parameter Properties
40
41    #region ALPSParameter
42
43    public IValueParameter<IntValue> AgeGapParameter { get { return (IValueParameter<IntValue>) Parameters["AgeGap"]; } }
44
45    public IValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter { get { return (IValueParameter<EnumValue<AgingScheme>>) Parameters["AgingScheme"]; } }
46    public IValueParameter<DoubleValue> AgeInheritanceParameter {   get { return (IValueParameter<DoubleValue>) Parameters["AgeInheritance"]; } }
47    public IValueParameter<IntArray> AgeLimitsParameter {   get { return (IValueParameter<IntArray>) Parameters["AgeLimits"]; }   }
48    public IValueParameter<BoolValue> ReduceToPopulationSizeParameter {   get { return (IValueParameter<BoolValue>) Parameters["ReduceToPopulationSize"]; }   }
49    public IValueParameter<IntValue> NumberOfLayersParameter {   get { return (IValueParameter<IntValue>) Parameters["NumberOfLayers"]; } }
50    public IValueParameter<MultiAnalyzer> LayerAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["LayerAnalyzer"]; } }
51    public IValueParameter<MultiAnalyzer> GroupAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["GroupAnalyzer"]; } }
52    #endregion
53    #region OSParameter
54
55    public IFixedValueParameter<DoubleValue> SuccessRatioParameter { get { return (IFixedValueParameter<DoubleValue>) Parameters["SuccessRatio"]; } }
56    public IFixedValueParameter<DoubleValue> ComparisonFactorParameter { get { return (IFixedValueParameter<DoubleValue>) Parameters["ComparisonFactor"]; } }
57    public IFixedValueParameter<DoubleValue> MaximumSelectionPressureParameter { get { return (IFixedValueParameter<DoubleValue>) Parameters["MaximumSelectionPressure"]; } }
58    public IFixedValueParameter<BoolValue> OffspringSelectionBeforeMutationParameter { get { return (IFixedValueParameter<BoolValue>) Parameters["OffspringSelectionBeforeMutation"]; } }
59    public IFixedValueParameter<IntValue> SelectedParentsParameter { get { return (IFixedValueParameter<IntValue>) Parameters["SelectedParents"]; } }
60    #endregion
61
62    #region IslandParameter
63
64    public IValueParameter<MultiAnalyzer> IslandAnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["IslandAnalyzer"]; } }
65    public IValueParameter<IntValue> NumberOfIslandsParameter {   get { return (IValueParameter<IntValue>) Parameters["NumberOfIslands"]; } }
66    public IValueParameter<PercentValue> MigrationRateParameter {   get { return (IValueParameter<PercentValue>) Parameters["MigrationRate"]; } }
67    public IValueParameter<IntValue> MigrationIntervalParameter {   get { return (IValueParameter<IntValue>) Parameters["MigrationInterval"]; } }
68    public IConstrainedValueParameter<IMigrator> MigratorParameter {   get { return (IConstrainedValueParameter<IMigrator>) Parameters["Migrator"]; } }
69    public IConstrainedValueParameter<ISelector> EmigrantsSelectorParameter {   get { return (IConstrainedValueParameter<ISelector>) Parameters["EmigrantsSelector"]; } }
70    public IConstrainedValueParameter<IReplacer> ImmigrationReplacerParameter {   get { return (IConstrainedValueParameter<IReplacer>) Parameters["ImmigrationReplacer"]; } }
71    #endregion
72
73    #region GeneralParameter
74
75    public IValueParameter<IntValue> SeedParameter {   get { return (IValueParameter<IntValue>) Parameters["Seed"]; } }
76    public IValueParameter<BoolValue> SetSeedRandomlyParameter {   get { return (IValueParameter<BoolValue>) Parameters["SetSeedRandomly"]; } }
77    public IValueParameter<IntValue> PopulationSizeParameter {   get { return (IValueParameter<IntValue>) Parameters["PopulationSize"]; } }
78    public IValueParameter<MultiAnalyzer> AnalyzerParameter {   get { return (IValueParameter<MultiAnalyzer>) Parameters["Analyzer"]; } }
79    public IConstrainedValueParameter<ISelector> SelectorParameter {   get { return (IConstrainedValueParameter<ISelector>) Parameters["Selector"]; } }
80    public IConstrainedValueParameter<ICrossover> CrossoverParameter {   get { return (IConstrainedValueParameter<ICrossover>) Parameters["Crossover"]; } }
81    public IValueParameter<PercentValue> MutationProbabilityParameter {   get { return (IValueParameter<PercentValue>) Parameters["MutationProbability"]; } }
82    public IConstrainedValueParameter<IManipulator> MutatorParameter {   get { return (IConstrainedValueParameter<IManipulator>) Parameters["Mutator"]; } }
83    public IValueParameter<IntValue> ElitesParameter {   get { return (IValueParameter<IntValue>) Parameters["Elites"]; } }
84    public IFixedValueParameter<BoolValue> ReevaluateElitesParameter {   get { return (IFixedValueParameter<BoolValue>) Parameters["ReevaluateElites"]; } }
85    public IValueParameter<MultiTerminator> TerminatorParameter {   get { return (IValueParameter<MultiTerminator>) Parameters["Terminator"]; } }
86    #endregion
87
88    #endregion
89
90    #region Properties
91
92    public IntValue Seed {
93      get { return SeedParameter.Value; }
94      set { SeedParameter.Value = value; }
95    }
96
97    public BoolValue SetSeedRandomly {
98      get { return SetSeedRandomlyParameter.Value; }
99      set { SetSeedRandomlyParameter.Value = value; }
100    }
101
102    public IntValue PopulationSize {
103      get { return PopulationSizeParameter.Value; }
104      set { PopulationSizeParameter.Value = value; }
105    }
106
107    public IntValue NumberOfIslands {
108      get { return NumberOfIslandsParameter.Value; }
109      set { NumberOfIslandsParameter.Value = value; }
110    }
111
112    public MultiAnalyzer Analyzer {
113      get { return AnalyzerParameter.Value; }
114      set { AnalyzerParameter.Value = value; }
115    }
116
117    public MultiAnalyzer IslandAnalyzer {
118      get { return IslandAnalyzerParameter.Value; }
119      set { IslandAnalyzerParameter.Value = value; }
120    }
121
122    public MultiAnalyzer LayerAnalyzer {
123      get { return LayerAnalyzerParameter.Value; }
124      set { LayerAnalyzerParameter.Value = value; }
125    }
126
127    public MultiAnalyzer GroupAnalyzer {
128      get { return GroupAnalyzerParameter.Value; }
129      set { GroupAnalyzerParameter.Value = value; }
130    }
131
132    public ISelector Selector {
133      get { return SelectorParameter.Value; }
134      set { SelectorParameter.Value = value; }
135    }
136
137    public ICrossover Crossover {
138      get { return CrossoverParameter.Value; }
139      set { CrossoverParameter.Value = value; }
140    }
141
142    public PercentValue MutationProbability {
143      get { return MutationProbabilityParameter.Value; }
144      set { MutationProbabilityParameter.Value = value; }
145    }
146
147    public IManipulator Mutator {
148      get { return MutatorParameter.Value; }
149      set { MutatorParameter.Value = value; }
150    }
151
152    public IntValue Elites {
153      get { return ElitesParameter.Value; }
154      set { ElitesParameter.Value = value; }
155    }
156
157    public bool ReevaluteElites {
158      get { return ReevaluateElitesParameter.Value.Value; }
159      set { ReevaluateElitesParameter.Value.Value = value; }
160    }
161
162    public MultiTerminator Terminators {
163      get { return TerminatorParameter.Value; }
164    }
165
166    public EnumValue<AgingScheme> AgingScheme {
167      get { return AgingSchemeParameter.Value; }
168      set { AgingSchemeParameter.Value = value; }
169    }
170
171    public IntValue AgeGap {
172      get { return AgeGapParameter.Value; }
173      set { AgeGapParameter.Value = value; }
174    }
175
176    public DoubleValue AgeInheritance {
177      get { return AgeInheritanceParameter.Value; }
178      set { AgeInheritanceParameter.Value = value; }
179    }
180
181    public IntArray AgeLimits {
182      get { return AgeLimitsParameter.Value; }
183      set { AgeLimitsParameter.Value = value; }
184    }
185
186    public IntValue NumberOfLayers {
187      get { return NumberOfLayersParameter.Value; }
188      set { NumberOfLayersParameter.Value = value; }
189    }
190
191    #endregion
192
193    #region Helper Properties
194
195    private IslandAlpsOffspringSelectionAlgorithmMainLoop MainLoop {
196      get { return OperatorGraph.Iterate().OfType<IslandAlpsOffspringSelectionAlgorithmMainLoop>().First(); }
197    }
198
199    private SolutionsCreator SolutionsCreator {
200      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
201    }
202
203    #endregion
204
205    #region Preconfigured Terminators
206
207    [Storable] private readonly ComparisonTerminator<IntValue> generationsTerminator;
208    [Storable] private readonly ComparisonTerminator<IntValue> evaluationsTerminator;
209    [Storable] private readonly SingleObjectiveQualityTerminator qualityTerminator;
210    [Storable] private readonly ExecutionTimeTerminator executionTimeTerminator;
211
212    #endregion
213
214    #region Preconfigured Analyzers
215
216    [Storable] private readonly BestAverageWorstQualityAnalyzer qualityAnalyzer;
217    [Storable] private readonly BestAverageWorstQualityAnalyzer islandQualityAnalyzer;
218    [Storable] private readonly BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
219    [Storable] private readonly BestAverageWorstQualityAnalyzer groupQualityAnalyzer;
220
221    #endregion
222
223    #region Constructors
224
225    [StorableConstructor]
226    private IslandAlpsOffspringSelectionAlgorithm(bool deserializing) : base(deserializing) {}
227
228    [StorableHook(HookType.AfterDeserialization)]
229    private void AfterDeserialization() {
230      InitializeEventHandler();
231    }
232
233    private IslandAlpsOffspringSelectionAlgorithm(IslandAlpsOffspringSelectionAlgorithm original, Cloner cloner)
234      : base(original, cloner) {
235      //clone Properties
236
237      //analyzer
238      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
239      islandQualityAnalyzer = cloner.Clone(original.islandQualityAnalyzer);
240      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
241      groupQualityAnalyzer = cloner.Clone(original.groupQualityAnalyzer);
242      //terminator
243      generationsTerminator = cloner.Clone(original.generationsTerminator);
244      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
245      qualityTerminator = cloner.Clone(original.qualityTerminator);
246      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
247
248      InitializeEventHandler();
249    }
250
251    public IslandAlpsOffspringSelectionAlgorithm() {
252   
253      AddParameters();
254
255      #region create Operators
256
257      var globalRandomCreator = new RandomCreator();
258      var islandLayerCreator = new SubScopesCreator {Name = "Create Islands"};
259      var islandUssp = new UniformSubScopesProcessor();
260      var islandRandomCreator = new LocalRandomCreator();
261      var layerZeroCreator = new SubScopesCreator {Name = "Create Layer 0"};
262      var layerZeroUssp = new UniformSubScopesProcessor();
263      var layerRandomCreator = new LocalRandomCreator();
264      var islandSolutionsCounter = new DataReducer {Name = "Count IslandSolutions"};
265      var layerSolutionCreator = new SolutionsCreator();
266      var ageInitializerUssp = new UniformSubScopesProcessor();
267      var ageInitializerVc = new VariableCreator {Name = "Initialize Age"};
268      var evaluatedSolutionsVc = new VariableCreator {Name = "Create LayerEvaluatedSolutions"};
269      var evaluatedSolutionsCounter = new SubScopesCounter {Name = "Count LayerEvaluatedSolutions"};
270      var globalEvaluatedSolutionsCounter = new DataReducer {Name = "Count GlobalSolutions"};
271      var resultsCollector = new ResultsCollector();
272      var mainLoop = new IslandAlpsOffspringSelectionAlgorithmMainLoop();
273
274      #endregion
275
276      #region Set selectors
277
278      var selectors = ApplicationManager.Manager.GetInstances<ISelector>()
279                                        .Where(s => !(s is IMultiObjectiveSelector))
280                                        .OrderBy(s => Name);
281      foreach (var selector in selectors)
282        SelectorParameter.ValidValues.Add(selector);
283
284      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
285      if (defaultSelector != null) {
286        defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
287        SelectorParameter.Value = defaultSelector;
288      }
289
290      #endregion
291
292      #region Create Analyzers
293      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
294      islandQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
295      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
296      groupQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
297      #endregion
298
299      #region Create terminators
300
301      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
302      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) {Name = "Evaluations"};
303      qualityTerminator = new SingleObjectiveQualityTerminator {Name = "Quality"};
304      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
305
306      #endregion
307
308      #region Operator Graph
309
310      globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
311      globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
312      globalRandomCreator.SetSeedRandomlyParameter.Value = null;
313      globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
314      globalRandomCreator.SeedParameter.Value = null;
315
316      //create islands
317      islandLayerCreator.NumberOfSubScopesParameter.ActualName = NumberOfIslandsParameter.Name;
318
319      islandRandomCreator.GlobalRandomParameter.ActualName = globalRandomCreator.RandomParameter.ActualName;
320      islandRandomCreator.LocalRandomParameter.ActualName = "IslandRandom";
321
322      layerZeroCreator.NumberOfSubScopesParameter.Value = new IntValue(1);
323
324      islandSolutionsCounter.ParameterToReduce.Depth = 1;
325      islandSolutionsCounter.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
326      islandSolutionsCounter.TargetParameter.ActualName = "IslandEvaluatedSolutions";
327      islandSolutionsCounter.ReductionOperation.Value.Value = ReductionOperations.Sum;
328      islandSolutionsCounter.TargetOperation.Value.Value = ReductionOperations.Assign;
329
330      layerRandomCreator.GlobalRandomParameter.ActualName = globalRandomCreator.RandomParameter.ActualName;
331      layerRandomCreator.LocalRandomParameter.ActualName = "LayerRandom";
332
333      layerSolutionCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
334      layerSolutionCreator.ParallelParameter.Value = new BoolValue(true);
335
336      ageInitializerVc.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
337
338      evaluatedSolutionsVc.CollectedValues.Add(new ValueParameter<IntValue>("LayerEvaluatedSolutions", new IntValue(0)));
339
340      evaluatedSolutionsCounter.ValueParameter.ActualName = "LayerEvaluatedSolutions";
341
342      globalEvaluatedSolutionsCounter.ParameterToReduce.Depth = 1;
343      globalEvaluatedSolutionsCounter.ParameterToReduce.ActualName = "IslandEvaluatedSolutions";
344      globalEvaluatedSolutionsCounter.TargetParameter.ActualName = "EvaluatedSolutions";
345      globalEvaluatedSolutionsCounter.ReductionOperation.Value.Value = ReductionOperations.Sum;
346      globalEvaluatedSolutionsCounter.TargetOperation.Value.Value = ReductionOperations.Assign;
347
348      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions"));
349
350      //flow
351      OperatorGraph.InitialOperator = globalRandomCreator;
352      globalRandomCreator.Successor = islandLayerCreator;
353      islandLayerCreator.Successor = islandUssp;
354      islandUssp.Operator = islandRandomCreator;
355      islandRandomCreator.Successor = layerZeroCreator;
356      layerZeroCreator.Successor = layerZeroUssp;
357      layerZeroUssp.Operator = layerRandomCreator;
358      layerRandomCreator.Successor = layerSolutionCreator;
359      layerSolutionCreator.Successor = ageInitializerUssp;
360      ageInitializerUssp.Operator = ageInitializerVc;
361      ageInitializerVc.Successor = null;
362      ageInitializerUssp.Successor = evaluatedSolutionsVc;
363      evaluatedSolutionsVc.Successor = evaluatedSolutionsCounter;
364      evaluatedSolutionsCounter.Successor = null;
365      layerZeroUssp.Successor = islandSolutionsCounter;
366      islandSolutionsCounter.Successor = null;
367      islandUssp.Successor = globalEvaluatedSolutionsCounter;
368      globalEvaluatedSolutionsCounter.Successor = resultsCollector;
369      resultsCollector.Successor = mainLoop;
370
371      #endregion
372
373      #region parametrize
374      UpdateAnalyzers();
375      ParameterizeAnalyzers();
376      ParameterizeSelectors();
377      UpdateTerminators();
378      ParameterizeAgeLimits();
379      ParametrizeMigration();
380
381      #endregion
382
383      InitializeEventHandler();
384    }
385
386    private void AddParameters() {
387      #region ALPSParameter
388
389      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(20)));
390      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)));
391      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});
392      Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
393      Parameters.Add(new ValueParameter<BoolValue>("ReduceToPopulationSize", ".", new BoolValue(true)));
394
395      Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "", new IntValue(10000)));
396      Parameters.Add(new ValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
397      Parameters.Add(new ValueParameter<MultiAnalyzer>("GroupAnalyzer", "The operator used to analyze each layergroup.", new MultiAnalyzer()));
398
399      #endregion
400      #region OS
401
402      Parameters.Add(new FixedValueParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
403      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)));
404      Parameters.Add(new FixedValueParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
405      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)));
406      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)));
407
408      #endregion
409
410      #region IslandParameter
411
412      Parameters.Add(new ValueParameter<IntValue>("NumberOfIslands", "The number of islands.", new IntValue(5)));
413      Parameters.Add(new ValueParameter<PercentValue>("MigrationRate", "How many individuals should migrate.", new PercentValue(0.15)));
414      Parameters.Add(new ValueParameter<IntValue>("MigrationInterval", "The number Generations before a migration occurs.", new IntValue(20)));
415      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
416      Parameters.Add(new ConstrainedValueParameter<IMigrator>("Migrator", "The migration strategy."));
417      Parameters.Add(new ConstrainedValueParameter<ISelector>("EmigrantsSelector", "Selects the individuals that will be migrated."));
418      Parameters.Add(new ConstrainedValueParameter<IReplacer>("ImmigrationReplacer", "Selects the population from the unification of the original population and the immigrants."));
419
420      #endregion
421
422      #region GeneralParameter   
423
424      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
425      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
426      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
427      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
428      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
429      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
430      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
431      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
432      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
433      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});
434      Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
435
436      #endregion
437    }
438
439
440    public override IDeepCloneable Clone(Cloner cloner) {
441      return new IslandAlpsOffspringSelectionAlgorithm(this, cloner);
442    }
443
444    #endregion
445
446    #region events
447
448    protected override void RegisterProblemEvents() {
449      base.RegisterProblemEvents();
450      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
451      if (maximizationParameter != null) maximizationParameter.ValueChanged += MaximizationParameter_ValueChanged;
452    }
453    protected override void DeregisterProblemEvents() {
454      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
455      if (maximizationParameter != null) maximizationParameter.ValueChanged -= MaximizationParameter_ValueChanged;
456      base.DeregisterProblemEvents();
457    }
458
459    protected override void OnProblemChanged() {
460      base.OnProblemChanged();
461      ParameterizeStochasticOperator(Problem.SolutionCreator);
462      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
463      foreach (var op in Problem.Operators.OfType<IOperator>()) {
464        ParameterizeStochasticOperator(op);
465      }
466
467      ParameterizeSolutionsCreator();
468      ParameterizeMainLoop();
469      ParameterizeSelectors();
470      ParameterizeAnalyzers();
471      ParameterizeTerminators();
472      ParameterizeIterationBasedOperators();
473
474      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
475
476      UpdateAnalyzers();
477      UpdateCrossovers();
478      UpdateMutators();
479      UpdateTerminators();
480    }
481
482    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
483      base.Problem_SolutionCreatorChanged(sender, e);
484      ParameterizeStochasticOperator(Problem.SolutionCreator);
485      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
486
487      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
488
489      ParameterizeSolutionsCreator();
490      ParameterizeAnalyzers();
491    }
492
493    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
494      base.Problem_EvaluatorChanged(sender, e);
495
496      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
497      ParameterizeSolutionsCreator();
498      ParameterizeMainLoop();
499      ParameterizeSelectors();
500      ParameterizeAnalyzers();
501      ParameterizeTerminators();
502
503      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
504
505      UpdateAnalyzers();
506      UpdateCrossovers();
507      UpdateMutators();
508      UpdateTerminators();
509    }
510
511    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
512      base.Problem_OperatorsChanged(sender, e);
513      ParameterizeIterationBasedOperators();
514      UpdateCrossovers();
515      UpdateMutators();
516      UpdateAnalyzers();
517      UpdateTerminators();
518    }
519
520    private void InitializeEventHandler() {
521      PopulationSizeParameter.ValueChanged += PopulationSizeParameter_ValueChanged;
522      PopulationSize.ValueChanged += PopulationSize_ValueChanged;
523      ElitesParameter.ValueChanged += ElitesParameter_ValueChanged;
524      Elites.ValueChanged += Elites_ValueChanged;
525      MigrationRateParameter.Value.ValueChanged += MigrationRate_ValueChanged;
526      MigrationRateParameter.ValueChanged += MigrationRate_ValueChanged;
527
528      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
529      IslandAnalyzer.Operators.ItemsAdded += IslandAnalyzerOperators_ItemsAdded;
530      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
531      GroupAnalyzer.Operators.ItemsAdded += GroupAnalyzerOperators_ItemsAdded;
532
533      if (Problem != null) {
534        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
535      }
536
537      AgeGapParameter.ValueChanged += AgeGapParameter_ValueChanged;
538      AgeGap.ValueChanged += AgeGap_ValueChanged;
539      AgingSchemeParameter.ValueChanged += AgingSchemeParameter_ValueChanged;
540      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
541
542      NumberOfLayersParameter.ValueChanged += NumberOfLayersParameter_ValueChanged;
543      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
544      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += QualityAnalyzer_CurrentBestQualityParameter_NameChanged;
545    }
546
547    private void MigrationRate_ValueChanged(object sender, EventArgs e) {
548      var migrationSize = (int)Math.Ceiling(MigrationRateParameter.Value.Value * PopulationSize.Value);
549      foreach (var selector in EmigrantsSelectorParameter.ValidValues) {
550        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(migrationSize);
551      }
552    }
553
554    private void GroupAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
555      foreach (var analyzer in e.Items) {
556        IParameter resultParameter;
557        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
558          var lookupParameter = resultParameter as ILookupParameter;
559          if (lookupParameter != null)
560            lookupParameter.ActualName = "GroupResults";
561        }
562        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
563          parameter.Depth = 1;
564        }
565      }
566    }
567    private void IslandAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
568      foreach (var analyzer in e.Items) {
569        IParameter resultParameter;
570        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
571          var lookupParameter = resultParameter as ILookupParameter;
572          if (lookupParameter != null)
573            lookupParameter.ActualName = "IslandResults";
574        }
575        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
576          parameter.Depth = 2;
577        }
578      }
579    }
580    private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
581      foreach (var analyzer in e.Items) {
582        IParameter resultParameter;
583        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
584          var lookupParameter = resultParameter as ILookupParameter;
585          if (lookupParameter != null)
586            lookupParameter.ActualName = "LayerResults";
587        }
588        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
589          parameter.Depth = 1;
590        }
591      }
592    }
593
594    private void AnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
595      foreach (var analyzer in e.Items) {
596        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
597          parameter.Depth = 3;
598        }
599      }
600    }
601
602    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
603      ParameterizeMainLoop();
604      ParameterizeSelectors();
605      ParameterizeAnalyzers();
606    }
607
608    private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
609      ParameterizeTerminators();
610    }
611    private void QualityAnalyzer_CurrentBestQualityParameter_NameChanged(object sender, EventArgs e) {
612      ParameterizeTerminators();
613    }
614    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
615      ParameterizeSelectors();
616    }
617
618    private void Elites_ValueChanged(object sender, EventArgs e) {
619      ParameterizeSelectors();
620    }
621
622    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
623      ParameterizeSelectors();
624    }
625
626    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
627      ParameterizeSelectors();
628    }
629
630    private void NumberOfLayersParameter_ValueChanged(object sender, EventArgs e) {
631      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
632      ParameterizeAgeLimits();
633    }
634
635    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
636      ParameterizeAgeLimits();
637    }
638
639    private void AgeGapParameter_ValueChanged(object sender, EventArgs e) {
640      AgeGap.ValueChanged += AgeGap_ValueChanged;
641      ParameterizeAgeLimits();
642    }
643
644    private void AgeGap_ValueChanged(object sender, EventArgs e) {
645      ParameterizeAgeLimits();
646    }
647
648    private void AgingSchemeParameter_ValueChanged(object sender, EventArgs e) {
649      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
650      ParameterizeAgeLimits();
651    }
652
653    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
654      ParameterizeAgeLimits();
655    }
656
657    #endregion
658
659    #region Update Functions
660
661    private void UpdateCrossovers() {
662      var oldCrossover = CrossoverParameter.Value;
663      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
664      CrossoverParameter.ValidValues.Clear();
665      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name)) {
666        ParameterizeStochasticOperatorForLayer(crossover);
667        CrossoverParameter.ValidValues.Add(crossover);
668      }
669      if (oldCrossover != null) {
670        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
671        if (crossover != null) CrossoverParameter.Value = crossover;
672        else oldCrossover = null;
673      }
674      if (oldCrossover == null && defaultCrossover != null)
675        CrossoverParameter.Value = defaultCrossover;
676    }
677
678    private void UpdateMutators() {
679      var oldMutator = MutatorParameter.Value;
680      MutatorParameter.ValidValues.Clear();
681      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name)) {
682        ParameterizeStochasticOperatorForLayer(mutator);
683        MutatorParameter.ValidValues.Add(mutator);
684      }
685      if (oldMutator != null) {
686        var mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
687        if (mutator != null) MutatorParameter.Value = mutator;
688      }
689    }
690
691    private void UpdateAnalyzers() {
692      LayerAnalyzer.Operators.Clear();
693      IslandAnalyzer.Operators.Clear();
694      GroupAnalyzer.Operators.Clear();
695      Analyzer.Operators.Clear();
696
697      //add analyzer
698      GroupAnalyzer.Operators.Add(groupQualityAnalyzer, false);
699      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
700      IslandAnalyzer.Operators.Add(islandQualityAnalyzer, false);
701      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
702      //depth for each analyzer gets set when added
703      if (Problem != null) {
704        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
705          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
706          IslandAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
707          LayerAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
708          GroupAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
709        }
710      }
711    }
712
713    private void UpdateTerminators() {
714      var newTerminators = new Dictionary<ITerminator, bool> {
715        {
716          generationsTerminator,
717          !Terminators.Operators.Contains(generationsTerminator) ||
718          Terminators.Operators.ItemChecked(generationsTerminator)
719        }, {
720          evaluationsTerminator,
721          Terminators.Operators.Contains(evaluationsTerminator) &&
722          Terminators.Operators.ItemChecked(evaluationsTerminator)
723        }, {
724          qualityTerminator,
725          Terminators.Operators.Contains(qualityTerminator) && Terminators.Operators.ItemChecked(qualityTerminator)
726        }, {
727          executionTimeTerminator,
728          Terminators.Operators.Contains(executionTimeTerminator) &&
729          Terminators.Operators.ItemChecked(executionTimeTerminator)
730        }
731      };
732      if (Problem != null) {
733        foreach (var terminator in Problem.Operators.OfType<ITerminator>())
734          newTerminators.Add(terminator,
735                             !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
736      }
737
738      Terminators.Operators.Clear();
739
740      foreach (var newTerminator in newTerminators)
741        Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
742    }
743
744    private void ParameterizeAgeLimits() {
745      var scheme = AgingScheme.Value;
746      var ageGap = AgeGap.Value;
747      var numberOfLayers = NumberOfLayers.Value;
748      AgeLimits = scheme.CalculateAgeLimits(ageGap, numberOfLayers);
749    }
750
751    private void ParameterizeMainLoop() {
752      MainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
753      MainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
754      MainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
755      MainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
756      MainLoop.AgeParameter.ActualName = "Age";
757      MainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
758      MainLoop.IslandRandomParameter.ActualName = "IslandRandom";
759      MainLoop.LayerRandomParameter.ActualName = "LayerRandom";
760
761      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
762      MainLoop.LayerEvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
763
764      MainLoop.NumberOfIslandsParameter.ActualName = NumberOfIslandsParameter.Name;
765      MainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
766      MainLoop.MigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
767      MainLoop.MigratorParameter.ActualName = MigratorParameter.Name;
768      MainLoop.EmigrantsSelectorParameter.ActualName = EmigrantsSelectorParameter.Name;
769      MainLoop.ImmigrationReplacerParameter.ActualName = ImmigrationReplacerParameter.Name;
770
771      MainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
772      MainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
773      MainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
774      MainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
775      MainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
776      MainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
777      MainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
778      MainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
779
780      MainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
781      MainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
782      MainLoop.IslandAnalyzerParameter.ActualName = IslandAnalyzerParameter.Name;
783      MainLoop.GroupAnalyzerParameter.ActualName = GroupAnalyzerParameter.Name;
784
785      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
786      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
787
788      MainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
789      MainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
790      MainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
791      MainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
792      //MainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
793    }
794
795    private void ParametrizeMigration() {
796      var migrationSize = (int) Math.Ceiling(MigrationRateParameter.Value.Value*PopulationSize.Value);
797      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name)) {
798        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(migrationSize);
799        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
800
801        ParameterizeStochasticOperatorForLayer(selector);
802
803        EmigrantsSelectorParameter.ValidValues.Add(selector);
804      }
805
806      foreach (var replacer in ApplicationManager.Manager.GetInstances<IReplacer>().OrderBy(x => x.Name)) {
807        ParameterizeStochasticOperatorForLayer(replacer);
808        ImmigrationReplacerParameter.ValidValues.Add(replacer);
809      }
810
811      MigratorParameter.ValidValues.Add(new LayerMigrator());
812    }
813
814    private void ParameterizeSolutionsCreator() {
815      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
816      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
817    }
818
819    private void ParameterizeSelectors() {
820      foreach (var selector in SelectorParameter.ValidValues) {
821        selector.CopySelected = new BoolValue(true);
822        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
823        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
824        ParameterizeStochasticOperatorForLayer(selector);
825      }
826
827      if (Problem != null) {
828        foreach (var selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
829          ParametrizeSingleObjectiveSelector(selector);
830        }
831        foreach (var replacer in EmigrantsSelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
832          ParametrizeSingleObjectiveSelector(replacer);
833        }
834        foreach (var selector in ImmigrationReplacerParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
835          ParametrizeSingleObjectiveSelector(selector);
836        }
837      }
838    }
839
840    private void ParametrizeSingleObjectiveSelector(ISingleObjectiveSelector selector) {
841      selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
842      selector.MaximizationParameter.Hidden = true;
843      selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
844      selector.QualityParameter.Hidden = true;
845    }
846
847    private void ParameterizeAnalyzers() {
848      layerQualityAnalyzer.ResultsParameter.ActualName = "LayerResults";
849      layerQualityAnalyzer.ResultsParameter.Hidden = true;
850
851      islandQualityAnalyzer.ResultsParameter.ActualName = "IslandResults";
852      islandQualityAnalyzer.ResultsParameter.Hidden = true;
853
854      qualityAnalyzer.ResultsParameter.ActualName = "Results";
855      qualityAnalyzer.ResultsParameter.Hidden = true;
856
857      groupQualityAnalyzer.ResultsParameter.ActualName = "GroupResults";
858      groupQualityAnalyzer.ResultsParameter.Hidden = true;
859
860      if (Problem != null) {
861        SetAnalyzerParameter(layerQualityAnalyzer);
862        SetAnalyzerParameter(islandQualityAnalyzer);
863        SetAnalyzerParameter(qualityAnalyzer);
864        SetAnalyzerParameter(groupQualityAnalyzer);
865      }
866    }
867
868    private void SetAnalyzerParameter(BestAverageWorstQualityAnalyzer analyzer) {
869      analyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
870      analyzer.MaximizationParameter.Hidden = true;
871      analyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
872      analyzer.QualityParameter.Hidden = true;
873      analyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
874      analyzer.BestKnownQualityParameter.Hidden = true;
875    }
876
877    private void ParameterizeTerminators() {
878      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
879    }
880
881    private void ParameterizeIterationBasedOperators() {
882      if (Problem != null) {
883        foreach (var op in Problem.Operators.OfType<IIterationBasedOperator>()) {
884          op.IterationsParameter.ActualName = "Generations";
885          op.IterationsParameter.Hidden = true;
886          op.MaximumIterationsParameter.ActualName = generationsTerminator.ThresholdParameter.Name;
887          op.MaximumIterationsParameter.Hidden = true;
888        }
889      }
890    }
891
892    private void ParameterizeStochasticOperator(IOperator op) {
893      var stochasticOp = op as IStochasticOperator;
894      if (stochasticOp != null) {
895        stochasticOp.RandomParameter.ActualName = "GlobalRandom";
896        stochasticOp.RandomParameter.Hidden = true;
897      }
898    }
899
900    private void ParameterizeStochasticOperatorForLayer(IOperator op) {
901      var stochasticOp = op as IStochasticOperator;
902      if (stochasticOp != null) {
903        stochasticOp.RandomParameter.ActualName = "LayerRandom";
904        stochasticOp.RandomParameter.Hidden = true;
905      }
906    }
907
908    #endregion
909  }
910}
Note: See TracBrowser for help on using the repository browser.