Free cookie consent management tool by TermsFeed Policy Generator

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

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

#2558 migration bug fixed, hopefully
File size: 43.4 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      ParametrizeMigration();
549    }
550
551    private void GroupAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
552      foreach (var analyzer in e.Items) {
553        IParameter resultParameter;
554        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
555          var lookupParameter = resultParameter as ILookupParameter;
556          if (lookupParameter != null)
557            lookupParameter.ActualName = "GroupResults";
558        }
559        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
560          parameter.Depth = 1;
561        }
562      }
563    }
564    private void IslandAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
565      foreach (var analyzer in e.Items) {
566        IParameter resultParameter;
567        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
568          var lookupParameter = resultParameter as ILookupParameter;
569          if (lookupParameter != null)
570            lookupParameter.ActualName = "IslandResults";
571        }
572        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
573          parameter.Depth = 2;
574        }
575      }
576    }
577    private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
578      foreach (var analyzer in e.Items) {
579        IParameter resultParameter;
580        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
581          var lookupParameter = resultParameter as ILookupParameter;
582          if (lookupParameter != null)
583            lookupParameter.ActualName = "LayerResults";
584        }
585        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
586          parameter.Depth = 1;
587        }
588      }
589    }
590
591    private void AnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
592      foreach (var analyzer in e.Items) {
593        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
594          parameter.Depth = 3;
595        }
596      }
597    }
598
599    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
600      ParameterizeMainLoop();
601      ParameterizeSelectors();
602      ParameterizeAnalyzers();
603    }
604
605    private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
606      ParameterizeTerminators();
607    }
608    private void QualityAnalyzer_CurrentBestQualityParameter_NameChanged(object sender, EventArgs e) {
609      ParameterizeTerminators();
610    }
611    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
612      ParameterizeSelectors();
613    }
614
615    private void Elites_ValueChanged(object sender, EventArgs e) {
616      ParameterizeSelectors();
617    }
618
619    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
620      ParameterizeSelectors();
621    }
622
623    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
624      ParameterizeSelectors();
625      ParametrizeMigration();
626    }
627
628    private void NumberOfLayersParameter_ValueChanged(object sender, EventArgs e) {
629      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
630      ParameterizeAgeLimits();
631    }
632
633    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
634      ParameterizeAgeLimits();
635    }
636
637    private void AgeGapParameter_ValueChanged(object sender, EventArgs e) {
638      AgeGap.ValueChanged += AgeGap_ValueChanged;
639      ParameterizeAgeLimits();
640    }
641
642    private void AgeGap_ValueChanged(object sender, EventArgs e) {
643      ParameterizeAgeLimits();
644    }
645
646    private void AgingSchemeParameter_ValueChanged(object sender, EventArgs e) {
647      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
648      ParameterizeAgeLimits();
649    }
650
651    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
652      ParameterizeAgeLimits();
653    }
654
655    #endregion
656
657    #region Update Functions
658
659    private void UpdateCrossovers() {
660      var oldCrossover = CrossoverParameter.Value;
661      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
662      CrossoverParameter.ValidValues.Clear();
663      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name)) {
664        ParameterizeStochasticOperatorForLayer(crossover);
665        CrossoverParameter.ValidValues.Add(crossover);
666      }
667      if (oldCrossover != null) {
668        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
669        if (crossover != null) CrossoverParameter.Value = crossover;
670        else oldCrossover = null;
671      }
672      if (oldCrossover == null && defaultCrossover != null)
673        CrossoverParameter.Value = defaultCrossover;
674    }
675
676    private void UpdateMutators() {
677      var oldMutator = MutatorParameter.Value;
678      MutatorParameter.ValidValues.Clear();
679      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name)) {
680        ParameterizeStochasticOperatorForLayer(mutator);
681        MutatorParameter.ValidValues.Add(mutator);
682      }
683      if (oldMutator != null) {
684        var mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
685        if (mutator != null) MutatorParameter.Value = mutator;
686      }
687    }
688
689    private void UpdateAnalyzers() {
690      LayerAnalyzer.Operators.Clear();
691      IslandAnalyzer.Operators.Clear();
692      GroupAnalyzer.Operators.Clear();
693      Analyzer.Operators.Clear();
694
695      //add analyzer
696      GroupAnalyzer.Operators.Add(groupQualityAnalyzer, false);
697      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
698      IslandAnalyzer.Operators.Add(islandQualityAnalyzer, false);
699      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
700      //depth for each analyzer gets set when added
701      if (Problem != null) {
702        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
703          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
704          IslandAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
705          LayerAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
706          GroupAnalyzer.Operators.Add((IAnalyzer) analyzer.Clone(), false);
707        }
708      }
709    }
710
711    private void UpdateTerminators() {
712      var newTerminators = new Dictionary<ITerminator, bool> {
713        {
714          generationsTerminator,
715          !Terminators.Operators.Contains(generationsTerminator) ||
716          Terminators.Operators.ItemChecked(generationsTerminator)
717        }, {
718          evaluationsTerminator,
719          Terminators.Operators.Contains(evaluationsTerminator) &&
720          Terminators.Operators.ItemChecked(evaluationsTerminator)
721        }, {
722          qualityTerminator,
723          Terminators.Operators.Contains(qualityTerminator) && Terminators.Operators.ItemChecked(qualityTerminator)
724        }, {
725          executionTimeTerminator,
726          Terminators.Operators.Contains(executionTimeTerminator) &&
727          Terminators.Operators.ItemChecked(executionTimeTerminator)
728        }
729      };
730      if (Problem != null) {
731        foreach (var terminator in Problem.Operators.OfType<ITerminator>())
732          newTerminators.Add(terminator,
733                             !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
734      }
735
736      Terminators.Operators.Clear();
737
738      foreach (var newTerminator in newTerminators)
739        Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
740    }
741
742    private void ParameterizeAgeLimits() {
743      var scheme = AgingScheme.Value;
744      var ageGap = AgeGap.Value;
745      var numberOfLayers = NumberOfLayers.Value;
746      AgeLimits = scheme.CalculateAgeLimits(ageGap, numberOfLayers);
747    }
748
749    private void ParameterizeMainLoop() {
750      MainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
751      MainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
752      MainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
753      MainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
754      MainLoop.AgeParameter.ActualName = "Age";
755      MainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
756      MainLoop.IslandRandomParameter.ActualName = "IslandRandom";
757      MainLoop.LayerRandomParameter.ActualName = "LayerRandom";
758
759      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
760      MainLoop.LayerEvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
761
762      MainLoop.NumberOfIslandsParameter.ActualName = NumberOfIslandsParameter.Name;
763      MainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
764      MainLoop.MigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
765      MainLoop.MigratorParameter.ActualName = MigratorParameter.Name;
766      MainLoop.EmigrantsSelectorParameter.ActualName = EmigrantsSelectorParameter.Name;
767      MainLoop.ImmigrationReplacerParameter.ActualName = ImmigrationReplacerParameter.Name;
768
769      MainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
770      MainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
771      MainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
772      MainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
773      MainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
774      MainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
775      MainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
776      MainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
777
778      MainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
779      MainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
780      MainLoop.IslandAnalyzerParameter.ActualName = IslandAnalyzerParameter.Name;
781      MainLoop.GroupAnalyzerParameter.ActualName = GroupAnalyzerParameter.Name;
782
783      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
784      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
785
786      MainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
787      MainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
788      MainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
789      MainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
790      //MainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
791    }
792
793    private void ParametrizeMigration() {
794      var migrationSize = (int) Math.Ceiling(MigrationRateParameter.Value.Value*PopulationSize.Value);
795      EmigrantsSelectorParameter.ValidValues.Clear();
796      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name)) {
797        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(migrationSize);
798        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
799
800        ParameterizeStochasticOperatorForLayer(selector);
801
802        EmigrantsSelectorParameter.ValidValues.Add(selector);
803      }
804
805      ImmigrationReplacerParameter.ValidValues.Clear();
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.Clear();
812      MigratorParameter.ValidValues.Add(new LayerMigrator());
813    }
814
815    private void ParameterizeSolutionsCreator() {
816      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
817      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
818    }
819
820    private void ParameterizeSelectors() {
821      foreach (var selector in SelectorParameter.ValidValues) {
822        selector.CopySelected = new BoolValue(true);
823        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
824        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
825        ParameterizeStochasticOperatorForLayer(selector);
826      }
827
828      if (Problem != null) {
829        foreach (var selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
830          ParametrizeSingleObjectiveSelector(selector);
831        }
832        foreach (var replacer in EmigrantsSelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
833          ParametrizeSingleObjectiveSelector(replacer);
834        }
835        foreach (var selector in ImmigrationReplacerParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
836          ParametrizeSingleObjectiveSelector(selector);
837        }
838      }
839    }
840
841    private void ParametrizeSingleObjectiveSelector(ISingleObjectiveSelector selector) {
842      selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
843      selector.MaximizationParameter.Hidden = true;
844      selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
845      selector.QualityParameter.Hidden = true;
846    }
847
848    private void ParameterizeAnalyzers() {
849      layerQualityAnalyzer.ResultsParameter.ActualName = "LayerResults";
850      layerQualityAnalyzer.ResultsParameter.Hidden = true;
851
852      islandQualityAnalyzer.ResultsParameter.ActualName = "IslandResults";
853      islandQualityAnalyzer.ResultsParameter.Hidden = true;
854
855      qualityAnalyzer.ResultsParameter.ActualName = "Results";
856      qualityAnalyzer.ResultsParameter.Hidden = true;
857
858      groupQualityAnalyzer.ResultsParameter.ActualName = "GroupResults";
859      groupQualityAnalyzer.ResultsParameter.Hidden = true;
860
861      if (Problem != null) {
862        SetAnalyzerParameter(layerQualityAnalyzer);
863        SetAnalyzerParameter(islandQualityAnalyzer);
864        SetAnalyzerParameter(qualityAnalyzer);
865        SetAnalyzerParameter(groupQualityAnalyzer);
866      }
867    }
868
869    private void SetAnalyzerParameter(BestAverageWorstQualityAnalyzer analyzer) {
870      analyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
871      analyzer.MaximizationParameter.Hidden = true;
872      analyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
873      analyzer.QualityParameter.Hidden = true;
874      analyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
875      analyzer.BestKnownQualityParameter.Hidden = true;
876    }
877
878    private void ParameterizeTerminators() {
879      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
880    }
881
882    private void ParameterizeIterationBasedOperators() {
883      if (Problem != null) {
884        foreach (var op in Problem.Operators.OfType<IIterationBasedOperator>()) {
885          op.IterationsParameter.ActualName = "Generations";
886          op.IterationsParameter.Hidden = true;
887          op.MaximumIterationsParameter.ActualName = generationsTerminator.ThresholdParameter.Name;
888          op.MaximumIterationsParameter.Hidden = true;
889        }
890      }
891    }
892
893    private void ParameterizeStochasticOperator(IOperator op) {
894      var stochasticOp = op as IStochasticOperator;
895      if (stochasticOp != null) {
896        stochasticOp.RandomParameter.ActualName = "GlobalRandom";
897        stochasticOp.RandomParameter.Hidden = true;
898      }
899    }
900
901    private void ParameterizeStochasticOperatorForLayer(IOperator op) {
902      var stochasticOp = op as IStochasticOperator;
903      if (stochasticOp != null) {
904        stochasticOp.RandomParameter.ActualName = "LayerRandom";
905        stochasticOp.RandomParameter.Hidden = true;
906      }
907    }
908
909    #endregion
910  }
911}
Note: See TracBrowser for help on using the repository browser.