pymoo 0.6.1.5.dev0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pymoo/algorithms/soo/nonconvex/pso.py

@@ -0,0 +1,399 @@
+import numpy as np
+
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.individual import Individual
+from pymoo.core.initialization import Initialization
+from pymoo.core.population import Population
+from pymoo.core.repair import NoRepair
+from pymoo.core.replacement import ImprovementReplacement
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.dex import repair_random_init
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.repair.bounds_repair import is_out_of_bounds_by_problem
+from pymoo.operators.repair.to_bound import set_to_bounds_if_outside
+from pymoo.operators.sampling.lhs import LHS
+from pymoo.util.display.column import Column
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.misc import norm_eucl_dist
+from pymoo.visualization.fitness_landscape import FitnessLandscape
+from pymoo.visualization.video.callback_video import AnimationCallback
+
+
+# =========================================================================================================
+# Display
+# =========================================================================================================
+
+class PSOFuzzyOutput(SingleObjectiveOutput):
+
+    def __init__(self):
+        super().__init__()
+
+        self.f = Column(name="f", width=8)
+        self.S = Column(name="S", width=7)
+        self.w = Column(name="w", width=7)
+        self.c1 = Column(name="c1", width=8)
+        self.c2 = Column(name="c2", width=8)
+
+        self.columns += [self.f, self.S, self.w, self.c1, self.c2]
+
+    def update(self, algorithm):
+        super().update(algorithm)
+
+        self.f.set(algorithm.f)
+        self.S.set(algorithm.strategy)
+        self.w.set(algorithm.w)
+        self.c1.set(algorithm.c1)
+        self.c2.set(algorithm.c2)
+
+
+# =========================================================================================================
+# Adaptation Constants
+# =========================================================================================================
+
+
+def S1_exploration(f):
+    if f <= 0.4:
+        return 0
+    elif 0.4 < f <= 0.6:
+        return 5 * f - 2
+    elif 0.6 < f <= 0.7:
+        return 1
+    elif 0.7 < f <= 0.8:
+        return -10 * f + 8
+    elif 0.8 < f:
+        return 0
+
+
+def S2_exploitation(f):
+    if f <= 0.2:
+        return 0
+    elif 0.2 < f <= 0.3:
+        return 10 * f - 2
+    elif 0.3 < f <= 0.4:
+        return 1
+    elif 0.4 < f <= 0.6:
+        return -5 * f + 3
+    elif 0.6 < f:
+        return 0
+
+
+def S3_convergence(f):
+    if f <= 0.1:
+        return 1
+    elif 0.1 < f <= 0.3:
+        return -5 * f + 1.5
+    elif 0.3 < f:
+        return 0
+
+
+def S4_jumping_out(f):
+    if f <= 0.7:
+        return 0
+    elif 0.7 < f <= 0.9:
+        return 5 * f - 3.5
+    elif 0.9 < f:
+        return 1
+
+
+# =========================================================================================================
+# Equation
+# =========================================================================================================
+
+def pso_equation(X, P_X, S_X, V, V_max, w, c1, c2, r1=None, r2=None):
+    n_particles, n_var = X.shape
+
+    if r1 is None:
+        r1 = np.random.random((n_particles, n_var))
+
+    if r2 is None:
+        r2 = np.random.random((n_particles, n_var))
+
+    inerta = w * V
+    cognitive = c1 * r1 * (P_X - X)
+    social = c2 * r2 * (S_X - X)
+
+    # calculate the velocity vector
+    Vp = inerta + cognitive + social
+    Vp = set_to_bounds_if_outside(Vp, - V_max, V_max)
+
+    Xp = X + Vp
+
+    return Xp, Vp
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class PSO(Algorithm):
+
+    def __init__(self,
+                 pop_size=25,
+                 sampling=LHS(),
+                 w=0.9,
+                 c1=2.0,
+                 c2=2.0,
+                 adaptive=True,
+                 initial_velocity="random",
+                 max_velocity_rate=0.20,
+                 pertube_best=True,
+                 repair=NoRepair(),
+                 output=PSOFuzzyOutput(),
+                 **kwargs):
+        """
+
+        Parameters
+        ----------
+        pop_size : The size of the swarm being used.
+
+        sampling : {sampling}
+
+        adaptive : bool
+            Whether w, c1, and c2 are changed dynamically over time. The update uses the spread from the global
+            optimum to determine suitable values.
+
+        w : float
+            The inertia F to be used in each iteration for the velocity update. This can be interpreted
+            as the momentum term regarding the velocity. If `adaptive=True` this is only the
+            initially used value.
+
+        c1 : float
+            The cognitive impact (personal best) during the velocity update. If `adaptive=True` this is only the
+            initially used value.
+        c2 : float
+            The social impact (global best) during the velocity update. If `adaptive=True` this is only the
+            initially used value.
+
+        initial_velocity : str - ('random', or 'zero')
+            How the initial velocity of each particle should be assigned. Either 'random' which creates a
+            random velocity vector or 'zero' which makes the particles start to find the direction through the
+            velocity update equation.
+
+        max_velocity_rate : float
+            The maximum velocity rate. It is determined variable (and not vector) wise. We consider the rate here
+            since the value is normalized regarding the `xl` and `xu` defined in the problem.
+
+        pertube_best : bool
+            Some studies have proposed to mutate the global best because it has been found to converge better.
+            Which means the population size is reduced by one particle and one function evaluation is spend
+            additionally to permute the best found solution so far.
+
+        """
+
+        super().__init__(output=output, **kwargs)
+
+        self.initialization = Initialization(sampling)
+
+        self.pop_size = pop_size
+        self.adaptive = adaptive
+        self.pertube_best = pertube_best
+        self.V_max = None
+        self.initial_velocity = initial_velocity
+        self.max_velocity_rate = max_velocity_rate
+        self.repair = repair
+
+        self.w = w
+        self.c1 = c1
+        self.c2 = c2
+
+        self.particles = None
+        self.sbest = None
+
+    def _setup(self, problem, **kwargs):
+        self.V_max = self.max_velocity_rate * (problem.xu - problem.xl)
+        self.f, self.strategy = None, None
+
+    def _initialize_infill(self):
+        return self.initialization.do(self.problem, self.pop_size, algorithm=self)
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        particles = self.pop
+
+        if self.initial_velocity == "random":
+            init_V = np.random.random((len(particles), self.problem.n_var)) * self.V_max[None, :]
+        elif self.initial_velocity == "zero":
+            init_V = np.zeros((len(particles), self.problem.n_var))
+        else:
+            raise Exception("Unknown velocity initialization.")
+
+        particles.set("V", init_V)
+        self.particles = particles
+
+        super()._initialize_advance(infills=infills, **kwargs)
+
+    def _infill(self):
+        problem, particles, pbest = self.problem, self.particles, self.pop
+
+        (X, V) = particles.get("X", "V")
+        P_X = pbest.get("X")
+
+        sbest = self._social_best()
+        S_X = sbest.get("X")
+
+        Xp, Vp = pso_equation(X, P_X, S_X, V, self.V_max, self.w, self.c1, self.c2)
+
+        # if the problem has boundaries to be considered
+        if problem.has_bounds():
+
+            for k in range(20):
+                # find the individuals which are still infeasible
+                m = is_out_of_bounds_by_problem(problem, Xp)
+
+                if len(m) == 0:
+                    break
+
+                # actually execute the differential equation
+                Xp[m], Vp[m] = pso_equation(X[m], P_X[m], S_X[m], V[m], self.V_max, self.w, self.c1, self.c2)
+
+            # if still infeasible do a random initialization
+            Xp = repair_random_init(Xp, X, *problem.bounds())
+
+        # create the offspring population
+        off = Population.new(X=Xp, V=Vp)
+
+        # try to improve the current best with a pertubation
+        if self.pertube_best:
+            k = FitnessSurvival().do(problem, pbest, n_survive=1, return_indices=True)[0]
+            mut = PM(prob=0.9, eta=np.random.uniform(5, 30), at_least_once=False)
+            mutant = mut(problem, Population(Individual(X=pbest[k].X)))[0]
+            off[k].set("X", mutant.X)
+
+        self.repair(problem, off)
+        self.sbest = sbest
+
+        return off
+
+    def _advance(self, infills=None, **kwargs):
+        assert infills is not None, "This algorithms uses the AskAndTell interface thus 'infills' must to be provided."
+
+        # set the new population to be equal to the offsprings
+        self.particles = infills
+
+        # if an offspring has improved the personal store that index
+        has_improved = ImprovementReplacement().do(self.problem, self.pop, infills, return_indices=True)
+
+        # set the personal best which have been improved
+        self.pop[has_improved] = infills[has_improved]
+
+        if self.adaptive:
+            self._adapt()
+
+    def _social_best(self):
+        return Population([self.opt[0]] * len(self.pop))
+
+    def _adapt(self):
+        pop = self.pop
+
+        X, F = pop.get("X", "F")
+        sbest = self.sbest
+        w, c1, c2, = self.w, self.c1, self.c2
+
+        # get the average distance from one to another for normalization
+        D = norm_eucl_dist(self.problem, X, X)
+        mD = D.sum(axis=1) / (len(pop) - 1)
+        _min, _max = mD.min(), mD.max()
+
+        # get the average distance to the best
+        g_D = norm_eucl_dist(self.problem, sbest.get("X"), X).mean()
+        f = (g_D - _min) / (_max - _min + 1e-32)
+
+        S = np.array([S1_exploration(f), S2_exploitation(f), S3_convergence(f), S4_jumping_out(f)])
+        strategy = S.argmax() + 1
+
+        delta = 0.05 + (np.random.random() * 0.05)
+
+        if strategy == 1:
+            c1 += delta
+            c2 -= delta
+        elif strategy == 2:
+            c1 += 0.5 * delta
+            c2 -= 0.5 * delta
+        elif strategy == 3:
+            c1 += 0.5 * delta
+            c2 += 0.5 * delta
+        elif strategy == 4:
+            c1 -= delta
+            c2 += delta
+
+        c1 = max(1.5, min(2.5, c1))
+        c2 = max(1.5, min(2.5, c2))
+
+        if c1 + c2 > 4.0:
+            c1 = 4.0 * (c1 / (c1 + c2))
+            c2 = 4.0 * (c2 / (c1 + c2))
+
+        w = 1 / (1 + 1.5 * np.exp(-2.6 * f))
+
+        self.f = f
+        self.strategy = strategy
+        self.c1 = c1
+        self.c2 = c2
+        self.w = w
+
+
+# =========================================================================================================
+# Animation
+# =========================================================================================================
+
+class PSOAnimation(AnimationCallback):
+
+    def __init__(self,
+                 nth_gen=1,
+                 n_samples_for_surface=200,
+                 dpi=200,
+                 **kwargs):
+
+        super().__init__(nth_gen=nth_gen, dpi=dpi, **kwargs)
+        self.n_samples_for_surface = n_samples_for_surface
+        self.last_pop = None
+
+    def do(self, problem, algorithm):
+        import matplotlib.pyplot as plt
+
+        if problem.n_var != 2 or problem.n_obj != 1:
+            raise Exception(
+                "This visualization can only be used for problems with two variables and one objective!")
+
+        # draw the problem surface
+        FitnessLandscape(problem,
+                         _type="contour",
+                         kwargs_contour=dict(alpha=0.3),
+                         n_samples=self.n_samples_for_surface,
+                         close_on_destroy=False).do()
+
+        # get the population
+        off = algorithm.particles
+        pop = algorithm.particles if self.last_pop is None else self.last_pop
+        pbest = algorithm.pop
+
+        for i in range(len(pop)):
+            plt.plot([off[i].X[0], pop[i].X[0]], [off[i].X[1], pop[i].X[1]], color="blue", alpha=0.5)
+            plt.plot([pbest[i].X[0], pop[i].X[0]], [pbest[i].X[1], pop[i].X[1]], color="red", alpha=0.5)
+            plt.plot([pbest[i].X[0], off[i].X[0]], [pbest[i].X[1], off[i].X[1]], color="red", alpha=0.5)
+
+        X, F, CV = pbest.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], edgecolors="red", marker="*", s=70, facecolors='none', label="pbest")
+
+        X, F, CV = off.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], color="blue", marker="o", s=30, label="particle")
+
+        X, F, CV = pop.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], color="blue", marker="o", s=30, alpha=0.5)
+
+        opt = algorithm.opt
+        X, F, CV = opt.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], color="black", marker="x", s=100, label="gbest")
+
+        xl, xu = problem.bounds()
+        plt.xlim(xl[0], xu[0])
+        plt.ylim(xl[1], xu[1])
+
+        plt.title(f"Generation: %s \nf: %.5E" % (algorithm.n_gen, opt[0].F[0]))
+        plt.legend()
+
+        self.last_pop = off.copy(deep=True)
+
+
+parse_doc_string(PSO.__init__)

