Changeset 5381 for trunk/sources/HeuristicLab.Encodings.RealVectorEncoding

Timestamp:

01/26/11 18:39:49 (14 years ago)

Author:

abeham

Message:

#1395

• Allowed to select the bounds checker to use in all RealVectorManipulator and RealVectorCrossover operators
• Added a second bounds checker, the ReflectiveBoundsChecker which does not cut at the bounds, but mirrors the vector at the bounds
• Use a repeating strategy in the move generators
• Removed obsolete IRealVectorPSODecoder and IRealVectorPSOEncoder interfaces
• Marked RealVectorToRealVectorEncoder as obsolete, internal and removed all meaningful code from it (it slipped into the release and should be thrown out as soon as possible)
• Use a repeating strategy to stick within the bounds in the StdDevStrategyVectorManipulator when manipulating the mutation strengths
• By default use smaller initial bounds in the StdDevStrategyVectorCreator (parameterized by the problem)

Location:

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3

Files:

• BoundsChecker.cs (modified) (1 diff)
• HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj (modified) (2 diffs)
• Moves/AdditiveMoveGenerator.cs (modified) (2 diffs)
• Moves/StochasticNormalMultiMoveGenerator.cs (modified) (1 diff)
• Moves/StochasticPolynomialMultiMoveGenerator.cs (modified) (1 diff)
• RealVectorCrossover.cs (modified) (2 diffs)
• RealVectorManipulator.cs (modified) (2 diffs)
• ReflectiveBoundsChecker.cs (added)
• StrategyParameters/StdDevStrategyVectorManipulator.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/BoundsChecker.cs

@@ -33 +33 @@
   /// If not, the elements are corrected.
   /// </summary>
-  [Item("BoundsChecker", "Checks if all elements of a real vector are inside the bounds. If not, elements are corrected.")]
+  [Item("BoundsChecker", "Checks if all elements of a real vector are inside the bounds. If not, elements are set to the respective values of the bounds.")]
   [StorableClass]
   public class BoundsChecker : SingleSuccessorOperator, IRealVectorBoundsChecker {

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj

@@ -12 +12 @@
     <AssemblyName>HeuristicLab.Encodings.RealVectorEncoding-3.3</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <TargetFrameworkProfile></TargetFrameworkProfile>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
     <SignAssembly>true</SignAssembly>
@@ -157 +158 @@
     <Compile Include="Manipulators\PolynomialOnePositionManipulator.cs" />
     <Compile Include="Manipulators\UniformOnePositionManipulator.cs" />
+    <Compile Include="ReflectiveBoundsChecker.cs" />
     <Compile Include="StrategyParameters\StdDevStrategyVectorCreator.cs" />
     <Compile Include="StrategyParameters\StdDevStrategyVectorCrossover.cs" />

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveGenerator.cs

@@ -65 +65 @@
     public override IOperation Apply() {
       RealVector vector = RealVectorParameter.ActualValue;
-      AdditiveMove[] moves = GenerateMoves(RandomParameter.ActualValue, vector);
       DoubleMatrix bounds = BoundsParameter.ActualValue;
-      if (bounds != null) {
-        for (int i = 0; i < moves.Length; i++) {
-          AdditiveMove move = moves[i];
-          if (vector[move.Dimension] + move.MoveDistance < bounds[move.Dimension % bounds.Rows, 0])
-            vector[move.Dimension] = bounds[move.Dimension % bounds.Rows, 0];
-          else if (vector[move.Dimension] + move.MoveDistance > bounds[move.Dimension % bounds.Rows, 1])
-            vector[move.Dimension] = bounds[move.Dimension % bounds.Rows, 1];
-        }
-      }
+      AdditiveMove[] moves = GenerateMoves(RandomParameter.ActualValue, vector, bounds);
       Scope[] moveScopes = new Scope[moves.Length];
       for (int i = 0; i < moveScopes.Length; i++) {
@@ -85 +76 @@
     }
 
-    protected abstract AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector);
+    protected abstract AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds);
   }
 }

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticNormalMultiMoveGenerator.cs

@@ -52 +52 @@
     }
 
-    public static AdditiveMove[] Apply(IRandom random, RealVector realVector, double sigma, int sampleSize) {
+    public static AdditiveMove[] Apply(IRandom random, RealVector vector, double sigma, int sampleSize, DoubleMatrix bounds) {
       AdditiveMove[] moves = new AdditiveMove[sampleSize];
       NormalDistributedRandom N = new NormalDistributedRandom(random, 0, sigma);
       for (int i = 0; i < sampleSize; i++) {
-        int index = random.Next(realVector.Length);
-        moves[i] = new AdditiveMove(index, N.NextDouble());
+        int index = random.Next(vector.Length);
+        double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1];
+        do {
+          strength = N.NextDouble();
+        } while (vector[index] + strength < min || vector[index] + strength > max);
+        moves[i] = new AdditiveMove(index, strength);
       }
       return moves;
     }
 
