pyswarms.discrete package

The pyswarms.discrete module implements various techniques in discrete optimization. These are techniques that can be applied to a discrete search-space.

pyswarms.discrete.binary module

A Binary Particle Swarm Optimization (binary PSO) algorithm.

It takes a set of candidate solutions, and tries to find the best solution using a position-velocity update method. Unlike pyswarms.single.gb and pyswarms.single.lb, this technique is often applied to discrete binary problems such as job-shop scheduling, sequencing, and the like.

The update rule for the velocity is still similar, as shown in the proceeding equation:

\[v_{ij}(t + 1) = m * v_{ij}(t) + c_{1}r_{1j}(t)[y_{ij}(t) − x_{ij}(t)] + c_{2}r_{2j}(t)[\hat{y}_{j}(t) − x_{ij}(t)]\]

For the velocity update rule, a particle compares its current position with respect to its neighbours. The nearest neighbours are being determined by a kD-tree given a distance metric, similar to local-best PSO. The neighbours are computed for every iteration. However, this whole behavior can be modified into a global-best PSO by changing the nearest neighbours equal to the number of particles in the swarm. In this case, all particles see each other, and thus a global best particle can be established.

In addition, one notable change for binary PSO is that the position update rule is now decided upon by the following case expression:

\[\begin{split}X_{ij}(t+1) = \left\{\begin{array}{lr} 0, & \text{if } \text{rand() } \geq S(v_{ij}(t+1))\\ 1, & \text{if } \text{rand() } < S(v_{ij}(t+1)) \end{array}\right\}\end{split}\]

Where the function \(S(x)\) is the sigmoid function defined as:

\[S(x) = \dfrac{1}{1 + e^{-x}}\]

This enables the algorithm to output binary positions rather than a stream of continuous values as seen in global-best or local-best PSO.

This algorithm was adapted from the standard Binary PSO work of J. Kennedy and R.C. Eberhart in Particle Swarm Optimization [SMC1997].

[SMC1997]J. Kennedy and R.C. Eberhart, “A discrete binary version of particle swarm algorithm,” Proceedings of the IEEE International Conference on Systems, Man, and Cybernetics, 1997.
class pyswarms.discrete.binary.BinaryPSO(n_particles, dimensions, options, init_pos=None, velocity_clamp=None, vh_strategy='unmodified', ftol=-inf)[source]

Bases: pyswarms.base.base_discrete.DiscreteSwarmOptimizer

__init__(n_particles, dimensions, options, init_pos=None, velocity_clamp=None, vh_strategy='unmodified', ftol=-inf)[source]

Initialize the swarm

n_particles

int – number of particles in the swarm.

dimensions

int – number of dimensions in the space.

options

dict with keys {'c1', 'c2', 'k', 'p'} – a dictionary containing the parameters for the specific optimization technique

  • c1 : float
    cognitive parameter
  • c2 : float
    social parameter
  • w : float
    inertia parameter
  • k : int
    number of neighbors to be considered. Must be a positive integer less than n_particles
  • p: int {1,2}
    the Minkowski p-norm to use. 1 is the sum-of-absolute values (or L1 distance) while 2 is the Euclidean (or L2) distance.
init_pos

numpy.ndarray (default is None) – option to explicitly set the particles’ initial positions. Set to None if you wish to generate the particles randomly.

velocity_clamp

tuple (default is None) – a tuple of size 2 where the first entry is the minimum velocity and the second entry is the maximum velocity. It sets the limits for velocity clamping.

vh_strategy

String – a strategy for the handling of the velocity of out-of-bounds particles. Only the “unmodified” and the “adjust” strategies are allowed.

ftol

float – relative error in objective_func(best_pos) acceptable for convergence

optimize(objective_func, iters, n_processes=None, **kwargs)[source]

Optimize the swarm for a number of iterations

Performs the optimization to evaluate the objective function f for a number of iterations iter.

Parameters:
  • objective_func (function) – objective function to be evaluated
  • iters (int) – number of iterations
  • n_processes (int) – number of processes to use for parallel particle evaluation (default: None = no parallelization)
  • kwargs (dict) – arguments for objective function
Returns:

the local best cost and the local best position among the swarm.
Return type:

tuple