This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Date of publication xxxx 00, 0000, date of current version xxxx 00, 0000.

Digital Object Identifier 10.1109/ACCESS.2017.DOI

pymoo: Multi-objective Optimization inPythonJULIAN BLANK and KALYANMOY DEB (FELLOW, IEEE)Michigan State University, East Lansing, MI 48824, USA

Corresponding Author: Julian Blank (blankjul@egr.msu.edu)

ABSTRACT Python has become the programming language of choice for research and industry projectsrelated to data science, machine learning, and deep learning. Since optimization is an inherent part of theseresearch fields, more optimization related frameworks have arisen in the past few years. Only a few of themsupport optimization of multiple conflicting objectives at a time, but do not provide comprehensive toolsfor a complete multi-objective optimization task. To address this issue, we have developed pymoo, a multi-objective optimization framework in Python. We provide a guide to getting started with our frameworkby demonstrating the implementation of an exemplary constrained multi-objective optimization scenario.Moreover, we give a high-level overview of the architecture of pymoo to show its capabilities followed byan explanation of each module and its corresponding sub-modules. The implementations in our frameworkare customizable and algorithms can be modified/extended by supplying custom operators. Moreover, avariety of single, multi- and many-objective test problems are provided and gradients can be retrieved byautomatic differentiation out of the box. Also, pymoo addresses practical needs, such as the parallelizationof function evaluations, methods to visualize low and high-dimensional spaces, and tools for multi-criteriadecision making. For more information about pymoo, readers are encouraged to visit: https://pymoo.org.

INDEX TERMS Customization, Genetic Algorithm, Multi-objective Optimization, Python

I. INTRODUCTION

OPTIMIZATION plays an essential role in many scien-tific areas, such as engineering, data analytics, and deep

learning. These fields are fast-growing and their concepts areemployed for various purposes, for instance gaining insightsfrom a large data sets or fitting accurate prediction models.Whenever an algorithm has to handle a significantly largeamount of data, an efficient implementation in a suitableprogramming language is important. Python [1] has becomethe programming language of choice for the above mentionedresearch areas over the last few years, not only because it iseasy to use but also good community support exists. Pythonis a high-level, cross-platform, and interpreted programminglanguage that focuses on code readability. A large numberof high-quality libraries are available and support for anykind of scientific computation is ensured. These character-istics make Python an appropriate tool for many researchand industry projects where the investigations can be rathercomplex.

A fundamental principle of research is to ensure repro-ducibility of studies and to provide access to materials usedin the research, whenever possible. In computer science, this

translates to a sketch of an algorithm and the implemen-tation itself. However, the implementation of optimizationalgorithms can be challenging and specifically benchmarkingis time-consuming. Having access to either a good collec-tion of different source codes or a comprehensive library istime-saving and avoids an error-prone implementation fromscratch.

To address this need for multi-objective optimization inPython, we introduce pymoo. The goal of our frameworkis not only to provide state of the art optimization algo-rithms, but also to cover different aspects related to theoptimization process itself. We have implemented single,multi and many-objective test problems which can be usedas a test-bed for algorithms. In addition to the objective andconstraint values of test problems, gradient information canbe retrieved through automatic differentiation [2]. Moreover,a parallelized evaluation of solutions can be implementedthrough vectorized computations, multi-threaded execution,and distributed computing. Further, pymoo provides imple-mentations of performance indicators to measure the qualityof results obtained by a multi-objective optimization algo-rithm. Tools for an explorative analysis through visualization

VOLUME 4, 2016 1

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

of lower and higher-dimensional data are available and multi-criteria decision making methods guide the selection of asingle solution from a solution set based on preferences.

Our framework is designed to be extendable through of itsmodular implementation. For instance, a genetic algorithmis assembled in a plug-and-play manner by making use ofspecific sub-modules, such as initial sampling, mating selec-tion, crossover, mutation and survival selection. Each sub-module takes care of an aspect independently and, therefore,variants of algorithms can be initiated by passing differentcombinations of sub-modules. This concept allows end-usersto incorporate domain knowledge through custom imple-mentations. For example, in an evolutionary algorithm abiased initial sampling module created with the knowledgeof domain experts can guide the initial search.

Furthermore, we like to mention that our framework iswell-documented with a large number of available code-snippets. We created a starter’s guide for users to becomefamiliar with our framework and to demonstrate its capabili-ties. As an example, it shows the optimization results of a bi-objective optimization problem with two constraints. An ex-tract from the guide will be presented in this paper. Moreover,we provide an explanation of each algorithm and source codeto run it on a suitable optimization problem in our softwaredocumentation. Additionally, we show a definition of testproblems and provide a plot of their fitness landscapes. Theframework documentation is built using Sphinx [3] and cor-rectness of modules is ensured by automatic unit testing [4].Most algorithms have been developed in collaboration withthe second author and have been benchmarked extensivelyagainst the original implementations.

In the remainder of this paper, we first present relatedexisting optimization frameworks in Python and in otherprogramming languages. Then, we provide a guide to gettingstarted with pymoo in Section III which covers the mostimportant steps of our proposed framework. In Section IV weillustrate the framework architecture and the correspondingmodules, such as problems, algorithms and related analytics.Each of the modules is then discussed separately in Sec-tions V to VII. Finally, concluding remarks are presented inSection VIII.

II. RELATED WORKSIn the last decades, various optimization frameworks indiverse programming languages were developed. However,some of them only partially cover multi-objective optimiza-tion. In general, the choice of a suitable framework for anoptimization task is a multi-objective problem itself. More-over, some criteria are rather subjective, for instance, theusability and extendibility of a framework and, therefore, theassessment regarding criteria as well as the decision makingprocess differ from user to user. For example, one might havedecided on a programming language first, either because ofpersonal preference or a project constraint, and then searchfor a suitable framework. One might give more importance tothe overall features of a framework, for example paralleliza-

tion or visualization, over the programming language itself.An overview of some existing multi-objective optimizationframeworks in Python is listed in Table 1, each of which isdescribed in the following.

Recently, the well-known multi-objective optimizationframework jMetal [5] developed in Java [6] has been portedto a Python version, namely jMetalPy [7]. The authors aimto further extend it and to make use of the full feature setof Python, for instance, data analysis and data visualization.In addition to traditional optimization algorithms, jMetalPyalso offers methods for dynamic optimization. Moreover, thepost analysis of performance metrics of an experiment withseveral independent runs is automated.

Parallel Global Multiobjective Optimizer, PyGMO [8], isan optimization library for the easy distribution of massiveoptimization tasks over multiple CPUs. It uses the gener-alized island-model paradigm for the coarse grained paral-lelization of optimization algorithms and, therefore, allowsusers to develop asynchronous and distributed algorithms.

Platypus [9] is a multi-objective optimization frameworkthat offers implementations of state-of-the art algorithms. Itenables users to create an experiment with various algorithmsand provides post-analysis methods based on metrics andvisualization.

A Distributed Evolutionary Algorithms in Python (DEAP)[10] is novel evolutionary computation framework for rapidprototyping and testing of ideas. Even though, DEAP doesnot focus on multi-objective optimization, however, due tothe modularity and extendibility of the framework multi-objective algorithms can be developed. Moreover, paral-lelization and load-balancing tasks are supported out of thebox.

Inspyred [11] is a framework for creating bio-inspiredcomputational intelligence algorithms in Python which isnot focused on multi-objective algorithms directly, but onevolutionary computation in general. However, an examplefor NSGA-II [12] is provided and other multi-objective algo-rithms can be implemented through the modular implemen-tation of the framework.

If the search for frameworks is not limited to Python, otherpopular frameworks should be considered: PlatEMO [13] inMatlab, MOEA [14] and jMetal [5] in Java, jMetalCpp [15]and PaGMO [16] in C++. Of course this is not an exhaustivelist and readers may search for other available options.

