pyswarm 0.7.0__py3-none-any.whl

pyswarm/__init__.py

@@ -0,0 +1,17 @@
+"""
+================================================================================
+pyswarm: Particle swarm optimization (PSO) with constraint support
+================================================================================
+
+Authors: Abraham Lee
+         Sebastian Castillo-Hair
+Copyright: 2013-2015
+
+"""
+# from __future__ import absolute_import
+
+__author__ = 'Abraham Lee'
+__version__ = '0.7.0'
+
+from pyswarm.pso import *
+    

pyswarm/pso.py

@@ -0,0 +1,234 @@
+from functools import partial
+import numpy as np
+
+def _obj_wrapper(func, args, kwargs, x):
+    return func(x, *args, **kwargs)
+
+def _is_feasible_wrapper(func, x):
+    return np.all(func(x)>=0)
+
+def _cons_none_wrapper(x):
+    return np.array([0])
+
+def _cons_ieqcons_wrapper(ieqcons, args, kwargs, x):
+    return np.array([y(x, *args, **kwargs) for y in ieqcons])
+
+def _cons_f_ieqcons_wrapper(f_ieqcons, args, kwargs, x):
+    return np.array(f_ieqcons(x, *args, **kwargs))
+    
+def pso(func, lb, ub, ieqcons=[], f_ieqcons=None, args=(), kwargs={}, 
+        swarmsize=100, omega=0.5, phip=0.5, phig=0.5, maxiter=100, 
+        minstep=1e-8, minfunc=1e-8, debug=False, processes=1,
+        particle_output=False):
+    """
+    Perform a particle swarm optimization (PSO)
+   
+    Parameters
+    ==========
+    func : function
+        The function to be minimized
+    lb : array
+        The lower bounds of the design variable(s)
+    ub : array
+        The upper bounds of the design variable(s)
+   
+    Optional
+    ========
+    ieqcons : list
+        A list of functions of length n such that ieqcons[j](x,*args) >= 0.0 in 
+        a successfully optimized problem (Default: [])
+    f_ieqcons : function
+        Returns a 1-D array in which each element must be greater or equal 
+        to 0.0 in a successfully optimized problem. If f_ieqcons is specified, 
+        ieqcons is ignored (Default: None)
+    args : tuple
+        Additional arguments passed to objective and constraint functions
+        (Default: empty tuple)
+    kwargs : dict
+        Additional keyword arguments passed to objective and constraint 
+        functions (Default: empty dict)
+    swarmsize : int
+        The number of particles in the swarm (Default: 100)
+    omega : scalar
+        Particle velocity scaling factor (Default: 0.5)
+    phip : scalar
+        Scaling factor to search away from the particle's best known position
+        (Default: 0.5)
+    phig : scalar
+        Scaling factor to search away from the swarm's best known position
+        (Default: 0.5)
+    maxiter : int
+        The maximum number of iterations for the swarm to search (Default: 100)
+    minstep : scalar
+        The minimum stepsize of swarm's best position before the search
+        terminates (Default: 1e-8)
+    minfunc : scalar
+        The minimum change of swarm's best objective value before the search
+        terminates (Default: 1e-8)
+    debug : boolean
+        If True, progress statements will be displayed every iteration
+        (Default: False)
+    processes : int
+        The number of processes to use to evaluate objective function and 
+        constraints (default: 1)
+    particle_output : boolean
+        Whether to include the best per-particle position and the objective
+        values at those.
+   
+    Returns
+    =======
+    g : array
+        The swarm's best known position (optimal design)
+    f : scalar
+        The objective value at ``g``
+    p : array
+        The best known position per particle
+    pf: arrray
+        The objective values at each position in p
+   
+    """
+   
+    assert len(lb)==len(ub), 'Lower- and upper-bounds must be the same length'
+    assert hasattr(func, '__call__'), 'Invalid function handle'
+    lb = np.array(lb)
+    ub = np.array(ub)
+    assert np.all(ub>lb), 'All upper-bound values must be greater than lower-bound values'
+   
+    vhigh = np.abs(ub - lb)
+    vlow = -vhigh
+
+    # Initialize objective function
+    obj = partial(_obj_wrapper, func, args, kwargs)
+    
+    # Check for constraint function(s) #########################################
+    if f_ieqcons is None:
+        if not len(ieqcons):
+            if debug:
+                print('No constraints given.')
+            cons = _cons_none_wrapper
+        else:
+            if debug:
+                print('Converting ieqcons to a single constraint function')
+            cons = partial(_cons_ieqcons_wrapper, ieqcons, args, kwargs)
+    else:
+        if debug:
+            print('Single constraint function given in f_ieqcons')
+        cons = partial(_cons_f_ieqcons_wrapper, f_ieqcons, args, kwargs)
+    is_feasible = partial(_is_feasible_wrapper, cons)
+
+    # Initialize the multiprocessing module if necessary
+    if processes > 1:
+        import multiprocessing
+        mp_pool = multiprocessing.Pool(processes)
+        
+    # Initialize the particle swarm ############################################
+    S = swarmsize
+    D = len(lb)  # the number of dimensions each particle has
+    x = np.random.rand(S, D)  # particle positions
+    v = np.zeros_like(x)  # particle velocities
+    p = np.zeros_like(x)  # best particle positions
+    fx = np.zeros(S)  # current particle function values
+    fs = np.zeros(S, dtype=bool)  # feasibility of each particle
+    fp = np.ones(S)*np.inf  # best particle function values
+    g = []  # best swarm position
+    fg = np.inf  # best swarm position starting value
+    
+    # Initialize the particle's position
+    x = lb + x*(ub - lb)
+
+    # Calculate objective and constraints for each particle
+    if processes > 1:
+        fx = np.array(mp_pool.map(obj, x))
+        fs = np.array(mp_pool.map(is_feasible, x))
+    else:
+        for i in range(S):
+            fx[i] = obj(x[i, :])
+            fs[i] = is_feasible(x[i, :])
+       
+    # Store particle's best position (if constraints are satisfied)
+    i_update = np.logical_and((fx < fp), fs)
+    p[i_update, :] = x[i_update, :].copy()
+    fp[i_update] = fx[i_update]
+
+    # Update swarm's best position
+    i_min = np.argmin(fp)
+    if fp[i_min] < fg:
+        fg = fp[i_min]
+        g = p[i_min, :].copy()
+    else:
+        # At the start, there may not be any feasible starting point, so just
+        # give it a temporary "best" point since it's likely to change
+        g = x[0, :].copy()
+       
+    # Initialize the particle's velocity
+    v = vlow + np.random.rand(S, D)*(vhigh - vlow)
+       
+    # Iterate until termination criterion met ##################################
+    it = 1
+    while it <= maxiter:
+        rp = np.random.uniform(size=(S, D))
+        rg = np.random.uniform(size=(S, D))
+
+        # Update the particles velocities
+        v = omega*v + phip*rp*(p - x) + phig*rg*(g - x)
+        # Update the particles' positions
+        x = x + v
+        # Correct for bound violations
+        maskl = x < lb
+        masku = x > ub
+        x = x*(~np.logical_or(maskl, masku)) + lb*maskl + ub*masku
+
+        # Update objectives and constraints
+        if processes > 1:
+            fx = np.array(mp_pool.map(obj, x))
+            fs = np.array(mp_pool.map(is_feasible, x))
+        else:
+            for i in range(S):
+                fx[i] = obj(x[i, :])
+                fs[i] = is_feasible(x[i, :])
+
+        # Store particle's best position (if constraints are satisfied)
+        i_update = np.logical_and((fx < fp), fs)
+        p[i_update, :] = x[i_update, :].copy()
+        fp[i_update] = fx[i_update]
+
+        # Compare swarm's best position with global best position
+        i_min = np.argmin(fp)
+        if fp[i_min] < fg:
+            if debug:
+                print('New best for swarm at iteration {:}: {:} {:}'\
+                    .format(it, p[i_min, :], fp[i_min]))
+
+            p_min = p[i_min, :].copy()
+            stepsize = np.sqrt(np.sum((g - p_min)**2))
+
+            if np.abs(fg - fp[i_min]) <= minfunc:
+                print('Stopping search: Swarm best objective change less than {:}'\
+                    .format(minfunc))
+                if particle_output:
+                    return p_min, fp[i_min], p, fp
+                else:
+                    return p_min, fp[i_min]
+            elif stepsize <= minstep:
+                print('Stopping search: Swarm best position change less than {:}'\
+                    .format(minstep))
+                if particle_output:
+                    return p_min, fp[i_min], p, fp
+                else:
+                    return p_min, fp[i_min]
+            else:
+                g = p_min.copy()
+                fg = fp[i_min]
+
+        if debug:
+            print('Best after iteration {:}: {:} {:}'.format(it, g, fg))
+        it += 1
+
+    print('Stopping search: maximum iterations reached --> {:}'.format(maxiter))
+    
+    if not is_feasible(g):
+        print("However, the optimization couldn't find a feasible design. Sorry")
+    if particle_output:
+        return g, fg, p, fp
+    else:
+        return g, fg

