pydmoo 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

pydmoo/algorithms/knowledge/nsga2_kgb.py

@@ -0,0 +1,378 @@
+import random
+
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from sklearn.naive_bayes import GaussianNB
+
+from pydmoo.algorithms.base.dmoo.dnsga2 import DNSGA2
+
+
+def euclidean_distance(a, b):
+    a = np.array(a)
+    b = np.array(b)
+    return np.sqrt(np.sum((a - b) ** 2))
+
+
+class NSGA2KGB(DNSGA2):
+    """Knowledge Guided Bayesian (KGB).
+
+    References
+    ----------
+    Ye, Y., Li, L., Lin, Q., Wong, K.-C., Li, J., and Ming, Z. (2022).
+    Knowledge guided bayesian classification for dynamic multi-objective optimization.
+    Knowledge-Based Systems, 250, 109173.
+    https://doi.org/10.1016/j.knosys.2022.109173
+    """
+    def __init__(
+        self,
+        c_size=13,
+        perturb_dev=0.1,
+        ps={},
+        save_ps=False,
+        **kwargs,
+    ):
+
+        super().__init__(**kwargs)
+
+        self.C_SIZE = c_size
+        self.PERTURB_DEV = perturb_dev
+
+        self.ps = ps
+        self.save_ps = save_ps
+
+        self.nr_rand_solutions = 50 * self.pop_size
+        self.t = 0
+
+    def _infill_static_dynamic(self):
+        # archive the current POS
+        self.add_to_ps()
+
+        return super()._infill_static_dynamic()
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        # increase t counter for unique key of PS
+        self.t += 1
+
+        # conduct knowledge reconstruction examination
+        pop_useful, pop_useless, c = self.knowledge_reconstruction_examination()
+
+        # Train a naive bayesian classifier
+        model = self.naive_bayesian_classifier(pop_useful, pop_useless)
+
+        # generate a lot of random solutions with the dimensions of problem decision space
+        X_test = self.random_strategy(self.nr_rand_solutions)
+
+        # introduce noise to vary previously useful solutions
+        noise = self.random_state.normal(0, self.PERTURB_DEV, self.problem.n_var)
+        noisy_useful_history = np.asarray(pop_useful) + noise
+
+        # check whether solutions are within bounds
+        noisy_useful_history = self.check_boundaries(noisy_useful_history)
+
+        # add noisy useful history to randomly generated solutions
+        X_test = np.vstack((X_test, noisy_useful_history))
+
+        # predict whether random solutions are useful or useless
+        Y_test = model.predict(X_test)
+
+        # create list of useful predicted solutions
+        predicted_pop = self.predicted_population(X_test, Y_test)
+
+        # ------ POPULATION GENERATION --------
+        # take a random sample from predicted pop and known useful pop
+        if len(predicted_pop) >= self.pop_size - self.C_SIZE:
+            init_pop = []
+            predicted_pop = random.sample(
+                predicted_pop, self.pop_size - self.C_SIZE
+            )
+
+            # add sampled solutions to init_pop
+            for solution in predicted_pop:
+                init_pop.append(solution)
+
+            # add cluster centroids to init_pop
+            for solution in c:
+                init_pop.append(np.asarray(solution))
+
+        else:
+
+            # if not enough predicted solutions are available, add all predicted solutions to init_pop
+            init_pop = []
+
+            for solution in predicted_pop:
+                init_pop.append(solution)
+
+            # add cluster centroids to init_pop
+            for solution in c:
+                init_pop.append(np.asarray(solution))
+
+        # if there are still not enough solutions in init_pop randomly sample previously useful solutions directly without noise to init_pop
+        if len(init_pop) < self.pop_size:
+
+            # fill up init_pop with randomly sampled solutions from pop_useful
+            if len(pop_useful) >= self.pop_size - len(init_pop):
+
+                init_pop = np.vstack(
+                    (
+                        init_pop,
+                        random.sample(pop_useful, self.pop_size - len(init_pop)),
+                    )
+                )
+            else:
+                # if not enough solutions are available, add all previously known useful solutions without noise to init_pop
+                for solution in pop_useful:
+                    init_pop.append(solution)
+
+        # if there are still not enough solutions in init_pop generate random solutions with the dimensions of problem decision space
+        if len(init_pop) < self.pop_size:
+
+            # fill up with random solutions
+            init_pop = np.vstack(
+                (init_pop, self.random_strategy(self.pop_size - len(init_pop)))
+            )
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=init_pop)
+
+        # reevaluate because we know there was a change
+        self.evaluator.eval(self.problem, pop)
+
+        # do a survival to recreate rank and crowding of all individuals
+        pop = self.survival.do(self.problem, pop, n_survive=len(pop), random_state=self.random_state)
+
+        return pop
+
+    def knowledge_reconstruction_examination(self):
+        """
+        Perform the knowledge reconstruction examination.
+        :return: Tuple containing the useful population, useless population, and cluster centroids
+        """
+        clusters = self.ps  # set historical PS set as clusters
+        Nc = self.C_SIZE  # set final nr of clusters
+        size = len(self.ps)  # set size iteration to length of cluster
+        run_counter = 0  # counter variable to give unique key
+
+        # while there are still clusters to be condensed
+        while size > Nc:
+
+            counter = 0
+            min_distance = None
+            min_distance_index = []
+
+            # get clusters that are closest to each other by calculating the euclidean distance
+            for keys_i in clusters.keys():
+                for keys_j in clusters.keys():
+                    if (
+                        clusters[keys_i]["solutions"]
+                        is not clusters[keys_j]["solutions"]
+                    ):
+
+                        dst = euclidean_distance(
+                            clusters[keys_i]["centroid"],
+                            clusters[keys_j]["centroid"],
+                        )
+
+                        if min_distance == None:
+                            min_distance = dst
+                            min_distance_index = [keys_i, keys_j]
+                        elif dst < min_distance:
+                            min_distance = dst
+
+                            min_distance_index = [keys_i, keys_j]
+
+                        counter += 1
+
+            # merge closest clusters
+            for solution in clusters[min_distance_index[1]]["solutions"]:
+                clusters[min_distance_index[0]]["solutions"].append(solution)
+
+            # calculate new centroid for merged cluster
+            clusters[min_distance_index[0]][
+                "centroid"
+            ] = self.calculate_cluster_centroid(
+                clusters[min_distance_index[0]]["solutions"]
+            )
+
+            # remove cluster that was merged
+            del clusters[min_distance_index[1]]
+
+            size -= 1
+            run_counter += 1
+
+        c = []  # list of centroids
+        pop_useful = []
+        pop_useless = []
+
+        # get centroids of clusters
+        for key in clusters.keys():
+            c.append(clusters[key]["centroid"])
+
+        # create pymoo population objected to evaluate centroid solutions
+        centroid_pop = Population.new("X", c)
+
+        # evaluate centroids
+        self.evaluator.eval(self.problem, centroid_pop)
+
+        # do non-dominated sorting on centroid solutions
+        ranking = NonDominatedSorting().do(centroid_pop.get("F"), return_rank=True)[-1]
+
+        # add the individuals from the clusters with the best objective values to the useful population the rest is useless :(
+
+        for idx, rank in enumerate(ranking):
+            if rank == 0:
+                for key in clusters.keys():
+                    if centroid_pop[idx].X == clusters[key]["centroid"]:
+                        for cluster_individual in clusters[key]["solutions"]:
+                            pop_useful.append(cluster_individual)
+            else:
+                for key in clusters.keys():
+                    if centroid_pop[idx].X == clusters[key]["centroid"]:
+                        for cluster_individual in clusters[key]["solutions"]:
+                            pop_useless.append(cluster_individual)
+
+        # return useful and useless population and the centroid solutions
+        return pop_useful, pop_useless, c
+
+    def naive_bayesian_classifier(self, pop_useful, pop_useless):
+        """
+        Train a naive Bayesian classifier using the useful and useless populations.
+        :param pop_useful: Useful population
+        :param pop_useless: Useless population
+        :return: Trained GaussianNB classifier
+        """
+        labeled_useful_solutions = []
+        labeled_useless_solutions = []
+
+        # add labels to solutions
+        for individual in pop_useful:
+            labeled_useful_solutions.append((individual, +1))
+
+        for individual in pop_useless:
+            labeled_useless_solutions.append((individual, -1))
+
+        x_train = []
+        y_train = []
+
+        for i in range(len(labeled_useful_solutions)):
+            x_train.append(labeled_useful_solutions[i][0])
+            y_train.append(labeled_useful_solutions[i][1])
+
+        for i in range(len(labeled_useless_solutions)):
+            x_train.append(labeled_useless_solutions[i][0])
+            y_train.append(labeled_useless_solutions[i][1])
+
+        x_train = np.asarray(x_train)
+        y_train = np.asarray(y_train)
+
+        # fit the naive bayesian classifier with the training data
+        model = GaussianNB()
+        model.fit(x_train, y_train)
+
+        return model
+
+    def add_to_ps(self):
+        """
+        Add the current Pareto optimal set (POS) to the Pareto set (PS) with individual keys.
+        """
+
+        PS_counter = 0
+
+        for individual in self.opt:
+
+            if isinstance(individual.X, list):
+                individual.X = np.asarray(individual.X)
+
+            centroid = self.calculate_cluster_centroid(individual.X)
+
+            self.ps[str(PS_counter) + "-" + str(self.t)] = {
+                "solutions": [individual.X.tolist()],
+                "centroid": centroid,
+            }
+
+            PS_counter += 1
+
+    def predicted_population(self, X_test, Y_test):
+        """
+        Create a predicted population from the test set with positive labels.
+        :param X_test: Test set of features
+        :param Y_test: Test set of labels
+        :return: Predicted population
+        """
+        predicted_pop = []
+        for i in range(len(Y_test)):
+            if Y_test[i] == 1:
+                predicted_pop.append(X_test[i])
+        return predicted_pop
+
+    def calculate_cluster_centroid(self, solution_cluster):
+        """
+        Calculate the centroid for a given cluster of solutions.
+        :param solution_cluster: List of solutions in the cluster
+        :return: Cluster centroid
+        """
+        # Get number of variable shape
+        try:
+            n_vars = len(solution_cluster[0])
+        except TypeError:
+            solution_cluster = np.array(solution_cluster)
+            return solution_cluster.tolist()
+
+        # TODO: this is lazy garbage fix whats coming in
+        cluster = []
+        for i in range(len(solution_cluster)):
+            # cluster.append(solution_cluster[i].tolist())
+            cluster.append(solution_cluster[i])
+        solution_cluster = np.asarray(cluster)
+
+        # Get number of solutions
+        length = solution_cluster.shape[0]
+
+        centroid_points = []
+
+        # calculate centroid for each variable, by taking mean of every variable of cluster
+        for i in range(n_vars):
+            # calculate sum over cluster
+            centroid_points.append(np.sum(solution_cluster[:, i]))
+
+        return [x / length for x in centroid_points]
+
+    def check_boundaries(self, pop):
+        """
+        Check and fix the boundaries of the given population.
+        :param pop: Population to check and fix boundaries
+        :return: Population with corrected boundaries
+        """
+        # check whether numpy array or pymoo population is given
+        if isinstance(pop, Population):
+            pop = pop.get("X")
+
+        # check if any solution is outside the bounds
+        for individual in pop:
+            for i in range(len(individual)):
+                if individual[i] > self.problem.xu[i]:
+                    individual[i] = self.problem.xu[i]
+                elif individual[i] < self.problem.xl[i]:
+                    individual[i] = self.problem.xl[i]
+        return pop
+
+    def random_strategy(self, N_r):
+        """
+        Generate a random population within the problem boundaries.
+        :param N_r: Number of random solutions to generate
+        :return: Randomly generated population
+        """
+        # generate a random population of size N_r
+        # TODO: Check boundaries
+        random_pop = self.random_state.random((N_r, self.problem.n_var))
+
+        # check if any solution is outside the bounds
+        for individual in random_pop:
+            for i in range(len(individual)):
+                if individual[i] > self.problem.xu[i]:
+                    individual[i] = self.problem.xu[i]
+                elif individual[i] < self.problem.xl[i]:
+                    individual[i] = self.problem.xl[i]
+
+        return random_pop

