Pushing the docs for revision for branch: master, commit 4d6d749d87f725a9e1a2f3ace4d188c6d8603b0b

Author: skoptci

_downloads/0125ffa429cf97cfbaa8c01b31f985c2/sampling_comparison.ipynb

@@ -55,7 +55,7 @@
       },
       "outputs": [],
       "source": [
-        "from matplotlib.pyplot import cm\nimport time\nfrom skopt import gp_minimize, forest_minimize, dummy_minimize\n\ndef plot_convergence(result_list, true_minimum=None, yscale=None, title=\"Convergence plot\"):\n\n    ax = plt.gca()\n    ax.set_title(title)\n    ax.set_xlabel(\"Number of calls $n$\")\n    ax.set_ylabel(r\"$\\min f(x)$ after $n$ calls\")\n    ax.grid()\n    if yscale is not None:\n        ax.set_yscale(yscale)\n    colors = cm.hsv(np.linspace(0.25, 1.0, len(result_list)))\n\n    for results, color in zip(result_list, colors):\n        name, results = results\n        n_calls = len(results[0].x_iters)\n        iterations = range(1, n_calls + 1)\n        mins = [[np.min(r.func_vals[:i]) for i in iterations]\n                for r in results]\n        ax.plot(iterations, np.mean(mins, axis=0), c=color, label=name)\n        #ax.errorbar(iterations, np.mean(mins, axis=0),\n        #             yerr=np.std(mins, axis=0), c=color, label=name)\n    if true_minimum:\n        ax.axhline(true_minimum, linestyle=\"--\",\n                   color=\"r\", lw=1,\n                   label=\"True minimum\")\n    ax.legend(loc=\"best\")\n    return ax\n\n\ndef run(minimizer, initial_point_generator, init_point_gen_kwargs,\n        n_random_starts=10, n_repeats=1):\n    return [minimizer(func, bounds, n_random_starts=n_random_starts,\n                      initial_point_generator=initial_point_generator,\n                      init_point_gen_kwargs=init_point_gen_kwargs,\n                      n_calls=n_calls, random_state=n)\n            for n in range(n_repeats)]\n\n\ndef run_measure(initial_point_generator,\n                n_random_starts=10,\n                init_point_gen_kwargs=None):\n    start = time.time()\n    # n_repeats must set to a much higher value to obtain meaningful results.\n    n_repeats = 1\n    res = run(gp_minimize, initial_point_generator, init_point_gen_kwargs,\n              n_random_starts=n_random_starts, n_repeats=n_repeats)\n    duration = time.time() - start\n    # print(\"%s %s: %.2f s\" % (initial_point_generator,\n    #                          str(init_point_gen_kwargs),\n    #                          duration))\n    return res"
+        "from matplotlib.pyplot import cm\nimport time\nfrom skopt import gp_minimize, forest_minimize, dummy_minimize\n\ndef plot_convergence(result_list, true_minimum=None, yscale=None, title=\"Convergence plot\"):\n\n    ax = plt.gca()\n    ax.set_title(title)\n    ax.set_xlabel(\"Number of calls $n$\")\n    ax.set_ylabel(r\"$\\min f(x)$ after $n$ calls\")\n    ax.grid()\n    if yscale is not None:\n        ax.set_yscale(yscale)\n    colors = cm.hsv(np.linspace(0.25, 1.0, len(result_list)))\n\n    for results, color in zip(result_list, colors):\n        name, results = results\n        n_calls = len(results[0].x_iters)\n        iterations = range(1, n_calls + 1)\n        mins = [[np.min(r.func_vals[:i]) for i in iterations]\n                for r in results]\n        ax.plot(iterations, np.mean(mins, axis=0), c=color, label=name)\n        #ax.errorbar(iterations, np.mean(mins, axis=0),\n        #             yerr=np.std(mins, axis=0), c=color, label=name)\n    if true_minimum:\n        ax.axhline(true_minimum, linestyle=\"--\",\n                   color=\"r\", lw=1,\n                   label=\"True minimum\")\n    ax.legend(loc=\"best\")\n    return ax\n\n\ndef run(minimizer, initial_point_generator,\n        n_initial_points=10, n_repeats=1):\n    return [minimizer(func, bounds, n_initial_points=n_initial_points,\n                      initial_point_generator=initial_point_generator,\n                      n_calls=n_calls, random_state=n)\n            for n in range(n_repeats)]\n\n\ndef run_measure(initial_point_generator, n_initial_points=10):\n    start = time.time()\n    # n_repeats must set to a much higher value to obtain meaningful results.\n    n_repeats = 1\n    res = run(gp_minimize, initial_point_generator,\n              n_initial_points=n_initial_points, n_repeats=n_repeats)\n    duration = time.time() - start\n    # print(\"%s %s: %.2f s\" % (initial_point_generator,\n    #                          str(init_point_gen_kwargs),\n    #                          duration))\n    return res"
       ]
     },
     {
@@ -73,7 +73,7 @@
       },
       "outputs": [],
       "source": [
-        "from functools import partial\nexample = \"hart6\"\n\nif example == \"hart6\":\n    func = partial(hart6, noise_level=0.1)\n    bounds = [(0., 1.), ] * 6\n    true_minimum = -3.32237\n    n_calls = 40\n    n_random_starts = 10\n    yscale = None\n    title = \"Convergence plot - hart6\"\nelse:\n    func = partial(branin, noise_level=2.0)\n    bounds = [(-5.0, 10.0), (0.0, 15.0)]\n    true_minimum = 0.397887\n    n_calls = 30\n    n_random_starts = 10\n    yscale=\"log\"\n    title = \"Convergence plot - branin\""
+        "from functools import partial\nexample = \"hart6\"\n\nif example == \"hart6\":\n    func = partial(hart6, noise_level=0.1)\n    bounds = [(0., 1.), ] * 6\n    true_minimum = -3.32237\n    n_calls = 40\n    n_initial_points = 10\n    yscale = None\n    title = \"Convergence plot - hart6\"\nelse:\n    func = partial(branin, noise_level=2.0)\n    bounds = [(-5.0, 10.0), (0.0, 15.0)]\n    true_minimum = 0.397887\n    n_calls = 30\n    n_initial_points = 10\n    yscale=\"log\"\n    title = \"Convergence plot - branin\""
       ]
     },
     {
@@ -84,7 +84,7 @@
       },
       "outputs": [],
       "source": [
-        "# Random search\ndummy_res = run_measure( \"random\", n_random_starts)\nlhs_res = run_measure(\"lhs\", n_random_starts,\n                      {\"lhs_type\": \"classic\",\n                       \"criterion\": None})\nlhs2_res = run_measure(\"lhs\", n_random_starts,\n                       {\"criterion\": \"maximin\"})\nsobol_res = run_measure(\"sobol\", n_random_starts,\n                        {\"randomize\": False,\n                         \"min_skip\": 1, \"max_skip\": 100})\nhalton_res = run_measure(\"halton\", n_random_starts)\nhammersly_res = run_measure(\"hammersly\", n_random_starts)"
+        "from skopt.utils import cook_initial_point_generator\n\n# Random search\ndummy_res = run_measure(\"random\", n_initial_points)\nlhs = cook_initial_point_generator(\n    \"lhs\", lhs_type=\"classic\", criterion=None)\nlhs_res = run_measure(lhs, n_initial_points)\nlhs2 = cook_initial_point_generator(\"lhs\", criterion=\"maximin\")\nlhs2_res = run_measure(lhs2, n_initial_points)\nsobol = cook_initial_point_generator(\"sobol\", randomize=False,\n                                     min_skip=1, max_skip=100)\nsobol_res = run_measure(sobol, n_initial_points)\nhalton_res = run_measure(\"halton\", n_initial_points)\nhammersly_res = run_measure(\"hammersly\", n_initial_points)\ngrid_res = run_measure(\"grid\", n_initial_points)"
       ]
     },
     {
@@ -102,7 +102,7 @@
       },
       "outputs": [],
       "source": [
-        "plot = plot_convergence([(\"random\", dummy_res),\n                        (\"lhs\", lhs_res),\n                        (\"lhs_maximin\", lhs2_res),\n                        (\"sobol\", sobol_res),\n                        (\"halton\", halton_res),\n                        (\"hammersly\", hammersly_res)],\n                        true_minimum=true_minimum,\n                        yscale=yscale,\n                        title=title)\n\nplt.show()"
+        "plot = plot_convergence([(\"random\", dummy_res),\n                        (\"lhs\", lhs_res),\n                        (\"lhs_maximin\", lhs2_res),\n                        (\"sobol\", sobol_res),\n                        (\"halton\", halton_res),\n                        (\"hammersly\", hammersly_res),\n                        (\"grid\", grid_res)],\n                        true_minimum=true_minimum,\n                        yscale=yscale,\n                        title=title)\n\nplt.show()"
       ]
     },
     {
@@ -127,7 +127,7 @@
       },
       "outputs": [],
       "source": [
-        "lhs2_15_res = run_measure(\"lhs\", 12,\n                          {\"criterion\": \"maximin\"})\nlhs2_20_res = run_measure(\"lhs\", 14,\n                          {\"criterion\": \"maximin\"})\nlhs2_25_res = run_measure(\"lhs\", 16,\n                          {\"criterion\": \"maximin\"})"
+        "lhs2 = cook_initial_point_generator(\"lhs\", criterion=\"maximin\")\nlhs2_15_res = run_measure(lhs2, 12)\nlhs2_20_res = run_measure(lhs2, 14)\nlhs2_25_res = run_measure(lhs2, 16)"
       ]
     },
     {

_downloads/17233f04e84c7fb9fb96b6267eb354f3/initial-sampling-method-integer.ipynb

@@ -26,7 +26,7 @@
       },
       "outputs": [],
       "source": [
-        "print(__doc__)\nimport numpy as np\nnp.random.seed(1234)\nimport matplotlib.pyplot as plt\nfrom skopt.space import Space\nfrom skopt.sampler import Sobol\nfrom skopt.sampler import Lhs\nfrom skopt.sampler import Halton\nfrom skopt.sampler import Hammersly\nfrom scipy.spatial.distance import pdist"
+        "print(__doc__)\nimport numpy as np\nnp.random.seed(1234)\nimport matplotlib.pyplot as plt\nfrom skopt.space import Space\nfrom skopt.sampler import Sobol\nfrom skopt.sampler import Lhs\nfrom skopt.sampler import Halton\nfrom skopt.sampler import Hammersly\nfrom skopt.sampler import Grid\nfrom scipy.spatial.distance import pdist"
       ]
     },
     {
@@ -37,7 +37,7 @@
       },
       "outputs": [],
       "source": [
-        "def plot_searchspace(x, title):\n    fig, ax = plt.subplots()\n    plt.plot(np.array(x)[:, 0], np.array(x)[:, 1], 'bo', label='samples')\n    plt.plot(np.array(x)[:, 0], np.array(x)[:, 1], 'bs', markersize=40, alpha=0.5)\n    # ax.legend(loc=\"best\", numpoints=1)\n    ax.set_xlabel(\"X1\")\n    ax.set_xlim([0, 5])\n    ax.set_ylabel(\"X2\")\n    ax.set_ylim([0, 5])\n    plt.title(title)\n    ax.grid(True)\n\n\nn_samples = 10\nspace = Space([(0, 5), (0, 5)])\nspace.set_transformer(\"normalize\")"
+        "def plot_searchspace(x, title):\n    fig, ax = plt.subplots()\n    plt.plot(np.array(x)[:, 0], np.array(x)[:, 1], 'bo', label='samples')\n    plt.plot(np.array(x)[:, 0], np.array(x)[:, 1], 'bs', markersize=40, alpha=0.5)\n    # ax.legend(loc=\"best\", numpoints=1)\n    ax.set_xlabel(\"X1\")\n    ax.set_xlim([0, 5])\n    ax.set_ylabel(\"X2\")\n    ax.set_ylim([0, 5])\n    plt.title(title)\n    ax.grid(True)\n\n\nn_samples = 10\nspace = Space([(0, 5), (0, 5)])"
       ]
     },
     {
@@ -202,6 +202,24 @@
         "hammersly = Hammersly()\nx = hammersly.generate(space.dimensions, n_samples)\nplot_searchspace(x, 'Hammersly')\nprint(\"empty fields: %d\" % (36 - np.size(np.unique(x, axis=0), 0)))\npdist_data.append(pdist(x).flatten())\nx_label.append(\"hammersly\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Grid sampling\n-------------\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "grid = Grid(border=\"include\", use_full_layout=False)\nx = grid.generate(space.dimensions, n_samples)\nplot_searchspace(x, 'Grid')\nprint(\"empty fields: %d\" % (36 - np.size(np.unique(x, axis=0), 0)))\npdist_data.append(pdist(x).flatten())\nx_label.append(\"grid\")"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},

_downloads/285ba9b2b7077a2b8a0045abf2f5d258/initial-sampling-method-integer.py

@@ -31,6 +31,7 @@
 from skopt.sampler import Lhs
 from skopt.sampler import Halton
 from skopt.sampler import Hammersly
+from skopt.sampler import Grid
 from scipy.spatial.distance import pdist
 
 #############################################################################
@@ -50,7 +51,6 @@ def plot_searchspace(x, title):
 
 n_samples = 10
 space = Space([(0, 5), (0, 5)])
-space.set_transformer("normalize")
 
 #############################################################################
 # Random sampling
@@ -151,6 +151,17 @@ def plot_searchspace(x, title):
 pdist_data.append(pdist(x).flatten())
 x_label.append("hammersly")
 
+#############################################################################
+# Grid sampling
+# -------------
+
+grid = Grid(border="include", use_full_layout=False)
+x = grid.generate(space.dimensions, n_samples)
+plot_searchspace(x, 'Grid')
+print("empty fields: %d" % (36 - np.size(np.unique(x, axis=0), 0)))
+pdist_data.append(pdist(x).flatten())
+x_label.append("grid")
+
 #############################################################################
 # Pdist boxplot of all methods
 # ----------------------------

_downloads/43e5f44bcbdd86676fcefed360c94018/initial-sampling-method.py

@@ -32,6 +32,7 @@
 from skopt.sampler import Lhs
 from skopt.sampler import Halton
 from skopt.sampler import Hammersly
+from skopt.sampler import Grid
 from scipy.spatial.distance import pdist
 
 #############################################################################
@@ -50,7 +51,7 @@ def plot_searchspace(x, title):
 n_samples = 10
 
 space = Space([(-5., 10.), (0., 15.)])
-space.set_transformer("normalize")
+# space.set_transformer("normalize")
 
 #############################################################################
 # Random sampling
@@ -142,6 +143,16 @@ def plot_searchspace(x, title):
 pdist_data.append(pdist(x).flatten())
 x_label.append("hammersly")
 
+#############################################################################
+# Grid sampling
+# -------------
+
+grid = Grid(border="include", use_full_layout=False)
+x = grid.generate(space.dimensions, n_samples)
+plot_searchspace(x, 'Grid')
+pdist_data.append(pdist(x).flatten())
+x_label.append("grid")
+
 #############################################################################
 # Pdist boxplot of all methods
 # ----------------------------

_downloads/55e499d257673f3a6610c4c61b7957e6/sampling_comparison.py

@@ -78,23 +78,20 @@ def plot_convergence(result_list, true_minimum=None, yscale=None, title="Converg
     return ax
 
 
-def run(minimizer, initial_point_generator, init_point_gen_kwargs,
-        n_random_starts=10, n_repeats=1):
-    return [minimizer(func, bounds, n_random_starts=n_random_starts,
+def run(minimizer, initial_point_generator,
+        n_initial_points=10, n_repeats=1):
+    return [minimizer(func, bounds, n_initial_points=n_initial_points,
                       initial_point_generator=initial_point_generator,
-                      init_point_gen_kwargs=init_point_gen_kwargs,
                       n_calls=n_calls, random_state=n)
             for n in range(n_repeats)]
 
 
-def run_measure(initial_point_generator,
-                n_random_starts=10,
-                init_point_gen_kwargs=None):
+def run_measure(initial_point_generator, n_initial_points=10):
     start = time.time()
     # n_repeats must set to a much higher value to obtain meaningful results.
     n_repeats = 1
-    res = run(gp_minimize, initial_point_generator, init_point_gen_kwargs,
-              n_random_starts=n_random_starts, n_repeats=n_repeats)
+    res = run(gp_minimize, initial_point_generator,
+              n_initial_points=n_initial_points, n_repeats=n_repeats)
     duration = time.time() - start
     # print("%s %s: %.2f s" % (initial_point_generator,
     #                          str(init_point_gen_kwargs),
@@ -121,33 +118,34 @@ def run_measure(initial_point_generator,
     bounds = [(0., 1.), ] * 6
     true_minimum = -3.32237
     n_calls = 40
-    n_random_starts = 10
+    n_initial_points = 10
     yscale = None
     title = "Convergence plot - hart6"
 else:
     func = partial(branin, noise_level=2.0)
     bounds = [(-5.0, 10.0), (0.0, 15.0)]
     true_minimum = 0.397887
     n_calls = 30
-    n_random_starts = 10
+    n_initial_points = 10
     yscale="log"
     title = "Convergence plot - branin"
 
 #############################################################################
-
+from skopt.utils import cook_initial_point_generator
 
 # Random search
-dummy_res = run_measure( "random", n_random_starts)
-lhs_res = run_measure("lhs", n_random_starts,
-                      {"lhs_type": "classic",
-                       "criterion": None})
-lhs2_res = run_measure("lhs", n_random_starts,
-                       {"criterion": "maximin"})
-sobol_res = run_measure("sobol", n_random_starts,
-                        {"randomize": False,
-                         "min_skip": 1, "max_skip": 100})
-halton_res = run_measure("halton", n_random_starts)
-hammersly_res = run_measure("hammersly", n_random_starts)
+dummy_res = run_measure("random", n_initial_points)
+lhs = cook_initial_point_generator(
+    "lhs", lhs_type="classic", criterion=None)
+lhs_res = run_measure(lhs, n_initial_points)
+lhs2 = cook_initial_point_generator("lhs", criterion="maximin")
+lhs2_res = run_measure(lhs2, n_initial_points)
+sobol = cook_initial_point_generator("sobol", randomize=False,
+                                     min_skip=1, max_skip=100)
+sobol_res = run_measure(sobol, n_initial_points)
+halton_res = run_measure("halton", n_initial_points)
+hammersly_res = run_measure("hammersly", n_initial_points)
+grid_res = run_measure("grid", n_initial_points)
 
 #############################################################################
 # Note that this can take a few minutes.
@@ -157,7 +155,8 @@ def run_measure(initial_point_generator,
                         ("lhs_maximin", lhs2_res),
                         ("sobol", sobol_res),
                         ("halton", halton_res),
-                        ("hammersly", hammersly_res)],
+                        ("hammersly", hammersly_res),
+                        ("grid", grid_res)],
                         true_minimum=true_minimum,
                         yscale=yscale,
                         title=title)
@@ -172,12 +171,10 @@ def run_measure(initial_point_generator,
 
 #############################################################################
 # Test with different n_random_starts values
-lhs2_15_res = run_measure("lhs", 12,
-                          {"criterion": "maximin"})
-lhs2_20_res = run_measure("lhs", 14,
-                          {"criterion": "maximin"})
-lhs2_25_res = run_measure("lhs", 16,
-                          {"criterion": "maximin"})
+lhs2 = cook_initial_point_generator("lhs", criterion="maximin")
+lhs2_15_res = run_measure(lhs2, 12)
+lhs2_20_res = run_measure(lhs2, 14)
+lhs2_25_res = run_measure(lhs2, 16)
 
 #############################################################################
 # n_random_starts = 10 produces the best results
@@ -191,4 +188,4 @@ def run_measure(initial_point_generator,
                         yscale=yscale,
                         title=title)
 
-plt.show()
+plt.show()