Feature parameterize obj

examples/basic_optimization_with_arguments.ipynb

@@ -0,0 +1,200 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Basic Optimization with Arguments"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here, we will run a basic optimization using an objective function that needs parameterization.  We will use the ``single.GBestPSO`` and a version of the rosenbrock function to demonstrate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running Python 3.5.2 |Anaconda custom (64-bit)| (default, Jul  2 2016, 17:53:06) \n",
+      "[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "# change directory to access pyswarms\n",
+    "sys.path.append('../')\n",
+    "\n",
+    "print(\"Running Python {}\".format(sys.version))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false,
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# import modules\n",
+    "import numpy as np\n",
+    "\n",
+    "# create a parameterized version of the classic Rosenbrock unconstrained optimzation function\n",
+    "def rosenbrock_with_args(x, a, b):\n",
+    "\n",
+    "    f = (a - x[:, 0]) ** 2 + b * (x[:, 1] - x[:, 0] ** 2) ** 2\n",
+    "    return f"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using Arguments"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Arguments can either be passed in using a tuple or a dictionary, using the ``args=()`` and ``kwargs={}`` paradigm. First lets optimize the Rosenbrock function using args.  Note in the definition of the Rosenbrock function above, there were two arguments that need to be passed other than the design variables, ``a``, and ``b``."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:pyswarms.single.global_best:Iteration 1/1000, cost: 17849.1066764\n",
+      "INFO:pyswarms.single.global_best:Iteration 101/1000, cost: 0.0127720296794\n",
+      "INFO:pyswarms.single.global_best:Iteration 201/1000, cost: 0.00118393018803\n",
+      "INFO:pyswarms.single.global_best:Iteration 301/1000, cost: 1.93661349444e-06\n",
+      "INFO:pyswarms.single.global_best:Iteration 401/1000, cost: 7.54187359817e-08\n",
+      "INFO:pyswarms.single.global_best:Iteration 501/1000, cost: 1.56235319713e-10\n",
+      "INFO:pyswarms.single.global_best:Iteration 601/1000, cost: 7.2848456422e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 701/1000, cost: 5.93891975854e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 801/1000, cost: 4.24299200168e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 901/1000, cost: 3.70662128431e-11\n",
+      "INFO:pyswarms.single.global_best:================================\n",
+      "Optimization finished!\n",
+      "Final cost: 0.0000\n",
+      "Best value: [0.99999402891984257, 0.99998804008671482]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pyswarms.single.global_best import GlobalBestPSO\n",
+    "\n",
+    "# instatiate the optimizer\n",
+    "x_max = 10 * np.ones(2)\n",
+    "x_min = -1 * x_max\n",
+    "bounds = (x_min, x_max)\n",
+    "options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}\n",
+    "optimizer = GlobalBestPSO(n_particles=10, dimensions=2, options=options, bounds=bounds)\n",
+    "\n",
+    "# now run the optimization, pass a=1 and b=100 as a tuple assigned to args\n",
+    "args = (1.0, 100.0)\n",
+    "cost, pos = optimizer.optimize(rosenbrock_with_args, iters=1000, args=args, print_step=100, verbose=3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now lets use kwargs to parameterize the model instead."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:pyswarms.single.global_best:Iteration 1/1000, cost: 3.56818109307e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 101/1000, cost: 3.55379244278e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 201/1000, cost: 3.5520228268e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 301/1000, cost: 3.55181104999e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 401/1000, cost: 3.55171536074e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 501/1000, cost: 3.55165535881e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 601/1000, cost: 3.55163343941e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 701/1000, cost: 3.55162583716e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 801/1000, cost: 3.55162357208e-11\n",
+      "INFO:pyswarms.single.global_best:Iteration 901/1000, cost: 3.55162279771e-11\n",
+      "INFO:pyswarms.single.global_best:================================\n",
+      "Optimization finished!\n",
+      "Final cost: 0.0000\n",
+      "Best value: [0.99999404111206025, 0.99998807338372564]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "kwargs={\"a\": 1.0, \"b\": 100.0}\n",
+    "cost, pos = optimizer.optimize(rosenbrock_with_args, iters=1000, kwargs=kwargs, print_step=100, verbose=3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python [conda env:anaconda3]",
+   "language": "python",
+   "name": "conda-env-anaconda3-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

pyswarms/base/base_discrete.py

@@ -193,7 +193,7 @@ def _populate_history(self, hist):
         self.pos_history.append(hist.position)
         self.velocity_history.append(hist.velocity)
 
-    def optimize(self, objective_func, iters, print_step=1, verbose=1):
+    def optimize(self, objective_func, iters, args=(), kwargs={}, print_step=1, verbose=1):
         """Optimizes the swarm for a number of iterations.
 
         Performs the optimization to evaluate the objective

pyswarms/base/base_single.py

@@ -224,7 +224,7 @@ def _populate_history(self, hist):
         self.pos_history.append(hist.position)
         self.velocity_history.append(hist.velocity)
 
-    def optimize(self, objective_func, iters, print_step=1, verbose=1):
+    def optimize(self, objective_func, iters, args=(), kwargs={}, print_step=1, verbose=1):
         """Optimizes the swarm for a number of iterations.
 
         Performs the optimization to evaluate the objective

pyswarms/discrete/binary.py

@@ -149,7 +149,7 @@ def __init__(
         # Initialize the topology
         self.top = Ring()
 
-    def optimize(self, objective_func, iters, print_step=1, verbose=1):
+    def optimize(self, objective_func, iters, args=(), kwargs={}, print_step=1, verbose=1):
         """Optimizes the swarm for a number of iterations.
 
         Performs the optimization to evaluate the objective
@@ -172,10 +172,13 @@ def optimize(self, objective_func, iters, print_step=1, verbose=1):
             the local best cost and the local best position among the
             swarm.
         """
+        cli_print("Arguments Passed to Objective Function: \nargs: %s \nkwargs: %s\n" % (args, kwargs),
+                  verbose, 2, logger=self.logger)
+
         for i in range(iters):
             # Compute cost for current position and personal best
-            self.swarm.current_cost = objective_func(self.swarm.position)
-            self.swarm.pbest_cost = objective_func(self.swarm.pbest_pos)
+            self.swarm.current_cost = objective_func(self.swarm.position, *args, **kwargs)
+            self.swarm.pbest_cost = objective_func(self.swarm.pbest_pos, *args, **kwargs)
             self.swarm.pbest_pos, self.swarm.pbest_cost = compute_pbest(
                 self.swarm
             )

pyswarms/single/global_best.py

@@ -131,7 +131,7 @@ def __init__(
         # Initialize the topology
         self.top = Star()
 
-    def optimize(self, objective_func, iters, print_step=1, verbose=1):
+    def optimize(self, objective_func, iters, args=(), kwargs={}, print_step=1, verbose=1):
         """Optimizes the swarm for a number of iterations.
 
         Performs the optimization to evaluate the objective
@@ -143,6 +143,10 @@ def optimize(self, objective_func, iters, print_step=1, verbose=1):
             objective function to be evaluated
         iters : int
             number of iterations
+        args : tuple
+            arguments for the objective function
+        kwargs : dict
+            arguments for the objective function
         print_step : int (default is 1)
             amount of steps for printing into console.
         verbose : int  (default is 1)
@@ -153,10 +157,14 @@ def optimize(self, objective_func, iters, print_step=1, verbose=1):
         tuple
             the global best cost and the global best position.
         """
+
+        cli_print("Arguments Passed to Objective Function: \nargs: %s \nkwargs: %s\n" % (args, kwargs),
+                  verbose, 2, logger=self.logger)
+
         for i in range(iters):
             # Compute cost for current position and personal best
-            self.swarm.current_cost = objective_func(self.swarm.position)
-            self.swarm.pbest_cost = objective_func(self.swarm.pbest_pos)
+            self.swarm.current_cost = objective_func(self.swarm.position, *args, **kwargs)
+            self.swarm.pbest_cost = objective_func(self.swarm.pbest_pos, *args, **kwargs)
             self.swarm.pbest_pos, self.swarm.pbest_cost = compute_pbest(
                 self.swarm
             )

pyswarms/single/local_best.py

@@ -174,7 +174,7 @@ def __init__(
         # Initialize the topology
         self.top = Ring()
 
-    def optimize(self, objective_func, iters, print_step=1, verbose=1):
+    def optimize(self, objective_func, iters, args=(), kwargs={}, print_step=1, verbose=1):
         """Optimizes the swarm for a number of iterations.
 
         Performs the optimization to evaluate the objective
@@ -186,6 +186,10 @@ def optimize(self, objective_func, iters, print_step=1, verbose=1):
             objective function to be evaluated
         iters : int
             number of iterations
+        args : tuple
+            arguments for the objective function
+        kwargs : dict
+            arguments for the objective function
         print_step : int (default is 1)
             amount of steps for printing into console.
         verbose : int  (default is 1)
@@ -197,10 +201,13 @@ def optimize(self, objective_func, iters, print_step=1, verbose=1):
             the local best cost and the local best position among the
             swarm.
         """
+        cli_print("Arguments Passed to Objective Function: \nargs: %s \nkwargs: %s\n" % (args, kwargs),
+                  verbose, 2, logger=self.logger)
+
         for i in range(iters):
             # Compute cost for current position and personal best
-            self.swarm.current_cost = objective_func(self.swarm.position)
-            self.swarm.pbest_cost = objective_func(self.swarm.pbest_pos)
+            self.swarm.current_cost = objective_func(self.swarm.position, *args, **kwargs)
+            self.swarm.pbest_cost = objective_func(self.swarm.pbest_pos, *args, **kwargs)
             self.swarm.pbest_pos, self.swarm.pbest_cost = compute_pbest(
                 self.swarm
             )

pyswarms/utils/environments/plot_environment.py

@@ -104,7 +104,7 @@ def assertions(self):
                 "Missing methods in optimizer, check " "pyswarms.base module"
             )
 
-    def __init__(self, optimizer, objective_func, iters):
+    def __init__(self, optimizer, objective_func, iters, obj_args=(), obj_kwargs={}):
         """Runs the optimizer against an objective function for a number
         of iterations
 
@@ -125,17 +125,26 @@ def __init__(self, optimizer, objective_func, iters):
         iters : int
             The number of iterations to run the optimizer. This argument
             is passed to the :code:`optimize` method of the :code:`optimizer`.
+        obj_args : tuple
+            Tuple of arguments to be passed into the objective function for
+            parameterization.
+        obj_kwargs : dict
+            dictionary of kwargs to be passed into the objective function for
+            parameterization.
         """
         self.logger = logging.getLogger(__name__)
         # Store the arguments
         self.optimizer = optimizer
         self.objective_func = objective_func
         self.iters = iters
+        self.obj_args = obj_args
+        self.obj_kwargs = obj_kwargs
         # Check assertions
         self.assertions()
         # Run the optimizer
         self.optimizer.reset()
-        self.status = self.optimizer.optimize(objective_func, iters, 1, 0)
+        self.status = self.optimizer.optimize(objective_func, iters, args=obj_args,
+                                              kwargs=obj_kwargs, print_step=1, verbose=0)
         # Initialize tuples for particle plotting
         self.Index = namedtuple("Index", ["x", "y", "z"])
         self.Limit = namedtuple("Limit", ["x", "y", "z"])

pyswarms/utils/search/base_search.py

@@ -33,6 +33,8 @@ def __init__(
         options,
         objective_func,
         iters,
+        obj_args=(),
+        obj_kwargs={},
         bounds=None,
         velocity_clamp=(0, 1),
     ):
@@ -66,6 +68,10 @@ def __init__(
             objective function to be evaluated
         iters: int
             number of iterations
+        obj_args : tuple
+            tuple of arguments for objective function parameterization.
+        obj_kwargs : dict
+            dict of arguments for objective function parameterization.
         bounds : tuple of np.ndarray, optional (default is None)
             a tuple of size 2 where the first entry is the minimum bound
             while the second entry is the maximum bound. Each array must
@@ -85,6 +91,8 @@ def __init__(
         self.vclamp = velocity_clamp
         self.objective_func = objective_func
         self.iters = iters
+        self.obj_args = obj_args
+        self.obj_kwargs = obj_kwargs
         # Invoke assertions
         self.assertions()
 
@@ -104,7 +112,8 @@ def generate_score(self, options):
         )
 
         # Return score
-        return f.optimize(self.objective_func, self.iters)[0]
+        return f.optimize(self.objective_func, self.iters,
+                          args=self.obj_args, kwargs=self.obj_kwargs)[0]
 
     def search(self, maximum=False):
         """Compares optimizer's objective function performance scores