Changeset 6042 for trunk/sources/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearchMainLoop.cs

Timestamp:

04/23/11 00:29:24 (13 years ago)

Author:

abeham

Message:

#1425

• Changed LocalImprovementOperators
  • Changed interface (made Problem a property, added a property that denotes the type of the problem that it can be applied on, added some general parameters)
  • Added some parameters and wiring
  • Changed move discovery and parameterization and added a helper class to ease finding compatible move operators
  • Discovering only IMultiMoveOperators and IExhaustiveMoveOperators and putting the multi move ones first
  • Fixed bug in Apply method that could create an endless string of nested execution contexts
  • Removed all problem specific analyzers in the two local improvement operators and only left the BestAverageWorstQualityAnalyzer since it doesn't make any sense to perform diversity or allele analysis during local improvement in the most common case and those analyzers take a lot of time (one can always add them manually should he/she be interested). The analyzers in the VNS's Analyzer parameter are left untouched.
• Removed shaking operator and interface from VNS plugin and added that to Optimization and Optimization.Operators
• Changed some ValueParameters to ConstrainedValueParameters and added type discovery to fill them (using the ProblemType property to get compatible local improvement operators)
• Added missing GPL license headers
• Changed some ValueParameters to the new FixedValueParameters
• Added an additional encoding specific ShakingOperator to each encoding and added that to each problem
  • reason is that only the problem/encoding can really decide if a shaking operator is meaningful or not
• Fixed an unrelated bug in the BestAverageWorstQualityAnalyzer that I encountered (and made the fix backwards compatible)
  • Also added a snippet for creating the backwards compatible comment marker and region
• Fixed the operator graph of the VNS main loop
  • The condition to continue only when the local search was not successful is not necessary and is not part of the VNS definition as far as I know it (only condition to break the inner loop is when k reaches k_max)
• Changed the ShakingOperator to input current index and output the maximum number of neighborhoods instead of a boolean that indicates that the last index has been reached since the maximum number is a little more generally useful and equally powerful in modeling
  • Remodeled the VNS main loop to check for k < k_max in order to continue the inner loop
• other changes that I forgot...

Still necessary

• test, test, test
• check for backwards compatible breakers
• add a maximum evaluated solutions stop criterion
• optionally: implement fast problem specific local search improvement operators that do not build on the whole generic overhead (e.g. a 2-opt TSP specific local search operator). The idea of VNS is really to converge to a local optimum which is difficult to achieve using the current rather limited termination options

File:

• trunk/sources/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearchMainLoop.cs (modified) (16 diffs)

trunk/sources/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearchMainLoop.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Selection;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Algorithms.VariableNeighborhoodSearch {
@@ -42 +38 @@
   public sealed class VariableNeighborhoodSearchMainLoop : AlgorithmOperator {
     #region Parameter properties
-    public ValueLookupParameter<IRandom> RandomParameter {
-      get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ValueLookupParameter<BoolValue> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
-    }
-    public LookupParameter<DoubleValue> QualityParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
-    }
-    public ValueLookupParameter<IOperator> EvaluatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
-    }
-    public ValueLookupParameter<IntValue> MaximumIterationsParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
-    }
-    public ValueLookupParameter<VariableCollection> ResultsParameter {
-      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
-    }
-    public ValueLookupParameter<IOperator> AnalyzerParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
-    }
-    public LookupParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (LookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
-    }
-    public ValueLookupParameter<ILocalImprovementOperator> LocalImprovementParameter {
-      get { return (ValueLookupParameter<ILocalImprovementOperator>)Parameters["LocalImprovement"]; }
-    }
-    public ValueLookupParameter<IShakingOperator> ShakingParameter {
-      get { return (ValueLookupParameter<IShakingOperator>)Parameters["Shaking"]; }
+    public IValueLookupParameter<IRandom> RandomParameter {
+      get { return (IValueLookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public IValueLookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    public IValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
+    }
+    public ILookupParameter<IntValue> IterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Iterations"]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    public IValueLookupParameter<VariableCollection> ResultsParameter {
+      get { return (IValueLookupParameter<VariableCollection>)Parameters["Results"]; }
+    }
+    public IValueLookupParameter<IOperator> AnalyzerParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
+    }
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public ILookupParameter<IntValue> CurrentNeighborhoodIndexParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentNeighborhoodIndex"]; }
+    }
+    public ILookupParameter<IntValue> NeighborhoodCountParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NeighborhoodCount"]; }
+    }
+    public IValueLookupParameter<ILocalImprovementOperator> LocalImprovementParameter {
+      get { return (IValueLookupParameter<ILocalImprovementOperator>)Parameters["LocalImprovement"]; }
+    }
+    public IValueLookupParameter<IMultiNeighborhoodShakingOperator> ShakingOperatorParameter {
+      get { return (IValueLookupParameter<IMultiNeighborhoodShakingOperator>)Parameters["ShakingOperator"]; }
     }
     #endregion
@@ -81 +86 @@
     public VariableNeighborhoodSearchMainLoop()
       : base() {
-        Initialize();
+      Initialize();
     }
     private VariableNeighborhoodSearchMainLoop(VariableNeighborhoodSearchMainLoop original, Cloner cloner)
@@ -97 +102 @@
       Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
+      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The iterations to count."));
       Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
       Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
-
       Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze the solution."));
       Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
       Parameters.Add(new ValueLookupParameter<ILocalImprovementOperator>("LocalImprovement", "The local improvement operation."));
