pydmoo 0.0.18__py3-none-any.whl → 0.1.0__py3-none-any.whl

pydmoo/algorithms/base/moo/nsga2.py

@@ -0,0 +1,122 @@
+"""
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [nsga2.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/algorithms/moo/nsga2.py).
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
+"""
+
+import warnings
+
+import numpy as np
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.tournament import TournamentSelection, compare
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+from pymoo.termination.default import DefaultMultiObjectiveTermination
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.dominator import Dominator
+from pymoo.util.misc import has_feasible
+
+from pydmoo.algorithms.base.core.genetic import GeneticAlgorithm
+
+# ---------------------------------------------------------------------------------------------------------
+# Binary Tournament Selection Function
+# ---------------------------------------------------------------------------------------------------------
+
+
+def binary_tournament(pop, P, algorithm, **kwargs):
+    n_tournaments, n_parents = P.shape
+
+    if n_parents != 2:
+        raise ValueError("Only implemented for binary tournament!")
+
+    tournament_type = algorithm.tournament_type
+    S = np.full(n_tournaments, np.nan)
+
+    for i in range(n_tournaments):
+
+        a, b = P[i, 0], P[i, 1]
+        a_cv, a_f, b_cv, b_f = pop[a].CV[0], pop[a].F, pop[b].CV[0], pop[b].F
+        rank_a, cd_a = pop[a].get("rank", "crowding")
+        rank_b, cd_b = pop[b].get("rank", "crowding")
+
+        # if at least one solution is infeasible
+        if a_cv > 0.0 or b_cv > 0.0:
+            S[i] = compare(a, a_cv, b, b_cv, method='smaller_is_better', return_random_if_equal=True, random_state=algorithm.random_state)
+
+        # both solutions are feasible
+        else:
+
+            if tournament_type == 'comp_by_dom_and_crowding':
+                rel = Dominator.get_relation(a_f, b_f)
+                if rel == 1:
+                    S[i] = a
+                elif rel == -1:
+                    S[i] = b
+
+            elif tournament_type == 'comp_by_rank_and_crowding':
+                S[i] = compare(a, rank_a, b, rank_b, method='smaller_is_better')
+
+            else:
+                raise Exception("Unknown tournament type.")
+
+            # if rank or domination relation didn't make a decision compare by crowding
+            if np.isnan(S[i]):
+                S[i] = compare(a, cd_a, b, cd_b, method='larger_is_better', return_random_if_equal=True, random_state=algorithm.random_state)
+
+    return S[:, None].astype(int, copy=False)
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Survival Selection
+# ---------------------------------------------------------------------------------------------------------
+
+
+class RankAndCrowdingSurvival(RankAndCrowding):
+
+    def __init__(self, nds=None, crowding_func="cd"):
+        super().__init__(nds, crowding_func)
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class NSGA2(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 sampling=FloatRandomSampling(),
+                 selection=TournamentSelection(func_comp=binary_tournament),
+                 crossover=SBX(eta=15, prob=0.9),
+                 mutation=PM(eta=20),
+                 survival=RankAndCrowding(),
+                 output=MultiObjectiveOutput(),
+                 **kwargs):
+
+        super().__init__(
+            pop_size=pop_size,
+            sampling=sampling,
+            selection=selection,
+            crossover=crossover,
+            mutation=mutation,
+            survival=survival,
+            output=output,
+            advance_after_initial_infill=True,
+            **kwargs)
+
+        self.termination = DefaultMultiObjectiveTermination()
+        self.tournament_type = 'comp_by_dom_and_crowding'
+
+    def _set_optimum(self, **kwargs):
+        if not has_feasible(self.pop):
+            self.opt = self.pop[[np.argmin(self.pop.get("CV"))]]
+        else:
+            self.opt = self.pop[self.pop.get("rank") == 0]
+
+
+parse_doc_string(NSGA2.__init__)

pydmoo/algorithms/modern/__init__.py

