Changeset 12993 for branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs

Timestamp:

10/09/15 14:37:18 (9 years ago)

Author:

pfleck

Message:

#2269 Removed Alps base class and integrated the code in AlpsGeneticAlgorithm.

File:

• branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs (modified) (17 diffs)

branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -39 +41 @@
   [Creatable("Algorithms")]
   [StorableClass]
-  public sealed class AlpsGeneticAlgorithm : Alps {
+  public sealed class AlpsGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+    public string Filename { get; set; }
+
+    #region Problem Properties
+    public override Type ProblemType {
+      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
+    }
+    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
+      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      set { base.Problem = value; }
+    }
+    #endregion
+
     #region Parameter Properties
+    private IValueParameter<IntValue> SeedParameter {
+      get { return (IValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private IValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (IValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+
+    private IFixedValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    private IFixedValueParameter<MultiAnalyzer> LayerAnalyzerParameter {
+      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["LayerAnalyzer"]; }
+    }
+
+    private IValueParameter<IntValue> NumberOfLayersParameter {
+      get { return (IValueParameter<IntValue>)Parameters["NumberOfLayers"]; }
+    }
     private IValueParameter<IntValue> PopulationSizeParameter {
       get { return (IValueParameter<IntValue>)Parameters["PopulationSize"]; }
     }
+
     public IConstrainedValueParameter<ISelector> SelectorParameter {
       get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
@@ -50 +82 @@
       get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
     }
+    public IConstrainedValueParameter<IManipulator> MutatorParameter {
+      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
+    }
     private IValueParameter<PercentValue> MutationProbabilityParameter {
       get { return (IValueParameter<PercentValue>)Parameters["MutationProbability"]; }
     }
-    public IConstrainedValueParameter<IManipulator> MutatorParameter {
-      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
-    }
     private IValueParameter<IntValue> ElitesParameter {
       get { return (IValueParameter<IntValue>)Parameters["Elites"]; }
@@ -65 +97 @@
       get { return (IValueParameter<BoolValue>)Parameters["PlusSelection"]; }
     }
+
+    private IValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter {
+      get { return (IValueParameter<EnumValue<AgingScheme>>)Parameters["AgingScheme"]; }
+    }
+    private IValueParameter<IntValue> AgeGapParameter {
+      get { return (IValueParameter<IntValue>)Parameters["AgeGap"]; }
+    }
+    private IValueParameter<EnumValue<AgeInheritance>> AgeInheritanceParameter {
+      get { return (IValueParameter<EnumValue<AgeInheritance>>)Parameters["AgeInheritance"]; }
+    }
+    private IValueParameter<ReductionOperation> AgeInheritanceReductionParameter {
+      get { return (IValueParameter<ReductionOperation>)Parameters["AgeInheritanceReduction"]; }
+    }
+    private IValueParameter<IntArray> AgeLimitsParameter {
+      get { return (IValueParameter<IntArray>)Parameters["AgeLimits"]; }
+    }
+
+    private IValueParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
+    }
+    private IValueParameter<PercentValue> MatingPoolSelectionPercentageParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["MatingPoolSelectionPercentage"]; }
+    }
+
+    private IValueParameter<MultiTerminator> TerminatorParameter {
+      get { return (IValueParameter<MultiTerminator>)Parameters["Terminator"]; }
+    }
     #endregion
 
     #region Properties
+    public IntValue Seed {
+      get { return SeedParameter.Value; }
+      set { SeedParameter.Value = value; }
+    }
+    public BoolValue SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value; }
+      set { SetSeedRandomlyParameter.Value = value; }
+    }
+
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+    }
+    public MultiAnalyzer LayerAnalyzer {
+      get { return LayerAnalyzerParameter.Value; }
+    }
+
+    public IntValue NumberOfLayers {
+      get { return NumberOfLayersParameter.Value; }
+      set { NumberOfLayersParameter.Value = value; }
+    }
     public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
     }
