Changeset 13111

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.

Location:

branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3

Files:

• AlpsGeneticAlgorithmMainLoop.cs (modified) (3 diffs)
• EldersEmigrator.cs (deleted)
• HeuristicLab.Algorithms.ALPS-3.3.csproj (modified) (2 diffs)
• LayerOpener.cs (deleted)
• ReseedingController.cs (moved) (moved from branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerReseeder.cs) (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;
+    }
   }
 }

branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj

@@ -133 +133 @@
   <ItemGroup>
     <Compile Include="AlpsGeneticAlgorithmMainOperator.cs" />
-    <Compile Include="LayerOpener.cs" />
-    <Compile Include="LayerReseeder.cs" />
+    <Compile Include="ReseedingController.cs" />
     <Compile Include="WeightingReducer.cs" />
     <Compile Include="Analyzers\OldestAverageYoungestAgeAnalyzer.cs" />
@@ -142 +141 @@
     <Compile Include="AlpsGeneticAlgorithmMainLoop.cs" />
     <Compile Include="Analyzers\OldestAverageYoungestAgeCalculator.cs" />
-    <Compile Include="EldersEmigrator.cs" />
     <Compile Include="EldersSelector.cs" />
     <Compile Include="LayerCreator.cs" />

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

@@ -20 +20 @@
 #endregion
 
-using System.Drawing;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
-using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.ALPS {
-  [Item("LayerReseeder", "An operator that encapsulates the reseeding of the lowest layer in ALPS.")]
+  [Item("ReseedingController", "An operator that controls if reseeding is needed.")]
   [StorableClass]
-  public sealed class LayerReseeder : SingleSuccessorOperator, IOperatorGraphOperator {
-    public static new Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Module; }
-    }
-    public override Image ItemImage {
-      get {
-        if (Breakpoint) return HeuristicLab.Common.Resources.VSImageLibrary.BreakpointActive;
-        else return base.ItemImage;
-      }
-    }
-
+  public sealed class ReseedingController : SingleSuccessorOperator {
     private ILookupParameter<IntValue> GenerationsParameter {
       get { return (ILookupParameter<IntValue>)Parameters["Generations"]; }
@@ -49 +37 @@
       get { return (ILookupParameter<IntValue>)Parameters["AgeGap"]; }
     }
+    public OperatorParameter FirstLayerOperatorParameter {
+      get { return (OperatorParameter)Parameters["FirstLayerOperator"]; }
+    }
 
-    [Storable]
-    private OperatorGraph operatorGraph;
-    public OperatorGraph OperatorGraph {
-      get { return operatorGraph; }
+    public IOperator FirstLayerOperator {
+      get { return FirstLayerOperatorParameter.Value; }
+      set { FirstLayerOperatorParameter.Value = value; }
     }
 
     [StorableConstructor]
-    private LayerReseeder(bool deserializing)
+    private ReseedingController(bool deserializing)
       : base(deserializing) { }
 
-    private LayerReseeder(LayerReseeder original, Cloner cloner)
+    private ReseedingController(ReseedingController original, Cloner cloner)
       : base(original, cloner) {
-      operatorGraph = cloner.Clone(original.operatorGraph);
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new LayerReseeder(this, cloner);
+      return new ReseedingController(this, cloner);
     }
 
-    public LayerReseeder()
+    public ReseedingController()
       : base() {
       Parameters.Add(new LookupParameter<IntValue>("Generations"));
       Parameters.Add(new LookupParameter<IntValue>("AgeGap"));
-
-      operatorGraph = new OperatorGraph();
-
-      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" };
-
-      OperatorGraph.InitialOperator = 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)));
-      initializeAge.Successor = null;
-
-      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = "EvaluatedSolutions";
-      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
-      incrEvaluatedSolutionsAfterReseeding.Successor = null;
+      Parameters.Add(new OperatorParameter("FirstLayerOperator"));
     }
 
@@ -106 +71 @@
       if (generations % ageGap == 0) {
         var layerZeroScope = ExecutionContext.Scope.SubScopes[0];
-        if (operatorGraph.InitialOperator != null)
-          next.Insert(0, ExecutionContext.CreateChildOperation(operatorGraph.InitialOperator, layerZeroScope));
+        if (FirstLayerOperator != null)
+          next.Insert(0, ExecutionContext.CreateChildOperation(FirstLayerOperator, layerZeroScope));
       }
       return next;