III. GETTING STARTED 1

In the following, we provide a starter’s guide for pymoo. Itcovers the most important steps in an optimization scenariostarting with the installation of the framework, defining anoptimization problem, and the optimization procedure itself.

1ALL SOURCE CODES IN THIS PAPER ARE RELATED TO PYMOOVERSION 0.4.0. A GETTING STARTED GUIDE FOR UPCOMING VER-SIONS CAN BE FOUND AT HTTPS://PYMOO.ORG.

2 VOLUME 4, 2016

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

TABLE 1: Multi-objective Optimization Frameworks inPython

Name License Focus onmulti-

objective

PurePython

Visua-lization

DecisionMaking

jMetalPy MIT 3 3 3 7

PyGMO GPL-3.0 3 7 7 7

Platypus GPL-3.0 3 3 7 7

DEAP LGPL-3.0 7 3 7 7

Inspyred MIT 7 3 7 7

pymoo Apache 2.0 3 3 3 3

A. INSTALLATION

Our framework pymoo is available on PyPI [17] which is acentral repository to make Python software package easilyaccessible. The framework can be installed by using thepackage manager:

$ pip install -U pymoo

Some components are available in Python and addition-ally in Cython [18]. Cython allows developers to annotateexisting Python code which is translated to C or C++ pro-gramming languages. The translated files are compiled to abinary executable and can be used to speed up computations.During the installation of pymoo, attempts are made forcompilation, however, if unsuccessful due to the lack of asuitable compiler or other reasons, the pure Python version isinstalled. We would like to emphasize that the compilation isoptional and all features are available without it. More detailabout the compilation and troubleshooting can be found inour installation guide online.

B. PROBLEM DEFINITION

In general, multi-objective optimization has several objectivefunctions with subject to inequality and equality constraintsto optimize[19]. The goal is to find a set of solutions (variablevectors) that satisfy all constraints and are as good as possibleregarding all its objectives values. The problem definition inits general form is given by:

min fm(x) m = 1, ..,M,

s.t. gj(x) ≤ 0, j = 1, .., J,

hk(x) = 0, k = 1, ..,K,

xLi ≤ xi ≤ xUi , i = 1, .., N.

(1)

The formulation above defines a multi-objective optimiza-tion problem with N variables, M objectives, J inequality,and K equality constraints. Moreover, for each variable xi,lower and upper variable boundaries (xLi and xUi ) are alsodefined.

0.5 0.0 0.5 1.0 1.5x1

0.50

0.25

0.00

0.25

0.50

0.75

1.00

x 2

g1(x) g2(x) f1(x) f2(x)

FIGURE 1: Contour plot of the test problem (Equation 2).

In the following, we illustrate a bi-objective optimizationproblem with two constraints.

min f1(x) = (x21 + x22),

max f2(x) = −(x1 − 1)2 − x22,

s.t. g1(x) = 2 (x1 − 0.1) (x1 − 0.9) ≤ 0,

g2(x) = 20 (x1 − 0.4) (x1 − 0.6) ≥ 0,

− 2 ≤ x1 ≤ 2,

− 2 ≤ x2 ≤ 2.

(2)

It consists of two objectives (M = 2) where f1(x) isminimized and f2(x) maximized. The optimization is withsubject to two inequality constraints (J = 2) where g1(x)is formulated as a less-than-equal-to and g2(x) as a greater-than-equal-to constraint. The problem is defined with respectto two variables (N = 2), x1 and x2, which both are inthe range [−2, 2]. The problem does not contain any equalityconstraints (K = 0). Contour plots of the objective functionsare shown in Figure 1. The contours of the objective functionf1(x) are represented by solid lines and f2(x) by dashedlines. Constraints g1(x) and g2(x) are parabolas which in-tersect the x1-axis at (0.1, 0.9) and (0.4, 0.6). The Pareto-optimal set is marked by a thick orange line. Through thecombination of both constraints the Pareto-set is split intotwo parts. Analytically, the Pareto-optimal set is given byPS = {(x1, x2) | (0.1 ≤ x1 ≤ 0.4) ∨ (0.6 ≤ x1 ≤0.9) ∧ x2 = 0} and the efficient-front by f2 = (

√f1 − 1)2

where f1 is defined in [0.01, 0.16] and [0.36, 0.81].In the following, we provide an example implementation

of the problem formulation above using pymoo. We assumethe reader is familiar with Python and has a fundamentalknowledge of NumPy [20] which is utilized to deal withvector and matrix computations.

In pymoo, we consider pure minimization problems foroptimization in all our modules. However, without loss ofgenerality an objective which is supposed to be maximized,can be multiplied by −1 and be minimized [19]. Therefore,

VOLUME 4, 2016 3

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

we minimize −f2(x) instead of maximizing f2(x) in ouroptimization problem. Furthermore, all constraint functionsneed to be formulated as a less-than-equal-to constraint.For this reason, g2(x) needs to be multiplied by −1 to flipthe ≥ to a ≤ relation. We recommend the normalizationof constraints to give equal importance to each of them.For g1(x), the constant ‘resource’ value of the constraint is2 · (−0.1) · (−0.9) = 0.18 and for g2(x) it is 20 · (−0.4) ·(−0.6) = 4.8, respectively. We achieve normalization ofconstraints by dividing g1(x) and g2(x) by the correspondingconstant [21].

Finally, the optimization problem to be optimized usingpymoo is defined by:

min f1(x) = (x21 + x22),

min f2(x) = (x1 − 1)2 + x22,

s.t. g1(x) = 2 (x1 − 0.1) (x1 − 0.9) / 0.18 ≤ 0,

g2(x) = −20 (x1 − 0.4) (x1 − 0.6) / 4.8 ≤ 0,

− 2 ≤ x1 ≤ 2,

− 2 ≤ x2 ≤ 2.

(3)

Next, the derived problem formulation is implemented inPython. Each optimization problem in pymoo has to inheritfrom the Problem class. First, by calling the super()function the problem properties such as the number ofvariables (n_var), objectives (n_obj) and constraints(n_constr) are initialized. Furthermore, lower (xl) andupper variables boundaries (xu) are supplied as a NumPyarray. Additionally, the evaluation function _evaluateneeds to be overwritten from the superclass. The methodtakes a two-dimensional NumPy array x with n rows andm columns as an input. Each row represents an individualand each column an optimization variable. After doing thenecessary calculations, the objective values are added to thedictionary out with the key F and the constraints with keyG.

import autograd.numpy as anpfrom pymoo.model.problem import Problem

class MyProblem(Problem):

def __init__(self):super().__init__(n_var=2,

n_obj=2,n_constr=2,xl=anp.array([-2,-2]),xu=anp.array([2,2]))

def _evaluate(self, x, out, *args, **kwargs):f1 = x[:,0]**2 + x[:,1]**2f2 = (x[:,0]-1)**2 + x[:,1]**2

g1 = 2*(x[:, 0]-0.1) * (x[:, 0]-0.9) / 0.18g2 = - 20*(x[:, 0]-0.4) * (x[:, 0]-0.6) / 4.8

out["F"] = anp.column_stack([f1, f2])out["G"] = anp.column_stack([g1, g2])

As mentioned above, pymoo utilizes NumPy [20] for mostof its computations. To be able to retrieve gradients throughautomatic differentiation we are using a wrapper around

NumPy called Autograd [22]. Note that this is not obligatoryfor a problem definition.

