Fingerprints & Formatting Tox21.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PC1</th>\n",
       "      <th>PC2</th>\n",
       "      <th>PC3</th>\n",
       "      <th>PC4</th>\n",
       "      <th>PC5</th>\n",
       "      <th>PC6</th>\n",
       "      <th>PC7</th>\n",
       "      <th>PC8</th>\n",
       "      <th>PUBCHEM_CID</th>\n",
       "      <th>Activity Outcome</th>\n",
       "      <th>...</th>\n",
       "      <th>RotatableBondCount</th>\n",
       "      <th>CanonicalSMILES</th>\n",
       "      <th>IsomericSMILES</th>\n",
       "      <th>InChI</th>\n",
       "      <th>XLogP</th>\n",
       "      <th>ExactMass</th>\n",
       "      <th>TPSA</th>\n",
       "      <th>HeavyAtomCount</th>\n",
       "      <th>Complexity</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.403337</td>\n",
       "      <td>-0.503341</td>\n",
       "      <td>-0.387764</td>\n",
       "      <td>-0.082259</td>\n",
       "      <td>-0.278501</td>\n",
       "      <td>-0.000986</td>\n",
       "      <td>-0.089140</td>\n",
       "      <td>0.055148</td>\n",
       "      <td>1923.0</td>\n",
       "      <td>active agonist</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>C1=CC2=C(C(=C1)O)N=CC=C2</td>\n",
       "      <td>C1=CC2=C(C(=C1)O)N=CC=C2</td>\n",
       "      <td>InChI=1S/C9H7NO/c11-8-5-1-3-7-4-2-6-10-9(7)8/h...</td>\n",
       "      <td>2.0</td>\n",
       "      <td>145.052764</td>\n",
       "      <td>33.1</td>\n",
       "      <td>11.0</td>\n",
       "      <td>138.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.114826</td>\n",
       "      <td>0.268539</td>\n",
       "      <td>-1.038696</td>\n",
       "      <td>0.154652</td>\n",
       "      <td>0.502283</td>\n",
       "      <td>-0.237560</td>\n",
       "      <td>0.066917</td>\n",
       "      <td>0.154261</td>\n",
       "      <td>2118.0</td>\n",
       "      <td>active antagonist</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>CC1=NN=C2N1C3=C(C=C(C=C3)Cl)C(=NC2)C4=CC=CC=C4</td>\n",
       "      <td>CC1=NN=C2N1C3=C(C=C(C=C3)Cl)C(=NC2)C4=CC=CC=C4</td>\n",
       "      <td>InChI=1S/C17H13ClN4/c1-11-20-21-16-10-19-17(12...</td>\n",
       "      <td>2.1</td>\n",
       "      <td>308.082874</td>\n",
       "      <td>43.1</td>\n",
       "      <td>22.0</td>\n",
       "      <td>434.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.891772</td>\n",
       "      <td>1.015351</td>\n",
       "      <td>-0.548019</td>\n",
       "      <td>1.033463</td>\n",
       "      <td>0.017861</td>\n",
       "      <td>0.398095</td>\n",
       "      <td>-0.157217</td>\n",
       "      <td>-0.126047</td>\n",
       "      <td>2176.0</td>\n",
       "      <td>active agonist</td>\n",
       "      <td>...</td>\n",
       "      <td>8.0</td>\n",
       "      <td>CCOC(=O)OC(C)OC1=C(N(S(=O)(=O)C2=CC=CC=C21)C)C...</td>\n",
       "      <td>CCOC(=O)OC(C)OC1=C(N(S(=O)(=O)C2=CC=CC=C21)C)C...</td>\n",
       "      <td>InChI=1S/C20H21N3O7S/c1-4-28-20(25)30-13(2)29-...</td>\n",
       "      <td>4.0</td>\n",
       "      <td>447.110021</td>\n",
       "      <td>133.0</td>\n",
       "      <td>31.0</td>\n",
       "      <td>808.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.357005</td>\n",
       "      <td>-0.033105</td>\n",
       "      <td>-0.441273</td>\n",
       "      <td>0.566864</td>\n",
       "      <td>-0.057438</td>\n",
       "      <td>0.691294</td>\n",
       "      <td>0.277729</td>\n",
       "      <td>0.042834</td>\n",
       "      <td>2194.0</td>\n",
       "      <td>active antagonist</td>\n",
       "      <td>...</td>\n",
       "      <td>2.0</td>\n",
       "      <td>COC1=CC=C(C=C1)C2=CC(=S)SS2</td>\n",
       "      <td>COC1=CC=C(C=C1)C2=CC(=S)SS2</td>\n",
       "      <td>InChI=1S/C10H8OS3/c1-11-8-4-2-7(3-5-8)9-6-10(1...</td>\n",
       "      <td>2.8</td>\n",
       "      <td>239.973728</td>\n",
       "      <td>91.9</td>\n",
       "      <td>14.0</td>\n",
       "      <td>254.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2.381299</td>\n",
       "      <td>0.265859</td>\n",
       "      <td>-0.401451</td>\n",
       "      <td>0.916811</td>\n",
       "      <td>0.416766</td>\n",
       "      <td>0.295284</td>\n",
       "      <td>-0.221053</td>\n",
       "      <td>-0.110032</td>\n",
       "      <td>2225.0</td>\n",
       "      <td>active antagonist</td>\n",
       "      <td>...</td>\n",
       "      <td>7.0</td>\n",
       "      <td>CC1=C(C(C(=C(N1)C)C(=O)OCC(=O)C)C2=CC=CC=C2[N+...</td>\n",
       "      <td>CC1=C(C(C(=C(N1)C)C(=O)OCC(=O)C)C2=CC=CC=C2[N+...</td>\n",
       "      <td>InChI=1S/C19H20N2O7/c1-10(22)9-28-19(24)16-12(...</td>\n",
       "      <td>2.0</td>\n",
       "      <td>388.127051</td>\n",
       "      <td>128.0</td>\n",
       "      <td>28.0</td>\n",
       "      <td>748.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 24 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        PC1       PC2       PC3       PC4       PC5       PC6       PC7  \\\n",
       "0 -1.403337 -0.503341 -0.387764 -0.082259 -0.278501 -0.000986 -0.089140   \n",
       "1 -0.114826  0.268539 -1.038696  0.154652  0.502283 -0.237560  0.066917   \n",
       "2  2.891772  1.015351 -0.548019  1.033463  0.017861  0.398095 -0.157217   \n",
       "3 -0.357005 -0.033105 -0.441273  0.566864 -0.057438  0.691294  0.277729   \n",
       "4  2.381299  0.265859 -0.401451  0.916811  0.416766  0.295284 -0.221053   \n",
       "\n",
       "        PC8  PUBCHEM_CID   Activity Outcome  ... RotatableBondCount  \\\n",
       "0  0.055148       1923.0     active agonist  ...                0.0   \n",
       "1  0.154261       2118.0  active antagonist  ...                1.0   \n",
       "2 -0.126047       2176.0     active agonist  ...                8.0   \n",
       "3  0.042834       2194.0  active antagonist  ...                2.0   \n",
       "4 -0.110032       2225.0  active antagonist  ...                7.0   \n",
       "\n",
       "                                     CanonicalSMILES  \\\n",
       "0                           C1=CC2=C(C(=C1)O)N=CC=C2   \n",
       "1     CC1=NN=C2N1C3=C(C=C(C=C3)Cl)C(=NC2)C4=CC=CC=C4   \n",
       "2  CCOC(=O)OC(C)OC1=C(N(S(=O)(=O)C2=CC=CC=C21)C)C...   \n",
       "3                        COC1=CC=C(C=C1)C2=CC(=S)SS2   \n",
       "4  CC1=C(C(C(=C(N1)C)C(=O)OCC(=O)C)C2=CC=CC=C2[N+...   \n",
       "\n",
       "                                      IsomericSMILES  \\\n",
       "0                           C1=CC2=C(C(=C1)O)N=CC=C2   \n",
       "1     CC1=NN=C2N1C3=C(C=C(C=C3)Cl)C(=NC2)C4=CC=CC=C4   \n",
       "2  CCOC(=O)OC(C)OC1=C(N(S(=O)(=O)C2=CC=CC=C21)C)C...   \n",
       "3                        COC1=CC=C(C=C1)C2=CC(=S)SS2   \n",
       "4  CC1=C(C(C(=C(N1)C)C(=O)OCC(=O)C)C2=CC=CC=C2[N+...   \n",
       "\n",
       "                                               InChI  XLogP   ExactMass  \\\n",
       "0  InChI=1S/C9H7NO/c11-8-5-1-3-7-4-2-6-10-9(7)8/h...    2.0  145.052764   \n",
       "1  InChI=1S/C17H13ClN4/c1-11-20-21-16-10-19-17(12...    2.1  308.082874   \n",
       "2  InChI=1S/C20H21N3O7S/c1-4-28-20(25)30-13(2)29-...    4.0  447.110021   \n",
       "3  InChI=1S/C10H8OS3/c1-11-8-4-2-7(3-5-8)9-6-10(1...    2.8  239.973728   \n",
       "4  InChI=1S/C19H20N2O7/c1-10(22)9-28-19(24)16-12(...    2.0  388.127051   \n",
       "\n",
       "    TPSA HeavyAtomCount  Complexity  target  \n",
       "0   33.1           11.0       138.0       1  \n",
       "1   43.1           22.0       434.0       1  \n",
       "2  133.0           31.0       808.0       1  \n",
       "3   91.9           14.0       254.0       1  \n",
       "4  128.0           28.0       748.0       1  \n",
       "\n",
       "[5 rows x 24 columns]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from rdkit import Chem\n",
    "from rdkit import DataStructs\n",
    "from rdkit.Chem import MACCSkeys\n",
    "from rdkit.Chem import AllChem\n",
    "from rdkit.Chem.Fingerprints import FingerprintMols\n",
    "\n",
    "import urllib\n",
    "from urllib.request import urlopen\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "#hiding warning messages\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "#Reading in Molecular Properties CSV\n",
    "data = pd.read_csv('Downsampled_Tox21_Full')\n",
    "#data = data.astype(float, errors = 'ignore')\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MACCS Keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C1=CC2=C(C(=C1)O)N=CC=C2'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Making list of isomericSMILES identifiers\n",
    "iSMILES = data['IsomericSMILES']\n",
    "iSMILES[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Making list of molecules from iSMILES\n",
    "i = 0\n",
    "ms = []\n",
    "while (i < len(iSMILES)):\n",
    "    molecule = Chem.MolFromSmiles(iSMILES[i])\n",
    "    ms.append(molecule)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Getting MACCS fingerprints list\n",
    "#Turning fingerprints to bit strings\n",
    "maccs_fps = [MACCSkeys.GenMACCSKeys(x).ToBitString()[1:] for x in ms ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Topological Fingerprint (Daylight Analogue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2048"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from rdkit.Chem import rdmolops\n",
    "\n",
    "#getting list of topological fingerprints\n",
    "top_fps = [rdmolops.RDKFingerprint(x, fpSize=2048, minPath=1, maxPath=7).ToBitString() for x in ms]\n",
    "len(top_fps[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Morgan Fingerprint (ECFP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from rdkit.Chem import AllChem\n",
    "\n",
    "#getting morgan ecfp fingerprint\n",
    "ecfp_fps = [AllChem.GetMorganFingerprintAsBitVect(x,4,nBits=1024).ToBitString() for x in ms]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Morgan Fingerprint (FCFP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1010101010000000000000000000000000000000000000000001000000001001001000000000000000000100000000000000000000000000000000000100000000000000000000000001010010000000000000000000000000000000000000000100000000001000000000000100000000000000000000000000000000000000000000000000100000000000001000000000000000010000000001000100000001000000000000000000000000000100000000000000000000000000000000000000000000000000010000000000000000000000000010000000000000000000000000000000000000000000000100000000000000000000001000000000000000000000000000000000100000000000000000000001000000000000001000000000000000000000000000100000000000000000000000000000010000010000100000000000000000000000000000000000000000010000000000000001000000100000000001000000000000000000000000010100000000000100000000000000000000010000000000100000001010000000000000000000000001000000000001000000000000000000000000000000000100000000000000000001000000000000000000100000000000000000000000101000000000000000000000000000000010000000000000000000000001000010001000000000000001100000\n"
     ]
    }
   ],
   "source": [
    "fcfp_fps = [AllChem.GetMorganFingerprintAsBitVect(x,4,nBits=1024,useFeatures=True).ToBitString() for x in ms]\n",
    "print(fcfp_fps[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PubChem FP Decoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Getting CID list\n",
    "CID_list = data['PUBCHEM_CID']\n",
    "\n",
    "#Making them integers (removing decimals)\n",
    "CID_list = [int(i) for i in CID_list]\n",
    "\n",
    "list1 = CID_list[:600]\n",
    "list2 = CID_list[600:]\n",
    "\n",
    "#Changing list to str, dropping start/end brackets, removing spaces\n",
    "str1 = (str(list1)[1:-1])\n",
    "str1 = str1.replace(' ', '')\n",
    "str2 = (str(list2)[1:-1])\n",
    "str2 = str2.replace(' ', '')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Getting the Pubchem Fingerprints for each CID\n",
    "\n",
    "#opening and reading the 1URLs\n",
    "url1 = ('https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/' + str1 + '/property/Fingerprint2D/TXT')\n",
    "html1 = urlopen(url1) \n",
    "soup1 = BeautifulSoup(html1, 'lxml')\n",
    "url2 = ('https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/' + str2 + '/property/Fingerprint2D/TXT')\n",
    "html2 = urlopen(url2) \n",
    "soup2 = BeautifulSoup(html2, 'lxml')\n",
    "\n",
    "pub_fp1 = soup1.get_text()\n",
    "pub_fp2 = soup2.get_text()\n",
    "\n",
    "#total pub_fp string\n",
    "pub_fp = pub_fp1 + pub_fp2 \n",
    "\n",
    "#pub_fp string to pub_fp list\n",
    "pub_fp = pub_fp.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Decoding Fingerprints\n",
    "from base64 import b64decode\n",
    "\n",
    "def PCFP_BitString(pcfp_base64) :\n",
    "\n",
    "    pcfp_bitstring = \"\".join( [\"{:08b}\".format(x) for x in b64decode( pcfp_base64 )] )[32:913]\n",
    "    return pcfp_bitstring\n",
    "\n",
    "i = 0\n",
    "pub_fp_decoded = []\n",
    "while (i < len(pub_fp)):\n",
    "    fp = PCFP_BitString(pub_fp[i])\n",
    "    pub_fp_decoded.append(fp)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FinalDFTox21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Name</th>\n",
       "      <th>MACCS</th>\n",
       "      <th>Topological</th>\n",
       "      <th>Morgan ECFP</th>\n",
       "      <th>Morgan FCFP</th>\n",
       "      <th>Pubchem FP</th>\n",
       "      <th>Activity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1923.0</td>\n",
       "      <td>0000000000000000000000000000000000000000000000...</td>\n",
       "      <td>1000010000010000000000000100000000100000000010...</td>\n",
       "      <td>0000000000000001000100000000000000000000000000...</td>\n",
       "      <td>0001101000000000000000000000000000000001000000...</td>\n",
       "      <td>1000000001110010001000000000000000000000000000...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2118.0</td>\n",
       "      <td>0000000000000000001000000000000000000100000000...</td>\n",
       "      <td>1010010000110000000110001001110000010110010101...</td>\n",
       "      <td>0000000000000001000000000000010011000000000000...</td>\n",
       "      <td>1010101010000000000000000000000000000000000000...</td>\n",
       "      <td>1100000001111011100000000000000000000100000000...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2176.0</td>\n",
       "      <td>0000000000000010000000000000000110010100000010...</td>\n",
       "      <td>1111011110111011111011011011111110011110100110...</td>\n",
       "      <td>0100000000000000000000000000001001000000000000...</td>\n",
       "      <td>1110101000100000000000000000001000010000000100...</td>\n",
       "      <td>1110000001111011001110000000000001000000000000...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2194.0</td>\n",
       "      <td>0000000000000000000000000000000000010000000000...</td>\n",
       "      <td>0110000000000000001000000101100000000000000010...</td>\n",
       "      <td>0000000000000001000000000000001001000000000000...</td>\n",
       "      <td>1010101000000000000000000000000000000000000000...</td>\n",
       "      <td>1100000001110000001000000000000001100000000000...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2225.0</td>\n",
       "      <td>0000000000000000000000010000000000000000000010...</td>\n",
       "      <td>0011100111110001010100111000110100010110010000...</td>\n",
       "      <td>1001000000000000000000000000000001001000000000...</td>\n",
       "      <td>1010100010000000100100010000000000000000000000...</td>\n",
       "      <td>1110000001111011001110000000000000000000000000...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Name                                              MACCS  \\\n",
       "0  1923.0  0000000000000000000000000000000000000000000000...   \n",
       "1  2118.0  0000000000000000001000000000000000000100000000...   \n",
       "2  2176.0  0000000000000010000000000000000110010100000010...   \n",
       "3  2194.0  0000000000000000000000000000000000010000000000...   \n",
       "4  2225.0  0000000000000000000000010000000000000000000010...   \n",
       "\n",
       "                                         Topological  \\\n",
       "0  1000010000010000000000000100000000100000000010...   \n",
       "1  1010010000110000000110001001110000010110010101...   \n",
       "2  1111011110111011111011011011111110011110100110...   \n",
       "3  0110000000000000001000000101100000000000000010...   \n",
       "4  0011100111110001010100111000110100010110010000...   \n",
       "\n",
       "                                         Morgan ECFP  \\\n",
       "0  0000000000000001000100000000000000000000000000...   \n",
       "1  0000000000000001000000000000010011000000000000...   \n",
       "2  0100000000000000000000000000001001000000000000...   \n",
       "3  0000000000000001000000000000001001000000000000...   \n",
       "4  1001000000000000000000000000000001001000000000...   \n",
       "\n",
       "                                         Morgan FCFP  \\\n",
       "0  0001101000000000000000000000000000000001000000...   \n",
       "1  1010101010000000000000000000000000000000000000...   \n",
       "2  1110101000100000000000000000001000010000000100...   \n",
       "3  1010101000000000000000000000000000000000000000...   \n",
       "4  1010100010000000100100010000000000000000000000...   \n",
       "\n",
       "                                          Pubchem FP  Activity  \n",
       "0  1000000001110010001000000000000000000000000000...         1  \n",
       "1  1100000001111011100000000000000000000100000000...         1  \n",
       "2  1110000001111011001110000000000001000000000000...         1  \n",
       "3  1100000001110000001000000000000001100000000000...         1  \n",
       "4  1110000001111011001110000000000000000000000000...         1  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fps_df = pd.DataFrame()\n",
    "fps_df['Name'] = data['PUBCHEM_CID']\n",
    "fps_df['MACCS'] = maccs_fps\n",
    "fps_df['Topological'] = top_fps\n",
    "fps_df['Morgan ECFP'] = ecfp_fps\n",
    "fps_df['Morgan FCFP'] = fcfp_fps\n",
    "fps_df['Pubchem FP'] = pub_fp_decoded\n",
    "fps_df['Activity'] = data['target']\n",
    "fps_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing to csv\n",
    "fps_df.to_csv('Fingerprints Tox21', index = False)\n"
   ]
  },
  {
   "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": "markdown",
   "metadata": {},
   "source": [
    "# Formatting - MACCS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#making list of maccs1, maccs2, etc.\n",
    "i = 0\n",
    "maccs_names = ['Name']\n",
    "while (i < len(maccs_fps[0])):\n",
    "    string = \"MACCS\" + str(i + 1)\n",
    "    maccs_names.append(string)\n",
    "    i = i + 1\n",
    "    \n",
    "#Putting quotes around each CID \n",
    "#These are strings, should I change to int\n",
    "i = 0\n",
    "CID_list = fps_df['Name'].tolist()\n",
    "CID_str = []\n",
    "while (i < len(CID_list)):\n",
    "    string = \"\\'\" + str(CID_list[i]) + \"\\'\"\n",
    "    CID_str.append(string)\n",
    "    i = i + 1\n",
    "    \n",
    "#Splitting each bitstring fp into individual bits, and putting them in a df by row\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.extend([int(a) for a in str(maccs_fps[0])])\n",
    "maccs_df = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(maccs_fps)):\n",
    "    bit_row1 = [int(y) for y in str(maccs_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    maccs_df = maccs_df.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "\n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "maccs_df.columns = [maccs_names]\n",
    "\n",
    "#removing decimals\n",
    "maccs_df = maccs_df.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing fingerpring information\n",
    "maccs_df.to_csv('maccs_fps.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding activity_score/Making input train data\n",
    "#making list of maccs1, maccs2, etc.\n",
    "i = 0\n",
    "maccs_names = ['Name', 'Activity']\n",
    "while (i < len(maccs_fps[0])):\n",
    "    string = \"MACCS\" + str(i + 1)\n",
    "    maccs_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "i = 0\n",
    "CID_list = fps_df['Name'].tolist()\n",
    "act_list = fps_df['Activity'].tolist()\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(maccs_fps[0])])\n",
    "input_train_maccs = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(maccs_fps)):\n",
    "    bit_row1 = [int(y) for y in str(maccs_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_train_maccs = input_train_maccs.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "    \n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "input_train_maccs.columns = [maccs_names]\n",
    "\n",
    "#removing decimals\n",
    "input_train_maccs = input_train_maccs.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_train_maccs = input_train_maccs.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing TRAIN MACCS DATA(to TAB DELIMTED FILE?)\n",
    "input_train_maccs.to_csv('input_train_maccs.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(722, 168)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_train_maccs.dropna().shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formatting - Topological Fingerprint "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#making list of names\n",
    "i = 0\n",
    "top_names = ['Name']\n",
    "while (i < len(top_fps[0])):\n",
    "    string = \"TOP\" + str(i + 1)\n",
    "    top_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "#Splitting each bitstring fp into individual bits, and putting them in a df by row\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.extend([int(a) for a in str(top_fps[0])])\n",
    "top_df = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(top_fps)):\n",
    "    bit_row1 = [int(y) for y in str(top_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    top_df = top_df.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "top_df.shape \n",
    "\n",
    "\n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "top_df.columns = [top_names]\n",
    "\n",
    "#removing decimals\n",
    "top_df = top_df.astype(int)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing to csv\n",
    "top_df.to_csv('top_fps.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "top_names = ['Name', 'Activity']\n",
    "while (i < len(top_fps[0])):\n",
    "    string = \"TOP\" + str(i + 1)\n",
    "    top_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(top_fps[0])])\n",
    "input_train_top = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(top_fps)):\n",
    "    bit_row1 = [int(y) for y in str(top_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_train_top = input_train_top.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "    \n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "input_train_top.columns = [top_names]\n",
    "\n",
    "#removing decimals\n",
    "input_train_top = input_train_top.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_train_top = input_train_top.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing TRAIN Topological DATA(to TAB DELIMTED FILE?)\n",
    "input_train_top.to_csv('input_train_top.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formatting - Morgan (ecfp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#making list of names\n",
    "i = 0\n",
    "ecfp_names = ['Name']\n",
    "while (i < len(ecfp_fps[0])):\n",
    "    string = \"ECFP\" + str(i + 1)\n",
    "    ecfp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "#Splitting each bitstring fp into individual bits, and putting them in a df by row\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.extend([int(a) for a in str(ecfp_fps[0])])\n",
    "ecfp_df = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(ecfp_fps)):\n",
    "    bit_row1 = [int(y) for y in str(ecfp_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    ecfp_df = ecfp_df.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "ecfp_df.shape \n",
    "\n",
    "\n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "ecfp_df.columns = [ecfp_names]\n",
    "\n",
    "#removing decimals\n",
    "ecfp_df = ecfp_df.astype(int)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing to csv\n",
    "ecfp_df.to_csv('ecfp_fps.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "ecfp_names = ['Name', 'Activity']\n",
    "while (i < len(ecfp_fps[0])):\n",
    "    string = \"ECFP\" + str(i + 1)\n",
    "    ecfp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(ecfp_fps[0])])\n",
    "input_train_ecfp = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(ecfp_fps)):\n",
    "    bit_row1 = [int(y) for y in str(ecfp_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_train_ecfp = input_train_ecfp.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "    \n",
    "#Reindexing df, namesetc as column headers\n",
    "input_train_ecfp.columns = [ecfp_names]\n",
    "\n",
    "#removing decimals\n",
    "input_train_ecfp = input_train_ecfp.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_train_ecfp = input_train_ecfp.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing TRAIN DATA(to TAB DELIMTED FILE?)\n",
    "input_train_ecfp.to_csv('input_train_ecfp.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formatting - Morgan (fcfp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#making list of names\n",
    "i = 0\n",
    "fcfp_names = ['Name']\n",
    "while (i < len(fcfp_fps[0])):\n",
    "    string = \"FCFP\" + str(i + 1)\n",
    "    fcfp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "#Splitting each bitstring fp into individual bits, and putting them in a df by row\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.extend([int(a) for a in str(fcfp_fps[0])])\n",
    "fcfp_df = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(fcfp_fps)):\n",
    "    bit_row1 = [int(y) for y in str(fcfp_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    fcfp_df = fcfp_df.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "fcfp_df.shape \n",
    "\n",
    "\n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "fcfp_df.columns = [fcfp_names]\n",
    "\n",
    "#removing decimals\n",
    "fcfp_df = fcfp_df.astype(int)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing to csv\n",
    "fcfp_df.to_csv('fcfp_fps.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "fcfp_names = ['Name', 'Activity']\n",
    "while (i < len(fcfp_fps[0])):\n",
    "    string = \"FCFP\" + str(i + 1)\n",
    "    fcfp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "#Splitting each bitstring fp into individual bits, and putting them in a df by row\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(fcfp_fps[0])])\n",
    "input_train_fcfp = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(fcfp_fps)):\n",
    "    bit_row1 = [int(y) for y in str(fcfp_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_train_fcfp = input_train_fcfp.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "\n",
    "    \n",
    "#Reindexing df, namesetc as column headers\n",
    "input_train_fcfp.columns = [fcfp_names]\n",
    "\n",
    "#removing decimals\n",
    "input_train_fcfp = input_train_fcfp.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_train_fcfp = input_train_fcfp.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing TRAINING DATA to csv\n",
    "input_train_fcfp.to_csv('input_train_fcfp.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formatting - PubchemFP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#making list of names\n",
    "i = 0\n",
    "pub_fp_names = ['Name']\n",
    "while (i < len(pub_fp_decoded[0])):\n",
    "    string = \"PubFP\" + str(i + 1)\n",
    "    pub_fp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "#Splitting each bitstring fp into individual bits, and putting them in a df by row\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.extend([int(a) for a in str(pub_fp_decoded[0])])\n",
    "pub_fp_df = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(pub_fp_decoded)):\n",
    "    bit_row1 = [int(y) for y in str(pub_fp_decoded[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    pub_fp_df = pub_fp_df.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "pub_fp_df.shape \n",
    "\n",
    "\n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "pub_fp_df.columns = [pub_fp_names]\n",
    "\n",
    "#removing decimals\n",
    "pub_fp_df = pub_fp_df.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing to csv\n",
    "pub_fp_df.to_csv('pub_fps.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "pub_fp_names = ['Name', 'Activity']\n",
    "while (i < len(pub_fp_decoded[0])):\n",
    "    string = \"PubFP\" + str(i + 1)\n",
    "    pub_fp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(pub_fp_decoded[0])])\n",
    "input_train_pub = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(pub_fp_decoded)):\n",
    "    bit_row1 = [int(y) for y in str(pub_fp_decoded[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_train_pub = input_train_pub.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "\n",
    "    \n",
    "#Reindexing df, namesetc as column headers\n",
    "input_train_pub.columns = [pub_fp_names]\n",
    "\n",
    "#removing decimals\n",
    "input_train_pub = input_train_pub.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_train_pub = input_train_pub.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing TRAINING DATA to csv\n",
    "input_train_pub.to_csv('input_train_pub.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repeating Process for Test Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inactive             527\n",
       "active antagonist     28\n",
       "active agonist        13\n",
       "Name: Activity Outcome, dtype: int64"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "data = pd.read_csv('Test_Tox21')\n",
    "#data = data.astype(float, errors = 'ignore')\n",
    "data.head()\n",
    "data['Activity Outcome'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "data = pd.read_csv('Test_Tox21')\n",
    "#data = data.astype(float, errors = 'ignore')\n",
    "data.head()\n",
    "\n",
    "# MACCS Keys\n",
    "\n",
    "#Making list of isomericSMILES identifiers\n",
    "iSMILES = data['IsomericSMILES']\n",
    "iSMILES[0]\n",
    "\n",
    "#Making list of molecules from iSMILES\n",
    "i = 0\n",
    "ms = []\n",
    "while (i < len(iSMILES)):\n",
    "    molecule = Chem.MolFromSmiles(iSMILES[i])\n",
    "    ms.append(molecule)\n",
    "    i = i + 1\n",
    "\n",
    "#Getting MACCS fingerprints list\n",
    "#Turning fingerprints to bit strings\n",
    "maccs_fps = [MACCSkeys.GenMACCSKeys(x).ToBitString()[1:] for x in ms ]\n",
    "\n",
    "# Topological Fingerprint (Daylight Analogue)\n",
    "\n",
    "from rdkit.Chem import rdmolops\n",
    "\n",
    "#getting list of topological fingerprints\n",
    "top_fps = [rdmolops.RDKFingerprint(x, fpSize=2048, minPath=1, maxPath=7).ToBitString() for x in ms]\n",
    "\n",
    "# Morgan Fingerprint (ECFP)\n",
    "\n",
    "from rdkit.Chem import AllChem\n",
    "\n",
    "#getting morgan ecfp fingerprint\n",
    "ecfp_fps = [AllChem.GetMorganFingerprintAsBitVect(x,4,nBits=1024).ToBitString() for x in ms]\n",
    "\n",
    "# Morgan Fingerprint (FCFP)\n",
    "\n",
    "fcfp_fps = [AllChem.GetMorganFingerprintAsBitVect(x,4,nBits=1024,useFeatures=True).ToBitString() for x in ms]\n",
    "\n",
    "# PubChem FP Decoding\n",
    "\n",
    "#Getting CID list\n",
    "CID_list = data['PUBCHEM_CID']\n",
    "\n",
    "#Making them integers (removing decimals)\n",
    "CID_list = [int(i) for i in CID_list]\n",
    "\n",
    "list1 = CID_list[:600]\n",
    "\n",
    "#Changing list to str, dropping start/end brackets, removing spaces\n",
    "str1 = (str(list1)[1:-1])\n",
    "str1 = str1.replace(' ', '')\n",
    "\n",
    "\n",
    "#Getting the Pubchem Fingerprints for each CID\n",
    "#opening and reading the 1URLs\n",
    "url1 = ('https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/' + str1 + '/property/Fingerprint2D/TXT')\n",
    "html1 = urlopen(url1) \n",
    "soup1 = BeautifulSoup(html1, 'lxml')\n",
    "\n",
    "pub_fp = soup1.get_text()\n",
    "\n",
    "#pub_fp string to pub_fp list\n",
    "pub_fp = pub_fp.split()\n",
    "\n",
    "#Decoding Fingerprints\n",
    "from base64 import b64decode\n",
    "\n",
    "def PCFP_BitString(pcfp_base64) :\n",
    "\n",
    "    pcfp_bitstring = \"\".join( [\"{:08b}\".format(x) for x in b64decode( pcfp_base64 )] )[32:913]\n",
    "    return pcfp_bitstring\n",
    "\n",
    "i = 0\n",
    "pub_fp_decoded = []\n",
    "while (i < len(pub_fp)):\n",
    "    fp = PCFP_BitString(pub_fp[i])\n",
    "    pub_fp_decoded.append(fp)\n",
    "    i = i + 1\n",
    "\n",
    "# FinalDFTox21\n",
    "\n",
    "fps_df = pd.DataFrame()\n",
    "fps_df['Name'] = data['PUBCHEM_CID']\n",
    "fps_df['MACCS'] = maccs_fps\n",
    "fps_df['Topological'] = top_fps\n",
    "fps_df['Morgan ECFP'] = ecfp_fps\n",
    "fps_df['Morgan FCFP'] = fcfp_fps\n",
    "fps_df['Pubchem FP'] = pub_fp_decoded\n",
    "fps_df['Activity'] = data['target']\n",
    "fps_df.head()\n",
    "\n",
    "#Writing to csv\n",
    "fps_df.to_csv('Fingerprints Tox21 Test', index = False)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Formatting - MACCS\n",
    "\n",
    "#Adding activity_score/Making input train data\n",
    "#making list of maccs1, maccs2, etc.\n",
    "i = 0\n",
    "maccs_names = ['Name', 'Activity']\n",
    "while (i < len(maccs_fps[0])):\n",
    "    string = \"MACCS\" + str(i + 1)\n",
    "    maccs_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "i = 0\n",
    "CID_list = fps_df['Name'].tolist()\n",
    "act_list = fps_df['Activity'].tolist()\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(maccs_fps[0])])\n",
    "input_test_maccs = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(maccs_fps)):\n",
    "    bit_row1 = [int(y) for y in str(maccs_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_test_maccs = input_test_maccs.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "    \n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "input_test_maccs.columns = [maccs_names]\n",
    "\n",
    "#removing decimals\n",
    "input_test_maccs = input_test_maccs.astype(int)\n",
    "\n",
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_test_maccs = input_test_maccs.astype(float)\n",
    "\n",
    "#Writing test MACCS DATA\n",
    "input_test_maccs.to_csv('input_test_maccs.csv', index = False)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Formatting - Topological Fingerprint \n",
    "\n",
    "\n",
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "top_names = ['Name', 'Activity']\n",
    "while (i < len(top_fps[0])):\n",
    "    string = \"TOP\" + str(i + 1)\n",
    "    top_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(top_fps[0])])\n",
    "input_test_top = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(top_fps)):\n",
    "    bit_row1 = [int(y) for y in str(top_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_test_top = input_test_top.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "    \n",
    "#Reindexing df, MACCS1, MACCS2, etc as column headers\n",
    "input_test_top.columns = [top_names]\n",
    "\n",
    "#removing decimals\n",
    "input_test_top = input_test_top.astype(int)\n",
    "\n",
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_test_top = input_test_top.astype(float)\n",
    "\n",
    "#Writing test Topological DATA\n",
    "input_test_top.to_csv('input_test_top.csv', index = False)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Formatting - Morgan (ecfp)\n",
    "\n",
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "ecfp_names = ['Name', 'Activity']\n",
    "while (i < len(ecfp_fps[0])):\n",
    "    string = \"ECFP\" + str(i + 1)\n",
    "    ecfp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(ecfp_fps[0])])\n",
    "input_test_ecfp = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(ecfp_fps)):\n",
    "    bit_row1 = [int(y) for y in str(ecfp_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_test_ecfp = input_test_ecfp.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "    \n",
    "#Reindexing df, namesetc as column headers\n",
    "input_test_ecfp.columns = [ecfp_names]\n",
    "\n",
    "#removing decimals\n",
    "input_test_ecfp = input_test_ecfp.astype(int)\n",
    "\n",
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_test_ecfp = input_test_ecfp.astype(float)\n",
    "\n",
    "#Writing Test DATA\n",
    "input_test_ecfp.to_csv('input_test_ecfp.csv', index = False)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Formatting - Morgan (fcfp)\n",
    "\n",
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "fcfp_names = ['Name', 'Activity']\n",
    "while (i < len(fcfp_fps[0])):\n",
    "    string = \"FCFP\" + str(i + 1)\n",
    "    fcfp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "#Splitting each bitstring fp into individual bits, and putting them in a df by row\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(fcfp_fps[0])])\n",
    "input_test_fcfp = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(fcfp_fps)):\n",
    "    bit_row1 = [int(y) for y in str(fcfp_fps[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_test_fcfp = input_test_fcfp.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "\n",
    "    \n",
    "#Reindexing df, namesetc as column headers\n",
    "input_test_fcfp.columns = [fcfp_names]\n",
    "\n",
    "#removing decimals\n",
    "input_test_fcfp = input_test_fcfp.astype(int)\n",
    "\n",
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_test_fcfp = input_test_fcfp.astype(float)\n",
    "\n",
    "#Writing test DATA to csv\n",
    "input_test_fcfp.to_csv('input_test_fcfp.csv', index = False)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Formatting - PubchemFP\n",
    "\n",
    "#Adding activity_score/Making input train data\n",
    "#making list of names etc.\n",
    "i = 0\n",
    "pub_fp_names = ['Name', 'Activity']\n",
    "while (i < len(pub_fp_decoded[0])):\n",
    "    string = \"PubFP\" + str(i + 1)\n",
    "    pub_fp_names.append(string)\n",
    "    i = i + 1\n",
    "\n",
    "first_row = []\n",
    "first_row.append(CID_list[0])\n",
    "first_row.append(act_list[0])\n",
    "first_row.extend([int(a) for a in str(pub_fp_decoded[0])])\n",
    "input_test_pub = pd.DataFrame(first_row).T\n",
    "x = 1\n",
    "row = []\n",
    "while (x < len(pub_fp_decoded)):\n",
    "    bit_row1 = [int(y) for y in str(pub_fp_decoded[x])]\n",
    "    row.append(CID_list[x])\n",
    "    row.append(act_list[x])\n",
    "    row.extend(bit_row1)\n",
    "    row1df = pd.DataFrame(row).T\n",
    "    input_test_pub = input_test_pub.append(row1df)\n",
    "    row.clear()   \n",
    "    x = x + 1\n",
    "\n",
    "    \n",
    "#Reindexing df, namesetc as column headers\n",
    "input_test_pub.columns = [pub_fp_names]\n",
    "\n",
    "#removing decimals\n",
    "input_test_pub = input_test_pub.astype(int)\n",
    "\n",
    "#Changing int to float (because scikit learn wants it like that)\n",
    "#input_test_pub = input_test_pub.astype(float)\n",
    "\n",
    "#Writing test DATA to csv\n",
    "input_test_pub.to_csv('input_test_pub.csv', index = False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'DataFrame' object has no attribute 'value_counts'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-52-3565cb28ca59>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0minput_test_ecfp\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'Activity'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalue_counts\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mc:\\users\\singhs29\\appdata\\local\\continuum\\anaconda3\\envs\\my-rdkit-env\\lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36m__getattr__\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m   5065\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_info_axis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_can_hold_identifiers_and_holds_name\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5066\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 5067\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   5068\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5069\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'DataFrame' object has no attribute 'value_counts'"
     ]
    }
   ],
   "source": [
    "input_test_ecfp['Activity'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'DataFrame' object has no attribute 'value_counts'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-51-225f61662eda>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0minput_test_maccs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'Activity'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalue_counts\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mc:\\users\\singhs29\\appdata\\local\\continuum\\anaconda3\\envs\\my-rdkit-env\\lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36m__getattr__\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m   5065\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_info_axis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_can_hold_identifiers_and_holds_name\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5066\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 5067\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   5068\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5069\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'DataFrame' object has no attribute 'value_counts'"
     ]
    }
   ],
   "source": [
    "input_test_maccs['Activity'].value_counts"
   ]
  },
  {
   "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
}