From 67c4b812817090c7c8123e158cccf92458099269 Mon Sep 17 00:00:00 2001 From: "Pablo R. Mier" Date: Mon, 1 Jun 2020 13:37:08 +0200 Subject: [PATCH] Version 1.1.0 --- notebooks/yabox-tutorial.ipynb | 251 +++++++++++++++++++++++++++++---- yabox/algorithms/de.py | 2 +- yabox/version.py | 2 +- 3 files changed, 222 insertions(+), 33 deletions(-) diff --git a/notebooks/yabox-tutorial.ipynb b/notebooks/yabox-tutorial.ipynb index abfa72d..b07a054 100644 --- a/notebooks/yabox-tutorial.ipynb +++ b/notebooks/yabox-tutorial.ipynb @@ -22,11 +22,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Yabox version: 1.1.0\n" + ] + } + ], "source": [ "%matplotlib inline\n", + "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import sys\n", "\n", @@ -47,32 +56,188 @@ "source": [ "# Basics\n", "\n", - "Optimization of a lambda function:" + "Easiest way to optimize a function is to pass it as a lambda function to DE and call `solve`. For example, find the minimum of the function $f = \\sum_i x_i^2 + 1$ in 5 dimensions ($x = [x_0,\\dots,x_4]$), bounding the search between -10 and 10 for each $x_i$:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "53020729b6534ed0914cc197c9752bba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Optimizing (DE)', max=10000.0, style=ProgressStyle(descri…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[ 2.61763944e-09, 3.81970011e-09, 3.05075076e-10,\n", + " -3.29102257e-09, -5.35349898e-09]]),\n", + " 1.0)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "DE(lambda x: sum(x**2), [(-10, 10)], maxiters=1000).solve(show_progress=True)" + "DE(lambda x: sum(x**2) + 1, [(-10, 10)] * 5, maxiters=10000).solve(show_progress=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In many scenarios, the function to optimize may depend on many other components or other fixed parameters. It is very convenient to define a function to create your optimizable function. Here is an example of this, where `create_loss` is a function that prepares the data and returns another function to be optimize:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "def fun(x, a, b):\n", - " return a + sum(x**2) / (b + 1)\n", + "def create_loss(p1, p2, p3):\n", + " # Prepare here whatever you need. Load parameters,\n", + " # read from file, etc\n", + " a = p1 * p2\n", + " b = p2 / p3\n", + " # Define the function to be optimized as an inner function\n", + " # that can make use of the other parameters\n", + " def f(x):\n", + " return 1 + a*x - b*x**2 + 0.01*x**3 + 0.001 * x**4\n", + " return f\n", "\n", - "def f(x):\n", - " # You can initialize here your params a, b\n", - " return fun(x, 10, -2)\n", - "\n", - "DE(f, [(-10, 10)], maxiters=1000).solve(show_progress=True)" + "f = create_loss(5, 2, 0.1)\n", + "f(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(-150, 150, 0.1)\n", + "plt.plot(x, f(x));" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d0cdb7a1e04d428bb0ee80aaa74e61ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Optimizing (DE)', max=1000.0, style=ProgressStyle(descrip…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[-103.94039252]]), array([-111621.93226051]))" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xo, yo = DE(f, [(-150, 150)], maxiters=1000).solve(show_progress=True)\n", + "xo, yo" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(x, f(x));\n", + "ax.plot(xo[0][0], yo[0], '*')" ] }, { @@ -84,31 +249,55 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-79695.64776739] [0.26333499] [-70.99950227]\n", + "[-89871.02737402] [0.24074883] [-77.77534998]\n", + "[-89871.02737402] [0.24074883] [-77.77534998]\n", + "[-91053.15530339] [0.23795163] [-78.61451093]\n", + "[-97210.93178287] [0.22241614] [-83.27515819]\n", + "[-110556.19311946] [0.1708188] [-98.75436014]\n", + "[-110556.19311946] [0.1708188] [-98.75436014]\n", + "[-111186.87686619] [0.16447298] [-100.65810671]\n", + "[-111555.89127852] [0.15775271] [-102.67418668]\n", + "[-111555.89127852] [0.15775271] [-102.67418668]\n", + "[-111555.89127852] [0.15775271] [-102.67418668]\n", + "[-111572.57070825] [0.14992452] [-105.02264334]\n", + "[-111572.57070825] [0.14992452] [-105.02264334]\n", + "[-111572.57070825] [0.14992452] [-105.02264334]\n", + "[-111599.04208511] [0.15601054] [-103.19683851]\n", + "[-111599.04208511] [0.15601054] [-103.19683851]\n", + "[-111614.19343449] [0.1520991] [-104.37026969]\n", + "[-111614.19343449] [0.1520991] [-104.37026969]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92806358] [0.15356547] [-103.93036017]\n", + "[-111621.92978939] [0.15350637] [-103.9480899]\n", + "[-111621.93165727] [0.15351935] [-103.94419568]\n" + ] + } + ], "source": [ "# Control the iteration process\n", - "de = DE(lambda x: sum(x**2), [(-10, 10)], maxiters=30)\n", + "de = DE(f, [(-150, 150)], maxiters=30)\n", "for step in de.geniterator():\n", " idx = step.best_idx\n", " norm_vector = step.population[idx]\n", " best_params = de.denormalize([norm_vector])\n", " print(step.best_fitness, norm_vector, best_params[0])" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# NOTE: On windows, processes are not spawn from ipython\n", - "def f(x):\n", - " return sum(x**2)\n", - "\n", - "PDE(f, [(-10, 10)], maxiters=1000).solve(show_progress=False)" - ] } ], "metadata": { diff --git a/yabox/algorithms/de.py b/yabox/algorithms/de.py index da74b20..a10fec4 100644 --- a/yabox/algorithms/de.py +++ b/yabox/algorithms/de.py @@ -184,7 +184,7 @@ def solve(self, show_progress=False): idx = step.best_idx P = step.population fitness = step.fitness - return self.denormalize(P[idx].reshape(-1, 1)), fitness[idx] + return self.denormalize(P[idx].reshape(1, -1)), fitness[idx] class PDE(DE): diff --git a/yabox/version.py b/yabox/version.py index 5c8095d..7e26771 100644 --- a/yabox/version.py +++ b/yabox/version.py @@ -1,3 +1,3 @@ # -*- coding: utf-8 -*- -__version__ = '1.0.6' +__version__ = '1.1.0' VERSION = __version__ \ No newline at end of file