Changeset 5561 for trunk/sources

Timestamp:

02/24/11 19:22:39 (14 years ago)

Author:

mkofler

Message:

#852: Code refactoring. Worked on swarm updater.

Location:

trunk/sources

Files:

• HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs (modified) (7 diffs)
• HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorSwarmUpdater.cs (modified) (1 diff)
• HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs (modified) (5 diffs)
• HeuristicLab.Optimization/3.3/Interfaces/ISwarmUpdater.cs (modified) (1 diff)
• HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs

@@ -114 +114 @@
     private ParticleSwarmOptimizationMainLoop mainLoop;
 
+    [Storable]
+    private CombinedOperator swarmUpdater;
+
     public ITopologyInitializer TopologyInitializer {
       get { return TopologyInitializerParameter.Value; }
@@ -141 +144 @@
       qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
       solutionsCreator = cloner.Clone(original.solutionsCreator);
-      mainLoop = cloner.Clone(original.mainLoop); 
+      mainLoop = cloner.Clone(original.mainLoop);
+      swarmUpdater = cloner.Clone(original.swarmUpdater); 
       Initialize();
     }
@@ -166 +170 @@
       ResultsCollector resultsCollector = new ResultsCollector(); 
       Placeholder analyzerPlaceholder = new Placeholder();
-      RealVectorSwarmUpdater swarmUpdater = new RealVectorSwarmUpdater();
+      swarmUpdater = new CombinedOperator();
       mainLoop = new ParticleSwarmOptimizationMainLoop();
 
@@ -206 +210 @@
       mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
       mainLoop.ResultsParameter.ActualName = "Results";
-      mainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name; 
      // mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
 
@@ -212 +215 @@
       ////InitVelocityBoundsUpdater();
       InitializeParticleCreator();
+      InitializeSwarmUpdater();
       ParameterizeSolutionsCreator(); 
       UpdateAnalyzers();
@@ -252 +256 @@
       UpdateTopologyParameters();
       InitializeParticleCreator();
+      InitializeSwarmUpdater();
       ParameterizeSolutionsCreator(); 
       base.OnProblemChanged();
@@ -395 +400 @@
 
     private void ParameterizeMainLoop() {
-      mainLoop.MaxIterationsParameter.ActualName = MaxIterationsParameter.Name;
+      if (Problem != null) { 
+        mainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      }
+    }
+
+    private void InitializeSwarmUpdater() {
+      if (Problem != null) {
+        ISwarmUpdater updater = Problem.Operators.OfType<ISwarmUpdater>().FirstOrDefault();
+        swarmUpdater.OperatorGraph.InitialOperator = updater;
+      }
     }
     #endregion

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorSwarmUpdater.cs

@@ -25 +25 @@
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IRealVectorSwarmUpdater : ISwarmUpdater, IRealVectorOperator {
-    ILookupParameter<RealVector> NeighborsBestParameter { get; }
-    ILookupParameter<RealVector> PersonalBestParameter { get; }
-    ILookupParameter<RealVector> RealVectorParameter { get; }
+    IScopeTreeLookupParameter<RealVector> NeighborsBestParameter { get; }
+    IScopeTreeLookupParameter<RealVector> PersonalBestParameter { get; }
+    IScopeTreeLookupParameter<RealVector> RealVectorParameter { get; }
   }
 }

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs

@@ -20 +20 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -36 +37 @@
 
     #region Parameter properties
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    public ILookupParameter<DoubleValue> PersonalBestQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["PersonalBestQuality"]; }
-    }
-    public ILookupParameter<DoubleValue> NeighborsBestQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["NeighborsBestQuality"]; }
-    }
-    public ILookupParameter<RealVector> RealVectorParameter {
-      get { return (ILookupParameter<RealVector>)Parameters["RealVector"]; }
-    }
-    public ILookupParameter<RealVector> PersonalBestParameter {
-      get { return (ILookupParameter<RealVector>)Parameters["PersonalBest"]; }
-    }
-    public ILookupParameter<RealVector> NeighborsBestParameter {
-      get { return (ILookupParameter<RealVector>)Parameters["NeighborsBest"]; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> PersonalBestQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["PersonalBestQuality"]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> NeighborsBestQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["NeighborsBestQuality"]; }
+    }
+    public IScopeTreeLookupParameter<RealVector> RealVectorParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["RealVector"]; }
+    }
+    public IScopeTreeLookupParameter<RealVector> PersonalBestParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["PersonalBest"]; }
+    }
+    public IScopeTreeLookupParameter<RealVector> NeighborsBestParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["NeighborsBest"]; }
     }
     public IValueLookupParameter<BoolValue> MaximizationParameter {
       get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
+    public ILookupParameter<DoubleValue> BestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestQuality"]; }
+    }
+    public ILookupParameter<RealVector> BestPointParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["BestPoint"]; }
+    }
+    public IScopeTreeLookupParameter<IntArray> NeighborsParameter {
+      get { return (IScopeTreeLookupParameter<IntArray>)Parameters["Neighbors"]; }
+    }
     #endregion
 
     #region Parameter values
