mainSOexps.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main Notebook\n",
    "\n",
    "File to perform experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import gpflow\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import time\n",
    "from tqdm import tqdm\n",
    "\n",
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' \n",
    "import tensorflow as tf\n",
    "\n",
    "from models.SOGP import GaussianProcess\n",
    "from acquisition_functions.SingleObjective import SingleObjectiveAcq\n",
    "\n",
    "from acquisition_functions.SingleObjective import pi, ei, ucb, mes,  simulated_mes \n",
    "from benchmarkFunctions.eggholder import eggholder\n",
    "from benchmarkFunctions.ackley import ackley\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithm Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 1\n",
    "np.random.seed(seed)\n",
    "total_iter = 38\n",
    "initial_iter = 2\n",
    "\n",
    "lower_bound = -2\n",
    "upper_bound = 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 2\n",
    "\n",
    "def evaluation(x):\n",
    "    #return eggholder(np.array([512,x]))\n",
    "    return np.array([ackley(x)])\n",
    "    return np.array([1-np.exp(-np.sum(x**2))])\n",
    "\n",
    "N = 1001\n",
    "X = np.linspace(lower_bound,upper_bound,N)\n",
    "\n",
    "if d==1:\n",
    "    Z = np.zeros(N)\n",
    "    for i in range(N):\n",
    "        Z[i]=evaluation(X[i])\n",
    "    opt_arg, opt_val = Z.argmin(), np.amin(Z)    \n",
    "\n",
    "elif d==2:\n",
    "    Z = np.zeros((N,N))\n",
    "\n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            Z[i,j]=evaluation(np.array([X[i],X[j]]))\n",
    "\n",
    "    opt_arg, opt_val = np.unravel_index(Z.argmin(), Z.shape), np.amin(Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_acq(GP):\n",
    "    while True:\n",
    "        x_rand = np.random.uniform(GP.lowerBound, GP.upperBound, GP.d)\n",
    "        if GP.X is None or not x_rand in GP.X:\n",
    "                break\n",
    "    return x_rand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## N experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Thu Jun 16 22:28:55 2022\n",
      "1 Thu Jun 16 22:29:22 2022\n",
      "2 Thu Jun 16 22:29:47 2022\n",
      "3 Thu Jun 16 22:30:11 2022\n",
      "4 Thu Jun 16 22:30:37 2022\n",
      "5 Thu Jun 16 22:31:02 2022\n",
      "6 Thu Jun 16 22:31:26 2022\n",
      "7 Thu Jun 16 22:31:51 2022\n",
      "8 Thu Jun 16 22:32:16 2022\n",
      "9 Thu Jun 16 22:32:42 2022\n",
      "10 Thu Jun 16 22:33:06 2022\n",
      "11 Thu Jun 16 22:33:31 2022\n",
      "12 Thu Jun 16 22:33:56 2022\n",
      "13 Thu Jun 16 22:34:21 2022\n",
      "14 Thu Jun 16 22:34:47 2022\n",
      "15 Thu Jun 16 22:35:12 2022\n",
      "16 Thu Jun 16 22:35:37 2022\n",
      "17 Thu Jun 16 22:36:01 2022\n",
      "18 Thu Jun 16 22:36:27 2022\n",
      "19 Thu Jun 16 22:36:51 2022\n"
     ]
    }
   ],
   "source": [
    "root_folder = \"SingleObjectiveExperiments\"\n",
    "testF = \"ackley\"\n",
    "acqF = \"simulated_mes5\"\n",
    "function = simulated_mes\n",
    "df = None\n",
    "n_experiments = 20\n",
    "\n",
    "with tf.device('/GPU:1'):\n",
    "\n",
    "    for i in range(n_experiments):\n",
    "        print(i, time.ctime())\n",
    "\n",
    "        ### GPs Initialization\n",
    "        GP = GaussianProcess(d, lower_bound, upper_bound, noise_variance=2e-6)\n",
    "\n",
    "        #### Initial samples, at least 1\n",
    "        for l in range(initial_iter):\n",
    "            ## Get random evaluation point\n",
    "            x_rand = random_acq(GP)\n",
    "\n",
    "            ## EVALUATION OF THE OUTSIDE FUNCTION\n",
    "            y_rand = evaluation(x_rand)\n",
    "            GP.addSample(x_rand,y_rand)\n",
    "\n",
    "        GP.updateGP()\n",
    "        GP.optimizeKernel()\n",
    "        if False:\n",
    "            GP.plotSamples()\n",
    "\n",
    "        row = {\n",
    "            'exp_id' : i,\n",
    "            'testF' : testF,\n",
    "            'acqF': acqF,\n",
    "            'time': 0,\n",
    "            'ns' : len(GP.X),\n",
    "            'x'  : x_rand,\n",
    "            'y'  : y_rand,\n",
    "            'acq': 0\n",
    "        }\n",
    "        metrics = GP.evaluateOptimum(opt_val)\n",
    "        row.update(metrics)\n",
    "        if df is None:\n",
    "            df = pd.DataFrame({k: [v] for k, v in row.items()})\n",
    "        else:\n",
    "            df = pd.concat([df, pd.DataFrame({k: [v] for k, v in row.items()})])        \n",
    "\n",
    "        for l in range(total_iter):\n",
    "\n",
    "            ## Search of the best acquisition function\n",
    "            start = time.time()\n",
    "            #x_best, acq = SingleObjectiveAcq(function, GP)\n",
    "            x_best, acq = simulated_mes(GP, M = 5)\n",
    "            end = time.time()\n",
    "\n",
    "\n",
    "            ## EVALUATION OF THE OUTSIDE FUNCTION\n",
    "            y_best = evaluation(x_best)\n",
    "\n",
    "            #print(x_best, acq, y_best)\n",
    "            \n",
    "            ## UPDATE\n",
    "            GP.addSample(x_best,y_best)     ## Add new sample to the model\n",
    "            GP.updateGP()                   ## Update data on the GP regressor\n",
    "            GP.optimizeKernel()             ## Optimize kernel hyperparameters\n",
    "\n",
    "            ## Evaluate Pareto (distances and hypervolumes)\n",
    "            row = {\n",
    "                'exp_id' : i,\n",
    "                'testF' : testF,\n",
    "                'acqF': acqF,\n",
    "                'time': float(start-end),\n",
    "                'ns' : len(GP.X),\n",
    "                'x'  : x_best,\n",
    "                'y'  : y_best,\n",
    "                'acq': acq\n",
    "            }\n",
    "            metrics = GP.evaluateOptimum(opt_val)\n",
    "            row.update(metrics)\n",
    "\n",
    "            df = pd.concat([df, pd.DataFrame({k: [v] for k, v in row.items()})])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv(root_folder+\"/\"+testF+\"/\"+acqF+\".csv\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "5ff4c3eb246f2b52b7f298535ee10c6d55e8929659d135abbc88f0b5728f4230"
  },
  "kernelspec": {
   "display_name": "MOO-venv",
   "language": "python",
   "name": "moo-venv"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}