pydmoo/algorithms/knowledge/nsga2_ktmm.py

@@ -0,0 +1,115 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.base.dmoo.dnsga2 import DNSGA2
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class NSGA2KTMM(DNSGA2):
+    """Knowledge Transfer with Mixture Model.
+
+    References
+    ----------
+    Zou, J., Hou, Z., Jiang, S., Yang, S., Ruan, G., Xia, Y., and Liu, Y. (2025).
+    Knowledge transfer with mixture model in dynamic multi-objective optimization.
+    IEEE Transactions on Evolutionary Computation, in press.
+    https://doi.org/10.1109/TEVC.2025.3566481
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+        self.size_pool = 14  # the size of knowledge pool
+        self.denominator = 0.5
+
+    def _response_mechanism(self) -> Population:
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size solutions in decision space
+        samples_old = self.sampling_new_pop()
+
+        # select self.pop_size/2 individuals with better convergence and diversity
+        samples = samples_old[:int(len(samples_old)/2)]
+
+        # knowledge in decision space
+        means_stds_ps, mean, std = self._in_decision_or_objective_space_1d(samples, "decision_space")
+        mean_new, std_new = self._select_means_stds(means_stds_ps, mean, std)
+
+        # sample self.pop_size solutions in decision space
+        X = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = np.clip(X, xl, xu)  # not provided in the original reference literature
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def _in_decision_or_objective_space_1d(self, samples, decision_or_objective="decision_space"):
+        # decision space or objective space
+        flag = "X" if decision_or_objective == "decision_space" else "F"
+
+        means_stds = self.data.get("means_stds", [])
+
+        flag_value = self.opt.get(flag)
+        if len(flag_value) <= 1:
+            flag_value = self.pop.get(flag)
+            flag_value = flag_value[:2]
+
+        means_stds.append((np.mean(flag_value, axis=0), np.std(flag_value, axis=0), self.n_iter - 1))  # 1-based
+        self.data["means_stds"] = means_stds
+
+        flag_value = samples.get(flag)
+        mean, std = np.mean(flag_value, axis=0), np.std(flag_value, axis=0)
+        return means_stds, mean, std
+
+    def sampling_new_pop(self):
+        samples = self.initialization.sampling(self.problem, self.pop_size)
+        samples = self.evaluator.eval(self.problem, samples)
+
+        # do a survival to recreate rank and crowding of all individuals
+        samples = RankAndCrowding().do(self.problem, samples, n_survive=len(samples))
+        return samples
+
+    def _select_means_stds(self, means_stds, mean_new, std_new):
+        # Unpack means and stds
+        means = np.array([m[0] for m in means_stds])
+        stds = np.array([m[1] for m in means_stds])
+
+        # Calculate distances
+        mean_diffs = means - mean_new
+        std_diffs = stds - std_new
+
+        distances = np.sqrt(np.sum(mean_diffs**2, axis=1) + np.sum(std_diffs**2, axis=1))
+
+        # Get top K closest
+        top_k_idx = np.argsort(distances)[:self.size_pool]
+        top_k_dist = distances[top_k_idx]
+        top_k_means = means[top_k_idx]
+        top_k_stds = stds[top_k_idx]
+
+        # Update pool
+        self._update_means_stds_pool(means_stds, top_k_idx)
+
+        # Calculate weights
+        weights = 1 / (top_k_dist + 1e-8)  # Add small epsilon to avoid division by zero
+        weights = weights / (np.sum(weights) + self.denominator)
+
+        # Weighted combination
+        mean_new = (1 - np.sum(weights)) * mean_new + np.sum(weights[:, None] * top_k_means, axis=0)
+        std_new = (1 - np.sum(weights)) * std_new + np.sum(weights[:, None] * top_k_stds, axis=0)
+        return mean_new, std_new
+
+    def _update_means_stds_pool(self, means_stds, top_k_idx) -> None:
+        self.data["means_stds"] = [means_stds[i] for i in top_k_idx]
+        return None

pydmoo/algorithms/learning/moead_tr.py

@@ -30,7 +30,7 @@ class MOEADTr(DMOEAD):
         #
         self._maxiter = max(self.pop_size, 100)  # default is 1000
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X, F = pop.get("X", "F")

pydmoo/algorithms/learning/moeadde_tr.py

@@ -30,7 +30,7 @@ class MOEADDETr(DMOEADDE):
         #
         self._maxiter = max(self.pop_size, 100)  # default is 1000
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X, F = pop.get("X", "F")

pydmoo/algorithms/learning/nsga2_tr.py

@@ -30,7 +30,7 @@ class NSGA2Tr(DNSGA2):
         #
         self._maxiter = max(self.pop_size, 100)  # default is 1000
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X, F = pop.get("X", "F")

pydmoo/algorithms/modern/moead_imkt.py

@@ -19,7 +19,7 @@ class MOEADIMKT(MOEADKTMM):
         self.size_pool = 10
         self.denominator = 0.5
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moead_imkt_igp.py

@@ -16,7 +16,7 @@ class MOEADIMKTIGP(MOEADIMKT):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moead_imkt_lstm.py

@@ -42,7 +42,7 @@ class MOEADIMLSTM(MOEADIMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moead_imkt_n.py

@@ -19,7 +19,7 @@ class MOEADIMKTN(MOEADIMKT):
         self.size_pool = 10
         self.denominator = 0.5
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moead_imkt_n_igp.py

@@ -16,7 +16,7 @@ class MOEADIMKTNIGP(MOEADIMKTN):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moead_imkt_n_lstm.py

@@ -43,7 +43,7 @@ class MOEADIMNLSTM(MOEADIMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moead_ktmm.py

@@ -22,7 +22,7 @@ class MOEADKTMM(DMOEAD):
         self.size_pool = 14  # the size of knowledge pool
         self.denominator = 0.5
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt.py

@@ -19,7 +19,7 @@ class MOEADDEIMKT(MOEADDEKTMM):
         self.size_pool = 10
         self.denominator = 0.5
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt_clstm.py

@@ -36,7 +36,7 @@ class MOEADDEIMcLSTM(MOEADDEIMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt_igp.py

@@ -16,7 +16,7 @@ class MOEADDEIMKTIGP(MOEADDEIMKT):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt_lstm.py

@@ -42,7 +42,7 @@ class MOEADDEIMLSTM(MOEADDEIMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt_n.py

@@ -19,7 +19,7 @@ class MOEADDEIMKTN(MOEADDEIMKT):
         self.size_pool = 10
         self.denominator = 0.5
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt_n_clstm.py

@@ -37,7 +37,7 @@ class MOEADDEIMNcLSTM(MOEADDEIMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt_n_igp.py

@@ -16,7 +16,7 @@ class MOEADDEIMKTNIGP(MOEADDEIMKTN):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/moeadde_imkt_n_lstm.py

@@ -43,7 +43,7 @@ class MOEADDEIMNLSTM(MOEADDEIMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")