-      Parameters.Add(new ValueLookupParameter<IShakingOperator>("Shaking", "The shaking operation."));
+      Parameters.Add(new ValueLookupParameter<IMultiNeighborhoodShakingOperator>("ShakingOperator", "The shaking operation."));
+      Parameters.Add(new LookupParameter<IntValue>("CurrentNeighborhoodIndex", "The index of the current shaking operation that should be applied."));
+      Parameters.Add(new LookupParameter<IntValue>("NeighborhoodCount", "The number of neighborhood operators used for shaking."));
       #endregion
 
@@ -126 +133 @@
 
       QualityComparator qualityComparator = new QualityComparator();
-      ConditionalBranch improvesQualityBranch1 = new ConditionalBranch();
-      ConditionalBranch improvesQualityBranch2 = new ConditionalBranch();
+      ConditionalBranch improvesQualityBranch = new ConditionalBranch();
 
       Assigner bestQualityUpdater = new Assigner();
@@ -139 +145 @@
       Placeholder analyzer2 = new Placeholder();
 
+      Comparator indexComparator = new Comparator();
       ConditionalBranch indexTermination = new ConditionalBranch();
 
@@ -145 +152 @@
       ConditionalBranch iterationsTermination = new ConditionalBranch();
 
-      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Index", new IntValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("Continue", new BoolValue(false)));
       variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("IsBetter", new BoolValue(false)));
       variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("BestQuality", new DoubleValue(0)));
@@ -159 +163 @@
 
       resultsCollector1.CopyValue = new BoolValue(false);
-      resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
       resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
       resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
 
-      iteration.Name = "Iteration";
-
-      iterationInit.Name = "Init iteration";
-      iterationInit.LeftSideParameter.ActualName = "Index";
+      iteration.Name = "MainLoop Body";
+
+      iterationInit.Name = "Init k = 0";
+      iterationInit.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
       iterationInit.RightSideParameter.Value = new IntValue(0);
 
@@ -176 +179 @@
 
       shaking.Name = "Shaking operator (placeholder)";
-      shaking.OperatorParameter.ActualName = ShakingParameter.Name;
+      shaking.OperatorParameter.ActualName = ShakingOperatorParameter.Name;
 
       localImprovement.Name = "Local improvement operator (placeholder)";
@@ -192 +195 @@
       qualityComparator.ResultParameter.ActualName = "IsBetter";
 
-      improvesQualityBranch1.ConditionParameter.ActualName = "IsBetter";
-      improvesQualityBranch2.ConditionParameter.ActualName = "IsBetter";
+      improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
 
       bestQualityUpdater.Name = "Update BestQuality";
@@ -204 +206 @@
       bestSelector.QualityParameter.ActualName = QualityParameter.Name;
 
-      indexCounter.Name = "Count index";
+      indexCounter.Name = "Count neighborhood index";
       indexCounter.Increment.Value = 1;
-      indexCounter.ValueParameter.ActualName = "Index";
-
-      indexResetter.Name = "Reset index";
-      indexResetter.LeftSideParameter.ActualName = "Index";
+      indexCounter.ValueParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
+
+      indexResetter.Name = "Reset neighborhood index";
+      indexResetter.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
       indexResetter.RightSideParameter.Value = new IntValue(0);
 
@@ -217 +219 @@
       iterationsCounter.Name = "Iterations Counter";
       iterationsCounter.Increment = new IntValue(1);
-      iterationsCounter.ValueParameter.ActualName = "Iterations";
+      iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
 
       iterationsComparator.Name = "Iterations >= MaximumIterations";
       iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
-      iterationsComparator.LeftSideParameter.ActualName = "Iterations";
+      iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
       iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
       iterationsComparator.ResultParameter.ActualName = "Terminate";
@@ -228 +230 @@
       iterationsTermination.ConditionParameter.ActualName = "Terminate";
 
+      indexComparator.Name = "k < k_max (index condition)";
+      indexComparator.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
+      indexComparator.RightSideParameter.ActualName = NeighborhoodCountParameter.Name;
+      indexComparator.Comparison = new Comparison(ComparisonType.Less);
+      indexComparator.ResultParameter.ActualName = "ContinueIteration";
+
       indexTermination.Name = "Index Termination Condition";
-      indexTermination.ConditionParameter.ActualName = "Continue";
+      indexTermination.ConditionParameter.ActualName = "ContinueIteration";
       #endregion
 
@@ -255 +263 @@
       evalCounter.Successor = localImprovement;
       localImprovement.Successor = qualityComparator;
-      qualityComparator.Successor = improvesQualityBranch1;
-      improvesQualityBranch1.TrueBranch = bestQualityUpdater;
-      improvesQualityBranch1.FalseBranch = indexCounter;
+      qualityComparator.Successor = improvesQualityBranch;
+      improvesQualityBranch.TrueBranch = bestQualityUpdater;
+      improvesQualityBranch.FalseBranch = indexCounter;
 
       bestQualityUpdater.Successor = indexResetter;
@@ -266 +274 @@
       bestSelector.Successor = rightReducer;
       rightReducer.Successor = analyzer2;
-      analyzer2.Successor = indexTermination;
-      indexTermination.TrueBranch = improvesQualityBranch2;
+      analyzer2.Successor = indexComparator;
+      indexComparator.Successor = indexTermination;
+      indexTermination.TrueBranch = createChild;
       indexTermination.FalseBranch = null;
-
-      improvesQualityBranch2.TrueBranch = null;
-      improvesQualityBranch2.FalseBranch = createChild;
 
       iterationsCounter.Successor = iterationsComparator;
@@ -281 +287 @@
 
     public override IOperation Apply() {
-      if (LocalImprovementParameter.ActualValue == null || EvaluatorParameter.ActualValue == null)
+      if (LocalImprovementParameter.ActualValue == null || ShakingOperatorParameter.ActualValue == null)
         return null;
       return base.Apply();