C. ALGORITHM INITIALIZATIONNext, we need to initialize a method to optimize the prob-lem. In pymoo, an algorithm object needs to be created foroptimization. For each of the algorithms an API documenta-tion is available and through supplying different parameters,algorithms can be customized in a plug-and-play manner. Ingeneral, the choice of a suitable algorithm for optimizationproblems is a challenge itself. Whenever problem character-istics are known beforehand we recommended using thosethrough customized operators. However, in our case the opti-mization problem is rather simple, but the aspect of havingtwo objectives and two constraints should be considered.For this reason, we decided to use NSGA-II [12] with itsdefault configuration with minor modifications. We chosea population size of 40, but instead of generating the samenumber of offsprings, we create only 10 in each generation.This is a steady-state variant of NSGA-II and it is likely toimprove the convergence property for rather simple optimiza-tion problems without much difficulties, such as the existenceof local Pareto-fronts. Moreover, we enable a duplicate checkwhich makes sure that the mating produces offsprings whichare different with respect to themselves and also from theexisting population regarding their variable vectors. To illus-trate the customization aspect, we listed the other unmodifieddefault operators in the code-snippet below. The constructorof NSGA2 is called with the supplied parameters and returnsan initialized algorithm object.

from pymoo.algorithms.nsga2 import NSGA2from pymoo.factory import get_sampling, get_crossover,

get_mutation

algorithm = NSGA2(pop_size=40,n_offsprings=10,sampling=get_sampling("real_random"),crossover=get_crossover("real_sbx", prob=0.9, eta=15),mutation=get_mutation("real_pm", eta=20),eliminate_duplicates=True

)

D. OPTIMIZATIONNext, we use the initialized algorithm object to optimize thedefined problem. Therefore, the minimize function withboth instances problem and algorithm as parametersis called. Moreover, we supply the termination criterion ofrunning the algorithm for 40 generations which will resultin 40 + 40× 10 = 440 function evaluations. In addition, wedefine a random seed to ensure reproducibility and enable theverbose flag to see printouts for each generation.

from pymoo.optimize import minimize

res = minimize(MyProblem(),algorithm,('n_gen', 40),seed=1,verbose=True)

4 VOLUME 4, 2016

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

0.50 0.25 0.00 0.25 0.50 0.75 1.00 1.25 1.50x1

2

1

0

1

2

x 2

(a) Design Space

0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8f1

0.0

0.2

0.4

0.6

0.8

f 2

(b) Objective Space

FIGURE 2: Result of the Getting Started Optimization

The method returns a Result object which contains thenon-dominated set of solutions found by the algorithm.

The optimization results are illustrated in Figure 2 wherethe design space is shown in Figure 2a and in the objectivespace in Figure 2b. The solid line represents the analyticallyderived Pareto set and front in the corresponding spaceand the circles solutions found by the algorithm. It can beobserved that the algorithm was able to converge and a set ofnearly-optimal solutions was obtained. Some additional post-processing steps and more details about other aspects of theoptimization procedure can be found in the remainder of thispaper and in our software documentation.

The starters guide showed the steps starting from theinstallation up to solving an optimization problem. The inves-tigation of a constrained bi-objective problem demonstratedthe basic procedure in an optimization scenario.

IV. ARCHITECTURESoftware architecture is fundamentally important to keepsource code organized. On the one hand, it helps developersand users to get an overview of existing classes, and on theother hand, it allows flexibility and extendibility by addingnew modules. Figure 3 visualizes the architecture of pymoo.The first level of abstraction consists of the optimizationproblems, algorithms and analytics. Each of the modules canbe categorized into more detail and consists of multiple sub-modules.

(i) Problems: Optimization problems in our frameworkare categorized into single, multi, and many-objective

test problems. Gradients are available through automaticdifferentiation and parallelization can be implementedby using a variety of techniques.

(ii) Optimization: Since most of the algorithms are basedon evolutionary computations, operators such as sam-pling, mating selection, crossover and mutation have tobe chosen or implemented. Furthermore, because manyproblems in practice have one or more constraints, amethodology for handling those must be incorporated.Some algorithms are based on decomposition whichsplits the multi-objective problem into many single-objective problems. Moreover, when the algorithm isused to solve the problem, a termination criterion mustbe defined either explicitly or implicitly by the imple-mentation of the algorithm.

(iii) Analytics: During and after an optimization run an-alytics support the understanding of data. First, intu-itively the design space, objective space, or other met-rics can be explored through visualization. Moreover, tomeasure the convergence and/or diversity of a Pareto-optimal set performance indicators can be used. Forreal-parameter problems, recently proposed theoreticalKKT proximity metric [23] computation procedure isincluded in pymoo to compute the proximity of a solu-tion to the true Pareto-optimal front, despite not know-ing its exact location. To support the decision makingprocess either through finding points close to the area ofinterest in the objective space or high trade-off solutions.This can be applied either during an optimization run tomimic interactive optimization or as a post analysis.

In the remainder of the paper, we will discuss each of themodules mentioned in more detail.

V. PROBLEMSIt is common practice for researchers to evaluate the perfor-mance of algorithms on a variety of test problems. Since weknow no single-best algorithm for all arbitrary optimizationproblems exist [24], this helps to identify problem classeswhere the algorithm is suitable. Therefore, a collection oftest problems with different numbers of variables, objectivesor constraints and alternating complexity becomes handyfor algorithm development. Moreover, in a multi-objectivecontext, test problems with different Pareto-front shapes orvarying variable density close to the optimal region are ofinterest.

A. IMPLEMENTATIONSIn our framework, we categorize test problems regarding thenumber of objectives: single-objective (1 objective), multi-objective (2 or 3 objectives) and many-objective (more than3 objectives). Test problems implemented in pymoo are listedin Table 2. For each problem the number of variables, ob-jectives, and constraints are indicated. If the test problemis scalable to any of the parameters, we label the problemwith (s). If the problem is scalable, but a default number wasoriginal proposed we indicate that with surrounding brackets.

VOLUME 4, 2016 5

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

pymoo

OptimizationProblems Analytics

Mating Selection

Crossover Mutation

RepairSurvival

Decomposition

single-objective

multi-objective

many-objective

Visualization Performance Indicator

Decision Making

Sampling

Termination Criterion

Constraint Handling

Parallelization

Architecture

Gradients

FIGURE 3: Architecture of pymoo.

In case the category does not apply, for example because werefer to a test problem family with several functions, we use(·).

The implementations in pymoo let end-users define whatvalues of the corresponding problem should be returned.On an implementation level, the evaluate function of aProblem instance takes a list return_value_of whichcontains the type of values being returned. By default theobjective values "F" and if the problem has constraints theconstraint violation "CV" are included. The constraint func-tion values can be returned independently by adding "G".This gives developers the flexibility to receive the values thatare needed for their methods.

B. GRADIENTSAll our test problems are implemented using Autograd [22].Therefore, automatic differentiation is supported out of thebox. We have shown in Section III how a new optimizationproblem is defined.

If gradients are desired to be calculated the prefix "d"needs to be added to the corresponding value of thereturn_value_of list. For instance to ask for the ob-jective values and its gradients return_value_of =["F", "dF"].

Let us consider the problem we have implemented shownin Equation 3. The derivation of the objective functions Fwith respect to each variable is given by:

∇F =

[2x1 2x2

2(x1 − 1) 2x2

]. (4)

The gradients at the point [0.1, 0.2] are calculated by:

F, dF = problem.evaluate(np.array([0.1, 0.2]),return_values_of=["F", "dF"])

returns the following output

TABLE 2: Multi-objective Optimization Test problems.

Problem Variables Objectives Constraints

Single-Objective

Ackley (s) 1 -Cantilevered Beams 4 1 2

Griewank (s) 1 -Himmelblau 2 1 -

Knapsack (s) 1 1Pressure Vessel 4 1 4

Rastrigin (s) 1 -Rosenbrock (s) 1 -

Schwefel (s) 1 -Sphere (s) 1 -

Zakharov (s) 1 -G1-9 (·) (·) (·)

Multi-Objective

BNH 2 2 2Carside 7 3 10Kursawe 3 2 -

