2.7.2 SMA：黏菌算法

  def objective_function(solution):
    food = np.array([50,50]) 
    result = np.linalg.norm(solution - food)    
    
    return result                                     
  

  #!/usr/bin/env python
# Created by "Thieu" at 20:22, 12/06/2020 ----------%
#       Email: nguyenthieu2102@gmail.com            %
#       Github: https://github.com/thieu1995        %
# --------------------------------------------------%

import numpy as np

import sys
import os

from ..optimizer import Optimizer


class DevSMA(Optimizer):
    """
    The developed version: Slime Mould Algorithm (SMA)

    Notes:
        + Selected 2 unique and random solution to create new solution (not to create variable)
        + Check bound and compare old position with new position to get the best one

    Hyper-parameters should fine-tune in approximate range to get faster convergence toward the global optimum:
        + p_t (float): (0, 1.0) -> better [0.01, 0.1], probability threshold (z in the paper)

    """

    def __init__(
        self,
        epoch: int = 10000,
        pop_size: int = 100,
        p_t: float = 0.03,
        **kwargs: object
    ) -> None:
        """
        Args:
            epoch (int): maximum number of iterations, default = 10000
            pop_size (int): number of population size, default = 100
            p_t (float): probability threshold (z in the paper), default = 0.03
        """
        super().__init__(**kwargs)
        self.epoch = self.validator.check_int("epoch", epoch, [1, 100000])
        self.pop_size = self.validator.check_int(
            "pop_size", pop_size, [5, 10000]
        )
        self.p_t = self.validator.check_float("p_t", p_t, (0, 1.0))
        self.set_parameters(["epoch", "pop_size", "p_t"])
        self.sort_flag = True

        if self.pickle_fn is None:
            self.pickle_fn = "processData/pData.pkl"

    def initialize_variables(self):
        self.weights = np.zeros((self.pop_size, self.problem.n_dims))

    def evolve(self, epoch):
        """
        The main operations (equations) of algorithm. Inherit from Optimizer class

        Args:
            epoch (int): The current iteration
        """
        self.processData_epoch = {}
        # plus eps to avoid denominator zero
        ss = (
            self.g_best.target.fitness
            - self.pop[-1].target.fitness
            + self.EPSILON
        )
        # calculate the fitness weight of each slime mold
        processData_epoch_weight = {
            "bF": self.g_best.target.fitness,
            "wF": self.pop[-1].target.fitness,
            "Si": [],
        }
        for idx in range(0, self.pop_size):
            # Eq.(2.5)
            if idx <= int(self.pop_size / 2):
                self.weights[idx] = 1 + self.generator.uniform(
                    0, 1, self.problem.n_dims
                ) * np.log10(
                    (self.g_best.target.fitness - self.pop[idx].target.fitness)
                    / ss
                    + 1
                )
            else:
                self.weights[idx] = 1 - self.generator.uniform(
                    0, 1, self.problem.n_dims
                ) * np.log10(
                    (self.g_best.target.fitness - self.pop[idx].target.fitness)
                    / ss
                    + 1
                )

            processData_epoch_weight["Si"].append(self.pop[idx].target.fitness)

        self.processData_epoch["weightEpoch"] = processData_epoch_weight

        a = np.arctanh(-(epoch / self.epoch) + 1)  # Eq.(2.4)
        b = 1 - epoch / self.epoch
        pop_new = []
        for idx in range(0, self.pop_size):
            # Update the Position of search agent
            if self.generator.uniform() < self.p_t:  # Eq.(2.7)
                pos_new = self.problem.generate_solution()
            else:
                p = np.tanh(
                    np.abs(
                        self.pop[idx].target.fitness
                        - self.g_best.target.fitness
                    )
                )  # Eq.(2.2)
                vb = self.generator.uniform(
                    -a, a, self.problem.n_dims
                )  # Eq.(2.3)
                vc = self.generator.uniform(-b, b, self.problem.n_dims)
                # two positions randomly selected from population, apply for the whole problem size instead of 1 variable
                id_a, id_b = self.generator.choice(
                    list(set(range(0, self.pop_size)) - {idx}), 2, replace=False
                )
                pos_1 = self.g_best.solution + vb * (
                    self.weights[idx] * self.pop[id_a].solution
                    - self.pop[id_b].solution
                )
                pos_2 = vc * self.pop[idx].solution
                condition = self.generator.random(self.problem.n_dims) < p
                pos_new = np.where(condition, pos_1, pos_2)
            # Check bound and re-calculate fitness after each individual move
            pos_new = self.correct_solution(pos_new)
            agent = self.generate_empty_agent(pos_new)
            pop_new.append(agent)
            if self.mode not in self.AVAILABLE_MODES:
                agent.target = self.get_target(pos_new)
                self.pop[idx] = self.get_better_agent(
                    agent, self.pop[idx], self.problem.minmax
                )
        if self.mode in self.AVAILABLE_MODES:
            pop_new = self.update_target_for_population(pop_new)
            self.pop = self.greedy_selection_population(
                self.pop, pop_new, self.problem.minmax
            )
  

  import numpy as np