+
+    public ISelector Selector {
+      get { return SelectorParameter.Value; }
+      set { SelectorParameter.Value = value; }
+    }
+    public ICrossover Crossover {
+      get { return CrossoverParameter.Value; }
+      set { CrossoverParameter.Value = value; }
+    }
+    public IManipulator Mutator {
+      get { return MutatorParameter.Value; }
+      set { MutatorParameter.Value = value; }
+    }
+    public PercentValue MutationProbability {
+      get { return MutationProbabilityParameter.Value; }
+      set { MutationProbabilityParameter.Value = value; }
+    }
+    public IntValue Elites {
+      get { return ElitesParameter.Value; }
+      set { ElitesParameter.Value = value; }
+    }
+    public bool ReevaluteElites {
+      get { return ReevaluateElitesParameter.Value.Value; }
+      set { ReevaluateElitesParameter.Value.Value = value; }
+    }
+    public bool PlusSelection {
+      get { return PlusSelectionParameter.Value.Value; }
+      set { PlusSelectionParameter.Value.Value = value; }
+    }
+
+    public EnumValue<AgingScheme> AgingScheme {
+      get { return AgingSchemeParameter.Value; }
+      set { AgingSchemeParameter.Value = value; }
+    }
+    public IntValue AgeGap {
+      get { return AgeGapParameter.Value; }
+      set { AgeGapParameter.Value = value; }
+    }
+    public EnumValue<AgeInheritance> AgeInheritance {
+      get { return AgeInheritanceParameter.Value; }
+      set { AgeInheritanceParameter.Value = value; }
+    }
+    private ReductionOperation AgeInheritanceReduction {
+      get { return AgeInheritanceReductionParameter.Value; }
+      set { AgeInheritanceReductionParameter.Value = value; }
+    }
+    public IntArray AgeLimits {
+      get { return AgeLimitsParameter.Value; }
+      set { AgeLimitsParameter.Value = value; }
+    }
+
+    public IntValue MatingPoolRange {
+      get { return MatingPoolRangeParameter.Value; }
+      set { MatingPoolRangeParameter.Value = value; }
+    }
+    public PercentValue MatingPoolSelectionPercentage {
+      get { return MatingPoolSelectionPercentageParameter.Value; }
+      set { MatingPoolSelectionPercentageParameter.Value = value; }
+    }
+
+    public MultiTerminator Terminators {
+      get { return TerminatorParameter.Value; }
+    }
+
     public int MaximumGenerations {
       get { return generationsTerminator.Threshold.Value; }
       set { generationsTerminator.Threshold.Value = value; }
     }
-    public ISelector Selector {
-      get { return SelectorParameter.Value; }
-      set { SelectorParameter.Value = value; }
-    }
-    public ICrossover Crossover {
-      get { return CrossoverParameter.Value; }
-      set { CrossoverParameter.Value = value; }
-    }
-    public PercentValue MutationProbability {
-      get { return MutationProbabilityParameter.Value; }
-      set { MutationProbabilityParameter.Value = value; }
-    }
-    public IManipulator Mutator {
-      get { return MutatorParameter.Value; }
-      set { MutatorParameter.Value = value; }
-    }
-    public IntValue Elites {
-      get { return ElitesParameter.Value; }
-      set { ElitesParameter.Value = value; }
-    }
-    public bool ReevaluteElites {
-      get { return ReevaluateElitesParameter.Value.Value; }
-      set { ReevaluateElitesParameter.Value.Value = value; }
-    }
-    public bool PlusSelection {
-      get { return PlusSelectionParameter.Value.Value; }
-      set { PlusSelectionParameter.Value.Value = value; }
-    }
-
+    #endregion
+
+    #region Helper Properties
+    private RandomCreator GlobalRandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+    private SolutionsCreator SolutionsCreator {
+      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
+    }
     private AlpsGeneticAlgorithmMainLoop MainLoop {
       get { return OperatorGraph.Iterate().OfType<AlpsGeneticAlgorithmMainLoop>().First(); }
@@ -110 +233 @@
     #endregion
 
+    #region Preconfigured Analyzers
+    [Storable]
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
+    [Storable]
+    private BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
+    #endregion
+
+    #region Preconfigured Terminators
     [Storable]
     private ComparisonTerminator<IntValue> generationsTerminator;
+    [Storable]
+    private ComparisonTerminator<IntValue> evaluationsTerminator;
+    [Storable]
+    private SingleObjectiveQualityTerminator qualityTerminator;
+    [Storable]
+    private ExecutionTimeTerminator executionTimeTerminator;
+    #endregion
 
     [StorableConstructor]
@@ -122 +260 @@
     private AlpsGeneticAlgorithm(AlpsGeneticAlgorithm original, Cloner cloner)
       : base(original, cloner) {
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
       generationsTerminator = cloner.Clone(original.generationsTerminator);
+      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
+      qualityTerminator = cloner.Clone(original.qualityTerminator);
+      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
       Initialize();
     }
@@ -130 +273 @@
     public AlpsGeneticAlgorithm()
       : base() {
+      #region Add parameters
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+
+      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
+      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
+
+      Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
       Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions each layer.", new IntValue(100)));
+
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
       Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
       Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
-      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
       Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
       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 });
       Parameters.Add(new ValueParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation.", new BoolValue(false)) { Hidden = true });
 
+      Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
+      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)));
+      Parameters.Add(new ValueParameter<EnumValue<AgeInheritance>>("AgeInheritance", "The operator for determining the age of an offspring based the parents' age.", new EnumValue<AgeInheritance>(ALPS.AgeInheritance.Older)));
+      Parameters.Add(new ValueParameter<ReductionOperation>("AgeInheritanceReduction") { Hidden = true });
+      Parameters.Add(new ValueParameter<IntArray>("AgeLimits", new IntArray(new int[0])) { Hidden = true });
+
+      Parameters.Add(new ValueParameter<IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1)) { Hidden = true });
+      Parameters.Add(new ValueParameter<PercentValue>("MatingPoolSelectionPercentage", "Percentage of the previous layers used for creating a mating pool.", new PercentValue(1.0, restrictToUnitInterval: true)) { Hidden = true });
+
+      Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria which sould be checked.", new MultiTerminator()));
+      #endregion
+
+      #region Create operators
       var globalRandomCreator = new RandomCreator();
       var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
