Source code for niapy.algorithms.other.aso

# encoding=utf8
import logging

import numpy as np

from niapy.algorithms.algorithm import Algorithm
from niapy.util import full_array, euclidean

logging.basicConfig()
logger = logging.getLogger('niapy.algorithms.other')
logger.setLevel('INFO')

__all__ = ['AnarchicSocietyOptimization', 'elitism', 'sequential', 'crossover']


def elitism(x, xpb, xb, xr, mp_c, mp_s, mp_p, mutation_rate, crossover_probability, task, rng):
    r"""Select the best of all three strategies.

    Args:
        x (numpy.ndarray): individual position.
        xpb (numpy.ndarray): individuals best position.
        xb (numpy.ndarray): current best position.
        xr (numpy.ndarray): random individual.
        mp_c (float): Fickleness index value.
        mp_s (float): External irregularity index value.
        mp_p (float): Internal irregularity index value.
        mutation_rate (float): scale factor.
        crossover_probability (float): crossover factor.
        task (Task): optimization task.
        rng (numpy.random.Generator): random number generator.

    Returns:
        Tuple[numpy.ndarray, float]:
            1. New position of individual
            2. New positions fitness/function value

    """
    xn = [task.repair(mp_current(x, mutation_rate, crossover_probability, mp_c, rng), rng=rng),
          task.repair(mp_society(x, xr, xb, crossover_probability, mp_s, rng), rng=rng),
          task.repair(mp_past(x, xpb, crossover_probability, mp_p, rng), rng=rng)]
    xn_f = np.apply_along_axis(task.eval, 1, xn)
    ib = np.argmin(xn_f)
    return xn[ib], xn_f[ib]


def sequential(x, xpb, xb, xr, mp_c, mp_s, mp_p, mutation_rate, crossover_probability, task, rng):
    r"""Sequentially combines all three strategies.

    Args:
        x (numpy.ndarray): individual position.
        xpb (numpy.ndarray): individuals best position.
        xb (numpy.ndarray): current best position.
        xr (numpy.ndarray): random individual.
        mp_c (float): Fickleness index value.
        mp_s (float): External irregularity index value.
        mp_p (float): Internal irregularity index value.
        mutation_rate (float): scale factor.
        crossover_probability (float): crossover factor.
        task (Task): optimization task.
        rng (numpy.random.Generator): random number generator.

    Returns:
        tuple[numpy.ndarray, float]:
            1. new position
            2. new positions function/fitness value

    """
    xn = task.repair(mp_society(
        mp_past(mp_current(x, mutation_rate, crossover_probability, mp_c, rng), xpb, crossover_probability, mp_p, rng),
        xr,
        xb, crossover_probability, mp_s, rng), rng=rng)
    return xn, task.eval(xn)


def crossover(x, xpb, xb, xr, mp_c, mp_s, mp_p, mutation_rate, crossover_probability, task, rng):
    r"""Create a crossover over all three strategies.

    Args:
        x (numpy.ndarray): individual position.
        xpb (numpy.ndarray): individuals best position.
        xb (numpy.ndarray): current best position.
        xr (numpy.ndarray): random individual.
        mp_c (float): Fickleness index value.
        mp_s (float): External irregularity index value.
        mp_p (float): Internal irregularity index value.
        mutation_rate (float): scale factor.
        crossover_probability (float): crossover factor.
        task (Task): optimization task.
        rng (numpy.random.Generator): random number generator.

    Returns:
        Tuple[numpy.ndarray, float]:
            1. new position
            2. new positions function/fitness value.

    """
    xns = [task.repair(mp_current(x, mutation_rate, crossover_probability, mp_c, rng), rng=rng),
           task.repair(mp_society(x, xr, xb, crossover_probability, mp_s, rng), rng=rng),
           task.repair(mp_past(x, xpb, crossover_probability, mp_p, rng), rng=rng)]
    index = rng.integers(len(xns))
    x = np.asarray([xns[index][i] if rng.random() < crossover_probability else x[i] for i in range(len(x))])
    return x, task.eval(x)


def mp_current(x, mutation_rate, crossover_rate, mp, rng):
    r"""Get bew position based on fickleness.

    Args:
        x (numpy.ndarray): Current individuals position.
        mutation_rate (float): Scale factor.
        crossover_rate (float): Crossover probability.
        mp (float): Fickleness index value
        rng (numpy.random.Generator): Random number generator

    Returns:
        numpy.ndarray: New position

    """
    if mp < 0.5:
        b = np.sort(rng.choice(len(x), 2, replace=False))
        x[b[0]:b[1]] = x[b[0]:b[1]] + mutation_rate * rng.normal(0, 1, b[1] - b[0])
        return x
    return np.asarray(
        [x[i] + mutation_rate * rng.normal(0, 1) if rng.random() < crossover_rate else x[i] for i in range(len(x))])


