interactive_plots_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "73efd5f8",
   "metadata": {},
   "source": [
    "# Functions and Imports (no user input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a5c141c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import openpyxl\n",
    "\n",
    "from scipy import stats\n",
    "from scipy.interpolate import interp1d\n",
    "\n",
    "from sklearn import linear_model\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler, QuantileTransformer\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import TSNE\n",
    "\n",
    "from yellowbrick.cluster import KElbowVisualizer\n",
    "\n",
    "from datetime import date\n",
    "\n",
    "import holoviews as hv\n",
    "import bokeh\n",
    "from bokeh.models import HoverTool\n",
    "hv.extension('bokeh')\n",
    "\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem.Draw import rdMolDraw2D\n",
    "\n",
    "from IPython.display import SVG\n",
    "\n",
    "# For alternative fonts:\n",
    "# import matplotlib.font_manager\n",
    "# fonts = matplotlib.font_manager.findSystemFonts(fontpaths=None, fontext='ttf')\n",
    "# font_names = [matplotlib.font_manager.get_font(f).family_name for f in fonts]\n",
    "# print(font_names)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f86aeb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "    Image generation from SMILES strings\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "\"\"\"\n",
    "\n",
    "# adapted from https://birdlet.github.io/2018/06/06/rdkit_svg_web/\n",
    "def DrawMol(dataframe, smiles_column_loc, image_column, id_column='Name', molSize=(200, 100), kekulize=True):\n",
    "    images = []\n",
    "    for index, row in dataframe.iterrows():\n",
    "        smiles_string = row.iloc[smiles_column_loc]  # Use iloc for position-based indexing\n",
    "        \n",
    "        # Check if the SMILES string is blank or NaN\n",
    "        if pd.isnull(smiles_string) or smiles_string == '':\n",
    "            print(f\"Skipping ID: {row[id_column]} due to blank or NaN SMILES\")\n",
    "            continue\n",
    "\n",
    "        try:\n",
    "            mc = Chem.MolFromSmiles(smiles_string)\n",
    "            if kekulize:\n",
    "                try:\n",
    "                    Chem.Kekulize(mc)\n",
    "                except:\n",
    "                    mc = Chem.Mol(smiles_string.ToBinary())\n",
    "\n",
    "            if not mc.GetNumConformers():\n",
    "                Chem.rdDepictor.Compute2DCoords(mc)\n",
    "\n",
    "            drawer = rdMolDraw2D.MolDraw2DSVG(*molSize)\n",
    "            drawer.DrawMolecule(mc)\n",
    "            drawer.FinishDrawing()\n",
    "            svg = drawer.GetDrawingText().replace('svg:', '')\n",
    "            images.append(SVG(svg).data)\n",
    "        except:\n",
    "            print(f\"Error for ID: {row[id_column]} with SMILES: {smiles_string}\")\n",
    "\n",
    "    try:\n",
    "        dataframe.insert(smiles_column_loc+1, image_column, images)\n",
    "    except: \n",
    "        dataframe[image_column] = images\n",
    "        \n",
    "    return dataframe\n",
    "    \n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "    Allow for user to input both name (string) or index number for column headers\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "\"\"\"\n",
    "\n",
    "def get_column_loc(column, dataframe):\n",
    "    if isinstance(column, str):\n",
    "        return dataframe.columns.get_loc(column), column\n",
    "    else:\n",
    "        return column, dataframe.columns[column]\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "    HoloViews: Scatter Plot\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "\"\"\"\n",
    "def scatter_plot(\n",
    "    dataframe: pd.DataFrame, \n",
    "    x: str,  # x-axis data\n",
    "    y: str,  # y-axis data\n",
    "    title: str = 'default',  # title of plot\n",
    "    x_label: str = 'default',  # axis label to be printed on plot (does not need to match dataframe name)\n",
    "    x_range: tuple = None,  # range of x-axis\n",
    "    y_label: str = 'default',  # axis label to be printed on plot (does not need to match dataframe name)\n",
    "    y_range: tuple = None,  # range of y-axis\n",
    "    legend: str = '',  # string with data label if using classifiers/building plots by category\n",
    "    svgs: str = None,  # string with column name of svgs \n",
    "    hover_list: list = None,  # list of column names with data to be shown on hover \n",
    "    marker: str = 'o',  # marker type - most of the matplotlib markers are supported (https://matplotlib.org/stable/api/markers_api.html)\n",
    "    bubbleplot: bool = False,  # if True, will create a bubble plot\n",
    "    size: int = 10,  # size of markers (recommended: 10-20)\n",
    "    bubblesize: str = None,  # string with column name for size of points in bubbleplot\n",
    "    heatmap: bool = False,  # if True, will create a heatmap\n",
    "    heatmap_col: str = '',  # color of heatmap\n",
    "    clabel: str = 'default', # label for heatmap colorbar\n",
    "    heatmap_color: str = 'Plasma',  # color of heatmap\n",
    "    color: str = '#931319',  # color of markers\n",
    "    line_color: str = '#29323d',  # color of marker line_color\n",
    "    alpha: int = 1,  # transparency of markers\n",
    "    groupby: str = None,  # string with column name to group data by\n",
    "    height: int = 500,  #plot height (recommended: 500)\n",
    "    width: int = 500,  #plot width (recommended: 500)\n",
    "):\n",
    "    \n",
    "    \"\"\"\n",
    "    scatter_plot function based off of HoloViews 'Scatter' element. See documentation for more information:\n",
    "    hv.help(hv.Scatter)\n",
    "    https://holoviews.org/reference/elements/bokeh/Scatter.html\n",
    "    \"\"\"\n",
    "\n",
    "    if x_label == 'default':  # if no x_label provided, use x column name\n",
    "        x_label = x\n",
    "    if y_label == 'default':  # if no y_label provided, use y column name\n",
    "        y_label = y\n",
    "    if clabel == 'default':  # if no clabel provided, use heatmap_col column name\n",
    "        clabel = heatmap_col\n",
    "\n",
    "    if not x_range:\n",
    "        x_min = min(dataframe[x]); x_max = max(dataframe[x])\n",
    "        x_buffer = abs(x_max-x_min)/10\n",
    "        x_range = (x_min-x_buffer, x_max+x_buffer)\n",
    "    if not y_range:\n",
    "        y_min = min(dataframe[y]); y_max = max(dataframe[y])\n",
    "        y_buffer = abs(y_max-y_min)/10\n",
    "        y_range = (y_min-y_buffer, y_max+y_buffer)\n",
    "\n",
    "    if groupby is not None:\n",
    "        color = hv.Cycle(color).values\n",
    "        hover_list.insert(0, groupby)\n",
    "\n",
    "    if svgs == None and labels == None: # no hover information provided\n",
    "        if title == 'default':  # if no title provided, define from x, y labels\n",
    "            title = f'{y_label} vs. {x_label}'\n",
    "        plt = hv.Scatter(dataframe, kdims=[x], vdims=[y], label=legend).opts(title=title, marker=marker, height=height, width=width, color=color, alpha=alpha, size=size, line_color=line_color)\n",
    "    else:  # hover information provided, build list of hover tools\n",
    "        hover_list.insert(0, y)\n",
    "        tooltips = f'<div>end' # beginning of tooltips if no svgs provided\n",
    "        if svgs != None:\n",
    "            tooltips = f'<div><div>@{svgs}{{safe}}</div>end'  # beginning of tooltips if svgs are provided\n",
    "            hover_list.insert(1, svgs)\n",
    "        if len(hover_list) < 4:\n",
    "            for label in hover_list:\n",
    "                if label != svgs and label != y:\n",
    "                    tooltips = tooltips.replace('end', f'<div><span style=\"font-size: 17px; font-weight: bold;\">@{label}</span></div>end')\n",
    "        else:\n",
    "            for label in hover_list:\n",
    "                if label != svgs and label != y:\n",
    "                    tooltips = tooltips.replace('end', f'<div><span style=\"font-size: 12px;\">{label}: @{label}</span></div>end')\n",
    "        \n",
    "        tooltips = tooltips.replace('end', '</div>')\n",
    "        hover = HoverTool(tooltips=tooltips)\n",
    "        if heatmap == False and bubbleplot == False:  # if no heatmap or bubbleplot, build scatter plot  \n",
    "            if title == 'default':  # if no title provided, define from x, y labels\n",
    "                title = f'{y_label} vs. {x_label}'          \n",
    "            plt = hv.Scatter(dataframe, kdims=[x], vdims=hover_list, label=legend).opts(title=title, marker=marker, height=height, width=width, tools=[hover], color=color, alpha=alpha, size=size, line_color=line_color)\n",
    "\n",
    "        elif heatmap == True and bubbleplot == False:\n",
    "            if heatmap_col not in hover_list:\n",
    "                hover_list.append(heatmap_col)\n",
    "            if title == 'default':  # if no title provided, define from x, y labels\n",
    "                title = f'{y_label} vs. {x_label}, colored by {heatmap_col}'\n",
    "            plt = hv.Scatter(dataframe, kdims=[x], vdims=hover_list, label=legend).opts(title=title, marker=marker, height=height, width=width, tools=[hover], color=heatmap_col, cmap=heatmap_color, colorbar=True, clabel=clabel, alpha=alpha, size=size, line_color=line_color)\n",
    "\n",
    "        elif heatmap == False and bubbleplot == True:\n",
    "            if bubblesize not in hover_list:\n",
    "                hover_list.append(bubblesize)\n",
    "            if title == 'default':  # if no title provided, define from x, y labels\n",
    "                title = f'{y_label} vs. {x_label}, sized by {bubblesize}'\n",
    "            min_size = min(dataframe[bubblesize]); max_size = max(dataframe[bubblesize])\n",
    "            plt = hv.Scatter(dataframe, kdims=[x], vdims=hover_list, label=legend).opts(title=title, marker=marker, height=height, width=width, tools=[hover], color=color, alpha=alpha, size=((hv.dim(bubblesize)-min_size)/max_size)*(10*size), line_color=line_color)\n",
    "\n",
    "        elif heatmap == True and bubbleplot == True:\n",
    "            if heatmap_col not in hover_list:\n",
    "                hover_list.append(heatmap_col)\n",
    "            if bubblesize not in hover_list:\n",
    "                hover_list.append(bubblesize)\n",
    "\n",
    "            if title == 'default':\n",
    "                title = f'{y_label} vs. {x_label}, colored by {heatmap_col}, sized by {bubblesize}'\n",
    "            min_size = min(dataframe[bubblesize]); max_size = max(dataframe[bubblesize])\n",
    "            plt = hv.Scatter(dataframe, kdims=[x], vdims=hover_list, label=legend).opts(title=title, marker=marker, height=height, width=width, tools=[hover], color=heatmap_col, cmap=heatmap_color, colorbar=True, clabel=clabel, alpha=alpha, size=((hv.dim(bubblesize)-min_size)/max_size)*(10*size), line_color=line_color, xlim=x_range, ylim=y_range)\n",
    "        \n",
    "        if groupby != None:\n",
    "            color = hv.Cycle(color).values\n",
    "            plt = plt.opts(color=groupby, cmap=color)\n",
    "\n",
    "        return plt\n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "    HoloViews: Slope\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "\"\"\"\n",
    "\n",
    "def plot_slope(\n",
    "    dataframe: pd.DataFrame, \n",
    "    x: str,  # string with column name, used to determine slope\n",
    "    y: str,  # string with column name, used to determine slope\n",
    "    x_label: str = 'default',  # axis label to be printed on plot (does not need to match dataframe name)\n",
    "    y_label: str = 'default',  # axis label to be printed on plot (does not need to match dataframe name)\n",
    "    color: str = '#000000',  # color of slope line\n",
    "    line_width: int = 2,  # width of slope line\n",
    "    alpha: int = 1,  # transparency of slope line\n",
    "    height: int = 500,  # plot height (recommended: 500)\n",
    "    width: int = 500,  # plot width (recommended: 500)\n",
    "    pad: float = 0.0  # padding around data points\n",
    "):\n",
    "    \n",
    "    if x_label == 'default':  # if no x_label provided, use x column name\n",
    "        x_label = x\n",
    "    if y_label == 'default':  # if no y_label provided, use y column name\n",
    "        y_label = y\n",
    "    \n",
    "    x_min, x_max = dataframe[x].agg(['min', 'max'])\n",
    "\n",
    "    y_min, y_max = dataframe[y].agg(['min', 'max'])\n",
    "\n",
    "\n",
    "    line = hv.Bounds((x_min-pad, y_min-pad, x_max+pad, y_max+pad)).opts(color=None)\n",
    "\n",
    "    slope, intercept, r_value, p_value, std_err = stats.linregress(dataframe[x], dataframe[y])\n",
    "    slope_plt = hv.Slope(slope, intercept).opts(xlabel=x_label, ylabel=y_label, line_color=color, line_width=line_width, alpha=alpha, height=height, width=width)\n",
    "    \n",
    "    plt =  hv.Overlay(slope_plt*line)\n",
    "    return plt, slope, intercept, r_value, p_value, std_err\n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "    HoloViews: Confidence Interval\n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "\"\"\"\n",
    "\n",
    "def plot_confidence_interval(\n",
    "        dataframe: pd.DataFrame,  # dataframe\n",
    "        x: str,  # string with column name, used to determine confidence interval\n",
    "        y: str,  # string with column name, used to determine confidence interval\n",
    "        x_label: str = 'default',  # axis label to be printed on plot (does not need to match dataframe name)\n",
    "        x_range: tuple = None,  # range of x-axis\n",
    "        y_label: str = 'default',  # axis label to be printed on plot (does not need to match dataframe name)\n",
    "        y_range: tuple = None,  # range of y-axis\n",
    "        ci: int = 0.999,  # confidence interval (0.9-0.99 recommended)\n",
    "        color: str = '#5289a1',  # color of confidence interval\n",
    "        line_color: str = '#FFFFFF',  # color of confidence interval line\n",
    "        alpha: int = 0.2,  # transparency of confidence interval\n",
    "        height: int = 500,  #plot height (recommended: 500)\n",
    "        width: int = 500,  #plot width (recommended: 500)\n",
    "):\n",
    "        \n",
    "    \"\"\" \n",
    "    Confidence interval calculations use inferences made on the mean and variance of the distributed data (assumes normal distribution)\n",
    "    and is calculated by applying a student-t test. Plotting function based off of HoloViews 'Area' element as 'area between curves'. \n",
    "    See documentation for more information:\n",
    "    hv.help(hv.Area)\n",
    "    https://holoviews.org/reference/elements/bokeh/Area.html\n",
    "    \n",
    "    \"\"\"  \n",
    "\n",
    "    if x_label == 'default':  # if no x_label provided, use x column name\n",
    "        x_label = x\n",
    "    if y_label == 'default':  # if no y_label provided, use y column name\n",
    "        y_label = y\n",
    "\n",
    "    if not x_range:\n",
    "        x_min = min(dataframe[x]); x_max = max(dataframe[x])\n",
    "        x_buffer = abs(x_max-x_min)/10\n",
    "        x_range = (x_min-x_buffer, x_max+x_buffer)\n",
    "    if not y_range:\n",
    "        y_min = min(dataframe[y]); y_max = max(dataframe[y])\n",
    "        y_buffer = abs(y_max-y_min)/10\n",
    "        y_range = (y_min-y_buffer, y_max+y_buffer)\n",
    "\n",
    "    n = len(dataframe[x])\n",
    "    t_value = stats.t.ppf(1 - (1 - ci) / 2, n - 2)  # t-value for confidence interval (student-t test for n-2 degrees of freedom)\n",
    "    x_mean = np.mean(dataframe[x])  # mean of x values\n",
    "    \n",
    "    slope, intercept, r_value, p_value, std_err = stats.linregress(dataframe[x], dataframe[y])\n",
    "\n",
    "    S_xx = (n * np.sum(dataframe[x] ** 2) - np.sum(dataframe[x]) ** 2) / n  # sample-corrected sum of squares (sum of the square of the difference between x and its mean)\n",
    "    S_xy = (n * np.sum(dataframe[x] * dataframe[y]) - np.sum(dataframe[x]) * np.sum(dataframe[y])) / n  # sample-corrected covariance for x and y \n",
    "    S_yy = (n * np.sum(dataframe[y] ** 2) - np.sum(dataframe[y]) ** 2) / n  # sample-corrected sum of squares (sum of the square of the difference between y and its mean)\n",
    "    \n",
    "    SSE = S_yy - slope * S_xy # sum of squared estimate of errors (deviation of the observed value from the estimated value)\n",
    "    s2 = SSE / (n - 2)  #variance of the x, y data\n",
    "    s = np.sqrt(s2)  # standard deviation of the x, y data\n",
    "\n",
    "    unique_x = np.unique(dataframe[x])  # unique x values (prevents overplotting of confidence interval)\n",
    "    mean_upperconfidence_list = slope * unique_x + intercept + t_value * s * np.sqrt((1 / n + (np.square(unique_x - x_mean)) / S_xx))  # line for upper confidence interval\n",
    "    mean_lowerconfidence_list = slope * unique_x + intercept - t_value * s * np.sqrt((1 / n + (np.square(unique_x - x_mean)) / S_xx))  # line for lower confidence interval\n",
    "\n",
    "    upper_spread = interp1d(x=unique_x, y=mean_upperconfidence_list, kind='quadratic', fill_value='extrapolate')  # interpolation function for upper confidence interval (smooths line)\n",
    "    lower_spread = interp1d(x=unique_x, y=mean_lowerconfidence_list, kind='quadratic', fill_value='extrapolate')  # interpolation function for lower confidence interval (smooths line)\n",
    "\n",
    "    ci_x = np.linspace(min(unique_x) - abs(max(unique_x) - min(unique_x)) / 2, max(unique_x) + abs(max(unique_x) - min(unique_x)) / 2, num=1000)  # x values for confidence interval plot (extends beyond data range)\n",
    "    ci_upper_y = upper_spread(ci_x)  # y values for upper confidence interval plot corresponding to 'extended' x values\n",
    "    ci_lower_y = lower_spread(ci_x)  # y values for lower confidence interval plot corresponding to 'extended' x values\n",
    "\n",
    "    # plot confidence interval\n",
    "    ci_plt = hv.Area((ci_x, ci_upper_y, ci_lower_y), vdims=['ci_y1', 'ci_y2']).opts(xlabel=x_label, ylabel=y_label, color=color, alpha=alpha, line_color=line_color, height=height, width=width, xlim=x_range, ylim=y_range)\n",
    "    return ci_plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a55380",
   "metadata": {},
   "source": [
    "# Data Import from Data Frame and Generate SMILES Images (skip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91a28d3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# excel_file = 'example_spreadsheet.xlsx'\n",
    "# excel_sheet = 'Sheet1'\n",
    "# header = 0  # row number of header (0-index) (set header = 1 to drop row with x1, x2... column names if present)\n",
    "\n",
    "# id_column = 'Name' #name or 0-index\n",
    "# smiles_column = 'Smiles' #name or 0-index (leave blank if not available)\n",
    "# response_column = 'Fake Yield' #name or 0-index (leave blank if not available)\n",
    "# descriptor_start_column = 'P_NMR_min' #name or 0-index\n",
    "# image_column = 'Image' #name of column that svgs will go into (not pre-existing)\n",
    "\n",
    "# # Read in data\n",
    "# df = pd.read_excel(excel_file, excel_sheet, header=header, engine='openpyxl')\n",
    "# df = df.dropna(axis=1, how='any')\n",
    "\n",
    "# # Generate list of descriptors \n",
    "# descriptor_start_column_loc, descriptor_start_column = get_column_loc(descriptor_start_column, df)\n",
    "# descriptors = list(df.columns)[descriptor_start_column_loc:]\n",
    "\n",
    "# #  Generate folder for any saved figures, named with run date\n",
    "# run_date = date.today().strftime(\"%b-%d-%Y\")\n",
    "# if not os.path.exists(run_date):\n",
    "#     os.makedirs(run_date)\n",
    "\n",
    "# # Generate SMILES images\n",
    "# image_column = 'Image' #name of column that svgs will go into (not pre-existing)\n",
    "\n",
    "# smiles_column_loc, smiles_column = get_column_loc(smiles_column, df)\n",
    "# df = DrawMol(df, smiles_column_loc, image_column)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "417692d4",
   "metadata": {},
   "source": [
    "# Data Import from Pickle File (SMILES SVGs pre-generated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbdccd68",
   "metadata": {},
   "outputs": [],
   "source": [
    "id_column = 'Name' #name or 0-index\n",
    "response_column = 'Fake Yield' #name or 0-index (leave blank if not available)\n",
    "descriptor_start_column = 'P_NMR_min' #name or 0-index\n",
    "image_column = 'Image'  \n",
    "\n",
    "# Read in data from pickle file (svgs are already imbedded)\n",
    "df = pd.read_pickle('tutorial_df.pkl')\n",
    "\n",
    "# Generate list of descriptors \n",
    "descriptor_start_column_loc, descriptor_start_column = get_column_loc(descriptor_start_column, df)\n",
    "descriptors = list(df.columns)[descriptor_start_column_loc:]\n",
    "\n",
    "#  Generate folder for any saved figures, named with run date\n",
    "run_date = date.today().strftime(\"%b-%d-%Y\")\n",
    "if not os.path.exists(run_date):\n",
    "    os.makedirs(run_date)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7889452",
   "metadata": {},
   "source": [
    "# Modeling"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a6b4182",
   "metadata": {},
   "source": [
    "## Univariate Scatter Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b0a416e",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df\n",
    "x_axis = 'P_NBO_max'\n",
    "y_axis = response_column\n",
    "hover_list = [id_column]\n",
    "\n",
    "scatter_plt = scatter_plot(dataframe, x=x_axis, y=y_axis, svgs=image_column, hover_list=hover_list, color='#7291ab', alpha=0.8)\n",
    "scatter_plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b53831c",
   "metadata": {},
   "source": [
    "## Slope Line"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6baf268",
   "metadata": {},
   "source": [
    "Scroll out to visualize line - no set axes on this plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc8df4e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "line, slope, intercept, r_value, p_value, std_err = plot_slope(dataframe, x=x_axis, y=y_axis)\n",
    "\n",
    "line"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "662b6910",
   "metadata": {},
   "source": [
    "## Confidence Interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b262f638",
   "metadata": {},
   "outputs": [],
   "source": [
    "confidence_interval = plot_confidence_interval(dataframe, x=x_axis, y=y_axis, ci=0.99)  # Confidence interval is calculated incorrectly here but represents the function\n",
    "confidence_interval"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdaba064",
   "metadata": {},
   "source": [
    "## Combine Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31f51b35",
   "metadata": {},
   "outputs": [],
   "source": [
    "scatter_plt * line  # bottom layer (first) contains interactive information (if multiple layers contain hover information), top layer is last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14ec2191",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt = scatter_plt * line * confidence_interval  # bottom layer (first) contains interactive information, top layer is last\n",
    "plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7bfb27a",
   "metadata": {},
   "source": [
    "# Save HTML File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef04af64",
   "metadata": {},
   "outputs": [],
   "source": [
    "file_name = 'univariate model {y_axis} vs {x_axis}'\n",
    "file_path = run_date\n",
    "\n",
    "hv.save(plt, file_path + '/' + file_name + '.html', fmt='html')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94f3804e",
   "metadata": {},
   "source": [
    "# Chemical Space: PCA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6316a44",
   "metadata": {},
   "source": [
    "## Run PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "172ab012",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df \n",
    "train_dataframe = dataframe\n",
    "n_components = 2\n",
    "\n",
    "# Fit PCA\n",
    "pca = PCA(n_components=n_components)\n",
    "pca.fit(train_dataframe[descriptors])\n",
    "principal_components = pca.transform(dataframe[descriptors])\n",
    "\n",
    "# Add principal components to dataframe\n",
    "for i in range(n_components):\n",
    "    dataframe[f'pc{i+1}'] = principal_components[:, i]\n",
    "\n",
    "# Print explained variance\n",
    "pca_score = pca.explained_variance_ratio_\n",
    "print(f'Variance explained by each principal component:')\n",
    "for i, variance in enumerate(pca_score):\n",
    "    print(f'pc{i+1}: {round(variance*100, 1)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a31bc3d9",
   "metadata": {},
   "source": [
    "## Interactive PCA Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c98c451",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df\n",
    "x_axis = 'pc1'\n",
    "y_axis = 'pc2'\n",
    "hover_list = [id_column]  # set svgs = column name if images are available, they will be automatically added to hover_list\n",
    "\n",
    "plt = scatter_plot(dataframe, x=x_axis, y=y_axis, svgs=image_column, hover_list=hover_list, color='#7291ab', alpha=0.8)\n",
    "plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15f1dea1",
   "metadata": {},
   "source": [
    "## Cluster PCA Space (k-Means)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f568c460",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Uncomment if KElbowVisualizer (below) is producing a font error\n",
    "\n",
    "# import matplotlib.pyplot as plt\n",
    "# plt.rcParams[\"font.family\"] = \"DejaVu Sans\"  # or another font available on your system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "526284c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df\n",
    "dimred_columns = [col for col in dataframe.columns if col.startswith('pc')]  # list of columns with principal components\n",
    "\n",
    "clustering_algorithm = 'kMeans'\n",
    "clustering_range = (5,15)\n",
    "random_state = 42\n",
    "n_init = 10 \n",
    "\n",
    "model = KMeans(random_state=random_state, n_init=n_init)\n",
    "visualizer = KElbowVisualizer(model, k=clustering_range)\n",
    "visualizer.fit(dataframe[dimred_columns])  # Fit the data to the visualizer\n",
    "n_clust = visualizer.elbow_value_\n",
    "print(f'Optimal number of clusters using distortion score (elbow plot): {n_clust}')\n",
    "visualizer.show()  # Finalize and render the figure\n",
    "\n",
    "# Add cluster number to dataframe using optimal number of clusters\n",
    "kmeans_clustering = KMeans(n_clusters=n_clust, random_state=random_state, n_init=n_init)\n",
    "kmeans_clustering.fit(dataframe[dimred_columns])\n",
    "\n",
    "# Add cluster number to dataframe\n",
    "dataframe[f'{clustering_algorithm}_cluster'] = kmeans_clustering.labels_ + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3251ef91",
   "metadata": {},
   "source": [
    "## Interactive Clustered PCA Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adbbec84",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df\n",
    "x_axis = 'pc1'\n",
    "y_axis = 'pc2'\n",
    "\n",
    "groupby = 'kMeans_cluster'  # name or 0-index for column used to group data\n",
    "color_palette = 'Category20'  # color palette for grouped data- limited Bokeh support for use with 'groupby'\n",
    "\n",
    "plt = scatter_plot(dataframe, x=x_axis, y=y_axis, svgs=image_column, hover_list=[id_column], groupby=groupby, color=color_palette)\n",
    "plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e88a429d",
   "metadata": {},
   "source": [
    "# Interactive Plotting Tools (advanced mode)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83b435e3",
   "metadata": {},
   "source": [
    "Examples shown using PCA plot generated above and can be modified in many ways"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac3e6110",
   "metadata": {},
   "source": [
    "## Categorical Coloring (user defined colors and labels, in contrast to cluster plotting method above)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48ea9a21",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df\n",
    "x_axis = 'pc1'\n",
    "y_axis = 'pc2'\n",
    "\n",
    "category_column = 'Commercial'  # name or 0-index for column containing category criteria\n",
    "category_criteria = {  # column value: [label, color] (column value can be string or integer)\n",
    "    0: ['Non-commercial', '#7291ab'],\n",
    "    1: ['Commercial', '#45d7ed']\n",
    "}\n",
    "\n",
    "plt = None\n",
    "for key, value in category_criteria.items():\n",
    "    legend = value[0]\n",
    "    color = value[1]\n",
    "    if plt:\n",
    "        subplt = scatter_plot(dataframe.loc[dataframe[category_column] == key], x=x_axis, y=y_axis, legend=legend, svgs=image_column, hover_list=[id_column], color=color)\n",
    "        plt = plt * subplt\n",
    "    else:\n",
    "        plt = scatter_plot(dataframe.loc[dataframe[category_column] == key], x=x_axis, y=y_axis, legend=legend, svgs=image_column, hover_list=[id_column], color=color)\n",
    "base_plt = scatter_plot(dataframe, x=x_axis, y=y_axis, svgs=image_column, hover_list=[id_column], alpha=0)  # add svg hover info to all layers (default is bottom plt only)\n",
    "plt = base_plt * plt\n",
    "plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "581966a0",
   "metadata": {},
   "source": [
    "## Heatmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f7d6c14",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df\n",
    "x_axis = 'pc1'\n",
    "y_axis = 'pc2'\n",
    "color_col = 'bite_angle'  # dataframe column used to color data points\n",
    "heatmap_color = 'Plasma_r'\n",
    "title = f'PCA, colored by {color_col}'\n",
    "hover_list = [id_column]\n",
    "\n",
    "plt = scatter_plot(dataframe, x=x_axis, y=y_axis, title=title, svgs=image_column, hover_list=hover_list, heatmap=True, heatmap_col=color_col, heatmap_color=heatmap_color, alpha=0.8)\n",
    "plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4338d6e5",
   "metadata": {},
   "source": [
    "## Bubble Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc1a01ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "dataframe = df\n",
    "x_axis = 'pc1'\n",
    "y_axis = 'pc2'\n",
    "size_col = 'bite_angle'\n",
    "title = f'PCA, sized by {size_col}'\n",
    "hover_list = [id_column]\n",
    "\n",
    "plt = scatter_plot(dataframe, x=x_axis, y=y_axis, title=title, svgs=image_column, hover_list=hover_list, bubbleplot=True, bubblesize=size_col, alpha=0.8)\n",
    "\n",
    "plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3af2c711",
   "metadata": {},
   "source": [
    "## Heatmap Bubble Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8d09944",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = df\n",
    "x_axis = 'pc1'\n",
    "y_axis = 'pc2'\n",
    "color_col = response_column\n",
    "heatmap_color = 'Plasma'\n",
    "size_col = 'bite_angle'\n",
    "hover_list = [id_column]\n",
    "\n",
    "save_plot = False\n",
    "file_name = 'pca heatmap bubbleplot'\n",
    "file_path = run_date\n",
    "\n",
    "plt = scatter_plot(dataframe, x=x_axis, y=y_axis, svgs=image_column, hover_list=hover_list, heatmap=True, heatmap_col=color_col, heatmap_color=heatmap_color, bubbleplot=True, bubblesize=size_col, alpha=0.8)\n",
    "\n",
    "if save_plot:\n",
    "    hv.save(plt, file_path + '/' + file_name + '.html', fmt='html')\n",
    "\n",
    "plt"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}