-    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector) {
-      return Apply(random, realVector, SigmaParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value);
+    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds) {
+      return Apply(random, realVector, SigmaParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value, bounds);
     }
   }

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticPolynomialMultiMoveGenerator.cs

@@ -62 +62 @@
     }
 
-    public static AdditiveMove[] Apply(IRandom random, RealVector realVector, double contiguity, int sampleSize, double maxManipulation) {
+    public static AdditiveMove[] Apply(IRandom random, RealVector vector, double contiguity, int sampleSize, double maxManipulation, DoubleMatrix bounds) {
       AdditiveMove[] moves = new AdditiveMove[sampleSize];
       for (int i = 0; i < sampleSize; i++) {
-        int index = random.Next(realVector.Length);
-        moves[i] = new AdditiveMove(index, PolynomialOnePositionManipulator.Apply(random, contiguity) * maxManipulation);
+        int index = random.Next(vector.Length);
+        double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1];
+        do {
+          strength = PolynomialOnePositionManipulator.Apply(random, contiguity) * maxManipulation;
+        } while (vector[index] + strength < min || vector[index] + strength > max);
+        moves[i] = new AdditiveMove(index, strength);
       }
       return moves;
     }
 
-    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector) {
-      return Apply(random, realVector, ContiguityParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value, MaximumManipulationParameter.ActualValue.Value);
+    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds) {
+      return Apply(random, realVector, ContiguityParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value, MaximumManipulationParameter.ActualValue.Value, bounds);
     }
   }

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs

@@ -51 +51 @@
       get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
+    public OptionalValueParameter<IRealVectorBoundsChecker> BoundsCheckerParameter {
+      get { return (OptionalValueParameter<IRealVectorBoundsChecker>)Parameters["BoundsChecker"]; }
+    }
 
     [StorableConstructor]
@@ -63 +66 @@
       ChildParameter.ActualName = "RealVector";
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds of the real vector."));
+      Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
     }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code (remove with 3.4)
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("BoundsChecker"))
+        Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
+    }
+    #endregion
 
     public sealed override IOperation Apply() {
       RealVector result = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
-      DoubleMatrix bounds = BoundsParameter.ActualValue;
-      if (bounds != null) BoundsChecker.Apply(result, bounds);
-      ChildParameter.ActualValue = result;
-      return base.Apply();
+
+      IRealVectorBoundsChecker checker = BoundsCheckerParameter.Value;
+      IOperation successor = base.Apply();
+      if (checker != null) {
+        IOperation checkerOperation = ExecutionContext.CreateChildOperation(checker);
+        if (successor == null) return checkerOperation;
+        else return new OperationCollection(checkerOperation, successor);
+      } else return successor;
     }
 

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs

@@ -48 +48 @@
       get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
+    public OptionalValueParameter<IRealVectorBoundsChecker> BoundsCheckerParameter {
+      get { return (OptionalValueParameter<IRealVectorBoundsChecker>)Parameters["BoundsChecker"]; }
+    }
 
     [StorableConstructor]
@@ -57 +60 @@
       Parameters.Add(new LookupParameter<RealVector>("RealVector", "The vector which should be manipulated."));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds of the real vector."));
+      Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
     }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code (remove with 3.4)
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("BoundsChecker"))
+        Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
+    }
+    #endregion
 
     public sealed override IOperation Apply() {
       RealVector vector = RealVectorParameter.ActualValue;
       Manipulate(RandomParameter.ActualValue, vector);
-      DoubleMatrix bounds = BoundsParameter.ActualValue;
-      if (bounds != null) BoundsChecker.Apply(vector, bounds);
-      return base.Apply();
+
+      IRealVectorBoundsChecker checker = BoundsCheckerParameter.Value;
+      IOperation successor = base.Apply();
+      if (checker != null) {
+        IOperation checkerOperation = ExecutionContext.CreateChildOperation(checker);
+        if (successor == null) return checkerOperation;
+        else return new OperationCollection(checkerOperation, successor);
+      } else return successor;
     }
 

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorManipulator.cs

@@ -89 +89 @@
       double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
       for (int i = 0; i < vector.Length; i++) {
-        vector[i] *= generalMultiplier * Math.Exp(learningRate * N.NextDouble());
+        double change = vector[i] * generalMultiplier * Math.Exp(learningRate * N.NextDouble());
         if (bounds != null) {
           double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1];
-          if (vector[i] < min) vector[i] = min;
-          if (vector[i] > max) vector[i] = max;
+          if (min == max) vector[i] = min;
+          else {
+            while (change < min || change > max)
+              change = vector[i] * generalMultiplier * Math.Exp(learningRate * N.NextDouble());
+            vector[i] = change;
+          }
         }
       }