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": [
    "# MACCS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files - Maccs\n",
    "grep_maccs = pd.read_csv('domain_appl_maccs.grep', sep = ',')\n",
    "grep_maccs = grep_maccs.T.reset_index(drop = True).T\n",
    "grep_maccs = grep_maccs.drop([0])\n",
    "\n",
    "#converting to str \n",
    "grep_maccs = grep_maccs.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_maccs = grep_maccs[0].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_maccs)):\n",
    "    str_split_maccs[i] = str_split_maccs[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "\n",
    "#making df\n",
    "data_maccs = pd.DataFrame(str_split_maccs)\n",
    "data_maccs = data_maccs.rename(columns = {0 : 'Set', 1 : 'IDX', 2 : 'CID', 3 : 'Min Dist', 4 : 'Index at Min Dist', 5 : 'CID at Min Dist', 6 : 'Num_Neighbors'})\n",
    "\n",
    "#splitting into train, test, ext1, ext2\n",
    "data_maccs_train = data_maccs.loc[data_maccs['Set'] == 'Train']\n",
    "data_maccs_test = data_maccs.loc[data_maccs['Set'] == 'Test']\n",
    "data_maccs_ncgc = data_maccs.loc[data_maccs['Set'] == 'Ext1']\n",
    "data_maccs_chembl = data_maccs.loc[data_maccs['Set'] == 'Ext2']"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Test "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(568, 8)\n",
      "0     176\n",
      "1      87\n",
      "2      47\n",
      "3      27\n",
      "4      18\n",
      "7      15\n",
      "5      15\n",
      "19     11\n",
      "11     10\n",
      "6       9\n",
      "12      9\n",
      "22      9\n",
      "13      8\n",
      "14      8\n",
      "16      7\n",
      "9       7\n",
      "18      7\n",
      "23      7\n",
      "25      6\n",
      "21      6\n",
      "10      6\n",
      "24      6\n",
      "51      5\n",
      "27      5\n",
      "17      5\n",
      "28      4\n",
      "8       4\n",
      "20      4\n",
      "38      4\n",
      "43      4\n",
      "32      4\n",
      "29      3\n",
      "34      3\n",
      "31      3\n",
      "42      2\n",
      "26      2\n",
      "67      2\n",
      "30      2\n",
      "15      2\n",
      "33      2\n",
      "62      1\n",
      "36      1\n",
      "58      1\n",
      "46      1\n",
      "73      1\n",
      "57      1\n",
      "48      1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(392, 168)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data_maccs_test.shape)\n",
    "print(data_maccs_test['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_maccs_test has 568 total\n",
    "#176 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_maccs_test = data_maccs_test[data_maccs_test.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_maccs_test = data_maccs_test['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_maccs_test = pd.read_csv('input_test_maccs.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_maccs_test = full_maccs_test.loc[full_maccs_test['Name'].isin(cids_maccs_test)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_maccs_test.to_csv('input_test_maccs_appl.csv', index = False)\n",
    "appl_maccs_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NCGC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(328, 8)\n",
      "0     138\n",
      "1      37\n",
      "3      19\n",
      "2      17\n",
      "4      15\n",
      "5      11\n",
      "6      11\n",
      "17      8\n",
      "7       8\n",
      "11      7\n",
      "21      6\n",
      "20      4\n",
      "14      4\n",
      "10      4\n",
      "8       4\n",
      "12      3\n",
      "19      3\n",
      "18      3\n",
      "9       3\n",
      "24      3\n",
      "23      3\n",
      "13      2\n",
      "29      2\n",
      "22      2\n",
      "15      2\n",
      "31      2\n",
      "43      1\n",
      "28      1\n",
      "34      1\n",
      "35      1\n",
      "41      1\n",
      "26      1\n",
      "27      1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(190, 168)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data_maccs_ncgc.shape)\n",
    "print(data_maccs_ncgc['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_maccs_ncgc has 328 total\n",
    "#138 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_maccs_ncgc = data_maccs_ncgc[data_maccs_ncgc.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_maccs_ncgc = data_maccs_ncgc['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_maccs_ncgc = pd.read_csv('input_ncgc_maccs.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_maccs_ncgc = full_maccs_ncgc.loc[full_maccs_ncgc['Name'].isin(cids_maccs_ncgc)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_maccs_ncgc.to_csv('input_ncgc_maccs_appl.csv', index = False)\n",
    "appl_maccs_ncgc.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ChEMBL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1456, 8)\n",
      "0     1266\n",
      "1       77\n",
      "2        7\n",
      "5        7\n",
      "3        7\n",
      "4        7\n",
      "8        6\n",
      "17       6\n",
      "58       5\n",
      "28       5\n",
      "9        5\n",
      "23       5\n",
      "6        3\n",
      "34       3\n",
      "7        3\n",
      "14       3\n",
      "13       3\n",
      "10       3\n",
      "48       2\n",
      "21       2\n",
      "32       2\n",
      "29       2\n",
      "50       2\n",
      "36       2\n",
      "31       1\n",
      "52       1\n",
      "38       1\n",
      "24       1\n",
      "35       1\n",
      "42       1\n",
      "27       1\n",
      "55       1\n",
      "25       1\n",
      "67       1\n",
      "16       1\n",
      "54       1\n",
      "59       1\n",
      "63       1\n",
      "43       1\n",
      "33       1\n",
      "19       1\n",
      "37       1\n",
      "61       1\n",
      "11       1\n",
      "12       1\n",
      "15       1\n",
      "53       1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(190, 168)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data_maccs_chembl.shape)\n",
    "print(data_maccs_chembl['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_maccs_chembl has 1456 total\n",
    "#1266 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_maccs_chembl = data_maccs_chembl[data_maccs_chembl.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_maccs_chembl = data_maccs_chembl['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_maccs_chembl = pd.read_csv('input_chembl_maccs.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_maccs_chembl = full_maccs_chembl.loc[full_maccs_chembl['Name'].isin(cids_maccs_chembl)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_maccs_chembl.to_csv('input_chembl_maccs_appl.csv', index = False)\n",
    "appl_maccs_chembl.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TOP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files - top\n",
    "grep_top = pd.read_csv('domain_appl_top.grep', sep = ',')\n",
    "grep_top = grep_top.T.reset_index(drop = True).T\n",
    "grep_top = grep_top.drop([0])\n",
    "\n",
    "#converting to str \n",
    "grep_top = grep_top.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_top = grep_top[0].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_top)):\n",
    "    str_split_top[i] = str_split_top[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "\n",
    "#making df\n",
    "data_top = pd.DataFrame(str_split_top)\n",
    "data_top = data_top.rename(columns = {0 : 'Set', 1 : 'IDX', 2 : 'CID', 3 : 'Min Dist', 4 : 'Index at Min Dist', 5 : 'CID at Min Dist', 6 : 'Num_Neighbors'})\n",
    "\n",
    "#splitting into train, test, ext1, ext2\n",
    "data_top_train = data_top.loc[data_top['Set'] == 'Train']\n",
    "data_top_test = data_top.loc[data_top['Set'] == 'Test']\n",
    "data_top_ncgc = data_top.loc[data_top['Set'] == 'Ext1']\n",
    "data_top_chembl = data_top.loc[data_top['Set'] == 'Ext2']"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Test "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(568, 8)\n",
      "0      99\n",
      "1      63\n",
      "2      17\n",
      "225     9\n",
      "221     8\n",
      "209     8\n",
      "202     7\n",
      "175     7\n",
      "6       7\n",
      "3       7\n",
      "226     6\n",
      "228     6\n",
      "217     6\n",
      "203     6\n",
      "10      6\n",
      "234     5\n",
      "163     5\n",
      "224     5\n",
      "227     5\n",
      "8       5\n",
      "214     4\n",
      "208     4\n",
      "188     4\n",
      "138     4\n",
      "162     4\n",
      "128     4\n",
      "216     4\n",
      "7       4\n",
      "182     4\n",
      "239     4\n",
      "       ..\n",
      "172     1\n",
      "48      1\n",
      "140     1\n",
      "116     1\n",
      "236     1\n",
      "40      1\n",
      "206     1\n",
      "13      1\n",
      "51      1\n",
      "235     1\n",
      "107     1\n",
      "219     1\n",
      "118     1\n",
      "44      1\n",
      "46      1\n",
      "91      1\n",
      "117     1\n",
      "232     1\n",
      "53      1\n",
      "134     1\n",
      "193     1\n",
      "71      1\n",
      "150     1\n",
      "192     1\n",
      "176     1\n",
      "87      1\n",
      "212     1\n",
      "49      1\n",
      "95      1\n",
      "11      1\n",
      "Name: Num_Neighbors, Length: 172, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(469, 2050)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data_top_test.shape)\n",
    "print(data_top_test['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_top_test has 568 total\n",
    "#99 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_top_test = data_top_test[data_top_test.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_top_test = data_top_test['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_top_test = pd.read_csv('input_test_top.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_top_test = full_top_test[full_top_test['Name'].isin(cids_top_test)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_top_test.to_csv('input_test_top_appl.csv', index = False)\n",
    "appl_top_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NCGC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(328, 8)\n",
      "0      115\n",
      "1       22\n",
      "225      6\n",
      "165      5\n",
      "2        5\n",
      "6        4\n",
      "187      4\n",
      "177      4\n",
      "3        4\n",
      "176      4\n",
      "219      4\n",
      "168      3\n",
      "209      3\n",
      "231      3\n",
      "167      3\n",
      "198      3\n",
      "179      3\n",
      "156      3\n",
      "180      3\n",
      "196      3\n",
      "183      3\n",
      "117      3\n",
      "189      2\n",
      "210      2\n",
      "202      2\n",
      "160      2\n",
      "74       2\n",
      "188      2\n",
      "169      2\n",
      "191      2\n",
      "      ... \n",
      "87       1\n",
      "131      1\n",
      "138      1\n",
      "233      1\n",
      "218      1\n",
      "100      1\n",
      "184      1\n",
      "50       1\n",
      "136      1\n",
      "12       1\n",
      "178      1\n",
      "68       1\n",
      "197      1\n",
      "125      1\n",
      "9        1\n",
      "157      1\n",
      "229      1\n",
      "220      1\n",
      "228      1\n",
      "159      1\n",
      "154      1\n",
      "185      1\n",
      "124      1\n",
      "83       1\n",
      "238      1\n",
      "108      1\n",
      "51       1\n",
      "175      1\n",
      "203      1\n",
      "29       1\n",
      "Name: Num_Neighbors, Length: 111, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(213, 2050)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data_top_ncgc.shape)\n",
    "print(data_top_ncgc['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_top_ncgc has 328 total\n",
    "#115 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_top_ncgc = data_top_ncgc[data_top_ncgc.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_top_ncgc = data_top_ncgc['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_top_ncgc = pd.read_csv('input_ncgc_top.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_top_ncgc = full_top_ncgc.loc[full_top_ncgc['Name'].isin(cids_top_ncgc)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_top_ncgc.to_csv('input_ncgc_top_appl.csv', index = False)\n",
    "appl_top_ncgc.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ChEMBL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1456, 8)\n",
      "0      1314\n",
      "1        50\n",
      "2         9\n",
      "10        8\n",
      "40        7\n",
      "4         7\n",
      "38        5\n",
      "7         4\n",
      "36        4\n",
      "3         4\n",
      "30        3\n",
      "5         3\n",
      "6         2\n",
      "163       2\n",
      "28        2\n",
      "27        2\n",
      "31        2\n",
      "25        2\n",
      "8         2\n",
      "9         2\n",
      "12        2\n",
      "56        2\n",
      "39        1\n",
      "29        1\n",
      "11        1\n",
      "37        1\n",
      "64        1\n",
      "170       1\n",
      "69        1\n",
      "26        1\n",
      "17        1\n",
      "87        1\n",
      "18        1\n",
      "66        1\n",
      "169       1\n",
      "21        1\n",
      "57        1\n",
      "123       1\n",
      "178       1\n",
      "60        1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(142, 2050)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data_top_chembl.shape)\n",
    "print(data_top_chembl['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_top_chembl has 1456 total\n",
    "#1314 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_top_chembl = data_top_chembl[data_top_chembl.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_top_chembl = data_top_chembl['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_top_chembl = pd.read_csv('input_chembl_top.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_top_chembl = full_top_chembl.loc[full_top_chembl['Name'].isin(cids_top_chembl)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_top_chembl.to_csv('input_chembl_top_appl.csv', index = False)\n",
    "appl_top_chembl.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ECFP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files - ecfp\n",
    "grep_ecfp = pd.read_csv('domain_appl_ecfp.grep', sep = ',')\n",
    "grep_ecfp = grep_ecfp.T.reset_index(drop = True).T\n",
    "grep_ecfp = grep_ecfp.drop([0])\n",
    "\n",
    "#converting to str \n",
    "grep_ecfp = grep_ecfp.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_ecfp = grep_ecfp[0].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_ecfp)):\n",
    "    str_split_ecfp[i] = str_split_ecfp[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "\n",
    "#making df\n",
    "data_ecfp = pd.DataFrame(str_split_ecfp)\n",
    "data_ecfp = data_ecfp.rename(columns = {0 : 'Set', 1 : 'IDX', 2 : 'CID', 3 : 'Min Dist', 4 : 'Index at Min Dist', 5 : 'CID at Min Dist', 6 : 'Num_Neighbors'})\n",
    "\n",
    "#splitting into train, test, ext1, ext2\n",
    "data_ecfp_train = data_ecfp.loc[data_ecfp['Set'] == 'Train']\n",
    "data_ecfp_test = data_ecfp.loc[data_ecfp['Set'] == 'Test']\n",
    "data_ecfp_ncgc = data_ecfp.loc[data_ecfp['Set'] == 'Ext1']\n",
    "data_ecfp_chembl = data_ecfp.loc[data_ecfp['Set'] == 'Ext2']"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Test "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(568, 8)\n",
      "0      44\n",
      "1      40\n",
      "2      10\n",
      "5       9\n",
      "266     6\n",
      "292     5\n",
      "271     5\n",
      "222     4\n",
      "305     4\n",
      "314     4\n",
      "185     4\n",
      "335     4\n",
      "355     4\n",
      "371     4\n",
      "283     4\n",
      "3       4\n",
      "275     4\n",
      "116     4\n",
      "241     4\n",
      "302     4\n",
      "299     3\n",
      "336     3\n",
      "215     3\n",
      "120     3\n",
      "308     3\n",
      "27      3\n",
      "81      3\n",
      "223     3\n",
      "366     3\n",
      "237     3\n",
      "       ..\n",
      "131     1\n",
      "164     1\n",
      "316     1\n",
      "132     1\n",
      "367     1\n",
      "333     1\n",
      "146     1\n",
      "60      1\n",
      "313     1\n",
      "326     1\n",
      "25      1\n",
      "199     1\n",
      "17      1\n",
      "135     1\n",
      "158     1\n",
      "243     1\n",
      "216     1\n",
      "35      1\n",
      "85      1\n",
      "387     1\n",
      "22      1\n",
      "253     1\n",
      "234     1\n",
      "280     1\n",
      "341     1\n",
      "194     1\n",
      "134     1\n",
      "39      1\n",
      "15      1\n",
      "345     1\n",
      "Name: Num_Neighbors, Length: 264, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(524, 1026)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data_ecfp_test.shape)\n",
    "print(data_ecfp_test['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_ecfp_test has 568 total\n",
    "#44 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_ecfp_test = data_ecfp_test[data_ecfp_test.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_ecfp_test = data_ecfp_test['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_ecfp_test = pd.read_csv('input_test_ecfp.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_ecfp_test = full_ecfp_test.loc[full_ecfp_test['Name'].isin(cids_ecfp_test)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_ecfp_test.to_csv('input_test_ecfp_appl.csv', index = False)\n",
    "appl_ecfp_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NCGC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(328, 8)\n",
      "0      51\n",
      "1       8\n",
      "3       7\n",
      "13      4\n",
      "332     4\n",
      "314     4\n",
      "294     3\n",
      "66      3\n",
      "225     3\n",
      "144     3\n",
      "146     3\n",
      "201     3\n",
      "216     3\n",
      "163     3\n",
      "321     3\n",
      "322     3\n",
      "245     3\n",
      "389     3\n",
      "264     2\n",
      "204     2\n",
      "17      2\n",
      "211     2\n",
      "355     2\n",
      "4       2\n",
      "297     2\n",
      "129     2\n",
      "348     2\n",
      "309     2\n",
      "315     2\n",
      "255     2\n",
      "       ..\n",
      "237     1\n",
      "289     1\n",
      "118     1\n",
      "32      1\n",
      "329     1\n",
      "180     1\n",
      "175     1\n",
      "176     1\n",
      "174     1\n",
      "29      1\n",
      "251     1\n",
      "23      1\n",
      "367     1\n",
      "218     1\n",
      "318     1\n",
      "384     1\n",
      "126     1\n",
      "266     1\n",
      "186     1\n",
      "82      1\n",
      "57      1\n",
      "354     1\n",
      "136     1\n",
      "241     1\n",
      "353     1\n",
      "43      1\n",
      "63      1\n",
      "205     1\n",
      "331     1\n",
      "396     1\n",
      "Name: Num_Neighbors, Length: 185, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_ecfp_ncgc.shape)\n",
    "print(data_ecfp_ncgc['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_ecfp_ncgc has 328 total\n",
    "#51 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_ecfp_ncgc = data_ecfp_ncgc[data_ecfp_ncgc.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_ecfp_ncgc = data_ecfp_ncgc['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_ecfp_ncgc = pd.read_csv('input_ncgc_ecfp.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_ecfp_ncgc = full_ecfp_ncgc.loc[full_ecfp_ncgc['Name'].isin(cids_ecfp_ncgc)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_ecfp_ncgc.to_csv('input_ncgc_ecfp_appl.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ChEMBL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1456, 8)\n",
      "0      1279\n",
      "1        56\n",
      "2        27\n",
      "4        14\n",
      "10       11\n",
      "3        10\n",
      "5         7\n",
      "6         6\n",
      "12        5\n",
      "11        4\n",
      "8         4\n",
      "16        4\n",
      "9         2\n",
      "28        2\n",
      "13        2\n",
      "31        2\n",
      "14        2\n",
      "18        2\n",
      "7         2\n",
      "43        1\n",
      "187       1\n",
      "42        1\n",
      "22        1\n",
      "26        1\n",
      "38        1\n",
      "40        1\n",
      "23        1\n",
      "32        1\n",
      "24        1\n",
      "27        1\n",
      "21        1\n",
      "25        1\n",
      "57        1\n",
      "50        1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_ecfp_chembl.shape)\n",
    "print(data_ecfp_chembl['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_ecfp_chembl has 1456 total\n",
    "#1279 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_ecfp_chembl = data_ecfp_chembl[data_ecfp_chembl.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_ecfp_chembl = data_ecfp_chembl['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_ecfp_chembl = pd.read_csv('input_chembl_ecfp.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_ecfp_chembl = full_ecfp_chembl.loc[full_ecfp_chembl['Name'].isin(cids_ecfp_chembl)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_ecfp_chembl.to_csv('input_chembl_ecfp_appl.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FCFP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files - fcfp\n",
    "grep_fcfp = pd.read_csv('domain_appl_fcfp.grep', sep = ',')\n",
    "grep_fcfp = grep_fcfp.T.reset_index(drop = True).T\n",
    "grep_fcfp = grep_fcfp.drop([0])\n",
    "\n",
    "#converting to str \n",
    "grep_fcfp = grep_fcfp.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_fcfp = grep_fcfp[0].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_fcfp)):\n",
    "    str_split_fcfp[i] = str_split_fcfp[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "\n",
    "#making df\n",
    "data_fcfp = pd.DataFrame(str_split_fcfp)\n",
    "data_fcfp = data_fcfp.rename(columns = {0 : 'Set', 1 : 'IDX', 2 : 'CID', 3 : 'Min Dist', 4 : 'Index at Min Dist', 5 : 'CID at Min Dist', 6 : 'Num_Neighbors'})\n",
    "\n",
    "#splitting into train, test, ext1, ext2\n",
    "data_fcfp_train = data_fcfp.loc[data_fcfp['Set'] == 'Train']\n",
    "data_fcfp_test = data_fcfp.loc[data_fcfp['Set'] == 'Test']\n",
    "data_fcfp_ncgc = data_fcfp.loc[data_fcfp['Set'] == 'Ext1']\n",
    "data_fcfp_chembl = data_fcfp.loc[data_fcfp['Set'] == 'Ext2']"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Test "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(568, 8)\n",
      "0      58\n",
      "1      30\n",
      "2      13\n",
      "256     9\n",
      "3       8\n",
      "4       8\n",
      "223     6\n",
      "353     5\n",
      "282     5\n",
      "311     5\n",
      "271     4\n",
      "10      4\n",
      "7       4\n",
      "274     4\n",
      "187     4\n",
      "213     4\n",
      "247     4\n",
      "254     4\n",
      "316     4\n",
      "8       4\n",
      "6       4\n",
      "261     4\n",
      "313     4\n",
      "364     3\n",
      "36      3\n",
      "128     3\n",
      "301     3\n",
      "197     3\n",
      "66      3\n",
      "184     3\n",
      "       ..\n",
      "117     1\n",
      "37      1\n",
      "200     1\n",
      "103     1\n",
      "217     1\n",
      "258     1\n",
      "348     1\n",
      "253     1\n",
      "317     1\n",
      "129     1\n",
      "163     1\n",
      "161     1\n",
      "321     1\n",
      "283     1\n",
      "77      1\n",
      "349     1\n",
      "352     1\n",
      "328     1\n",
      "42      1\n",
      "226     1\n",
      "234     1\n",
      "242     1\n",
      "322     1\n",
      "332     1\n",
      "246     1\n",
      "105     1\n",
      "237     1\n",
      "389     1\n",
      "276     1\n",
      "61      1\n",
      "Name: Num_Neighbors, Length: 274, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_fcfp_test.shape)\n",
    "print(data_fcfp_test['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_fcfp_test has 568 total\n",
    "#58 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_fcfp_test = data_fcfp_test[data_fcfp_test.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_fcfp_test = data_fcfp_test['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_fcfp_test = pd.read_csv('input_test_fcfp.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_fcfp_test = full_fcfp_test.loc[full_fcfp_test['Name'].isin(cids_fcfp_test)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_fcfp_test.to_csv('input_test_fcfp_appl.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(510, 1026)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "appl_fcfp_test.shape\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NCGC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(328, 8)\n",
      "0      50\n",
      "1      11\n",
      "3       7\n",
      "207     6\n",
      "4       4\n",
      "298     3\n",
      "5       3\n",
      "198     3\n",
      "133     3\n",
      "243     3\n",
      "24      3\n",
      "37      3\n",
      "2       3\n",
      "282     3\n",
      "60      2\n",
      "132     2\n",
      "173     2\n",
      "208     2\n",
      "216     2\n",
      "257     2\n",
      "74      2\n",
      "194     2\n",
      "367     2\n",
      "333     2\n",
      "129     2\n",
      "327     2\n",
      "300     2\n",
      "21      2\n",
      "219     2\n",
      "366     2\n",
      "       ..\n",
      "44      1\n",
      "118     1\n",
      "51      1\n",
      "353     1\n",
      "95      1\n",
      "184     1\n",
      "23      1\n",
      "238     1\n",
      "301     1\n",
      "277     1\n",
      "144     1\n",
      "47      1\n",
      "274     1\n",
      "192     1\n",
      "130     1\n",
      "307     1\n",
      "332     1\n",
      "136     1\n",
      "241     1\n",
      "145     1\n",
      "340     1\n",
      "228     1\n",
      "281     1\n",
      "205     1\n",
      "127     1\n",
      "48      1\n",
      "161     1\n",
      "150     1\n",
      "320     1\n",
      "213     1\n",
      "Name: Num_Neighbors, Length: 196, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_fcfp_ncgc.shape)\n",
    "print(data_fcfp_ncgc['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_fcfp_ncgc has 328 total\n",
    "#50 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_fcfp_ncgc = data_fcfp_ncgc[data_fcfp_ncgc.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_fcfp_ncgc = data_fcfp_ncgc['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_fcfp_ncgc = pd.read_csv('input_ncgc_fcfp.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_fcfp_ncgc = full_fcfp_ncgc.loc[full_fcfp_ncgc['Name'].isin(cids_fcfp_ncgc)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_fcfp_ncgc.to_csv('input_ncgc_fcfp_appl.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ChEMBL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1456, 8)\n",
      "0      1257\n",
      "1        64\n",
      "2        27\n",
      "4        16\n",
      "3        15\n",
      "7        14\n",
      "5        10\n",
      "6         7\n",
      "10        6\n",
      "13        5\n",
      "8         5\n",
      "9         3\n",
      "16        3\n",
      "14        3\n",
      "33        2\n",
      "39        2\n",
      "23        2\n",
      "11        2\n",
      "12        2\n",
      "36        2\n",
      "28        1\n",
      "53        1\n",
      "26        1\n",
      "27        1\n",
      "31        1\n",
      "34        1\n",
      "32        1\n",
      "51        1\n",
      "144       1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_fcfp_chembl.shape)\n",
    "print(data_fcfp_chembl['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_fcfp_chembl has 1456 total\n",
    "#1257 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_fcfp_chembl = data_fcfp_chembl[data_fcfp_chembl.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_fcfp_chembl = data_fcfp_chembl['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_fcfp_chembl = pd.read_csv('input_chembl_fcfp.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_fcfp_chembl = full_fcfp_chembl.loc[full_fcfp_chembl['Name'].isin(cids_fcfp_chembl)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_fcfp_chembl.to_csv('input_chembl_fcfp_appl.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in grep files - pub\n",
    "grep_pub = pd.read_csv('domain_appl_pub.grep', sep = ',')\n",
    "grep_pub = grep_pub.T.reset_index(drop = True).T\n",
    "grep_pub = grep_pub.drop([0])\n",
    "\n",
    "#converting to str \n",
    "grep_pub = grep_pub.astype(str)\n",
    "\n",
    "#splitting scores \n",
    "str_split_pub = grep_pub[0].tolist()\n",
    "i = 0\n",
    "while (i < len(str_split_pub)):\n",
    "    str_split_pub[i] = str_split_pub[i].split()\n",
    "    i = i + 1\n",
    "    \n",
    "\n",
    "#making df\n",
    "data_pub = pd.DataFrame(str_split_pub)\n",
    "data_pub = data_pub.rename(columns = {0 : 'Set', 1 : 'IDX', 2 : 'CID', 3 : 'Min Dist', 4 : 'Index at Min Dist', 5 : 'CID at Min Dist', 6 : 'Num_Neighbors'})\n",
    "\n",
    "#splitting into train, test, ext1, ext2\n",
    "data_pub_train = data_pub.loc[data_pub['Set'] == 'Train']\n",
    "data_pub_test = data_pub.loc[data_pub['Set'] == 'Test']\n",
    "data_pub_ncgc = data_pub.loc[data_pub['Set'] == 'Ext1']\n",
    "data_pub_chembl = data_pub.loc[data_pub['Set'] == 'Ext2']"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Test "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(568, 8)\n",
      "0     128\n",
      "1      72\n",
      "2      47\n",
      "3      32\n",
      "4      24\n",
      "7      11\n",
      "12     10\n",
      "5      10\n",
      "6      10\n",
      "10      9\n",
      "22      8\n",
      "18      8\n",
      "17      8\n",
      "9       7\n",
      "11      7\n",
      "33      6\n",
      "8       6\n",
      "14      6\n",
      "34      5\n",
      "46      5\n",
      "24      5\n",
      "87      5\n",
      "13      5\n",
      "15      5\n",
      "28      5\n",
      "45      5\n",
      "19      5\n",
      "43      4\n",
      "71      4\n",
      "16      4\n",
      "     ... \n",
      "50      2\n",
      "30      2\n",
      "44      2\n",
      "79      2\n",
      "37      2\n",
      "72      2\n",
      "80      2\n",
      "40      2\n",
      "25      2\n",
      "27      2\n",
      "88      1\n",
      "23      1\n",
      "49      1\n",
      "26      1\n",
      "36      1\n",
      "83      1\n",
      "47      1\n",
      "58      1\n",
      "86      1\n",
      "84      1\n",
      "59      1\n",
      "52      1\n",
      "62      1\n",
      "81      1\n",
      "73      1\n",
      "63      1\n",
      "48      1\n",
      "32      1\n",
      "85      1\n",
      "75      1\n",
      "Name: Num_Neighbors, Length: 81, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_pub_test.shape)\n",
    "print(data_pub_test['Num_Neighbors'].value_counts())\n",
    "\n",
    "#data_pub_test has 568 total\n",
    "#128 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_pub_test = data_pub_test[data_pub_test.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_pub_test = data_pub_test['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_pub_test = pd.read_csv('input_test_pub.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_pub_test = full_pub_test.loc[full_pub_test['Name'].isin(cids_pub_test)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_pub_test.to_csv('input_test_pub_appl.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NCGC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(328, 8)\n",
      "0     96\n",
      "1     32\n",
      "2     28\n",
      "3     16\n",
      "6      9\n",
      "22     9\n",
      "7      8\n",
      "18     7\n",
      "4      6\n",
      "28     5\n",
      "15     5\n",
      "19     5\n",
      "34     5\n",
      "37     4\n",
      "27     4\n",
      "25     4\n",
      "12     4\n",
      "39     3\n",
      "10     3\n",
      "9      3\n",
      "44     3\n",
      "36     3\n",
      "42     3\n",
      "11     3\n",
      "5      3\n",
      "23     3\n",
      "43     3\n",
      "14     2\n",
      "24     2\n",
      "68     2\n",
      "8      2\n",
      "38     2\n",
      "21     2\n",
      "48     2\n",
      "26     2\n",
      "67     2\n",
      "31     2\n",
      "41     2\n",
      "16     2\n",
      "45     2\n",
      "61     2\n",
      "46     2\n",
      "30     2\n",
      "80     2\n",
      "29     2\n",
      "71     1\n",
      "81     1\n",
      "83     1\n",
      "47     1\n",
      "77     1\n",
      "70     1\n",
      "75     1\n",
      "32     1\n",
      "89     1\n",
      "35     1\n",
      "50     1\n",
      "33     1\n",
      "17     1\n",
      "20     1\n",
      "13     1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_pub_ncgc.shape)\n",
    "print(data_pub_ncgc['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_pub_ncgc has 328 total\n",
    "#96 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_pub_ncgc = data_pub_ncgc[data_pub_ncgc.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_pub_ncgc = data_pub_ncgc['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_pub_ncgc = pd.read_csv('input_ncgc_pub.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_pub_ncgc = full_pub_ncgc.loc[full_pub_ncgc['Name'].isin(cids_pub_ncgc)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_pub_ncgc.to_csv('input_ncgc_pub_appl.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ChEMBL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1456, 8)\n",
      "0     1272\n",
      "1       96\n",
      "8       11\n",
      "2        8\n",
      "3        7\n",
      "79       5\n",
      "22       5\n",
      "6        4\n",
      "23       4\n",
      "7        3\n",
      "24       3\n",
      "36       3\n",
      "20       3\n",
      "49       3\n",
      "43       3\n",
      "26       3\n",
      "21       2\n",
      "32       2\n",
      "39       2\n",
      "17       1\n",
      "42       1\n",
      "12       1\n",
      "38       1\n",
      "89       1\n",
      "19       1\n",
      "4        1\n",
      "27       1\n",
      "51       1\n",
      "81       1\n",
      "31       1\n",
      "76       1\n",
      "68       1\n",
      "50       1\n",
      "78       1\n",
      "59       1\n",
      "45       1\n",
      "Name: Num_Neighbors, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data_pub_chembl.shape)\n",
    "print(data_pub_chembl['Num_Neighbors'].value_counts())\n",
    "\n",
    "# data_pub_chembl has 1456 total\n",
    "#1272 compounds with no neighbors\n",
    "#dropping values where Num Neighbors = 0\n",
    "data_pub_chembl = data_pub_chembl[data_pub_chembl.Num_Neighbors != '0']\n",
    "\n",
    "#only keeping CIDs of remaining\n",
    "cids_pub_chembl = data_pub_chembl['CID'].tolist()\n",
    "\n",
    "#reading in original input files\n",
    "full_pub_chembl = pd.read_csv('input_chembl_pub.csv')\n",
    "\n",
    "#getting fingerprints of remaining molecules (from original input file)\n",
    "appl_pub_chembl = full_pub_chembl.loc[full_pub_chembl['Name'].isin(cids_pub_chembl)]\n",
    "\n",
    "#Writing new input file to csv\n",
    "appl_pub_chembl.to_csv('input_chembl_pub_appl.csv', index = False)"
   ]
  },
  {
   "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": []
  },
  {
   "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": []
  },
  {
   "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
}