Merge pull request #35 from gugarosa/feat/slime_mould_algorithm

gugarosa · web-flow · commit 7326a887ed8e · 2023-05-11T12:21:58.000-03:00
chore(optimizers): Adds Slime Mould Algorithm.
diff --git a/examples/optimizers/science/create_sma.py b/examples/optimizers/science/create_sma.py
@@ -0,0 +1,8 @@
+from opytimizer.optimizers.science import SMA
+
+# One should declare a hyperparameters object based
+# on the desired algorithm that will be used
+params = {"z": 0.03}
+
+# Creates a WCA optimizer
+o = SMA(params=params)
diff --git a/opytimizer/optimizers/science/__init__.py b/opytimizer/optimizers/science/__init__.py
@@ -14,6 +14,7 @@
 from opytimizer.optimizers.science.moa import MOA
 from opytimizer.optimizers.science.mvo import MVO
 from opytimizer.optimizers.science.sa import SA
+from opytimizer.optimizers.science.sma import SMA
 from opytimizer.optimizers.science.teo import TEO
 from opytimizer.optimizers.science.two import TWO
 from opytimizer.optimizers.science.wca import WCA
diff --git a/opytimizer/optimizers/science/sma.py b/opytimizer/optimizers/science/sma.py
@@ -0,0 +1,150 @@
+"""Slime Mould Algorithm.
+"""
+
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+import opytimizer.math.random as r
+import opytimizer.utils.exception as e
+import opytimizer.utils.constant as c
+from opytimizer.core import Optimizer
+from opytimizer.core.agent import Agent
+from opytimizer.core.function import Function
+from opytimizer.core.space import Space
+from opytimizer.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class SMA(Optimizer):
+    """A SMA class, inherited from Optimizer.
+
+    This is the designed class to define SMA-related
+    variables and methods.
+
+    References:
+        S. Li, H. Chen, M. Wang, A. A. Heidari, S. Mirjalili
+        Slime mould algorithm: A new method for stochastic optimization.
+        Future Generation Computer Systems (2020).
+
+    """
+
+    def __init__(self, params: Optional[Dict[str, Any]] = None) -> None:
+        """Initialization method.
+
+        Args:
+            params: Contains key-value parameters to the meta-heuristics.
+
+        """
+
+        logger.info("Overriding class: Optimizer -> SMA.")
+
+        super(SMA, self).__init__()
+
+        self.z = 0.03
+
+        self.build(params)
+
+        logger.info("Class overrided.")
+    
+    @property
+    def z(self) -> float:
+        """Probability threshold."""
+
+        return self._z
+
+    @z.setter
+    def z(self, z: float) -> None:
+        if not isinstance(z, (float, int)):
+            raise e.TypeError("`z` should be a float or integer")
+        if z < 0:
+            raise e.ValueError("`z` should be >= 0")
+
+        self._z = z
+    
+    @property
+    def weight(self) -> np.ndarray:
+        """Array of weights."""
+
+        return self._weight
+
+    @weight.setter
+    def weight(self, weight: np.ndarray) -> None:
+        if not isinstance(weight, np.ndarray):
+            raise e.TypeError("`weight` should be a numpy array")
+
+        self._weight = weight
+
+    def compile(self, space: Space) -> None:
+        """Compiles additional information that is used by this optimizer.
+        Args:
+            space: A Space object containing meta-information.
+        """
+
+        self.weight = np.zeros(
+            (space.n_agents, space.n_variables, space.n_dimensions)
+        )
+    
+    def _update_weight(self, agents: List[Agent]):
+        """Updates the weight of slime mould (eq. 2.5).
+
+        Args:
+            agents: List of agents.
+
+        """
+
+        best, worst = agents[0].fit, agents[-1].fit
+
+        n_agents = len(agents)
+
+        for i in range(n_agents):
+            
+            r1 = r.generate_uniform_random_number(0, 1,
+                (agents[i].n_variables, agents[i].n_dimensions))
+            
+            if i <= int(n_agents/2):
+                self.weight[i] = 1 + r1 * \
+                    np.log10((best - agents[i].fit)/((best - worst)+c.EPSILON) + 1)
+            else:
+                self.weight[i] = 1 - r1 * \
+                    np.log10((best - agents[i].fit)/((best - worst)+c.EPSILON) + 1)
+
+    def update(self, space: Space, iteration: int, n_iterations: int) -> None:
+        """Wraps Slime Mould Algorithm over all agents and variables.
+
+        Args:
+            space: Space containing agents and update-related information.
+            function: A function object.
+
+        """
+
+        space.agents.sort(key=lambda x: x.fit)
+
+        self._update_weight(space.agents)
+
+        a = np.arctanh(-((iteration+1)/(n_iterations+1)) + 1)
+        b = 1 - (iteration+1)/(n_iterations+1)
+        
+        for i, agent in enumerate(space.agents):
+            
+            r2 = r.generate_uniform_random_number()
+            
+            if r2 < self.z:
+                agent.fill_with_uniform()
+            else:
+                p = np.tanh(np.abs(agent.fit - space.agents[0].fit))
+                vb = r.generate_uniform_random_number(-a, a)
+                vc = r.generate_uniform_random_number(-b, b)
+
+                r3 = r.generate_uniform_random_number()
+
+                if r3 < p:
+                    k = r.generate_integer_random_number(0, len(space.agents))
+                    l = r.generate_integer_random_number(
+                        0, len(space.agents), exclude_value=k
+                    )
+                    agent.position = space.agents[0].position + vb * \
+                        (self.weight[i] * (space.agents[k].position - space.agents[l].position))
+                else:
+                    agent.position *= vc
diff --git a/tests/opytimizer/optimizers/science/test_sma.py b/tests/opytimizer/optimizers/science/test_sma.py
@@ -0,0 +1,64 @@
+import numpy as np
+
+from opytimizer.optimizers.science import sma
+from opytimizer.spaces import search
+
+def test_sma_params():
+    params = {"z": 0.03}
+
+    new_sma = sma.SMA(params=params)
+
+    assert new_sma.z == 0.03
+
+def test_sma_params_setter():
+    new_sma = sma.SMA()
+
+    try:
+        new_sma.z = "a"
+    except:
+        new_sma.z = 0.05
+    
+    try:
+        new_sma.z = -1
+    except:
+        new_sma.z = 0.05
+    
+    assert new_sma.z == 0.05
+
+def test_sma_compile():
+    search_space = search.SearchSpace(
+        n_agents=2, n_variables=2, lower_bound=[0, 0], upper_bound=[10, 10]
+    )
+
+    new_sma = sma.SMA()
+    new_sma.compile(search_space)
+
+    try:
+        new_sma.weight = 1
+    except:
+        new_sma.weight = np.array([1])
+
+    assert new_sma.weight == np.array([1])
+
+def test_sma_update_weight():
+    def square(x):
+        return np.sum(x**2)
+
+    search_space = search.SearchSpace(
+        n_agents=10, n_variables=2, lower_bound=[0, 0], upper_bound=[10, 10]
+    )
+
+    new_sma = sma.SMA()
+    new_sma.compile(search_space)
+
+    new_sma._update_weight(search_space.agents)
+
+def test_sma_update():
+    search_space = search.SearchSpace(
+        n_agents=10, n_variables=2, lower_bound=[0, 0], upper_bound=[10, 10]
+    )
+
+    new_sma = sma.SMA()
+    new_sma.compile(search_space)
+
+    new_sma.update(search_space, 1, 10)