from typing import List, Union, Tuple, Dict
from moths.heuristic_algorithms.utils.agent import Agent
from moths.heuristic_algorithms.utils.problem import Problem
from math import gamma
from moths.heuristic_algorithms.utils.history import History
from moths.heuristic_algorithms.utils.target import Target
from moths.heuristic_algorithms.utils.termination import Termination
from moths.heuristic_algorithms.utils.logger import Logger
from moths.heuristic_algorithms.utils.validator import Validator
import concurrent.futures as parallel
from functools import partial
import os
import time

ghenv.Component.Name = '3-HeuristicOptimizer'
ghenv.Component.NickName = '3-HeuristicOptimizer'
ghenv.Component.Description = '元启发式算法优化器'
ghenv.Component.Message = '0.0.1'
ghenv.Component.Category = 'Moths'
ghenv.Component.SubCategory = 'Algorithm N Design'
ghenv.Component.PanelSection = 3

class Optimizer:
    """
    The base class of all algorithms. All methods in this class will be inherited

    Notes
    ~~~~~
    + The function solve() is the most important method, trained the model
    + The parallel (multithreading or multiprocessing) is used in method: generate_population(), update_target_for_population()
    + The general format of:
        + population = [agent_1, agent_2, ..., agent_N]
        + agent = [solution, target]
        + target = [fitness value, objective_list]
        + objective_list = [obj_1, obj_2, ..., obj_M]
    """

    EPSILON = 10E-10
    SUPPORTED_MODES = ["process", "thread", "swarm", "single"]
    AVAILABLE_MODES = ["process", "thread", "swarm"]
    PARALLEL_MODES = ["process", "thread"]
    SUPPORTED_ARRAYS = [list, tuple, np.ndarray]
	
    def __init__(self, **kwargs):

    def __set_keyword_arguments(self, kwargs):

    def set_parameters(self, parameters: Union[List, Tuple, Dict]) -> None:

	def get_parameters(self) -> Dict:
	
    def get_attributes(self) -> Dict:

    def get_name(self) -> str:

    def __str__(self):

    def initialize_variables(self):

    def before_initialization(self, starting_solutions: Union[List, Tuple, np.ndarray] = None) -> None:

    def initialization(self) -> None:

    def after_initialization(self) -> None:

    def before_main_loop(self):

    def evolve(self, epoch: int) -> None:
	
    def check_problem(self, problem, seed) -> None:

    def check_mode_and_workers(self, mode, n_workers):

    def check_termination(self, mode="start", termination=None, epoch=None):

    def solve(self, problem: Union[Dict, Problem] = None, mode: str = 'single', n_workers: int = None,
              termination: Union[Dict, Termination] = None, starting_solutions: Union[List, np.ndarray, Tuple] = None,
              seed: int = None) -> Agent:
        """
        Args:
            problem: an instance of Problem class or a dictionary
            mode: Parallel: 'process', 'thread'; Sequential: 'swarm', 'single'.

                * 'process': The parallel mode with multiple cores run the tasks
                * 'thread': The parallel mode with multiple threads run the tasks
                * 'swarm': The sequential mode that no effect on updating phase of other agents
                * 'single': The sequential mode that effect on updating phase of other agents, this is default mode

            n_workers: The number of workers (cores or threads) to do the tasks (effect only on parallel mode)
            termination: The termination dictionary or an instance of Termination class
            starting_solutions: List or 2D matrix (numpy array) of starting positions with length equal pop_size parameter
            seed: seed for random number generation needed to be *explicitly* set to int value

        Returns:
            g_best: g_best, the best found agent, that hold the best solution and the best target. Access by: .g_best.solution, .g_best.target
        """
        self.check_problem(problem, seed)
        self.check_mode_and_workers(mode, n_workers)
        self.check_termination("start", termination, None)
        self.initialize_variables()

        self.before_initialization(starting_solutions)
        self.initialization()
        self.after_initialization()

        self.before_main_loop()
        for epoch in range(1, self.epoch + 1):
            # print(f"Epoch:{epoch}")
            time_epoch = time.perf_counter()

            # Evolve method will be called in child class
            self.evolve(epoch)

            # Update global best solution, the population is sorted or not depended on algorithm's strategy
            pop_temp, self.g_best = self.update_global_best_agent(self.pop)
            if self.sort_flag: self.pop = pop_temp

            time_epoch = time.perf_counter() - time_epoch
            self.track_optimize_step(self.pop, epoch, time_epoch)
            if self.check_termination("end", None, epoch):
                break

        self.track_optimize_process()
        return self.g_best

    def track_optimize_step(self, pop: List[Agent] = None, epoch: int = None, runtime: float = None) -> None:
        """
        Save some historical data and print out the detailed information of training process in each epoch

        Args:
            pop: the current population
            epoch: current iteration
            runtime: the runtime for current iteration
        """
        # Save history data
        if self.problem.save_population:
            self.history.list_population.append(Optimizer.duplicate_pop(pop))
        self.history.list_epoch_time.append(runtime)
        self.history.list_global_best_fit.append(self.history.list_global_best[-1].target.fitness)
        self.history.list_current_best_fit.append(self.history.list_current_best[-1].target.fitness)
        # Save the exploration and exploitation data for later usage
        pos_matrix = np.array([agent.solution for agent in pop])
        div = np.mean(np.abs(np.median(pos_matrix, axis=0) - pos_matrix), axis=0)
        self.history.list_diversity.append(np.mean(div, axis=0))
        # Print epoch
        self.logger.info(f">>>Problem: {self.problem.name}, Epoch: {epoch}, Current best: {self.history.list_current_best[-1].target.fitness}, "
                         f"Global best: {self.history.list_global_best[-1].target.fitness}, Runtime: {runtime:.5f} seconds")
        if Verbose:
            print(f">>>Problem: {self.problem.name}, Epoch: {epoch}, Current best: {self.history.list_current_best[-1].target.fitness}, "
                            f"Global best: {self.history.list_global_best[-1].target.fitness}, Runtime: {runtime:.5f} seconds")

    def track_optimize_process(self) -> None:

    def generate_empty_agent(self, solution: np.ndarray = None) -> Agent:

    def generate_agent(self, solution: np.ndarray = None) -> Agent:

    def generate_population(self, pop_size: int = None) -> List[Agent]:

    def amend_solution(self, solution: np.ndarray) -> np.ndarray:

    def correct_solution(self, solution: np.ndarray) -> np.ndarray:

    def update_target_for_population(self, pop: List[Agent] = None) -> List[Agent]:

    def get_target(self, solution: np.ndarray, counted: bool = True) -> Target:

    @staticmethod
    def compare_target(target_x: Target, target_y: Target, minmax: str = "min") -> bool:

    @staticmethod
    def compare_fitness(fitness_x: Union[float, int], fitness_y: Union[float, int], minmax: str = "min") -> bool:

    @staticmethod
    def duplicate_pop(pop: List[Agent]) -> List[Agent]:

    @staticmethod
    def get_sorted_population(pop: List[Agent], minmax: str = "min", return_index: bool = False) -> List[Agent]:

    @staticmethod
    def get_best_agent(pop: List[Agent], minmax: str = "min") -> Agent:

    @staticmethod
    def get_index_best(pop: List[Agent], minmax: str = "min") -> int:

    @staticmethod
    def get_worst_agent(pop: List[Agent], minmax: str = "min") -> Agent:

    @staticmethod
    def get_special_agents(pop: List[Agent] = None, n_best: int = 3, n_worst: int = 3,

    @staticmethod
    def get_special_fitness(pop: List[Agent] = None, minmax: str = "min") -> Tuple[Union[float, np.ndarray], float, float]:

    @staticmethod
    def get_better_agent(agent_x: Agent, agent_y: Agent, minmax: str = "min", reverse: bool = False) -> Agent:

    @staticmethod
    def greedy_selection_population(pop_old: List[Agent] = None, pop_new: List[Agent] = None, minmax: str = "min") -> List[Agent]:

    @staticmethod
    def get_sorted_and_trimmed_population(pop: List[Agent] = None, pop_size: int = None, minmax: str = "min") -> List[Agent]:
	
	def get_index_roulette_wheel_selection(self, list_fitness: np.array):

    def get_index_kway_tournament_selection(self, pop: List = None, k_way: float = 0.2, output: int = 2, reverse: bool = False) -> List:

    def get_levy_flight_step(self, beta: float = 1.0, multiplier: float = 0.001, 

    def generate_opposition_solution(self, agent: Agent = None, g_best: Agent = None) -> np.ndarray:

    def generate_group_population(self, pop: List[Agent], n_groups: int, m_agents: int) -> List:

    def crossover_arithmetic(self, dad_pos=None, mom_pos=None):

    def improved_ms(self, pop=None, g_best=None):  ## m: mutation, s: search
	
if __name__=="__main__":
    Optimizer = Optimizer	
  

  import numpy as np

ghenv.Component.Name = "3-SMA"
ghenv.Component.NickName = "3-SMA"
ghenv.Component.Description = "SMA——黏菌算法"
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Algorithm N Design"
ghenv.Component.PanelSection = 3


class DevSMA(Optimizer):

    def __init__(
        self,
        epoch: int = 10000,
        pop_size: int = 100,
        p_t: float = 0.03,
        **kwargs: object
    ) -> None:

    def initialize_variables(self):

    def evolve(self, epoch):

if __name__ == "__main__":
    if Epoch and Pop_size:
        if Starting_solutions is not None:
            starting_solutions = [[pt[0], pt[1]] for pt in Starting_solutions]

            SMA = DevSMA(
                epoch=Epoch,
                pop_size=len(Starting_solutions),
                p_t=P_t,
                starting_solutions=starting_solutions,
            )
        else:
            SMA = DevSMA(epoch=Epoch, pop_size=Pop_size, p_t=P_t)
  

  """
    配置 HeuristicOptimizer（优化器）和 SMA 后，指定解的区间（LB 和 UB）及解的方向（MinMax），最大值还是最小值，给定目标函数求解
    Inputs:
        SMA: Item Access; No Type Hint
            SMA 类的实例化对象
        LB: List Access; float
            解的最小值列表，对应维度
        UB: List Access; float
            解的最大值列表，对应维度
        MinMax: Item Access; str
            求解方向，min 或 max
        ObjectionveFunction: Item Access; No Type Hint
            目标函数
        Run: Item Access; bool
            是否运行求解
    Output:
        Verbose: Item; str
            打印输出的字符串。结算信息
        Solution: List; float
            最优解
        Fitness: Item; flaot
            适应度
        
"""

from moths.heuristic_algorithms.utils.space import FloatVar

ghenv.Component.Name = "3-SMAMetaHeuristicSolving"
ghenv.Component.NickName = "3-SMAMetaHeuristicSolving"
ghenv.Component.Description = "SMA——元启发式算法解算"
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Algorithm N Design"
ghenv.Component.PanelSection = 3


if __name__ == "__main__":
    if hasattr(SMA, "starting_solutions"):
        dimension = 2
    elif Dimension:
        dimension = Dimension
    else:
        dimension = 1

    if ObjectionveFunction:
        problem_dict = {
            "bounds": FloatVar(
                lb=LB * dimension, ub=UB * dimension, name="delta"
            ),
            "minmax": MinMax,
            "obj_func": ObjectionveFunction,
        }

        if Run:
            g_best = SMA.solve(problem_dict)

            Solution = list(SMA.g_best.solution)
            Fitness = SMA.g_best.target.fitness
  

  """
    在曲线上寻找4个点，使得围合的面积趋向于指定的目标面积
    Inputs: 
        Curve: Item Access; Curve
            输入的曲线
        Area: Item Access; float
            趋向于的目标面积
    Output:
        ObjectionveFunction: Function
            目标函数

"""

import numpy as np
import rhinoscriptsyntax as rs
import Rhino.Geometry as rg

ghenv.Component.Name = "3-ObjFunc-FindPolygon"
ghenv.Component.NickName = "3-ObjFunc-FindPolygon"
ghenv.Component.Description = (
    "在曲线上寻找4个点，使得围合的面积趋向于指定的目标面积"
)
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Algorithm N Design"
ghenv.Component.PanelSection = 3


def objective_function(solution):
    curveLength = rs.CurveLength(Curve)
    pts = [rs.EvaluateCurve(Curve, param * curveLength) for param in solution]
    polyline = rs.AddPolyline(pts + [pts[0]])
    polylineArea = rs.Area(polyline)

    return abs(Area - polylineArea)


if __name__ == "__main__":
    ObjectionveFunction = objective_function
  

  """
    从打印输出的字符串中提取信息，查看全局最优解
    Inputs:
        Verbose: Item Access; str
            打印输出的字符串
    Output:
        Epoch: List; int
            迭代次数
        GlobalBest: List; float
            全局最优解
"""

import re

ghenv.Component.Name = "3-Verbose-Global Best"
ghenv.Component.NickName = "3-Verbose-Global Best"
ghenv.Component.Description = "查看全局最优解"
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Algorithm N Design"
ghenv.Component.PanelSection = 3

if Verbose:
    match = re.search(r">>>(.*)", Verbose)
    parsed_entries = []
    if match:
        key_value_str = match.group(1).strip()
        pairs = [kv.strip() for kv in key_value_str.split(",")]
        key_value_dict = {
            k.strip(): v.strip() for k, v in (kv.split(":") for kv in pairs)
        }
        parsed_entries.append(key_value_dict)

        Epoch = int(key_value_dict["Epoch"])
        GlobalBest = float(key_value_dict["Global best"])