pyswarm-0.7.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pyswarm
+Version: 0.7.0
+Summary: Particle swarm optimization (PSO) with constraint support
+Home-page: https://github.com/tisimst/pyswarm
+Author: Abraham Lee
+Author-email: tisimst@gmail.com
+License: BSD License
+Keywords: PSO,particle swarm optimization,optimization,python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+=========================================================
+Particle swarm optimization (PSO) with constraint support
+=========================================================
+
+The ``pyswarm`` package is a gradient-free, evolutionary optimization package 
+for python that supports constraints.
+
+What's New
+==========
+
+This release features multiprocessing support.
+
+Requirements
+============
+
+- NumPy
+
+Installation and download
+=========================
+
+See the `package homepage`_ for helpful hints relating to downloading
+and installing pyswarm.
+
+
+Source Code
+===========
+
+The latest, bleeding-edge, but working, `code
+<https://github.com/tisimst/pyDOE/tree/master/pyswarm>`_
+and `documentation source
+<https://github.com/tisimst/pyswarm/tree/master/doc/>`_ are
+available `on GitHub <https://github.com/tisimst/pyswarm/>`_.
+
+Contact
+=======
+
+Any feedback, questions, bug reports, or success stores should
+be sent to the `author`_. I'd love to hear from you!
+
+License
+=======
+
+This package is provided under two licenses:
+
+1. The *BSD License*
+2. Any other that the author approves (just ask!)
+
+References
+==========
+
+- `Particle swarm optimization`_ on Wikipedia
+
+.. _author: mailto:tisimst@gmail.com
+.. _Particle swarm optimization: http://en.wikipedia.org/wiki/Particle_swarm_optimization
+.. _package homepage: http://pythonhosted.org/pyswarm

pyswarm-0.7.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+pyswarm/__init__.py,sha256=31IekRDjnoW1gOUKWEpt6E6XN1_lAIkoyufJsFp3EBc,454
+pyswarm/pso.py,sha256=_I8XeGGCi_m1TdvT5YhMbfSI01e1TPM_Beg8mddpE5E,8374
+pyswarm-0.7.0.dist-info/METADATA,sha256=yCfgnoMQgTe3lWy6jp_TJUlghGTNWxbThgADUXhbEes,2768
+pyswarm-0.7.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyswarm-0.7.0.dist-info/top_level.txt,sha256=vWlGQiprJPdLXlglfuM1_U7yfhgvNGd9JBmwdHjTa2g,8
+pyswarm-0.7.0.dist-info/RECORD,,

pyswarm-0.7.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyswarm-0.7.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyswarm