API Reference

This page provides API documentation for the main classes and methods in D²MTOLab.

Algorithms

All algorithms follow a consistent interface:

from ddmtolab.Algorithms.STSO.DE import DE
from ddmtolab.Methods.mtop import MTOP

problem = MTOP()
problem.add_task(objective_func, dim=10)

optimizer = DE(problem, n=50, max_nfes=1000)
results = optimizer.optimize()

print(results.best_decs, results.best_objs)

Single-Task Single-Objective (STSO)

Genetic Algorithm (GA)

This module implements the Genetic Algorithm for single-objective optimization problems.

References

[1] David E. Goldberg. Genetic Algorithms in Search, Optimization, and Machine Learning. Addison-Wesley, Reading, MA, 1989.

[2] John H. Holland. Adaptation in Natural and Artificial Systems: An Introductory Analysis with Applications to Biology, Control, and Artificial Intelligence. University of Michigan Press, Ann Arbor, MI, 1st edition, 1975. Reprinted by MIT Press in 1992.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.11 Version: 1.0

class ddmtolab.Algorithms.STSO.GA.GA(problem, n=None, max_nfes=None, muc=2.0, mum=5.0, save_data=True, save_path='./Data', name='GA', disable_tqdm=True)[source]

Bases: object

Genetic Algorithm for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=2.0, mum=5.0, save_data=True, save_path='./Data', name='GA', disable_tqdm=True)[source]

Initialize Genetic Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 2.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 5.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘GA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Genetic Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Differential Evolution (DE)

This module implements Differential Evolution for single-objective optimization problems.

References

[1] Storn, Rainer, and Kenneth Price. “Differential evolution–a simple and efficient heuristic for global optimization over continuous spaces.” Journal of global optimization 11.4 (1997): 341-359.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.10.24 Version: 1.0

class ddmtolab.Algorithms.STSO.DE.DE(problem, n=None, max_nfes=None, F=0.5, CR=0.9, save_data=True, save_path='./Data', name='DE', disable_tqdm=True)[source]

Bases: object

Differential Evolution algorithm for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, F=0.5, CR=0.9, save_data=True, save_path='./Data', name='DE', disable_tqdm=True)[source]

Initialize Differential Evolution algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
F (float, optional) – Scaling factor for mutation (default: 0.5)
CR (float, optional) – Crossover probability (default: 0.9)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘DE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Differential Evolution algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Particle Swarm Optimization (PSO)

This module implements Particle Swarm Optimization for single-objective optimization problems.

References

[1] Kennedy, James, and Russell Eberhart. “Particle swarm optimization.” Proceedings of ICNN’95-international conference on neural networks. Vol. 4. IEEE, 1995.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.10.23 Version: 1.0

class ddmtolab.Algorithms.STSO.PSO.PSO(problem, n=None, max_nfes=None, min_w=0.4, max_w=0.9, c1=0.2, c2=0.2, save_data=True, save_path='./Data', name='PSO', disable_tqdm=True)[source]

Bases: object

Particle Swarm Optimization algorithm for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, min_w=0.4, max_w=0.9, c1=0.2, c2=0.2, save_data=True, save_path='./Data', name='PSO', disable_tqdm=True)[source]

Initialize Particle Swarm Optimization algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
min_w (float, optional) – Minimum inertia weight (default: 0.4)
max_w (float, optional) – Maximum inertia weight (default: 0.9)
c1 (float, optional) – Cognitive coefficient (self-learning factor) (default: 0.2)
c2 (float, optional) – Social coefficient (swarm-learning factor) (default: 0.2)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘PSO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Particle Swarm Optimization algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

CMA-ES (Covariance Matrix Adaptation Evolution Strategy)

This module implements the CMA-ES algorithm for single-objective optimization problems.

References

[1] Hansen, N., & Ostermeier, A. (2001). Completely Derandomized Self-Adaptation in Evolution Strategies. Evolutionary Computation, 9(2), 159-195. DOI: 10.1162/106365601750190398

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.12 Version: 1.0

class ddmtolab.Algorithms.STSO.CMA_ES.CMA_ES(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='CMA-ES', disable_tqdm=True)[source]

Bases: object

CMA-ES for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='CMA-ES', disable_tqdm=True)[source]

Initialize CMA-ES Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: None, will use 4+3*log(D))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
sigma0 (float, optional) – Initial step size (default: 0.3)
use_n (bool, optional) – If True, use provided n; if False, use 4+3*log(D) (default: True)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘CMA-ES’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the CMA-ES Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

IPOP-CMA-ES (Increasing Population CMA-ES)

This module implements the IPOP-CMA-ES algorithm for single-objective optimization problems.

References

[1] Auger, A., & Hansen, N. (2005). A Restart CMA Evolution Strategy with Increasing Population Size. 2005 IEEE Congress on Evolutionary Computation, 2, 1769-1776. DOI: 10.1109/CEC.2005.1554902

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.27 Version: 1.0

class ddmtolab.Algorithms.STSO.IPOP_CMA_ES.IPOP_CMA_ES(problem, n=None, max_nfes=None, sigma0=0.3, use_n=False, save_data=True, save_path='./Data', name='IPOP-CMA-ES', disable_tqdm=True)[source]

Bases: object

IPOP-CMA-ES for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, sigma0=0.3, use_n=False, save_data=True, save_path='./Data', name='IPOP-CMA-ES', disable_tqdm=True)[source]

Initialize IPOP-CMA-ES Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Initial population size per task (default: None, will use 4+3*log(D))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
sigma0 (float, optional) – Initial step size (default: 0.3)
use_n (bool, optional) – If True, use provided n; if False, use 4+3*log(D) (default: False)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘IPOP-CMA-ES’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the IPOP-CMA-ES Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

sep-CMA-ES (Separable Covariance Matrix Adaptation Evolution Strategy)

This module implements the sep-CMA-ES algorithm for single-objective optimization problems. sep-CMA-ES achieves linear time and space complexity by using a diagonal covariance matrix.

References

[1] Ros, R., & Hansen, N. (2008). A Simple Modification in CMA-ES Achieving Linear Time and Space Complexity. Parallel Problem Solving from Nature, PPSN X, 296-305. DOI: 10.1007/978-3-540-87700-4_30

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.27 Version: 1.0

class ddmtolab.Algorithms.STSO.sep_CMA_ES.sep_CMA_ES(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='sep-CMA-ES', disable_tqdm=True)[source]

Bases: object

sep-CMA-ES for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='sep-CMA-ES', disable_tqdm=True)[source]

Initialize sep-CMA-ES Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: None, will use 4+3*log(D))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
sigma0 (float, optional) – Initial step size (default: 0.3)
use_n (bool, optional) – If True, use provided n; if False, use 4+3*log(D) (default: True)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘sep-CMA-ES’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the sep-CMA-ES Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

MA-ES (Matrix Adaptation Evolution Strategy)

This module implements the MA-ES algorithm for single-objective optimization problems. MA-ES uses matrix adaptation instead of covariance matrix adaptation for efficiency.

References

[1] Bayer, H. G., & Sendhoff, B. (2017). Simplify Your Covariance Matrix Adaptation Evolution Strategy. IEEE Transactions on Evolutionary Computation, 21(5), 746-759. DOI: 10.1109/TEVC.2017.2680320

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.27 Version: 1.0

class ddmtolab.Algorithms.STSO.MA_ES.MA_ES(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='MA-ES', disable_tqdm=True)[source]

Bases: object

MA-ES for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='MA-ES', disable_tqdm=True)[source]

Initialize MA-ES Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: None, will use 4+3*log(D))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
sigma0 (float, optional) – Initial step size (default: 0.3)
use_n (bool, optional) – If True, use provided n; if False, use 4+3*log(D) (default: True)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MA-ES’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MA-ES Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

OpenAI-ES (OpenAI Evolution Strategies)

This module implements the OpenAI-ES algorithm for single-objective optimization problems. OpenAI-ES uses antithetic sampling and momentum-based gradient descent.

References

[1] Salimans, T., Ho, J., Chen, X., Sidor, S., & Sutskever, I. (2017). Evolution Strategies as a Scalable Alternative to Reinforcement Learning. arXiv:1703.03864 [stat.ML].

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.27 Version: 1.0

class ddmtolab.Algorithms.STSO.OpenAI_ES.OpenAI_ES(problem, n=None, max_nfes=None, sigma=1.0, lr=0.001, momentum=0.9, save_data=True, save_path='./Data', name='OpenAI-ES', disable_tqdm=True)[source]

Bases: object

OpenAI-ES for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, sigma=1.0, lr=0.001, momentum=0.9, save_data=True, save_path='./Data', name='OpenAI-ES', disable_tqdm=True)[source]

Initialize OpenAI-ES Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (must be even, default: None, will use 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
sigma (float, optional) – Noise standard deviation (default: 1.0)
lr (float, optional) – Learning rate (default: 1e-3)
momentum (float, optional) – Momentum coefficient (default: 0.9)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘OpenAI-ES’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the OpenAI-ES Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

xNES (Exponential Natural Evolution Strategies)

This module implements the xNES algorithm for single-objective optimization problems. xNES uses natural gradients to adapt the search distribution.

References

[1] Glasmachers, T., Schaul, T., Yi, S., Wierstra, D., & Schmidhuber, J. (2010). Exponential Natural Evolution Strategies. Proceedings of the 12th Annual Conference on Genetic and Evolutionary Computation, 393-400. [2] Wierstra, D., Schaul, T., Glasmachers, T., Sun, Y., Peters, J., & Schmidhuber, J. (2014). Natural Evolution Strategies. Journal of Machine Learning Research, 15(27), 949-980.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.27 Version: 1.0

class ddmtolab.Algorithms.STSO.xNES.xNES(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='xNES', disable_tqdm=True)[source]

Bases: object

xNES for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, save_data=True, save_path='./Data', name='xNES', disable_tqdm=True)[source]

Initialize xNES Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: None, will use 4+3*log(D))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
sigma0 (float, optional) – Initial step size (default: 0.3)
use_n (bool, optional) – If True, use provided n; if False, use 4+3*log(D) (default: True)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘xNES’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the xNES Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Competitive Swarm Optimizer (CSO)

This module implements Competitive Swarm Optimizer for single-objective optimization problems.

References

[1] Cheng, Ran, and Yaochu Jin. “A competitive swarm optimizer for large scale optimization.” IEEE Transactions on Cybernetics 45.2 (2015): 191-204.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.10.31 Version: 1.0

class ddmtolab.Algorithms.STSO.CSO.CSO(problem, n=None, max_nfes=None, phi=0.1, save_data=True, save_path='./Data', name='CSO', disable_tqdm=True)[source]

Bases: object

Competitive Swarm Optimizer algorithm for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, phi=0.1, save_data=True, save_path='./Data', name='CSO', disable_tqdm=True)[source]

Initialize Competitive Swarm Optimizer algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
phi (float, optional) – Social influence parameter for mean position learning (default: 0.1)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘CSO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Competitive Swarm Optimizer algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Social Learning Particle Swarm Optimization (SL-PSO)

This module implements the Social Learning PSO for single-objective optimization problems.

References

[1] Cheng, R., & Jin, Y. (2014). A social learning particle swarm optimization algorithm for scalable optimization. Information Sciences, 291, 43-60.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.22 Version: 1.0

class ddmtolab.Algorithms.STSO.SL_PSO.SL_PSO(problem, n=None, max_nfes=None, save_data=True, save_path='./Data', name='SL-PSO', disable_tqdm=True)[source]

Bases: object

Social Learning Particle Swarm Optimization for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, save_data=True, save_path='./Data', name='SL-PSO', disable_tqdm=True)[source]

Initialize Social Learning PSO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Base swarm size M per task (default: 100, the paper’s setting). The actual swarm size per task is m = M + floor(dim / 10), following the reference formulation; M is also used in the learning-probability exponent and the social influence factor.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SL-PSO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Social Learning PSO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Knowledge Learning PSO (KLPSO)

This module implements Knowledge Learning PSO for single-objective optimization problems. A neural network learns successful movement patterns from improved particles. With probability LR, particles move using the learned knowledge instead of standard PSO velocity update.

References

[1] Jiang, Yi, et al. “Knowledge Learning for Evolutionary Computation.” IEEE Transactions on Evolutionary Computation, 2023. DOI: 10.1109/TEVC.2023.3278132

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.21 Version: 1.0

class ddmtolab.Algorithms.STSO.KLPSO.KLPSO(problem, n=None, max_nfes=None, lr=0.2, ep=10, min_w=0.4, max_w=0.9, c1=0.2, c2=0.2, save_data=True, save_path='./Data', name='KLPSO', disable_tqdm=True)[source]

Bases: object

Knowledge Learning PSO algorithm for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, lr=0.2, ep=10, min_w=0.4, max_w=0.9, c1=0.2, c2=0.2, save_data=True, save_path='./Data', name='KLPSO', disable_tqdm=True)[source]

Initialize KLPSO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
lr (float, optional) – Learning rate - probability of using neural net prediction (default: 0.2)
ep (int, optional) – Number of training epochs per generation (default: 10)
min_w (float, optional) – Minimum inertia weight (default: 0.4)
max_w (float, optional) – Maximum inertia weight (default: 0.9)
c1 (float, optional) – Cognitive coefficient (default: 0.2)
c2 (float, optional) – Social coefficient (default: 0.2)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘KLPSO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the KLPSO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Surrogate-assisted Hierarchical Particle Swarm Optimization (SHPSO)

This module implements SHPSO for expensive single-objective optimization problems.

References

[1] Yu, Haibo, et al. “Surrogate-assisted hierarchical particle swarm optimization.” Information Sciences 454 (2018): 59-72.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.13 Version: 1.0

class ddmtolab.Algorithms.STSO.SHPSO.SHPSO(problem, n_initial=None, max_nfes=None, ps=None, save_data=True, save_path='./Data', name='SHPSO', disable_tqdm=True)[source]

Bases: object

Surrogate-assisted Hierarchical Particle Swarm Optimization for expensive optimization problems.

This algorithm uses a two-level hierarchical structure: 1. Upper level: RBF surrogate model optimized by SL-PSO to find promising regions 2. Lower level: PSO swarm guided by surrogate model optimum with prescreening strategy

__init__(problem, n_initial=None, max_nfes=None, ps=None, save_data=True, save_path='./Data', name='SHPSO', disable_tqdm=True)[source]

Initialize SHPSO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
ps (int or List[int], optional) – Particle swarm size per task (default: 50)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SHPSO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SHPSO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Grey Wolf Optimizer (GWO)

This module implements the Grey Wolf Optimizer for single-objective optimization problems.

References

[1] Mirjalili, S., Mirjalili, S. M., & Lewis, A. (2014). Grey wolf optimizer. Advances in engineering software, 69, 46-61.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.08 Version: 1.0

class ddmtolab.Algorithms.STSO.GWO.GWO(problem, n=None, max_nfes=None, save_data=True, save_path='./Data', name='GWO', disable_tqdm=True)[source]

Bases: object

Grey Wolf Optimizer for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, save_data=True, save_path='./Data', name='GWO', disable_tqdm=True)[source]

Initialize Grey Wolf Optimizer.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘GWO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Grey Wolf Optimizer algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Aquila Optimizer (AO)

This module implements the Aquila Optimizer for single-objective optimization problems.

References

[1] Abualigah, L., Yousri, D., Abd Elaziz, M., Ewees, A. A., Al-qaness, M. A., & Gandomi, A. H. (2021). Aquila Optimizer: A novel meta-heuristic optimization algorithm. Computers & Industrial Engineering, 157, 107250.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.10 Version: 1.0

class ddmtolab.Algorithms.STSO.AO.AO(problem, n=None, max_nfes=None, alpha=0.1, delta=0.1, save_data=True, save_path='./Data', name='AO', disable_tqdm=True)[source]

Bases: object

Aquila Optimizer for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, alpha=0.1, delta=0.1, save_data=True, save_path='./Data', name='AO', disable_tqdm=True)[source]

Initialize Aquila Optimizer.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
alpha (float, optional) – Exploitation adjustment parameter (default: 0.1)
delta (float, optional) – Exploitation adjustment parameter (default: 0.1)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘AO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Aquila Optimizer algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Equilibrium Optimizer (EO)

This module implements the Equilibrium Optimizer for single-objective optimization problems.

References

[1] Faramarzi, A., Heidarinejad, M., Stephens, B., & Mirjalili, S. (2020). Equilibrium optimizer: A novel optimization algorithm. Knowledge-Based Systems, 191, 105190.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.12 Version: 1.0

class ddmtolab.Algorithms.STSO.EO.EO(problem, n=None, max_nfes=None, a1=2, a2=1, v=1, gp=0.5, save_data=True, save_path='./Data', name='EO', disable_tqdm=True)[source]

Bases: object

Equilibrium Optimizer for single-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, a1=2, a2=1, v=1, gp=0.5, save_data=True, save_path='./Data', name='EO', disable_tqdm=True)[source]

Initialize Equilibrium Optimizer.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
a1 (float, optional) – Exploration constant (default: 2)
a2 (float, optional) – Exploitation constant (default: 1)
v (float, optional) – Volume coefficient (default: 1)
gp (float, optional) – Generation probability (default: 0.5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Equilibrium Optimizer algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Global-Local Surrogate-Assisted Differential Evolution (GL-SADE)

This module implements GL-SADE for expensive single-objective optimization problems.

References

[1] Wang, Weizhong, Hai-Lin Liu, and Kay Chen Tan. “A surrogate-assisted differential evolution algorithm for high-dimensional expensive optimization problems.” IEEE Transactions on Cybernetics 53.4 (2022): 2685-2697.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.23 Version: 1.1

class ddmtolab.Algorithms.STSO.GL_SADE.GL_SADE(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='GL-SADE', disable_tqdm=True)[source]

Bases: object

Global-Local Surrogate-Assisted Differential Evolution for expensive optimization problems.

This algorithm adaptively switches between: 1. Global search: RBF model with plain acquisition (DE/best/1, 50 generations) 2. Local search: GPR model on recent samples with LCB-decay acquisition (prescreening)

__init__(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='GL-SADE', disable_tqdm=True)[source]

Initialize GL-SADE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘GL-SADE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the GL-SADE algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Bayesian Optimization (BO)

This module implements Bayesian Optimization for expensive single-objective optimization problems.

References

[1] Jones, Donald R., Matthias Schonlau, and William J. Welch. “Efficient global optimization of expensive black-box functions.” Journal of Global optimization 13.4 (1998): 455-492.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.11 Version: 1.0

class ddmtolab.Algorithms.STSO.BO.BO(problem, n_initial=None, max_nfes=None, mode='ei', save_data=True, save_path='./Data', name='BO', disable_tqdm=True)[source]

Bases: object

Bayesian Optimization algorithm for expensive optimization problems.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, mode='ei', save_data=True, save_path='./Data', name='BO', disable_tqdm=True)[source]

Initialize Bayesian Optimization algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 100)
mode (str, optional) – Acquisition function mode: ‘ei’ for Expected Improvement or ‘lcb’ for Lower Confidence Bound (default: ‘ei’)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘BO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Bayesian Optimization algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Evolutionary Expected Improvement based Bayesian Optimization (EEI-BO)

This module implements EEI-BO for expensive single-objective optimization. A GP surrogate provides the Expected Improvement (EI), and a persistent CMA-ES search distribution co-evolves alongside the BO loop: at every BO iteration the CMA-ES state advances a single generation (its samples ranked by the GP surrogate), and the resulting Gaussian density P(x) = N(x; mu, sigma^2 C) weights EI to form the Evolutionary Expected Improvement acquisition

EEI(x) = EI(x) * P(x),

which is maximized by differential evolution to select the next query point.

References

[1] J. Liu, Y. Wang, G. Sun, and T. Pang, “Solving Highly Expensive: Optimization Problems via Evolutionary Expected Improvement,” IEEE Transactions on Systems, Man, and Cybernetics: Systems, vol. 53, no. 8, pp. 4843-4855, 2023.

Notes

Corrected against the reference implementation (ST-EEI-BO, v2.0):

The CMA-ES distribution is now persistent and advances exactly one generation per BO iteration (the paper’s co-evolution). The previous version re-ran a full CMA-ES optimization from a random restart every iteration.
CMA-ES starts from the mean of the initial samples with sigma0 = 0.5 (half the [0, 1] search range), matching the reference init.
EEI is maximized in log space (log EI + log P) to avoid the underflow of EI*P when EI is tiny; the argmax is identical to the reference EI*P.
CMA-ES samples are ranked by the GP posterior mean (equivalent, for ranking, to the reference’s separate RBF surrogate and matching the MT reference).

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.18 Version: 2.0

class ddmtolab.Algorithms.STSO.EEI_BO.EEI_BO(problem, n_initial=None, max_nfes=None, cma_popsize=100, sigma0=0.5, n2=30, max_nfes2=6000, save_data=True, save_path='./Data', name='EEI-BO', disable_tqdm=True)[source]

Bases: object

Evolutionary Expected Improvement based Bayesian Optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, cma_popsize=100, sigma0=0.5, n2=30, max_nfes2=6000, save_data=True, save_path='./Data', name='EEI-BO', disable_tqdm=True)[source]

Initialize EEI-BO algorithm.

Parameters:

problem (MTOP) – Optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 100)
cma_popsize (int, optional) – Number of surrogate-ranked samples per CMA-ES generation (default: 100)
sigma0 (float, optional) – Initial CMA-ES step size in the [0, 1] space (default: 0.5)
n2 (int, optional) – Population size of the DE that maximizes EEI (default: 30)
max_nfes2 (int, optional) – Function evaluations of the DE that maximizes EEI (default: 6000)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EEI-BO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute EEI-BO.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Exploration-exploitation Switching Assisted Optimization (ESAO)

This module implements ESAO for expensive single-objective optimization problems.

References

[1] Wang, Xinjing, et al. “A novel evolutionary sampling assisted optimization method for high-dimensional expensive problems.” IEEE Transactions on Evolutionary Computation 23.5 (2019): 815-827.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.13 Version: 1.0

class ddmtolab.Algorithms.STSO.ESAO.ESAO(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='ESAO', disable_tqdm=True)[source]

Bases: object

Exploration-exploitation Switching Assisted Optimization for expensive optimization problems.

This algorithm adaptively switches between global and local search based on improvement: 1. Global search: RBF model built on all data points 2. Local search: RBF model built on top 2*dim points nearest to the best

__init__(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='ESAO', disable_tqdm=True)[source]

Initialize ESAO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘ESAO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the ESAO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Surrogate-Assisted Cooperative Swarm Optimization (SA-COSO)

This module implements SA-COSO for expensive single-objective optimization problems.

References

[1] Sun, Chaoli, et al. “Surrogate-assisted cooperative swarm optimization of high-dimensional expensive problems.” IEEE Transactions on Evolutionary Computation 21.4 (2017): 644-660.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.23 Version: 1.1

class ddmtolab.Algorithms.STSO.SA_COSO.SA_COSO(problem, n_initial=None, max_nfes=None, n_fes=30, n_rbf=200, save_data=True, save_path='./Data', name='SA-COSO', disable_tqdm=True)[source]

Bases: object

Surrogate-Assisted Cooperative Swarm Optimization for expensive optimization problems.

Two cooperating swarms share one RBF network (MATLAB newrb, at most 8 neurons) trained on a bounded archive of exactly evaluated solutions:

A PSO swarm whose fitness is mostly estimated by a Fitness Estimation Strategy (FES): plain RBF predictions plus position-relation-based estimates from the nearest neighbor’s virtual position; estimated particles that look better than their personal best (under both the estimate and the RBF prediction) are evaluated exactly.
A social-learning swarm whose particles learn dimension-wise from better solutions among the swarm itself and random archive members; its best predicted particle is evaluated exactly every iteration.

__init__(problem, n_initial=None, max_nfes=None, n_fes=30, n_rbf=200, save_data=True, save_path='./Data', name='SA-COSO', disable_tqdm=True)[source]

Initialize SA-COSO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: n_fes + n_rbf)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
n_fes (int, optional) – Population size of the FES-assisted PSO swarm (default: 30)
n_rbf (int, optional) – Population size of the RBF-assisted social-learning swarm (default: 200)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SA-COSO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SA-COSO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Three-Level Radial Basis Function Method (TLRBF)

This module implements TLRBF for expensive single-objective optimization problems.

References

[1] Li, Genghui, et al. “A three-level radial basis function method for expensive optimization.” IEEE Transactions on Cybernetics 52.7 (2021): 5720-5731.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.23 Version: 1.1

class ddmtolab.Algorithms.STSO.TLRBF.TLRBF(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='TLRBF', disable_tqdm=True)[source]

Bases: object

Three-Level Radial Basis Function Method for expensive optimization problems.

This algorithm uses three search strategies in rotation: 1. Global search: Random sampling with distance filtering 2. Subregion search: FCM clustering + local RBF models 3. Local search: K-nearest neighbors + local RBF model

__init__(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='TLRBF', disable_tqdm=True)[source]

Initialize TLRBF algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘TLRBF’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the TLRBF algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Surrogate-Assisted EA with Model and Infill Criterion Auto-Configuration (AutoSAEA)

This module implements AutoSAEA for expensive single-objective optimization problems.

References

[1] Xie, L., Li, G., Wang, Z., Cui, L., & Gong, M. (2023). Surrogate-assisted evolutionary algorithm with model and infill criterion auto-configuration. IEEE Transactions on Evolutionary Computation.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.19 Version: 1.0

class ddmtolab.Algorithms.STSO.AutoSAEA.AutoSAEA(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='AutoSAEA', disable_tqdm=True)[source]

Bases: object

Surrogate-Assisted EA with Model and Infill Criterion Auto-Configuration.

Uses a Two-Level UCB multi-armed bandit to adaptively select from 8 model-criterion combinations: - {RBF, prescreening}, {RBF, local search} - {GP, LCB}, {GP, EI} - {PRS, prescreening}, {PRS, local search} - {KNN, exploitation}, {KNN, exploration}

__init__(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='AutoSAEA', disable_tqdm=True)[source]

Initialize AutoSAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘AutoSAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the AutoSAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Data-Driven Evolutionary Algorithm with Multi-Evolutionary Sampling Strategy (DDEA-MESS)

This module implements DDEA-MESS for expensive single-objective optimization problems.

References

[1] Yu, F., Gong, W., & Zhen, H. (2022). A data-driven evolutionary algorithm with multi-evolutionary sampling strategy for expensive optimization. Knowledge-Based Systems, 242, 108436.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.23 Version: 1.1

class ddmtolab.Algorithms.STSO.DDEA_MESS.DDEA_MESS(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='DDEA-MESS', disable_tqdm=True)[source]

Bases: object

Data-Driven Evolutionary Algorithm with Multi-Evolutionary Sampling Strategy.

Dynamically selects from three search strategies based on evaluation budget usage: 1. Global search: one-generation DE prescreening on RBF built from the first min(N, 300) samples 2. Local search: DE/best/1 (10 generations) on RBF built from the top tau samples by fitness 3. Interior-point search: local optimization on RBF around the best solution

__init__(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='DDEA-MESS', disable_tqdm=True)[source]

Initialize DDEA-MESS algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘DDEA-MESS’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the DDEA-MESS algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Lipschitz Surrogate-Assisted Differential Evolution (LSADE)

This module implements LSADE for expensive single-objective optimization problems.

References

[1] Kudela, J., & Matousek, R. (2023). Combining Lipschitz and RBF surrogate models for high-dimensional computationally expensive problems. Information Sciences, 619, 457-477.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.19 Version: 1.0

class ddmtolab.Algorithms.STSO.LSADE.LSADE(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='LSADE', disable_tqdm=True)[source]

Bases: object

Lipschitz Surrogate-Assisted Differential Evolution for expensive optimization problems.

Uses three surrogate strategies in deterministic rotation: 1. RBF prescreening: DE/best/1 on Gaussian RBF model 2. Lipschitz prescreening: DE/best/1 on Lipschitz lower-bound surrogate 3. Local optimization: SQP on local RBF model around best solutions

__init__(problem, n_initial=None, max_nfes=None, save_data=True, save_path='./Data', name='LSADE', disable_tqdm=True)[source]

Initialize LSADE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘LSADE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the LSADE algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

LLM-Assisted Evolutionary Algorithm (LAEA)

This module implements LAEA for expensive single-objective optimization problems. The surrogate is not a trained model but a large language model prompted with the archive as in-context examples: a regression prompt supplies the value used to pick the single solution that is really evaluated, and a classification prompt supplies the good/bad labels that steer the next generation’s estimation-of-distribution model.

The port follows the reference implementation (class LSEA in https://github.com/hhyqhh/LAEA) rather than the paper, including its variable-width histogram EDA, its quadratic local search, and its one-real- evaluation-per-generation budget policy. The reference builds on pymoo; this version is native and works in the platform’s normalized [0, 1] space, where the EDA bounds are 0 and 1.

Cost note: each generation issues 2 * n_initial LLM calls – one regression and one classification query per offspring – and consumes exactly one real function evaluation. The default setting therefore spends about 25,000 calls to reach max_nfes=300. Set max_llm_calls to cap this, and keep the cache file so the run can be replayed offline.

References

[1] Hao, H., Zhang, X., & Zhou, A. (2024). Large Language Models as Surrogate Models in Evolutionary Algorithms: A Preliminary Study. arXiv preprint arXiv:2406.10675.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.03 Version: 1.0

class ddmtolab.Algorithms.STSO.LAEA.LAEA(problem, n_initial=None, max_nfes=None, tao=50, rate=0.3, pb=0.2, pc=0.2, m=15, llm_backend='replay', llm_model='deepseek-chat', llm_base_url='https://api.deepseek.com', llm_api_key_env='DEEPSEEK_API_KEY', llm_temperature=0.0, llm_max_tokens=10, llm_max_retries=3, llm_parallel=1, llm_beta=3, llm_seed=42, max_llm_calls=None, llm_price_prompt=0.0, llm_price_completion=0.0, llm_cache_path='', strict_source=False, save_data=True, save_path='./Data', name='LAEA', disable_tqdm=True)[source]

Bases: object

LLM-Assisted Evolutionary Algorithm for expensive optimization problems.

Each generation:

take the tao best archive members as in-context examples;
label them good/bad at quantile rate and fit both LLM surrogates;
sample offspring from the VWH model, refined by quadratic local search and crossed with it;
ask the regression surrogate to rank the offspring and the classification surrogate to label them;
really evaluate only the top-ranked offspring, and carry the positively-labelled offspring forward as the unevaluated population that widens the next VWH update.

Variables:

algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements
llm_information (dict) – Dictionary describing how the algorithm uses a language model

__init__(problem, n_initial=None, max_nfes=None, tao=50, rate=0.3, pb=0.2, pc=0.2, m=15, llm_backend='replay', llm_model='deepseek-chat', llm_base_url='https://api.deepseek.com', llm_api_key_env='DEEPSEEK_API_KEY', llm_temperature=0.0, llm_max_tokens=10, llm_max_retries=3, llm_parallel=1, llm_beta=3, llm_seed=42, max_llm_calls=None, llm_price_prompt=0.0, llm_price_completion=0.0, llm_cache_path='', strict_source=False, save_data=True, save_path='./Data', name='LAEA', disable_tqdm=True)[source]

Initialize LAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task, also the population size and the number of offspring per generation (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
tao (int, optional) – Number of best archive members shown to the LLM as examples (default: 50)
rate (float, optional) – Quantile splitting good from bad solutions when labelling (default: 0.3)
pb (float, optional) – Fraction of the population refined by local search (default: 0.2)
pc (float, optional) – Per-variable probability of crossing an offspring with a locally-refined solution (default: 0.2)
m (int, optional) – Number of histogram bins per dimension in the VWH model (default: 15)
llm_backend (str, optional) – ‘openai_compatible’ to call a real endpoint, ‘replay’ to serve only from the cache, or ‘mock’ for offline synthetic responses (default: ‘replay’)
llm_model (str, optional) – Model identifier (default: ‘deepseek-chat’)
llm_base_url (str, optional) – Endpoint root, passed through verbatim (default: ‘https://api.deepseek.com’)
llm_api_key_env (str, optional) – Environment variable holding the API key (default: ‘DEEPSEEK_API_KEY’)
llm_temperature (float, optional) – Sampling temperature (default: 0.0)
llm_max_tokens (int, optional) – Completion token cap. The reference uses 10 (default: 10)
llm_max_retries (int, optional) – Attempts per query before falling back to a random prediction (default: 3)
llm_parallel (int, optional) – Worker threads used to issue the per-offspring queries (default: 1)
llm_beta (int, optional) – Decimal places kept when rounding features in the prompt (default: 3)
llm_seed (int, optional) – Seed for the fallback RNG of the surrogates (default: 42)
max_llm_calls (int, optional) – Cap on LLM calls per run. The run stops early and returns partial results when it is reached (default: None, unlimited)
llm_price_prompt (float, optional) – USD per million prompt tokens, used only to report an estimated spend (default: 0.0)
llm_price_completion (float, optional) – USD per million completion tokens (default: 0.0)
llm_cache_path (str, optional) – JSONL cache file. Empty means <save_path>/llm_cache/<name>.jsonl (default: ‘’)
strict_source (bool, optional) – Reproduce the reference regression parser, which accepts only the ‘Value’ JSON key even though its own prompt asks for ‘Target’ (default: False)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘LAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the LAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Batched LLM-Assisted Evolutionary Algorithm (LAEA-light)

This module implements LAEA-light, a drop-in variant of LAEA that asks the language model about a whole generation of offspring in one request instead of one request per candidate.

The search itself is untouched – same variable-width histogram EDA, same quadratic local search, same one-real-evaluation-per-generation policy, and the same two questions asked of the same in-context examples. Only the transport changes: the regression prompt and the classification prompt each carry every candidate of the current generation and come back with one answer per candidate.

Why this is worth a separate class: in LAEA about 97% of every prompt is the in-context archive, and the serial path resends it once per candidate. At n_initial=50 a generation therefore costs 2 * 50 = 100 requests and, at D=10 with tao=50, roughly 149,000 prompt tokens – to buy a single real function evaluation. Batching the whole generation brings that down to two requests and about 3,500 prompt tokens.

llm_batch_size caps how many candidates share a request, so a generation costs 2 * ceil(n_initial / llm_batch_size) requests. The default packs the whole generation into one request per surrogate.

Notes on fidelity

The two surrogates stay independent, as in LAEA: the regression answer never appears in the classification prompt or the other way round. What does change is that a candidate is now judged alongside its siblings rather than alone, so predictions are not bit-identical to the serial ones and existing serial llm_cache files do not carry over. A response that cannot be parsed, or that does not return exactly one answer per candidate, is retried and then falls back per candidate exactly as the serial path does.

References

[1] Hao, H., Zhang, X., & Zhou, A. (2024). Large Language Models as Surrogate Models in Evolutionary Algorithms: A Preliminary Study. arXiv preprint arXiv:2406.10675.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.15 Version: 1.0

class ddmtolab.Algorithms.STSO.LAEA_light.LAEA_light(problem, n_initial=None, max_nfes=None, tao=50, rate=0.3, pb=0.2, pc=0.2, m=15, llm_batch_size=None, llm_backend='replay', llm_model='deepseek-chat', llm_base_url='https://api.deepseek.com', llm_api_key_env='DEEPSEEK_API_KEY', llm_temperature=0.0, llm_max_tokens=2048, llm_max_retries=3, llm_parallel=1, llm_beta=3, llm_seed=42, max_llm_calls=None, llm_price_prompt=0.0, llm_price_completion=0.0, llm_cache_path='', strict_source=False, save_data=True, save_path='./Data', name='LAEA-light', disable_tqdm=True)[source]

Bases: LAEA

LAEA with one LLM request per surrogate per generation instead of one request per candidate.

__init__(problem, n_initial=None, max_nfes=None, tao=50, rate=0.3, pb=0.2, pc=0.2, m=15, llm_batch_size=None, llm_backend='replay', llm_model='deepseek-chat', llm_base_url='https://api.deepseek.com', llm_api_key_env='DEEPSEEK_API_KEY', llm_temperature=0.0, llm_max_tokens=2048, llm_max_retries=3, llm_parallel=1, llm_beta=3, llm_seed=42, max_llm_calls=None, llm_price_prompt=0.0, llm_price_completion=0.0, llm_cache_path='', strict_source=False, save_data=True, save_path='./Data', name='LAEA-light', disable_tqdm=True)[source]

Initialize LAEA-light.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task, also the population size and the number of offspring per generation (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
tao (int, optional) – Number of best archive members shown to the LLM as examples (default: 50)
rate (float, optional) – Quantile splitting good from bad solutions when labelling (default: 0.3)
pb (float, optional) – Fraction of the population refined by local search (default: 0.2)
pc (float, optional) – Per-variable probability of crossing an offspring with a locally-refined solution (default: 0.2)
m (int, optional) – Number of histogram bins per dimension in the VWH model (default: 15)
llm_batch_size (int, optional) – Number of candidates packed into one request. None puts the whole generation into one request per surrogate, which is the point of this variant and costs two requests per real evaluation. A smaller value trades that back for shorter, easier to parse responses and costs 2 * ceil(n_initial / llm_batch_size) (default: None)
llm_backend (str, optional) – ‘openai_compatible’ to call a real endpoint, ‘replay’ to serve only from the cache, or ‘mock’ for offline synthetic responses (default: ‘replay’)
llm_model (str, optional) – Model identifier (default: ‘deepseek-chat’)
llm_base_url (str, optional) – Endpoint root, passed through verbatim (default: ‘https://api.deepseek.com’)
llm_api_key_env (str, optional) – Environment variable holding the API key (default: ‘DEEPSEEK_API_KEY’)
llm_temperature (float, optional) – Sampling temperature (default: 0.0)
llm_max_tokens (int, optional) – Completion cap. A batched answer carries one entry per candidate, so this is far larger than the serial default of 10 (default: 2048)
llm_max_retries (int, optional) – Attempts per request before falling back (default: 3)
llm_parallel (int, optional) – Worker threads issuing requests. Reduces wall-clock time, not the number of requests (default: 1)
llm_beta (int, optional) – Decimal places kept when rounding normalized features (default: 3)
llm_seed (int, optional) – Seed forwarded to the endpoint and used by the fallback RNG (default: 42)
max_llm_calls (int, optional) – Hard cap on requests; the run stops early when it is reached (default: None)
llm_price_prompt (float, optional) – USD per 1M prompt tokens, for the cost estimate (default: 0.0)
llm_price_completion (float, optional) – USD per 1M completion tokens, for the cost estimate (default: 0.0)
llm_cache_path (str, optional) – Cache file; defaults to <save_path>/llm_cache/<name>.jsonl. Serial LAEA caches are not compatible because the prompts differ (default: ‘’)
strict_source (bool, optional) – Accept only the Value JSON key, reproducing the reference parser (default: False)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘LAEA-light’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()

Execute the LAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Single-Task Multiobjective (STMO)

Nondominated Sorting Genetic Algorithm II (NSGA-II)

This module implements NSGA-II for multi-objective optimization problems.

References

[1] Deb, Kalyanmoy, et al. “A fast and elitist multiobjective genetic algorithm: NSGA-II.” IEEE transactions on evolutionary computation 6.2 (2002): 182-197.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.10.23 Version: 1.0

class ddmtolab.Algorithms.STMO.NSGA_II.NSGA_II(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='NSGA-II', disable_tqdm=True)[source]

Bases: object

Nondominated Sorting Genetic Algorithm II for multi-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='NSGA-II', disable_tqdm=True)[source]

Initialize NSGA-II algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘NSGA-II’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the NSGA-II algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Nondominated Sorting Genetic Algorithm III (NSGA-III)

This module implements NSGA-III for many-objective optimization problems.

References

[1] Deb, Kalyanmoy, and Himanshu Jain. “An evolutionary many-objective optimization algorithm using reference-point-based nondominated sorting approach, part I: Solving problems with box constraints.” IEEE Transactions on Evolutionary Computation 18.4 (2014): 577-601.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.12 Version: 1.0

class ddmtolab.Algorithms.STMO.NSGA_III.NSGA_III(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='NSGA-III', disable_tqdm=True)[source]

Bases: object

Nondominated Sorting Genetic Algorithm III for many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='NSGA-III', disable_tqdm=True)[source]

Initialize NSGA-III algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘NSGA-III’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the NSGA-III algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Nondominated Sorting Genetic Algorithm II with Strengthened Dominance Relation (NSGA-II-SDR)

This module implements NSGA-II-SDR for multi-objective optimization problems.

References

[1] Y. Tian, R. Cheng, X. Zhang, Y. Su, and Y. Jin. A strengthened dominance relation considering convergence and diversity for evolutionary many-objective optimization. IEEE Transactions on Evolutionary Computation, 2019, 23(2): 331-345.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.14 Version: 1.1

class ddmtolab.Algorithms.STMO.NSGA_II_SDR.NSGA_II_SDR(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='NSGA-II-SDR', disable_tqdm=True)[source]

Bases: object

Nondominated Sorting Genetic Algorithm II with Strengthened Dominance Relation for multi-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='NSGA-II-SDR', disable_tqdm=True)[source]

Initialize NSGA-II-SDR algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘NSGA-II-SDR’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the NSGA-II-SDR algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-objective Evolutionary Algorithm Based on Decomposition (MOEA/D)

This module implements MOEA/D for multi-objective optimization problems.

References

[1] Zhang, Qingfu, and Hui Li. “MOEA/D: A multiobjective evolutionary algorithm based on decomposition.” IEEE Transactions on Evolutionary Computation 11.6 (2007): 712-731.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.03 Version: 1.0

class ddmtolab.Algorithms.STMO.MOEA_D.MOEA_D(problem, n=None, max_nfes=None, decomp_type=1, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='MOEA-D', disable_tqdm=True)[source]

Bases: object

Multi-objective Evolutionary Algorithm Based on Decomposition.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, decomp_type=1, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='MOEA-D', disable_tqdm=True)[source]

Initialize MOEA/D algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
decomp_type (int, optional) – Decomposition approach type (default: 1) 1: PBI (Penalty-based Boundary Intersection) 2: Tchebycheff 3: Tchebycheff with normalization 4: Modified Tchebycheff
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MOEA-D’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MOEA/D.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multi-objective Evolutionary Algorithm Based on Decomposition and Dominance (MOEA/DD)

This module implements MOEA/DD for multi/many-objective optimization problems.

References

[1] Li, Ke, et al. “An evolutionary many-objective optimization algorithm based on dominance and decomposition.” IEEE transactions on evolutionary computation 19.5 (2014): 694-716.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.18 Version: 1.0

class ddmtolab.Algorithms.STMO.MOEA_DD.MOEA_DD(problem, n=None, max_nfes=None, delta=0.9, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='MOEA-DD', disable_tqdm=True)[source]

Bases: object

Multi-objective Evolutionary Algorithm Based on Decomposition and Dominance.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, delta=0.9, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='MOEA-DD', disable_tqdm=True)[source]

Initialize MOEA/DD.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
delta (float, optional) – Probability of choosing parents locally (default: 0.9)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MOEA-DD’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MOEA/DD algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

MOEA/D with Stable Matching (MOEA/D-STM)

This module implements MOEA/D-STM for multi-objective optimization problems.

References

[1] Li, Ke, et al. “Stable matching-based selection in evolutionary multiobjective optimization.” IEEE Transactions on Evolutionary Computation 18.6 (2014): 909-923.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.01 Version: 1.0

class ddmtolab.Algorithms.STMO.MOEA_D_STM.MOEA_D_STM(problem, n=None, max_nfes=None, T=None, save_data=True, save_path='./Data', name='MOEA-D-STM', disable_tqdm=True)[source]

Bases: object

MOEA/D with Stable Matching for multi-objective optimization.

This algorithm uses a stable matching model to select solutions for subproblems, ensuring a stable assignment between solutions and weight vectors.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, T=None, save_data=True, save_path='./Data', name='MOEA-D-STM', disable_tqdm=True)[source]

Initialize MOEA/D-STM algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
T (int or List[int], optional) – Size of neighborhood (default: ceil(n/10))
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MOEA-D-STM’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MOEA/D-STM algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

MOEA/D with Fitness-Rate-Rank-based Multi-Armed Bandit (MOEA/D-FRRMAB)

This module implements MOEA/D-FRRMAB for multi-objective optimization problems.

References

[1] Li, Ke, et al. “Adaptive operator selection with bandits for a multiobjective evolutionary algorithm based on decomposition.” IEEE Transactions on Evolutionary Computation 18.1 (2014): 114-130.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.01 Version: 1.0

class ddmtolab.Algorithms.STMO.MOEA_D_FRRMAB.MOEA_D_FRRMAB(problem, n=None, max_nfes=None, C=5, W=None, D=1, T=20, nr=2, save_data=True, save_path='./Data', name='MOEA-D-FRRMAB', disable_tqdm=True)[source]

Bases: object

MOEA/D with Fitness-Rate-Rank-based Multi-Armed Bandit.

This algorithm uses a multi-armed bandit approach to adaptively select differential evolution operators during optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, C=5, W=None, D=1, T=20, nr=2, save_data=True, save_path='./Data', name='MOEA-D-FRRMAB', disable_tqdm=True)[source]

Initialize MOEA/D-FRRMAB algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
C (float, optional) – Scaling factor in bandit-based operator selection (default: 5)
W (int or List[int], optional) – Size of sliding window (default: ceil(n/2))
D (float, optional) – Decaying factor in calculating credit value (default: 1)
T (int, optional) – Size of neighborhood (default: 20)
nr (int, optional) – Maximum number of solutions replaced by each offspring (default: 2)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MOEA-D-FRRMAB’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MOEA/D-FRRMAB algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multiple Classifiers-assisted Evolutionary Algorithm based on Decomposition (MCEAD)

This module implements MCEAD for multi-objective optimization problems.

References

[1] T. Sonoda and M. Nakata. Multiple classifiers-assisted evolutionary algorithm based on decomposition for high-dimensional multi-objective problems. IEEE Transactions on Evolutionary Computation, 2022.

Notes

Author: Haowei Guo Email: ghw@mail.nwpu.edu.cn Date: 2026.01.06 Version: 1.0

class ddmtolab.Algorithms.STMO.MCEA_D.MCEA_D(problem, n_initial=None, max_nfes=None, delta=0.9, nr=2, r_max=10, save_data=True, save_path='./Data', name='MCEA-D', disable_tqdm=True)[source]

Bases: object

Multiple Classifiers-assisted Evolutionary Algorithm based on Decomposition for multi-objective optimization

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, delta=0.9, nr=2, r_max=10, save_data=True, save_path='./Data', name='MCEA-D', disable_tqdm=True)[source]

Initialize MCEAD algorithm.

Parameters:

problem (MTOP) – Problem instance.
n_initial (int or List[int], optional) – Number of initial Latin-hypercube samples per task (default: 100). In MCEA/D this is also the population size and the number of weight vectors, so it is adjusted upwards by uniform_point exactly as [W, Problem.N] = UniformPoint(Problem.N, Problem.M) does in PlatEMO.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
delta (float, optional) – Probability of choosing parents from neighborhood (default: 0.9).
nr (int, optional) – Maximum number of solutions replaced by each offspring (default: 2).
r_max (int, optional) – Maximum repeat time of offspring generation (default: 10).
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path for saving results (default: ‘./TestData’)
name (str, optional) – Name of the experiment/file (default: ‘MCEAD_test’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MCEAD algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Reference Vector Guided Evolutionary Algorithm (RVEA)

This module implements RVEA for many-objective optimization problems.

References

[1] Cheng, Ran, et al. “A reference vector guided evolutionary algorithm for many-objective optimization.” IEEE transactions on evolutionary computation 20.5 (2016): 773-791.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.10.25 Version: 1.0

class ddmtolab.Algorithms.STMO.RVEA.RVEA(problem, n=None, max_nfes=None, alpha=2.0, fr=0.1, save_data=True, save_path='./Data', name='RVEA', disable_tqdm=True)[source]

Bases: object

Reference Vector Guided Evolutionary Algorithm for many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, alpha=2.0, fr=0.1, save_data=True, save_path='./Data', name='RVEA', disable_tqdm=True)[source]

Initialize RVEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
alpha (float, optional) – Parameter controlling the rate of change of penalty (default: 2.0)
fr (float, optional) – Frequency of employing reference vector adaptation (default: 0.1)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘RVEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the RVEA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Kriging-assisted Reference Vector Guided Evolutionary Algorithm (K-RVEA)

This module implements K-RVEA for computationally expensive multi/many-objective optimization.

References

[1] T. Chugh, Y. Jin, K. Miettinen, J. Hakanen, and K. Sindhya. A surrogate-assisted reference vector guided evolutionary algorithm for computationally expensive many-objective optimization. IEEE Transactions on Evolutionary Computation, 2018, 22(1): 129-142.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.11 Version: 2.0

class ddmtolab.Algorithms.STMO.K_RVEA.K_RVEA(problem, n_initial=None, max_nfes=None, n=100, alpha=2.0, wmax=20, mu=5, save_data=True, save_path='./Data', name='K-RVEA', disable_tqdm=True)[source]

Bases: object

Kriging-assisted Reference Vector Guided Evolutionary Algorithm for expensive multi/many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, alpha=2.0, wmax=20, mu=5, save_data=True, save_path='./Data', name='K-RVEA', disable_tqdm=True)[source]

Initialize K-RVEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size (number of reference vectors) per task (default: 100)
alpha (float, optional) – Parameter controlling the rate of change of penalty (default: 2.0)
wmax (int, optional) – Number of generations before updating Kriging models (default: 20)
mu (int, optional) – Number of re-evaluated solutions at each generation (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘K-RVEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the K-RVEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Indicator-Based Evolutionary Algorithm (IBEA)

This module implements IBEA for multi-objective optimization problems.

References

[1] Zitzler, Eckart, and Simon Künzli. “Indicator-based selection in multiobjective search.” International conference on parallel problem solving from nature. 2004.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.13 Version: 1.0

class ddmtolab.Algorithms.STMO.IBEA.IBEA(problem, n=None, max_nfes=None, kappa=0.05, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='IBEA', disable_tqdm=True)[source]

Bases: object

Indicator-Based Evolutionary Algorithm for multi-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, kappa=0.05, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='IBEA', disable_tqdm=True)[source]

Initialize IBEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
kappa (float, optional) – Fitness scaling factor (default: 0.05)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘IBEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the IBEA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Strength Pareto Evolutionary Algorithm 2 (SPEA2)

This module implements SPEA2 for multi-objective optimization problems.

References

[1] Zitzler, E., Laumanns, M., & Thiele, L. (2001). SPEA2: Improving the Strength Pareto Evolutionary Algorithm For Multiobjective Optimization. In Evolutionary Methods for Design, Optimization and Control with Applications to Industrial Problems. Proceedings of the EUROGEN’2001.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.13 Version: 1.1

class ddmtolab.Algorithms.STMO.SPEA2.SPEA2(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, epsilon=0, save_data=True, save_path='./Data', name='SPEA2', disable_tqdm=True)[source]

Bases: object

Strength Pareto Evolutionary Algorithm 2 for multi-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, epsilon=0, save_data=True, save_path='./Data', name='SPEA2', disable_tqdm=True)[source]

Initialize SPEA2 algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
epsilon (float, optional) – Constraint epsilon value for epsilon-constraint method (default: 0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SPEA2’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SPEA2 algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Two-Archive Algorithm 2 (Two_Arch2)

This module implements Two_Arch2 for many-objective optimization problems.

References

[1] Wang, H., Jiao, L., & Yao, X. (2015). Two_Arch2: An improved two-archive algorithm for many-objective optimization. IEEE Transactions on Evolutionary Computation, 19(4), 524-541.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.13 Version: 1.1

class ddmtolab.Algorithms.STMO.TwoArch2.TwoArch2(problem, n=None, max_nfes=None, CA_size=None, p=None, save_data=True, save_path='./Data', name='Two_Arch2', disable_tqdm=True)[source]

Bases: object

Two-Archive Algorithm 2 for many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, CA_size=None, p=None, save_data=True, save_path='./Data', name='Two_Arch2', disable_tqdm=True)[source]

Initialize Two_Arch2 algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
CA_size (int or None, optional) – Convergence archive size (default: None, will be set to population size)
p (float or None, optional) – Parameter for fractional distance (default: None, will be set to 1/M)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘Two_Arch2’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Two_Arch2 algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Coevolutionary Framework for Constrained Multiobjective Optimization (CCMO)

This module implements CCMO for constrained multi-objective optimization problems.

References

[1] Tian, Ye, et al. “A Coevolutionary Framework for Constrained Multiobjective Optimization Problems.” IEEE Transactions on Evolutionary Computation 25.1 (2021): 102-116.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.14 Version: 1.0

class ddmtolab.Algorithms.STMO.CCMO.CCMO(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='CCMO', disable_tqdm=True)[source]

Bases: object

Coevolutionary Framework for Constrained Multiobjective Optimization.

CCMO uses two co-evolving populations: - Population 1: Optimizes objectives with strict constraint handling (epsilon=0) - Population 2: Optimizes objectives with relaxed constraints (epsilon=inf)

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='CCMO', disable_tqdm=True)[source]

Initialize CCMO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘CCMO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the CCMO algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Constrained Two-Archive Evolutionary Algorithm (C-TAEA)

This module implements C-TAEA for constrained multi-objective optimization problems.

References

[1] Li, Ke, et al. “Two-archive evolutionary algorithm for constrained multi-objective optimization.” IEEE Transactions on Evolutionary Computation 23.2 (2018): 303-315.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.01 Version: 1.0

class ddmtolab.Algorithms.STMO.C_TAEA.C_TAEA(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='C-TAEA', disable_tqdm=True)[source]

Bases: object

Constrained Two-Archive Evolutionary Algorithm for constrained multi-objective optimization.

C-TAEA uses two co-evolving archives: - Convergence Archive (CA): Focuses on convergence towards the Pareto front - Diversity Archive (DA): Maintains diversity in the objective space

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='C-TAEA', disable_tqdm=True)[source]

Initialize C-TAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘C-TAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the C-TAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Classification and Pareto Domination Based Multi-Objective Evolutionary Algorithm (CPS-MOEA)

This module implements CPS-MOEA for multi-objective optimization problems.

References

[1] J. Zhang, A. Zhou, and G. Zhang. “A classification and Pareto domination based multiobjective evolutionary algorithm.” Proceedings of the IEEE Congress on Evolutionary Computation, 2015, 2883-2890.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.22 Version: 1.0

class ddmtolab.Algorithms.STMO.CPS_MOEA.CPS_MOEA(problem, n_initial=None, max_nfes=None, M=3, CR=1.0, F=0.5, proM=1.0, disM=20.0, k_neighbors=5, save_data=True, save_path='./Data', name='CPS-MOEA', disable_tqdm=True)[source]

Bases: object

Classification and Pareto Domination Based Multi-Objective Evolutionary Algorithm.

This algorithm uses KNN-based classification to distinguish between good and bad solutions, and uses this information to guide offspring generation via differential evolution with surrogate-assisted pre-selection.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, M=3, CR=1.0, F=0.5, proM=1.0, disM=20.0, k_neighbors=5, save_data=True, save_path='./Data', name='CPS-MOEA', disable_tqdm=True)[source]

Initialize CPS-MOEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 100). This is also the population size N, because PlatEMO’s CPS-MOEA draws N random solutions in Problem.Initialization() and re-evaluates N offsprings per generation.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
M (int, optional) – Number of candidate offsprings generated per solution (default: 3)
CR (float, optional) – Crossover probability for differential evolution (default: 1.0)
F (float, optional) – Scaling factor for differential evolution (default: 0.5)
proM (float, optional) – Expected number of mutated variables (default: 1.0)
disM (float, optional) – Distribution index for polynomial mutation (default: 20.0)
k_neighbors (int, optional) – Number of neighbors for KNN classification (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘CPS-MOEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the CPS-MOEA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Pareto Efficient Global Optimization (ParEGO)

This module implements ParEGO for expensive multi-objective optimization problems.

References

[1] Knowles, Joshua. “ParEGO: A hybrid algorithm with on-line landscape approximation for expensive multiobjective optimization problems.” IEEE Transactions on Evolutionary Computation 10.1 (2006): 50-66.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.10 Version: 1.0

class ddmtolab.Algorithms.STMO.ParEGO.ParEGO(problem, n_initial=None, n_weights=None, max_nfes=None, rho=0.05, save_data=True, save_path='./Data', name='ParEGO', disable_tqdm=True)[source]

Bases: object

Pareto Efficient Global Optimization algorithm for expensive multi-objective optimization.

ParEGO uses scalarization with randomly selected weight vectors to convert multi-objective problems into single-objective problems, which are then solved using Bayesian Optimization with Expected Improvement.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, n_weights=None, max_nfes=None, rho=0.05, save_data=True, save_path='./Data', name='ParEGO', disable_tqdm=True)[source]

Initialize ParEGO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim - 1, following Knowles 2006)
n_weights (int or List[int], optional) – Number of reference weight vectors per task (default: 100, matching PlatEMO’s Problem.N; the actual count is adjusted by uniform_point)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task, including the initial design (default: 200)
rho (float, optional) – Augmentation coefficient for augmented Tchebycheff scalarization (default: 0.05)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘ParEGO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the ParEGO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multistage Evolutionary Algorithm (MSEA)

This module implements MSEA for better diversity preservation in multi-objective optimization.

References

[1] Tian, Ye, et al. “A multistage evolutionary algorithm for better diversity preservation in multiobjective optimization.” IEEE Transactions on Systems, Man, and Cybernetics: Systems, 51.9 (2021): 5880-5894.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.12 Version: 1.0

class ddmtolab.Algorithms.STMO.MSEA.MSEA(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='MSEA', disable_tqdm=True)[source]

Bases: object

Multistage Evolutionary Algorithm for diversity preservation in multi-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='MSEA', disable_tqdm=True)[source]

Initialize MSEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MSEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MSEA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Expensive Multiobjective Optimization by Relation Learning and Prediction (REMO)

This module implements REMO for computationally expensive multi/many-objective optimization. A three-hidden-layer pattern-recognition network learns the ternary relation (better / equal / worse) between pairs of decision vectors, and the learnt relation is used to rank surrogate offspring without any objective regression.

References

[1] H. Hao, A. Zhou, H. Qian, and H. Zhang. Expensive multiobjective optimization by relation learning and prediction. IEEE Transactions on Evolutionary Computation, 2022, 26(5): 1157-1170.

Notes

Author: Haowei Guo Email: ghw@mail.nwpu.edu.cn Date: 2026.01.16 Version: 2.0

class ddmtolab.Algorithms.STMO.REMO.REMO(problem, n_initial=None, max_nfes=None, n=100, k=6, gmax=3000, save_data=True, save_path='./Data', name='REMO', disable_tqdm=True)[source]

Bases: object

Expensive Multiobjective Optimization by Relation Learning and Prediction.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, k=6, gmax=3000, save_data=True, save_path='./Data', name='REMO', disable_tqdm=True)[source]

Initialize REMO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1 if dim <= 10 else 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
n (int or List[int], optional) – Population size per task (MATLAB Problem.N, default: 100)
k (int, optional) – Number of reference solutions (default: 6)
gmax (int, optional) – Number of solutions evaluated by the relation model (default: 3000)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘REMO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the REMO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Kriging-Assisted Two-Archive Evolutionary Algorithm 2 (KTA2)

This module implements KTA2 for computationally expensive many-objective optimization. It maintains two archives (convergence and diversity) and uses point-insensitive Kriging models with adaptive sampling strategies.

References

[1] Z. Song, H. Wang, C. He, and Y. Jin. A Kriging-assisted two-archive evolutionary algorithm for expensive many-objective optimization. IEEE Transactions on Evolutionary Computation, 2021, 25(6): 1013-1027.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.16 Version: 1.0

class ddmtolab.Algorithms.STMO.KTA2.KTA2(problem, n_initial=None, max_nfes=None, n=100, tau=0.75, phi=0.1, wmax=10, mu=5, save_data=True, save_path='./Data', name='KTA2', disable_tqdm=True)[source]

Bases: object

Kriging-Assisted Two-Archive Evolutionary Algorithm 2 for expensive many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, tau=0.75, phi=0.1, wmax=10, mu=5, save_data=True, save_path='./Data', name='KTA2', disable_tqdm=True)[source]

Initialize KTA2 algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task. PlatEMO’s KTA2 draws Problem.N Latin-hypercube samples, so the default is n.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population/archive size per task (default: 100)
tau (float, optional) – Proportion of training data for insensitive models (default: 0.75)
phi (float, optional) – Fraction of DA for uncertainty sampling (default: 0.1)
wmax (int, optional) – Number of inner surrogate evolution generations (default: 10)
mu (int, optional) – Number of re-evaluated solutions per generation (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘KTA2’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the KTA2 algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Dual-Surrogate Assisted Evolutionary Algorithm with Portfolio Strategy (DSAEA-PS)

This module implements DSAEA-PS for computationally expensive multi/many-objective optimization. It uses two types of surrogates (Kriging for objective prediction and RBF for dominance relation prediction) combined with a portfolio of three environmental selection strategies (IBEA, RVEA, NSGA-II/CSDR) to balance convergence and diversity.

References

[1] J. Shen, P. Wang, Y. Tian, and H. Dong. A dual surrogate assisted evolutionary algorithm based on parallel search for expensive multi/many-objective optimization. Applied Soft Computing, 2023, 148: 110879.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.18 Version: 1.0

class ddmtolab.Algorithms.STMO.DSAEA_PS.DSAEA_PS(problem, n_initial=None, max_nfes=None, n=100, wmax=20, mu=5, save_data=True, save_path='./Data', name='DSAEA-PS', disable_tqdm=True)[source]

Bases: object

Dual-Surrogate Assisted Evolutionary Algorithm with Portfolio Strategy for expensive multi/many-objective optimization.

Uses Kriging models for objective prediction and an RBF model for dominance relation prediction, combined with three environmental selection strategies (IBEA, RVEA, CSDR).

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, wmax=20, mu=5, save_data=True, save_path='./Data', name='DSAEA-PS', disable_tqdm=True)[source]

Initialize DSAEA-PS algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size (number of reference vectors) per task (default: 100)
wmax (int, optional) – Number of inner surrogate evolution generations (default: 20)
mu (int, optional) – Number of re-evaluated solutions per iteration (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘DSAEA-PS’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the DSAEA-PS algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Adaptive Dropout based Surrogate-Assisted Particle Swarm Optimization (ADSAPSO)

This module implements ADSAPSO for computationally expensive multi/many-objective optimization. It uses adaptive dropout to select important decision variables, builds RBF surrogate models in the reduced space, and applies PSO on surrogates to find promising solutions.

References

[1] J. Lin, C. He, and R. Cheng. Adaptive dropout for high-dimensional expensive multiobjective optimization. Complex & Intelligent Systems, 2022, 8(1): 271-285.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.ADSAPSO.ADSAPSO(problem, n_initial=100, max_nfes=None, n=100, k=5, beta=0.5, n_a=200, n_s=50, save_data=True, save_path='./Data', name='ADSAPSO', disable_tqdm=True)[source]

Bases: object

Adaptive Dropout based Surrogate-Assisted Particle Swarm Optimization for expensive multi/many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=100, max_nfes=None, n=100, k=5, beta=0.5, n_a=200, n_s=50, save_data=True, save_path='./Data', name='ADSAPSO', disable_tqdm=True)[source]

Initialize ADSAPSO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size for PSO per task (default: 100)
k (int, optional) – Number of re-evaluated solutions per generation (default: 5)
beta (float, optional) – Percentage of dropout (fraction of dimensions to keep) (default: 0.5)
n_a (int, optional) – Number of solutions for building surrogate models (default: 200)
n_s (int, optional) – Number of well/poorly performing solutions for dimension analysis (default: 50)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘ADSAPSO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the ADSAPSO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Classification-based Surrogate-assisted Evolutionary Algorithm (CSEA)

This module implements CSEA for computationally expensive multi/many-objective optimization. It uses a neural network classifier to distinguish promising solutions from non-promising ones relative to reference solutions, with adaptive surrogate-assisted selection strategies.

References

[1] L. Pan, C. He, Y. Tian, H. Wang, X. Zhang, and Y. Jin. A classification based surrogate-assisted evolutionary algorithm for expensive many-objective optimization. IEEE Transactions on Evolutionary Computation, 2019, 23(1): 74-88.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.16 Version: 1.0

class ddmtolab.Algorithms.STMO.CSEA.CSEA(problem, n_initial=None, max_nfes=None, n=100, k=6, gmax=3000, save_data=True, save_path='./Data', name='CSEA', disable_tqdm=True)[source]

Bases: object

Classification-based Surrogate-assisted Evolutionary Algorithm for expensive multi/many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, k=6, gmax=3000, save_data=True, save_path='./Data', name='CSEA', disable_tqdm=True)[source]

Initialize CSEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: min(11*dim-1, 109))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size per task (MATLAB Problem.N, default: 100)
k (int, optional) – Number of reference solutions (default: 6)
gmax (int, optional) – Number of solutions evaluated by surrogate model (default: 3000)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘CSEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the CSEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Distribution-based Kriging-assisted evolutionary algorithm (DISK)

This module implements DISK for computationally expensive multi/many-objective optimization. It uses Distribution-based Probabilistic Dominance (DIPD) that combines prediction uncertainty from Kriging with the Gaussian density fitted on the currently non-dominated decision vectors. It features an adaptive local search, triggered when the newly evaluated candidates fail to dominate the archive front, that is guided by the reference vector pointing at the widest gap of the current front.

References

[1] Z. Zhang, Y. Wang, G. Sun, and T. Pang. A distribution information based Kriging-assisted evolutionary algorithm for expensive many-objective optimization problems. IEEE Transactions on Evolutionary Computation, 2024.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.DISK.DISK(problem, n_initial=None, max_nfes=None, wmax=60, alpha=5, save_data=True, save_path='./Data', name='DISK', disable_tqdm=True)[source]

Bases: object

Distribution-Informed Surrogate-assisted Kriging for expensive multi-objective optimization with adaptive local search.

__init__(problem, n_initial=None, max_nfes=None, wmax=60, alpha=5, save_data=True, save_path='./Data', name='DISK', disable_tqdm=True)[source]

Initialize DISK algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1). This is MATLAB’s NI = Problem.N: it is simultaneously the size of the initial Latin hypercube design, the size of the archive A1 kept by EnvironmentalSelection and the size of the surrogate population.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
wmax (int, optional) – Surrogate evolution generations (default: 60)
alpha (int, optional) – Number of candidates per iteration (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘DISK’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the DISK algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Deep Reinforcement Learning-assisted Surrogate-Assisted Evolutionary Algorithm (DRL-SAEA)

This module implements DRL-SAEA for computationally expensive constrained multi-objective optimization. It uses a Double Deep Q-Network (DDQN) to dynamically select among three constraint handling strategies for surrogate model management.

References

[1] S. Shao, Y. Tian, and Y. Zhang. Deep reinforcement learning assisted surrogate model management for expensive constrained multi-objective optimization. Swarm and Evolutionary Computation, 2025, 92: 101817.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.DRLSAEA.DRLSAEA(problem, n_initial=None, max_nfes=None, n=100, wmax=20, mu=5, save_data=True, save_path='./Data', name='DRL-SAEA', disable_tqdm=True)[source]

Bases: object

Deep Reinforcement Learning-assisted Surrogate-Assisted Evolutionary Algorithm for expensive constrained multi-objective optimization.

Uses DDQN to select among 3 constraint handling strategies: - Action 0: objectives + normalized aggregate CV - Action 1: objectives + individual normalized active constraints - Action 2: objectives only (unconstrained)

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, wmax=20, mu=5, save_data=True, save_path='./Data', name='DRL-SAEA', disable_tqdm=True)[source]

Initialize DRL-SAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Archive/population size per task (default: 100)
wmax (int, optional) – Number of inner GA generations on surrogates (default: 20)
mu (int, optional) – Number of real evaluated solutions per iteration (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘DRL-SAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the DRL-SAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Expected Direction-based Hypervolume Improvement (DirHV-EI)

This module implements DirHV-EI for parallel expensive multi/many-objective optimization. It uses GP surrogates with a MOEA/D-GR framework to maximize direction-based hypervolume expected improvement, and a greedy batch selection strategy.

References

[1] L. Zhao and Q. Zhang. Hypervolume-guided decomposition for parallel expensive multiobjective optimization. IEEE Transactions on Evolutionary Computation, 2024, 28(2): 432-444.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.16 Version: 1.0

class ddmtolab.Algorithms.STMO.DirHV_EI.DirHV_EI(problem, n_initial=None, max_nfes=None, batch_size=5, save_data=True, save_path='./Data', name='DirHV-EI', disable_tqdm=True)[source]

Bases: object

Expected Direction-based Hypervolume Improvement for parallel expensive multi/many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, batch_size=5, save_data=True, save_path='./Data', name='DirHV-EI', disable_tqdm=True)[source]

Initialize DirHV-EI algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
batch_size (int, optional) – Number of true function evaluations per iteration (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘DirHV-EI’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the DirHV-EI algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Efficient Dropout Neural Network based AR-MOEA (EDN-ARMOEA)

This module implements EDN-ARMOEA for computationally expensive multi/many-objective optimization. It uses a dropout neural network as surrogate model with MC dropout for uncertainty estimation, combined with an adaptive reference point based evolutionary algorithm (AR-MOEA).

References

[1] D. Guo, X. Wang, K. Gao, Y. Jin, J. Ding, and T. Chai. Evolutionary optimization of high-dimensional multiobjective and many-objective expensive problems assisted by a dropout neural network. IEEE Transactions on Systems, Man, and Cybernetics: Systems, 2022, 52(4): 2084-2097.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.EDN_ARMOEA.EDN_ARMOEA(problem, n_initial=None, max_nfes=None, n=100, delta=0.05, wmax=20, ke=3, save_data=True, save_path='./Data', name='EDN-ARMOEA', disable_tqdm=True)[source]

Bases: object

Efficient Dropout Neural Network based AR-MOEA for expensive multi/many-objective optimization.

__init__(problem, n_initial=None, max_nfes=None, n=100, delta=0.05, wmax=20, ke=3, save_data=True, save_path='./Data', name='EDN-ARMOEA', disable_tqdm=True)[source]

Initialize EDN-ARMOEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size per task (default: 100)
delta (float, optional) – Threshold for judging diversity improvement (default: 0.05)
wmax (int, optional) – Number of generations before updating models (default: 20)
ke (int, optional) – Number of solutions to be re-evaluated in each iteration (default: 3)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EDN-ARMOEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EDN-ARMOEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Expected Improvement Matrix based Efficient Global Optimization (EIM-EGO)

This module implements EIM-EGO for computationally expensive multi-objective optimization. It builds Kriging (Gaussian Process) models for each objective and uses the Expected Improvement Matrix (EIM) criterion to select one promising candidate per iteration via GA optimization.

Three EIM infill criteria are supported:

Euclidean distance-based EIM criterion (default)
Maximin distance-based EIM criterion
Hypervolume-based EIM criterion

References

[1] D. Zhan, Y. Cheng, and J. Liu. Expected improvement matrix-based infill criteria for expensive multiobjective optimization. IEEE Transactions on Evolutionary Computation, 2017, 21(6): 956-975.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.EIM_EGO.EIM_EGO(problem, n_initial=None, max_nfes=None, eim_type=1, ga_pop_size=100, ga_generations=100, save_data=True, save_path='./Data', name='EIM-EGO', disable_tqdm=True)[source]

Bases: object

Expected Improvement Matrix based Efficient Global Optimization for expensive multi-objective optimization.

__init__(problem, n_initial=None, max_nfes=None, eim_type=1, ga_pop_size=100, ga_generations=100, save_data=True, save_path='./Data', name='EIM-EGO', disable_tqdm=True)[source]

Initialize EIM-EGO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
eim_type (int, optional) – EIM infill criterion type (default: 1) 1 = Euclidean distance-based, 2 = Maximin distance-based, 3 = Hypervolume-based
ga_pop_size (int, optional) – Population size for internal GA optimizer (default: 100)
ga_generations (int, optional) – Number of generations for internal GA optimizer (default: 100)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EIM-EGO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EIM-EGO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Ensemble-based Surrogate Model-Assisted Evolutionary Algorithm (EM-SAEA)

This module implements EM-SAEA for computationally expensive constrained/unconstrained multi/many-objective optimization. It uses a two-stage approach: - Stage 1 (objective-oriented, FE < 50% budget): RVMM-based search with two sub-populations - Stage 2 (constraint-oriented, FE >= 50% budget): MOEA/D with ensemble constraint models

References

[1] Y. Li, X. Feng, and H. Yu. Enhancing landscape approximation with ensemble-based surrogate model for expensive constrained multiobjective optimization. IEEE Transactions on Evolutionary Computation, 2025.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.EM_SAEA.EM_SAEA(problem, n_initial=None, max_nfes=None, n=100, wmax=20, lc_num=5, mu=5, alpha=2.0, kk=0.5, save_data=True, save_path='./Data', name='EM-SAEA', disable_tqdm=True)[source]

Bases: object

Ensemble-based Surrogate Model-Assisted Evolutionary Algorithm for expensive constrained/unconstrained multi/many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, wmax=20, lc_num=5, mu=5, alpha=2.0, kk=0.5, save_data=True, save_path='./Data', name='EM-SAEA', disable_tqdm=True)[source]

Initialize EM-SAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size (number of reference vectors) per task (default: 100)
wmax (int, optional) – Number of generations before updating surrogate models (default: 20)
lc_num (int, optional) – Number of local constraint model clusters (default: 5)
mu (int, optional) – Number of re-evaluated solutions per iteration in stage 2 (default: 5)
alpha (float, optional) – Parameter controlling APD penalty rate (default: 2.0)
kk (float, optional) – Uncertainty weighting factor for MSE augmentation (default: 0.5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EM-SAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EM-SAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Kriging-Assisted Two-Archive Search (KTS)

This module implements KTS for computationally expensive constrained/unconstrained multi-objective optimization. It adaptively switches between two search modes:

Mode 0 (unconstrained/KTA2-style): two-archive CA/DA with convergence/diversity
Mode 1 (constrained/KCCMO-style): SPEA2-based fitness with K-means sampling

The switching is based on the correlation between convergence metric Q and constraint violation CV.

References

[1] Z. Song, H. Wang, and B. Xue. A Kriging-Assisted Two-Archive Evolutionary Algorithm for Expensive Multi-Objective Optimization. IEEE Transactions on Evolutionary Computation, 2024.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.KTS.KTS(problem, n_initial=None, max_nfes=None, n=100, tau=0.6, phi=-0.2, mu=20, phi1=0.1, wmax1=10, mu1=5, save_data=True, save_path='./Data', name='KTS', disable_tqdm=True)[source]

Bases: object

Kriging-Assisted Two-Archive Search for expensive constrained/unconstrained multi-objective optimization with adaptive mode switching.

__init__(problem, n_initial=None, max_nfes=None, n=100, tau=0.6, phi=-0.2, mu=20, phi1=0.1, wmax1=10, mu1=5, save_data=True, save_path='./Data', name='KTS', disable_tqdm=True)[source]

Initialize KTS algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task. PlatEMO’s KTS draws Problem.N Latin-hypercube samples, so the default is n.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population/archive size per task (default: 100)
tau (float, optional) – Correlation threshold for mode 0 (default: 0.6)
phi (float, optional) – Correlation threshold for mode 1 (default: -0.2)
mu (int, optional) – Number of elite solutions for correlation (default: 20)
phi1 (float, optional) – Uncertainty sampling fraction (default: 0.1)
wmax1 (int, optional) – Inner surrogate evolution generations (default: 10)
mu1 (int, optional) – Number of re-evaluated solutions per generation (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘KTS’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the KTS algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multigranularity Surrogate-Assisted Evolutionary Algorithm (MGSAEA)

This module implements MGSAEA for computationally expensive constrained multi-objective optimization. It uses a two-stage framework:

Stage 1 (convergence stage): Builds surrogates for objectives only, ignoring constraints
Stage 2 (constraint stage): Adaptively selects constraint handling strategy based on constraint satisfaction status (all violated, partially violated, all satisfied)

Stage transition is triggered when the ideal point change rate drops below a threshold, indicating convergence of the unconstrained search.

References

[1] Y. Zhang, H. Jiang, Y. Tian, H. Ma, and X. Zhang. Multigranularity surrogate modeling for evolutionary multiobjective optimization with expensive constraints. IEEE Transactions on Neural Networks and Learning Systems, 2024, 35(3): 2956-2968.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.MGSAEA.MGSAEA(problem, n_initial=None, max_nfes=None, n=100, wmax=20, mu=5, gap=20, lam=0.001, save_data=True, save_path='./Data', name='MGSAEA', disable_tqdm=True)[source]

Bases: object

Multigranularity Surrogate-Assisted Evolutionary Algorithm for expensive constrained multi-objective optimization.

Two-stage approach: - Stage 1: Objective-only surrogates until ideal points converge - Stage 2: Constraint-aware surrogates with adaptive granularity

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, wmax=20, mu=5, gap=20, lam=0.001, save_data=True, save_path='./Data', name='MGSAEA', disable_tqdm=True)[source]

Initialize MGSAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Archive/population size per task (default: 100)
wmax (int, optional) – Number of inner GA generations on surrogates (default: 20)
mu (int, optional) – Number of real evaluated solutions per iteration (default: 5)
gap (int, optional) – Window for ideal point change rate computation (default: 20)
lam (float, optional) – Threshold for stage transition (default: 1e-3)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MGSAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MGSAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-Model-based Ranking Aggregation Evolutionary Algorithm (MMRAEA)

This module implements MMRAEA for computationally expensive multi/many-objective optimization. It uses three RBF surrogate models (objective approximation, dominance prediction, and fitness prediction) combined with a ranking aggregation infill strategy and dual evolutionary optimization (CSO + GA) for balanced convergence and diversity.

References

[1] J. Shen, X. Wang, R. He, Y. Tian, W. Wang, P. Wang, and Z. Wen. Optimization of high-dimensional expensive multi-objective problems using multi-mode radial basis functions. Complex & Intelligent Systems, 2025, 11(2): 147.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.18 Version: 1.0

class ddmtolab.Algorithms.STMO.MMRAEA.MMRAEA(problem, n_initial=None, max_nfes=None, n=100, wmax=20, save_data=True, save_path='./Data', name='MMRAEA', disable_tqdm=True)[source]

Bases: object

Multi-Model-based Ranking Aggregation Evolutionary Algorithm for expensive multi/many-objective optimization.

Uses three RBF surrogate models (objective, dominance, fitness) with ranking aggregation infill strategy and dual evolutionary optimization (CSO + GA).

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=100, wmax=20, save_data=True, save_path='./Data', name='MMRAEA', disable_tqdm=True)[source]

Initialize MMRAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size per task (default: 100)
wmax (int, optional) – Number of inner surrogate evolution generations (default: 20)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MMRAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MMRAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

MOEA/D with Efficient Global Optimization (MOEA/D-EGO)

This module implements MOEA/D-EGO for computationally expensive multi-objective optimization. It uses clustering-based Gaussian Process models, MOEA/D-DE to maximize Expected Tchebycheff Improvement (ETI) with Moment Matching Approximation, and K-means batch selection.

References

[1] Q. Zhang, W. Liu, E. Tsang, and B. Virginas. Expensive multiobjective optimization by MOEA/D with Gaussian process model. IEEE Transactions on Evolutionary Computation, 2010, 14(3): 456-474.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.MOEA_D_EGO.MOEA_D_EGO(problem, n_initial=None, max_nfes=None, batch_size=5, save_data=True, save_path='./Data', name='MOEA-D-EGO', disable_tqdm=True)[source]

Bases: object

MOEA/D with Efficient Global Optimization for expensive multi-objective optimization.

__init__(problem, n_initial=None, max_nfes=None, batch_size=5, save_data=True, save_path='./Data', name='MOEA-D-EGO', disable_tqdm=True)[source]

Initialize MOEA/D-EGO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
batch_size (int, optional) – Number of true evaluations per iteration (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MOEA-D-EGO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MOEA/D-EGO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-objective Efficient Global Optimization (MultiObjectiveEGO)

This module implements MultiObjectiveEGO for computationally expensive multi-objective optimization. It uses reference direction-based Augmented Achievement Scalarizing Function (AASF) to decompose the multi-objective problem into scalar subproblems, builds a single GP model per infill, and maximizes Standard Expected Improvement to select new evaluation points.

References

[1] R. Hussein and K. Deb. A generative Kriging surrogate model for constrained and unconstrained multi-objective optimization. Proceedings of the Genetic and Evolutionary Computation Conference, 2016, 573-580.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.MultiObjectiveEGO.MultiObjectiveEGO(problem, n_initial=None, max_nfes=None, alpha=0.7, num_k=5, H=21, rho=0.001, save_data=True, save_path='./Data', name='MultiObjectiveEGO', disable_tqdm=True)[source]

Bases: object

Multi-objective Efficient Global Optimization for expensive multi-objective optimization using reference direction-based scalarization and Expected Improvement.

__init__(problem, n_initial=None, max_nfes=None, alpha=0.7, num_k=5, H=21, rho=0.001, save_data=True, save_path='./Data', name='MultiObjectiveEGO', disable_tqdm=True)[source]

Initialize MultiObjectiveEGO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
alpha (float, optional) – Portion of samples for Kriging construction (default: 0.7)
num_k (int, optional) – Number of infill points per reference direction (default: 5)
H (int, optional) – Number of reference directions (default: 21)
rho (float, optional) – Parameter for AASF scalarization (default: 1e-3)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MultiObjectiveEGO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MultiObjectiveEGO algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Pairwise Comparison Surrogate-Assisted Evolutionary Algorithm (PC-SAEA)

This module implements PC-SAEA for computationally expensive multi-objective optimization. It uses a Probabilistic Neural Network (PNN) based pairwise comparison surrogate that classifies whether one solution is better than another, combined with adaptive selection strategies based on surrogate reliability.

References

[1] Y. Tian, J. Hu, C. He, H. Ma, L. Zhang, and X. Zhang. A pairwise comparison based surrogate-assisted evolutionary algorithm for expensive multi-objective optimization. Swarm and Evolutionary Computation, 2023, 80: 101323.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 1.0

class ddmtolab.Algorithms.STMO.PCSAEA.PCSAEA(problem, n_initial=None, max_nfes=None, n=100, delta=0.8, gmax=3000, spread=0.1925, save_data=True, save_path='./Data', name='PC-SAEA', disable_tqdm=True)[source]

Bases: object

Pairwise Comparison Surrogate-Assisted Evolutionary Algorithm for expensive multi-objective optimization using PNN-based pairwise comparison surrogates.

__init__(problem, n_initial=None, max_nfes=None, n=100, delta=0.8, gmax=3000, spread=0.1925, save_data=True, save_path='./Data', name='PC-SAEA', disable_tqdm=True)[source]

Initialize PC-SAEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: max(11*dim-1, n))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size per task (default: 100)
delta (float, optional) – Reliability threshold for surrogate (default: 0.8)
gmax (int, optional) – Number of solutions evaluated by the surrogate model (default: 3000)
spread (float, optional) – PNN RBF spread parameter (default: 0.1925)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘PC-SAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the PC-SAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Pareto-based Kriging-assisted constrained multi-objective evolutionary algorithm (PEA)

This module implements PEA for expensive constrained multi-objective optimization. Kriging (Gaussian process) surrogates are built for every objective and every constraint, and the surrogate-based search is driven by Constrained Probabilistic Pareto Dominance (CPPD): the probability that solution i is better than solution j on an objective is weighted by the least probability of feasibility of the two solutions, and the resulting weighted probabilities define the dominance relation.

References

[1] Z. Zhang, Y. Wang, G. Sun, and K. Tang. Constrained probabilistic Pareto dominance for expensive constrained multiobjective optimization problems. IEEE Transactions on Evolutionary Computation, 2024.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 2.0

class ddmtolab.Algorithms.STMO.PEA.PEA(problem, n_initial=None, max_nfes=None, wmax=20, mu=5, save_data=True, save_path='./Data', name='PEA', disable_tqdm=True)[source]

Bases: object

Pareto-based Kriging-assisted constrained multi-objective evolutionary algorithm for expensive optimization, based on Constrained Probabilistic Pareto Dominance.

__init__(problem, n_initial=None, max_nfes=None, wmax=20, mu=5, save_data=True, save_path='./Data', name='PEA', disable_tqdm=True)[source]

Initialize PEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1). This is MATLAB’s NI = Problem.N: it is simultaneously the size of the initial Latin hypercube design and the size of the working population maintained by Pop_Update.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
wmax (int, optional) – Generations of the surrogate-based evolutionary search (default: 20)
mu (int, optional) – Number of candidates selected per iteration (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘PEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the PEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Performance Indicator-based Evolutionary Algorithm (PIEA)

This module implements PIEA for computationally expensive high-dimensional multi/many-objective optimization. It adaptively selects among three performance indicators (SDE, I_epsilon+, Minkowski distance) to train an SVR surrogate model, then uses DE-based model optimization and hierarchical evaluation to guide the search.

References

[1] Y. Li, W. Li, S. Li, and Y. Zhao. A performance indicator-based evolutionary algorithm for expensive high-dimensional multi-/many-objective optimization. Information Sciences, 2024: 121045.

Notes

Author: Jiangtao Shen (DDMTOLab implementation) Email: j.shen5@exeter.ac.uk Date: 2026.02.16 Version: 1.0

class ddmtolab.Algorithms.STMO.PIEA.PIEA(problem, n_initial=None, max_nfes=None, n=None, eta=5, r_max=20, tau=20, save_data=True, save_path='./Data', name='PIEA', disable_tqdm=True)[source]

Bases: object

Performance Indicator-based Evolutionary Algorithm for expensive multi/many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=None, eta=5, r_max=20, tau=20, save_data=True, save_path='./Data', name='PIEA', disable_tqdm=True)[source]

Initialize PIEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: same as n)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Population size per task (default: 100)
eta (int, optional) – Number of pre-selected survivors (default: 5)
r_max (int, optional) – Maximum repeat time of offspring generation (default: 20)
tau (int, optional) – Window width for history list (default: 20)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘PIEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the PIEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Surrogate-Assisted Evolutionary Algorithm with Decomposition-Based Local Learning (SAEA-DBLL)

This module implements SAEA-DBLL for computationally expensive multi/many-objective optimization. It uses RBF surrogate models with a decomposition-based local learning strategy, where a subset of reference vectors defines neighborhoods for competitive swarm optimization, combined with adaptive vector selection and APD-based environmental selection.

References

[1] J. Shen, P. Wang, H. Dong, W. Wang, and J. Li. Surrogate-assisted evolutionary algorithm with decomposition-based local learning for high-dimensional multi-objective optimization. Expert Systems with Applications, 2024, 240: 122575.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.18 Version: 1.0

class ddmtolab.Algorithms.STMO.SAEA_DBLL.SAEA_DBLL(problem, n_initial=None, max_nfes=None, n=None, alpha=2.0, wmax=20, mu=5, T=3, K=2, save_data=True, save_path='./Data', name='SAEA-DBLL', disable_tqdm=True)[source]

Bases: object

Surrogate-Assisted Evolutionary Algorithm with Decomposition-Based Local Learning for expensive multi/many-objective optimization.

Uses RBF surrogates with neighborhood-aware competitive swarm optimization and adaptive sub-reference vector management.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n=None, alpha=2.0, wmax=20, mu=5, T=3, K=2, save_data=True, save_path='./Data', name='SAEA-DBLL', disable_tqdm=True)[source]

Initialize SAEA-DBLL algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: dim+50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
n (int or List[int], optional) – Requested number of reference vectors per task (default: 55 when the task has 10 objectives, otherwise 50)
alpha (float, optional) – Exponent for theta progression (default: 2.0)
wmax (int, optional) – Number of inner surrogate evolution generations (default: 20)
mu (int, optional) – Number of re-evaluated solutions per iteration (default: 5)
T (int, optional) – Neighborhood size for sub-vectors (default: 3)
K (int, optional) – Division factor for sub-vector count (default: 2)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SAEA-DBLL’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SAEA-DBLL algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Self-Organizing Surrogate-Assisted Non-Dominated Sorting Differential Evolution (SSDE)

This module implements SSDE for computationally expensive multi/many-objective optimization. It uses a Self-Organizing Map (SOM) as a surrogate model to predict offspring quality, combined with NSGA-II environmental selection. Only offspring that survive selection are evaluated with the expensive objective function.

References

[1] A. F. R. Araujo, L. R. C. Farias, and A. R. C. Goncalves. Self-organizing surrogate-assisted non-dominated sorting differential evolution. Swarm and Evolutionary Computation, 2024, 91: 101703.

Notes

Author: Jiangtao Shen (DDMTOLab implementation) Email: j.shen5@exeter.ac.uk Date: 2026.02.16 Version: 1.0

class ddmtolab.Algorithms.STMO.SSDE.SSDE(problem, n_initial=None, max_nfes=None, num_nodes=None, eta0=0.2, sigma0=None, save_data=True, save_path='./Data', name='SSDE', disable_tqdm=True)[source]

Bases: object

Self-Organizing Surrogate-Assisted Non-Dominated Sorting Differential Evolution for expensive multi/many-objective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, num_nodes=None, eta0=0.2, sigma0=None, save_data=True, save_path='./Data', name='SSDE', disable_tqdm=True)[source]

Initialize SSDE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1). This plays the role of MATLAB’s Problem.N: it is simultaneously the population size, the initial sample count, the default number of SOM neurons and the default neighbourhood size.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
num_nodes (int, optional) – Number of neurons in the SOM (default: same as n_initial)
eta0 (float, optional) – Initial learning rate for SOM training (default: 0.2)
sigma0 (float, optional) – Initial neighborhood size for SOM (default: same as n_initial)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SSDE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SSDE algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Two-phase Evolutionary Algorithm (TEA)

This module implements TEA for expensive constrained multi-objective optimization. The search is driven by Kriging (Gaussian process) surrogates and a probabilistic dominance relation (PDPD) that splits the objectives of every compared pair into a “certain” group (the two dominance probabilities differ by more than epsilon) and an “uncertain” group (aggregated by a product of probabilities). The algorithm runs in two phases: phase 1 ignores the constraints, phase 2 additionally models the constraints and uses the constrained PDPD relation. The transition is triggered when the newly sampled candidates stop improving the feasible non-dominated set for ct_max consecutive iterations.

References

[1] Z. Zhang, Y. Wang, J. Liu, G. Sun, and K. Tang. A two-phase Kriging-assisted evolutionary algorithm for expensive constrained multiobjective optimization problems. IEEE Transactions on Systems, Man, and Cybernetics: Systems, 2024, 54(8): 4579-4591.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.17 Version: 2.0

class ddmtolab.Algorithms.STMO.TEA.TEA(problem, n_initial=None, max_nfes=None, wmax=20, mu=5, save_data=True, save_path='./Data', name='TEA', disable_tqdm=True)[source]

Bases: object

Two-phase Evolutionary Algorithm for expensive (constrained) multi-objective optimization using PDPD sorting and Kriging surrogates.

__init__(problem, n_initial=None, max_nfes=None, wmax=20, mu=5, save_data=True, save_path='./Data', name='TEA', disable_tqdm=True)[source]

Initialize TEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim-1). This is MATLAB’s NI = Problem.N: it is simultaneously the size of the initial Latin hypercube design and the size of the working population maintained by Pop_Reselect.
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
wmax (int, optional) – Generations of the surrogate-based evolutionary search (default: 20)
mu (int, optional) – Number of candidates selected per iteration (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘TEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the TEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Grouping via Sensitivity Analysis Evolutionary Algorithm (GSAEA)

This module implements GSAEA for high-dimensional expensive multi-objective optimization. Sobol’ first order sensitivity indices, computed on Kriging models of each objective, split the decision variables into convergence-related and diversity-related subsets. Each subset is then searched by its own surrogate-assisted operator: differential evolution driven by a predicted convergence indicator, and a genetic algorithm driven by per-cluster objective models. The reconstructed candidates are ranked by a predicted shift-based density estimation value, and the best ones are evaluated exactly.

References

[1] W. Chen, Z. Li, J. Yu, and Y. Pu. Grouping via sensitivity analysis evolutionary algorithm for high-dimensional expensive multi-objective optimization. Complex & Intelligent Systems, 2026, 12: 66.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.14 Version: 1.0

class ddmtolab.Algorithms.STMO.GSAEA.GSAEA(problem, n_initial=None, max_nfes=None, n=50, k=5, n_clusters=None, wmax=20, n_sobol=256, F=0.5, CR=0.9, muc=20, mum=20, save_data=True, save_path='./Data', name='GSAEA', disable_tqdm=True)[source]

Bases: object

Grouping via Sensitivity Analysis Evolutionary Algorithm for high-dimensional expensive multi-objective optimization.

__init__(problem, n_initial=None, max_nfes=None, n=50, k=5, n_clusters=None, wmax=20, n_sobol=256, F=0.5, CR=0.9, muc=20, mum=20, save_data=True, save_path='./Data', name='GSAEA', disable_tqdm=True)[source]

Initialize GSAEA.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial LHS samples per task (default: 100, capped so that at least one infill iteration fits inside the budget)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 300)
n (int or List[int], optional) – Population size per task (default: 50)
k (int, optional) – Number of candidates re-evaluated per iteration (default: 5)
n_clusters (int, optional) – Number of K-means clusters used for the local objective models. None follows the paper’s default nc = M (default: None)
wmax (int, optional) – Number of generations of the surrogate-assisted DE search on the convergence-related variables (default: 20)
n_sobol (int, optional) – Base sample size of the Sobol’ index estimator; the grouping costs n_sobol * (D + 2) cheap Kriging predictions and no real evaluations (default: 256)
F (float, optional) – DE differential weight (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.9)
muc (float, optional) – Distribution index of the SBX crossover (default: 20)
mum (float, optional) – Distribution index of the polynomial mutation (default: 20)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘GSAEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

Notes

The paper fixes N = 50, NI = 100, FEs_max = 300, k = 5 and nc = M, and leaves wmax and the Sobol’ sample size unspecified; the defaults above keep the surrogate search cost of the same order as the DE-based baselines the paper compares against.

optimize()[source]

Execute the GSAEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Surrogate-assisted Multi-objective Evolutionary Algorithm with Adaptive local region Search (AS-SMEA)

This module implements AS-SMEA for high-dimensional expensive multi-objective optimization. The decision space is partitioned into several hyper-ellipsoidal local regions whose position and shape are carried by a covariance matrix adaptation state. Each region is searched in parallel: local Gaussian processes turn the expensive problem into K cheap approximate multi-objective problems, one per acquisition function, each solved by NSGA-II. A multi-armed bandit then decides which acquisition function’s candidate set is worth the real evaluations, and stagnating regions are restarted at a Thompson-sampled hypervolume optimum far from the existing region centers.

References

[1] Q. Wang, H. Li, W. Zhang, Y. Zhang, D. Gong, F. Chu, A. W. Mohamed, and I. Muhammad. Surrogate-assisted evolutionary algorithm with adaptive local region search for high-dimensional expensive multi-objective optimization problems. Swarm and Evolutionary Computation, 2026, 100: 102232.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.14 Version: 1.0

class ddmtolab.Algorithms.STMO.AS_SMEA.AS_SMEA(problem, n_initial=None, max_nfes=None, n_regions=5, n_select=3, n=100, n_gen=50, gamma=0.75, alpha=0.99735, kappa=2.0, shrinkage=0.1, n_screen=20, n_fantasy=3, fantasy_size=10, n_hv_sample=4096, restart_patience=3, n_restart_cand=2000, muc=20, mum=20, save_data=True, save_path='./Data', name='AS-SMEA', disable_tqdm=True)[source]

Bases: object

Surrogate-assisted multi-objective evolutionary algorithm with adaptive local region search for high-dimensional expensive multi-objective optimization.

__init__(problem, n_initial=None, max_nfes=None, n_regions=5, n_select=3, n=100, n_gen=50, gamma=0.75, alpha=0.99735, kappa=2.0, shrinkage=0.1, n_screen=20, n_fantasy=3, fantasy_size=10, n_hv_sample=4096, restart_patience=3, n_restart_cand=2000, muc=20, mum=20, save_data=True, save_path='./Data', name='AS-SMEA', disable_tqdm=True)[source]

Initialize AS-SMEA.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial LHS samples per task (default: min(300, max_nfes/2))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 509)
n_regions (int, optional) – Number of local regions L (default: 5)
n_select (int, optional) – Number of representative solutions really evaluated per region and iteration, S in Algorithm 4 (default: 3)
n (int, optional) – Population size of the NSGA-II run on each approximate problem (default: 100)
n_gen (int, optional) – Number of generations of that NSGA-II run (default: 50)
gamma (float, optional) – Decay factor of the accumulated bandit reward, Eq. (8) (default: 0.75)
alpha (float, optional) – Confidence level of the chi-square cutoff that closes the hyper-ellipsoidal region, Eq. (5) (default: 0.99735, the 3-sigma rule)
kappa (float, optional) – Trade-off weight of the UCB acquisition function (default: 2.0)
shrinkage (float, optional) – Weight of the identity matrix blended into the sample covariance of a region (default: 0.1)
n_screen (int, optional) – Number of candidates kept per approximate problem before the HVKG search (default: 20)
n_fantasy (int, optional) – Number of fantasy draws averaged by the HVKG criterion, N’ in Eq. (10) (default: 3)
fantasy_size (int, optional) – Size of the random subset V_i in Eq. (10) (default: 10)
n_hv_sample (int, optional) – Number of Monte-Carlo samples used for the hypervolume of the bandit reward (default: 4096)
restart_patience (int, optional) – Number of consecutive iterations without hypervolume improvement after which a region is restarted (default: 3)
n_restart_cand (int, optional) – Size of the random pool scanned for the new region center in Algorithm 3 (default: 2000)
muc (float, optional) – Distribution index of the SBX crossover (default: 20)
mum (float, optional) – Distribution index of the polynomial mutation (default: 20)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘AS-SMEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

Notes

The paper fixes L = 5, S = 3, gamma = 0.75, a 100/50 NSGA-II and FEs_max = 509 with min(Original, 300) initial samples. It leaves the restart condition, the covariance regularization and the cost of the HVKG search unspecified; restart_patience, shrinkage, n_screen, n_fantasy and fantasy_size fill those gaps and are documented on the corresponding helpers.

optimize()[source]

Execute the AS-SMEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multitask Single-Objective (MTSO)

Multifactorial Evolutionary Algorithm (MFEA)

This module implements MFEA for multi-task optimization with knowledge transfer across tasks.

References

[1] Abhishek Gupta, Yew-Soon Ong, and Liang Feng. “Multifactorial Evolution: Toward Evolutionary Multitasking.” IEEE Transactions on Evolutionary Computation, 20(3): 343-357, 2015.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.12 Version: 1.0

class ddmtolab.Algorithms.MTSO.MFEA.MFEA(problem, n=None, max_nfes=None, rmp=0.3, muc=2.0, mum=5.0, save_data=True, save_path='./Data', name='MFEA', disable_tqdm=True)[source]

Bases: object

Multifactorial Evolutionary Algorithm for multi-task optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, rmp=0.3, muc=2.0, mum=5.0, save_data=True, save_path='./Data', name='MFEA', disable_tqdm=True)[source]

Initialize Multifactorial Evolutionary Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability for inter-task crossover (default: 0.3)
muc (float, optional) – Distribution index for SBX crossover (default: 2.0)
mum (float, optional) – Distribution index for polynomial mutation (default: 5.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MFEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Multifactorial Evolutionary Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multifactorial Evolutionary Algorithm With Online Transfer Parameter Estimation (MFEA-II)

This module implements MFEA-II for multi-task optimization with knowledge transfer across tasks.

References

[1] Bali, Kavitesh Kumar, et al. “Multifactorial evolutionary algorithm with online transfer parameter estimation: MFEA-II.” IEEE Transactions on Evolutionary Computation 24.1 (2019): 69-83.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.16 Version: 1.0

class ddmtolab.Algorithms.MTSO.MFEA_II.MFEA_II(problem, n=None, max_nfes=None, muc=2.0, mum=5.0, swap=0.5, save_data=True, save_path='./Data', name='MFEA-II', disable_tqdm=True)[source]

Bases: object

Multifactorial Evolutionary Algorithm With Online Transfer Parameter Estimation

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=2.0, mum=5.0, swap=0.5, save_data=True, save_path='./Data', name='MFEA-II', disable_tqdm=True)[source]

Initialize MFEA-II.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for SBX crossover (default: 2.0)
mum (float, optional) – Distribution index for polynomial mutation (default: 5.0)
swap (float, optional) – Variable swap probability threshold; a gene is swapped between the two children when rand() >= swap (default: 0.5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MFEA-II’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Multifactorial Evolutionary Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Generalized Multifactorial Evolutionary Algorithm (G-MFEA)

This module implements G-MFEA for multi-task optimization with adaptive knowledge transfer.

References

[1] Ding, Jinliang, et al. “Generalized Multitasking for Evolutionary Optimization of Expensive Problems.” IEEE Transactions on Evolutionary Computation 23.1 (2019): 44-58. https://doi.org/10.1109/TEVC.2017.2785351

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.12 Version: 1.0

class ddmtolab.Algorithms.MTSO.G_MFEA.G_MFEA(problem, n=None, max_nfes=None, rmp=0.3, muc=2.0, mum=5.0, phi=0.1, theta=0.02, top=0.4, save_data=True, save_path='./Data', name='G-MFEA', disable_tqdm=True)[source]

Bases: object

Generalized Multifactorial Evolutionary Algorithm for multi-task optimization.

This algorithm features: - Adaptive knowledge transfer via task-pair specific transfer vectors - Dimension shuffling for heterogeneous task alignment - Translation strategy based on population centroids

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, rmp=0.3, muc=2.0, mum=5.0, phi=0.1, theta=0.02, top=0.4, save_data=True, save_path='./Data', name='G-MFEA', disable_tqdm=True)[source]

Initialize G-MFEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability for inter-task crossover (default: 0.3)
muc (float, optional) – Distribution index for SBX crossover (default: 2.0)
mum (float, optional) – Distribution index for polynomial mutation (default: 5.0)
phi (float, optional) – Threshold ratio to activate translation (default: 0.1)
theta (float, optional) – Interval ratio for translation frequency (default: 0.02)
top (float, optional) – Ratio of top individuals to estimate current optimums (default: 0.4)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘G-MFEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the G-MFEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-task Evolutionary Algorithm with Adaptive Knowledge Transfer via Anomaly Detection (MTEA-AD)

This module implements MTEA-AD for multi-task optimization with adaptive knowledge transfer using anomaly detection to identify beneficial solutions from other tasks.

References

[1] Wang, Chao, et al. “Solving multitask optimization problems with adaptive knowledge transfer via anomaly detection.” IEEE Transactions on Evolutionary Computation 26.2 (2021): 304-318.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.12 Version: 1.0

class ddmtolab.Algorithms.MTSO.MTEA_AD.MTEA_AD(problem, n=None, max_nfes=None, TRP=0.1, muc=2.0, mum=5.0, save_data=True, save_path='./Data', name='MTEA-AD', disable_tqdm=True)[source]

Bases: object

Multi-task Evolutionary Algorithm with Adaptive Knowledge Transfer via Anomaly Detection.

Uses a Gaussian-based anomaly detection model to adaptively identify and transfer beneficial solutions from other tasks during optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, TRP=0.1, muc=2.0, mum=5.0, save_data=True, save_path='./Data', name='MTEA-AD', disable_tqdm=True)[source]

Initialize MTEA-AD algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
TRP (float, optional) – Transfer probability - probability of knowledge transfer in each generation (default: 0.1)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 2.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 5.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTEA-AD’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTEA-AD algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-task Evolutionary Algorithm with Self-adaptive Solvers (MTEA-SaO)

This module implements MTEA-SaO for multi-task single-objective optimization problems.

References

[1] Li, Yanchi, Wenyin Gong, and Shuijia Li. “Multitasking Optimization via an Adaptive Solver Multitasking Evolutionary Framework.” Information Sciences (2022). https://doi.org/10.1016/j.ins.2022.10.099

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.02 Version: 1.0

class ddmtolab.Algorithms.MTSO.MTEA_SaO.MTEA_SaO(problem, n=None, max_nfes=None, t_gap=10, t_num=10, sa_gap=70, memory=30, ga_muc=2.0, ga_mum=5.0, de_f=0.5, de_cr=0.9, save_data=True, save_path='./Data', name='MTEA-SaO', disable_tqdm=True)[source]

Bases: object

Multi-task Evolutionary Algorithm with Self-adaptive Solvers for single-objective optimization.

This algorithm features: - Two solver strategies: GA (SBX + PM) and DE (DE/rand/1/bin) - Self-adaptive solver selection based on success/failure history - Knowledge transfer between tasks via random solution injection - Adaptive population partitioning among solvers

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, t_gap=10, t_num=10, sa_gap=70, memory=30, ga_muc=2.0, ga_mum=5.0, de_f=0.5, de_cr=0.9, save_data=True, save_path='./Data', name='MTEA-SaO', disable_tqdm=True)[source]

Initialize MTEA-SaO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
t_gap (int, optional) – Transfer gap - perform knowledge transfer every t_gap generations (default: 10)
t_num (int, optional) – Number of solutions to transfer (default: 10)
sa_gap (int, optional) – Self-adaptive gap - update solver allocation every sa_gap generations (default: 70)
memory (int, optional) – Memory length for success/failure history (default: 30)
ga_muc (float, optional) – Distribution index for GA crossover (SBX) (default: 2.0)
ga_mum (float, optional) – Distribution index for GA mutation (PM) (default: 5.0)
de_f (float, optional) – DE scaling factor (default: 0.5)
de_cr (float, optional) – DE crossover probability (default: 0.9)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTEA-SaO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTEA-SaO algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Evolutionary Multitasking via Explicit Autoencoding (EMEA)

This module implements EMEA for multi-task optimization with knowledge transfer via autoencoding.

References

[1] Feng, Liang, et al. “Evolutionary multitasking via explicit autoencoding.” IEEE transactions on cybernetics 49.9 (2018): 3457-3470.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.10.25 Version: 1.0

class ddmtolab.Algorithms.MTSO.EMEA.EMEA(problem, n=None, max_nfes=None, SNum=10, TGap=10, muc=2, mum=5, F=0.5, CR=0.6, save_data=True, save_path='./Data', name='EMEA', disable_tqdm=True)[source]

Bases: object

Evolutionary Multitasking via Explicit Autoencoding for multi-task optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, SNum=10, TGap=10, muc=2, mum=5, F=0.5, CR=0.6, save_data=True, save_path='./Data', name='EMEA', disable_tqdm=True)[source]

Initialize EMEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
SNum (int, optional) – Number of transferred solutions (default: 10)
TGap (int, optional) – Transfer interval in generations (default: 10)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 2.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 5.0)
F (float, optional) – Scaling factor for DE mutation (default: 0.5)
CR (float, optional) – Crossover rate for DE (default: 0.6)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EMEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EMEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Meta-Knowledge Transfer-based Differential Evolution (MKTDE)

This module implements MKTDE for multi-task optimization using centroid-based meta-knowledge transfer between tasks in a multi-population DE framework.

References

[1] Li, Jian-Yu, et al. “A Meta-Knowledge Transfer-Based Differential: Evolution for Multitask Optimization.” IEEE Transactions on Evolutionary Computation, 26(4): 719-734, 2022.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 2.0

class ddmtolab.Algorithms.MTSO.MKTDE.MKTDE(problem, n=None, max_nfes=None, F=0.5, CR=0.6, save_data=True, save_path='./Data', name='MKTDE', disable_tqdm=True)[source]

Bases: object

Meta-Knowledge Transfer-based Differential Evolution.

Uses centroid alignment to transform source task solutions into the target task’s search distribution, creating an extended donor pool for DE/rand/1/bin. The base vector x1 is selected from the current task only, while difference vectors x2, x3 come from the combined pool. Additionally, an elite solution from the source task is transferred each generation.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, F=0.5, CR=0.6, save_data=True, save_path='./Data', name='MKTDE', disable_tqdm=True)[source]

Initialize MKTDE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
F (float, optional) – DE mutation scale factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.6)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MKTDE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MKTDE algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Self-Regulated Evolutionary Multitask Optimization (SREMTO)

This module implements SREMTO for multi-task single-objective optimization problems.

References

[1] Zheng, Xiaolong, A. K. Qin, Maoguo Gong, and Deyun Zhou. “Self-Regulated Evolutionary Multitask Optimization.” IEEE Transactions on Evolutionary Computation 24.1 (2020): 16-28. https://doi.org/10.1109/TEVC.2019.2904696

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.28 Version: 1.0

class ddmtolab.Algorithms.MTSO.SREMTO.SREMTO(problem, n=None, max_nfes=None, th=0.3, p_alpha=0.7, p_beta=1.0, muc=1.0, mum=39.0, save_data=True, save_path='./Data', name='SREMTO', disable_tqdm=True)[source]

Bases: object

Self-Regulated Evolutionary Multitask Optimization.

This algorithm features: - Ability vector for self-regulated knowledge transfer - Two-line segment ability calculation based on ranking - Combined SBX crossover with differential mutation - Multi-factorial evaluation based on ability probability

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, th=0.3, p_alpha=0.7, p_beta=1.0, muc=1.0, mum=39.0, save_data=True, save_path='./Data', name='SREMTO', disable_tqdm=True)[source]

Initialize SREMTO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
th (float, optional) – Threshold for two-line segments point (default: 0.3)
p_alpha (float, optional) – Probability of crossover (default: 0.7)
p_beta (float, optional) – Probability of differential mutation (default: 1.0)
muc (float, optional) – Distribution index for SBX crossover (default: 1.0)
mum (float, optional) – Distribution index for polynomial mutation (default: 39.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SREMTO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SREMTO algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Radial Basis Functions-Assisted MTEA (RAMTEA)

This module implements RAMTEA for expensive multi-task optimization with surrogate-assisted adaptive knowledge transfer. Each task keeps an RBF surrogate built from its evaluated database; a GA search seeded from that database refines the surrogate optimum, and promising solutions are transferred between tasks with a probability equal to their rank-correlation similarity.

References

[1] J. Shen, et al., “Surrogate-assisted adaptive knowledge transfer for: expensive multitasking optimization,” 2024 IEEE Congress on Evolutionary Computation (CEC). IEEE, 2024.

Notes

Reconciled with the reference MATLAB implementation (MTO-Platform) and generalized to K >= 3 tasks (v2.0):

Task similarity is the Spearman rank correlation between the objective values a shared set of points attains on each task, clamped to >= 0 (the reference’s S = max(S, 0)). The previous version used Pearson correlation on the raw objectives and transferred on |corr|, which incorrectly transferred between negatively correlated tasks.
The surrogate search is seeded from each task’s evaluated database and runs w_max GA generations, keeping the n_in best by RBF prediction each generation (the reference procedure), instead of a GA restarted from random points which can chase unreliable RBF extrapolations far from the data.
Knowledge transfer generalizes the reference’s coupled 2-task transfer to any number of tasks: task r always evaluates its own surrogate optimum and, for each other task s, additionally evaluates task s’s optimum with probability S(r, s). For two tasks the per-direction transfer probability is identical to the reference.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.18 Version: 2.0

class ddmtolab.Algorithms.MTSO.RAMTEA.RAMTEA(problem, n_initial=None, max_nfes=None, n_in=50, w_max=50, muc=2, mum=5, save_data=True, save_path='./Data', name='RAMTEA', disable_tqdm=True)[source]

Bases: object

Radial Basis Functions-Assisted Multi-Task Evolutionary Algorithm for expensive optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n_in=50, w_max=50, muc=2, mum=5, save_data=True, save_path='./Data', name='RAMTEA', disable_tqdm=True)[source]

Initialize RAMTEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50; the reference uses 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 100)
n_in (int, optional) – Number of solutions retained each generation of the surrogate search (default: 50)
w_max (int, optional) – Number of generations of the surrogate search (default: 50)
muc (float, optional) – Distribution index for SBX crossover in the surrogate search (default: 2)
mum (float, optional) – Distribution index for polynomial mutation in the surrogate search (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘RAMTEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the RAMTEA algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

A Surrogate-Assisted Evolutionary Framework for Expensive Multitask Optimization Problems (SELF)

This module implements SELF using multi-task Gaussian processes and Bayesian optimization for expensive multi-task optimization. Each optimization cycle runs two phases (paper Algorithm 1): a global knowledge transfer phase, where DE assisted with an MTGP surrogate preselects one candidate per individual by the lower confidence bound (Eq. 18), and a local knowledge transfer phase, where task-local BO improves each population’s best individual (Algorithm 3) and the improved best individuals are transferred across tasks with the correlation-based probability p_T (Eq. 23, Algorithm 4).

References

[1] S. Tan, Y. Wang, G. Sun, T. Pang, and K. Tang, “A surrogate-assisted: evolutionary framework for expensive multitask optimization problems,” IEEE Transactions on Evolutionary Computation, vol. 29, no. 3, pp. 779-793, 2025.

Notes

Corrected against the paper (v2.0):

Global phase uses DE/rand/1 with binomial crossover against the current individual (Algorithm 2, Eqs. 19-20) and preselects candidates by the LCB mean - std (Eq. 18), not the posterior mean alone.
Local BO builds the GP on the n nearest evaluated solutions to the best individual and maximizes EI inside the bounding box of those solutions (Eq. 21); the BO candidate competes for the best individual’s slot.
Transfer moves the BO-improved best individuals X_I (not population bests) with probability p_T from the MTGP task correlation (no absolute value); the best transferred solution competes for the best individual’s slot.
Paper parameter defaults: NP=10, lambda=50, F=0.6, CR=0.7, n=50, MaxFEs=200 per task (400 total for two tasks).

Validated on the paper’s 10-D CEC17-MTSO test suite (Table II protocol).

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.18 Version: 2.0

class ddmtolab.Algorithms.MTSO.SELF.SELF(problem, n_initial=None, max_nfes=None, F=0.6, CR=0.7, ng=50, nl=50, save_data=True, save_path='./Data', name='SELF', disable_tqdm=True)[source]

Bases: object

Surrogate-Assisted Evolutionary Framework for expensive multi-task optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, F=0.6, CR=0.7, ng=50, nl=50, save_data=True, save_path='./Data', name='SELF', disable_tqdm=True)[source]

Initialize SELF algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int, optional) – Number of initial LHS samples per task, which also fixes the population size NP kept throughout the run (default: 10, paper setting)
max_nfes (int, optional) – Maximum number of function evaluations per task, shared as a single budget of max_nfes * n_tasks across tasks (default: 200, the paper’s setting of MaxFEs = 400 for two tasks)
F (float, optional) – Mutation factor for DE (default: 0.6, paper setting)
CR (float, optional) – Crossover rate for DE (default: 0.7, paper setting)
ng (int, optional) – Number of trial vectors lambda per individual in the global knowledge transfer phase (default: 50, paper setting)
nl (int, optional) – Number n of nearest evaluated solutions used to train the local GP model in the local knowledge transfer phase (default: 50, paper setting)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SELF’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SELF algorithm (paper Algorithm 1).

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

EBS (Evolutionary Biocoenosis-based Symbiosis)

This module implements the EBS algorithm for evolutionary many-tasking optimization.

References

[1] Liaw, R. T., & Ting, C. K. (2017). Evolutionary many-tasking based on biocoenosis through symbiosis: A framework and benchmark problems. In 2017 IEEE Congress on Evolutionary Computation (CEC) (pp. 2266-2273). IEEE. doi:10.1109/CEC.2017.7969579 [2] Liaw, R. T., & Ting, C. K. (2020). Evolution of biocoenosis through symbiosis with fitness approximation for many-tasking optimization. Memetic Computing, 12(4), 399-417. doi:10.1007/s12293-020-00317-2 [3] Tan, X. (2018). EBSGA.m, reference implementation of [1], in drwuHUST/MTGA. https://github.com/drwuHUST/MTGA/blob/master/EBSGA.m

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.01.09 Version: 1.0

class ddmtolab.Algorithms.MTSO.EBS.EBS(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, rmp0=0.3, gamma_min=0.0, save_data=True, save_path='./Data', name='EBS', disable_tqdm=True)[source]

Bases: object

Evolutionary Biocoenosis-based Symbiosis for many-task optimization.

EBS uses multiple CMA-ES instances with adaptive information exchange among tasks. Each task maintains two CMA-ES distributions: - One updated when knowledge transfer occurs - One updated when no knowledge transfer occurs

The information exchange probability gamma_i is recomputed every generation from the transfer-rate formula of [2] (attributed there to [1]):

gamma_i = S_io / (S_is + S_io)
S_is = #Surpassing_is / #Evals_is
S_io = #Surpassing_io / #Evals_io

where the _is counters are credited to the task’s own EA and the _io counters to the union of the other tasks’ EAs. There is no warm-up phase: generation 1 only initialises the populations, and gamma is seeded with rmp0 and updated from generation 2 onward, matching the reference implementation [3].

Known defect (reference-faithful, not a porting bug)

gamma_i has an absorbing zero state. Transfer is the only way foreign offspring are ever evaluated, so once gamma_i reaches 0 (or NaN) the _io counters can never grow again and transfer stays dead for the rest of the run. Two entry conditions exist, both present in [3]:

#Evals_io == 0 (the transfer coin has never fired): S_io = 0/0 = NaN, gamma_i = NaN, and rand() < NaN is False forever.
#Evals_io > 0 but #Surpassing_io == 0: S_io = 0 and gamma_i = 0.

Seeding with rmp0 = 0.3 makes the first condition unlikely but does not remove it. The optional gamma_min guard restores ergodicity but is a deviation from the published algorithm and is disabled by default.

ivar algorithm_information:: Dictionary containing algorithm capabilities and requirements
vartype algorithm_information:: dict

__init__(problem, n=None, max_nfes=None, sigma0=0.3, use_n=True, rmp0=0.3, gamma_min=0.0, save_data=True, save_path='./Data', name='EBS', disable_tqdm=True)[source]

Initialize EBS Algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: None, will use 4+3*log(D))
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
sigma0 (float, optional) – Initial step size for CMA-ES (default: 0.3)
use_n (bool, optional) – If True, use provided n; if False, use 4+3*log(D) (default: True)
rmp0 (float, optional) – Initial information-exchange probability, used for generation 2 before any transfer statistics exist (default: 0.3, the value the reference implementation’s driver passes to EBSGA.m)
gamma_min (float, optional) – Lower bound applied to gamma, also used in place of NaN (default: 0.0, i.e. disabled). Any value > 0 is a deliberate DEVIATION from the published algorithm: it removes the absorbing zero state described in the class docstring by guaranteeing that transfer generations keep occurring, at the cost of no longer reproducing the reference behaviour.
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EBS’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EBS Algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-Task Bayesian Optimization (MTBO)

This module implements MTBO for expensive multi-task optimization with knowledge transfer via multi-task Gaussian processes.

Cost-sensitive evaluation (paper Sec. 2.4 / 3.3): each task carries an evaluation cost c_k, and the budget is a shared amount of cost rather than a per-task count of evaluations. The next evaluation maximizes the expected improvement per unit cost, EI(x, k) / c_k, so a cheap task can absorb many evaluations while an expensive one is entered only when it is worth its price. Both are computed in log space as log EI - log c_k, LogEI being what the acquisition optimizer returns.

The default cost vector is [1, 1, …, 1]. Under equal costs there is nothing to trade off – every task buys the same information per unit budget – so the algorithm keeps the round-robin schedule of one evaluation per task per iteration, and the run is identical to the cost-unaware version, including the total number of evaluations. A non-uniform cost vector switches the loop to the paper’s rule and lets the allocation across tasks be decided by the acquisition, which means per-task evaluation counts are then an outcome rather than an input.

References

[1] Swersky, Kevin, Jasper Snoek, and Ryan P. Adams. “Multi-task bayesian optimization.” Advances in neural information processing systems 26 (2013).

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.12 Version: 2.0

class ddmtolab.Algorithms.MTSO.MTBO.MTBO(problem, n_initial=None, max_nfes=None, task_cost=None, save_data=True, save_path='./Data', name='MTBO', disable_tqdm=True)[source]

Bases: object

Multi-Task Bayesian Optimization for expensive multi-task optimization problems.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, task_cost=None, save_data=True, save_path='./Data', name='MTBO', disable_tqdm=True)[source]

Initialize Multi-Task Bayesian Optimization algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 100)
task_cost (List[float] or None, optional) –
Evaluation cost c_k of each task, e.g. the wall-clock duration of one evaluation. Defaults to equal costs [1, 1, …, 1].

The costs define a shared budget of sum(max_nfes_k * c_k) cost units, of which the initial samples already consume sum(n_initial_k * c_k). Every evaluation of task k spends c_k, and the task to evaluate next is the one maximizing EI per unit cost. Equal costs (of any magnitude) reproduce the cost-unaware schedule exactly; unequal costs let the algorithm buy more evaluations of the cheap tasks, so max_nfes then only sets the size of the budget and no longer fixes each task’s own count.

Note that max_nfes counts evaluations at unit price, so the budget scales with the costs: raising one task’s cost enlarges the budget rather than shrinking the run. To hold the budget fixed while making a task pricier, lower max_nfes to match. Note also that the cost is one term of the trade-off and not an override – a task whose expected improvement is high enough is still worth entering at several times the price.
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTBO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the Multi-Task Bayesian Optimization algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-task Max-value Bayesian Optimization (MUMBO)

This module implements MUMBO for expensive multi-task optimization. The algorithm uses an information-theoretic acquisition function based on mutual information between candidate observations and the optimal objective value g*. A multi-task Gaussian process (intrinsic coregionalization kernel, Matern 5/2 base) provides cross-task knowledge transfer, and the MUMBO acquisition exploits the bivariate predictive distribution between the target task and each candidate task through the extended skew Gaussian (ESG) form of y | g < g*. The acquisition value is divided by the evaluation cost of each task, selecting the evaluation with the largest information gain per unit cost (paper Eq. 2).

Adaptation to multi-task optimization: the paper optimizes a single objective with auxiliary information sources. Here every task must be optimized, so the target task (z0 in the paper) rotates round-robin over the tasks with remaining budget; all tasks with remaining budget act as candidate information sources at every iteration. With equal costs the target mostly evaluates itself (rho is maximal at the target, collapsing MUMBO to MES per paper Sec. 3.2) and transfer happens through the shared coregionalized GP; a cost vector shifts evaluations toward cheaper tasks via the alpha/cost ratio.

The GP is fitted on negated, per-task min-max normalized objectives (mtgp_build convention), so the paper’s maximization formulation applies verbatim in the model space while the platform minimizes.

References

[1] Moss, Henry B., David S. Leslie, and Paul Rayson. “Mumbo: Multi-task: max-value Bayesian optimization.” Joint European Conference on Machine Learning and Knowledge Discovery in Databases. Springer, 2020.
[2] Wang, Zi, and Stefanie Jegelka. “Max-value entropy search for efficient: Bayesian optimization.” ICML, 2017.

Notes

Corrected against the paper source (arXiv:2006.12093):

g* is sampled with the mean-field Gumbel method of [2] (product of posterior marginal CDFs over a random grid plus evaluated points, quantile-fitted Gumbel), not from a heuristic around the best posterior mean.
Task feature uses integer encoding float(task_id) matching mtgp_build; fractional encodings collapse distinct tasks under BoTorch’s integer cast.
The target task rotates over tasks instead of being fixed to task 0.
Acquisition candidates, g* samples (N=10) and Simpson resolution (61 points over mean +/- 4 std, paper Appendix A) use paper-scaled defaults.
task_cost only weights the acquisition ratio; the per-task evaluation budget max_nfes keeps the platform’s count-based semantics.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.17 Version: 3.0

class ddmtolab.Algorithms.MTSO.MUMBO.MUMBO(problem, n_initial=None, max_nfes=None, task_cost=None, n_gstar_samples=10, n_candidates=None, n_quad=61, n_grid=None, save_data=True, save_path='./Data', name='MUMBO', disable_tqdm=True)[source]

Bases: object

Multi-task Max-value Bayesian Optimization (MUMBO).

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements.

__init__(problem, n_initial=None, max_nfes=None, task_cost=None, n_gstar_samples=10, n_candidates=None, n_quad=61, n_grid=None, save_data=True, save_path='./Data', name='MUMBO', disable_tqdm=True)[source]

Initialize MUMBO.

Parameters:

problem (MTOP) – Multi-task optimization problem instance.
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50).
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 100).
task_cost (List[float] or None, optional) – Evaluation cost c(z) of each task. Defaults to equal costs [1, 1, …, 1]; the next evaluation maximizes the information gain per unit cost alpha(x, z) / c(z) (paper Eq. 2). Costs only weight this selection ratio; budgets stay evaluation counts.
n_gstar_samples (int, optional) – Number N of Monte Carlo g* samples per iteration (default: 10, the paper’s robust MUMBO-10 setting).
n_candidates (int, optional) – Acquisition candidates per task and iteration. Default None selects min(200 * d, 2000); 80% uniform random, 20% Gaussian perturbations around the task’s best observed solutions.
n_quad (int, optional) – Simpson integration points over mean +/- 4 std of the ESG (default: 61; forced odd).
n_grid (int, optional) – Size of the random grid for mean-field g* sampling. Default None selects min(2000 * d, 20000) (paper uses 10000 * d; reduced for runtime, configurable). Evaluated target-task points are always appended to the grid.
save_data (bool, optional) – Whether to save optimization data (default: True).
save_path (str, optional) – Path to save results (default: ‘./Data’).
name (str, optional) – Name for the experiment (default: ‘MUMBO’).
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True).

optimize()[source]

Execute MUMBO.

Returns:: Optimization results containing decision variables, objectives, and runtime.
Return type:: Results

Lower Confidence Bound-based Evolutionary Multi-Tasking (LCB-EMT)

This module implements LCB-EMT for multi-task optimization with knowledge transfer via Transfer Gaussian Process and similarity-based lower confidence bound.

References

[1] Wang, Zhenzhong, et al. “Evolutionary multitask optimization with lower confidence bound-based solution selection strategy.” IEEE Transactions on Evolutionary Computation (2024).

Notes

Verified against the paper (Wang et al., IEEE TEVC 2025). This is the vanilla multipopulation-based LCB-EMT: each task is evolved by its own GA solver, and every TGap generations the LCB-based solution-selection module transfers up to Nt solutions from a source task into the target population. The module matches the paper’s formulation:

TGP with the task-transfer kernel (Eqs. 8-9) and inter-task similarity lambda = max(2/(1+e^b) - 1, 0) learned by maximizing the marginal likelihood (Eqs. 10, 14; Algorithm 1).
SLCB(x’) = f(x’) - lambda_gen * sigma(x’) with the TGP-predicted target-task mean and uncertainty (Eq. 16), and the two-stage transfer probability of Eqs. 18-20 (Algorithm 2).

Correction: cross-task solution alignment now follows Eq. 21 – missing genes are generated randomly (not zero-padded) when the source has fewer dimensions than the target; overlong genes are truncated. In the unified [0, 1] space the bound rescaling of Eq. 21 is the identity.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.18 Version: 1.1

class ddmtolab.Algorithms.MTSO.LCB_EMT.LCB_EMT(problem, n=None, max_nfes=None, Nt=10, TGap=20, muc=2, mum=5, save_data=True, save_path='./Data', name='LCB-EMT', disable_tqdm=True)[source]

Bases: object

Lower Confidence Bound-based Evolutionary Multi-Tasking.

This algorithm uses Transfer Gaussian Process (TGP) to model task relationships and employs a Similarity-based Lower Confidence Bound (SLCB) strategy to select promising solutions for knowledge transfer between tasks.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, Nt=10, TGap=20, muc=2, mum=5, save_data=True, save_path='./Data', name='LCB-EMT', disable_tqdm=True)[source]

Initialize LCB-EMT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
Nt (int, optional) – Number of solutions to transfer per knowledge transfer operation (default: 20)
TGap (int, optional) – Transfer interval in generations (default: 20)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 2.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 5.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘LCB-EMT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the LCB-EMT algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Bayesian Optimization with Lower Confidence Bound and Competitive Knowledge Transfer (BO-LCB-CKT)

This module implements BO-LCB-CKT for expensive sequential transfer optimization problems.

Key Features: - Task 0: Target task (to be optimized) - Tasks 1:k: Source tasks (provide knowledge base) - Only task 0 is actively optimized; source tasks are pre-optimized once

References

[1] Xue, Xiaoming, et al. “Surrogate-assisted search with competitive knowledge transfer for expensive optimization.” IEEE Transactions on Evolutionary Computation (2024).

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.09 Version: 1.0

class ddmtolab.Algorithms.MTSO.BO_LCB_CKT.BO_LCB_CKT(problem, n_initial=None, max_nfes=None, gen_gap=20, ada_flag=False, save_data=True, save_path='./Data', name='BO-LCB-CKT', disable_tqdm=True)[source]

Bases: object

Bayesian Optimization with Lower Confidence Bound and Competitive Knowledge Transfer.

This algorithm optimizes task 0 (target) by leveraging knowledge from tasks 1:k (sources). Source tasks are pre-optimized once to build a knowledge base, then only the target task is optimized with competitive knowledge transfer.

Now supports tasks with different dimensions using space_transfer.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, gen_gap=20, ada_flag=False, save_data=True, save_path='./Data', name='BO-LCB-CKT', disable_tqdm=True)[source]

Initialize BO-LCB-CKT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance. Task 0 is the target task, tasks 1:k are source tasks.
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50, as in the reference implementation)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: [500, 100, 100, …]) - First value: budget for target task (task 0), 500 in the paper - Remaining values: budget for source tasks
gen_gap (int, optional) – Knowledge transfer trigger interval in true evaluations (default: 20, matching paras.interval in the reference code)
ada_flag (bool, optional) – Whether to enable task adaptation (default: False)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘BO-LCB-CKT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the BO-LCB-CKT algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

BO-LCB-BCKT: Bayesian Optimization with Lower Confidence Bound and Bayesian Competitive Knowledge Transfer

This module implements BO-LCB-BCKT for expensive multi-task optimization problems.

References

[1] Lu, Yi, et al. “Multi-Task Surrogate-Assisted Search with Bayesian Competitive Knowledge Transfer for Expensive Optimization.” arXiv preprint arXiv:2510.23407 (2025).

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.09 Version: 2.0

class ddmtolab.Algorithms.MTSO.BO_LCB_BCKT.BO_LCB_BCKT(problem, n_initial=None, max_nfes=None, gen_gap=10, sigma_I_sq=0.0025000000000000005, padding='zero', save_data=True, save_path='./Data', name='BO-LCB-BCKT', disable_tqdm=True)[source]

Bases: object

BO-LCB-BCKT algorithm for expensive multi-task optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, gen_gap=10, sigma_I_sq=0.0025000000000000005, padding='zero', save_data=True, save_path='./Data', name='BO-LCB-BCKT', disable_tqdm=True)[source]

Initialize BO-LCB-BCKT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance (all tasks optimized simultaneously, unlike the sequential-transfer CKT variant).
n_initial (int, optional) – Number of initial samples per task (default: 50, matching the reference implementation)
max_nfes (int, optional) – Maximum number of function evaluations per task, including the initial samples (default: 200, matching FEsMax = 200 x T in the reference code)
gen_gap (int, optional) – Knowledge transfer trigger interval per task in true evaluations; the total-FE interval is n_tasks * gen_gap as in the reference code (default: 10)
sigma_I_sq (float, optional) – Observation variance of the similarity measurements in the conjugate Gaussian model of transferability (default: 0.05**2)
padding (str, optional) – Padding mode for the unified search space (default: ‘zero’)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘BO-LCB-BCKT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the BO-LCB-BCKT algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Evolutionary Expected Improvement based Bayesian Optimization for MTOPs (EEI-BO+)

Multi-task extension of EEI-BO. Each task keeps its own GP surrogate and its own persistent CMA-ES search distribution, which advances one generation per BO iteration. Knowledge is transferred by periodically letting one task’s EEI be guided by another task’s CMA-ES distribution: every switch_interval no-transfer iterations, a single transfer iteration replaces each task’s own search distribution with the (dimension-adapted) distribution of another task, following the reference’s global 6-no-transfer / 1-transfer schedule.

References

[1] J. Liu, Y. Wang, G. Sun, and T. Pang, “Solving Highly Expensive: Optimization Problems via Evolutionary Expected Improvement,” IEEE Transactions on Systems, Man, and Cybernetics: Systems, vol. 53, no. 8, pp. 4843-4855, 2023.

Notes

Corrected against the reference implementation (MT-EEI-BO, v2.0):

Persistent per-task CMA-ES advancing one generation per iteration (was a full CMA-ES restart every iteration); shares the ST-EEI-BO components.
A single global transfer schedule shared by all tasks (was tracked per task and could desync): switch_interval no-transfer iterations then one transfer iteration, repeating.
Transfer uses the other task’s CMA-ES distribution snapshot from the same iteration (all tasks advance CMA-ES first, then all tasks query), matching the reference’s two-pass structure.
Cross-task distribution mapping is dimension pad/truncation in the unified [0, 1] space (the reference’s bound rescaling is the identity there).
EEI maximized in log space; see EEI_BO for the shared acquisition details.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.18 Version: 2.0

class ddmtolab.Algorithms.MTSO.EEI_BO_plus.EEI_BO_plus(problem, n_initial=None, max_nfes=None, switch_interval=6, cma_popsize=100, sigma0=0.5, n2=30, max_nfes2=6000, save_data=True, save_path='./Data', name='EEI-BO+', disable_tqdm=True)[source]

Bases: object

Evolutionary Expected Improvement based Bayesian Optimization for MTOPs.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, switch_interval=6, cma_popsize=100, sigma0=0.5, n2=30, max_nfes2=6000, save_data=True, save_path='./Data', name='EEI-BO+', disable_tqdm=True)[source]

Initialize EEI-BO+ algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 100)
switch_interval (int, optional) – Number of no-transfer iterations between transfer iterations (default: 6, the reference’s 6-no-transfer / 1-transfer schedule)
cma_popsize (int, optional) – Number of surrogate-ranked samples per CMA-ES generation (default: 100)
sigma0 (float, optional) – Initial CMA-ES step size in the [0, 1] space (default: 0.5)
n2 (int, optional) – Population size of the DE that maximizes EEI (default: 30)
max_nfes2 (int, optional) – Function evaluations of the DE that maximizes EEI (default: 6000)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EEI-BO+’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute EEI-BO+.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Block-Level Knowledge Transfer DE (BLKT-DE)

This module implements BLKT-DE for multi-task optimization using block-level decision variable decomposition with k-means clustering for cross-task knowledge transfer.

References

[1] Jiang, Yi, et al. “Block-Level Knowledge Transfer for Evolutionary: Multitask Optimization.” IEEE Transactions on Cybernetics, 1-14, 2023.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.BLKT_DE.BLKT_DE(problem, n=None, max_nfes=None, F=0.5, CR=0.7, save_data=True, save_path='./Data', name='BLKT-DE', disable_tqdm=True)[source]

Bases: object

Block-Level Knowledge Transfer DE.

Decomposes decision variables into fixed-size blocks, clusters them across all tasks and individuals using k-means, then performs DE/rand/1 within each cluster for cross-task knowledge transfer. Combined with standard DE/rand/1/bin offspring per task.

Adaptive block size (divD) and cluster count (divK) based on per-task improvement: full reset if all tasks stagnate, slight perturbation if some tasks stagnate, no change if all improve.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, F=0.5, CR=0.7, save_data=True, save_path='./Data', name='BLKT-DE', disable_tqdm=True)[source]

Initialize BLKT-DE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
F (float, optional) – DE mutation scale factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.7)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘BLKT-DE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the BLKT-DE algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Distribution Direction-Assisted Two-Stage Knowledge Transfer (DTSKT)

This module implements DTSKT for many-task single-objective optimization with distribution-based two-stage knowledge transfer.

References

[1] Zhang, Tingyu, et al. “Distribution Direction-Assisted Two-Stage Knowledge: Transfer for Many-Task Optimization.” IEEE Transactions on Systems, Man, and Cybernetics: Systems (2025): 1-15.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.DTSKT.DTSKT(problem, n=None, max_nfes=None, A=0.35, beta=0.6, rmp=0.5, topn=2, save_data=True, save_path='./Data', name='DTSKT', disable_tqdm=True)[source]

Bases: object

Distribution Direction-Assisted Two-Stage Knowledge Transfer for Many-Task Optimization.

Uses Gaussian EDA with two-stage knowledge transfer: - Exploring stage: shifts sampling mean along the best source task’s search path - Exploiting stage: uses combined source-target distribution for refined search

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, A=0.35, beta=0.6, rmp=0.5, topn=2, save_data=True, save_path='./Data', name='DTSKT', disable_tqdm=True)[source]

Initialize DTSKT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance (all tasks must have equal dimensions)
n (int, optional) – Population size per task (default: 200)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
A (float, optional) – Elite ratio for weighted mean computation (default: 0.35)
beta (float, optional) – Stage transition ratio - fraction of budget for exploring stage (default: 0.6)
rmp (float, optional) – Probability of knowledge transfer in offspring generation (default: 0.5)
topn (int, optional) – Number of top source tasks for multi-source transfer (default: 2)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘DTSKT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the DTSKT algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Evolutionary Multi-Task Optimization with Adaptive Intensity (EMTO-AI)

This module implements EMTO-AI for multi-task optimization with adaptive knowledge transfer intensity based on cross-task competitiveness evaluation.

References

[1] Zhou, Xinyu, et al. “Evolutionary Multi-Task Optimization With Adaptive: Intensity of Knowledge Transfer.” IEEE Transactions on Emerging Topics in Computational Intelligence, 1-13, 2024.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.EMTO_AI.EMTO_AI(problem, n=None, max_nfes=None, F=0.5, CR=0.6, rate=0.05, gap_gen=35, save_data=True, save_path='./Data', name='EMTO-AI', disable_tqdm=True)[source]

Bases: object

Evolutionary Multi-Task Optimization with Adaptive Intensity of Knowledge Transfer.

Uses a DE-based multi-factorial framework with:

Per-task elite archives for inter-task knowledge transfer
DE mutation with archive base vector for transfer, DE/rand/1 for intra-task
Binomial crossover
Adaptive transfer intensity (rmp) updated periodically by cross-evaluating each task’s subpopulation on other tasks and measuring competitiveness

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, F=0.5, CR=0.6, rate=0.05, gap_gen=35, save_data=True, save_path='./Data', name='EMTO-AI', disable_tqdm=True)[source]

Initialize EMTO-AI algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
F (float, optional) – DE mutation scale factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.6)
rate (float, optional) – Archive size as fraction of per-task population (default: 0.05)
gap_gen (int, optional) – Generation interval for transfer intensity update (default: 35)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EMTO-AI’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EMTO-AI algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multifactorial Evolutionary Algorithm with Adaptive Knowledge Transfer (MFEA-AKT)

This module implements MFEA-AKT for multi-task optimization with adaptive crossover operator selection for inter-task knowledge transfer.

References

[1] Zhou, Lei, et al. “Toward Adaptive Knowledge Transfer in Multifactorial: Evolutionary Computation.” IEEE Transactions on Cybernetics, 51(5): 2563-2576, 2021.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.MFEA_AKT.MFEA_AKT(problem, n=None, max_nfes=None, rmp=0.3, gap=20, muc=2, mum=5, save_data=True, save_path='./Data', name='MFEA-AKT', disable_tqdm=True)[source]

Bases: object

Multifactorial Evolutionary Algorithm with Adaptive Knowledge Transfer.

Extends MFEA with 6 crossover operators for inter-task transfer and an adaptive mechanism to select the best operator based on improvement tracking.

The 6 crossover operators are:: 0: Two-point crossover 1: Uniform crossover 2: Arithmetical crossover (r=0.25) 3: Geometric crossover (r=0.2) 4: BLX-alpha crossover (a=0.3) 5: SBX crossover

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, rmp=0.3, gap=20, muc=2, mum=5, save_data=True, save_path='./Data', name='MFEA-AKT', disable_tqdm=True)[source]

Initialize MFEA-AKT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability for inter-task crossover (default: 0.3)
gap (int, optional) – History window size for operator selection fallback (default: 20)
muc (float, optional) – Distribution index for SBX crossover (default: 2)
mum (float, optional) – Distribution index for polynomial mutation (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MFEA-AKT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MFEA-AKT algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multifactorial Evolutionary Algorithm Based on Diffusion Gradient Descent (MFEA-DGD)

This module implements MFEA-DGD for multi-task optimization using gradient estimation via finite differences with random orthogonal directions.

References

[1] Liu, Zhaobo, et al. “Multifactorial Evolutionary Algorithm Based on: Diffusion Gradient Descent.” IEEE Transactions on Cybernetics, 1-13, 2023.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.MFEA_DGD.MFEA_DGD(problem, n=None, max_nfes=None, rmp=0.7, gamma=0.1, save_data=True, save_path='./Data', name='MFEA-DGD', disable_tqdm=True)[source]

Bases: object

Multifactorial Evolutionary Algorithm Based on Diffusion Gradient Descent.

Uses gradient estimation via random finite differences to guide crossover and mutation operators: - Random perturbation direction from Gaussian distribution - Finite-difference gradient estimation per parent pair - Gradient-guided blend crossover with opposition-based learning (OBL) - Gradient descent mutation for non-transfer offspring - Adaptive sigma randomly selected each generation

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

Notes

One generation costs 4 * n * n_tasks + 2 evaluations: two probes per parent per pair for the finite-difference gradient (2 * n * n_tasks), the main offspring (n * n_tasks), and the surviving probe buffer that the reference implementation re-evaluates together with the offspring (n * n_tasks + 2).

__init__(problem, n=None, max_nfes=None, rmp=0.7, gamma=0.1, save_data=True, save_path='./Data', name='MFEA-DGD', disable_tqdm=True)[source]

Initialize MFEA-DGD algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability for inter-task crossover (default: 0.7)
gamma (float, optional) – Smoothing factor for gradient norm tracking (default: 0.1)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MFEA-DGD’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MFEA-DGD algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multifactorial Evolutionary Algorithm with Single-Step Generative Model (MFEA-SSG)

This module implements MFEA-SSG for expensive multi-task optimization using a diffusion-based generative model with knowledge distillation for single-step inference.

References

[1] R. Wang, X. Feng, H. Yu, Y. Tan, and E. M. K. Lai, “Meta-Learning Inspired Single-Step Generative Model for Expensive Multitask Optimization Problems,” IEEE Transactions on Evolutionary Computation, 2025.

Notes

Reproduction of paper Table II (CEC17-MTSO, 20 runs): use n=50 (the paper’s “population size 100” counts the population shared across both tasks) and max_nfes=400 with the remaining defaults. The paper text states E=5 training epochs, but each refinement sees at most one mini-batch (elites < batch_size), so 5 epochs = 5 gradient steps per refinement; 50 epochs per refinement with cumulative (progressive) training is required to reach the reported accuracy.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.01 Version: 1.1

class ddmtolab.Algorithms.MTSO.MFEA_SSG.MFEA_SSG(problem, n_initial=None, max_nfes=None, rmp=0.3, muc=2, mum=5, max_gen=None, refine_freq=1, n_pairs_per_gen=None, n_diffusion_steps=100, train_epochs=50, distill_epochs=50, batch_size=512, lr=0.0005, base_ch=64, save_data=True, save_path='./Data', name='MFEA-SSG', disable_tqdm=True, n=None)[source]

Bases: object

Multifactorial Evolutionary Algorithm with Single-Step Generative Model.

Follows the MFEA architecture with a diffusion-based generative model replacing crossover in early generations. Knowledge distillation compresses the teacher model into a lightweight student for single-step inference.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, rmp=0.3, muc=2, mum=5, max_gen=None, refine_freq=1, n_pairs_per_gen=None, n_diffusion_steps=100, train_epochs=50, distill_epochs=50, batch_size=512, lr=0.0005, base_ch=64, save_data=True, save_path='./Data', name='MFEA-SSG', disable_tqdm=True, n=None)[source]

Initialize MFEA-SSG algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int, optional) – Size of the initial design evaluated per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability (default: 0.3)
muc (float, optional) – Distribution index for SBX crossover (default: 2)
mum (float, optional) – Distribution index for polynomial mutation (default: 5)
max_gen (int, optional) – Maximum generation for generative phase. By default the generative model drives the search for the entire run (paper Fig. 4 shows the student model still active at Gen=100 under the 400-FE budget); pass a value to switch to pure GA crossover after that generation.
refine_freq (int, optional) – Refinement frequency tau for generative model (default: 1)
n_pairs_per_gen (int, optional) – Number of parent pairs bred per generation; each pair costs one true evaluation on the generative branch and two on the GA branch (default: None, i.e. one pair per task)
n_diffusion_steps (int, optional) – Number of diffusion timesteps N (default: 100)
train_epochs (int, optional) – Training epochs for teacher model (default: 50)
distill_epochs (int, optional) – Knowledge distillation epochs (default: 50)
batch_size (int, optional) – Mini-batch size for training (default: 512)
lr (float, optional) – Learning rate for Adam optimizer (default: 5e-4)
base_ch (int, optional) – Base channel count for U-Net models (default: 64)
n (int, optional) – Deprecated spelling of n_initial, still accepted
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MFEA-SSG’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MFEA-SSG algorithm (Algorithm 1 in paper).

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multifactorial Evolutionary Algorithm with Variational Crossover (MFEA-VC)

This module implements MFEA-VC for multi-task optimization using a contrastive Variational Auto-Encoder (VAE) to guide knowledge transfer in early generations.

References

[1] Wang, Ruilin, et al. “Contrastive Variational Auto-Encoder Driven: Convergence Guidance in Evolutionary Multitasking.” Applied Soft Computing, 163: 111883, 2024.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.MFEA_VC.MFEA_VC(problem, n=None, max_nfes=None, rmp=0.3, muc=2, mum=5, vae_gens=25, lam=0.8, save_data=True, save_path='./Data', name='MFEA-VC', disable_tqdm=True)[source]

Bases: object

Multifactorial Evolutionary Algorithm with Variational Crossover.

Uses a VAE (with random weights, no training) to generate cross-task individuals for the first vae_gens generations. The VAE encodes both tasks’ population data into a shared latent space and decodes to produce mixed-task offspring used as SBX crossover partners.

After vae_gens generations, reverts to standard MFEA behavior with SBX crossover and polynomial mutation.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, rmp=0.3, muc=2, mum=5, vae_gens=25, lam=0.8, save_data=True, save_path='./Data', name='MFEA-VC', disable_tqdm=True)[source]

Initialize MFEA-VC algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability (default: 0.3)
muc (float, optional) – Distribution index for SBX crossover (default: 2)
mum (float, optional) – Distribution index for polynomial mutation (default: 5)
vae_gens (int, optional) – Number of generations to use VAE-guided crossover (default: 25)
lam (float, optional) – Lambda scaling factor for VAE latent space (default: 0.8)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MFEA-VC’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MFEA-VC algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multitask Differential Evolution with Adaptive Dual Knowledge Transfer (MTDE-ADKT)

This module implements MTDE-ADKT for multi-task optimization using SHADE-based adaptive parameters, distribution-aligned knowledge transfer, and adaptive transfer probability control.

References

[1] Zhang, Tingyu, et al. “Multitask Differential Evolution with Adaptive: Dual Knowledge Transfer.” Applied Soft Computing, 165: 112040, 2024.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.MTDE_ADKT.MTDE_ADKT(problem, n=None, max_nfes=None, P=0.1, H=100, Gap=50, Alpha=0.25, RMP0=0.15, Beta=0.9, TGap=1, save_data=True, save_path='./Data', name='MTDE-ADKT', disable_tqdm=True)[source]

Bases: object

Multitask DE with Adaptive Dual Knowledge Transfer.

Combines SHADE-based adaptive F/CR with two knowledge transfer modes: - Type 1: Distribution-aligned transfer via covariance whitening/coloring - Type 2: Direct transfer from source task - Type 3: Standard DE/current-to-pbest/1 (no transfer)

Transfer probabilities (RMP1, RMP2) are adaptively adjusted based on the relative success rates of each transfer type.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, P=0.1, H=100, Gap=50, Alpha=0.25, RMP0=0.15, Beta=0.9, TGap=1, save_data=True, save_path='./Data', name='MTDE-ADKT', disable_tqdm=True)[source]

Initialize MTDE-ADKT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
P (float, optional) – Top P fraction for pbest selection (default: 0.1)
H (int, optional) – SHADE success history memory size (default: 100)
Gap (int, optional) – RMP adaptation period in generations (default: 50)
Alpha (float, optional) – Population reduction timing as fraction of budget (default: 0.25)
RMP0 (float, optional) – Initial random mating probability (default: 0.15)
Beta (float, optional) – EMA smoothing factor for centroid tracking (default: 0.9)
TGap (int, optional) – Transfer frequency: transfer every TGap generations (default: 1)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTDE-ADKT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTDE-ADKT algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-Task Evolutionary Algorithm with Hierarchical Knowledge Transfer Strategy (MTEA-HKTS)

This module implements MTEA-HKTS for multi-task optimization using KLD-based variable ordering, adaptive knowledge transfer with hierarchical strategy selection, and alternating GA/DE operators.

References

[1] Zhao, Ben, et al. “A Multi-Task Evolutionary Algorithm for Solving: the Problem of Transfer Targets.” Information Sciences, 681: 121214, 2024.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.MTEA_HKTS.MTEA_HKTS(problem, n=None, max_nfes=None, pTransfer=0.5, mu=2, mum=5, F=0.5, CR=0.5, minx=0.1, Lb=0.1, Ub=0.7, save_data=True, save_path='./Data', name='MTEA-HKTS', disable_tqdm=True)[source]

Bases: object

Multi-Task EA with Hierarchical Knowledge Transfer Strategy.

Uses KLD-based decision variable alignment across tasks, adaptive transfer probability control via a task selection table, and alternating GA (SBX+PM) / DE (rand/1/bin) operators.

Three operation modes per generation: - sign=0 (10%): Separate transferred population evaluated independently - sign=1 (9%): Transferred individuals replace worst, standard GA/DE - sign=2 (81%): Transferred individuals in temp pop, cross-population GA/DE

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, pTransfer=0.5, mu=2, mum=5, F=0.5, CR=0.5, minx=0.1, Lb=0.1, Ub=0.7, save_data=True, save_path='./Data', name='MTEA-HKTS', disable_tqdm=True)[source]

Initialize MTEA-HKTS algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
pTransfer (float, optional) – Initial transfer portion (default: 0.5)
mu (float, optional) – SBX crossover distribution index (default: 2)
mum (float, optional) – Polynomial mutation distribution index (default: 5)
F (float, optional) – DE mutation factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.5)
minx (float, optional) – Minimum scale boundary (default: 0.1)
Lb (float, optional) – Lower bound for transfer probability (default: 0.1)
Ub (float, optional) – Upper bound for transfer probability (default: 0.7)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTEA-HKTS’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTEA-HKTS algorithm.

Returns:: Optimization results
Return type:: Results

Multi-Task Evolutionary Algorithm with Progressive Auto-Encoding (MTEA-PAE)

This module implements MTEA-PAE for multi-task optimization using kernelized autoencoding (NFC) for cross-task knowledge transfer with adaptive operator and transfer type selection.

References

[1] Gu, Qiong, et al. “Progressive Auto-Encoding for Domain Adaptation: in Evolutionary Multi-Task Optimization.” Applied Soft Computing, 113916, 2025.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.MTEA_PAE.MTEA_PAE(problem, n=None, max_nfes=None, Seg=10, TNum=20, TGap=5, F=0.5, CR=0.9, MuC=2, MuM=5, save_data=True, save_path='./Data', name='MTEA-PAE', disable_tqdm=True)[source]

Bases: object

Multi-Task Evolutionary Algorithm with Progressive Auto-Encoding.

Uses kernelized autoencoding (NFC) for cross-task knowledge transfer with two transfer strategies: segment transfer (using current distribution) and stochastic replacement transfer (using archive). Adaptive selection between DE/rand/1/bin and GA (SBX+PM) for offspring generation.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, Seg=10, TNum=20, TGap=5, F=0.5, CR=0.9, MuC=2, MuM=5, save_data=True, save_path='./Data', name='MTEA-PAE', disable_tqdm=True)[source]

Initialize MTEA-PAE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
Seg (int, optional) – Number of segments for distribution snapshots (default: 10)
TNum (int, optional) – Number of solutions to transfer (default: 20)
TGap (int, optional) – Generation gap between transfers (default: 5)
F (float, optional) – DE mutation scale factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.9)
MuC (float, optional) – SBX distribution index (default: 2)
MuM (float, optional) – PM distribution index (default: 5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTEA-PAE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTEA-PAE algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multi-Task Evolution Strategy with Knowledge-Guided External Sampling (MTES-KG)

This module implements the MTES-KG algorithm for multi-task single-objective optimization. The algorithm extends CMA-ES with two types of knowledge-guided external sampling across tasks: DoS (Domain of Solution knowledge) and SaS (Shape of function knowledge), along with adaptive negative transfer mitigation.

References

[1] Y. Li, W. Gong, and S. Li. “Multitask Evolution Strategy With Knowledge-Guided External: Sampling.” IEEE Transactions on Evolutionary Computation, 28(6): 1733-1745, 2024.

Notes

The code is developed in accordance with the MATLAB-based MTO-platform framework.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.21 Version: 1.0

class ddmtolab.Algorithms.MTSO.MTES_KG.MTES_KG(problem, n=None, max_nfes=None, tau0=2, alpha=0.5, adj_gap=50, sigma0=0.3, save_data=True, save_path='./Data', name='MTES-KG', disable_tqdm=True)[source]

Bases: object

Multi-Task Evolution Strategy with Knowledge-Guided External Sampling.

Each task maintains an independent CMA-ES instance. Knowledge transfer between tasks is achieved through external samples generated via two strategies:

DoS (Domain of Solution knowledge): Samples from an auxiliary task’s distribution, projected to within the current task’s neighborhood
SaS (Shape of function knowledge): Transfers the search direction from an auxiliary task’s successful solutions using CMA-ES coordinate system transformation

An adaptive mechanism adjusts the number of external samples (tau) to mitigate negative transfer.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, tau0=2, alpha=0.5, adj_gap=50, sigma0=0.3, save_data=True, save_path='./Data', name='MTES-KG', disable_tqdm=True)[source]

Initialize MTES-KG algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size (lambda) per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
tau0 (int, optional) – Initial external sample number per task (default: 2)
alpha (float, optional) – Probability of using DoS vs SaS for external sampling (default: 0.5)
adj_gap (int, optional) – Generation gap for adjusting tau (default: 50)
sigma0 (float, optional) – Initial step size for CMA-ES (default: 0.3)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTES-KG’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTES-KG algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

SaEF-AKT: Surrogate-Assisted Evolutionary Framework with Adaptive Knowledge Transfer

This module implements SaEF-AKT for expensive multi-task single-objective optimization.

References

[1] Z. Huang, J. Zhong, and W. N. N. Yu, “Surrogate-Assisted Evolutionary Framework with Adaptive Knowledge Transfer for Multi-Task Optimization,” IEEE Trans. Emerg. Topics Comput., vol. 9, no. 4, pp. 1930-1944, 2021.

Notes

Verified against the paper (v1.1). Structure matches Algorithm 2 and the component equations: local GP on the NC nearest + NR most-recent points, merit functions f_M = t_hat - g*s_t with g in {0, 1, 2, 4} optimized inside the hypercube around x_best (Eqs. 15-16), KLD similarity between the training-data normal distributions (Eq. 21), Softmax-normalized reciprocal similarity (Eqs. 23-24), pheromone/similarity transfer selection (Eqs. 22, 25), and pheromone volatilize/reward/clamp (Eqs. 26-28). Default parameters follow the paper: NC = NR = 60, Phe_a = 0.1, Phe_max = 1.0, Phe_min = 0.01, P_max = 0.9, DE population 15 with 2000 merit evaluations.

Correction: the GPOP phase now evaluates the optima of all four merit functions with the true fitness each generation (the defining exploration mechanism of GPOP), instead of the previous single best-predicted candidate.

Deliberate substitutions (inner-solver / modeling choices that do not change the algorithm’s semantics): the merit functions and GP hyper-parameters are optimized with the platform’s DE / botorch’s L-BFGS rather than the paper’s JADE, and the GP uses botorch’s default Matern 5/2 kernel rather than the paper’s squared-exponential-with-periodic kernel (more robust on general, non-periodic landscapes).

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.07.18 Version: 1.1

class ddmtolab.Algorithms.MTSO.SaEF_AKT.SaEF_AKT(problem, n_initial=None, max_nfes=None, NC=60, NR=60, Phe_a=0.1, Phe_max=1.0, Phe_min=0.01, P_max=0.9, g_values=None, de_pop=15, de_merit_evals=2000, save_data=True, save_path='./Data', name='SaEF-AKT', disable_tqdm=True)[source]

Bases: object

Surrogate-Assisted Evolutionary Framework with Adaptive Knowledge Transfer.

This algorithm features: - Local Gaussian Process modeling (NC nearest + NR recent points) - Multiple merit functions with different exploration-exploitation balance (g = 0, 1, 2, 4) - DE-based optimization of merit functions on GP surrogate - KL divergence-based task similarity measurement - Pheromone-based adaptive auxiliary task selection for knowledge transfer

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, NC=60, NR=60, Phe_a=0.1, Phe_max=1.0, Phe_min=0.01, P_max=0.9, g_values=None, de_pop=15, de_merit_evals=2000, save_data=True, save_path='./Data', name='SaEF-AKT', disable_tqdm=True)[source]

Initialize SaEF-AKT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 50)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 100)
NC (int, optional) – Number of nearest neighbor points for local GP (default: 60)
NR (int, optional) – Number of most recent evaluation points for local GP (default: 60)
Phe_a (float, optional) – Pheromone evaporation rate (default: 0.1)
Phe_max (float, optional) – Maximum pheromone concentration (default: 1.0)
Phe_min (float, optional) – Minimum pheromone concentration (default: 0.01)
P_max (float, optional) – Probability of selecting the task with maximum transfer probability (default: 0.9)
g_values (list of float, optional) – Exploration weights for merit functions (default: [0, 1, 2, 4])
de_pop (int, optional) – DE population size for merit function optimization (default: 15)
de_merit_evals (int, optional) – Max DE evaluations for merit function optimization (default: 2000)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SaEF-AKT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SaEF-AKT algorithm.

The main loop follows Algorithm 3 in the paper: Phase 1: GPOP search + real evaluation for each task (1 FE per task) Phase 2: Similarity measurement via KL divergence on updated databases Phase 3: Knowledge transfer + pheromone update for each task (1 FE per task)

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Scenario-based Self-Learning Transfer Differential Evolution (SSLT-DE)

This module implements SSLT-DE for multi-task optimization using a DQN-based reinforcement learning framework to adaptively select among four knowledge transfer scenarios.

References

[1] Z. Yuan, G. Dai, L. Peng, M. Wang, Z. Song, and X. Chen, “Scenario-based: self-learning transfer framework for multi-task optimization problems,” Knowledge-Based Systems, vol. 325, p. 113824, 2025.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.SSLT_DE.SSLT_DE(problem, n=None, max_nfes=None, threshold=150, gap=50, gamma=0.9, epsilon=0.8, F=0.5, CR=0.9, save_data=True, save_path='./Data', name='SSLT-DE', disable_tqdm=True)[source]

Bases: object

Scenario-based Self-Learning Transfer Differential Evolution.

Uses a DQN-based reinforcement learning framework to adaptively select among four knowledge transfer scenarios: 1. No transfer (standard DE/rand/1/bin) 2. Shape transfer (shift smoothed source toward target center) 3. Bi-directional transfer (DE on merged populations) 4. Domain transfer (direction-guided from best source-target difference)

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, threshold=150, gap=50, gamma=0.9, epsilon=0.8, F=0.5, CR=0.9, save_data=True, save_path='./Data', name='SSLT-DE', disable_tqdm=True)[source]

Initialize SSLT-DE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
threshold (int, optional) – Number of generations before building DQN (default: 150)
gap (int, optional) – DQN update interval in generations (default: 50)
gamma (float, optional) – Discount factor for Q-learning (default: 0.9)
epsilon (float, optional) – Epsilon-greedy exploration rate (default: 0.8)
F (float, optional) – DE mutation scale factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.9)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SSLT-DE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SSLT-DE algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Transfer Task-averaged Natural Gradient - Separable NES (TNG-SNES)

This module implements TNG-SNES for many-task single-objective optimization using separable Natural Evolution Strategy with task-averaged gradient transfer.

References

[1] Li, Yanchi, et al. “Transfer Task-averaged Natural Gradient for Efficient: Many-task Optimization.” IEEE Transactions on Evolutionary Computation, 29(5): 1952-1965, 2025.

Notes

Author: Jiangtao Shen (DDMTOLab adaptation) Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTSO.TNG_SNES.TNG_SNES(problem, n=None, max_nfes=None, sigma0=0.3, rho0=0.1, alpha0=0.7, adj_gap=100, save_data=True, save_path='./Data', name='TNG-SNES', disable_tqdm=True)[source]

Bases: object

Transfer Task-averaged Natural Gradient for Many-Task Optimization (Separable NES).

Uses separable NES with task-averaged natural gradient for knowledge transfer: - Each task maintains a Gaussian distribution N(x, diag(S^2)) - Natural gradients are computed from fitness-ranked utility weights - Task-averaged gradient is transferred with adaptive utilization rate (rho) - Adaptive transfer control adjusts rho and alpha via virtual parameter comparison

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, sigma0=0.3, rho0=0.1, alpha0=0.7, adj_gap=100, save_data=True, save_path='./Data', name='TNG-SNES', disable_tqdm=True)[source]

Initialize TNG-SNES algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
sigma0 (float, optional) – Initial standard deviation for all dimensions (default: 0.3)
rho0 (float, optional) – Initial utilization factor for gradient transfer (default: 0.1)
alpha0 (float, optional) – Initial transfer rate / probability (default: 0.7)
adj_gap (int, optional) – Generation interval for adaptive transfer control (default: 100)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘TNG-SNES’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the TNG-SNES algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Multitask Multiobjective (MTMO)

Multiobjective Multifactorial Evolutionary Algorithm (MO-MFEA)

This module implements MO-MFEA for multi-objective multi-task optimization with knowledge transfer.

References

[1] Gupta, Abhishek, Yew-Soon Ong, Liang Feng, and Kay Chen Tan. “Multiobjective Multifactorial Optimization in Evolutionary Multitasking.” IEEE Transactions on Cybernetics 47, no. 7 (2017): 1652-1665.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.27 Version: 1.1

class ddmtolab.Algorithms.MTMO.MO_MFEA.MO_MFEA(problem, n=None, max_nfes=None, rmp=0.3, muc=20.0, mum=15.0, save_data=True, save_path='./Data', name='MO-MFEA', disable_tqdm=True)[source]

Bases: object

Multiobjective Multifactorial Evolutionary Algorithm for multi-objective multi-task optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, rmp=0.3, muc=20.0, mum=15.0, save_data=True, save_path='./Data', name='MO-MFEA', disable_tqdm=True)[source]

Initialize MO-MFEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability for inter-task crossover (default: 0.3)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 15.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MO-MFEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MO-MFEA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multiobjective Multifactorial Evolutionary Algorithm With Online Transfer Parameter Estimation (MO-MFEA-II)

This module implements MO-MFEA-II for multi-objective multi-task optimization with knowledge transfer.

References

[1] Bali, Kavitesh Kumar, Abhishek Gupta, Yew-Soon Ong, and Puay Siew Tan. “Cognizant Multitasking in Multiobjective Multifactorial Evolution: MO-MFEA-II.” IEEE Transactions on Cybernetics 51, no. 4 (2021): 1784-1796.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.16 Version: 1.1

class ddmtolab.Algorithms.MTMO.MO_MFEA_II.MO_MFEA_II(problem, n=None, max_nfes=None, muc=20.0, mum=15.0, swap=0.5, save_data=True, save_path='./Data', name='MO-MFEA-II', disable_tqdm=True)[source]

Bases: object

Multiobjective Multifactorial Evolutionary Algorithm With Online Transfer Parameter Estimation.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, muc=20.0, mum=15.0, swap=0.5, save_data=True, save_path='./Data', name='MO-MFEA-II', disable_tqdm=True)[source]

Initialize MO-MFEA-II.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 15.0)
swap (float, optional) – Variable swap probability of the uniform crossover applied to the two children of an assortative mating (default: 0.5)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MO-MFEA-II’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MO-MFEA-II algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multiobjective Evolutionary Multitasking via Explicit Autoencoding (MO-EMEA)

This module implements the MO_EMEA algorithm for multi-task multi-objective optimization problems with knowledge transfer.

References

[1] L. Feng, L. Zhou, J. Zhong, A. Gupta, Y. -S. Ong, K. -C. Tan, and A. K. Qin. “Evolutionary Multitasking via Explicit Autoencoding.” IEEE Transactions on Cybernetics, 49(9): 3457-3470, 2019.

Notes

The code is developed in accordance with the MATLAB-based MTO-platform framework.

Author: Jing Wang Email: Date: 2026.01.09 Version: 1.0

class ddmtolab.Algorithms.MTMO.MO_EMEA.MO_EMEA(problem, n=None, max_nfes=None, operator='SP/NS', s_num=None, t_gap=None, mu_c=None, mu_m=None, save_data=True, save_path='./Data', name='MO-EMEA', disable_tqdm=True)[source]

Bases: object

Multi-task Multi-objective Evolutionary Multitasking via Explicit Autoencoding (MO_EMEA).

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, operator='SP/NS', s_num=None, t_gap=None, mu_c=None, mu_m=None, save_data=True, save_path='./Data', name='MO-EMEA', disable_tqdm=True)[source]

Initialize MO-EMEA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
operator (str, optional) –
Selection operator(s) split with ‘/’, e.g., ‘SP/NS’ (default: ‘SP/NS’)
- ’SP’: SPEA2 selection
- ’NS’: NSGA-II selection
s_num (int, optional) – Number of solutions for knowledge transfer (default: 10)
t_gap (int, optional) – Generation gap for knowledge transfer (default: 10)
mu_c (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20)
mu_m (float, optional) – Distribution index for polynomial mutation (PM) (default: 15)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MO-EMEA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute MO_EMEA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints and runtime
Return type:: Results

Multi-objective Multi-task Evolutionary Algorithm with Self-adaptive Solvers (MO-MTEA-SaO)

This module implements MO-MTEA-SaO for multi-task multi-objective optimization problems.

References

[1] Li, Yanchi, Wenyin Gong, and Shuijia Li. “Multitasking Optimization via an Adaptive Solver Multitasking Evolutionary Framework.” Information Sciences (2022).

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.18 Version: 1.0

class ddmtolab.Algorithms.MTMO.MO_MTEA_SaO.MO_MTEA_SaO(problem, n=None, max_nfes=None, t_gap=10, t_num=10, sa_gap=70, memory=30, ga_muc=20.0, ga_mum=15.0, de_f=0.5, de_cr=0.9, save_data=True, save_path='./Data', name='MO-MTEA-SaO', disable_tqdm=True)[source]

Bases: object

Multi-objective Multi-task Evolutionary Algorithm with Self-adaptive Solvers.

This algorithm features:

Two solver strategies: GA + NSGA-II and DE + SPEA2
Self-adaptive solver selection based on success/failure history
Random cross-task knowledge transfer of whole genomes
Adaptive population partitioning among solvers

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, t_gap=10, t_num=10, sa_gap=70, memory=30, ga_muc=20.0, ga_mum=15.0, de_f=0.5, de_cr=0.9, save_data=True, save_path='./Data', name='MO-MTEA-SaO', disable_tqdm=True)[source]

Initialize MO-MTEA-SaO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
t_gap (int, optional) – Transfer gap - perform knowledge transfer every t_gap generations (default: 10)
t_num (int, optional) – Number of solutions to transfer (default: 10)
sa_gap (int, optional) – Self-adaptive gap - update solver allocation every sa_gap generations (default: 70)
memory (int, optional) – Memory length for success/failure history (default: 30)
ga_muc (float, optional) – Distribution index for GA crossover (SBX) (default: 20.0)
ga_mum (float, optional) – Distribution index for GA mutation (PM) (default: 15.0)
de_f (float, optional) – DE scaling factor (default: 0.5)
de_cr (float, optional) – DE crossover probability (default: 0.9)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MO-MTEA-SaO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MO-MTEA-SaO algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multi-task Multi-objective Evolutionary Algorithm Based on Decomposition with Dynamic Neighborhood (MTEA-D-DN)

This module implements MTEA-D-DN for multi-task multi-objective optimization problems.

References

[1] Wang, Xianpeng, Zhiming Dong, Lixin Tang, and Qingfu Zhang. “Multiobjective Multitask Optimization - Neighborhood as a Bridge for Knowledge Transfer.” IEEE Transactions on Evolutionary Computation 27.1 (2023): 155-169.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.18 Version: 1.0

class ddmtolab.Algorithms.MTMO.MTEA_D_DN.MTEA_D_DN(problem, n=None, max_nfes=None, beta=0.2, F=0.5, CR=0.9, mum=20.0, save_data=True, save_path='./Data', name='MTEA-D-DN', disable_tqdm=True)[source]

Bases: object

Multi-task Multi-objective Evolutionary Algorithm Based on Decomposition with Dynamic Neighborhood.

This algorithm uses neighborhood structure as a bridge for knowledge transfer between tasks. It maintains two types of neighborhoods: - B: Primary neighborhood within the same task (based on weight vector distance) - B2: Secondary neighborhood from other tasks (for knowledge transfer)

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, beta=0.2, F=0.5, CR=0.9, mum=20.0, save_data=True, save_path='./Data', name='MTEA-D-DN', disable_tqdm=True)[source]

Initialize MTEA-D-DN algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
beta (float, optional) – Probability of choosing parents locally (from neighborhood) (default: 0.2)
F (float, optional) – Scaling factor for DE mutation (default: 0.5)
CR (float, optional) – Crossover rate for DE (default: 0.9)
mum (float, optional) – Distribution index for polynomial mutation (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTEA-D-DN’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTEA-D-DN algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multi-objective Multi-task Differential Evolution with Multiple Knowledge Types and Transfer Adaptation (MTDE-MKTA)

This module implements MTDE-MKTA for multi-task multi-objective optimization problems.

References

[1] Li, Yanchi, and Wenyin Gong. “Multiobjective Multitask Optimization With Multiple Knowledge Types and Transfer Adaptation.” IEEE Transactions on Evolutionary Computation 29.1 (2025): 205-216.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.18 Version: 1.0

class ddmtolab.Algorithms.MTMO.MTDE_MKTA.MTDE_MKTA(problem, n=None, max_nfes=None, tau1=0.2, tau2=0.1, save_data=True, save_path='./Data', name='MTDE-MKTA', disable_tqdm=True)[source]

Bases: object

Multi-objective Multi-task Differential Evolution with Multiple Knowledge Types and Transfer Adaptation.

This algorithm features: - Self-adaptive parameters (F, CR, TR, KP) for each individual - Rank-based DE parent selection - Two knowledge transfer types: direct transfer and distribution-based transfer

Notes

Following the MTO-Platform reference implementation, the whole population is evolved in a unified $[0, 1]^{\max_t D_t}$ space; when an individual is evaluated on task t only its first $D_t$ genes are used. This is what makes a decision vector directly exchangeable between tasks of different dimensionality.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, tau1=0.2, tau2=0.1, save_data=True, save_path='./Data', name='MTDE-MKTA', disable_tqdm=True)[source]

Initialize MTDE-MKTA algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
tau1 (float, optional) – Mutation probability for F and CR parameters (default: 0.2)
tau2 (float, optional) – Mutation probability for TR and KP parameters (default: 0.1)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTDE-MKTA’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTDE-MKTA algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Evolutionary Multi-task with Effective Transfer (EMT-ET)

This module implements EMT-ET for multi-task multi-objective optimization problems.

References

[1] Lin, Jiabin, Hai-Lin Liu, Kay Chen Tan, and Fangqing Gu. “An Effective Knowledge Transfer Approach for Multiobjective Multitasking Optimization.” IEEE Transactions on Cybernetics 51.6 (2021): 3238-3248.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.16 Version: 1.0

class ddmtolab.Algorithms.MTMO.EMT_ET.EMT_ET(problem, n=None, max_nfes=None, G=8, P=0.5, muc=20.0, mum=15.0, save_data=True, save_path='./Data', name='EMT-ET', disable_tqdm=True)[source]

Bases: object

Evolutionary Multi-task with Effective Transfer.

This algorithm features: - Adaptive knowledge transfer seeded by previously successful transfers - Transfer solutions taken from the neighbourhood of a successful immigrant - Multiplicative perturbation of transferred solutions - NSGA-II based environmental selection

Notes

Following the MTO-Platform reference implementation, the whole population is evolved in a unified $[0, 1]^{\max_t D_t}$ space; when an individual is evaluated on task t only its first $D_t$ genes are used. Solutions are therefore exchanged verbatim between tasks of different dimensionality.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, G=8, P=0.5, muc=20.0, mum=15.0, save_data=True, save_path='./Data', name='EMT-ET', disable_tqdm=True)[source]

Initialize EMT-ET algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
G (int, optional) – Number of transfer solutions per generation (default: 8)
P (float, optional) – Probability of perturbing a transferred solution (default: 0.5)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 15.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EMT-ET’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EMT-ET algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Evolutionary Multi-task with Population Distribution-based Transfer (EMT-PD)

This module implements EMT-PD for multi-task multi-objective optimization problems.

References

[1] Liang, Zhengping, Weiqi Liang, Zhiqiang Wang, Xiaoliang Ma, Ling Liu, and Zexuan Zhu. “Multiobjective Evolutionary Multitasking With Two-Stage Adaptive Knowledge Transfer Based on Population Distribution.” IEEE Transactions on Systems, Man, and Cybernetics: Systems (2021): 1-13.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.01.13 Version: 1.1

class ddmtolab.Algorithms.MTMO.EMT_PD.EMT_PD(problem, n=None, max_nfes=None, rmp=0.3, G=5, muc=20.0, mum=15.0, save_data=True, save_path='./Data', name='EMT-PD', disable_tqdm=True)[source]

Bases: object

Evolutionary Multi-task with Population Distribution-based Transfer.

This algorithm features: - Two-stage adaptive knowledge transfer based on population distribution - Covariance-based distribution alignment between tasks - Multifactorial evolutionary framework with RMP - NSGA-II based environmental selection

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, rmp=0.3, G=5, muc=20.0, mum=15.0, save_data=True, save_path='./Data', name='EMT-PD', disable_tqdm=True)[source]

Initialize EMT-PD algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
rmp (float, optional) – Random mating probability for inter-task crossover (default: 0.3)
G (int, optional) – Transfer gap - perform distribution-based transfer every G generations (default: 5)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 15.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EMT-PD’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EMT-PD algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

ParEGO with Knowledge Transfer (ParEGO-KT)

This module implements ParEGO-KT for expensive multitask multiobjective optimization. It extends ParEGO with cross-task knowledge transfer using Spearman rank correlation to identify and leverage beneficial task relationships.

References

[1] J. Knowles. “ParEGO: A hybrid algorithm with on-line landscape approximation for expensive multiobjective optimization problems.” IEEE Transactions on Evolutionary Computation, 2006, 10(1): 50-66.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.12.18 Version: 1.0

class ddmtolab.Algorithms.MTMO.ParEGO_KT.ParEGO_KT(problem, n_initial=None, n_weights=None, max_nfes=None, rho=0.05, save_data=True, save_path='./Data', name='ParEGO-KT', disable_tqdm=True)[source]

Bases: object

ParEGO with knowledge transfer for expensive multitask multiobjective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, n_weights=None, max_nfes=None, rho=0.05, save_data=True, save_path='./Data', name='ParEGO-KT', disable_tqdm=True)[source]

Initialize ParEGO-KT algorithm with knowledge transfer.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial samples per task (default: 11*dim - 1)
n_weights (int or List[int], optional) – Number of reference weight vectors per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 200)
rho (float, optional) – Augmentation coefficient for augmented Tchebycheff scalarization (default: 0.05)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘ParEGO-KT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the ParEGO-KT algorithm with knowledge transfer.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Surrogate-Assisted Evolutionary Algorithm with Adaptive Knowledge Transfer (SAEA-AKT)

This module implements SAEA-AKT for expensive multitask multiobjective optimization. Every task is solved in turn as the target task, paired with a randomly drawn source task, by running four components in sequence: a competitive surrogate selection that lets a Kriging model and a heterogeneous ensemble model compete on a held-out validation split, an adaptive solution selection that transfers either convergent or diverse solutions from the source task depending on the current optimization state, a surrogate-assisted evolutionary optimizer seeded with the transferred population, and an adaptive infilling criterion that reuses the same selection to pick the samples that are truly evaluated.

References

[1] X. Wu, S. Liu, Q. Lin, K. C. Tan, and V. C. M. Leung. Evolutionary multitasking with adaptive knowledge transfer for expensive multiobjective optimization. IEEE Transactions on Evolutionary Computation, 2025, 29(6): 2537-2551.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.03 Version: 1.0

class ddmtolab.Algorithms.MTMO.SAEA_AKT.SAEA_AKT(problem, n_initial=None, max_nfes=None, n_kt=10, n_ic=5, g_max=20, p1=0.5, p2=0.75, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='SAEA-AKT', disable_tqdm=True)[source]

Bases: object

Surrogate-assisted evolutionary algorithm with adaptive knowledge transfer for expensive multitask multiobjective optimization.

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n_initial=None, max_nfes=None, n_kt=10, n_ic=5, g_max=20, p1=0.5, p2=0.75, muc=20.0, mum=20.0, save_data=True, save_path='./Data', name='SAEA-AKT', disable_tqdm=True)[source]

Initialize the SAEA-AKT algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n_initial (int or List[int], optional) – Number of initial Latin hypercube samples per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 500)
n_kt (int, optional) – Number of transfer solutions taken from the source task (default: 10)
n_ic (int, optional) – Number of infill solutions truly evaluated per iteration (default: 5)
g_max (int, optional) – Number of generations run by the surrogate-assisted optimizer (default: 20)
p1 (float, optional) – Probability of performing knowledge transfer in one iteration (default: 0.5)
p2 (float, optional) – Probability of assigning a sample to the surrogate training split, the remainder forming the validation split (default: 0.75)
muc (float, optional) – Distribution index for simulated binary crossover (SBX) (default: 20.0)
mum (float, optional) – Distribution index for polynomial mutation (PM) (default: 20.0)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘SAEA-AKT’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the SAEA-AKT algorithm.

Returns:: Optimization results containing decision variables, objectives, and runtime
Return type:: Results

Evolutionary Multitasking for Multi-objective Optimization Based on Generative Strategies (EMT-GS)

This module implements EMT-GS for multi-task multi-objective optimization problems. EMT-GS uses Generative Adversarial Networks (GANs) to transfer knowledge between tasks.

References

[1] Liang, Zhengping, Yingmiao Zhu, Xiyu Wang, Zhi Li, and Zexuan Zhu. “Evolutionary Multitasking for Multi-objective Optimization Based on Generative Strategies.” IEEE Transactions on Evolutionary Computation (2022): 1-1.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.1

class ddmtolab.Algorithms.MTMO.EMT_GS.EMT_GS(problem, n=None, max_nfes=None, G=10, lrD=0.0002, lrG=0.0003, BS=10, save_data=True, save_path='./Data', name='EMT-GS', disable_tqdm=True)[source]

Bases: object

Evolutionary Multitasking for Multi-objective Optimization Based on Generative Strategies.

This algorithm features: - GAN-based cross-task knowledge transfer, one GAN per ordered task pair - DE mutation with a rand-or-best base vector and the previous population - NSGA-II based environmental selection per task

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, G=10, lrD=0.0002, lrG=0.0003, BS=10, save_data=True, save_path='./Data', name='EMT-GS', disable_tqdm=True)[source]

Initialize EMT-GS algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
G (int, optional) – GAN training gap in generations (default: 10)
lrD (float, optional) – Learning rate for the discriminator (default: 0.0002)
lrG (float, optional) – Learning rate for the generator (default: 0.0003)
BS (int, optional) – Batch size for GAN training (default: 10)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘EMT-GS’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the EMT-GS algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multi-objective Multi-task Evolutionary Algorithm with Progressive Auto-Encoding (MO-MTEA-PAE)

This module implements MO-MTEA-PAE for multi-task multi-objective optimization problems.

References

[1] Q. Gu, Y. Li, W. Gong, Z. Yuan, B. Ning, C. Hu, and J. Wu, “Progressive Auto-Encoding for Domain Adaptation in Evolutionary Multi-Task Optimization,” Applied Soft Computing, vol. 175, p. 113916, 2025.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTMO.MO_MTEA_PAE.MO_MTEA_PAE(problem, n=None, max_nfes=None, Seg=10, TNum=20, TGap=5, F=0.5, CR=0.9, MuC=20, MuM=15, save_data=True, save_path='./Data', name='MO-MTEA-PAE', disable_tqdm=True)[source]

Bases: object

Multi-objective Multi-task Evolutionary Algorithm with Progressive Auto-Encoding.

This algorithm features:

Kernelized autoencoding (NFC) for cross-task knowledge transfer
Two transfer strategies: segment transfer (historical distribution) and stochastic replacement transfer (current distribution)
Adaptive selection between DE and GA offspring generation
Adaptive selection between transfer types based on success rates
SPEA2 environmental selection per task
Elite solution transfer across tasks

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, Seg=10, TNum=20, TGap=5, F=0.5, CR=0.9, MuC=20, MuM=15, save_data=True, save_path='./Data', name='MO-MTEA-PAE', disable_tqdm=True)[source]

Initialize MO-MTEA-PAE algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
Seg (int, optional) – Number of segments for the DisPop update schedule (default: 10)
TNum (int, optional) – Number of transfer solutions per transfer event (default: 20)
TGap (int, optional) – Transfer gap in generations (default: 5)
F (float, optional) – DE mutation factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.9)
MuC (float, optional) – SBX crossover distribution index (default: 20)
MuM (float, optional) – PM mutation distribution index (default: 15)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MO-MTEA-PAE’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MO-MTEA-PAE algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multi-Objective Symbiosis-Based Optimization (MO-SBO)

This module implements the MO-SBO algorithm for multi-objective many-task optimization based on symbiotic relationships in biocoenosis. The algorithm adaptively controls knowledge transfer rates by tracking six types of symbiotic interactions: mutualism, commensalism, parasitism, competition, amensalism, and neutralism.

References

[1] R.-T. Liaw and C.-K. Ting. “Evolutionary Manytasking Optimization Based on Symbiosis in Biocoenosis.” Proceedings of the AAAI Conference on Artificial Intelligence, 33(01): 4295-4303, 2019.

Notes

The code is developed in accordance with the MATLAB-based MTO-platform framework.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.21 Version: 1.0

class ddmtolab.Algorithms.MTMO.MO_SBO.MO_SBO(problem, n=None, max_nfes=None, benefit=0.25, harm=0.5, mu_c=20, mu_m=15, save_data=True, save_path='./Data', name='MO-SBO', disable_tqdm=True)[source]

Bases: object

Multi-Objective Symbiosis-Based Optimization for many-task multi-objective optimization.

The algorithm uses symbiotic relationships between tasks to adaptively control knowledge transfer rates. Six types of symbiotic interactions are tracked:

Mutualism (MIJ): Both tasks benefit (transferred solution ranks high in both)
Commensalism (OIJ): One benefits, other neutral
Parasitism (PIJ): One benefits, other harmed
Competition (CIJ): Both harmed
Amensalism (AIJ): One harmed, other neutral
Neutralism (NIJ): Both neutral

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, benefit=0.25, harm=0.5, mu_c=20, mu_m=15, save_data=True, save_path='./Data', name='MO-SBO', disable_tqdm=True)[source]

Initialize MO-SBO algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int, optional) – Population size per task (default: 100)
max_nfes (int, optional) – Maximum number of function evaluations per task (default: 10000)
benefit (float, optional) – Beneficial factor threshold for symbiosis categorization (default: 0.25)
harm (float, optional) – Harmful factor threshold for symbiosis categorization (default: 0.5)
mu_c (float, optional) – Distribution index for simulated binary crossover (default: 20)
mu_m (float, optional) – Distribution index for polynomial mutation (default: 15)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MO-SBO’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MO-SBO algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multi-task Evolutionary Algorithm Based on Decomposition with Transfer of Search Directions (MTEA-D-TSD)

This module implements MTEA-D-TSD for multi-task multi-objective optimization problems.

References

[1] Y. Li, W. Gong, and Q. Gu, “Transfer Search Directions Among Decomposed Subtasks for Evolutionary Multitasking in Multiobjective Optimization,” in Proceedings of the Genetic and Evolutionary Computation Conference (GECCO ‘24), 2024, pp. 557-565.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTMO.MTEA_D_TSD.MTEA_D_TSD(problem, n=None, max_nfes=None, TR0=0.2, CF=0.4, SNum=10, Delta=0.9, NR=2, F=0.5, CR=0.9, MuM=15, save_data=True, save_path='./Data', name='MTEA-D-TSD', disable_tqdm=True)[source]

Bases: object

Multi-task Evolutionary Algorithm Based on Decomposition with Transfer of Search Directions.

This algorithm features: - MOEA/D framework with Tchebycheff decomposition - Search direction (SD) tracking for each individual - Cross-task transfer of search directions based on cosine similarity - Adaptive per-individual transfer rate - DE/rand/1 mutation with polynomial mutation

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, TR0=0.2, CF=0.4, SNum=10, Delta=0.9, NR=2, F=0.5, CR=0.9, MuM=15, save_data=True, save_path='./Data', name='MTEA-D-TSD', disable_tqdm=True)[source]

Initialize MTEA-D-TSD algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
TR0 (float, optional) – Initial transfer rate (default: 0.2)
CF (float, optional) – Cumulative factor for search direction update (default: 0.4)
SNum (int, optional) – Number of random samples for source selection (default: 10)
Delta (float, optional) – Probability of choosing parents from local neighborhood (default: 0.9)
NR (int, optional) – Maximum number of solutions replaced per offspring (default: 2)
F (float, optional) – DE mutation factor (default: 0.5)
CR (float, optional) – DE crossover rate (default: 0.9)
MuM (float, optional) – PM mutation distribution index (default: 15)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTEA-D-TSD’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTEA-D-TSD algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Multi-task Evolutionary Algorithm via Diversity- and Convergence-Oriented Knowledge Transfer (MTEA-DCK)

This module implements MTEA-DCK for multi-task multi-objective optimization problems.

References

[1] Y. Li, D. Li, W. Gong, and Q. Gu, “Multiobjective Multitask Optimization via Diversity- and Convergence-Oriented Knowledge Transfer,” IEEE Trans. Syst., Man, Cybern., Syst., vol. 55, no. 3, pp. 2367-2379, 2025.

Notes

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.02.22 Version: 1.0

class ddmtolab.Algorithms.MTMO.MTEA_DCK.MTEA_DCK(problem, n=None, max_nfes=None, Tau=0.1, TRC0=0.3, save_data=True, save_path='./Data', name='MTEA-DCK', disable_tqdm=True)[source]

Bases: object

Multi-task Evolutionary Algorithm via Diversity- and Convergence-Oriented Knowledge Transfer.

This algorithm features: - Competitive Swarm Optimizer (CSO) framework with winner/loser pairing - DE-based generation with diversified knowledge transfer (DKT) via region mapping - CSO-based generation with convergent knowledge transfer (CKT) via fragment swap - Adaptive per-individual parameters (F, CR, TRD) with Cauchy/Normal perturbation - SPEA2 environmental selection

Variables:: algorithm_information (dict) – Dictionary containing algorithm capabilities and requirements

__init__(problem, n=None, max_nfes=None, Tau=0.1, TRC0=0.3, save_data=True, save_path='./Data', name='MTEA-DCK', disable_tqdm=True)[source]

Initialize MTEA-DCK algorithm.

Parameters:

problem (MTOP) – Multi-task optimization problem instance
n (int or List[int], optional) – Population size per task (default: 100)
max_nfes (int or List[int], optional) – Maximum number of function evaluations per task (default: 10000)
Tau (float, optional) – Probability of random parameter reset (default: 0.1)
TRC0 (float, optional) – Initial transfer rate for convergent knowledge transfer (default: 0.3)
save_data (bool, optional) – Whether to save optimization data (default: True)
save_path (str, optional) – Path to save results (default: ‘./Data’)
name (str, optional) – Name for the experiment (default: ‘MTEA-DCK’)
disable_tqdm (bool, optional) – Whether to disable progress bar (default: True)

optimize()[source]

Execute the MTEA-DCK algorithm.

Returns:: Optimization results containing decision variables, objectives, constraints, and runtime
Return type:: Results

Problems

MTOP Class

The MTOP (Multitask Optimization Problem) class is the core component for defining optimization problems.

class ddmtolab.Methods.mtop.MTOP(unified_eval_mode: bool = False, fill_value: float = 0.0)[source]

Bases: object

Multi-Task Optimization Problem (MTOP) definition and management.

This class allows defining multiple optimization tasks, each with decision variables, objectives, and constraints. It handles vectorized and non-vectorized objective/constraint functions, normalizes outputs to consistent 2D arrays, and provides unified evaluation interfaces.

Parameters:

unified_eval_mode (bool, optional) – If True, evaluation results will be padded to maximum dimensions across all tasks (default is False).
fill_value (float, optional) – Value used for padding in unified evaluation mode (default is 0.0).

Variables:

tasks (List[Dict[str, Any]]) – List of task dictionaries containing function wrappers and metadata.
dims (List[int]) – List of decision variable dimensions for each task.
bounds (List[Tuple[np.ndarray, np.ndarray]]) – List of (lower_bound, upper_bound) tuples for each task.
n_tasks (int) – Total number of tasks.
m_max (int) – Maximum number of objectives across all tasks.
c_max (int) – Maximum number of constraints across all tasks.
unified_eval_mode (bool) – Whether unified evaluation mode is enabled.
fill_value (float) – Fill value for padding in unified evaluation mode.

Examples

Create a simple MTOP with two tasks:

>>> def sphere(x):
...     return np.sum(x**2, axis=1)
>>> def rosenbrock(x):
...     x = np.atleast_2d(x)
...     return np.sum(100*(x[:, 1:] - x[:, :-1]**2)**2 + (1 - x[:, :-1])**2, axis=1)
>>>
>>> mtop = MTOP()
>>> mtop.add_task(sphere, dim=3)
0
>>> mtop.add_task(rosenbrock, dim=5, lower_bound=-5, upper_bound=5)
1
>>>
>>> # Evaluate first task
>>> X = np.random.rand(10, 3)
>>> obj, con = mtop.evaluate_task(0, X)
>>> obj.shape
(10, 1)

Decision variable types

ddmtolab.Methods.mtop.normalize_var_type(var_type: Any, dim: int) → ndarray[source]

Expand any accepted spelling of var_type into one code per variable.

Parameters:

var_type (None, str, sequence, or dict) –
Accepted forms, all describing the same thing:
- None : every variable is a float (the default).
- 'I' or 'integer' : one type, broadcast to every variable.
- 'FFFIIB' : one letter per variable, length must equal dim.
- [('F', 3), ('I', 2), ('B', 1)] : runs of (type, count), which is the compact way to say “this stretch is float, the next is integer”.
- ['F', 'F', 'integer'] : one entry per variable, names allowed.
- {'I': [3, 4], 'C': range(8, 12)} : the indices of each type, with everything not mentioned left float.
dim (int) – Number of decision variables the task declares.

Returns:

Array of shape (dim,) and dtype ‘<U1’, one code per variable.

Return type:

np.ndarray

Raises:

ValueError – If a type is unknown, a length disagrees with dim, or an index in the dict form falls outside the task.

ddmtolab.Methods.mtop.normalize_var_values(var_values: Any, codes: ndarray, lb: ndarray, ub: ndarray) → Dict[int, Tuple][source]

Check and freeze the value list attached to each indexed variable.

A categorical or ordinal variable is an index into an explicit list: the decision variable ranges over lb..ub and picks values[x - lb]. The list is what makes a problem self-describing, and for an ordinal variable its order is the order the codes stand for.

Parameters:

var_values (dict or None) – Maps a variable index to the values it draws from.
codes (np.ndarray) – Per-variable type codes, as returned by normalize_var_type().
lb (np.ndarray) – Bounds of the task, one entry per variable.
ub (np.ndarray) – Bounds of the task, one entry per variable.

Returns:

The same mapping with tuples for values, empty when none were given.

Return type:

Dict[int, Tuple]

Raises:

ValueError – If an index is out of range, names a variable that is not categorical or ordinal, or carries a list whose length does not match its bounds.

ddmtolab.Methods.mtop.validate_var_bounds(codes: ndarray, lb: ndarray, ub: ndarray) → None[source]

Check that the bounds can express the declared types.

Binary variables have to run over exactly {0, 1}; integer, binary, categorical and ordinal variables need integral bounds, since every value they can take is one of the integers between them.

Raises:: ValueError – If a bound cannot represent the type declared for that variable.

Benchmark Problem Suites

STSO Problems:

class ddmtolab.Problems.STSO.classical_so.CLASSICALSO[source]

Classical Single-Task Optimization (CLASSICALSO) benchmark problems.

This class provides a set of standard single-objective optimization benchmark functions (e.g., Ackley, Rastrigin, Sphere) configured as Multi-Task Optimization Problems (MTOPs) with only one task. This serves as a baseline for comparing single-task solvers or as individual tasks in a multi-task setting.

P1(D=50) → MTOP[source]

Generates a single-task MTOP based on the Ackley function.

The search space is set to [-100.0, 100.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Ackley task.
Return type:: MTOP

P2(D=50) → MTOP[source]

Generates a single-task MTOP based on the Elliptic function.

The search space is set to [-100.0, 100.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Elliptic task.
Return type:: MTOP

P3(D=50) → MTOP[source]

Generates a single-task MTOP based on the Griewank function.

The search space is set to [-100.0, 100.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Griewank task.
Return type:: MTOP

P4(D=50) → MTOP[source]

Generates a single-task MTOP based on the Rastrigin function.

The search space is set to [-100.0, 100.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Rastrigin task.
Return type:: MTOP

P5(D=50) → MTOP[source]

Generates a single-task MTOP based on the Rosenbrock function.

The search space is set to [-100.0, 100.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Rosenbrock task.
Return type:: MTOP

P6(D=50) → MTOP[source]

Generates a single-task MTOP based on the Schwefel function (F6).

The search space is set to [-500.0, 500.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Schwefel task.
Return type:: MTOP

P7(D=50) → MTOP[source]

Generates a single-task MTOP based on the Schwefel 2.22 function (F7).

The search space is set to [-100.0, 100.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Schwefel 2.22 task.
Return type:: MTOP

P8(D=50) → MTOP[source]

Generates a single-task MTOP based on the Sphere function.

The search space is set to [-100.0, 100.0] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Sphere task.
Return type:: MTOP

P9(D=50) → MTOP[source]

Generates a single-task MTOP based on the Weierstrass function.

The search space is set to [-0.5, 0.5] in all dimensions.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the Weierstrass task.
Return type:: MTOP

problem_information = {'n_cases': 9, 'n_cons': '0', 'n_dims': 'D', 'n_objs': '1', 'n_tasks': '1', 'type': 'synthetic'}

class ddmtolab.Problems.STSO.cec10_cso.CEC10_CSO[source]

CEC 2010 Competition on Constrained Real-Parameter Optimization (CSO) benchmark problems.

This class provides constrained single-objective optimization benchmark functions configured as Multi-Task Optimization Problems (MTOPs) with only one task.

References

[1] Mallipeddi, Rammohan and Suganthan, Ponnuthurai. “Problem Definitions and Evaluation Criteria for the CEC 2010 Competition on Constrained Real-parameter Optimization.” (2010)

Variables:

delta (float) – Tolerance for equality constraints (default: 1e-4).
data_dir (str) – The directory path for problem data files.
max_dim (int) – Maximum allowed dimension (30, due to offset vector size).

P1(D=10) → MTOP[source]

Generates CEC10_CSO Problem 1.

This is a constrained optimization problem with: - 1 objective function - 2 inequality constraints - Search space: [0, 10] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 1.
Return type:: MTOP

P10(D=10) → MTOP[source]

Generates CEC10_CSO Problem 10.

This is a constrained optimization problem with: - 1 objective function (Rosenbrock) - 1 equality constraint - Uses rotation matrix M - Search space: [-500, 500] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 10.
Return type:: MTOP

P11(D=10) → MTOP[source]

Generates CEC10_CSO Problem 11.

This is a constrained optimization problem with: - 1 objective function (modified cosine function) - 1 equality constraint (Rosenbrock) - Uses rotation matrix M - Search space: [-100, 100] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 11.
Return type:: MTOP

P12(D=10) → MTOP[source]

Generates CEC10_CSO Problem 12.

This is a constrained optimization problem with: - 1 objective function (Schwefel) - 1 equality constraint - 1 inequality constraint - Search space: [-1000, 1000] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 12.
Return type:: MTOP

P13(D=10) → MTOP[source]

Generates CEC10_CSO Problem 13.

This is a constrained optimization problem with: - 1 objective function (modified Schwefel) - 3 inequality constraints - Search space: [-500, 500] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 13.
Return type:: MTOP

P14(D=10) → MTOP[source]

Generates CEC10_CSO Problem 14.

This is a constrained optimization problem with: - 1 objective function (Rosenbrock) - 3 inequality constraints - Search space: [-1000, 1000] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 14.
Return type:: MTOP

P15(D=10) → MTOP[source]

Generates CEC10_CSO Problem 15.

This is a constrained optimization problem with: - 1 objective function (Rosenbrock) - 3 inequality constraints - Uses rotation matrix M - Search space: [-1000, 1000] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 15.
Return type:: MTOP

P16(D=10) → MTOP[source]

Generates CEC10_CSO Problem 16.

This is a constrained optimization problem with: - 1 objective function (Griewank) - 1 inequality constraint - 2 equality constraints - Search space: [-10, 10] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 16.
Return type:: MTOP

P17(D=10) → MTOP[source]

Generates CEC10_CSO Problem 17.

This is a constrained optimization problem with: - 1 objective function (sum of squared differences) - 2 inequality constraints - 1 equality constraint - Search space: [-10, 10] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 17.
Return type:: MTOP

P18(D=10) → MTOP[source]

Generates CEC10_CSO Problem 18.

This is a constrained optimization problem with: - 1 objective function (sum of squared differences) - 1 inequality constraint - 1 equality constraint - Search space: [-50, 50] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 18.
Return type:: MTOP

P2(D=10) → MTOP[source]

Generates CEC10_CSO Problem 2.

This is a constrained optimization problem with: - 1 objective function (max function) - 2 inequality constraints - 1 equality constraint - Search space: [-5.12, 5.12] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 2.
Return type:: MTOP

P3(D=10) → MTOP[source]

Generates CEC10_CSO Problem 3.

This is a constrained optimization problem with: - 1 objective function (Rosenbrock) - 1 equality constraint - Search space: [-1000, 1000] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 3.
Return type:: MTOP

P4(D=10) → MTOP[source]

Generates CEC10_CSO Problem 4.

This is a constrained optimization problem with: - 1 objective function (max function) - 4 equality constraints - Search space: [-50, 50] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 4.
Return type:: MTOP

P5(D=10) → MTOP[source]

Generates CEC10_CSO Problem 5.

This is a constrained optimization problem with: - 1 objective function (max function) - 2 equality constraints - Search space: [-600, 600] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 5.
Return type:: MTOP

P6(D=10) → MTOP[source]

Generates CEC10_CSO Problem 6.

This is a constrained optimization problem with: - 1 objective function (max function) - 2 equality constraints - Uses rotation matrix M - Search space: [-600, 600] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 6.
Return type:: MTOP

P7(D=10) → MTOP[source]

Generates CEC10_CSO Problem 7.

This is a constrained optimization problem with: - 1 objective function (Rosenbrock) - 1 inequality constraint - Search space: [-140, 140] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 7.
Return type:: MTOP

P8(D=10) → MTOP[source]

Generates CEC10_CSO Problem 8.

This is a constrained optimization problem with: - 1 objective function (Rosenbrock) - 1 inequality constraint - Uses rotation matrix M - Search space: [-140, 140] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 8.
Return type:: MTOP

P9(D=10) → MTOP[source]

Generates CEC10_CSO Problem 9.

This is a constrained optimization problem with: - 1 objective function (Rosenbrock) - 1 equality constraint - Search space: [-500, 500] for all dimensions

Parameters:: D (int, optional) – The dimensionality of the search space (default is 10, max is 30).
Returns:: A Multi-Task Optimization Problem instance containing Problem 9.
Return type:: MTOP

max_dim = 30

problem_information = {'n_cases': 18, 'n_cons': '[2, 5]', 'n_dims': '[10, 30]', 'n_objs': '1', 'n_tasks': '1', 'type': 'synthetic'}

class ddmtolab.Problems.STSO.stsotest.STSOtest[source]

Modified Single-Task Optimization (STSOtest) benchmark problems.

This class provides a set of standard single-objective optimization benchmark functions (e.g., Ackley, Rastrigin, Sphere) configured as Multi-Task Optimization Problems (MTOPs) with only one task. Unlike CLASSICALSO, this class uses non-identity rotation matrices (M) and non-zero offset vectors (o) to create different but corresponding problem instances.

P1(D=50) → MTOP[source]

Generates a single-task MTOP based on the Ackley function.

The search space is set to [-100.0, 100.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Ackley task.
Return type:: MTOP

P2(D=50) → MTOP[source]

Generates a single-task MTOP based on the Elliptic function.

The search space is set to [-100.0, 100.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Elliptic task.
Return type:: MTOP

P3(D=50) → MTOP[source]

Generates a single-task MTOP based on the Griewank function.

The search space is set to [-100.0, 100.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Griewank task.
Return type:: MTOP

P4(D=50) → MTOP[source]

Generates a single-task MTOP based on the Rastrigin function.

The search space is set to [-100.0, 100.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Rastrigin task.
Return type:: MTOP

P5(D=50) → MTOP[source]

Generates a single-task MTOP based on the Rosenbrock function.

The search space is set to [-100.0, 100.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Rosenbrock task.
Return type:: MTOP

P6(D=50) → MTOP[source]

Generates a single-task MTOP based on the Schwefel function (F6).

The search space is set to [-500.0, 500.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Schwefel task.
Return type:: MTOP

P7(D=50) → MTOP[source]

Generates a single-task MTOP based on the Schwefel 2.22 function (F7).

The search space is set to [-100.0, 100.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Schwefel 2.22 task.
Return type:: MTOP

P8(D=50) → MTOP[source]

Generates a single-task MTOP based on the Sphere function.

The search space is set to [-100.0, 100.0] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Sphere task.
Return type:: MTOP

P9(D=50) → MTOP[source]

Generates a single-task MTOP based on the Weierstrass function.

The search space is set to [-0.5, 0.5] in all dimensions. Uses fixed rotation matrix M and offset vector o.

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance containing the modified Weierstrass task.
Return type:: MTOP

problem_information = {'n_cases': 9, 'n_cons': '0', 'n_dims': 'D', 'n_objs': '1', 'n_tasks': '1', 'type': 'synthetic'}

STMO Problems:

class ddmtolab.Problems.STMO.ZDT.ZDT[source]

Implementation of the ZDT test suite for multi-objective optimization.

The ZDT test problems (ZDT1 to ZDT6) are standard bi-objective optimization benchmarks proposed by Zitzler, Deb, and Thiele (2000).

Each method in this class generates a Multi-Task Optimization Problem (MTOP) instance containing a single ZDT task.

References

[1] E. Zitzler, K. Deb, and L. Thiele. “Comparison of multiobjective evolutionary algorithms: Empirical results.” Evolutionary Computation, 2000, 8(2): 173-195.

Notes

All ZDT problems have exactly M=2 objectives. The decision space dimension can be adjusted via the D parameter.

ZDT1(D=30) → MTOP[source]

Generates the ZDT1 problem.

ZDT1 features a convex Pareto front and tests the ability to converge to the optimal front uniformly.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the ZDT1 task.
Return type:: MTOP

ZDT2(D=30) → MTOP[source]

Generates the ZDT2 problem.

ZDT2 features a non-convex Pareto front and tests the ability to maintain diversity in non-convex regions.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the ZDT2 task.
Return type:: MTOP

ZDT3(D=30) → MTOP[source]

Generates the ZDT3 problem.

ZDT3 features a disconnected Pareto front and tests the ability to maintain subpopulations in different regions.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the ZDT3 task.
Return type:: MTOP

ZDT4(D=10) → MTOP[source]

Generates the ZDT4 problem.

ZDT4 features multiple local Pareto fronts and tests the ability to avoid local optima. It has 21^9 local Pareto fronts.

Parameters:: D (int, optional) – Number of decision variables (default is 10).
Returns:: A Multi-Task Optimization Problem instance containing the ZDT4 task.
Return type:: MTOP

ZDT5(D=80) → MTOP[source]

Generates the ZDT5 problem.

ZDT5 is a binary-encoded problem with a deceptive fitness landscape. The dimension is adjusted to be 30 + 5k where k is an integer.

Parameters:: D (int, optional) – Number of decision variables (default is 80). The actual dimension will be adjusted to 30 + 5k format.
Returns:: A Multi-Task Optimization Problem instance containing the ZDT5 task.
Return type:: MTOP

Notes

Decision variables are binary-encoded. Continuous inputs are converted to binary by thresholding at 0.5: x > 0.5 → 1, x ≤ 0.5 → 0.

ZDT6(D=10) → MTOP[source]

Generates the ZDT6 problem.

ZDT6 features a non-uniform search space and non-convex Pareto front. It has low density of solutions near the Pareto front.

Parameters:: D (int, optional) – Number of decision variables (default is 10).
Returns:: A Multi-Task Optimization Problem instance containing the ZDT6 task.
Return type:: MTOP

problem_information = {'n_cases': 6, 'n_cons': '0', 'n_dims': 'D', 'n_objs': '2', 'n_tasks': '1', 'type': 'synthetic'}

class ddmtolab.Problems.STMO.DTLZ.DTLZ[source]

Implementation of the DTLZ test suite for multi-objective optimization.

The DTLZ test problems (DTLZ1 to DTLZ7) are standard unconstrained multi-objective optimization benchmarks. DTLZ8 and DTLZ9 are constrained.

Each method in this class generates a Multi-Task Optimization Problem (MTOP) instance containing a single DTLZ task.

Notes

The decision variables (x) are typically split into M objectives (x[0:M-1]) and k complexity variables (x[M-1:]).

DTLZ1(M=3, D=None) → MTOP[source]

Generates the DTLZ1 problem.

DTLZ1 features a simple linear Pareto-optimal front (PF) and a complex multi-modal search space due to the g-function.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M + k - 1, where k=5 for DTLZ1 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ1 task.

Return type:

MTOP

DTLZ2(M=3, D=None) → MTOP[source]

Generates the DTLZ2 problem.

DTLZ2 features a simple convex spherical PF and a simple uni-modal g-function.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M + k - 1, where k=10 for DTLZ2 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ2 task.

Return type:

MTOP

DTLZ3(M=3, D=None) → MTOP[source]

Generates the DTLZ3 problem.

DTLZ3 features a convex spherical PF (similar to DTLZ2) but has a multi-modal g-function, making it difficult to converge.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M + k - 1, where k=10 for DTLZ3 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ3 task.

Return type:

MTOP

DTLZ4(M=3, D=None, alpha=100) → MTOP[source]

Generates the DTLZ4 problem.

DTLZ4 features a convex spherical PF (similar to DTLZ2) but introduces a bias towards certain objective regions due to the exponent $\alpha$, making diversity maintenance challenging.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M + k - 1, where k=10 for DTLZ4 (default is None).
alpha (int, optional) – Exponent used to bias the solution (default is 100).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ4 task.

Return type:

MTOP

DTLZ5(M=3, D=None) → MTOP[source]

Generates the DTLZ5 problem.

DTLZ5 features a degenerated (curve-like) PF, lying on a $(M-1)$-dimensional manifold of the M-dimensional objective space.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M + k - 1, where k=10 for DTLZ5 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ5 task.

Return type:

MTOP

DTLZ6(M=3, D=None) → MTOP[source]

Generates the DTLZ6 problem.

DTLZ6 also features a degenerated (curve-like) PF (similar to DTLZ5), but introduces a connectivity difficulty with its g-function ($g(x_M) = \sum x_M^{0.1}$).

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M + k - 1, where k=10 for DTLZ6 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ6 task.

Return type:

MTOP

DTLZ7(M=3, D=None) → MTOP[source]

Generates the DTLZ7 problem.

DTLZ7 features a disconnected PF and is used to test an algorithm’s ability to converge to multiple disconnected regions.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M + k - 1, where k=20 for DTLZ7 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ7 task.

Return type:

MTOP

DTLZ8(M=3, D=None) → MTOP[source]

Generates the DTLZ8 problem (Constrained).

DTLZ8 has simple objective functions but complex constraints, typically resulting in a PF that is a linear or piecewise linear manifold.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M * k, where k=10 for DTLZ8 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ8 task.

Return type:

MTOP

DTLZ9(M=2, D=None) → MTOP[source]

Generates the DTLZ9 problem (Constrained).

DTLZ9 has simple objective functions but constraints that define a parabolic shape for the PF.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables. If None, it is set to M * k, where k=10 for DTLZ9 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the DTLZ9 task.

Return type:

MTOP

problem_information = {'n_cases': 9, 'n_cons': '[0, M]', 'n_dims': 'D', 'n_objs': 'M', 'n_tasks': '1', 'type': 'synthetic'}

class ddmtolab.Problems.STMO.WFG.WFG[source]

Implementation of the WFG (Walking Fish Group) test suite for multi-objective optimization.

The WFG test problems are scalable benchmarks designed to test various characteristics of multi-objective optimization algorithms, including bias, flatness, and mixed Pareto fronts.

WFG1(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG1 problem.

WFG1 features a mixed Pareto front with both convex and non-convex regions, along with polynomial bias and flat region transformations.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter (number of position-related variables), which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG1 task.

Return type:

MTOP

WFG2(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG2 problem.

WFG2 features a disconnected Pareto front and uses non-separable reduction functions. It tests an algorithm’s ability to maintain diversity across disconnected regions.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG2 task.

Return type:

MTOP

WFG3(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG3 problem.

WFG3 features a linear Pareto front with a degenerate geometry, testing an algorithm’s ability to handle problems with dependencies between objectives.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG3 task.

Return type:

MTOP

WFG4(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG4 problem.

WFG4 features a concave Pareto front with multi-modal transformations, testing an algorithm’s ability to handle multi-modality.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG4 task.

Return type:

MTOP

WFG5(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG5 problem.

WFG5 features a concave Pareto front with parameter-deceptive transformations, testing an algorithm’s ability to handle deceptive fitness landscapes.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG5 task.

Return type:

MTOP

WFG6(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG6 problem.

WFG6 features a concave Pareto front with non-separable reduction functions, testing an algorithm’s ability to handle non-separable problems.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG6 task.

Return type:

MTOP

WFG7(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG7 problem.

WFG7 features a concave Pareto front with parameter-dependent transformations, testing an algorithm’s ability to handle parameter dependencies.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG7 task.

Return type:

MTOP

WFG8(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG8 problem.

WFG8 features a concave Pareto front with parameter-dependent transformations on distance parameters, testing an algorithm’s ability to handle complex parameter dependencies.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG8 task.

Return type:

MTOP

WFG9(M=3, Kp=None, D=None) → MTOP[source]

Generates the WFG9 problem.

WFG9 features a concave Pareto front with parameter-dependent transformations, deceptive and multi-modal shifts, and non-separable reduction functions, testing multiple characteristics simultaneously.

Parameters:

M (int, optional) – Number of objectives (default is 3).
Kp (int, optional) – Position parameter, which should be a multiple of M-1. If None, it is set to M-1 (default is None).
D (int, optional) – Number of decision variables. If None, it is set to Kp + 10 (default is None).

Returns:

A Multi-Task Optimization Problem instance containing the WFG9 task.

Return type:

MTOP

problem_information = {'n_cases': 9, 'n_cons': '0', 'n_dims': 'D', 'n_objs': 'M', 'n_tasks': '1', 'type': 'synthetic'}

class ddmtolab.Problems.STMO.UF.UF[source]

Implementation of the UF test suite for multi-objective optimization.

The UF test problems (UF1 to UF10) are unconstrained benchmark MOPs proposed by Zhang et al. (2009) for the CEC 2009 special session and competition.

Each method in this class generates a Multi-Task Optimization Problem (MTOP) instance containing a single UF task.

References

[1] Q. Zhang, A. Zhou, S. Zhao, P. N. Suganthan, W. Liu, and S. Tiwari. “Multiobjective optimization test instances for the CEC 2009 special session and competition.” School of CS & EE, University of Essex, Working Report CES-487, 2009.

Notes

UF1-UF7 have M=2 objectives, UF8-UF10 have M=3 objectives. The decision space dimension can be adjusted via the D parameter.

UF1(D=30) → MTOP[source]

Generates the UF1 problem.

UF1 is a bi-objective problem with a convex Pareto front.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF1 task.
Return type:: MTOP

UF10(D=30) → MTOP[source]

Generates the UF10 problem.

UF10 is a three-objective problem with spherical Pareto front and complex landscape.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF10 task.
Return type:: MTOP

UF2(D=30) → MTOP[source]

Generates the UF2 problem.

UF2 is a bi-objective problem with more complex variable linkage.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF2 task.
Return type:: MTOP

UF3(D=30) → MTOP[source]

Generates the UF3 problem.

UF3 features a complex landscape with product terms.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF3 task.
Return type:: MTOP

UF4(D=30) → MTOP[source]

Generates the UF4 problem.

UF4 features a complex sine-based transformation with h function.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF4 task.
Return type:: MTOP

UF5(D=30) → MTOP[source]

Generates the UF5 problem.

UF5 features multimodal landscape with oscillatory Pareto front.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF5 task.
Return type:: MTOP

UF6(D=30) → MTOP[source]

Generates the UF6 problem.

UF6 features disconnected Pareto front with product terms.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF6 task.
Return type:: MTOP

UF7(D=30) → MTOP[source]

Generates the UF7 problem.

UF7 features a power transformation in the objectives.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF7 task.
Return type:: MTOP

UF8(D=30) → MTOP[source]

Generates the UF8 problem.

UF8 is a three-objective problem with spherical Pareto front.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF8 task.
Return type:: MTOP

UF9(D=30) → MTOP[source]

Generates the UF9 problem.

UF9 is a three-objective problem with disconnected Pareto front.

Parameters:: D (int, optional) – Number of decision variables (default is 30).
Returns:: A Multi-Task Optimization Problem instance containing the UF9 task.
Return type:: MTOP

problem_information = {'n_cases': 10, 'n_cons': '0', 'n_dims': 'D', 'n_objs': '[2, 3]', 'n_tasks': '1', 'type': 'synthetic'}

class ddmtolab.Problems.STMO.CF.CF[source]

Implementation of the CF test suite (CEC 2009) for constrained multi-objective optimization.

The CF test problems (CF1 to CF10) are standard constrained multi-objective optimization benchmarks from the CEC 2009 competition.

References

[1] Q. Zhang, A. Zhou, S. Zhao, P. N. Suganthan, W. Liu, and S. Tiwari. “Multiobjective optimization test instances for the CEC 2009 special session and competition.” University of Essex, Colchester, UK, Tech. Rep. CES-487, 2009.

CF1(M=2, D=10) → MTOP[source]: Generates the CF1 problem.

CF10(M=3, D=10) → MTOP[source]: Generates the CF10 problem.

CF2(M=2, D=10) → MTOP[source]: Generates the CF2 problem.

CF3(M=2, D=10) → MTOP[source]: Generates the CF3 problem.

CF4(M=2, D=10) → MTOP[source]: Generates the CF4 problem.

CF5(M=2, D=10) → MTOP[source]: Generates the CF5 problem.

CF6(M=2, D=10) → MTOP[source]: Generates the CF6 problem.

CF7(M=2, D=10) → MTOP[source]: Generates the CF7 problem.

CF8(M=3, D=10) → MTOP[source]: Generates the CF8 problem.

CF9(M=3, D=10) → MTOP[source]: Generates the CF9 problem.

problem_information = {'n_cases': 10, 'n_cons': '[1, 2]', 'n_dims': 'D', 'n_objs': '[2, 3]', 'n_tasks': '1', 'type': 'synthetic'}

class ddmtolab.Problems.STMO.MW.MW[source]

Implementation of the MW test suite for constrained multi-objective optimization.

The MW test problems are standard constrained multi-objective optimization benchmarks proposed by Ma and Wang (2019).

References

[1] Z. Ma and Y. Wang. “Evolutionary constrained multiobjective optimization: Test suite construction and performance comparisons.” IEEE Transactions on Evolutionary Computation, 2019, 23(6): 972-986.

MW1(M=2, D=15) → MTOP[source]

Generates the MW1 problem.

MW1 features a linear Pareto front with a nonlinear constraint boundary that creates a challenging feasible region.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW1 task.

Return type:

MTOP

MW10(M=2, D=15) → MTOP[source]

Generates the MW10 problem.

MW10 features a convex Pareto front (f2 = 1 - f1^2) with three constraints that create a complex feasible region with multiple disconnected segments.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW10 task.

Return type:

MTOP

MW11(M=2, D=15) → MTOP[source]

Generates the MW11 problem.

MW11 features a quarter-circle Pareto front with four constraints that create a highly complex feasible region with multiple disconnected segments.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW11 task.

Return type:

MTOP

MW12(M=2, D=15) → MTOP[source]

Generates the MW12 problem.

MW12 features a complex oscillating Pareto front with two constraints involving sinusoidal terms that create intricate feasible regions.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW12 task.

Return type:

MTOP

MW13(M=2, D=15) → MTOP[source]

Generates the MW13 problem.

MW13 features a complex Pareto front involving exponential and sinusoidal terms with two constraints that create intricate feasible regions.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW13 task.

Return type:

MTOP

MW14(M=3, D=15) → MTOP[source]

Generates the MW14 problem.

MW14 is a multi/many-objective constrained problem with a complex Pareto front involving exponential and sinusoidal terms, and a single constraint creating a disconnected feasible region.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW14 task.

Return type:

MTOP

MW2(M=2, D=15) → MTOP[source]

Generates the MW2 problem.

MW2 features a linear Pareto front (f2 = 1 - f1) with a multi-modal g function and a nonlinear constraint boundary.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW2 task.

Return type:

MTOP

MW3(M=2, D=15) → MTOP[source]

Generates the MW3 problem.

MW3 features a linear Pareto front (f2 = 1 - f1) with two constraints that create a complex feasible region.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW3 task.

Return type:

MTOP

MW4(M=3, D=15) → MTOP[source]

Generates the MW4 problem.

MW4 is a multi/many-objective constrained problem with a simplex-shaped Pareto front and a nonlinear constraint.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW4 task.

Return type:

MTOP

MW5(M=2, D=15) → MTOP[source]

Generates the MW5 problem.

MW5 features a quarter-circle Pareto front with three constraints that create a complex feasible region with disconnected segments.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW5 task.

Return type:

MTOP

MW6(M=2, D=15) → MTOP[source]

Generates the MW6 problem.

MW6 features an elliptical Pareto front with a complex constraint based on angular position.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW6 task.

Return type:

MTOP

MW7(M=2, D=15) → MTOP[source]

Generates the MW7 problem.

MW7 features a quarter-circle Pareto front with two constraints that create a complex angular-dependent feasible region.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW7 task.

Return type:

MTOP

MW8(M=3, D=15) → MTOP[source]

Generates the MW8 problem.

MW8 is a multi/many-objective constrained problem with a normalized spherical Pareto front and a constraint based on the angular position of the last objective.

Parameters:

M (int, optional) – Number of objectives (default is 3).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW8 task.

Return type:

MTOP

MW9(M=2, D=15) → MTOP[source]

Generates the MW9 problem.

MW9 features a concave Pareto front (f2 = 1 - f1^0.6) with three constraints that create a complex feasible region with multiple disconnected segments.

Parameters:

M (int, optional) – Number of objectives (default is 2).
D (int, optional) – Number of decision variables (default is 15).

Returns:

A Multi-Task Optimization Problem instance containing the MW9 task.

Return type:

MTOP

problem_information = {'n_cases': 14, 'n_cons': '[1, 4]', 'n_dims': 'D', 'n_objs': '[2, 3]', 'n_tasks': '1', 'type': 'synthetic'}

MTSO Problems:

class ddmtolab.Problems.MTSO.cec17_mtso.CEC17MTSO[source]

Implementation of the CEC 2017 Competition on Evolutionary Multi-Task Optimization (EMTO) benchmark problems P1 to P9.

These problems are two-task optimization scenarios designed to test the ability of algorithms to leverage knowledge transfer under various relationships between tasks (similarity of global optima and search spaces).

Notes

Fixed parameters by benchmark definition: - D=50 (decision variables), except P6 whose second task is 25-dimensional - K=2 (number of tasks)

Variables:: data_dir (str) – The directory path for problem data files.

P1() → MTOP[source]

Generates Problem 1: CI-HS (Complete Intersection - High Similarity).

Task 1: Rotated and shifted Griewank (Dim 50, [-100, 100])
Task 2: Rotated and shifted Rastrigin (Dim 50, [-50, 50])
Characteristic: Complete Overlap of the global optima and High Similarity of the solution space structures (Griewank, Rastrigin are both multi-modal).

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P2() → MTOP[source]

Generates Problem 2: CI-MS (Complete Intersection - Medium Similarity).

Task 1: Rotated and shifted Ackley (Dim 50, [-50, 50])
Task 2: Rotated and shifted Rastrigin (Dim 50, [-50, 50])
Characteristic: Complete Overlap of the global optima and Medium Similarity of the solution space structures (Ackley is generally smoother than Rastrigin).

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P3() → MTOP[source]

Generates Problem 3: CI-LS (Complete Intersection - Low Similarity).

Task 1: Rotated and shifted Ackley (Dim 50, [-50, 50])
Task 2: Standard Schwefel (Dim 50, [-500, 500])
Characteristic: Complete Overlap of the global optima and Low Similarity of the solution space structures (Schwefel is very difficult, Ackley is moderate).

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P4() → MTOP[source]

Generates Problem 4: PI-HS (Partial Intersection - High Similarity).

Task 1: Rotated and shifted Rastrigin (Dim 50, [-50, 50])
Task 2: Shifted Sphere (Dim 50, [-100, 100])
Characteristic: Partial Overlap of the global optima and High Similarity of the solution space structures (Rastrigin is multi-modal, Sphere is uni-modal).

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P5() → MTOP[source]

Generates Problem 5: PI-MS (Partial Intersection - Medium Similarity).

Task 1: Rotated and shifted Ackley (Dim 50, [-50, 50])
Task 2: Standard Rosenbrock (Dim 50, [-50, 50])
Characteristic: Partial Overlap of the global optima and Medium Similarity of the solution space structures (Ackley is multi-modal, Rosenbrock is uni-modal and valley-shaped).

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P6() → MTOP[source]

Generates Problem 6: PI-LS (Partial Intersection - Low Similarity).

Task 1: Rotated and shifted Ackley (Dim 50, [-50, 50])
Task 2: Rotated and shifted Weierstrass (Dim 25, [-0.5, 0.5])
Characteristic: Partial Overlap of the global optima, Unequal Dimensions (50 vs 25), and Low Similarity (Weierstrass is highly complex and non-differentiable).

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P7() → MTOP[source]

Generates Problem 7: NI-HS (No Intersection - High Similarity).

Task 1: Standard Rosenbrock (Dim 50, [-50, 50])
Task 2: Rotated and shifted Rastrigin (Dim 50, [-50, 50])
Characteristic: No Overlap of the global optima and High Similarity of the solution space structures.

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P8() → MTOP[source]

Generates Problem 8: NI-MS (No Intersection - Medium Similarity).

Task 1: Rotated and shifted Griewank (Dim 50, [-100, 100])
Task 2: Rotated and shifted Weierstrass (Dim 50, [-0.5, 0.5])
Characteristic: No Overlap of the global optima and Medium Similarity of the solution space structures.

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

P9() → MTOP[source]

Generates Problem 9: NI-LS (No Intersection - Low Similarity).

Task 1: Rotated and shifted Rastrigin (Dim 50, [-50, 50])
Task 2: Standard Schwefel (Dim 50, [-500, 500])
Characteristic: No Overlap of the global optima and Low Similarity of the solution space structures (Rastrigin is multi-modal, Schwefel is highly complex/difficult).

Returns:: A Multi-Task Optimization Problem instance containing Task 1 and Task 2.
Return type:: MTOP

problem_information = {'n_cases': 9, 'n_cons': '0', 'n_dims': '[25, 50]', 'n_objs': '1', 'n_tasks': '2', 'type': 'synthetic'}

class ddmtolab.Problems.MTSO.cec17_mtso_10d.CEC17MTSO_10D[source]

Implementation of the 10-Dimensional (10D) versions of the CEC 2017 Multi-Task Optimization (MTSO) benchmark problems P1 to P9.

These problems maintain the same underlying functions and global optima relationships as the original 50D CEC17 MTSO set but are configured with a reduced search space dimensionality (D=10) for both tasks.

Notes

Fixed parameters by benchmark definition: - D=10 (decision variables) - K=2 (number of tasks)

Variables:: data_dir (str) – The directory path for 10D problem data files.

P1() → MTOP[source]

Generates Problem 1 (10D): T1: Griewank, T2: Rastrigin.

T1: Griewank (Dim 10, [-100, 100]) - Standard
T2: Rastrigin (Dim 10, [-50, 50]) - Standard
Relationship: Global optima are at origin (0) for both tasks (Complete Intersection).

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P2() → MTOP[source]

Generates Problem 2 (10D): T1: Rosenbrock, T2: Rastrigin.

T1: Rosenbrock (Dim 10, [-50, 50]) - Shifted to (1, …, 1)
T2: Rastrigin (Dim 10, [-50, 50]) - Shifted to (1, …, 1)
Relationship: Global optima are at (1, …, 1) for both tasks (Complete Intersection).

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P3() → MTOP[source]

Generates Problem 3 (10D): T1: Griewank, T2: Weierstrass.

T1: Griewank (Dim 10, [-100, 100]) - Shifted to (10, …, 10)
T2: Weierstrass (Dim 10, [-0.5, 0.5]) - Shifted to (1, …, 1)
Relationship: Global optima are misaligned (No Intersection).

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P4() → MTOP[source]

Generates Problem 4 (10D): T1: Ackley, T2: Rosenbrock.

T1: Ackley (Dim 10, [-50, 50]) - Rotated and Shifted (Data loaded from P4.mat)
T2: Rosenbrock (Dim 10, [-50, 50]) - Standard (optimum at origin $mathbf{0}$)
Relationship: Partial Intersection of global optima due to rotation/shift in T1.

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P5() → MTOP[source]

Generates Problem 5 (10D): T1: Rastrigin, T2: Sphere.

T1: Rastrigin (Dim 10, [-50, 50]) - Rotated and Shifted (Data loaded from P5.mat)
T2: Sphere (Dim 10, [-100, 100]) - Shifted (Data loaded from P5.mat)
Relationship: Partial Intersection of global optima.

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P6() → MTOP[source]

Generates Problem 6 (10D): T1: Ackley, T2: Rastrigin.

T1: Ackley (Dim 10, [-50, 50]) - Rotated and Shifted (Data loaded from P6.mat)
T2: Rastrigin (Dim 10, [-50, 50]) - Rotated and Shifted (Data loaded from P6.mat)
Relationship: Complete Intersection of global optima, but different rotations (Data files define this).

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P7() → MTOP[source]

Generates Problem 7 (10D): T1: Ackley, T2: Schwefel.

T1: Ackley (Dim 10, [-50, 50]) - Rotated and Shifted (Data loaded from P7.mat)
T2: Schwefel (Dim 10, [-500, 500]) - Standard (optimum at origin $mathbf{0}$)
Relationship: Partial Intersection of global optima.

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P8() → MTOP[source]

Generates Problem 8 (10D): T1: Ackley, T2: Weierstrass.

T1: Ackley (Dim 10, [-50, 50]) - Rotated and Shifted (Data loaded from P8.mat)
T2: Weierstrass (Dim 10, [-0.5, 0.5]) - Rotated (Data loaded from P8.mat)
Relationship: Partial Intersection of global optima.

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

P9() → MTOP[source]

Generates Problem 9 (10D): T1: Rastrigin, T2: Schwefel.

T1: Rastrigin (Dim 10, [-50, 50]) - Rotated and Shifted (Data loaded from P9.mat)
T2: Schwefel (Dim 10, [-500, 500]) - Standard (optimum at origin $mathbf{0}$)
Relationship: Partial Intersection of global optima.

Returns:: A Multi-Task Optimization Problem instance containing the two tasks.
Return type:: MTOP

problem_information = {'n_cases': 9, 'n_cons': '0', 'n_dims': '10', 'n_objs': '1', 'n_tasks': '2', 'type': 'synthetic'}

class ddmtolab.Problems.MTSO.cec19_matso.CEC19MaTSO[source]

Implementation of the CEC 2019 Competition on Massive Multi-Task Optimization (MaTSO) benchmark problems P1 to P6.

These problems are designed to challenge algorithms with a large number of optimization tasks (typically 100 or more) derived from the same underlying function, but with different rotations and shifts, thereby testing transfer learning across many similar, but distinct tasks.

Variables:

dim (int) – The dimensionality of the search space for all tasks (fixed at 50).
data_dir (str) – The directory path for problem data files.

P1(K=10) → MTOP[source]

Generates Problem 1 (MaTSO): Rosenbrock tasks.

Each task is a 50D Rosenbrock function, rotated and shifted.

Parameters:: K (int, optional) – Number of tasks to create (default: 10).

Notes

Fixed parameters by benchmark definition: D=50

Function: Rosenbrock
Dimensions: 50D
Bounds: [-50, 50]

Returns:: A Multi-Task Optimization Problem instance containing task_num tasks.
Return type:: MTOP

P2(K=10) → MTOP[source]

Generates Problem 2 (MaTSO): Ackley tasks.

Each task is a 50D Ackley function, rotated and shifted.

Parameters:: K (int, optional) – Number of tasks to create (default: 10).

Notes

Fixed parameters by benchmark definition: D=50

Function: Ackley
Dimensions: 50D
Bounds: [-50, 50]

Returns:: A Multi-Task Optimization Problem instance containing task_num tasks.
Return type:: MTOP

P3(K=10) → MTOP[source]

Generates Problem 3 (MaTSO): Rastrigin tasks.

Each task is a 50D Rastrigin function, rotated and shifted.

Parameters:: K (int, optional) – Number of tasks to create (default: 10).

Notes

Fixed parameters by benchmark definition: D=50

Function: Rastrigin
Dimensions: 50D
Bounds: [-50, 50]

Returns:: A Multi-Task Optimization Problem instance containing task_num tasks.
Return type:: MTOP

P4(K=10) → MTOP[source]

Generates Problem 4 (MaTSO): Griewank tasks.

Each task is a 50D Griewank function, rotated and shifted.

Parameters:: K (int, optional) – Number of tasks to create (default: 10).

Notes

Fixed parameters by benchmark definition: D=50

Function: Griewank
Dimensions: 50D
Bounds: [-100, 100]

Returns:: A Multi-Task Optimization Problem instance containing task_num tasks.
Return type:: MTOP

P5(K=10) → MTOP[source]

Generates Problem 5 (MaTSO): Weierstrass tasks.

Each task is a 50D Weierstrass function, rotated and shifted.

Parameters:: K (int, optional) – Number of tasks to create (default: 10).

Notes

Fixed parameters by benchmark definition: D=50

Function: Weierstrass
Dimensions: 50D
Bounds: [-0.5, 0.5]

Returns:: A Multi-Task Optimization Problem instance containing task_num tasks.
Return type:: MTOP

P6(K=10) → MTOP[source]

Generates Problem 6 (MaTSO): Schwefel tasks.

Each task is a 50D Schwefel function, rotated and shifted.

Parameters:: K (int, optional) – Number of tasks to create (default: 10).

Notes

Fixed parameters by benchmark definition: D=50

Function: Schwefel
Dimensions: 50D
Bounds: [-500, 500]

Returns:: A Multi-Task Optimization Problem instance containing task_num tasks.
Return type:: MTOP

problem_information = {'n_cases': 6, 'n_cons': '0', 'n_dims': '50', 'n_objs': '1', 'n_tasks': 'K', 'type': 'synthetic'}

class ddmtolab.Problems.MTSO.cmt.CMT[source]

CMT (Constrained Multi-Task) benchmark problems.

This class provides constrained multi-task optimization problems with various function combinations and constraint types.

CMT1(D: int = 50) → MTOP[source]

CMT Problem 1: Griewank (Type 1 constraint) + Rastrigin (Type 1 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT2(D: int = 50) → MTOP[source]

CMT Problem 2: Ackley (Type 2 constraint) + Rastrigin (Type 2 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT3(D: int = 50) → MTOP[source]

CMT Problem 3: Ackley (Type 2 constraint) + Schwefel (Type 1 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT4(D: int = 50) → MTOP[source]

CMT Problem 4: Rastrigin (Type 1 constraint) + Sphere (Type 1 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT5(D: int = 50) → MTOP[source]

CMT Problem 5: Ackley (Type 1 constraint) + Rosenbrock (Type 2 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT6(D: int = 50) → MTOP[source]

CMT Problem 6: Ackley (Type 2 constraint) + Weierstrass (Type 3 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT7(D: int = 50) → MTOP[source]

CMT Problem 7: Rosenbrock (Type 1 constraint) + Rastrigin (Type 1 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT8(D: int = 50) → MTOP[source]

CMT Problem 8: Griewank (Type 2 constraint) + Weierstrass (Type 3 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

CMT9(D: int = 50) → MTOP[source]

CMT Problem 9: Rastrigin (Type 4 constraint) + Schwefel (Type 2 constraint).

Parameters:: D (int, optional) – Number of decision variables (default is 50).
Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

problem_information = {'n_cases': 9, 'n_cons': '[1, 2]', 'n_dims': 'D', 'n_objs': '1', 'n_tasks': '2', 'type': 'synthetic'}

class ddmtolab.Problems.MTSO.stop.STOP[source]

Implementation of STOP (Scalable Test Problem Generator for Sequential Transfer Optimization) benchmark problems.

These problems are designed to challenge algorithms with many tasks derived from various benchmark functions with different characteristics, testing transfer learning across many similar but distinct tasks.

Reference: X. Xue et al., “A Scalable Test Problem Generator for Sequential Transfer Optimization,” IEEE Trans. Cybern., vol. 55, no. 5, pp. 2110-2123, 2025.

Variables:: data_dir (str) – The directory path for problem data files.

STOP1(K=10) → MTOP[source]: STOP Problem 1: Sphere-Ta-hh2-d50-k49

STOP10(K=10) → MTOP[source]: STOP Problem 10: Rastrigin-Te-hl2-d30-k49

STOP11(K=10) → MTOP[source]: STOP Problem 11: Ackley-Ta-hl2-d50-k49

STOP12(K=10) → MTOP[source]: STOP Problem 12: Ellipsoid-Te-hl1-d50-k49

STOP2(K=10) → MTOP[source]: STOP Problem 2: Ellipsoid-Te-hh2-d25-k49

STOP3(K=10) → MTOP[source]: STOP Problem 3: Schwefel-Ta-hh2-d30-k49

STOP4(K=10) → MTOP[source]: STOP Problem 4: Quartic-Te-hh2-d50-k49

STOP5(K=10) → MTOP[source]: STOP Problem 5: Ackley-Ta-hm1-d25-k49

STOP6(K=10) → MTOP[source]: STOP Problem 6: Rastrigin-Te-hm2-d50-k49

STOP7(K=10) → MTOP[source]: STOP Problem 7: Griewank-Ta-hm3-d25-k49

STOP8(K=10) → MTOP[source]: STOP Problem 8: Levy-Te-hm4-d30-k49

STOP9(K=10) → MTOP[source]: STOP Problem 9: Sphere-Ta-hl1-d25-k49

static S_Ellipsoid(var, opt)[source]: Ellipsoid function (STOP variant, shifted only).

static S_Levy(var, opt)[source]: Levy function (STOP variant, shifted only).

static S_Quartic(var, opt)[source]: Quartic function with noise (STOP variant, shifted only).

static S_Schwefel(var, opt)[source]: Schwefel 2.2 function (STOP variant, shifted only).

problem_information = {'n_cases': 12, 'n_cons': '0', 'n_dims': '[25, 50]', 'n_objs': '1', 'n_tasks': 'K', 'type': 'synthetic'}

class ddmtolab.Problems.MTSO.many_task_10d.ManyTask_10D[source]

Many-Task Optimization Benchmark (10D).

Contains 4 problems: - P1, P2: 3 tasks each - P3, P4: 5 tasks each

All tasks are 10-dimensional single-objective unconstrained problems.

Variables:: problem_information (dict) – Metadata about the benchmark suite.

P1() → MTOP[source]

Problem 1 (3 tasks, high similarity).

T1: Griewank ([-100, 100]), optimum at origin
T2: Rastrigin ([-50, 50]), optimum at origin
T3: Ackley ([-50, 50]), optimum at origin

All three tasks share the same global optimum at the origin, resulting in complete intersection and strong positive transfer.

Returns:: A 3-task optimization problem.
Return type:: MTOP

P2() → MTOP[source]

Problem 2 (3 tasks, high similarity).

T1: Rosenbrock ([-50, 50]), shifted to (1, …, 1)
T2: Rastrigin ([-50, 50]), shifted to (1, …, 1)
T3: Sphere ([-100, 100]), shifted to (1, …, 1)

All tasks have global optima near (1, …, 1) in the original decision space, yielding close optima in the [0, 1] unified space.

Returns:: A 3-task optimization problem.
Return type:: MTOP

P3() → MTOP[source]

Problem 3 (5 tasks, medium-high similarity).

T1: Ackley ([-50, 50]), rotated (R1), optimum at origin
T2: Ackley ([-50, 50]), rotated (R2), optimum at origin
T3: Rastrigin ([-50, 50]), rotated (R3), optimum at origin
T4: Rastrigin ([-50, 50]), rotated (R4), optimum at origin
T5: Griewank ([-100, 100]), identity rotation, optimum at origin

All five tasks share the same global optimum at the origin. Different rotation matrices create landscape diversity while preserving complete intersection of optima.

Returns:: A 5-task optimization problem.
Return type:: MTOP

P4() → MTOP[source]

Problem 4 (5 tasks, medium similarity).

T1: Sphere ([-100, 100]), optimum at origin
T2: Sphere ([-100, 100]), optimum at (2, …, 2)
T3: Rastrigin ([-50, 50]), optimum at origin
T4: Rastrigin ([-50, 50]), optimum at (2, …, 2)
T5: Ackley ([-50, 50]), optimum at (1, …, 1)

Tasks form two groups (Sphere pair, Rastrigin pair) with an Ackley task bridging them. Within each group, optima are close in the [0, 1] unified space (0.50 vs 0.51 for Sphere, 0.50 vs 0.52 for Rastrigin), encouraging selective knowledge transfer.

Returns:: A 5-task optimization problem.
Return type:: MTOP

problem_information = {'n_cases': 4, 'n_cons': '0', 'n_dims': '10', 'n_objs': '1', 'n_tasks': '[3, 5]', 'type': 'synthetic'}

MTMO Problems:

class ddmtolab.Problems.MTMO.cec17_mtmo.CEC17MTMO[source]

Implementation of the CEC 2017 Competition on Evolutionary Multi-Task Multi-Objective Optimization (MTMO) benchmark problems P1 to P9.

These problems consist of two multi-objective optimization tasks (MO-tasks) with shared variables, designed to test knowledge transfer in the presence of multiple conflicting objectives. All tasks are minimization problems.

Notes

Fixed parameters by benchmark definition: - K=2 (number of tasks) - D and M vary by problem (see individual method docstrings)

Variables:: data_dir (str) – The directory path for problem data files.

P1() → MTOP[source]

Generates Problem 1: T1 (ZDT3-like) vs T2 (ZDT2-like).

Both tasks are 2-objective, 50-dimensional.

T1: Modified ZDT3-like, PF is discontinuous, non-convex (Curved, Piecewise).
T2: Modified ZDT2-like, PF is continuous, non-convex.
Relationship: Decision space overlap exists only in $x_1$ dimension ($[0, 1]$).

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P2() → MTOP[source]

Generates Problem 2: T1 (ZDT2-like, Rosenbrock) vs T2 (ZDT3-like, Rotated).

Both tasks are 2-objective, 10-dimensional.

T1: Modified ZDT2-like with Rosenbrock-like component.
T2: Modified ZDT3-like with rotated non-linear component (Mcm2).
Relationship: Decision variables are coupled and search spaces are different.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P3() → MTOP[source]

Generates Problem 3: T1 (ZDT3-like, Rastrigin) vs T2 (ZDT1-like, Ackley).

Both tasks are 2-objective, 50-dimensional.

T1: Modified ZDT3-like with Rastrigin-like component in $g$. PF is discontinuous, non-convex.
T2: Modified ZDT1-like with Ackley-like component in $g$. PF is continuous, convex.
Relationship: Tasks have different search spaces and different $g$-functions.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P4() → MTOP[source]

Generates Problem 4: T1 (ZDT1-like, Sphere) vs T2 (ZDT1-like, Rastrigin).

Both tasks are 2-objective, 50-dimensional.

T1: Modified ZDT1-like with Sphere component in $g$. PF is continuous, convex.
T2: Modified ZDT1-like with shifted Rastrigin component (Sph2) in $g$. PF is continuous, convex.
Relationship: The $g$-functions and search spaces are different.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P5() → MTOP[source]

Generates Problem 5: T1 (ZDT3-like, Rotated Sphere) vs T2 (ZDT2-like, Rotated Rastrigin).

Both tasks are 2-objective, 50-dimensional.

T1: Modified ZDT3-like with rotated and shifted Sphere component in $g$ (Mpm1, Spm1). PF is discontinuous, non-convex.
T2: Modified ZDT2-like with rotated Rastrigin component in $g$ (Mpm2). PF is continuous, non-convex.
Relationship: Different problem landscapes and global optimum locations in the search space.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P6() → MTOP[source]

Generates Problem 6: T1 (ZDT3-like, Griewank) vs T2 (ZDT3-like, Ackley).

Both tasks are 2-objective, 50-dimensional.

T1: Modified ZDT3-like with Griewank component in $g$. PF is discontinuous, non-convex.
T2: Modified ZDT3-like with shifted Ackley component (Spl2) in $g$. PF is discontinuous, non-convex.
Relationship: PF shapes are similar, but $g$-functions and search spaces are different.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P7() → MTOP[source]

Generates Problem 7: T1 (ZDT3-like, Rosenbrock) vs T2 (ZDT1-like, Sphere).

Both tasks are 2-objective, 50-dimensional.

T1: Modified ZDT3-like with Rosenbrock component in $g$. PF is discontinuous, non-convex.
T2: Modified ZDT1-like with Sphere component in $g$. PF is continuous, convex.
Relationship: Highly multi-modal $g$-function in T1 and different PF shapes.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P8() → MTOP[source]

Generates Problem 8: T1 (DTLZ1-like, 3-obj) vs T2 (ZDT2-like, 2-obj).

T1 is 3-objective, T2 is 2-objective. Both are 20-dimensional.

T1: Modified DTLZ1-like with Rosenbrock component in $g$. PF is a plane (linear).
T2: Modified ZDT2-like with rotated Sphere component in $g$ (Mnm2). PF is continuous, non-convex.
Relationship: Tasks have different number of objectives and different PF shapes/geometries.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P9() → MTOP[source]

Generates Problem 9: T1 (DTLZ1-like, 3-obj) vs T2 (ZDT2-like, 2-obj).

T1 is 3-objective (25-dimensional), T2 is 2-objective (50-dimensional).

T1: Modified DTLZ1-like with shifted Griewank component (Snl1) in $g$. PF is a plane (linear).
T2: Modified ZDT2-like with Ackley component in $g$. PF is continuous, non-convex.
Relationship: Different objectives, different dimensions, and different PF shapes.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

problem_information = {'n_cases': 9, 'n_cons': '0', 'n_dims': '[10, 50]', 'n_objs': '[2, 3]', 'n_tasks': '2', 'type': 'synthetic'}

class ddmtolab.Problems.MTMO.cec19_mtmo.CEC19MTMO[source]

Implementation of the CEC 2019 Competition on Evolutionary Multi-Task Multi-Objective Optimization (MTMO) benchmark problems.

These problems are based on the LZ09 test suite and consist of multiple tasks with different configurations designed to test knowledge transfer in multi-objective optimization scenarios.

Notes

Fixed parameters by benchmark definition: - K=2 (number of tasks) - D and M vary by problem (see individual method docstrings)

P1() → MTOP[source]

Generates Problem P1 (CPLX1): T1 (LZ09_F1) vs T2 (LZ09_F2).

Both tasks are 2-objective, 10-dimensional.

T1: LZ09_F1 with ptype=21, dtype=1, ltype=21
T2: LZ09_F2 with ptype=21, dtype=1, ltype=22
Relationship: Same PF shape (ptype=21), different link functions

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P10() → MTOP[source]

Generates Problem P10 (CPLX10): T1 (LZ09_F7) vs T2 (LZ09_F8).

Both tasks are 2-objective, 10-dimensional.

T1: LZ09_F7 with ptype=21, dtype=3, ltype=21
T2: LZ09_F8 with ptype=21, dtype=4, ltype=21
Relationship: Same PF shape (ptype=21), different distance functions and search spaces

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P2() → MTOP[source]

Generates Problem P2 (CPLX2): T1 (LZ09_F1) vs T2 (LZ09_F7).

Both tasks are 2-objective, 10-dimensional.

T1: LZ09_F1 with ptype=21, dtype=1, ltype=21
T2: LZ09_F7 with ptype=21, dtype=3, ltype=21 # 修正：dtype=3
Relationship: Same PF shape (ptype=21), different distance functions

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P3() → MTOP[source]

Generates Problem P3 (CPLX3): T1 (LZ09_F2) vs T2 (LZ09_F4).

Both tasks are 2-objective, 30-dimensional.

T1: LZ09_F2 with ptype=21, dtype=1, ltype=22
T2: LZ09_F4 with ptype=21, dtype=1, ltype=24
Relationship: Same PF shape (ptype=21), different link functions and search spaces

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P4() → MTOP[source]

Generates Problem P4 (CPLX4): T1 (LZ09_F2) vs T2 (LZ09_F9).

Both tasks are 2-objective, 30-dimensional.

T1: LZ09_F2 with ptype=21, dtype=1, ltype=22
T2: LZ09_F9 with ptype=22, dtype=1, ltype=22
Relationship: Different PF shapes (ptype=21 vs ptype=22), same link function

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P5() → MTOP[source]

Generates Problem P5 (CPLX5): T1 (LZ09_F3, 2-obj) vs T2 (LZ09_F6, 3-obj).

Tasks have different objectives and dimensions.

T1: LZ09_F3, 2-objective, 30-dimensional, ptype=21, dtype=1, ltype=23
T2: LZ09_F6, 3-objective, 10-dimensional, ptype=31, dtype=1, ltype=32
Relationship: Different number of objectives and dimensions

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P6() → MTOP[source]

Generates Problem P6 (CPLX6): T1 (LZ09_F3) vs T2 (LZ09_F9).

Both tasks are 2-objective, 30-dimensional.

T1: LZ09_F3 with ptype=21, dtype=1, ltype=23
T2: LZ09_F9 with ptype=22, dtype=1, ltype=22
Relationship: Different PF shapes and search spaces

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P7() → MTOP[source]

Generates Problem P7 (CPLX7): T1 (LZ09_F4) vs T2 (LZ09_F5).

Both tasks are 2-objective, 30-dimensional.

T1: LZ09_F4 with ptype=21, dtype=1, ltype=24
T2: LZ09_F5 with ptype=21, dtype=1, ltype=26
Relationship: Same PF shape (ptype=21), different link functions

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P8() → MTOP[source]

Generates Problem P8 (CPLX8): T1 (LZ09_F5) vs T2 (LZ09_F7).

Both tasks are 2-objective with different dimensions.

T1: LZ09_F5, 30-dimensional, ptype=21, dtype=1, ltype=26
T2: LZ09_F7, 10-dimensional, ptype=21, dtype=3, ltype=21
Relationship: Same PF shape (ptype=21), different dimensions and link functions
Note: x1 and x2 both in [0,1] for both tasks

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P9() → MTOP[source]

Generates Problem P9 (CPLX9): T1 (LZ09_F6, 3-obj) vs T2 (LZ09_F9, 2-obj).

Tasks have different objectives and dimensions.

T1: LZ09_F6, 3-objective, 10-dimensional, ptype=31, dtype=1, ltype=32
T2: LZ09_F9, 2-objective, 30-dimensional, ptype=22, dtype=1, ltype=22
Relationship: Different number of objectives, dimensions, and PF shapes
Note: x1 and x2 both in [0,1] for both tasks

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

problem_information = {'n_cases': 10, 'n_cons': '0', 'n_dims': '[10, 30]', 'n_objs': '[2, 3]', 'n_tasks': '2', 'type': 'synthetic'}

class ddmtolab.Problems.MTMO.cec19_matmo.CEC19_MaTMO[source]

Implementation of CEC19 MaTMO (Many-Task Multi-Objective) benchmark problems P1-P6.

CRITICAL: P1, P4, P6 use DTLZ formulation: P2, P3, P5 use ZDT formulation

Notes

Fixed parameters by benchmark definition: - D=50 (decision variables), except P3 which is 10-dimensional - M=2 (number of objectives) - K is configurable (default is 10)

Variables:: data_dir (str) – The directory path for problem data files.

P1(K=10) → MTOP[source]

P1: Sphere + Circular PF (DTLZ formulation)

Dimension: 50
g-function: Sphere
PF: Circular (DTLZ-style)

P2(K=10) → MTOP[source]

P2: Mean + Concave PF (ZDT formulation)

Dimension: 50
g-function: Mean
PF: Concave

P3(K=10) → MTOP[source]

P3: Rosenbrock + Concave PF (ZDT formulation)

Dimension: 10
g-function: Rosenbrock
PF: Concave

P4(K=10) → MTOP[source]

P4: Rastrigin + Circular PF (DTLZ formulation)

Dimension: 50
g-function: Rastrigin
PF: Circular (DTLZ-style)

P5(K=10) → MTOP[source]

P5: Ackley + Convex PF (ZDT formulation)

Dimension: 50
g-function: Ackley
PF: Convex

P6(K=10) → MTOP[source]

P6: Griewank + Circular PF (DTLZ formulation)

Dimension: 50
g-function: Griewank
PF: Circular (DTLZ-style)

problem_information = {'n_cases': 6, 'n_cons': '0', 'n_dims': '[10, 50]', 'n_objs': '2', 'n_tasks': 'K', 'type': 'synthetic'}

class ddmtolab.Problems.MTMO.cec21_mtmo.CEC21MTMO[source]

Implementation of the CEC 2021 Competition on Evolutionary Multi-Task Multi-Objective Optimization (MTMO) benchmark problems.

These problems consist of two multi-objective optimization tasks (MO-tasks) with shared variables, designed to test knowledge transfer in the presence of multiple conflicting objectives. All tasks are minimization problems.

Notes

Fixed parameters by benchmark definition: - K=2 (number of tasks) - D=50, M=2 for all problems

Variables:

data_dir (str) – The directory path for problem data files.
funcs (CEC21MTMOFunctions) – Instance of the functions helper class.

P1() → MTOP[source]

Generates Problem 1: T1 (MMDTLZ, F17) vs T2 (MMZDT, F17).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F17 (Modified Schwefel + Rastrigin + Elliptic).
T2: MMZDT-type with linear f1, hybrid function F17, and concave h.
Relationship: Different task types but same g-function complexity.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P10() → MTOP[source]

Generates Problem 10: T1 (MMDTLZ, F15) vs T2 (MMZDT, F17).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F15 (ExGriewRosen).
T2: MMZDT-type with linear f1, hybrid function F17 (Modified Schwefel + Rastrigin + Elliptic), and concave h.
Relationship: Different task types and different g-functions.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P2() → MTOP[source]: Generates Problem 2: T1 (MMDTLZ, F19) vs T2 (MMDTLZ, F19).

P3() → MTOP[source]

Generates Problem 3: T1 (MMDTLZ, F22) vs T2 (MMZDT, F22).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F22 (Katsuura + HappyCat + ExGriewRosen + Modified Schwefel + Ackley).
T2: MMZDT-type with linear f1, hybrid function F22, and convex h.
Relationship: Different task types but same g-function complexity.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P4() → MTOP[source]

Generates Problem 4: T1 (MMZDT, F15) vs T2 (MMZDT, F15).

Both tasks are 2-objective, 50-dimensional.

T1: MMZDT-type with linear f1, hybrid function F15 (ExGriewRosen), and convex h.
T2: MMZDT-type with linear f1, hybrid function F15 (ExGriewRosen), and convex h.
Relationship: Same task type and g-function, both convex.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P5() → MTOP[source]

Generates Problem 5: T1 (MMDTLZ, F4) vs T2 (MMZDT, F4).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F4 (Rosenbrock).
T2: MMZDT-type with linear f1, hybrid function F4 (Rosenbrock), and concave h.
Relationship: Different task types but same g-function (Rosenbrock).

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P6() → MTOP[source]

Generates Problem 6: T1 (MMDTLZ, F9) vs T2 (MMDTLZ, F9).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F9 (Rastrigin, rotated).
T2: MMDTLZ-type with hybrid function F9 (Rastrigin, rotated).
Relationship: Same task type and g-function.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P7() → MTOP[source]

Generates Problem 7: T1 (MMDTLZ, F8) vs T2 (MMZDT, F8).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F8 (Rastrigin, non-rotated).
T2: MMZDT-type with linear f1, hybrid function F8 (Rastrigin, non-rotated), and convex h.
Relationship: Different task types but same g-function.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P8() → MTOP[source]

Generates Problem 8: T1 (MMDTLZ, F18) vs T2 (MMZDT, F20).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F18 (Cigar + HGBat + Rastrigin).
T2: MMZDT-type with linear f1, hybrid function F20 (HGBat + Discus + ExGriewRosen + Rastrigin), and concave h.
Relationship: Different task types and different g-functions.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P9() → MTOP[source]

Generates Problem 9: T1 (MMDTLZ, F11) vs T2 (MMZDT, F18).

Both tasks are 2-objective, 50-dimensional.

T1: MMDTLZ-type with hybrid function F11 (Modified Schwefel).
T2: MMZDT-type with linear f1, hybrid function F18 (Cigar + HGBat + Rastrigin), and concave h.
Relationship: Different task types and different g-functions.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

problem_information = {'n_cases': 10, 'n_cons': '0', 'n_dims': '50', 'n_objs': '2', 'n_tasks': '2', 'type': 'synthetic'}

class ddmtolab.Problems.MTMO.mtmo_instance.MTMOInstances[source]

Additional Multi-Task Multi-Objective Optimization (MTMO) benchmark problems.

These problems consist of two multi-objective optimization tasks with different characteristics to test knowledge transfer capabilities.

Variables:: data_dir (str) – The directory path for problem data files.

P1() → MTOP[source]

Generates MTMO Instance 1: T1 (ZDT4_R, Rastrigin) vs T2 (ZDT4_G, Griewank).

Both tasks are 2-objective, 10-dimensional.

T1: Modified ZDT1-like with Rastrigin component in g-function. PF is continuous, convex.
T2: Modified ZDT2-like with Griewank component in g-function. PF is continuous, non-convex.
Relationship: Different g-functions create different landscape difficulties.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P2() → MTOP[source]

Generates MTMO Instance 2: T1 (ZDT4_RC, Rastrigin + Constraint) vs T2 (ZDT4_A, Ackley).

T1 is 2-objective with 1 constraint (10-dimensional). T2 is 2-objective without constraints (10-dimensional).

T1: Modified ZDT1-like with Rastrigin component and a sinusoidal constraint.
PF is continuous, convex, but partially infeasible.
T2: Modified ZDT2-like with Ackley component in g-function. PF is continuous, non-convex.
Relationship: One task has constraints while the other doesn’t, testing constraint handling transfer.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

problem_information = {'n_cases': 2, 'n_cons': '[0, 1]', 'n_dims': '10', 'n_objs': '2', 'n_tasks': '2', 'type': 'synthetic'}

Real-World Optimization (RWO) Problems:

class ddmtolab.Problems.RWO.pepvm.PEPVM[source]

Parameter Extraction of Photovoltaic Models (PEPVM) benchmark problem.

This problem consists of three single-objective optimization tasks for parameter extraction of different photovoltaic cell models using experimental I-V data.

Task 1: Single Diode Model (5 parameters)
Task 2: Double Diode Model (7 parameters)
Task 3: PV Module Model (5 parameters)

The tasks share similar parameter extraction objectives but differ in model complexity and experimental conditions.

References

[1] Li, S., Gu, Q., Gong, W., & Ning, B. (2020). An Enhanced Adaptive Differential Evolution Algorithm for Parameter Extraction of Photovoltaic Models. Energy Conversion and Management, 205, 112443. [2] Li, Y., Gong, W., & Li, S. (2022). Multitasking Optimization via an Adaptive Solver Multitasking Evolutionary Framework. Information Sciences. [3] Li, Y., Gong, W., & Li, S. (2023). Evolutionary Competitive Multitasking Optimization via Improved Adaptive Differential Evolution. Expert Systems with Applications, 119550.

Variables:: benchmark. (None required for this)

P1() → MTOP[source]

Generates PEPVM Problem: Three photovoltaic parameter extraction tasks.

Task 1: Single Diode Model (5-D, experimental data at 33°C)
Task 2: Double Diode Model (7-D, experimental data at 33°C)
Task 3: PV Module Model (5-D, experimental data at 45°C)

All tasks minimize RMSE between measured and modeled I-V characteristics.

Returns:: A Multi-Task Optimization Problem instance with 3 tasks.
Return type:: MTOP

problem_information = {'n_cases': 1, 'n_cons': '0', 'n_dims': '[5, 7]', 'n_objs': '1', 'n_tasks': '3', 'type': 'real_world'}

class ddmtolab.Problems.RWO.sopm.SOPM[source]

Implementation of Synchronous Optimal Pulse-width Modulation (SOPM) benchmark problems for Multi-Task Multi-Objective Optimization (MTMO).

These problems involve optimizing switching angles for multilevel inverters to minimize Total Harmonic Distortion (THD) and maintain desired fundamental voltage component while satisfying monotonicity constraints on switching angles.

References

[1] Y. Li, W. Gong, “Multiobjective Multitask Optimization with Multiple Knowledge Types and Transfer Adaptation,” IEEE Trans. Evol. Comput., 2024. [2] A. Kumar et al., “A Benchmark-suite of Real-world Constrained Multi-objective Optimization Problems and Some Baseline Results,” Swarm and Evolutionary Computation, vol. 67, 2021.

Notes

All problems are constrained 2-objective optimization problems where: - Objective 1: Total Harmonic Distortion (THD) - Objective 2: Squared deviation from target modulation index - Constraints: Monotonically decreasing switching angles

P1() → MTOP[source]

Generates SOPM MTMO Problem 1: [3, 5, 7]-level Inverters.

Three tasks optimizing switching angles for different inverter levels.

T1 (3-level): 2-objective, 25-dimensional * Decision variables: 25 switching angles in [0, 90] degrees * Target modulation index: m = 0.32 * Constraints: 24 monotonicity constraints (α_i ≥ α_{i+1})
T2 (5-level): 2-objective, 25-dimensional * Decision variables: 25 switching angles in [0, 90] degrees * Target modulation index: m = 0.32 * Constraints: 24 monotonicity constraints
T3 (7-level): 2-objective, 25-dimensional * Decision variables: 25 switching angles in [0, 90] degrees * Target modulation index: m = 0.36 * Constraints: 24 monotonicity constraints
Relationship: Different inverter levels with similar structure but different harmonic patterns. Tests knowledge transfer across inverter configurations.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

P2() → MTOP[source]

Generates SOPM MTMO Problem 2: [9, 11, 13]-level Inverters.

Three tasks optimizing switching angles for higher-level inverters.

T1 (9-level): 2-objective, 30-dimensional * Decision variables: 30 switching angles in [0, 90] degrees * Target modulation index: m = 0.32 * Constraints: 29 monotonicity constraints
T2 (11-level): 2-objective, 30-dimensional * Decision variables: 30 switching angles in [0, 90] degrees * Target modulation index: m = 0.3333 * Constraints: 29 monotonicity constraints
T3 (13-level): 2-objective, 30-dimensional * Decision variables: 30 switching angles in [0, 90] degrees * Target modulation index: m = 0.32 * Constraints: 29 monotonicity constraints
Relationship: Higher-level inverters with more complex harmonic patterns. Tests scalability and knowledge transfer for increased problem complexity.

Returns:: A Multi-Task Multi-Objective Optimization Problem instance.
Return type:: MTOP

problem_information = {'n_cases': 2, 'n_cons': '[24, 29]', 'n_dims': '[25, 30]', 'n_objs': '2', 'n_tasks': '3', 'type': 'real_world'}

class ddmtolab.Problems.RWO.nn_training.NN_Training(test_ratio=0.3, seed=42)[source]

Neural Network Weight Training benchmark suite for single-task optimization.

The decision variables are the flattened weights and biases of a fixed-architecture MLP. The optimization algorithm directly searches for optimal weight configurations – evaluation is a single forward pass (no gradient-based training), making these problems fast to evaluate.

Data is split into train / test. The optimization objective is the test set error rate (classification) or test MSE (regression).

Problems are ordered from easy to hard (by dimension & difficulty):

P	Dataset	Architecture	Dim	Task type
P1 P2 P3 P4 P5 P6	California Housing Diabetes Digits Covertype Digits (large net) Covertype (large net)	[8, 10, 1] [10, 10, 1] [64, 10, 10] [54, 20, 7] [64, 20, 10] [54, 30, 7]	101 121 760 1247 1510 1867	Regression Regression Classification Classification Classification Classification

Objectives (minimize):

Classification: test error rate (1 - accuracy), range [0, 1]
Regression: test MSE on standardized targets

Bounds: [-3, 3] for all weight parameters.

Parameters:

test_ratio (float, optional) – Fraction of data for testing (default 0.3).
seed (int, optional) – Random seed for train/test split (default 42).

P1() → MTOP[source]

Problem 1: California Housing regression.

Architecture: [8, 10, 1], 101-D. 5000 samples (subsampled). Objective: test MSE, minimize.

P2() → MTOP[source]

Problem 2: Diabetes regression.

Architecture: [10, 10, 1], 121-D. 442 samples. Objective: test MSE, minimize.

P3() → MTOP[source]

Problem 3: Digits classification (small net).

Architecture: [64, 10, 10], 760-D. 1797 samples, 10 classes. Objective: test error rate, minimize.

P4() → MTOP[source]

Problem 4: Covertype classification (medium net).

Architecture: [54, 20, 7], 1247-D. 5000 samples (subsampled), 7 classes. Objective: test error rate, minimize.

P5() → MTOP[source]

Problem 5: Digits classification (large net).

Architecture: [64, 20, 10], 1510-D. 1797 samples, 10 classes. Objective: test error rate, minimize.

P6() → MTOP[source]

Problem 6: Covertype classification (large net).

Architecture: [54, 30, 7], 1857-D. 5000 samples (subsampled), 7 classes. Objective: test error rate, minimize.

problem_information = {'n_cases': 6, 'n_cons': '0', 'n_dims': '[101, 1867]', 'n_objs': '1', 'n_tasks': '1', 'type': 'real_world'}

Traveling Salesman Problem (TSP) benchmark problems.

This module provides real-world combinatorial optimization problems formulated as continuous single-task optimization via random keys encoding. Each decision variable x_i in [0, 1] represents the priority of city i; the visiting order (permutation) is obtained by sorting these priorities (argsort).

This encoding allows standard continuous evolutionary algorithms (GA, DE, PSO, CMA-ES, etc.) to solve TSP without any problem-specific operator.

The objective is the total Euclidean tour length (round trip), to be minimized.

Problems are ordered from easy to hard (by number of cities):

P	Instance	Cities	Description
P1 P2 P3 P4 P5 P6	Random-20 Circle-30 Clustered-50 Random-50 Random-100 Random-200	20 30 50 50 100 200	Random layout Circular layout 5 clusters Random layout Random layout Random layout

References

[1] Reinelt, G. (1991). “TSPLIB – A Traveling Salesman Problem Library.” ORSA Journal on Computing, 3(4), 376-384. [2] Bean, J.C. (1994). “Genetic Algorithms and Random Keys for Sequencing and Optimization.” ORSA Journal on Computing, 6(2), 154-160. [3] Applegate, D.L., Bixby, R.E., Chvatal, V., and Cook, W.J. (2006). “The Traveling Salesman Problem: A Computational Study.” Princeton University Press.

class ddmtolab.Problems.RWO.tsp.TSP(seed=42)[source]

Traveling Salesman Problem (TSP) benchmark suite for single-task optimization.

Decision variables are random keys in [0, 1]: continuous values whose argsort defines the visiting permutation. This allows any continuous optimizer (GA, DE, PSO, CMA-ES, etc.) to solve TSP directly.

Objective (minimize): total Euclidean round-trip tour length.

Parameters:: seed (int, optional) – Random seed for city coordinate generation (default 42).

References

P1() → MTOP[source]

Problem 1: Random-20 – 20 random cities, 20-D.

Objective: total tour length, minimize.

References: [1] [2]

P2() → MTOP[source]

Problem 2: Circle-30 – 30 cities on a circle, 30-D.

The optimal tour visits cities in order around the circle. Objective: total tour length, minimize.

References: [1] [2]

P3() → MTOP[source]

Problem 3: Clustered-50 – 50 cities in 5 clusters, 50-D.

Cities are grouped in 5 clusters; intra-cluster distances are small. Objective: total tour length, minimize.

References: [1] [2] [3]

P4() → MTOP[source]

Problem 4: Random-50 – 50 random cities, 50-D.

Objective: total tour length, minimize.

References: [1] [2] [3]

P5() → MTOP[source]

Problem 5: Random-100 – 100 random cities, 100-D.

Objective: total tour length, minimize.

References: [1] [2] [3]

P6() → MTOP[source]

Problem 6: Random-200 – 200 random cities, 200-D.

Objective: total tour length, minimize.

References: [1] [2] [3]

plot_tour(problem_id, decision_vars, title=None, save_path=None, figsize=(8, 4), show=True) → float[source]

Plot the TSP tour defined by decision variables (random keys).

This is a visualisation helper, not a benchmark problem: unlike the P1-P6 methods it does not return an MTOP, so problem discovery skips it.

Parameters:

problem_id (int) – Problem index (1-6).
decision_vars (np.ndarray, shape (n_cities,)) – Decision variables in [0, 1]. The tour is obtained via argsort.
title (str, optional) – Figure title. If None, auto-generated from problem name and tour length.
save_path (str, optional) – If provided, save the figure to this path.
figsize (tuple, optional) – Figure size (default (8, 8)).
show (bool, optional) – Whether to call plt.show() (default True).

Returns:

The total tour length.

Return type:

float

problem_information = {'n_cases': 6, 'n_cons': '0', 'n_dims': '[20, 200]', 'n_objs': '1', 'n_tasks': '1', 'type': 'real_world'}

class ddmtolab.Problems.RWO.scp.SCP(Nmin=25, Nmax=35)[source]

Implementation of the Sensor Coverage Problem (SCP) for Multi-Task Optimization.

This problem involves optimizing sensor placements to maximize coverage of target points while minimizing the number of sensors and their sensing radii. Each task corresponds to a different number of sensors (variable-length optimization).

The problem optimizes sensor positions (x, y) and sensing radii (r) to: - Maximize coverage of target points - Minimize number of sensors - Minimize sensing costs (proportional to r²)

References

[1] M. L. Ryerkerk et al., “Solving Metameric Variable-length Optimization Problems Using Genetic Algorithms,” Genetic Programming and Evolvable Machines, vol. 18, no. 2, pp. 247-277, 2017. [2] G. Li et al., “Evolutionary Competitive Multitasking Optimization,” IEEE Trans. Evol. Comput., 2022.

Variables:

Nmin (int) – Minimum number of sensors (default: 25)
Nmax (int) – Maximum number of sensors (default: 35)
A (ndarray) – Target points to be covered, shape (n_points, 2)
data_dir (str) – The directory path for problem data files.

P1() → MTOP[source]

Generates SCP Problem 1: Multi-Task Sensor Coverage Optimization.

Creates tasks for different numbers of sensors from Nmin to Nmax. Each task optimizes sensor placements and radii.

Task Structure:

T_i (i sensors): 1-objective, (3*i)-dimensional
- Decision variables: [x1, y1, r1, x2, y2, r2, …, xi, yi, ri]
- x, y: Sensor positions in [-1, 1]
- r: Sensing radii in [0.1, 0.25]
- Objective: Weighted sum of:
  - Coverage penalty: 1000 * (1 - coverage_ratio)
  - Sensor count penalty: 1 * number_of_sensors
  - Sensing cost: 10 * sum(r²)
Relationship: Variable-length tasks with increasing complexity. Tests transfer learning across different problem dimensions.

Returns:: A Multi-Task Optimization Problem instance with (Nmax - Nmin + 1) tasks.
Return type:: MTOP

problem_information = {'n_cases': 1, 'n_cons': '0', 'n_dims': '[75, 105]', 'n_objs': '1', 'n_tasks': '11', 'type': 'real_world'}

class ddmtolab.Problems.RWO.mo_scp.MO_SCP[source]

Implementation of Multi-Objective Sensor Coverage Problem (MO_SCP) for Multi-Task Multi-Objective Optimization.

This problem extends the single-objective SCP to bi-objective optimization, balancing coverage maximization against sensor deployment costs. Each task corresponds to a different number of sensors with variable-length dimensions.

Objectives: - f1: Inverted coverage percentage (minimize uncovered area) - f2: Total sensor cost (number of sensors + sensing costs)

References

[1] Y. Li et al., “Transfer Search Directions Among Decomposed Subtasks for Evolutionary Multitasking in Multiobjective Optimization,” GECCO, 2024. [2] Y. Li et al., “Evolutionary Competitive Multiobjective Multitasking: One-Pass Optimization of Heterogeneous Pareto Solutions,” IEEE TEVC, 2024.

Variables:

A (ndarray) – Target points to be covered, shape (n_points, 2)
data_dir (str) – The directory path for problem data files.

P1(Nmin=28, K=5, gap=1) → MTOP[source]

Generates MO_SCP Problem 1: Multi-Objective Sensor Coverage with uniform gap.

Creates multiple tasks with different numbers of sensors, where sensor counts increase uniformly by a fixed gap.

Parameters:

Nmin (int, optional) – Minimum number of sensors (default: 28)
K (int, optional) – Number of tasks to create (default: 5)
gap (int, optional) – Gap between consecutive tasks’ sensor numbers (default: 1)
Structure (Task)
T_i (-) –
- Decision variables: [x1, y1, r1, …, xk, yk, rk]
- x, y: Sensor positions in [-1, 1]
- r: Sensing radii in [0.1, 0.25]
- Objective 1 (f1): Inverted coverage percentage (0-100)
- Objective 2 (f2): Total cost = sensor_count + 10*sum(r²)
Relationship (-) – learning across different problem scales.

Returns:

A Multi-Task Multi-Objective Optimization Problem instance.

Return type:

MTOP

P2(Nmin=25, K=4, gap=3) → MTOP[source]

Generates MO_SCP Problem 2: Multi-Objective Sensor Coverage with larger gap.

Creates multiple tasks with different numbers of sensors, where sensor counts increase with a larger gap. The second objective includes an additional coupling term for increased task correlation.

Parameters:

Nmin (int, optional) – Minimum number of sensors (default: 25)
K (int, optional) – Number of tasks to create (default: 4)
gap (int, optional) – Gap between consecutive tasks’ sensor numbers (default: 3)
Structure (Task)
T_i (-) –
- Decision variables: [x1, y1, r1, …, xk, yk, rk]
- x, y: Sensor positions in [-1, 1]
- r: Sensing radii in [0.1, 0.25]
- Objective 1 (f1): Inverted coverage percentage (0-100)
- Objective 2 (f2): Total cost + f1/10 (coupled objectives)
Relationship (-) – to test transfer learning in more heterogeneous scenarios.

Returns:

A Multi-Task Multi-Objective Optimization Problem instance.

Return type:

MTOP

problem_information = {'n_cases': 2, 'n_cons': '0', 'n_dims': '[75, 102]', 'n_objs': '2', 'n_tasks': '[4, 5]', 'type': 'real_world'}

class ddmtolab.Problems.RWO.pkacp.PKACP[source]

Implementation of Planar Kinematic Arm Control Problem (PKACP) for Multi-Task/Many-Task Single-Objective Optimization.

This problem involves controlling a planar kinematic arm with multiple joints to reach a target position. Each task has different constraints on the maximum angular range and link lengths, creating diverse optimization landscapes.

The objective is to minimize the Euclidean distance between the end effector position and the target position (0.5, 0.5).

References

[1] Y. Jiang et al., “A Bi-Objective Knowledge Transfer Framework for Evolutionary Many-Task Optimization,” IEEE TEVC, 2022. [2] H. Xu et al., “Evolutionary Multi-Task Optimization with Adaptive Knowledge Transfer,” IEEE TEVC, 2021.

Variables:: data_dir (str) – Directory for task parameter files (in user’s home directory)

P1(K=20, D=20) → MTOP[source]

Generates PKACP Problem 1: Planar Kinematic Arm Control.

Creates multiple tasks with different maximum angular ranges and link lengths. Each task optimizes joint angles to minimize the distance between the end effector and target position.

Parameters:

K (int, optional) – Number of tasks to create (default: 20)
D (int, optional) – Number of joints (dimensionality) for each task (default: 20)
Structure (Task)
T_i (-) –
- Decision variables: Joint angles in [0, 1]
- These are scaled to actual angular ranges based on task parameters
- Objective: Euclidean distance to target (0.5, 0.5)
Parameters (Task)
Amax (-)
Lmax (-)
Tessellation) (- These parameters are generated using CVT (Centroidal Voronoi) – to create diverse but structured task variations
Relationship (-) – learning across different arm configurations.

Returns:

A Multi-Task Optimization Problem instance with K tasks.

Return type:

MTOP

problem_information = {'n_cases': 1, 'n_cons': '0', 'n_dims': 'D', 'n_objs': '1', 'n_tasks': 'K', 'type': 'real_world'}

class ddmtolab.Problems.RWO.pinn_hpo.PINN_HPO[source]

Physics-Informed Neural Network Hyperparameter Optimization (PINN-HPO) benchmark suite.

This class provides a collection of multi-task optimization problems for tuning PINN hyperparameters across different PDEs (Convection, Reaction, Wave, Helmholtz). Each problem consists of multiple related tasks with varying PDE parameters.

Notes

Decision variables for all problems: - x[0]: Number of layers (integer, [2, 10]) - x[1]: Number of nodes per layer (integer, [5, 100]) - x[2]: Activation function (float, [0, 5] mapping to tanh/relu/sigmoid/sin/swish) - x[3]: Training epochs (integer, [5000, 100000]) - x[4]: Grid size (integer, [10, 200]) - x[5]: Learning rate (float, [1e-5, 0.1])

P1() → MTOP[source]

Generates Problem 1: Convection ($\beta=20$, $\beta=30$).

Two-task hyperparameter optimization for Convection PDE with different convection velocities.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P10() → MTOP[source]

Generates Problem 10: Mixed (Wave $\alpha=4, \beta=3$; Helmholtz $n=4$).

Two-task mixed hyperparameter optimization combining Wave and Helmholtz PDEs.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P11() → MTOP[source]

Generates Problem 11: Mixed (Convection $\beta=30$, Reaction $\rho=5$, Wave $\alpha=4, \beta=3$).

Three-task mixed hyperparameter optimization combining Convection, Reaction, and Wave PDEs.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P12() → MTOP[source]

Generates Problem 12: Mixed (Convection $\beta=30$, Reaction $\rho=5$, Wave $\alpha=4, \beta=3$, Helmholtz $n=4$).

Four-task mixed hyperparameter optimization combining all PDE types: Convection, Reaction, Wave, and Helmholtz.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P2() → MTOP[source]

Generates Problem 2: Reaction ($\rho=4$, $\rho=5$).

Two-task hyperparameter optimization for Reaction PDE with different reaction rates.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P3() → MTOP[source]

Generates Problem 3: Wave ($\alpha=3, \beta=3$; $\alpha=4, \beta=3$).

Two-task hyperparameter optimization for Wave PDE with different wave speed parameters.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P4() → MTOP[source]

Generates Problem 4: Helmholtz ($n=3$, $n=4$).

Two-task hyperparameter optimization for Helmholtz PDE with different wave number multipliers.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P5() → MTOP[source]

Generates Problem 5: Convection ($\beta=20$, $\beta=30$, $\beta=40$).

Three-task hyperparameter optimization for Convection PDE with different convection velocities.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P6() → MTOP[source]

Generates Problem 6: Reaction ($\rho=4$, $\rho=5$, $\rho=6$).

Three-task hyperparameter optimization for Reaction PDE with different reaction rates.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P7() → MTOP[source]

Generates Problem 7: Wave ($\alpha=3, \beta=3$; $\alpha=4, \beta=3$; $\alpha=4, \beta=4$).

Three-task hyperparameter optimization for Wave PDE with different wave speed and frequency parameters.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P8() → MTOP[source]

Generates Problem 8: Helmholtz ($n=3$, $n=4$, $n=5$).

Three-task hyperparameter optimization for Helmholtz PDE with different wave number multipliers.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

P9() → MTOP[source]

Generates Problem 9: Mixed (Convection $\beta=30$, Reaction $\rho=5$).

Two-task mixed hyperparameter optimization combining Convection and Reaction PDEs.

Returns:: A Multi-Task Optimization Problem instance.
Return type:: MTOP

static T10_helmholtz_n4(x)[source]

static T10_wave_alpha4_beta3(x)[source]

static T11_convection_beta30(x)[source]

static T11_reaction_rho5(x)[source]

static T11_wave_alpha4_beta3(x)[source]

static T12_convection_beta30(x)[source]

static T12_helmholtz_n4(x)[source]

static T12_reaction_rho5(x)[source]

static T12_wave_alpha4_beta3(x)[source]

static T1_convection_beta20(x)[source]

static T1_convection_beta30(x)[source]

static T2_reaction_rho4(x)[source]

static T2_reaction_rho5(x)[source]

static T3_wave_alpha3_beta3(x)[source]

static T3_wave_alpha4_beta3(x)[source]

static T4_helmholtz_n3(x)[source]

static T4_helmholtz_n4(x)[source]

static T5_convection_beta20(x)[source]

static T5_convection_beta30(x)[source]

static T5_convection_beta40(x)[source]

static T6_reaction_rho4(x)[source]

static T6_reaction_rho5(x)[source]

static T6_reaction_rho6(x)[source]

static T7_wave_alpha3_beta3(x)[source]

static T7_wave_alpha4_beta3(x)[source]

static T7_wave_alpha4_beta4(x)[source]

static T8_helmholtz_n3(x)[source]

static T8_helmholtz_n4(x)[source]

static T8_helmholtz_n5(x)[source]

static T9_convection_beta30(x)[source]

static T9_reaction_rho5(x)[source]

problem_information = {'n_cases': 12, 'n_cons': '0', 'n_dims': '6', 'n_objs': '1', 'n_tasks': '[2, 4]', 'type': 'real_world'}

Methods and Utilities

Batch Experiment

class ddmtolab.Methods.batch_experiment.BatchExperiment(base_path: str = './Data', clear_folder: bool = False)[source]

Bases: object

Batch Experiment Module

This class provides a framework to define and run batch experiments for multiple optimization algorithms on multiple benchmark problems. It supports:

Adding multiple problems via problem creator functions.
Adding multiple optimization algorithm classes with fixed parameters.
Running experiments in parallel using multiple CPU cores.
Logging execution time, status, and errors for each run.
Saving timing summaries to CSV files.
Printing experiment configuration summaries to console.
Optional folder clearing before experiments.
Saving and loading experiment configuration from YAML files.

Warning

run() uses ProcessPoolExecutor. On Windows (and macOS), which use the spawn start method, the calling script must wrap the call in an if __name__ == '__main__': guard. Calling run() at module top level re-imports the script in every worker process and spawns processes recursively.

Example

>>> if __name__ == '__main__':
...     batch_exp = BatchExperiment(base_path='./Data', clear_folder=True)
...     batch_exp.add_problem(problem_creator, 'P1')
...     batch_exp.add_algorithm(GA, 'GA', n=100, max_nfes=10000)
...     batch_exp.run(n_runs=5, max_workers=6)

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.11.25 Version: 1.0

add_algorithm(algorithm_class: Type, algorithm_name: str, **params)[source]

Add an optimization algorithm class

Parameters:

algorithm_class – Algorithm class (e.g., GA, DE, PSO, etc.)
algorithm_name – Algorithm name (used for file naming and folder creation, must be unique)
**params – Fixed parameters for the algorithm (e.g., n, max_nfes, muc, mum, etc.) Note: problem, save_path, and name will be set automatically

Raises:

ValueError – If an algorithm with the same name was already added (duplicate names would silently overwrite result files).

add_problem(problem_creator, problem_name: str, **problem_params)[source]

Add an experiment problem using a creator function

Parameters:

problem_creator – Function that creates the problem instance
problem_name – Problem name (used for file naming, must be unique)
**problem_params – Parameters to pass to problem creator

Raises:

ValueError – If a problem with the same name was already added (duplicate names would silently overwrite result files).

run(n_runs: int = None, verbose: bool = True, max_workers: int = None, base_seed: int = None)[source]

Run all experiments using multi-core parallel processing

Parameters:

n_runs – Number of independent runs for each algorithm on each problem If None and loaded from config, uses config value
verbose – Whether to print detailed progress information
max_workers – Maximum number of worker processes, defaults to CPU count if None If None and loaded from config, uses config value
base_seed – Base seed for system-level random-seed control. When given, run r (1-indexed) is executed under seed base_seed + r - 1, applied to the global random, NumPy and PyTorch (including CUDA) generators before the problem and algorithm are built, so each individual run is reproducible from its seed. The per-run seed is recorded in the timing summary. If None and loaded from config, uses config value; if still None, no seeding is performed and runs use the interpreter’s default random state.

Returns:

One timing/status record per executed run, with keys ‘Algorithm’, ‘Problem’, ‘Run’, ‘Filename’, ‘Time(s)’, ‘Status’, ‘Error’, ‘Seed’. Empty list if nothing was run.

Return type:

List[Dict]

Data Analysis

class ddmtolab.Methods.data_analysis.DataAnalyzer(data_path: str | Path = './Data', settings: Dict[str, Any] | None = None, algorithm_order: List[str] | None = None, save_path: str | Path = './Results', table_format: str = 'excel', figure_format: str = 'pdf', statistic_type: str = 'mean', significance_level: float = 0.05, rank_sum_test: bool = True, holm_correction: bool = False, effect_size: bool = False, friedman_test: bool = False, friedman_control: str | None = None, log_scale: bool = False, show_pf: bool = True, show_nd: bool = True, merge_plots: bool = False, merge_columns: int = 3, show_std_band: bool = False, best_so_far: bool = True, clear_results: bool = True, convergence_k: int | None = None, cd_diagram: bool = False, cd_alpha: float | None = None, multi_problem_report: bool = False, report_scheme: str = 'friedman', report_control: str | None = None)[source]

Main class for comprehensive data analysis and visualization of multi-task optimization experiments.

This class provides a complete pipeline for:

Scanning data directories to detect algorithms, problems, and runs
Calculating performance metrics (IGD, HV, or objective values)
Generating statistical comparison tables (Excel or LaTeX)
Creating convergence curve plots
Visualizing runtime comparisons
Plotting non-dominated solutions

Variables:

data_path (Path) – Path to the data directory containing experiment results.
settings (Optional[Dict[str, Any]]) – Problem settings including reference definitions and metric configuration.
algorithm_order (Optional[List[str]]) – Custom ordering of algorithms for display.
table_config (TableConfig) – Configuration for table generation.
plot_config (PlotConfig) – Configuration for plot generation.

generate_cd_diagram() → NemenyiResult[source]

Run a Nemenyi all-pairs post-hoc test and draw its critical difference diagram, the visualization proposed by Demsar (2006, Figure 1a).

The test ranks the algorithms on the same per-instance statistic the results table displays, so the diagram and the Average Rank row of the table tell the same story.

Returns:: Critical difference, average ranks, pairwise comparisons and the cliques the diagram connects.
Return type:: NemenyiResult
Raises:: ValueError – If the test cannot be applied, for instance with fewer than 3 algorithms or fewer than 2 instances.

run() → MetricResults[source]

Execute the complete analysis pipeline.

This method runs all analysis steps in sequence:

Clear existing results (if configured)
Scan data directory
Calculate metrics
Generate statistical tables
Run the multi-problem statistical analysis (if configured)
Draw the critical difference diagram (if configured)
Generate convergence plots
Generate runtime plots
Generate non-dominated solution plots

Returns:: Complete metric results from the analysis.
Return type:: MetricResults

class ddmtolab.Methods.test_data_analysis.TestDataAnalyzer(data_path: str | Path = './Data', settings: Dict[str, Any] | None = None, algorithm_order: List[str] | None = None, save_path: str | Path = './Results', figure_format: str = 'pdf', log_scale: bool = False, show_pf: bool = True, show_nd: bool = True, best_so_far: bool = True, clear_results: bool = True, file_suffix: str = '.pkl')[source]

Main class for analyzing single-run test data.

This class handles pickle files stored directly in the data folder, providing a lightweight analysis pipeline without statistical analysis.

Variables:

data_path – Path Path to the data directory containing pickle files.
settings – Optional[Dict[str, Any]] Problem settings including reference definitions.
algorithm_order – Optional[List[str]] Custom ordering of algorithms for display.
plot_config – PlotConfig Configuration for plot generation.

run() → TestMetricResults[source]

Execute the complete test analysis pipeline.

Returns:

TestMetricResults: Complete metric results from the analysis.

Statistical Tests

Every test is implemented once, in ddmtolab.Methods.statistical_tests. Each takes its data first, then the optimization direction, then its options, and returns a dataclass rather than a tuple.

Two algorithms:

Nonparametric Statistical Tests for Comparing Algorithms over Multiple Problems

This module implements the methodology recommended by the two standard references on comparing (evolutionary) algorithms across a benchmark suite:

J. Demsar, Statistical Comparisons of Classifiers over Multiple Data Sets, JMLR 7 (2006) 1-30.
J. Derrac, S. Garcia, D. Molina, F. Herrera, A practical tutorial on the use of nonparametric statistical tests as a methodology for comparing evolutionary and swarm intelligence algorithms, Swarm and Evolutionary Computation 1 (2011) 3-18.

Every test here consumes one value per algorithm-problem pair – typically the mean or median over the independent runs of that pair – arranged as a matrix of shape (n_algorithms, n_instances). This is the multi-problem setting: it answers “is algorithm A better than B across the suite”, which is a different question from the per-problem rank-sum test over runs in ddmtolab.Methods.data_analysis.

Which test to use

Two algorithms: sign_test() (quick, weak) or wilcoxon_signed_rank_test() (recommended).
Many algorithms, omnibus: friedman_test() (plus its Iman-Davenport correction), friedman_aligned_test() or quade_test().
Many algorithms against one control: control_post_hoc(), which reports an adjusted p-value per comparison under any of seven procedures.
Every algorithm against every other: all_pairs_post_hoc(), with the Nemenyi, Holm, Shaffer and Bergmann-Hommel procedures.
How large the difference is: contrast_estimation().

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.05 Version: 1.0

class ddmtolab.Methods.statistical_tests.EffectSizeResult(delta: float, magnitude: str, method: str = 'cliffs_delta')[source]

Effect size of a pairwise comparison, reported separately from significance.

No-index:

Variables:

delta (float) – Cliff’s delta in [-1, 1], oriented so that a positive value means the algorithm is better than the baseline under the given optimization direction. np.nan when it cannot be computed.
magnitude (str) – Qualitative magnitude derived from |delta|: ‘negligible’, ‘small’, ‘medium’, ‘large’, or ‘undefined’ when delta is np.nan.
method (str) – Name of the effect size measure, always ‘cliffs_delta’.

delta: float

magnitude: str

method: str = 'cliffs_delta'

class ddmtolab.Methods.statistical_tests.PairwiseTestResult(name: str, statistic: float, p_value: float, n_instances: int, p_value_one_sided: float = nan, wins: float = 0.0, losses: float = 0.0, ties: int = 0, r_plus: float = nan, r_minus: float = nan)[source]

Outcome of a test comparing exactly two algorithms over many problems.

No-index:

Variables:

name (str) – Name of the test.
statistic (float) – Test statistic: the number of wins for the sign test, T = min(R+, R-) for the Wilcoxon signed-rank test.
p_value (float) – Two-tailed p-value.
p_value_one_sided (float) – One-sided p-value for “the first algorithm is better”. The critical value tables printed in both papers (Demsar’s Table 3, Derrac’s Table 4) correspond to this one, not to p_value.
n_instances (int) – Number of problems compared, after dropping incomparable ones.
wins (float) – Problems on which the first algorithm was better. Ties are split evenly between the two algorithms, so this can be a half-integer.
losses (float) – Problems on which the first algorithm was worse, ties split evenly.
ties (int) – Number of tied problems, before splitting.
r_plus (float) – Sum of ranks favouring the first algorithm (Wilcoxon only).
r_minus (float) – Sum of ranks favouring the second algorithm (Wilcoxon only).

losses: float = 0.0

n_instances: int

name: str

p_value: float

p_value_one_sided: float = nan

r_minus: float = nan

r_plus: float = nan

statistic: float

ties: int = 0

wins: float = 0.0

ddmtolab.Methods.statistical_tests.classify_cliffs_delta(delta: float) → str[source]

Map a Cliff’s delta to its qualitative magnitude.

Parameters:: delta (float) – Cliff’s delta value; only its absolute value matters.
Returns:: ‘negligible’ (|delta| < 0.147), ‘small’ (< 0.33), ‘medium’ (< 0.474), ‘large’ otherwise, or ‘undefined’ for NaN.
Return type:: str

ddmtolab.Methods.statistical_tests.cliffs_delta(first: Sequence[float], second: Sequence[float], direction: OptimizationDirection = OptimizationDirection.MINIMIZE) → EffectSizeResult[source]

Compute Cliff’s delta, a non-parametric effect size for two samples.

Cliff’s delta is the difference between the probability that a value of one sample exceeds a value of the other and the probability of the reverse; for independent samples it is equivalent to the rank-biserial correlation derived from the rank-sum statistic. It is reported independently of the significance test: a large delta on few runs may still be non-significant, and a significant difference may be negligible in size.

The sign is oriented by direction so that a positive delta always means the first sample is better.

Parameters:

first (Sequence[float]) – Sample of the algorithm being tested. NaN entries are dropped.
second (Sequence[float]) – Sample of the baseline. NaN entries are dropped.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE).

Returns:

Delta in [-1, 1] with its qualitative magnitude, or (np.nan, ‘undefined’) when either sample is empty.

Return type:

EffectSizeResult

ddmtolab.Methods.statistical_tests.rank_sum_test(first: Sequence[float], second: Sequence[float], direction: OptimizationDirection = OptimizationDirection.MINIMIZE) → PairwiseTestResult[source]

Wilcoxon rank-sum test on two unpaired samples.

This is the test for the other setting the platform supports: the samples are the independent runs of two algorithms on a single problem, which are not paired with each other, so the ranks of the pooled sample are compared rather than the ranks of per-problem differences. Use wilcoxon_signed_rank_test() instead when the samples are one value per problem and therefore paired.

Parameters:

first (Sequence[float]) – Runs of the first algorithm.
second (Sequence[float]) – Runs of the second algorithm; it need not have the same length.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE). It only orients the win and loss counts; the two-tailed p-value is the same either way.

Returns:

The rank-sum statistic and its two-tailed p-value. wins and losses compare the medians rather than counting problems, since unpaired runs cannot be matched up one by one.

Return type:

PairwiseTestResult

Raises:

ValueError – If either sample is empty after dropping NaNs.

ddmtolab.Methods.statistical_tests.sign_test(first: Sequence[float], second: Sequence[float], direction: OptimizationDirection = OptimizationDirection.MINIMIZE) → PairwiseTestResult[source]

Two-tailed sign test on the counts of wins, losses and ties.

The simplest pairwise test: under the null hypothesis each algorithm wins on about half of the problems, so the number of wins follows a binomial distribution. It assumes nothing about the scores beyond their order, which also makes it the weakest of the pairwise tests – it rejects only when one algorithm wins nearly always.

Parameters:

first (Sequence[float]) – Performance of the first algorithm, one value per problem.
second (Sequence[float]) – Performance of the second algorithm, aligned with first.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE).

Returns:

Wins, losses, ties and the exact binomial p-value. Both papers tabulate the critical number of wins for one-sided testing, so compare their tables against p_value_one_sided: 11 wins out of 14 is their threshold at alpha = 0.05, which is a one-sided p of 0.029 and a two-sided p of 0.057.

Return type:

PairwiseTestResult

Raises:

ValueError – If the two samples have different lengths or are empty.

ddmtolab.Methods.statistical_tests.wilcoxon_signed_rank_test(first: Sequence[float], second: Sequence[float], direction: OptimizationDirection = OptimizationDirection.MINIMIZE) → PairwiseTestResult[source]

Wilcoxon signed-rank test, the recommended pairwise comparison.

The per-problem differences are ranked by absolute value and the ranks of the positive and negative differences are compared. Unlike the sign test it weighs how large each difference is, and unlike the paired t-test it assumes neither normality nor commensurability of the scores – only that a larger difference counts for more. Zero differences are split evenly between the two rank sums, as both papers prescribe.

Parameters:

first (Sequence[float]) – Performance of the first algorithm, one value per problem.
second (Sequence[float]) – Performance of the second algorithm, aligned with first.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE). It only orients r_plus and r_minus; the two-tailed p-value is the same either way.

Returns:

T = min(R+, R-), its p-value, and both rank sums. r_plus is the sum of ranks on the problems where the first algorithm is better.

Return type:

PairwiseTestResult

Raises:

ValueError – If the two samples have different lengths or are empty.

Many algorithms, omnibus:

Nonparametric Statistical Tests for Comparing Algorithms over Multiple Problems

This module implements the methodology recommended by the two standard references on comparing (evolutionary) algorithms across a benchmark suite:

J. Demsar, Statistical Comparisons of Classifiers over Multiple Data Sets, JMLR 7 (2006) 1-30.
J. Derrac, S. Garcia, D. Molina, F. Herrera, A practical tutorial on the use of nonparametric statistical tests as a methodology for comparing evolutionary and swarm intelligence algorithms, Swarm and Evolutionary Computation 1 (2011) 3-18.

Every test here consumes one value per algorithm-problem pair – typically the mean or median over the independent runs of that pair – arranged as a matrix of shape (n_algorithms, n_instances). This is the multi-problem setting: it answers “is algorithm A better than B across the suite”, which is a different question from the per-problem rank-sum test over runs in ddmtolab.Methods.data_analysis.

Which test to use

Two algorithms: sign_test() (quick, weak) or wilcoxon_signed_rank_test() (recommended).
Many algorithms, omnibus: friedman_test() (plus its Iman-Davenport correction), friedman_aligned_test() or quade_test().
Many algorithms against one control: control_post_hoc(), which reports an adjusted p-value per comparison under any of seven procedures.
Every algorithm against every other: all_pairs_post_hoc(), with the Nemenyi, Holm, Shaffer and Bergmann-Hommel procedures.
How large the difference is: contrast_estimation().

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.05 Version: 1.0

class ddmtolab.Methods.statistical_tests.RankScheme(*values)[source]

Ranking scheme underlying an omnibus test.

FRIEDMAN: Ranks within each problem, 1 for the best. Only intra-problem comparisons are meaningful.
ALIGNED: Each value is first aligned by subtracting the average performance on its problem; all k*n aligned observations are then ranked together, so inter-problem comparisons become meaningful too.
QUADE: Friedman ranks weighted by how discriminating each problem is, measured by the range of the values observed on it.

ALIGNED = 'aligned'

FRIEDMAN = 'friedman'

QUADE = 'quade'

class ddmtolab.Methods.statistical_tests.RankingResult(scheme: RankScheme, average_ranks: Dict[str, float], ranks: ndarray, statistic: float, p_value: float, statistic_name: str, standard_error: float, n_algorithms: int, n_instances: int, n_instances_dropped: int = 0, iman_davenport_statistic: float = nan, iman_davenport_p_value: float = nan)[source]

Ranks and omnibus statistic produced by one of the three ranking schemes.

No-index:

Variables:

scheme (RankScheme) – Ranking scheme used.
average_ranks (Dict[str, float]) – Average rank per algorithm, keyed by name. Lower is better for every scheme; the best possible value is 1 for FRIEDMAN and QUADE, while ALIGNED ranks live on the 1..k*n scale.
ranks (np.ndarray) – Per-instance ranks of shape (n_algorithms, n_instances).
statistic (float) – Omnibus statistic: chi^2_F for FRIEDMAN, F_AR for ALIGNED, F_Q for QUADE.
p_value (float) – P-value of statistic.
statistic_name (str) – Name of the statistic, for reporting.
standard_error (float) – Standard error of a difference of two average ranks under this scheme, used by the post-hoc z statistics.
n_algorithms (int) – Number of algorithms (k).
n_instances (int) – Number of instances retained (N).
n_instances_dropped (int) – Instances dropped because at least one algorithm had no value there.
iman_davenport_statistic (float) – Iman-Davenport F_F correction of chi^2_F. FRIEDMAN scheme only.
iman_davenport_p_value (float) – P-value of F_F under F(k-1, (k-1)(N-1)). FRIEDMAN scheme only.

average_ranks: Dict[str, float]

iman_davenport_p_value: float = nan

iman_davenport_statistic: float = nan

n_algorithms: int

n_instances: int

n_instances_dropped: int = 0

p_value: float

ranks: ndarray

scheme: RankScheme

standard_error: float

statistic: float

statistic_name: str

ddmtolab.Methods.statistical_tests.friedman_aligned_test(data_matrix: ndarray | Sequence[Sequence[float]], algorithm_names: Sequence[str], direction: OptimizationDirection = OptimizationDirection.MINIMIZE) → RankingResult[source]

Friedman test on aligned ranks, which also compares across problems.

Friedman ranks only within a problem, so a value is never compared against values from another problem. Aligning removes that limitation: the average performance on a problem is subtracted from every value on it, and all k*N aligned observations are then ranked together from 1 to k*N. This tends to be more powerful than the plain Friedman test when few algorithms are compared.

Parameters:

data_matrix (Union[np.ndarray, Sequence[Sequence[float]]]) – Results of shape (n_algorithms, n_instances).
algorithm_names (Sequence[str]) – One name per row.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE).

Returns:

Average aligned ranks on the 1..k*N scale, and the statistic F_AR compared against a chi-squared distribution with k-1 degrees of freedom.

Return type:

RankingResult

Notes

The average ranks and the post-hoc z statistics reproduce Tables 9, 12 and 14 of Derrac et al. (2011) exactly. The omnibus statistic follows their Eq. (4), i.e. the Hodges-Lehmann form; the value printed in their Table 11 is not reproducible from that equation and the ranks they publish.

ddmtolab.Methods.statistical_tests.friedman_test(data_matrix: ndarray | Sequence[Sequence[float]], algorithm_names: Sequence[str], direction: OptimizationDirection = OptimizationDirection.MINIMIZE) → RankingResult[source]

Friedman test: are the average ranks of the algorithms all equal?

Each problem is ranked separately, rank 1 going to the best algorithm and tied algorithms sharing the average rank. The statistic

\[\chi^2_F = \frac{12N}{k(k+1)} \left[ \sum_j R_j^2 - \frac{k(k+1)^2}{4} \right]\]

follows a chi-squared distribution with k-1 degrees of freedom. Because it is known to be conservative, the Iman-Davenport correction

\[F_F = \frac{(N-1)\chi^2_F}{N(k-1) - \chi^2_F}\]

is reported alongside it and is the statistic to prefer.

Parameters:

data_matrix (Union[np.ndarray, Sequence[Sequence[float]]]) – Results of shape (n_algorithms, n_instances).
algorithm_names (Sequence[str]) – One name per row.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE).

Returns:

Average ranks, chi^2_F with its p-value, and the Iman-Davenport correction.

Return type:

RankingResult

ddmtolab.Methods.statistical_tests.omnibus_test(data_matrix: ndarray | Sequence[Sequence[float]], algorithm_names: Sequence[str], direction: OptimizationDirection = OptimizationDirection.MINIMIZE, scheme: RankScheme = RankScheme.FRIEDMAN) → RankingResult[source]

Run the omnibus test of the requested ranking scheme.

Parameters:

data_matrix (Union[np.ndarray, Sequence[Sequence[float]]]) – Results of shape (n_algorithms, n_instances).
algorithm_names (Sequence[str]) – One name per row.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE).
scheme (RankScheme, optional) – FRIEDMAN, ALIGNED or QUADE (default: FRIEDMAN).

Returns:

Result of the corresponding test.

Return type:

RankingResult

ddmtolab.Methods.statistical_tests.quade_test(data_matrix: ndarray | Sequence[Sequence[float]], algorithm_names: Sequence[str], direction: OptimizationDirection = OptimizationDirection.MINIMIZE) → RankingResult[source]

Quade test, a Friedman test that weighs the problems by how much they discriminate.

Friedman treats every problem as equally important. Quade instead ranks the problems themselves by their sample range – the spread between the best and the worst value observed on them – and scales each problem’s contribution by that rank, so a problem on which the algorithms differ widely counts for more than one on which they all behave alike.

Parameters:

data_matrix (Union[np.ndarray, Sequence[Sequence[float]]]) – Results of shape (n_algorithms, n_instances).
algorithm_names (Sequence[str]) – One name per row.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE).

Returns:

Average weighted ranks T_j, and the statistic F_Q compared against an F distribution with k-1 and (k-1)(N-1) degrees of freedom.

Return type:

RankingResult

Many algorithms, post-hoc:

Nonparametric Statistical Tests for Comparing Algorithms over Multiple Problems

This module implements the methodology recommended by the two standard references on comparing (evolutionary) algorithms across a benchmark suite:

J. Demsar, Statistical Comparisons of Classifiers over Multiple Data Sets, JMLR 7 (2006) 1-30.
J. Derrac, S. Garcia, D. Molina, F. Herrera, A practical tutorial on the use of nonparametric statistical tests as a methodology for comparing evolutionary and swarm intelligence algorithms, Swarm and Evolutionary Computation 1 (2011) 3-18.

Every test here consumes one value per algorithm-problem pair – typically the mean or median over the independent runs of that pair – arranged as a matrix of shape (n_algorithms, n_instances). This is the multi-problem setting: it answers “is algorithm A better than B across the suite”, which is a different question from the per-problem rank-sum test over runs in ddmtolab.Methods.data_analysis.

Which test to use

Two algorithms: sign_test() (quick, weak) or wilcoxon_signed_rank_test() (recommended).
Many algorithms, omnibus: friedman_test() (plus its Iman-Davenport correction), friedman_aligned_test() or quade_test().
Many algorithms against one control: control_post_hoc(), which reports an adjusted p-value per comparison under any of seven procedures.
Every algorithm against every other: all_pairs_post_hoc(), with the Nemenyi, Holm, Shaffer and Bergmann-Hommel procedures.
How large the difference is: contrast_estimation().

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.05 Version: 1.0

class ddmtolab.Methods.statistical_tests.Hypothesis(label: str, algorithms: ~typing.Tuple[str, str], rank_difference: float, z_statistic: float, p_value: float, adjusted: ~typing.Dict[str, float] = <factory>)[source]

One comparison of a post-hoc family.

No-index:

Variables:

label (str) – Human-readable description, e.g. 'PSO vs DE-Exp'.
algorithms (Tuple[str, str]) – The two algorithms compared, better-ranked one first.
rank_difference (float) – Difference of their average ranks.
z_statistic (float) – Standardized rank difference.
p_value (float) – Unadjusted two-tailed p-value.
adjusted (Dict[str, float]) – Adjusted p-value (APV) per post-hoc procedure, keyed by procedure name. An APV can be compared directly against any significance level.

adjusted: Dict[str, float]

algorithms: Tuple[str, str]

label: str

p_value: float

rank_difference: float

z_statistic: float

class ddmtolab.Methods.statistical_tests.NemenyiComparison(algorithm_a: str, algorithm_b: str, rank_difference: float, q_statistic: float, p_value: float, significant: bool)[source]

One all-pairs comparison of the Nemenyi post-hoc test.

No-index:

Variables:

algorithm_a (str) – First algorithm of the pair, the better-ranked one.
algorithm_b (str) – Second algorithm of the pair, the worse-ranked one.
rank_difference (float) – Absolute difference of the two average ranks.
q_statistic (float) – Studentized range statistic of the pair.
p_value (float) – Two-tailed p-value from the studentized range distribution, already accounting for all k(k-1)/2 comparisons.
significant (bool) – Whether the pair differs significantly, i.e. whether the rank difference exceeds the critical difference.

algorithm_a: str

algorithm_b: str

p_value: float

q_statistic: float

rank_difference: float

significant: bool

class ddmtolab.Methods.statistical_tests.NemenyiResult(critical_difference: float, q_alpha: float, average_ranks: ~typing.Dict[str, float], n_algorithms: int, n_instances: int, n_instances_dropped: int = 0, significance_level: float = 0.05, comparisons: ~typing.List[~ddmtolab.Methods.statistical_tests.NemenyiComparison] = <factory>, cliques: ~typing.List[~typing.List[str]] = <factory>)[source]

Outcome of a Nemenyi all-pairs post-hoc test, in critical-difference form.

This is the shape the critical difference diagram consumes. For adjusted p-values of the same family, see all_pairs_post_hoc().

No-index:

Variables:

critical_difference (float) – Critical difference CD; two algorithms differ significantly when their average ranks differ by at least this much.
q_alpha (float) – Critical value of the studentized range statistic divided by sqrt(2), as tabulated by Demsar (2006, Table 5a).
average_ranks (Dict[str, float]) – Average rank per algorithm (1 is best), keyed by algorithm name.
n_algorithms (int) – Number of algorithms compared (k).
n_instances (int) – Number of instances retained after dropping incomplete ones (N).
n_instances_dropped (int) – Number of instances dropped because at least one algorithm had no value.
significance_level (float) – Significance level the critical difference was computed for.
comparisons (List[NemenyiComparison]) – One entry per unordered pair, ordered by increasing rank difference.
cliques (List[List[str]]) – Groups of algorithms that are not significantly different from each other, each sorted by average rank and each with at least two members. An algorithm in no clique differs significantly from every other one. These are the groups the critical difference diagram connects.

average_ranks: Dict[str, float]

cliques: List[List[str]]

comparisons: List[NemenyiComparison]

critical_difference: float

n_algorithms: int

n_instances: int

n_instances_dropped: int = 0

q_alpha: float

significance_level: float = 0.05

class ddmtolab.Methods.statistical_tests.PostHocResult(family: str, scheme: RankScheme, control: str | None, hypotheses: List[Hypothesis], procedures: Tuple[str, ...])[source]

A family of post-hoc comparisons with their adjusted p-values.

No-index:

Variables:

family (str) – 'control' for the k-1 comparisons against a control algorithm, 'all_pairs' for the k(k-1)/2 comparisons among all algorithms.
scheme (RankScheme) – Ranking scheme the comparisons were derived from.
control (Optional[str]) – Control algorithm, for the 'control' family only.
hypotheses (List[Hypothesis]) – Comparisons ordered by increasing unadjusted p-value.
procedures (Tuple[str, ...]) – Post-hoc procedures applied, in the order requested.

control: str | None

family: str

hypotheses: List[Hypothesis]

procedures: Tuple[str, ...]

rejected(procedure: str, significance_level: float = 0.05) → List[str][source]

Labels of the hypotheses a procedure rejects at a significance level.

Parameters:

procedure (str) – Name of a procedure present in procedures.
significance_level (float, optional) – Threshold applied to the adjusted p-values (default: 0.05).

Returns:

Labels of the rejected hypotheses, most significant first.

Return type:

List[str]

scheme: RankScheme

ddmtolab.Methods.statistical_tests.adjust_p_values(p_values: Sequence[float | None], method: str = 'holm', n_algorithms: int | None = None, pairs: Sequence[Tuple[int, int]] | None = None) → List[float | None][source]

Convert raw p-values of a family of comparisons into adjusted p-values.

An adjusted p-value (APV) is the smallest significance level at which the procedure would still reject that hypothesis, given the whole family. It can therefore be compared directly against any alpha, which is why Derrac et al. (2011) recommend reporting APVs rather than a bare accept/reject verdict.

Supported procedures, from least to most powerful within each class:

one-step: 'bonferroni' ('nemenyi' is the same computation applied to an all-pairwise family)
step-down: 'holm', 'holland', 'finner'
step-up: 'hochberg', 'hommel'
two-step: 'li'
logically-aware, all-pairwise only: 'shaffer', 'bergmann'

Entries that are None or NaN are not part of the family: they neither contribute to its size nor receive an adjusted value.

Parameters:

p_values (Sequence[Optional[float]]) – Raw p-values, in any order.
method (str, optional) – Procedure name (default: 'holm').
n_algorithms (Optional[int], optional) – Number of algorithms, required by 'shaffer' and 'bergmann'.
pairs (Optional[Sequence[Tuple[int, int]]], optional) – Algorithm index pair of every hypothesis, aligned with p_values. Required by 'bergmann'.

Returns:

Adjusted p-values in the input order, None wherever the input was.

Return type:

List[Optional[float]]

Examples

>>> adjust_p_values([0.01, 0.02, 0.03], 'holm')
[0.03, 0.04, 0.04]

ddmtolab.Methods.statistical_tests.all_pairs_post_hoc(ranking: RankingResult, procedures: Sequence[str] = ('nemenyi', 'holm', 'shaffer', 'bergmann')) → PostHocResult[source]

Compare every algorithm against every other, with adjusted p-values.

This is the NxN family: k(k-1)/2 hypotheses. Because the hypotheses are logically interrelated – if A differs from B they cannot both equal C – Shaffer’s and Bergmann-Hommel’s procedures can reject more than Holm while still controlling the family-wise error rate.

Parameters:

ranking (RankingResult) – Output of one of the omnibus tests.
procedures (Sequence[str], optional) – Procedures whose APVs to report (default: all of ALL_PAIRS_PROCEDURES).

Returns:

One hypothesis per unordered pair, ordered by p-value.

Return type:

PostHocResult

ddmtolab.Methods.statistical_tests.control_post_hoc(ranking: RankingResult, control: str | None = None, procedures: Sequence[str] = ('bonferroni', 'holm', 'holland', 'finner', 'hochberg', 'hommel', 'li')) → PostHocResult[source]

Compare every algorithm against one control, with adjusted p-values.

This is the 1xN family: k-1 hypotheses, one per non-control algorithm. It is the right family when the study asks whether a newly proposed method beats the existing ones, and it is more powerful than the all-pairwise family because it tests far fewer hypotheses.

Parameters:

ranking (RankingResult) – Output of friedman_test(), friedman_aligned_test() or quade_test(); its scheme decides the standard error used.
control (Optional[str], optional) – Control algorithm. Default: None, which picks the best-ranked one.
procedures (Sequence[str], optional) – Procedures whose APVs to report (default: all of CONTROL_PROCEDURES).

Returns:

One hypothesis per non-control algorithm, ordered by p-value.

Return type:

PostHocResult

Raises:

ValueError – If control is not one of the ranked algorithms.

ddmtolab.Methods.statistical_tests.exhaustive_sets(pairs: Sequence[Tuple[int, int]], n_algorithms: int) → List[List[int]][source]

All exhaustive index sets of an all-pairwise family of hypotheses.

A set of hypotheses is exhaustive when exactly those hypotheses could be true at the same time. For pairwise equalities that happens precisely when the set collects all pairs inside the blocks of some partition of the algorithms, so the partitions of the k algorithms enumerate them.

Parameters:

pairs (Sequence[Tuple[int, int]]) – Algorithm index pair of every hypothesis, in the order of the p-values.
n_algorithms (int) – Number of algorithms (k).

Returns:

Each entry lists the hypothesis indices of one non-empty exhaustive set.

Return type:

List[List[int]]

Raises:

ValueError – If k exceeds BERGMANN_MAX_ALGORITHMS, since the number of partitions grows faster than exponentially.

ddmtolab.Methods.statistical_tests.nemenyi_critical_value(n_algorithms: int, significance_level: float = 0.05) → float[source]

Critical value q_alpha of the two-tailed Nemenyi test.

It is the studentized range statistic for n_algorithms groups and infinite degrees of freedom, divided by sqrt(2). The returned values reproduce Table 5(a) of Demsar (2006): 2.569 for 4 algorithms at alpha = 0.05 and 2.291 at alpha = 0.10.

Parameters:

n_algorithms (int) – Number of algorithms compared (k >= 2).
significance_level (float, optional) – Significance level alpha (default: 0.05).

Returns:

Critical value q_alpha.

Return type:

float

Raises:

ValueError – If fewer than 2 algorithms are given or alpha is outside (0, 1).

ddmtolab.Methods.statistical_tests.nemenyi_test(data_matrix: ndarray | Sequence[Sequence[float]], algorithm_names: Sequence[str], direction: OptimizationDirection = OptimizationDirection.MINIMIZE, significance_level: float = 0.05) → NemenyiResult[source]

Nemenyi all-pairs post-hoc test in critical-difference form.

Two algorithms differ significantly when their average Friedman ranks differ by at least

\[CD = q_\alpha \sqrt{k(k+1) / (6N)}\]

with $q_\alpha$ the studentized range statistic divided by sqrt(2). Because the critical value already accounts for all $k(k-1)/2$ comparisons, no further multiplicity correction applies on top of it.

This returns the single threshold the critical difference diagram draws. all_pairs_post_hoc() answers the same question as adjusted p-values and additionally offers the more powerful Shaffer and Bergmann-Hommel procedures; use this one when a diagram is what you want.

Parameters:

data_matrix (Union[np.ndarray, Sequence[Sequence[float]]]) – Results of shape (n_algorithms, n_instances).
algorithm_names (Sequence[str]) – One name per row.
direction (OptimizationDirection, optional) – Optimization direction (default: MINIMIZE).
significance_level (float, optional) – Significance level of the critical difference (default: 0.05). Demsar’s own diagrams use 0.10, since the all-pairs test is conservative.

Returns:

Critical difference, average ranks, every pairwise comparison, and the cliques of algorithms that are not significantly different.

Return type:

NemenyiResult

Raises:

ValueError – If fewer than 3 algorithms are supplied, if the names do not match the rows, or if fewer than 2 complete instances remain.

ddmtolab.Methods.statistical_tests.shaffer_t_values(n_algorithms: int) → List[int][source]

Maximum number of hypotheses that can still be true at each step of Shaffer’s static procedure.

In an all-pairwise family the hypotheses are logically interrelated: if A differs from B, then A and B cannot both equal C. Shaffer exploits this by replacing Holm’s divisor m - i + 1 with t_i, the largest number of hypotheses that can be simultaneously true once any i - 1 of them are false. The attainable counts follow the recursion

\[S(k) = \bigcup_{j=1}^{k} \{ \binom{j}{2} + x : x \in S(k-j) \}\]

with S(0) = S(1) = {0}.

Parameters:: n_algorithms (int) – Number of algorithms compared (k >= 2).
Returns:: t_i for i = 1 .. k(k-1)/2, non-increasing.
Return type:: List[int]

Examples

>>> shaffer_t_values(3)
[3, 1, 1]

Magnitude of the differences:

Nonparametric Statistical Tests for Comparing Algorithms over Multiple Problems

This module implements the methodology recommended by the two standard references on comparing (evolutionary) algorithms across a benchmark suite:

J. Demsar, Statistical Comparisons of Classifiers over Multiple Data Sets, JMLR 7 (2006) 1-30.
J. Derrac, S. Garcia, D. Molina, F. Herrera, A practical tutorial on the use of nonparametric statistical tests as a methodology for comparing evolutionary and swarm intelligence algorithms, Swarm and Evolutionary Computation 1 (2011) 3-18.

Every test here consumes one value per algorithm-problem pair – typically the mean or median over the independent runs of that pair – arranged as a matrix of shape (n_algorithms, n_instances). This is the multi-problem setting: it answers “is algorithm A better than B across the suite”, which is a different question from the per-problem rank-sum test over runs in ddmtolab.Methods.data_analysis.

Which test to use

Two algorithms: sign_test() (quick, weak) or wilcoxon_signed_rank_test() (recommended).
Many algorithms, omnibus: friedman_test() (plus its Iman-Davenport correction), friedman_aligned_test() or quade_test().
Many algorithms against one control: control_post_hoc(), which reports an adjusted p-value per comparison under any of seven procedures.
Every algorithm against every other: all_pairs_post_hoc(), with the Nemenyi, Holm, Shaffer and Bergmann-Hommel procedures.
How large the difference is: contrast_estimation().

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2026.08.05 Version: 1.0

class ddmtolab.Methods.statistical_tests.ContrastResult(algorithms: List[str], estimators: ndarray, performances: Dict[str, float])[source]

Estimated differences between algorithm performances, based on medians.

No-index:

Variables:

algorithms (List[str]) – Algorithm names, in the order of the matrix rows.
estimators (np.ndarray) – Matrix of shape (k, k) whose entry [u, v] estimates the performance difference M_u - M_v. It is antisymmetric with a zero diagonal.
performances (Dict[str, float]) – The per-algorithm term m_u the estimators are built from; the estimator of M_u - M_v is m_u - m_v.

algorithms: List[str]

estimators: ndarray

performances: Dict[str, float]

ddmtolab.Methods.statistical_tests.contrast_estimation(data_matrix: ndarray | Sequence[Sequence[float]], algorithm_names: Sequence[str]) → ContrastResult[source]

Estimate by how much each algorithm outperforms each other, using medians.

Significance tests say whether a difference is real, not how large it is. Contrast estimation answers the second question on the original scale of the performance measure: for every pair it takes the median over problems of their per-problem differences, and turns those into one number per algorithm

\[m_u = \frac{1}{k} \sum_{j} Z_{uj}, \qquad \widehat{M_u - M_v} = m_u - m_v\]

where $Z_{uv}$ is the median difference of u and v. It assumes the expected difference between two algorithms is the same across problems, so the values must be commensurable – do not mix scales.

The estimator is direction-agnostic: it is expressed in the units of the input, so with an error measure a negative value means u errs less than v.

Parameters:

data_matrix (Union[np.ndarray, Sequence[Sequence[float]]]) – Results of shape (n_algorithms, n_instances).
algorithm_names (Sequence[str]) – One name per row.

Returns:

The (k, k) estimator matrix and the per-algorithm terms behind it.

Return type:

ContrastResult

Reporting layer

class ddmtolab.Methods.data_analysis.StatisticsCalculator[source]

Statistics the results table and the plots are built from.

The tests themselves live in ddmtolab.Methods.statistical_tests, which is the canonical entry point and the only place they are implemented. What remains here is what the reporting pipeline needs on top of them:

turning per-run samples into the displayed statistic (calculate_statistic()) and into the +/-/= annotation (perform_rank_sum_test()),
reshaping a test result into the dataclasses the table and the critical difference diagram render (perform_friedman_test(), perform_nemenyi_test()),
navigating the nested per-run result structure (iterate_instances(), build_instance_matrix(), collect_task_data(), select_representative_run()).

The remaining perform_* and effect-size methods are thin wrappers kept for backward compatibility; new code should call the module functions directly, which follow the <name>_test naming and accept the same arguments in the same order for every test.

static build_instance_matrix(all_best_values: Dict[str, Dict[str, Dict[int, List[float]]]], algorithm_order: List[str], statistic_type: StatisticType = StatisticType.MEAN) → Tuple[ndarray, List[str]][source]

Aggregate the runs of every algorithm into one value per instance.

This is the matrix the rank-based omnibus tests consume: the runs are already collapsed into the same statistic the results table displays, so ranks derived from it agree with the numbers in the table.

Parameters:

all_best_values (Dict[str, Dict[str, Dict[int, List[float]]]]) – Nested dictionary containing best metric values.
algorithm_order (List[str]) – Algorithm names, in the order the matrix rows should follow.
statistic_type (StatisticType, optional) – Statistic used to collapse the runs of one instance (default: StatisticType.MEAN).

Returns:

Matrix of shape (n_algorithms, n_instances) and the instance labels, ‘P1’ for a single-task problem and ‘P1-T2’ otherwise.

Return type:

Tuple[np.ndarray, List[str]]

static calculate_statistic(data: List[float], statistic_type: StatisticType) → Tuple[float, float | None][source]

Calculate a statistical measure and optional standard deviation from data.

Parameters:

data (List[float]) – List of numeric values to compute statistics from.
statistic_type (StatisticType) – Type of statistic to calculate (MEAN, MEDIAN, MAX, MIN, MEDIAN_IQR).

Returns:

Tuple of (statistic_value, dispersion_value). The dispersion is the standard deviation for MEAN and the interquartile range for MEDIAN_IQR; it is None otherwise. Returns (np.nan, np.nan) for empty data.

Return type:

Tuple[float, Optional[float]]

static collect_task_data(all_best_values: Dict[str, Dict[str, Dict[int, List[float]]]], algo: str, prob: str, task_idx: int) → List[float][source]

Collect non-NaN values from all runs for a specific algorithm-problem-task combination.

Parameters:

all_best_values (Dict[str, Dict[str, Dict[int, List[float]]]]) – Nested dictionary containing best metric values.
algo (str) – Algorithm name.
prob (str) – Problem name.
task_idx (int) – Task index (0-based).

Returns:

List of non-NaN metric values from all runs.

Return type:

List[float]

static iterate_instances(all_best_values: Dict[str, Dict[str, Dict[int, List[float]]]], algorithm_order: List[str]) → List[Tuple[str, int]][source]

List every problem-task instance the algorithms are compared over.

One instance is one row of the results table and one block of the Friedman and Nemenyi tests, so both go through this function and always see the same set. The task count of a problem comes from the first algorithm that has any run on it, so an algorithm whose runs all failed cannot make the problem disappear.

Parameters:

all_best_values (Dict[str, Dict[str, Dict[int, List[float]]]]) – Nested dictionary containing best metric values.
algorithm_order (List[str]) – Algorithm names to consider.

Returns:

Pairs of (problem name, 0-based task index), problems in natural order. Problems on which no algorithm has a single run are skipped with a warning.

Return type:

List[Tuple[str, int]]

static perform_friedman_test(data_matrix: ndarray | List[List[float]], algorithm_names: List[str], direction: OptimizationDirection = OptimizationDirection.MINIMIZE, control: str | None = None, significance_level: float = 0.05) → FriedmanResult[source]

Run a Friedman test with Holm-corrected post-hoc comparisons against a control algorithm, in the shape the results table renders.

The statistics come from ddmtolab.Methods.statistical_tests.friedman_test() and the comparisons from ddmtolab.Methods.statistical_tests.control_post_hoc(); this wrapper only rearranges them into FriedmanResult and adds the +/-/= symbols. For the aligned-ranks and Quade schemes, or for post-hoc procedures other than Holm, call those functions directly.

Parameters:

data_matrix (Union[np.ndarray, List[List[float]]]) – Results with shape (n_algorithms, n_instances); entry [i, j] is the performance of algorithm i on instance j.
algorithm_names (List[str]) – Algorithm names, one per row of data_matrix.
direction (OptimizationDirection, optional) – Optimization direction (MINIMIZE or MAXIMIZE).
control (Optional[str], optional) – Control algorithm for the post-hoc comparisons. Defaults to the last entry of algorithm_names.
significance_level (float, optional) – Threshold applied to the corrected post-hoc p-values (default: 0.05).

Returns:

Omnibus statistic and p-value, average ranks, and one post-hoc entry per algorithm, in the order the algorithms were supplied.

Return type:

FriedmanResult

Raises:

ValueError – If fewer than 3 algorithms are supplied (the test is not applicable), if the number of names does not match the number of rows, if fewer than 2 complete instances remain, or if control is not one of algorithm_names.

static perform_nemenyi_test(data_matrix: ndarray | List[List[float]], algorithm_names: List[str], direction: OptimizationDirection = OptimizationDirection.MINIMIZE, significance_level: float = 0.05) → NemenyiResult[source]

Run the Nemenyi all-pairs post-hoc test in critical-difference form.

Thin wrapper over ddmtolab.Methods.statistical_tests.nemenyi_test(), kept because the critical difference diagram consumes its result.

Parameters:

data_matrix (Union[np.ndarray, List[List[float]]]) – Results with shape (n_algorithms, n_instances).
algorithm_names (List[str]) – Algorithm names, one per row of data_matrix.
direction (OptimizationDirection, optional) – Optimization direction (MINIMIZE or MAXIMIZE).
significance_level (float, optional) – Significance level of the critical difference (default: 0.05).

Returns:

Critical difference, average ranks, pairwise comparisons and the cliques the diagram connects.

Return type:

NemenyiResult

static perform_rank_sum_test(algo_data: List[float], base_data: List[float], significance_level: float = 0.05, direction: OptimizationDirection = OptimizationDirection.MINIMIZE, compute_effect_size: bool = False) → ComparisonResult[source]

Compare the runs of two algorithms on one instance and render the verdict as a table symbol.

The test itself is ddmtolab.Methods.statistical_tests.rank_sum_test(); this wrapper adds the +/-/= presentation the results table needs.

Parameters:

algo_data (List[float]) – Data from the algorithm being tested.
base_data (List[float]) – Data from the baseline algorithm.
significance_level (float, optional) – P-value threshold for significance (default: 0.05).
direction (OptimizationDirection, optional) – Optimization direction (MINIMIZE or MAXIMIZE).
compute_effect_size (bool, optional) – Whether to also compute Cliff’s delta and store it in the effect_size / effect_magnitude fields of the result. Default: False, which leaves both fields as None.

Returns:

Result containing comparison symbol and p-value. Symbol: ‘+’ (better), ‘-’ (worse), ‘=’ (no significant difference).

Return type:

ComparisonResult

static select_representative_run(all_best_values: Dict[str, Dict[str, Dict[int, List[float]]]], algo: str, prob: str, task_idx: int, statistic_type: StatisticType) → int | None[source]

Select a representative run based on the specified statistic type.

Parameters:

all_best_values (Dict[str, Dict[str, Dict[int, List[float]]]]) – Nested dictionary containing best metric values.
algo (str) – Algorithm name.
prob (str) – Problem name.
task_idx (int) – Task index (0-based).
statistic_type (StatisticType) – Type of statistic (MEAN returns None as all runs are used). MEDIAN_IQR selects the same run as MEDIAN.

Returns:

Run number of the representative run, or None if MEAN or no valid data.

Return type:

Optional[int]

class ddmtolab.Methods.data_analysis.ComparisonResult(symbol: str, p_value: float | None = None, p_adjusted: float | None = None, effect_size: float | None = None, effect_magnitude: str | None = None)[source]

Result of statistical comparison between algorithms.

No-index:

Variables:

symbol (str) – Comparison symbol: ‘+’ (better), ‘-’ (worse), ‘=’ (no significant difference).
p_value (Optional[float]) – Raw (uncorrected) p-value from the statistical test, or None if the test was not performed.
p_adjusted (Optional[float]) – Multiplicity-corrected p-value, populated only when a correction such as Holm-Bonferroni is applied over a family of comparisons. None otherwise.
effect_size (Optional[float]) – Effect size (Cliff’s delta) oriented so that a positive value means the algorithm is better than the baseline. None when not requested.
effect_magnitude (Optional[str]) – Qualitative magnitude of effect_size: ‘negligible’, ‘small’, ‘medium’, ‘large’, or ‘undefined’. None when not requested.

class ddmtolab.Methods.data_analysis.FriedmanResult(statistic: float, p_value: float, average_ranks: ~typing.Dict[str, float], n_algorithms: int, n_instances: int, n_instances_dropped: int = 0, iman_davenport_statistic: float = nan, iman_davenport_p_value: float = nan, control: str | None = None, significance_level: float = 0.05, post_hoc: ~typing.List[~ddmtolab.Methods.data_analysis.FriedmanPostHocResult] = <factory>)[source]

Outcome of a Friedman test with post-hoc comparisons against a control.

No-index:

Variables:

statistic (float) – Friedman chi-squared statistic (chi^2_F).
p_value (float) – P-value of the omnibus Friedman test.
average_ranks (Dict[str, float]) – Average rank per algorithm (1 is best), keyed by algorithm name.
n_algorithms (int) – Number of algorithms compared.
n_instances (int) – Number of instances (blocks) retained after dropping incomplete ones.
n_instances_dropped (int) – Number of instances dropped because at least one algorithm had no value.
iman_davenport_statistic (float) – Iman-Davenport F_F statistic derived from chi^2_F, which corrects the Friedman statistic for being undesirably conservative.
iman_davenport_p_value (float) – P-value of F_F under F(k-1, (k-1)(N-1)).
control (Optional[str]) – Control algorithm used for the post-hoc comparisons.
significance_level (float) – Significance level applied to the corrected post-hoc p-values.
post_hoc (List[FriedmanPostHocResult]) – One entry per algorithm, in the order the algorithms were supplied.

class ddmtolab.Methods.data_analysis.FriedmanPostHocResult(algorithm: str, average_rank: float, z_statistic: float, p_value: float | None = None, p_adjusted: float | None = None, significant: bool = False, symbol: str = '')[source]

One post-hoc comparison of an algorithm against the control algorithm.

No-index:

Variables:

algorithm (str) – Name of the compared algorithm.
average_rank (float) – Average Friedman rank of the algorithm (1 is best).
z_statistic (float) – Standardized rank difference against the control algorithm.
p_value (Optional[float]) – Raw two-sided p-value, or None for the control algorithm itself.
p_adjusted (Optional[float]) – Holm-Bonferroni corrected p-value over the k-1 comparisons, or None for the control algorithm itself.
significant (bool) – Whether the corrected p-value is below the significance level.
symbol (str) – ‘+’ (better than control), ‘-’ (worse), ‘=’ (not significant), or ‘’ for the control algorithm itself.

Animation Generator

class ddmtolab.Methods.animation_generator.AnimationGenerator(data_path='./Data', save_path='./Results', algorithm_order=None, title=None, merge=0, max_nfes=100, fps=10, dpi=100, interval=100, format='gif', log_scale=False, file_suffix='.pkl')[source]

Main class for generating optimization process animations.

For single-objective tasks:

Decision space convergence (scatter plot)
Convergence curve (best objective value over NFEs)

For multi-objective tasks:

Decision space convergence (scatter plot)
Objective space convergence (Pareto front evolution)

Supports 4 merge modes for comparing multiple algorithms:

merge=0: No merge, individual animations
merge=1: Full merge, all algorithms in same plots
merge=2: Decision space separated, objective space merged
merge=3: Both decision and objective spaces separated

Variables:

data_path (Path) – Path to the data directory containing pickle files.
save_path (Path) – Path to save animation files.

run()[source]

Execute the animation generation pipeline.

Returns:: Dictionary with ‘success’ and ‘failed’ lists of filenames.
Return type:: dict

ddmtolab.Methods.animation_generator.create_optimization_animation(pkl_path=None, output_path=None, fps=10, dpi=100, interval=100, data_path='./Data', save_path='./Results', pattern='*.pkl', format='gif', merge=0, title=None, algorithm_order=None, max_nfes=100, logscale=False)[source]

Convenience function to create optimization animation.

If pkl_path is None, automatically scans data_path for all .pkl files.

Parameters:

pkl_path (str or list, optional) – Path to the .pkl results file, or list of paths for merge mode. If None, scans data_path for all .pkl files
output_path (str, optional) – Path for output animation file
fps (int, optional) – Frames per second (default: 10)
dpi (int, optional) – DPI for output (default: 100)
interval (int, optional) – Delay between frames in milliseconds (default: 100)
data_path (str, optional) – Directory to scan for .pkl files when pkl_path is None (default: ‘./Data’)
save_path (str, optional) – Directory to save animations when pkl_path is None (default: ‘./Results’)
pattern (str, optional) – File pattern to search for when pkl_path is None (default: '*.pkl')
format (str, optional) – Output format: ‘gif’ or ‘mp4’ (default: ‘gif’)
merge (int, optional) – Merge mode (default: 0) - 0: No merge, individual animations for each file - 1: Full merge, all algorithms in same plots (left & right) - 2: Partial merge, separate decision space (left), merged objective space (right) - 3: Separate plots, decision and objective spaces both separated
title (str, optional) – Custom title for the animation (for merge mode, default is ‘test’)
algorithm_order (list, optional) – List of algorithm names (file stems) specifying the display order. Only used when merge>0. If None, uses the order from pkl_path. Example: [‘BO’, ‘MTBO’, ‘RAMTEA’, ‘BO-LCB-BCKT’]
max_nfes (int or list, optional) – Maximum number of function evaluations (NFEs) for each task. Can be a scalar (same for all tasks) or a list (one per task). Default: 100 Examples: max_nfes=200 or max_nfes=[200, 300]
logscale (bool, optional) – Use logarithmic scale for y-axis in single-objective convergence curves (default: False)

Returns:

If pkl_path is provided: Path to the saved animation file If pkl_path is None: Dictionary with ‘success’ and ‘failed’ lists

Return type:

str or dict

Examples

>>> # Single file - GIF (default)
>>> create_optimization_animation('results.pkl')
>>>
>>> # Single file with custom NFEs and log scale
>>> create_optimization_animation('results.pkl', max_nfes=200, logscale=True)
>>> create_optimization_animation('results.pkl', max_nfes=[200, 300])  # Multi-task
>>>
>>> # Single file - MP4 (smaller file, better quality)
>>> create_optimization_animation('results.pkl', format='mp4')
>>> create_optimization_animation('results.pkl', output_path='result.mp4')
>>>
>>> # Merge mode 1: Full merge with log scale
>>> create_optimization_animation(['algo1.pkl', 'algo2.pkl', 'algo3.pkl'], merge=1,
>>>                               max_nfes=200, logscale=True)
>>>
>>> # Merge mode 2 with custom order: Decision separated, objective merged
>>> create_optimization_animation(
>>>     ['algo1.pkl', 'algo2.pkl', 'algo3.pkl'],
>>>     merge=2,
>>>     title='Comparison',
>>>     algorithm_order=['BO', 'MTBO', 'RAMTEA'],
>>>     max_nfes=[200, 300],
>>>     logscale=True
>>> )
>>>
>>> # Merge mode 3: All separated with custom order
>>> create_optimization_animation(
>>>     ['algo1.pkl', 'algo2.pkl'],
>>>     merge=3,
>>>     algorithm_order=['RAMTEA', 'BO'],
>>>     max_nfes=500
>>> )
>>>
>>> # Auto-scan - generate all as MP4
>>> create_optimization_animation(format='mp4', max_nfes=200)
>>> create_optimization_animation(dpi=70, fps=8, format='mp4')
>>>
>>> # Auto-scan and merge all files with custom order
>>> create_optimization_animation(
>>>     merge=1,
>>>     title='All Algorithms',
>>>     algorithm_order=['BO', 'MTBO', 'RAMTEA', 'BO-LCB-BCKT'],
>>>     max_nfes=1000,
>>>     logscale=True
>>> )

ddmtolab.Methods.animation_generator.generate_all_animations(data_path='./Data', save_path='./Results', fps=10, dpi=100, interval=100, pattern='*.pkl', format='gif', merge=0, title=None, algorithm_order=None, max_nfes=100, logscale=False)[source]

Automatically scan for .pkl files and generate animations for all results.

Parameters:

data_path (str) – Directory containing .pkl result files (default: ‘./Data’)
save_path (str) – Directory to save animation files (default: ‘./Results’)
fps (int) – Frames per second (default: 10)
dpi (int) – Resolution (default: 100)
interval (int) – Interval between frames in milliseconds (default: 100)
pattern (str) – File pattern to search for (default: '*.pkl')
format (str) – Output format: ‘gif’ or ‘mp4’ (default: ‘gif’)
merge (int) – Merge mode (default: 0)
title (str, optional) – Custom title for merged animation (default: ‘test’)
algorithm_order (list, optional) – List of algorithm names specifying the display order when merge>0. Example: [‘BO’, ‘MTBO’, ‘RAMTEA’, ‘BO-LCB-BCKT’]
max_nfes (int or list, optional) – Maximum number of function evaluations (NFEs) for each task. Can be a scalar (same for all tasks) or a list (one per task). Default: 100
logscale (bool, optional) – Use logarithmic scale for y-axis in single-objective convergence curves (default: False)

Returns:

Dictionary with ‘success’ and ‘failed’ lists of filenames

Return type:

dict

Performance Metrics

class ddmtolab.Methods.metrics.CV[source]

Constraint Violation (CV) metric. Lower is better (ideally 0 for feasible solutions).

calculate(cons: ndarray) → float[source]

Compute CV metric - returns the best (minimum) CV in the population

Parameters:: cons ((n, c) constraint violation matrix) – where n is the number of solutions and c is the number of constraints Constraint is satisfied when cons <= 0
Returns:: float
Return type:: CV value of the best solution (minimum CV)

class ddmtolab.Methods.metrics.DeltaP[source]

Averaged Hausdorff Distance (Δp) metric. Lower is better.

calculate(objs: ndarray, pf: ndarray) → float[source]

Compute Δp(objs, pf)

Parameters:

objs ((n, m) obtained objective vectors)
pf ((n_pf, m) true Pareto front)

Returns:

float

Return type:

Δp value (Averaged Hausdorff Distance)

class ddmtolab.Methods.metrics.FR[source]

Feasible Rate metric. Calculates the proportion of feasible solutions in the population. Higher is better (more feasible solutions).

calculate(cons: ndarray) → float[source]

Compute feasible rate

Parameters:: cons ((n, c) constraint violation matrix) – where n is the number of solutions and c is the number of constraints A solution is feasible if all constraints <= 0
Returns:: float
Return type:: Feasible rate (proportion of feasible solutions)

class ddmtolab.Methods.metrics.GD[source]

Generational Distance (GD) metric. Lower is better.

calculate(objs: ndarray, pf: ndarray) → float[source]

Compute GD(objs, pf)

Parameters:

objs ((n, m) obtained objective vectors)
pf ((n_pf, m) true Pareto front)

Returns:

float

Return type:

GD value

class ddmtolab.Methods.metrics.HV[source]

Hypervolume (HV) metric. Higher is better.

calculate(objs: ndarray, pf: ndarray = None, reference: ndarray = None) → float[source]

Compute HV for a set of objective vectors.

The objectives are normalized so that the reference point maps to 1 in every dimension, which puts the result on the [0, 1] scale whichever way the reference is supplied. Passing pf places the reference 10% beyond the front, so calculate(objs, pf=front) equals calculate(objs, reference=fmin + 1.1 * (front.max(0) - fmin)).

Parameters:

objs (np.ndarray) – Objective matrix, shape (n, m)
pf (np.ndarray, optional) – True Pareto front, whose nadir defines the reference point, shape (n_pf, m)
reference (np.ndarray, optional) – Reference point for HV calculation, shape (m,)

Returns:

HV value in [0, 1]

Return type:

float

Raises:

ValueError – If neither pf nor reference is given.

class ddmtolab.Methods.metrics.IGD[source]

Inverted Generational Distance (IGD) metric. Lower is better.

calculate(objs: ndarray, pf: ndarray) → float[source]

Compute IGD(objs, pf)

Parameters:

objs ((n, m) obtained objective vectors)
pf ((n_pf, m) true Pareto front)

Returns:

float

Return type:

IGD value

class ddmtolab.Methods.metrics.IGDp[source]

Inverted Generational Distance Plus (IGD+) metric. Lower is better.

calculate(objs: ndarray, pf: ndarray) → float[source]

Compute IGD+(objs, pf)

Parameters:

objs ((n, m) obtained objective vectors)
pf ((n_pf, m) true Pareto front)

Returns:

float

Return type:

IGD+ value

class ddmtolab.Methods.metrics.Spacing[source]

Spacing metric. Lower is better.

calculate(objs: ndarray) → float[source]

Compute Spacing metric

Parameters:: objs ((n, m) obtained objective vectors) – where n is the number of solutions and m is the number of objectives
Returns:: float
Return type:: Spacing value (standard deviation of nearest neighbor distances)

class ddmtolab.Methods.metrics.Spread[source]

Spread metric. Lower is better.

calculate(objs: ndarray, pf: ndarray) → float[source]

Compute Spread metric

Parameters:

objs ((n, m) obtained objective vectors) – where n is the number of solutions and m is the number of objectives
pf ((n_pf, m) true Pareto front)

Returns:

float

Return type:

Spread value

Algorithm Utilities

This script contains commonly used components for implementing algorithms.

Author: Jiangtao Shen Email: j.shen5@exeter.ac.uk Date: 2025.10.18 Version: 1.0

class ddmtolab.Methods.Algo_Methods.algo_utils.Results(best_decs: List[ndarray], best_objs: List[ndarray], all_decs: List[List[ndarray]], all_objs: List[List[ndarray]], runtime: float, max_nfes: List[int], best_cons: List[ndarray] | None = None, all_cons: List[List[ndarray]] | None = None, bounds: List[Tuple[ndarray, ndarray]] | None = None)[source]

Container for optimization results.

Variables:

best_decs (List[np.ndarray]) – Best decision variables for each task
best_objs (List[np.ndarray]) – Best objective values for each task
all_decs (List[List[np.ndarray]]) – Decision variables history for all tasks across generations
all_objs (List[List[np.ndarray]]) – Objective values history for all tasks across generations
runtime (float) – Total runtime in seconds
max_nfes (List[int]) – Function evaluations each task actually consumed, which the recorded history spans. This is a measurement, not the requested budget: an algorithm may overshoot its budget on the last generation, and in multitask algorithms that share one population the split across tasks is decided at run time and is rarely even. Analysis code relies on it to scale the horizontal axis of convergence curves, so it must never be filled with the declared max_nfes argument.
best_cons (Optional[List[np.ndarray]]) – Best constraint values for each task (None if unconstrained)
all_cons (Optional[List[List[np.ndarray]]]) – Constraint values history for all tasks (None if unconstrained)
bounds (Optional[List[np.ndarray]]) – Bounds for each task, where each element is a 2D array with shape (2, dim)

all_cons: List[List[ndarray]] | None = None

all_decs: List[List[ndarray]]

all_objs: List[List[ndarray]]

best_cons: List[ndarray] | None = None

best_decs: List[ndarray]

best_objs: List[ndarray]

bounds: List[Tuple[ndarray, ndarray]] | None = None

max_nfes: List[int]

runtime: float

ddmtolab.Methods.Algo_Methods.algo_utils.align_dimensions(dec, target_dim, fill='random')[source]

Align decision variable dimensions to target dimension.

Supports both 1D vectors and 2D arrays. If the input has fewer dimensions than the target, padding is added. If it has more, it is truncated.

Parameters:

dec (np.ndarray) – Decision variable(s), shape (dim,) for 1D or (n, dim) for 2D
target_dim (int) – Target dimension
fill (str, optional) – Padding strategy: ‘random’ for U[0,1] values, ‘zero’ for zeros (default: ‘random’)

Returns:

aligned_dec – Aligned decision variable(s), shape (target_dim,) or (n, target_dim)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.append_history(*pairs: Any) → Tuple[list, ...][source]

Append current generation data to history storage.

Parameters:

*pairs (tuple) –

Alternating pairs of (history_list, current_data).

history_list: List to store historical data
current_data: Either a single np.ndarray (single task) or List[np.ndarray] (multi-task)

Returns:

results – All updated history lists (all_1, all_2, …)

Return type:

tuple

ddmtolab.Methods.Algo_Methods.algo_utils.build_save_results(all_decs: List[List[ndarray]], all_objs: List[List[ndarray]], runtime: float, max_nfes: List[int], all_cons: List[List[ndarray]] | None = None, bounds: List[Tuple[ndarray, ndarray]] | None = None, save_path: str | None = None, filename: str | None = None, save_data: bool = True, **kwargs) → Results[source]

Extract best solutions, build results, and optionally save to file.

Automatically detects single-objective vs multi-objective tasks:

Single-objective (n_objs=1): returns the best individual
Multi-objective (n_objs>1): returns the entire final population (Pareto front)

Parameters:

all_decs (List[List[np.ndarray]]) – Decision variables history for all tasks. all_decs[i][g] has shape (n_samples, dim) for task i at generation g.
all_objs (List[List[np.ndarray]]) – Objective values history for all tasks. all_objs[i][g] has shape (n_samples, n_objs) for task i at generation g.
runtime (float) – Total runtime in seconds
max_nfes (List[int]) – Function evaluations each task actually consumed, i.e. the algorithm’s own per-task counter at the end of the run, not the budget it was asked for. Pass the measured counts: analysis code uses this to scale the horizontal axis of convergence curves, so a declared budget here silently mis-scales every plot.
all_cons (List[List[np.ndarray]], optional) – Constraint values history for all tasks (default: None)
bounds (List[Tuple[np.ndarray, np.ndarray]], optional) – Bounds (lower, upper) for each task (default: None)
save_path (str, optional) – Directory path where the results will be saved (default: None)
filename (str, optional) – Name of the output file without extension (default: None)
save_data (bool, optional) – Whether to save the data to file (default: True)
**kwargs (dict) – Additional data to include in the saved file

Returns:

results – Results object containing best solutions and optimization history

Return type:

Results

ddmtolab.Methods.Algo_Methods.algo_utils.build_staircase_history(db_decs: List[ndarray], db_objs: List[ndarray], k: int = 1, db_cons: List[ndarray] | None = None) → Tuple[List[List[ndarray]], List[List[ndarray]]] | Tuple[List[List[ndarray]], List[List[ndarray]], List[List[ndarray]]][source]

Convert flat database lists into staircase history structure.

For each task, creates an incrementally growing sequence of generations where generation g contains min(k * (g+1), total) solutions from the database.

Parameters:

db_decs (List[np.ndarray]) – Database of all decision variables per task. db_decs[i] has shape (n_i, dim_i).
db_objs (List[np.ndarray]) – Database of all objective values per task. db_objs[i] has shape (n_i, n_objs).
k (int, optional) – Step size controlling the staircase gradient (default: 1). Generation g contains min(k * (g+1), total) solutions.
db_cons (List[np.ndarray], optional) – Database of all constraint values per task (default: None).

Returns:

all_decs (List[List[np.ndarray]]) – Staircased decision variable history.
all_objs (List[List[np.ndarray]]) – Staircased objective value history.
all_cons (List[List[np.ndarray]], optional) – Staircased constraint history (only returned if db_cons is not None).

ddmtolab.Methods.Algo_Methods.algo_utils.cmaes_init_params(dim, lam=None, sigma0=0.3)[source]

Initialize CMA-ES parameters for a given dimension.

Parameters:

dim (int) – Problem dimension
lam (int, optional) – Population size (lambda). If None, uses 4 + floor(3 * log(dim)).
sigma0 (float, optional) – Initial step size (default: 0.3)

Returns:

params – CMA-ES state dictionary containing:

Strategy parameters: dim, lam, mu, weights, mueff
Control parameters: cs, damps, cc, c1, cmu, chiN
State variables: m_dec, ps, pc, B, D, C, invsqrtC, sigma, eigenFE

Return type:

dict

ddmtolab.Methods.Algo_Methods.algo_utils.cmaes_sample(m_dec, sigma, B, D, lam, clip=True)[source]

Generate offspring using CMA-ES sampling.

Samples from N(m_dec, sigma^2 * C) where C = B * diag(D^2) * B^T.

Parameters:

m_dec (np.ndarray) – Mean decision vector, shape (d,)
sigma (float) – Step size (global scaling factor)
B (np.ndarray) – Eigenvector matrix from covariance decomposition, shape (d, d)
D (np.ndarray) – Square root of eigenvalues (standard deviations), shape (d,)
lam (int) – Number of offspring to generate
clip (bool, optional) – If True, clip offspring to [0, 1] (default: True)

Returns:

offdecs – Offspring decision variables, shape (lam, d)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.cmaes_update(params, sorted_decs, nfes)[source]

Update CMA-ES parameters given fitness-sorted offspring.

Updates mean, evolution paths, covariance matrix, step size, and performs eigendecomposition when needed. Modifies params dict in-place.

Parameters:

params (dict) – CMA-ES parameter dictionary from cmaes_init_params()
sorted_decs (np.ndarray) – Offspring sorted by fitness (best first), shape (>=mu, dim)
nfes (int) – Current number of function evaluations (for eigendecomposition timing)

Returns:

restarted – True if eigendecomposition failed and covariance was reset to identity

Return type:

bool

ddmtolab.Methods.Algo_Methods.algo_utils.constrained_sort(objs, cvs)[source]

Sort indices by constraint violation first, then by objective value (ascending).

Parameters:

objs (np.ndarray) – Objective values, shape (n,) or (n, 1)
cvs (np.ndarray) – Constraint violation values (total CV per individual), shape (n,) or (n, 1)

Returns:

sorted_indices – Indices that would sort the population by (cvs, objs) ascending, shape (n,)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.crossover(par_dec1: ndarray, par_dec2: ndarray, mu: float = 2) → tuple[ndarray, ndarray][source]

Perform Simulated Binary Crossover (SBX) on two decision vectors.

Parameters:

par_dec1 (np.ndarray) – First parent decision vector, values scaled in [0, 1], shape (dim,)
par_dec2 (np.ndarray) – Second parent decision vector, values scaled in [0, 1], shape (dim,)
mu (float, optional) – Distribution index for crossover (default: 2)

Returns:

off_dec1 (np.ndarray) – First offspring decision vector, values clipped to [0, 1], shape (dim,)
off_dec2 (np.ndarray) – Second offspring decision vector, values clipped to [0, 1], shape (dim,)

ddmtolab.Methods.Algo_Methods.algo_utils.crowding_distance(pop_obj: ndarray, front_no: ndarray | None = None) → ndarray[source]

Calculate the crowding distance for a population of solutions.

Parameters:

pop_obj (np.ndarray) – Objective value matrix, shape (n, m), where n is the number of solutions and m is the number of objectives
front_no (np.ndarray, optional) – Non-dominated front number for each solution, shape (n,). If not provided, all solutions are assumed to belong to the same front.

Returns:

crowd_dis – Crowding distance for each solution, shape (n,). Boundary solutions are assigned infinite distance.

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.de_generation(parents: ndarray, F: float, CR: float) → ndarray[source]

Generate offspring for a population using Differential Evolution (DE).

Uses DE/rand/1/bin strategy: random base vector, one difference vector, and binomial crossover.

Parameters:

parents (np.ndarray) – Array of parent solutions, shape (n, d)
F (float) – Differential weight (mutation scale factor)
CR (float) – Crossover rate in [0, 1] for binomial crossover

Returns:

offdecs – Offspring array, shape (n, d), clipped to [0, 1]

Return type:

np.ndarray

Inverse normalization to restore original scale.

Parameters:

data (Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]) –
Normalized data (same format as normalize() output).
- Single 1D array: [0, 0.25, 0.5, 0.75, 1]
- Single 2D matrix: [[0, 0], [0.5, 0.5], [1, 1]]
- List of multiple arrays/matrices
stat1 (Union[np.ndarray, List[np.ndarray]]) – Min values (minmax) or mean values (zscore) from normalize()
stat2 (Union[np.ndarray, List[np.ndarray]]) – Max values (minmax) or std values (zscore) from normalize()
axis (int, optional) –
Must match the axis used in normalize(), default is 0.
- 0: Column-wise normalization (default)
- 1: Row-wise normalization
method (str, optional) –
Must match the method used in normalize(), default is ‘minmax’.
- ’minmax’: Inverse min-max normalization (default)
- ’zscore’: Inverse z-score normalization

Returns:

restored – Restored data in original scale (same format as input)

Return type:

Union[np.ndarray, List[np.ndarray]]

ddmtolab.Methods.Algo_Methods.algo_utils.dsmerge(S, Y, ds=1e-14)[source]

Merge data for duplicate/near-duplicate design sites.

Finds clusters of points within threshold distance in normalized space and merges them by averaging.

Parameters:

S (np.ndarray) – Design sites, shape (m, n)
Y (np.ndarray) – Responses, shape (m,) or (m, 1)
ds (float) – Threshold for near-duplicate detection (default: 1e-14)

Returns:

mS (np.ndarray) – Merged design sites
mY (np.ndarray) – Merged responses

ddmtolab.Methods.Algo_Methods.algo_utils.evaluation(problem, decs: List[ndarray], unified: bool = False, fill_value: float = 0.0, eval_objectives: bool | List[bool | int | List[int]] = True, eval_constraints: bool | List[bool | int | List[int]] = True) → Tuple[List[ndarray], List[ndarray]][source]

Evaluate a list of decision variable matrices on multiple tasks.

Parameters:

problem (MTOP) – An instance of the MTOP class.
decs (list of ndarray) – List of decision variable matrices for each task, shape [n, d_i], scaled in [0,1].
unified (bool, optional) – If True, pad objectives to m_max and constraints to c_max. Default False.
fill_value (float, optional) – Value used for padding in unified mode. Default 0.0.
eval_objectives (bool or list, optional) –
- True: evaluate all objectives for all tasks (default)
- False: skip objective evaluation for all tasks
- List: per-task specification, each element can be:
  - True/False: evaluate all/none
  - int: evaluate only the i-th objective
  - List[int]: evaluate specified objectives
eval_constraints (bool or list, optional) –
- True: evaluate all constraints for all tasks (default)
- False: skip constraint evaluation for all tasks
- List: per-task specification, same format as eval_objectives

Returns:

objs (list of ndarray) – List of objective value matrices for each task.
- Normal mode: shape [n, m_i] or [n, len(selected)]
- Unified mode: shape [n, m_max]
cons (list of ndarray) – List of constraint value matrices for each task.
- Normal mode: shape [n, c_i] or [n, 1] if no constraints
- Unified mode: shape [n, c_max]

ddmtolab.Methods.Algo_Methods.algo_utils.evaluation_single(problem, decs: ndarray, index: int, unified: bool = False, fill_value: float = 0.0, eval_objectives: bool | int | List[int] = True, eval_constraints: bool | int | List[int] = True) → Tuple[ndarray, ndarray][source]

Evaluate decision variables on a specific task.

Parameters:

problem (MTOP) – An instance of the MTOP class.
decs (ndarray) – Decision variable matrix for the task, shape [n, d], scaled in [0,1].
index (int) – Index of the task to evaluate.
unified (bool, optional) – If True, pad objectives to m_max and constraints to c_max. Default False.
fill_value (float, optional) – Value used for padding in unified mode. Default 0.0.
eval_objectives (bool, int, or list of int, optional) –
- True: evaluate all objectives (default)
- False: skip objective evaluation
- int: evaluate only the i-th objective
- List[int]: evaluate specified objectives
eval_constraints (bool, int, or list of int, optional) –
- True: evaluate all constraints (default)
- False: skip constraint evaluation
- int: evaluate only the i-th constraint
- List[int]: evaluate specified constraints

Returns:

objs (ndarray) – Objective values for the task.
- Normal mode: shape [n, m] or [n, len(selected)]
- Unified mode: shape [n, m_max]
cons (ndarray) – Constraint values for the task.
- Normal mode: shape [n, c] or [n, 1] if no constraints
- Unified mode: shape [n, c_max]

ddmtolab.Methods.Algo_Methods.algo_utils.ga_generation(parents: ndarray, muc: float, mum: float) → ndarray[source]

Generate offspring population using genetic algorithm operators.

Applies simulated binary crossover (SBX) and polynomial mutation to create offspring from parent population.

Parameters:

parents (np.ndarray) – Parent population, shape (n, d)
muc (float) – Distribution index for crossover
mum (float) – Distribution index for mutation

Returns:

offdecs – Offspring decision variables, shape (n, d)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.ga_generation_matlab(parents: ndarray, muc: float, mum: float) → ndarray[source]

Offspring generation matching MTO-Platform GA.Generation exactly.

A random permutation is split in halves and parent i is paired with parent i + floor(N/2) for i = 1..ceil(N/2); each pair yields two children (SBX then polynomial mutation), and the single clip to [0, 1] happens only after mutation. For odd N this produces N + 1 offspring (the middle permutation index is used twice), exactly as in MATLAB.

Parameters:

parents (np.ndarray) – Parent population, shape (n, d)
muc (float) – Distribution index for crossover
mum (float) – Distribution index for mutation

Returns:

offdecs – Offspring decision variables, shape (2 * ceil(n / 2), d)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.get_algorithm_information(algorithm_class: type, print_info: bool = True) → dict[source]

Get algorithm information from any algorithm class.

Parameters:

algorithm_class (type) – Algorithm class with ‘algorithm_information’ attribute
print_info (bool, optional) – Whether to print the information (default: True)

Returns:

algo_info – Algorithm information dictionary

Return type:

dict

ddmtolab.Methods.Algo_Methods.algo_utils.ibea_fitness(objs, kappa)[source]

Calculate fitness values for the population using IBEA indicator.

Parameters:

objs (ndarray) – Objective values with shape (N, M), where N is the number of individuals and M is the number of objectives.
kappa (float) – Fitness scaling factor.

Returns:

fitness (ndarray) – Fitness values for each individual with shape (N,).
I (ndarray) – Indicator matrix with shape (N, N).
C (ndarray) – Normalization constants with shape (N,).

ddmtolab.Methods.Algo_Methods.algo_utils.init_history(decs: List[ndarray], objs: List[ndarray], cons: List[ndarray] | None = None) → tuple[List[List[ndarray]], List[List[ndarray]]] | tuple[List[List[ndarray]], List[List[ndarray]], List[List[ndarray]]][source]

Initialize history storage for populations across generations.

Parameters:

decs (List[np.ndarray]) – Initial decision variables for each task. decs[i] has shape (n_samples, dim) for task i.
objs (List[np.ndarray]) – Initial objective values for each task. objs[i] has shape (n_samples, n_objs) for task i.
cons (List[np.ndarray], optional) – Initial constraint values for each task (default: None). cons[i] has shape (n_samples, n_cons) for task i.

Returns:

all_decs (List[List[np.ndarray]]) – History storage for decision variables
all_objs (List[List[np.ndarray]]) – History storage for objective values
all_cons (List[List[np.ndarray]], optional) – History storage for constraint values (only returned if cons is not None)

ddmtolab.Methods.Algo_Methods.algo_utils.initialization(problem: MTOP, n: int | List[int], method: str = 'random', the_same: bool = False) → List[ndarray][source]

Initialize decision variable matrices for multiple tasks.

Parameters:

problem (MTOP) – An instance of the MTOP class
n (Union[int, List[int]]) –
Number of samples per task.
- If int: same number of samples for all tasks
- If list: number of samples for each task, e.g., [30, 50]
method (str, optional) – Sampling method: ‘random’ or ‘lhs’ (default: ‘random’)
the_same (bool, optional) – If True, all tasks share the same sample points (default: False). For tasks with different dimensions, samples are generated in the maximum dimension and then truncated to each task’s dimension.

Returns:

decs – List of decision variable matrices for each task. decs[i] has shape (n_i, d_i) for task i.

Return type:

List[np.ndarray]

ddmtolab.Methods.Algo_Methods.algo_utils.is_duplicate(x, X, epsilon=1e-10)[source]

Check if position(s) x are duplicates in X or within themselves.

Parameters:

x (np.ndarray) – Position(s) to check, shape (dim,) or (1, dim) or (n_points, dim)
X (np.ndarray) – Existing positions, shape (n_samples, dim)
epsilon (float) – Tolerance for duplicate detection

Returns:

If x is single point: returns bool
If x contains multiple points: returns list of bool for each point

Return type:

bool or list of bool

ddmtolab.Methods.Algo_Methods.algo_utils.kmeans_clustering(data, k)[source]

K-means clustering using sklearn.

Parameters:

data (np.ndarray) – Data points, shape (N, D)
k (int) – Number of clusters

Returns:

labels – Cluster labels for each point, shape (N,) Labels are integers in range [0, k-1]

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.merge_archive(arc_decs, arc_objs, new_decs, new_objs)[source]

Update archive by merging and removing duplicates.

Parameters:

arc_decs (np.ndarray) – Current archive
arc_objs (np.ndarray) – Current archive
new_decs (np.ndarray) – New solutions
new_objs (np.ndarray) – New solutions

Returns:

merged_decs, merged_objs – Updated archive

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.mutation(dec: ndarray, mu: float = 5) → ndarray[source]

Perform polynomial mutation on a decision vector.

Parameters:

dec (np.ndarray) – Parent decision vector, values scaled in [0, 1], shape (dim,)
mu (float, optional) – Distribution index for mutation (default: 5)

Returns:

mutated_dec – Mutated decision vector, values clipped to [0, 1], shape (dim,)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.nd_sort(objs: ndarray, *args) → Tuple[ndarray, int][source]

Perform non-dominated sorting on a population of objective values.

Parameters:

objs (np.ndarray) – Objective value matrix, shape (n, m)
*args (tuple) –
Optional arguments:
- (n_sort,): Number of solutions to sort
- (cons, n_sort): Constraint matrix and number of solutions to sort

Returns:

front_no (np.ndarray) – Non-dominated front number for each solution, shape (n,)
max_fno (int) – Maximum front number assigned

ddmtolab.Methods.Algo_Methods.algo_utils.newrb_surrogate(X_train, Y_train, goal=0.1, spread=1.0, max_neurons=8)[source]

Build an approximating Gaussian RBF network equivalent to MATLAB’s newrb(X', y', goal, spread, max_neurons).

Neurons (centered on training points) are added greedily: at each step the candidate input vector whose basis-function column best explains the current residual is added, and the output layer (weights + bias) is re-solved by least squares. Growth stops when the training MSE drops to goal or max_neurons neurons are reached.

Parameters:

X_train (np.ndarray) – Training inputs, shape (n, d)
Y_train (np.ndarray) – Training outputs, shape (n,) or (n, 1)
goal (float) – Target mean squared error (default: 0.1)
spread (float) – Gaussian spread parameter (default: 1.0)
max_neurons (int) – Maximum number of hidden neurons (default: 8)

Returns:

predict – predict(x) accepts an array of shape (nq, d) or (d,) and returns predictions of shape (nq,)

Return type:

callable

ddmtolab.Methods.Algo_Methods.algo_utils.newrbe_surrogate(X_train, Y_train, spread=None)[source]

Build an exact Gaussian RBF interpolant equivalent to MATLAB’s newrbe(X', y', spread). When spread is None it is estimated as max(pairwise distance) / (dim * n) ** (1 / dim).

MATLAB’s newrbe uses Gaussian basis functions exp(-(0.8326 * r / spread)^2) (so that the response is 0.5 at distance spread) plus an output bias, solved as an underdetermined linear system. Here the (n+1)-parameter system is solved with least squares (minimum-norm solution).

Parameters:

X_train (np.ndarray) – Training inputs, shape (n, d)
Y_train (np.ndarray) – Training outputs, shape (n,) or (n, 1)
spread (float, optional) – Gaussian spread parameter; estimated from the data when None.

Returns:

predict – predict(x) accepts an array of shape (nq, d) or (d,) and returns predictions of shape (nq,)

Return type:

callable

Normalize input data (arrays or matrices).

Parameters:

data (Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]) –
Supports the following input formats:
- Single 1D array: [1, 2, 3]
- Single 2D matrix: [[1,2], [3,4]]
- List of multiple arrays/matrices: [[1,2,3], [4,5,6]] or [matrix1, matrix2]
axis (int, optional) –
Axis along which to normalize (only applies to 2D+ data), default is 0.
- 0: Column-wise normalization (default, recommended for multi-objective optimization)
- 1: Row-wise normalization
- For 1D arrays, global normalization is always used
method (str, optional) –
Normalization method, default is ‘minmax’.
- ’minmax’: Min-max normalization, scales to [0, 1] (default)
- ’zscore’: Z-score normalization, mean=0, std=1

Returns:

normalized (Union[np.ndarray, List[np.ndarray]]) – Normalized result (same format as input)
stat1 (Union[np.ndarray, List[np.ndarray]]) – Min values (minmax) or mean values (zscore)
stat2 (Union[np.ndarray, List[np.ndarray]]) – Max values (minmax) or std values (zscore)

ddmtolab.Methods.Algo_Methods.algo_utils.nsga2_sort(objs: ndarray, cons: ndarray | None = None) → Tuple[ndarray, ndarray, ndarray][source]

Sort solutions by the NSGA-II criteria (PlatEMO/MToP NSGA2Sort).

Parameters:

objs (np.ndarray) – Objective value matrix of shape (pop_size, n_obj)
cons (np.ndarray, optional) – Constraint matrix of shape (pop_size, n_con). If None or empty, no constraints are considered (default: None)

Returns:

rank (np.ndarray) – Ranking of each solution (0-based index after sorting) of shape (pop_size,). rank[i] indicates the position of solution i in the sorted order
front_no (np.ndarray) – Non-dominated front number of each solution of shape (pop_size,)
crowd_dis (np.ndarray) – Crowding distance of each solution of shape (pop_size,)

Notes

Solutions are sorted first by front number (ascending), then by crowding distance (descending). Larger crowding distance values indicate better diversity preservation.

ddmtolab.Methods.Algo_Methods.algo_utils.par_list(par: int | List[int], n_tasks: int) → List[int][source]

Convert a parameter to a list for multi-task scenarios.

Parameters:

par (Union[int, List[int]]) – Parameter value(s) - can be a single integer or a list
n_tasks (int) – Number of tasks

Returns:

par_per_task – List of parameter values, one for each task.

If par is int: returns [par, par, …, par] (n_tasks times)
If par is list: returns the list as is

Return type:

List[int]

ddmtolab.Methods.Algo_Methods.algo_utils.platemo_tournament_selection(K: int, N: int, *fitness: ndarray) → ndarray[source]

Exact port of PlatEMO’s TournamentSelection.

Candidates are compared lexicographically on the given fitness keys (lower values are better). Solutions with identical fitness values share the same rank, so a tournament among tied candidates is decided by the (random) draw order, i.e. uniformly at random. This differs from ranking with a composite total order, which would break ties deterministically.

Parameters:

K (int) – Tournament size
N (int) – Number of parents to select
*fitness (np.ndarray) – One or more fitness vectors of equal length (primary key first)

Returns:

index – Indices of the selected parents, shape (N,)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.poly_mutation_unclipped(dec: ndarray, mu: float) → ndarray[source]

Polynomial mutation (MTO-Platform GA_Mutation) with probability 1/D per gene.

Operates on the possibly out-of-bounds crossover output and does NOT clip; the caller clips once afterwards, matching the MATLAB reference.

Parameters:

dec (np.ndarray) – Decision vector to mutate, shape (d,)
mu (float) – Distribution index for mutation

Returns:

dec – Mutated decision vector, unclipped, shape (d,)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.rbf_build(X_train, Y_train, bf_c=1.0)[source]

Build an RBF (Multiquadric) interpolation model.

Parameters:

X_train (np.ndarray) – Training inputs, shape (n, d)
Y_train (np.ndarray) – Training outputs, shape (n,) or (n, 1)
bf_c (float) – Multiquadric parameter (default: 1.0)

Returns:

model – RBF model containing coefficients and parameters

Return type:

dict

ddmtolab.Methods.Algo_Methods.algo_utils.rbf_predict(model, X_train, X_query)[source]

Predict using RBF model.

Parameters:

model (dict) – RBF model from rbf_build
X_train (np.ndarray) – Training inputs, shape (n, d)
X_query (np.ndarray) – Query points, shape (nq, d)

Returns:

Y_pred – Predicted values, shape (nq,)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.remove_duplicates(new_decs, existing_decs=None, tol=1e-06)[source]

Remove duplicate solutions from new decision variables.

Parameters:

new_decs (np.ndarray) – New decision variables to be filtered, shape (N, D)
existing_decs (np.ndarray, optional) – Existing decision variables to check against, shape (M, D) If None, only remove duplicates within new_decs
tol (float, optional) – Tolerance for duplicate detection (default: 1e-6)

Returns:

unique_decs – Unique decision variables, shape (K, D) where K <= N

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.reorganize_initial_data(data: List[ndarray], nt: int, n_initial_per_task: List[int], interval: int = 1) → List[List[ndarray]][source]

Reorganize initial data by task and number of initial points.

Parameters:

data (List[np.ndarray]) – Original data list, where data[i] is the data array for task i
nt (int) – Number of tasks
n_initial_per_task (List[int]) – List of number of initial points for each task
interval (int, optional) – Interval for selecting points. Default is 1. - interval=1: 1, 2, 3, 4, … points - interval=2: 2, 4, 6, 8, … points - interval=k: k, 2k, 3k, 4k, … (plus remaining points if not divisible)

Returns:

all_data – Reorganized data

Return type:

List[List[np.ndarray]]

ddmtolab.Methods.Algo_Methods.algo_utils.resolve_budget(problem, max_nfes, n_tasks: int, default: int | None = None) → List[int] | None[source]

Resolve the per-task evaluation budget $N^k$ an algorithm should run under.

The budget can come from two places: the task itself, when it was declared through MTOP.add_task(..., budget=...), or the algorithm’s max_nfes argument. An explicitly supplied max_nfes always wins, so passing the argument keeps the historical behaviour unchanged; the task-declared budget is used only when the caller left max_nfes unset.

Parameters:

problem (MTOP) – Problem instance, optionally carrying per-task budgets.
max_nfes (int, List[int] or None) – Budget explicitly requested by the caller, if any.
n_tasks (int) – Number of tasks.
default (int, optional) – Fallback used when neither source provides a budget.

Returns:

Per-task budgets, or None when no source provides one and no default is given, in which case the algorithm applies its own default.

Return type:

List[int] or None

ddmtolab.Methods.Algo_Methods.algo_utils.sbx_crossover_unclipped(par_dec1: ndarray, par_dec2: ndarray, mu: float) → tuple[ndarray, ndarray][source]

Simulated binary crossover (MTO-Platform GA_Crossover).

Unlike crossover(), offspring are NOT clipped to [0, 1] here: the MATLAB reference clips only once at the end of Generation, after mutation has acted on the raw crossover output.

Parameters:

par_dec1 (np.ndarray) – First parent decision vector, shape (d,)
par_dec2 (np.ndarray) – Second parent decision vector, shape (d,)
mu (float) – Distribution index for crossover

Returns:

off_dec1 (np.ndarray) – First offspring decision vector, unclipped, shape (d,)
off_dec2 (np.ndarray) – Second offspring decision vector, unclipped, shape (d,)

ddmtolab.Methods.Algo_Methods.algo_utils.select_by_index(index: ndarray, *arrays: ndarray | None) → ndarray | List[ndarray | None][source]

Select rows from arrays by index.

Parameters:

index (np.ndarray) – Indices to select, shape (n_selected,)
*arrays (np.ndarray or None) – Variable number of arrays to select from. Each array has shape (n_samples,) or (n_samples, dim). None values are passed through unchanged.

Returns:

results – Selected array if single input, or list of selected arrays if multiple inputs. None inputs return None in the corresponding position.

Return type:

Union[np.ndarray, List[Optional[np.ndarray]]]

ddmtolab.Methods.Algo_Methods.algo_utils.selection_elit(objs: ndarray, n: int, cons: ndarray | None = None, epsilon: float = 0) → ndarray[source]

Elite selection for single-objective (optionally constrained) optimization.

Parameters:

objs (np.ndarray) – Objective values of the population (smaller is better), shape (N, 1)
n (int) – Number of individuals to select
cons (np.ndarray, optional) – Constraint violation values, each column is a constraint, shape (N, c). Default is None.
epsilon (float, optional) – Threshold for constraint violations to be treated as feasible (default: 0)

Returns:

indices – Selected individual indices (0-based), shape (n,)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.set_seed(seed: int) → int[source]

Fix every random generator the platform draws from, in one call.

All stochastic stages of the platform (initial sampling, data splitting, surrogate training, and the stochastic optimization operators) draw from the global random, NumPy and PyTorch streams, so seeding those three streams makes a whole run reproducible.

Parameters:: seed (int) – Seed applied to the random, NumPy and PyTorch (including CUDA) generators.
Returns:: The seed that was applied, so callers can record it alongside results.
Return type:: int

Notes

PyTorch is seeded only if it is installed; the platform does not require it for algorithms that are purely NumPy-based.

ddmtolab.Methods.Algo_Methods.algo_utils.space_transfer(problem: MTOP, decs: List[ndarray], objs: List[ndarray] | None = None, cons: List[ndarray] | None = None, type: str = 'real', padding: str = 'zero') → List[ndarray] | Tuple[List[ndarray], List[ndarray]] | Tuple[List[ndarray], List[ndarray], List[ndarray]][source]

Transfer decision variables, objectives, and constraints between unified and real spaces.

Parameters:

problem (MTOP) – An instance of the MTOP class containing task configuration
decs (List[np.ndarray]) –
List of decision variable matrices.
- Real space: decs[i] has shape (n_i, d_i)
- Unified space: decs[i] has shape (n_i, d_max)
objs (List[np.ndarray], optional) –
List of objective value matrices (default: None).
- Real space: objs[i] has shape (n_i, m_i)
- Unified space: objs[i] has shape (n_i, m_max)
cons (List[np.ndarray], optional) –
List of constraint value matrices (default: None).
- Real space: cons[i] has shape (n_i, c_i)
- Unified space: cons[i] has shape (n_i, c_max)
type (str, optional) –
Transfer type (default: ‘real’):
- ’uni’: Pad matrices with zeros or random values to the maximum dimension (Unified Space)
- ’real’: Truncate matrices back to their original dimensions (Real Space)
padding (str, optional) –
Padding strategy when type=’uni’ (default: ‘zero’):
- ’zero’: Pad with zeros
- ’random’: Pad with random values uniformly distributed in [0, 1]

Returns:

new_decs (List[np.ndarray]) – Returned if objs and cons are None
(new_decs, new_objs) (tuple[List[np.ndarray], List[np.ndarray]]) – Returned if objs is provided but cons is None
(new_decs, new_objs, new_cons) (tuple[List[np.ndarray], List[np.ndarray], List[np.ndarray]]) – Returned if both objs and cons are provided

Notes

The padding parameter only affects the ‘uni’ transfer type. When type=’real’, padding is ignored as truncation is performed instead.

Fix (2025.12.22): Properly handles cases where some tasks have constraints and others don’t. When ncons[i] = 0, ensures consistent shape (n, c_max) in unified space.

ddmtolab.Methods.Algo_Methods.algo_utils.spea2_fitness(pop_obj, pop_con=None)[source]

Calculate SPEA2 fitness with constrained dominance.

Parameters:

pop_obj (np.ndarray, shape (N, M))
pop_con (np.ndarray, shape (N, C), optional) – Constraint violation values (positive = violation).

Returns:

fitness – SPEA2 fitness values. Lower is better; < 1 means non-dominated.

Return type:

np.ndarray, shape (N,)

ddmtolab.Methods.Algo_Methods.algo_utils.spea2_truncation(pop_obj, N)[source]

Select N solutions by iteratively removing the most crowded. Uses SPEA2-style lexicographic nearest-neighbor comparison.

Parameters:

pop_obj (np.ndarray, shape (n, M)) – Objectives.
N (int) – Number of solutions to keep.

Returns:

selected – Indices of selected solutions.

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.spea2_truncation_fast(pop_obj, N)[source]

Select N solutions by iteratively removing the one with smallest nearest-neighbor distance.

Parameters:

pop_obj (np.ndarray, shape (n, M)) – Objectives.
N (int) – Number of solutions to keep.

Returns:

selected – Indices of selected solutions.

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.tournament_selection(K: int, N: int, *fitness_arrays: ndarray, rng: Generator | None = None) → ndarray[source]

Perform tournament selection on a population.

Parameters:

K (int) – Tournament size. If K <= 1, selection is purely random with replacement.
N (int) – Number of individuals to select
*fitness_arrays (np.ndarray) – One or more arrays of fitness values, compared lexicographically (first array is the primary key). Lower values are considered better.
rng (np.random.Generator, optional) – NumPy random number generator. If None, the legacy global stream (np.random.*) is used, so that np.random.seed reproduces the selection. Do NOT fall back to np.random.default_rng(): an unseeded Generator draws from OS entropy and silently makes every run that relies on this helper irreproducible.

Returns:

selected – Array of selected individual indices, shape (N,), dtype=int

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.algo_utils.trim_excess_evaluations(all_decs: List[List[ndarray]], all_objs: List[List[ndarray]], nt: int, max_nfes_per_task: List[int], nfes_per_task: List[int], all_cons: List[List[ndarray]] | None = None) → Tuple[List[List[ndarray]], List[List[ndarray]], List[int]] | Tuple[List[List[ndarray]], List[List[ndarray]], List[int], List[List[ndarray]]][source]

Trim excess evaluations when nfes_per_task exceeds max_nfes_per_task

Parameters:

all_decs (List[List[np.ndarray]]) – Decision variables history for all tasks
all_objs (List[List[np.ndarray]]) – Objective values history for all tasks
nt (int) – Number of tasks
max_nfes_per_task (List[int]) – Maximum evaluation budget per task
nfes_per_task (List[int]) – Actual evaluations used per task
all_cons (List[List[np.ndarray]], optional) – Constraint values history for all tasks

Returns:

all_decs (List[List[np.ndarray]]) – Trimmed decision variables history
all_objs (List[List[np.ndarray]]) – Trimmed objective values history
nfes_per_task (List[int]) – Updated evaluation counts per task (after trimming)
all_cons (List[List[np.ndarray]], optional) – Trimmed constraint values history (only if input all_cons is provided)

ddmtolab.Methods.Algo_Methods.algo_utils.vstack_groups(*args: List[ndarray] | tuple[ndarray, ...] | None) → ndarray | List[ndarray][source]

Stack population arrays vertically.

Supports both single arrays (list of arrays) and tuples with variable number of arrays.

Parameters:

*args (Union[List[np.ndarray], tuple[np.ndarray, ...], None]) –

Variable number of arguments, each can be:

List of arrays to stack vertically
Tuple of arrays (any number) to stack
None (will be skipped)

Returns:

results – Stacked array if single input, or list of stacked arrays if multiple inputs

Return type:

Union[np.ndarray, List[np.ndarray]]

Bayesian Optimization Utilities

ddmtolab.Methods.Algo_Methods.bo_utils.bo_next_point(dim_i: int, decs_i: ndarray, objs_i: ndarray, data_type: dtype = torch.float32) → ndarray[source]

Get the next sampling point using Bayesian Optimization

Parameters:

dim_i (int) – Dimension of decision variables
decs_i (np.ndarray) – Historical decision variables, shape: (n_samples, dim_i)
objs_i (np.ndarray) – Historical objective function values, shape: (n_samples,) or (n_samples, 1)
data_type (torch.dtype, optional) – Data type, default is torch.float

Returns:

candidate_np – Next sampling point, shape: (1, dim_i)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.bo_utils.bo_next_point_lcb(dim_i: int, decs_i: ndarray, objs_i: ndarray, data_type: dtype = torch.float32, kappa: float = 2.0) → tuple[source]

Get the next sampling point using Bayesian Optimization with LCB acquisition

Parameters:

dim_i (int) – Dimension of decision variables
decs_i (np.ndarray) – Historical decision variables, shape: (n_samples, dim_i)
objs_i (np.ndarray) – Historical objective function values, shape: (n_samples,) or (n_samples, 1)
data_type (torch.dtype, optional) – Data type, default is torch.float
kappa (float, optional) – Exploration weight for LCB, default is 2.0

Returns:

candidate_np (np.ndarray) – Next sampling point, shape: (1, dim_i)
gp (SingleTaskGP) – Fitted Gaussian Process model

ddmtolab.Methods.Algo_Methods.bo_utils.gp_build(decs: ndarray, objs: ndarray, data_type: dtype = torch.float32) → SingleTaskGP[source]

Build and fit a Single-Task Gaussian Process model.

Parameters:

decs (np.ndarray) – Historical decision variables, shape: (n_samples, dim)
objs (np.ndarray) – Historical objective function values, shape: (n_samples,) or (n_samples, 1)
data_type (torch.dtype, optional) – Data type for tensors (default: torch.float)

Returns:

gp – Fitted Gaussian Process model

Return type:

SingleTaskGP

ddmtolab.Methods.Algo_Methods.bo_utils.gp_predict(gp: SingleTaskGP, test_X: ndarray, data_type: dtype = torch.float32) → tuple[ndarray, ndarray][source]

Predict objectives and uncertainties using a trained Gaussian Process model.

Parameters:

gp (SingleTaskGP) – Trained Gaussian Process model
test_X (np.ndarray) – Test decision variables, shape: (n_candidates, dim)
data_type (torch.dtype, optional) – Data type for tensors (default: torch.float)

Returns:

pred_objs (np.ndarray) – Predicted objective values, shape: (n_candidates, 1)
pred_std (np.ndarray) – Predicted standard deviations, shape: (n_candidates, 1)

ddmtolab.Methods.Algo_Methods.bo_utils.mo_gp_build(decs, objs, data_type=torch.float32)[source]

Build Gaussian Process models for each objective in multi-objective optimization.

Parameters:

decs (np.ndarray) – Decision variables, shape (N, D) where N is the number of samples and D is the dimension of decision space.
objs (np.ndarray) – Objective values, shape (N, M) where M is the number of objectives.
data_type (torch.dtype, optional) – Data type for GP models (default: torch.float).

Returns:

models – List of trained GP models, one for each objective.

Return type:

list

ddmtolab.Methods.Algo_Methods.bo_utils.mo_gp_predict(models, x, data_type=torch.float32, mse=False)[source]

Predict objectives using trained GP models for multi-objective optimization.

Parameters:

models (list) – List of trained GP models (one per objective), as returned by mo_gp_build.
x (np.ndarray) – Decision variables to predict, shape (N, D) where N is the number of samples and D is the dimension of decision space.
data_type (torch.dtype, optional) – Data type for GP prediction (default: torch.float).
mse (bool, optional) – If True, also return the Mean Squared Error (variance) of predictions. If False, only return predicted objective values (default: False).

Returns:

pred_objs (np.ndarray) – Predicted objective values, shape (N, M) where M is the number of objectives.
pred_mse (np.ndarray, optional) – Predicted MSE (variance) for each objective, shape (N, M). Only returned if mse=True.

ddmtolab.Methods.Algo_Methods.bo_utils.mtbo_next_point(mtgp: MultiTaskGP, task_id: int, objs: list[ndarray], dims: list[int], nt: int, data_type: dtype = torch.float32, return_acq_value: bool = False)[source]

Get the next sampling point using Multi-Task Bayesian Optimization.

Parameters:

mtgp (MultiTaskGP) – Trained Multi-Task Gaussian Process model
task_id (int) – Task index for which to find the next point
objs (list[np.ndarray]) – List of objective value matrices for each task
dims (list[int]) – List of dimensionalities for each task
nt (int) – Total number of tasks
data_type (torch.dtype, optional) – Data type for tensors (default: torch.float)
return_acq_value (bool, optional) – Whether to also return the acquisition value attained at the returned point (default: False). The value is the log expected improvement, so callers comparing tasks under different evaluation costs should work in log space, i.e. compare log_ei - log(cost) rather than dividing. Default False keeps the historical single return value.

Returns:

candidate_np (np.ndarray) – Next sampling point, shape: (1, dims[task_id])
acq_value (float) – Log expected improvement at candidate_np. Only returned when return_acq_value is True.

ddmtolab.Methods.Algo_Methods.bo_utils.mtgp_build(decs: list[ndarray], objs: list[ndarray], dims: list[int], data_type: dtype = torch.float32) → MultiTaskGP[source]

Build a Multi-Task Gaussian Process model.

Parameters:

decs (list[np.ndarray]) – List of decision variable matrices for each task
objs (list[np.ndarray]) – List of objective value matrices for each task
dims (list[int]) – List of dimensionalities for each task
data_type (torch.dtype) – Data type for tensors

Returns:

mtgp – Fitted Multi-Task GP model

Return type:

MultiTaskGP

ddmtolab.Methods.Algo_Methods.bo_utils.mtgp_predict(mtgp: MultiTaskGP, off_decs: ndarray, task_id: int, dims: list[int], nt: int, obj_min_vals: list[float] | None = None, obj_max_vals: list[float] | None = None, data_type: dtype = torch.float32) → tuple[ndarray, ndarray][source]

Use Multi-Task GP to predict objectives and uncertainties for candidate solutions.

Parameters:

mtgp (MultiTaskGP) – Trained Multi-Task Gaussian Process model
off_decs (np.ndarray) – Candidate decision variables, shape (n_candidates, dim)
task_id (int) – Task index for prediction
dims (list[int]) – List of dimensionalities for each task
nt (int) – Total number of tasks
obj_min_vals (list[float] | None) – Minimum objective values for each task (for denormalization)
obj_max_vals (list[float] | None) – Maximum objective values for each task (for denormalization)
data_type (torch.dtype, optional) – Data type for tensors (default: torch.float)

Returns:

pred_objs (np.ndarray) – Predicted objective values, shape (n_candidates, 1)
pred_std (np.ndarray) – Predicted standard deviations, shape (n_candidates, 1)

ddmtolab.Methods.Algo_Methods.bo_utils.mtgp_task_corr(mtgp: MultiTaskGP) → ndarray[source]

Extract task correlation matrix from multi-task Gaussian process model.

Parameters:: mtgp (MultiTaskGP) – Trained Multi-Task Gaussian Process model
Returns:: task_corr – Task correlation matrix (normalized covariance matrix)
Return type:: np.ndarray

ddmtolab.Methods.Algo_Methods.bo_utils.optimize_logei(gp: SingleTaskGP, objs: ndarray, dim: int, data_type: dtype = torch.float32, num_restarts: int = 5, raw_samples: int = 20) → ndarray[source]

Optimize the Log Expected Improvement acquisition over [0, 1]^dim.

Parameters:

gp (SingleTaskGP) – GP model fitted on negated objectives (maximization convention)
objs (np.ndarray) – Historical objective values used to derive best_f, shape: (n_samples,) or (n_samples, 1)
dim (int) – Dimension of decision variables
data_type (torch.dtype, optional) – Data type for tensors (default: torch.float)
num_restarts (int, optional) – Number of restarts for acquisition optimization (default: 5)
raw_samples (int, optional) – Number of raw samples for acquisition optimization (default: 20)

Returns:

candidate_np – Next sampling point, shape: (1, dim)

Return type:

np.ndarray

ddmtolab.Methods.Algo_Methods.bo_utils.select_local_data(decs_t: ndarray, objs_t: ndarray, nc: int, nr: int) → tuple[ndarray, ndarray][source]

Select local surrogate training data: NC nearest to the best + NR most recent.

Parameters:

decs_t (np.ndarray) – Decision variables of one task, shape: (n, dim)
objs_t (np.ndarray) – Objective values of one task, shape: (n,) or (n, 1)
nc (int) – Number of nearest neighbours (around the current best) to keep
nr (int) – Number of most recent samples to keep

Returns:

selected_idx (np.ndarray) – Sorted unique indices of the selected training samples
nearest_idx (np.ndarray) – Indices of the NC nearest samples (useful for local search bounds)

Uniform Point Generation

ddmtolab.Methods.Algo_Methods.uniform_point.uniform_point(N: int, M: int, method: str = 'NBI') → tuple[ndarray, int][source]

Generate a set of uniformly distributed points.

Parameters:

N (int) – Approximate number of points to generate
M (int) – Number of objectives/dimensions
method (str, optional) –
Sampling method to use (default: ‘NBI’). Options:
- ’NBI’: Normal-boundary intersection method
- ’ILD’: Incremental lattice design
- ’MUD’: Mixture uniform design
- ’grid’: Grid sampling
- ’Latin’: Latin hypercube sampling

Returns:

W (np.ndarray) – Array of uniformly distributed points, shape (N_actual, M)
N_actual (int) – Actual number of points generated