OSY 6 2 6TNK 2 2 2

Truss2D 3 2 1Welded Beam 4 2 4

CTP1-8 (s) 2 (s)ZDT1-3 (30) 2 -ZDT4 (10) 2 -ZDT5 (80) 2 -ZDT6 (10) 2 -

Many-Objective

DTLZ 1-7 (s) (s) -CDTLZ (s) (s) -

DTLZ1−1 (s) (s) -SDTLZ (s) (s) -WFG (s) (s) -

6 VOLUME 4, 2016

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

F <- [0.05, 0.85]dF <- [[ 0.2, 0.4],

[-1.8, 0.4]]

It can easily be verified that the values are matchingwith the analytic gradient derivation. The gradients for theconstraint functions can be calculated accordingly by adding"dG" to the return_value_of list.

C. PARALLELIZATIONIf evaluation functions are computationally expensive, a seri-alized evaluation of a set of solutions can become the bottle-neck of the overall optimization procedure. For this reason,parallelization is desired for an use of existing computationalresources more efficiently and distribute long-running cal-culations. In pymoo, the evaluation function receives a setof solutions if the algorithm is utilizing a population. Thisempowers the user to implement any kind of parallelizationas long as the objective values for all solutions are writtenas an output when the evaluation function terminates. In ourframework, a couple of possibilities to implement paralleliza-tion exist:

(i) Vectorized Evaluation: A common technique to par-allelize evaluations is to use matrices where each rowrepresents a solution. Therefore, a vectorized evaluationrefers to a column which includes the variables of allsolutions. By using vectors the objective values of allsolutions are calculated at once. The code-snippet of theexample problem in Section III shows such an imple-mentation using NumPy [20]. To run calculations on aGPU, implementing support for PyTorch [25] tensorscan be done with little overhead given suitable hardwareand correctly installed drivers.

(ii) Threaded Loop-wise Evaluation: If the function eval-uation should occur independently, a for loop can beused to set the values. By default the evaluation is serial-ized and no calculations occur in parallel. By providinga keyword to the evaluation function, pymoo spawns athread for each evaluation and manages those by usingthe default thread pool implementation in Python. Thisbehaviour can be implemented out of the box and thenumber of parallel threads can be modified.

(iii) Distributed Evaluation: If the evaluation should not belimited to a single machine, the evaluation itself canbe distributed to several workers or a whole cluster.We recommend using Dask [26] which enables dis-tributed computations on different levels. For instance,the matrix operation itself can be distributed or a wholefunction can be outsourced. Similar to the loop wiseevaluation each individual can be evaluate element-wiseby sending it to a worker.

VI. OPTIMIZATION MODULEThe optimization module provides different kinds of sub-modules to be used in algorithms. Some of them are more of ageneric nature, such as decomposition and termination crite-

TABLE 3: Multi-objective Optimization Algorithms.

Algorithm Reference

GABRKGA [30]DE [31]Nelder-Mead [32]CMA-ES [33]

NSGA-II [12]RNSGA-II [34]NSGA-III [35, 36, 37]UNSGA-III [38]RNSGA-III [39]MOEAD [40]

rion, and others are more related to evolutionary computing.By assembling those modules together algorithms are built.

A. ALGORITHMSAvailable algorithm implementations in pymoo are listed inTable 3. Compared to other optimization frameworks the listof algorithms may look rather short, however, each algorithmis customizable and variants can be initialized with differentparameters. For instance, a Steady-State NSGA-II [27] canbe initialized by setting the number of offspring to 1. Thiscan be achieved by supplying this as a parameter in theinitialization method as shown in Section III. Moreover, itis worth mentioning that many-objective algorithms, suchas NSGA-III or MOEAD, require reference directions to beprovided. The reference directions are commonly desired tobe uniform or to have a bias towards a region of interest. Ourframework offers an implementation of the Das and Dennismethod [28] for a fixed number of points (fixed with respectto a parameter often referred to as partition number) and arecently proposed Riesz-Energy based method which createsa well-spaced point set for an arbitrary number of points andis capable of introducing a bias towards preferred regions inthe objective space [29].

B. OPERATORSThe following evolutionary operators are available:

(i) Sampling: The initial population is mostly based onsampling. In some cases it is created through domainknowledge and/or some solutions are already evaluated,they can directly be used as an initial population. Other-wise, it can be sampled randomly for real, integer, orbinary variables. Additionally, Latin-Hypercube Sam-pling [41] can be used for real variables.

(ii) Crossover: A variety of crossover operators for dif-ferent type of variables are implemented. In Figure 4some of them are presented. Figures 4a to 4d help tovisualize the information exchange in a crossover withtwo parents being involved. Each row represents anoffspring and each column a variable. The correspond-ing boxes indicate whether the values of the offspringare inherited from the first or from the second parent.

VOLUME 4, 2016 7

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

For one and two-point crossovers it can be observedthat either one or two cuts in the variable sequenceexist. Contrarily, the Uniform Crossover (UX) does nothave any clear pattern, because each variable is chosenrandomly either from the first or from the second parent.For the Half Uniform Crossover (HUX) half of thevariables, which are different, are exchanged. For thepurpose of illustration, we have created two parents thathave different values in 10 different positions. For realvariables, Simulated Binary Crossover [42] is knownto be an efficient crossover. It mimics the crossover ofbinary encoded variables. In Figure 4e the probabilitydistribution when the parents x1 = 0.2 and x2 = 0.8where xi ∈ [0, 1] with η = 0.8 are recombined is shown.Analogously, in case of integer variables we subtract 0.5from the lower and add (0.5 − ε) to the upper boundbefore applying the crossover and round to the nearestinteger afterwards (see Figure 4f).

(iii) Mutation: For real and integer variables PolynomialMutation [19, 43] and for binary variables Bitflip mu-tation [44] is provided.

Different problems require different type of operators. Inpractice, if a problem is supposed to be solved repeatedlyand routinely, it makes sense to customize the evolutionaryoperators to improve the convergence of the algorithm. More-over, for custom variable types, for instance trees or mixedvariables [45], custom operators [46] can be implementedeasily and called by algorithm class. Our software documen-tation contains examples for custom modules, operators andvariable types.

C. TERMINATION CRITERIONFor every algorithm it must be determined when it shouldterminate a run. This can be simply based on a predefinednumber of function evaluations, iterations, or a more ad-vanced criterion, such as the change of a performance metricover time. For example, we have implemented a terminationcriterion based on the variable and objective space differ-ence between generations. To make the termination crite-rion more robust the last k generations are considered. Thelargest movement from a solution to its closest neighbour istracked across generation and whenever it is below a certainthreshold, the algorithm is considered to have converged.Analogously, the movement in the objective space can also beused. In the objective space, however, normalization is morechallenging and has to be addressed carefully. The defaulttermination criterion for multi-objective problems in pymookeeps track of the boundary points in the objective space anduses them, when they have settled down, for normalization.More details about the proposed termination criterion can befound in [47].

D. DECOMPOSITIONDecomposition transforms multi-objective problems intomany single-objective optimization problems [48]. Such a

0 100Variables

0

50

Indi

vidu

als

(a) One Point

0 100Variables

0

50

Indi

vidu

als

(b) Two Point

0 100Variables

0

50

Indi

vidu

als

(c) UX

0 100Variables

0

50

Indi

vidu

als

(d) HUX

0.2 0.8x

p(x)

(e) SBX (real, eta=0.8)

10 10x

p(x)

(f) SBX (int, eta=3)

FIGURE 4: Illustration of some crossover operators for dif-ferent variables types.