-    private double Quality {
-      get { return QualityParameter.ActualValue.Value; }
-    }
-    private double PersonalBestQuality {
-      get { return PersonalBestQualityParameter.ActualValue.Value; }
-      set { PersonalBestQualityParameter.ActualValue = new DoubleValue(value); }
-    }
-    private double NeighborsBestQuality {
-      get { return NeighborsBestQualityParameter.ActualValue.Value; }
-      set { NeighborsBestQualityParameter.ActualValue = new DoubleValue(value); }
-    }
-    private RealVector RealVector {
+    private DoubleValue BestQuality {
+      get { return BestQualityParameter.ActualValue; }
+    }
+    private RealVector BestPoint {
+      get { return BestPointParameter.ActualValue; }
+      set { BestPointParameter.ActualValue = value; }
+    }
+    private ItemArray<DoubleValue> Quality {
+      get { return QualityParameter.ActualValue; }
+    }
+    private ItemArray<DoubleValue> PersonalBestQuality {
+      get { return PersonalBestQualityParameter.ActualValue; }
+    }
+    private ItemArray<DoubleValue> NeighborsBestQuality {
+      get { return NeighborsBestQualityParameter.ActualValue; }
+    }
+    private ItemArray<RealVector> RealVector {
       get { return RealVectorParameter.ActualValue; }
     }
-    private RealVector PersonalBest {
+    private ItemArray<RealVector> PersonalBest {
       get { return PersonalBestParameter.ActualValue; }
       set { PersonalBestParameter.ActualValue = value; }
     }
-    private RealVector NeighborsBest {
+    private ItemArray<RealVector> NeighborsBest {
       get { return NeighborsBestParameter.ActualValue; }
       set { NeighborsBestParameter.ActualValue = value; }
@@ -84 +99 @@
     private bool Maximization {
       get { return MaximizationParameter.ActualValue.Value; }
+    }
+    private ItemArray<IntArray> Neighbors {
+      get { return NeighborsParameter.ActualValue; }
     }
     #endregion
@@ -94 +112 @@
     public RealVectorSwarmUpdater()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "Particle's quality"));
-      Parameters.Add(new LookupParameter<DoubleValue>("PersonalBestQuality", "Particle's personal best quality"));
-      Parameters.Add(new LookupParameter<DoubleValue>("NeighborsBestQuality", "Global best particle quality"));
-      Parameters.Add(new LookupParameter<RealVector>("RealVector", "Particle's position"));
-      Parameters.Add(new LookupParameter<RealVector>("PersonalBest", "Particle's personal best position"));
-      Parameters.Add(new LookupParameter<RealVector>("NeighborsBest", "Neighborhood (or global in case of totally connected neighborhood) best particle position"));
+      Parameters.Add(new LookupParameter<DoubleValue>("BestQuality", "Overall best quality."));
+      Parameters.Add(new LookupParameter<RealVector>("BestPoint", "Global best particle position"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "Particle's quality"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("PersonalBestQuality", "Particle's personal best quality"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("NeighborsBestQuality", "Global best particle quality"));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "Particle's position"));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("PersonalBest", "Particle's personal best position"));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("NeighborsBest", "Neighborhood (or global in case of totally connected neighborhood) best particle position"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntArray>("Neighbors", "The list of neighbors for each particle."));
       Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
     }
