Changeset 15181 for trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/AdaptiveRandomTopologyUpdater.cs

Timestamp:

07/10/17 17:26:43 (7 years ago)

Author:

abeham

Message:

#2797:

• Added IStochasticOperator interface to MultiPSOTopologyUpdater
• Changed parameter defaults to those described in the paper
• Added analyzer placeholder for the last iteration (has not been previously analyzed)
• Changed random topology initializer to include itself (to be able to use it with SPSOSwarmUpdater -> this should not change the old RealVectorSwarmUpdater)
• Changed ring topology initializer to include itself (same as above)
• Changed von neumann topology initializer to include itself (same as above)
• Added SPSO compatible random topology initializer (as described in the paper by Clerc)
• Changed sampling of the random directional vector to be uniformly random on the surface of a hypersphere to avoid a slight bias in diagonal direction
• Updating SwarmBestQuality and BestRealVector parameters in SPSOSwarmUpdater (an oversight)
• Added a faster method to create a copy of a RealVector (based on Array.Copy)
• Updated the sample
• Updated the sample's test results (due to changed sampling in SPSO2011ParticleUpdater)

File:

• trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/AdaptiveRandomTopologyUpdater.cs (copied) (copied from trunk/sources/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/MultiPSOTopologyUpdater.cs) (3 diffs)

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

@@ -31 +31 @@
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
-  [Item("Multi PSO Topology Updater", "Splits swarm into NrOfSwarms non-overlapping sub-swarms. Swarms are re-grouped every regroupingPeriod iteration. The operator is implemented as described in Liang, J.J. and Suganthan, P.N 2005. Dynamic multi-swarm particle swarm optimizer. IEEE Swarm Intelligence Symposium, pp. 124-129.")]
+  [Item("SPSO Adaptive Random Topology Updater", "Each unsuccessful iteration the topology initializer is applied again.")]
   [StorableClass]
-  public sealed class MultiPSOTopologyUpdater : SingleSuccessorOperator, ITopologyUpdater {
+  public sealed class SPSOAdaptiveRandomTopologyUpdater : SingleSuccessorOperator, ITopologyUpdater, ISingleObjectiveOperator {
 
     public override bool CanChangeName {
@@ -40 +40 @@
 
     #region Parameters
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public IValueLookupParameter<IntValue> NrOfSwarmsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["NrOfSwarms"]; }
+    public ILookupParameter<DoubleValue> SwarmBestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["SwarmBestQuality"]; }
     }
-    public ILookupParameter<IntValue> SwarmSizeParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["SwarmSize"]; }
+    public ILookupParameter<DoubleValue> PreviousBestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PreviousBestQuality"]; }
+    }
+    public ILookupParameter<ITopologyInitializer> TopologyInitializerParameter {
+      get { return (ILookupParameter<ITopologyInitializer>)Parameters["TopologyInitializer"]; }
     }
     public IScopeTreeLookupParameter<IntArray> NeighborsParameter {
       get { return (IScopeTreeLookupParameter<IntArray>)Parameters["Neighbors"]; }
-    }
-    public ILookupParameter<IntValue> CurrentIterationParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["CurrentIteration"]; }
-    }
-    public IValueLookupParameter<IntValue> RegroupingPeriodParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["RegroupingPeriod"]; }
-    }
-    #endregion
-
-    #region Parameter Values
-    private IRandom Random {
-      get { return RandomParameter.ActualValue; }
-    }
-    private int NrOfSwarms {
-      get { return NrOfSwarmsParameter.ActualValue.Value; }
-    }
-    private int SwarmSize {
-      get { return SwarmSizeParameter.ActualValue.Value; }
-    }
-    private ItemArray<IntArray> Neighbors {
-      get { return NeighborsParameter.ActualValue; }
-      set { NeighborsParameter.ActualValue = value; }
-    }
-    private int CurrentIteration {
-      get { return CurrentIterationParameter.ActualValue.Value; }
-    }
-    private int RegroupingPeriod {
-      get { return RegroupingPeriodParameter.ActualValue.Value; }
     }
     #endregion
