Changeset 5642 for branches/VNS/HeuristicLab.Algorithms.VariableNeighborhoodSearch

Timestamp:

03/09/11 11:17:48 (14 years ago)

Author:

svonolfe

Message:

Implemented wiring (#1425)

Location:

branches/VNS/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3

Files:

• HeuristicLab.Algorithms.VariableNeighborhoodSearch-3.3.csproj (modified) (1 diff)
• IShakingOperator.cs (added)
• ShakingOperator.cs (modified) (3 diffs)
• VariableNeighborhoodSearch.cs (modified) (7 diffs)
• VariableNeighborhoodSearchMainLoop.cs (modified) (4 diffs)

branches/VNS/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/HeuristicLab.Algorithms.VariableNeighborhoodSearch-3.3.csproj

@@ -108 +108 @@
   <ItemGroup>
     <Compile Include="HeuristicLabAlgorithmsVariableNeighborhoodSearchPlugin.cs" />
+    <Compile Include="IShakingOperator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ShakingOperator.cs" />

branches/VNS/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/ShakingOperator.cs

@@ -38 +38 @@
   [Item("ShakingOperator", "A shaking operator for VNS.")]
   [StorableClass]
-  public class ShakingOperator: CheckedMultiOperator<IManipulator> {
+  public class ShakingOperator<T> : CheckedMultiOperator<T>, IShakingOperator where T : class, IManipulator {
     public IValueLookupParameter<IntValue> IndexParameter {
       get { return (ValueLookupParameter<IntValue>)Parameters["Index"]; }
@@ -49 +49 @@
     [StorableConstructor]
     protected ShakingOperator(bool deserializing) : base(deserializing) { }
-    protected ShakingOperator(ShakingOperator original, Cloner cloner) : base(original, cloner) { }
+    protected ShakingOperator(ShakingOperator<T> original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new ShakingOperator(this, cloner);
+      return new ShakingOperator<T>(this, cloner);
     }
     public ShakingOperator()
@@ -57 +57 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("Index", "The index of the operator that should be applied (k)."));
       Parameters.Add(new LookupParameter<BoolValue>("Continue", "True if k <= available operators."));
+    }
+
+    public void Parameterize(IProblem problem) {
+      Operators.Clear();
+
+      if (problem != null) {
+        foreach (T manipulator in problem.Operators.OfType<T>().OrderBy(x => x.Name))
+          Operators.Add(manipulator);
+      }
     }
 

branches/VNS/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearch.cs

@@ -39 +39 @@
       get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     }
-    public /*Constrained*/ValueParameter<ISingleObjectiveEvaluator> EvaluatorParameter {
-      get { return (/*Constrained*/ValueParameter<ISingleObjectiveEvaluator>)Parameters["Evaluator"]; }
-    }
     private ValueParameter<ILocalImprovement> LocalImprovementParameter {
       get { return (ValueParameter<ILocalImprovement>)Parameters["LocalImprovement"]; }
     }
-    private ValueParameter<ShakingOperator> ShakingParameter {
-      get { return (ValueParameter<ShakingOperator>)Parameters["Shaking"]; }
+    private ValueParameter<IShakingOperator> ShakingParameter {
+      get { return (ValueParameter<IShakingOperator>)Parameters["Shaking"]; }
     }
     private ValueParameter<IntValue> MaximumIterationsParameter {
@@ -53 +50 @@
     private ValueParameter<MultiAnalyzer> AnalyzerParameter {
       get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    private VariableNeighborhoodSearchMainLoop VNSMainLoop {
+      get { return FindMainLoop(SolutionsCreator.Successor); }
     }
     #endregion
@@ -60 +60 @@
       get { return (RandomCreator)OperatorGraph.InitialOperator; }
     }
-    #endregion
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+      set { AnalyzerParameter.Value = value; }
+    }
+    private SolutionsCreator SolutionsCreator {
+      get { return (SolutionsCreator)RandomCreator.Successor; }
+    }
+    #endregion
+
+    [Storable]
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
 
     [StorableConstructor]
@@ -70 +80 @@
     private VariableNeighborhoodSearch(VariableNeighborhoodSearch original, Cloner cloner)
       : base(original, cloner) {
-
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      Initialize();
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -79 +90 @@
       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 /*Constrained*/ValueParameter<ISingleObjectiveEvaluator>("Evaluator", "The operator used to evaluate the solutions."));
       Parameters.Add(new ValueParameter<ILocalImprovement>("LocalImprovement", "The local improvement operation", new LocalSearchImprovement()));
-      Parameters.Add(new ValueParameter<ShakingOperator>("Shaking", "The shaking operation", new ShakingOperator()));
+      Parameters.Add(new ValueParameter<IShakingOperator>("Shaking", "The shaking operation"));
       Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
       Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution and moves.", new MultiAnalyzer()));
@@ -112 +122 @@
       mainLoop.LocalImprovementParameter.ActualName = LocalImprovementParameter.Name;
       mainLoop.ShakingParameter.ActualName = ShakingParameter.Name;
-      mainLoop.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
       mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
       mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
@@ -119 +128 @@
       mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
 
-      /*Initialize();*/
-    }
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      ParameterizeAnalyzers();
+      UpdateAnalyzers();
+
+      Initialize();
+    }
+
+    public override void Prepare() {
+      if (Problem != null) base.Prepare();
+    }
+
+    private void Initialize() {
+      if (Problem != null) {
+        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      }
+    }
+
+    #region Events
+    protected override void OnProblemChanged() {
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperator(Problem.Evaluator);
+      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
+      ParameterizeSolutionsCreator();
+      ParameterizeVNSMainLoop();
+      ParameterizeAnalyzers();
+      ParameterizeIterationBasedOperators();
+      UpdateShakingOperator();
+      UpdateLocalImprovementOperator();
+      UpdateAnalyzers();
+      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      base.OnProblemChanged();
+    }
+
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeSolutionsCreator();
+      base.Problem_SolutionCreatorChanged(sender, e);
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      ParameterizeStochasticOperator(Problem.Evaluator);
+      ParameterizeSolutionsCreator();
+      ParameterizeVNSMainLoop();
+      ParameterizeAnalyzers();
+      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
+      ParameterizeIterationBasedOperators();
+      UpdateShakingOperator();
+      UpdateLocalImprovementOperator();
+      UpdateAnalyzers();
+      base.Problem_OperatorsChanged(sender, e);
+    }
+
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeVNSMainLoop();
+      ParameterizeAnalyzers();
+    }
+    #endregion
+
+    #region Helpers
+    private void ParameterizeSolutionsCreator() {
+      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+    }
+    private void ParameterizeStochasticOperator(IOperator op) {
+      if (op is IStochasticOperator)
+        ((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+    }
+    private void ParameterizeVNSMainLoop() {
+      VNSMainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      VNSMainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+      VNSMainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+    }
+    private void ParameterizeAnalyzers() {
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      if (Problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        qualityAnalyzer.QualityParameter.Depth = 1;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+      }
+    }
+    private void ParameterizeIterationBasedOperators() {
+      if (Problem != null) {
+        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
+          op.IterationsParameter.ActualName = "OuterIterations";
+          op.MaximumIterationsParameter.ActualName = "MaximumIterations";
+        }
+      }
+    }
+    private void UpdateShakingOperator() {
+      Type manipulatorType = typeof(IManipulator);
+      List<Type> manipulatorInterfaces = new List<Type>();
+
+      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name)) {
+        Type t = mutator.GetType();
+        Type[] interfaces = t.GetInterfaces();
+
+        for(int i = 0; i < interfaces.Length; i++) {
+          if (manipulatorType.IsAssignableFrom(interfaces[i])) {
+            bool assignable = false;
+            for (int j = 0; j < interfaces.Length; j++) {
+              if (i != j && interfaces[i].IsAssignableFrom(interfaces[j])) {
+                assignable = true;
+                break;
+              }
+            }
+
+            if(!assignable)
+              manipulatorInterfaces.Add(interfaces[i]);
+          }         
+        }
+      }
+
+      foreach (Type manipulatorInterface in manipulatorInterfaces) {
+        //manipulatorInterface is more specific
+        if (manipulatorType.IsAssignableFrom(manipulatorInterface)) {
+          //and compatible to all other found manipulator types
+          bool compatible = true;
+          foreach (Type manipulatorInterface2 in manipulatorInterfaces) {
+            if (!manipulatorInterface.IsAssignableFrom(manipulatorInterface2)) {
+              compatible = false;
+              break;
+            }
+          }
+
+          if (compatible)
+            manipulatorType = manipulatorInterface;
+        }
+      }
+      
+      Type genericType = typeof(ShakingOperator<>).MakeGenericType(manipulatorType);
+      ShakingParameter.Value = (IShakingOperator)Activator.CreateInstance(genericType, new object[]{});
+
+      ShakingParameter.Value.Parameterize(Problem);
+    }
+    private void UpdateLocalImprovementOperator() {
+      LocalImprovementParameter.Value.Parameterize(Problem);
+    }
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      if (Problem != null) {
+        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
+            param.Depth = 1;
+          Analyzer.Operators.Add(analyzer);
+        }
+      }
+      Analyzer.Operators.Add(qualityAnalyzer);
+    }
+    private VariableNeighborhoodSearchMainLoop FindMainLoop(IOperator start) {
+      IOperator mainLoop = start;
+      while (mainLoop != null && !(mainLoop is VariableNeighborhoodSearchMainLoop))
+        mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
+      if (mainLoop == null) return null;
+      else return (VariableNeighborhoodSearchMainLoop)mainLoop;
+    }
+    #endregion
   }
 }

