Free cookie consent management tool by TermsFeed Policy Generator

source: branches/Async/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs @ 14710

Last change on this file since 14710 was 13173, checked in by abeham, 9 years ago

#2454: added some acronyms
File size: 37.8 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Linq;
24using HeuristicLab.Analysis;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Data;
28using HeuristicLab.Operators;
29using HeuristicLab.Optimization;
30using HeuristicLab.Optimization.Operators;
31using HeuristicLab.Parameters;
32using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
33using HeuristicLab.PluginInfrastructure;
34using HeuristicLab.Random;
35
36namespace HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm {
37  /// <summary>
38  /// An offspring selection island genetic algorithm.
39  /// </summary>
40  [Item("Island Offspring Selection Genetic Algorithm (Island-OSGA)", "An island offspring selection genetic algorithm.")]
41  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 130)]
42  [StorableClass]
43  public sealed class IslandOffspringSelectionGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
44    public string Filename { get; set; }
45
46    #region Problem Properties
47    public override Type ProblemType {
48      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
49    }
50    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
51      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
52      set { base.Problem = value; }
53    }
54    #endregion
55
56    #region Parameter Properties
57    private ValueParameter<IntValue> SeedParameter {
58      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
59    }
60    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
61      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
62    }
63    private ValueParameter<IntValue> NumberOfIslandsParameter {
64      get { return (ValueParameter<IntValue>)Parameters["NumberOfIslands"]; }
65    }
66    private ValueParameter<IntValue> MigrationIntervalParameter {
67      get { return (ValueParameter<IntValue>)Parameters["MigrationInterval"]; }
68    }
69    private ValueParameter<PercentValue> MigrationRateParameter {
70      get { return (ValueParameter<PercentValue>)Parameters["MigrationRate"]; }
71    }
72    public IConstrainedValueParameter<IMigrator> MigratorParameter {
73      get { return (IConstrainedValueParameter<IMigrator>)Parameters["Migrator"]; }
74    }
75    public IConstrainedValueParameter<ISelector> EmigrantsSelectorParameter {
76      get { return (IConstrainedValueParameter<ISelector>)Parameters["EmigrantsSelector"]; }
77    }
78    public IConstrainedValueParameter<IReplacer> ImmigrationReplacerParameter {
79      get { return (IConstrainedValueParameter<IReplacer>)Parameters["ImmigrationReplacer"]; }
80    }
81    private ValueParameter<IntValue> PopulationSizeParameter {
82      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
83    }
84    private ValueParameter<IntValue> MaximumGenerationsParameter {
85      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
86    }
87    public IConstrainedValueParameter<ISelector> SelectorParameter {
88      get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
89    }
90    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
91      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
92    }
93    private ValueParameter<PercentValue> MutationProbabilityParameter {
94      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
95    }
96    public IConstrainedValueParameter<IManipulator> MutatorParameter {
97      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
98    }
99    private ValueParameter<IntValue> ElitesParameter {
100      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
101    }
102    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
103      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
104    }
105    private ValueLookupParameter<DoubleValue> SuccessRatioParameter {
106      get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
107    }
108    private ValueLookupParameter<DoubleValue> ComparisonFactorLowerBoundParameter {
109      get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorLowerBound"]; }
110    }
111    private ValueLookupParameter<DoubleValue> ComparisonFactorUpperBoundParameter {
112      get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorUpperBound"]; }
113    }
114    public IConstrainedValueParameter<IDiscreteDoubleValueModifier> ComparisonFactorModifierParameter {
115      get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["ComparisonFactorModifier"]; }
116    }
117    private ValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
118      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
119    }
120    private ValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
121      get { return (ValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
122    }
123    private ValueLookupParameter<IntValue> SelectedParentsParameter {
124      get { return (ValueLookupParameter<IntValue>)Parameters["SelectedParents"]; }
125    }
126    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
127      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
128    }
129    private ValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
130      get { return (ValueParameter<MultiAnalyzer>)Parameters["IslandAnalyzer"]; }
131    }
132    private ValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
133      get { return (ValueParameter<IntValue>)Parameters["MaximumEvaluatedSolutions"]; }
134    }
135    private IFixedValueParameter<BoolValue> FillPopulationWithParentsParameter {
136      get { return (IFixedValueParameter<BoolValue>)Parameters["FillPopulationWithParents"]; }
137    }
138    #endregion
139
140    #region Properties
141    public IntValue Seed {
142      get { return SeedParameter.Value; }
143      set { SeedParameter.Value = value; }
144    }
145    public BoolValue SetSeedRandomly {
146      get { return SetSeedRandomlyParameter.Value; }
147      set { SetSeedRandomlyParameter.Value = value; }
148    }
149    public IntValue NumberOfIslands {
150      get { return NumberOfIslandsParameter.Value; }
151      set { NumberOfIslandsParameter.Value = value; }
152    }
153    public IntValue MigrationInterval {
154      get { return MigrationIntervalParameter.Value; }
155      set { MigrationIntervalParameter.Value = value; }
156    }
157    public PercentValue MigrationRate {
158      get { return MigrationRateParameter.Value; }
159      set { MigrationRateParameter.Value = value; }
160    }
161    public IMigrator Migrator {
162      get { return MigratorParameter.Value; }
163      set { MigratorParameter.Value = value; }
164    }
165    public ISelector EmigrantsSelector {
166      get { return EmigrantsSelectorParameter.Value; }
167      set { EmigrantsSelectorParameter.Value = value; }
168    }
169    public IReplacer ImmigrationReplacer {
170      get { return ImmigrationReplacerParameter.Value; }
171      set { ImmigrationReplacerParameter.Value = value; }
172    }
173    public IntValue PopulationSize {
174      get { return PopulationSizeParameter.Value; }
175      set { PopulationSizeParameter.Value = value; }
176    }
177    public IntValue MaximumGenerations {
178      get { return MaximumGenerationsParameter.Value; }
179      set { MaximumGenerationsParameter.Value = value; }
180    }
181    public ISelector Selector {
182      get { return SelectorParameter.Value; }
183      set { SelectorParameter.Value = value; }
184    }
185    public ICrossover Crossover {
186      get { return CrossoverParameter.Value; }
187      set { CrossoverParameter.Value = value; }
188    }
189    public PercentValue MutationProbability {
190      get { return MutationProbabilityParameter.Value; }
191      set { MutationProbabilityParameter.Value = value; }
192    }
193    public IManipulator Mutator {
194      get { return MutatorParameter.Value; }
195      set { MutatorParameter.Value = value; }
196    }
197    public IntValue Elites {
198      get { return ElitesParameter.Value; }
199      set { ElitesParameter.Value = value; }
200    }
201    public bool ReevaluteElites {
202      get { return ReevaluateElitesParameter.Value.Value; }
203      set { ReevaluateElitesParameter.Value.Value = value; }
204    }
205    public DoubleValue SuccessRatio {
206      get { return SuccessRatioParameter.Value; }
207      set { SuccessRatioParameter.Value = value; }
208    }
209    public DoubleValue ComparisonFactorLowerBound {
210      get { return ComparisonFactorLowerBoundParameter.Value; }
211      set { ComparisonFactorLowerBoundParameter.Value = value; }
212    }
213    public DoubleValue ComparisonFactorUpperBound {
214      get { return ComparisonFactorUpperBoundParameter.Value; }
215      set { ComparisonFactorUpperBoundParameter.Value = value; }
216    }
217    public IDiscreteDoubleValueModifier ComparisonFactorModifier {
218      get { return ComparisonFactorModifierParameter.Value; }
219      set { ComparisonFactorModifierParameter.Value = value; }
220    }
221    public DoubleValue MaximumSelectionPressure {
222      get { return MaximumSelectionPressureParameter.Value; }
223      set { MaximumSelectionPressureParameter.Value = value; }
224    }
225    public BoolValue OffspringSelectionBeforeMutation {
226      get { return OffspringSelectionBeforeMutationParameter.Value; }
227      set { OffspringSelectionBeforeMutationParameter.Value = value; }
228    }
229    public MultiAnalyzer Analyzer {
230      get { return AnalyzerParameter.Value; }
231      set { AnalyzerParameter.Value = value; }
232    }
233    public MultiAnalyzer IslandAnalyzer {
234      get { return IslandAnalyzerParameter.Value; }
235      set { IslandAnalyzerParameter.Value = value; }
236    }
237    public IntValue MaximumEvaluatedSolutions {
238      get { return MaximumEvaluatedSolutionsParameter.Value; }
239      set { MaximumEvaluatedSolutionsParameter.Value = value; }
240    }
241    public bool FillPopulationWithParents {
242      get { return FillPopulationWithParentsParameter.Value.Value; }
243      set { FillPopulationWithParentsParameter.Value.Value = value; }
244    }
245    private RandomCreator RandomCreator {
246      get { return (RandomCreator)OperatorGraph.InitialOperator; }
247    }
248    private UniformSubScopesProcessor IslandProcessor {
249      get { return ((RandomCreator.Successor as SubScopesCreator).Successor as UniformSubScopesProcessor); }
250    }
251    private SolutionsCreator SolutionsCreator {
252      get { return (SolutionsCreator)IslandProcessor.Operator; }
253    }
254    private IslandOffspringSelectionGeneticAlgorithmMainLoop MainLoop {
255      get { return FindMainLoop(IslandProcessor.Successor); }
256    }
257    [Storable]
258    private BestAverageWorstQualityAnalyzer islandQualityAnalyzer;
259    [Storable]
260    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
261    [Storable]
262    private ValueAnalyzer islandSelectionPressureAnalyzer;
263    [Storable]
264    private ValueAnalyzer selectionPressureAnalyzer;
265    [Storable]
266    private SuccessfulOffspringAnalyzer successfulOffspringAnalyzer;
267    #endregion
268
269    [StorableConstructor]
270    private IslandOffspringSelectionGeneticAlgorithm(bool deserializing) : base(deserializing) { }
271    [StorableHook(HookType.AfterDeserialization)]
272    private void AfterDeserialization() {
273      // BackwardsCompatibility3.3
274      #region Backwards compatible code, remove with 3.4
275      if (successfulOffspringAnalyzer == null)
276        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
277      if (!Parameters.ContainsKey("ReevaluateElites")) {
278        Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", (BoolValue)new BoolValue(false).AsReadOnly()) { Hidden = true });
279      }
280      if (!Parameters.ContainsKey("FillPopulationWithParents"))
281        Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false)) { Hidden = true });
282      #endregion
283
284      Initialize();
285    }
286    private IslandOffspringSelectionGeneticAlgorithm(IslandOffspringSelectionGeneticAlgorithm original, Cloner cloner)
287      : base(original, cloner) {
288      islandQualityAnalyzer = cloner.Clone(original.islandQualityAnalyzer);
289      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
290      islandSelectionPressureAnalyzer = cloner.Clone(original.islandSelectionPressureAnalyzer);
291      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
292      successfulOffspringAnalyzer = cloner.Clone(original.successfulOffspringAnalyzer);
293      Initialize();
294    }
295    public override IDeepCloneable Clone(Cloner cloner) {
296      return new IslandOffspringSelectionGeneticAlgorithm(this, cloner);
297    }
298    public IslandOffspringSelectionGeneticAlgorithm()
299      : base() {
300      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
301      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
302      Parameters.Add(new ValueParameter<IntValue>("NumberOfIslands", "The number of islands.", new IntValue(5)));
303      Parameters.Add(new ValueParameter<IntValue>("MigrationInterval", "The number of generations that should pass between migration phases.", new IntValue(20)));
304      Parameters.Add(new ValueParameter<PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands.", new PercentValue(0.15)));
305      Parameters.Add(new ConstrainedValueParameter<IMigrator>("Migrator", "The migration strategy."));
306      Parameters.Add(new ConstrainedValueParameter<ISelector>("EmigrantsSelector", "Selects the individuals that will be migrated."));
307      Parameters.Add(new ConstrainedValueParameter<IReplacer>("ImmigrationReplacer", "Replaces part of the original population with the immigrants."));
308      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions of each island.", new IntValue(100)));
309      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations that should be processed.", new IntValue(100)));
310      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
311      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
312      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
313      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
314      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
315      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 });
316      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
317      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorLowerBound", "The lower bound of the comparison factor (start).", new DoubleValue(0)));
318      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorUpperBound", "The upper bound of the comparison factor (end).", new DoubleValue(1)));
319      Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("ComparisonFactorModifier", "The operator used to modify the comparison factor.", new ItemSet<IDiscreteDoubleValueModifier>(new IDiscreteDoubleValueModifier[] { new LinearDiscreteDoubleValueModifier() }), new LinearDiscreteDoubleValueModifier()));
320      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
321      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
322      Parameters.Add(new ValueLookupParameter<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)));
323      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
324      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
325      Parameters.Add(new ValueParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions (approximately).", new IntValue(int.MaxValue)));
326      Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(true)) { Hidden = true });
327
328      RandomCreator randomCreator = new RandomCreator();
329      SubScopesCreator populationCreator = new SubScopesCreator();
330      UniformSubScopesProcessor ussp1 = new UniformSubScopesProcessor();
331      SolutionsCreator solutionsCreator = new SolutionsCreator();
332      VariableCreator variableCreator = new VariableCreator();
333      UniformSubScopesProcessor ussp2 = new UniformSubScopesProcessor();
334      SubScopesCounter subScopesCounter = new SubScopesCounter();
335      ResultsCollector resultsCollector = new ResultsCollector();
336      IslandOffspringSelectionGeneticAlgorithmMainLoop mainLoop = new IslandOffspringSelectionGeneticAlgorithmMainLoop();
337      OperatorGraph.InitialOperator = randomCreator;
338
339      randomCreator.RandomParameter.ActualName = "Random";
340      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
341      randomCreator.SeedParameter.Value = null;
342      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
343      randomCreator.SetSeedRandomlyParameter.Value = null;
344      randomCreator.Successor = populationCreator;
345
346      populationCreator.NumberOfSubScopesParameter.ActualName = NumberOfIslandsParameter.Name;
347      populationCreator.Successor = ussp1;
348
349      ussp1.Operator = solutionsCreator;
350      ussp1.Successor = variableCreator;
351
352      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
353      solutionsCreator.Successor = null;
354
355      variableCreator.Name = "Initialize EvaluatedSolutions";
356      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue()));
357      variableCreator.Successor = ussp2;
358
359      ussp2.Operator = subScopesCounter;
360      ussp2.Successor = resultsCollector;
361
362      subScopesCounter.Name = "Increment EvaluatedSolutions";
363      subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
364
365      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", "", "EvaluatedSolutions"));
366      resultsCollector.ResultsParameter.ActualName = "Results";
367      resultsCollector.Successor = mainLoop;
368
369      mainLoop.EmigrantsSelectorParameter.ActualName = EmigrantsSelectorParameter.Name;
370      mainLoop.ImmigrationReplacerParameter.ActualName = ImmigrationReplacerParameter.Name;
371      mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
372      mainLoop.MigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
373      mainLoop.MigrationRateParameter.ActualName = MigrationRateParameter.Name;
374      mainLoop.MigratorParameter.ActualName = MigratorParameter.Name;
375      mainLoop.NumberOfIslandsParameter.ActualName = NumberOfIslandsParameter.Name;
376      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
377      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
378      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
379      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
380      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
381      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
382      mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
383      mainLoop.ResultsParameter.ActualName = "Results";
384      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
385      mainLoop.ComparisonFactorParameter.ActualName = "ComparisonFactor";
386      mainLoop.ComparisonFactorStartParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
387      mainLoop.ComparisonFactorModifierParameter.ActualName = ComparisonFactorModifierParameter.Name;
388      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
389      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
390      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
391      mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
392      mainLoop.Successor = null;
393
394      foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
395        SelectorParameter.ValidValues.Add(selector);
396      ISelector proportionalSelector = SelectorParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("ProportionalSelector"));
397      if (proportionalSelector != null) SelectorParameter.Value = proportionalSelector;
398
399      foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
400        EmigrantsSelectorParameter.ValidValues.Add(selector);
401
402      foreach (IReplacer replacer in ApplicationManager.Manager.GetInstances<IReplacer>().OrderBy(x => x.Name))
403        ImmigrationReplacerParameter.ValidValues.Add(replacer);
404
405      ParameterizeSelectors();
406
407      foreach (IMigrator migrator in ApplicationManager.Manager.GetInstances<IMigrator>().OrderBy(x => x.Name)) {
408        // BackwardsCompatibility3.3
409        // Set the migration direction to counterclockwise
410        var unidirectionalRing = migrator as UnidirectionalRingMigrator;
411        if (unidirectionalRing != null) unidirectionalRing.ClockwiseMigrationParameter.Value = new BoolValue(false);
412        MigratorParameter.ValidValues.Add(migrator);
413      }
414
415      foreach (IDiscreteDoubleValueModifier modifier in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
416        ComparisonFactorModifierParameter.ValidValues.Add(modifier);
417      IDiscreteDoubleValueModifier linearModifier = ComparisonFactorModifierParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("LinearDiscreteDoubleValueModifier"));
418      if (linearModifier != null) ComparisonFactorModifierParameter.Value = linearModifier;
419      ParameterizeComparisonFactorModifiers();
420
421      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
422      islandQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
423      selectionPressureAnalyzer = new ValueAnalyzer();
424      islandSelectionPressureAnalyzer = new ValueAnalyzer();
425      successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
426      ParameterizeAnalyzers();
427      UpdateAnalyzers();
428
429      Initialize();
430    }
431    public override void Prepare() {
432      if (Problem != null) base.Prepare();
433    }
434
435    #region Events
436    protected override void OnProblemChanged() {
437      ParameterizeStochasticOperator(Problem.SolutionCreator);
438      ParameterizeStochasticOperator(Problem.Evaluator);
439      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
440      ParameterizeSolutionsCreator();
441      ParameterizeMainLoop();
442      ParameterizeSelectors();
443      ParameterizeAnalyzers();
444      ParameterizeIterationBasedOperators();
445      UpdateCrossovers();
446      UpdateMutators();
447      UpdateAnalyzers();
448      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
449      base.OnProblemChanged();
450    }
451
452    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
453      ParameterizeStochasticOperator(Problem.SolutionCreator);
454      ParameterizeSolutionsCreator();
455      base.Problem_SolutionCreatorChanged(sender, e);
456    }
457    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
458      ParameterizeStochasticOperator(Problem.Evaluator);
459      ParameterizeSolutionsCreator();
460      ParameterizeMainLoop();
461      ParameterizeSelectors();
462      ParameterizeAnalyzers();
463      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
464      base.Problem_EvaluatorChanged(sender, e);
465    }
466    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
467      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
468      ParameterizeIterationBasedOperators();
469      UpdateCrossovers();
470      UpdateMutators();
471      UpdateAnalyzers();
472      base.Problem_OperatorsChanged(sender, e);
473    }
474    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
475      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
476      ParameterizeSelectors();
477    }
478    private void Elites_ValueChanged(object sender, EventArgs e) {
479      ParameterizeSelectors();
480    }
481    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
482      NumberOfIslands.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
483      ParameterizeSelectors();
484    }
485    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
486      ParameterizeSelectors();
487    }
488    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
489      ParameterizeMainLoop();
490      ParameterizeSelectors();
491      ParameterizeAnalyzers();
492    }
493    private void MigrationRateParameter_ValueChanged(object sender, EventArgs e) {
494      MigrationRate.ValueChanged += new EventHandler(MigrationRate_ValueChanged);
495      ParameterizeSelectors();
496    }
497    private void MigrationRate_ValueChanged(object sender, EventArgs e) {
498      ParameterizeSelectors();
499    }
500    private void MaximumMigrationsParameter_ValueChanged(object sender, EventArgs e) {
501      MaximumGenerations.ValueChanged += new EventHandler(MaximumMigrations_ValueChanged);
502      ParameterizeComparisonFactorModifiers();
503    }
504    private void MaximumMigrations_ValueChanged(object sender, EventArgs e) {
505      ParameterizeComparisonFactorModifiers();
506    }
507    private void MigrationIntervalParameter_ValueChanged(object sender, EventArgs e) {
508      MigrationInterval.ValueChanged += new EventHandler(MigrationInterval_ValueChanged);
509      ParameterizeComparisonFactorModifiers();
510    }
511    private void MigrationInterval_ValueChanged(object sender, EventArgs e) {
512      ParameterizeComparisonFactorModifiers();
513    }
514    #endregion
515
516    #region Helpers
517    private void Initialize() {
518      PopulationSizeParameter.ValueChanged += new EventHandler(PopulationSizeParameter_ValueChanged);
519      PopulationSize.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
520      MigrationRateParameter.ValueChanged += new EventHandler(MigrationRateParameter_ValueChanged);
521      MigrationRate.ValueChanged += new EventHandler(MigrationRate_ValueChanged);
522      ElitesParameter.ValueChanged += new EventHandler(ElitesParameter_ValueChanged);
523      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
524      MigrationIntervalParameter.ValueChanged += new EventHandler(MigrationIntervalParameter_ValueChanged);
525      MigrationInterval.ValueChanged += new EventHandler(MigrationInterval_ValueChanged);
526      MaximumGenerationsParameter.ValueChanged += new EventHandler(MaximumMigrationsParameter_ValueChanged);
527      MaximumGenerations.ValueChanged += new EventHandler(MaximumMigrations_ValueChanged);
528      if (Problem != null) {
529        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
530      }
531    }
532    private void ParameterizeSolutionsCreator() {
533      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
534      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
535    }
536    private void ParameterizeMainLoop() {
537      MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
538      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
539      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
540      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
541    }
542    private void ParameterizeStochasticOperator(IOperator op) {
543      if (op is IStochasticOperator)
544        ((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
545    }
546    private void ParameterizeSelectors() {
547      foreach (ISelector selector in SelectorParameter.ValidValues) {
548        selector.CopySelected = new BoolValue(true);
549        selector.NumberOfSelectedSubScopesParameter.Value = null;
550        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
551        ParameterizeStochasticOperator(selector);
552      }
553      foreach (ISelector selector in EmigrantsSelectorParameter.ValidValues) {
554        selector.CopySelected = new BoolValue(true);
555        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue((int)Math.Ceiling(PopulationSize.Value * MigrationRate.Value));
556        ParameterizeStochasticOperator(selector);
557      }
558      foreach (IReplacer selector in ImmigrationReplacerParameter.ValidValues) {
559        ParameterizeStochasticOperator(selector);
560      }
561      if (Problem != null) {
562        foreach (ISingleObjectiveSelector selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
563          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
564          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
565        }
566        foreach (ISingleObjectiveSelector selector in EmigrantsSelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
567          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
568          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
569        }
570        foreach (ISingleObjectiveReplacer replacer in ImmigrationReplacerParameter.ValidValues.OfType<ISingleObjectiveReplacer>()) {
571          replacer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
572          replacer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
573        }
574      }
575    }
576    private void ParameterizeAnalyzers() {
577      islandQualityAnalyzer.ResultsParameter.ActualName = "Results";
578      islandQualityAnalyzer.QualityParameter.Depth = 1;
579      qualityAnalyzer.ResultsParameter.ActualName = "Results";
580      qualityAnalyzer.QualityParameter.Depth = 2;
581
582      islandSelectionPressureAnalyzer.ResultsParameter.ActualName = "Results";
583      islandSelectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
584      islandSelectionPressureAnalyzer.ValueParameter.Depth = 0;
585      islandSelectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
586      islandSelectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
587
588      selectionPressureAnalyzer.ResultsParameter.ActualName = "Results";
589      selectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
590      selectionPressureAnalyzer.ValueParameter.Depth = 1;
591      selectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
592      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
593
594      successfulOffspringAnalyzer.ResultsParameter.ActualName = "Results";
595      successfulOffspringAnalyzer.GenerationsParameter.ActualName = "Generations";
596      successfulOffspringAnalyzer.SuccessfulOffspringFlagParameter.Value.Value = "SuccessfulOffspring";
597      successfulOffspringAnalyzer.DepthParameter.Value = new IntValue(2);
598
599      if (Problem != null) {
600        islandQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
601        islandQualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
602        islandQualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
603
604        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
605        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
606        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
607      }
608    }
609    private void ParameterizeComparisonFactorModifiers() {
610      foreach (IDiscreteDoubleValueModifier modifier in ComparisonFactorModifierParameter.ValidValues) {
611        modifier.IndexParameter.ActualName = "Generations";
612        modifier.EndIndexParameter.Value = new IntValue(MigrationInterval.Value * MaximumGenerations.Value);
613        modifier.EndValueParameter.ActualName = ComparisonFactorUpperBoundParameter.Name;
614        modifier.StartIndexParameter.Value = new IntValue(0);
615        modifier.StartValueParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
616        modifier.ValueParameter.ActualName = "ComparisonFactor";
617      }
618    }
619    private void ParameterizeIterationBasedOperators() {
620      if (Problem != null) {
621        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
622          op.IterationsParameter.ActualName = "Generations";
623          op.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
624        }
625      }
626    }
627    private void UpdateCrossovers() {
628      ICrossover oldCrossover = CrossoverParameter.Value;
629      ICrossover defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
630      CrossoverParameter.ValidValues.Clear();
631      foreach (ICrossover crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name))
632        CrossoverParameter.ValidValues.Add(crossover);
633      if (oldCrossover != null) {
634        ICrossover crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
635        if (crossover != null) CrossoverParameter.Value = crossover;
636        else oldCrossover = null;
637      }
638      if (oldCrossover == null && defaultCrossover != null)
639        CrossoverParameter.Value = defaultCrossover;
640    }
641    private void UpdateMutators() {
642      IManipulator oldMutator = MutatorParameter.Value;
643      MutatorParameter.ValidValues.Clear();
644      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name))
645        MutatorParameter.ValidValues.Add(mutator);
646      if (oldMutator != null) {
647        IManipulator mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
648        if (mutator != null) MutatorParameter.Value = mutator;
649      }
650    }
651    private void UpdateAnalyzers() {
652      IslandAnalyzer.Operators.Clear();
653      Analyzer.Operators.Clear();
654      IslandAnalyzer.Operators.Add(islandQualityAnalyzer, islandQualityAnalyzer.EnabledByDefault);
655      IslandAnalyzer.Operators.Add(islandSelectionPressureAnalyzer, islandSelectionPressureAnalyzer.EnabledByDefault);
656      if (Problem != null) {
657        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
658          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
659            param.Depth = 2;
660          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
661        }
662      }
663      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
664      Analyzer.Operators.Add(selectionPressureAnalyzer, selectionPressureAnalyzer.EnabledByDefault);
665      Analyzer.Operators.Add(successfulOffspringAnalyzer, successfulOffspringAnalyzer.EnabledByDefault);
666    }
667    private IslandOffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {
668      IOperator mainLoop = start;
669      while (mainLoop != null && !(mainLoop is IslandOffspringSelectionGeneticAlgorithmMainLoop))
670        mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
671      if (mainLoop == null) return null;
672      else return (IslandOffspringSelectionGeneticAlgorithmMainLoop)mainLoop;
673    }
674    #endregion
675  }
676}
Note: See TracBrowser for help on using the repository browser.