Example_BO.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "from botorch import fit_gpytorch_model\n",
    "from botorch.models.transforms.outcome import Standardize\n",
    "from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood\n",
    "from botorch.optim.optimize import optimize_acqf\n",
    "from botorch.models.gp_regression import SingleTaskGP\n",
    "from botorch.sampling import SobolQMCNormalSampler\n",
    "from botorch.acquisition import qExpectedImprovement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In pytorch we deal with tensors which at this point you can just think of as pytorch equivalent of numpy arrays\n",
    "# Setting up a global variable tkwargs which has the information of which CPU or GPU\n",
    "# to initialize the tensors on.\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.set_device(0)\n",
    "    tkwargs = {\n",
    "        \"dtype\": torch.double,\n",
    "        \"device\": torch.cuda.current_device(),}\n",
    "else:\n",
    "    tkwargs = {\n",
    "        \"dtype\": torch.double,\n",
    "        \"device\": torch.device(\"cpu\"),}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function generates some random initial data that we use to start the optimization. The args are the input dimension\n",
    "# of the problem, the number of initial points.\n",
    "def generate_initial_data(dim_x,points):\n",
    "    train_x=np.random.rand(points,dim_x)\n",
    "    train_x=torch.from_numpy(train_x)\n",
    "    train_x=train_x.to(**tkwargs)\n",
    "    train_obj=problem(train_x)\n",
    "    return train_x, train_obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function models our objective function. It generates a GP and then marginal log likelihood of it that is used as a\n",
    "# criteria of how good the GP models our data.\n",
    "def initialize_model(train_x, train_obj):\n",
    "\n",
    "    model = SingleTaskGP(\n",
    "        train_x,\n",
    "        train_obj,\n",
    "        outcome_transform=Standardize(m=train_obj.shape[-1])\n",
    "    )\n",
    "    #model.likelihood.noise_covar.register_constraint(\"raw_noise\", GreaterThan(1e-1)) # Only use if you want to add aritificial noise\n",
    "    mll = ExactMarginalLogLikelihood(model.likelihood, model)\n",
    "    return mll, model\n",
    "\n",
    "# This is a helper function that deals with converting numpy to tensor arrays and calling the objective function\n",
    "# Here we simply use a Forrester function defined below.\n",
    "def problem(x):\n",
    "    X=x.cpu()\n",
    "    X=X.numpy()\n",
    "    print('Sim Input',X)\n",
    "    y=np.zeros((X.shape[0],1))\n",
    "    y = np.apply_along_axis(forrester, 1, X)\n",
    "    y_out=torch.from_numpy(y).to(**tkwargs)\n",
    "    print('Sim Output MO',y_out)\n",
    "    return y_out\n",
    "\n",
    "\n",
    "def forrester(x):\n",
    "    val=-((6 * x - 2)**2 * np.sin(12 * x - 4) + 7.025)\n",
    "    return val\n",
    "\n",
    "def Sinc(x):\n",
    "    x = 50*(x-0.5)\n",
    "    val=np.sin(x)/x\n",
    "    return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a helper function that calls the qEI acquisition function and then optimizes this acquisition function\n",
    "# The input parameters at which qEI is maximized would be the input parameters where we would call our objective function next.\n",
    "def optimize_qEI_and_get_observation(model,bounds,train_obj,BATCH_SIZE):\n",
    "    \"\"\"Optimizes LCB and returns a new candidate, observation, and cost.\"\"\"\n",
    "    best_value = train_obj.max()\n",
    "    # sampler = SobolQMCNormalSampler(sample_shape=torch.Size([512]), seed=0)   # This is the new botorch version syntax\n",
    "    sampler = SobolQMCNormalSampler(num_samples=512, seed=0)                  # This is the old botorch version syntax\n",
    "    qEI= qExpectedImprovement(model, best_f=best_value, sampler=sampler)\n",
    "\n",
    "    candidates, acq_value = optimize_acqf(\n",
    "        acq_function=qEI,\n",
    "        bounds=bounds,\n",
    "        q=BATCH_SIZE,\n",
    "        num_restarts=10,\n",
    "        raw_samples=512,\n",
    "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
    "    )\n",
    "\n",
    "    new_x = candidates.detach()\n",
    "    new_obj= problem(new_x)\n",
    "    return new_x, new_obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting variables\n",
    "dim_x=1\n",
    "dim_y=1\n",
    "n_TRIALS = 1  # Number of trials to run\n",
    "n_BATCH = 15  # Number of iterations in one trial\n",
    "BATCH_SIZE = 1 # Number of parallel evaluations\n",
    "n_INIT = 2     # Number of initial points\n",
    "standard_bounds = torch.tensor([[0.0] * dim_x, [1.0] * dim_x], **tkwargs) # the bounds of the problem\n",
    "# The bounds constrain our input parameters to be within a certain range.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***************************************************************************\n",
      "Trial is  0\n",
      "Sim Input [[0.1293753 ]\n",
      " [0.33634089]]\n",
      "Sim Output MO tensor([[-6.0670],\n",
      "        [-7.0250]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  1\n",
      "Sim Input [[0.91507114]]\n",
      "Sim Output MO tensor([[-14.8518]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  2\n",
      "Sim Input [[0.54394377]]\n",
      "Sim Output MO tensor([[-7.9454]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  3\n",
      "Sim Input [[0.]]\n",
      "Sim Output MO tensor([[-10.0522]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  4\n",
      "Sim Input [[0.50660413]]\n",
      "Sim Output MO tensor([[-7.9691]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  5\n",
      "Sim Input [[0.21831306]]\n",
      "Sim Output MO tensor([[-6.5574]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  6\n",
      "Sim Input [[0.65725375]]\n",
      "Sim Output MO tensor([[-4.4629]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  7\n",
      "Sim Input [[0.83460906]]\n",
      "Sim Output MO tensor([[-4.6307]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  8\n",
      "Sim Input [[0.21153497]]\n",
      "Sim Output MO tensor([[-6.4941]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  9\n",
      "Sim Input [[0.56866467]]\n",
      "Sim Output MO tensor([[-7.6476]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  10\n",
      "Sim Input [[0.58055957]]\n",
      "Sim Output MO tensor([[-7.4078]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  11\n",
      "Sim Input [[0.0879828]]\n",
      "Sim Output MO tensor([[-6.6000]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  12\n",
      "Sim Input [[0.75570587]]\n",
      "Sim Output MO tensor([[-1.0055]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  13\n",
      "Sim Input [[0.75561932]]\n",
      "Sim Output MO tensor([[-1.0057]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  14\n",
      "Sim Input [[0.02380587]]\n",
      "Sim Output MO tensor([[-8.8942]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  15\n",
      "Sim Input [[0.57783676]]\n",
      "Sim Output MO tensor([[-7.4685]], device='cuda:0', dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "# Running Opt\n",
    "# Defining arrays that would have the input and output data.\n",
    "train_x = torch.zeros(n_INIT+n_BATCH,dim_x,n_TRIALS).to(**tkwargs)\n",
    "train_obj = torch.zeros(n_INIT+n_BATCH,dim_y,n_TRIALS).to(**tkwargs)\n",
    "\n",
    "for trial in range(0, n_TRIALS):\n",
    "    torch.manual_seed(trial)\n",
    "    print('***************************************************************************')\n",
    "    print('Trial is ',trial)\n",
    "    # Generating initial data and training the model.\n",
    "    train_x[:n_INIT,:,trial], train_obj[:n_INIT,:,trial] = generate_initial_data(dim_x,n_INIT)\n",
    "    mll, model = initialize_model(train_x[:n_INIT,:,trial], train_obj[:n_INIT,:,trial])\n",
    "    # run N_BATCH rounds of BayesOpt after the initial random batch\n",
    "    for iteration in range(0, n_BATCH ):\n",
    "            print('----------------------------')\n",
    "            print('Iteration Number is ',iteration+1)\n",
    "\n",
    "            # fit the models\n",
    "            fit_gpytorch_model(mll)\n",
    "            # optimize acquisition functions and get new observations\n",
    "            new_x,new_obj= optimize_qEI_and_get_observation(\n",
    "                model,standard_bounds,train_obj,BATCH_SIZE)\n",
    "            # Storing new values\n",
    "            train_x[n_INIT+iteration,:,trial]=new_x\n",
    "            train_obj[n_INIT+iteration,:,trial]=new_obj\n",
    "            # reinitialize the models so they are ready for fitting on next iteration\n",
    "            mll, model = initialize_model(train_x[:n_INIT+iteration,:,trial], train_obj[:n_INIT+iteration,:,trial])\n",
    "# Converting tensors to numpy arrays again\n",
    "train_x=train_x.cpu().numpy()\n",
    "train_obj=train_obj.cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x151091310550>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generating the True function\n",
    "x = np.linspace(0,1,100)\n",
    "y = forrester(x)\n",
    "\n",
    "# The points are colored according to the sequence they were chosen during the optimization.\n",
    "import matplotlib.cm as cm\n",
    "c = cm.jet(np.linspace(0,1,n_BATCH+n_INIT))\n",
    "fig, axes = plt.subplots(1, 1, figsize=(9, 6))\n",
    "axes.plot(x,y,label='True Function')\n",
    "axes.scatter(train_x[:,:,0],train_obj[:,:,0],marker='o',color=c,label='Optimization points')\n",
    "axes.set_title('Forrester Function Opt')\n",
    "axes.set_ylabel('Forrester(x)')\n",
    "axes.set_xlabel('x')\n",
    "axes.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Redefining the problem to optimize a Sinc function instead of a forrester function.\n",
    "n_BATCH = 30\n",
    "\n",
    "\n",
    "def problem(x):\n",
    "    X=x.cpu()\n",
    "    X=X.numpy()\n",
    "    print('Sim Input',X)\n",
    "    y=np.zeros((X.shape[0],1))\n",
    "    y = np.apply_along_axis(Sinc, 1, X)\n",
    "    y_out=torch.from_numpy(y).to(**tkwargs)\n",
    "    print('Sim Output MO',y_out)\n",
    "    return y_out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***************************************************************************\n",
      "Trial is  0\n",
      "Sim Input [[0.37627702]\n",
      " [0.10514987]]\n",
      "Sim Output MO tensor([[-0.0157],\n",
      "        [ 0.0395]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  1\n",
      "Sim Input [[1.]]\n",
      "Sim Output MO tensor([[-0.0053]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  2\n",
      "Sim Input [[1.]]\n",
      "Sim Output MO tensor([[-0.0053]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  3\n",
      "Sim Input [[0.]]\n",
      "Sim Output MO tensor([[-0.0053]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  4\n",
      "Sim Input [[0.]]\n",
      "Sim Output MO tensor([[-0.0053]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  5\n",
      "Sim Input [[0.16378453]]\n",
      "Sim Output MO tensor([[-0.0531]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  6\n",
      "Sim Input [[0.16230366]]\n",
      "Sim Output MO tensor([[-0.0547]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  7\n",
      "Sim Input [[0.6882634]]\n",
      "Sim Output MO tensor([[0.0012]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  8\n",
      "Sim Input [[0.70429392]]\n",
      "Sim Output MO tensor([[-0.0695]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  9\n",
      "Sim Input [[0.7438155]]\n",
      "Sim Output MO tensor([[-0.0301]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  10\n",
      "Sim Input [[1.]]\n",
      "Sim Output MO tensor([[-0.0053]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  11\n",
      "Sim Input [[0.75704197]]\n",
      "Sim Output MO tensor([[0.0219]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  12\n",
      "Sim Input [[0.99391734]]\n",
      "Sim Output MO tensor([[-0.0171]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  13\n",
      "Sim Input [[0.29278196]]\n",
      "Sim Output MO tensor([[-0.0777]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  14\n",
      "Sim Input [[0.66221736]]\n",
      "Sim Output MO tensor([[0.1192]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  15\n",
      "Sim Input [[0.57116241]]\n",
      "Sim Output MO tensor([[-0.1137]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  16\n",
      "Sim Input [[0.6965896]]\n",
      "Sim Output MO tensor([[-0.0401]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  17\n",
      "Sim Input [[0.40223256]]\n",
      "Sim Output MO tensor([[-0.2014]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  18\n",
      "Sim Input [[0.16662081]]\n",
      "Sim Output MO tensor([[-0.0492]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  19\n",
      "Sim Input [[0.68902123]]\n",
      "Sim Output MO tensor([[-0.0028]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  20\n",
      "Sim Input [[0.35903164]]\n",
      "Sim Output MO tensor([[0.0983]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  21\n",
      "Sim Input [[0.79284912]]\n",
      "Sim Output MO tensor([[0.0598]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  22\n",
      "Sim Input [[0.28245448]]\n",
      "Sim Output MO tensor([[-0.0913]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  23\n",
      "Sim Input [[0.58005751]]\n",
      "Sim Output MO tensor([[-0.1895]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  24\n",
      "Sim Input [[0.86655698]]\n",
      "Sim Output MO tensor([[-0.0272]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  25\n",
      "Sim Input [[0.16019087]]\n",
      "Sim Output MO tensor([[-0.0564]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  26\n",
      "Sim Input [[0.46112143]]\n",
      "Sim Output MO tensor([[0.4790]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  27\n",
      "Sim Input [[0.45902538]]\n",
      "Sim Output MO tensor([[0.4334]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  28\n",
      "Sim Input [[0.6820075]]\n",
      "Sim Output MO tensor([[0.0350]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  29\n",
      "Sim Input [[0.48718748]]\n",
      "Sim Output MO tensor([[0.9330]], device='cuda:0', dtype=torch.float64)\n",
      "----------------------------\n",
      "Iteration Number is  30\n",
      "Sim Input [[0.49826934]]\n",
      "Sim Output MO tensor([[0.9988]], device='cuda:0', dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "# Running Opt\n",
    "# Defining arrays that would have the input and output data.\n",
    "train_x=torch.zeros(n_INIT+n_BATCH,dim_x,n_TRIALS).to(**tkwargs)\n",
    "train_obj=torch.zeros(n_INIT+n_BATCH,dim_y,n_TRIALS).to(**tkwargs)\n",
    "\n",
    "for trial in range(0, n_TRIALS):\n",
    "    torch.manual_seed(trial)\n",
    "    print('***************************************************************************')\n",
    "    print('Trial is ',trial)\n",
    "    # Generating initial data and training the model.\n",
    "    train_x[:n_INIT,:,trial], train_obj[:n_INIT,:,trial] = generate_initial_data(dim_x,n_INIT)\n",
    "    mll, model = initialize_model(train_x[:n_INIT,:,trial], train_obj[:n_INIT,:,trial])\n",
    "    # run N_BATCH rounds of BayesOpt after the initial random batch\n",
    "    for iteration in range(0, n_BATCH ):\n",
    "            print('----------------------------')\n",
    "            print('Iteration Number is ',iteration+1)\n",
    "\n",
    "            # fit the models\n",
    "            fit_gpytorch_model(mll)\n",
    "            # optimize acquisition functions and get new observations\n",
    "            new_x,new_obj= optimize_qEI_and_get_observation(\n",
    "                model,standard_bounds,train_obj,BATCH_SIZE)\n",
    "            # Storing new values\n",
    "            train_x[n_INIT+iteration,:,trial]=new_x\n",
    "            train_obj[n_INIT+iteration,:,trial]=new_obj\n",
    "            # reinitialize the models so they are ready for fitting on next iteration\n",
    "            mll, model = initialize_model(train_x[:n_INIT+iteration,:,trial], train_obj[:n_INIT+iteration,:,trial])\n",
    "# Converting tensors to numpy arrays again\n",
    "train_x=train_x.cpu().numpy()\n",
    "train_obj=train_obj.cpu().numpy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x15108026f430>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generating the True function\n",
    "x = np.linspace(0,1,10000)\n",
    "y2 = Sinc(x)\n",
    "\n",
    "# The points are colored according to the sequence they were chosen during the optimization.\n",
    "import matplotlib.cm as cm\n",
    "c = cm.jet(np.linspace(0,1,n_BATCH+n_INIT))\n",
    "fig, axes = plt.subplots(1, 1, figsize=(9, 6))\n",
    "axes.plot(x,y2,label='True Function')\n",
    "axes.scatter(train_x[:,:,0],train_obj[:,:,0],marker='o',color=c,label='Optimization points')\n",
    "axes.set_title('Sinc Function Opt')\n",
    "axes.set_ylabel('Sinc(x)')\n",
    "axes.set_xlabel('x')\n",
    "axes.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myfb",
   "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.8.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}