@@ -0,0 +1,94 @@
+from pydmoo.algorithms.modern.moeadde_imkt_clstm import (
+    MOEADDEIMicLSTM1003,
+    MOEADDEIMicLSTM1005,
+    MOEADDEIMicLSTM1007,
+    MOEADDEIMicLSTM1009,
+    MOEADDEIMicLSTM1503,
+    MOEADDEIMicLSTM1505,
+    MOEADDEIMicLSTM1507,
+    MOEADDEIMicLSTM1509,
+    MOEADDEIMicLSTM1511,
+    MOEADDEIMicLSTM1513,
+)
+from pydmoo.algorithms.modern.moeadde_imkt_lstm import (
+    MOEADDEIMiLSTM1003,
+    MOEADDEIMiLSTM1005,
+    MOEADDEIMiLSTM1007,
+    MOEADDEIMiLSTM1009,
+    MOEADDEIMiLSTM1503,
+    MOEADDEIMiLSTM1505,
+    MOEADDEIMiLSTM1507,
+    MOEADDEIMiLSTM1509,
+    MOEADDEIMiLSTM1511,
+    MOEADDEIMiLSTM1513,
+)
+from pydmoo.algorithms.modern.nsga2_imkt_clstm import (
+    NSGA2IMicLSTM1003,
+    NSGA2IMicLSTM1005,
+    NSGA2IMicLSTM1007,
+    NSGA2IMicLSTM1009,
+    NSGA2IMicLSTM1503,
+    NSGA2IMicLSTM1505,
+    NSGA2IMicLSTM1507,
+    NSGA2IMicLSTM1509,
+    NSGA2IMicLSTM1511,
+    NSGA2IMicLSTM1513,
+)
+from pydmoo.algorithms.modern.nsga2_imkt_lstm import (
+    NSGA2IMiLSTM1003,
+    NSGA2IMiLSTM1005,
+    NSGA2IMiLSTM1007,
+    NSGA2IMiLSTM1009,
+    NSGA2IMiLSTM1503,
+    NSGA2IMiLSTM1505,
+    NSGA2IMiLSTM1507,
+    NSGA2IMiLSTM1509,
+    NSGA2IMiLSTM1511,
+    NSGA2IMiLSTM1513,
+)
+
+ALGORITHMS_ABLATION = {
+    "MOEADDEIMicLSTM1003": MOEADDEIMicLSTM1003,
+    "MOEADDEIMicLSTM1005": MOEADDEIMicLSTM1005,
+    "MOEADDEIMicLSTM1007": MOEADDEIMicLSTM1007,
+    "MOEADDEIMicLSTM1009": MOEADDEIMicLSTM1009,
+    "MOEADDEIMicLSTM1503": MOEADDEIMicLSTM1503,
+    "MOEADDEIMicLSTM1505": MOEADDEIMicLSTM1505,
+    "MOEADDEIMicLSTM1507": MOEADDEIMicLSTM1507,
+    "MOEADDEIMicLSTM1509": MOEADDEIMicLSTM1509,
+    "MOEADDEIMicLSTM1511": MOEADDEIMicLSTM1511,
+    "MOEADDEIMicLSTM1513": MOEADDEIMicLSTM1513,
+
+    "MOEADDEIMiLSTM1003": MOEADDEIMiLSTM1003,
+    "MOEADDEIMiLSTM1005": MOEADDEIMiLSTM1005,
+    "MOEADDEIMiLSTM1007": MOEADDEIMiLSTM1007,
+    "MOEADDEIMiLSTM1009": MOEADDEIMiLSTM1009,
+    "MOEADDEIMiLSTM1503": MOEADDEIMiLSTM1503,
+    "MOEADDEIMiLSTM1505": MOEADDEIMiLSTM1505,
+    "MOEADDEIMiLSTM1507": MOEADDEIMiLSTM1507,
+    "MOEADDEIMiLSTM1509": MOEADDEIMiLSTM1509,
+    "MOEADDEIMiLSTM1511": MOEADDEIMiLSTM1511,
+    "MOEADDEIMiLSTM1513": MOEADDEIMiLSTM1513,
+
+    "NSGA2IMicLSTM1003": NSGA2IMicLSTM1003,
+    "NSGA2IMicLSTM1005": NSGA2IMicLSTM1005,
+    "NSGA2IMicLSTM1007": NSGA2IMicLSTM1007,
+    "NSGA2IMicLSTM1009": NSGA2IMicLSTM1009,
+    "NSGA2IMicLSTM1503": NSGA2IMicLSTM1503,
+    "NSGA2IMicLSTM1505": NSGA2IMicLSTM1505,
+    "NSGA2IMicLSTM1507": NSGA2IMicLSTM1507,
+    "NSGA2IMicLSTM1509": NSGA2IMicLSTM1509,
+    "NSGA2IMicLSTM1511": NSGA2IMicLSTM1511,
+    "NSGA2IMicLSTM1513": NSGA2IMicLSTM1513,
+
+    "NSGA2IMiLSTM1003": NSGA2IMiLSTM1003,
+    "NSGA2IMiLSTM1005": NSGA2IMiLSTM1005,
+    "NSGA2IMiLSTM1007": NSGA2IMiLSTM1007,
+    "NSGA2IMiLSTM1009": NSGA2IMiLSTM1009,
+    "NSGA2IMiLSTM1503": NSGA2IMiLSTM1503,
+    "NSGA2IMiLSTM1505": NSGA2IMiLSTM1505,
+    "NSGA2IMiLSTM1507": NSGA2IMiLSTM1507,
+    "NSGA2IMiLSTM1509": NSGA2IMiLSTM1509,
+    "NSGA2IMiLSTM1511": NSGA2IMiLSTM1511,
+    "NSGA2IMiLSTM1513": NSGA2IMiLSTM1513,
+}

