diff --git a/README.rst b/README.rst index 7660806ac..1c05ae3bd 100644 --- a/README.rst +++ b/README.rst @@ -14,7 +14,7 @@ You can find the detailed documentation here: https://pymoo.org .. |python| image:: https://img.shields.io/badge/python-3.6-blue.svg :alt: python 3.6 -.. |license| image:: https://img.shields.io/badge/license-apache-blue.svg +.. |license| image:: https://img.shields.io/badge/license-apache-orange.svg :alt: license apache :target: https://www.apache.org/licenses/LICENSE-2.0 diff --git a/doc/Makefile b/doc/Makefile index 56bfb74e3..4cba15530 100755 --- a/doc/Makefile +++ b/doc/Makefile @@ -51,7 +51,3 @@ html: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." - - -live: - sphinx-autobuild -b html "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/doc/README b/doc/README new file mode 100644 index 000000000..e070e6ed1 --- /dev/null +++ b/doc/README @@ -0,0 +1 @@ +pip install requirements.txt \ No newline at end of file diff --git a/doc/github/README.template b/doc/github/README.template index 934317c09..20b36d5fd 100644 --- a/doc/github/README.template +++ b/doc/github/README.template @@ -1,24 +1,65 @@ pymoo - Multi-Objective Optimization Framework ==================================================================== -You can find the detailed documentation here: -https://www.egr.msu.edu/coinlab/blankjul/pymoo/ +You can find the detailed documentation here: https://pymoo.org -.. image:: https://gitlab.msu.edu/blankjul/pymoo/badges/master/pipeline.svg + +|gitlab| |python| |license| + + +.. |gitlab| image:: https://gitlab.msu.edu/blankjul/pymoo/badges/master/pipeline.svg :alt: build status :target: https://gitlab.msu.edu/blankjul/pymoo/commits/master -.. image:: https://img.shields.io/badge/python-3.6-blue.svg +.. |python| image:: https://img.shields.io/badge/python-3.6-blue.svg :alt: python 3.6 -.. image:: https://img.shields.io/badge/license-apache-blue.svg - :alt: python 3.6 +.. |license| image:: https://img.shields.io/badge/license-apache-orange.svg + :alt: license apache :target: https://www.apache.org/licenses/LICENSE-2.0 +We are currently working on a paper about *pymoo*. +Meanwhile, if you have used our framework for research purposes, please cite us with: + +:: + + @misc{pymoo, + author = {Julian Blank and Kalyanmoy Deb}, + title = {pymoo - {Multi-objective Optimization in Python}}, + howpublished = {https://pymoo.org} + } + + + Installation ==================================================================== -{% include 'docs/source/_installation.rst' %} + +First, make sure you have a Python 3 environment installed. We recommend miniconda3 or anaconda3. + +The official release is always available at PyPi: + +.. code:: bash + + pip install Cython>=0.29 numpy>=1.15 pymoo + + +For the current developer version: + +.. code:: bash + + git clone https://github.com/msu-coinlab/pymoo + cd pymoo + pip install . + + +Since for speedup some of the modules are also available compiled you can double check +if the compilation worked. When executing the command be sure not already being in the local pymoo +directory because otherwise not the in site-packages installed version will be used. + +.. code:: bash + + python -c "from pymoo.cython.function_loader import is_compiled;print('Compiled Extensions: ', is_compiled())" Usage diff --git a/doc/requirements.txt b/doc/requirements.txt new file mode 100644 index 000000000..ae86b6e9c --- /dev/null +++ b/doc/requirements.txt @@ -0,0 +1,4 @@ +sphinx +numpydoc +nbsphinx +sphinxcontrib-bibtex \ No newline at end of file diff --git a/doc/source/algorithms/differential_evolution.ipynb b/doc/source/algorithms/differential_evolution.ipynb index 911ef33d7..e3ba5b6a3 100644 --- a/doc/source/algorithms/differential_evolution.ipynb +++ b/doc/source/algorithms/differential_evolution.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -32,8 +32,8 @@ "output_type": "stream", "text": [ "Best solution found: \n", - "X = [-3.60438355e-11 9.94958640e-01 -2.52891937e-09]\n", - "F = [0.99495906]\n" + "X = [ 1.39583098e-09 -2.96314339e-09 1.06196328e-09]\n", + "F = [0.]\n" ] } ], @@ -48,8 +48,9 @@ " method=get_algorithm('de',\n", " variant = \"DE/rand/1/bin\",\n", " pop_size = 100,\n", - " CR = 2,\n", - " F = 0.75),\n", + " CR = 0.3,\n", + " F = 0.5,\n", + " seed=1),\n", " termination=('n_gen', 200),\n", " seed=1,\n", " disp=False)\n", @@ -73,6 +74,13 @@ ".. autofunction:: pymoo.algorithms.so_de.de\n", " :noindex:" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/doc/source/algorithms/moead.ipynb b/doc/source/algorithms/moead.ipynb index 5e30671c9..3ff78f113 100644 --- a/doc/source/algorithms/moead.ipynb +++ b/doc/source/algorithms/moead.ipynb @@ -60,9 +60,21 @@ "plotting.plot(res.F)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\n", + "\\begin{figure}\n", + " \\centering\n", + " {\\includegraphics[width=2.5in]{../resources/images/nsga2_survival.png}}\n", + " \\caption{Comparing Dq from different p-model}\n", + " \\end{figure}$$" + ] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -75,19 +87,12 @@ " if line == 'french':\n", " print(\"Salut tout le monde!\")\n", " else:\n", - " print(\"Hello world!\")\n", - "\n", - "@register_line_magic\n", - "def load_and_run(line):\n", - " if line == 'french':\n", - " print(\"Salut tout le monde!\")\n", - " else:\n", - " print(\"Hello world!\")" + " print(\"Hello world!\")\n" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -104,58 +109,16 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "from __future__ import print_function\n", - "from IPython.core.magic import Magics, magics_class, line_magic\n", - "\n", - "@magics_class\n", - "class MyMagics(Magics):\n", - "\n", - " @line_magic\n", - " def lmagic(self, line):\n", - " \"Replace current line with new output\"\n", - " raw_code = 'print(\"Hello world!\")'\n", - " \n", - " # Comment out this line if you actually want to run the code.\n", - " self.shell.set_next_input('# %lmagic\\n{}'.format(raw_code), replace=True)\n", - " \n", - " # Uncomment this line if you want to run the code instead.\n", - " # self.shell.run_cell(raw_code, store_history=False)\n", - "\n", - "ip = get_ipython()\n", - "ip.register_magics(MyMagics)" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Writing test.py\n" - ] - } - ], - "source": [ - "%%writefile test.py\n", - "print(\"Hello world!\")" - ] - }, - { - "cell_type": "code", - "execution_count": 43, + "execution_count": 112, "metadata": {}, "outputs": [], "source": [ "\n", "from __future__ import print_function\n", "from IPython.core.magic import Magics, magics_class, line_magic, cell_magic\n", + "from IPython.core import interactiveshell\n", + "\n", + "\n", "\n", "@magics_class\n", "class MyMagics(Magics):\n", @@ -164,14 +127,20 @@ " def load_and_run(self, fname):\n", " \n", " header = \"%load_and_run {}\".format(fname)\n", - " with open(fname.replace('\\'', '').replace(\"\\\"\", '')) as f:\n", + " path = fname.replace('\\'', '').replace(\"\\\"\", '')\n", + " \n", + " with open(path) as f:\n", " source = f.read()\n", - " \n", + "\n", " # Comment out this line if you actually want to run the code.\n", - " #self.shell.set_next_input(\"%s\\n\\n%s\" % (header, source), replace=True)\n", + " self.shell.set_next_input(\"%s\\n\\n%s\" % (header, source), replace=True)\n", " \n", + " print(\"FINISH UPDATE\")\n", + " import time\n", + " time.sleep(3)\n", + "\n", " # Run the actual code in this cell\n", - " #ret = self.shell.ex(source)\n", + " self.shell.run_cell(source)\n", " \n", " print(\"DONE\")\n", "\n", @@ -183,41 +152,18 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DONE\n", - "test\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%load_and_run \"../../../pymoo/usage/nsga2.py\"\n", "\n", "\n", - "from pymoo.optimize import minimize\n", "from pymoo.factory import get_algorithm\n", + "from pymoo.optimize import minimize\n", "from pymoo.util import plotting\n", "from pymop.factory import get_problem\n", "\n", - "\n", - "print(\"test\")\n", - "\n", - "\n", "# create the algorithm object\n", "method = get_algorithm(\"nsga2\",\n", " pop_size=100,\n", @@ -237,6 +183,46 @@ "plotting.plot(pf, res.F, labels=[\"Pareto-front\", \"F\"])\n" ] }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "from IPython.core.magic import Magics, magics_class, line_magic\n", + "\n", + "@magics_class\n", + "class MyMagics(Magics):\n", + "\n", + " @line_magic\n", + " def lmagic(self, line):\n", + " \n", + " raw_code = 'print(\"Hello world!\")'\n", + " \n", + " # Comment out this line if you actually want to run the code.\n", + " self.shell.set_next_input('%lmagic\\n{}'.format(raw_code), replace=True)\n", + " \n", + " # Uncomment this line if you want to run the code instead.\n", + " self.shell.run_cell(raw_code, store_history=False)\n", + " \n", + " #import time\n", + " #time.sleep(2)\n", + "\n", + "ip = get_ipython()\n", + "ip.register_magics(MyMagics)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%lmagic\n", + "print(\"Hello world!\")" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/doc/source/algorithms/nsga2.ipynb b/doc/source/algorithms/nsga2.ipynb index 452108401..97324e16c 100644 --- a/doc/source/algorithms/nsga2.ipynb +++ b/doc/source/algorithms/nsga2.ipynb @@ -67,17 +67,20 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "scrolled": true }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overwriting ../../../pymoo/usage/nsga2.py\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ diff --git a/doc/source/algorithms/nsga3.ipynb b/doc/source/algorithms/nsga3.ipynb index 6714c620b..d92d372a7 100644 --- a/doc/source/algorithms/nsga3.ipynb +++ b/doc/source/algorithms/nsga3.ipynb @@ -68,7 +68,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -93,18 +93,39 @@ " pop_size=92,\n", " ref_dirs=ref_dirs)\n", "\n", - "# create the test problem\n", - "problem = get_problem(\"dtlz1\")\n", - "\n", - "\n", "# execute the optimization\n", - "res = minimize(problem,\n", + "res = minimize(get_problem(\"dtlz1\"),\n", " method,\n", " termination=('n_gen', 600))\n", "\n", "plotting.plot(res.F, show=True)\n" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# execute the optimization\n", + "res = minimize(get_problem(\"dtlz1_-1\"),\n", + " method,\n", + " termination=('n_gen', 600))\n", + "\n", + "plotting.plot(res.F, show=True)" + ] + }, { "cell_type": "markdown", "metadata": { diff --git a/doc/source/algorithms/test.py b/doc/source/algorithms/test.py new file mode 100644 index 000000000..f1a18139c --- /dev/null +++ b/doc/source/algorithms/test.py @@ -0,0 +1 @@ +print("Hello world!") diff --git a/doc/source/components/crossover.ipynb b/doc/source/components/crossover.ipynb index f6d65a891..214d8a008 100644 --- a/doc/source/components/crossover.ipynb +++ b/doc/source/components/crossover.ipynb @@ -34,6 +34,29 @@ "Details about the crossover can be found in . Real values can be representated in a binary notation and then a the point crossovers can be performed. SBX simulated this operation by using a probability distribution *simulating* the binary crossover." ] }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + ".. _nb_crossover_point:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Point Crossover ('real_point', 'bin_point', 'int_point' )\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Text..." + ] + }, { "cell_type": "raw", "metadata": { @@ -47,7 +70,83 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Uniform Crossover ('real_uniform', 'bin_uniform')\n" + "### Uniform Crossover ('real_ux', 'bin_ux', 'int_ux')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Text..." + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + ".. _nb_crossover_half_uniform:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Half Uniform Crossover ('bin_hux', 'int_hux')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Text..." + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + ".. _nb_crossover_exponential:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exponential Crossover ('real_exp', 'bin_exp', 'int_exp')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Text..." + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + ".. _nb_crossover_differential:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Differential Crossover ('real_de')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Text..." ] }, { diff --git a/doc/source/components/sampling.ipynb b/doc/source/components/sampling.ipynb index 3727dabf5..1cb70b209 100644 --- a/doc/source/components/sampling.ipynb +++ b/doc/source/components/sampling.ipynb @@ -79,17 +79,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Latin Hypercube Sampling ('lhs')" + "### Latin Hypercube Sampling ('real_lhs')" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAGe9JREFUeJzt3X+s3XV9x/Hnm4LSbWgXWxNte23NCtrIsuIdsJBMEJTCH5So00KMujEb3TALbiQ1LszgH9aRuWDWTTtGEBMFZaa5CTVdNiAkxLKWlIl01tSKthczqlL+oQrV9/44p+H09px7vud7Pt/v58f39Uga7jn3m97Pl3v7/r7f78/7+73m7oiISFnOir0AEREJT8FdRKRACu4iIgVScBcRKZCCu4hIgRTcRUQKpOAuIlIgBXcRkQIpuIuIFOjsWF94+fLlvmbNmlhfXkQkS0888cTP3H3FuOOiBfc1a9awb9++WF9eRCRLZvbjKsepLSMiUiAFdxGRAim4i4gUSMFdRKRACu4iIgVScBcRKZCCu4hIgcYGdzO728yeM7Pvjfi8mdkXzeyQmX3XzC4Kv0wREZlElZuY7gH+Cbh3xOevAdb1/1wC/Ev/vyKSiJ3757lj90GePX6CNy5byq1XX8D1G1bGXpY0aGzm7u6PAr9Y5JBNwL3eswdYZmZvCLVAEZnOzv3zfOpbTzF//AQOzB8/wae+9RQ798/HXpo0KETPfSVwZOD10f57IpKAO3Yf5MTLvz7tvRMv/5o7dh+MtCJpQ6vPljGzLcAWgJmZmTa/tMhYpbYunj1+YqL3pQwhMvd5YPXA61X9987g7jvcfdbdZ1esGPtQM5HWlNy6eOOypRO9L2UIEdzngA/1p2YuBV5w958G+HtFWlNy6+LWqy9g6TlLTntv6TlLuPXqCyKtSNowti1jZl8HLgeWm9lR4O+AcwDc/UvALuBa4BDwIvCnTS1WpCklty5OtZaGtZxKbUVJheDu7jeM+bwDfxlsRSJjNBGQ3rhsKfNDAnkprYvrN6w84//RqVbUqYrlVCvq1PGSN92hKllpqjfexdZFya0oifibmETqWCwgTZNtLta6KFXJraiYUml1KbhLVpoMSMNaFyUrvRVVx7SBOaVWl9oykhWN9YXTxVbUYkK0/FJqdSm4S1YUkMK5fsNKPveeC1m5bCkGrFy2lM+958JOVS+DQgTmlFpdastIVob1xq94ywru2H2QW+5/shO98pC61opaTIjAnFKrS8FdsjMYkFLqccr0Ym5GhgjMt159wWk/jxCvslRbRrKWUo9TphP7ERAhWn4ptbqUucvUYmZbKfU4ZTpNjblWFWocNpVWl4K7TCV2WySlHqdMJ4ULdSqBOQS1ZWQqsdsimp4ph8Zcw1JwD2Dn/nku2/YQa7c+yGXbHiriMbFVxc62UupxynR0oQ5LbZkpxW5LxJZCW6SkUrrLuvgIiCYpuE8p9iZQbCmNfkn+SrxQxxo4UHCfUtNtiVQeQjSKsi2R0WJW9gruU2qyLZFLy6fEbEskhJiVfSc2VJvc8GxyEyj2JIqITCfmwEHxmXvT2W+TbYnYkygiKUu9ZQlxBw6KD+5tlEVNtSVSmEQRSVEuLcuYAwfFt2Vyzn419ysyXC4ty5j3YRSfueec/WoSRWS4nJK2WAMHxQf33OewNYkiXVK1j55z0taW4tsyuj1dUtXlx1YMM8kjf9WyHK/4zB2U/Up6ctkQbNMkww+LtSxzmKJpQyeCu0hquv7YimEm7aMPS9p00XxF8W0ZkRTltCHYlhCP/M1liqYNCu4iEejZ5Wca10evskehi+YrFNxFItCG4JkWG36outmqi+Yr1HOXYqW8saZ7GIYbNfxQdY8i99HnkBTcpUjTbKy1dVHQFFd1Vdstumi+olJwN7ONwJ3AEuAud9+24PMzwFeAZf1jtrr7rsBrFams7jSKpi3SNMlNS7po9oztuZvZEmA7cA2wHrjBzNYvOOxvgW+4+wZgM/DPoRcqMom6G2uhpy10o1IY2qOYXJUN1YuBQ+5+2N1fAu4DNi04xoHX9D9+LfBsuCWKTK7uxlrIaYtJ7riUxelO88lVacusBI4MvD4KXLLgmM8A/2FmnwB+G7gqyOpEaqq7sRbymSW6USkstVsmE2oU8gbgHndfBVwLfNXMzvi7zWyLme0zs33Hjh0L9KVFzlQ30wtZ/mvmuhq1rppRJXOfB1YPvF7Vf2/QTcBGAHf/jpmdCywHnhs8yN13ADsAZmdnveaaRSqpk+mFnLbQkwvH0wZ2c6oE973AOjNbSy+obwZuXHDMT4ArgXvM7K3AuYBSc8lSqPJfM9fjpdq6SvkeiarGBnd3P2lmNwO76Y053u3uT5vZ7cA+d58D/hr4VzO7hd7m6kfcXZm5dJpmrsdLsXVVSjVRac69P7O+a8F7tw18fAC4LOzSZFolZB+50ybg4lJsXaVaTUxKz5bJxKSbThrDkxykOL+eYjVRh4J7BuoEaj36VHKQ4vx6KQ8f07NlMlCnTCwl+5Dypda6KmUjXME9A3UCdahepvr20jWlbIQruGegTqAOkX2UMjUgceScGKRWTdShnnsG6mw6hehlqm8vdWlDPz5l7hmoWyZOm32oby91lTJOmLNOB/ecysYYZWKKM8iSByUG8XU2uKufPNqpi9788RMYvVuOT8lxakDap8Qgvs723NVPHm6wVwq9wG79z6Uwgyx5SPHmpK7pbOausnG4YRc9pxfYH9v6zqn//pxaYVJfKeOEOetscFfZOFyTFz21wtLT5MW2hHHCnHW2LaOycbgmb71WKywtGlcsW2eD+8I58GVLz+Hcc87ilvuf7PRvg2nyoqdWWFp0sS1bZ4M79AL8Y1vfyT9+4A/41cnf8PyLL3c+g2nyQU6lPJCpFLrYlq2zPfdBuuHidE31Skt5IFMptO8UVmrDAp3O3E9RBtOOFB/v2mXadwonxf0LZe4og2mTJijSoXHFcFKs/osJ7tOURGoXSFfpYhtGitV/EcF92vlpZTAiMo0Uq/8ignuIkkgZjIjUlWL1X0RwT7Ekku5IbUpC2pdi9V9EcJ+kJNI/RAlJj1SQU1Kr/osYhaw60pXiuJLkTXd5SqqKyNyrlkRNjiupIugmtQQlVUUEd6hWEjX1D1GleZ5CXJBTnJIQgULaMlU19WwTleb5CdWi012ekqpOBfem/iGqNM9PqAuyHqkgqSqmLVNFU+NKKs3zE/KCnNqUhGgPDDoW3KGZf4gp3sAgi9MFuVzaA+up1JYxs41mdtDMDpnZ1hHHvN/MDpjZ02b2tbDLbM/O/fNctu0h1m59sPIv7VBpnh/1ysulPbCesZm7mS0BtgPvAo4Ce81szt0PDByzDvgUcJm7P29mr29qwU0ad8VfrNRTaZ6XFO8olDC0B9ZTpS1zMXDI3Q8DmNl9wCbgwMAxHwW2u/vzAO7+XOiFtmHcFV+lXll0QS6TWm49VdoyK4EjA6+P9t8bdD5wvpk9ZmZ7zGxjqAW2abEr/qSlXp32johMTy23nlAbqmcD64DLgVXAo2Z2obsfHzzIzLYAWwBmZmYCfelwFrviT1LqaUNHJB613HqqBPd5YPXA61X99wYdBR5395eBH5nZD+gF+72DB7n7DmAHwOzsrNdddFMWm3q5Y/fByqVeir+VRXo0ItcNarlVa8vsBdaZ2VozexWwGZhbcMxOelk7ZracXpvmcMB1tmKxqZdJSj1t6KRJD46TLhmbubv7STO7GdgNLAHudvenzex2YJ+7z/U/924zOwD8GrjV3X/e5MKbMuqKP0mpV3dDR1lls1RRSZdU6rm7+y5g14L3bhv42IFP9v8Uq2qpV+emJvXpm6eKSrqkU8+WaUudm5p048V0qkwnNfXgOJEUde7xA22ZdENHWWV9VasePSZCukSZeyKUVdZXterRYyKkS5S5J0JZZX2TVD0akZueNv7zoOCeCN14UZ9uN29PjI1/XUzqUXBPiLLKelT1tKftcVJNkdWnnrtkT7309rS98a8psvqUuUsRVPW0o+0b9DRFVp8yd5FF6Omep6vzxMVpHvugKbL6FNxFRkjlWTQpXWDavkFPj++tT20ZkRFSeBZNihuKbd6gpymy+hTcRUZIod+bwgVmWtOOqmo/pR61ZURGaKLfO2mLJYULzLTUWolDwT2ClHqoMlrooFSnh1/ChqJGVeNQW6ZlKfZQZbjQ/d46LZZSbtBSa6V9Cu4ti91D1a3ckwkZlOq0WLShKHUpuLcsZg9VVUNcdTcWlfVKHeq5tyxmD1W3csd1xVtWYAvey7HFInlQcG9ZzMmBEiYvcrVz/zz//sQ8PvCeAe99u7JyaYbaMi2L2UPVo3HjGVY1OfDw94/FWZBMJMe9KgX3CGL1UEuZvMiRqqZ85bpXpbZMZG3OvGveOJ4S5tW7Kte9KmXuEcXICDR5EYeqpnzlWnUpc48o14xAJqeqKV+LVV0p322uzD2iXDMCqUdVU55GVV1XvGVF0r14Ze4RqQ8rkr5RVdfD3z+WdOWtzD0i9WFF2lV3pHFY1XXL/U8OPTaVylvBPaKUnhuS4xyvyCRCDzCkft+IgntkKfRhc53jFZlE6If2pV55K7jLRD/0yvAlV6EHGFKqvIepFNzNbCNwJ7AEuMvdt4047r3AA8Afuvu+YKuURlX9oVeGnyZdcKtpoo2SQuU9ythpGTNbAmwHrgHWAzeY2fohx50H/BXweOhFSrOqTu1oLj89dX67U1d17df9VRmFvBg45O6H3f0l4D5g05DjPgt8HvhlwPVJC6r+0GsuPz264FbXtRvJqrRlVgJHBl4fBS4ZPMDMLgJWu/uDZnbrqL/IzLYAWwBmZmYmX600omrvMPXpgC4adWGdP36Cy7Y9pBbNAim3UUKbekPVzM4CvgB8ZNyx7r4D2AEwOzvrYw6XFlX5oU99OqCLRl1wQXsiXVelLTMPrB54var/3innAW8DHjGzZ4BLgTkzmw21SEnDJGVtys/cKMmwltogtWi6q0rmvhdYZ2Zr6QX1zcCNpz7p7i8Ay0+9NrNHgL/RtEyZqmT4mqppz2BLbVQGrz2Rbhqbubv7SeBmYDfwv8A33P1pM7vdzK5reoGSH23ytev6DSt5bOs7WalnFcmASj13d98F7Frw3m0jjr18+mVJzlKdqil9HryLeyKlf0+noTtUJbgUp2q60CpK/Y7J0LrwPZ2GgrsEl2IGGfq5Iqnq0qhfV76ndRUb3FWuxZNiBplqq0jq0/d0cUUGd5Vr8aWWQabYKpLp6Hu6uCJ/E5OmNWShNp8rohn/dnTtWTGTKjJzV7mWr6baaW21ilQ1tifF9l9KigzuKtfy1HRgbKNVpE2+dqXW/ktJkW2ZFMs1lerjldBOU9UoqSgyc0+tXFOpXk0JgVFVo6SiyOAOaZVrXS7VJ+mhlxAYU5zxl24qsi2TmhIy0jom/S1BKbbTJtW1Xwgh6So2c09JCRlpHZNWLKm10+pKqWqU7lJwb0FXS/U6FYsCY550R3h6FNxbUEpGOqmuVixdo4GBNCm4t6SLGWlXK5ZSVM3GuzwwkDIFd2lMVyuWEkySjXd1YCB1Cu6ZS73X2cWKpQSTZONqv6VJo5AZm3TUUKSqSbLxEkZYS6Tgnqgqjyso4XZ9SdOorHvY+5rtT5PaMgmq2u9Ur1OaMulmuNpv6VHmnqCqGfkk2VXq9GC1tCgbz58y9wRVzchLGTXUnHQYoTfXlY3nTZl7gqpm5KVkV9o7mJ4212WhbDP31EcApzFJRl5CdqW9g+npRiJZKMvgXnoZ37WbfzQnPT1dIGWhLIN7F7KUEjLyqkrZO4hJF0hZKMueu7KUspSydxBTyBuJNLlUhiwzd2Up5elSpdKEUK280lueXZJlcFcZL3KmEBfILrQ8Q8hhoCPL4N61DUeRtqjlOV4u1U2l4G5mG4E7gSXAXe6+bcHnPwn8OXASOAb8mbv/OPBaT6MyfrQcsgpJk1qe4+VS3YzdUDWzJcB24BpgPXCDma1fcNh+YNbdfx94APj70AuVanQzi0xDT3gcL5fqpsq0zMXAIXc/7O4vAfcBmwYPcPeH3f3F/ss9wKqwy5SqdLdn80qeJtHk0ni5PNOpSltmJXBk4PVR4JJFjr8J+PawT5jZFmALwMzMTMUlyiRyySpylUu/dRpqeS4ul4GOoHPuZvZBYBa4Y9jn3X2Hu8+6++yKFStCfulOWSxzzCWryJUqI8mluqmSuc8Dqwder+q/dxozuwr4NPAOd/9VmOWlKeaG5bjMMZesIleqjATyqG6qBPe9wDozW0svqG8Gbhw8wMw2AF8GNrr7c8FXmZDYZfm4nfrSx0RjTwJpmkRyMTa4u/tJM7sZ2E1vFPJud3/azG4H9rn7HL02zO8A3zQzgJ+4+3UNrjua2GNQVTLHHLKKOmJfWCGffqtIpTl3d98F7Frw3m0DH18VeF3Jil2WdzlzjH1hBd1AJ/nI8g7VmGIH1y5njrEvrKeUWhlJWbJ8KmRMsW/yyGWnvgmaBJImlHrfgjL3CaVQlnc1c+xy1SLNSGEfpykK7jV0NbjGlsKFtUmxJ4G6KIV9nKYouEtWYl5Ymwy+JWeQKUtlH6cJ6rmLVND0A9l052scJe/jKLhLNDltZDUdfEvOIFMWe0CiSWrLSBS5tSGaDr6xR2y7quR9HAV3iSK3jaymg28bk0DasB2u1AEJtWUkitzaEE2X703fv6Bf4tI9ytxHUJbTrNzaEG2U701mkLlVSjI9BfchcusH5yjHG5JyLt9zq5RkemrLDKGxtOaNa0PkNEmTg5JH/mQ4Ze5DlJjlpNhmGpUJq3IKL8dKSaajzH2I0rKc3DbTVDmF1+UHznWVMvchSstycttMK7FySkHOewbTSrFybZqC+xCl3diQW7DMbZJG0tbVNp+C+wglZTm5BcvSKic5XdtZdG6VayjquXdAbs/PUH+4XDH2f3KrXENR5t4BObaZSqqc5BUxsujcKtdQFNw7QsGyHDlvDsbIorva5lNwF8lI7puDMbLoHCvXEBTcOy7nLLCLct8cjJVFd7FyVXDvsGmzQF0Y2pf75mBXs+gYFNw7bJosMPf2QK5K2BzsYhYdg0YhO2yaLFCPCIgjt7FWiUeZe4dNkwXm3h7IVcptDbXp0qLg3mHTbG6V0B7IVdttjSpBW2269Kgt02HT3Amq9kDzUnimfdU7StWmS0+lzN3MNgJ3AkuAu9x924LPvxq4F3g78HPgA+7+TNilShPqZoEptwdKkEomXHXTXW269IwN7ma2BNgOvAs4Cuw1szl3PzBw2E3A8+7+e2a2Gfg88IEmFizp0NRDc1KZZ68atNWmS0+VtszFwCF3P+zuLwH3AZsWHLMJ+Er/4weAK83Mwi1TpFtSyYSr/uIatenSUyW4rwSODLw+2n9v6DHufhJ4AXhdiAWKdFEqvw2satDWkzzT0+q0jJltAbYAzMzMtPmlRbKSysOuJtlbUZsuLVWC+zyweuD1qv57w445amZnA6+lt7F6GnffAewAmJ2d9ToLFumClDasFbTzVCW47wXWmdlaekF8M3DjgmPmgA8D3wHeBzzk7greIlNQUJVpjA3u7n7SzG4GdtMbhbzb3Z82s9uBfe4+B/wb8FUzOwT8gt4FQEREIqnUc3f3XcCuBe/dNvDxL4E/Cbs0ERGpS3eoiogUSMFdRKRACu4iIgVScBcRKZCCu4hIgRTcRUQKZLHuNTKzY8CPp/xrlgM/C7CcXHTtfKF756zzLVuI832Tu68Yd1C04B6Cme1z99nY62hL184XunfOOt+ytXm+asuIiBRIwV1EpEC5B/cdsRfQsq6dL3TvnHW+ZWvtfLPuuYuIyHC5Z+4iIjJEFsHdzDaa2UEzO2RmW4d8/tVmdn//84+b2Zr2VxlOhfP9pJkdMLPvmtl/mdmbYqwzlHHnO3Dce83MzSz76Yoq52xm7+9/n582s6+1vcaQKvxMz5jZw2a2v/9zfW2MdYZiZneb2XNm9r0Rnzcz+2L//8d3zeyi4Itw96T/0HuG/A+BNwOvAv4HWL/gmL8AvtT/eDNwf+x1N3y+VwC/1f/446Wfb/+484BHgT3AbOx1t/A9XgfsB363//r1sdfd8PnuAD7e/3g98EzsdU95zn8MXAR8b8TnrwW+DRhwKfB46DXkkLlfDBxy98Pu/hJwH7BpwTGbgK/0P34AuNLMrMU1hjT2fN39YXd/sf9yD71ffZirKt9fgM8Cnwd+2ebiGlLlnD8KbHf35wHc/bmW1xhSlfN14DX9j18LPNvi+oJz90fp/eKiUTYB93rPHmCZmb0h5BpyCO4rgSMDr4/23xt6jLufBF4AXtfK6sKrcr6DbqKXAeRq7Pn2S9bV7v5gmwtrUJXv8fnA+Wb2mJntMbONra0uvCrn+xngg2Z2lN4vBvpEO0uLZtJ/5xOr9JuYJE1m9kFgFnhH7LU0xczOAr4AfCTyUtp2Nr3WzOX0KrNHzexCdz8edVXNuQG4x93/wcz+iN6v7Xybu/8m9sJylUPmPg+sHni9qv/e0GPM7Gx6Zd3PW1ldeFXOFzO7Cvg0cJ27/6qltTVh3PmeB7wNeMTMnqHXn5zLfFO1yvf4KDDn7i+7+4+AH9AL9jmqcr43Ad8AcPfvAOfSew5LqSr9O59GDsF9L7DOzNaa2avobZjOLThmDvhw/+P3AQ95f9ciQ2PP18w2AF+mF9hz7sXCmPN19xfcfbm7r3H3NfT2GK5z931xlhtElZ/pnfSydsxsOb02zeE2FxlQlfP9CXAlgJm9lV5wP9bqKts1B3yoPzVzKfCCu/806FeIvatccef5WnqZyw+BT/ffu53eP3Lo/SB8EzgE/Dfw5thrbvh8/xP4P+DJ/p+52Gtu8nwXHPsImU/LVPweG7121AHgKWBz7DU3fL7rgcfoTdI8Cbw79pqnPN+vAz8FXqZXhd0EfAz42MD3d3v//8dTTfxM6w5VEZEC5dCWERGRCSm4i4gUSMFdRKRACu4iIgVScBcRKZCCu4hIgRTcRUQKpOAuIlKg/weKyebzhjRcggAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/doc/source/getting_started.ipynb b/doc/source/getting_started.ipynb index 6171f39cc..71606171d 100644 --- a/doc/source/getting_started.ipynb +++ b/doc/source/getting_started.ipynb @@ -20,9 +20,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This is a guide how to get started solving an example problem using *pymoo*. The problem definition is outsourced to another library called [pymop](https://github.com/msu-coinlab/pymop). There, various test problems (single- as well as multi-objective) are defined. In addition to the objective values gradients are available as well. For details we refer to the corresping [documentation](https://www.egr.msu.edu/coinlab/blankjul/pymop/).\n", - "\n", - "It is worth to mention that in *pymoo* all functions are supposed to be **minimized**. However, in case of maximization (as you might alread now), you can simply multiply the objective by -1 and then minimize it." + "This is a guide how to get started solving an example problem using *pymoo*. The problem definition is outsourced to another library called [pymop](https://github.com/msu-coinlab/pymop). There, various test problems (single- as well as multi-objective) are defined. In addition to the objective values gradients are available as well. For details we refer to the corresping [documentation](https://www.egr.msu.edu/coinlab/blankjul/pymop/)." ] }, { @@ -31,28 +29,63 @@ "source": [ "In this guide we are going to solve a bi-objective problem with the following definition:\n", "\n", - "$$ F = \\min_x \\; (f_1(x), f_2(x))$$\n", - "$$ G = (g_1(x))$$\n", "\n", + "$$\\begin{align*} \n", + "\\text{Minimize} \\;\\; & f_1(x) = (x_1^2 + x_2^2) \\\\ \n", + "\\text{Maxmize} \\;\\; & f_2(x) = -(x_1-1)^2 - x_2^2 \\\\\n", + "\\text{subject to} \\;\\; & g_1(x) = x_1^2 - x_1 \\geq - \\frac{3}{16} \\\\ \n", + "& -2 < x_1 < 2 \\\\\n", + "& -2 < x_2 < 2\n", + "\\end{align*}$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define a Problem\n", + "\n", + "In *pymoo* all functions are supposed to be **minimized**. However, in case of maximization (as you might alread now), you can simply multiply the objective by -1 and then minimize it. In our case, the second objective $f_2(x) = -(x_1-1)^2 - x_2^2$ to be maximized will become $f_2(x) = (x_1-1)^2 + x_2^2$ to be minimized.\n", "\n", - "$$f_1(x) = \\frac{1}{n} \\sum_i^n (x_i - 2)^2$$\n", - "$$f_2(x) = \\frac{1}{n} \\sum_i^n (x_i + 2)^2$$\n", + "Most of the algorithms in *pymoo* are able to handle constraints. A solution is defined to be feasible or infeasible as follows:\n", "\n", "\n", - "$$g_1(x) = (\\frac{1}{n} \\sum_i^n x_i^2)> 0.5$$\n", + "$$ \\begin{cases}\n", + "\\text{feasible,} \\quad \\quad \\sum_i^n \\langle g_i(x)\\rangle = 0\\\\\n", + "\\text{infeasbile,} \\quad \\quad \\quad \\text{otherwise}\\\\\n", + "\\end{cases}\n", + "$$\n", "\n", - "$$-5 < x_i < 5 \\quad \\forall i \\in (1, ... n) $$" + "$$\n", + "\\text{where} \\quad \\langle g_i(x)\\rangle =\n", + "\\begin{cases}\n", + "0, \\quad \\quad \\; \\text{if} \\; g_i(x) \\leq 0\\\\\n", + "g_i(x), \\quad \\text{otherwise}\\\\\n", + "\\end{cases}\n", + "$$\n", + "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Define a Problem\n", + "Therefore, a constraint counts as violated when $g_i(x)$ is *positive* for at least one constraint. For the purpose of convergence it is useful to make sure the positive value corresponds to the amount of infeasibility. If $g_i(x)$ returns a negative value no constraint violation does exist and the solution is considered as feasible. \n", + "In *pymoo* \n", + "Therefore, the constraint function $g_i(x)$ needs to be converted to a $\\leq 0$ constraint: $g_1(x) = -(x_1^2 - x_1 +\\frac{3}{16}) \\leq 0$.\n", + "\n", + "Finally, the problem to be defined is:\n", + "\n", + "$$\\begin{align*} \n", + "\\text{Minimize} \\;\\; & f_1(x) = (x_1^2 + x_2^2) \\\\ \n", + "\\text{Minimize} \\;\\; & f_2(x) = (x_1-1)^2 + x_2^2 \\\\\n", + "\\text{subject to} \\;\\; & g_1(x) = - (x_1^2 - x_1 + \\frac{3}{16}) \\leq 0\\\\ \n", + "& -2 < x_1 < 2 \\\\\n", + "& -2 < x_2 < 2\n", + "\\end{align*}$$\n", "\n", - "First, the problem needs to be defined. One way to do that is by defining an object which inherits from the Problem class. The instructor needs to set the number of variables *n_var*, the number of objectives *n_obj*, the number of constraints *n_constr* and the variable boundaries (if applicable to the variable type).\n", "\n", - "Moverover, the *_evaluate* function needs to be overwritten. The input *x* is a 2d-array, where each row represents an entry to be evaluated." + "The implementation of this problem is the follows: First, the problem class needs to be defined. One way to do that is by defining an object which inherits from the Problem class. The instructor needs to set the number of variables *n_var*, the number of objectives *n_obj*, the number of constraints *n_constr* and the variable boundaries (if applicable to the variable type). Moverover, the *\\_evaluate* function needs to be overwritten. The input *x* is a 2d-array, where each row represents an entry to be evaluated." ] }, { @@ -66,18 +99,17 @@ "\n", "class MyProblem(Problem):\n", "\n", - " def __init__(self, n_var):\n", - " super().__init__(n_var=n_var, n_obj=2, n_constr=1, \n", - " xl=np.full(n_var, -5), xu=np.full(n_var, 5))\n", + " def __init__(self):\n", + " super().__init__(n_var=2, n_obj=2, n_constr=1, \n", + " xl=np.array([-2,-2]), xu=np.array([2,2]))\n", "\n", " def _evaluate(self, x, out, *args, **kwargs):\n", - " f1 = np.sqrt(np.sum(np.square(x - 2), axis=1) / self.n_var)\n", - " f2 = np.sqrt(np.sum(np.square(x + 2), axis=1) / self.n_var)\n", + " f1 = x[:,0]**2 + x[:,1]**2\n", + " f2 = (x[:,0]-1)**2 + x[:,1]**2\n", " out[\"F\"] = np.column_stack([f1, f2])\n", - " #out[\"G\"] = np.sum(np.square(x), axis=1) / self.n_var - 0.5\n", - " out[\"G\"] = np.full(len(x), 0)\n", + " out[\"G\"] = - (x[:,0]**2 - x[:,0] + 3/16)\n", " \n", - "problem = MyProblem(10)\n" + "problem = MyProblem()\n" ] }, { @@ -93,7 +125,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Second, an algorithm to solve the problem need to be defined. Depending on the optimization problem different algorithms can be used to optimize the problem. In our example, a bi-objective problem with one constraint can solved by using the well-known [NSGA-II](/algorithms/nsga2.html)." + "Second, an algorithm to solve the problem need to be defined. Depending on the optimization problem different algorithms can be used to optimize the problem. Choosing an apropriate algorithm with suitable hyperparameters is a challange itself.\n", + "In our example, a bi-objective problem with one constraint can solved by using the well-known [NSGA-II](/algorithms/nsga2.html)." ] }, { @@ -104,9 +137,7 @@ "source": [ "from pymoo.factory import get_algorithm\n", "\n", - "method = get_algorithm(\"nsga2\",\n", - " pop_size=100,\n", - " elimate_duplicates=True)\n" + "method = get_algorithm(\"nsga2\", pop_size=20)" ] }, { @@ -125,12 +156,38 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Design Space\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Objective Space\n" + ] + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -141,16 +198,24 @@ ], "source": [ "from pymoo.optimize import minimize\n", + "import matplotlib.pyplot as plt\n", "from pymoo.util import plotting\n", "\n", "res = minimize(problem,\n", " method,\n", - " termination=('n_gen', 150),\n", + " termination=('n_gen', 20),\n", " seed=1,\n", " save_history=True,\n", " disp=False)\n", "\n", - "plotting.plot(res.F)\n" + "print(\"\\nDesign Space\")\n", + "plotting.plot(res.X, show=False, no_fill=True)\n", + "plt.ylim(-2, 2)\n", + "plt.xlim(-2, 2)\n", + "plt.show()\n", + "\n", + "print(\"\\nObjective Space\")\n", + "plotting.plot(res.F, no_fill=True)\n" ] }, { @@ -169,7 +234,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -182,13 +247,23 @@ "from pymoo.indicators.hv import Hypervolume\n", "\n", "# create the performance indicator object with reference point (4,4)\n", - "_hv = Hypervolume(ref_point=np.array([4,4]))\n", + "_hv = Hypervolume(ref_point=np.array([1.0, 1.0]))\n", + "\n", + "# collect the population in each generation\n", + "pop_each_gen = [a.pop for a in res.history]\n", + "\n", + "# receive the population in each generation\n", + "obj_and_feasible_each_gen = [pop[pop.get(\"feasible\")[:,0]].get(\"F\") for pop in pop_each_gen]\n", "\n", "# calculate for each generation the HV metric\n", - "hv = [_hv.calc(a.pop.get(\"F\")) for a in res.history]\n", + "hv = [_hv.calc(f) for f in obj_and_feasible_each_gen]\n", "\n", "# visualze the convergence curve \n", - "plotting.plot(np.column_stack([np.arange(len(hv)), hv]))\n" + "plt.plot(np.arange(len(hv)), hv, '-o')\n", + "plt.title(\"Convergence\")\n", + "plt.xlabel(\"Generation\")\n", + "plt.ylabel(\"Hypervolume\")\n", + "plt.show()\n" ] } ], diff --git a/doc/source/index.rst b/doc/source/index.rst index 2c8a8795c..54bbea667 100755 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -3,7 +3,6 @@ pymoo ============================================================================== - The framework is available on PyPi and can be installed with: :: @@ -15,6 +14,18 @@ Please note, that the dependencies used in the command above must be fulfilled b and can, therefore, not be ensured to be installed prior compilation with the setup script. More details about the installation can be found :ref:`here `. +.. raw:: html + + + + + +|vspace| + +.. |vspace| raw:: latex + + \vspace{5mm} + This framework to be used for **any** profit-making purposes, please contact `Julian Blank `_. We are currently working on a paper about *pymoo*. @@ -47,7 +58,9 @@ Features **Sampling:** :ref:`Random `, :ref:`Latin Hypercube Sampling `, -**Crossover:** :ref:`Simulated Binary `, :ref:`Uniform `, +**Crossover:** :ref:`Simulated Binary Crossover`, :ref:`Uniform Crossover`, +:ref:`Half Uniform Crossover`, :ref:`Differential Crossover`, +:ref:`Point Crossover`, :ref:`Exponential Crossover` **Mutation:** :ref:`Polynomial Mutation `, :ref:`Bitflip Mutation` diff --git a/doc/source/index_top.html b/doc/source/index_top.html new file mode 100644 index 000000000..e69de29bb diff --git a/pymoo/algorithms/nsga3.py b/pymoo/algorithms/nsga3.py index 49d2e01f9..285c639be 100644 --- a/pymoo/algorithms/nsga3.py +++ b/pymoo/algorithms/nsga3.py @@ -46,6 +46,10 @@ def _solve(self, problem, termination): return super()._solve(problem, termination) + def _finalize(self): + super()._finalize() + self.opt = self.pop[self.pop.get("is_closest")] + def comp_by_cv_then_random(pop, P, **kwargs): S = np.full(P.shape[0], np.nan) @@ -223,7 +227,7 @@ def niching(pop, n_remaining, niche_count, niche_of_individuals, dist_to_niche): # add the selected individual to the survivors mask[next_ind] = False - pop[next_ind].data["closest"] = is_closest + pop[next_ind].data["is_closest"] = is_closest survivors.append(int(next_ind)) # increase the corresponding niche count diff --git a/pymoo/algorithms/so_de.py b/pymoo/algorithms/so_de.py index 1c31c58ad..cb0a2bb8d 100755 --- a/pymoo/algorithms/so_de.py +++ b/pymoo/algorithms/so_de.py @@ -1,14 +1,15 @@ import numpy as np -from pymoo.docs import parse_doc_string -from pymoo.rand import random - from pymoo.algorithms.genetic_algorithm import GeneticAlgorithm +from pymoo.docs import parse_doc_string from pymoo.operators.crossover.differental_evolution_crossover import DifferentialEvolutionCrossover +from pymoo.operators.crossover.exponential_crossover import ExponentialCrossover +from pymoo.operators.crossover.uniform_crossover import UniformCrossover from pymoo.operators.default_operators import set_if_none -from pymoo.operators.mutation.differential_evoluation_mutation import DifferentialEvolutionMutation +from pymoo.operators.repair.bounds_back_repair import BoundsBackRepair from pymoo.operators.sampling.latin_hypercube_sampling import LatinHypercubeSampling from pymoo.operators.selection.random_selection import RandomSelection +from pymoo.rand import random from pymoo.util.display import disp_single_objective from pymoo.util.misc import parameter_less @@ -20,10 +21,9 @@ class DifferentialEvolution(GeneticAlgorithm): def __init__(self, - variant="DE/rand+best/1/bin", - CR=0.5, - F=0.75, - n_replace=None, + variant, + CR, + F, **kwargs): _, self.var_selection, self.var_n, self.var_mutation, = variant.split("/") @@ -32,11 +32,15 @@ def __init__(self, set_if_none(kwargs, 'sampling', LatinHypercubeSampling(criterion="maxmin", iterations=100)) set_if_none(kwargs, 'crossover', DifferentialEvolutionCrossover(weight=F)) set_if_none(kwargs, 'selection', RandomSelection()) - set_if_none(kwargs, 'mutation', DifferentialEvolutionMutation(self.var_mutation, CR)) + + if self.var_mutation == "exp": + set_if_none(kwargs, 'mutation', ExponentialCrossover(CR)) + elif self.var_mutation == "bin": + set_if_none(kwargs, 'mutation', UniformCrossover(CR)) + set_if_none(kwargs, 'survival', None) super().__init__(**kwargs) - self.n_replace = n_replace self.func_display_attrs = disp_single_objective def _next(self, pop): @@ -63,20 +67,16 @@ def _next(self, pop): else: raise Exception("Unknown selection: %s" % self.var_selection) - self.off = self.crossover.do(self.problem, pop, P) - - # do the mutation by using the offsprings - self.off = self.mutation.do(self.problem, self.off, algorithm=self) + # do the first crossover which is the actual DE operation + self.off = self.crossover.do(self.problem, pop, P, algorithm=self) - # bring back to bounds if violated through crossover - bounce back strategy - X = self.off.get("X") - xl = np.repeat(self.problem.xl[None, :], X.shape[0], axis=0) - xu = np.repeat(self.problem.xu[None, :], X.shape[0], axis=0) + # then do the mutation (which is actually ) + _pop = self.off.new().merge(self.pop).merge(self.off) + _P = np.column_stack([np.arange(len(pop)), np.arange(len(pop)) + len(pop)]) + self.off = self.mutation.do(self.problem, _pop, _P, algorithm=self)[:len(self.pop)] - # otherwise bounds back into the feasible space - X[X < xl] = (xl + (xl - X))[X < xl] - X[X > xu] = (xu - (X - xu))[X > xu] - self.off.set("X", X) + # bounds back if something is out of bounds + self.off = BoundsBackRepair().do(self.off, self.problem) # evaluate the results self.evaluator.eval(self.problem, self.off, algorithm=self) @@ -87,10 +87,6 @@ def _next(self, pop): # find the individuals which are indeed better is_better = np.where((_F <= F)[:, 0])[0] - # truncate the replacements if desired - if self.n_replace is not None and self.n_replace < len(is_better): - is_better = is_better[random.perm(len(is_better))[:self.n_replace]] - # replace the individuals in the population pop[is_better] = self.off[is_better] @@ -114,7 +110,9 @@ def de( Parameters ---------- pop_size : {pop_size} + sampling : {sampling} + variant : str CR : float @@ -130,12 +128,13 @@ def de( _, _selection, _n, _mutation, = variant.split("/") - return DifferentialEvolution(pop_size=pop_size, - sampling=sampling, - selection=RandomSelection(), - crossover=DifferentialEvolutionCrossover(weight=F), - mutation=DifferentialEvolutionMutation(_mutation, CR), - **kwargs) + return DifferentialEvolution( + variant, + CR, + F, + pop_size=pop_size, + sampling=sampling, + **kwargs) parse_doc_string(de) diff --git a/pymoo/experimental/test.py b/pymoo/experimental/test.py new file mode 100644 index 000000000..a9c222237 --- /dev/null +++ b/pymoo/experimental/test.py @@ -0,0 +1,42 @@ +import numpy as np +from pymop.factory import get_problem + +from pymop.problem import Problem + + +class MyProblem(Problem): + + def __init__(self): + super().__init__(n_var=2, n_obj=2, n_constr=1, + xl=np.array([-2, -2]), xu=np.array([2, 2])) + + def _evaluate(self, x, out, *args, **kwargs): + f1 = x[:, 0] ** 2 + x[:, 1] ** 2 + f2 = (x[:, 0] - 1) ** 2 + x[:, 1] ** 2 + out["F"] = np.column_stack([f1, f2]) + out["G"] = np.full(len(x), 0) + + +problem = MyProblem() + + +problem = get_problem("zdt1") +from pymoo.factory import get_algorithm + +method = get_algorithm("nsga2", + pop_size=20, + elimate_duplicates=False) + + +from pymoo.optimize import minimize +from pymoo.util import plotting + +res = minimize(problem, + method, + termination=('n_gen', 1000), + seed=1, + save_history=True, + disp=False) + +plotting.plot(res.F) + diff --git a/pymoo/factory.py b/pymoo/factory.py index 89821162b..7318f5d4a 100644 --- a/pymoo/factory.py +++ b/pymoo/factory.py @@ -5,6 +5,8 @@ """ +import re + import numpy as np from pymoo.algorithms.moead import moead @@ -17,6 +19,9 @@ from pymoo.algorithms.unsga3 import unsga3 from pymoo.docs import parse_doc_string from pymoo.operators.crossover.differental_evolution_crossover import DifferentialEvolutionCrossover +from pymoo.operators.crossover.exponential_crossover import ExponentialCrossover +from pymoo.operators.crossover.half_uniform_crossover import HalfUniformCrossover +from pymoo.operators.crossover.point_crossover import PointCrossover from pymoo.operators.crossover.simulated_binary_crossover import SimulatedBinaryCrossover from pymoo.operators.crossover.uniform_crossover import UniformCrossover from pymoo.operators.mutation.bitflip_mutation import BinaryBitflipMutation @@ -32,11 +37,11 @@ # ========================================================================================================= -def get_from_list(l, name, kwargs): - +def get_from_list(l, name, args, kwargs): i = None for k, e in enumerate(l): - if e[0] == name: + + if re.match(e[0], name): i = k break @@ -53,7 +58,7 @@ def get_from_list(l, name, kwargs): default_kwargs[key] = val kwargs = default_kwargs - return clazz(**kwargs) + return clazz(*args, **kwargs) else: raise Exception("Object '%s' for not found in %s" % (name, [e[0] for e in l])) @@ -100,8 +105,8 @@ def dummy(name, kwargs): ] -def get_algorithm(name, d={}, **kwargs): - return get_from_list(ALGORITHMS, name, {**d, **kwargs}) +def get_algorithm(name, *args, d={}, **kwargs): + return get_from_list(ALGORITHMS, name, args, {**d, **kwargs}) parse_doc_string(dummy, get_algorithm, {"type": "algorithm", @@ -121,8 +126,8 @@ def get_algorithm(name, d={}, **kwargs): ] -def get_sampling(name, d={}, **kwargs): - return get_from_list(SAMPLING, name, {**d, **kwargs}) +def get_sampling(name, *args, d={}, **kwargs): + return get_from_list(SAMPLING, name, args, {**d, **kwargs}) parse_doc_string(dummy, get_sampling, {"type": "sampling", @@ -140,8 +145,8 @@ def get_sampling(name, d={}, **kwargs): ] -def get_selection(name, d={}, **kwargs): - return get_from_list(SELECTION, name, {**d, **kwargs}) +def get_selection(name, *args, d={}, **kwargs): + return get_from_list(SELECTION, name, args,{**d, **kwargs}) parse_doc_string(dummy, get_selection, {"type": "selection", @@ -156,13 +161,17 @@ def get_selection(name, d={}, **kwargs): CROSSOVER = [ ("real_sbx", SimulatedBinaryCrossover), ("real_de", DifferentialEvolutionCrossover), - ("real_uniform", UniformCrossover, {'var_type': np.float}), - ("bin_uniform", UniformCrossover, {'var_type': np.bool}) + ("(real|bin|int)_ux", UniformCrossover), + ("(bin|int)_hux", HalfUniformCrossover), + ("(real|bin|int)_exp", ExponentialCrossover), + ("(real|bin|int)_one_point", PointCrossover, {'n_points': 1}), + ("(real|bin|int)_two_point", PointCrossover, {'n_points': 2}), + ("(real|bin|int)_k_point", PointCrossover) ] -def get_crossover(name, d={}, **kwargs): - return get_from_list(CROSSOVER, name, {**d, **kwargs}) +def get_crossover(name, *args, d={}, **kwargs): + return get_from_list(CROSSOVER, name, args,{**d, **kwargs}) parse_doc_string(dummy, get_crossover, {"type": "crossover", @@ -180,8 +189,8 @@ def get_crossover(name, d={}, **kwargs): ] -def get_mutation(name, d={}, **kwargs): - return get_from_list(MUTATION, name, {**d, **kwargs}) +def get_mutation(name, *args, d={}, **kwargs): + return get_from_list(MUTATION, name, args,{**d, **kwargs}) parse_doc_string(dummy, get_mutation, {"type": "mutation", diff --git a/pymoo/model/repair.py b/pymoo/model/repair.py new file mode 100644 index 000000000..5d446a825 --- /dev/null +++ b/pymoo/model/repair.py @@ -0,0 +1,14 @@ +from abc import abstractmethod + + +class Repair: + """ + This class is allows to repair individuals after crossover if necessary. + """ + + def do(self, pop, problem, **kwargs): + return self._do(pop, problem, **kwargs) + + @abstractmethod + def _do(self, pop, problem, **kwargs): + pass diff --git a/pymoo/model/sampling.py b/pymoo/model/sampling.py index ddba461fe..3ebf29f39 100644 --- a/pymoo/model/sampling.py +++ b/pymoo/model/sampling.py @@ -1,10 +1,5 @@ from abc import abstractmethod -import numpy as np - -from pymoo.model.population import Population -from pymop.problem import Problem - class Sampling: """ diff --git a/pymoo/operators/crossover/exponential_crossover.py b/pymoo/operators/crossover/exponential_crossover.py new file mode 100644 index 000000000..8f978b85c --- /dev/null +++ b/pymoo/operators/crossover/exponential_crossover.py @@ -0,0 +1,46 @@ +import numpy as np + +from pymoo.model.crossover import Crossover +from pymoo.operators.crossover.util import crossver_by_mask +from pymoo.rand import random + + +class ExponentialCrossover(Crossover): + + def __init__(self, prob): + super().__init__(2, 2) + self.prob = prob + + def _do(self, problem, pop, parents, **kwargs): + + # get the X of parents and count the matings + X = pop.get("X")[parents.T] + n_matings = parents.shape[0] + + # the mask do to the crossover + M = np.full((len(pop), problem.n_var), False) + + # start point of crossover + n = random.randint(0, problem.n_var, size=len(pop)) + + # the probabilities are calculated beforehand + r = np.random((n_matings, problem.n_var)) < self.prob + + # create for each individual the crossover range + for i in range(n_matings): + + # the actual index where we start + start = n[i] + for j in range(problem.n_var): + + # the current position where we are pointing to + current = (start + j) % problem.n_var + + # replace only if random value keeps being smaller than CR + if r[i, current]: + M[i, current] = True + else: + break + + _X = crossver_by_mask(X, M) + return pop.new("X", _X) diff --git a/pymoo/operators/crossover/half_uniform_crossover.py b/pymoo/operators/crossover/half_uniform_crossover.py new file mode 100644 index 000000000..5c084e938 --- /dev/null +++ b/pymoo/operators/crossover/half_uniform_crossover.py @@ -0,0 +1,41 @@ +from pymoo.model.crossover import Crossover +from pymoo.operators.crossover.util import crossver_by_mask + +import numpy as np + +from pymoo.rand import random + + +class HalfUniformCrossover(Crossover): + + def __init__(self, prob=0.5): + super().__init__(2, 2) + self.prob = prob + + def _do(self, problem, pop, parents, **kwargs): + + # get the X of parents and count the matings + X = pop.get("X")[parents.T] + _, n_matings, n_var = X.shape + + # the mask do to the crossover + M = np.full((n_matings, n_var), False) + + not_equal = X[0] != X[1] + + # create for each individual the crossover range + for i in range(n_matings): + + I = np.where(not_equal[i])[0] + + if len(I) == 0: + pass + elif len(I) == 1: + M[i, I[0]] = True + else: + n = int(len(I) / 2) + _I = I[random.perm(len(I))[:n]] + M[i, _I] = True + + _X = crossver_by_mask(X, M) + return pop.new("X", _X) diff --git a/pymoo/operators/crossover/point_crossover.py b/pymoo/operators/crossover/point_crossover.py new file mode 100644 index 000000000..899ef63a1 --- /dev/null +++ b/pymoo/operators/crossover/point_crossover.py @@ -0,0 +1,38 @@ +import numpy as np + +from pymoo.model.crossover import Crossover +from pymoo.operators.crossover.util import crossver_by_mask +from pymoo.rand import random + + +class PointCrossover(Crossover): + + def __init__(self, n_points): + super().__init__(2, 2) + self.n_points = n_points + + def _do(self, problem, pop, parents, **kwargs): + + # get the X of parents and count the matings + X = pop.get("X")[parents.T] + _, n_matings, n_var = X.shape + + # start point of crossover + r = np.row_stack([random.perm(n_var-1) + 1 for _ in range(n_matings)])[:, :self.n_points] + r.sort(axis=1) + r = np.column_stack([r, np.full(n_matings, n_var)]) + + # the mask do to the crossover + M = np.full((n_matings, n_var), False) + + # create for each individual the crossover range + for i in range(n_matings): + + j = 0 + while j < r.shape[1] - 1: + a, b = r[i, j], r[i, j + 1] + M[i, a:b] = True + j += 2 + + _X = crossver_by_mask(X, M) + return pop.new("X", _X) diff --git a/pymoo/operators/crossover/uniform_crossover.py b/pymoo/operators/crossover/uniform_crossover.py index c18926b11..944811098 100644 --- a/pymoo/operators/crossover/uniform_crossover.py +++ b/pymoo/operators/crossover/uniform_crossover.py @@ -1,33 +1,22 @@ -import numpy as np - from pymoo.model.crossover import Crossover +from pymoo.operators.crossover.util import crossver_by_mask from pymoo.rand import random class UniformCrossover(Crossover): - def __init__(self, var_type=np.float): + def __init__(self, prob=0.5): super().__init__(2, 2) - self.var_type = var_type + self.prob = prob def _do(self, problem, pop, parents, **kwargs): - # number of parents - n_matings = parents.shape[0] - off = np.full((n_matings * self.n_offsprings, problem.n_var), np.inf, dtype=self.var_type) - + # get the X of parents and count the matings X = pop.get("X")[parents.T] + n_matings = parents.shape[0] # random matrix to do the crossover - M = random.random((n_matings, problem.n_var)) - smaller, larger = M < 0.5, M > 0.5 - - # first possibility where first parent 0 is copied - off[:n_matings][smaller] = X[0, :, :][smaller] - off[:n_matings][larger] = X[1, :, :][larger] - - # now flip the order of parents with the same random array and write the second half of off - off[n_matings:][smaller] = X[1, :, :][smaller] - off[n_matings:][larger] = X[0, :, :][larger] + M = random.random((n_matings, problem.n_var)) < self.prob - return pop.new("X", off.astype(self.var_type)) + _X = crossver_by_mask(X, M) + return pop.new("X", _X) diff --git a/pymoo/operators/crossover/util.py b/pymoo/operators/crossover/util.py new file mode 100644 index 000000000..0ee8800e0 --- /dev/null +++ b/pymoo/operators/crossover/util.py @@ -0,0 +1,17 @@ +import numpy as np + + +def crossver_by_mask(X, M): + # convert input to output by flatting along the first axis + _X = X.reshape(-1, X.shape[-1]) + + # invert the whole logical array + _M = np.logical_not(M) + + # first the second parent donors the to first + _X[:len(M)][M] = X[1][M] + + # now the first parent donors to the second + _X[len(M):][_M] = X[0][_M] + + return _X diff --git a/pymoo/operators/repair/bounds_back_repair.py b/pymoo/operators/repair/bounds_back_repair.py new file mode 100644 index 000000000..b03146b27 --- /dev/null +++ b/pymoo/operators/repair/bounds_back_repair.py @@ -0,0 +1,19 @@ +from pymoo.model.repair import Repair + +import numpy as np + + +class BoundsBackRepair(Repair): + + def _do(self, pop, problem, **kwargs): + # bring back to bounds if violated through crossover - bounce back strategy + X = pop.get("X") + xl = np.repeat(problem.xl[None, :], X.shape[0], axis=0) + xu = np.repeat(problem.xu[None, :], X.shape[0], axis=0) + + # otherwise bounds back into the feasible space + _range = xu - xl + X[X < xl] = (xl + np.mod((xl - X), _range))[X < xl] + X[X > xu] = (xu - np.mod((X - xu), _range))[X > xu] + + return pop.new("X", X) diff --git a/pymoo/operators/sampling/bin_random_sampling.py b/pymoo/operators/sampling/bin_random_sampling.py deleted file mode 100644 index 3ea86ea69..000000000 --- a/pymoo/operators/sampling/bin_random_sampling.py +++ /dev/null @@ -1,19 +0,0 @@ -import numpy as np - -from pymoo.model.sampling import Sampling -from pymoo.rand import random - - -class BinaryRandomSampling(Sampling): - """ - Randomly sample points in the real space by considering the lower and upper bounds of the problem. - """ - - def sample(self, problem, pop, n_samples, **kwargs): - - m = problem.n_var - - val = random.random((n_samples, m)) - val = (val < 0.5).astype(np.bool) - - return pop.new("X", val) diff --git a/pymoo/usage/de.py b/pymoo/usage/de.py index 51573e9cb..8242a1574 100644 --- a/pymoo/usage/de.py +++ b/pymoo/usage/de.py @@ -1,18 +1,17 @@ from pymoo.optimize import minimize from pymop.factory import get_problem +from pymoo.factory import get_algorithm -problem = get_problem("rastrigin", n_var=10) +problem = get_problem("rastrigin", n_var=3) res = minimize(problem, - method='de', - method_args={ - 'variant': "DE/best/1/bin", - 'CR': 2, - 'F': 0.75, - 'pop_size': 200 - }, - termination=('n_gen', 1000), - disp=True) + method=get_algorithm('de', + variant="DE/rand/1/bin", + pop_size=100, + CR=0.7, + F=2), + termination=('n_gen', 200), + seed=1, + disp=False) -print("Best solution found: %s" % res.X) -print("Function value: %s" % res.F) +print("Best solution found: \nX = %s\nF = %s" % (res.X, res.F)) diff --git a/pymoo/usage/ga.py b/pymoo/usage/ga.py index 0d695dbab..4b0c71ebc 100644 --- a/pymoo/usage/ga.py +++ b/pymoo/usage/ga.py @@ -1,17 +1,18 @@ +from pymoo.algorithms.so_genetic_algorithm import ga +from pymoo.factory import get_crossover from pymoo.optimize import minimize from pymop.factory import get_problem problem = get_problem("g01") +method = ga(pop_size=100, + crossover=get_crossover("real_two_point_crossover"), + eliminate_duplicates=False) + res = minimize(problem, - method='ga', - method_args={ - 'pop_size': 100, - 'eliminate_duplicates': False, - }, + method, termination=('n_gen', 50), disp=True) print("Best solution found: %s" % res.X) print("Function value: %s" % res.F) - diff --git a/pymoo/usage/nsga3.py b/pymoo/usage/nsga3.py index 88a59d708..4005d1a64 100644 --- a/pymoo/usage/nsga3.py +++ b/pymoo/usage/nsga3.py @@ -2,26 +2,19 @@ from pymoo.util import plotting from pymoo.util.reference_direction import UniformReferenceDirectionFactory from pymop.factory import get_problem - -problem = get_problem("dtlz1") +from pymoo.factory import get_algorithm # create the reference directions to be used for the optimization ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do() -# create the pareto front for the given reference lines -pf = problem.pareto_front(ref_dirs) +# create the algorithm object +method = get_algorithm("nsga3", + pop_size=92, + ref_dirs=ref_dirs) -res = minimize(problem, - method='nsga3', - method_args={ - 'pop_size': 92, - 'ref_dirs': ref_dirs - }, - termination=('n_gen', 600), - pf=pf, - seed=4, - disp=True) +# execute the optimization +res = minimize(get_problem("dtlz1"), + method, + termination=('n_gen', 200)) -# if desired we can filter out the solutions that are not close to ref_dirs -closest_to_ref_dir = res.opt.get("closest") -plotting.plot(res.F[closest_to_ref_dir, :], show=True) +plotting.plot(res.F, show=True) diff --git a/pymoo/usage/problem_binary.py b/pymoo/usage/problem_binary.py index 93e300bf1..bc5a14579 100644 --- a/pymoo/usage/problem_binary.py +++ b/pymoo/usage/problem_binary.py @@ -8,9 +8,9 @@ problem.type_var = np.bool method = get_algorithm("ga", - pop_size=20, + pop_size=200, sampling=get_sampling("bin_random"), - crossover=get_crossover("bin_uniform"), + crossover=get_crossover("bin_hux"), mutation=get_mutation("bin_bitflip"), elimate_duplicates=True) diff --git a/pymoo/util/plotting.py b/pymoo/util/plotting.py index 775b99a5a..36c848d24 100644 --- a/pymoo/util/plotting.py +++ b/pymoo/util/plotting.py @@ -3,7 +3,7 @@ from matplotlib import animation -def plot(*args, show=True, labels=None, **kwargs): +def plot(*args, show=True, labels=None, no_fill=False,**kwargs): F = args[0] if F.ndim == 1: @@ -13,7 +13,7 @@ def plot(*args, show=True, labels=None, **kwargs): n_dim = F.shape[1] if n_dim == 2: - plot_2d(*args, labels=labels, **kwargs) + plot_2d(*args, labels=labels, no_fill=no_fill, **kwargs) elif n_dim == 3: plot_3d(*args, labels=labels, **kwargs) else: @@ -40,13 +40,22 @@ def plot_3d(*args, labels=None): -def plot_2d(*args, labels=None): +def plot_2d(*args, labels=None, no_fill=False): + + if no_fill: + kwargs = dict( + s=20, + facecolors='none', + edgecolors='r' + ) + else: + kwargs = {} for i, F in enumerate(args): if labels: - plt.scatter(F[:, 0], F[:, 1], label=labels[i]) + plt.scatter(F[:, 0], F[:, 1], label=labels[i], **kwargs) else: - plt.scatter(F[:, 0], F[:, 1]) + plt.scatter(F[:, 0], F[:, 1], **kwargs) def animate(path_to_file, H, problem=None, func_iter=None, plot_min=None, plot_max=None): diff --git a/tests/test_suite.py b/tests/test_suite.py index 0f5817291..31b9b6c7c 100644 --- a/tests/test_suite.py +++ b/tests/test_suite.py @@ -9,7 +9,7 @@ testmodules = [ 'tests.test_nsga2', - 'pymoo.usage.test_usage' + #'pymoo.usage.test_usage' ] suite = unittest.TestSuite()