branches/VNS/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearchMainLoop.cs

@@ -72 +72 @@
       get { return (ValueLookupParameter<ILocalImprovement>)Parameters["LocalImprovement"]; }
     }
-    public ValueLookupParameter<ShakingOperator> ShakingParameter {
-      get { return (ValueLookupParameter<ShakingOperator>)Parameters["Shaking"]; }
+    public ValueLookupParameter<IShakingOperator> ShakingParameter {
+      get { return (ValueLookupParameter<IShakingOperator>)Parameters["Shaking"]; }
     }
     #endregion
@@ -103 +103 @@
       Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
       Parameters.Add(new ValueLookupParameter<ILocalImprovement>("LocalImprovement", "The local improvement operation."));
-      Parameters.Add(new ValueLookupParameter<ShakingOperator>("Shaking", "The shaking operation."));
+      Parameters.Add(new ValueLookupParameter<IShakingOperator>("Shaking", "The shaking operation."));
       #endregion
 
@@ -148 +148 @@
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OuterIterations", new IntValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Index", new DoubleValue(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)));
@@ -242 +242 @@
       #region Create operator graph
       OperatorGraph.InitialOperator = variableCreator;
-      variableCreator.Successor = analyzer1;
-      analyzer1.Successor = subScopesProcessor0;
+      variableCreator.Successor = subScopesProcessor0;
       subScopesProcessor0.Operators.Add(bestQualityInitializer);
-      subScopesProcessor0.Successor = resultsCollector1;
+      subScopesProcessor0.Successor = analyzer1;
+      analyzer1.Successor = resultsCollector1;
       /////////
       resultsCollector1.Successor = iteration;