Heatmaps - Applicability Domain.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "#hiding warning messages\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import time "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files\n",
    "grep_nb = pd.read_csv('grep_nb_appl', sep = '\\t')\n",
    "grep_nb = grep_nb.T\n",
    "grep_nb = grep_nb.reset_index()\n",
    "grep_nb = grep_nb.T\n",
    "grep_nb = grep_nb.reset_index(drop = True)\n",
    "\n",
    "#converting to str (NB)\n",
    "grep_nb = grep_nb.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_nb = grep_nb[1].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_nb)):\n",
    "    str_split_nb[i] = str_split_nb[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "#making df\n",
    "scores_nb = pd.DataFrame(str_split_nb)\n",
    "\n",
    "#label df\n",
    "labels_nb = pd.DataFrame(grep_nb[0])\n",
    "labels_nb = labels_nb.rename(columns = {0 : 'labels'})\n",
    "\n",
    "#combining\n",
    "data_nb = pd.concat([labels_nb, scores_nb], axis = 1)\n",
    "\n",
    "#reindexing\n",
    "data_nb = data_nb.rename(columns = {0 : 'ACC', 1 : 'AUC', 2 : 'MCC', 3 : 'SENS', 4 : 'SPHE', 5 : 'BACC',})\n",
    "data_nb = data_nb.set_index('labels')\n",
    "\n",
    "#seperating datasets into Train, Test, Ext1, Ext2, Ext3\n",
    "data_nb = data_nb.iloc[:25]\n",
    "data_nb.loc['output_maccs:Test']\n",
    "subset_nb_train = data_nb.loc[['output_maccs:Train', 'output_top:Train', 'output_ecfp:Train', 'output_fcfp:Train', 'output_pub:Train',], :]\n",
    "subset_nb_test = data_nb.loc[['output_maccs:Test', 'output_top:Test', 'output_ecfp:Test', 'output_fcfp:Test', 'output_pub:Test',], :]\n",
    "subset_nb_ext1 = data_nb.loc[['output_maccs:Ext1', 'output_top:Ext1', 'output_ecfp:Ext1', 'output_fcfp:Ext1', 'output_pub:Ext1',], :]\n",
    "subset_nb_ext2 = data_nb.loc[['output_maccs:Ext2', 'output_top:Ext2', 'output_ecfp:Ext2', 'output_fcfp:Ext2', 'output_pub:Ext2',], :]\n",
    "#subset_nb_ext3 = data_nb.loc[['output_maccs:Ext3', 'output_top:Ext3', 'output_ecfp:Ext3', 'output_fcfp:Ext3', 'output_pub:Ext3',], :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files\n",
    "grep_dt = pd.read_csv('grep_dt_appl', sep = '\\t')\n",
    "grep_dt = grep_dt.T\n",
    "grep_dt = grep_dt.reset_index()\n",
    "grep_dt = grep_dt.T\n",
    "grep_dt = grep_dt.reset_index(drop = True)\n",
    "\n",
    "#converting to str (dt)\n",
    "grep_dt = grep_dt.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_dt = grep_dt[1].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_dt)):\n",
    "    str_split_dt[i] = str_split_dt[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "#making df\n",
    "scores_dt = pd.DataFrame(str_split_dt)\n",
    "\n",
    "#label df\n",
    "labels_dt = pd.DataFrame(grep_dt[0])\n",
    "labels_dt = labels_dt.rename(columns = {0 : 'labels'})\n",
    "\n",
    "#combining\n",
    "data_dt = pd.concat([labels_dt, scores_dt], axis = 1)\n",
    "\n",
    "#reindexing\n",
    "data_dt = data_dt.rename(columns = {0 : 'ACC', 1 : 'AUC', 2 : 'MCC', 3 : 'SENS', 4 : 'SPHE', 5 : 'BACC',})\n",
    "data_dt = data_dt.set_index('labels')\n",
    "\n",
    "#seperating datasets into Train, Test, Ext1, Ext2, Ext3\n",
    "data_dt = data_dt.iloc[:25]\n",
    "data_dt.loc['output_maccs:Test']\n",
    "subset_dt_train = data_dt.loc[['output_maccs:Train', 'output_top:Train', 'output_ecfp:Train', 'output_fcfp:Train', 'output_pub:Train',], :]\n",
    "subset_dt_test = data_dt.loc[['output_maccs:Test', 'output_top:Test', 'output_ecfp:Test', 'output_fcfp:Test', 'output_pub:Test',], :]\n",
    "subset_dt_ext1 = data_dt.loc[['output_maccs:Ext1', 'output_top:Ext1', 'output_ecfp:Ext1', 'output_fcfp:Ext1', 'output_pub:Ext1',], :]\n",
    "subset_dt_ext2 = data_dt.loc[['output_maccs:Ext2', 'output_top:Ext2', 'output_ecfp:Ext2', 'output_fcfp:Ext2', 'output_pub:Ext2',], :]\n",
    "#subset_dt_ext3 = data_dt.loc[['output_maccs:Ext3', 'output_top:Ext3', 'output_ecfp:Ext3', 'output_fcfp:Ext3', 'output_pub:Ext3',], :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files\n",
    "grep_rf = pd.read_csv('grep_rf_appl', sep = '\\t')\n",
    "grep_rf = grep_rf.T\n",
    "grep_rf = grep_rf.reset_index()\n",
    "grep_rf = grep_rf.T\n",
    "grep_rf = grep_rf.reset_index(drop = True)\n",
    "\n",
    "#converting to str (rf)\n",
    "grep_rf = grep_rf.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_rf = grep_rf[1].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_rf)):\n",
    "    str_split_rf[i] = str_split_rf[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "#making df\n",
    "scores_rf = pd.DataFrame(str_split_rf)\n",
    "\n",
    "#label df\n",
    "labels_rf = pd.DataFrame(grep_rf[0])\n",
    "labels_rf = labels_rf.rename(columns = {0 : 'labels'})\n",
    "\n",
    "#combining\n",
    "data_rf = pd.concat([labels_rf, scores_rf], axis = 1)\n",
    "\n",
    "#reindexing\n",
    "data_rf = data_rf.rename(columns = {0 : 'ACC', 1 : 'AUC', 2 : 'MCC', 3 : 'SENS', 4 : 'SPHE', 5 : 'BACC',})\n",
    "data_rf = data_rf.set_index('labels')\n",
    "\n",
    "#seperating datasets into Train, Test, Ext1, Ext2, Ext3\n",
    "data_rf = data_rf.iloc[:25]\n",
    "data_rf.loc['output_maccs:Test']\n",
    "subset_rf_train = data_rf.loc[['output_maccs:Train', 'output_top:Train', 'output_ecfp:Train', 'output_fcfp:Train', 'output_pub:Train',], :]\n",
    "subset_rf_test = data_rf.loc[['output_maccs:Test', 'output_top:Test', 'output_ecfp:Test', 'output_fcfp:Test', 'output_pub:Test',], :]\n",
    "subset_rf_ext1 = data_rf.loc[['output_maccs:Ext1', 'output_top:Ext1', 'output_ecfp:Ext1', 'output_fcfp:Ext1', 'output_pub:Ext1',], :]\n",
    "subset_rf_ext2 = data_rf.loc[['output_maccs:Ext2', 'output_top:Ext2', 'output_ecfp:Ext2', 'output_fcfp:Ext2', 'output_pub:Ext2',], :]\n",
    "#subset_rf_ext3 = data_rf.loc[['output_maccs:Ext3', 'output_top:Ext3', 'output_ecfp:Ext3', 'output_fcfp:Ext3', 'output_pub:Ext3',], :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files\n",
    "grep_knn = pd.read_csv('grep_knn_appl', sep = '\\t')\n",
    "grep_knn = grep_knn.T\n",
    "grep_knn = grep_knn.reset_index()\n",
    "grep_knn = grep_knn.T\n",
    "grep_knn = grep_knn.reset_index(drop = True)\n",
    "\n",
    "#converting to str (knn)\n",
    "grep_knn = grep_knn.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_knn = grep_knn[1].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_knn)):\n",
    "    str_split_knn[i] = str_split_knn[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "#making df\n",
    "scores_knn = pd.DataFrame(str_split_knn)\n",
    "\n",
    "#label df\n",
    "labels_knn = pd.DataFrame(grep_knn[0])\n",
    "labels_knn = labels_knn.rename(columns = {0 : 'labels'})\n",
    "\n",
    "#combining\n",
    "data_knn = pd.concat([labels_knn, scores_knn], axis = 1)\n",
    "\n",
    "#reindexing\n",
    "data_knn = data_knn.rename(columns = {0 : 'ACC', 1 : 'AUC', 2 : 'MCC', 3 : 'SENS', 4 : 'SPHE', 5 : 'BACC',})\n",
    "data_knn = data_knn.set_index('labels')\n",
    "\n",
    "#seperating datasets into Train, Test, Ext1, Ext2, Ext3\n",
    "data_knn = data_knn.iloc[:25]\n",
    "data_knn.loc['output_maccs:Test']\n",
    "subset_knn_train = data_knn.loc[['output_maccs:Train', 'output_top:Train', 'output_ecfp:Train', 'output_fcfp:Train', 'output_pub:Train',], :]\n",
    "subset_knn_test = data_knn.loc[['output_maccs:Test', 'output_top:Test', 'output_ecfp:Test', 'output_fcfp:Test', 'output_pub:Test',], :]\n",
    "subset_knn_ext1 = data_knn.loc[['output_maccs:Ext1', 'output_top:Ext1', 'output_ecfp:Ext1', 'output_fcfp:Ext1', 'output_pub:Ext1',], :]\n",
    "subset_knn_ext2 = data_knn.loc[['output_maccs:Ext2', 'output_top:Ext2', 'output_ecfp:Ext2', 'output_fcfp:Ext2', 'output_pub:Ext2',], :]\n",
    "#subset_knn_ext3 = data_knn.loc[['output_maccs:Ext3', 'output_top:Ext3', 'output_ecfp:Ext3', 'output_fcfp:Ext3', 'output_pub:Ext3',], :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files\n",
    "grep_svm = pd.read_csv('grep_svm_appl', sep = '\\t')\n",
    "grep_svm = grep_svm.T\n",
    "grep_svm = grep_svm.reset_index()\n",
    "grep_svm = grep_svm.T\n",
    "grep_svm = grep_svm.reset_index(drop = True)\n",
    "\n",
    "#converting to str (svm)\n",
    "grep_svm = grep_svm.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_svm = grep_svm[1].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_svm)):\n",
    "    str_split_svm[i] = str_split_svm[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "#making df\n",
    "scores_svm = pd.DataFrame(str_split_svm)\n",
    "\n",
    "#label df\n",
    "labels_svm = pd.DataFrame(grep_svm[0])\n",
    "labels_svm = labels_svm.rename(columns = {0 : 'labels'})\n",
    "\n",
    "#combining\n",
    "data_svm = pd.concat([labels_svm, scores_svm], axis = 1)\n",
    "\n",
    "#reindexing\n",
    "data_svm = data_svm.rename(columns = {0 : 'ACC', 1 : 'AUC', 2 : 'MCC', 3 : 'SENS', 4 : 'SPHE', 5 : 'BACC',})\n",
    "data_svm = data_svm.set_index('labels')\n",
    "\n",
    "#seperating datasets into Train, Test, Ext1, Ext2, Ext3\n",
    "data_svm = data_svm.iloc[:25]\n",
    "data_svm.loc['output_maccs:Test']\n",
    "subset_svm_train = data_svm.loc[['output_maccs:Train', 'output_top:Train', 'output_ecfp:Train', 'output_fcfp:Train', 'output_pub:Train',], :]\n",
    "subset_svm_test = data_svm.loc[['output_maccs:Test', 'output_top:Test', 'output_ecfp:Test', 'output_fcfp:Test', 'output_pub:Test',], :]\n",
    "subset_svm_ext1 = data_svm.loc[['output_maccs:Ext1', 'output_top:Ext1', 'output_ecfp:Ext1', 'output_fcfp:Ext1', 'output_pub:Ext1',], :]\n",
    "subset_svm_ext2 = data_svm.loc[['output_maccs:Ext2', 'output_top:Ext2', 'output_ecfp:Ext2', 'output_fcfp:Ext2', 'output_pub:Ext2',], :]\n",
    "#subset_svm_ext3 = data_svm.loc[['output_maccs:Ext3', 'output_top:Ext3', 'output_ecfp:Ext3', 'output_fcfp:Ext3', 'output_pub:Ext3',], :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files\n",
    "grep_nn = pd.read_csv('grep_nn_appl', sep = '\\t')\n",
    "grep_nn = grep_nn.T\n",
    "grep_nn = grep_nn.reset_index()\n",
    "grep_nn = grep_nn.T\n",
    "grep_nn = grep_nn.reset_index(drop = True)\n",
    "\n",
    "#converting to str (nn)\n",
    "grep_nn = grep_nn.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_nn = grep_nn[1].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_nn)):\n",
    "    str_split_nn[i] = str_split_nn[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "#making df\n",
    "scores_nn = pd.DataFrame(str_split_nn)\n",
    "\n",
    "#label df\n",
    "labels_nn = pd.DataFrame(grep_nn[0])\n",
    "labels_nn = labels_nn.rename(columns = {0 : 'labels'})\n",
    "\n",
    "#combining\n",
    "data_nn = pd.concat([labels_nn, scores_nn], axis = 1)\n",
    "\n",
    "#reindexing\n",
    "data_nn = data_nn.rename(columns = {0 : 'ACC', 1 : 'AUC', 2 : 'MCC', 3 : 'SENS', 4 : 'SPHE', 5 : 'BACC',})\n",
    "data_nn = data_nn.set_index('labels')\n",
    "\n",
    "#seperating datasets into Train, Test, Ext1, Ext2, Ext3\n",
    "data_nn = data_nn.iloc[:25]\n",
    "data_nn.loc['output_maccs:Test']\n",
    "subset_nn_train = data_nn.loc[['output_maccs:Train', 'output_top:Train', 'output_ecfp:Train', 'output_fcfp:Train', 'output_pub:Train',], :]\n",
    "subset_nn_test = data_nn.loc[['output_maccs:Test', 'output_top:Test', 'output_ecfp:Test', 'output_fcfp:Test', 'output_pub:Test',], :]\n",
    "subset_nn_ext1 = data_nn.loc[['output_maccs:Ext1', 'output_top:Ext1', 'output_ecfp:Ext1', 'output_fcfp:Ext1', 'output_pub:Ext1',], :]\n",
    "subset_nn_ext2 = data_nn.loc[['output_maccs:Ext2', 'output_top:Ext2', 'output_ecfp:Ext2', 'output_fcfp:Ext2', 'output_pub:Ext2',], :]\n",
    "#subset_nn_ext3 = data_nn.loc[['output_maccs:Ext3', 'output_top:Ext3', 'output_ecfp:Ext3', 'output_fcfp:Ext3', 'output_pub:Ext3',], :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combining Dataframes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining auc for tests\n",
    "auc_nb_test = subset_nb_test['AUC']\n",
    "auc_dt_test = subset_dt_test['AUC']\n",
    "auc_rf_test = subset_rf_test['AUC']\n",
    "auc_knn_test = subset_knn_test['AUC']\n",
    "auc_svm_test = subset_svm_test['AUC']\n",
    "auc_nn_test = subset_nn_test['AUC']\n",
    "auc_all_test = pd.concat([auc_nb_test, auc_dt_test, auc_rf_test, auc_knn_test, auc_svm_test, auc_svm_test], axis = 1)\n",
    "auc_all_test.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "auc_all_test['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "auc_all_test = auc_all_test.set_index('FPs')\n",
    "auc_all_test = auc_all_test.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#combining auc for ext1\n",
    "auc_nb_ext1 = subset_nb_ext1['AUC']\n",
    "auc_dt_ext1 = subset_dt_ext1['AUC']\n",
    "auc_rf_ext1 = subset_rf_ext1['AUC']\n",
    "auc_knn_ext1 = subset_knn_ext1['AUC']\n",
    "auc_svm_ext1 = subset_svm_ext1['AUC']\n",
    "auc_nn_ext1 = subset_nn_ext1['AUC']\n",
    "auc_all_ext1 = pd.concat([auc_nb_ext1, auc_dt_ext1, auc_rf_ext1, auc_knn_ext1, auc_svm_ext1, auc_svm_ext1], axis = 1)\n",
    "auc_all_ext1.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "auc_all_ext1['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "auc_all_ext1 = auc_all_ext1.set_index('FPs')\n",
    "auc_all_ext1 = auc_all_ext1.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining auc for ext2\n",
    "auc_nb_ext2 = subset_nb_ext2['AUC']\n",
    "auc_dt_ext2 = subset_dt_ext2['AUC']\n",
    "auc_rf_ext2 = subset_rf_ext2['AUC']\n",
    "auc_knn_ext2 = subset_knn_ext2['AUC']\n",
    "auc_svm_ext2 = subset_svm_ext2['AUC']\n",
    "auc_nn_ext2 = subset_nn_ext2['AUC']\n",
    "auc_all_ext2 = pd.concat([auc_nb_ext2, auc_dt_ext2, auc_rf_ext2, auc_knn_ext2, auc_svm_ext2, auc_svm_ext2], axis = 1)\n",
    "auc_all_ext2.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "auc_all_ext2['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "auc_all_ext2 = auc_all_ext2.set_index('FPs')\n",
    "auc_all_ext2 = auc_all_ext2.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining auc for ext3\n",
    "#auc_nb_ext3 = subset_nb_ext3['AUC']\n",
    "#auc_dt_ext3 = subset_dt_ext3['AUC']\n",
    "#auc_rf_ext3 = subset_rf_ext3['AUC']\n",
    "#auc_knn_ext3 = subset_knn_ext3['AUC']\n",
    "#auc_svm_ext3 = subset_svm_ext3['AUC']\n",
    "#uc_nn_ext3 = subset_nn_ext3['AUC']\n",
    "#auc_all_ext3 = pd.concat([auc_nb_ext3, auc_dt_ext3, auc_rf_ext3, auc_knn_ext3, auc_svm_ext3, auc_svm_ext3], axis = 1)\n",
    "#uc_all_ext3.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "#auc_all_ext3['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "#auc_all_ext3 = auc_all_ext3.set_index('FPs')\n",
    "#auc_all_ext3 = auc_all_ext3.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining bacc for tests\n",
    "bacc_nb_test = subset_nb_test['BACC']\n",
    "bacc_dt_test = subset_dt_test['BACC']\n",
    "bacc_rf_test = subset_rf_test['BACC']\n",
    "bacc_knn_test = subset_knn_test['BACC']\n",
    "bacc_svm_test = subset_svm_test['BACC']\n",
    "bacc_nn_test = subset_nn_test['BACC']\n",
    "bacc_all_test = pd.concat([bacc_nb_test, bacc_dt_test, bacc_rf_test, bacc_knn_test, bacc_svm_test, bacc_svm_test], axis = 1)\n",
    "bacc_all_test.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "bacc_all_test['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "bacc_all_test = bacc_all_test.set_index('FPs')\n",
    "bacc_all_test = bacc_all_test.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining bacc for ext1\n",
    "bacc_nb_ext1 = subset_nb_ext1['BACC']\n",
    "bacc_dt_ext1 = subset_dt_ext1['BACC']\n",
    "bacc_rf_ext1 = subset_rf_ext1['BACC']\n",
    "bacc_knn_ext1 = subset_knn_ext1['BACC']\n",
    "bacc_svm_ext1 = subset_svm_ext1['BACC']\n",
    "bacc_nn_ext1 = subset_nn_ext1['BACC']\n",
    "bacc_all_ext1 = pd.concat([bacc_nb_ext1, bacc_dt_ext1, bacc_rf_ext1, bacc_knn_ext1, bacc_svm_ext1, bacc_svm_ext1], axis = 1)\n",
    "bacc_all_ext1.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "bacc_all_ext1['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "bacc_all_ext1 = bacc_all_ext1.set_index('FPs')\n",
    "bacc_all_ext1 = bacc_all_ext1.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining bacc for ext1\n",
    "bacc_nb_ext2 = subset_nb_ext2['BACC']\n",
    "bacc_dt_ext2 = subset_dt_ext2['BACC']\n",
    "bacc_rf_ext2 = subset_rf_ext2['BACC']\n",
    "bacc_knn_ext2 = subset_knn_ext2['BACC']\n",
    "bacc_svm_ext2 = subset_svm_ext2['BACC']\n",
    "bacc_nn_ext2 = subset_nn_ext2['BACC']\n",
    "bacc_all_ext2 = pd.concat([bacc_nb_ext2, bacc_dt_ext2, bacc_rf_ext2, bacc_knn_ext2, bacc_svm_ext2, bacc_svm_ext2], axis = 1)\n",
    "bacc_all_ext2.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "bacc_all_ext2['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "bacc_all_ext2 = bacc_all_ext2.set_index('FPs')\n",
    "bacc_all_ext2 = bacc_all_ext2.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining sens for tests\n",
    "sens_nb_test = subset_nb_test['SENS']\n",
    "sens_dt_test = subset_dt_test['SENS']\n",
    "sens_rf_test = subset_rf_test['SENS']\n",
    "sens_knn_test = subset_knn_test['SENS']\n",
    "sens_svm_test = subset_svm_test['SENS']\n",
    "sens_nn_test = subset_nn_test['SENS']\n",
    "sens_all_test = pd.concat([sens_nb_test, sens_dt_test, sens_rf_test, sens_knn_test, sens_svm_test, sens_svm_test], axis = 1)\n",
    "sens_all_test.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "sens_all_test['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "sens_all_test = sens_all_test.set_index('FPs')\n",
    "sens_all_test = sens_all_test.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#combining sphe for tests\n",
    "sphe_nb_test = subset_nb_test['SPHE']\n",
    "sphe_dt_test = subset_dt_test['SPHE']\n",
    "sphe_rf_test = subset_rf_test['SPHE']\n",
    "sphe_knn_test = subset_knn_test['SPHE']\n",
    "sphe_svm_test = subset_svm_test['SPHE']\n",
    "sphe_nn_test = subset_nn_test['SPHE']\n",
    "sphe_all_test = pd.concat([sphe_nb_test, sphe_dt_test, sphe_rf_test, sphe_knn_test, sphe_svm_test, sphe_svm_test], axis = 1)\n",
    "sphe_all_test.columns = ['Naive Bayes', 'Decision Tree', 'Random Forest', 'K Nearest Neighbors', 'Support Vector Machine', 'Neural Network']\n",
    "sphe_all_test['FPs'] = ['Maccs', 'Topological', 'Morgan ECFP', 'Morgan FCFP', 'PubChem']\n",
    "sphe_all_test = sphe_all_test.set_index('FPs')\n",
    "sphe_all_test = sphe_all_test.astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making Heatmaps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x260ba48afd0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = plt.figure(figsize = (5, 3))\n",
    "sns.heatmap(bacc_all_ext2, annot = True, cmap = cm.YlGnBu, vmin = 0.5, vmax = 1)\n",
    "#f.savefig(\"auc_ncgc_appl.png\", bbox_inches='tight', dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x260b9a590f0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (5, 3))\n",
    "sns.heatmap(auc_all_ext1, annot = True, cmap = cm.YlGnBu, vmin = 0.5, vmax = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x260b9b92d68>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (5, 3))\n",
    "sns.heatmap(auc_all_ext2, annot = True, cmap = cm.YlGnBu, vmin = 0.5, vmax = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x260b9c69f60>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.heatmap(sphe_all_test, annot = True, cmap = cm.Reds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x260b9d52470>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.heatmap(auc_all_ext1, annot = True, cmap = cm.Reds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x260b9e26978>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.heatmap(auc_all_ext2, annot = True, cmap = cm.Reds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'auc_all_ext3' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-9620fd3f2fcc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mheatmap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mauc_all_ext3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mannot\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcmap\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcm\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mReds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'auc_all_ext3' is not defined"
     ]
    }
   ],
   "source": [
    "sns.heatmap(auc_all_ext3, annot = True, cmap = cm.Reds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}