Changeset 7786 for branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/TestFunctions/TestFunctionsImprovementOperator.cs

Timestamp:

05/09/12 12:22:33 (12 years ago)

Author:

jkarder

Message:

#1331:

• fixed bug in path relinking selection
• fixed bug in ScatterSearch.Prepare()
• added custom interface (IImprovementOperator) for Scatter Search specific improvement operators
• switched from diversity calculation to similarity calculation
• separated IPathRelinker from ICrossover
• changed TestFunctionsImprovementOperator to use reflection for evaluating functions
• changed SolutionPoolUpdateMethod to use similarity calculation for solution comparison
• improved TravelingSalesmanImprovementOperator
• improved operator graph
• removed specific operators used to evaluate TestFunctions problems
• removed custom crossover operator (NChildCrossover)
• added parameters and adjusted types
• adjusted event handling
• changed access levels
• minor code improvements

File:

• branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/TestFunctions/TestFunctionsImprovementOperator.cs (modified) (9 diffs)

branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/TestFunctions/TestFunctionsImprovementOperator.cs

@@ -21 +21 @@
 
 using System;
+using System.Reflection;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -26 +27 @@
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.Knapsack;
 using HeuristicLab.Problems.TestFunctions;
 
@@ -38 +37 @@
   [Item("TestFunctionsImprovementOperator", "An operator that improves test functions solutions.")]
   [StorableClass]
-  public abstract class TestFunctionsImprovementOperator : SingleSuccessorOperator, ILocalImprovementOperator, IScatterSearchTargetProcessor {
-    #region Problem properties
-    public Type ProblemType {
-      get { return typeof(KnapsackProblem); }
-    }
-    [Storable]
-    private KnapsackProblem problem;
-    public IProblem Problem {
-      get { return problem; }
-      set { problem = (KnapsackProblem)value; }
-    }
-    #endregion
-
+  public sealed class TestFunctionsImprovementOperator : SingleSuccessorOperator, IImprovementOperator {
     #region Parameter properties
+    public IValueParameter<DoubleValue> AlphaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    public IValueParameter<DoubleValue> BetaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Beta"]; }
+    }
     public ScopeParameter CurrentScopeParameter {
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
     }
-    public IValueLookupParameter<DoubleMatrix> CoordinatesParameter {
-      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    public IValueParameter<DoubleValue> DeltaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Delta"]; }
     }
     public IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
       get { return (IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>)Parameters["Evaluator"]; }
     }
+    public IValueParameter<DoubleValue> GammaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Gamma"]; }
+    }
     public IValueLookupParameter<IntValue> ImprovementAttemptsParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters["ImprovementAttempts"]; }
@@ -70 +66 @@
       get { return (IValueLookupParameter<IItem>)Parameters["Target"]; }
     }
-    public IValueParameter<DoubleValue> AlphaParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["Alpha"]; }
-    }
-    public IValueParameter<DoubleValue> BetaParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["Beta"]; }
-    }
-    public IValueParameter<DoubleValue> GammaParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["Gamma"]; }
-    }
-    public IValueParameter<DoubleValue> DeltaParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["Delta"]; }
-    }
-    #region ILocalImprovementOperator Parameters
-    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
-    }
-    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
-    }
-    public ILookupParameter<ResultCollection> ResultsParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
     #endregion
-    #endregion
 
     #region Properties
-    private IItem Target {
-      get { return TargetParameter.ActualValue; }
-    }
     private DoubleValue Alpha {
       get { return AlphaParameter.Value; }
@@ -105 +75 @@
       get { return BetaParameter.Value; }
     }
-    private DoubleValue Gamma {
-      get { return GammaParameter.Value; }
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
     }
     private DoubleValue Delta {
       get { return DeltaParameter.Value; }
-    }
-    protected Func<RealVector, double> FunctionEvaluator { get; set; }
-    public IScope CurrentScope {
-      get { return CurrentScopeParameter.ActualValue; }
-    }
-    public DoubleMatrix Coordinates {
-      get { return CoordinatesParameter.ActualValue; }
-      set { CoordinatesParameter.ActualValue = value; }
     }
     public ISingleObjectiveTestFunctionProblemEvaluator Evaluator {
@@ -123 +85 @@
       set { EvaluatorParameter.ActualValue = value; }
     }
+    private DoubleValue Gamma {
+      get { return GammaParameter.Value; }
+    }
     public IntValue ImprovementAttempts {
       get { return ImprovementAttemptsParameter.ActualValue; }
@@ -131 +96 @@
       set { RandomParameter.ActualValue = value; }
     }
+    private IItem Target {
+      get { return TargetParameter.ActualValue; }
+    }
     #endregion
 
     [StorableConstructor]