@@ -152 +317 @@
       var resultsCollector = new ResultsCollector();
       var mainLoop = new AlpsGeneticAlgorithmMainLoop();
-
+      #endregion
+
+      #region Create and parameterize operator graph
       OperatorGraph.InitialOperator = globalRandomCreator;
 
@@ -195 +362 @@
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
       resultsCollector.Successor = mainLoop;
-
+      #endregion
+
+      #region Set selectors
       foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
         SelectorParameter.ValidValues.Add(selector);
-      var tournamentSelector = SelectorParameter.ValidValues.OfType<TournamentSelector>().FirstOrDefault();
-      if (tournamentSelector != null) {
-        tournamentSelector.GroupSizeParameter.Value = new IntValue(4);
-        SelectorParameter.Value = tournamentSelector;
-      }
-
+      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
+      if (defaultSelector != null) {
+        defaultSelector.PressureParameter.Value = new DoubleValue(4);
+        SelectorParameter.Value = defaultSelector;
+      }
+      #endregion
+
+      #region Create analyzers
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      #endregion
+
+      #region Create terminators
       generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
+      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
+      qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
+      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
+      #endregion
+
+      #region Parameterize
+      ParameterizeAnalyzers();
+      UpdateAnalyzers();
 
       ParameterizeSelectors();
@@ -210 +394 @@
       UpdateTerminators();
 
+      ParameterizeAgeLimits();
+      ParameterizeAgeInheritanceReduction();
+      #endregion
+
       Initialize();
     }
 
     #region Events
+    public override void Prepare() {
+      if (Problem != null)
+        base.Prepare();
+    }
     protected override void OnProblemChanged() {
       base.OnProblemChanged();
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
+      foreach (var @operator in Problem.Operators.OfType<IOperator>())
+        ParameterizeStochasticOperator(@operator);
+
+      ParameterizeIterationBasedOperators();
+
       ParameterizeSolutionsCreator();
       ParameterizeMainLoop();
+      ParameterizeAnalyzers();
       ParameterizeSelectors();
-      ParameterizeIterationBasedOperators();
+      ParameterizeTerminators();
+
+      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+
+      UpdateAnalyzers();
       UpdateCrossovers();
       UpdateMutators();
       UpdateTerminators();
     }
+
+    protected override void RegisterProblemEvents() {
+      base.RegisterProblemEvents();
+      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
+      if (maximizationParameter != null) maximizationParameter.ValueChanged += new EventHandler(MaximizationParameter_ValueChanged);
+    }
+    protected override void DeregisterProblemEvents() {
+      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
+      if (maximizationParameter != null) maximizationParameter.ValueChanged -= new EventHandler(MaximizationParameter_ValueChanged);
+      base.DeregisterProblemEvents();
+    }
+
     protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
       base.Problem_SolutionCreatorChanged(sender, e);
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
+
+      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+
       ParameterizeSolutionsCreator();
