camphor-copper.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projective Preferential Bayesian Optimization: Campor/Cu(111)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"4\">In this notebook the user's belief about an optimal configuration can be elicited by using the [Projective Preferential Bayesian Optimization](https://arxiv.org/abs/2002.03113) framework. The test case is the adsorption of a non-symmetric bulky molecule camphor on the flat surface of (111)-plane terminated Cu slab.</font> \n",
    "\n",
    "Note: The last elicitation iteration may take while to finish."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(action='ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9e81c697409344fc9f0c1ef18d39f6fe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>div.output_scroll { height: 45em; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "sys.path.insert(1, os.getcwd()+'/src')\n",
    "sys.path.insert(1, os.getcwd()+'/camphor_copper')\n",
    "import time\n",
    "from datetime import datetime\n",
    "import numpy as np\n",
    "from gui import GUI_session, generate_optimal_configuration\n",
    "from gp_model import GPModel\n",
    "from ppbo_settings import PPBO_settings\n",
    "from acquisition import next_query\n",
    "from jupyter_ui_poll import run_ui_poll_loop\n",
    "from ipywidgets import VBox\n",
    "from IPython.display import display, IFrame, HTML, clear_output\n",
    "from IPython.core.display import display\n",
    "display(HTML(\"<style>div.output_scroll { height: 45em; }</style>\")) #Make outputwindow larger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Session configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "session_name = 'TEST'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Specify the aquisition strategy and the problem setting\n",
    "Acquisition startegies with unit projections ($\\boldsymbol{\\xi}$ is an unit vector):\n",
    "- PCD = preferential coordinate descent\n",
    "- EI-EXT = finds unit projection that maximizes EI, and x is set to xstar\n",
    "- EI-EXT-FAST = same as EI-EXT except $d\\mathbf{x}$ integral omitted\n",
    "- EI-VARMAX = same as EI-EXT except $\\mathbf{x}$ is chosen to maximize GP variance\n",
    "- EI-VARMAX-FAST = same as EI-VARMAX except $d\\mathbf{x}$ integral omitted\n",
    "\n",
    "Acquisition startegies with non-unit projections:\n",
    "- EI = expected improvement by projective preferential query\n",
    "- EI-FIXEDX = same as EI except $\\mathbf{x}$ is fixed to $\\textrm{argmax}_{\\mathbf{x}}\\mu(\\mathbf{x})$ (xstar)\n",
    "- EXT = pure exploitation\n",
    "- EXR = pure exploration (variance maximization)\n",
    "- RAND = random "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "acquisition_strategy = 'PCD'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "PPBO_settings = PPBO_settings(D=6,bounds=((-0.5,0.5),(-0.5,0.5),(4,7),(-180,180),(-180,180),(-180,180)),\n",
    "                              kernel = 'camphor_copper_kernel',theta_initial=[0.001,0.26,0.1],\n",
    "                              xi_acquisition_function=acquisition_strategy,verbose=False,\n",
    "                              skip_computations_during_initialization=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "original scale = a vector in the space ((-0.5,0.5),(-0.5,0.5),(4,7),(-180,180),(-180,180),(-180,180))<br>\n",
    "GP domain scale = a vector in the space ((0,1),(0,1),(0,1),(0,1),(0,1),(0,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Querying settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUMBER_OF_QUERIES = 14 # + 6 initial queries\n",
    "ADAPTIVE_INITIALIZATION = True  #At initilization: immediatly update the coordinate according to the user feedback"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set initial queries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of initial queries is: 6\n"
     ]
    }
   ],
   "source": [
    "initial_queries_xi = np.array([list(np.eye(6)[i]) for i in range(6)]) #Initial xi:s correspond to unit vectors\n",
    "if ADAPTIVE_INITIALIZATION:\n",
    "    initial_queries_x = np.array([[-0.5, -0.5, 5.0, -84.4, 142.8, 2.7],]*6) #1st coordinate does not have relevance\n",
    "else:\n",
    "    initial_queries_x = np.array([[-0.5, -0.5, 5.0, -84.4, 142.8, 2.7],]*6)\n",
    "    #initial_queries_x = np.random.uniform([PPBO_settings.original_bounds[i][0] for i in range(6)], [PPBO_settings.original_bounds[i][1] for i in range(6)], size=(6,6))\n",
    "print(\"Number of initial queries is: \" + str(len(initial_queries_xi)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Hyperparameter optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "OPTIMIZE_HYPERPARAMETERS_AFTER_EACH_ITERATION = False\n",
    "OPTIMIZE_HYPERPARAMETERS_AFTER_QUERY_NUMBER = 999"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialize the user session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "should_log = False\n",
    "if should_log:\n",
    "    orig_stdout = sys.stdout\n",
    "    log_file = open('camphor_copper/user_session_log_'+str(datetime.now().strftime(\"%d-%m-%Y_%H-%M-%S\"))+'.txt', \"w\")\n",
    "    sys.stdout = log_file\n",
    "GUI_ses = GUI_session(PPBO_settings)\n",
    "results_mustar = []\n",
    "results_xstar = []\n",
    "results_time = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Knowledge elicitation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PPBO event loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialization in progress... (6/6)\r"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "750cd1dab62f44c0ba7f8ef298bfec3b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(NGLWidget(max_frame=99), IntSlider(value=0, continuous_update=False, description='Confidence: '…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(len(initial_queries_xi)+NUMBER_OF_QUERIES):\n",
    "    if i < len(initial_queries_xi):\n",
    "        print(f'Initialization in progress... ({i+1}/{len(initial_queries_xi)})\\r', end=\"\")\n",
    "        if i==len(initial_queries_xi)-1:\n",
    "            GP_model_preference.turn_initialization_off()   \n",
    "    else:\n",
    "        print(f'Elicitation in progress... ({i+1-len(initial_queries_xi)}/{NUMBER_OF_QUERIES})\\r', end=\"\")\n",
    "        if i+1==len(initial_queries_xi)+NUMBER_OF_QUERIES:\n",
    "            GP_model_preference.set_last_iteration()\n",
    "    ''' Projective preferential query '''\n",
    "    if i < len(initial_queries_xi):\n",
    "        xi = initial_queries_xi[i].copy()\n",
    "        if not i==0 and GUI_ses.user_feedback_preference is not None and ADAPTIVE_INITIALIZATION:\n",
    "            initial_queries_x[i:,:] = GUI_ses.user_feedback_preference\n",
    "        x = initial_queries_x[i].copy()\n",
    "        x[xi!=0] = 0\n",
    "    else:\n",
    "        xi,x = next_query(PPBO_settings,GP_model_preference,unscale=True)\n",
    "    GUI_ses.initialize_iteration(x,xi)\n",
    "    ''' Event loop '''\n",
    "    view,button,slider = GUI_ses.getMiniGUI()\n",
    "    app = VBox([view,slider,button])\n",
    "    def wait_user_input():\n",
    "        if not GUI_ses.user_feedback_was_given:\n",
    "            pass\n",
    "            return None\n",
    "        app.close()\n",
    "        GUI_ses.user_feedback_was_given = False\n",
    "        GUI_ses.save_results()\n",
    "        return 1       \n",
    "    display(app)\n",
    "    query_presented = time.time()\n",
    "    dt = run_ui_poll_loop(wait_user_input)\n",
    "    time_spent = time.time() - query_presented\n",
    "    ''' Create GP model for first time '''\n",
    "    if i==0:\n",
    "        GP_model_preference = GPModel(PPBO_settings)\n",
    "    ''' Update GP model '''\n",
    "    GP_model_preference.update_feedback_processing_object(np.array(GUI_ses.results_preference))\n",
    "    GP_model_preference.update_data()\n",
    "    if i+1==OPTIMIZE_HYPERPARAMETERS_AFTER_QUERY_NUMBER:\n",
    "        GP_model_preference.update_model(optimize_theta=True)\n",
    "        print('Hyperparameters: ' + str(GP_model_preference.theta))\n",
    "    else:\n",
    "        GP_model_preference.update_model(optimize_theta=OPTIMIZE_HYPERPARAMETERS_AFTER_EACH_ITERATION)\n",
    "    results_mustar.append(GP_model_preference.mustar)\n",
    "    results_xstar.append(GP_model_preference.FP.unscale(GP_model_preference.xstar))\n",
    "    results_time.append(time_spent)\n",
    "    clear_output(wait=True)\n",
    "print(\"Elicitation done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Total time: \" + str(time.time()-start) + \" seconds.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xstar = GP_model_preference.xstar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generate html-file corresponding to the user's most preferred configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimal_molecule_html = generate_optimal_configuration(GP_model_preference.FP.unscale(xstar))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save the user session results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Save results to csv-file\n",
    "print(\"Saving the user session results...\")\n",
    "user_session_results = GUI_ses.results_preference.copy()\n",
    "user_session_results_confidence = GUI_ses.results_confidence.copy()\n",
    "user_session_results['iter_mustar'] = results_mustar\n",
    "user_session_results['iter_xstar_unscaled'] = results_xstar\n",
    "user_session_results['time_feedback'] = results_time\n",
    "user_session_results.to_csv('camphor_copper/' + str(session_name)+'_results_'+str(datetime.now().strftime(\"%d-%m-%Y_%H-%M-%S\"))+'.csv',index=False)\n",
    "user_session_results_confidence.to_csv('camphor_copper/' + str(session_name)+'_confidence_results_'+str(datetime.now().strftime(\"%d-%m-%Y_%H-%M-%S\"))+'.csv',index=False)\n",
    "#Close the log-file\n",
    "if should_log:\n",
    "    sys.stdout = orig_stdout\n",
    "    log_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyze the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### View the user's most preferred configuration\n",
    "<font color='red'>Press \"i\" to restore the default view</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IFrame(src=\"./camphor_copper/\"+str(optimal_molecule_html), width=900, height=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slice plots of the utility function (predictive mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plot_results as pr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pr.sliceplot_pred_mean('alpha','beta',GP_model_preference,xstar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pr.sliceplot_pred_mean('x','y',GP_model_preference,xstar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pr.sliceplot_pred_mean('z','gamma',GP_model_preference,xstar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The most preferred configuration (original scale): \" + str(list(GP_model_preference.FP.unscale(xstar))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The most preferred configuration (GP domain scale): \" + str(list(xstar)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The experiment results (for each iteration: preferred molecule and user feedback time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(HTML(user_session_results.iloc[:,14:].to_html()))"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}