technique can be either embedded in a multi-objective al-gorithm and solved simultaneously or independently using asingle-objective optimizer. Some decomposition methods arebased on the lp-metrics with different p values. For instance,a naive but frequently used decomposition approach is theWeighted-Sum Method (p = 1), which is known to be notable to converge to the non-convex part of a Pareto-front [19].Moreover, instead of summing values, Tchebysheff Method(p = ∞) considers only the maximum value of the differ-ence between the ideal point and a solution. Similarly, theAchievement Scalarization Function (ASF) [49] and a modi-fied version Augmented Achievement Scalarization Function(AASF) [50] use the maximum of all differences. Further-more, Penalty Boundary Intersection (PBI) [40] is calculatedby a weighted sum of the norm of the projection of a pointonto the reference direction and the perpendicular distance.Also it is worth to note that normalization is essential forany kind of decomposition. All decomposition techniquesmentioned above are implemented in pymoo.

VII. ANALYTICSA. PERFORMANCE INDICATORSFor single-objective optimization algorithms the compari-son regarding performance is rather simple because eachoptimization run results in a single best solution. In multi-objective optimization, however, each run returns a non-dominated set of solutions. To compare sets of solutions,

8 VOLUME 4, 2016

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

various performance indicators have been proposed in thepast [51]. In pymoo most commonly used performance in-dicators are described:

(i) GD/IGD: Given the Pareto-front PF the deviation be-tween the non-dominated set S found by the algorithmand the optimum can be measured. Following this prin-ciple, Generational Distance (GD) indicator [52] cal-culates the average Euclidean distance in the objectivespace from each solution in S to the closest solution inPF. This measures the convergence of S, but does notindicate whether a good diversity on the Pareto-front hasbeen reached. Similarly, Inverted Generational Distance(IGD) indicator [52] measures the average Euclideandistance in the objective space from each solution in PFto the closest solution in S. The Pareto-front as a wholeneeds to be covered by solutions from S to minimizethe performance metric. Thus, lower the GD and IGDvalues, the better is the set. However, IGD is known tobe not Pareto compliant [53].

(ii) GD+/IGD+: A variation of GD and IGD has beenproposed in [53]. The Euclidean distance is replaced bya distance measure that takes the dominance relationinto account. The authors show that IGD+ is weaklyPareto compliant.

(iii) Hypervolume: Moreover, the dominated portion of theobjective space can be used to measure the quality ofnon-dominated solutions [54]. The higher the hypervol-ume, the better is the set. Instead of the Pareto-front areference point needs to be provided. It has been shownthat Hypervolume is Pareto compliant [55]. Becausethe performance metric becomes computationally ex-pensive in higher dimensional spaces the exact measurebecomes intractable. However, we plan to include someproposed approximation methods in the near future.

Performance indicators are used to compare existing algo-rithms. Moreover, the development of new algorithms can bedriven by the goodness of different metrics itself.

B. VISUALIZATIONThe visualization of intermediate steps or the final result isinevitable. In multi and many-objective optimization, visual-ization of the objective space is of interest so that trade-offinformation among solutions can be easily experienced fromthe plots. Depending on the dimension of the objective space,different types of plots are suitable to represent a singleor a set of solutions. In pymoo the implemented visualiza-tions wrap around the well-known plotting library in PythonMatplotlib [56]. Keyword arguments provided by Matplotlibitself are still available which allows to modify for instancethe color, thickness, opacity of lines, points or other shapes.Therefore, all visualization techniques are customizable andextendable.

For 2 or 3 objectives, scatter plots (see Figure 5a and5b) can give a good intuition about the solution set. Trade-offs can be observed by considering the distance between

two points. It might be desired to normalize each objectiveto make sure a comparison between values is based onrelative and not absolute values. Pairwise Scatter Plots (seeFigure 5c) visualize more than 3 objectives by showing eachpair of axes independently. The diagonal is used to label thecorresponding objectives.

Also, high-dimensional data can be illustrated by ParallelCoordinate Plots (PCP) as shown in Figure 5d. All axes areplotted vertically and represent an objective. Each solution isillustrated by a line from the left to the right. The intersectionof a line and an axis indicate the value of the solutionregarding the corresponding objective. For the purpose ofcomparison solution(s) can be highlighted by varying colorand opacity.

Moreover, a common practice is to project the higherdimensional objective values onto the 2D plane using atransformation function. Radviz (Figure 5e) visualizes allpoints in a circle and the objective axes are uniformly posi-tioned around on the perimeter. Considering a minimizationproblem and a set of non-dominated solutions, an extremepoint very close to an axis represents the worst solutionfor that corresponding objective, but is comparably "good"in one or many other objectives. Similarly, Star CoordinatePlots (Figure 5f) illustrate the objective space, except that thetransformation function allows solutions outside of the circle.

Heatmaps (Figure 5g) are used to represent the goodnessof solutions through colors. Each row represents a solutionand each column a variable. We leave the choice to the end-user of what color map to use and whether light or darkcolors illustrate better or worse solutions. Also, solutions canbe sorted lexicographically by their corresponding objectivevalues.

Instead of visualizing a set of solutions, one solution canbe illustrated at a time. The Petal Diagram (Figure 5h) is apie diagram where the objective value is represented by eachpiece’s diameter. Colors are used to further distinguish thepieces. Finally, the Spider-Web or Radar Diagram (Figure 5i)shows the objectives values as a point on an axis. The idealand nadir point [19] is represented by the inner and outerpolygon. By definition, the solution lies in between those twoextremes. If the objective space ranges are scaled differently,normalization for the purpose of plotting can be enabled andthe diagram becomes symmetric. New and emerging methodsfor visualizing more than three-dimensional efficient solu-tions, such as 2.5-dimensional PaletteViz plots [57], wouldbe implemented in the future.

C. DECISION MAKINGIn practice, after obtaining a set of non-dominated solutions asingle solution has to be chosen for implementation. pymooprovides a few “a posteriori” approaches for decision making[19].

(i) Compromise Programming: One way of making a de-cision is to compute value of a scalarized and aggregatedfunction and select one solution based on minimum ormaximum value of the function. In pymoo a number of

VOLUME 4, 2016 9

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

0.00 0.25 0.50 0.75f1

0.5

0.0

0.5

1.0

f 2

(a) Scatter 2D

f1

0.00.1

0.20.3

0.40.5

f2

0.00.1

0.20.3

0.40.5

f3

0.00.10.20.30.40.5

(b) Scatter 3D

f1f10.0 0.5

f1

0.0

0.5

f 2

0.0 0.5f1

0.0

0.5

f 3

0.0 0.5f1

0.0

0.5

f 4

0.0 0.5f2

0.0

0.5

f 1 f2f20.0 0.5

f2

0.0

0.5

f 3

0.0 0.5f2

0.0

0.5

f 4

0.0 0.5f3

0.0

0.5

f 1

0.0 0.5f3

0.0

0.5

f 2 f3f30.0 0.5

f3

0.0

0.5

f 4

0.0 0.5f4

0.0

0.5

f 1

0.0 0.5f4

0.0

0.5

f 2

0.0 0.5f4

0.0

0.5

f 3 f4f4

(c) Scatter ND [58]

f1 f2 f3 f4 f5 f6 f7 f8 f9 f10(d) PCP [59]

f1

f2

f3f4

f5

f6

f7

f8 f9

f10

(e) Radviz [60]

f1

f2

f3f4f5

f6

f7f8 f9

f10

(f) Star Coordinate Graph [61]

f1 f2 f3 f4 f5 f6(g) Heatmap [62]

f1

f2

f3

f4

f5

f6

(h) Petal Diagram [63]

f1

f2f3

f4

f5(i) Spider-Web/Radar [64]

FIGURE 5: Different visualization methods coded in pymoo.

scalarization functions described in Section VI-D can beused to come to a decision regarding desired weights ofobjectives.

(ii) Pseudo-Weights: However, a more intuitive way tochose a solution out of a Pareto-front is the pseudo-weight vector approach proposed in [19]. The pseudoweight wi for the i-th objective function is calculatedby:

wi =(fmax

i − fi(x)) / (fmaxi − fmin

i )∑Mm=1(f

maxm − fm(x)) / (fmax

m − fminm )

. (5)

The normalized distance to the worst solution regardingeach objective i is calculated. It is interesting to note thatfor non-convex Pareto-fronts, the pseudo weight doesnot correspond to the result of an optimization usingthe weighted-sum method. A solution having the closest

pseudo-weight to a target preference vector of objectives(f1 being preferred twice as important as f2 results in atarget preference vector of (0.667, 0.333)) can be chosenas the preferred solution from the efficient set.

(iii) High Trade-Off Solutions: Furthermore, high trade-offsolutions are usually of interest, but not straightforwardto detect in higher-dimensional objective spaces. Wehave implemented the procedure proposed in [65]. Itwas described to be embedded in an algorithm to guidethe search; we, however, use it for post-processing.The metric for each solution pair xi and xj in a non-dominated set is given by:

T (xi, xj) =

∑Mi=1 max[0, fm(xj)− fm(xi)]∑Mi=1 max[0, fm(xi)− fm(xj)]

, (6)

where the numerator represents the aggregated sacrifice

10 VOLUME 4, 2016

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

and the denominator the aggregated gain. The trade-offmeasure µ(xi, S) for each solution xi with respect to aset of neighboring solutions S is obtained by:

µ(xi, S) = minxj∈S

T (xi, xj) (7)

It finds the minimum T (xi, xj) from xi to all othersolutions xj ∈ S. Instead of calculating the metricwith respect to all others, we provide the option toonly consider the k closest neighbors in the objectivespace to reduce the computational complexity. Basedon circumstances, the ‘min’ operator can be replacedwith ‘average’, or ‘max’, or any other suitable operator.Thereafter, the solution having the maximum µ can bechosen as the preferred solution, meaning that this solu-tion causes a maximum sacrifice in one of the objectivevalues for a unit gain in another objective value for it bethe most valuable solution for implementation.

The above methods are algorithmic, but requires an userinteraction to choose a single preferred solution. However,in real practice, a more problem specific decision-makingmethod must be used, such as an interaction EMO methodsuggested elsewhere [66]. We emphasize here the factthat multi-objective frameworks should include methods formulti-criteria decision making and support end-user furtherin choosing a solution out of a trade-off solution set.

VIII. CONCLUDING REMARKSThis paper has introduced pymoo, a multi-objective opti-mization framework in Python. We have walked through ourframework beginning with the installation up to the opti-mization of a constrained bi-objective optimization problem.Moreover, we have presented the overall architecture of theframework consisting of three core modules: Problems, Op-timization, and Analytics. Each module has been describedin depth and illustrative examples have been provided. Wehave shown that our framework covers various aspects ofmulti-objective optimization including the visualization ofhigh-dimensional spaces and multi-criteria decision makingto finally select a solution out of the obtained solution set.One distinguishing feature of our framework with otherexisting ones is that we have provided a few options forvarious key aspects of a multi-objective optimization task,providing standard evolutionary operators for optimization,standard performance metrics for evaluating a run, standardvisualization techniques for showcasing obtained trade-offsolutions, and a few approaches for decision-making. Mostsuch implementations were originally suggested and devel-oped by the second author and his collaborators for more than25 years. Hence, we consider that the implementations of allsuch ideas are authentic and error-free. Thus, the results fromthe proposed framework should stay as benchmark results ofimplemented procedures.

However, the framework can be definitely extended tomake it more comprehensive and we are constantly addingnew capabilities based on practicalities learned from our

collaboration with industries. In the future, we plan to im-plement more optimization algorithms and test problems toprovide more choices to end-users. Also, we aim to imple-ment some methods from the classical literature on single-objective optimization which can also be used for multi-objective optimization through decomposition or embeddedas a local search. So far, we have provided a few basic perfor-mance metrics. We plan to extend this by creating a modulethat runs a list of algorithms on test problems automaticallyand provides a statistics of different performance indicators.

Furthermore, we like to mention that any kind of con-tribution is more than welcome. We see our framework asa collaborative collection from and to the multi-objectiveoptimization community. By adding a method or algorithmto pymoo the community can benefit from a growing compre-hensive framework and it can help researchers to advertisetheir methods. Interested researchers are welcome to con-tact the authors. In general, different kinds of contributionsare possible and more information can be found online.Moreover, we would like to mention that even though wetry to keep our framework as bug-free as possible, in caseof exceptions during the execution or doubt of correctness,please contact us directly or use our issue tracker.

REFERENCES[1] G. Rossum, “Python reference manual,” Amsterdam,

The Netherlands, The Netherlands, Tech. Rep., 1995.[2] M. Bücker, G. Corliss, P. Hovland, U. Naumann,

and B. Norris, Automatic Differentiation: Applications,Theory, and Implementations (Lecture Notes in Com-putational Science and Engineering). Berlin, Heidel-berg: Springer-Verlag, 2006.

[3] R. Lehmann, “Sphinx documentation,” 2019.[4] A. Pajankar, Python Unit Test Automation: Practical

Techniques for Python Developers and Testers, 1st ed.Berkely, CA, USA: Apress, 2017.

[5] J. J. Durillo and A. J. Nebro, “jMetal: a javaframework for multi-objective optimization,” Advancesin Engineering Software, vol. 42, pp. 760–771,2011. [Online]. Available: http://www.sciencedirect.com/science/article/pii/S0965997811001219

[6] J. Gosling, B. Joy, G. L. Steele, G. Bracha, and A. Buck-ley, The Java Language Specification, Java SE 8 Edi-tion, 1st ed. Addison-Wesley Professional, 2014.

[7] A. Benítez-Hidalgo, A. J. Nebro, J. García-Nieto, I. Oregi, and J. D. Ser, “jmetalpy: Apython framework for multi-objective optimizationwith metaheuristics,” Swarm and EvolutionaryComputation, vol. 51, p. 100598, 2019. [Online]. Avail-able: http://www.sciencedirect.com/science/article/pii/S2210650219301397

[8] D. Izzo, “PyGMO and PyKEP: open sourcetools for massively parallel optimization inastrodynamics (the case of interplanetary trajectoryoptimization),” in 5th International Conference onAstrodynamics Tools and Techniques (ICATT 2012),

VOLUME 4, 2016 11

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

2012. [Online]. Available: http://www.esa.int/gsp/ACT/doc/MAD/pub/ACT-RPR-MAD-2012-(ICATT)PyKEP-PaGMO-SOCIS.pdf

[9] D. Hadka, “Platypus: multiobjective optimizationin python,” https://platypus.readthedocs.io, accessed:2019-05-16.

[10] F.-A. Fortin, F.-M. De Rainville, M.-A. Gardner,M. Parizeau, and C. Gagné, “DEAP: Evolutionary al-gorithms made easy,” Journal of Machine LearningResearch, vol. 13, pp. 2171–2175, jul 2012.

[11] A. Garrett, “inspyred: python library forbio-inspired computational intelligence,”https://github.com/aarongarrett/inspyred, accessed:2019-05-16.

[12] K. Deb, A. Pratap, S. Agarwal, and T. Meyarivan,“A fast and elitist multiobjective genetic algorithm:NSGA-II,” Trans. Evol. Comp, vol. 6, no. 2, pp.182–197, Apr. 2002. [Online]. Available: http://dx.doi.org/10.1109/4235.996017

[13] Y. Tian, R. Cheng, X. Zhang, and Y. Jin, “PlatEMO:A MATLAB platform for evolutionary multi-objectiveoptimization,” IEEE Computational Intelligence Maga-zine, vol. 12, no. 4, pp. 73–87, 2017.

[14] D. Hadka, “MOEA Framework: a free and open sourceJava framework for multiobjective optimization,” http://moeaframework.org, accessed: 2019-05-16.