+      ParameterizeAnalyzers();
     }
     protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
       base.Problem_EvaluatorChanged(sender, e);
+      foreach (var @operator in Problem.Operators.OfType<IOperator>())
+        ParameterizeStochasticOperator(@operator);
+
+      UpdateAnalyzers();
+
       ParameterizeSolutionsCreator();
       ParameterizeMainLoop();
@@ -241 +468 @@
       UpdateTerminators();
     }
-    protected override void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      base.Evaluator_QualityParameter_ActualNameChanged(sender, e);
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
       ParameterizeMainLoop();
+      ParameterizeAnalyzers();
       ParameterizeSelectors();
+    }
+    private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
+      ParameterizeTerminators();
+    }
+    private void QualityAnalyzer_CurrentBestQualityParameter_NameChanged(object sender, EventArgs e) {
+      ParameterizeTerminators();
+    }
+
+    private void AgeGapParameter_ValueChanged(object sender, EventArgs e) {
+      AgeGap.ValueChanged += AgeGap_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+    private void AgeGap_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+    private void AgingSchemeParameter_ValueChanged(object sender, EventArgs e) {
+      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+    private void NumberOfLayersParameter_ValueChanged(object sender, EventArgs e) {
+      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+    private void AgeInheritanceParameter_ValueChanged(object sender, EventArgs e) {
+      AgeInheritance.ValueChanged += AgeInheritance_ValueChanged;
+      ParameterizeAgeInheritanceReduction();
+    }
+    private void AgeInheritance_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeInheritanceReduction();
+    }
+
+    private void AnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 2;
+        }
+      }
+    }
+    private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        IParameter resultParameter;
+        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
+          var lookupParameter = resultParameter as ILookupParameter;
+          if (lookupParameter != null)
+            lookupParameter.ActualName = "LayerResults";
+        }
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 1;
+        }
+      }
     }
     #endregion
@@ -250 +533 @@
     #region Parameterization
     private void Initialize() {
+      if (Problem != null)
+        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+
+      NumberOfLayersParameter.ValueChanged += NumberOfLayersParameter_ValueChanged;
+      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
+
+      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
+      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
+
+      AgeGapParameter.ValueChanged += AgeGapParameter_ValueChanged;
+      AgeGap.ValueChanged += AgeGap_ValueChanged;
+      AgingSchemeParameter.ValueChanged += AgingSchemeParameter_ValueChanged;
+      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
+      AgeInheritanceParameter.ValueChanged += AgeInheritanceParameter_ValueChanged;
+      AgeInheritance.ValueChanged += AgeInheritance_ValueChanged;
+
+      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += new EventHandler(QualityAnalyzer_CurrentBestQualityParameter_NameChanged);
     }
     private void ParameterizeSolutionsCreator() {
+      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
       MainLoop.LayerUpdator.SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
       MainLoop.LayerUpdator.SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
@@ -263 +565 @@
       MainLoop.LayerUpdator.SolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
     }
+    private void ParameterizeAnalyzers() {
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      qualityAnalyzer.ResultsParameter.Hidden = true;
+      qualityAnalyzer.QualityParameter.Depth = 2;
+      layerQualityAnalyzer.ResultsParameter.ActualName = "Results";
+      layerQualityAnalyzer.ResultsParameter.Hidden = true;
+      layerQualityAnalyzer.QualityParameter.Depth = 1;
+      if (Problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.MaximizationParameter.Hidden = true;
+        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        qualityAnalyzer.QualityParameter.Hidden = true;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+        layerQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        layerQualityAnalyzer.MaximizationParameter.Hidden = true;
+        layerQualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        layerQualityAnalyzer.QualityParameter.Hidden = true;
+        layerQualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        layerQualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+      }
+    }
     private void ParameterizeSelectors() {
       foreach (var selector in SelectorParameter.ValidValues) {
@@ -279 +603 @@
         }
       }
+    }
+    private void ParameterizeTerminators() {
+      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
     }
     private void ParameterizeIterationBasedOperators() {
@@ -290 +617 @@
       }
     }
