# 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]
__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, optional – option to explicitly set the particles’ initial positions. Set to None if you wish to generate the particles randomly.

velocity_clamp

tuple, optional – 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, optional) – number of processes to use for parallel particle evaluation Defaut is None with no parallelization. kwargs (dict) – arguments for objective function the local best cost and the local best position among the swarm. tuple