Merge pull request #13 from NimishVerma/master

Adding GWO

Author: HaaLeo

.idea/swarmlib.iml

@@ -3,7 +3,7 @@
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
 # run arbitrary code
-extension-pkg-whitelist=
+extension-pkg-whitelist=numpy
 
 # Add files or directories to the blacklist. They should be base names, not
 # paths.
@@ -25,7 +25,7 @@ jobs=1
 load-plugins=pylint_quotes,pylintfileheader
 
 # Option for the pylintfileheader plugin
-file-header=# ------------------------------------------------------------------------------------------------------\n#  Copyright \(c\) Leo Hanisch. All rights reserved.\n#  Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.\n# ------------------------------------------------------------------------------------------------------\n
+file-header=# ------------------------------------------------------------------------------------------------------\n#  Copyright \(c\) Leo Hanisch( and contributors)?. All rights reserved.\n#  Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.\n# ------------------------------------------------------------------------------------------------------\n
 
 # Pickle collected data for later comparisons.
 persistent=yes

.pylintrc

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2018, Leo Hanisch
+Copyright (c) 2018, Leo Hanisch and contributors.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

LICENSE.txt

@@ -15,6 +15,7 @@ Currently, the following algorithms are implemented:
 * [Particle Swarm Optimization](#particle-swarm-optimization)
 * [Ant Colony Optimization](#ant-colony-optimization)
 * [Artificial Bee Colony](#artificial-bee-colony)
+* [Grey Wolf Optimization](#grey-wolf-optimization)
 
 ## Installation
 
@@ -214,3 +215,37 @@ problem = ABCProblem(bees=10, function=FUNCTIONS['michalewicz'])
 best_bee = problem.solve()
 problem.replay()
 ```
+
+### Grey Wolf Optimization
+
+The Grey Wolf Optimization (GWO) algorithm was proposed by S. Mirjalili et  al. in the paper [Grey Wolf Optimizer](https://www.sciencedirect.com/science/article/pii/S0965997813001853?casa_token=IJMUjrkkBVkAAAAA:TIW5bZqXDqgQwD1aX-5vqsDvmf4AgWFODvWepUiZi79MgSii3MlDMXMwgMVPcQvuGlZYLKm5GA).
+The paper proposed a novel algorithm based on the hunting and the hierarchy structure in grey wolves
+
+#### Features
+
+Enables the GWO algorithm to one of the provided 2D functions. The algorithm tries to find the global minimum of the selected function.
+
+Currently two functions can be selected:
+* [ackley](https://www.sfu.ca/~ssurjano/ackley.html)
+* [michalewicz](https://www.sfu.ca/~ssurjano/michal.html)
+
+![GWO Sample](https://raw.githubusercontent.com/HaaLeo/swarmlib/master/doc/gwo.gif)
+
+
+To print all available options execute:
+
+```
+swarm wolves -h
+```
+
+#### API
+
+In addition to the cli you can also use the API:
+
+```python
+from swarmlib import GWOProblem, FUNCTIONS
+
+problem = GWOProblem(wolves=10, function=FUNCTIONS['michalewicz'])
+best_wolf = problem.solve()
+problem.replay()
+```

README.md

@@ -8,4 +8,5 @@
 from .cuckoosearch.cuckoo_problem import CuckooProblem
 from .pso.pso_problem import PSOProblem
 from .abc.abc_problem import ABCProblem
+from .gwo.gwo_problem import GWOProblem
 from .util.functions import FUNCTIONS

doc/gwo.gif

@@ -13,7 +13,7 @@
 from .cuckoosearch.main import configure_parser as cuckoo_parser
 from .pso.main import configure_parser as pso_parser
 from .abc.main import configure_parser as abc_parser
-
+from .gwo.main import configure_parser as gwo_parser
 from ._version import __version__
 
 logging.basicConfig(
@@ -62,7 +62,7 @@ def run_swarm():
     cuckoo_parser(sub_parsers)
     pso_parser(sub_parsers)
     abc_parser(sub_parsers)
-
+    gwo_parser(sub_parsers)
     args = vars(parser.parse_args())
     if args:
         algorithm = args.pop('func')

swarmlib/__init__.py

@@ -0,0 +1,4 @@
+# ------------------------------------------------------------------------------------------------------
+#  Copyright (c) Leo Hanisch and contributors. All rights reserved.
+#  Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.
+# ------------------------------------------------------------------------------------------------------

swarmlib/__main__.py

@@ -0,0 +1,60 @@
+# ------------------------------------------------------------------------------------------------------
+#  Copyright (c) Leo Hanisch and contributors. All rights reserved.
+#  Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.
+# ------------------------------------------------------------------------------------------------------
+
+import logging
+from copy import deepcopy
+from .wolf import Wolf
+from .visualizer import Visualizer
+
+# pylint: disable=too-many-instance-attributes
+
+LOGGER = logging.getLogger(__name__)
+
+
+class GWOProblem:
+    def __init__(self, **kwargs):
+        """
+        Initialize a new grey wolf optimization problem.
+        """
+
+        self.__iteration_number = kwargs.get('iteration_number', 30)
+        self.__wolves = [
+            Wolf(**kwargs)
+            for _ in range(kwargs['wolves'])
+        ]
+        self.__alpha, self.__beta, self.__delta = self.__wolves[:3]  # random alpha beta delta for initial coloring
+        # Initialize visualizer for plotting
+        positions = [wolf.position for wolf in self.__wolves]
+        self.__visualizer = Visualizer(**kwargs)
+        self.__visualizer.add_data(
+            positions=positions)  # ,alpha_pos =self.alpha.position,beta_pos=self.beta.position,delta_pos=self.delta.position)
+
+    def solve(self) -> Wolf:
+
+        for iter_no in range(self.__iteration_number + 1):
+            a_parameter = 2 - iter_no * ((2) / self.__iteration_number)
+            # Update alpha beta delta
+            self.__wolves.sort(key=lambda wolf: wolf.value)
+
+            self.__alpha, self.__beta, self.__delta = deepcopy(self.__wolves[:3])
+
+            for wolf in self.__wolves:
+                wolf.step(a_parameter, self.__alpha.position, self.__beta.position, self.__delta.position)
+
+            # Add data for plot
+            positions = [particle.position for particle in self.__wolves]
+            self.__visualizer.add_data(
+                positions=positions)  # ,alpha_pos =self.alpha.position,beta_pos=self.beta.position,delta_pos=self.delta.position)
+
+        LOGGER.info('Last best solution="%s" at position="%s"', self.__alpha.value, self.__alpha.position)
+        return self.__alpha
+
+    def replay(self):
+        """
+        Start the problems visualization.
+        """
+        self.__visualizer.replay()
+
+# print(GWOProblem(function=FUNCTIONS['michalewicz'], wolves=20, iteration_number=10))

swarmlib/gwo/__init__.py

@@ -0,0 +1,62 @@
+# ------------------------------------------------------------------------------------------------------
+#  Copyright (c) Leo Hanisch and contributors. All rights reserved.
+#  Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.
+# ------------------------------------------------------------------------------------------------------
+import logging
+
+from .gwo_problem import GWOProblem
+from ..util.functions import FUNCTIONS
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _run_gwo(args):
+    LOGGER.info('Start grey wolf optimization with parameters="%s"', args)
+    args['function'] = FUNCTIONS[args['function']]
+
+    problem = GWOProblem(**args)
+    problem.solve()
+    problem.replay()
+
+
+def configure_parser(sub_parsers):
+    """
+    Get the argument parser for grey wolf optimization
+    """
+
+    parser = sub_parsers.add_parser(
+        'wolves',
+        description='Solving an minimization problem using the grey wolf optimization algorithm',
+        help='Grey Wolf optimization algorithm for minimization problem')
+
+    parser.add_argument(
+        '-f',
+        '--function',
+        type=str,
+        default='michalewicz',
+        help='Choose the function that is used for searching the minimum.',
+        choices=['michalewicz', 'ackley'])
+    parser.add_argument(
+        '-u',
+        '--upper-boundary',
+        type=float,
+        default=4.,
+        help='Upper boundary of the function (default 4)')
+    parser.add_argument(
+        '-l',
+        '--lower-boundary',
+        type=float,
+        default=0.,
+        help='Lower boundary of the function (default 0)')
+    parser.add_argument(
+        '-n',
+        '--iteration-number',
+        type=int,
+        default=30,
+        help='Number of iterations to execute (default 30)')
+    parser.add_argument(
+        'wolves',
+        type=int,
+        help='Number of wolves used for solving')
+
+    parser.set_defaults(func=_run_gwo)

swarmlib/gwo/gwo_problem.py

@@ -0,0 +1,14 @@
+# ------------------------------------------------------------------------------------------------------
+#  Copyright (c) Leo Hanisch and contributors. All rights reserved.
+#  Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.
+# ------------------------------------------------------------------------------------------------------
+
+import numpy as np
+from ..util.base_visualizer import BaseVisualizer
+
+class Visualizer(BaseVisualizer):
+    def replay(self):
+        self._velocities = [self._positions[index+1]-position for index, position in enumerate(self._positions[:-1])]
+        self._velocities.insert(0, np.zeros(self._positions[0].shape))
+        self._velocities.append(np.zeros(self._positions[0].shape))
+        super().replay()

swarmlib/gwo/main.py

@@ -0,0 +1,54 @@
+# ------------------------------------------------------------------------------------------------------
+#  Copyright (c) Leo Hanisch and contributors. All rights reserved.
+#  Licensed under the BSD 3-Clause License. See LICENSE.txt in the project root for license information.
+# ------------------------------------------------------------------------------------------------------
+
+# pylint: disable-msg=too-many-locals
+from typing import Tuple
+import numpy as np
+
+from ..util.coordinate import Coordinate
+
+
+class Wolf(Coordinate):
+    def step(self, a_parameter, alpha_pos: Tuple[float, float], beta_pos: Tuple[float, float],
+             delta_pos: Tuple[float, float]) -> None:
+        """
+        Execute a wolf step.
+        Update the wolf's position and value.
+
+        Arguments:
+            alpha_pos {Tuple[float, float]} -- The alpha position
+            beta_pos {Tuple[float, float]} -- The beta position
+            delta_pos {Tuple[float, float]} -- The delta position
+        """
+
+
+        r_1 = np.random.random()  # r_1 is a random number in [0,1]
+        r_2 = np.random.random()  # r_2 is a random number in [0,1]
+
+        a_1 = 2 * a_parameter * r_1 - a_parameter  # Equation (3.3)
+        c_1 = 2 * r_2  # Equation (3.4)
+
+        d_alpha = abs(c_1 * alpha_pos - self._position)  # Equation (3.5)-part 1
+        x_1 = alpha_pos - a_1 * d_alpha  # Equation (3.6)-part 1
+
+        r_1 = np.random.random()
+        r_2 = np.random.random()
+
+        a_2 = 2 * a_parameter * r_1 - a_parameter # Equation (3.3)
+        c_2 = 2 * r_2  # Equation (3.4)
+
+        d_beta = abs(c_2 * beta_pos - self._position)  # Equation (3.5)-part 2
+        x_2 = beta_pos - a_2 * d_beta  # Equation (3.6)-part 2
+
+        r_1 = np.random.random()
+        r_2 = np.random.random()
+
+        a_3 = 2 * a_parameter * r_1 - a_parameter  # Equation (3.3)
+        c_3 = 2 * r_2  # Equation (3.4)
+
+        d_delta = abs(c_3 * delta_pos - self._position)  # Equation (3.5)-part 3
+        x_3 = delta_pos - a_3 * d_delta  # Equation (3.5)-part 3
+
+        self._position = (x_1 + x_2 + x_3) / 3  # Equation (3.7)