-
-    protected override ReductionOperations GetAgeInheritanceReduction(AgeInheritance ageInheritance) {
+    private void ParameterizeAgeInheritanceReduction() {
+      AgeInheritanceReduction.Value = GetAgeInheritanceReduction(AgeInheritance.Value);
+    }
+    private void ParameterizeAgeLimits() {
+      var scheme = AgingScheme.Value;
+      int ageGap = AgeGap.Value;
+      int numberOfLayers = NumberOfLayers.Value;
+      AgeLimits = scheme.CalculateAgeLimits(ageGap, numberOfLayers);
+    }
+
+    private void ParameterizeStochasticOperator(IOperator @operator) {
+      var stochasticOperator = @operator as IStochasticOperator;
+      if (stochasticOperator != null) {
+        stochasticOperator.RandomParameter.ActualName = "GlobalRandom";
+        stochasticOperator.RandomParameter.Hidden = true;
+      }
+    }
+
+    private void ParameterizeStochasticOperatorForLayer(IOperator @operator) {
+      var stochasticOperator = @operator as IStochasticOperator;
+      if (stochasticOperator != null) {
+        stochasticOperator.RandomParameter.ActualName = "LocalRandom";
+        stochasticOperator.RandomParameter.Hidden = true;
+      }
+    }
+
+    private ReductionOperations GetAgeInheritanceReduction(AgeInheritance ageInheritance) {
       switch (ageInheritance) {
         case ALPS.AgeInheritance.Older: return ReductionOperations.Max;
@@ -302 +654 @@
 
     #region Updates
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      LayerAnalyzer.Operators.Clear();
+
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, layerQualityAnalyzer.EnabledByDefault);
+
+      if (Problem != null) {
+        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+        }
+      }
+    }
+    private void UpdateCrossovers() {
+      var oldCrossover = CrossoverParameter.Value;
+      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
+      CrossoverParameter.ValidValues.Clear();
+      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(c => c.Name)) {
+        ParameterizeStochasticOperatorForLayer(crossover);
+        CrossoverParameter.ValidValues.Add(crossover);
+      }
+      if (oldCrossover != null) {
+        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(c => c.GetType() == oldCrossover.GetType());
+        if (crossover != null)
+          CrossoverParameter.Value = crossover;
+        else
+          oldCrossover = null;
+      }
+      if (oldCrossover == null && defaultCrossover != null)
+        CrossoverParameter.Value = defaultCrossover;
+    }
+    private void UpdateMutators() {
+      var oldMutator = MutatorParameter.Value;
+      MutatorParameter.ValidValues.Clear();
+      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(m => m.Name)) {
+        ParameterizeStochasticOperatorForLayer(mutator);
+        MutatorParameter.ValidValues.Add(mutator);
+      }
+      if (oldMutator != null) {
+        var mutator = MutatorParameter.ValidValues.FirstOrDefault(m => m.GetType() == oldMutator.GetType());
+        if (mutator != null)
+          MutatorParameter.Value = mutator;
+      }
+    }
     private void UpdateTerminators() {
       var newTerminators = new Dictionary<ITerminator, bool> {
@@ -319 +715 @@
         Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
     }
-    private void UpdateCrossovers() {
-      var oldCrossover = CrossoverParameter.Value;
-      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
-      CrossoverParameter.ValidValues.Clear();
-      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(c => c.Name)) {
-        ParameterizeStochasticOperatorForLayer(crossover);
-        CrossoverParameter.ValidValues.Add(crossover);
-      }
-      if (oldCrossover != null) {
-        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(c => c.GetType() == oldCrossover.GetType());
-        if (crossover != null)
-          CrossoverParameter.Value = crossover;
-        else
-          oldCrossover = null;
-      }
-      if (oldCrossover == null && defaultCrossover != null)
-        CrossoverParameter.Value = defaultCrossover;
-    }
-    private void UpdateMutators() {
-      var oldMutator = MutatorParameter.Value;
-      MutatorParameter.ValidValues.Clear();
-      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(m => m.Name)) {
-        ParameterizeStochasticOperatorForLayer(mutator);
-        MutatorParameter.ValidValues.Add(mutator);
-      }
-      if (oldMutator != null) {
-        var mutator = MutatorParameter.ValidValues.FirstOrDefault(m => m.GetType() == oldMutator.GetType());
-        if (mutator != null)
-          MutatorParameter.Value = mutator;
-      }
-    }
     #endregion
   }