Skip to content

particle_swarm

particle_swarm(fun, lb, ub, n_particles=100, max_iter=100, momentum=0.9, phi=0.1, verbose=False, topology='full', use_cpp=True)

Particle swarm optimization.

Parameters:

Name Type Description Default
fun callable

Function to minimize

 required
lb (n,) numpy double array

Vector of lower bounds

 required
ub (n,) numpy double array

Vector of upper bounds

 required
n_particles int, optional (default: 100)

Number of particles

 100
max_iter int, optional (default: 1000)

Maximum number of iterations

 100
topology str, optional (default: 'full')

Connectivity of the swarm. Either 'full' or 'ring'.

 'full'
verbose bool, optional (default: False)

Print progress to stdout

 False
use_cpp bool, optional (default: True)

Whether to use the C++ binding when available. Falls back to the pure-Python implementation if the binding cannot be imported.

 True

Returns:

Name Type Description
x (n,) numpy double array

Best solution
f double

Best objective value

Examples:

import numpy as np
from gpytoolbox import particle_swarm
# Minimize a function with a known minimum at x = val
val = 3.5
def fun(x):
    return (x - val)**2
lb = np.array([-10])
ub = np.array([10])
x, f = particle_swarm(fun, lb, ub, max_iter=1000)
# x is now close to val
Source code in src/gpytoolbox/particle_swarm.py 
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
def particle_swarm(fun,lb,ub,n_particles=100,max_iter=100,momentum=0.9,phi=0.1,verbose=False, topology='full', use_cpp=True):
    """Particle swarm optimization.

    Parameters
    ----------
    fun : callable
        Function to minimize
    lb : (n,) numpy double array
        Vector of lower bounds
    ub : (n,) numpy double array
        Vector of upper bounds
    n_particles : int, optional (default: 100)
        Number of particles
    max_iter : int, optional (default: 1000)
        Maximum number of iterations
    topology : str, optional (default: 'full')
        Connectivity of the swarm. Either 'full' or 'ring'.
    verbose : bool, optional (default: False)
        Print progress to stdout
    use_cpp : bool, optional (default: True)
        Whether to use the C++ binding when available. Falls back to the
        pure-Python implementation if the binding cannot be imported.

    Returns
    -------
    x : (n,) numpy double array
        Best solution
    f : double
        Best objective value

    Examples
    --------
    ```python
    import numpy as np
    from gpytoolbox import particle_swarm
    # Minimize a function with a known minimum at x = val
    val = 3.5
    def fun(x):
        return (x - val)**2
    lb = np.array([-10])
    ub = np.array([10])
    x, f = particle_swarm(fun, lb, ub, max_iter=1000)
    # x is now close to val
    ```
    """
    lb = np.asarray(lb, dtype=np.float64)
    ub = np.asarray(ub, dtype=np.float64)

    if use_cpp:
        try:
            from gpytoolbox_bindings import _particle_swarm_cpp_impl
            def _fun_wrapper(x):
                return float(np.squeeze(fun(x)))
            best_x, best_f = _particle_swarm_cpp_impl(
                _fun_wrapper, lb, ub,
                int(n_particles), int(max_iter),
                float(momentum), float(phi),
                bool(verbose), str(topology))
            return best_x, best_f
        except ImportError:
            pass

    current_best_f = np.inf
    n = len(lb)
    x = np.random.uniform(lb,ub,(n_particles,n))
    best_xi = x.copy()
    best_fi = np.inf*np.ones(n_particles)
    for i in range(n_particles):
        # This x
        xi = x[i,:]
        # print(xi)
        f = fun(xi)
        # print(xi)
        best_xi[i,:] = xi.copy()
        best_fi[i] = np.squeeze(f.copy())
        # if verbose:
            # print("Particle %d: f = %f" % (i,f))
        if f < current_best_f:
            current_best_x = xi.copy()
            current_best_f = f.copy()
    # print(current_best_x.reshape((-1, 3)))
    # initialize particle velocities
    velocity_lb = lb - ub
    velocity_ub = ub - lb
    v = np.random.uniform(velocity_lb,velocity_ub,(n_particles,n))

    # Repeat until convergence
    for iter in range(max_iter):
        for i in range(n_particles):
            # Pick random numbers rp and rg between 0 and 1
            rp = np.random.uniform()
            rg = np.random.uniform()
            # Update velocity
            if topology == 'full':
                best_neighbor = current_best_x.copy()
            elif topology == 'ring':
                # Pick the best among the current particle and its two neighbors
                neighbors = np.array([i-1,i,i+1])%n_particles
                xi_neighbors = np.array([best_xi[j,:] for j in neighbors])
                fi_neighbors = np.array([best_fi[j] for j in neighbors])
                best_neighbor = xi_neighbors[np.argmin(fi_neighbors)]
            v[i,:] = momentum*v[i,:] + phi*rp*(best_xi[i,:] - x[i,:]) + phi*rg*(best_neighbor - x[i,:])
            # Update position
            x[i,:] = x[i,:] + v[i,:]
            # Check bounds
            x[i,:] = np.maximum(x[i,:],lb)
            x[i,:] = np.minimum(x[i,:],ub)
            # Evaluate objective
            f = fun(x[i,:])
            # Update best position
            if f < best_fi[i]:
                best_xi[i,:] = x[i,:].copy()
                best_fi[i] = np.squeeze(f.copy())
                if f < current_best_f:
                    current_best_x = x[i,:].copy()
                    current_best_f = f.copy()
        if verbose:
            print("Iteration %d: f = %f" % (iter,current_best_f))
    # print(current_best_x)
    return current_best_x, current_best_f