pymoo/algorithms/soo/nonconvex/pso_ep.py

@@ -0,0 +1,297 @@
+"""
+
+Particle Swarm Optimization (PSO)
+
+-------------------------------- Description -------------------------------
+
+
+
+-------------------------------- References --------------------------------
+
+[1] J. Blank and K. Deb, pymoo: Multi-Objective Optimization in Python, in IEEE Access,
+vol. 8, pp. 89497-89509, 2020, DOI: 10.1109/ACCESS.2020.2990567
+
+-------------------------------- License -----------------------------------
+
+
+----------------------------------------------------------------------------
+"""
+
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.duplicate import NoDuplicateElimination
+from pymoo.core.infill import InfillCriterion
+from pymoo.core.population import Population
+from pymoo.core.replacement import ImprovementReplacement, is_better
+from pymoo.core.variable import Real, Choice, get
+from pymoo.docs import parse_doc_string
+from pymoo.operators.control import EvolutionaryParameterControl
+from pymoo.operators.repair.bounds_repair import repair_random_init, repair_clamp
+from pymoo.operators.sampling.rnd import FloatRandomSampling, random
+from pymoo.termination.default import DefaultSingleObjectiveTermination
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.sliding_window import SlidingWindow
+
+
+# =========================================================================================================
+# Mating
+# =========================================================================================================
+
+
+def pso_canonical(V, X, P_X, L_X, w, c1, c2):
+    n_particles, n_var = X.shape
+    r1, r2 = np.random.random((n_particles, n_var)), np.random.random((n_particles, n_var))
+    Vp = w * V + c1 * r1 * (P_X - X) + c2 * r2 * (L_X - X)
+    return Vp
+
+
+def pso_rotation_invariant(V, X, P_X, L_X, inertia, c1, c2):
+    n_particles, n_var = X.shape
+
+    r1 = np.random.random((n_particles, n_var))
+    p = X + c1 * r1 * (P_X - X)
+
+    r2 = np.random.random((n_particles, n_var))
+    l = X + c2 * r2 * (L_X - X)
+
+    G = (X + p + l) / 3
+    r = np.linalg.norm(G - X, axis=1, keepdims=True)
+
+    Vp = inertia * V + alea_sphere(G, r) - X
+
+    return Vp
+
+
+def alea_sphere(G, radius):
+    n, m = G.shape
+
+    x = np.random.normal(size=(n, m))
+    l = np.sqrt(np.sum(x ** 2, axis=1, keepdims=True))
+
+    r = np.random.random(size=(n, 1))
+    x = r * radius * x / l
+    return x + G
+
+
+class Swarm(InfillCriterion):
+
+    def __init__(self,
+                 w=0.7,
+                 c1=1.4,
+                 c2=1.4,
+                 V_max=0.2,
+                 prob_mut=0.33,
+                 control=EvolutionaryParameterControl,
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.w = Real(w, bounds=(0.7, 0.9), strict=(0.0, 1.0))
+        self.c1 = Real(c1, bounds=(1.2, 1.6), strict=(0.0, None))
+        self.c2 = Real(c2, bounds=(1.2, 1.6), strict=(0.0, None))
+        self.V_max = V_max
+        self.prob_mut = prob_mut
+
+        # of parameter control should be applied on the mating level
+        self.control = control(self)
+
+    def do(self, problem, pop, n_offsprings, algorithm=None, **kwargs):
+        control = self.control
+
+        # let the parameter control now some information
+        control.tell(pop=pop)
+
+        # set the controlled parameter for the desired number of offsprings
+        control.do(n_offsprings)
+
+        # get the parameters that will be used
+        w, c1, c2 = get(self.w, self.c1, self.c2, size=(len(pop), 1))
+
+        # get all the population that play a role for the mating
+        swarm, pbest, lbest = algorithm.swarm, algorithm.pbest, algorithm.lbest
+
+        V, X, P_X, L_X = swarm.get("V"), swarm.get("X"), pbest.get("X"), lbest.get("X")
+
+        Vp = pso_canonical(V, X, P_X, L_X, w, c1, c2)
+        # Vp = pso_rotation_invariant(V, X, P_X, L_X, w, c1, c2)
+
+        # if a maximum velocity has been defined
+        V_max = self.V_max
+        if V_max is not None:
+            xl, xu = problem.bounds()
+            Vp = repair_clamp(Vp, -V_max * (xu - xl), V_max * (xu - xl))
+
+        # the position of the new swarm particles
+        Xp = X + Vp
+
+        # if adding the velocity has brought them out of bounds -> bring them back
+        if problem.has_bounds():
+            Xp = repair_random_init(Xp, X, *problem.bounds())
+
+        # do a mutation  of the global best solution (helps to keep some diversity)
+        # Xm = PM(prob=1.0, eta=20).do(problem, swarm).get("X")
+        # mut = pbest.get("rank") == 0
+        # Xp[mut] = Xm[mut]
+
+        # recalculate the velocity after the repair has happened
+        Vp = Xp - X
+
+        # create the population
+        off = Population.new(X=Xp, V=Vp)
+
+        # do the reset of particles if their personal bests have not moved much
+        # for k, ind in enumerate(pbest):
+        #     delta = algorithm.delta[k]
+        #
+        #     if k != algorithm.best and delta.is_full() and np.array(delta).mean() < 0.001:
+        #         particle = FloatRandomSampling().do(problem, 1)[0]
+        #         particle.set("V", np.zeros(problem.n_var))
+        #         off[k], pbest[k], lbest[k] = particle, particle, particle
+        #         delta.clear()
+
+        # repair the individuals if necessary - disabled if repair is NoRepair
+        off = self.repair(problem, off, **kwargs)
+
+        # advance the parameter control by attaching them to the offsprings
+        control.advance(off)
+
+        return off
+
+
+def get_neighbors(name, N):
+    if name == "star":
+        return np.tile(np.arange(N), (N, 1))
+    elif name == "ring":
+        return (np.array([np.arange(3) for _ in range(N)]) + np.arange(N)[:, None] - 1) % N
+    elif name.startswith("random"):
+        K = 3
+        neighbors = []
+        for i in range(N):
+            vals = np.random.permutation(N)[:K]
+            neighbors.append([i] + vals.tolist())
+        return neighbors
+    else:
+        raise Exception(f"Unknown topology: {name}")
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class EPPSO(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 sampling=FloatRandomSampling(),
+                 swarm=Swarm(),
+                 topology="star",
+                 init_V="zero",
+                 output=SingleObjectiveOutput(),
+                 **kwargs):
+
+        super().__init__(pop_size=pop_size,
+                         sampling=sampling,
+                         mating=swarm,
+                         init_V=init_V,
+                         n_offsprings=None,
+                         eliminate_duplicates=NoDuplicateElimination(),
+                         output=output,
+                         **kwargs)
+
+        # how the initial weights should be created
+        self.init_V = Choice(init_V, options=["zero", "random"])
+
+        # how the individual are connected to determine the local (or also global) best
+        self.topology = Choice(topology, options=["star", "ring"])
+
+        # create the neighbors of each particle given the topology
+        self.neighbors = get_neighbors(get(self.topology), pop_size)
+
+        # choose the single-objective default termination
+        self.termination = DefaultSingleObjectiveTermination()
+
+        # the particles that fly around to find good solutions (pop is the pbest)
+        self.swarm = None
+
+        # the personal and local best solution
+        self.lbest = None
+        self.pbest = None
+
+        # the integer of the currently best individual
+        self.best = None
+
+    def _initialize_infill(self):
+        swarm = super()._initialize_infill()
+
+        n_var = self.problem.n_var
+        init_V = get(self.init_V)
+        if init_V == "zero":
+            V = np.zeros((len(swarm), n_var))
+        elif init_V == "random":
+            Xp = random(self.problem, len(swarm))
+            V = (swarm.get("X") - Xp) / 2
+        else:
+            raise Exception("Unknown velocity initialization.")
+        swarm.set("V", V)
+
+        return swarm
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        self.swarm = infills
+        self.pbest = self.pop
+        self.lbest = Population.create(*self.pbest)
+        self.delta = [SlidingWindow(30) for _ in range(len(infills))]
+
+        FitnessSurvival().do(self.problem, self.pbest, return_indices=True)
+
+    def _advance(self, infills=None, **kwargs):
+        assert infills is not None, "This algorithms uses the AskAndTell interface thus 'infills' must to be provided."
+
+        X = self.pbest.get("X")
+
+        self.swarm = infills
+        ImprovementReplacement().do(self.problem, self.pbest, infills, inplace=True)
+        Xp = self.pbest.get("X")
+
+        xl, xu = self.problem.bounds()
+        delta = np.max(np.abs(X - Xp) / (xu - xl), axis=1)
+        [self.delta[k].append(delta[k]) for k in range(len(delta))]
+
+        pbest = self.pbest
+        S = FitnessSurvival().do(self.problem, pbest, return_indices=True)
+        rank = pbest.get("rank")
+        self.best = S[0]
+
+        if get(self.topology) == "random-adaptive" and pbest[self.best].get("n_gen") != self.n_gen:
+            self.neighbors = get_neighbors(get(self.topology), len(pbest))
+
+        # send the message from each particle to all its neighbors
+        msgs = [[] for _ in range(len(pbest))]
+        for k, neighbors in enumerate(self.neighbors):
+            for neighbor in neighbors:
+                msgs[neighbor].append(k)
+
+        # now receive the messages and set the new local best (if an improvement has been found)
+        for k, msg in enumerate(msgs):
+
+            # if messages have been received
+            if len(msg) > 0:
+
+                # find the best one from the swarm that have been send
+                i = msg[rank[msg].argmin()]
+
+                # if the best from the message is better than the current local best
+                if is_better(pbest[i], self.lbest[k]):
+                    self.lbest[k] = pbest[i]
+
+        self.pop = self.pbest
+
+    def _set_optimum(self, **kwargs):
+        k = self.pop.get("rank") == 0
+        self.opt = self.pop[k]
+
+
+parse_doc_string(EPPSO.__init__)
+