demo_customize_your_own_function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This notebook defines our own black-box function to be optimized with Bayesian Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from bayes_opt import BayesOpt_KnownOptimumValue,BayesOpt\n",
    "import numpy as np\n",
    "from bayes_opt import vis_ERM,functions\n",
    "from tabulate import tabulate\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Customize your own function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class YourFunction:\n",
    "    def __init__(self):\n",
    "       \n",
    "        # define the search range for each variable\n",
    "        self.bounds = np.asarray([\n",
    "                                [-5,10],  # variable 1\n",
    "                                  [0,15] # variable 2\n",
    "                                 ])\n",
    "            \n",
    "        self.input_dim = self.bounds.shape[0] # this is 2\n",
    "\n",
    "        # do we want to maximize the function or minimize ?\n",
    "        self.ismax=-1  # set -1 if we want to minimize\n",
    "        \n",
    "        # define the known optimum value if it is available\n",
    "        #self.fstar = 0.397887*self.ismax # set it None if we dont know\n",
    "        \n",
    "        # define the name of your function\n",
    "        self.name='ICML20'\n",
    "        \n",
    "    def evaluate_single_fx(self,X): # this is actually a Branin function\n",
    "        # evaluate y=f(X)\n",
    "        X = np.reshape(X,self.input_dim)\n",
    "        x1,x2=X[0],X[1]\n",
    "     \n",
    "        a=1\n",
    "        b=5.1/(4*np.pi**2)\n",
    "        c=5/np.pi\n",
    "        r=6\n",
    "        s=10\n",
    "        t=1/(8*np.pi)\n",
    "        y=a*(x2-b*x1*x1+c*x1-r)**2+s*(1-t)*np.cos(x1)+s    \n",
    "      \n",
    "        return y*self.ismax # return the (-1) * fx for minimization problem\n",
    "   \n",
    "    \n",
    "    def func(self,X):\n",
    "        X=np.asarray(X)        \n",
    "       \n",
    "        if len(X.shape)==1: # 1 data point\n",
    "            fx=self.evaluate_single_fx(X)\n",
    "        else: # multiple data points\n",
    "            fx=np.apply_along_axis( self.evaluate_single_fx,1,X)\n",
    "            \n",
    "        return fx  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Init the black-box function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunction=YourFunction()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Specify Bayesian optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#acq_name='erm'\n",
    "acq_name='ei'\n",
    "\n",
    "if 'kov' in acq_name or acq_name == 'erm' or acq_name == 'cbm':\n",
    "    bo=BayesOpt_KnownOptimumValue(myfunction.func,myfunction.bounds,fstar=myfunction.fstar, \\\n",
    "                              acq_name=acq_name,IsTGP=1,verbose=1)\n",
    "else:\n",
    "    bo=BayesOpt(myfunction.func,myfunction.bounds,acq_name=acq_name,verbose=1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialize BO using 3*dim number of observations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "bo.init(n_init_points=3*myfunction.input_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run for 10*dim iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimated lengthscale [0.0353949]\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "     0  [-0.862  5.967]          -18.501                -18.501\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "     1  [-1.818  7.607]          -10.586                -10.586\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "     2  [-2.858 10.062]           -3.158                 -3.158\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "     3  [-4.881 10.904]          -46.923                 -3.158\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "     4  [-1.63   9.679]           -9.986                 -3.158\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "     5  [4.21  7.399]          -39.126                 -3.158\n",
      "estimated lengthscale [0.0417672]\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "     6  [-2.428 12.466]           -6.132                 -3.158\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "     7  [-2.241 15.   ]          -26.926                 -3.158\n",
      "  Iter  Selected x      Output y=f(x)    Best Observed Value\n",
      "------  ------------  ---------------  ---------------------\n",
      "     8  [10.  0.]             -10.961                 -3.158\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "     9  [7.471 0.   ]          -15.332                 -3.158\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    10  [9.046 2.372]           -1.117                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    11  [6.881 3.052]          -21.499                 -1.117\n",
      "estimated lengthscale [0.04193778]\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "    12  [10.     4.575]           -4.414                 -1.117\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "    13  [10.     7.691]          -23.925                 -1.117\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "    14  [10.    12.868]          -99.259                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    15  [8.283 5.527]          -20.801                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    16  [3.591 0.   ]           -5.156                 -1.117\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "    17  [10.     2.538]           -2.159                 -1.117\n",
      "estimated lengthscale [0.04712622]\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    18  [2.647 1.937]           -2.121                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    19  [1.763 0.207]          -19.649                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    20  [4.007 1.537]           -3.798                 -1.117\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "    21  [ 4.678 15.   ]         -195.118                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    22  [3.139 4.024]           -3.449                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    23  [1.131 3.555]           -14.74                 -1.117\n",
      "estimated lengthscale [0.0706129]\n",
      "  Iter  Selected x      Output y=f(x)    Best Observed Value\n",
      "------  ------------  ---------------  ---------------------\n",
      "    24  [-5. 15.]             -17.508                 -1.117\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    25  [3.221 2.883]           -0.876                 -0.876\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    26  [9.278 3.498]            -1.81                 -0.876\n",
      "  Iter  Selected x       Output y=f(x)    Best Observed Value\n",
      "------  -------------  ---------------  ---------------------\n",
      "    27  [7.257 9.254]          -79.407                 -0.876\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "    28  [-3.188  8.578]           -14.91                 -0.876\n",
      "  Iter  Selected x         Output y=f(x)    Best Observed Value\n",
      "------  ---------------  ---------------  ---------------------\n",
      "    29  [-3.679 13.355]           -1.814                 -0.876\n",
      "==================================================================================\n",
      "Best found x      Best found f(x)\n",
      "--------------  -----------------\n",
      "[3.221 2.883]              -0.876\n"
     ]
    }
   ],
   "source": [
    "NN=15*myfunction.input_dim\n",
    "for index in range(0,NN):\n",
    "\n",
    "    bo.select_next_point()\n",
    "\n",
    "    print(tabulate([[ index,np.round(bo.X_ori[-1],3), np.round(bo.Y_ori[-1],3), np.round(bo.Y_ori.max(),3)]], \\\n",
    "               headers=['Iter','Selected x', 'Output y=f(x)', 'Best Observed Value']))\n",
    "\n",
    "    \n",
    "print(\"==================================================================================\")\n",
    "idxMax=np.argmax(bo.Y_ori)\n",
    "print(tabulate([[ np.round(bo.X_ori[idxMax],3), np.round(bo.Y_ori[idxMax],3)]], \\\n",
    "           headers=['Best found x', 'Best found f(x)']))   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot the performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Performance')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(figsize=(6, 3))\n",
    "myYbest=[bo.Y_ori[:idx+1].max() for idx,val in enumerate(bo.Y_ori)]\n",
    "plt.plot(range(len(myYbest)),myYbest,linewidth=2,color='m',linestyle='-',marker='o',label='BO')\n",
    "\n",
    "\n",
    "plt.xlabel('Iteration',fontsize=14)\n",
    "plt.ylabel('Best Found Value',fontsize=14)\n",
    "plt.legend(prop={'size': 16})\n",
    "plt.title('Performance',fontsize=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run Random Search Baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of points\n",
    "n_point=len(bo.Y_ori) \n",
    "\n",
    "# uniformly select the input\n",
    "X_rand = np.random.uniform(myfunction.bounds[:, 0], myfunction.bounds[:, 1],size=(n_point, myfunction.input_dim))\n",
    "\n",
    "# evaluate the black-box function\n",
    "Y_rand=myfunction.func(X_rand)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparing Bayes Opt with Random Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Performance')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(figsize=(6, 3))\n",
    "\n",
    "myYbest_BO=[bo.Y_ori[:idx+1].max() for idx,val in enumerate(bo.Y_ori)]\n",
    "plt.plot(range(len(myYbest_BO)),myYbest_BO,linewidth=2,color='m',linestyle='-',marker='o',label='BO')\n",
    "\n",
    "\n",
    "myYbest_Rand=[Y_rand[:idx+1].max() for idx,val in enumerate(Y_rand)]\n",
    "plt.plot(range(len(myYbest_Rand)),myYbest_Rand,linewidth=2,color='b',linestyle=':',marker='s',label='Rand')\n",
    "\n",
    "#plt.hlines(y=myfunction.ismax*myfunction.fstar,xmin=0,xmax=len(myYbest),label='f*')\n",
    "\n",
    "plt.ylim([-5,0])\n",
    "plt.xlabel('Iteration',fontsize=14)\n",
    "plt.ylabel('Best Found Value',fontsize=14)\n",
    "plt.legend(prop={'size': 16})\n",
    "plt.title('Performance',fontsize=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Most of the time, BayesOpt will outperform Random Search"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}