{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction: Active Learning Cycle\n",
    "\n",
    "This notebook encompasses the comprehensive workflow of the active learning cycle, designed to iteratively improve the predictive accuracy of our model by intelligently selecting new data points for training. The cycle consists of the following steps:\n",
    "\n",
    "1. Load the Cleaned Data: Import the pre-processed and cleaned data set ready for integration and analysis.\n",
    "\n",
    "2. Integrate All Obtained Data: Combine data from various sources into a unified dataset for model training.\n",
    "\n",
    "3. Save the Integrated Data: Persist the integrated dataset to disk for reproducibility and future reference.\n",
    "\n",
    "4. Train a Predictive Model: Utilize the integrated data to train a machine learning model capable of predicting target variables with high accuracy.\n",
    "\n",
    "5. Save the Predictive Model: Save the trained model to ensure that it can be reused without retraining.\n",
    "\n",
    "6. Create a Grid in the Feature Space: Generate a comprehensive grid that spans the entire feature space under consideration.\n",
    "\n",
    "7. Extract a Subset of the Grid that is Experimentally Feasible: Identify and isolate parts of the grid that are viable for experimental verification based on predefined criteria.\n",
    "\n",
    "8. Predict the Target Value in the Subset: Use the trained model to predict target values for the experimentally feasible subset.\n",
    "\n",
    "9. Save the Predicted Properties of the Subset: Store the predictions to guide future experimental endeavors.\n",
    "\n",
    "10. Acquire Data Based on Predicted Properties: Select new data points for acquisition based on the model's predictions and a tiered acquisition strategy, aiming to maximize the model's learning.\n",
    "\n",
    "\n",
    "11. Save the Acquired Data: Document the newly acquired data points to refine the model in subsequent learning cycles.\n",
    "\n",
    "By following this structured approach, we aim to efficiently navigate the feature space, prioritize experimental efforts, and iteratively refine our model's predictive capability. This cycle is pivotal in harnessing the potential of active learning to address complex problems with an evolving data-driven strategy."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Libraries\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "\n",
    "import numpy as np \n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import scipy \n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import statsmodels.api as sm\n",
    "import random\n",
    "import sklearn\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.metrics import f1_score, mean_squared_error, r2_score, make_scorer, mean_absolute_percentage_error, mean_absolute_error\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn import svm, neighbors\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.model_selection import ShuffleSplit\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import preprocessing\n",
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn.gaussian_process.kernels import DotProduct, WhiteKernel, RBF, Matern, RationalQuadratic, ConstantKernel\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import pandas as pd\n",
    "import plotly.express as px\n",
    "\n",
    "from tqdm import tqdm\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "import inspect\n",
    "import sys\n",
    "\n",
    "script_path = inspect.getframeinfo(inspect.currentframe()).filename\n",
    "script_dir = os.path.dirname(os.path.abspath(script_path))\n",
    "sys.path.append(script_dir)\n",
    "\n",
    "import lithium_brine_ml as lbml"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_from_dict(data_dict_address):\n",
    "    '''This function loads dataframes from excel files and returns a dictionary of dataframes.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    data_dict_address: dictionary of addresses of excel files\n",
    "        dictionary\n",
    "        \n",
    "    Returns:\n",
    "    -------\n",
    "    data_dict: dictionary of dataframes\n",
    "        dictionary'''\n",
    "        \n",
    "    data_dict = {}\n",
    "    \n",
    "    # load dataframes from excel files:\n",
    "    \n",
    "    for key in data_dict_address.keys():\n",
    "        \n",
    "        data_dict[key] = pd.read_excel(data_dict_address[key])\n",
    "        \n",
    "    return data_dict\n",
    "\n",
    "\n",
    "def dataframe_format_correction(data_dict, label1, label2):\n",
    "    '''\n",
    "    This function changes the column names/labels to the same format for all dataframes.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    data_dict: dictionary of dataframes\n",
    "        dictionary of pd.DataFrame\n",
    "        \n",
    "    label1: list of old column names\n",
    "        list\n",
    "        \n",
    "    label2: list of new column names\n",
    "        list\n",
    "        \n",
    "    Returns:\n",
    "    -------\n",
    "    data_corrected_labels: dictionary of dataframes with corrected labels\n",
    "        dictionary of pd.DataFrame'''\n",
    "    \n",
    "    data_corrected_labels = {}\n",
    "    \n",
    "    # for each dataframe in the dictionary:\n",
    "    # change the column names/labels to the same format for all dataframes\n",
    "    # label1 list of old column names and label2 list of new column names\n",
    "    \n",
    "    for key in data_dict.keys():\n",
    "        \n",
    "        data_corrected_labels[key] = data_dict[key].rename(columns=dict(zip(label1, label2)))\n",
    "    \n",
    "    return data_corrected_labels\n",
    "\n",
    "\n",
    "def basic_clean(data_dict, eps=0.01):\n",
    "    '''\n",
    "    This function cleans the dataframes by removing NaN values and replacing 0 values with eps.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    data_dict: dictionary of dataframes\n",
    "        dictionary of pd.DataFrame\n",
    "    \n",
    "    eps: small number to replace 0 values\n",
    "        float\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    data_cleaned: dictionary of cleaned dataframes\n",
    "        dictionary of pd.DataFrame\n",
    "    '''\n",
    "    data_cleaned = {}\n",
    "    \n",
    "    for key in data_dict.keys():\n",
    "        data_cleaned[key] = data_dict[key].dropna()\n",
    "        data_cleaned[key]['yield'] = data_dict[key]['yield'].apply(lambda x: x+eps if x==0 else x)\n",
    "        \n",
    "    return data_cleaned\n",
    "\n",
    "def data_integration(data_dict):\n",
    "    ''' \n",
    "    This function integrates the dataframes in the dictionary into one dataframe.\n",
    "    \n",
    "    Parameter:\n",
    "    ----------\n",
    "    data_dict: dictionary of dataframes\n",
    "        dictionary of pd.DataFrame\n",
    "    \n",
    "    Return:\n",
    "    -------\n",
    "    data_integrated: integrated dataframe\n",
    "        pd.DataFrame\n",
    "    '''\n",
    "    \n",
    "    data_integrated = pd.DataFrame()\n",
    "    \n",
    "    for key in data_dict.keys():\n",
    "        data_integrated = pd.concat([data_integrated, data_dict[key]])\n",
    "    \n",
    "    data_integrated = data_integrated.reset_index(drop=True)\n",
    "    \n",
    "    return data_integrated\n",
    "\n",
    "\n",
    "def fact_check(combination):\n",
    "    '''\n",
    "    Checking if the nominated data (suggested experiment) satisfies acquisition guidlines or not\n",
    "    \n",
    "    Parameter:\n",
    "    ----------\n",
    "    combination: an array containing the experiment combinations. \n",
    "                     The combination of data must follow below order: \n",
    "                     [{C} , {N}, {Li}, {T}]\n",
    "    Returens: \n",
    "    ----------\n",
    "    check: True if all the criteria are satisfied, False if not \n",
    "    \n",
    "    '''\n",
    "    #print(combination)\n",
    "    \n",
    "    c = combination[0]\n",
    "    n = combination[1]\n",
    "    l = combination[2]\n",
    "    \n",
    "    c_total_limit = 0.5 * n\n",
    "    \n",
    "    \n",
    "    if n > 6:\n",
    "        return False\n",
    "    \n",
    "    if c > c_total_limit:\n",
    "        return False\n",
    "    \n",
    "    if c > 2.5: \n",
    "        return False\n",
    "    \n",
    "    if l > 6 or l <= 0:\n",
    "        return False\n",
    "    \n",
    "    if c < (l/2):\n",
    "        return False\n",
    "    \n",
    "    #print('n: ', n, ' || n_total: ',n_total, ' || c: ', c, \" || c_total_limit: \", c_total_limit, \" || Li: \", l)\n",
    "    return True \n",
    "\n",
    "def df_scaler(fit_df, transform_df, labels_list = ['init_C', 'init_N', 'init_Li', 'T']):\n",
    "    '''\n",
    "    Recieves two dataframes and scales the second dataframe using the first dataframe\n",
    "    Parameters:\n",
    "    ----------\n",
    "    fit_df: the dataframe to be used for fitting the scaler\n",
    "        pd.DataFrame\n",
    "        \n",
    "    transform_df: the dataframe to be scaled\n",
    "        pd.DataFrame\n",
    "        \n",
    "    labels_list: the list of labels to be used for scaling\n",
    "        list\n",
    "    \n",
    "    Returns:\n",
    "    ----------\n",
    "    scaled_df: the scaled dataframe\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    # using the batch containing all the data scale the experimental grid\n",
    "    scaler = preprocessing.StandardScaler().fit(fit_df[labels_list])\n",
    "    scaled_df = scaler.transform(transform_df[labels_list])\n",
    "    \n",
    "    return scaled_df\n",
    "\n",
    "def entropy_measure(std_list):\n",
    "    '''\n",
    "    The function is used to calculate the entropy of the standard deviation of the model prediction\n",
    "    \n",
    "    Parameters:\n",
    "    ------------\n",
    "        std_list: the list of the standard deviation of the model prediction\n",
    "            list\n",
    "            \n",
    "    Returns:\n",
    "    ------------\n",
    "        entropy: the entropy of the standard deviation of the model prediction\n",
    "            float\n",
    "    '''\n",
    "    \n",
    "    std_list = np.array(std_list)\n",
    "    # entropy = ln(std*root(2*pi*e))\n",
    "    entropy = np.log(std_list * np.sqrt(2*np.pi*np.e))\n",
    "    \n",
    "    return entropy\n",
    "\n",
    "\n",
    "def binary_model_plot(model, scaler, range_a, range_b, val_c,\n",
    "                      label_a, label_b , label_c , T = 66,\n",
    "                      entropy_contour=False, std_contour=True, yield_contour=True):\n",
    "    '''\n",
    "    The function is used to plot the binary contour plot of the model prediction\n",
    "\n",
    "    Parameters:\n",
    "    ------------\n",
    "        model: the model to predict the yield\n",
    "            SKlearn model object\n",
    "            \n",
    "        scaler: the scaler used to scale the data\n",
    "            SKlearn scaler object\n",
    "            \n",
    "        range_a: the range of the first parameter\n",
    "            tuple\n",
    "            \n",
    "        range_b: the range of the second parameter\n",
    "            tuple\n",
    "            \n",
    "        val_c: the value of the third parameter\n",
    "            float\n",
    "            \n",
    "        label_a: the label of the first parameter\n",
    "            string\n",
    "            \n",
    "        label_b: the label of the second parameter\n",
    "            string\n",
    "            \n",
    "        label_c: the label of the third parameter\n",
    "            string\n",
    "            \n",
    "        T: the temperature of the experiment\n",
    "            float\n",
    "            \n",
    "        entropy_contour: if True, the entropy contour will be plotted\n",
    "            bool\n",
    "            \n",
    "        std_contour: if True, the standard deviation contour will be plotted\n",
    "            bool\n",
    "        \n",
    "        yield_contour: if True, the yield contour will be plotted\n",
    "            bool\n",
    "        \n",
    "    Returns:\n",
    "    ------------\n",
    "    none\n",
    "        \n",
    "        '''\n",
    "    \n",
    "    a_list = np.linspace(range_a[0], range_a[1], 50)\n",
    "    b_list = np.linspace(range_b[0], range_b[1], 50)\n",
    "\n",
    "    a_mesh, b_mesh = np.meshgrid(a_list, b_list)\n",
    "    yield_mesh = a_mesh.copy()\n",
    "    std_mesh = a_mesh.copy()\n",
    "    entropy_mesh = a_mesh.copy()\n",
    "    \n",
    "    for i in tqdm(range(len(a_list))):\n",
    "        for j in range(len(b_list)):\n",
    "            x_df = pd.DataFrame({label_a: a_mesh[i,j],\n",
    "                                 label_b : b_mesh[i,j],\n",
    "                                 label_c : [val_c],\n",
    "                                 'T':[T]})\n",
    "            # it is crucial to rearrange the columns in the same order as the training data!!!\n",
    "            x_df = x_df[['init_C', 'init_N', 'init_Li', 'T']]\n",
    "            \n",
    "            scaled_grid = scaler.transform(x_df)\n",
    "            yield_mesh[i,j], std_mesh[i,j] = model.predict(scaled_grid, return_std=True)\n",
    "            if entropy_contour:\n",
    "                entropy_mesh[i,j] = entropy_measure(std_mesh[i,j])\n",
    "            \n",
    "    plt.figure()\n",
    "    \n",
    "    plt.contourf(a_mesh, b_mesh, yield_mesh, 100, cmap = 'viridis')\n",
    "    cbar = plt.colorbar()\n",
    "    \n",
    "    if std_contour:\n",
    "        contour1 = plt.contour(a_mesh, b_mesh, std_mesh, colors = 'red')\n",
    "        plt.clabel(contour1, inline=True, fontsize=8)\n",
    "    \n",
    "    if yield_contour:\n",
    "        contour2 = plt.contour(a_mesh, b_mesh, yield_mesh, colors = 'black')\n",
    "        plt.clabel(contour2, inline=True, fontsize=8)\n",
    "    \n",
    "    if entropy_contour:\n",
    "        contour3 = plt.contour(a_mesh, b_mesh, entropy_mesh, colors = 'blue')\n",
    "        plt.clabel(contour3, inline=True, fontsize=8)\n",
    "    \n",
    "        \n",
    "    \n",
    "    plt.xlabel(label_a)\n",
    "    plt.ylabel(label_b)\n",
    "    cbar.ax.set_ylabel('Yield')\n",
    "    plt.title(label_c + \": \" + str(val_c))\n",
    "    plt.show()\n",
    "    plt.tight_layout()\n",
    "    \n",
    "    return\n",
    "\n",
    "\n",
    "def model_scaler_setup(model, train_df, labels_list = ['init_C', 'init_N', 'init_Li', 'T'], target = 'yield'):\n",
    "    '''\n",
    "    This function takes in a model, training data, and the labels and target of the training data and returns the trained model and scaler.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    model: sklearn model\n",
    "    \n",
    "    train_df: pandas dataframe\n",
    "    \n",
    "    labels_list: list of strings\n",
    "    \n",
    "    target: string\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    model: fitted sklearn model \n",
    "    \n",
    "    scaler: fitted sklearn scaler\n",
    "    \n",
    "    '''\n",
    "    # Define the scaler \n",
    "    scaler = preprocessing.StandardScaler().fit(train_df[labels_list])\n",
    "    scaled_batch = scaler.transform(train_df[labels_list])\n",
    "    \n",
    "    # train the model on scaled data\n",
    "    model.fit(scaled_batch, train_df[target])\n",
    "    \n",
    "    return model, scaler\n",
    "\n",
    "# Create a grid for the prediction space:\n",
    "\n",
    "def create_exp_grid(label_a = \"init_C\", label_b = \"init_N\", label_c = \"init_Li\", label_d= \"T\",\n",
    "                    range_a = (0,2.5), range_b = (0,6), range_c = (0,6), range_d = (66,66)\n",
    "                    ):\n",
    "    '''\n",
    "    This function creates a grid of experimental conditions for the model to predict.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    label_a: string\n",
    "    \n",
    "    label_b: string\n",
    "    \n",
    "    label_c: string\n",
    "    \n",
    "    label_d: string\n",
    "    \n",
    "    range_a: tuple\n",
    "    \n",
    "    range_b: tuple\n",
    "    \n",
    "    range_c: tuple\n",
    "    \n",
    "    range_d: tuple\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    exp_grid: pandas dataframe\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    exp_grid = pd.DataFrame({label_a:[], label_b : [], label_c : [], label_d: []})\n",
    "    \n",
    "    for a in tqdm(np.linspace(range_a[0], range_a[1], 16)):\n",
    "        for b in np.linspace(range_b[0],range_b[1],37):\n",
    "            for c in np.linspace(range_c[0],range_c[1],37):\n",
    "                for d in np.linspace(range_d[0],range_d[1],1):\n",
    "                    x_df = pd.DataFrame({label_a:[a],\n",
    "                                         label_b : [b],\n",
    "                                         label_c : [c],\n",
    "                                         label_d: [d]})\n",
    "                    exp_grid = exp_grid.append(x_df)\n",
    "    \n",
    "    return exp_grid\n",
    "    \n",
    "    \n",
    "def grid_feasibility(data_df, label_a = \"init_C\", label_b = \"init_N\", label_c = \"init_Li\", label_d= \"T\"):\n",
    "    '''This function takes in a dataframe of experimental conditions and returns a list of booleans indicating whether the conditions are feasible or not.\n",
    "    Parameters:\n",
    "    ----------\n",
    "    data_df: pandas dataframe\n",
    "    \n",
    "    label_a: string\n",
    "    \n",
    "    label_b: string\n",
    "    \n",
    "    label_c: string\n",
    "    \n",
    "    label_d: string\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    data_df: pandas dataframe'''    \n",
    "    fact_check_list = []\n",
    "    \n",
    "    for i in tqdm(range(len(data_df))):\n",
    "        fact_check_list.append(fact_check([data_df[label_a][i],\n",
    "                                           data_df[label_b][i],\n",
    "                                           data_df[label_c][i],\n",
    "                                           data_df[label_d][i]]))\n",
    "    \n",
    "    data_df['fact_check'] = fact_check_list\n",
    "    \n",
    "    return data_df\n",
    "\n",
    "\n",
    "def scale_dataframe(exp_grid, train_df, labels_list = ['init_C', 'init_N', 'init_Li', 'T']):\n",
    "    '''This function takes in a dataframe of experimental conditions and returns the scaled dataframe.\n",
    "    Parameters:\n",
    "    ----------\n",
    "    exp_grid: pandas dataframe\n",
    "    \n",
    "    train_df: pandas dataframe\n",
    "    \n",
    "    labels_list: list of strings\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    exp_grid: pandas dataframe with scaled columns'''\n",
    "    \n",
    "    # Define the scaler \n",
    "    scaler = preprocessing.StandardScaler().fit(train_df[labels_list])\n",
    "    scaled_batch = scaler.transform(train_df[labels_list])\n",
    "    \n",
    "    # scale the experimental grid\n",
    "    scaled_exp_grid = scaler.transform(exp_grid[labels_list])\n",
    "    \n",
    "    exp_grid['scl_'+labels_list[0]] = scaled_exp_grid[:,0]\n",
    "    exp_grid['scl_'+labels_list[1]] = scaled_exp_grid[:,1]\n",
    "    exp_grid['scl_'+labels_list[2]] = scaled_exp_grid[:,2]\n",
    "    exp_grid['scl_'+labels_list[3]] = scaled_exp_grid[:,3]\n",
    "    \n",
    "    return exp_grid\n",
    "\n",
    "\n",
    "\n",
    "def euclidean_distance(input_batch, vector, n_components = 3):\n",
    "    '''\n",
    "    Finds the minimum euclidean distance between a batch of vector (batch, np.arrays) and a new vector (experiment, np.array)\n",
    "    \n",
    "    Parameters:\n",
    "    -----------\n",
    "    input_batch: 2D np array (a set of vectors)\n",
    "    vector: 1D np array (a vector)\n",
    "    \n",
    "    Returne:\n",
    "    -----------\n",
    "    min_distance: minimum Euclidean distance of the vector to the batch \n",
    "    \n",
    "    '''\n",
    "    \n",
    "    batch_np = np.array(input_batch)\n",
    "    vector_np = np.array(vector)\n",
    "    \n",
    "\n",
    "    dislocation = batch_np[0, 0:n_components] - vector_np[0:n_components]\n",
    "    min_distance = np.linalg.norm(dislocation)\n",
    "\n",
    "    for i in range(len(batch_np)):\n",
    "        dislocation = batch_np[i,0:n_components] - vector_np[0:n_components]\n",
    "        distance = np.linalg.norm(dislocation)\n",
    "        \n",
    "        if min_distance > distance:\n",
    "            min_distance = distance\n",
    "    \n",
    "    return min_distance\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def tierd_greedy_acquisition(exp_grid_df, train_df, tier1_label = 'std', tier2_label = 'gpr_yield', \n",
    "                             tier1_acquisition = 12, tier2_acquisition = 6, tier3_acquisition = 6, min_distance = 0.5):\n",
    "    \"\"\"\n",
    "    data_df: dataframe with columns 'std' and 'gpr_yield'\n",
    "    tier1_label: column name for the first tier of acquisition\n",
    "    tier2_label: column name for the second tier of acquisition\n",
    "    n: number of samples to acquire\n",
    "    \"\"\"\n",
    "    acquisition_batch = []\n",
    "    control_batch = train_df[['init_C', 'init_N', 'init_Li']].values\n",
    "    temp_df = exp_grid_df.copy()\n",
    "    # sort the dataframe by the first tier\n",
    "    temp_df = temp_df.sort_values(by=tier1_label, ascending=False)\n",
    "    temp_df.reset_index(drop=True)\n",
    "    \n",
    "    acquisition_counter = 0 \n",
    "    row_counter = 0\n",
    "    while acquisition_counter < tier1_acquisition:\n",
    "        if euclidean_distance(control_batch, temp_df.iloc[row_counter, 0:3].values) > min_distance and temp_df.iloc[row_counter][\"fact_check\"]==True:\n",
    "            acquisition_batch.append(temp_df.iloc[row_counter])\n",
    "            control_batch = np.append(control_batch, [temp_df.iloc[row_counter, 0:3]], axis=0)\n",
    "            acquisition_counter += 1\n",
    "        \n",
    "        row_counter += 1\n",
    "    \n",
    "    acquisition_counter = 0 \n",
    "    row_counter = 0\n",
    "    temp_df = temp_df.sort_values(by=tier2_label, ascending=False)\n",
    "    temp_df.reset_index(drop=True)\n",
    "    while acquisition_counter < tier2_acquisition:\n",
    "        if euclidean_distance(control_batch, temp_df.iloc[row_counter, 0:3].values) > min_distance and temp_df.iloc[row_counter][\"fact_check\"]==True:\n",
    "            acquisition_batch.append(temp_df.iloc[row_counter])\n",
    "            control_batch = np.append(control_batch, [temp_df.iloc[row_counter, 0:3]], axis=0)\n",
    "            acquisition_counter += 1\n",
    "        \n",
    "        row_counter += 1\n",
    "    \n",
    "    acquisition_counter = 0 \n",
    "    while acquisition_counter < tier3_acquisition:\n",
    "        row_counter = random.randint(0,len(exp_grid_df)-1)\n",
    "        if euclidean_distance(control_batch, temp_df.iloc[row_counter, 0:3].values) > min_distance and temp_df.iloc[row_counter][\"fact_check\"]==True:\n",
    "            acquisition_batch.append(temp_df.iloc[row_counter])\n",
    "            control_batch = np.append(control_batch, [temp_df.iloc[row_counter, 0:3]], axis=0)\n",
    "            acquisition_counter += 1\n",
    "        \n",
    "    acquisition_df = pd.DataFrame(acquisition_batch, columns = ['init_C', 'init_N', 'init_Li', 'T', 'gpr_yield', 'std', 'fact_check'])\n",
    "    \n",
    "    acquisition_type = []\n",
    "    for i in range(len(acquisition_df)):\n",
    "        if i < tier1_acquisition:\n",
    "            acquisition_type.append(tier1_label)\n",
    "        elif i < tier1_acquisition + tier2_acquisition:\n",
    "            acquisition_type.append(tier2_label)\n",
    "        else:\n",
    "            acquisition_type.append('random')\n",
    "        \n",
    "    acquisition_df['acquisition'] = acquisition_type\n",
    "    \n",
    "    return acquisition_df\n",
    "    \n",
    "\n",
    "def binary_model_plot(model, scaler, range_a, range_b, val_c,\n",
    "                      label_a, label_b , label_c , T = 66,\n",
    "                      entropy_contour=False, std_contour=True, yield_contour=True):\n",
    "    '''\n",
    "    The function is used to plot the binary contour plot of the model prediction\n",
    "\n",
    "    Parameters:\n",
    "    ------------\n",
    "        model: the model to predict the yield\n",
    "            SKlearn model object\n",
    "            \n",
    "        scaler: the scaler used to scale the data\n",
    "            SKlearn scaler object\n",
    "            \n",
    "        range_a: the range of the first parameter\n",
    "            tuple\n",
    "            \n",
    "        range_b: the range of the second parameter\n",
    "            tuple\n",
    "            \n",
    "        val_c: the value of the third parameter\n",
    "            float\n",
    "            \n",
    "        label_a: the label of the first parameter\n",
    "            string\n",
    "            \n",
    "        label_b: the label of the second parameter\n",
    "            string\n",
    "            \n",
    "        label_c: the label of the third parameter\n",
    "            string\n",
    "            \n",
    "        T: the temperature of the experiment\n",
    "            float\n",
    "            \n",
    "        entropy_contour: if True, the entropy contour will be plotted\n",
    "            bool\n",
    "            \n",
    "        std_contour: if True, the standard deviation contour will be plotted\n",
    "            bool\n",
    "        \n",
    "        yield_contour: if True, the yield contour will be plotted\n",
    "            bool\n",
    "        \n",
    "    Returns:\n",
    "    ------------\n",
    "    none\n",
    "        \n",
    "        '''\n",
    "    \n",
    "    a_list = np.linspace(range_a[0], range_a[1], 50)\n",
    "    b_list = np.linspace(range_b[0], range_b[1], 50)\n",
    "\n",
    "    a_mesh, b_mesh = np.meshgrid(a_list, b_list)\n",
    "    yield_mesh = a_mesh.copy()\n",
    "    std_mesh = a_mesh.copy()\n",
    "    entropy_mesh = a_mesh.copy()\n",
    "    \n",
    "    for i in tqdm(range(len(a_list))):\n",
    "        for j in range(len(b_list)):\n",
    "            x_df = pd.DataFrame({label_a: a_mesh[i,j],\n",
    "                                 label_b : b_mesh[i,j],\n",
    "                                 label_c : [val_c],\n",
    "                                 'T':[T]})\n",
    "            # it is crucial to rearrange the columns in the same order as the training data!!!\n",
    "            x_df = x_df[['init_C', 'init_N', 'init_Li', 'T']]\n",
    "            \n",
    "            scaled_grid = scaler.transform(x_df)\n",
    "            yield_mesh[i,j], std_mesh[i,j] = model.predict(scaled_grid, return_std=True)\n",
    "            if entropy_contour:\n",
    "                entropy_mesh[i,j] = entropy_measure(std_mesh[i,j])\n",
    "            \n",
    "    plt.figure()\n",
    "    \n",
    "    plt.contourf(a_mesh, b_mesh, yield_mesh, 100, cmap = 'viridis')\n",
    "    cbar = plt.colorbar()\n",
    "    \n",
    "    if std_contour:\n",
    "        contour1 = plt.contour(a_mesh, b_mesh, std_mesh, colors = 'red')\n",
    "        plt.clabel(contour1, inline=True, fontsize=8)\n",
    "    \n",
    "    if yield_contour:\n",
    "        contour2 = plt.contour(a_mesh, b_mesh, yield_mesh, colors = 'black')\n",
    "        plt.clabel(contour2, inline=True, fontsize=8)\n",
    "    \n",
    "    if entropy_contour:\n",
    "        contour3 = plt.contour(a_mesh, b_mesh, entropy_mesh, colors = 'blue')\n",
    "        plt.clabel(contour3, inline=True, fontsize=8)\n",
    "    \n",
    "        \n",
    "    \n",
    "    plt.xlabel(label_a)\n",
    "    plt.ylabel(label_b)\n",
    "    cbar.ax.set_ylabel('Yield')\n",
    "    plt.title(label_c + \": \" + str(val_c))\n",
    "    plt.show()\n",
    "    plt.tight_layout()\n",
    "    \n",
    "    return\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1- Load the Cleaned Data \n",
    "\n",
    "Import the pre-processed and cleaned data set ready for integration and analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Instructions for users:\n",
    "# Update the file_paths list below with the actual paths to your cleaned data files.\n",
    "# These paths should point to the Excel files containing the data from each batch you wish to load.\n",
    "# Ensure the format is correct and consistent with your operating system's path conventions.\n",
    "# Example format for Windows: \"data\\\\clean\\\\batch0.xlsx\"\n",
    "# Example format for Unix/Linux: \"data/clean/batch0.xlsx\"\n",
    "\n",
    "file_paths = [\n",
    "    'data/clean/batch0.xlsx',  # Update this path to your first batch file\n",
    "    'data/clean/batch1.xlsx',  # Update this path to your second batch file\n",
    "    'data/clean/batch2.xlsx'   # Update this path to your third batch file\n",
    "    # Add more paths as needed for additional batches\n",
    "]\n",
    "\n",
    "# Initialize a list to store the loaded data from each batch\n",
    "data_batches = []\n",
    "\n",
    "# Loop through the file paths, loading each file's data into a DataFrame\n",
    "# and appending it to the data_batches list.\n",
    "for path in file_paths:\n",
    "    # Load the Excel file into a DataFrame\n",
    "    data = pd.read_excel(path)\n",
    "    # Append the loaded data to the data_batches list\n",
    "    data_batches.append(data)\n",
    "\n",
    "# At this point, data_batches contains a list of DataFrames,\n",
    "# each representing the data from one of the specified files.\n",
    "# You can now proceed with integrating and analyzing these DataFrames as needed.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2- Integrate All Obtained Data\n",
    "\n",
    "\n",
    "Combine data from various sources into a unified dataset for model training.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instructions for users:\n",
    "# At this point, it's assumed that you have a list of DataFrames named `data_batches`,\n",
    "# each containing data from different batches as loaded in the previous step.\n",
    "\n",
    "# To integrate all the obtained data into a single DataFrame for model training,\n",
    "# we use the pandas concat function. This function effectively merges the list of\n",
    "# DataFrames into one, stacking them vertically (one on top of the other) by default.\n",
    "\n",
    "# Integrate all obtained data from the different batches\n",
    "data = pd.concat(data_batches, ignore_index=True)\n",
    "\n",
    "# The `ignore_index=True` parameter is used to reindex the new DataFrame. This is useful\n",
    "# when the original DataFrames have their own indices that might overlap; reindexing\n",
    "# prevents any potential issues with duplicate indices.\n",
    "\n",
    "# At this stage, `data` is a unified DataFrame containing all the data from the different batches.\n",
    "# This integrated dataset is now ready for further processing, such as cleaning, exploration,\n",
    "# and model training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data inspection: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Telescope_id</th>\n",
       "      <th>exp_id</th>\n",
       "      <th>init_C</th>\n",
       "      <th>init_N</th>\n",
       "      <th>init_Li</th>\n",
       "      <th>T</th>\n",
       "      <th>fini_Li</th>\n",
       "      <th>yield</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CS-NRCan-014_A1</td>\n",
       "      <td>B0-0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>4.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>66</td>\n",
       "      <td>0.720406</td>\n",
       "      <td>0.279594</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CS-NRCan-014_A2</td>\n",
       "      <td>B0-1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>4.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>66</td>\n",
       "      <td>0.660309</td>\n",
       "      <td>0.339691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CS-NRCan-014_A3</td>\n",
       "      <td>B0-2</td>\n",
       "      <td>1.5</td>\n",
       "      <td>4.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>66</td>\n",
       "      <td>0.735669</td>\n",
       "      <td>0.264331</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>CS-NRCan-014_A5</td>\n",
       "      <td>B0-3</td>\n",
       "      <td>1.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>66</td>\n",
       "      <td>0.621322</td>\n",
       "      <td>0.378678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CS-NRCan-014_A6</td>\n",
       "      <td>B0-4</td>\n",
       "      <td>1.5</td>\n",
       "      <td>6.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>66</td>\n",
       "      <td>0.655983</td>\n",
       "      <td>0.344017</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Telescope_id exp_id  init_C  init_N  init_Li   T   fini_Li     yield\n",
       "0  CS-NRCan-014_A1   B0-0     0.5     4.5      1.0  66  0.720406  0.279594\n",
       "1  CS-NRCan-014_A2   B0-1     1.0     4.5      1.0  66  0.660309  0.339691\n",
       "2  CS-NRCan-014_A3   B0-2     1.5     4.5      1.0  66  0.735669  0.264331\n",
       "3  CS-NRCan-014_A5   B0-3     1.0     6.0      1.0  66  0.621322  0.378678\n",
       "4  CS-NRCan-014_A6   B0-4     1.5     6.0      1.0  66  0.655983  0.344017"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dcf01336058c424b9fbf1135571fde95",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,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' width=719.9999999999999/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Assuming 'data' is your DataFrame\n",
    "\n",
    "# Set the size of each subplot with the 'height' parameter.\n",
    "# 'aspect' controls the width of each subplot relative to its height; aspect=1 means each plot is square.\n",
    "pairplot = sns.pairplot(data, height=1.2, aspect=1)\n",
    "\n",
    "# Adjust overall figure size if necessary\n",
    "plt.subplots_adjust(top=0.9)\n",
    "plt.suptitle('Pairplot of Data', fontsize=12)  # Add a title to the figure\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3- Save the Integrated Data:\n",
    "\n",
    "Persist the integrated dataset to disk for reproducibility and future reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "\n",
    "# Assuming `data` is your integrated DataFrame and you want to save it as 'new_data_integrated'\n",
    "\n",
    "# Get the current date and time in the format Year-Month-Day_Hour-Minute-Second\n",
    "# This ensures that each file saved has a unique name based on the exact time it was saved.\n",
    "now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n",
    "\n",
    "# Define the path and filename with the current timestamp\n",
    "# Adjust the directory path as needed for your project's file organization.\n",
    "file_path = f'data/clean/new_data_{now}.xlsx'\n",
    "\n",
    "# Save the DataFrame as an Excel file using the path and filename defined above\n",
    "# If you're using a Windows system, you might need to use double backslashes (\\\\) or raw string literals (r'path')\n",
    "data.to_excel(file_path, index=False)\n",
    "\n",
    "# Note: The `index=False` parameter is used to prevent pandas from writing row indices into the Excel file.\n",
    "# If your data's index carries meaningful information, you might want to omit this parameter.\n",
    "\n",
    "# This command will save your integrated data to the specified path with a timestamp,\n",
    "# making it easy to identify and access specific versions of your data.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4- Train a Predictive Model\n",
    "\n",
    "Utilize the integrated data to train a machine learning model capable of predicting target variables with high accuracy."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature and target selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Selecting the features and the target from the dataset. The features include initial concentrations\n",
    "# and temperature ('init_C', 'init_N', 'init_Li'), and the target is the yield ('yield').\n",
    "x_train = data[['init_C', 'init_N', 'init_Li']]\n",
    "y_train = data['yield']\n",
    "\n",
    "# Scaling the features to standardize them. This is crucial for models that are sensitive to\n",
    "# the scale of the input features, such as Gaussian Process Regressors.\n",
    "scaler = preprocessing.StandardScaler().fit(x_train)\n",
    "x_train_scaled = scaler.transform(x_train)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the models and hyperparameters tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 72 candidates, totalling 360 fits\n",
      "                                               params  mean_test_score  \\\n",
      "0                    {'alpha': 1e-05, 'kernel': 1**2}        -0.219749   \n",
      "1     {'alpha': 1e-05, 'kernel': RBF(length_scale=1)}        -0.108052   \n",
      "2   {'alpha': 1e-05, 'kernel': RBF(length_scale=0.5)}        -0.108052   \n",
      "3    {'alpha': 1e-05, 'kernel': RBF(length_scale=10)}        -0.187659   \n",
      "4   {'alpha': 1e-05, 'kernel': RBF(length_scale=100)}        -0.187659   \n",
      "..                                                ...              ...   \n",
      "67  {'alpha': 100.0, 'kernel': RBF(length_scale=100)}        -0.315294   \n",
      "68  {'alpha': 100.0, 'kernel': Matern(length_scale...        -0.422865   \n",
      "69  {'alpha': 100.0, 'kernel': Matern(length_scale...        -0.315298   \n",
      "70  {'alpha': 100.0, 'kernel': Matern(length_scale...        -0.315299   \n",
      "71  {'alpha': 100.0, 'kernel': WhiteKernel(noise_l...        -0.427234   \n",
      "\n",
      "    std_test_score  \n",
      "0         0.113909  \n",
      "1         0.092560  \n",
      "2         0.092560  \n",
      "3         0.163989  \n",
      "4         0.163989  \n",
      "..             ...  \n",
      "67        0.069801  \n",
      "68        0.139160  \n",
      "69        0.069796  \n",
      "70        0.069796  \n",
      "71        0.141448  \n",
      "\n",
      "[72 rows x 3 columns]\n",
      "==================================================\n",
      "Best parameters for GPR: {'alpha': 0.01, 'kernel': Matern(length_scale=0.5, nu=1.5)}\n",
      "Best score: -0.05234413020655955\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn.gaussian_process.kernels import WhiteKernel, RBF, Matern, ConstantKernel as C\n",
    "from sklearn.metrics import make_scorer, mean_absolute_error\n",
    "import numpy as np\n",
    "\n",
    "# The choice of model and its hyperparameters can significantly affect the prediction performance.\n",
    "# We use the Gaussian Process Regressor (GPR), a powerful and flexible model for regression problems.\n",
    "\n",
    "# Defining a grid of hyperparameters allows us to explore a range of model configurations.\n",
    "# The 'kernel' parameter controls the shape of the process' covariance function,\n",
    "# and 'alpha' deals with the model's noise level. We'll use GridSearchCV to find the best combination.\n",
    "param_grid = {\n",
    "    'kernel': [C(1.0, (1e-2, 1e2)), RBF(1.0, (1e-2, 1e2)),\n",
    "               RBF(0.5, (1e-2, 1e2)),\n",
    "               RBF(10.0, (1e-2, 1e2)),\n",
    "               RBF(100.0, (1e-2, 1e2)),\n",
    "               Matern(length_scale=0.1),\n",
    "               Matern(length_scale=0.5),\n",
    "               Matern(length_scale=1),\n",
    "               WhiteKernel()],\n",
    "    'alpha': np.logspace(-5, 2, 8)\n",
    "}\n",
    "\n",
    "# GridSearchCV systematically works through multiple combinations of parameter values,\n",
    "# cross-validates each to determine which configuration gives the best performance.\n",
    "gpr = GaussianProcessRegressor()\n",
    "\n",
    "mae_scorer = make_scorer(mean_absolute_error, greater_is_better=False)\n",
    "\n",
    "# Performing the grid search on the scaled training data.\n",
    "grid_search = GridSearchCV(\n",
    "    gpr, \n",
    "    param_grid, \n",
    "    cv=5, \n",
    "    n_jobs=-1,\n",
    "    scoring= mae_scorer,\n",
    "    error_score='raise', # raise an exception if a score cannot be computed\n",
    "    verbose=2 # print out more detailed error messages\n",
    ")\n",
    "\n",
    "# Fit GridSearchCV to the data. This process can be time-consuming for large datasets or complex models\n",
    "# but is crucial for finding the most accurate model configuration.\n",
    "grid_search.fit(x_train_scaled, y_train)\n",
    "\n",
    "# Get the cross-validation results\n",
    "cv_results = pd.DataFrame(grid_search.cv_results_)\n",
    "print(cv_results[['params', 'mean_test_score', 'std_test_score']])\n",
    "print('='*50)\n",
    "best_idx = cv_results['mean_test_score'].argmax()\n",
    "print(f'Best parameters for GPR: {cv_results[\"params\"][best_idx]}')\n",
    "print('Best score: {}'.format(grid_search.best_score_))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Best parameters for different methods are as follows:\n",
    "\n",
    "- Best parameters for GPR: {'alpha': 0.001, 'kernel': Matern(length_scale=10, nu=1.5)}\n",
    "- Best score: -0.053484038058140136\n",
    "\n",
    "- Best parameters for Decision Tree: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2}\n",
    "- Best score for Decision Tree: 0.06063882006374226\n",
    "\n",
    "- Best parameters for Random Forest: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 500}\n",
    "- Best score for Random Forest: 0.055737128116578306\n",
    "\n",
    "- Best parameters for K-Nearest Neighbor: {'n_neighbors': 5, 'p': 2, 'weights': 'distance'}\n",
    "- Best score for K-Nearest Neighbor: 0.08994459562199185"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3. Train the models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GaussianProcessRegressor(kernel=Matern(length_scale=0.5, nu=1.5),\n",
       "                         n_restarts_optimizer=5)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GaussianProcessRegressor</label><div class=\"sk-toggleable__content\"><pre>GaussianProcessRegressor(kernel=Matern(length_scale=0.5, nu=1.5),\n",
       "                         n_restarts_optimizer=5)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "GaussianProcessRegressor(kernel=Matern(length_scale=0.5, nu=1.5),\n",
       "                         n_restarts_optimizer=5)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# After identifying the best parameters, we train a final model using these settings.\n",
    "# This model is then ready to make predictions on new, unseen data.\n",
    "\n",
    "#best_kernel = grid_search.best_params_['kernel']\n",
    "#model = GaussianProcessRegressor(kernel=best_kernel, alpha=grid_search.best_params_['alpha'], n_restarts_optimizer=5)\n",
    "#model.fit(x_train_scaled, y_train)\n",
    "\n",
    "#Example:\n",
    "model = GaussianProcessRegressor(kernel=Matern(length_scale=0.5, nu=1.5), n_restarts_optimizer=5)\n",
    "model.fit(x_train_scaled, y_train)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5- Save the predictive model\n",
    "\n",
    "Save the trained model to ensure that it can be reused without retraining."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import pickle\n",
    "\n",
    "# Assuming `model` is your trained model object from the previous steps\n",
    "\n",
    "# Specify the filename for the saved model\n",
    "#model_filename = 'trained_model.pkl'\n",
    "\n",
    "# Open a file in write-binary (wb) mode to save the model\n",
    "#with open(model_filename, 'wb') as file:\n",
    "#    pickle.dump(model, file)\n",
    "\n",
    "# The model is now saved to 'trained_model.pkl' and can be loaded later for predictions\n",
    "\n",
    "# Load the model from the file\n",
    "#with open(model_filename, 'rb') as file:\n",
    "#    loaded_model = pickle.load(file)\n",
    "\n",
    "# `loaded_model` is now the same as the `model` object you saved earlier\n",
    "# You can use `loaded_model.predict()` to make predictions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6- Create a Grid in the Feature Space\n",
    "\n",
    "Generate a comprehensive grid that spans the entire feature space under consideration.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_exp_grid(label_a = \"init_C\", label_b = \"init_N\", label_c = \"init_Li\", label_d= \"T\",\n",
    "                    range_a = (0,2.5), range_b = (0,6), range_c = (0,6), range_d = (66,66)\n",
    "                    ):\n",
    "    '''\n",
    "    This function generates a comprehensive grid over the specified feature space.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    label_a, label_b, label_c, label_d : str\n",
    "        The labels of the features for which the grid is created.\n",
    "    range_a, range_b, range_c, range_d : tuple\n",
    "        The minimum and maximum values (inclusive) to create the grid for each feature.\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    pd.DataFrame\n",
    "        A DataFrame containing all combinations of the specified feature ranges.\n",
    "    '''\n",
    "    \n",
    "    exp_grid = pd.DataFrame({label_a:[], label_b : [], label_c : [], label_d: []})\n",
    "    \n",
    "    for a in tqdm(np.linspace(range_a[0], range_a[1], 16)):\n",
    "        for b in np.linspace(range_b[0],range_b[1],37):\n",
    "            for c in np.linspace(range_c[0],range_c[1],37):\n",
    "                for d in np.linspace(range_d[0],range_d[1],1):\n",
    "                    x_df = pd.DataFrame({label_a:[a],\n",
    "                                         label_b : [b],\n",
    "                                         label_c : [c],\n",
    "                                         label_d: [d]})\n",
    "                    exp_grid = exp_grid.append(x_df)\n",
    "    \n",
    "    return exp_grid\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 16/16 [00:10<00:00,  1.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   init_C  init_N   init_Li     T\n",
      "0     0.0     0.0  0.000000  66.0\n",
      "0     0.0     0.0  0.166667  66.0\n",
      "0     0.0     0.0  0.333333  66.0\n",
      "0     0.0     0.0  0.500000  66.0\n",
      "0     0.0     0.0  0.666667  66.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Example usage of the function to create an experimental grid\n",
    "# Users should adjust the feature labels and ranges according to their specific datasets\n",
    "exp_grid = create_exp_grid()\n",
    "print(exp_grid.head())  # Display the first few rows of the grid\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_dataframe(exp_grid, train_df, labels_list = ['init_C', 'init_N', 'init_Li']):\n",
    "    '''This function takes in a dataframe of experimental conditions and returns the scaled dataframe.\n",
    "    Parameters:\n",
    "    ----------\n",
    "    exp_grid: pandas dataframe\n",
    "    \n",
    "    train_df: pandas dataframe\n",
    "    \n",
    "    labels_list: list of strings\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    exp_grid: pandas dataframe with scaled columns'''\n",
    "    \n",
    "    # Define the scaler \n",
    "    scaler = preprocessing.StandardScaler().fit(train_df[labels_list])\n",
    "    scaled_batch = scaler.transform(train_df[labels_list])\n",
    "    \n",
    "    # scale the experimental grid\n",
    "    scaled_exp_grid = scaler.transform(exp_grid[labels_list])\n",
    "    \n",
    "    exp_grid['scl_'+labels_list[0]] = scaled_exp_grid[:,0]\n",
    "    exp_grid['scl_'+labels_list[1]] = scaled_exp_grid[:,1]\n",
    "    exp_grid['scl_'+labels_list[2]] = scaled_exp_grid[:,2]\n",
    "    \n",
    "    return exp_grid\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   init_C  init_N   init_Li     T  scl_init_C  scl_init_N  scl_init_Li\n",
      "0     0.0     0.0  0.000000  66.0   -1.662726   -3.539546    -1.659431\n",
      "1     0.0     0.0  0.166667  66.0   -1.662726   -3.539546    -1.484481\n",
      "2     0.0     0.0  0.333333  66.0   -1.662726   -3.539546    -1.309531\n",
      "3     0.0     0.0  0.500000  66.0   -1.662726   -3.539546    -1.134581\n",
      "4     0.0     0.0  0.666667  66.0   -1.662726   -3.539546    -0.959630\n"
     ]
    }
   ],
   "source": [
    "# Assuming 'x_train' is your training DataFrame which has already been defined\n",
    "# Here, we scale the experimental grid based on 'x_train'\n",
    "exp_grid = scale_dataframe(exp_grid, x_train, ['init_C', 'init_N', 'init_Li'])\n",
    "\n",
    "# Reset the index for clarity\n",
    "exp_grid.reset_index(drop=True, inplace=True)\n",
    "print(exp_grid.head())  # Display the first few rows of the scaled grid\n",
    "\n",
    "# Note to users:\n",
    "# Ensure that the training data ('x_train') has been properly prepared before using it to scale the experimental grid.\n",
    "# The experimental grid now matches the scale of your training data and is ready for predictive modeling.\n",
    "# Proceed to assess the experimental feasibility of each combination in the grid in the next step."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7- Extract a Subset of the Grid that is Experimentally Feasible\n",
    "\n",
    "Identify and isolate parts of the grid that are viable for experimental verification based on predefined criteria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fact_check(combination):\n",
    "    '''\n",
    "    Evaluates if the given combination of experimental conditions meets predefined feasibility criteria.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    combination : list\n",
    "        List containing the experiment combinations in the order: [C, N, Li, T].\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    bool\n",
    "        True if all criteria are satisfied, False otherwise.\n",
    "    \n",
    "    The feasibility criteria used here are placeholders. Adjust them based on actual experimental constraints.\n",
    "    '''\n",
    "    \n",
    "    # Extract individual feature values from the combination\n",
    "    c, n, l = combination[0], combination[1], combination[2]\n",
    "    \n",
    "    # Define feasibility criteria based on chemical and experimental guidelines\n",
    "    c_total_limit = 0.5 * n\n",
    "    if n > 6 or c > c_total_limit or c > 2.5 or l > 6 or l <= 0 or c < (l / 2):\n",
    "        return False  # Criteria not met\n",
    "    return True  # Criteria met"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grid_feasibility(data_df, label_a=\"init_C\", label_b=\"init_N\", label_c=\"init_Li\", label_d=\"T\"):\n",
    "    '''\n",
    "    Iterates over a DataFrame of experimental conditions, applying `fact_check` to each row.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    data_df : pd.DataFrame\n",
    "        DataFrame containing experimental conditions.\n",
    "    label_a, label_b, label_c, label_d : str\n",
    "        Column labels for the features to check for feasibility.\n",
    "    \n",
    "    Returns:\n",
    "    -------\n",
    "    pd.DataFrame\n",
    "        Original DataFrame with an added 'fact_check' column indicating feasibility.\n",
    "    '''\n",
    "    \n",
    "    # List to store feasibility results\n",
    "    fact_check_list = []\n",
    "    \n",
    "    # Check each row for feasibility\n",
    "    for i in tqdm(data_df.index, desc=\"Assessing feasibility\"):\n",
    "        combination = [data_df.loc[i, label_a], data_df.loc[i, label_b], data_df.loc[i, label_c], data_df.loc[i, label_d]]\n",
    "        fact_check_list.append(fact_check(combination))\n",
    "    \n",
    "    # Add feasibility results to DataFrame\n",
    "    data_df['fact_check'] = fact_check_list\n",
    "    \n",
    "    return data_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Assessing feasibility: 100%|██████████| 21904/21904 [00:00<00:00, 30415.60it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        init_C    init_N   init_Li     T  scl_init_C  scl_init_N  scl_init_Li  \\\n",
      "1444  0.166667  0.333333  0.166667  66.0   -1.422222   -3.290527    -1.484481   \n",
      "1445  0.166667  0.333333  0.333333  66.0   -1.422222   -3.290527    -1.309531   \n",
      "1481  0.166667  0.500000  0.166667  66.0   -1.422222   -3.166018    -1.484481   \n",
      "1482  0.166667  0.500000  0.333333  66.0   -1.422222   -3.166018    -1.309531   \n",
      "1518  0.166667  0.666667  0.166667  66.0   -1.422222   -3.041508    -1.484481   \n",
      "\n",
      "      fact_check  \n",
      "1444        True  \n",
      "1445        True  \n",
      "1481        True  \n",
      "1482        True  \n",
      "1518        True  \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Apply the feasibility check to the experimental grid\n",
    "exp_grid = grid_feasibility(exp_grid)\n",
    "\n",
    "# Filter the grid for feasible experiments\n",
    "feasible_exp_grid = exp_grid[exp_grid['fact_check'] == True]\n",
    "\n",
    "# Display the first few rows of the feasible experimental grid\n",
    "print(feasible_exp_grid.head())\n",
    "\n",
    "# Instructions to Users:\n",
    "# The `feasible_exp_grid` DataFrame now contains only those combinations deemed experimentally viable.\n",
    "# This filtered grid should be used for subsequent model predictions and experimental planning.\n",
    "# Adjust the feasibility criteria in the `fact_check` function based on your specific experimental constraints and safety guidelines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>init_C</th>\n",
       "      <th>init_N</th>\n",
       "      <th>init_Li</th>\n",
       "      <th>T</th>\n",
       "      <th>scl_init_C</th>\n",
       "      <th>scl_init_N</th>\n",
       "      <th>scl_init_Li</th>\n",
       "      <th>scl_T</th>\n",
       "      <th>fact_check</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-2.060409</td>\n",
       "      <td>-5.261654</td>\n",
       "      <td>-2.344928</td>\n",
       "      <td>0.805534</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-2.060409</td>\n",
       "      <td>-5.261654</td>\n",
       "      <td>-2.121620</td>\n",
       "      <td>0.805534</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-2.060409</td>\n",
       "      <td>-5.261654</td>\n",
       "      <td>-1.898313</td>\n",
       "      <td>0.805534</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-2.060409</td>\n",
       "      <td>-5.261654</td>\n",
       "      <td>-1.675005</td>\n",
       "      <td>0.805534</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-2.060409</td>\n",
       "      <td>-5.261654</td>\n",
       "      <td>-1.451697</td>\n",
       "      <td>0.805534</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   init_C  init_N   init_Li     T  scl_init_C  scl_init_N  scl_init_Li  \\\n",
       "0     0.0     0.0  0.000000  66.0   -2.060409   -5.261654    -2.344928   \n",
       "1     0.0     0.0  0.166667  66.0   -2.060409   -5.261654    -2.121620   \n",
       "2     0.0     0.0  0.333333  66.0   -2.060409   -5.261654    -1.898313   \n",
       "3     0.0     0.0  0.500000  66.0   -2.060409   -5.261654    -1.675005   \n",
       "4     0.0     0.0  0.666667  66.0   -2.060409   -5.261654    -1.451697   \n",
       "\n",
       "      scl_T  fact_check  \n",
       "0  0.805534       False  \n",
       "1  0.805534       False  \n",
       "2  0.805534       False  \n",
       "3  0.805534       False  \n",
       "4  0.805534       False  "
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_grid.head()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8- Predict the Target Value in the Subset\n",
    "\n",
    "Use the trained model to predict target values for the experimentally feasible subset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        init_C    init_N   init_Li     T  scl_init_C  scl_init_N  scl_init_Li  \\\n",
      "1444  0.166667  0.333333  0.166667  66.0   -1.422222   -3.290527    -1.484481   \n",
      "1445  0.166667  0.333333  0.333333  66.0   -1.422222   -3.290527    -1.309531   \n",
      "1481  0.166667  0.500000  0.166667  66.0   -1.422222   -3.166018    -1.484481   \n",
      "1482  0.166667  0.500000  0.333333  66.0   -1.422222   -3.166018    -1.309531   \n",
      "1518  0.166667  0.666667  0.166667  66.0   -1.422222   -3.041508    -1.484481   \n",
      "\n",
      "      fact_check  \n",
      "1444        True  \n",
      "1445        True  \n",
      "1481        True  \n",
      "1482        True  \n",
      "1518        True  \n",
      "        init_C    init_N   init_Li     T  scl_init_C  scl_init_N  scl_init_Li  \\\n",
      "1444  0.166667  0.333333  0.166667  66.0   -1.422222   -3.290527    -1.484481   \n",
      "1445  0.166667  0.333333  0.333333  66.0   -1.422222   -3.290527    -1.309531   \n",
      "1481  0.166667  0.500000  0.166667  66.0   -1.422222   -3.166018    -1.484481   \n",
      "1482  0.166667  0.500000  0.333333  66.0   -1.422222   -3.166018    -1.309531   \n",
      "1518  0.166667  0.666667  0.166667  66.0   -1.422222   -3.041508    -1.484481   \n",
      "\n",
      "      fact_check     gpr_yield       std  \n",
      "1444        True -1.124478e-07  0.000010  \n",
      "1445        True  1.935593e-02  0.033434  \n",
      "1481        True -3.834630e-04  0.012515  \n",
      "1482        True  2.040830e-02  0.032492  \n",
      "1518        True -4.558765e-04  0.018514  \n"
     ]
    }
   ],
   "source": [
    "# Assuming `models` is a list of trained model objects and we're using the first model for prediction.\n",
    "# Ensure your model has been trained and is ready for making predictions.\n",
    "\n",
    "# Filter the experimental grid for feasible experiments based on the 'fact_check' column\n",
    "feasible_grid = exp_grid[exp_grid['fact_check'] == True]\n",
    "\n",
    "# Display the first few rows of the feasible experimental grid\n",
    "print(feasible_grid.head())\n",
    "\n",
    "# Predict target values using the trained model for the scaled features of the feasible grid\n",
    "# 'scl_init_C', 'scl_init_N', 'scl_init_Li' should be scaled versions of your features prepared earlier\n",
    "y_pred, std = model.predict(feasible_grid[['scl_init_C', 'scl_init_N', 'scl_init_Li']], return_std=True)\n",
    "\n",
    "# Add the predictions (yield) and standard deviations to the feasible experimental grid as new columns\n",
    "feasible_grid['gpr_yield'] = y_pred\n",
    "feasible_grid['std'] = std\n",
    "\n",
    "# Instructions to Users:\n",
    "# - The feasible experimental grid now includes predicted yields ('gpr_yield') and their uncertainties ('std').\n",
    "# - These predictions can be used to guide experimental planning, focusing efforts on areas of the feature space\n",
    "#   with high potential yield or interesting properties.\n",
    "# - The 'std' column provides an estimate of the prediction uncertainty, useful for risk assessment and experimental prioritization.\n",
    "\n",
    "# Note:\n",
    "# - Ensure that the feature names in the prediction line match those used during model training.\n",
    "# - If your model does not support `return_std`, you may need to adjust the code to omit standard deviation predictions.\n",
    "# - Replace `models[0]` with the variable name of your trained model if different.\n",
    "\n",
    "# Display the first few rows of the feasible grid with predictions\n",
    "print(feasible_grid.head())\n",
    "\n",
    "# Reminder:\n",
    "# - Prior to prediction, it's crucial to scale your experimental grid's features using the same scaler object\n",
    "#   that was applied to the training data to ensure consistency between training and prediction.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9- Save the Predicted Properties of the Subset\n",
    "\n",
    "Store the predictions to guide future experimental endeavors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime  # Ensure datetime is imported for timestamping\n",
    "import pandas as pd  # Make sure pandas is available for DataFrame operations\n",
    "\n",
    "# Current date and time for timestamping the output file, ensuring uniqueness\n",
    "now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n",
    "\n",
    "# Saving the experimental grid with predictions to an Excel file\n",
    "# Adjust the file path and name as needed for your project structure and naming conventions\n",
    "file_path = 'data/generated/exp_grid_{}.xlsx'.format(now)  # Constructs the file path with a timestamp\n",
    "\n",
    "# Save the DataFrame to an Excel file\n",
    "# Note: The DataFrame 'exp_grid' should include all your experimental conditions along with the 'gpr_yield' and 'std' columns\n",
    "exp_grid.to_excel(file_path, index=False)  # Set index=False to avoid saving the DataFrame index as a separate column\n",
    "\n",
    "# Instructions to Users:\n",
    "# - This step saves the experimental grid, complete with your model's predictions and uncertainties, to an Excel file.\n",
    "# - The filename includes a timestamp to prevent overwriting previous files and to track when predictions were made.\n",
    "# - Use this saved file as a reference for planning and conducting future experiments. The 'gpr_yield' column indicates\n",
    "#   the predicted yield for each set of conditions, while the 'std' column provides an estimate of prediction uncertainty.\n",
    "# - This file serves as a valuable resource for identifying promising areas of the feature space to explore experimentally.\n",
    "\n",
    "# Note:\n",
    "# - Ensure you have write permissions to the target directory\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10- Acquire Data Based on Predicted Properties:\n",
    "\n",
    "Select new data points for acquisition based on the model's predictions and a tiered acquisition strategy, aiming to maximize the model's learning.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclidean_distance(input_batch, vector, n_components = 3):\n",
    "    '''\n",
    "    Finds the minimum euclidean distance between a batch of vector (batch, np.arrays) and a new vector (experiment, np.array)\n",
    "    \n",
    "    Parameters:\n",
    "    -----------\n",
    "    input_batch: 2D np array (a set of vectors)\n",
    "    vector: 1D np array (a vector)\n",
    "    \n",
    "    Returne:\n",
    "    -----------\n",
    "    min_distance: minimum Euclidean distance of the vector to the batch \n",
    "    \n",
    "    '''\n",
    "    \n",
    "    batch_np = np.array(input_batch)\n",
    "    vector_np = np.array(vector)\n",
    "    \n",
    "\n",
    "    dislocation = batch_np[0, 0:n_components] - vector_np[0:n_components]\n",
    "    min_distance = np.linalg.norm(dislocation)\n",
    "\n",
    "    for i in range(len(batch_np)):\n",
    "        dislocation = batch_np[i,0:n_components] - vector_np[0:n_components]\n",
    "        distance = np.linalg.norm(dislocation)\n",
    "        \n",
    "        if min_distance > distance:\n",
    "            min_distance = distance\n",
    "    \n",
    "    return min_distance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tierd_greedy_acquisition(exp_grid_df, train_df, tier1_label='std', tier2_label='gpr_yield', \n",
    "                             tier1_acquisition=12, tier2_acquisition=6, tier3_acquisition=6, min_distance=0.5):\n",
    "    \"\"\"\n",
    "    Selects new data points for acquisition based on the model's predictions and a tiered acquisition strategy.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    exp_grid_df : pd.DataFrame\n",
    "        DataFrame with columns 'std' and 'gpr_yield' among others.\n",
    "    train_df : pd.DataFrame\n",
    "        DataFrame used for training the model, used to avoid selecting points too close to existing data.\n",
    "    tier1_label, tier2_label : str\n",
    "        Column names for sorting data points in tiered acquisition.\n",
    "    tier1_acquisition, tier2_acquisition, tier3_acquisition : int\n",
    "        Number of samples to acquire in each tier.\n",
    "    min_distance : float\n",
    "        Minimum Euclidean distance from any point in the training set for a point to be eligible for acquisition.\n",
    "        \n",
    "    Returns:\n",
    "    -------\n",
    "    pd.DataFrame\n",
    "        DataFrame of selected points for acquisition.\n",
    "    \"\"\"\n",
    "    \n",
    "    acquisition_batch = []\n",
    "    control_batch = train_df[['init_C', 'init_N', 'init_Li']].values\n",
    "    temp_df = exp_grid_df.copy()\n",
    "    \n",
    "    # Tier 1 Acquisition\n",
    "    temp_df = temp_df.sort_values(by=tier1_label, ascending=False).reset_index(drop=True)\n",
    "    \n",
    "    acquisition_counter = 0\n",
    "    row_counter = 0\n",
    "    while acquisition_counter < tier1_acquisition and row_counter < len(temp_df):\n",
    "        if euclidean_distance(control_batch, temp_df.iloc[row_counter, [0, 1, 2]].values) > min_distance and temp_df.iloc[row_counter][\"fact_check\"]:\n",
    "            acquisition_batch.append(temp_df.iloc[row_counter])\n",
    "            control_batch = np.vstack((control_batch, temp_df.iloc[row_counter, [0, 1, 2]].values))\n",
    "            acquisition_counter += 1\n",
    "        row_counter += 1\n",
    "\n",
    "    # Tier 2 Acquisition\n",
    "    temp_df = temp_df.sort_values(by=tier2_label, ascending=False).reset_index(drop=True)\n",
    "    \n",
    "    acquisition_counter = 0\n",
    "    row_counter = 0\n",
    "    while acquisition_counter < tier2_acquisition and row_counter < len(temp_df):\n",
    "        if euclidean_distance(control_batch, temp_df.iloc[row_counter, [0, 1, 2]].values) > min_distance and temp_df.iloc[row_counter][\"fact_check\"]:\n",
    "            acquisition_batch.append(temp_df.iloc[row_counter])\n",
    "            control_batch = np.vstack((control_batch, temp_df.iloc[row_counter, [0, 1, 2]].values))\n",
    "            acquisition_counter += 1\n",
    "        row_counter += 1\n",
    "\n",
    "    # Tier 3 Acquisition (Random)\n",
    "    while acquisition_counter < tier3_acquisition:\n",
    "        row_counter = random.randint(0, len(temp_df) - 1)\n",
    "        if euclidean_distance(control_batch, temp_df.iloc[row_counter, [0, 1, 2]].values) > min_distance and temp_df.iloc[row_counter][\"fact_check\"]:\n",
    "            acquisition_batch.append(temp_df.iloc[row_counter])\n",
    "            control_batch = np.vstack((control_batch, temp_df.iloc[row_counter, [0, 1, 2]].values))\n",
    "            acquisition_counter += 1\n",
    "\n",
    "    # Construct the acquisition DataFrame\n",
    "    acquisition_df = pd.DataFrame(acquisition_batch).reset_index(drop=True)\n",
    "    \n",
    "    # Assign acquisition types\n",
    "    acquisition_types = (['tier1'] * min(tier1_acquisition, len(acquisition_df)) + \n",
    "                         ['tier2'] * min(tier2_acquisition, len(acquisition_df) - tier1_acquisition) +\n",
    "                         ['random'] * max(len(acquisition_df) - tier1_acquisition - tier2_acquisition, 0))\n",
    "    acquisition_df['acquisition_type'] = acquisition_types[:len(acquisition_df)]\n",
    "    \n",
    "    return acquisition_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[53], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Corrected usage\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m acquisition_df \u001b[38;5;241m=\u001b[39m \u001b[43mtierd_greedy_acquisition\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfeasible_grid\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmin_distance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.75\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m      4\u001b[0m \u001b[38;5;66;03m# Display the selected points for acquisition\u001b[39;00m\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(acquisition_df\u001b[38;5;241m.\u001b[39mhead())\n",
      "Cell \u001b[1;32mIn[52], line 56\u001b[0m, in \u001b[0;36mtierd_greedy_acquisition\u001b[1;34m(exp_grid_df, train_df, tier1_label, tier2_label, tier1_acquisition, tier2_acquisition, tier3_acquisition, min_distance)\u001b[0m\n\u001b[0;32m     54\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m acquisition_counter \u001b[38;5;241m<\u001b[39m tier3_acquisition:\n\u001b[0;32m     55\u001b[0m     row_counter \u001b[38;5;241m=\u001b[39m random\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;28mlen\u001b[39m(temp_df) \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m---> 56\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m euclidean_distance(control_batch, \u001b[43mtemp_df\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43mrow_counter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mvalues) \u001b[38;5;241m>\u001b[39m min_distance \u001b[38;5;129;01mand\u001b[39;00m temp_df\u001b[38;5;241m.\u001b[39miloc[row_counter][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfact_check\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n\u001b[0;32m     57\u001b[0m         acquisition_batch\u001b[38;5;241m.\u001b[39mappend(temp_df\u001b[38;5;241m.\u001b[39miloc[row_counter])\n\u001b[0;32m     58\u001b[0m         control_batch \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvstack((control_batch, temp_df\u001b[38;5;241m.\u001b[39miloc[row_counter, [\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m]]\u001b[38;5;241m.\u001b[39mvalues))\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\indexing.py:1067\u001b[0m, in \u001b[0;36m_LocationIndexer.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   1065\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_is_scalar_access(key):\n\u001b[0;32m   1066\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj\u001b[38;5;241m.\u001b[39m_get_value(\u001b[38;5;241m*\u001b[39mkey, takeable\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_takeable)\n\u001b[1;32m-> 1067\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_tuple\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1068\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   1069\u001b[0m     \u001b[38;5;66;03m# we by definition only have the 0th axis\u001b[39;00m\n\u001b[0;32m   1070\u001b[0m     axis \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxis \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;241m0\u001b[39m\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\indexing.py:1565\u001b[0m, in \u001b[0;36m_iLocIndexer._getitem_tuple\u001b[1;34m(self, tup)\u001b[0m\n\u001b[0;32m   1563\u001b[0m tup \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_validate_tuple_indexer(tup)\n\u001b[0;32m   1564\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m suppress(IndexingError):\n\u001b[1;32m-> 1565\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_lowerdim\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtup\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1567\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_tuple_same_dim(tup)\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\indexing.py:991\u001b[0m, in \u001b[0;36m_LocationIndexer._getitem_lowerdim\u001b[1;34m(self, tup)\u001b[0m\n\u001b[0;32m    989\u001b[0m             \u001b[38;5;28;01mreturn\u001b[39;00m section\n\u001b[0;32m    990\u001b[0m         \u001b[38;5;66;03m# This is an elided recursive call to iloc/loc\u001b[39;00m\n\u001b[1;32m--> 991\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msection\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[43mnew_key\u001b[49m\u001b[43m]\u001b[49m\n\u001b[0;32m    993\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m IndexingError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnot applicable\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\indexing.py:1073\u001b[0m, in \u001b[0;36m_LocationIndexer.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   1070\u001b[0m axis \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxis \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m   1072\u001b[0m maybe_callable \u001b[38;5;241m=\u001b[39m com\u001b[38;5;241m.\u001b[39mapply_if_callable(key, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj)\n\u001b[1;32m-> 1073\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_axis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmaybe_callable\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\indexing.py:1616\u001b[0m, in \u001b[0;36m_iLocIndexer._getitem_axis\u001b[1;34m(self, key, axis)\u001b[0m\n\u001b[0;32m   1614\u001b[0m \u001b[38;5;66;03m# a list of integers\u001b[39;00m\n\u001b[0;32m   1615\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_list_like_indexer(key):\n\u001b[1;32m-> 1616\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_list_axis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1618\u001b[0m \u001b[38;5;66;03m# a single integer\u001b[39;00m\n\u001b[0;32m   1619\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   1620\u001b[0m     key \u001b[38;5;241m=\u001b[39m item_from_zerodim(key)\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\indexing.py:1587\u001b[0m, in \u001b[0;36m_iLocIndexer._get_list_axis\u001b[1;34m(self, key, axis)\u001b[0m\n\u001b[0;32m   1570\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m   1571\u001b[0m \u001b[38;5;124;03mReturn Series values by list or array of integers.\u001b[39;00m\n\u001b[0;32m   1572\u001b[0m \n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1584\u001b[0m \u001b[38;5;124;03m`axis` can only be zero.\u001b[39;00m\n\u001b[0;32m   1585\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m   1586\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 1587\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_take_with_is_copy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1588\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[0;32m   1589\u001b[0m     \u001b[38;5;66;03m# re-raise with different error message\u001b[39;00m\n\u001b[0;32m   1590\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpositional indexers are out-of-bounds\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\series.py:945\u001b[0m, in \u001b[0;36mSeries._take_with_is_copy\u001b[1;34m(self, indices, axis)\u001b[0m\n\u001b[0;32m    936\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_take_with_is_copy\u001b[39m(\u001b[38;5;28mself\u001b[39m, indices, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Series:\n\u001b[0;32m    937\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    938\u001b[0m \u001b[38;5;124;03m    Internal version of the `take` method that sets the `_is_copy`\u001b[39;00m\n\u001b[0;32m    939\u001b[0m \u001b[38;5;124;03m    attribute to keep track of the parent dataframe (using in indexing\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    943\u001b[0m \u001b[38;5;124;03m    See the docstring of `take` for full explanation of the parameters.\u001b[39;00m\n\u001b[0;32m    944\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 945\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtake\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindices\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mindices\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mc:\\Users\\mousas10\\AppData\\Local\\anaconda3\\envs\\SI\\lib\\site-packages\\pandas\\core\\series.py:929\u001b[0m, in \u001b[0;36mSeries.take\u001b[1;34m(self, indices, axis, is_copy, **kwargs)\u001b[0m\n\u001b[0;32m    921\u001b[0m     warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[0;32m    922\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mis_copy is deprecated and will be removed in a future version. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    923\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtake\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m always returns a copy, so there is no need to specify this.\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m    924\u001b[0m         \u001b[38;5;167;01mFutureWarning\u001b[39;00m,\n\u001b[0;32m    925\u001b[0m         stacklevel\u001b[38;5;241m=\u001b[39mfind_stack_level(),\n\u001b[0;32m    926\u001b[0m     )\n\u001b[0;32m    927\u001b[0m nv\u001b[38;5;241m.\u001b[39mvalidate_take((), kwargs)\n\u001b[1;32m--> 929\u001b[0m indices \u001b[38;5;241m=\u001b[39m \u001b[43mensure_platform_int\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindices\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    930\u001b[0m new_index \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex\u001b[38;5;241m.\u001b[39mtake(indices)\n\u001b[0;32m    931\u001b[0m new_values \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_values\u001b[38;5;241m.\u001b[39mtake(indices)\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Corrected usage\n",
    "acquisition_df = tierd_greedy_acquisition(feasible_grid, x_train, min_distance=0.75)\n",
    "\n",
    "# Display the selected points for acquisition\n",
    "print(acquisition_df.head())\n",
    "\n",
    "# Instructions to Users:\n",
    "# - This function helps in selecting new data points for acquisition based on the model's predictions and a tiered strategy.\n",
    "# - The tiered strategy involves selecting points based on their predicted standard deviation ('std'), predicted yield ('gpr_yield'),\n",
    "#   and a random selection to explore the feature space.\n",
    "# - Ensure the 'exp_grid_df' passed to the function has been filtered for feasibility (`fact_check` == True) and includes\n",
    "#   scaled features (`scl_init_C`, `scl_init_N`, `scl_init_Li`) used for prediction.\n",
    "# - The 'train_df' should include the same features as 'exp_grid_df' and represent the data used to train the model.\n",
    "# - Adjust the acquisition tiers and the\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>init_C</th>\n",
       "      <th>init_N</th>\n",
       "      <th>init_Li</th>\n",
       "      <th>T</th>\n",
       "      <th>gpr_yield</th>\n",
       "      <th>std</th>\n",
       "      <th>fact_check</th>\n",
       "      <th>acquisition</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1444</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.400134</td>\n",
       "      <td>0.351154</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1629</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>1.166667</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.328078</td>\n",
       "      <td>0.289295</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1814</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.251631</td>\n",
       "      <td>0.256215</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1999</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>2.833333</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.227632</td>\n",
       "      <td>0.228918</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8659</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.339778</td>\n",
       "      <td>0.202977</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2184</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>3.666667</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.261588</td>\n",
       "      <td>0.193080</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21868</th>\n",
       "      <td>2.500000</td>\n",
       "      <td>6.000000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.433743</td>\n",
       "      <td>0.184640</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11582</th>\n",
       "      <td>1.333333</td>\n",
       "      <td>2.833333</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.382915</td>\n",
       "      <td>0.180349</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21675</th>\n",
       "      <td>2.500000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.737172</td>\n",
       "      <td>0.178645</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21897</th>\n",
       "      <td>2.500000</td>\n",
       "      <td>6.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.776501</td>\n",
       "      <td>0.175824</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21646</th>\n",
       "      <td>2.500000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.569017</td>\n",
       "      <td>0.174424</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17317</th>\n",
       "      <td>2.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.534577</td>\n",
       "      <td>0.172032</td>\n",
       "      <td>True</td>\n",
       "      <td>std</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16265</th>\n",
       "      <td>1.833333</td>\n",
       "      <td>5.333333</td>\n",
       "      <td>3.666667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.739930</td>\n",
       "      <td>0.086747</td>\n",
       "      <td>True</td>\n",
       "      <td>gpr_yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18818</th>\n",
       "      <td>2.166667</td>\n",
       "      <td>4.500000</td>\n",
       "      <td>3.666667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.708813</td>\n",
       "      <td>0.088322</td>\n",
       "      <td>True</td>\n",
       "      <td>gpr_yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15931</th>\n",
       "      <td>1.833333</td>\n",
       "      <td>3.833333</td>\n",
       "      <td>3.500000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.647225</td>\n",
       "      <td>0.120750</td>\n",
       "      <td>True</td>\n",
       "      <td>gpr_yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13005</th>\n",
       "      <td>1.500000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.549470</td>\n",
       "      <td>0.126346</td>\n",
       "      <td>True</td>\n",
       "      <td>gpr_yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10448</th>\n",
       "      <td>1.166667</td>\n",
       "      <td>3.833333</td>\n",
       "      <td>2.333333</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.524431</td>\n",
       "      <td>0.062215</td>\n",
       "      <td>True</td>\n",
       "      <td>gpr_yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18918</th>\n",
       "      <td>2.166667</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>1.833333</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.455859</td>\n",
       "      <td>0.048620</td>\n",
       "      <td>True</td>\n",
       "      <td>gpr_yield</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10658</th>\n",
       "      <td>1.166667</td>\n",
       "      <td>4.833333</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.126403</td>\n",
       "      <td>0.098772</td>\n",
       "      <td>True</td>\n",
       "      <td>random</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8994</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>3.500000</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.058022</td>\n",
       "      <td>0.107840</td>\n",
       "      <td>True</td>\n",
       "      <td>random</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9473</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>5.666667</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.139092</td>\n",
       "      <td>0.109784</td>\n",
       "      <td>True</td>\n",
       "      <td>random</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5296</th>\n",
       "      <td>0.500000</td>\n",
       "      <td>5.333333</td>\n",
       "      <td>0.833333</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.220441</td>\n",
       "      <td>0.060282</td>\n",
       "      <td>True</td>\n",
       "      <td>random</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8707</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>2.166667</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.408810</td>\n",
       "      <td>0.109876</td>\n",
       "      <td>True</td>\n",
       "      <td>random</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3738</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>4.500000</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>66.0</td>\n",
       "      <td>-0.274444</td>\n",
       "      <td>0.137729</td>\n",
       "      <td>True</td>\n",
       "      <td>random</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         init_C    init_N   init_Li     T  gpr_yield       std  fact_check  \\\n",
       "1444   0.166667  0.333333  0.166667  66.0  -0.400134  0.351154        True   \n",
       "1629   0.166667  1.166667  0.166667  66.0  -0.328078  0.289295        True   \n",
       "1814   0.166667  2.000000  0.166667  66.0  -0.251631  0.256215        True   \n",
       "1999   0.166667  2.833333  0.166667  66.0  -0.227632  0.228918        True   \n",
       "8659   1.000000  2.000000  0.166667  66.0  -0.339778  0.202977        True   \n",
       "2184   0.166667  3.666667  0.166667  66.0  -0.261588  0.193080        True   \n",
       "21868  2.500000  6.000000  0.166667  66.0  -0.433743  0.184640        True   \n",
       "11582  1.333333  2.833333  0.166667  66.0  -0.382915  0.180349        True   \n",
       "21675  2.500000  5.000000  5.000000  66.0   0.737172  0.178645        True   \n",
       "21897  2.500000  6.000000  5.000000  66.0   0.776501  0.175824        True   \n",
       "21646  2.500000  5.000000  0.166667  66.0  -0.569017  0.174424        True   \n",
       "17317  2.000000  4.000000  0.166667  66.0  -0.534577  0.172032        True   \n",
       "16265  1.833333  5.333333  3.666667  66.0   0.739930  0.086747        True   \n",
       "18818  2.166667  4.500000  3.666667  66.0   0.708813  0.088322        True   \n",
       "15931  1.833333  3.833333  3.500000  66.0   0.647225  0.120750        True   \n",
       "13005  1.500000  3.000000  3.000000  66.0   0.549470  0.126346        True   \n",
       "10448  1.166667  3.833333  2.333333  66.0   0.524431  0.062215        True   \n",
       "18918  2.166667  5.000000  1.833333  66.0   0.455859  0.048620        True   \n",
       "10658  1.166667  4.833333  0.333333  66.0  -0.126403  0.098772        True   \n",
       "8994   1.000000  3.500000  0.500000  66.0  -0.058022  0.107840        True   \n",
       "9473   1.000000  5.666667  0.166667  66.0  -0.139092  0.109784        True   \n",
       "5296   0.500000  5.333333  0.833333  66.0   0.220441  0.060282        True   \n",
       "8707   1.000000  2.166667  2.000000  66.0   0.408810  0.109876        True   \n",
       "3738   0.333333  4.500000  0.166667  66.0  -0.274444  0.137729        True   \n",
       "\n",
       "      acquisition  \n",
       "1444          std  \n",
       "1629          std  \n",
       "1814          std  \n",
       "1999          std  \n",
       "8659          std  \n",
       "2184          std  \n",
       "21868         std  \n",
       "11582         std  \n",
       "21675         std  \n",
       "21897         std  \n",
       "21646         std  \n",
       "17317         std  \n",
       "16265   gpr_yield  \n",
       "18818   gpr_yield  \n",
       "15931   gpr_yield  \n",
       "13005   gpr_yield  \n",
       "10448   gpr_yield  \n",
       "18918   gpr_yield  \n",
       "10658      random  \n",
       "8994       random  \n",
       "9473       random  \n",
       "5296       random  \n",
       "8707       random  \n",
       "3738       random  "
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acquisition_df.reset_index(drop=True)\n",
    "acquisition_df.head(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11- Save the Acquired Data\n",
    "\n",
    " Document the newly acquired data points to refine the model in subsequent learning cycles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n",
    "\n",
    "acquisition_df.to_excel('data\\\\generated\\\\TGA_batch_{}.xlsx'.format(now))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "chemdev",
   "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.16"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "d382266be4744d0754a97ce7ea21db92af52e4d5aa60fa44c3f1d1cf60cd486a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}