pydmoo/algorithms/modern/moead_imkt.py

@@ -0,0 +1,161 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.modern.moead_ktmm import MOEADKTMM
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.inverse import closed_form_solution
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class MOEADIMKT(MOEADKTMM):
+    """Inverse Modeling with Knowledge Transfer.
+
+    Inverse Modeling for Dynamic Multiobjective Optimization with Knowledge Transfer In objective Space.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_stds, mean, std = self._in_decision_or_objective_space_1d(samples, "objective_space")
+        mean_new, std_new = self._select_means_stds(means_stds, mean, std)
+
+        # sample self.pop_size individuals in objective space
+        F = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        # X = FB
+        B = closed_form_solution(samples.get("X"), samples.get("F"))
+
+        # X = FB
+        X = np.dot(F, B)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def sampling_new_pop(self):
+        X = self.pop.get("X")
+
+        if not self.problem.has_constraints():
+
+            last_X = self.data.get("last_X", [])
+            if len(last_X) == 0:
+                last_X = X
+            self.data["last_X"] = X
+
+            d = np.mean(X - last_X, axis=0)
+
+            radius = max(np.linalg.norm(d) / self.problem.n_obj, 0.1)
+
+            X = X + d + self.random_state.uniform(low=-radius, high=radius, size=X.shape)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        samples = Population.new(X=X)
+        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
+
+
+class MOEADIMKT0(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+class MOEADIMKT1(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 2
+        self.denominator = 0.5
+
+
+class MOEADIMKT2(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 4
+        self.denominator = 0.5
+
+
+class MOEADIMKT3(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 6
+        self.denominator = 0.5
+
+
+class MOEADIMKT4(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 8
+        self.denominator = 0.5
+
+
+class MOEADIMKT5(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+
+class MOEADIMKT6(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 12
+        self.denominator = 0.5
+
+
+class MOEADIMKT7(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 14
+        self.denominator = 0.5
+
+
+class MOEADIMKT8(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 16
+        self.denominator = 0.5
+
+
+class MOEADIMKT9(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 18
+        self.denominator = 0.5
+
+
+class MOEADIMKT10(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 20
+        self.denominator = 0.5

pydmoo/algorithms/modern/moead_imkt_igp.py

@@ -0,0 +1,56 @@
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.moead_imkt import MOEADIMKT
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.predictions import igp_based_predictor
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class MOEADIMKTIGP(MOEADIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+        self.delta_s = 0.01
+        self.sigma_n = 0.01
+        self.sigma_n_2 = self.sigma_n ** 2
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_stds, mean, std = self._in_decision_or_objective_space_1d(samples, "objective_space")
+        mean_new, std_new = self._select_means_stds(means_stds, mean, std)
+
+        # sample self.pop_size individuals in objective space
+        F = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        X = igp_based_predictor(samples.get("X"), samples.get("F"), F, self.sigma_n_2)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+
+class MOEADIMKTIGP0(MOEADIMKTIGP):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

pydmoo/algorithms/modern/moead_imkt_lstm.py

@@ -0,0 +1,109 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.moead_imkt import MOEADIMKT
+from pydmoo.algorithms.modern.nsga2_imkt_lstm import prepare_data_means_std
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.inverse import closed_form_solution
+from pydmoo.core.lstm.lstm import LSTMpredictor
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class MOEADIMLSTM(MOEADIMKT):
+    """Inverse Modeling with LSTM (IMLSTM).
+
+    Inverse Modeling for Dynamic Multiobjective Optimization with LSTM prediction In objective Space.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+        self._n_timesteps = 10
+        self._sequence_length = 5  # Use 5 historical time steps to predict next step
+        self._incremental_learning = False
+
+    def _setup(self, problem, **kwargs):
+        super()._setup(problem, **kwargs)
+
+        # Must be here
+        self._lstm = LSTMpredictor(
+            self._sequence_length,
+            hidden_dim=64,
+            num_layers=1,
+            epochs=50,
+            batch_size=32,
+            lr=0.001,
+            device="cpu",  # for fair comparison
+            patience=5,
+            seed=self.seed,
+            model_type="lstm",
+            incremental_learning=self._incremental_learning,
+        )
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_stds, mean, std = self._in_decision_or_objective_space_1d(samples, "objective_space")
+
+        # Check if sufficient historical data is available for LSTM prediction
+        if len(means_stds) > self._n_timesteps:
+            # Update pool
+            self.data["means_stds"] = means_stds[self._n_timesteps:]
+
+            # Prepare time series data from historical means and standard deviations
+            time_series_data = prepare_data_means_std(self._n_timesteps, means_stds)
+
+            # Initialize predictor and generate prediction for next time step
+            next_prediction = self._lstm.convert_train_predict(time_series_data)
+
+            # Convert prediction tensor to numpy array for further processing
+            next_prediction = next_prediction.numpy()
+
+            # Split prediction into mean and standard deviation components
+            # First n_obj elements represent mean values, remaining elements represent standard deviations
+            mean_new, std_new = next_prediction[:self.problem.n_obj], next_prediction[self.problem.n_obj:]
+            std_new = np.abs(std_new)
+
+        else:
+            mean_new, std_new = self._select_means_stds(means_stds, mean, std)
+
+        # sample self.pop_size individuals in objective space
+        F = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        # X = FB
+        B = closed_form_solution(samples.get("X"), samples.get("F"))
+
+        # X = FB
+        X = np.dot(F, B)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+
+class MOEADIMiLSTM(MOEADIMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self._incremental_learning = True

pydmoo/algorithms/modern/moead_imkt_n.py

@@ -0,0 +1,117 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.moead_imkt import MOEADIMKT
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.distance import norm_mean_frobenius_distance
+from pydmoo.core.inverse import closed_form_solution
+from pydmoo.core.sample_gaussian import multivariate_gaussian_sample
+
+
+class MOEADIMKTN(MOEADIMKT):
+    """Inverse Modeling with Knowledge Transfer.
+
+    Inverse Modeling for Dynamic Multiobjective Optimization with Knowledge Transfer In objective Space.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_stds, mean, cov = self._in_decision_or_objective_space_nd(samples, "objective_space")
+        mean_new, cov_new = self._select_means_covs(means_stds, mean, cov)
+
+        # sample self.pop_size individuals in objective space
+        F = multivariate_gaussian_sample(mean_new, cov_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        # X = FB
+        B = closed_form_solution(samples.get("X"), samples.get("F"))
+
+        # X = FB
+        X = np.dot(F, B)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def _in_decision_or_objective_space_nd(self, samples, decision_or_objective="decision_space"):
+        # decision space or objective space
+        flag = "X" if decision_or_objective == "decision_space" else "F"
+
+        means_covs = self.data.get("means_covs", [])
+
+        flag_value = self.opt.get(flag)
+        if len(flag_value) <= 1:
+            flag_value = self.pop.get(flag)
+            flag_value = flag_value[:2]
+
+        m, c = np.mean(flag_value, axis=0), np.cov(flag_value.T)
+        means_covs.append((m, 0.5 * (c.T + c), self.n_iter - 1))  # 1-based
+        self.data["means_covs"] = means_covs
+
+        flag_value = samples.get(flag)
+        mean, cov = np.mean(flag_value, axis=0), np.cov(flag_value.T)
+        return means_covs, mean, 0.5 * (cov.T + cov)
+
+    def _select_means_covs(self, means_covs, mean_new, cov_new):
+        # Unpack means and stds
+        means = np.array([m[0] for m in means_covs])
+        covs = np.array([m[1] for m in means_covs])
+
+        # Calculate distances
+        distances = np.array([
+            norm_mean_frobenius_distance(mean, cov, mean_new, cov_new) for mean, cov in zip(means, covs)
+        ])
+
+        # 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_covs = covs[top_k_idx]
+
+        # Update pool
+        self._update_means_covs_pool(means_covs, 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)
+        cov_new = (1 - np.sum(weights)) * cov_new + np.sum(weights[:, None, None] * top_k_covs, axis=0)
+
+        # Symmetric matrix
+        cov_new = 0.5 * (cov_new.T + cov_new)
+        return mean_new, cov_new
+
+    def _update_means_covs_pool(self, means_covs, top_k_idx) -> None:
+        self.data["means_covs"] = [means_covs[i] for i in top_k_idx]
+        return None
+
+
+class MOEADIMKTN0(MOEADIMKTN):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)