@@ -84 +59 @@
     #region Construction & Cloning
     [StorableConstructor]
-    private MultiPSOTopologyUpdater(bool deserializing) : base(deserializing) { }
-    private MultiPSOTopologyUpdater(MultiPSOTopologyUpdater original, Cloner cloner) : base(original, cloner) { }
-    public MultiPSOTopologyUpdater()
+    private SPSOAdaptiveRandomTopologyUpdater(bool deserializing) : base(deserializing) { }
+    private SPSOAdaptiveRandomTopologyUpdater(SPSOAdaptiveRandomTopologyUpdater original, Cloner cloner) : base(original, cloner) { }
+    public SPSOAdaptiveRandomTopologyUpdater()
       : base() {
-      Parameters.Add(new LookupParameter<IRandom>("Random", "A random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("NrOfSwarms", "Nr of connected sub-swarms.", new IntValue(3)));
-      Parameters.Add(new LookupParameter<IntValue>("SwarmSize", "Number of particles in the swarm."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "Whether the problem is to be maximized or not."));
+      Parameters.Add(new LookupParameter<DoubleValue>("SwarmBestQuality", "The swarm's best quality."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PreviousBestQuality", "The best quality of the previous iteration."));
+      Parameters.Add(new LookupParameter<ITopologyInitializer>("TopologyInitializer", "The topology initializer is called again in case no improvement is made."));
       Parameters.Add(new ScopeTreeLookupParameter<IntArray>("Neighbors", "The list of neighbors for each particle."));
-      Parameters.Add(new LookupParameter<IntValue>("CurrentIteration", "The current iteration of the algorithm."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("RegroupingPeriod", "Update interval (=iterations) for regrouping of neighborhoods.", new IntValue(5)));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiPSOTopologyUpdater(this, cloner);
+      return new SPSOAdaptiveRandomTopologyUpdater(this, cloner);
     }
     #endregion
 
     public override IOperation Apply() {
-      if (CurrentIteration > 0 && CurrentIteration % RegroupingPeriod == 0) {
-        ItemArray<IntArray> neighbors = new ItemArray<IntArray>(SwarmSize);
+      var swarmBest = SwarmBestQualityParameter.ActualValue;
+      if (swarmBest == null) return base.Apply();
 
-        var particles = Enumerable.Range(0, SwarmSize).ToList();
-        for (int i = SwarmSize-1; i>0; i--) {
-          int j = Random.Next(i+1);
-          int t = particles[j];
-          particles[j] = particles[i];
-          particles[i] = t;
-        }
+      var previousBest = PreviousBestQualityParameter.ActualValue;
+      if (previousBest == null) {
+        PreviousBestQualityParameter.ActualValue = new DoubleValue(swarmBest.Value);
+        return base.Apply();
+      };
 
-        for (int partitionNr = 0; partitionNr<NrOfSwarms; partitionNr++) {
-          int start = partitionNr*SwarmSize/NrOfSwarms;
-          int end = (partitionNr+1)*SwarmSize/NrOfSwarms;
-          for (int i = start; i<end; i++)
-            neighbors[particles[i]] = GetSegment(particles, start, end, i);
-        }
+      var successor = new OperationCollection(new[] { base.Apply() });
+      var max = MaximizationParameter.ActualValue.Value;
+      if (max && swarmBest.Value >= previousBest.Value
+        || !max && swarmBest.Value <= previousBest.Value)
+        successor.Insert(0, ExecutionContext.CreateOperation(TopologyInitializerParameter.ActualValue));
 
-        Neighbors = neighbors;
-      }
-      return base.Apply();
-    }
-
-    public static IntArray GetSegment(IEnumerable<int> list, int start, int end, int excludedIndex) {
-      return new IntArray(list
-        .Skip(start)
-        .Take(end-start)
-        .Where((p, j) => start+j != excludedIndex)
-        .ToArray());
+      previousBest.Value = swarmBest.Value;
+      return successor;
     }
   }