{"id":286,"date":"2025-08-28T13:44:49","date_gmt":"2025-08-28T13:44:49","guid":{"rendered":"https:\/\/www.jecdm.cs.put.poznan.pl\/?page_id=286"},"modified":"2025-09-04T16:35:18","modified_gmt":"2025-09-04T16:35:18","slug":"configuring-the-nsga-ii-algorithm","status":"publish","type":"page","link":"https:\/\/www.jecdm.cs.put.poznan.pl\/?page_id=286","title":{"rendered":"Configuring the NSGA-II algorithm"},"content":{"rendered":"\n

This quick-start tutorial demonstrates how to configure the NSGA-II algorithm and apply it to the DTLZ2 problem with two objectives. Furthermore, it is demonstrated how numerical results can be reported and how the visualization of the final population can be performed. The complete source code for this tutorial can be found in the Projects module: y2025.SoftwareX_JECDM.QuickStart1 (framework’s version at least <\/strong>1.7.0). In what follows, the relevant commented code blocks are presented, and the expected results are visualized for convenience. Note that a list of essential imports can be found at the end of this tutorial.<\/p>\n\n\n\n

The overview of the source code:<\/h2>\n\n\n\n

Let us start with defininf the criteria\/objectives:<\/p>\n\n\n

\/\/ The following line instantiates 2 criteria using a factory-like method.<\/span>\n\nCriteria C = Criteria.constructCriteria(\n        \"C\"<\/span>, \/\/ denotes a prefix for criteria names (\"C0\", \"C1\")<\/span>\n        2<\/span>, \/\/ denotes the number of criteria to instantiate<\/span>\n        false<\/span> \/\/indicates that the criteria are cost-type.<\/span>\n);<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, we can define the problem-specifica data:<\/p>\n\n\n
\/\/ Now, let us instantiate a DTLZ2 packed in a bundle-like class. It comprises various auxiliary data, e.g., the Pareto front bounds, and delivers the evaluation procedure, while also providing default reproduction and initialization phases (SBX and PM operators; random vectors initialization; see the method's code for further information).<\/span>\n\nDTLZBundle dtlz2 = DTLZBundle.getBundle(\n        Problem.DTLZ2, \/\/ the problem id<\/span>\n        C._no, \/\/ the problem dimensionality<\/span>\n        DTLZBundle.getRecommendedNODistanceRelatedParameters(Problem.DTLZ2, C._no) \/\/ the number of<\/span>\n        \/\/ distance-related variables (10 + no. objectives - 1):<\/span>\n\n        \/\/ Alternatively, you can also supply your own operator constructors, as shown in the following example:<\/span>\n        \/\/ (problem, M, D) -> new SBX(1.0d, 20.0d), \/\/ probability = 1.0; distribution index = 20.0<\/span>\n        \/\/ (problem, M, D) -> new PM(1.0d \/ (double) (D + M), 20.0d) \/\/ probability = 1 \/ (the number of decision variables for this problem = 12); distribution index = 20.0)<\/span>\n);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Then, we can proceed to instantiating the NSGA-II algorithm:<\/p>\n\n\n
\/\/ Now, instantiate the NSGA-II method, using the factory-like static method (it is recommended to examine other similar static methods in this class):<\/span>\n\nNSGAII nsgaii = NSGAII.getNSGAII(\n        true<\/span>, \/\/ This flag indicates that NSGA-II will be parameterized to dynamically update its internal data on the known Pareto front bounds during optimization (false = the data is fixed and derived from the bundle; in the case of DTLZ2, the bounds are [0, 1] intervals; they are used primarily to properly normalize objectives when calculating crowding distances<\/span>\n        30<\/span>, \/\/ the population size<\/span>\n        new<\/span> L32_X64_MIX(0<\/span>), \/\/ the random number generator instantiated with a seed of 0 for reproducibility<\/span>\n        dtlz2 \/\/ problem bundle (delivers by default dedicated operators, etc.; these can also be supplied by using other static methods of the NSGAII class)<\/span>\n);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, we can execute the method. Two means of doing that are presented:<\/p>\n\n\n
\/\/ The EA can be executed manually by calling its init and step methods. The former is associated with the 0th generation, during which mainly an initial population is constructed and evaluated. The step method executes a regular generation process that involves parent selection, reproduction, evaluation, and survival of the fittest, among other steps. Note that the method requires providing the current generation number as the input. These generation numbers should start from 1, as 0 is reserved for the init step.<\/span>\n\ntry<\/span>\n{\n    nsgaii.init();\n    for<\/span> (int g = 1<\/span>; g < 300<\/span>; g++) nsgaii.step(new<\/span> EATimestamp(g));\n} catch<\/span> (EAException e)\n{\n    throw<\/span> new<\/span> RuntimeException(e);\n}\n\n\/\/ Alternatively, a dedicated runner object can be used to perform the evolution. It is worth noting that it can handle multiple EAs as well as coupling the simulation with visualization.<\/span>\n\n\/*IRunner runner = new Runner(new Runner.Params(nsgaii));\ntry\n{\n    runner.executeEvolution(200);\n} catch (RunnerException e)\n{\n    throw new RuntimeException(e);\n}*\/<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
The following piece of code accesses the specimens and prints the information on their objective and decision vectors:<\/p>\n\n\n
\/\/ Now, let us print the population:<\/span>\n\nfor<\/span> (Specimen s : nsgaii.getSpecimensContainer().getPopulation())\n{\n    String<\/span> sb = PrintUtils.getVectorOfDoubles(s.getEvaluations(), 3<\/span>) + \/\/ objective vector (precision of three decimal places)<\/span>\n            \" : \"<\/span> + \/\/ separator<\/span>\n            PrintUtils.getVectorOfDoubles(s.getDoubleDecisionVector(), 3<\/span>); \/\/ decision vector (precision of three decimal places)<\/span>\n    System.out.println(sb);\n}<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Expected first lines of the console output:<\/p>\n\n\n\n
1.023 0.000 : 0.000 0.495 0.516 0.491 0.519 0.518 0.480 0.500 0.499 0.564 0.502 0.632
0.000 1.046 : 1.000 0.493 0.468 0.492 0.394 0.477 0.430 0.523 0.483 0.485 0.335 0.487
1.023 0.000 : 0.000 0.495 0.516 0.491 0.519 0.518 0.480 0.500 0.499 0.564 0.502 0.632
0.000 1.046 : 1.000 0.493 0.468 0.492 0.394 0.477 0.430 0.523 0.483 0.485 0.335 0.487
0.690 0.727 : 0.517 0.498 0.470 0.487 0.516 0.478 0.503 0.509 0.525 0.506 0.503 0.499<\/p>\n\n\n\n
Additionally, we can calculate the hypervolume attained by the final population and compare it with the easy-to-calculate optimum:<\/p>\n\n\n
\/\/ We can also perform a simple performance assessment using a standard hypervolume metric.<\/span>\n\nHV.Params pHV = new<\/span> HV.Params( \/\/ the parameterization of various objects in this framework is often conducted via an inner static class called Params, which is then passed via the constructor<\/span>\n        C._no, \/\/ the number of objectives considered<\/span>\n        dtlz2._normalizations, \/\/ functions used to normalize the input objective vectors into [0,1] hypercube<\/span>\n        ArrayUtils.getDoubleArray(C._no, 1.1<\/span>d) \/\/ set the reference point (nadir) in the normalized space to [1.1, 1.1]<\/span>\n);\n\n\/\/ Let us now instantiate the indicator:<\/span>\n\nIPerformanceIndicator indicator = new<\/span> HV(pHV);\ndouble hv = indicator.evaluate(nsgaii); \/\/ calculate the hypervolume based on the current state of the algorithm<\/span>\n\n\/\/ We can easily calculate the optimal hypervolume in this setting (1.1^2 - one fourth of a 1-radius disk):<\/span>\ndouble optimalHV = 1.1<\/span>d * 1.1<\/span>d - Math<\/span>.PI \/ 4.0<\/span>d;\nSystem.out.println(\"HV = \"<\/span> + hv); \/\/ print the attained hypervolume<\/span>\nSystem.out.println(\"Optimal HV = \"<\/span> + optimalHV); \/\/ print the optimal hypervolume<\/span>\nSystem.out.println(\"Difference = \"<\/span> + (optimalHV - hv)); \/\/ print the difference<\/span><\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Expected console output:<\/p>\n\n\n\n
HV = 0.40047534244224003
Optimal HV = 0.4246018366025519
Difference = 0.024126494160311873<\/p>\n\n\n\n
We can finally visualize the last population constructed by NSGA-II. It begins by creating the plot:<\/p>\n\n\n
\/\/ Finally, let us visualize the constructed population using a 2D plot. We will use the Plot2DFactory class for this purpose, which allows for the quick instantiation of simple 2D plots. Note that this class features numerous static factory methods, enabling various customizations.<\/span>\n\nPlot2D plot2D = Plot2DFactory.getPlot(\n        \"f1\"<\/span>, \/\/ label for the x-axis<\/span>\n        \"f2\"<\/span>, \/\/ label for the y-axis<\/span>\n        1.5<\/span>d, \/\/ limit for both axes: [0; limit]<\/span>\n        1.2<\/span>f, \/\/ auxiliary parameter for relative font rescaling (1.0 = default value)<\/span>\n        scheme -> scheme._colors.put(ColorFields.PLOT_BACKGROUND, Color.WHITE) \/\/ plot scheme adjuster can be<\/span>\n        \/\/ supplied via this argument; the plot look is mostly controlled by a Scheme object that can be altered<\/span>\n        \/\/ on the fly in this way; this piece of code sets the plot background color to white (transparent by default)<\/span>\n);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Then, a dedicated Frame object (extends the Java Swing’s Frame class) must be instantiated:<\/p>\n\n\n
\/\/ The plot object is displayed using a dedicated Frame (extension of JSwing's Frame):<\/span>\n\nFrame frame = new<\/span> Frame(\n        plot2D, \/\/ plot to be displayed<\/span>\n        800<\/span>, \/\/ plot width in pixels<\/span>\n        800<\/span> \/\/ plot height in pixels<\/span>\n);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
After instantiating the plot and the frame, we can start preparing the data sets to be visualized:<\/p>\n\n\n
\/\/ We can now supply the plot with data sets to be visualized. Note that it can only be done after bounding the plot with the frame. We will visualize the Pareto front and the final population (objective vectors).<\/span>\n\nArrayList<IDataSet> dataSets = new<\/span> ArrayList<>(2<\/span>); \/\/ initialize an array of data sets<\/span>\n\/\/ Prepare the pareto front:<\/span>\ndataSets.add(\n        \/\/ ReferenceParetoFront class provides simple methods for quickly instantiating straightforward Pareto<\/span>\n        \/\/ fronts to be displayed. Here, we ask for a concave spherical 2D front.<\/span>\n        ReferenceParetoFront.getConcaveSpherical2DPF(\n                1.0<\/span>d, \/\/ the radius of the sphere<\/span>\n                new<\/span> LineStyle(0.5<\/span>f, color.gradient.Color.BLACK) \/\/ line style (width and color)<\/span>\n        )\n);\n\n\/\/ Now, we can construct a data set representing the population. For this reason, we will use the primary way of instantiating data sets: a dedicated factory-like class, DSFactory2D.<\/span>\ndataSets.add(\n        DSFactory2D.getDS(\n                \"Population\"<\/span>, \/\/ the data set name<\/span>\n                new<\/span> EASource(nsgaii).createData(), \/\/ we need to provide objective vectors defined as double[][]<\/span>\n                \/\/ matrix; for this purpose, we will use an auxiliary data processor: EASource<\/span>\n                new<\/span> MarkerStyle( \/\/ finally, we can define the marker style<\/span>\n                        3.0<\/span>f, \/\/ marker size<\/span>\n                        ColorPalettes.getFromDefaultPalette(0<\/span>), \/\/ color obtained from the default color palette (bluish)<\/span>\n                        Marker.CIRCLE \/\/ marker style<\/span>\n                )\n        )\n);\n\n\/\/ The following line delivers the data sets to be displayed to the plot:<\/span>\nplot2D.getModel().setDataSets(dataSets);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
The following piece of code displays the rendered plot:<\/p>\n\n\n
\/\/ Finally, we can display the plot (ensure that the screen scaling in the OS is set to 1.0 for best outcomes; a different factor may result in visual artifacts):<\/span>\nframe.setVisible(true<\/span>);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Lastly, this tutorial showcases how to create the plot’s screenshot that can be then used, e.g., in one’s publication:<\/p>\n\n\n
\/\/ For this quick start tutorial, the screenshot of the plot is generated and stored. It can be accomplished in the following way:<\/span>\nScreenshot screenshot = plot2D.getModel().requestScreenshotCreation(\n        1000<\/span>, \/\/ screenshot width (independent to the current plot width)<\/span>\n        1000<\/span>,  \/\/ screenshot height (independent to the current plot height)<\/span>\n        false<\/span>, \/\/ do not use the alpha channel<\/span>\n        null<\/span> \/\/ optional parameter that indicates that the plot will be clipped to its content by<\/span>\n        \/\/ removing the first\/last columns\/rows that match the given color (e.g., check Color.WHITE)<\/span>\n);\n\n\/\/ Generating the screenshot is asynchronous. We need to wait by calling .await() on the provided synchronization barrier:<\/span>\ntry<\/span>\n{\n    screenshot._barrier.await();\n} catch<\/span> (InterruptedException e)\n{\n    throw<\/span> new<\/span> RuntimeException(e);\n}\n\n\/\/ Finally, we can use the following method to save the screenshot.<\/span>\nImageSaver.saveImage(\n        screenshot._image, \/\/ screenshot to be saved<\/span>\n        \"D:\"<\/span> + File.serparatorChar + \"quickstart1\"<\/span>, \/\/ file path (excludes the extension; alter it according to your computer specification and needs)<\/span>\n        \"jpg\"<\/span>, \/\/ file extension (only regular file types, e.g., bmp or jpg are supported; in the case of providing an unsupported extension, an error message will be printed)<\/span>\n        1.0f<\/span> \/\/ image quality (1.0 = the best; not all extensions support this parameter)<\/span>\n);<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
The expected final render is provided below. Note the poor performance in terms of distribution, which is often attributed to the classic NSGA-II algorithm.<\/p>\n\n\n
\n
\"\"<\/figure><\/div>\n\n\n
Used imports:<\/strong><\/p>\n\n\n
import<\/span> color<\/span>.Color<\/span>;\nimport<\/span> color<\/span>.gradient<\/span>.ColorPalettes<\/span>;\nimport<\/span> criterion<\/span>.Criteria<\/span>;\nimport<\/span> dataset<\/span>.DSFactory2D<\/span>;\nimport<\/span> dataset<\/span>.IDataSet<\/span>;\nimport<\/span> dataset<\/span>.painter<\/span>.style<\/span>.LineStyle<\/span>;\nimport<\/span> dataset<\/span>.painter<\/span>.style<\/span>.MarkerStyle<\/span>;\nimport<\/span> dataset<\/span>.painter<\/span>.style<\/span>.enums<\/span>.Marker<\/span>;\nimport<\/span> ea<\/span>.EATimestamp<\/span>;\nimport<\/span> emo<\/span>.aposteriori<\/span>.nsgaii<\/span>.NSGAII<\/span>;\nimport<\/span> exception<\/span>.EAException<\/span>;\nimport<\/span> exception<\/span>.RunnerException<\/span>;\nimport<\/span> frame<\/span>.Frame<\/span>;\nimport<\/span> indicator<\/span>.IPerformanceIndicator<\/span>;\nimport<\/span> indicator<\/span>.emo<\/span>.HV<\/span>;\nimport<\/span> io<\/span>.image<\/span>.ImageSaver<\/span>;\nimport<\/span> plot<\/span>.Plot2D<\/span>;\nimport<\/span> plot<\/span>.Plot2DFactory<\/span>;\nimport<\/span> population<\/span>.Specimen<\/span>;\nimport<\/span> print<\/span>.PrintUtils<\/span>;\nimport<\/span> problem<\/span>.Problem<\/span>;\nimport<\/span> problem<\/span>.moo<\/span>.dtlz<\/span>.DTLZBundle<\/span>;\nimport<\/span> random<\/span>.L32_X64_MIX<\/span>;\nimport<\/span> reproduction<\/span>.operators<\/span>.crossover<\/span>.SBX<\/span>;\nimport<\/span> reproduction<\/span>.operators<\/span>.mutation<\/span>.PM<\/span>;\nimport<\/span> runner<\/span>.IRunner<\/span>;\nimport<\/span> runner<\/span>.Runner<\/span>;\nimport<\/span> scheme<\/span>.enums<\/span>.ColorFields<\/span>;\nimport<\/span> utils<\/span>.ArrayUtils<\/span>;\nimport<\/span> utils<\/span>.Screenshot<\/span>;\nimport<\/span> visualization<\/span>.updaters<\/span>.sources<\/span>.EASource<\/span>;\nimport<\/span> visualization<\/span>.utils<\/span>.ReferenceParetoFront<\/span>;\n\nimport<\/span> java<\/span>.io<\/span>.File<\/span>;\nimport<\/span> java<\/span>.util<\/span>.ArrayList<\/span>;<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>","protected":false},"excerpt":{"rendered":"
This quick-start tutorial demonstrates how to configure the NSGA-II algorithm and apply it to the DTLZ2 problem with two objectives. Furthermore, it is demonstrated how numerical results can be reported and how the visualization of the final population can be performed. The complete source code for this tutorial can be found in the Projects module:\u2026 Read More »<\/a><\/span><\/p>\n","protected":false},"author":2,"featured_media":0,"parent":276,"menu_order":1,"comment_status":"closed","ping_status":"closed","template":"page-templates\/full-width.php","meta":{"footnotes":""},"class_list":["post-286","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=\/wp\/v2\/pages\/286"}],"collection":[{"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=286"}],"version-history":[{"count":43,"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=\/wp\/v2\/pages\/286\/revisions"}],"predecessor-version":[{"id":408,"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=\/wp\/v2\/pages\/286\/revisions\/408"}],"up":[{"embeddable":true,"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=\/wp\/v2\/pages\/276"}],"wp:attachment":[{"href":"https:\/\/www.jecdm.cs.put.poznan.pl\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=286"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}