@@ -110 +131 @@
 
     public override IOperation Apply() {
-      if (Maximization && Quality > PersonalBestQuality ||
-         !Maximization && Quality < PersonalBestQuality) {
-        PersonalBestQuality = Quality;
-        PersonalBest = RealVector;
-        if (Maximization && PersonalBestQuality > NeighborsBestQuality ||
-           !Maximization && PersonalBestQuality < NeighborsBestQuality) {
-             NeighborsBestQuality = PersonalBestQuality;
-             NeighborsBest = PersonalBest;
-        }
-      }
+      InitializeBestPoint();
+      UpdateNeighbors();
+      UpdateVelocityBounds();
+      UpdateSwarm();
       return base.Apply();
+    }
+
+    private void InitializeBestPoint() {
+      if (BestQuality == null)
+        BestQualityParameter.ActualValue = new DoubleValue(); 
+      BestQuality.Value = Maximization ? Quality.Max(v => v.Value) : Quality.Min(v => v.Value);
+      int bestIndex = Quality.FindIndex(v => v.Value == BestQuality.Value);
+      BestPoint = (RealVector)RealVector[bestIndex].Clone();
+    }
+
+    private void UpdateNeighbors() {
+      if (Neighbors != null & Neighbors.Length > 0) {
+        if (this.NeighborsBest == null || NeighborsBest.Length != Neighbors.Length)
+          NeighborsBest = new ItemArray<RealVector>(Neighbors.Length);
+        for (int n = 0; n < Neighbors.Length; n++) {
+          var pairs = Quality.Zip(RealVector, (q, p) => new { Quality = q, Point = p })
+            .Where((p, i) => i == n || Neighbors[n].Contains(i));
+          NeighborsBest[n] = Maximization ?
+          pairs.OrderByDescending(p => p.Quality.Value).First().Point :
+          pairs.OrderBy(p => p.Quality.Value).First().Point;
+        }
+        NeighborsBestParameter.ActualValue = NeighborsBest;
+      }
+    }
+
+    private void UpdateVelocityBounds() {
+      // ToDo: Add code
+    }
+
+    private void UpdateSwarm() {
+      if (PersonalBestQuality.Length == 0) {
+        PersonalBestQualityParameter.ActualValue = new ItemArray<DoubleValue>(RealVector.Length);
+        for (int i = 0; i < RealVector.Length; i++) {
+          if (Maximization) {
+            PersonalBestQuality[i] = new DoubleValue();
+          } else {
+            PersonalBestQuality[i] = new DoubleValue(double.MaxValue); 
+          }
+        }
+      }
+      if (NeighborsBestQuality.Length == 0) {
+        NeighborsBestQualityParameter.ActualValue = new ItemArray<DoubleValue>(RealVector.Length);
+        for (int i = 0; i < RealVector.Length; i++) {
+          if (Maximization) {
+            NeighborsBestQuality[i] = new DoubleValue();
+          } else {
+            NeighborsBestQuality[i] = new DoubleValue(double.MaxValue);
+          }
+        }
+      }
+      if (NeighborsBest.Length == 0) {
+        NeighborsBestParameter.ActualValue = new ItemArray<RealVector>(RealVector.Length);
+      }
+      for (int i = 0; i < RealVector.Length; i++) {
+        if (Maximization && Quality[i].Value > PersonalBestQuality[i].Value ||
+          !Maximization && Quality[i].Value < PersonalBestQuality[i].Value) {
+          PersonalBestQuality[i].Value = Quality[i].Value;
+          PersonalBest[i] = RealVector[i];
+          if (Maximization && PersonalBestQuality[i].Value > NeighborsBestQuality[i].Value ||
+             !Maximization && PersonalBestQuality[i].Value < NeighborsBestQuality[i].Value) {
+            NeighborsBestQuality[i].Value = PersonalBestQuality[i].Value;
+            NeighborsBest[i] = PersonalBest[i];
+          }
+        }
+      }
     }
 

trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISwarmUpdater.cs

@@ -25 +25 @@
 namespace HeuristicLab.Optimization {
   public interface ISwarmUpdater : IOperator {
-    ILookupParameter<DoubleValue> QualityParameter { get; }
-    ILookupParameter<DoubleValue> NeighborsBestQualityParameter { get; }
-    ILookupParameter<DoubleValue> PersonalBestQualityParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> NeighborsBestQualityParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> PersonalBestQualityParameter { get; }
     IValueLookupParameter<BoolValue> MaximizationParameter { get; }
   }

trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs

@@ -412 +412 @@
         op.BoundsParameter.ActualName = BoundsParameter.Name; 
       }
+      foreach (IRealVectorSwarmUpdater op in Operators.OfType<IRealVectorSwarmUpdater>()) {
+        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.MaximizationParameter.ActualName = MaximizationParameter.Name; 
+      }
     }
     private void UpdateStrategyVectorBounds() {