{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# pysamoo: Surrogate-Assisted Multi-objective Optimization" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "\n", "|python| |license|\n", "\n", "\n", ".. |python| image:: https://img.shields.io/badge/python-3.9-blue.svg\n", " :alt: python 3.6\n", "\n", ".. |license| image:: https://img.shields.io/badge/license-apache-orange.svg\n", " :alt: license apache\n", " :target: https://www.apache.org/licenses/LICENSE-2.0\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In practice, most optimization problems in practice consist of one or multiple **computationally expensive** objective or constraint functions to which special attention must be paid during algorithm design. Most commonly, so-called surrogates (also known as metamodels or simply approximation models) are utilized during optimization to learn from previous evaluations and exploit this knowledge in future iterations. **pysamoo** is an extension of [pymoo](https://pymoo.org) - a comprehensive toolbox for multi-objective optimization - focusing on solving optimization problems with computationally expensive objective or constraint functions.\n", "\n", "Please find the Github repository here: https://github.com/anyoptimization/pysamoo" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![title](_img/surrogate.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Please find an overview of this software documentation below:" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ ".. admonition:: Overview\n", " :class: myOwnStyle\n", "\n", " - `License <#License>`_: GNU Affero General Public License (AGPL).\n", " - `Installation <#Installation>`_: How to install the current release of pysamoo.\n", " - `Algorithms <#Algorithms>`_: An overview of algorithms and their underlying concepts.\n", " - `Usage <#Usage>`_: Instructions and code snippets to execute algorithms.\n", " - `Contact <#Contact>`_: Information to contact the framework's leading developer." ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ ".. csv-table:: Algorithms available in pysamoo\n", " :widths: 60, 10, 30, 30, 200\n", " :file: algorithms.csv" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# License" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**GNU Affero General Public License (AGPL)**: The GNU Affero General Public License is a modified version of the ordinary GNU GPL version 3. It has one added requirement: if you run a modified program on a server and let other users communicate with it there, your server must also allow them to download the source code corresponding to the modified version running there." ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ ".. warning::\n", "\n", " Please note that pysamoo has a more permissive software license which only allows non-commercial usage. If you intend to use pysamoo for commercial purposes please contact us." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Citation" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ ".. note::\n", "\n", " If you use this framework, we kindly ask you to cite the following paper:" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "`Julian Blank, & Kalyanmoy Deb. (2022). pysamoo: Surrogate-Assisted Multi-Objective Optimization in Python. `_\n", "\n", "::\n", "\n", " @misc{pysamoo,\n", " title={pysamoo: Surrogate-Assisted Multi-Objective Optimization in Python}, \n", " author={Julian Blank and Kalyanmoy Deb},\n", " year={2022},\n", " eprint={2204.05855},\n", " archivePrefix={arXiv},\n", " primaryClass={cs.NE}\n", " }" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Installation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The framework is available at the PyPi Repository and can be easily installed by:" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "\n", ".. code:: bash\n", "\n", " pip install -U pysamoo\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Algorithms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this part of the software documentation, some more words about the algorithms being implemented in the framework shall be said. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Commonly, surrogates -- approximation or interpolation models -- are utilized during optimization to improve the convergence behavior. \n", "First, one shall distinguish between two different types of evaluations: ESEs that require to run the computationally expensive evaluation; and ASEs which is a computationally inexpensive approximation by the surrogate. \n", "Where the overall optimization run is limited by $\\texttt{ESE}^{\\max}$ function evaluation, function calls of ASEs are only considered as algorithmic overhead. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simple Surrogate Assisted (SSA)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In order to improve the convergence of NSGA-II, the surrogates provide ASEs and let the algorithm look several iterations into the future without any evaluation of ESEs. \n", "The surrogate models are used to create a set of infill solutions as follows: First, NSGA-II is run for $k$ more iterations (starting from the best solutions found so far), returning the solution set $X^{\\texttt{(cand)}}$.\n", "The number of solutions in $X^{\\texttt{(cand)}}$ corresponds to the population size of the algorithm.\n", "After eliminating duplicates in $X^{\\texttt{(cand)}}$, the number of solutions $N$ desired to run using ESEs needs to be selected. The selection first creates $N$ clusters (in the objective space based on $X^{\\texttt{(cand)}}$) using the k-means algorithm and then uses a roulette wheel selection based on the predicted crowding distances. Note that this will introduce a bias towards boundary points as they have been depicted with a crowding distance of infinity.\n", "Altogether, this results in $N$ solutions to be then evaluated using ESEs in this optimization cycle.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \"SSA-NSGA-II\"\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## PSAF" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In contrast to most existing surrogate-assisted algorithms, PSAF uses not only the final solution(s) obtained by optimizing the surrogate but the whole *search pattern*. By making use of the search pattern, the exploration-exploitation balance is found by taking the surrogate's accuracy into account. To allow even more flexible exploitation of the surrogate, we propose two phases. First, derive a solution set that is influenced by the surrogate, and second, introduce surrogate bias by optimizing the surrogate for a number of iterations. Both procedures are important to incorporate surrogates into existing methods effectively." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One of the major challenges when proposing a generalized optimization framework is the number and strictness of assumptions being made. \n", "On the one hand, too many assumptions restrict the applicability; on the other hand, too few assumptions limit the usage of existing elements in algorithms.\n", "In this study, we target any type of population-based algorithm with two phases in an iteration: the process of generating new solutions to be evaluated (infill) and a method processing evaluated infill solutions (advance). \n", "So, how can existing optimization methods be described into *infill* and *advance* phases?\n", "Genetic algorithms (GAs) generate new solutions using evolutionary recombination-mutation operators and then process them using an environmental survival selection operator; PSO methods create new solutions based on a particles' current velocity, personal best, and global best, and process the solutions using a replacement strategy; CMAES samples new solutions from a normal distribution, which is then updated in each iteration. Shown by well-known state-of-the-art algorithms following or being suitable to be implemented in this optimization method design pattern, this seems to be a reasonable assumption to be made for a generic framework. Moreover, it is worth noting that some researchers and practitioners also refer to the pattern as *ask-and-tell* interface." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \"SSA-NSGA-II\"\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### $\\alpha$-Phase" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A well-known concept in evolutionary computation to introduce a bias toward more promising solutions is *tournament selection*. An individual from the population has to win a tournament to contribute to the mating process.\n", "The number of competitors ($\\alpha$) balances how greedy the selection procedure will be. On the one hand, a larger value of $\\alpha$ allows only elitist solutions to participate in mating, while a smaller value introduces less selection pressure.\n", "For genetic algorithms, the most frequently used tournament mode is the binary tournament ($\\alpha=2$), which compares a pair of solutions regarding one or multiple metrics. A standard binary tournament implementation for constrained single-objective optimization declares the less infeasible solution as the winner if one or both solutions are infeasible or otherwise the solution with the smaller function value.\n", "\n", "In the context of surrogate assistance, the tournament selection introduces surrogate bias during the generation of new infill solutions.\n", "Whereas in genetic algorithms, evaluated solutions (using ESE) compete with each other during mating selection, in PSAF solutions evaluated on the surrogate (ASE) are compared." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \"SSA-NSGA-II\"\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### $\\beta$-Phase" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While the tournament is an effective concept to incorporate the surrogate's approximation, it is limited by looking only a *single* iteration into the future. To further increase the surrogate's impact, the baseline algorithm is continued to run for $\\beta$ more consecutive iterations on the surrogate's approximations.\n", "Inevitably, the question of how many iterations are suitable arises and indicates the importance of tuning $\\beta$.\n", "Nevertheless, even more critical, how should the algorithm profit from simulating the algorithm on the surrogate?\n", "An inappropriate choice of $\\beta$ will cause the surrogate's optimum to be repeatedly found and will entirely discard the baseline algorithm's default infill procedure. \n", "This also causes a diversity loss of infill solutions and does not account for the surrogate's approximation error. Thus, we propose a probabilistic surrogate-assisted approach that balances the surrogate's impact on the baseline algorithm to address these issues.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An example with five iterations ($\\beta = 5$) and four infill solutions $X_1$, $X_2$, $X_3$, and $X_4$ is also illustrated in the figure below. Calling the infill function of the baseline algorithm results in five solution sets with four solutions each. When running the algorithm, the assignment takes place, and for instance, $X_1$ has four solutions being the closest to, and $X_4$ has six. The assignment of the closest solution will show cluster-like arrangements and preserve diversity." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \"SSA-NSGA-II\"\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For more information please we would like to the corresponding publication:" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "**Publication**:\n", "\n", "`Julian Blank and Kalyanmoy Deb. 2021. PSAF: a probabilistic surrogate-assisted framework for single-objective optimization. In Proceedings of the Genetic and Evolutionary Computation Conference (GECCO '21). Association for Computing Machinery, New York, NY, USA, 652–659. `_\n", "\n" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "**BibTex:**\n", "::\n", "\n", " @inproceedings{10.1145/3449639.3459297,\n", " author = {Blank, Julian and Deb, Kalyanmoy},\n", " title = {PSAF: A Probabilistic Surrogate-Assisted Framework for Single-Objective Optimization},\n", " year = {2021},\n", " isbn = {9781450383509},\n", " publisher = {Association for Computing Machinery},\n", " address = {New York, NY, USA},\n", " url = {https://doi.org/10.1145/3449639.3459297},\n", " doi = {10.1145/3449639.3459297},\n", " booktitle = {Proceedings of the Genetic and Evolutionary Computation Conference},\n", " pages = {652–659},\n", " numpages = {8},\n", " keywords = {simulation optimization, metamodel-based optimization, surrogate-assisted optimization, genetic algorithms, evolutionary computing},\n", " location = {Lille, France},\n", " series = {GECCO '21}\n", " }\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## GPSAF" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, PSAF shall be extended to be suitable to handle multiple objectives and constraints.\n", "GPSAF follows the two-phase concept as PSAF. However, the $\\alpha$-phase and the $\\beta$-phase now have to consider multiple criteria when comparing solutions.\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Extension of PSAF to constrained and multi-objective optimization\n", "- What needs to be modified?\n", " - Multiple Surrogates: One for each constraint, one for each objective\n", " - Solution Comparisons: Instead of comparing only the objective, the constraint satisfaction and Pareto Dominance now need to be considered.\n", " - Exploration vs. Exploitation: The bottle variable rho needs to be redefined." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For single-objective optimization, the $\\alpha$-phase has already been described. There, the comparison of the two solutions is based only on one single objective value. \n", "For the more generic version with constrainAnalogously to PSAF, GPSAF further increases the surrogate's impact by looking $\\beta$ iterations into the future through calling infill *and* advance of the baseline algorithm repetitively.\n", "To obtain the $\\beta$-solution for constrained multi-objective problems, we use a so-called Probabilistic Knockout Tournament (PKT) to select solutions from each cluster with the goal of self-adaptively exploiting surrogates. The goal is to use surrogates more when they provide accurate predictions but use them more carefully when they provide only rough estimations. \n", "Necessary for generalization, PKT also applies to problems with multiple objectives and constraints, often with varying complexities and surrogate errors to be considered.ts and objectives, the winner of each solution pool is determined as follows: if *all* solutions are infeasible, select the least infeasible solution; otherwise, select a non-dominated solution (break ties randomly). For both the constraint and objective values, only ASEs are used. \n", "Otherwise, the $\\alpha$-phase remains the same, including its responsibilities and mechanics." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Analogously to PSAF, GPSAF further increases the surrogate's impact by looking $\\beta$ iterations into the future through calling infill *and* advance of the baseline algorithm repetitively.\n", "To obtain the $\\beta$-solution for constrained multi-objective problems, we use a so-called PKT to select solutions from each cluster with the goal of self-adaptively exploiting surrogates. The goal is to use surrogates more when they provide accurate predictions but use them more carefully when they provide only rough estimations. \n", "Necessary for generalization, PKT also applies to problems with multiple objectives and constraints, often with varying complexities and surrogate errors to be considered." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \"SSA-NSGA-II\"\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For more information please we would like to the corresponding publication:" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "**Publication**:\n", "\n", "`Julian Blank and Kalyanmoy Deb. 2022. GPSAF: A Generalized Probabilistic Surrogate-Assisted Framework for Constrained Single- and Multi-objective Optimization. COINLab Report 202204. `_\n", "\n" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "**BibTex:**\n", "::\n", "\n", " @misc{gpsaf,\n", " doi = {10.48550/ARXIV.2204.04054},\n", " url = {https://arxiv.org/abs/2204.04054},\n", " author = {Blank, Julian and Deb, Kalyanmoy},\n", " keywords = {Optimization and Control (math.OC), Machine Learning (cs.LG), Mathematical Software (cs.MS), FOS: Mathematics, FOS: Mathematics, FOS: Computer and information sciences, FOS: Computer and information sciences, G.1.6; G.1.2; I.6.3, 68U07},\n", " title = {GPSAF: A Generalized Probabilistic Surrogate-Assisted Framework for Constrained Single- and Multi-objective Optimization},\n", " publisher = {arXiv},\n", " year = {2022},\n", " copyright = {arXiv.org perpetual, non-exclusive license}\n", " }\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Usage" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In general, *pysamoo* uses the main functionalities of pymoo for defining the optimization problem. However, it provides a new set of algorithms designed for computationally expensive functions. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## SSA-NSGA-II" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For bi-objective optimization problems, a variant of NSGA-II called Simple Surrogate Assisted NSGA-II (SSA-NSGA-II) could be a good starting point. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==========================================================================\n", "n_gen | n_eval | n_nds | igd | gd | hv \n", "==========================================================================\n", " 1 | 50 | 8 | 1.5264428232 | 2.2537834613 | 0.000000E+00\n", " 2 | 60 | 12 | 0.0447088272 | 0.5062280434 | 0.6033429744\n", " 3 | 70 | 20 | 0.0317166787 | 0.1679151161 | 0.6185749342\n", " 4 | 80 | 24 | 0.0254483220 | 0.0084090160 | 0.6309981786\n", " 5 | 90 | 29 | 0.0230370295 | 0.0144214557 | 0.6344052194\n", " 6 | 100 | 35 | 0.0212245222 | 0.0132708565 | 0.6370941415\n", " 7 | 110 | 42 | 0.0195966238 | 0.0130647742 | 0.6396760863\n", " 8 | 120 | 48 | 0.0177374193 | 0.0108200540 | 0.6420831108\n", " 9 | 130 | 50 | 0.0175224609 | 0.0174397893 | 0.6422432439\n", " 10 | 140 | 53 | 0.0158996130 | 0.0094427526 | 0.6444796025\n", " 11 | 150 | 59 | 0.0153706224 | 0.0176365671 | 0.6454315717\n", " 12 | 160 | 63 | 0.0138676188 | 0.0168468611 | 0.6472923167\n", " 13 | 170 | 69 | 0.0136776440 | 0.0160061467 | 0.6478761757\n", " 14 | 180 | 74 | 0.0125680488 | 0.0153520648 | 0.6495825568\n", " 15 | 190 | 79 | 0.0121553028 | 0.0148969083 | 0.6500744968\n", " 16 | 200 | 83 | 0.0114381989 | 0.0104171897 | 0.6513000952\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from pymoo.optimize import minimize\n", "from pymoo.problems.multi.zdt import ZDT1\n", "from pymoo.visualization.scatter import Scatter\n", "from pysamoo.algorithms.ssansga2 import SSANSGA2\n", "\n", "problem = ZDT1(n_var=10)\n", "\n", "algorithm = SSANSGA2(n_initial_doe=50,\n", " n_infills=10,\n", " surr_pop_size=100,\n", " surr_n_gen=50)\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 200),\n", " seed=1,\n", " verbose=True)\n", "\n", "plot = Scatter()\n", "plot.add(problem.pareto_front(), plot_type=\"line\", color=\"black\", alpha=0.7)\n", "plot.add(res.F, facecolor=\"none\", edgecolor=\"red\")\n", "plot.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## PSAF-GA" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "================================================================================================================================================================\n", "n_gen | n_eval | f_min | f_gap | r2 | bias | mae | model \n", "================================================================================================================================================================\n", " 1 | 30 | 2.036794E+01 | 2.036794E+01 | - | - | 0.2738756231 | RBF[kernel=linear,tail=constant,normalized=True]\n", " 2 | 40 | 1.614481E+01 | 1.614481E+01 | 0.3763933967 | 0.7000000000 | 0.5348634440 | RBF[kernel=cubic,tail=linear+quadratic,normalized=False]\n", " 3 | 50 | 1.614481E+01 | 1.614481E+01 | 0.3976668792 | 0.7000000000 | 0.6351592863 | RBF[kernel=linear,tail=constant,normalized=True]\n", " 4 | 60 | 1.479848E+01 | 1.479848E+01 | 0.2795887538 | 0.7000000000 | 0.8588945004 | RBF[kernel=mq,tail=linear+quadratic,normalized=False]\n", " 5 | 70 | 1.310293E+01 | 1.310293E+01 | -2.495997E-01 | 0.7000000000 | 1.0450900866 | RBF[kernel=linear,tail=linear+quadratic,normalized=False]\n", " 6 | 80 | 1.268252E+01 | 1.268252E+01 | 0.1339056137 | 0.7000000000 | 1.4391106360 | RBF[kernel=linear,tail=constant,normalized=True]\n", " 7 | 90 | 1.198853E+01 | 1.198853E+01 | 0.1004963738 | 0.7000000000 | 1.1109921715 | krg-cont\n", " 8 | 100 | 1.070961E+01 | 1.070961E+01 | -1.356016E-01 | 0.7000000000 | 1.1038348109 | krg-cont\n", " 9 | 110 | 9.0245380210 | 9.0245380210 | -3.871513E-02 | 0.7000000000 | 1.1543317740 | krg-cont\n", " 10 | 120 | 8.8940807360 | 8.8940807360 | -3.268868E-02 | 0.7000000000 | 0.8929508896 | krg-cont\n", " 11 | 130 | 8.4131436015 | 8.4131436015 | 0.1006854678 | 0.7000000000 | 0.9085243047 | krg-cont\n", " 12 | 140 | 7.8246574061 | 7.8246574061 | -8.313746E-01 | 0.7000000000 | 0.5755873561 | krg-lin\n", " 13 | 150 | 7.0834789444 | 7.0834789444 | 0.4176491944 | 0.7000000000 | 0.6266697638 | krg-cont\n", " 14 | 160 | 6.0646712483 | 6.0646712483 | 0.2139484322 | 0.7000000000 | 0.4735844314 | krg-lin\n", " 15 | 170 | 5.9366538601 | 5.9366538601 | 0.4389178038 | 0.7000000000 | 0.5479664682 | krg-lin\n", " 16 | 180 | 5.6660865834 | 5.6660865834 | 0.0852439643 | 0.7000000000 | 0.5417697700 | krg-cont\n", " 17 | 190 | 5.0408470264 | 5.0408470264 | -1.175129E-01 | 0.7000000000 | 0.5883136752 | krg-cont\n", " 18 | 200 | 4.6010645765 | 4.6010645765 | -6.175937E-01 | 0.7000000000 | 0.5818244380 | krg-cont\n", " 19 | 210 | 4.5254801853 | 4.5254801853 | -1.176425E+00 | 0.7000000000 | 0.6073626579 | krg-cont\n", " 20 | 220 | 3.9720804105 | 3.9720804105 | -2.661123E+00 | 0.7000000000 | 0.5095595451 | krg-cont\n", " 21 | 230 | 3.9720804105 | 3.9720804105 | -2.542042E+00 | 0.7000000000 | 0.5437289305 | krg-cont\n", " 22 | 240 | 3.6608112233 | 3.6608112233 | -2.833233E+00 | 0.7000000000 | 0.4527138832 | krg-cont\n", " 23 | 250 | 3.4490801784 | 3.4490801784 | -2.355759E+00 | 0.7000000000 | 0.4256093867 | krg-lin\n", " 24 | 260 | 3.0871007367 | 3.0871007367 | -4.493002E+00 | 0.7000000000 | 0.5288772233 | krg-lin\n", " 25 | 270 | 3.0871007367 | 3.0871007367 | -5.774866E+00 | 0.7000000000 | 0.6508483015 | krg-lin\n", " 26 | 280 | 3.0020921309 | 3.0020921309 | -9.136042E+00 | 0.7000000000 | 0.5603836037 | krg-lin\n", " 27 | 290 | 2.9161694816 | 2.9161694816 | -8.368297E+00 | 0.7000000000 | 0.6311346722 | krg-lin\n", " 28 | 300 | 2.8268436055 | 2.8268436055 | -1.130324E+01 | 0.7000000000 | 0.6046665921 | krg-lin\n", "Best solution found: \n", "X = [ 0.97346909 0.03114564 -1.06840523 0.04009389 -0.0521602 0.27861872\n", " 1.03606787 -0.07359098 -0.98842002 -0.03037685]\n", "F = [2.82684361]\n", "CV=[0.]\n" ] } ], "source": [ "from pymoo.algorithms.soo.nonconvex.ga import GA\n", "from pymoo.optimize import minimize\n", "from pymoo.problems.single import Ackley\n", "from pysamoo.algorithms.psaf import PSAF\n", "\n", "problem = Ackley(n_var=10)\n", "\n", "algorithm = GA(pop_size=20, n_offsprings=10)\n", "\n", "algorithm = PSAF(algorithm, n_initial_doe=30, alpha=10, beta=30, max_rho=0.7, n_max_infills=10, n_max_doe=500)\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 300),\n", " seed=2,\n", " verbose=True)\n", "\n", "print(\"Best solution found: \\nX = %s\\nF = %s\\nCV=%s\" % (res.X, res.F, res.CV))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## PSAF-DE" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "================================================================================================================================================================\n", "n_gen | n_eval | f_min | f_gap | r2 | bias | mae | model \n", "================================================================================================================================================================\n", " 1 | 30 | 2.036794E+01 | 2.036794E+01 | - | - | 0.2738756231 | RBF[kernel=linear,tail=constant,normalized=True]\n", " 2 | 40 | 1.647220E+01 | 1.647220E+01 | 0.3763933967 | 0.7000000000 | 0.6182901894 | RBF[kernel=cubic,tail=linear+quadratic,normalized=False]\n", " 3 | 50 | 1.647220E+01 | 1.647220E+01 | 0.3341034259 | 0.7000000000 | 1.0337146201 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 4 | 60 | 1.647220E+01 | 1.647220E+01 | -2.325472E-01 | 0.7000000000 | 1.1952242311 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 5 | 70 | 1.526461E+01 | 1.526461E+01 | -2.483244E-01 | 0.7000000000 | 1.3548503486 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 6 | 80 | 1.353941E+01 | 1.353941E+01 | -2.854016E-01 | 0.7000000000 | 1.7725365031 | RBF[kernel=mq,tail=constant,normalized=False]\n", " 7 | 90 | 1.353941E+01 | 1.353941E+01 | -6.876366E-01 | 0.7000000000 | 0.4617090285 | krg-cont\n", " 8 | 100 | 1.013393E+01 | 1.013393E+01 | 0.9168512037 | 0.9168512037 | 0.5703039705 | krg-cont\n", " 9 | 110 | 1.013393E+01 | 1.013393E+01 | 0.8668379853 | 0.8668379853 | 0.5693628726 | krg-lin\n", " 10 | 120 | 9.7623502147 | 9.7623502147 | 0.8575626049 | 0.8575626049 | 0.5840720180 | krg-lin\n", " 11 | 130 | 9.0558961856 | 9.0558961856 | 0.8603199816 | 0.8603199816 | 0.5523672725 | krg-lin\n", " 12 | 140 | 9.0558961856 | 9.0558961856 | 0.8717525585 | 0.8717525585 | 0.5662209881 | krg-cont\n", " 13 | 150 | 9.0237677371 | 9.0237677371 | 0.7948496762 | 0.7948496762 | 0.4791068868 | krg-cont\n", " 14 | 160 | 6.6233913732 | 6.6233913732 | 0.7726556864 | 0.7726556864 | 0.4877162796 | krg-cont\n", " 15 | 170 | 6.6233913732 | 6.6233913732 | 0.8429714787 | 0.8429714787 | 0.4170345533 | krg-cont\n", " 16 | 180 | 5.7617523828 | 5.7617523828 | 0.8788722441 | 0.8788722441 | 0.4330862204 | krg-cont\n", " 17 | 190 | 5.7617523828 | 5.7617523828 | 0.8581799389 | 0.8581799389 | 0.4180912931 | krg-lin\n", " 18 | 200 | 3.9941402749 | 3.9941402749 | 0.8439598319 | 0.8439598319 | 0.3781019454 | krg-lin\n", " 19 | 210 | 3.9941402749 | 3.9941402749 | 0.9041705189 | 0.9041705189 | 0.4175998236 | krg-lin\n", " 20 | 220 | 3.9914565327 | 3.9914565327 | 0.8239454481 | 0.8239454481 | 0.4864284914 | krg-cont\n", " 21 | 230 | 3.9914565327 | 3.9914565327 | 0.8487160611 | 0.8487160611 | 0.4507227421 | krg-cont\n", " 22 | 240 | 3.8211595495 | 3.8211595495 | 0.8687656158 | 0.8687656158 | 0.5130797895 | krg-cont\n", " 23 | 250 | 3.6463534058 | 3.6463534058 | 0.8626187728 | 0.8626187728 | 0.5621053352 | krg-cont\n", " 24 | 260 | 3.6463534058 | 3.6463534058 | 0.8201204070 | 0.8201204070 | 0.5304724523 | krg-cont\n", " 25 | 270 | 3.6463534058 | 3.6463534058 | 0.8196879465 | 0.8196879465 | 0.5066856628 | krg-cont\n", " 26 | 280 | 3.6463534058 | 3.6463534058 | 0.7784551445 | 0.7784551445 | 0.5778498499 | krg-cont\n", " 27 | 290 | 3.6463534058 | 3.6463534058 | 0.7348469218 | 0.7348469218 | 0.5360693341 | krg-lin\n", " 28 | 300 | 3.6463534058 | 3.6463534058 | 0.7136844062 | 0.7136844062 | 0.5894129213 | krg-lin\n", "Best solution found: \n", "X = [-0.017365 -0.13750357 -0.05619225 0.369787 -0.54064667 0.02531361\n", " 0.18193453 1.34091596 -0.55839746 -0.31890217]\n", "F = [3.64635341]\n", "CV=[0.]\n" ] } ], "source": [ "from pymoo.algorithms.soo.nonconvex.de import DE\n", "from pymoo.optimize import minimize\n", "from pymoo.problems.single import Ackley\n", "from pysamoo.algorithms.psaf import PSAF\n", "\n", "problem = Ackley(n_var=10)\n", "\n", "algorithm = DE(pop_size=20, n_offsprings=10)\n", "\n", "algorithm = PSAF(algorithm, n_initial_doe=30, alpha=10, beta=30, max_rho=0.7, n_max_infills=10, n_max_doe=500)\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 300),\n", " seed=2,\n", " verbose=True)\n", "\n", "print(\"Best solution found: \\nX = %s\\nF = %s\\nCV=%s\" % (res.X, res.F, res.CV))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## PSAF-CMAES" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "================================================================================================================================================================\n", "n_gen | n_eval | f_min | f_gap | r2 | bias | mae | model \n", "================================================================================================================================================================\n", " 1 | 30 | 2.036794E+01 | 2.036794E+01 | - | - | 0.2738756231 | RBF[kernel=linear,tail=constant,normalized=True]\n", " 2 | 40 | 1.332973E+01 | 1.332973E+01 | 0.3763933967 | 0.7000000000 | 0.7291380548 | RBF[kernel=cubic,tail=linear+quadratic,normalized=False]\n", " 3 | 50 | 1.332973E+01 | 1.332973E+01 | 0.2592841419 | 0.7000000000 | 0.9917695888 | RBF[kernel=mq,tail=linear+quadratic,normalized=False]\n", " 4 | 60 | 1.332973E+01 | 1.332973E+01 | 0.1644667959 | 0.7000000000 | 1.1552330246 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 5 | 70 | 1.332973E+01 | 1.332973E+01 | 0.3694414291 | 0.7000000000 | 1.5138747301 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 6 | 80 | 1.332973E+01 | 1.332973E+01 | 0.2600993833 | 0.7000000000 | 1.8085470200 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 7 | 90 | 1.241845E+01 | 1.241845E+01 | 0.2038351057 | 0.7000000000 | 0.6335623668 | krg-cont\n", " 8 | 100 | 7.3256172613 | 7.3256172613 | 0.8492853728 | 0.8492853728 | 0.8690919422 | krg-cont\n", " 9 | 110 | 7.3256172613 | 7.3256172613 | 0.7486633888 | 0.7486633888 | 1.0053520252 | krg-cont\n", " 10 | 120 | 6.9655651500 | 6.9655651500 | 0.6028752305 | 0.7000000000 | 1.1338932661 | krg-cont\n", " 11 | 130 | 5.0841360021 | 5.0841360021 | 0.6039414826 | 0.7000000000 | 1.1598374455 | krg-cont\n", " 12 | 140 | 5.0841360021 | 5.0841360021 | 0.6085190250 | 0.7000000000 | 1.2980426541 | krg-cont\n", " 13 | 150 | 4.7082954697 | 4.7082954697 | 0.6037349339 | 0.7000000000 | 1.0560636000 | krg-cont\n", " 14 | 160 | 3.9307717509 | 3.9307717509 | 0.6416580369 | 0.7000000000 | 0.8196459781 | krg-cont\n", " 15 | 170 | 3.9307717509 | 3.9307717509 | 0.7689568545 | 0.7689568545 | 0.6934795741 | krg-cont\n", " 16 | 180 | 3.6005443620 | 3.6005443620 | 0.7947301965 | 0.7947301965 | 0.6828921049 | krg-cont\n", " 17 | 190 | 3.5337383218 | 3.5337383218 | 0.7862944244 | 0.7862944244 | 0.5887485674 | krg-lin\n", " 18 | 200 | 3.5337383218 | 3.5337383218 | 0.8054350086 | 0.8054350086 | 0.8994223086 | krg-lin\n", " 19 | 210 | 3.5337383218 | 3.5337383218 | 0.2592954046 | 0.7000000000 | 0.9427215928 | krg-lin\n", " 20 | 220 | 3.5337383218 | 3.5337383218 | 0.0777094174 | 0.7000000000 | 1.0415795870 | krg-lin\n", " 21 | 230 | 3.5337383218 | 3.5337383218 | -2.692331E-01 | 0.7000000000 | 1.0218187624 | krg-lin\n", " 22 | 240 | 3.5337383218 | 3.5337383218 | -7.771233E-01 | 0.7000000000 | 1.1893524253 | krg-lin\n", " 23 | 250 | 2.9110175231 | 2.9110175231 | -1.132129E+00 | 0.7000000000 | 0.8852039354 | krg-cont\n", " 24 | 260 | 2.6880983494 | 2.6880983494 | -1.270011E+00 | 0.7000000000 | 1.0067140755 | krg-cont\n", " 25 | 270 | 2.6880983494 | 2.6880983494 | -2.820539E+00 | 0.7000000000 | 1.0239253459 | krg-cont\n", " 26 | 280 | 2.6880983494 | 2.6880983494 | -3.069151E+00 | 0.7000000000 | 1.0617400742 | krg-lin\n", " 27 | 290 | 2.6260580244 | 2.6260580244 | -3.561686E+00 | 0.7000000000 | 0.9515962802 | krg-lin\n", " 28 | 300 | 2.6260580244 | 2.6260580244 | -4.387418E+00 | 0.7000000000 | 1.3332084142 | RBF[kernel=cubic,tail=constant,normalized=True]\n", "Best solution found: \n", "X = [-0.05580694 -0.09378573 -0.37298884 -0.08638338 0.0515077 -0.41373204\n", " 0.09691779 1.07067447 0.1263253 -0.20414152]\n", "F = [2.62605802]\n", "CV=[0.]\n" ] } ], "source": [ "from pymoo.algorithms.soo.nonconvex.cmaes import SimpleCMAES\n", "from pymoo.optimize import minimize\n", "from pymoo.problems.single import Ackley\n", "from pysamoo.algorithms.psaf import PSAF\n", "\n", "problem = Ackley(n_var=10)\n", "\n", "algorithm = SimpleCMAES(pop_size=20)\n", "\n", "algorithm = PSAF(algorithm, n_initial_doe=30, alpha=10, beta=30, max_rho=0.7, n_max_infills=10, n_max_doe=500)\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 300),\n", " seed=2,\n", " verbose=True)\n", "\n", "print(\"Best solution found: \\nX = %s\\nF = %s\\nCV=%s\" % (res.X, res.F, res.CV))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## GPSAF-GA" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "================================================================================================================================================\n", "n_gen | n_eval | f_min | f_gap | n_influenced | mae | model \n", "================================================================================================================================================\n", " 1 | 30 | 2.036794E+01 | 2.036794E+01 | - | 0.2395537352 | RBF[kernel=gaussian,tail=quadratic,normalized=True]\n", " 2 | 40 | 9.6180845318 | 9.6180845318 | 4/10 | 0.7292616206 | RBF[kernel=gaussian,tail=quadratic,normalized=False]\n", " 3 | 50 | 9.5397702619 | 9.5397702619 | 4/10 | 1.2838259268 | RBF[kernel=gaussian,tail=quadratic,normalized=False]\n", " 4 | 60 | 8.3350419429 | 8.3350419429 | 5/10 | 1.1933475702 | RBF[kernel=gaussian,tail=linear+quadratic,normalized=True]\n", " 5 | 70 | 8.2371788716 | 8.2371788716 | 4/10 | 1.1919714473 | RBF[kernel=gaussian,tail=linear+quadratic,normalized=True]\n", " 6 | 80 | 8.0191285291 | 8.0191285291 | 2/10 | 0.8810109187 | kriging-const-ARD\n", " 7 | 90 | 7.8519168526 | 7.8519168526 | 4/10 | 0.7338034351 | kriging-lin\n", " 8 | 100 | 7.7553809035 | 7.7553809035 | 2/10 | 0.7521845637 | kriging-lin\n", " 9 | 110 | 7.3837499736 | 7.3837499736 | 6/10 | 0.8561025281 | kriging-lin\n", " 10 | 120 | 7.3837499736 | 7.3837499736 | 6/10 | 2.7239305748 | kriging-quadr\n", " 11 | 130 | 7.3837499736 | 7.3837499736 | 4/10 | 1.7610057486 | kriging-lin\n", " 12 | 140 | 7.3640055044 | 7.3640055044 | 6/10 | 1.0600526491 | kriging-const-ARD\n", " 13 | 150 | 7.0657745472 | 7.0657745472 | 4/10 | 1.2643272170 | kriging-const-ARD\n", " 14 | 160 | 7.0657745472 | 7.0657745472 | 6/10 | 2.2759640477 | kriging-lin\n", " 15 | 170 | 7.0407792334 | 7.0407792334 | 3/10 | 2.1436566074 | kriging-lin\n", " 16 | 180 | 6.9854628698 | 6.9854628698 | 4/10 | 0.3210627737 | kriging-quadr\n", " 17 | 190 | 6.9847040068 | 6.9847040068 | 2/10 | 1.8313479569 | kriging-lin\n", " 18 | 200 | 6.9162278041 | 6.9162278041 | 3/10 | 1.2739195852 | kriging-lin\n", " 19 | 210 | 6.9081087618 | 6.9081087618 | 3/10 | 0.6008899786 | kriging-lin\n", " 20 | 220 | 6.8826264252 | 6.8826264252 | 6/10 | 0.6377193155 | kriging-lin\n", " 21 | 230 | 6.8815544475 | 6.8815544475 | 5/10 | 0.6552357623 | kriging-lin\n", " 22 | 240 | 6.8403116305 | 6.8403116305 | 6/10 | 0.0724192352 | kriging-quadr\n", " 23 | 250 | 6.8274044511 | 6.8274044511 | 3/10 | 0.4952315643 | kriging-lin\n", " 24 | 260 | 6.8274035650 | 6.8274035650 | 7/10 | 0.5406026626 | kriging-lin\n", " 25 | 270 | 6.8030346170 | 6.8030346170 | 5/10 | 0.4775624871 | kriging-lin\n", " 26 | 280 | 6.8009722666 | 6.8009722666 | 1/10 | 0.4409766638 | kriging-lin\n", " 27 | 290 | 5.2446639674 | 5.2446639674 | 4/10 | 1.043396E+01 | kriging-lin\n", " 28 | 300 | 5.1590950227 | 5.1590950227 | 2/10 | 1.336450E+01 | kriging-quadr\n", "Best solution found: \n", "X = [-2.00803163 1.86061669 -2.09794872 1.95560802 -0.14461223 0.08631508\n", " 0.07473123 -0.07630844 0.89663685 -0.25277987]\n", "F = [5.15909502]\n", "CV=[0.]\n" ] } ], "source": [ "from pymoo.algorithms.soo.nonconvex.ga import GA\n", "from pymoo.optimize import minimize\n", "from pymoo.problems.single import Ackley\n", "from pysamoo.algorithms.gpsaf import GPSAF\n", "\n", "problem = Ackley(n_var=10)\n", "\n", "algorithm = GA(pop_size=20, n_offsprings=10)\n", "\n", "algorithm = GPSAF(algorithm, n_initial_doe=30, alpha=10, beta=30, n_max_infills=10, n_max_doe=500)\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 300),\n", " seed=2,\n", " verbose=True)\n", "\n", "print(\"Best solution found: \\nX = %s\\nF = %s\\nCV=%s\" % (res.X, res.F, res.CV))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## GPSAF-DE" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "================================================================================================================================================\n", "n_gen | n_eval | f_min | f_gap | n_influenced | mae | model \n", "================================================================================================================================================\n", " 1 | 30 | 2.033913E+01 | 2.033913E+01 | - | 0.2584492905 | RBF[kernel=mq,tail=linear,normalized=True]\n", " 2 | 40 | 1.489029E+01 | 1.489029E+01 | 5/10 | 0.4320034794 | RBF[kernel=mq,tail=linear,normalized=True]\n", " 3 | 50 | 1.489029E+01 | 1.489029E+01 | 6/10 | 0.5599724717 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 4 | 60 | 1.203982E+01 | 1.203982E+01 | 8/10 | 0.7991257442 | RBF[kernel=linear,tail=linear,normalized=True]\n", " 5 | 70 | 1.203982E+01 | 1.203982E+01 | 5/10 | 0.8959677659 | RBF[kernel=linear,tail=constant,normalized=True]\n", " 6 | 80 | 1.203982E+01 | 1.203982E+01 | 5/10 | 1.0550719580 | RBF[kernel=linear,tail=constant,normalized=True]\n", " 7 | 90 | 1.190403E+01 | 1.190403E+01 | 4/10 | 0.6643174886 | kriging-const\n", " 8 | 100 | 8.7732279452 | 8.7732279452 | 7/10 | 0.7612524061 | kriging-const\n", " 9 | 110 | 8.7732279452 | 8.7732279452 | 6/10 | 0.6504482134 | kriging-const\n", " 10 | 120 | 8.7732279452 | 8.7732279452 | 7/10 | 0.6183165691 | kriging-const\n", " 11 | 130 | 7.4950684256 | 7.4950684256 | 8/10 | 0.6255644662 | kriging-const\n", " 12 | 140 | 7.4950684256 | 7.4950684256 | 7/10 | 0.6872365051 | kriging-const\n", "BIASED: TOO CLOSE (SKIP)\n", " 13 | 150 | 7.4950684256 | 7.4950684256 | 8/10 | 0.5375685411 | kriging-const\n", " 14 | 160 | 6.4510590085 | 6.4510590085 | 4/10 | 0.4939197965 | kriging-const-ARD\n", " 15 | 170 | 5.9600945536 | 5.9600945536 | 7/10 | 0.4638647655 | kriging-quadr\n", " 16 | 180 | 5.9600945536 | 5.9600945536 | 7/10 | 0.4446192503 | kriging-const-ARD\n", " 17 | 190 | 5.4886456424 | 5.4886456424 | 7/10 | 0.4839298024 | kriging-const-ARD\n", " 18 | 200 | 5.4886456424 | 5.4886456424 | 9/10 | 0.6993539907 | kriging-lin-ARD\n", " 19 | 210 | 5.4886456424 | 5.4886456424 | 6/10 | 0.7372165210 | kriging-lin-ARD\n", " 20 | 220 | 5.4886456424 | 5.4886456424 | 8/10 | 0.7630410210 | kriging-lin-ARD\n", " 21 | 230 | 5.4886456424 | 5.4886456424 | 7/10 | 0.6797742577 | kriging-quadr-ARD\n", " 22 | 240 | 5.2455941969 | 5.2455941969 | 5/10 | 0.7468197492 | kriging-lin-ARD\n", " 23 | 250 | 3.8890189117 | 3.8890189117 | 5/10 | 0.5426021921 | kriging-lin-ARD\n", " 24 | 260 | 3.8890189117 | 3.8890189117 | 3/10 | 0.4366853768 | kriging-lin-ARD\n", " 25 | 270 | 3.8890189117 | 3.8890189117 | 5/10 | 0.3746281150 | kriging-const-ARD\n", " 26 | 280 | 3.8890189117 | 3.8890189117 | 7/10 | 0.4238507263 | kriging-const-ARD\n", " 27 | 290 | 3.8890189117 | 3.8890189117 | 5/10 | 0.3439499037 | kriging-quadr-ARD\n", " 28 | 300 | 3.8890189117 | 3.8890189117 | 4/10 | 0.5077978046 | kriging-const-ARD\n", "Best solution found: \n", "X = [-0.73853388 0.20019719 0.29418694 -0.68726892 0.33516822 0.03035722\n", " -0.48582207 -0.93401104 0.81073807 -0.38538059]\n", "F = [3.88901891]\n", "CV=[0.]\n" ] } ], "source": [ "from pymoo.algorithms.soo.nonconvex.de import DE\n", "from pymoo.optimize import minimize\n", "from pymoo.problems.single import Ackley\n", "from pysamoo.algorithms.gpsaf import GPSAF\n", "\n", "problem = Ackley(n_var=10)\n", "\n", "algorithm = DE(pop_size=20, n_offsprings=10)\n", "\n", "algorithm = GPSAF(algorithm, n_initial_doe=30, alpha=10, beta=30, n_max_infills=10, n_max_doe=500)\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 300),\n", " seed=1,\n", " verbose=True)\n", "\n", "print(\"Best solution found: \\nX = %s\\nF = %s\\nCV=%s\" % (res.X, res.F, res.CV))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## GPSAF-ISRES" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=================================================================================================\n", "n_gen | n_eval | cv_min | cv_avg | f_min | f_gap | n_influenced\n", "=================================================================================================\n", " 1 | 27 | 1.714499E+02 | 5.617944E+02 | - | - | -\n", " 2 | 28 | 1.7247367719 | 5.617944E+02 | - | - | 1/1\n", " 3 | 29 | 0.000000E+00 | 5.617944E+02 | -6.400043E+00 | 8.5999570206 | 1/1\n", " 4 | 30 | 0.000000E+00 | 5.617944E+02 | -1.079833E+01 | 4.2016695983 | 1/1\n", " 5 | 31 | 0.000000E+00 | 5.617944E+02 | -1.155193E+01 | 3.4480660762 | 1/1\n", " 6 | 32 | 0.000000E+00 | 5.617944E+02 | -1.304470E+01 | 1.9552979195 | 1/1\n", " 7 | 33 | 0.000000E+00 | 5.617944E+02 | -1.454634E+01 | 0.4536595946 | 1/1\n", " 8 | 34 | 0.000000E+00 | 5.617944E+02 | -1.480047E+01 | 0.1995280575 | 1/1\n", " 9 | 35 | 0.000000E+00 | 5.617944E+02 | -1.491833E+01 | 0.0816667392 | 1/1\n", " 10 | 36 | 0.000000E+00 | 5.617944E+02 | -1.495020E+01 | 0.0498020785 | 1/1\n", " 11 | 37 | 0.000000E+00 | 5.617944E+02 | -1.497953E+01 | 0.0204729495 | 1/1\n", " 12 | 38 | 0.000000E+00 | 5.617944E+02 | -1.498599E+01 | 0.0140111011 | 1/1\n", " 13 | 39 | 0.000000E+00 | 5.617944E+02 | -1.499666E+01 | 0.0033414569 | 1/1\n", " 14 | 40 | 0.000000E+00 | 5.617944E+02 | -1.499798E+01 | 0.0020232532 | 1/1\n", " 15 | 41 | 0.000000E+00 | 5.617944E+02 | -1.499893E+01 | 0.0010657277 | 1/1\n", " 16 | 42 | 0.000000E+00 | 5.617944E+02 | -1.499951E+01 | 0.0004923939 | 1/1\n", " 17 | 43 | 0.000000E+00 | 5.617944E+02 | -1.499989E+01 | 0.0001121181 | 1/1\n", " 18 | 44 | 0.000000E+00 | 5.617944E+02 | -1.499996E+01 | 0.0000392967 | 1/1\n", " 19 | 45 | 0.000000E+00 | 5.617944E+02 | -1.499998E+01 | 0.0000213215 | 1/1\n", " 20 | 46 | 0.000000E+00 | 5.617944E+02 | -1.499999E+01 | 6.450720E-06 | 1/1\n", " 21 | 47 | 0.000000E+00 | 5.617944E+02 | -1.500000E+01 | 2.063368E-06 | 1/1\n", " 22 | 48 | 0.000000E+00 | 5.617944E+02 | -1.500000E+01 | 1.004444E-06 | 1/1\n", " 23 | 49 | 0.000000E+00 | 5.617944E+02 | -1.500000E+01 | 7.880460E-07 | 1/1\n", " 24 | 50 | 0.000000E+00 | 5.617944E+02 | -1.500000E+01 | 3.512184E-07 | 1/1\n", "Best solution found: \n", "X = [0.99999999 1. 1. 0.99999999 0.99999996 0.99999999\n", " 0.99999999 0.99999999 1. 2.99999992 2.99999995 2.99999995\n", " 1. ]\n", "F = [-14.99999965]\n", "CV=[0.]\n" ] } ], "source": [ "from pymoo.algorithms.soo.nonconvex.isres import ISRES\n", "from pymoo.problems import get_problem\n", "from pymoo.optimize import minimize\n", "from pysamoo.algorithms.gpsaf import GPSAF\n", "\n", "problem = get_problem(\"g1\")\n", "\n", "algorithm = ISRES()\n", "\n", "algorithm = GPSAF(algorithm,\n", " alpha=3,\n", " beta=30,\n", " n_max_infills=1)\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 50),\n", " seed=1,\n", " verbose=True)\n", "\n", "print(\"Best solution found: \\nX = %s\\nF = %s\\nCV=%s\" % (res.X, res.F, res.CV))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## GPSAF-NSGA-II" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==========================================================================================================================\n", "n_gen | n_eval | n_nds | igd | gd | hv | n_influenced | mae f1 | mae f2 \n", "==========================================================================================================================\n", " 1 | 21 | 3 | 1.8942829534 | 3.0095912826 | 0.000000E+00 | - | 2.158343E-16 | 0.1648489778\n", " 2 | 31 | 3 | 0.4620001734 | 0.7493117302 | 0.1510010190 | 4/10 | 2.875825E-16 | 0.1602687910\n", " 3 | 41 | 2 | 0.3371490822 | 0.2924047767 | 0.3268413114 | 2/10 | 3.001494E-16 | 0.1174748180\n", " 4 | 51 | 8 | 0.1408073065 | 0.2210541972 | 0.4390090282 | 4/10 | 3.452678E-16 | 0.0959817810\n", " 5 | 61 | 10 | 0.1408073065 | 0.0554779978 | 0.4390090282 | 2/10 | 3.650537E-16 | 0.0920210809\n", " 6 | 71 | 16 | 0.1221342838 | 0.0449904710 | 0.4557288877 | 4/10 | 4.895776E-16 | 0.0935525354\n", " 7 | 81 | 27 | 0.0827579407 | 0.0468689921 | 0.5246360468 | 4/10 | 4.549254E-16 | 0.0804396406\n", " 8 | 91 | 43 | 0.0665862375 | 0.0457088275 | 0.5597220040 | 5/10 | 5.034923E-16 | 0.0734327256\n", " 9 | 101 | 47 | 0.0619377292 | 0.0447108249 | 0.5713835331 | 5/10 | 4.815151E-16 | 0.0677243980\n", " 10 | 111 | 61 | 0.0388290475 | 0.0363894044 | 0.6033660247 | 8/10 | 5.531123E-16 | 0.0557135910\n", " 11 | 121 | 66 | 0.0346932634 | 0.0310968683 | 0.6118625353 | 6/10 | 5.023857E-16 | 0.0514084161\n", " 12 | 131 | 71 | 0.0289701336 | 0.0298619940 | 0.6199182144 | 6/10 | 6.586745E-16 | 0.0580864746\n", " 13 | 141 | 80 | 0.0259409226 | 0.0264607872 | 0.6244944372 | 5/10 | 6.353598E-16 | 0.0663689181\n", " 14 | 151 | 90 | 0.0250694448 | 0.0228440028 | 0.6262433378 | 5/10 | 5.765809E-16 | 0.0502260611\n", " 15 | 161 | 99 | 0.0244332270 | 0.0232342003 | 0.6281135848 | 8/10 | 5.182270E-16 | 0.0512215780\n", " 16 | 171 | 106 | 0.0242365158 | 0.0192595759 | 0.6285037545 | 8/10 | 3.970392E-16 | 0.0534405466\n", " 17 | 181 | 107 | 0.0223183843 | 0.0149311969 | 0.6310924941 | 3/10 | 5.725975E-16 | 0.0440707098\n", " 18 | 191 | 123 | 0.0218602416 | 0.0143220756 | 0.6318522249 | 6/10 | 8.820722E-16 | 0.0486144418\n", " 19 | 201 | 138 | 0.0211919510 | 0.0138804874 | 0.6332318400 | 6/10 | 1.540363E-15 | 0.0497609611\n", " 20 | 211 | 155 | 0.0211090608 | 0.0133719333 | 0.6333551695 | 6/10 | 1.865587E-15 | 0.0442893928\n", " 21 | 221 | 166 | 0.0203041406 | 0.0127681633 | 0.6344643397 | 8/10 | 1.988264E-15 | 0.0582482969\n", " 22 | 231 | 171 | 0.0200470557 | 0.0120744782 | 0.6352276331 | 5/10 | 2.353805E-15 | 0.0773347096\n", " 23 | 241 | 173 | 0.0199378688 | 0.0113533889 | 0.6358860735 | 5/10 | 2.550337E-15 | 0.0800614458\n", " 24 | 251 | 192 | 0.0196526487 | 0.0121477068 | 0.6363797924 | 9/10 | 3.551637E-15 | 0.0640281394\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "\n", "from pymoo.algorithms.moo.nsga2 import NSGA2\n", "from pymoo.optimize import minimize\n", "from pymoo.problems.multi import ZDT1\n", "from pymoo.visualization.scatter import Scatter\n", "from pysamoo.algorithms.gpsaf import GPSAF\n", "\n", "problem = ZDT1(n_var=10)\n", "\n", "algorithm = NSGA2(pop_size=20, n_offsprings=10)\n", "\n", "algorithm = GPSAF(algorithm,\n", " alpha=10,\n", " beta=50,\n", " n_max_doe=100,\n", " n_max_infills=np.inf,\n", " )\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 250),\n", " seed=1,\n", " verbose=True)\n", "\n", "plot = Scatter()\n", "plot.add(problem.pareto_front(), plot_type=\"line\", color=\"black\", alpha=0.7)\n", "plot.add(res.F, facecolor=\"none\", edgecolor=\"red\")\n", "plot.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## GPSAF-NSGA-III" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==========================================================================================================================\n", "n_gen | n_eval | n_nds | cv_min | cv_avg | igd | gd | hv | n_influenced\n", "==========================================================================================================================\n", " 1 | 5 | 1 | 0.5717037305 | 7.3349018351 | - | - | - | -\n", " 2 | 15 | 2 | 0.000000E+00 | 7.3349018351 | 0.2653544470 | 0.0984902580 | 0.0294105975 | 7/10\n", " 3 | 25 | 6 | 0.000000E+00 | 7.3349018351 | 0.1688552083 | 0.1110745959 | 0.0804323054 | 6/10\n", " 4 | 35 | 12 | 0.000000E+00 | 7.3349018351 | 0.1626975751 | 0.1069272188 | 0.0812678935 | 4/10\n", " 5 | 45 | 16 | 0.000000E+00 | 7.3349018351 | 0.1626975751 | 0.1074034919 | 0.0812678935 | 2/10\n", " 6 | 55 | 7 | 0.000000E+00 | 7.3349018351 | 0.1568291260 | 0.0536053149 | 0.1334154871 | 4/10\n", " 7 | 65 | 9 | 0.000000E+00 | 7.3349018351 | 0.1448912306 | 0.0645102339 | 0.1336500488 | 4/10\n", " 8 | 75 | 13 | 0.000000E+00 | 7.3349018351 | 0.1197962927 | 0.0676481356 | 0.1552136458 | 7/10\n", " 9 | 85 | 16 | 0.000000E+00 | 7.3349018351 | 0.1197962927 | 0.0687271946 | 0.1552136458 | 1/10\n", " 10 | 95 | 21 | 0.000000E+00 | 7.3349018351 | 0.0893101188 | 0.0667513661 | 0.1983892329 | 9/10\n", " 11 | 105 | 26 | 0.000000E+00 | 7.3349018351 | 0.0594609081 | 0.0484714727 | 0.2116452805 | 7/10\n", " 12 | 115 | 36 | 0.000000E+00 | 7.3349018351 | 0.0573628701 | 0.0455119835 | 0.2254828364 | 8/10\n", " 13 | 125 | 45 | 0.000000E+00 | 7.3349018351 | 0.0571111062 | 0.0453376673 | 0.2258291227 | 5/10\n", " 14 | 135 | 59 | 0.000000E+00 | 7.3349018351 | 0.0555906801 | 0.0455882251 | 0.2316224246 | 6/10\n", " 15 | 145 | 72 | 0.000000E+00 | 7.3349018351 | 0.0555906801 | 0.0462793825 | 0.2316224246 | 4/10\n", " 16 | 155 | 81 | 0.000000E+00 | 7.3349018351 | 0.0550140152 | 0.0473746175 | 0.2332016113 | 9/10\n", " 17 | 165 | 90 | 0.000000E+00 | 7.3349018351 | 0.0545351583 | 0.0479898213 | 0.2335873099 | 6/10\n", " 18 | 175 | 102 | 0.000000E+00 | 7.3349018351 | 0.0544481014 | 0.0472218443 | 0.2338235521 | 9/10\n", " 19 | 185 | 95 | 0.000000E+00 | 7.3349018351 | 0.0508618111 | 0.0389046008 | 0.2379154517 | 9/10\n", " 20 | 195 | 92 | 0.000000E+00 | 7.3349018351 | 0.0498523756 | 0.0336684226 | 0.2382643368 | 5/10\n", " 21 | 205 | 103 | 0.000000E+00 | 7.3349018351 | 0.0495946407 | 0.0339564545 | 0.2388966697 | 2/10\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "\n", "from pymoo.algorithms.moo.nsga3 import NSGA3\n", "from pymoo.problems import get_problem\n", "from pymoo.util.ref_dirs import get_reference_directions\n", "from pymoo.optimize import minimize\n", "from pymoo.problems.multi import TNK\n", "from pymoo.visualization.scatter import Scatter\n", "from pysamoo.algorithms.gpsaf import GPSAF\n", "\n", "problem = TNK()\n", "\n", "ref_dirs = get_reference_directions(\"das-dennis\", 2, n_points=20)\n", "\n", "# create the algorithm object\n", "algorithm = NSGA3(pop_size=20,\n", " n_offsprings=10,\n", " ref_dirs=ref_dirs)\n", "\n", "\n", "algorithm = GPSAF(algorithm,\n", " alpha=10,\n", " beta=50,\n", " n_max_doe=100,\n", " )\n", "\n", "res = minimize(\n", " problem,\n", " algorithm,\n", " ('n_evals', 200),\n", " seed=1,\n", " verbose=True)\n", "\n", "plot = Scatter()\n", "plot.add(problem.pareto_front(), plot_type=\"line\", color=\"black\", alpha=0.7)\n", "plot.add(res.F, facecolor=\"none\", edgecolor=\"red\")\n", "plot.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Tools" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Constrained Sampling for Design of Experiments (DOE)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For more information and more context, please see the following publication:" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "`Blank, J., Deb, K. (2021). Constrained Bi-objective Surrogate-Assisted Optimization of Problems with Heterogeneous Evaluation Times: Expensive Objectives and Inexpensive Constraints. In: , et al. Evolutionary Multi-Criterion Optimization. EMO 2021. Lecture Notes in Computer Science, vol 12654. Springer, Cham. `_\n", "\n", "::\n", "\n", " @InProceedings{10.1007/978-3-030-72062-9_21,\n", " author=\"Blank, Julian\n", " and Deb, Kalyanmoy\",\n", " editor=\"Ishibuchi, Hisao\n", " and Zhang, Qingfu\n", " and Cheng, Ran\n", " and Li, Ke\n", " and Li, Hui\n", " and Wang, Handing\n", " and Zhou, Aimin\",\n", " title=\"Constrained Bi-objective Surrogate-Assisted Optimization of Problems with Heterogeneous Evaluation Times: Expensive Objectives and Inexpensive Constraints\",\n", " booktitle=\"Evolutionary Multi-Criterion Optimization\",\n", " year=\"2021\",\n", " publisher=\"Springer International Publishing\",\n", " address=\"Cham\",\n", " pages=\"257--269\",\n", " isbn=\"978-3-030-72062-9\"\n", " }" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us say our goal is to find 50 feasible designs for the SRN problem. We assume that the constraints are computationally inexpensive in contrast to the objectives requiring a time-consuming evaluation." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "from pymoo.problems.multi import SRN\n", "problem = SRN()\n", "\n", "n_points = 50" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The function returning the constrained violation (CV) given a design can then be implemented by:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def calc_cv(X):\n", " G = problem.evaluate(X, return_values_of=[\"G\"])\n", " return np.maximum(G, 0.0).sum(axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let us define a plot function showing the design space and show infeasible solutions in red and feasible ones in blue:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "def plot(X):\n", "\n", " xl, xu = problem.bounds()\n", "\n", " def circle(x=0, y=0, r=1):\n", " theta = np.linspace(0, 2 * np.pi, 100)\n", " return x + r * np.cos(theta), y + r * np.sin(theta)\n", "\n", "\n", " fig, ax = plt.subplots(figsize=(6, 6))\n", " \n", " feas = calc_cv(X) <= 0\n", "\n", " ax.scatter(X[feas, 0], X[feas, 1], s=30, facecolors='none', edgecolors='blue')\n", " ax.scatter(X[~feas, 0], X[~feas, 1], s=30, facecolors='none', edgecolors='red')\n", "\n", " x, y = circle(r=15)\n", " ax.plot(x, y, color=\"black\", alpha=0.6)\n", "\n", " x = np.linspace(-20, 20)\n", " y = 1 / 3 * x + 10 / 3\n", " ax.plot(x, y, color=\"black\", alpha=0.6)\n", "\n", " ax.set_aspect(1)\n", "\n", " ax.set_xlim(xl[0], xu[0])\n", " ax.set_ylim(xl[1], xu[1])\n", "\n", " ax.set_xlabel(\"$x_1$\")\n", " ax.set_ylabel(\"$x_2$\")\n", "\n", " plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we perform LHS sampling, the result might look as follows:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from pymoo.operators.sampling.lhs import LHS\n", "\n", "X = LHS().do(problem, n_points).get(\"X\")\n", "plot(X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Clearly, the majority of designs are infeasible. A simple improvement of this method is repeating the sampling multiple times now until the required number of points has been found." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from pysamoo.sampling.rejection import RejectionConstrainedSampling\n", "\n", "X = RejectionConstrainedSampling(calc_cv).do(problem, n_points).get(\"X\")\n", "plot(X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By using a more sophisticated energy-based approach the uniformity can be further improved:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from pysamoo.sampling.energy import EnergyConstrainedSampling\n", "\n", "X = EnergyConstrainedSampling(calc_cv).do(problem, n_points).get(\"X\")\n", "plot(X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Contact" ] }, { "cell_type": "raw", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "\n", "Feel free to contact us if you have any question:\n", "\n", "::\n", "\n", " Julian Blank (blankjul [at] msu.edu)\n", " Michigan State University\n", " Computational Optimization and Innovation Laboratory (COIN)\n", " East Lansing, MI 48824, USA\n", "\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5" }, "pycharm": { "stem_cell": { "cell_type": "raw", "metadata": { "collapsed": false }, "source": [] } } }, "nbformat": 4, "nbformat_minor": 4 }