[15] E. López-Camacho, M. J. García-Godoy, A. J.Nebro, and J. F. A. Montes, “jmetalcpp: optimizingmolecular docking problems with a C++ metaheuristicframework,” Bioinformatics, vol. 30, no. 3, pp. 437–438, 2014. [Online]. Available: https://doi.org/10.1093/bioinformatics/btt679

[16] F. Biscani, D. Izzo, and C. H. Yam, “A globaloptimisation toolbox for massively parallel engineeringoptimisation,” CoRR, vol. abs/1004.3824, 2010.[Online]. Available: http://arxiv.org/abs/1004.3824

[17] P. S. Foundation, “PyPI: the python package index,”https://pypi.org, accessed: 2019-05-20.

[18] S. Behnel, R. Bradshaw, C. Citro, L. Dalcin, D. Selje-botn, and K. Smith, “Cython: The best of both worlds,”Computing in Science Engineering, vol. 13, no. 2, pp.31 –39, April 2011.

[19] K. Deb, Multi-Objective Optimization Using Evolu-tionary Algorithms. New York: Wiley, 2001.

[20] T. Oliphant, “NumPy: A guide to NumPy,” USA:Trelgol Publishing, 2006–, [Online; accessed May 16,2019]. [Online]. Available: http://www.numpy.org/

[21] K. Deb and R. Datta, “A bi-objective constrained op-timization algorithm using a hybrid evolutionary andpenalty function approach,” Engineering Optimization,vol. 45, no. 5, pp. 503–527, 2012.

[22] D. Maclaurin, D. Duvenaud, and R. P. Adams,“Autograd: Effortless gradients in numpy,”in ICML 2015 AutoML Workshop, 2015.[Online]. Available: /bib/maclaurin/maclaurinautograd/automl-short.pdf,https://indico.lal.in2p3.fr/event/2914/

session/1/contribution/6/3/material/paper/0.pdf,https://github.com/HIPS/autograd

[23] K. Deb and M. Abouhawwash, “An optimality the-ory based proximity measure for set based multi-objective optimization,” IEEE Transactions on Evolu-tionary Computation, vol. 20, no. 4, pp. 515–528, 2016.

[24] D. H. Wolpert and W. G. Macready, “No free lunchtheorems for optimization,” Trans. Evol. Comp, vol. 1,no. 1, pp. 67–82, Apr. 1997. [Online]. Available:https://doi.org/10.1109/4235.585893

[25] A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang,Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, andA. Lerer, “Automatic differentiation in pytorch,” 2017.

[26] Dask Development Team, Dask: Library for dynamictask scheduling, 2016. [Online]. Available: https://dask.org

[27] S. Mishra, S. Mondal, and S. Saha, “Fast implementa-tion of steady-state nsga-ii,” in 2016 IEEE Congress onEvolutionary Computation (CEC), July 2016, pp. 3777–3784.

[28] I. Das and J. Dennis, “Normal-boundary intersection:A new method for generating the Pareto surface innonlinear multicriteria optimization problems,” SIAMJ. of Optimization, vol. 8, no. 3, pp. 631–657, 1998.

[29] J. Blank, K. Deb, Y. Dhebar, S. Bandaru, and H. Seada,“Generating well-spaced points on a unit simplexfor evolutionary many-objective optimization,” IEEETransactions on Evolutionary Computation, in press.

[30] J. C. Bean, “Genetic algorithms and random keysfor sequencing and optimization,” ORSA Journal onComputing, vol. 6, no. 2, pp. 154–160, 1994. [Online].Available: https://doi.org/10.1287/ijoc.6.2.154

[31] K. Price, R. M. Storn, and J. A. Lampinen, DifferentialEvolution: A Practical Approach to Global Optimiza-tion (Natural Computing Series). Berlin, Heidelberg:Springer-Verlag, 2005.

[32] J. A. Nelder and R. Mead, “A Simplex Method forFunction Minimization,” The Computer Journal, vol. 7,no. 4, pp. 308–313, 01 1965. [Online]. Available:https://doi.org/10.1093/comjnl/7.4.308

[33] N. Hansen, The CMA Evolution Strategy: AComparing Review. Berlin, Heidelberg: SpringerBerlin Heidelberg, 2006, pp. 75–102. [Online].Available: https://doi.org/10.1007/3-540-32494-1_4

[34] K. Deb and J. Sundar, “Reference point based multi-objective optimization using evolutionary algorithms,”in Proceedings of the 8th Annual Conference onGenetic and Evolutionary Computation, ser. GECCO’06. New York, NY, USA: ACM, 2006, pp. 635–642. [Online]. Available: http://doi.acm.org/10.1145/1143997.1144112

[35] K. Deb and H. Jain, “An evolutionary many-objectiveoptimization algorithm using reference-point-basednondominated sorting approach, part I: Solving prob-lems with box constraints,” IEEE Transactions on Evo-lutionary Computation, vol. 18, no. 4, pp. 577–601,

12 VOLUME 4, 2016

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

2014.[36] H. Jain and K. Deb, “An evolutionary many-objective

optimization algorithm using reference-point basednondominated sorting approach, part II: Handling con-straints and extending to an adaptive approach,” IEEETransactions on Evolutionary Computation, vol. 18,no. 4, pp. 602–622, Aug 2014.

[37] J. Blank, K. Deb, and P. C. Roy, “Investigating thenormalization procedure of NSGA-III,” in Evolution-ary Multi-Criterion Optimization, K. Deb, E. Good-man, C. A. Coello Coello, K. Klamroth, K. Miettinen,S. Mostaghim, and P. Reed, Eds. Cham: SpringerInternational Publishing, 2019, pp. 229–240.

[38] H. Seada and K. Deb, “A unified evolutionary op-timization procedure for single, multiple, and manyobjectives,” IEEE Transactions on Evolutionary Com-putation, vol. 20, no. 3, pp. 358–369, June 2016.

[39] Y. Vesikar, K. Deb, and J. Blank, “Reference pointbased NSGA-III for preferred solutions,” in 2018IEEE Symposium Series on Computational Intelligence(SSCI), Nov 2018, pp. 1587–1594.

[40] Q. Zhang and H. Li, “A multi-objective evolutionaryalgorithm based on decomposition,” IEEE Transactionson Evolutionary Computation, Accepted, vol. 2007,2007.

[41] M. D. McKay, R. J. Beckman, and W. J. Conover,“A comparison of three methods for selecting valuesof input variables in the analysis of output froma computer code,” Technometrics, vol. 42, no. 1,pp. 55–61, Feb. 2000. [Online]. Available: http://dx.doi.org/10.2307/1271432

[42] K. Deb, K. Sindhya, and T. Okabe, “Self-adaptive simulated binary crossover for real-parameter optimization,” in Proceedings of the 9thAnnual Conference on Genetic and EvolutionaryComputation, ser. GECCO ’07. New York, NY,USA: ACM, 2007, pp. 1187–1194. [Online]. Available:http://doi.acm.org/10.1145/1276958.1277190

[43] K. Deb and D. Deb, “Analysing mutation schemes forreal-parameter genetic algorithms,” International Jour-nal of Artificial Intelligence and Soft Computing, vol. 4,no. 1, pp. 1–28, 2014.

[44] D. E. Goldberg, Genetic Algorithms for Search, Op-timization, and Machine Learning. Reading, MA:Addison-Wesley, 1989.

[45] K. Deb and M. Goyal, “A robust optimization procedurefor mechanical component design based on geneticadaptive search,” Transactions of the ASME: Journal ofMechanical Design, vol. 120, no. 2, pp. 162–164, 1998.

[46] K. Deb and C. Myburgh, “A population-based fastalgorithm for a billion-dimensional resource allocationproblem with integer variables,” European Journal ofOperational Research, vol. 261, no. 2, pp. 460–474,2017.