-    protected TestFunctionsImprovementOperator(bool deserializing) : base(deserializing) { }
-    protected TestFunctionsImprovementOperator(TestFunctionsImprovementOperator original, Cloner cloner)
-      : base(original, cloner) {
-      this.problem = cloner.Clone(original.problem);
-    }
+    private TestFunctionsImprovementOperator(bool deserializing) : base(deserializing) { }
+    private TestFunctionsImprovementOperator(TestFunctionsImprovementOperator original, Cloner cloner) : base(original, cloner) { }
     public TestFunctionsImprovementOperator()
       : base() {
       #region Create parameters
-      Parameters.Add(new ScopeParameter("CurrentScope"));
-      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Coordinates"));
-      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>("Evaluator"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("ImprovementAttempts", new IntValue(100)));
-      Parameters.Add(new ValueLookupParameter<IRandom>("Random"));
-      Parameters.Add(new ValueLookupParameter<IItem>("Target"));
       Parameters.Add(new ValueParameter<DoubleValue>("Alpha", new DoubleValue(1.0)));
       Parameters.Add(new ValueParameter<DoubleValue>("Beta", new DoubleValue(2.0)));
+      Parameters.Add(new ScopeParameter("CurrentScope"));
+      Parameters.Add(new ValueParameter<DoubleValue>("Delta", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>("Evaluator"));
       Parameters.Add(new ValueParameter<DoubleValue>("Gamma", new DoubleValue(0.5)));
-      Parameters.Add(new ValueParameter<DoubleValue>("Delta", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ImprovementAttempts", new IntValue(100)));
+      Parameters.Add(new ValueLookupParameter<IItem>("Target"));
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random"));
       #endregion
       TargetParameter.ActualName = "Point"; // temporary solution for the test functions problem
     }
 
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TestFunctionsImprovementOperator(this, cloner);
+    }
+
     public override IOperation Apply() {
-      var bestSol = CurrentScope.Variables[TargetParameter.ActualName].Value as RealVector;
-      var bestSolQuality = FunctionEvaluator(bestSol);
+      RealVector bestSol = CurrentScope.Variables[TargetParameter.ActualName].Value as RealVector;
+      MethodInfo evaluationMethod = Evaluator.GetType().GetMethod("Apply",
+                                                                  BindingFlags.Public | BindingFlags.Static,
+                                                                  null,
+                                                                  new Type[] { typeof(RealVector) }, null);
+      Func<RealVector, double> functionEvaluator = x => (double)evaluationMethod.Invoke(Evaluator, new object[] { x });
+      double bestSolQuality = functionEvaluator(bestSol);
 
       // create perturbed solutions
-      var simplex = new RealVector[bestSol.Length];
+      RealVector[] simplex = new RealVector[bestSol.Length];
       for (int i = 0; i < simplex.Length; i++) {
         simplex[i] = bestSol.Clone() as RealVector;
@@ -172 +145 @@
       for (int i = 0; i < ImprovementAttempts.Value; i++) {
         // order according to their objective function value
-        Array.Sort(simplex, (x, y) => FunctionEvaluator(x).CompareTo(FunctionEvaluator(y)));
+        Array.Sort(simplex, (x, y) => functionEvaluator(x).CompareTo(functionEvaluator(y)));
 
         // calculate centroid
-        var centroid = new RealVector(bestSol.Length);
+        RealVector centroid = new RealVector(bestSol.Length);
         foreach (var vector in simplex)
           for (int j = 0; j < centroid.Length; j++)
@@ -183 +156 @@
 
         // reflection
-        var reflectionPoint = new RealVector(bestSol.Length);
+        RealVector reflectionPoint = new RealVector(bestSol.Length);
         for (int j = 0; j < reflectionPoint.Length; j++)
           reflectionPoint[j] = centroid[j] + Alpha.Value * (centroid[j] - simplex[simplex.Length - 1][j]);
-        double reflectionPointQuality = FunctionEvaluator(reflectionPoint);
-        if (FunctionEvaluator(simplex[0]) <= reflectionPointQuality
-            && reflectionPointQuality < FunctionEvaluator(simplex[simplex.Length - 2]))
+        double reflectionPointQuality = functionEvaluator(reflectionPoint);
+        if (functionEvaluator(simplex[0]) <= reflectionPointQuality
+            && reflectionPointQuality < functionEvaluator(simplex[simplex.Length - 2]))
           simplex[simplex.Length - 1] = reflectionPoint;
 
         // expansion
-        if (reflectionPointQuality < FunctionEvaluator(simplex[0])) {
-          var expansionPoint = new RealVector(bestSol.Length);
+        if (reflectionPointQuality < functionEvaluator(simplex[0])) {
+          RealVector expansionPoint = new RealVector(bestSol.Length);
           for (int j = 0; j < expansionPoint.Length; j++)
             expansionPoint[j] = centroid[j] + Beta.Value * (reflectionPoint[j] - centroid[j]);
-          simplex[simplex.Length - 1] = FunctionEvaluator(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
+          simplex[simplex.Length - 1] = functionEvaluator(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
         }
 
         // contraction
-        if (FunctionEvaluator(simplex[simplex.Length - 2]) <= reflectionPointQuality
-            && reflectionPointQuality < FunctionEvaluator(simplex[simplex.Length - 1])) {
-          var outsideContractionPoint = new RealVector(bestSol.Length);
+        if (functionEvaluator(simplex[simplex.Length - 2]) <= reflectionPointQuality
+            && reflectionPointQuality < functionEvaluator(simplex[simplex.Length - 1])) {
+          RealVector outsideContractionPoint = new RealVector(bestSol.Length);
           for (int j = 0; j < outsideContractionPoint.Length; j++)
             outsideContractionPoint[j] = centroid[j] + Gamma.Value * (reflectionPoint[j] - centroid[j]);
-          if (FunctionEvaluator(outsideContractionPoint) <= reflectionPointQuality) {
+          if (functionEvaluator(outsideContractionPoint) <= reflectionPointQuality) {
             simplex[simplex.Length - 1] = outsideContractionPoint;
-            if (FunctionEvaluator(reflectionPoint) >= FunctionEvaluator(simplex[simplex.Length - 1])) {
-              var insideContractionPoint = new RealVector(bestSol.Length);
+            if (functionEvaluator(reflectionPoint) >= functionEvaluator(simplex[simplex.Length - 1])) {
+              RealVector insideContractionPoint = new RealVector(bestSol.Length);
               for (int j = 0; j < insideContractionPoint.Length; j++)
                 insideContractionPoint[j] = centroid[j] - Gamma.Value * (reflectionPoint[j] - centroid[j]);
-              if (FunctionEvaluator(insideContractionPoint) < FunctionEvaluator(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
+              if (functionEvaluator(insideContractionPoint) < functionEvaluator(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
             }
           }