def mp_society(x, xr, xb, crossover_rate, mp, rng):
    r"""Get new position based on external irregularity.

    Args:
        x (numpy.ndarray): Current individuals position.
        xr (numpy.ndarray): Random individuals position.
        xb (numpy.ndarray): Global best individuals position.
        crossover_rate (float): Crossover probability.
        mp (float): External irregularity index.
        rng (numpy.random.Generator): Random number generator.

    Returns:
        numpy.ndarray: New position.

    """
    if mp < 0.25:
        b = np.sort(rng.choice(len(x), 2, replace=False))
        x[b[0]:b[1]] = xb[b[0]:b[1]]
        return x
    elif mp < 0.5:
        return np.asarray([xb[i] if rng.random() < crossover_rate else x[i] for i in range(len(x))])
    elif mp < 0.75:
        b = np.sort(rng.choice(len(x), 2, replace=False))
        x[b[0]:b[1]] = xr[b[0]:b[1]]
        return x
    return np.asarray([xr[i] if rng.random() < crossover_rate else x[i] for i in range(len(x))])


def mp_past(x, xpb, crossover_rate, mp, rng):
    r"""Get new position based on internal irregularity.

    Args:
        x (numpy.ndarray): Current individuals position.
        xpb (numpy.ndarray): Current individuals personal best position.
        crossover_rate (float): Crossover probability.
        mp (float): Internal irregularity index value.
        rng (numpy.random.Generator): Random number generator.

    Returns:
        numpy.ndarray: Current individuals new position.

    """
    if mp < 0.5:
        b = np.sort(rng.choice(len(x), 2, replace=False))
        x[b[0]:b[1]] = xpb[b[0]:b[1]]
        return x
    return np.asarray([xpb[i] if rng.random() < crossover_rate else x[i] for i in range(len(x))])