[47] J. Blank and K. Deb, “A running performance metricand termination criterion for evaluating evolutionary

multi- and many-objective optimization algorithms,” in2020 IEEE Symposium Series on Computational Intel-ligence (SSCI), in press.

[48] A. Santiago, H. J. F. Huacuja, B. Dorronsoro,J. E. Pecero, C. G. Santillan, J. J. G.Barbosa, and J. C. S. Monterrubio, A Surveyof Decomposition Methods for Multi-objectiveOptimization. Cham: Springer International Pub-lishing, 2014, pp. 453–465. [Online]. Available:https://doi.org/10.1007/978-3-319-05170-3_31

[49] A. P. Wierzbicki, “The use of reference objectives inmultiobjective optimization,” in Multiple criteria deci-sion making theory and application. Springer, 1980,pp. 468–486.

[50] ——, “A mathematical basis for satisficing decisionmaking,” Mathematical Modelling, vol. 3, no. 5,pp. 391 – 405, 1982, special IIASA Issue.[Online]. Available: http://www.sciencedirect.com/science/article/pii/0270025582900380

[51] J. Knowles and D. Corne, “On metrics for compar-ing non-dominated sets,” in Proceedings of the 2002Congress on Evolutionary Computation Conference(CEC02). United States: Institute of Electrical andElectronics Engineers, 2002, pp. 711–716.

[52] D. A. V. Veldhuizen and D. A. V. Veldhuizen, “Multi-objective evolutionary algorithms: Classifications, anal-yses, and new innovations,” Evolutionary Computation,Tech. Rep., 1999.

[53] H. Ishibuchi, H. Masuda, Y. Tanigaki, and Y. Nojima,“Modified distance calculation in generational dis-tance and inverted generational distance,” in Evolution-ary Multi-Criterion Optimization, A. Gaspar-Cunha,C. Henggeler Antunes, and C. C. Coello, Eds. Cham:Springer International Publishing, 2015, pp. 110–125.

[54] E. Zitzler and L. Thiele, “Multiobjective optimizationusing evolutionary algorithms - a comparative casestudy,” in Proceedings of the 5th InternationalConference on Parallel Problem Solving fromNature, ser. PPSN V. London, UK, UK: Springer-Verlag, 1998, pp. 292–304. [Online]. Available:http://dl.acm.org/citation.cfm?id=645824.668610

[55] E. Zitzler, D. Brockhoff, and L. Thiele, “Thehypervolume indicator revisited: On the design ofpareto-compliant indicators via weighted integration,”in Proceedings of the 4th International Conferenceon Evolutionary Multi-criterion Optimization, ser.EMO’07. Berlin, Heidelberg: Springer-Verlag, 2007,pp. 862–876. [Online]. Available: http://dl.acm.org/citation.cfm?id=1762545.1762618

[56] J. D. Hunter, “Matplotlib: A 2d graphics environment,”Computing in Science & Engineering, vol. 9, no. 3, pp.90–95, 2007.

[57] A. K. A. Talukder and K. Deb, “PaletteViz: A vi-sualization method for functional understanding ofhigh-dimensional pareto-optimal data-sets to aid multi-criteria decision making,” IEEE Computational Intelli-

VOLUME 4, 2016 13

This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/.

This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI10.1109/ACCESS.2020.2990567, IEEE Access

Blank J. et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

gence Magazine, vol. 15, no. 2, pp. 36–48, 2020.[58] J. M. Chambers and B. Kleiner, “10 graphical tech-

niques for multivariate data and for clustering,” 1982.[59] E. Wegman, “Hyperdimensional data analysis using

parallel coordinates,” Journal of the American Statis-tical Association, vol. 85, pp. 664–675, 09 1990.

[60] P. Hoffman, G. Grinstein, and D. Pinkney, “Dimen-sional anchors: a graphic primitive for multidimen-sional multivariate information visualizations,” in Proc.Workshop on new Paradigms in Information Visualiza-tion and Manipulation in conjunction with the ACMInternational Conference on Information and Knowl-edge Management (NPIVM99). New York, NY, USA:ACM, 1999, pp. 9–16.

[61] E. Kandogan, “Star coordinates: A multi-dimensionalvisualization technique with uniform treatment of di-mensions,” in In Proceedings of the IEEE InformationVisualization Symposium, Late Breaking Hot Topics,2000, pp. 9–12.

[62] A. Pryke, S. Mostaghim, and A. Nazemi, “Heatmapvisualization of population based multi objective al-gorithms,” in Evolutionary Multi-Criterion Optimiza-tion, S. Obayashi, K. Deb, C. Poloni, T. Hiroyasu, andT. Murata, Eds. Berlin, Heidelberg: Springer BerlinHeidelberg, 2007, pp. 361–375.

[63] Y. S. Tan and N. M. Fraser, “The modified star graphand the petal diagram: two new visual aids for discretealternative multicriteria decision making,” Journal ofMulti-Criteria Decision Analysis, vol. 7, no. 1, pp. 20–33, 1998.

[64] E. Kasanen, R. Östermark, and M. Zeleny, “Gestaltsystem of holistic graphics: New management supportview of MCDM,” Computers & OR, vol. 18, no. 2, pp.233–239, 1991. [Online]. Available: https://doi.org/10.1016/0305-0548(91)90093-7

[65] L. Rachmawati and D. Srinivasan, “Multiobjective evo-lutionary algorithm with controllable focus on the kneesof the pareto front,” Evolutionary Computation, IEEETransactions on, vol. 13, pp. 810 – 824, 09 2009.

[66] K. Deb, A. Sinha, P. Korhonen, and J. Wallenius,“An interactive evolutionary multi-objective optimiza-tion method based on progressively approximated valuefunctions,” IEEE Transactions on Evolutionary Compu-tation, vol. 14, no. 5, pp. 723–739, 2010.

JULIAN BLANK received his B.Sc. in Busi-ness Information Systems from Otto von GuerickeUniversity, Germany in 2010. He was a visitingscholar for six months at the Michigan State Uni-versity, Michigan, USA in 2015, and, finishedhis M.Sc. in Computer Science at Otto von Gu-ericke University, Germany in 2016. He is cur-rently a Ph.D. student in Computer Science at theMichigan State University, Michigan, USA. Hiscurrent research interests include multi-objective

optimization, evolutionary computation, surrogate-assisted optimization andmachine learning.

KALYANMOY DEB is the Koenig Endowed ChairProfessor with the Department of Electrical andComputer Engineering, Michigan State Univer-sity, East Lansing, Michigan, USA. He receivedhis Bachelor’s degree in Mechanical Engineeringfrom IIT Kharagpur in India, and his Master’s andPh.D. degrees from the University of Alabama,Tuscaloosa, USA, in 1989 and 1991. He is largelyknown for his seminal research in evolutionarymulti-criterion optimization. He has authored two

text books on optimization and published over 535 international journal andconference research papers to date. His current research interests includeevolutionary optimization and its application in design, AI, and machinelearning. He is one of the top cited EC researchers with more than 140,000Google Scholar citations. Dr. Deb is a recipient of the IEEE CIS EC PioneerAward in 2018, the Lifetime Achievement Award from Clarivate Analyticsin 2017, the Infosys Prize in 2012, the TWAS Prize in Engineering Sciencesin 2012, the CajAstur Mamdani Prize in 2011, the Distinguished AlumniAward from IIT Kharagpur in 2011, the Edgeworth-Pareto Award in 2008,the Shanti Swarup Bhatnagar Prize in Engineering Sciences in 2005, and theThomson Citation Laureate Award from Thompson Reuters. He is a fellowof IEEE and ASME. More information about his work can be found fromhttp://www.coin-lab.org.

14 VOLUME 4, 2016