Changeset 13111 for branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs

Timestamp:

11/03/15 17:09:44 (8 years ago)

Author:

pfleck

Message:

#2269

• Instead of hidden execution scope change logic in LayerReseeder, the new ReseedingController makes the scope change more obvious by using an OperatorParameter.
• Instead of the classes for EldersEmigrator, LayerOpener and LayerReseeder the operator graph is created in the AlpsGeneticAlgorithmMainLoop using CombinedOperator.

File:

• branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs (modified) (3 diffs)

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

@@ -30 +30 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
 
 namespace HeuristicLab.Algorithms.ALPS {
@@ -83 +84 @@
       var generationsIcrementor = new IntCounter() { Name = "Increment Generations" };
       var evaluatedSolutionsReducer = new DataReducer() { Name = "Increment EvaluatedSolutions" };
-      var eldersEmigrator = new EldersEmigrator() { Name = "Emigrate Elders" };
-      var layerOpener = new LayerOpener() { Name = "Open new Layer" };
-      var layerReseeder = new LayerReseeder() { Name = "Reseed Layer Zero" };
+      var eldersEmigrator = CreateEldersEmigrator();
+      var layerOpener = CreateLayerOpener();
+      var layerReseeder = CreateReseeder();
       var layerAnalyzerProcessor = new UniformSubScopesProcessor();
       var layerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
@@ -153 +154 @@
       termination.ContinueBranch = matingPoolCreator;
     }
+
+    private static CombinedOperator CreateEldersEmigrator() {
+      var eldersEmigrator = new CombinedOperator() { Name = "Emigrate Elders" };
+      var selectorProsessor = new UniformSubScopesProcessor();
+      var eldersSelector = new EldersSelector();
+      var shiftToRightMigrator = new UnidirectionalRingMigrator();
+      var mergingProsessor = new UniformSubScopesProcessor();
+      var mergingReducer = new MergingReducer();
+      var subScopesCounter = new SubScopesCounter();
+      var countCalculator = new ExpressionCalculator() { Name = "LayerPopulationSize = Min(LayerPopulationSize, PopulationSize)" };
+      var bestSelector = new BestSelector();
+      var rightReducer = new RightReducer();
+
+      eldersEmigrator.OperatorGraph.InitialOperator = selectorProsessor;
+
+      selectorProsessor.Operator = eldersSelector;
+      selectorProsessor.Successor = shiftToRightMigrator;
+
+      shiftToRightMigrator.ClockwiseMigrationParameter.Value = new BoolValue(true);
+      shiftToRightMigrator.Successor = mergingProsessor;
+
+      mergingProsessor.Operator = mergingReducer;
+
+      mergingReducer.Successor = subScopesCounter;
+
+      subScopesCounter.ValueParameter.ActualName = "LayerPopulationSize";
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
+      subScopesCounter.Successor = countCalculator;
+
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>("PopulationSize"));
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>("LayerPopulationSize"));
+      countCalculator.ExpressionParameter.Value = new StringValue("LayerPopulationSize PopulationSize LayerPopulationSize PopulationSize < if toint");
+      countCalculator.ExpressionResultParameter.ActualName = "LayerPopulationSize";
+      countCalculator.Successor = bestSelector;
+
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "LayerPopulationSize";
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.Successor = rightReducer;
+
+      return eldersEmigrator;
+    }
+
+    private static CombinedOperator CreateLayerOpener() {
+      var layerOpener = new CombinedOperator() { Name = "Open new Layer if needed" };
+      var maxLayerReached = new Comparator() { Name = "MaxLayersReached = OpenLayers >= NumberOfLayers" };
+      var maxLayerReachedBranch = new ConditionalBranch() { Name = "MaxLayersReached?" };
+      var openNewLayerCalculator = new ExpressionCalculator() { Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]" };
+      var openNewLayerBranch = new ConditionalBranch() { Name = "OpenNewLayer?" };
+      var layerCreator = new LayerCreator() { Name = "Create Layer" };
+      var createChildrenViaCrossover = AlpsGeneticAlgorithmMainOperator.Create();
+      var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
+      var incrOpenLayers = new IntCounter() { Name = "Incr. OpenLayers" };
+      var newLayerResultsCollector = new ResultsCollector() { Name = "Collect new Layer Results" };
+
+      layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
+
+      maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
+      maxLayerReached.RightSideParameter.ActualName = "NumberOfLayers";
+      maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
+      maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      maxLayerReached.Successor = maxLayerReachedBranch;
+
+      maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
+      maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
+
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>("AgeLimits"));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("NumberOfLayers"));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
+      openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
+      openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
+      openNewLayerCalculator.Successor = openNewLayerBranch;
+
+      openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
+      openNewLayerBranch.TrueBranch = layerCreator;
+
+      layerCreator.NewLayerOperator = createChildrenViaCrossover;
+      layerCreator.Successor = incrOpenLayers;
+
+      createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
+
+      incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = "EvaluatedSolutions";
+      incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
+
+      incrOpenLayers.ValueParameter.ActualName = "OpenLayers";
+      incrOpenLayers.Increment = new IntValue(1);
+      incrOpenLayers.Successor = newLayerResultsCollector;
+
+      newLayerResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each layer", "LayerResults"));
+      newLayerResultsCollector.CopyValue = new BoolValue(false);
+      newLayerResultsCollector.Successor = null;
+
+      return layerOpener;
+    }
+
+    private static CombinedOperator CreateReseeder() {
+      var reseeder = new CombinedOperator() { Name = "Reseed Layer Zero if needed" };
+      var reseedingController = new ReseedingController() { Name = "Reseeding needed (Generation % AgeGap == 0)?" };
+      var removeIndividuals = new SubScopesRemover();
+      var createIndividuals = new SolutionsCreator();
+      var initializeAgeProsessor = new UniformSubScopesProcessor();
+      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
+      var incrEvaluatedSolutionsAfterReseeding = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
+
+      reseeder.OperatorGraph.InitialOperator = reseedingController;
+
+      reseedingController.FirstLayerOperator = removeIndividuals;
+
+      removeIndividuals.Successor = createIndividuals;
+
+      createIndividuals.NumberOfSolutionsParameter.ActualName = "PopulationSize";
+      createIndividuals.Successor = initializeAgeProsessor;
+
+      initializeAgeProsessor.Operator = initializeAge;
+      initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
+
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
+
+      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = "EvaluatedSolutions";
+      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
+
+      return reseeder;
+    }
   }
 }