[docs]class AnarchicSocietyOptimization(Algorithm): r"""Implementation of Anarchic Society Optimization algorithm. Algorithm: Anarchic Society Optimization algorithm Date: 2018 Authors: Klemen Berkovič License: MIT Reference paper: Ahmadi-Javid, Amir. "Anarchic Society Optimization: A human-inspired method." Evolutionary Computation (CEC), 2011 IEEE Congress on. IEEE, 2011. Attributes: Name (list of str): List of stings representing name of algorithm. alpha (List[float]): Factor for fickleness index function :math:`\in [0, 1]`. gamma (List[float]): Factor for external irregularity index function :math:`\in [0, \infty)`. theta (List[float]): Factor for internal irregularity index function :math:`\in [0, \infty)`. d (Callable[[float, float], float]): function that takes two arguments that are function values and calculates the distance between them. dn (Callable[[numpy.ndarray, numpy.ndarray], float]): function that takes two arguments that are points in function landscape and calculates the distance between them. nl (float): Normalized range for neighborhood search :math:`\in (0, 1]`. F (float): Mutation parameter. CR (float): Crossover parameter :math:`\in [0, 1]`. Combination (Callable[numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray, float, float, float, float, float, float, Task, numpy.random.Generator]): Function for combining individuals to get new position/individual. See Also: * :class:`niapy.algorithms.Algorithm` """ Name = ['AnarchicSocietyOptimization', 'ASO']
[docs] @staticmethod def info(): r"""Get basic information about the algorithm. Returns: str: Basic information. See Also: :func:`niapy.algorithms.algorithm.Algorithm.info` """ return r"""Ahmadi-Javid, Amir. "Anarchic Society Optimization: A human-inspired method." Evolutionary Computation (CEC), 2011 IEEE Congress on. IEEE, 2011."""
[docs] def __init__(self, population_size=43, alpha=(1, 0.83), gamma=(1.17, 0.56), theta=(0.932, 0.832), d=euclidean, dn=euclidean, nl=1, mutation_rate=1.2, crossover_rate=0.25, combination=elitism, *args, **kwargs): r"""Initialize AnarchicSocietyOptimization. Args: population_size (Optional[int]): Population size. alpha (Optional[Tuple[float, ...]]): Factor for fickleness index function :math:`\in [0, 1]`. gamma (Optional[Tuple[float, ...]]): Factor for external irregularity index function :math:`\in [0, \infty)`. theta (Optional[List[float]]): Factor for internal irregularity index function :math:`\in [0, \infty)`. d (Optional[Callable[[float, float], float]]): function that takes two arguments that are function values and calculates the distance between them. dn (Optional[Callable[[numpy.ndarray, numpy.ndarray], float]]): function that takes two arguments that are points in function landscape and calculates the distance between them. nl (Optional[float]): Normalized range for neighborhood search :math:`\in (0, 1]`. mutation_rate (Optional[float]): Mutation parameter. crossover_rate (Optional[float]): Crossover parameter :math:`\in [0, 1]`. combination (Optional[Callable[numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray, float, float, float, float, float, float, Task, numpy.random.Generator]]): Function for combining individuals to get new position/individual. See Also: * :func:`niapy.algorithms.Algorithm.set_parameters` """ super().__init__(population_size, *args, **kwargs) self.alpha = alpha self.gamma = gamma self.theta = theta self.d = d self.dn = dn self.nl = nl self.mutation_rate = mutation_rate self.crossover_rate = crossover_rate self.combination = combination
[docs] def set_parameters(self, population_size=43, alpha=(1, 0.83), gamma=(1.17, 0.56), theta=(0.932, 0.832), d=euclidean, dn=euclidean, nl=1, mutation_rate=1.2, crossover_rate=0.25, combination=elitism, **kwargs): r"""Set the parameters for the algorithm. Args: population_size (Optional[int]): Population size. alpha (Optional[Tuple[float, ...]]): Factor for fickleness index function :math:`\in [0, 1]`. gamma (Optional[Tuple[float, ...]]): Factor for external irregularity index function :math:`\in [0, \infty)`. theta (Optional[List[float]]): Factor for internal irregularity index function :math:`\in [0, \infty)`. d (Optional[Callable[[float, float], float]]): function that takes two arguments that are function values and calculates the distance between them. dn (Optional[Callable[[numpy.ndarray, numpy.ndarray], float]]): function that takes two arguments that are points in function landscape and calculates the distance between them. nl (Optional[float]): Normalized range for neighborhood search :math:`\in (0, 1]`. mutation_rate (Optional[float]): Mutation parameter. crossover_rate (Optional[float]): Crossover parameter :math:`\in [0, 1]`. combination (Optional[Callable[numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray, float, float, float, float, float, float, Task, numpy.random.Generator]]): Function for combining individuals to get new position/individual. See Also: * :func:`niapy.algorithms.Algorithm.set_parameters` * Combination methods: * :func:`niapy.algorithms.other.elitism` * :func:`niapy.algorithms.other.crossover` * :func:`niapy.algorithms.other.sequential` """ super().set_parameters(population_size=population_size, **kwargs) self.alpha = alpha self.gamma = gamma self.theta = theta self.d = d self.dn = dn self.nl = nl self.mutation_rate = mutation_rate self.crossover_rate = crossover_rate self.combination = combination
[docs] def get_parameters(self): r"""Get parameters of the algorithm. Returns: Dict[str, Any]: Algorithm parameters. """ params = super().get_parameters() params.update({ 'alpha': self.alpha, 'gamma': self.gamma, 'theta': self.theta, 'd': self.d, 'dn': self.dn, 'nl': self.nl, 'mutation_rate': self.mutation_rate, 'crossover_rate': self.crossover_rate, 'combination': self.combination }) return params
[docs] def init(self, _task): r"""Initialize dynamic parameters of algorithm. Args: _task (Task): Optimization task. Returns: Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray] 1. Array of `self.alpha` propagated values 2. Array of `self.gamma` propagated values 3. Array of `self.theta` propagated values """ return full_array(self.alpha, self.population_size), full_array(self.gamma, self.population_size), full_array( self.theta, self.population_size)
[docs] @staticmethod def fickleness_index(x_f, xpb_f, xb_f, alpha): r"""Get fickleness index. Args: x_f (float): Individuals fitness/function value. xpb_f (float): Individuals personal best fitness/function value. xb_f (float): Current best found individuals fitness/function value. alpha (float): Fickleness factor. Returns: float: Fickleness index. """ return 1 - alpha * xb_f / x_f - (1 - alpha) * xpb_f / x_f
[docs] def external_irregularity(self, x_f, xnb_f, gamma): r"""Get external irregularity index. Args: x_f (float): Individuals fitness/function value. xnb_f (float): Individuals new fitness/function value. gamma (float): External irregularity factor. Returns: float: External irregularity index. """ return 1 - np.exp(-gamma * self.d(x_f, xnb_f))
[docs] def irregularity_index(self, x_f, xpb_f, theta): r"""Get internal irregularity index. Args: x_f (float): Individuals fitness/function value. xpb_f (float): Individuals personal best fitness/function value. theta (float): Internal irregularity factor. Returns: float: Internal irregularity index """ return 1 - np.exp(-theta * self.d(x_f, xpb_f))
[docs] def get_best_neighbors(self, i, population, population_fitness, rs): r"""Get neighbors of individual. Measurement of distance for neighborhood is defined with `self.nl`. Function for calculating distances is define with `self.dn`. Args: i (int): Index of individual for hum we are looking for neighbours. population (numpy.ndarray): Current population. population_fitness (numpy.ndarray[float]): Current population fitness/function values. rs (numpy.ndarray[float]): distance between individuals. Returns: numpy.ndarray[int]: Indexes that represent individuals closest to `i`-th individual. """ nn = np.asarray([self.dn(population[i], population[j]) / rs for j in range(len(population))]) return np.argmin(population_fitness[np.where(nn <= self.nl)])
[docs] @staticmethod def update_personal_best(population, population_fitness, personal_best, personal_best_fitness): r"""Update personal best solution of all individuals in population. Args: population (numpy.ndarray): Current population. population_fitness (numpy.ndarray[float]): Current population fitness/function values. personal_best (numpy.ndarray): Current population best positions. personal_best_fitness (numpy.ndarray[float]): Current populations best positions fitness/function values. Returns: Tuple[numpy.ndarray, numpy.ndarray[float], numpy.ndarray, float]: 1. New personal best positions for current population. 2. New personal best positions function/fitness values for current population. 3. New best individual. 4. New best individual fitness/function value. """ ix_pb = np.where(population_fitness < personal_best_fitness) personal_best[ix_pb], personal_best_fitness[ix_pb] = population[ix_pb], population_fitness[ix_pb] return personal_best, personal_best_fitness
[docs] def init_population(self, task): r"""Initialize first population and additional arguments. Args: task (Task): Optimization task Returns: Tuple[numpy.ndarray, numpy.ndarray, dict]: 1. Initialized population 2. Initialized population fitness/function values 3. Dict[str, Any]: * x_best (numpy.ndarray): Initialized populations best positions. * x_best_fitness (numpy.ndarray): Initialized populations best positions function/fitness values. * alpha (numpy.ndarray): * gamma (numpy.ndarray): * theta (numpy.ndarray): * rs (float): distance of search space. See Also: * :func:`niapy.algorithms.algorithm.Algorithm.init_population` * :func:`niapy.algorithms.other.aso.AnarchicSocietyOptimization.init` """ population, population_fitness, d = Algorithm.init_population(self, task) alpha, gamma, theta = self.init(task) x_best, x_best_fitness = self.update_personal_best(population, task.optimization_type.value * population_fitness, np.zeros((self.population_size, task.dimension)), np.full(self.population_size, np.inf)) d.update({'x_best': x_best, 'x_best_fitness': x_best_fitness, 'alpha': alpha, 'gamma': gamma, 'theta': theta, 'rs': self.d(task.upper, task.lower)}) return population, population_fitness, d
[docs] def run_iteration(self, task, population, population_fitness, best_x, best_fitness, **params): r"""Core function of AnarchicSocietyOptimization algorithm. Args: task (Task): Optimization task. population (numpy.ndarray): Current populations positions. population_fitness (numpy.ndarray): Current populations function/fitness values. best_x (numpy.ndarray): Current global best individuals position. best_fitness (float): Current global best individual function/fitness value. **params: Additional arguments. Returns: Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, dict]: 1. Initialized population 2. Initialized population fitness/function values 3. New global best solution 4. New global best solutions fitness/objective value 5. Dict[str, Union[float, int, numpy.ndarray]: * x_best (numpy.ndarray): Initialized populations best positions. * x_best_fitness (numpy.ndarray): Initialized populations best positions function/fitness values. * alpha (numpy.ndarray): * gamma (numpy.ndarray): * theta (numpy.ndarray): * rs (float): distance of search space. """ x_best = params.pop('x_best') x_best_fitness = params.pop('x_best_fitness') alpha = params.pop('alpha') gamma = params.pop('gamma') theta = params.pop('theta') rs = params.pop('rs') x_in = [self.get_best_neighbors(i, population, population_fitness, rs) for i in range(len(population))] mp_c, mp_s, mp_p = np.asarray( [self.fickleness_index(population_fitness[i], x_best_fitness[i], best_fitness, alpha[i]) for i in range(len(population))]), np.asarray( [self.external_irregularity(population_fitness[i], population_fitness[x_in[i]], gamma[i]) for i in range(len(population))]), np.asarray( [self.irregularity_index(population_fitness[i], x_best_fitness[i], theta[i]) for i in range(len(population))]) x_tmp = np.asarray([self.combination(population[i], x_best[i], best_x, population[self.integers(len(population), skip=[i])], mp_c[i], mp_s[i], mp_p[i], self.mutation_rate, self.crossover_rate, task, self.rng) for i in range(len(population))], dtype=object) population, population_fitness = np.asarray([x_tmp[i][0] for i in range(len(population))]), np.asarray( [x_tmp[i][1] for i in range(len(population))]) x_best, x_best_fitness = self.update_personal_best(population, population_fitness, x_best, x_best_fitness) best_x, best_fitness = self.get_best(population, population_fitness, best_x, best_fitness) return population, population_fitness, best_x, best_fitness, {'x_best': x_best, 'x_best_fitness': x_best_fitness, 'alpha': alpha, 'gamma': gamma, 'theta': theta, 'rs': rs}